@fudrouter/fsrouter 0.6.63 → 0.6.64

package/open-sse/utils/claudeHeaderCache.js

@@ -1,70 +0,0 @@
-/**
- * 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/claudeSignature.js

@@ -1,41 +0,0 @@
-// Claude thinking signature validation (ported from CLIProxyAPI internal/signature).
-// E-form: single-layer base64, decoded[0] == 0x12 (Claude marker).
-// R-form: double-layer base64, outer decoded[0] == 'E', inner decoded[0] == 0x12.
-// Cache prefix "...#sig" stripped before validation.
-
-const MAX_CLAUDE_SIGNATURE_LEN = 32 * 1024 * 1024;
-const CLAUDE_SIGNATURE_MARKER = 0x12;
-
-function stripCachePrefix(rawSignature) {
-  const sig = (rawSignature || "").trim();
-  if (!sig) return "";
-  const idx = sig.indexOf("#");
-  return idx >= 0 ? sig.slice(idx + 1).trim() : sig;
-}
-
-export function hasClaudeSignaturePrefix(rawSignature) {
-  const sig = stripCachePrefix(rawSignature);
-  return sig.length > 0 && (sig[0] === "E" || sig[0] === "R");
-}
-
-// Strict-ish: validates base64 layers + Claude marker byte.
-export function isValidClaudeSignature(rawSignature) {
-  const sig = stripCachePrefix(rawSignature);
-  if (!sig || sig.length > MAX_CLAUDE_SIGNATURE_LEN) return false;
-
-  try {
-    if (sig[0] === "E") {
-      const decoded = Buffer.from(sig, "base64");
-      return decoded.length > 0 && decoded[0] === CLAUDE_SIGNATURE_MARKER;
-    }
-    if (sig[0] === "R") {
-      const outer = Buffer.from(sig, "base64");
-      if (!outer.length || outer[0] !== 0x45) return false; // 'E'
-      const inner = Buffer.from(outer.toString(), "base64");
-      return inner.length > 0 && inner[0] === CLAUDE_SIGNATURE_MARKER;
-    }
-    return false;
-  } catch {
-    return false;
-  }
-}

package/open-sse/utils/clientDetector.js

@@ -1,63 +0,0 @@
-/**
- * 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/codebuddySanitizer.js

@@ -1,96 +0,0 @@
-/**
- * Sanitize system prompt messages for CodeBuddy (Tencent) provider.
- * Removes sections containing keywords that trigger Tencent content moderation.
- * These are typically from Claude Code CLI's built-in security guidelines.
- */
-
-// Phrases that trigger Tencent security moderation when sent to CodeBuddy API.
-// These come from Claude Code CLI's injected system safety guidelines.
-const CODEBUDDY_SENSITIVE_PATTERNS = [
-  /IMPORTANT:\s*Assist with authorized security testing[\s\S]*?(?=\n\n|\n#|\z)/gi,
-  /authorized security testing/gi,
-  /defensive security/gi,
-  /CTF challenges/gi,
-  /DoS attacks?/gi,
-  /C2 frameworks?/gi,
-  /credential testing/gi,
-  /exploit development/gi,
-  /dual.use security/gi,
-  /mass targeting/gi,
-  /supply chain compromise/gi,
-  /detection evasion/gi,
-  /malicious purposes?/gi,
-  /destructive techniques?/gi,
-];
-
-/**
- * Strip sensitive security keywords from text content.
- * Removes full sentences containing sensitive keywords.
- */
-function stripSensitiveText(text) {
-  if (!text || typeof text !== "string") return text;
-  let result = text;
-
-  // 1. GFW/Tencent blocks OpenAI/ChatGPT branding in developer/system prompts
-  result = result.replace(/OpenAI/gi, "9Router");
-  result = result.replace(/ChatGPT/gi, "9Router Assistant");
-  result = result.replace(/Codex CLI/gi, "CLI Coding Agent");
-
-  // 2. Strip complete sentences containing sensitive patterns
-  result = result.replace(
-    /[^.!?\n]*(?:authorized security testing|defensive security|CTF challenges?|DoS attacks?|C2 frameworks?|credential testing|exploit development|dual.use security|mass targeting|supply chain compromise|detection evasion|malicious purposes?|destructive techniques?)[^.!?\n]*/gi,
-    ""
-  );
-
-  // 3. Strip complex sandboxing/approval policy boilerplate that Tencent flag as command escalation bypasses
-  result = result.replace(/## Codex CLI harness, sandboxing, and approvals[\s\S]*?(?=\n\n|\n#|\z)/gi, "");
-  result = result.replace(/## Plan tool[\s\S]*?(?=\n\n|\n#|\z)/gi, "");
-  result = result.replace(/<permissions instructions>[\s\S]*?<\/permissions instructions>/gi, "");
-
-  // Clean up double blank lines left by removal
-  result = result.replace(/\n{3,}/g, "\n\n").trim();
-  return result;
-}
-
-/**
- * Strip system prompt content from a messages array (OpenAI format).
- */
-function sanitizeMessages(messages) {
-  if (!Array.isArray(messages)) return;
-  for (const msg of messages) {
-    if (msg.role !== "system" && msg.role !== "developer") continue;
-    if (typeof msg.content === "string") {
-      msg.content = stripSensitiveText(msg.content);
-    } else if (Array.isArray(msg.content)) {
-      for (const part of msg.content) {
-        if (part && typeof part.text === "string") {
-          part.text = stripSensitiveText(part.text);
-        }
-      }
-    }
-  }
-}
-
-/**
- * Main entry point: sanitize translatedBody for CodeBuddy.
- * Handles OpenAI messages[] format.
- */
-export function sanitizeCodebuddySystemPrompt(body) {
-  if (!body) return;
-  // OpenAI format (messages[] or input[])
-  const arr = Array.isArray(body.messages) ? body.messages
-    : Array.isArray(body.input) ? body.input
-    : null;
-  if (arr) sanitizeMessages(arr);
-  // Also handle top-level system (Claude format fallback)
-  if (typeof body.system === "string") {
-    body.system = stripSensitiveText(body.system);
-  } else if (Array.isArray(body.system)) {
-    for (const block of body.system) {
-      if (block && typeof block.text === "string") {
-        block.text = stripSensitiveText(block.text);
-      }
-    }
-  }
-}
-

package/open-sse/utils/composerToolCalls.js

@@ -1,158 +0,0 @@
-const FW = "[\uFF5C|]";
-const SEP = "[\u2581_]";
-const OUTER_RE = new RegExp(
-  `<${FW}tool${SEP}calls${SEP}begin${FW}>([\\s\\S]*?)<${FW}tool${SEP}calls${SEP}end${FW}>`,
-  "i"
-);
-const INNER_RE = new RegExp(
-  `<${FW}tool${SEP}call${SEP}begin${FW}>([\\s\\S]*?)<${FW}tool${SEP}call${SEP}end${FW}>`,
-  "gi"
-);
-const ARG_SEP_RE = new RegExp(`<${FW}tool${SEP}sep${FW}>`, "gi");
-const PARTIAL_OPEN_MARKER_RE = new RegExp(
-  `<${FW}?(?:t(?:o(?:o(?:l(?:${SEP}(?:c(?:a(?:l(?:l(?:s)?(?:${SEP}(?:b(?:e(?:g(?:i(?:n${FW}?>?)?)?)?)?)?)?)?)?)?)?)?)?)?)?)?$`,
-  "i"
-);
-function hasComposerToolCalls(text) {
-  if (!text || typeof text !== "string") return false;
-  return OUTER_RE.test(text);
-}
-function generateToolCallId(index) {
-  const rand = crypto.randomUUID().replace(/-/g, "").slice(0, 10);
-  return `call_${rand}${index}`;
-}
-function parseInnerCall(body) {
-  const trimmed = body.replace(/^\s+|\s+$/g, "");
-  const segments = trimmed.split(ARG_SEP_RE);
-  const name = (segments.shift() ?? "").trim();
-  if (!name) {
-    return null;
-  }
-  const args = {};
-  for (const seg of segments) {
-    if (!seg) continue;
-    const idxNl = seg.indexOf("\n");
-    let argName;
-    let argValue;
-    if (idxNl < 0) {
-      argName = seg.trim();
-      argValue = "";
-    } else {
-      argName = seg.slice(0, idxNl).trim();
-      argValue = seg.slice(idxNl + 1);
-    }
-    if (!argName) continue;
-    argValue = argValue.replace(/\n+$/, "");
-    args[argName] = coerceArgValue(argValue);
-  }
-  return { name, arguments: JSON.stringify(args) };
-}
-function coerceArgValue(raw) {
-  if (raw === "") return "";
-  const stripped = raw.trim();
-  if (stripped.startsWith("{") && stripped.endsWith("}") || stripped.startsWith("[") && stripped.endsWith("]")) {
-    try {
-      return JSON.parse(stripped);
-    } catch {
-    }
-  }
-  if (stripped === "true") return true;
-  if (stripped === "false") return false;
-  if (stripped === "null") return null;
-  if (/^-?\d+$/.test(stripped)) {
-    const n = Number(stripped);
-    if (Number.isSafeInteger(n)) return n;
-  }
-  if (/^-?\d*\.\d+$/.test(stripped)) {
-    const n = Number(stripped);
-    if (Number.isFinite(n)) return n;
-  }
-  return raw;
-}
-function parseComposerToolCalls(text) {
-  if (!text || typeof text !== "string") {
-    return { content: text || "", toolCalls: [] };
-  }
-  const match = text.match(OUTER_RE);
-  if (!match || match.index === void 0) {
-    return { content: text, toolCalls: [] };
-  }
-  const preamble = text.slice(0, match.index);
-  const trailing = text.slice(match.index + match[0].length);
-  const block = match[1];
-  const toolCalls = [];
-  let idx = 0;
-  for (const innerMatch of block.matchAll(INNER_RE)) {
-    const parsed = parseInnerCall(innerMatch[1]);
-    if (!parsed) continue;
-    toolCalls.push({
-      id: generateToolCallId(idx),
-      type: "function",
-      function: parsed
-    });
-    idx += 1;
-  }
-  const residual = (preamble + trailing).trim();
-  return { content: residual, toolCalls };
-}
-function createStreamingState() {
-  return {
-    emitted: 0,
-    // number of safe content chars already emitted
-    done: false
-  };
-}
-function feedStreamingChunk(state, accumulated) {
-  if (state.done) {
-    return { safeDelta: "", ready: false, toolCalls: [], holdback: false };
-  }
-  if (!accumulated) {
-    return { safeDelta: "", ready: false, toolCalls: [], holdback: false };
-  }
-  const m = accumulated.match(OUTER_RE);
-  if (m && m.index !== void 0) {
-    const preamble = accumulated.slice(0, m.index);
-    const block = m[1];
-    const toolCalls = [];
-    let idx = 0;
-    for (const innerMatch of block.matchAll(INNER_RE)) {
-      const parsed = parseInnerCall(innerMatch[1]);
-      if (!parsed) continue;
-      toolCalls.push({
-        id: generateToolCallId(idx),
-        type: "function",
-        function: parsed
-      });
-      idx += 1;
-    }
-    const safe = preamble;
-    const safeDelta2 = safe.length > state.emitted ? safe.slice(state.emitted) : "";
-    state.emitted = safe.length;
-    state.done = true;
-    return { safeDelta: safeDelta2, ready: true, toolCalls, holdback: false };
-  }
-  const openOnlyRe = new RegExp(`<${FW}tool${SEP}calls${SEP}begin${FW}>`, "i");
-  const openMatch = accumulated.match(openOnlyRe);
-  if (openMatch && openMatch.index !== void 0) {
-    const safe = accumulated.slice(0, openMatch.index);
-    const safeDelta2 = safe.length > state.emitted ? safe.slice(state.emitted) : "";
-    state.emitted = safe.length;
-    return { safeDelta: safeDelta2, ready: false, toolCalls: [], holdback: true };
-  }
-  const tailMatch = accumulated.match(PARTIAL_OPEN_MARKER_RE);
-  if (tailMatch && tailMatch.index !== void 0) {
-    const safe = accumulated.slice(0, tailMatch.index);
-    const safeDelta2 = safe.length > state.emitted ? safe.slice(state.emitted) : "";
-    state.emitted = safe.length;
-    return { safeDelta: safeDelta2, ready: false, toolCalls: [], holdback: true };
-  }
-  const safeDelta = accumulated.length > state.emitted ? accumulated.slice(state.emitted) : "";
-  state.emitted = accumulated.length;
-  return { safeDelta, ready: false, toolCalls: [], holdback: false };
-}
-export {
-  createStreamingState,
-  feedStreamingChunk,
-  hasComposerToolCalls,
-  parseComposerToolCalls
-};

package/open-sse/utils/cors.js

@@ -1,13 +0,0 @@
-/**
- * Static CORS headers for open-sse handlers.
- *
- * `Access-Control-Allow-Origin` is set by the Next.js middleware
- * (`src/server/cors/origins.ts`). Handlers in this package only need the
- * methods/headers list; the middleware overlays the allowed origin per
- * the central allowlist on the way out.
- */
-export const CORS_HEADERS = {
-  "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
-  "Access-Control-Allow-Headers":
-    "Content-Type, Authorization, x-api-key, anthropic-version, x-omniroute-connection, x-internal-test, accept",
-};

package/open-sse/utils/cursorChecksum.js

@@ -1,149 +0,0 @@
-/**
- * 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
-};