wyxrouter 0.4.71

package/open-sse/utils/claudeCloaking.js

@@ -0,0 +1,155 @@
+import { createHash, randomBytes, randomUUID } from "crypto";
+import { CLAUDE_TOOL_SUFFIX, CC_DEFAULT_TOOLS } from "../config/appConstants.js";
+
+const CLAUDE_VERSION = "2.1.92";
+const CC_ENTRYPOINT = "sdk-cli";
+
+// Generate billing header matching real Claude Code 2.1.92+ format:
+// x-anthropic-billing-header: cc_version=<ver>.<build>; cc_entrypoint=sdk-cli; cch=<hash>;
+function generateBillingHeader(payload) {
+  const content = JSON.stringify(payload);
+  const cch = createHash("sha256").update(content).digest("hex").slice(0, 5);
+  const buildHash = randomBytes(2).toString("hex").slice(0, 3);
+  return `x-anthropic-billing-header: cc_version=${CLAUDE_VERSION}.${buildHash}; cc_entrypoint=${CC_ENTRYPOINT}; cch=${cch};`;
+}
+
+// Generate fake user ID in Claude Code 2.1.92+ JSON format:
+// {"device_id":"<64hex>","account_uuid":"<uuid>","session_id":"<uuid>"}
+function generateFakeUserID(sessionId) {
+  const deviceId = randomBytes(32).toString("hex");
+  const accountUuid = randomUUID();
+  const sessionUuid = sessionId || randomUUID();
+  return `{"device_id":"${deviceId}","account_uuid":"${accountUuid}","session_id":"${sessionUuid}"}`;
+}
+
+/**
+ * Cloak tools before sending to Claude provider (anti-ban):
+ * - Rename non-CC client tools with _cc suffix in tools[] and messages[]
+ * - Skip tools that are already CC default names (they become decoys as-is)
+ * - Inject CC_DECOY_TOOLS after client tools
+ * Returns { body, toolNameMap } where toolNameMap maps suffixed → original
+ * @param {object} body - Claude API request body
+ * @returns {{ body: object, toolNameMap: Map|null }}
+ */
+export function cloakClaudeTools(body) {
+  const tools = body.tools;
+  if (!tools || tools.length === 0) return { body, toolNameMap: null };
+
+  const suffix = (name) => `${name}${CLAUDE_TOOL_SUFFIX}`;
+  const toolNameMap = new Map();
+  const clientToolNames = new Set();
+  const clientDeclarations = [];
+
+  // All client tools get renamed with suffix
+  for (const tool of tools) {
+    const suffixed = suffix(tool.name);
+    toolNameMap.set(suffixed, tool.name);
+    clientToolNames.add(tool.name);
+    clientDeclarations.push({ ...tool, name: suffixed });
+  }
+
+  // Client tools first, then CC decoy tools (no overlap: client tools all have _cc suffix)
+  const allTools = [...clientDeclarations, ...CC_DECOY_TOOLS];
+
+  // Rename tool_use in message history (all client tools get suffix)
+  const renamedMessages = body.messages?.map(msg => {
+    if (!Array.isArray(msg.content)) return msg;
+    const renamedContent = msg.content.map(block =>
+      block.type === "tool_use" ? { ...block, name: suffix(block.name) } : block
+    );
+    return { ...msg, content: renamedContent };
+  });
+
+  const cloakedBody = { ...body, tools: allTools, messages: renamedMessages || body.messages };
+
+  // A forced tool_choice ({ type: "tool", name }) must point at the suffixed
+  // tool name, otherwise Claude rejects it: "Tool '<name>' not found in provided tools".
+  // Only rewrite when the choice targets one of the client tools we actually
+  // renamed — never a decoy/built-in name (those are sent unsuffixed).
+  if (
+    body.tool_choice?.type === "tool" &&
+    clientToolNames.has(body.tool_choice.name)
+  ) {
+    cloakedBody.tool_choice = { ...body.tool_choice, name: suffix(body.tool_choice.name) };
+  }
+
+  return {
+    body: cloakedBody,
+    toolNameMap: toolNameMap.size > 0 ? toolNameMap : null
+  };
+}
+
+// Decloak tool_use names in non-streaming Claude response body (INPUT side)
+export function decloakToolNames(body, toolNameMap) {
+  if (!toolNameMap?.size || !Array.isArray(body?.content)) return body;
+  const content = body.content.map(block => {
+    if (block?.type === "tool_use" && toolNameMap.has(block.name)) {
+      return { ...block, name: toolNameMap.get(block.name) };
+    }
+    return block;
+  });
+  return { ...body, content };
+}
+
+// CC decoy tools — Claude Code native tool names, marked unavailable
+const CC_DECOY_TOOLS = [
+  { name: "Task", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "TaskOutput", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "TaskStop", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "TaskCreate", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "TaskGet", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "TaskUpdate", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "TaskList", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "Bash", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "Glob", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "Grep", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "Read", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "Edit", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "Write", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "NotebookEdit", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "WebFetch", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "WebSearch", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "AskUserQuestion", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "Skill", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "EnterPlanMode", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+  { name: "ExitPlanMode", description: "This tool is currently unavailable.", input_schema: { type: "object", properties: {} } },
+];
+
+/**
+ * Apply Claude cloaking to request body:
+ * 1. Inject billing header as first system block
+ * 2. Inject fake user ID into metadata (JSON format, session_id aligned with X-Claude-Code-Session-Id)
+ * Only applies when using OAuth token (sk-ant-oat).
+ * @param {object} body - Claude API request body
+ * @param {string} apiKey - API key or OAuth token
+ * @param {string} [sessionId] - Session ID to align with X-Claude-Code-Session-Id header
+ * @returns {object} Modified body
+ */
+export function applyCloaking(body, apiKey, sessionId) {
+  if (!apiKey || !apiKey.includes("sk-ant-oat")) return body;
+
+  const result = { ...body };
+
+  // Inject billing header as system[0], preserve existing system blocks
+  const billingText = generateBillingHeader(body);
+  const billingBlock = { type: "text", text: billingText };
+
+  if (Array.isArray(result.system)) {
+    // Skip if already injected
+    if (!result.system[0]?.text?.startsWith("x-anthropic-billing-header:")) {
+      result.system = [billingBlock, ...result.system];
+    }
+  } else if (typeof result.system === "string") {
+    result.system = [billingBlock, { type: "text", text: result.system }];
+  } else {
+    result.system = [billingBlock];
+  }
+
+  // Inject fake user ID into metadata (session_id must match X-Claude-Code-Session-Id)
+  const existingUserId = result.metadata?.user_id;
+  if (!existingUserId) {
+    result.metadata = { ...result.metadata, user_id: generateFakeUserID(sessionId) };
+  }
+
+  return result;
+}

package/open-sse/utils/claudeHeaderCache.js

@@ -0,0 +1,70 @@
+/**
+ * Singleton cache for real Claude Code client headers.
+ * Captures headers from authentic Claude Code requests and makes them available
+ * for forwarding to api.anthropic.com, replacing static hardcoded values.
+ */
+
+const CLAUDE_IDENTITY_HEADERS = [
+  "user-agent",
+  "anthropic-beta",
+  "anthropic-version",
+  "anthropic-dangerous-direct-browser-access",
+  "x-app",
+  "x-stainless-helper-method",
+  "x-stainless-retry-count",
+  "x-stainless-runtime-version",
+  "x-stainless-package-version",
+  "x-stainless-runtime",
+  "x-stainless-lang",
+  "x-stainless-arch",
+  "x-stainless-os",
+  "x-stainless-timeout",
+  "x-claude-code-session-id",
+  "package-version",
+  "runtime-version",
+  "os",
+  "arch",
+];
+
+let cachedHeaders = null;
+
+/**
+ * Detect if request headers look like a real Claude Code client.
+ * @param {object} headers - Lowercase header key/value object
+ */
+function isClaudeCodeClient(headers) {
+  const ua = (headers["user-agent"] || "").toLowerCase();
+  const xApp = (headers["x-app"] || "").toLowerCase();
+  return ua.includes("claude-cli") || ua.includes("claude-code") || xApp === "cli";
+}
+
+/**
+ * Store Claude Code identity headers if this looks like a real client request.
+ * Called at the entry point before any translation/forwarding.
+ * @param {object} headers - Lowercase header key/value object (from request.headers.entries())
+ */
+export function cacheClaudeHeaders(headers) {
+  if (!headers || typeof headers !== "object") return;
+  if (!isClaudeCodeClient(headers)) return;
+
+  const captured = {};
+  for (const key of CLAUDE_IDENTITY_HEADERS) {
+    if (headers[key] !== undefined && headers[key] !== null) {
+      captured[key] = headers[key];
+    }
+  }
+
+  if (Object.keys(captured).length > 0) {
+    cachedHeaders = captured;
+    console.log(`[ClaudeHeaders] Cached ${Object.keys(captured).length} identity headers from Claude Code client`);
+  }
+}
+
+/**
+ * Get the most recently cached Claude Code identity headers.
+ * Returns null if no authentic client request has been seen yet (cold start).
+ * @returns {object|null}
+ */
+export function getCachedClaudeHeaders() {
+  return cachedHeaders;
+}

package/open-sse/utils/clientDetector.js

@@ -0,0 +1,63 @@
+/**
+ * Detect CLI tool identity from request headers/body.
+ * Used to determine if a request can be passed through losslessly.
+ */
+
+// Map of CLI tool identifiers to provider IDs they are "native" to
+const NATIVE_PAIRS = {
+  "claude": ["claude", "anthropic"],
+  "gemini-cli": ["gemini-cli"],
+  "antigravity": ["antigravity"],
+  "codex": ["codex"],
+};
+
+/**
+ * Detect which CLI tool is making the request.
+ * Returns one of: "claude" | "gemini-cli" | "antigravity" | "codex" | null
+ * @param {object} headers - Lowercase header key/value object
+ * @param {object} body    - Parsed request body
+ */
+export function detectClientTool(headers = {}, body = {}) {
+  const ua = (headers["user-agent"] || "").toLowerCase();
+  const xApp = (headers["x-app"] || "").toLowerCase();
+  const openaiIntent = (headers["openai-intent"] || "").toLowerCase();
+  const initiator = (headers["x-initiator"] || headers["X-Initiator"] || "").toLowerCase();
+
+  // Antigravity: detected via body field (not header)
+  if (body.userAgent === "antigravity") return "antigravity";
+
+  // GitHub Copilot / OAI compatible extension using Copilot chat headers
+  if (ua.includes("githubcopilotchat") || openaiIntent === "conversation-panel" || initiator === "user") {
+    return "github-copilot";
+  }
+
+  // Claude Code / Claude CLI
+  if (ua.includes("claude-cli") || ua.includes("claude-code") || xApp === "cli") return "claude";
+
+  // Gemini CLI
+  if (ua.includes("gemini-cli")) return "gemini-cli";
+
+  // Codex CLI
+  if (ua.includes("codex-cli")) return "codex";
+
+  // DeepSeek TUI
+  if (ua.includes("deepseek-tui")) return "deepseek-tui";
+
+  return null;
+}
+
+/**
+ * Check if this CLI tool + provider pair should be passed through losslessly.
+ * @param {string|null} clientTool - Result of detectClientTool()
+ * @param {string} provider        - Provider ID (e.g. "claude", "gemini-cli")
+ */
+export function isNativePassthrough(clientTool, provider) {
+  if (!clientTool) return false;
+  const nativeProviders = NATIVE_PAIRS[clientTool];
+  if (!nativeProviders) return false;
+  // Support anthropic-compatible-* variants
+  const normalizedProvider = provider.startsWith("anthropic-compatible")
+    ? "anthropic"
+    : provider;
+  return nativeProviders.includes(normalizedProvider);
+}

package/open-sse/utils/cursorChecksum.js

@@ -0,0 +1,149 @@
+/**
+ * Cursor Checksum Utility (Jyh Cipher)
+ *
+ * Generates the x-cursor-checksum header required for Cursor API authentication.
+ * Based on the JavaScript implementation from Cursor IDE.
+ */
+
+import crypto from "crypto";
+import { v5 as uuidv5 } from "uuid";
+
+/**
+ * Generate SHA-256 hash like generateHashed64Hex
+ * @param {string} input - Input string
+ * @param {string} salt - Optional salt
+ * @returns {string} - 64-character hex string
+ */
+export function generateHashed64Hex(input, salt = "") {
+  return crypto.createHash("sha256").update(input + salt).digest("hex");
+}
+
+/**
+ * Generate session ID using UUID v5 with DNS namespace
+ * @param {string} authToken - Auth token
+ * @returns {string} - UUID string
+ */
+export function generateSessionId(authToken) {
+  return uuidv5(authToken, uuidv5.DNS);
+}
+
+/**
+ * Generate cursor checksum (Jyh cipher)
+ *
+ * Algorithm:
+ * 1. Get Unix timestamp in specific format
+ * 2. XOR each byte with key (starting 165)
+ * 3. Update key: key = (key + byte) & 0xFF
+ * 4. URL-safe base64 encode
+ * 5. Format: {base64_encoded}{machineId}
+ *
+ * @param {string} machineId - Machine ID from Cursor storage or generated
+ * @returns {string} - Checksum string
+ */
+export function generateCursorChecksum(machineId) {
+  // Math.floor(Date.now() / 1e6) - same as Python implementation
+  const timestamp = Math.floor(Date.now() / 1000000);
+
+  // Create byte array from timestamp (6 bytes, big-endian)
+  const byteArray = new Uint8Array([
+    (timestamp >> 40) & 0xFF,
+    (timestamp >> 32) & 0xFF,
+    (timestamp >> 24) & 0xFF,
+    (timestamp >> 16) & 0xFF,
+    (timestamp >> 8) & 0xFF,
+    timestamp & 0xFF
+  ]);
+
+  // Jyh cipher obfuscation
+  let t = 165;
+  for (let i = 0; i < byteArray.length; i++) {
+    byteArray[i] = ((byteArray[i] ^ t) + (i % 256)) & 0xFF;
+    t = byteArray[i];
+  }
+
+  // URL-safe base64 encode (without padding)
+  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+  let encoded = "";
+
+  for (let i = 0; i < byteArray.length; i += 3) {
+    const a = byteArray[i];
+    const b = i + 1 < byteArray.length ? byteArray[i + 1] : 0;
+    const c = i + 2 < byteArray.length ? byteArray[i + 2] : 0;
+
+    encoded += alphabet[a >> 2];
+    encoded += alphabet[((a & 3) << 4) | (b >> 4)];
+
+    if (i + 1 < byteArray.length) {
+      encoded += alphabet[((b & 15) << 2) | (c >> 6)];
+    }
+    if (i + 2 < byteArray.length) {
+      encoded += alphabet[c & 63];
+    }
+  }
+
+  return `${encoded}${machineId}`;
+}
+
+/**
+ * Build all Cursor API headers
+ *
+ * @param {string} accessToken - Bearer token
+ * @param {string} machineId - Machine ID (or will be generated from token)
+ * @param {boolean} ghostMode - Enable ghost mode (privacy)
+ * @returns {Object} - Headers object
+ */
+export function buildCursorHeaders(accessToken, machineId = null, ghostMode = true) {
+  // Clean token if it has prefix
+  const cleanToken = accessToken.includes("::")
+    ? accessToken.split("::")[1]
+    : accessToken;
+
+  // Generate machine ID if not provided
+  const effectiveMachineId = machineId || generateHashed64Hex(cleanToken, "machineId");
+
+  // Generate derived values
+  const sessionId = generateSessionId(cleanToken);
+  const clientKey = generateHashed64Hex(cleanToken);
+  const checksum = generateCursorChecksum(effectiveMachineId);
+
+  // Detect OS
+  let os = "linux";
+  if (typeof process !== "undefined") {
+    if (process.platform === "win32") os = "windows";
+    else if (process.platform === "darwin") os = "macos";
+  }
+
+  // Detect architecture
+  let arch = "x64";
+  if (typeof process !== "undefined") {
+    if (process.arch === "arm64") arch = "aarch64";
+  }
+
+  return {
+    "authorization": `Bearer ${cleanToken}`,
+    "connect-accept-encoding": "gzip",
+    "connect-protocol-version": "1",
+    "content-type": "application/connect+proto",
+    "user-agent": "connect-es/1.6.1",
+    "x-amzn-trace-id": `Root=${crypto.randomUUID()}`,
+    "x-client-key": clientKey,
+    "x-cursor-checksum": checksum,
+    "x-cursor-client-version": "3.1.0",
+    "x-cursor-client-type": "ide",
+    "x-cursor-client-os": os,
+    "x-cursor-client-arch": arch,
+    "x-cursor-client-device-type": "desktop",
+    "x-cursor-config-version": crypto.randomUUID(),
+    "x-cursor-timezone": Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC",
+    "x-ghost-mode": ghostMode ? "true" : "false",
+    "x-request-id": crypto.randomUUID(),
+    "x-session-id": sessionId
+  };
+}
+
+export default {
+  generateCursorChecksum,
+  buildCursorHeaders,
+  generateHashed64Hex,
+  generateSessionId
+};