cccproxy 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ruslan Yakushev
+
+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/dist/index.js

@@ -0,0 +1,673 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { parseArgs } from "util";
+import { serve } from "@hono/node-server";
+
+// src/auth/token.ts
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+
+// src/config.ts
+import { randomUUID } from "crypto";
+var GITHUB_BASE_URL = "https://github.com";
+var GITHUB_API_BASE_URL = "https://api.github.com";
+var GITHUB_CLIENT_ID = "Iv1.b507a08c87ecfe98";
+var GITHUB_APP_SCOPES = "read:user";
+var COPILOT_VERSION = "0.26.7";
+var EDITOR_PLUGIN_VERSION = `copilot-chat/${COPILOT_VERSION}`;
+var USER_AGENT = `GitHubCopilotChat/${COPILOT_VERSION}`;
+var API_VERSION = "2025-04-01";
+var standardHeaders = () => ({
+  "content-type": "application/json",
+  accept: "application/json"
+});
+var copilotBaseUrl = (state2) => state2.accountType === "individual" ? "https://api.githubcopilot.com" : `https://api.${state2.accountType}.githubcopilot.com`;
+var copilotHeaders = (state2, vision = false) => {
+  const headers = {
+    Authorization: `Bearer ${state2.copilotToken}`,
+    "content-type": "application/json",
+    "copilot-integration-id": "vscode-chat",
+    "editor-version": `vscode/${state2.vsCodeVersion}`,
+    "editor-plugin-version": EDITOR_PLUGIN_VERSION,
+    "user-agent": USER_AGENT,
+    "openai-intent": "conversation-panel",
+    "x-github-api-version": API_VERSION,
+    "x-request-id": randomUUID(),
+    "x-vscode-user-agent-library-version": "electron-fetch"
+  };
+  if (vision) headers["copilot-vision-request"] = "true";
+  return headers;
+};
+var githubHeaders = (state2) => ({
+  ...standardHeaders(),
+  authorization: `token ${state2.githubToken}`,
+  "editor-version": `vscode/${state2.vsCodeVersion}`,
+  "editor-plugin-version": EDITOR_PLUGIN_VERSION,
+  "user-agent": USER_AGENT,
+  "x-github-api-version": API_VERSION,
+  "x-vscode-user-agent-library-version": "electron-fetch"
+});
+
+// src/auth/device-code.ts
+async function getDeviceCode() {
+  const response = await fetch(`${GITHUB_BASE_URL}/login/device/code`, {
+    method: "POST",
+    headers: standardHeaders(),
+    body: JSON.stringify({
+      client_id: GITHUB_CLIENT_ID,
+      scope: GITHUB_APP_SCOPES
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to get device code: ${response.status}`);
+  }
+  return await response.json();
+}
+async function pollAccessToken(deviceCode) {
+  const sleepDuration = (deviceCode.interval + 1) * 1e3;
+  while (true) {
+    const response = await fetch(
+      `${GITHUB_BASE_URL}/login/oauth/access_token`,
+      {
+        method: "POST",
+        headers: standardHeaders(),
+        body: JSON.stringify({
+          client_id: GITHUB_CLIENT_ID,
+          device_code: deviceCode.device_code,
+          grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+        })
+      }
+    );
+    if (!response.ok) {
+      await new Promise((resolve) => setTimeout(resolve, sleepDuration));
+      continue;
+    }
+    const json = await response.json();
+    if (json.access_token) {
+      return json.access_token;
+    }
+    await new Promise((resolve) => setTimeout(resolve, sleepDuration));
+  }
+}
+
+// src/state.ts
+var state = {
+  accountType: "individual",
+  vsCodeVersion: "1.104.3"
+};
+
+// src/auth/copilot-token.ts
+async function getCopilotToken() {
+  const response = await fetch(
+    `${GITHUB_API_BASE_URL}/copilot_internal/v2/token`,
+    {
+      headers: githubHeaders(state)
+    }
+  );
+  if (!response.ok) {
+    throw new Error(`Failed to get Copilot token: ${response.status}`);
+  }
+  return await response.json();
+}
+
+// src/auth/token.ts
+var APP_DIR = path.join(os.homedir(), ".local", "share", "copilot-api");
+var GITHUB_TOKEN_PATH = path.join(APP_DIR, "github_token");
+async function ensurePaths() {
+  await fs.mkdir(APP_DIR, { recursive: true });
+  try {
+    await fs.access(GITHUB_TOKEN_PATH, fs.constants.W_OK);
+  } catch {
+    await fs.writeFile(GITHUB_TOKEN_PATH, "");
+    await fs.chmod(GITHUB_TOKEN_PATH, 384);
+  }
+}
+async function readGithubToken() {
+  return fs.readFile(GITHUB_TOKEN_PATH, "utf8");
+}
+async function writeGithubToken(token) {
+  await fs.writeFile(GITHUB_TOKEN_PATH, token);
+}
+async function setupGitHubToken() {
+  await ensurePaths();
+  try {
+    const githubToken = await readGithubToken();
+    if (githubToken) {
+      state.githubToken = githubToken;
+      console.log("Using saved GitHub token");
+      return;
+    }
+  } catch {
+  }
+  console.log("Not logged in, starting authentication flow...");
+  const deviceCode = await getDeviceCode();
+  console.log(
+    `Please enter the code "${deviceCode.user_code}" at ${deviceCode.verification_uri}`
+  );
+  const token = await pollAccessToken(deviceCode);
+  await writeGithubToken(token);
+  state.githubToken = token;
+  console.log("GitHub authentication successful");
+}
+async function setupCopilotToken() {
+  const { token, refresh_in } = await getCopilotToken();
+  state.copilotToken = token;
+  console.log("Copilot token fetched successfully");
+  const refreshInterval = (refresh_in - 60) * 1e3;
+  setInterval(async () => {
+    try {
+      const { token: token2 } = await getCopilotToken();
+      state.copilotToken = token2;
+      console.log("Copilot token refreshed");
+    } catch (error) {
+      console.error("Failed to refresh Copilot token:", error);
+    }
+  }, refreshInterval);
+}
+
+// src/server.ts
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+
+// src/routes/messages.ts
+import { streamSSE } from "hono/streaming";
+
+// src/api/chat.ts
+import { events } from "fetch-event-stream";
+async function createChatCompletions(payload) {
+  if (!state.copilotToken) throw new Error("Copilot token not found");
+  const enableVision = payload.messages.some(
+    (x) => typeof x.content !== "string" && x.content?.some((x2) => x2.type === "image_url")
+  );
+  const isAgentCall = payload.messages.some(
+    (msg) => ["assistant", "tool"].includes(msg.role)
+  );
+  const headers = {
+    ...copilotHeaders(state, enableVision),
+    "X-Initiator": isAgentCall ? "agent" : "user"
+  };
+  const response = await fetch(`${copilotBaseUrl(state)}/chat/completions`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Copilot API error ${response.status}: ${text}`);
+  }
+  if (payload.stream) {
+    return events(response);
+  }
+  return await response.json();
+}
+
+// src/routes/translate.ts
+function mapStopReason(finishReason) {
+  if (finishReason === null) return null;
+  const map = {
+    stop: "end_turn",
+    length: "max_tokens",
+    tool_calls: "tool_use",
+    content_filter: "end_turn"
+  };
+  return map[finishReason];
+}
+function translateToOpenAI(payload) {
+  return {
+    model: translateModelName(payload.model),
+    messages: translateMessages(payload.messages, payload.system),
+    max_tokens: payload.max_tokens,
+    stop: payload.stop_sequences,
+    stream: payload.stream,
+    temperature: payload.temperature,
+    top_p: payload.top_p,
+    tools: translateTools(payload.tools),
+    tool_choice: translateToolChoice(payload.tool_choice)
+  };
+}
+function translateModelName(model) {
+  if (model.startsWith("claude-sonnet-4-")) {
+    return "claude-sonnet-4";
+  } else if (model.startsWith("claude-opus-4-")) {
+    return "claude-opus-4";
+  }
+  return model;
+}
+function translateMessages(messages, system) {
+  const systemMessages = handleSystemPrompt(system);
+  const otherMessages = messages.flatMap(
+    (message) => message.role === "user" ? handleUserMessage(message) : handleAssistantMessage(message)
+  );
+  return [...systemMessages, ...otherMessages];
+}
+function handleSystemPrompt(system) {
+  if (!system) return [];
+  if (typeof system === "string") {
+    return [{ role: "system", content: system }];
+  }
+  const text = system.map((block) => block.text).join("\n\n");
+  return [{ role: "system", content: text }];
+}
+function handleUserMessage(message) {
+  const result = [];
+  if (Array.isArray(message.content)) {
+    const toolResultBlocks = message.content.filter(
+      (block) => block.type === "tool_result"
+    );
+    const otherBlocks = message.content.filter(
+      (block) => block.type !== "tool_result"
+    );
+    for (const block of toolResultBlocks) {
+      result.push({
+        role: "tool",
+        tool_call_id: block.tool_use_id,
+        content: block.content
+      });
+    }
+    if (otherBlocks.length > 0) {
+      result.push({
+        role: "user",
+        content: mapContent(otherBlocks)
+      });
+    }
+  } else {
+    result.push({
+      role: "user",
+      content: message.content
+    });
+  }
+  return result;
+}
+function handleAssistantMessage(message) {
+  if (!Array.isArray(message.content)) {
+    return [{ role: "assistant", content: message.content }];
+  }
+  const toolUseBlocks = message.content.filter(
+    (block) => block.type === "tool_use"
+  );
+  const textBlocks = message.content.filter(
+    (block) => block.type === "text"
+  );
+  const thinkingBlocks = message.content.filter(
+    (block) => block.type === "thinking"
+  );
+  const allTextContent = [
+    ...textBlocks.map((b) => b.text),
+    ...thinkingBlocks.map((b) => b.thinking)
+  ].join("\n\n");
+  if (toolUseBlocks.length > 0) {
+    return [
+      {
+        role: "assistant",
+        content: allTextContent || null,
+        tool_calls: toolUseBlocks.map((toolUse) => ({
+          id: toolUse.id,
+          type: "function",
+          function: {
+            name: toolUse.name,
+            arguments: JSON.stringify(toolUse.input)
+          }
+        }))
+      }
+    ];
+  }
+  return [{ role: "assistant", content: mapContent(message.content) }];
+}
+function mapContent(content) {
+  const hasImage = content.some((block) => block.type === "image");
+  if (!hasImage) {
+    return content.filter(
+      (block) => block.type === "text" || block.type === "thinking"
+    ).map((block) => block.type === "text" ? block.text : block.thinking).join("\n\n");
+  }
+  const parts = [];
+  for (const block of content) {
+    if (block.type === "text") {
+      parts.push({ type: "text", text: block.text });
+    } else if (block.type === "thinking") {
+      parts.push({ type: "text", text: block.thinking });
+    } else if (block.type === "image") {
+      parts.push({
+        type: "image_url",
+        image_url: {
+          url: `data:${block.source.media_type};base64,${block.source.data}`
+        }
+      });
+    }
+  }
+  return parts;
+}
+function translateTools(tools) {
+  if (!tools) return void 0;
+  return tools.map((tool) => ({
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.input_schema
+    }
+  }));
+}
+function translateToolChoice(choice) {
+  if (!choice) return void 0;
+  switch (choice.type) {
+    case "auto":
+      return "auto";
+    case "any":
+      return "required";
+    case "tool":
+      if (choice.name) {
+        return { type: "function", function: { name: choice.name } };
+      }
+      return void 0;
+    case "none":
+      return "none";
+    default:
+      return void 0;
+  }
+}
+function translateToAnthropic(response) {
+  const allTextBlocks = [];
+  const allToolUseBlocks = [];
+  let stopReason = response.choices[0]?.finish_reason ?? null;
+  for (const choice of response.choices) {
+    const textBlocks = getTextBlocks(choice.message.content);
+    const toolUseBlocks = getToolUseBlocks(choice.message.tool_calls);
+    allTextBlocks.push(...textBlocks);
+    allToolUseBlocks.push(...toolUseBlocks);
+    if (choice.finish_reason === "tool_calls" || stopReason === "stop") {
+      stopReason = choice.finish_reason;
+    }
+  }
+  return {
+    id: response.id,
+    type: "message",
+    role: "assistant",
+    model: response.model,
+    content: [...allTextBlocks, ...allToolUseBlocks],
+    stop_reason: mapStopReason(stopReason),
+    stop_sequence: null,
+    usage: {
+      input_tokens: (response.usage?.prompt_tokens ?? 0) - (response.usage?.prompt_tokens_details?.cached_tokens ?? 0),
+      output_tokens: response.usage?.completion_tokens ?? 0,
+      ...response.usage?.prompt_tokens_details?.cached_tokens !== void 0 && {
+        cache_read_input_tokens: response.usage.prompt_tokens_details.cached_tokens
+      }
+    }
+  };
+}
+function getTextBlocks(content) {
+  if (typeof content === "string") {
+    return [{ type: "text", text: content }];
+  }
+  return [];
+}
+function getToolUseBlocks(toolCalls) {
+  if (!toolCalls) return [];
+  return toolCalls.map((tc) => ({
+    type: "tool_use",
+    id: tc.id,
+    name: tc.function.name,
+    input: JSON.parse(tc.function.arguments)
+  }));
+}
+
+// src/routes/stream.ts
+function isToolBlockOpen(state2) {
+  if (!state2.contentBlockOpen) return false;
+  return Object.values(state2.toolCalls).some(
+    (tc) => tc.anthropicBlockIndex === state2.contentBlockIndex
+  );
+}
+function translateChunkToEvents(chunk, state2) {
+  const events2 = [];
+  if (chunk.choices.length === 0) return events2;
+  const choice = chunk.choices[0];
+  const { delta } = choice;
+  if (!state2.messageStartSent) {
+    events2.push({
+      type: "message_start",
+      message: {
+        id: chunk.id,
+        type: "message",
+        role: "assistant",
+        content: [],
+        model: chunk.model,
+        stop_reason: null,
+        stop_sequence: null,
+        usage: {
+          input_tokens: (chunk.usage?.prompt_tokens ?? 0) - (chunk.usage?.prompt_tokens_details?.cached_tokens ?? 0),
+          output_tokens: 0,
+          ...chunk.usage?.prompt_tokens_details?.cached_tokens !== void 0 && {
+            cache_read_input_tokens: chunk.usage.prompt_tokens_details.cached_tokens
+          }
+        }
+      }
+    });
+    state2.messageStartSent = true;
+  }
+  if (delta.content) {
+    if (isToolBlockOpen(state2)) {
+      events2.push({
+        type: "content_block_stop",
+        index: state2.contentBlockIndex
+      });
+      state2.contentBlockIndex++;
+      state2.contentBlockOpen = false;
+    }
+    if (!state2.contentBlockOpen) {
+      events2.push({
+        type: "content_block_start",
+        index: state2.contentBlockIndex,
+        content_block: { type: "text", text: "" }
+      });
+      state2.contentBlockOpen = true;
+    }
+    events2.push({
+      type: "content_block_delta",
+      index: state2.contentBlockIndex,
+      delta: { type: "text_delta", text: delta.content }
+    });
+  }
+  if (delta.tool_calls) {
+    for (const toolCall of delta.tool_calls) {
+      if (toolCall.id && toolCall.function?.name) {
+        if (state2.contentBlockOpen) {
+          events2.push({
+            type: "content_block_stop",
+            index: state2.contentBlockIndex
+          });
+          state2.contentBlockIndex++;
+          state2.contentBlockOpen = false;
+        }
+        const anthropicBlockIndex = state2.contentBlockIndex;
+        state2.toolCalls[toolCall.index] = {
+          id: toolCall.id,
+          name: toolCall.function.name,
+          anthropicBlockIndex
+        };
+        events2.push({
+          type: "content_block_start",
+          index: anthropicBlockIndex,
+          content_block: {
+            type: "tool_use",
+            id: toolCall.id,
+            name: toolCall.function.name,
+            input: {}
+          }
+        });
+        state2.contentBlockOpen = true;
+      }
+      if (toolCall.function?.arguments) {
+        const toolCallInfo = state2.toolCalls[toolCall.index];
+        if (toolCallInfo) {
+          events2.push({
+            type: "content_block_delta",
+            index: toolCallInfo.anthropicBlockIndex,
+            delta: {
+              type: "input_json_delta",
+              partial_json: toolCall.function.arguments
+            }
+          });
+        }
+      }
+    }
+  }
+  if (choice.finish_reason) {
+    if (state2.contentBlockOpen) {
+      events2.push({
+        type: "content_block_stop",
+        index: state2.contentBlockIndex
+      });
+      state2.contentBlockOpen = false;
+    }
+    events2.push(
+      {
+        type: "message_delta",
+        delta: {
+          stop_reason: mapStopReason(choice.finish_reason),
+          stop_sequence: null
+        },
+        usage: {
+          input_tokens: (chunk.usage?.prompt_tokens ?? 0) - (chunk.usage?.prompt_tokens_details?.cached_tokens ?? 0),
+          output_tokens: chunk.usage?.completion_tokens ?? 0,
+          ...chunk.usage?.prompt_tokens_details?.cached_tokens !== void 0 && {
+            cache_read_input_tokens: chunk.usage.prompt_tokens_details.cached_tokens
+          }
+        }
+      },
+      { type: "message_stop" }
+    );
+  }
+  return events2;
+}
+
+// src/routes/messages.ts
+async function handleMessages(c) {
+  const anthropicPayload = await c.req.json();
+  const openAIPayload = translateToOpenAI(anthropicPayload);
+  const response = await createChatCompletions(openAIPayload);
+  if ("choices" in response) {
+    const anthropicResponse = translateToAnthropic(response);
+    return c.json(anthropicResponse);
+  }
+  return streamSSE(c, async (stream) => {
+    const state2 = {
+      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 events2 = translateChunkToEvents(chunk, state2);
+      for (const event of events2) {
+        await stream.writeSSE({
+          event: event.type,
+          data: JSON.stringify(event)
+        });
+      }
+    }
+  });
+}
+
+// src/server.ts
+var app = new Hono();
+app.use(
+  "*",
+  cors({
+    origin: (origin) => {
+      if (!origin) return null;
+      const url = new URL(origin);
+      if (url.hostname === "localhost" || url.hostname === "127.0.0.1") {
+        return origin;
+      }
+      return null;
+    }
+  })
+);
+app.post("/v1/messages", handleMessages);
+app.get("/health", (c) => c.json({ status: "ok" }));
+var server_default = app;
+
+// src/index.ts
+var { values } = parseArgs({
+  args: process.argv.slice(2),
+  options: {
+    port: {
+      type: "string",
+      short: "p",
+      default: "4141"
+    },
+    "account-type": {
+      type: "string",
+      short: "a",
+      default: "individual"
+    },
+    "github-token": {
+      type: "string",
+      short: "g"
+    },
+    help: {
+      type: "boolean",
+      short: "h",
+      default: false
+    }
+  }
+});
+if (values.help) {
+  console.log(`
+Copilot API Proxy (minimal) - Claude Code backend using GitHub Copilot
+
+Usage: npx cccproxy [options]
+
+Options:
+  -p, --port <port>           Port to listen on (default: 4141)
+  -a, --account-type <type>   Account type: individual, business, enterprise (default: individual)
+  -g, --github-token <token>  GitHub token (or use GH_TOKEN env var)
+  -h, --help                  Show this help message
+`);
+  process.exit(0);
+}
+var port = parseInt(values.port, 10);
+var accountType = values["account-type"];
+async function main() {
+  console.log("Starting Copilot API Proxy (minimal)...");
+  state.accountType = accountType;
+  const githubToken = values["github-token"] || process.env.GH_TOKEN;
+  if (githubToken) {
+    state.githubToken = githubToken;
+    console.log("Using provided GitHub token");
+  } else {
+    await setupGitHubToken();
+  }
+  await setupCopilotToken();
+  console.log(`Server starting on port ${port}...`);
+  console.log(`Anthropic API endpoint: http://localhost:${port}/v1/messages`);
+  serve({
+    fetch: server_default.fetch,
+    port,
+    hostname: "127.0.0.1"
+    // Bind to localhost only for security
+  });
+  console.log(`
+To use with Claude Code, set these environment variables:
+  ANTHROPIC_BASE_URL=http://localhost:${port}
+  ANTHROPIC_AUTH_TOKEN=dummy
+  ANTHROPIC_MODEL=claude-sonnet-4
+
+Or create .claude/settings.json with:
+{
+  "env": {
+    "ANTHROPIC_BASE_URL": "http://localhost:${port}",
+    "ANTHROPIC_AUTH_TOKEN": "dummy",
+    "ANTHROPIC_MODEL": "claude-sonnet-4"
+  }
+}
+`);
+}
+main().catch(console.error);

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "cccproxy",
+  "version": "1.0.0",
+  "type": "module",
+  "bin": {
+    "cccproxy": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --target node18 --clean",
+    "prepublishOnly": "npm run build",
+    "start": "node dist/index.js",
+    "dev": "tsup src/index.ts --format esm --target node18 --watch"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@hono/node-server": "^1.19.9",
+    "fetch-event-stream": "^0.1.5",
+    "hono": "^4.7.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.3",
+    "tsup": "^8.5.1",
+    "typescript": "^5.7.0"
+  }
+}