copilot-router 1.0.0

package/dist/lib/token-manager.d.ts

@@ -0,0 +1,95 @@
+import type { ModelsResponse } from "../services/copilot/get-models.js";
+/**
+ * Token entry with runtime state
+ */
+export interface TokenEntry {
+    id: number;
+    githubToken: string;
+    username: string | null;
+    copilotToken: string | null;
+    copilotTokenExpiresAt: Date | null;
+    accountType: string;
+    isActive: boolean;
+    models?: ModelsResponse;
+    lastUsed?: Date;
+    requestCount: number;
+    errorCount: number;
+}
+/**
+ * Token Manager - Manages multiple GitHub tokens with load balancing
+ */
+declare class TokenManager {
+    private tokens;
+    private roundRobinIndex;
+    private nextMemoryId;
+    /**
+     * Get all token entries
+     */
+    getAllTokenEntries(): TokenEntry[];
+    /**
+     * Get active token entries only
+     */
+    getActiveTokenEntries(): TokenEntry[];
+    /**
+     * Get a random active token entry for load balancing
+     */
+    getRandomTokenEntry(): TokenEntry | null;
+    /**
+     * Get next token using round-robin for load balancing
+     */
+    getNextTokenEntry(): TokenEntry | null;
+    /**
+     * Get a specific token entry by ID
+     */
+    getTokenEntryById(id: number): TokenEntry | undefined;
+    /**
+     * Load tokens from database (only if database is connected)
+     * If database is not connected, try to load from local gh auth
+     */
+    loadFromDatabase(): Promise<void>;
+    /**
+     * Load token from local gh auth CLI
+     * This is used when database is not configured
+     */
+    loadFromLocalGhAuth(): Promise<void>;
+    /**
+     * Add a new token (from VSCode login)
+     */
+    addToken(githubToken: string, accountType?: string): Promise<TokenEntry>;
+    /**
+     * Remove a token
+     */
+    removeToken(id: number): Promise<boolean>;
+    /**
+     * Remove all tokens (for cleanup)
+     */
+    removeAllTokens(): Promise<void>;
+    /**
+     * Report an error for a token (for tracking)
+     */
+    reportError(id: number): void;
+    /**
+     * Get token count
+     */
+    getTokenCount(): {
+        total: number;
+        active: number;
+    };
+    /**
+     * Get statistics for all tokens
+     */
+    getStatistics(): TokenStatistics[];
+}
+export interface TokenStatistics {
+    id: number;
+    username: string | null;
+    accountType: string;
+    isActive: boolean;
+    hasValidCopilotToken: boolean;
+    copilotTokenExpiresAt: Date | null;
+    requestCount: number;
+    errorCount: number;
+    lastUsed?: Date;
+}
+export declare const tokenManager: TokenManager;
+export {};

package/dist/lib/token-manager.js

@@ -0,0 +1,241 @@
+import consola from "consola";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { getAllTokens, saveToken, updateGithubToken, deactivateToken, isDatabaseConnected, } from "./database.js";
+import { getGitHubUserForToken } from "../services/github/get-user.js";
+const execAsync = promisify(exec);
+/**
+ * Get the local GitHub auth token from gh CLI
+ * Returns null if gh is not installed or not authenticated
+ */
+async function getLocalGhAuthToken() {
+    try {
+        const { stdout } = await execAsync("gh auth token");
+        const token = stdout.trim();
+        if (token && token.startsWith("gho_")) {
+            consola.debug(`Found local gh auth token: ${token.substring(0, 15)}...`);
+            return token;
+        }
+        return null;
+    }
+    catch (error) {
+        consola.debug("Failed to get local gh auth token:", error instanceof Error ? error.message : error);
+        return null;
+    }
+}
+/**
+ * Token Manager - Manages multiple GitHub tokens with load balancing
+ */
+class TokenManager {
+    tokens = new Map();
+    roundRobinIndex = 0;
+    nextMemoryId = 1; // For generating IDs in memory-only mode
+    /**
+     * Get all token entries
+     */
+    getAllTokenEntries() {
+        return Array.from(this.tokens.values());
+    }
+    /**
+     * Get active token entries only
+     */
+    getActiveTokenEntries() {
+        return this.getAllTokenEntries().filter(t => t.isActive);
+    }
+    /**
+     * Get a random active token entry for load balancing
+     */
+    getRandomTokenEntry() {
+        const activeTokens = this.getActiveTokenEntries();
+        if (activeTokens.length === 0)
+            return null;
+        const randomIndex = Math.floor(Math.random() * activeTokens.length);
+        const token = activeTokens[randomIndex];
+        token.lastUsed = new Date();
+        token.requestCount++;
+        return token;
+    }
+    /**
+     * Get next token using round-robin for load balancing
+     */
+    getNextTokenEntry() {
+        const activeTokens = this.getActiveTokenEntries();
+        if (activeTokens.length === 0)
+            return null;
+        this.roundRobinIndex = this.roundRobinIndex % activeTokens.length;
+        const token = activeTokens[this.roundRobinIndex];
+        this.roundRobinIndex++;
+        token.lastUsed = new Date();
+        token.requestCount++;
+        return token;
+    }
+    /**
+     * Get a specific token entry by ID
+     */
+    getTokenEntryById(id) {
+        return this.tokens.get(id);
+    }
+    /**
+     * Load tokens from database (only if database is connected)
+     * If database is not connected, try to load from local gh auth
+     */
+    async loadFromDatabase() {
+        if (!isDatabaseConnected()) {
+            consola.info("Database not connected, trying to load local gh auth token...");
+            await this.loadFromLocalGhAuth();
+            return;
+        }
+        const dbTokens = await getAllTokens();
+        for (const record of dbTokens) {
+            const entry = {
+                id: record.Id,
+                githubToken: record.Token,
+                username: record.UserName,
+                copilotToken: null,
+                copilotTokenExpiresAt: null,
+                accountType: record.AccountType,
+                isActive: record.IsActive,
+                requestCount: 0,
+                errorCount: 0,
+            };
+            this.tokens.set(record.Id, entry);
+            // Update nextMemoryId to avoid conflicts
+            if (record.Id >= this.nextMemoryId) {
+                this.nextMemoryId = record.Id + 1;
+            }
+        }
+        consola.info(`Loaded ${this.tokens.size} tokens from database`);
+    }
+    /**
+     * Load token from local gh auth CLI
+     * This is used when database is not configured
+     */
+    async loadFromLocalGhAuth() {
+        const ghToken = await getLocalGhAuthToken();
+        if (!ghToken) {
+            consola.info("No local gh auth token found. Use /auth/login to add tokens or run 'gh auth login'.");
+            return;
+        }
+        try {
+            await this.addToken(ghToken, "individual");
+            consola.success("Loaded token from local gh auth");
+        }
+        catch (error) {
+            consola.warn("Failed to add local gh auth token:", error instanceof Error ? error.message : error);
+        }
+    }
+    /**
+     * Add a new token (from VSCode login)
+     */
+    async addToken(githubToken, accountType = "individual") {
+        // Get user info first to validate token
+        consola.debug(`addToken: Validating GitHub token: ${githubToken.substring(0, 15)}...`);
+        const user = await getGitHubUserForToken(githubToken);
+        const username = user.login;
+        consola.debug(`addToken: Token belongs to user: ${username}`);
+        // Check if token for this user already exists
+        const existingEntry = Array.from(this.tokens.values()).find(t => t.username === username);
+        if (existingEntry) {
+            // Update existing entry with new token
+            consola.debug(`addToken: Updating existing entry for ${username}, old token: ${existingEntry.githubToken.substring(0, 15)}...`);
+            existingEntry.githubToken = githubToken;
+            existingEntry.isActive = true;
+            existingEntry.errorCount = 0;
+            // Update in database if connected
+            if (isDatabaseConnected()) {
+                await updateGithubToken(existingEntry.id, githubToken);
+            }
+            consola.info(`Updated token for existing user: ${username}`);
+            return existingEntry;
+        }
+        // Generate ID - from database or memory
+        let id;
+        if (isDatabaseConnected()) {
+            id = await saveToken(githubToken, username, accountType);
+            consola.debug(`addToken: Saved new token with ID ${id}`);
+        }
+        else {
+            id = this.nextMemoryId++;
+            consola.debug(`addToken: Generated memory ID ${id}`);
+        }
+        // Create token entry
+        const entry = {
+            id,
+            githubToken,
+            username,
+            copilotToken: null,
+            copilotTokenExpiresAt: null,
+            accountType,
+            isActive: true,
+            requestCount: 0,
+            errorCount: 0,
+        };
+        this.tokens.set(id, entry);
+        consola.success(`Added token for user: ${username}`);
+        return entry;
+    }
+    /**
+     * Remove a token
+     */
+    async removeToken(id) {
+        const entry = this.tokens.get(id);
+        if (!entry)
+            return false;
+        // Deactivate in database if connected
+        if (isDatabaseConnected()) {
+            await deactivateToken(id);
+        }
+        this.tokens.delete(id);
+        consola.info(`Removed token for user: ${entry.username}`);
+        return true;
+    }
+    /**
+     * Remove all tokens (for cleanup)
+     */
+    async removeAllTokens() {
+        if (isDatabaseConnected()) {
+            const { deleteAllTokens } = await import("./database.js");
+            const count = await deleteAllTokens();
+            consola.info(`Removed ${count} tokens from database`);
+        }
+        this.tokens.clear();
+        consola.info("Cleared all tokens from memory");
+    }
+    /**
+     * Report an error for a token (for tracking)
+     */
+    reportError(id) {
+        const entry = this.tokens.get(id);
+        if (entry) {
+            entry.errorCount++;
+        }
+    }
+    /**
+     * Get token count
+     */
+    getTokenCount() {
+        const entries = Array.from(this.tokens.values());
+        return {
+            total: entries.length,
+            active: entries.filter(t => t.isActive && t.copilotToken).length,
+        };
+    }
+    /**
+     * Get statistics for all tokens
+     */
+    getStatistics() {
+        return Array.from(this.tokens.values()).map(entry => ({
+            id: entry.id,
+            username: entry.username,
+            accountType: entry.accountType,
+            isActive: entry.isActive,
+            hasValidCopilotToken: !!entry.copilotToken,
+            copilotTokenExpiresAt: entry.copilotTokenExpiresAt,
+            requestCount: entry.requestCount,
+            errorCount: entry.errorCount,
+            lastUsed: entry.lastUsed,
+        }));
+    }
+}
+// Singleton instance
+export const tokenManager = new TokenManager();

package/dist/lib/utils.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Utility functions for copilot-router
+ * Note: Token management has been moved to token-manager.ts
+ */
+/**
+ * Sleep helper
+ */
+export declare function sleep(ms: number): Promise<void>;

package/dist/lib/utils.js

@@ -0,0 +1,10 @@
+/**
+ * Utility functions for copilot-router
+ * Note: Token management has been moved to token-manager.ts
+ */
+/**
+ * Sleep helper
+ */
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/main.d.ts

@@ -0,0 +1 @@
+import "dotenv/config";

package/dist/main.js

@@ -0,0 +1,97 @@
+import "dotenv/config";
+import { serve } from "@hono/node-server";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { cors } from "hono/cors";
+import { logger } from "hono/logger";
+import consola from "consola";
+import { join } from "path";
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+import { initializeDatabase } from "./lib/database.js";
+import { tokenManager } from "./lib/token-manager.js";
+import { registerOpenAIRoutes } from "./routes/openai/routes.js";
+import { registerAnthropicRoutes } from "./routes/anthropic/routes.js";
+import { registerGeminiRoutes } from "./routes/gemini/routes.js";
+import { registerUtilityRoutes } from "./routes/utility/routes.js";
+import { registerAuthRoutes } from "./routes/auth/routes.js";
+const PORT = parseInt(process.env.PORT || "4242", 10);
+const TOKEN_REFRESH_INTERVAL = 25 * 60 * 1000; // 25 minutes
+// Get the package root directory (for static files)
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// When running via npx, COPILOT_ROUTER_ROOT is set by CLI; otherwise use relative path
+const PACKAGE_ROOT = process.env.COPILOT_ROUTER_ROOT || join(__dirname, "..");
+const PUBLIC_DIR = join(PACKAGE_ROOT, "public");
+async function main() {
+    consola.info("Starting Copilot Router...");
+    // Initialize database
+    consola.info("Connecting to SQL Server...");
+    await initializeDatabase();
+    // Load tokens from database
+    consola.info("Loading tokens from database...");
+    await tokenManager.loadFromDatabase();
+    // Refresh all Copilot tokens
+    const tokenCount = tokenManager.getTokenCount();
+    if (tokenCount.total > 0) {
+        consola.info(`Found ${tokenCount.total} tokens, refreshing Copilot tokens...`);
+        const updatedCount = tokenManager.getTokenCount();
+        consola.success(`${updatedCount.active} tokens active`);
+    }
+    else {
+        consola.warn("No tokens found. Use /auth/login to add tokens or run 'gh auth login'.");
+    }
+    // Create OpenAPI Hono app
+    const app = new OpenAPIHono();
+    // Middleware
+    app.use(logger());
+    app.use(cors());
+    // Register utility routes at root
+    registerUtilityRoutes(app);
+    // Register auth routes
+    registerAuthRoutes(app);
+    // OpenAI-compatible routes
+    const openaiRouter = new OpenAPIHono();
+    registerOpenAIRoutes(openaiRouter);
+    app.route("/", openaiRouter); // /chat/completions, /models, /embeddings
+    app.route("/v1", openaiRouter); // /v1/chat/completions, /v1/models, /v1/embeddings
+    // Anthropic-compatible routes
+    const anthropicRouter = new OpenAPIHono();
+    registerAnthropicRoutes(anthropicRouter);
+    app.route("/v1", anthropicRouter); // /v1/messages, /v1/messages/count_tokens
+    // Gemini-compatible routes
+    const geminiRouter = new OpenAPIHono();
+    registerGeminiRoutes(geminiRouter);
+    app.route("/v1beta", geminiRouter); // /v1beta/models/:model:generateContent
+    // Serve static files (login page)
+    app.use("/static/*", serveStatic({ root: PUBLIC_DIR, rewriteRequestPath: (path) => path.replace("/static", "") }));
+    app.get("/login", serveStatic({ path: join(PUBLIC_DIR, "index.html") }));
+    // OpenAPI documentation
+    app.doc("/openapi.json", {
+        openapi: "3.0.0",
+        info: {
+            title: "Copilot Router API",
+            version: "1.0.0",
+            description: "GitHub Copilot API with OpenAI, Anthropic, and Gemini compatibility",
+        },
+    });
+    // Start server
+    consola.info(`Starting server on port ${PORT}...`);
+    serve({
+        fetch: app.fetch,
+        port: PORT,
+    });
+    consola.success(`Copilot Router running at http://localhost:${PORT}`);
+    consola.info("Available endpoints:");
+    consola.info("  Web UI:    GET /login");
+    consola.info("  Auth:      POST /auth/login, POST /auth/complete, GET /auth/tokens");
+    consola.info("  OpenAI:    POST /v1/chat/completions, GET /v1/models, POST /v1/embeddings");
+    consola.info("  Anthropic: POST /v1/messages, POST /v1/messages/count_tokens");
+    consola.info("  Gemini:    POST /v1beta/models/:model:generateContent");
+    consola.info("  Utility:   GET /, GET /token, GET /usage, GET /quota");
+    consola.info("  Docs:      GET /openapi.json");
+}
+main().catch((error) => {
+    consola.error("Failed to start server:", error);
+    process.exit(1);
+});

package/dist/routes/anthropic/routes.d.ts

@@ -0,0 +1,2 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+export declare function registerAnthropicRoutes(app: OpenAPIHono): void;

package/dist/routes/anthropic/routes.js

@@ -0,0 +1,155 @@
+import { createRoute, z } from "@hono/zod-openapi";
+import { streamSSE } from "hono/streaming";
+import consola from "consola";
+import { forwardError } from "../../lib/error.js";
+import { createChatCompletions, } from "../../services/copilot/create-chat-completions.js";
+import { translateToAnthropic, translateToOpenAI } from "./translation.js";
+import { translateChunkToAnthropicEvents } from "./stream-translation.js";
+const AnthropicErrorResponseSchema = z.object({
+    type: z.literal("error"),
+    error: z.object({
+        type: z.string(),
+        message: z.string(),
+    }),
+});
+// Messages route
+const messagesRoute = createRoute({
+    method: "post",
+    path: "/messages",
+    tags: ["Anthropic API"],
+    summary: "Create a message with Anthropic-compatible API",
+    description: "Create a message using the Anthropic-compatible API interface, powered by GitHub Copilot.",
+    request: {
+        body: {
+            content: {
+                "application/json": {
+                    schema: z.object({}).passthrough(),
+                },
+            },
+        },
+    },
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.object({}).passthrough(),
+                },
+                "text/event-stream": {
+                    schema: z.string(),
+                },
+            },
+            description: "Successfully created message",
+        },
+        400: {
+            content: { "application/json": { schema: AnthropicErrorResponseSchema } },
+            description: "Bad request",
+        },
+        500: {
+            content: { "application/json": { schema: AnthropicErrorResponseSchema } },
+            description: "Internal server error",
+        },
+    },
+});
+// Count tokens route
+const countTokensRoute = createRoute({
+    method: "post",
+    path: "/messages/count_tokens",
+    tags: ["Anthropic API"],
+    summary: "Count input tokens for Anthropic-compatible messages",
+    description: "Count the input tokens for messages using the Anthropic-compatible API interface.",
+    request: {
+        body: {
+            content: {
+                "application/json": {
+                    schema: z.object({}).passthrough(),
+                },
+            },
+        },
+    },
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.object({
+                        input_tokens: z.number(),
+                    }),
+                },
+            },
+            description: "Successfully counted input tokens",
+        },
+        500: {
+            content: { "application/json": { schema: AnthropicErrorResponseSchema } },
+            description: "Internal server error",
+        },
+    },
+});
+const isNonStreaming = (response) => Object.hasOwn(response, "choices");
+export function registerAnthropicRoutes(app) {
+    // POST /messages
+    app.openapi(messagesRoute, async (c) => {
+        try {
+            const anthropicPayload = await c.req.json();
+            consola.debug("Anthropic request payload:", JSON.stringify(anthropicPayload));
+            const openAIPayload = translateToOpenAI(anthropicPayload);
+            consola.debug("Translated OpenAI request payload:", JSON.stringify(openAIPayload));
+            const response = await createChatCompletions(openAIPayload);
+            if (isNonStreaming(response)) {
+                consola.debug("Non-streaming response from Copilot");
+                const anthropicResponse = translateToAnthropic(response);
+                return c.json(anthropicResponse);
+            }
+            consola.debug("Streaming response from Copilot");
+            return streamSSE(c, async (stream) => {
+                const streamState = {
+                    messageStartSent: false,
+                    contentBlockIndex: 0,
+                    contentBlockOpen: false,
+                    toolCalls: {},
+                };
+                for await (const rawEvent of response) {
+                    if (rawEvent.data === "[DONE]")
+                        break;
+                    if (!rawEvent.data)
+                        continue;
+                    const chunk = JSON.parse(rawEvent.data);
+                    const events = translateChunkToAnthropicEvents(chunk, streamState);
+                    for (const event of events) {
+                        await stream.writeSSE({
+                            event: event.type,
+                            data: JSON.stringify(event),
+                        });
+                    }
+                }
+            });
+        }
+        catch (error) {
+            return await forwardError(c, error);
+        }
+    });
+    // POST /messages/count_tokens
+    app.openapi(countTokensRoute, async (c) => {
+        try {
+            const anthropicPayload = await c.req.json();
+            const openAIPayload = translateToOpenAI(anthropicPayload);
+            // Simple estimation: count characters and divide by 4
+            let totalChars = 0;
+            for (const msg of openAIPayload.messages) {
+                if (typeof msg.content === "string") {
+                    totalChars += msg.content.length;
+                }
+                else if (Array.isArray(msg.content)) {
+                    for (const part of msg.content) {
+                        if (part.type === "text") {
+                            totalChars += part.text.length;
+                        }
+                    }
+                }
+            }
+            const estimatedTokens = Math.ceil(totalChars / 4);
+            return c.json({ input_tokens: estimatedTokens });
+        }
+        catch (error) {
+            return await forwardError(c, error);
+        }
+    });
+}

package/dist/routes/anthropic/stream-translation.d.ts

@@ -0,0 +1,3 @@
+import { type ChatCompletionChunk } from "../../services/copilot/create-chat-completions.js";
+import { type AnthropicStreamEventData, type AnthropicStreamState } from "./types.js";
+export declare function translateChunkToAnthropicEvents(chunk: ChatCompletionChunk, state: AnthropicStreamState): Array<AnthropicStreamEventData>;