@juspay/neurolink 9.30.0 → 9.31.0

package/dist/proxy/cloaking/index.js

@@ -0,0 +1,86 @@
+/**
+ * CloakingPipeline — runs an ordered chain of CloakingPlugin instances
+ * against each proxied request (and optionally its response).
+ *
+ * Usage:
+ *   const pipeline = new CloakingPipeline();
+ *   pipeline.use(createHeaderScrubber());
+ *   pipeline.use(createSessionIdentity());
+ *   const ctx = await pipeline.processRequest(ctx);
+ *
+ * NOTE: The pipeline is currently used for unit testing and is ready for
+ * integration into the proxy request flow. Callers should instantiate a
+ * CloakingPipeline from ProxyConfigFile.cloaking, register plugins based
+ * on the config, and call processRequest/processResponse around the
+ * upstream fetch in claudeProxyRoutes.ts / oauthFetch.ts.
+ */
+export class CloakingPipeline {
+    plugins = [];
+    /** Register a plugin. Plugins run in `order` field order during processRequest. */
+    use(plugin) {
+        this.plugins.push(plugin);
+        return this;
+    }
+    /** Remove a plugin by name. */
+    remove(name) {
+        this.plugins = this.plugins.filter((p) => p.name !== name);
+    }
+    /**
+     * Run every enabled plugin's `transformRequest` sorted by `order` (ascending).
+     *
+     * Mode dispatch:
+     * - "never": skip all plugins, return context unchanged
+     * - "always": always run all enabled plugins
+     * - "auto": only run plugins if account.type === "oauth"
+     */
+    async processRequest(ctx) {
+        // Mode dispatch
+        if (ctx.config.mode === "never") {
+            return ctx;
+        }
+        if (ctx.config.mode === "auto" && ctx.account.type !== "oauth") {
+            return ctx;
+        }
+        let current = ctx;
+        const sorted = [...this.plugins].sort((a, b) => a.order - b.order);
+        for (const plugin of sorted) {
+            if (!plugin.enabled) {
+                continue;
+            }
+            current = await plugin.transformRequest(current);
+        }
+        return current;
+    }
+    /**
+     * Run every enabled plugin's `transformResponse` (if defined) in REVERSE order.
+     *
+     * Mode dispatch follows the same rules as processRequest.
+     */
+    async processResponse(ctx) {
+        // Mode dispatch
+        if (ctx.config.mode === "never") {
+            return ctx;
+        }
+        if (ctx.config.mode === "auto" && ctx.account.type !== "oauth") {
+            return ctx;
+        }
+        let current = ctx;
+        for (const plugin of [...this.plugins]
+            .sort((a, b) => a.order - b.order)
+            .reverse()) {
+            if (!plugin.enabled || !plugin.transformResponse) {
+                continue;
+            }
+            current = await plugin.transformResponse(current);
+        }
+        return current;
+    }
+    /** Return the number of registered plugins. */
+    get size() {
+        return this.plugins.length;
+    }
+    /** List registered plugin names (useful for diagnostics). */
+    get pluginNames() {
+        return this.plugins.map((p) => p.name);
+    }
+}

package/dist/proxy/cloaking/plugins/headerScrubber.d.ts

@@ -0,0 +1,9 @@
+/**
+ * HeaderScrubber — strips headers that could reveal the presence of a proxy.
+ *
+ * Removes forwarding headers (x-forwarded-for, via, x-real-ip, etc.) and any
+ * custom proxy-fingerprint headers, while preserving legitimate request
+ * headers like content-type and authorization.
+ */
+import type { CloakingPlugin, HeaderScrubberOptions } from "../../../types/index.js";
+export declare function createHeaderScrubber(options?: HeaderScrubberOptions): CloakingPlugin;

package/dist/proxy/cloaking/plugins/headerScrubber.js

@@ -0,0 +1,86 @@
+/**
+ * HeaderScrubber — strips headers that could reveal the presence of a proxy.
+ *
+ * Removes forwarding headers (x-forwarded-for, via, x-real-ip, etc.) and any
+ * custom proxy-fingerprint headers, while preserving legitimate request
+ * headers like content-type and authorization.
+ */
+/** Exact-match headers to strip (all lower-cased). */
+const STRIP_HEADERS_EXACT = new Set([
+    "x-forwarded-for",
+    "x-forwarded-host",
+    "x-forwarded-port",
+    "x-forwarded-server",
+    "x-forwarded-proto",
+    "x-real-ip",
+    "x-client-ip",
+    "true-client-ip",
+    "cf-connecting-ip",
+    "fastly-client-ip",
+    "x-cluster-client-ip",
+    "forwarded",
+    "via",
+    "sec-ch-ua",
+    "sec-fetch-dest",
+    "sec-fetch-mode",
+    "sec-fetch-site",
+    "priority",
+    "referer",
+    "accept-encoding",
+    "x-title",
+    "content-length",
+    "connection",
+    "transfer-encoding",
+    "keep-alive",
+    "te",
+    "trailer",
+    "upgrade",
+    "host",
+]);
+/** Prefix-match patterns to strip (all lower-cased). */
+const STRIP_HEADERS_PREFIX = [
+    "sec-ch-ua-",
+    "x-stainless-",
+    "x-forwarded-",
+    "proxy-",
+];
+/** Check whether a lower-cased header name should be stripped. */
+function shouldStrip(lower, extraSet) {
+    if (STRIP_HEADERS_EXACT.has(lower)) {
+        return true;
+    }
+    if (extraSet.has(lower)) {
+        return true;
+    }
+    for (const prefix of STRIP_HEADERS_PREFIX) {
+        if (lower.startsWith(prefix)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function createHeaderScrubber(options = {}) {
+    const extraSet = new Set((options.extraHeaders ?? []).map((h) => h.toLowerCase()));
+    return {
+        name: "header-scrubber",
+        order: 10,
+        enabled: true,
+        async transformRequest(ctx) {
+            const cleaned = {};
+            for (const [key, value] of Object.entries(ctx.request.headers)) {
+                const lower = key.toLowerCase();
+                if (shouldStrip(lower, extraSet)) {
+                    continue; // strip
+                }
+                cleaned[key] = value;
+            }
+            return {
+                ...ctx,
+                request: {
+                    ...ctx.request,
+                    headers: cleaned,
+                },
+            };
+        },
+    };
+}

package/dist/proxy/cloaking/plugins/sessionIdentity.d.ts

@@ -0,0 +1,15 @@
+/**
+ * SessionIdentity — generates unique user_id / session_id values per account
+ * so that Anthropic sees consistent "user" fingerprints even when requests are
+ * spread across multiple accounts.
+ *
+ * Session IDs follow the format:
+ *   user_[32 hex chars]_account_[UUIDv4]_session_[UUIDv4]
+ *
+ * IDs are cached with a 1-hour TTL and reused for subsequent requests from
+ * the same account within that window.
+ */
+import type { CloakingPlugin } from "../../../types/index.js";
+/** Purge all expired sessions from the cache. Exported for external timer use. */
+export declare function purgeExpiredSessions(): void;
+export declare function createSessionIdentity(): CloakingPlugin;

package/dist/proxy/cloaking/plugins/sessionIdentity.js

@@ -0,0 +1,65 @@
+/**
+ * SessionIdentity — generates unique user_id / session_id values per account
+ * so that Anthropic sees consistent "user" fingerprints even when requests are
+ * spread across multiple accounts.
+ *
+ * Session IDs follow the format:
+ *   user_[32 hex chars]_account_[UUIDv4]_session_[UUIDv4]
+ *
+ * IDs are cached with a 1-hour TTL and reused for subsequent requests from
+ * the same account within that window.
+ */
+import { randomBytes, randomUUID } from "crypto";
+// ── Session cache with TTL ───────────────────────────────────────────────────
+const TTL_MS = 3_600_000; // 1 hour
+const sessionCache = new Map();
+/** Generate a new session user ID in the required format. */
+function generateUserId() {
+    const hex = randomBytes(32).toString("hex"); // 64 hex chars, take first 32
+    return `user_${hex.slice(0, 32)}_account_${randomUUID()}_session_${randomUUID()}`;
+}
+/** Purge all expired sessions from the cache. Exported for external timer use. */
+export function purgeExpiredSessions() {
+    const now = Date.now();
+    for (const [key, entry] of sessionCache) {
+        if (entry.expiresAt <= now) {
+            sessionCache.delete(key);
+        }
+    }
+}
+export function createSessionIdentity() {
+    return {
+        name: "session-identity",
+        order: 20,
+        enabled: true,
+        async transformRequest(ctx) {
+            const accountId = ctx.account.id;
+            const now = Date.now();
+            // Check cache first — reuse if still valid
+            let cached = sessionCache.get(accountId);
+            if (!cached || cached.expiresAt <= now) {
+                cached = {
+                    userId: generateUserId(),
+                    expiresAt: now + TTL_MS,
+                };
+                sessionCache.set(accountId, cached);
+            }
+            const body = { ...ctx.request.body };
+            // Only set user_id if not already present — in passthrough mode,
+            // oauthFetch.ts owns this field and sets it from its own session cache.
+            if (!body.metadata?.user_id) {
+                body.metadata = {
+                    ...body.metadata,
+                    user_id: cached.userId,
+                };
+            }
+            return {
+                ...ctx,
+                request: {
+                    ...ctx.request,
+                    body,
+                },
+            };
+        },
+    };
+}

package/dist/proxy/cloaking/plugins/systemPromptInjector.d.ts

@@ -0,0 +1,11 @@
+/**
+ * SystemPromptInjector — injects Claude Code session context blocks into the
+ * system prompt so that the request looks like it originates from a genuine
+ * Claude Code session (IDE metadata, session timestamp, etc.).
+ *
+ * This is designed for "cloaking" proxy requests to appear as native Claude
+ * Code interactions. Only applies to OAuth accounts — API key accounts are
+ * skipped since they do not need session mimicry.
+ */
+import type { CloakingPlugin, SystemPromptInjectorOptions } from "../../../types/index.js";
+export declare function createSystemPromptInjector(options?: SystemPromptInjectorOptions): CloakingPlugin;

package/dist/proxy/cloaking/plugins/systemPromptInjector.js

@@ -0,0 +1,83 @@
+/**
+ * SystemPromptInjector — injects Claude Code session context blocks into the
+ * system prompt so that the request looks like it originates from a genuine
+ * Claude Code session (IDE metadata, session timestamp, etc.).
+ *
+ * This is designed for "cloaking" proxy requests to appear as native Claude
+ * Code interactions. Only applies to OAuth accounts — API key accounts are
+ * skipped since they do not need session mimicry.
+ */
+const DEFAULT_OPTIONS = {
+    ide: "vscode",
+    ideVersion: "1.96.2",
+    platform: "darwin",
+    cwd: "/Users/user/project",
+};
+/** Cached session start timestamp — set once on first call, reused for the process lifetime. */
+let cachedSessionStartTs;
+function generateSessionBlock(opts) {
+    if (!cachedSessionStartTs) {
+        cachedSessionStartTs = new Date().toISOString();
+    }
+    return [
+        "<env>",
+        `Working directory: ${opts.cwd}`,
+        "Is directory a git repo: Yes",
+        `Platform: ${opts.platform}`,
+        `IDE: ${opts.ide} ${opts.ideVersion}`,
+        `Session start: ${cachedSessionStartTs}`,
+        "</env>",
+    ].join("\n");
+}
+export function createSystemPromptInjector(options = {}) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    return {
+        name: "system-prompt-injector",
+        order: 30,
+        enabled: true,
+        async transformRequest(ctx) {
+            // Only apply to OAuth accounts — API key accounts skip session mimicry
+            if (ctx.account.type === "api_key") {
+                return ctx;
+            }
+            const sessionBlock = generateSessionBlock(opts);
+            const preamble = (options.preamble ?? "").trim();
+            const existingSystem = ctx.request.body.system;
+            // Build the injected text from preamble + session block
+            const injectedParts = [];
+            if (preamble) {
+                injectedParts.push(preamble);
+            }
+            injectedParts.push(sessionBlock);
+            const injectedText = injectedParts.join("\n\n");
+            let newSystem;
+            if (Array.isArray(existingSystem)) {
+                // Preserve structured blocks — prepend injected content as a new text block
+                const injectedBlock = { type: "text", text: injectedText };
+                newSystem = [
+                    injectedBlock,
+                    ...existingSystem,
+                ];
+            }
+            else {
+                // String or undefined — concatenate as before
+                const existing = typeof existingSystem === "string" ? existingSystem : "";
+                const parts = [injectedText];
+                if (existing) {
+                    parts.push(existing);
+                }
+                newSystem = parts.join("\n\n");
+            }
+            return {
+                ...ctx,
+                request: {
+                    ...ctx.request,
+                    body: {
+                        ...ctx.request.body,
+                        system: newSystem,
+                    },
+                },
+            };
+        },
+    };
+}

package/dist/proxy/cloaking/plugins/tlsFingerprint.d.ts

@@ -0,0 +1,14 @@
+/**
+ * TlsFingerprint — optional TLS fingerprint mimicry (stub).
+ *
+ * In a full implementation this would configure the TLS ClientHello to
+ * match a known browser or CLI fingerprint (JA3/JA4), making the TLS
+ * handshake indistinguishable from a genuine Claude Code session.
+ *
+ * This is a placeholder: the transformRequest is a no-op pass-through.
+ * Real JA3 mimicry requires a native TLS library (e.g. curl-impersonate
+ * or a custom Node.js TLS agent), which is out of scope for the initial
+ * implementation.
+ */
+import type { CloakingPlugin, TlsFingerprintOptions } from "../../../types/index.js";
+export declare function createTlsFingerprint(options?: TlsFingerprintOptions): CloakingPlugin;

package/dist/proxy/cloaking/plugins/tlsFingerprint.js

@@ -0,0 +1,38 @@
+/**
+ * TlsFingerprint — optional TLS fingerprint mimicry (stub).
+ *
+ * In a full implementation this would configure the TLS ClientHello to
+ * match a known browser or CLI fingerprint (JA3/JA4), making the TLS
+ * handshake indistinguishable from a genuine Claude Code session.
+ *
+ * This is a placeholder: the transformRequest is a no-op pass-through.
+ * Real JA3 mimicry requires a native TLS library (e.g. curl-impersonate
+ * or a custom Node.js TLS agent), which is out of scope for the initial
+ * implementation.
+ */
+import { logger } from "../../../utils/logger.js";
+export function createTlsFingerprint(options = {}) {
+    const profile = options.profile ?? "claude-code";
+    const warnOnUse = options.warnOnUse ?? true;
+    let hasWarned = false;
+    return {
+        name: "tls-fingerprint",
+        order: 0,
+        // Stub — no real TLS mimicry is implemented; default-off to avoid misleading operators.
+        enabled: false,
+        async transformRequest(ctx) {
+            if (warnOnUse && !hasWarned) {
+                hasWarned = true;
+                logger.warn(`[tls-fingerprint] Stub: profile "${profile}" requested but TLS mimicry is not implemented.`);
+            }
+            // No-op: return context unchanged.
+            // A real implementation would attach a custom TLS agent to the
+            // request context here.
+            return ctx;
+        },
+        async transformResponse(ctx) {
+            // No-op pass-through
+            return ctx;
+        },
+    };
+}

package/dist/proxy/cloaking/plugins/wordObfuscator.d.ts

@@ -0,0 +1,9 @@
+/**
+ * WordObfuscator — inserts zero-width characters into sensitive words so
+ * that naive string-matching by upstream APIs cannot detect them.
+ *
+ * For example, "proxy" becomes "p\u200Broxy" (ZWS after the first character),
+ * making the text visually identical to humans but different at the byte level.
+ */
+import type { CloakingPlugin } from "../../../types/index.js";
+export declare function createWordObfuscator(customWords?: string[]): CloakingPlugin;

package/dist/proxy/cloaking/plugins/wordObfuscator.js

@@ -0,0 +1,121 @@
+/**
+ * WordObfuscator — inserts zero-width characters into sensitive words so
+ * that naive string-matching by upstream APIs cannot detect them.
+ *
+ * For example, "proxy" becomes "p\u200Broxy" (ZWS after the first character),
+ * making the text visually identical to humans but different at the byte level.
+ */
+/** Unicode zero-width space (U+200B). */
+const ZWS = "\u200B";
+/**
+ * Insert a zero-width space after the first character.
+ * This defeats simple substring matching while preserving readability.
+ */
+function obfuscateWord(word) {
+    if (word.length <= 1) {
+        return word;
+    }
+    return word.charAt(0) + ZWS + word.slice(1);
+}
+function escapeRegExp(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * Replace all case-insensitive occurrences of each sensitive word in `text`
+ * with the obfuscated version, preserving original casing.
+ *
+ * Words are sorted longest-first so that longer matches take priority over
+ * shorter substrings (e.g., "load balancer" matches before "load").
+ */
+function obfuscateText(text, sortedWords) {
+    let result = text;
+    for (const word of sortedWords) {
+        const pattern = new RegExp(escapeRegExp(word), "gi");
+        result = result.replace(pattern, (match) => obfuscateWord(match));
+    }
+    return result;
+}
+/** Default sensitive words that might reveal proxy usage. */
+const DEFAULT_SENSITIVE_WORDS = [
+    "proxy",
+    "neurolink",
+    "load balancer",
+    "round-robin",
+    "failover",
+    "multi-account",
+];
+export function createWordObfuscator(customWords) {
+    const words = customWords ?? [...DEFAULT_SENSITIVE_WORDS];
+    // Sort longest-first so longer matches take priority
+    const sorted = [...words].sort((a, b) => b.length - a.length);
+    return {
+        name: "word-obfuscator",
+        order: 40,
+        enabled: true,
+        async transformRequest(ctx) {
+            const messages = ctx.request.body.messages.map((msg) => {
+                if (typeof msg.content === "string") {
+                    return { ...msg, content: obfuscateText(msg.content, sorted) };
+                }
+                if (Array.isArray(msg.content)) {
+                    const obfuscatedContent = msg.content.map((block) => {
+                        if (block.type === "text" && typeof block.text === "string") {
+                            return {
+                                ...block,
+                                text: obfuscateText(block.text, sorted),
+                            };
+                        }
+                        // Obfuscate tool_result content (string or nested blocks)
+                        if (block.type === "tool_result") {
+                            if (typeof block.content === "string") {
+                                return {
+                                    ...block,
+                                    content: obfuscateText(block.content, sorted),
+                                };
+                            }
+                            if (Array.isArray(block.content)) {
+                                const obfuscatedBlocks = block.content.map((inner) => {
+                                    if (inner.type === "text" && typeof inner.text === "string") {
+                                        return {
+                                            ...inner,
+                                            text: obfuscateText(inner.text, sorted),
+                                        };
+                                    }
+                                    return inner;
+                                });
+                                return { ...block, content: obfuscatedBlocks };
+                            }
+                        }
+                        return block;
+                    });
+                    return { ...msg, content: obfuscatedContent };
+                }
+                return msg;
+            });
+            // Also obfuscate system prompt if present
+            let system = ctx.request.body.system;
+            if (typeof system === "string") {
+                system = obfuscateText(system, sorted);
+            }
+            else if (Array.isArray(system)) {
+                system = system.map((block) => {
+                    if (block.type === "text" && typeof block.text === "string") {
+                        return { ...block, text: obfuscateText(block.text, sorted) };
+                    }
+                    return block;
+                });
+            }
+            return {
+                ...ctx,
+                request: {
+                    ...ctx.request,
+                    body: {
+                        ...ctx.request.body,
+                        messages,
+                        ...(system !== undefined ? { system } : {}),
+                    },
+                },
+            };
+        },
+    };
+}

package/dist/proxy/cloaking/types.d.ts

@@ -0,0 +1 @@
+export type { CloakingAccount, CloakingRequest, CloakingResponse, CloakingMode, CloakingContext, CloakingPlugin, CloakingConfig, HeaderScrubberOptions, SystemPromptInjectorOptions, TlsFingerprintOptions, } from "../../types/index.js";

package/dist/proxy/cloaking/types.js

@@ -0,0 +1 @@
+export {};

package/dist/proxy/modelRouter.d.ts

@@ -0,0 +1,10 @@
+import type { FallbackEntry, ProxyRoutingConfig, RouteResult } from "../types/index.js";
+export declare class ModelRouter {
+    private readonly mappings;
+    private readonly passthrough;
+    private readonly fallback;
+    constructor(config: ProxyRoutingConfig);
+    resolve(requestedModel: string): RouteResult;
+    isClaudeTarget(requestedModel: string): boolean;
+    getFallbackChain(): FallbackEntry[];
+}

package/dist/proxy/modelRouter.js

@@ -0,0 +1,29 @@
+export class ModelRouter {
+    mappings;
+    passthrough;
+    fallback;
+    constructor(config) {
+        this.mappings = new Map(config.modelMappings.map((m) => [m.from, m]));
+        this.passthrough = new Set(config.passthroughModels ?? []);
+        this.fallback = config.fallbackChain;
+    }
+    resolve(requestedModel) {
+        const mapping = this.mappings.get(requestedModel);
+        if (mapping) {
+            return { provider: mapping.provider, model: mapping.to };
+        }
+        if (this.passthrough.has(requestedModel)) {
+            return { provider: "anthropic", model: requestedModel };
+        }
+        if (requestedModel.startsWith("claude-")) {
+            return { provider: "anthropic", model: requestedModel };
+        }
+        return { provider: null, model: requestedModel };
+    }
+    isClaudeTarget(requestedModel) {
+        return this.resolve(requestedModel).provider === "anthropic";
+    }
+    getFallbackChain() {
+        return this.fallback;
+    }
+}

package/dist/proxy/oauthFetch.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Shared OAuth fetch wrapper for Anthropic API requests.
+ *
+ * Extracted from `providers/anthropic.ts` so that any provider or proxy layer
+ * that needs OAuth-authenticated Anthropic requests can reuse the same logic.
+ *
+ * Applies full "cloaking" to make requests indistinguishable from the
+ * official Claude CLI / CLIProxyAPI, which is required for OAuth + tools
+ * to work correctly.
+ *
+ * @module proxy/oauthFetch
+ */
+import { CLAUDE_CLI_USER_AGENT, MCP_TOOL_PREFIX } from "../auth/anthropicOAuth.js";
+export { CLAUDE_CLI_USER_AGENT, MCP_TOOL_PREFIX };
+/**
+ * Creates a custom fetch function for OAuth-authenticated requests.
+ * This wrapper applies all required transformations for OAuth mode:
+ * - Uses Authorization: Bearer header (NOT x-api-key)
+ * - Adds OAuth-required beta headers
+ * - Sets User-Agent to Claude CLI
+ * - Adds ?beta=true query parameter to /v1/messages
+ * - Injects billing header & agent block into system prompt
+ * - Injects fake user ID into metadata
+ * - Adds Stainless SDK headers for fingerprint matching
+ * - Disables thinking when tool_choice is forced
+ *
+ * Accepts a getter function instead of a static token so that refreshed
+ * tokens are picked up automatically on each request.
+ *
+ * @param getToken              - Function returning the current OAuth access token
+ * @param includeOptionalBetas  - Whether to include optional beta headers (default true)
+ * @param enableMcpPrefix       - Whether to apply mcp_ prefix/strip logic to tool names (default false)
+ * @param skipBodyTransform     - When true, skip ALL body modifications (billing header, user ID, tool prefix).
+ *                                Used for proxy passthrough where the request body must be forwarded as-is.
+ */
+export declare function createOAuthFetch(getToken: () => string, includeOptionalBetas?: boolean, enableMcpPrefix?: boolean, skipBodyTransform?: boolean): typeof fetch;