copilot-cursor-proxy 1.0.0

package/responses-converters.ts

@@ -0,0 +1,170 @@
+export async function convertResponsesSyncToChatCompletions(response: Response, model: string, chatId: string, corsHeaders: any) {
+    const data = await response.json() as any;
+    const result: any = {
+        id: chatId,
+        object: 'chat.completion',
+        created: data.created_at || Math.floor(Date.now() / 1000),
+        model: model,
+        choices: [],
+        usage: data.usage ? {
+            prompt_tokens: data.usage.input_tokens,
+            completion_tokens: data.usage.output_tokens,
+            total_tokens: data.usage.total_tokens,
+        } : undefined,
+    };
+
+    let textContent = '';
+    const toolCalls: any[] = [];
+
+    for (const item of (data.output || [])) {
+        if (item.type === 'message' && item.content) {
+            for (const part of item.content) {
+                if (part.type === 'output_text') textContent += part.text;
+            }
+        }
+        if (item.type === 'function_call') {
+            toolCalls.push({
+                id: item.call_id || item.id,
+                type: 'function',
+                function: { name: item.name, arguments: item.arguments },
+            });
+        }
+    }
+
+    const choice: any = {
+        index: 0,
+        message: {
+            role: 'assistant',
+            content: textContent || null,
+        },
+        finish_reason: toolCalls.length > 0 ? 'tool_calls' : 'stop',
+    };
+    if (toolCalls.length > 0) choice.message.tool_calls = toolCalls;
+    result.choices.push(choice);
+
+    return new Response(JSON.stringify(result), {
+        status: 200,
+        headers: { ...corsHeaders, "Content-Type": "application/json" },
+    });
+}
+
+export function convertResponsesStreamToChatCompletions(response: Response, model: string, chatId: string, corsHeaders: any) {
+    const reader = response.body!.getReader();
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    let buffer = '';
+    let toolCallIndex = 0;
+    let sentRole = false;
+    let chunkCount = 0;
+
+    const makeChatChunk = (delta: any, finishReason: string | null = null) => {
+        const chunk: any = {
+            id: chatId,
+            object: 'chat.completion.chunk',
+            created: Math.floor(Date.now() / 1000),
+            model: model,
+            choices: [{ index: 0, delta, finish_reason: finishReason }],
+        };
+        return `data: ${JSON.stringify(chunk)}\n\n`;
+    };
+
+    function processLines(lines: string[], controller: ReadableStreamDefaultController) {
+        for (const line of lines) {
+            if (!line.startsWith('data: ')) continue;
+            const jsonStr = line.slice(6).trim();
+            if (!jsonStr || jsonStr === '[DONE]') continue;
+
+            let event: any;
+            try { event = JSON.parse(jsonStr); } catch { continue; }
+
+            const eventType = event.type;
+
+            if (eventType === 'response.output_text.delta') {
+                const delta: any = { content: event.delta };
+                if (!sentRole) { delta.role = 'assistant'; sentRole = true; }
+                controller.enqueue(encoder.encode(makeChatChunk(delta)));
+                chunkCount++;
+            }
+
+            else if (eventType === 'response.output_item.added' && event.item?.type === 'function_call') {
+                const delta: any = {
+                    tool_calls: [{
+                        index: toolCallIndex,
+                        id: event.item.call_id || event.item.id,
+                        type: 'function',
+                        function: { name: event.item.name, arguments: '' },
+                    }]
+                };
+                if (!sentRole) { delta.role = 'assistant'; sentRole = true; }
+                controller.enqueue(encoder.encode(makeChatChunk(delta)));
+                chunkCount++;
+            }
+
+            else if (eventType === 'response.function_call_arguments.delta') {
+                controller.enqueue(encoder.encode(makeChatChunk({
+                    tool_calls: [{
+                        index: toolCallIndex,
+                        function: { arguments: event.delta },
+                    }]
+                })));
+                chunkCount++;
+            }
+
+            else if (eventType === 'response.output_item.done' && event.item?.type === 'function_call') {
+                toolCallIndex++;
+            }
+
+            else if (eventType === 'response.completed') {
+                const hasToolCalls = (event.response?.output || []).some((o: any) => o.type === 'function_call');
+                const finishReason = hasToolCalls ? 'tool_calls' : 'stop';
+                controller.enqueue(encoder.encode(makeChatChunk({}, finishReason)));
+                if (event.response?.usage) {
+                    const usageChunk: any = {
+                        id: chatId, object: 'chat.completion.chunk',
+                        created: Math.floor(Date.now() / 1000), model,
+                        choices: [],
+                        usage: {
+                            prompt_tokens: event.response.usage.input_tokens,
+                            completion_tokens: event.response.usage.output_tokens,
+                            total_tokens: event.response.usage.total_tokens,
+                        },
+                    };
+                    controller.enqueue(encoder.encode(`data: ${JSON.stringify(usageChunk)}\n\n`));
+                }
+                chunkCount++;
+            }
+        }
+    }
+
+    const stream = new ReadableStream({
+        async start(controller) {
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done) {
+                        if (buffer.trim()) {
+                            processLines(buffer.split('\n'), controller);
+                        }
+                        controller.enqueue(encoder.encode('data: [DONE]\n\n'));
+                        console.log(`✅ Responses→Chat stream complete: ${chunkCount} events processed`);
+                        controller.close();
+                        return;
+                    }
+
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || '';
+                    processLines(lines, controller);
+                }
+            } catch (err: any) {
+                console.error('❌ Responses stream conversion error:', err);
+                try { controller.close(); } catch {}
+            }
+        }
+    });
+
+    return new Response(stream, {
+        status: 200,
+        headers: { ...corsHeaders, "Content-Type": "text/event-stream", "Cache-Control": "no-cache" },
+    });
+}

package/start.ts

@@ -0,0 +1,138 @@
+#!/usr/bin/env bun
+/**
+ * One-command startup: launches copilot-api (port 4141) + proxy-router (port 4142)
+ * Usage: bun run start.ts
+ */
+
+import { spawn, sleep } from 'bun';
+import { existsSync } from 'fs';
+
+const COPILOT_API_PORT = 4141;
+const PROXY_PORT = 4142;
+
+// Colors for distinguishing output
+const RED = '\x1b[31m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const CYAN = '\x1b[36m';
+const RESET = '\x1b[0m';
+
+async function isPortInUse(port: number): Promise<boolean> {
+    try {
+        await fetch(`http://localhost:${port}/`, { signal: AbortSignal.timeout(2000) });
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+async function waitForPort(port: number, timeoutMs = 30000): Promise<boolean> {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        try {
+            const resp = await fetch(`http://localhost:${port}/v1/models`);
+            if (resp.ok) return true;
+        } catch {}
+        await sleep(500);
+    }
+    return false;
+}
+
+async function main() {
+    console.log(`${CYAN}🚀 Starting Copilot Proxy Stack...${RESET}\n`);
+
+    // 1. Check if copilot-api is already running
+    const copilotAlreadyRunning = await isPortInUse(COPILOT_API_PORT);
+    let copilotProc: ReturnType<typeof spawn> | null = null;
+
+    if (copilotAlreadyRunning) {
+        console.log(`${GREEN}✅ copilot-api already running on port ${COPILOT_API_PORT}${RESET}`);
+    } else {
+        console.log(`${YELLOW}⏳ Starting copilot-api on port ${COPILOT_API_PORT}...${RESET}`);
+
+        // Detect npx path
+        const isWindows = process.platform === 'win32';
+        const npxCmd = isWindows ? 'npx.cmd' : 'npx';
+
+        copilotProc = spawn([npxCmd, 'copilot-api', 'start'], {
+            stdout: 'pipe',
+            stderr: 'pipe',
+        });
+
+        // Stream copilot-api output with prefix
+        (async () => {
+            const reader = copilotProc!.stdout.getReader();
+            const decoder = new TextDecoder();
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                const text = decoder.decode(value, { stream: true });
+                for (const line of text.split('\n').filter(Boolean)) {
+                    console.log(`${RED}[copilot-api]${RESET} ${line}`);
+                }
+            }
+        })();
+
+        (async () => {
+            const reader = copilotProc!.stderr.getReader();
+            const decoder = new TextDecoder();
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                const text = decoder.decode(value, { stream: true });
+                for (const line of text.split('\n').filter(Boolean)) {
+                    console.log(`${RED}[copilot-api]${RESET} ${line}`);
+                }
+            }
+        })();
+
+        // Wait for copilot-api to be ready
+        console.log(`${YELLOW}⏳ Waiting for copilot-api to be ready...${RESET}`);
+        const ready = await waitForPort(COPILOT_API_PORT);
+        if (!ready) {
+            console.error(`${RED}❌ copilot-api failed to start within 30s${RESET}`);
+            copilotProc.kill();
+            process.exit(1);
+        }
+        console.log(`${GREEN}✅ copilot-api is ready on port ${COPILOT_API_PORT}${RESET}`);
+    }
+
+    // 2. Check if proxy is already running
+    const proxyAlreadyRunning = await isPortInUse(PROXY_PORT);
+    if (proxyAlreadyRunning) {
+        console.log(`${GREEN}✅ proxy-router already running on port ${PROXY_PORT}${RESET}`);
+        console.log(`\n${CYAN}🎉 Everything is running! Configure Cursor to use: http://localhost:${PROXY_PORT}/v1${RESET}`);
+        // Keep alive if we started copilot-api
+        if (copilotProc) await copilotProc.exited;
+        return;
+    }
+
+    // 3. Start proxy-router in the same process
+    console.log(`${YELLOW}⏳ Starting proxy-router on port ${PROXY_PORT}...${RESET}`);
+    await import('./proxy-router');
+
+    console.log(`\n${CYAN}🎉 All services running!${RESET}`);
+    console.log(`${CYAN}   copilot-api:   http://localhost:${COPILOT_API_PORT}${RESET}`);
+    console.log(`${CYAN}   proxy-router:  http://localhost:${PROXY_PORT}${RESET}`);
+    console.log(`${CYAN}   dashboard:     http://localhost:${PROXY_PORT}/${RESET}`);
+    console.log(`${CYAN}   Cursor config: http://localhost:${PROXY_PORT}/v1${RESET}`);
+
+    // Handle graceful shutdown
+    process.on('SIGINT', () => {
+        console.log(`\n${YELLOW}🛑 Shutting down...${RESET}`);
+        if (copilotProc) copilotProc.kill();
+        process.exit(0);
+    });
+    process.on('SIGTERM', () => {
+        if (copilotProc) copilotProc.kill();
+        process.exit(0);
+    });
+
+    // Keep alive
+    if (copilotProc) await copilotProc.exited;
+}
+
+main().catch(err => {
+    console.error(`${RED}❌ Fatal error:${RESET}`, err);
+    process.exit(1);
+});

package/stream-proxy.ts

@@ -0,0 +1,50 @@
+export const createStreamProxy = (responseBody: ReadableStream<Uint8Array>, responseHeaders: Headers) => {
+    let chunkCount = 0;
+    let lastChunkData = '';
+    let totalBytes = 0;
+    const reader = responseBody.getReader();
+    const decoder = new TextDecoder();
+    
+    const stream = new ReadableStream({
+        async pull(controller) {
+            try {
+                const { done, value } = await reader.read();
+                if (done) {
+                    console.log(`✅ Stream complete: ${chunkCount} chunks, ${totalBytes} bytes`);
+                    console.log(`✅ Last chunk: ${lastChunkData.slice(-200)}`);
+                    controller.close();
+                    return;
+                }
+                chunkCount++;
+                totalBytes += value.length;
+                lastChunkData = decoder.decode(value, { stream: true });
+                if (chunkCount === 1) {
+                    console.log(`📡 Stream started, first chunk: ${lastChunkData.slice(0, 200)}`);
+                }
+                if (lastChunkData.includes('"error"')) {
+                    console.error(`❌ Error in stream chunk ${chunkCount}: ${lastChunkData.slice(0, 500)}`);
+                }
+                if (lastChunkData.includes('finish_reason')) {
+                    const match = lastChunkData.match(/"finish_reason"\s*:\s*"([^"]+)"/);
+                    if (match) {
+                        console.log(`📡 finish_reason: "${match[1]}" at chunk ${chunkCount}`);
+                    }
+                }
+                controller.enqueue(value);
+            } catch (err: any) {
+                if (err?.code === 'ERR_INVALID_THIS') return;
+                console.error(`❌ Stream read error at chunk ${chunkCount}:`, err);
+                try { controller.error(err); } catch {}
+            }
+        },
+        cancel() {
+            console.log(`⚠️ Stream cancelled by client after ${chunkCount} chunks, ${totalBytes} bytes`);
+            try { reader.cancel(); } catch {}
+        }
+    });
+
+    return new Response(stream, {
+        status: 200,
+        headers: responseHeaders,
+    });
+};