@juspay/neurolink 12.13.0 → 12.14.1

package/dist/cli/commands/proxy.d.ts

@@ -88,5 +88,6 @@ export declare const proxyStatusCommand: CommandModule<object, ProxyStatusArgs>;
 export declare const proxyTelemetryCommand: CommandModule<object, ProxyTelemetryArgs>;
 export declare const proxyGuardCommand: CommandModule<object, ProxyGuardArgs>;
 export declare const proxySetupCommand: CommandModule;
+export declare function buildProxyLaunchdPlist(port: number, host: string, envFile?: string, configFile?: string): string;
 export declare const proxyInstallCommand: CommandModule;
 export declare const proxyUninstallCommand: CommandModule;

package/dist/cli/commands/proxy.js

@@ -1,23 +1,15 @@
-/**
- * Proxy CLI Commands for NeuroLink
- *
- * Implements commands for managing the Claude multi-account proxy:
- * - neurolink proxy start  — Start the proxy server
- * - neurolink proxy status — Show proxy status (accounts, sessions, routing)
- *
- * The proxy creates a NeuroLink instance and builds a Hono app that registers
- * Claude-compatible proxy routes. All requests flow through ctx.neurolink
- * (generate/stream), with an optional ModelRouter for model remapping.
- */
+import { initializeProxyOtelLogs, routeProxyConsoleToOtel, flushProxyOtelLogs, shutdownProxyOtelLogs, isProxyOtelOnly, withProxyOtelLogShutdown, } from "../../proxy/otelLogSink.js";
+import { writeFileAtomic } from "../proxy-clients/snapshot.js";
 import { spawn } from "node:child_process";
 import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { dirname, join } from "node:path";
 import { stripVTControlCharacters } from "node:util";
 import chalk from "chalk";
 import ora from "ora";
 import { buildProxyHealthResponse, createProxyReadinessState, markProxyDrainingForUpdate, markProxyReady, resumeProxyConnections, waitForProxyReadiness, } from "../../proxy/proxyHealth.js";
 import { logger } from "../../utils/logger.js";
 import { applyAllClients, restoreAllClients, } from "../proxy-clients/registry.js";
+import { resolveProxyConfigPath } from "../../proxy/proxyConfig.js";
 import { redactUrlsInText, sanitizeForLog, } from "../../utils/logSanitize.js";
 import { withTimeout } from "../../utils/async/withTimeout.js";
 import { formatUptime, isProcessRunning, StateFileManager, } from "../utils/serverUtils.js";
@@ -2397,6 +2389,8 @@ function registerProxyShutdownHandlers(params) {
         }
         try {
             const { flushOpenTelemetry, shutdownOpenTelemetry } = await import("../../services/server/ai/observability/instrumentation.js");
+            await flushProxyOtelLogs();
+            await shutdownProxyOtelLogs();
             await flushOpenTelemetry();
             await shutdownOpenTelemetry();
         }
@@ -2696,7 +2690,9 @@ async function startProxyRuntime(params) {
         logger.always(`  ${chalk.bold("Env File:")}   ${chalk.cyan(params.loadedEnvFile)}`);
     }
     if (!isDev) {
-        for (const result of await applyAllClients(url)) {
+        for (const result of await applyAllClients(url, {
+            configPath: params.configPath,
+        })) {
             if (result.error) {
                 // Visible, not debug-level. A client whose config could not be written
                 // will keep talking to its own upstream, which looks like the proxy
@@ -2755,6 +2751,9 @@ async function startProxyRuntime(params) {
  * serving-process exits.
  */
 async function runLaunchdProxySupervisor(argv, spinner) {
+    await loadProxyStartEnv(argv, spinner);
+    initializeProxyOtelLogs("supervisor");
+    routeProxyConsoleToOtel();
     await ensureProxyStartAllowed(spinner);
     const entryScript = process.argv[1];
     if (!entryScript) {
@@ -2868,6 +2867,8 @@ async function runLaunchdProxySupervisor(argv, spinner) {
         updaterSupervisor.stop();
         await rollingServer.close();
         await flushProxyLifecycleEvents().catch((error) => logger.warn(String(error)));
+        await flushProxyOtelLogs().catch(() => undefined);
+        await shutdownProxyOtelLogs().catch(() => undefined);
         const supervisorState = loadProxySupervisorState();
         if (supervisorState?.pid === process.pid) {
             clearProxySupervisorState();
@@ -2948,14 +2949,14 @@ async function startProxyCommandHandler(argv) {
             env: baseEnv,
         });
         const loadedEnvFile = await loadProxyStartEnv(argv, spinner);
+        initializeProxyOtelLogs("worker");
+        routeProxyConsoleToOtel();
         // Reuse upstream TCP connections (longer keep-alive + bounded pool) instead
         // of opening a new flow per request — cuts outbound flow churn through host
         // content-filters. Runs once, after env load so it can be tuned via env.
         configureProxyKeepAliveDispatcher();
         const { neurolink, logsDir } = await createProxyNeurolinkRuntime(devPaths?.logsDir);
-        const configPath = argv.config
-            ? resolve(argv.config)
-            : join(homedir(), ".neurolink", "proxy-config.yaml");
+        const configPath = resolveProxyConfigPath(argv.config);
         const runtimeConfigStore = await ProxyRuntimeConfigStore.create({
             configPath,
             configRequired: Boolean(argv.config),
@@ -3012,6 +3013,7 @@ async function startProxyCommandHandler(argv) {
             passthrough,
             logsDir,
             runtimeConfigStore,
+            configPath,
         });
     }
     catch (error) {
@@ -3590,7 +3592,9 @@ export const proxyGuardCommand = {
             default: true,
         });
     },
-    handler: async (argv) => {
+    handler: withProxyOtelLogShutdown(async (argv) => {
+        initializeProxyOtelLogs("updater");
+        routeProxyConsoleToOtel();
         const host = argv.host ?? "127.0.0.1";
         const port = argv.port ?? 55669;
         const parentPid = Number(argv.parentPid);
@@ -3914,6 +3918,8 @@ export const proxyGuardCommand = {
                     logger.always(`[updater] update successful: now running ${result.latestVersion}`);
                     persistUpdaterState("record successful update", () => recordSuccessfulUpdate(result.latestVersion));
                     // The replacement proxy starts a worker running the new version.
+                    await flushProxyOtelLogs().catch(() => undefined);
+                    await shutdownProxyOtelLogs().catch(() => undefined);
                     process.exit(0);
                 }
                 else {
@@ -4081,7 +4087,7 @@ export const proxyGuardCommand = {
         if (cleared && !argv.quiet) {
             logger.always(`[proxy] fail-open guard removed stale ${expectedBaseUrl} from Claude settings`);
         }
-    },
+    }),
 };
 // =============================================================================
 // PROXY SETUP COMMAND
@@ -4174,7 +4180,9 @@ export const proxySetupCommand = {
             const nextStep = stepNum + 1;
             console.info(chalk.blue(`\nStep ${nextStep}:`) + " Configuring Claude Code...");
             const url = `http://127.0.0.1:${port}`;
-            for (const result of await applyAllClients(url)) {
+            for (const result of await applyAllClients(url, {
+                configPath: resolveProxyConfigPath(argv.config),
+            })) {
                 if (result.error) {
                     console.info(chalk.yellow(`  ⚠ Could not auto-configure ${result.displayName}: ${result.error.message}`));
                     // Claude Code is the one client whose manual fallback is a single
@@ -4253,7 +4261,7 @@ function buildLaunchdPath() {
     }
     return [...segments].join(":");
 }
-function buildPlist(port, host, envFile, configFile) {
+export function buildProxyLaunchdPlist(port, host, envFile, configFile) {
     // The plist invokes the trampoline script (a tiny shell wrapper at
     // ~/.neurolink/bin/neurolink-proxy) which re-resolves the real
     // `neurolink` binary via PATH on every launch.  This way, launchd
@@ -4269,6 +4277,20 @@ function buildPlist(port, host, envFile, configFile) {
     <string>--config</string>
     <string>${escapeXml(configFile)}</string>`
         : "";
+    const otelEnvironment = isProxyOtelOnly()
+        ? [
+            "NEUROLINK_PROXY_LOG_SINK",
+            "OTEL_EXPORTER_OTLP_ENDPOINT",
+            "OTEL_EXPORTER_OTLP_LOGS_ENDPOINT",
+            "OTEL_EXPORTER_OTLP_HEADERS",
+            "OTEL_EXPORTER_OTLP_LOGS_HEADERS",
+            "OTEL_SERVICE_NAME",
+            "NEUROLINK_PROXY_SESSION_SECRET",
+        ]
+            .filter((name) => process.env[name] !== undefined)
+            .map((name) => `    <key>${name}</key>\n    <string>${escapeXml(process.env[name])}</string>`)
+            .join("\n")
+        : "";
     return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
   "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -4307,10 +4329,10 @@ ${configArgs}
   <integer>45</integer>
 
   <key>StandardOutPath</key>
-  <string>${join(homedir(), ".neurolink", "logs", "proxy-launchd-stdout.log")}</string>
+  <string>${isProxyOtelOnly() ? "/dev/null" : join(homedir(), ".neurolink", "logs", "proxy-launchd-stdout.log")}</string>
 
   <key>StandardErrorPath</key>
-  <string>${join(homedir(), ".neurolink", "logs", "proxy-launchd-stderr.log")}</string>
+  <string>${isProxyOtelOnly() ? "/dev/null" : join(homedir(), ".neurolink", "logs", "proxy-launchd-stderr.log")}</string>
 
   <key>EnvironmentVariables</key>
   <dict>
@@ -4318,6 +4340,7 @@ ${configArgs}
     <string>${buildLaunchdPath()}</string>
     <key>HOME</key>
     <string>${homedir()}</string>
+${otelEnvironment}
   </dict>
 </dict>
 </plist>`;
@@ -4358,15 +4381,13 @@ export const proxyInstallCommand = {
             console.info(chalk.yellow("On Linux, use systemd. On Windows, use Task Scheduler."));
             process.exit(1);
         }
-        const { writeFileSync, mkdirSync, existsSync } = await import("fs");
+        const { mkdirSync, existsSync, chmodSync } = await import("fs");
         const envResolution = resolveProxyEnvFile({
             explicitEnvFile: argv.envFile,
         });
         const envFile = envResolution.path;
         const explicitConfig = argv.config;
-        const configPath = explicitConfig
-            ? resolve(explicitConfig)
-            : join(homedir(), ".neurolink", "proxy-config.yaml");
+        const configPath = resolveProxyConfigPath(explicitConfig);
         if (explicitConfig && !existsSync(configPath)) {
             console.info(chalk.red(`Proxy config file not found: ${configPath}`));
             process.exit(1);
@@ -4376,8 +4397,9 @@ export const proxyInstallCommand = {
             console.info(chalk.red(`Proxy env file not found: ${envFile}`));
             process.exit(1);
         }
+        await loadProxyEnvFile({ explicitEnvFile: envFile });
         const logsDir = join(homedir(), ".neurolink", "logs");
-        if (!existsSync(logsDir)) {
+        if (!isProxyOtelOnly() && !existsSync(logsDir)) {
             mkdirSync(logsDir, { recursive: true });
         }
         if (!existsSync(PLIST_DIR)) {
@@ -4401,8 +4423,9 @@ export const proxyInstallCommand = {
             process.exit(1);
         }
         console.info(chalk.green(`✓ Trampoline validated (resolves to neurolink v${trampolineVersion})`));
-        const plist = buildPlist(port, host, envFile, configFile);
-        writeFileSync(PLIST_PATH, plist, "utf-8");
+        const plist = buildProxyLaunchdPlist(port, host, envFile, configFile);
+        await writeFileAtomic(PLIST_PATH, plist, 0o600);
+        chmodSync(PLIST_PATH, 0o600);
         console.info(chalk.green(`✓ Plist written to ${PLIST_PATH}`));
         if (envFile) {
             console.info(chalk.green(`✓ Proxy env file: ${envFile}`));

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

@@ -0,0 +1,45 @@
+/**
+ * Grok Build client configurator.
+ *
+ * Grok Build (`grok`, xAI's terminal agent) is a Codex-shaped TOML client
+ * that speaks three wire formats. Built-in `grok-4.6` / `grok-4.5` stay on
+ * xAI (`cli-chat-proxy.grok.com`, Responses API, 500k window). This writer
+ * does not remap those. It adds the proxy's advertised catalog as extra
+ * picker entries so Grok can send Claude traffic through `/v1/messages`
+ * (passthrough) and Gemini/OpenAI traffic through `/v1/chat/completions`
+ * (translation), each with a `context_window` that Grok's own compaction
+ * will honour — the proxy does not truncate.
+ *
+ * Snapshot lives in `~/.neurolink/`, following Codex, never inside
+ * `config.toml`. Grok's TOML parser is not a closed schema, but putting
+ * bookkeeping keys in the user's file is how OpenCode was bricked, and new
+ * writers do not rely on tolerance.
+ *
+ * Adaptive thinking: Grok's global `default_reasoning_effort = "xhigh"`
+ * becomes Anthropic `thinking.type = "adaptive"`. Haiku 4.5 rejects that
+ * with 400. Only Claude Opus/Sonnet 4.6 and 5.x keep reasoning enabled.
+ */
+import type { CliGrokProxyModelSpec, CliProxyClientApplyOptions, CliProxyClientConfigurator, ModelMapping } from "../../types/index.js";
+declare function getGrokConfigDir(): string;
+declare function getGrokConfigPath(): string;
+declare function getGrokSnapshotPath(): string;
+declare function classifyGrokProxyModel(id: string, mapping?: ModelMapping): CliGrokProxyModelSpec;
+declare function loadRoutedModelIds(configPath?: string): Promise<string[]>;
+declare function catalogModelIds(configPath?: string): Promise<string[]>;
+declare function buildGrokManagedBlock(baseUrl: string, configPath?: string): Promise<string>;
+export declare function setGrokProxySettings(baseUrl: string, options?: CliProxyClientApplyOptions): Promise<boolean>;
+export declare function clearGrokProxySettings(expectedBaseUrl?: string): Promise<boolean>;
+export declare const grokConfigurator: CliProxyClientConfigurator;
+/** Test-only export (CLAUDE.md rule 15 determinism exception). See openCode.ts. */
+export declare const __grokTestHooks: {
+    getGrokConfigDir: typeof getGrokConfigDir;
+    getGrokConfigPath: typeof getGrokConfigPath;
+    getGrokSnapshotPath: typeof getGrokSnapshotPath;
+    setGrokProxySettings: typeof setGrokProxySettings;
+    clearGrokProxySettings: typeof clearGrokProxySettings;
+    classifyGrokProxyModel: typeof classifyGrokProxyModel;
+    loadRoutedModelIds: typeof loadRoutedModelIds;
+    catalogModelIds: typeof catalogModelIds;
+    buildGrokManagedBlock: typeof buildGrokManagedBlock;
+};
+export {};

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

@@ -0,0 +1,342 @@
+/**
+ * Grok Build client configurator.
+ *
+ * Grok Build (`grok`, xAI's terminal agent) is a Codex-shaped TOML client
+ * that speaks three wire formats. Built-in `grok-4.6` / `grok-4.5` stay on
+ * xAI (`cli-chat-proxy.grok.com`, Responses API, 500k window). This writer
+ * does not remap those. It adds the proxy's advertised catalog as extra
+ * picker entries so Grok can send Claude traffic through `/v1/messages`
+ * (passthrough) and Gemini/OpenAI traffic through `/v1/chat/completions`
+ * (translation), each with a `context_window` that Grok's own compaction
+ * will honour — the proxy does not truncate.
+ *
+ * Snapshot lives in `~/.neurolink/`, following Codex, never inside
+ * `config.toml`. Grok's TOML parser is not a closed schema, but putting
+ * bookkeeping keys in the user's file is how OpenCode was bricked, and new
+ * writers do not rely on tolerance.
+ *
+ * Adaptive thinking: Grok's global `default_reasoning_effort = "xhigh"`
+ * becomes Anthropic `thinking.type = "adaptive"`. Haiku 4.5 rejects that
+ * with 400. Only Claude Opus/Sonnet 4.6 and 5.x keep reasoning enabled.
+ */
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { logger } from "../../utils/logger.js";
+import { getContextWindowSize } from "../../constants/contextWindows.js";
+import { DEFAULT_PROXY_MODEL_IDS } from "../../constants/proxyModels.js";
+import { defaultProxyConfigPath, parseProxyConfigString, } from "../../proxy/proxyConfig.js";
+import { isUsableSnapshot, shouldCaptureSnapshot, writeFileAtomic, } from "./snapshot.js";
+const GROK_BLOCK_BEGIN = "# >>> neurolink-proxy (managed) >>>";
+const GROK_BLOCK_END = "# <<< neurolink-proxy (managed) <<<";
+const PLACEHOLDER_KEY = "neurolink-proxy";
+const ANTHROPIC_VERSION = "2023-06-01";
+function getGrokConfigDir() {
+    const env = process.env.GROK_HOME;
+    return env !== undefined && env.trim().length > 0
+        ? env.trim()
+        : join(homedir(), ".grok");
+}
+function getGrokConfigPath() {
+    return join(getGrokConfigDir(), "config.toml");
+}
+function getGrokSnapshotPath() {
+    return join(homedir(), ".neurolink", "grok-proxy-snapshot.json");
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function tomlKey(id) {
+    return /^[A-Za-z0-9_-]+$/.test(id) ? id : JSON.stringify(id);
+}
+function displayNameFor(id) {
+    const base = id.replace(/-\d{8}$/, "");
+    const pretty = base
+        .split("-")
+        .map((part) => /^\d/.test(part) ? part : part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ")
+        .replace(/(\d) (\d)/g, "$1.$2");
+    return `${pretty} (NeuroLink)`;
+}
+function providerForModelId(id) {
+    if (id.startsWith("claude-")) {
+        return "anthropic";
+    }
+    if (id.startsWith("gemini-")) {
+        return "vertex";
+    }
+    return "openai";
+}
+function providerFromMapping(provider, fallbackId) {
+    const normalized = provider.trim().toLowerCase();
+    if (normalized === "anthropic" || normalized === "claude") {
+        return "anthropic";
+    }
+    if (normalized === "openai") {
+        return "openai";
+    }
+    if (normalized === "vertex" ||
+        normalized === "google" ||
+        normalized === "google-ai" ||
+        normalized === "gemini") {
+        return "vertex";
+    }
+    return providerForModelId(fallbackId);
+}
+function isMissingFileError(error) {
+    if (!error || typeof error !== "object" || !("code" in error)) {
+        return false;
+    }
+    return error.code === "ENOENT";
+}
+/**
+ * Anthropic `thinking.type = "adaptive"` is what Grok emits for `xhigh`.
+ * Measured: Haiku 4.5 returns 400 "adaptive thinking is not supported".
+ * Opus/Sonnet 4.6 and the 5-series accept it.
+ */
+function supportsAdaptiveThinking(id) {
+    return (/^claude-(opus|sonnet)-4-6$/.test(id) || /^claude-(opus|sonnet)-5/.test(id));
+}
+function classifyGrokProxyModel(id, mapping) {
+    const classifyId = mapping && mapping.to.trim().length > 0 ? mapping.to.trim() : id;
+    const provider = mapping
+        ? providerFromMapping(mapping.provider, classifyId)
+        : providerForModelId(id);
+    const windowProvider = mapping && mapping.provider.trim().length > 0
+        ? mapping.provider.trim()
+        : provider;
+    const apiBackend = provider === "anthropic" ? "messages" : "chat_completions";
+    const contextWindow = getContextWindowSize(windowProvider, classifyId);
+    return {
+        id,
+        name: displayNameFor(id),
+        apiBackend,
+        contextWindow,
+        maxCompletionTokens: contextWindow >= 1_000_000 ? 16_384 : 8_192,
+        supportsReasoningEffort: supportsAdaptiveThinking(classifyId),
+    };
+}
+async function loadRoutedMappings(configPath) {
+    const resolvedPath = configPath ?? defaultProxyConfigPath();
+    try {
+        const config = await parseProxyConfigString(readFileSync(resolvedPath, "utf8"));
+        return (config.routing?.modelMappings ?? []).filter((mapping) => mapping.from.trim().length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+async function loadRoutedModelIds(configPath) {
+    return (await loadRoutedMappings(configPath)).map((mapping) => mapping.from.trim());
+}
+async function catalogGrokSpecs(configPath) {
+    const seen = new Set();
+    const specs = [];
+    const routed = await loadRoutedMappings(configPath);
+    const routedByFrom = new Map(routed.map((mapping) => [mapping.from.trim(), mapping]));
+    for (const id of [
+        ...DEFAULT_PROXY_MODEL_IDS,
+        ...routed.map((mapping) => mapping.from.trim()),
+    ]) {
+        if (id.startsWith("grok-") || seen.has(id)) {
+            continue;
+        }
+        seen.add(id);
+        specs.push(classifyGrokProxyModel(id, routedByFrom.get(id)));
+    }
+    return specs;
+}
+async function catalogModelIds(configPath) {
+    return (await catalogGrokSpecs(configPath)).map((spec) => spec.id);
+}
+function buildGrokModelBlock(spec, baseUrl) {
+    const lines = [
+        `[model.${tomlKey(spec.id)}]`,
+        `model = ${JSON.stringify(spec.id)}`,
+        `name = ${JSON.stringify(spec.name)}`,
+        `base_url = ${JSON.stringify(baseUrl)}`,
+        `api_backend = ${JSON.stringify(spec.apiBackend)}`,
+        `context_window = ${spec.contextWindow}`,
+        `auto_compact_threshold_percent = 80`,
+        `max_completion_tokens = ${spec.maxCompletionTokens}`,
+        `supports_backend_search = false`,
+    ];
+    if (!spec.supportsReasoningEffort) {
+        lines.push("supports_reasoning_effort = false");
+    }
+    if (spec.apiBackend === "messages") {
+        lines.push(`extra_headers = { "x-api-key" = ${JSON.stringify(PLACEHOLDER_KEY)}, "anthropic-version" = ${JSON.stringify(ANTHROPIC_VERSION)} }`);
+    }
+    else {
+        lines.push(`api_key = ${JSON.stringify(PLACEHOLDER_KEY)}`);
+    }
+    return lines.join("\n");
+}
+async function buildGrokManagedBlock(baseUrl, configPath) {
+    const specs = await catalogGrokSpecs(configPath);
+    const body = specs
+        .map((spec) => buildGrokModelBlock(spec, baseUrl))
+        .join("\n\n");
+    return [
+        GROK_BLOCK_BEGIN,
+        "# Proxy catalog. Built-in grok-4.6 / grok-4.5 stay on xAI.",
+        "# context_window is Grok's compaction limit and must be <= upstream.",
+        "",
+        body,
+        GROK_BLOCK_END,
+        "",
+    ].join("\n");
+}
+function stripGrokManagedBlock(text) {
+    const blockRe = new RegExp(`\\n?${escapeRegExp(GROK_BLOCK_BEGIN)}[\\s\\S]*?${escapeRegExp(GROK_BLOCK_END)}\\n?`, "g");
+    return text.replace(blockRe, "\n");
+}
+function extractManagedBaseUrl(text) {
+    const match = text.match(new RegExp(`${escapeRegExp(GROK_BLOCK_BEGIN)}[\\s\\S]*?base_url\\s*=\\s*"([^"]*)"`));
+    return match?.[1];
+}
+async function readGrokSnapshot() {
+    const fs = await import("fs");
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(getGrokSnapshotPath(), "utf8"));
+    }
+    catch {
+        return null;
+    }
+    if (!isUsableSnapshot(parsed, "originalExisted")) {
+        logger.debug("[proxy] Grok: ignoring a malformed snapshot rather than treating it as empty");
+        return null;
+    }
+    const record = parsed;
+    const originalExisted = record.originalExisted;
+    const writtenBaseUrl = record.writtenBaseUrl;
+    if (typeof originalExisted !== "boolean") {
+        return null;
+    }
+    if (typeof writtenBaseUrl !== "string") {
+        return null;
+    }
+    return { originalExisted, writtenBaseUrl };
+}
+export async function setGrokProxySettings(baseUrl, options) {
+    const fs = await import("fs");
+    try {
+        fs.accessSync(getGrokConfigDir());
+    }
+    catch {
+        return false;
+    }
+    let original;
+    try {
+        original = fs.readFileSync(getGrokConfigPath(), "utf8");
+    }
+    catch (error) {
+        if (!isMissingFileError(error)) {
+            logger.warn("[proxy] Grok: unable to read config.toml; leaving it untouched");
+            return false;
+        }
+        original = null;
+    }
+    const existingSnapshot = await readGrokSnapshot();
+    if (existingSnapshot === null && fs.existsSync(getGrokSnapshotPath())) {
+        logger.warn("[proxy] Grok: snapshot file is unreadable; leaving config.toml untouched rather than overwriting with no way back");
+        return false;
+    }
+    const currentBlock = original
+        ? original.includes(GROK_BLOCK_BEGIN)
+            ? original.slice(original.indexOf(GROK_BLOCK_BEGIN), original.indexOf(GROK_BLOCK_END) === -1
+                ? original.length
+                : original.indexOf(GROK_BLOCK_END) + GROK_BLOCK_END.length)
+            : undefined
+        : undefined;
+    if (existingSnapshot === null ||
+        shouldCaptureSnapshot({
+            hasSnapshot: existingSnapshot !== null,
+            written: existingSnapshot?.writtenBaseUrl,
+            current: extractManagedBaseUrl(original ?? "") ?? currentBlock,
+        })) {
+        fs.mkdirSync(join(homedir(), ".neurolink"), { recursive: true });
+        await writeFileAtomic(getGrokSnapshotPath(), JSON.stringify({
+            originalExisted: existingSnapshot?.originalExisted ?? original !== null,
+            writtenBaseUrl: baseUrl,
+        }, null, 2), 0o600);
+    }
+    const withoutBlock = original ? stripGrokManagedBlock(original) : "";
+    const trimmed = withoutBlock.replace(/\s*$/, "\n");
+    const next = `${trimmed}\n${await buildGrokManagedBlock(baseUrl, options?.configPath)}`;
+    await writeFileAtomic(getGrokConfigPath(), next.startsWith("\n") && original === null
+        ? next.replace(/^\n+/, "")
+        : next, original === null ? 0o600 : undefined);
+    return true;
+}
+export async function clearGrokProxySettings(expectedBaseUrl) {
+    const fs = await import("fs");
+    let current;
+    try {
+        current = fs.readFileSync(getGrokConfigPath(), "utf8");
+    }
+    catch {
+        return false;
+    }
+    if (!current.includes(GROK_BLOCK_BEGIN)) {
+        return false;
+    }
+    const configuredUrl = extractManagedBaseUrl(current);
+    if (expectedBaseUrl &&
+        configuredUrl !== undefined &&
+        configuredUrl !== expectedBaseUrl) {
+        logger.debug("[proxy] Grok clear: base URL is not the one we wrote, leaving it intact");
+        return false;
+    }
+    const snapshot = await readGrokSnapshot();
+    if (snapshot === null) {
+        logger.warn("[proxy] Grok clear: no usable snapshot, leaving config.toml untouched rather than stripping a block we cannot prove we own");
+        return false;
+    }
+    const remainder = stripGrokManagedBlock(current).replace(/\s*$/, "\n");
+    if (!snapshot.originalExisted && remainder.trim().length === 0) {
+        fs.rmSync(getGrokConfigPath(), { force: true });
+    }
+    else {
+        await writeFileAtomic(getGrokConfigPath(), remainder);
+    }
+    try {
+        fs.rmSync(getGrokSnapshotPath(), { force: true });
+    }
+    catch {
+        // next apply overwrites
+    }
+    return true;
+}
+export const grokConfigurator = {
+    id: "grok",
+    displayName: "Grok Build",
+    detect: async () => {
+        const fs = await import("fs");
+        try {
+            fs.accessSync(getGrokConfigDir());
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+    // Grok appends `/messages` or `/chat/completions` to `base_url`, so it
+    // takes the `/v1` door rather than the proxy root.
+    apply: (proxyBaseUrl, options) => setGrokProxySettings(`${proxyBaseUrl}/v1`, options),
+    restore: (proxyBaseUrl) => clearGrokProxySettings(`${proxyBaseUrl}/v1`),
+};
+/** Test-only export (CLAUDE.md rule 15 determinism exception). See openCode.ts. */
+export const __grokTestHooks = {
+    getGrokConfigDir,
+    getGrokConfigPath,
+    getGrokSnapshotPath,
+    setGrokProxySettings,
+    clearGrokProxySettings,
+    classifyGrokProxyModel,
+    loadRoutedModelIds,
+    catalogModelIds,
+    buildGrokManagedBlock,
+};
+//# sourceMappingURL=grok.js.map

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

@@ -1,4 +1,4 @@
-import type { CliProxyClientApplyResult, CliProxyClientConfigurator, CliProxyClientRestoreResult } from "../../types/index.js";
+import type { CliProxyClientApplyOptions, CliProxyClientApplyResult, CliProxyClientConfigurator, CliProxyClientRestoreResult } from "../../types/index.js";
 /**
  * Every CLI the proxy auto-configures, in apply order.
  *
@@ -14,6 +14,6 @@ export declare const PROXY_CLIENT_CONFIGURATORS: readonly CliProxyClientConfigur
  * how loudly to report — the daemon-start path logs failures at debug level
  * while the setup wizard prints a visible warning.
  */
-export declare function applyAllClients(proxyBaseUrl: string): Promise<CliProxyClientApplyResult[]>;
+export declare function applyAllClients(proxyBaseUrl: string, options?: CliProxyClientApplyOptions): Promise<CliProxyClientApplyResult[]>;
 /** Restore every client's previous configuration. See applyAllClients. */
 export declare function restoreAllClients(proxyBaseUrl: string): Promise<CliProxyClientRestoreResult[]>;

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

@@ -5,6 +5,7 @@ import { codexConfigurator } from "./codex.js";
 import { qwenCodeConfigurator } from "./qwenCode.js";
 import { copilotConfigurator } from "./copilot.js";
 import { geminiConfigurator } from "./gemini.js";
+import { grokConfigurator } from "./grok.js";
 /**
  * Every CLI the proxy auto-configures, in apply order.
  *
@@ -18,6 +19,7 @@ export const PROXY_CLIENT_CONFIGURATORS = [
     qwenCodeConfigurator,
     copilotConfigurator,
     geminiConfigurator,
+    grokConfigurator,
 ];
 /**
  * Point every detected client at the proxy.
@@ -27,12 +29,12 @@ export const PROXY_CLIENT_CONFIGURATORS = [
  * how loudly to report — the daemon-start path logs failures at debug level
  * while the setup wizard prints a visible warning.
  */
-export async function applyAllClients(proxyBaseUrl) {
+export async function applyAllClients(proxyBaseUrl, options) {
     const results = [];
     for (const client of PROXY_CLIENT_CONFIGURATORS) {
         try {
             const applied = (await client.detect())
-                ? await client.apply(proxyBaseUrl)
+                ? await client.apply(proxyBaseUrl, options)
                 : false;
             // Only ask for a note when something was actually written: a note on a
             // client that was skipped would read as an instruction to act on a