@juspay/neurolink 11.11.4 → 11.11.6

package/dist/cli/proxy-clients/claudeCode.js

@@ -0,0 +1,130 @@
+/**
+ * Claude Code client configurator.
+ *
+ * Moved verbatim out of `proxy.ts`, with one behaviour change: `detect()` is
+ * new. This was the only writer that created its config file for a CLI that
+ * may never have been installed.
+ */
+import { homedir } from "os";
+import { join } from "path";
+import { logger } from "../../lib/utils/logger.js";
+/**
+ * Resolved per call rather than at module load so `detect()` and `apply()`
+ * agree when HOME changes — under test, and on the `--dev` isolation path.
+ */
+function getClaudeSettingsDir() {
+    return join(homedir(), ".claude");
+}
+function getClaudeSettingsPath() {
+    return join(getClaudeSettingsDir(), "settings.json");
+}
+/** Keys we manage in Claude Code's settings.env */
+const PROXY_MANAGED_KEYS = ["ANTHROPIC_BASE_URL", "ENABLE_TOOL_SEARCH"];
+export async function setClaudeProxySettings(baseUrl) {
+    const fs = await import("fs");
+    let settings = {};
+    try {
+        settings = JSON.parse(fs.readFileSync(getClaudeSettingsPath(), "utf8"));
+    }
+    catch {
+        // file missing/invalid — create fresh settings object
+    }
+    const env = (settings.env ?? {});
+    // Preserve original values so clearClaudeProxySettings can restore them.
+    // Only snapshot once — subsequent calls should not overwrite the snapshot.
+    const originals = (settings
+        .__proxy_original_env ?? {});
+    for (const key of PROXY_MANAGED_KEYS) {
+        if (!(key in originals)) {
+            originals[key] = key in env ? env[key] : null;
+        }
+    }
+    settings.__proxy_original_env = originals;
+    env.ANTHROPIC_BASE_URL = baseUrl;
+    env.ENABLE_TOOL_SEARCH = "true";
+    settings.env = env;
+    fs.writeFileSync(getClaudeSettingsPath(), JSON.stringify(settings, null, 2));
+}
+export async function clearClaudeProxySettings(expectedBaseUrl) {
+    const fs = await import("fs");
+    let settings;
+    try {
+        settings = JSON.parse(fs.readFileSync(getClaudeSettingsPath(), "utf8"));
+    }
+    catch {
+        return false;
+    }
+    const env = settings.env;
+    if (!env) {
+        return false;
+    }
+    if (expectedBaseUrl &&
+        typeof env.ANTHROPIC_BASE_URL === "string" &&
+        env.ANTHROPIC_BASE_URL !== expectedBaseUrl) {
+        // User switched to a different proxy URL; do not clobber.
+        return false;
+    }
+    if (!("__proxy_original_env" in settings)) {
+        // No snapshot means we cannot prove these keys are ours. Without this
+        // guard the loop below reads every managed key as "did not exist before"
+        // and deletes it — wiping a real user value. Leaving a stale proxy URL
+        // behind is recoverable; destroying the user's own setting is not.
+        // OpenCode and Qwen refuse for the same reason.
+        logger.debug("[proxy] Claude clear: no original-env snapshot found, leaving settings.env intact");
+        return false;
+    }
+    const hadBaseUrl = typeof env.ANTHROPIC_BASE_URL === "string";
+    const hadToolSearch = env.ENABLE_TOOL_SEARCH === "true";
+    // Restore original values if they were saved, otherwise delete the keys
+    const originals = (settings
+        .__proxy_original_env ?? {});
+    for (const key of PROXY_MANAGED_KEYS) {
+        const original = originals[key];
+        if (original !== undefined && original !== null) {
+            // Restore the value that existed before the proxy was started
+            env[key] = original;
+        }
+        else {
+            // Key did not exist before — remove it
+            delete env[key];
+        }
+    }
+    delete settings.__proxy_original_env;
+    if (Object.keys(env).length === 0) {
+        delete settings.env;
+    }
+    else {
+        settings.env = env;
+    }
+    fs.writeFileSync(getClaudeSettingsPath(), JSON.stringify(settings, null, 2));
+    return hadBaseUrl || hadToolSearch;
+}
+export const claudeCodeConfigurator = {
+    id: "claude-code",
+    displayName: "Claude Code",
+    // New: previously this writer created ~/.claude/settings.json even when
+    // Claude Code had never been installed. The other two writers already
+    // probed; this one did not.
+    detect: async () => {
+        const fs = await import("fs");
+        try {
+            fs.accessSync(getClaudeSettingsDir());
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+    apply: async (proxyBaseUrl) => {
+        await setClaudeProxySettings(proxyBaseUrl);
+        return true;
+    },
+    restore: (proxyBaseUrl) => clearClaudeProxySettings(proxyBaseUrl),
+};
+export const __claudeCodeTestHooks = {
+    getClaudeSettingsDir,
+    getClaudeSettingsPath,
+    setClaudeProxySettings,
+    clearClaudeProxySettings,
+};
+//# sourceMappingURL=claudeCode.js.map

package/dist/cli/proxy-clients/codex.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Codex (ChatGPT) client configurator.
+ *
+ * Moved verbatim out of `proxy.ts`. Codex is the writer the other two should
+ * have copied: it probes for an installed CLI and reports whether it wrote.
+ */
+import type { CliProxyClientConfigurator } from "../../lib/types/index.js";
+/**
+ * Resolved per call rather than at module load so `detect()` and `apply()`
+ * agree when HOME changes — under test, and on the `--dev` isolation path.
+ */
+declare function getCodexConfigPath(): string;
+declare function getCodexSnapshotPath(): string;
+export declare function setCodexProxySettings(baseUrl: string): Promise<boolean>;
+export declare function clearCodexProxySettings(expectedBaseUrl?: string): Promise<boolean>;
+export declare const codexConfigurator: CliProxyClientConfigurator;
+export declare const __codexClientTestHooks: {
+    getCodexConfigPath: typeof getCodexConfigPath;
+    getCodexSnapshotPath: typeof getCodexSnapshotPath;
+    setCodexProxySettings: typeof setCodexProxySettings;
+    clearCodexProxySettings: typeof clearCodexProxySettings;
+};
+export {};

package/dist/cli/proxy-clients/codex.js

@@ -0,0 +1,217 @@
+/**
+ * Codex (ChatGPT) client configurator.
+ *
+ * Moved verbatim out of `proxy.ts`. Codex is the writer the other two should
+ * have copied: it probes for an installed CLI and reports whether it wrote.
+ */
+import { homedir } from "os";
+import { join } from "path";
+import { logger } from "../../lib/utils/logger.js";
+//
+// Points the Codex CLI at the proxy by managing `~/.codex/config.toml`:
+//   - appends a marker-delimited `[model_providers.neurolink]` table
+//   - flips the top-level `model_provider` to "neurolink"
+// The original `model_provider` value is snapshotted to a sidecar JSON so the
+// restore works even across process crashes. All edits are guarded and wrapped
+// so a failure never aborts proxy start/stop. Codex talks the Responses API to
+// the proxy's /backend-api/codex path.
+/**
+ * Resolved per call rather than at module load so `detect()` and `apply()`
+ * agree when HOME changes — under test, and on the `--dev` isolation path.
+ */
+function getCodexConfigPath() {
+    return join(homedir(), ".codex", "config.toml");
+}
+function getCodexSnapshotPath() {
+    return join(homedir(), ".neurolink", "codex-proxy-snapshot.json");
+}
+const CODEX_BLOCK_BEGIN = "# >>> neurolink-proxy (managed) >>>";
+const CODEX_BLOCK_END = "# <<< neurolink-proxy (managed) <<<";
+const CODEX_PROVIDER_LINE_RE = /^[ \t]*model_provider[ \t]*=.*$/m;
+const CODEX_MODEL_LINE_RE = /^[ \t]*model[ \t]*=.*$/m;
+/** Strip any previously-managed block + our injected provider line. */
+function stripCodexManagedConfig(text) {
+    const blockRe = new RegExp(`\\n?${escapeRegExp(CODEX_BLOCK_BEGIN)}[\\s\\S]*?${escapeRegExp(CODEX_BLOCK_END)}\\n?`, "g");
+    let out = text.replace(blockRe, "\n");
+    // Remove our injected selector line (only the exact "neurolink" one).
+    out = out.replace(/^[ \t]*model_provider[ \t]*=[ \t]*"neurolink"[ \t]*$\n?/m, "");
+    return out;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * Apply a top-level TOML key edit, confined to the document preamble.
+ *
+ * In TOML every key after a `[table]` header belongs to that table. A
+ * document-wide regex therefore happily rewrites `model_provider` inside
+ * `[model_providers.foo]`, which sets a table key instead of the top-level
+ * selector: Codex keeps using its original provider while the command reports
+ * success. Only the text before the first header can hold top-level keys.
+ */
+function editTomlPreamble(text, edit) {
+    const headerMatch = /^[ \t]*\[/m.exec(text);
+    const boundary = headerMatch ? headerMatch.index : text.length;
+    const preamble = text.slice(0, boundary);
+    const edited = edit(preamble);
+    return edited === null ? text : edited + text.slice(boundary);
+}
+function buildCodexProviderBlock(baseUrl) {
+    return [
+        CODEX_BLOCK_BEGIN,
+        "[model_providers.neurolink]",
+        'name = "NeuroLink Proxy"',
+        `base_url = "${baseUrl}/backend-api/codex"`,
+        'wire_api = "responses"',
+        "requires_openai_auth = true",
+        CODEX_BLOCK_END,
+        "",
+    ].join("\n");
+}
+export async function setCodexProxySettings(baseUrl) {
+    try {
+        const fs = await import("fs");
+        if (!fs.existsSync(getCodexConfigPath())) {
+            // Codex not installed / never configured — skip silently.
+            return false;
+        }
+        const original = fs.readFileSync(getCodexConfigPath(), "utf8");
+        // Snapshot the user's original selector once (survives crashes/restarts).
+        if (!fs.existsSync(getCodexSnapshotPath())) {
+            // Same preamble boundary the edit paths use. Matching document-wide would
+            // capture a `model_provider` belonging to a table — a legacy
+            // `[profiles.<name>]` block, say — and the restore would then write that
+            // profile's provider back as the top-level selector.
+            let providerMatch = null;
+            editTomlPreamble(original, (preamble) => {
+                providerMatch = preamble.match(CODEX_PROVIDER_LINE_RE);
+                return null;
+            });
+            // Ignore a stale managed selector line if present in the original.
+            const originalProviderLine = providerMatch && !/"neurolink"/.test(providerMatch[0])
+                ? providerMatch[0]
+                : null;
+            fs.mkdirSync(join(homedir(), ".neurolink"), { recursive: true });
+            fs.writeFileSync(getCodexSnapshotPath(), JSON.stringify({ originalProviderLine }, null, 2), { mode: 0o600 });
+        }
+        let text = stripCodexManagedConfig(original);
+        // Set the selector: replace an existing top-level model_provider or insert
+        // one right after the top-level `model = ...` line (stays before any table).
+        let selectorPlaced = false;
+        text = editTomlPreamble(text, (preamble) => {
+            if (CODEX_PROVIDER_LINE_RE.test(preamble)) {
+                selectorPlaced = true;
+                return preamble.replace(CODEX_PROVIDER_LINE_RE, 'model_provider = "neurolink"');
+            }
+            if (CODEX_MODEL_LINE_RE.test(preamble)) {
+                selectorPlaced = true;
+                return preamble.replace(CODEX_MODEL_LINE_RE, (line) => `${line}\nmodel_provider = "neurolink"`);
+            }
+            return null;
+        });
+        if (!selectorPlaced) {
+            text = `model_provider = "neurolink"\n${text}`;
+        }
+        const trimmed = text.replace(/\s*$/, "\n");
+        fs.writeFileSync(getCodexConfigPath(), `${trimmed}\n${buildCodexProviderBlock(baseUrl)}`);
+        return true;
+    }
+    catch (error) {
+        logger.debug(`[proxy] Codex client config not updated: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+    }
+}
+export async function clearCodexProxySettings(expectedBaseUrl) {
+    try {
+        const fs = await import("fs");
+        if (!fs.existsSync(getCodexConfigPath())) {
+            return false;
+        }
+        const original = fs.readFileSync(getCodexConfigPath(), "utf8");
+        // The managed block records its owner in `base_url`. Without this check a
+        // second proxy shutting down on another port would strip the block that the
+        // still-running proxy installed, and restore the snapshot selector on top —
+        // silently taking Codex off the live proxy. Mirrors the Claude and OpenCode
+        // clear paths.
+        if (expectedBaseUrl) {
+            const ownerMatch = original.match(new RegExp(`${escapeRegExp(CODEX_BLOCK_BEGIN)}[\\s\\S]*?base_url\\s*=\\s*"([^"]*)"`));
+            if (ownerMatch &&
+                ownerMatch[1] !== `${expectedBaseUrl}/backend-api/codex`) {
+                return false;
+            }
+        }
+        let text = stripCodexManagedConfig(original);
+        // Restore the user's original selector line if we snapshotted one.
+        let restored = null;
+        if (fs.existsSync(getCodexSnapshotPath())) {
+            try {
+                const snap = JSON.parse(fs.readFileSync(getCodexSnapshotPath(), "utf8"));
+                restored = snap.originalProviderLine ?? null;
+            }
+            catch {
+                restored = null;
+            }
+        }
+        if (restored) {
+            const restoredLine = restored;
+            let restorePlaced = false;
+            text = editTomlPreamble(text, (preamble) => {
+                if (CODEX_PROVIDER_LINE_RE.test(preamble)) {
+                    restorePlaced = true;
+                    return preamble.replace(CODEX_PROVIDER_LINE_RE, restoredLine);
+                }
+                if (CODEX_MODEL_LINE_RE.test(preamble)) {
+                    restorePlaced = true;
+                    return preamble.replace(CODEX_MODEL_LINE_RE, (line) => `${line}\n${restoredLine}`);
+                }
+                return null;
+            });
+            if (!restorePlaced) {
+                text = `${restoredLine}\n${text}`;
+            }
+        }
+        if (text === original) {
+            // Nothing managed remains, so the snapshot can no longer describe the
+            // user's current selector. Keeping it would let a later clear restore a
+            // value the user has since changed by hand.
+            try {
+                fs.rmSync(getCodexSnapshotPath(), { force: true });
+            }
+            catch {
+                // best-effort
+            }
+            return false;
+        }
+        fs.writeFileSync(getCodexConfigPath(), text.replace(/\s*$/, "\n"));
+        try {
+            fs.rmSync(getCodexSnapshotPath(), { force: true });
+        }
+        catch {
+            // best-effort
+        }
+        return true;
+    }
+    catch (error) {
+        logger.debug(`[proxy] Codex client config not cleared: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+    }
+}
+export const codexConfigurator = {
+    id: "codex",
+    displayName: "Codex",
+    detect: async () => {
+        const fs = await import("fs");
+        return fs.existsSync(getCodexConfigPath());
+    },
+    // setCodexProxySettings appends "/backend-api/codex" itself, so this takes
+    // the bare origin.
+    apply: (proxyBaseUrl) => setCodexProxySettings(proxyBaseUrl),
+    restore: (proxyBaseUrl) => clearCodexProxySettings(proxyBaseUrl),
+};
+export const __codexClientTestHooks = {
+    getCodexConfigPath,
+    getCodexSnapshotPath,
+    setCodexProxySettings,
+    clearCodexProxySettings,
+};
+//# sourceMappingURL=codex.js.map

package/dist/cli/proxy-clients/copilot.d.ts

@@ -0,0 +1,40 @@
+/**
+ * GitHub Copilot CLI client configurator.
+ *
+ * Copilot is the odd one out: its provider settings are read **only** from the
+ * environment. `app.js` resolves `COPILOT_PROVIDER_BASE_URL` (and siblings) via
+ * `process.env`, and `~/.copilot/config.json` — which announces itself as
+ * "managed automatically" — carries no provider block. There is no file this
+ * proxy can write that Copilot will read.
+ *
+ * So rather than edit a shell profile, which lives outside this proxy's blast
+ * radius and runs on every shell the user opens, `apply()` writes a small
+ * sourceable script inside the proxy's own directory. The user adds one line to
+ * their profile once:
+ *
+ *   [ -f ~/.neurolink/copilot-env.sh ] && . ~/.neurolink/copilot-env.sh
+ *
+ * `restore()` deletes the script, so a sourced-but-stale file cannot outlive
+ * the proxy — the guard above makes a missing file a no-op.
+ *
+ * Copilot also honours `OPENAI_API_KEY` + `OPENAI_BASE_URL`, but only when
+ * `COPILOT_ENABLE_ALT_PROVIDERS=true` is set; the `COPILOT_PROVIDER_*` path has
+ * no such gate, so that is the one used here.
+ */
+import type { CliProxyClientConfigurator } from "../../lib/types/index.js";
+/**
+ * Resolved per call rather than at module load so `detect()` and `apply()`
+ * agree when HOME changes — under test, and on the `--dev` isolation path.
+ */
+declare function getCopilotConfigDir(): string;
+declare function getCopilotEnvPath(): string;
+export declare function setCopilotProxySettings(baseUrl: string, proxyKey?: string): Promise<boolean>;
+export declare function clearCopilotProxySettings(expectedBaseUrl?: string): Promise<boolean>;
+export declare const copilotConfigurator: CliProxyClientConfigurator;
+export declare const __copilotTestHooks: {
+    getCopilotConfigDir: typeof getCopilotConfigDir;
+    getCopilotEnvPath: typeof getCopilotEnvPath;
+    setCopilotProxySettings: typeof setCopilotProxySettings;
+    clearCopilotProxySettings: typeof clearCopilotProxySettings;
+};
+export {};

package/dist/cli/proxy-clients/copilot.js

@@ -0,0 +1,124 @@
+/**
+ * GitHub Copilot CLI client configurator.
+ *
+ * Copilot is the odd one out: its provider settings are read **only** from the
+ * environment. `app.js` resolves `COPILOT_PROVIDER_BASE_URL` (and siblings) via
+ * `process.env`, and `~/.copilot/config.json` — which announces itself as
+ * "managed automatically" — carries no provider block. There is no file this
+ * proxy can write that Copilot will read.
+ *
+ * So rather than edit a shell profile, which lives outside this proxy's blast
+ * radius and runs on every shell the user opens, `apply()` writes a small
+ * sourceable script inside the proxy's own directory. The user adds one line to
+ * their profile once:
+ *
+ *   [ -f ~/.neurolink/copilot-env.sh ] && . ~/.neurolink/copilot-env.sh
+ *
+ * `restore()` deletes the script, so a sourced-but-stale file cannot outlive
+ * the proxy — the guard above makes a missing file a no-op.
+ *
+ * Copilot also honours `OPENAI_API_KEY` + `OPENAI_BASE_URL`, but only when
+ * `COPILOT_ENABLE_ALT_PROVIDERS=true` is set; the `COPILOT_PROVIDER_*` path has
+ * no such gate, so that is the one used here.
+ */
+import { homedir } from "os";
+import { join } from "path";
+import { logger } from "../../lib/utils/logger.js";
+/**
+ * Resolved per call rather than at module load so `detect()` and `apply()`
+ * agree when HOME changes — under test, and on the `--dev` isolation path.
+ */
+function getCopilotConfigDir() {
+    return join(homedir(), ".copilot");
+}
+function getCopilotEnvPath() {
+    return join(homedir(), ".neurolink", "copilot-env.sh");
+}
+function buildCopilotEnvScript(baseUrl, proxyKey) {
+    return [
+        "# Generated by `neurolink proxy` — do not edit.",
+        "# Removed automatically when the proxy stops.",
+        "#",
+        "# Copilot CLI reads its provider settings from the environment only, so",
+        "# source this from your shell profile:",
+        "#   [ -f ~/.neurolink/copilot-env.sh ] && . ~/.neurolink/copilot-env.sh",
+        'export COPILOT_PROVIDER_TYPE="openai"',
+        `export COPILOT_PROVIDER_BASE_URL="${baseUrl}"`,
+        `export COPILOT_PROVIDER_API_KEY="${proxyKey}"`,
+        "",
+    ].join("\n");
+}
+export async function setCopilotProxySettings(baseUrl, proxyKey) {
+    const fs = await import("fs");
+    try {
+        fs.accessSync(getCopilotConfigDir());
+    }
+    catch {
+        // Copilot CLI not installed — report the skip so no caller prints a
+        // success message for work that did not happen.
+        return false;
+    }
+    try {
+        const envPath = getCopilotEnvPath();
+        fs.mkdirSync(join(homedir(), ".neurolink"), { recursive: true });
+        fs.writeFileSync(envPath, buildCopilotEnvScript(baseUrl, proxyKey || "neurolink-proxy"), { mode: 0o600 });
+        // The mode option above only applies when open() creates the file. On an
+        // overwrite it is ignored, so a pre-existing file keeps whatever
+        // permissions it had — which for a file holding a proxy key could be
+        // world-readable. Enforce it on both paths.
+        fs.chmodSync(envPath, 0o600);
+        return true;
+    }
+    catch (error) {
+        logger.debug(`[proxy] Copilot env script not written: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+    }
+}
+export async function clearCopilotProxySettings(expectedBaseUrl) {
+    const fs = await import("fs");
+    const envPath = getCopilotEnvPath();
+    let existing;
+    try {
+        existing = fs.readFileSync(envPath, "utf8");
+    }
+    catch {
+        return false;
+    }
+    // The whole file is ours to delete — but only if it is still pointing where
+    // we pointed it. A user who hand-edited it to another endpoint keeps it.
+    if (expectedBaseUrl && !existing.includes(expectedBaseUrl)) {
+        return false;
+    }
+    try {
+        fs.rmSync(envPath, { force: true });
+        return true;
+    }
+    catch (error) {
+        logger.debug(`[proxy] Copilot env script not removed: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+    }
+}
+export const copilotConfigurator = {
+    id: "copilot",
+    displayName: "Copilot CLI",
+    detect: async () => {
+        const fs = await import("fs");
+        try {
+            fs.accessSync(getCopilotConfigDir());
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+    // Copilot speaks OpenAI Chat Completions, so it points at the /v1 door.
+    apply: (proxyBaseUrl) => setCopilotProxySettings(`${proxyBaseUrl}/v1`),
+    restore: (proxyBaseUrl) => clearCopilotProxySettings(`${proxyBaseUrl}/v1`),
+};
+export const __copilotTestHooks = {
+    getCopilotConfigDir,
+    getCopilotEnvPath,
+    setCopilotProxySettings,
+    clearCopilotProxySettings,
+};
+//# sourceMappingURL=copilot.js.map

package/dist/cli/proxy-clients/openCode.d.ts

@@ -0,0 +1,26 @@
+/**
+ * OpenCode client configurator.
+ *
+ * Moved verbatim out of `proxy.ts` so that adding a CLI means adding a file
+ * here rather than editing a 5,000-line command module in seven places.
+ */
+import type { CliProxyClientConfigurator } from "../../lib/types/index.js";
+declare function getOpenCodeConfigDir(): string;
+declare function getOpenCodeConfigPath(): string;
+export declare function setOpenCodeProxySettings(baseUrl: string, proxyKey?: string): Promise<boolean>;
+export declare function clearOpenCodeProxySettings(expectedBaseUrl?: string): Promise<boolean>;
+/**
+ * Test-only export (CLAUDE.md rule 15 determinism exception). The OpenCode
+ * client writers resolve paths from the environment and are only reachable
+ * from `proxy start` / `proxy setup`, neither of which can be driven against a
+ * throwaway HOME without starting a real server. Consumed by
+ * test/continuous-test-suite-proxy.ts.
+ */
+export declare const __openCodeTestHooks: {
+    getOpenCodeConfigDir: typeof getOpenCodeConfigDir;
+    getOpenCodeConfigPath: typeof getOpenCodeConfigPath;
+    setOpenCodeProxySettings: typeof setOpenCodeProxySettings;
+    clearOpenCodeProxySettings: typeof clearOpenCodeProxySettings;
+};
+export declare const openCodeConfigurator: CliProxyClientConfigurator;
+export {};