Copilot Unleashed

Your AI powerhouse — every model, every device, your server. Self-hosted multi-model AI chat powered by the official GitHub Copilot SDK.

The only open-source web UI built on the official @github/copilot-sdk — exposing the full power of Copilot Agents in a browser, on any device.
Access GPT-4.1, o-series, Claude, and Gemini through a single GitHub login. Run autonomous agents in autopilot mode. Use every GitHub MCP tool. Bring your own tools. Keep your sessions alive forever. All from your phone.

Disclaimer: This is an independent, community-driven project — not an official GitHub product. Use at your own risk.

Why This Exists

GitHub Copilot is extraordinarily powerful — but most of that power is locked inside VS Code or the terminal. You can't use autopilot mode from your phone. You can't switch between GPT-4.1 and Claude in the same conversation. You can't share a Copilot-powered agent with your team without everyone installing the CLI. You can't connect custom tools or call your internal APIs.

This project unlocks all of it.

Use Cases

1. Review PRs from your phone, on the go

Commuting? Waiting in line? Use the built-in GitHub MCP tools to browse open pull requests, read diffs, understand what changed, and get a plain-language summary — no laptop, no IDE.

"Summarize the changes in PR #312 and tell me if there are any security concerns"
→ Copilot fetches the PR, reads every file diff, and reports back with a structured review.

2. Run autonomous agents while you do something else

Switch to autopilot mode and give Copilot a complex task: implement a feature, write tests, refactor a module. The agent plans, executes shell commands and tool calls, and reports back. You monitor from your phone. No need to babysit a terminal.

"Implement the password reset flow as described in issue #88. Write tests and open a PR when done."
→ Copilot reads the issue, creates a plan, writes code, runs tests, and opens the PR — autonomously.

3. Compare models on hard problems — in the same UI

Stop switching between tabs. Ask a hard architecture question, then switch the model mid-conversation:
gpt-4.1 for speed → o3 for deep reasoning → claude-sonnet for a creative angle. All history preserved, all responses in one view.

One subscription. Four frontier models. Zero tab switching.

4. Extended thinking for the hardest bugs

Paste a gnarly stack trace and switch to o3 or claude-sonnet with xhigh reasoning effort. Watch the live reasoning trace — the model "thinks out loud" in a collapsible block before giving its answer. You see how it reaches the conclusion, not just what it concludes.

5. Connect your own tools and APIs

Define custom webhook tools in the settings UI. Copilot can now call your internal APIs, query your database, look up a Jira ticket, trigger a deployment, or read from a private data source — as part of its agentic workflow.

"Check if ticket PROJ-1234 is still open, then search GitHub for any related PRs"
→ Copilot calls your Jira webhook, reads the ticket, then uses GitHub MCP to search for PRs.

6. Deploy a shared AI assistant for your team

Run azd up once. Everyone on the team opens the URL, logs in with their own GitHub account, and gets their own isolated Copilot sessions — no shared API keys, no shared context. The server handles everything.

7. Resume long-running investigations across devices

Start debugging a gnarly issue on Monday morning at your desk. Close the laptop. On Tuesday, open the same session from your phone and pick up exactly where you left off — full history, full context, infinite sessions with automatic compaction.

Screenshots

Features

• Real-time streaming — token-by-token over WebSocket
• All Copilot models — GPT-4.1, o-series, Claude, Gemini — switch mid-conversation
• Extended thinking — live reasoning traces with color-coded effort levels for supported models
• Modes — ask / plan / autopilot, just like the CLI
• GitHub MCP tools — issues, PRs, code search, repos — all built in, with readonly toggle
• Custom MCP servers — add, update, and delete external MCP servers
• File attachments — attach code files and images to messages
• Permission control — approve/deny/always-allow tool execution per tool
• Custom webhook tools — define your own tools backed by HTTP endpoints
• Infinite sessions — automatic context compaction with configurable thresholds
• Session management — list, resume, and delete past sessions
• Custom instructions — appended to the system prompt, SDK guardrails preserved
• Subagent support — agent selection, lifecycle tracking, and status display
• Plan management — view, edit, and delete plans with collapsible panel
• Mobile-first dark UI — SvelteKit 5 with SSR, responsive, touch-optimized
• 2 env vars to run — GITHUB_CLIENT_ID + SESSION_SECRET

Quick Start

Prerequisites

• GitHub account with a Copilot license (free tier works)

• GitHub OAuth App — register one in 30 seconds:

  1. Click New OAuth App → name it anything, set both URLs to http://localhost:3000
  2. Copy the Client ID — that's your GITHUB_CLIENT_ID

  Device Flow auth — no client secret needed, no redirect URI to configure.

GitHub Codespaces (fastest)

1. Add GITHUB_CLIENT_ID as a Codespace secret scoped to this repo

2. Launch:

   

3. Done — the app builds and opens automatically.

Docker

# Create .env
echo "GITHUB_CLIENT_ID=<your-client-id>" >> .env
echo "SESSION_SECRET=$(openssl rand -hex 32)" >> .env

docker compose up --build

Open localhost:3000 — enter the code on GitHub, start chatting.

Node.js

Requires Node.js 24+ (the SDK needs node:sqlite).

npm install && npm run build && npm start

Development

npm run dev:local          # Local Vite dev server (hot reload)
npm run dev                # Docker Compose (full stack)
npm run check              # Type check (svelte-check)
npx playwright test        # E2E tests (desktop + mobile viewports)

Configuration

Tech Stack

How It Works

Browser (Svelte 5) ──WebSocket──▶ SvelteKit + server.js ──JSON-RPC──▶ @github/copilot CLI subprocess
        │                               │                                    │
        │  SSR + Device Flow auth       │  Session pool per user             │  Copilot API
        │  Rune-based reactive stores   │  SDK event forwarding              │  GitHub MCP tools
        ▼                               ▼                                    ▼

1. User opens the app → SvelteKit SSR checks session → renders login or chat
2. Authenticates via GitHub Device Flow, token stored server-side only
3. WebSocket connection opens → server spawns a CopilotClient with its own CLI subprocess
4. User sends a message → SDK streams events → server forwards as typed JSON → Svelte reactively re-renders
5. On disconnect → session pooled with TTL, reconnect replays buffered messages

Full architecture docs →

server.js                       # Custom entry: HTTP + express-session + WebSocket + SvelteKit handler
svelte.config.js                # SvelteKit config (adapter-node)
vite.config.ts                  # Vite config
tsconfig.json                   # TypeScript config (strict, ES2022)

src/
├── app.html                    # SvelteKit shell (viewport, theme-color, PWA meta)
├── app.css                     # Global reset, design tokens, highlight.js theme
├── hooks.server.ts             # Session bridge, CSRF, CSP, security headers, rate limiting
├── lib/
│   ├── components/             # 18 Svelte 5 components
│   │   ├── Banner.svelte           # Info/warning banners
│   │   ├── ChatInput.svelte        # Message input + file attachments
│   │   ├── ChatMessage.svelte      # Single message rendering
│   │   ├── CustomToolsEditor.svelte # Webhook tool editor
│   │   ├── DeviceFlowLogin.svelte  # GitHub Device Flow login UI
│   │   ├── EnvInfo.svelte          # Environment info display
│   │   ├── MessageList.svelte      # Scrollable message list
│   │   ├── ModelSheet.svelte       # Model selection bottom sheet
│   │   ├── PermissionPrompt.svelte # Tool permission allow/deny
│   │   ├── PlanPanel.svelte        # Plan view/edit panel
│   │   ├── QuotaDot.svelte         # Quota usage indicator
│   │   ├── ReasoningBlock.svelte   # Collapsible reasoning trace
│   │   ├── SessionsSheet.svelte    # Session history bottom sheet
│   │   ├── SettingsModal.svelte    # Settings with instructions, tools, MCP
│   │   ├── Sidebar.svelte          # Navigation sidebar
│   │   ├── ToolCall.svelte         # Tool execution display
│   │   ├── TopBar.svelte           # Top navigation bar
│   │   └── UserInputPrompt.svelte  # SDK input request UI
│   ├── stores/                 # Svelte 5 rune stores (factory functions)
│   │   ├── auth.svelte.ts          # Device flow state, polling, countdown
│   │   ├── chat.svelte.ts          # Messages, streaming, tool calls, models, plan
│   │   ├── settings.svelte.ts      # Persisted preferences (localStorage)
│   │   └── ws.svelte.ts            # WebSocket connection + typed send helpers
│   ├── server/                 # Server-only code
│   │   ├── config.ts               # Environment config (fail-fast validation)
│   │   ├── security-log.ts         # Security event logging
│   │   ├── session-store.ts        # Express session bridge store
│   │   ├── auth/
│   │   │   ├── github.ts           # Device Flow OAuth
│   │   │   ├── guard.ts            # Auth guard middleware
│   │   │   └── session-utils.ts    # Session utility helpers
│   │   ├── copilot/
│   │   │   ├── client.ts           # CopilotClient factory
│   │   │   └── session.ts          # Session config builder
│   │   └── ws/
│   │       ├── handler.ts          # WebSocket: 21 client + 27 SDK events
│   │       └── session-pool.ts     # Per-user session pool with TTL
│   ├── types/index.ts          # All types: 46+ server + 21 client message types
│   └── utils/markdown.ts       # Markdown pipeline (marked + DOMPurify + hljs)
├── routes/
│   ├── +page.svelte            # Main: login or chat (wires all components)
│   ├── +layout.server.ts       # Root: auth check from session
│   ├── +layout.svelte          # Root layout
│   ├── +error.svelte           # Error page
│   ├── auth/
│   │   ├── device/start/           # Start Device Flow
│   │   ├── device/poll/            # Poll for token
│   │   ├── logout/                 # Logout endpoint
│   │   └── status/                 # Auth status check
│   ├── api/
│   │   ├── models/                 # List available models
│   │   ├── upload/                 # File upload handler
│   │   ├── version/                # App version endpoint
│   │   └── client-error/           # Client error reporting
│   └── health/+server.ts      # Health check

scripts/
└── patch-sdk.mjs               # SDK postinstall patch

tests/
├── chat.spec.ts                # Chat functionality tests
├── login.spec.ts               # Login flow tests
├── messages.spec.ts            # Message rendering tests
├── responsive.spec.ts          # Mobile/desktop responsive tests
└── screenshots.spec.ts         # Screenshot generation

infra/                          # Azure Bicep IaC
├── main.bicep                  # Main template
├── main.parameters.json        # Parameters
└── modules/                    # Container Apps, ACR, Identity, Monitoring

Authentication & Authorization

This section documents the OAuth model, token scopes, and runtime authorization to help teams evaluate the app for security and governance.

OAuth App type

This app uses a GitHub OAuth App (not a GitHub App). It authenticates via the Device Flow — the same flow used by the GitHub CLI. No client secret is needed; only the Client ID is required.

Token scopes

The app requests the following OAuth scopes when the user authenticates:

[!IMPORTANT] The repo scope is broad — it grants read/write access to the user's repositories. This is required because the Copilot SDK's built-in tools (file operations, shell, code search) need repository access to function. This matches the permissions of the desktop Copilot CLI. If your governance policy restricts this scope, consider using ALLOWED_GITHUB_USERS to limit who can authenticate, or use excludedTools in the session config to disable tools that require repo access.

How the token is used

Token lifecycle

1. Acquisition — User authenticates via Device Flow; token is returned by GitHub's OAuth endpoint
2. Storage — Token is stored server-side only in the Express session (encrypted via SESSION_SECRET), bridged to SvelteKit via hooks.server.ts. It is never sent to the browser.
3. Freshness — Token age is checked on every API request against TOKEN_MAX_AGE_MS. On WebSocket connect, the token is also validated against GET /user to catch revoked tokens.
4. Revocation — When the user logs out or the session expires, the token is destroyed server-side. Users can also revoke the token from GitHub Settings → Applications.

Access control

What this app does NOT do

• No client secret — Device Flow does not require or use a client secret
• No server-side repo operations — The server itself never reads or writes repositories; repo access is used only by the Copilot SDK's built-in tools running within the user's own session
• No token sharing — Each user's token is isolated in their own server-side session
• No long-term storage — Tokens are held only in-memory (or file-based sessions in dev); nothing is persisted to a database

Deploy to Azure

az login && azd auth login
azd env set GITHUB_CLIENT_ID <your-client-id>

# Optional
azd env set allowedGithubUsers "user1,user2"
azd env set ipRestrictions "203.0.113.0/24"

azd up

azd deploy    # Subsequent deploys (skip infra provisioning)

az ad sp create-for-rbac \
  --name "copilot-unleashed-cicd" \
  --role contributor \
  --scopes /subscriptions/<sub-id>/resourceGroups/<rg> \
  --sdk-auth

Contributing

See CONTRIBUTING.md for development setup, code style guide, and PR process.

License

MIT