copilot-router 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 MS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,241 @@
+# Copilot Router
+
+GitHub Copilot API with OpenAI, Anthropic, and Gemini compatibility. Supports **multiple GitHub tokens** with load balancing and SQL Server storage.
+
+## Features
+
+- **Multi-token support**: Add multiple GitHub accounts for load balancing
+- **SQL Server storage**: Persist tokens across restarts (supports Azure AD authentication)
+- **Memory-only mode**: Works without database configuration
+- **GitHub Device Code flow**: Use device code flow to authenticate
+- **Web UI**: User-friendly login page for managing tokens
+- **Load balancing**: Randomly distribute requests across active tokens
+- **OpenAI, Anthropic, and Gemini compatibility**: Use familiar APIs
+- **OpenAPI documentation**: Auto-generated API docs at `/openapi.json`
+
+## Quick Start
+
+The fastest way to run Copilot Router without cloning the repository:
+
+```bash
+npx copilot-router@latest start
+```
+
+With custom port:
+
+```bash
+npx copilot-router@latest start --port 8080
+```
+
+## Setup (Development)
+
+### 1. Configure Environment
+
+Copy the example environment file:
+
+```bash
+cp .env.example .env
+```
+
+Edit `.env` with your configuration:
+
+```env
+# SQL Server connection string (optional - uses memory mode if not provided)
+DB_CONNECTION_STRING=Server=localhost;Database=copilot_router;Authentication=Active Directory Default
+PORT=4242
+```
+
+**Supported Authentication Types:**
+- `Active Directory Default` - Uses system's default Azure AD auth
+- `Active Directory Managed Identity` - Uses Azure Managed Identity (requires `User Id` for client-id)
+
+> **Note**: If `DB_CONNECTION_STRING` is not provided, the server runs in memory-only mode. In memory-only mode, the server will automatically detect and use your local `gh auth` token if available.
+
+### 2. Install Dependencies
+
+```bash
+npm install
+```
+
+### 3. Start the Server
+
+```bash
+npm run dev
+```
+
+Or for production:
+
+```bash
+npm start
+```
+
+## Web UI
+
+Access the login UI at `http://localhost:4242/login` to:
+- Login via GitHub Device Code flow
+- Add tokens directly
+- Manage existing tokens
+
+## Authentication
+
+### Method 1: Device Code Flow (Recommended)
+
+1. **Start login**:
+```bash
+curl -X POST http://localhost:4242/auth/login
+```
+
+Response:
+```json
+{
+  "user_code": "ABCD-1234",
+  "verification_uri": "https://github.com/login/device",
+  "device_code": "...",
+  "expires_in": 900,
+  "interval": 5
+}
+```
+
+2. **Visit the URL** and enter the code to authorize.
+
+3. **Complete login**:
+```bash
+curl -X POST http://localhost:4242/auth/complete \
+  -H "Content-Type: application/json" \
+  -d '{
+    "device_code": "...",
+    "account_type": "individual"
+  }'
+```
+
+Response:
+```json
+{
+  "status": "success",
+  "id": 1,
+  "username": "your-username",
+  "account_type": "individual",
+  "message": "Successfully logged in as your-username"
+}
+```
+
+### Method 2: Direct Token Input
+
+If you already have a GitHub token:
+
+```bash
+curl -X POST http://localhost:4242/auth/tokens \
+  -H "Content-Type: application/json" \
+  -d '{
+    "github_token": "ghu_xxx...",
+    "account_type": "individual"
+  }'
+```
+
+### Manage Tokens
+
+**List all tokens**:
+```bash
+curl http://localhost:4242/auth/tokens
+```
+
+**Delete a token**:
+```bash
+curl -X DELETE http://localhost:4242/auth/tokens/1
+```
+
+**Delete all tokens**:
+```bash
+curl -X DELETE http://localhost:4242/auth/tokens/all
+```
+
+## API Endpoints
+
+### OpenAI-Compatible
+
+Available at both root (`/`) and versioned (`/v1`) paths:
+
+- `POST /chat/completions` or `POST /v1/chat/completions` - Chat completion (load balanced)
+- `GET /models` or `GET /v1/models` - List models
+- `GET /models?grouped=true` or `GET /v1/models?grouped=true` - List models grouped by token
+- `POST /embeddings` or `POST /v1/embeddings` - Create embeddings (load balanced)
+
+### Anthropic-Compatible
+
+- `POST /v1/messages` - Create message (load balanced)
+- `POST /v1/messages/count_tokens` - Count tokens
+
+### Gemini-Compatible
+
+- `POST /v1beta/models/:model:generateContent` - Generate content (load balanced)
+- `POST /v1beta/models/:model:streamGenerateContent` - Stream content
+- `POST /v1beta/models/:model:countTokens` - Count tokens
+
+### Utility
+
+- `GET /` - Health check with token count
+- `GET /token` - List active tokens with Copilot token info
+- `GET /login` - Web UI for token management
+- `GET /openapi.json` - OpenAPI documentation
+
+### Auth
+
+- `POST /auth/login` - Start device code flow
+- `POST /auth/complete` - Complete device code authentication
+- `GET /auth/tokens` - List all tokens with statistics
+- `POST /auth/tokens` - Add token directly
+- `DELETE /auth/tokens/:id` - Delete a specific token
+- `DELETE /auth/tokens/all` - Delete all tokens
+
+## Load Balancing
+
+All API calls (`/chat/completions`, `/embeddings`, `/messages`, `:generateContent`) automatically use **random token selection** for load balancing. Each request will use a different token from your pool of active tokens.
+
+### Request Statistics
+
+View per-token statistics:
+
+```bash
+curl http://localhost:4242/auth/tokens
+```
+
+Response includes:
+- `request_count` - Total requests made with this token
+- `error_count` - Number of errors
+- `last_used` - Last time the token was used
+- `has_copilot_token` - Whether the Copilot token is valid
+- `copilot_token_expires_at` - Expiration time of the Copilot token
+
+## Grouped Display
+
+For multi-token setups, you can view models grouped by token:
+
+```bash
+# Models grouped by token
+curl "http://localhost:4242/v1/models?grouped=true"
+```
+
+## Database Schema
+
+When using SQL Server, the system automatically creates a `GithubTokens` table:
+
+```sql
+CREATE TABLE GithubTokens (
+  id INT IDENTITY(1,1) PRIMARY KEY,
+  Token NVARCHAR(500) NOT NULL,
+  UserName NVARCHAR(100) UNIQUE,
+  AccountType NVARCHAR(50) DEFAULT 'individual',
+  IsActive BIT DEFAULT 1
+)
+```
+
+## Tech Stack
+
+- **Runtime**: Node.js with TypeScript
+- **Framework**: [Hono](https://hono.dev/) with OpenAPI support
+- **Database**: Microsoft SQL Server (optional)
+- **Build Tool**: TSX for development, TypeScript for production
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import consola from "consola";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+// Get package.json location relative to this file
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJsonPath = join(__dirname, "..", "package.json");
+const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+const program = new Command();
+program
+    .name("copilot-router")
+    .description(packageJson.description)
+    .version(packageJson.version);
+program
+    .command("start")
+    .description("Start the Copilot Router server")
+    .option("-p, --port <port>", "Port to listen on", "4242")
+    .action(async (options) => {
+    // Set port from CLI option if provided
+    if (options.port) {
+        process.env.PORT = options.port;
+    }
+    // Set the package root for static files
+    process.env.COPILOT_ROUTER_ROOT = join(__dirname, "..");
+    consola.info("Starting Copilot Router via CLI...");
+    // Dynamically import the main module to start the server
+    await import("./main.js");
+});
+program.parse();

package/dist/lib/api-config.d.ts

@@ -0,0 +1,15 @@
+import type { TokenEntry } from "./token-manager.js";
+export declare const standardHeaders: () => {
+    "content-type": string;
+    accept: string;
+};
+/**
+ * Get base URL for token entry
+ */
+export declare const copilotBaseUrlForEntry: (entry: TokenEntry) => string;
+/**
+ * Create headers for a token entry
+ * Note: Using GitHub Access Token directly instead of Copilot Token
+ */
+export declare const copilotHeadersForEntry: (entry: TokenEntry, vision?: boolean) => Record<string, string>;
+export declare const GITHUB_API_BASE_URL = "https://api.github.com";

package/dist/lib/api-config.js

@@ -0,0 +1,30 @@
+export const standardHeaders = () => ({
+    "content-type": "application/json",
+    accept: "application/json",
+});
+const COPILOT_VERSION = "0.0.388";
+const API_VERSION = "2025-05-01";
+/**
+ * Get base URL for token entry
+ */
+export const copilotBaseUrlForEntry = (entry) => entry.accountType === "individual"
+    ? "https://api.githubcopilot.com"
+    : `https://api.${entry.accountType}.githubcopilot.com`;
+/**
+ * Create headers for a token entry
+ * Note: Using GitHub Access Token directly instead of Copilot Token
+ */
+export const copilotHeadersForEntry = (entry, vision = false) => {
+    const headers = {
+        Authorization: `Bearer ${entry.githubToken}`,
+        "content-type": standardHeaders()["content-type"],
+        "copilot-integration-id": "copilot-developer-cli",
+        "user-agent": `copilot/${COPILOT_VERSION} (linux v24.11.1) term/unknown`,
+        "openai-intent": "conversation-agent",
+        "x-github-api-version": API_VERSION,
+    };
+    if (vision)
+        headers["copilot-vision-request"] = "true";
+    return headers;
+};
+export const GITHUB_API_BASE_URL = "https://api.github.com";

package/dist/lib/database.d.ts

@@ -0,0 +1,60 @@
+import sql from "mssql";
+/**
+ * Check if database configuration is provided
+ */
+export declare function isDatabaseConfigured(): boolean;
+/**
+ * Check if database is connected
+ */
+export declare function isDatabaseConnected(): boolean;
+/**
+ * Initialize database connection and create tables if not exist
+ * Returns true if database was initialized, false if skipped (no config)
+ */
+export declare function initializeDatabase(): Promise<boolean>;
+/**
+ * Get database connection pool
+ */
+export declare function getPool(): sql.ConnectionPool;
+/**
+ * Token record from database
+ */
+export interface TokenRecord {
+    Id: number;
+    Token: string;
+    UserName: string | null;
+    AccountType: string;
+    IsActive: boolean;
+}
+/**
+ * Get all active tokens from database
+ */
+export declare function getAllTokens(): Promise<TokenRecord[]>;
+/**
+ * Get a specific token by ID
+ */
+export declare function getTokenById(id: number): Promise<TokenRecord | null>;
+/**
+ * Get a token by GitHub token value
+ */
+export declare function getTokenByGithubToken(githubToken: string): Promise<TokenRecord | null>;
+/**
+ * Save a new GitHub token to database (or update existing by username)
+ */
+export declare function saveToken(githubToken: string, username?: string, accountType?: string): Promise<number>;
+/**
+ * Update GitHub token for an existing entry
+ */
+export declare function updateGithubToken(id: number, githubToken: string): Promise<void>;
+/**
+ * Deactivate a token
+ */
+export declare function deactivateToken(id: number): Promise<void>;
+/**
+ * Delete all tokens (soft delete - sets IsActive = 0 for all records)
+ */
+export declare function deleteAllTokens(): Promise<number>;
+/**
+ * Close database connection
+ */
+export declare function closeDatabase(): Promise<void>;

package/dist/lib/database.js

@@ -0,0 +1,228 @@
+import sql from "mssql";
+import consola from "consola";
+/**
+ * Parse connection string to extract server, database, authentication type and user id
+ * Supported formats:
+ * - Server=xxx;Database=xxx;Authentication=Active Directory Default
+ * - Server=xxx;Database=xxx;User Id=xxx;Authentication=Active Directory Managed Identity
+ */
+function parseConnectionString(connectionString) {
+    if (!connectionString)
+        return null;
+    const serverMatch = connectionString.match(/Server=([^;]+)/i);
+    const databaseMatch = connectionString.match(/Database=([^;]+)/i);
+    const authMatch = connectionString.match(/Authentication=([^;]+)/i);
+    const userIdMatch = connectionString.match(/User Id=([^;]+)/i);
+    if (!serverMatch || !databaseMatch)
+        return null;
+    return {
+        server: serverMatch[1],
+        database: databaseMatch[1],
+        authentication: authMatch?.[1] || "Active Directory Default",
+        userId: userIdMatch?.[1]
+    };
+}
+/**
+ * Build mssql authentication config based on connection string authentication type
+ */
+function buildAuthConfig(dbConfig) {
+    const authType = dbConfig.authentication.toLowerCase();
+    // Active Directory Managed Identity
+    if (authType.includes("managed identity")) {
+        return {
+            type: "azure-active-directory-msi-app-service",
+            options: {
+                clientId: dbConfig.userId
+            }
+        };
+    }
+    // Active Directory Default (default fallback)
+    return {
+        type: "azure-active-directory-default",
+        options: {}
+    };
+}
+// Parse connection string
+const dbConfig = parseConnectionString(process.env.DB_CONNECTION_STRING || "");
+// SQL Server configuration
+const sqlConfig = {
+    server: dbConfig?.server || "",
+    database: dbConfig?.database || "",
+    options: {
+        encrypt: true, // Required for Azure
+        trustServerCertificate: false,
+    },
+    authentication: dbConfig ? buildAuthConfig(dbConfig) : undefined
+};
+let pool = null;
+/**
+ * Check if database configuration is provided
+ */
+export function isDatabaseConfigured() {
+    return !!dbConfig;
+}
+/**
+ * Check if database is connected
+ */
+export function isDatabaseConnected() {
+    return pool !== null;
+}
+/**
+ * Initialize database connection and create tables if not exist
+ * Returns true if database was initialized, false if skipped (no config)
+ */
+export async function initializeDatabase() {
+    // Skip if database is not configured
+    if (!isDatabaseConfigured()) {
+        consola.info("Database not configured, using memory-only mode");
+        return false;
+    }
+    try {
+        consola.info(`Connecting to ${sqlConfig.server}/${sqlConfig.database}...`);
+        pool = await sql.connect(sqlConfig);
+        consola.success("Connected to SQL Server");
+        // Check if GithubTokens table exists, if not create it
+        // If table exists, use it directly (fields are guaranteed to be correct)
+        await pool.request().query(`
+      IF NOT EXISTS (SELECT * FROM sysobjects WHERE name='GithubTokens' AND xtype='U')
+      BEGIN
+        CREATE TABLE GithubTokens (
+          id INT IDENTITY(1,1) PRIMARY KEY,
+          Token NVARCHAR(500) NOT NULL,
+          UserName NVARCHAR(100) UNIQUE,
+          AccountType NVARCHAR(50) DEFAULT 'individual',
+          IsActive BIT DEFAULT 1
+        )
+      END
+    `);
+        // Drop old unique constraint on Token if exists
+        await pool.request().query(`
+      BEGIN TRY
+        -- Try to drop the old unique constraint on Token
+        DECLARE @constraintName NVARCHAR(200)
+        SELECT @constraintName = name FROM sys.key_constraints 
+        WHERE parent_object_id = OBJECT_ID('GithubTokens') 
+        AND type = 'UQ' 
+        AND OBJECT_NAME(parent_object_id) = 'GithubTokens'
+        AND EXISTS (
+          SELECT 1 FROM sys.index_columns ic 
+          INNER JOIN sys.columns c ON ic.object_id = c.object_id AND ic.column_id = c.column_id
+          WHERE ic.object_id = OBJECT_ID('GithubTokens') AND c.name = 'Token'
+        )
+        IF @constraintName IS NOT NULL
+          EXEC('ALTER TABLE GithubTokens DROP CONSTRAINT ' + @constraintName)
+      END TRY
+      BEGIN CATCH
+        -- Ignore errors
+      END CATCH
+    `);
+        consola.success("Database tables initialized");
+        return true;
+    }
+    catch (error) {
+        consola.error("Failed to connect to SQL Server:", error);
+        throw error;
+    }
+}
+/**
+ * Get database connection pool
+ */
+export function getPool() {
+    if (!pool) {
+        throw new Error("Database not initialized");
+    }
+    return pool;
+}
+/**
+ * Get all active tokens from database
+ */
+export async function getAllTokens() {
+    const pool = getPool();
+    const result = await pool.request().query(`
+    SELECT * FROM GithubTokens WHERE IsActive = 1
+  `);
+    return result.recordset;
+}
+/**
+ * Get a specific token by ID
+ */
+export async function getTokenById(id) {
+    const pool = getPool();
+    const result = await pool.request()
+        .input("id", sql.Int, id)
+        .query(`SELECT * FROM GithubTokens WHERE id = @id`);
+    return result.recordset[0] || null;
+}
+/**
+ * Get a token by GitHub token value
+ */
+export async function getTokenByGithubToken(githubToken) {
+    const pool = getPool();
+    const result = await pool.request()
+        .input("Token", sql.NVarChar, githubToken)
+        .query(`SELECT * FROM GithubTokens WHERE Token = @Token`);
+    return result.recordset[0] || null;
+}
+/**
+ * Save a new GitHub token to database (or update existing by username)
+ */
+export async function saveToken(githubToken, username, accountType = "individual") {
+    const pool = getPool();
+    const result = await pool.request()
+        .input("Token", sql.NVarChar, githubToken)
+        .input("UserName", sql.NVarChar, username || null)
+        .input("AccountType", sql.NVarChar, accountType)
+        .query(`
+      MERGE GithubTokens AS target
+      USING (SELECT @UserName AS UserName) AS source
+      ON target.UserName = source.UserName
+      WHEN MATCHED THEN
+        UPDATE SET Token = @Token, AccountType = @AccountType, IsActive = 1
+      WHEN NOT MATCHED THEN
+        INSERT (Token, UserName, AccountType) VALUES (@Token, @UserName, @AccountType)
+      OUTPUT inserted.id;
+    `);
+    return result.recordset[0]?.id;
+}
+/**
+ * Update GitHub token for an existing entry
+ */
+export async function updateGithubToken(id, githubToken) {
+    const pool = getPool();
+    await pool.request()
+        .input("id", sql.Int, id)
+        .input("Token", sql.NVarChar, githubToken)
+        .query(`
+      UPDATE GithubTokens 
+      SET Token = @Token, 
+          IsActive = 1
+      WHERE id = @id
+    `);
+}
+/**
+ * Deactivate a token
+ */
+export async function deactivateToken(id) {
+    const pool = getPool();
+    await pool.request()
+        .input("id", sql.Int, id)
+        .query(`UPDATE GithubTokens SET IsActive = 0 WHERE id = @id`);
+}
+/**
+ * Delete all tokens (soft delete - sets IsActive = 0 for all records)
+ */
+export async function deleteAllTokens() {
+    const pool = getPool();
+    const result = await pool.request().query(`UPDATE GithubTokens SET IsActive = 0 WHERE IsActive = 1`);
+    return result.rowsAffected[0] || 0;
+}
+/**
+ * Close database connection
+ */
+export async function closeDatabase() {
+    if (pool) {
+        await pool.close();
+        pool = null;
+        consola.info("Database connection closed");
+    }
+}

package/dist/lib/error.d.ts

@@ -0,0 +1,11 @@
+import type { Context } from "hono";
+export declare class HTTPError extends Error {
+    response: Response;
+    constructor(message: string, response: Response);
+}
+export declare function forwardError(c: Context, error: unknown): Promise<Response & import("hono").TypedResponse<{
+    error: {
+        message: string;
+        type: string;
+    };
+}, -1 | 100 | 102 | 103 | 200 | 201 | 202 | 203 | 206 | 207 | 208 | 226 | 300 | 301 | 302 | 303 | 305 | 306 | 307 | 308 | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451 | 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511, "json">>;

package/dist/lib/error.js

@@ -0,0 +1,34 @@
+import consola from "consola";
+export class HTTPError extends Error {
+    response;
+    constructor(message, response) {
+        super(message);
+        this.response = response;
+    }
+}
+export async function forwardError(c, error) {
+    consola.error("Error occurred:", error);
+    if (error instanceof HTTPError) {
+        const errorText = await error.response.text();
+        let errorJson;
+        try {
+            errorJson = JSON.parse(errorText);
+        }
+        catch {
+            errorJson = errorText;
+        }
+        consola.error("HTTP error:", errorJson);
+        return c.json({
+            error: {
+                message: errorText,
+                type: "error",
+            },
+        }, error.response.status);
+    }
+    return c.json({
+        error: {
+            message: error.message,
+            type: "error",
+        },
+    }, 500);
+}

package/dist/lib/state.d.ts

@@ -0,0 +1,9 @@
+import type { ModelsResponse } from "../services/copilot/get-models.js";
+export interface State {
+    githubToken?: string;
+    copilotToken?: string;
+    accountType: string;
+    models?: ModelsResponse;
+    vsCodeVersion?: string;
+}
+export declare const state: State;

package/dist/lib/state.js

@@ -0,0 +1,3 @@
+export const state = {
+    accountType: "individual",
+};