swayrouter 1.0.0

package/src/utils/claudeCloaking.js

@@ -0,0 +1,10 @@
+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 };
+}

package/src/utils/claudeSignature.js

@@ -0,0 +1,35 @@
+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");
+}
+
+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;
+      const inner = Buffer.from(outer.toString(), "base64");
+      return inner.length > 0 && inner[0] === CLAUDE_SIGNATURE_MARKER;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}

package/src/utils/clientDetector.js

@@ -0,0 +1,183 @@
+import { clientDetectionsTotal, clientDetectionConflictsTotal } from "../observability/metrics.js";
+
+const NATIVE_PAIRS = {
+  "claude": ["claude", "anthropic"],
+  "gemini-cli": ["gemini-cli"],
+  "antigravity": ["antigravity"],
+  "codex": ["codex"],
+
+  "cursor": ["cursor"],
+  "kiro": ["kiro"],
+  "hermes": ["hermes"],
+};
+
+function detectFromHeaders(headers = {}) {
+  const ua = String(headers["user-agent"] || "").toLowerCase();
+  const xApp = String(headers["x-app"] || "").toLowerCase();
+  const openaiIntent = String(headers["openai-intent"] || "").toLowerCase();
+  const initiator = String(headers["x-initiator"] || headers["X-Initiator"] || "").toLowerCase();
+  const originator = String(headers["originator"] || "").toLowerCase();
+  const jcodeHack = String(headers["x-jcode"] || "").toLowerCase();
+
+  if (ua.includes("cursor")) return "cursor";
+
+  if (ua.includes("kiro")) return "kiro";
+  if (ua.includes("hermes") || ua.includes("nous")) return "hermes";
+  if (ua.includes("opencode")) return "opencode";
+  if (ua.includes("cline")) return "cline";
+
+  if (ua.includes("githubcopilotchat") || openaiIntent === "conversation-panel" || initiator === "user") {
+    return "github-copilot";
+  }
+
+  if (ua.includes("claude-cli") || ua.includes("claude-code") || xApp === "cli") return "claude";
+
+  if (ua.includes("gemini-cli")) return "gemini-cli";
+
+  if (ua.includes("codex-tui") || ua.includes("codex-cli") || ua.includes("codex_cli_rs") ||
+      ua.includes("codex desktop") || originator.startsWith("codex_") || jcodeHack.startsWith("codex")) return "codex";
+
+  if (ua.includes("deepseek-tui")) return "deepseek-tui";
+
+  if (ua.includes("aider")) return "aider";
+  return null;
+}
+
+function detectFromBody(body = {}) {
+  if (!body || typeof body !== "object") return null;
+
+  if (body.userAgent === "antigravity") return "antigravity";
+
+  if (body.anthropic_version || (body.system !== undefined && body.system !== null && body.messages && !body.model?.includes("/"))) {
+
+    if (body.anthropic_version) return "claude";
+  }
+
+  if (body.input && (Array.isArray(body.input) || typeof body.input === "string") && !body.messages) {
+    return "codex";
+  }
+
+  if (body.instructions && body.thinking === undefined && !body.messages?.length?.some?.(() => false) && body.stream_options === undefined) {
+
+    if (!body.messages) return "cursor";
+  }
+
+  if (body.contents && Array.isArray(body.contents)) return "gemini-cli";
+  return null;
+}
+
+function detectFromPrompt(body = {}) {
+  const msgs = body?.messages;
+  if (!Array.isArray(msgs)) return null;
+  const head = msgs.slice(0, 3);
+  const text = head
+    .map((m) => {
+      if (!m) return "";
+      const c = m.content;
+      if (typeof c === "string") return c;
+      if (Array.isArray(c)) return c.map((p) => (typeof p?.text === "string" ? p.text : "")).join(" ");
+      if (typeof c?.text === "string") return c.text;
+      return "";
+    })
+    .join("\n")
+    .slice(0, 4000)
+    .toLowerCase();
+  if (!text) return null;
+
+  if (text.includes("claude code") || text.includes("anthropic's official cli")) return "claude";
+  if (text.includes("you are codex") || text.includes("openai codex cli")) return "codex";
+  if (text.includes("you are gemini cli") || text.includes("google's gemini cli")) return "gemini-cli";
+  if (text.includes("you are cline") || text.includes("cline, your coding agent")) return "cline";
+  if (text.includes("you are opencode")) return "opencode";
+  if (text.includes("agent_kiro") || text.includes("kiro aws")) return "kiro";
+  if (text.includes("you are hermes") || text.includes("nous research")) return "hermes";
+  return null;
+}
+
+const PATH_CLIENT = [
+  [/\/v1\/messages/, "claude"],
+  [/\/v1\/chat\/completions/, null],
+  [/\/responses|\/v1\/responses/, "codex"],
+  [/\bv1\/models\b/, "gemini-cli"],
+];
+
+function detectFromPath(path = "") {
+  if (!path) return null;
+  for (const [re, id] of PATH_CLIENT) {
+    if (re.test(path)) return id;
+  }
+  return null;
+}
+
+function tallyVotes(votes) {
+  const counts = new Map();
+  for (const v of votes) {
+    if (!v) continue;
+    counts.set(v, (counts.get(v) || 0) + 1);
+  }
+  if (counts.size === 0) return null;
+  let best = null, bestN = 0;
+  for (const [id, n] of counts) {
+    if (n > bestN) { best = id; bestN = n; }
+  }
+  return { id: best, votes: bestN, distinct: counts.size };
+}
+
+export function detectClient(headers = {}, body = {}, ctx = {}) {
+  const fromHeaders = detectFromHeaders(headers);
+  const fromBody = detectFromBody(body);
+  const fromPrompt = detectFromPrompt(body);
+  const fromPath = detectFromPath(ctx.path || "");
+  const votes = [fromHeaders, fromBody, fromPrompt, fromPath];
+  const signalCount = votes.filter(Boolean).length;
+
+  const tally = tallyVotes(votes);
+  if (!tally) {
+    clientDetectionsTotal.inc({ client: "unknown", signals: "0" });
+    return { id: null, confidence: "low", signals: 0, agrees: 0, conflicts: [] };
+  }
+
+  const conflicts = [];
+  if (tally.distinct > 1) {
+    const seen = new Set([tally.id]);
+    for (const v of votes) {
+      if (v && !seen.has(v)) { seen.add(v); conflicts.push(v); }
+    }
+
+    clientDetectionConflictsTotal.inc({ resolved: tally.id, conflicting: conflicts[0] || "?" });
+  }
+
+  clientDetectionsTotal.inc({
+    client: tally.id,
+    signals: String(signalCount),
+  });
+
+  const confidence =
+    tally.votes >= 3 ? "high"
+    : tally.votes === 2 ? "medium"
+    : "low";
+  return {
+    id: tally.id,
+    confidence,
+    signals: signalCount,
+    agrees: tally.votes,
+    conflicts,
+  };
+}
+
+export function detectClientTool(headers = {}, body = {}) {
+  return detectClient(headers, body).id;
+}
+
+export function isNativePassthrough(clientTool, provider) {
+  if (!clientTool) return false;
+  const nativeProviders = NATIVE_PAIRS[clientTool];
+  if (!nativeProviders) return false;
+
+  const normalizedProvider = provider.startsWith("anthropic-compatible")
+    ? "anthropic"
+    : provider;
+  return nativeProviders.includes(normalizedProvider);
+}
+
+export { NATIVE_PAIRS };

package/src/utils/cursorChecksum.js

@@ -0,0 +1,104 @@
+import crypto from "crypto";
+import { v5 as uuidv5 } from "uuid";
+
+export function generateHashed64Hex(input, salt = "") {
+  return crypto.createHash("sha256").update(input + salt).digest("hex");
+}
+
+export function generateSessionId(authToken) {
+  return uuidv5(authToken, uuidv5.DNS);
+}
+
+export function generateCursorChecksum(machineId) {
+
+  const timestamp = Math.floor(Date.now() / 1000000);
+
+  const byteArray = new Uint8Array([
+    (timestamp >> 40) & 0xFF,
+    (timestamp >> 32) & 0xFF,
+    (timestamp >> 24) & 0xFF,
+    (timestamp >> 16) & 0xFF,
+    (timestamp >> 8) & 0xFF,
+    timestamp & 0xFF
+  ]);
+
+  let t = 165;
+  for (let i = 0; i < byteArray.length; i++) {
+    byteArray[i] = ((byteArray[i] ^ t) + (i % 256)) & 0xFF;
+    t = byteArray[i];
+  }
+
+  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}`;
+}
+
+export function buildCursorHeaders(accessToken, machineId = null, ghostMode = true) {
+
+  const cleanToken = accessToken.includes("::")
+    ? accessToken.split("::")[1]
+    : accessToken;
+
+  const effectiveMachineId = machineId || generateHashed64Hex(cleanToken, "machineId");
+
+  const sessionId = generateSessionId(cleanToken);
+  const clientKey = generateHashed64Hex(cleanToken);
+  const checksum = generateCursorChecksum(effectiveMachineId);
+
+  let os = "linux";
+  if (typeof process !== "undefined") {
+    if (process.platform === "win32") os = "windows";
+    else if (process.platform === "darwin") os = "macos";
+  }
+
+  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.12.17",
+    "x-cursor-client-commit": "0fb762053c34788bb7760d5673f8a6d4c8589d50",
+    "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
+};