copilot-cursor-proxy 1.0.1 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "copilot-cursor-proxy",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Proxy that bridges GitHub Copilot API to Cursor IDE — translates Anthropic format, bridges Responses API for GPT 5.x, and more",
   "bin": {
     "copilot-cursor-proxy": "bin/cli.js"
@@ -12,7 +12,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "bun build start.ts proxy-router.ts anthropic-transforms.ts responses-bridge.ts responses-converters.ts stream-proxy.ts debug-logger.ts --outdir dist --target node",
+    "build": "bun build start.ts proxy-router.ts anthropic-transforms.ts responses-bridge.ts responses-converters.ts stream-proxy.ts debug-logger.ts auth-config.ts --outdir dist --target node",
     "dev": "bun run start.ts",
     "start": "node dist/start.js"
   },

package/proxy-router.ts

@@ -2,7 +2,40 @@ import { normalizeRequest } from './anthropic-transforms';
 import { handleResponsesAPIBridge } from './responses-bridge';
 import { createStreamProxy } from './stream-proxy';
 import { logIncomingRequest, logTransformedRequest } from './debug-logger';
+import { addRequestLog, getNextRequestId, getUsageStats, flushToDisk, type RequestLog } from './usage-db';
+import { loadAuthConfig, saveAuthConfig, generateApiKey, validateApiKey } from './auth-config';
 
+// ── Console capture for SSE streaming ─────────────────────────────────────────
+interface ConsoleLine {
+    timestamp: number;
+    level: 'LOG' | 'INFO' | 'WARN' | 'ERROR' | 'DEBUG';
+    message: string;
+}
+
+const consoleLines: ConsoleLine[] = [];
+const MAX_CONSOLE_LINES = 500;
+const logSubscribers = new Set<ReadableStreamDefaultController>();
+
+const origLog = console.log;
+const origError = console.error;
+const origWarn = console.warn;
+
+function addConsoleLine(level: ConsoleLine['level'], args: any[]) {
+    const message = args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ');
+    const line: ConsoleLine = { timestamp: Date.now(), level, message };
+    consoleLines.push(line);
+    if (consoleLines.length > MAX_CONSOLE_LINES) consoleLines.shift();
+    const data = `data: ${JSON.stringify({ type: 'line', ...line })}\n\n`;
+    for (const ctrl of logSubscribers) {
+        try { ctrl.enqueue(new TextEncoder().encode(data)); } catch { logSubscribers.delete(ctrl); }
+    }
+}
+
+console.log = (...args: any[]) => { origLog(...args); addConsoleLine('LOG', args); };
+console.error = (...args: any[]) => { origError(...args); addConsoleLine('ERROR', args); };
+console.warn = (...args: any[]) => { origWarn(...args); addConsoleLine('WARN', args); };
+
+// ── Config ────────────────────────────────────────────────────────────────────
 const PORT = 4142;
 const TARGET_URL = "http://localhost:4141";
 const PREFIX = "cus-";
@@ -18,15 +51,113 @@ Bun.serve({
   async fetch(req) {
     const url = new URL(req.url);
 
+    // ── Dashboard ─────────────────────────────────────────────────────────
     if (url.pathname === "/" || url.pathname === "/dashboard.html") {
       try {
-        const dashboardContent = await Bun.file("dashboard.html").text();
+        const dashboardPath = import.meta.dir + "/dashboard.html";
+        const dashboardContent = await Bun.file(dashboardPath).text();
         return new Response(dashboardContent, { headers: { "Content-Type": "text/html" } });
       } catch (e) {
         return new Response("Dashboard not found.", { status: 404 });
       }
     }
 
+    // ── Dashboard API: usage stats ────────────────────────────────────────
+    if (url.pathname === "/api/usage") {
+        return new Response(JSON.stringify(getUsageStats()), {
+            headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" },
+        });
+    }
+
+    // ── Dashboard API: flush usage to disk ────────────────────────────────
+    if (url.pathname === "/api/usage/flush" && req.method === "POST") {
+        await flushToDisk();
+        return new Response('{"ok":true}', {
+            headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" },
+        });
+    }
+
+    // ── Dashboard API: SSE console log stream ─────────────────────────────
+    if (url.pathname === "/api/logs/stream") {
+        const stream = new ReadableStream({
+            start(controller) {
+                const initData = `data: ${JSON.stringify({ type: 'init', lines: consoleLines })}\n\n`;
+                controller.enqueue(new TextEncoder().encode(initData));
+                logSubscribers.add(controller);
+            },
+            cancel() {
+                // cleaned up on enqueue failure
+            },
+        });
+        return new Response(stream, {
+            headers: {
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "Access-Control-Allow-Origin": "*",
+            },
+        });
+    }
+
+    // ── Dashboard API: clear console logs ─────────────────────────────────
+    if (url.pathname === "/api/logs/clear" && req.method === "POST") {
+        consoleLines.length = 0;
+        const data = `data: ${JSON.stringify({ type: 'clear' })}\n\n`;
+        for (const ctrl of logSubscribers) {
+            try { ctrl.enqueue(new TextEncoder().encode(data)); } catch { logSubscribers.delete(ctrl); }
+        }
+        return new Response('{"ok":true}', {
+            headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" },
+        });
+    }
+
+    // ── API Key management endpoints ──────────────────────────────────
+    const corsHeaders = { "Access-Control-Allow-Origin": "*" };
+
+    if (url.pathname === "/api/keys" && req.method === "GET") {
+        const config = loadAuthConfig();
+        const maskedKeys = config.keys.map(k => ({
+            ...k,
+            key: k.key.slice(0, 12) + '...'
+        }));
+        return Response.json({ requireApiKey: config.requireApiKey, keys: maskedKeys }, { headers: corsHeaders });
+    }
+
+    if (url.pathname === "/api/keys" && req.method === "POST") {
+        const { name } = await req.json();
+        const config = loadAuthConfig();
+        const newKey = generateApiKey(name || 'Untitled');
+        config.keys.push(newKey);
+        saveAuthConfig(config);
+        return Response.json(newKey, { headers: corsHeaders });
+    }
+
+    if (url.pathname.startsWith("/api/keys/") && req.method === "PUT") {
+        const id = url.pathname.split('/').pop();
+        const { active } = await req.json();
+        const config = loadAuthConfig();
+        const key = config.keys.find(k => k.id === id);
+        if (key) { key.active = active; saveAuthConfig(config); }
+        return Response.json({ ok: true }, { headers: corsHeaders });
+    }
+
+    if (url.pathname.startsWith("/api/keys/") && req.method === "DELETE") {
+        const id = url.pathname.split('/').pop();
+        const config = loadAuthConfig();
+        config.keys = config.keys.filter(k => k.id !== id);
+        saveAuthConfig(config);
+        return Response.json({ ok: true }, { headers: corsHeaders });
+    }
+
+    if (url.pathname === "/api/settings/auth" && req.method === "PUT") {
+        const { requireApiKey } = await req.json();
+        const config = loadAuthConfig();
+        config.requireApiKey = requireApiKey;
+        saveAuthConfig(config);
+        return Response.json({ ok: true }, { headers: corsHeaders });
+    }
+
+    // ── Proxy logic ───────────────────────────────────────────────────────
     const targetUrl = new URL(url.pathname + url.search, TARGET_URL);
 
     if (req.method === "OPTIONS") {
@@ -41,6 +172,20 @@ Bun.serve({
 
     try {
       if (req.method === "POST" && url.pathname.includes("/chat/completions")) {
+        // Check API key if required
+        const authConfig = loadAuthConfig();
+        if (authConfig.requireApiKey) {
+            const authHeader = req.headers.get('authorization');
+            const providedKey = authHeader?.replace('Bearer ', '');
+            if (!providedKey || !validateApiKey(providedKey)) {
+                return Response.json(
+                    { error: { message: "Invalid API key. Generate one from the dashboard.", type: "invalid_api_key" } },
+                    { status: 401, headers: { "Access-Control-Allow-Origin": "*" } }
+                );
+            }
+        }
+
+        const startTime = Date.now();
         let json = await req.json();
 
         logIncomingRequest(json);
@@ -67,10 +212,32 @@ Bun.serve({
 
         const needsResponsesAPI = targetModel.match(/^gpt-5\.[2-9]|^gpt-5\.\d+-codex|^o[1-9]|^goldeneye/i);
         
+        // For models that need max_completion_tokens instead of max_tokens
+        const needsMaxCompletionTokens = targetModel.match(/^gpt-5\.[2-9]|^gpt-5\.\d+-codex|^goldeneye/i);
+        if (needsMaxCompletionTokens && json.max_tokens) {
+            json.max_completion_tokens = json.max_tokens;
+            delete json.max_tokens;
+            console.log(`🔧 Converted max_tokens → max_completion_tokens`);
+        }
+
+        // Try Responses API first for models that may need it; fall back to chat completions
         if (needsResponsesAPI) {
-            console.log(`🔀 Model ${targetModel} requires Responses API — converting`);
+            console.log(`🔀 Model ${targetModel} — trying Responses API bridge`);
             const chatId = `chatcmpl-proxy-${++responseCounter}`;
-            return await handleResponsesAPIBridge(json, req, chatId, TARGET_URL);
+            try {
+                const result = await handleResponsesAPIBridge(json, req, chatId, TARGET_URL);
+                if (result.status !== 404) {
+                    addRequestLog({
+                        id: getNextRequestId(), timestamp: startTime, model: targetModel,
+                        promptTokens: 0, completionTokens: 0, totalTokens: 0,
+                        status: result.status, duration: Date.now() - startTime, stream: !!json.stream,
+                    });
+                    return result;
+                }
+                console.log(`⚠️ Responses API returned 404 — falling back to chat/completions`);
+            } catch (e) {
+                console.log(`⚠️ Responses API failed — falling back to chat/completions`);
+            }
         }
 
         const hasVisionContent = (messages: any[]) => messages?.some(msg => 
@@ -94,13 +261,42 @@ Bun.serve({
         if (!response.ok) {
             const errText = await response.text();
             console.error(`❌ Upstream Error (${response.status}):`, errText);
+            addRequestLog({
+                id: getNextRequestId(), timestamp: startTime, model: targetModel,
+                promptTokens: 0, completionTokens: 0, totalTokens: 0,
+                status: response.status, duration: Date.now() - startTime, stream: !!json.stream,
+            });
             return new Response(errText, { status: response.status, headers: responseHeaders });
         }
 
         if (json.stream && response.body) {
-            return createStreamProxy(response.body, responseHeaders);
+            return createStreamProxy(response.body, responseHeaders, (usage) => {
+                addRequestLog({
+                    id: getNextRequestId(), timestamp: startTime, model: targetModel,
+                    promptTokens: usage.promptTokens, completionTokens: usage.completionTokens,
+                    totalTokens: usage.totalTokens,
+                    status: response.status, duration: Date.now() - startTime, stream: true,
+                });
+            });
         }
 
+        // Non-streaming: clone and parse to extract usage
+        const cloned = response.clone();
+        let promptTokens = 0, completionTokens = 0, totalTokens = 0;
+        try {
+            const respJson = await cloned.json();
+            if (respJson.usage) {
+                promptTokens = respJson.usage.prompt_tokens || 0;
+                completionTokens = respJson.usage.completion_tokens || 0;
+                totalTokens = respJson.usage.total_tokens || promptTokens + completionTokens;
+            }
+        } catch { /* ignore parse errors */ }
+        addRequestLog({
+            id: getNextRequestId(), timestamp: startTime, model: targetModel,
+            promptTokens, completionTokens, totalTokens,
+            status: response.status, duration: Date.now() - startTime, stream: false,
+        });
+
         return new Response(response.body, {
           status: response.status,
           headers: responseHeaders,
@@ -108,6 +304,19 @@ Bun.serve({
       }
 
       if (req.method === "GET" && url.pathname.includes("/models")) {
+        // Check API key if required
+        const authConfig = loadAuthConfig();
+        if (authConfig.requireApiKey) {
+            const authHeader = req.headers.get('authorization');
+            const providedKey = authHeader?.replace('Bearer ', '');
+            if (!providedKey || !validateApiKey(providedKey)) {
+                return Response.json(
+                    { error: { message: "Invalid API key. Generate one from the dashboard.", type: "invalid_api_key" } },
+                    { status: 401, headers: { "Access-Control-Allow-Origin": "*" } }
+                );
+            }
+        }
+
         const headers = new Headers(req.headers);
         headers.set("host", targetUrl.host);
         const response = await fetch(targetUrl.toString(), { method: "GET", headers: headers });

package/responses-converters.ts

@@ -89,7 +89,7 @@ export function convertResponsesStreamToChatCompletions(response: Response, mode
             else if (eventType === 'response.output_item.added' && event.item?.type === 'function_call') {
                 const delta: any = {
                     tool_calls: [{
-                        index: toolCallIndex,
+                        index: toolCallIndex++,
                         id: event.item.call_id || event.item.id,
                         type: 'function',
                         function: { name: event.item.name, arguments: '' },
@@ -103,7 +103,7 @@ export function convertResponsesStreamToChatCompletions(response: Response, mode
             else if (eventType === 'response.function_call_arguments.delta') {
                 controller.enqueue(encoder.encode(makeChatChunk({
                     tool_calls: [{
-                        index: toolCallIndex,
+                        index: toolCallIndex - 1,
                         function: { arguments: event.delta },
                     }]
                 })));
@@ -111,7 +111,7 @@ export function convertResponsesStreamToChatCompletions(response: Response, mode
             }
 
             else if (eventType === 'response.output_item.done' && event.item?.type === 'function_call') {
-                toolCallIndex++;
+                // toolCallIndex already incremented on 'added'
             }
 
             else if (eventType === 'response.completed') {

package/stream-proxy.ts

@@ -1,7 +1,18 @@
-export const createStreamProxy = (responseBody: ReadableStream<Uint8Array>, responseHeaders: Headers) => {
+export interface StreamUsageResult {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+}
+
+export const createStreamProxy = (
+    responseBody: ReadableStream<Uint8Array>,
+    responseHeaders: Headers,
+    onComplete?: (usage: StreamUsageResult) => void,
+) => {
     let chunkCount = 0;
     let lastChunkData = '';
     let totalBytes = 0;
+    let extractedUsage: StreamUsageResult = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
     const reader = responseBody.getReader();
     const decoder = new TextDecoder();
     
@@ -12,6 +23,7 @@ export const createStreamProxy = (responseBody: ReadableStream<Uint8Array>, resp
                 if (done) {
                     console.log(`✅ Stream complete: ${chunkCount} chunks, ${totalBytes} bytes`);
                     console.log(`✅ Last chunk: ${lastChunkData.slice(-200)}`);
+                    if (onComplete) onComplete(extractedUsage);
                     controller.close();
                     return;
                 }
@@ -30,6 +42,24 @@ export const createStreamProxy = (responseBody: ReadableStream<Uint8Array>, resp
                         console.log(`📡 finish_reason: "${match[1]}" at chunk ${chunkCount}`);
                     }
                 }
+                // Extract usage from chunks (often in the final chunk)
+                if (lastChunkData.includes('"usage"')) {
+                    try {
+                        const lines = lastChunkData.split('\n');
+                        for (const line of lines) {
+                            const jsonStr = line.replace(/^data:\s*/, '').trim();
+                            if (!jsonStr || jsonStr === '[DONE]') continue;
+                            const parsed = JSON.parse(jsonStr);
+                            if (parsed.usage) {
+                                extractedUsage = {
+                                    promptTokens: parsed.usage.prompt_tokens || 0,
+                                    completionTokens: parsed.usage.completion_tokens || 0,
+                                    totalTokens: parsed.usage.total_tokens || (parsed.usage.prompt_tokens || 0) + (parsed.usage.completion_tokens || 0),
+                                };
+                            }
+                        }
+                    } catch { /* ignore parse errors in partial chunks */ }
+                }
                 controller.enqueue(value);
             } catch (err: any) {
                 if (err?.code === 'ERR_INVALID_THIS') return;
@@ -39,6 +69,7 @@ export const createStreamProxy = (responseBody: ReadableStream<Uint8Array>, resp
         },
         cancel() {
             console.log(`⚠️ Stream cancelled by client after ${chunkCount} chunks, ${totalBytes} bytes`);
+            if (onComplete) onComplete(extractedUsage);
             try { reader.cancel(); } catch {}
         }
     });

package/usage-db.ts

@@ -0,0 +1,210 @@
+import { mkdirSync, existsSync, readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+// ── Types ────────────────────────────────────────────────────────────────────
+
+export interface RequestLog {
+    id: number;
+    timestamp: number;
+    model: string;
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    status: number;
+    duration: number;
+    stream: boolean;
+}
+
+interface DailySnapshot {
+    date: string;
+    requests: number;
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    errors: number;
+    byModel: Record<string, { requests: number; promptTokens: number; completionTokens: number; totalTokens: number; errors: number }>;
+}
+
+interface UsageData {
+    version: 1;
+    createdAt: number;
+    lastSavedAt: number;
+    requestIdCounter: number;
+    recentRequests: RequestLog[];
+    dailySnapshots: DailySnapshot[];
+    lifetimeTotals: {
+        requests: number;
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+        errors: number;
+    };
+}
+
+// ── Config ───────────────────────────────────────────────────────────────────
+
+const MAX_RECENT_REQUESTS = 1000;
+const MAX_DAILY_SNAPSHOTS = 90;
+const DEBOUNCE_MS = 3000;
+
+const DATA_DIR = process.env.DATA_DIR || join(homedir(), '.copilot-proxy');
+const USAGE_FILE = join(DATA_DIR, 'usage.json');
+
+// ── State ────────────────────────────────────────────────────────────────────
+
+let data: UsageData;
+let saveTimer: ReturnType<typeof setTimeout> | null = null;
+let dirty = false;
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+const todayKey = () => new Date().toISOString().slice(0, 10);
+
+const emptyData = (): UsageData => ({
+    version: 1,
+    createdAt: Date.now(),
+    lastSavedAt: Date.now(),
+    requestIdCounter: 0,
+    recentRequests: [],
+    dailySnapshots: [],
+    lifetimeTotals: { requests: 0, promptTokens: 0, completionTokens: 0, totalTokens: 0, errors: 0 },
+});
+
+// ── Persistence ──────────────────────────────────────────────────────────────
+
+const loadSync = (): UsageData => {
+    try {
+        if (!existsSync(USAGE_FILE)) return emptyData();
+        const text = readFileSync(USAGE_FILE, 'utf-8');
+        return JSON.parse(text) as UsageData;
+    } catch {
+        return emptyData();
+    }
+};
+
+const saveToDisk = async () => {
+    try {
+        data.lastSavedAt = Date.now();
+        writeFileSync(USAGE_FILE, JSON.stringify(data, null, 2), 'utf-8');
+    } catch (e) {
+        console.error('Failed to save usage data:', e);
+    }
+    dirty = false;
+};
+
+const scheduleSave = () => {
+    dirty = true;
+    if (saveTimer) return;
+    saveTimer = setTimeout(async () => {
+        saveTimer = null;
+        if (dirty) await saveToDisk();
+    }, DEBOUNCE_MS);
+};
+
+// ── Initialize ───────────────────────────────────────────────────────────────
+
+const init = () => {
+    if (!existsSync(DATA_DIR)) {
+        mkdirSync(DATA_DIR, { recursive: true });
+    }
+    data = loadSync();
+    console.log(`💾 Usage DB: ${USAGE_FILE} (${data.lifetimeTotals.requests} lifetime requests)`);
+};
+
+init();
+
+// ── Public API ───────────────────────────────────────────────────────────────
+
+export const getNextRequestId = (): number => {
+    data.requestIdCounter++;
+    return data.requestIdCounter;
+};
+
+export const addRequestLog = (log: RequestLog) => {
+    data.recentRequests.push(log);
+    if (data.recentRequests.length > MAX_RECENT_REQUESTS) {
+        data.recentRequests.shift();
+    }
+
+    data.lifetimeTotals.requests++;
+    data.lifetimeTotals.promptTokens += log.promptTokens;
+    data.lifetimeTotals.completionTokens += log.completionTokens;
+    data.lifetimeTotals.totalTokens += log.totalTokens;
+    if (log.status >= 400) data.lifetimeTotals.errors++;
+
+    const today = todayKey();
+    let snap = data.dailySnapshots.find(s => s.date === today);
+    if (!snap) {
+        snap = { date: today, requests: 0, promptTokens: 0, completionTokens: 0, totalTokens: 0, errors: 0, byModel: {} };
+        data.dailySnapshots.push(snap);
+        if (data.dailySnapshots.length > MAX_DAILY_SNAPSHOTS) {
+            data.dailySnapshots.shift();
+        }
+    }
+    snap.requests++;
+    snap.promptTokens += log.promptTokens;
+    snap.completionTokens += log.completionTokens;
+    snap.totalTokens += log.totalTokens;
+    if (log.status >= 400) snap.errors++;
+
+    if (!snap.byModel[log.model]) {
+        snap.byModel[log.model] = { requests: 0, promptTokens: 0, completionTokens: 0, totalTokens: 0, errors: 0 };
+    }
+    const m = snap.byModel[log.model];
+    m.requests++;
+    m.promptTokens += log.promptTokens;
+    m.completionTokens += log.completionTokens;
+    m.totalTokens += log.totalTokens;
+    if (log.status >= 400) m.errors++;
+
+    scheduleSave();
+};
+
+export const getRecentRequests = (): RequestLog[] => data.recentRequests;
+
+export const getUsageStats = () => {
+    const logs = data.recentRequests;
+    const byModel = Object.entries(
+        logs.reduce((acc, r) => {
+            if (!acc[r.model]) acc[r.model] = { requests: 0, promptTokens: 0, completionTokens: 0, totalTokens: 0, errors: 0, totalDuration: 0, avgDuration: 0 };
+            acc[r.model].requests++;
+            acc[r.model].promptTokens += r.promptTokens;
+            acc[r.model].completionTokens += r.completionTokens;
+            acc[r.model].totalTokens += r.totalTokens;
+            if (r.status >= 400) acc[r.model].errors++;
+            acc[r.model].totalDuration += r.duration;
+            acc[r.model].avgDuration = Math.round(acc[r.model].totalDuration / acc[r.model].requests);
+            return acc;
+        }, {} as Record<string, any>),
+    ).map(([model, d]) => ({ model, ...d }));
+
+    return {
+        totalRequests: data.lifetimeTotals.requests,
+        totalPromptTokens: data.lifetimeTotals.promptTokens,
+        totalCompletionTokens: data.lifetimeTotals.completionTokens,
+        totalTokens: data.lifetimeTotals.totalTokens,
+        totalErrors: data.lifetimeTotals.errors,
+        byModel,
+        recentRequests: logs.slice(-50).reverse(),
+        dailySnapshots: data.dailySnapshots,
+        persistence: {
+            dataDir: DATA_DIR,
+            file: USAGE_FILE,
+            lastSavedAt: data.lastSavedAt,
+            createdAt: data.createdAt,
+        },
+    };
+};
+
+export const flushToDisk = async () => {
+    if (saveTimer) {
+        clearTimeout(saveTimer);
+        saveTimer = null;
+    }
+    await saveToDisk();
+};
+
+process.on('beforeExit', () => { flushToDisk(); });
+process.on('SIGINT', async () => { await flushToDisk(); process.exit(0); });
+process.on('SIGTERM', async () => { await flushToDisk(); process.exit(0); });