@juspay/neurolink 12.29.2 → 12.30.1

package/dist/cli/factories/commandFactory.js

@@ -171,7 +171,8 @@ export class CLICommandFactory {
         "transcribe-audio": {
             type: "boolean",
             default: false,
-            description: "Extract and transcribe audio from video",
+            description: "Transcribe the video's spoken audio (needs ffmpeg and OPENAI_API_KEY). " +
+                "Unnecessary for Gemini, which hears the clip directly",
         },
         file: {
             type: "string",

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

@@ -8,6 +8,7 @@ import { homedir } from "os";
 import { join } from "path";
 import { logger } from "../../utils/logger.js";
 import { writeFileAtomic } from "./snapshot.js";
+import { dottedTableIds, findDuplicateTable, ownedLineCount, readStringValue, splitTomlSections, } from "./tomlSections.js";
 //
 // Points the Codex CLI at the proxy by managing `~/.codex/config.toml`:
 //   - appends a marker-delimited `[model_providers.neurolink]` table
@@ -28,18 +29,67 @@ function getCodexSnapshotPath() {
 }
 const CODEX_BLOCK_BEGIN = "# >>> neurolink-proxy (managed) >>>";
 const CODEX_BLOCK_END = "# <<< neurolink-proxy (managed) <<<";
+const CODEX_MANAGED_COMMENT_LINES = new Set([
+    CODEX_BLOCK_BEGIN,
+    CODEX_BLOCK_END,
+]);
+const CODEX_PROVIDER_ID = "neurolink";
+const CODEX_PROVIDER_NAME = "NeuroLink Proxy";
 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;
+const CODEX_MANAGED_SELECTOR_RE = /^[ \t]*model_provider[ \t]*=[ \t]*"neurolink"[ \t]*$\n?/m;
+/**
+ * What of a Codex config.toml the proxy owns, found by content rather than
+ * by the block markers. Codex's own saves keep comments (measured on
+ * codex-cli 0.155.1), but a hand edit or another tool need not, and a
+ * marker-only writer then appended a second `[model_providers.neurolink]`,
+ * which Codex cannot parse. The proxy's provider is that table carrying the
+ * name the proxy writes, with any sub-tables under it. `foreign` is set when
+ * a `neurolink` provider exists that the proxy did not write: another name, a
+ * dotted-key or array definition, or sub-tables with no provider table, which
+ * the proxy never writes. Writing ours beside it would declare the table twice
+ * or adopt the user's keys. `remainder` keeps every byte the proxy does not
+ * own, including comments the user wrote after its table.
+ */
+function inspectCodexConfig(text) {
+    const sections = splitTomlSections(text);
+    const isProvider = (section) => section.path !== null &&
+        section.path.length >= 2 &&
+        section.path[0] === "model_providers" &&
+        section.path[1] === CODEX_PROVIDER_ID;
+    const tables = sections.filter((section) => isProvider(section) && !section.arrayTable && section.path?.length === 2);
+    const ours = (section) => readStringValue(section, "name") === CODEX_PROVIDER_NAME;
+    const foreign = tables.some((table) => !ours(table)) ||
+        (tables.length === 0 && sections.some(isProvider)) ||
+        sections.some((section) => isProvider(section) && section.arrayTable) ||
+        dottedTableIds(sections, "model_providers").includes(CODEX_PROVIDER_ID);
+    const owned = sections.map((section) => isProvider(section) &&
+        !section.arrayTable &&
+        (section.path?.length === 2 ? ours(section) : !foreign));
+    const managedBaseUrls = [
+        ...new Set(sections.flatMap((section, index) => {
+            const url = owned[index]
+                ? readStringValue(section, "base_url")
+                : undefined;
+            return url === undefined ? [] : [url];
+        })),
+    ];
+    const remainder = sections
+        .flatMap((section, index) => owned[index]
+        ? section.lines.slice(ownedLineCount(section, CODEX_MANAGED_COMMENT_LINES))
+        : section.lines)
+        .filter((line) => !CODEX_MANAGED_COMMENT_LINES.has(line.trim()))
+        .join("");
+    return { remainder, managedBaseUrls, foreign };
 }
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/**
+ * Remove the selector the proxy injected. Only the preamble holds top-level
+ * keys: a profile's own `model_provider = "neurolink"` is the user's.
+ */
+function stripCodexSelector(text) {
+    return editTomlPreamble(text, (preamble) => CODEX_MANAGED_SELECTOR_RE.test(preamble)
+        ? preamble.replace(CODEX_MANAGED_SELECTOR_RE, "")
+        : null);
 }
 /**
  * Apply a top-level TOML key edit, confined to the document preamble.
@@ -60,8 +110,8 @@ function editTomlPreamble(text, edit) {
 function buildCodexProviderBlock(baseUrl) {
     return [
         CODEX_BLOCK_BEGIN,
-        "[model_providers.neurolink]",
-        'name = "NeuroLink Proxy"',
+        `[model_providers.${CODEX_PROVIDER_ID}]`,
+        `name = "${CODEX_PROVIDER_NAME}"`,
         `base_url = "${baseUrl}/backend-api/codex"`,
         'wire_api = "responses"',
         "requires_openai_auth = true",
@@ -77,6 +127,37 @@ export async function setCodexProxySettings(baseUrl) {
             return false;
         }
         const original = fs.readFileSync(getCodexConfigPath(), "utf8");
+        const inspected = inspectCodexConfig(original);
+        if (inspected.foreign) {
+            logger.warn("[proxy] Codex: config.toml already defines a neurolink provider the proxy did not write; leaving it untouched");
+            return false;
+        }
+        let text = stripCodexSelector(inspected.remainder);
+        // 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 next = `${text.replace(/\s*$/, "\n")}\n${buildCodexProviderBlock(baseUrl)}`;
+        // Codex will not load a config that declares a table twice. Writing into
+        // one would only bury the user's own error under ours.
+        const duplicate = findDuplicateTable(next);
+        if (duplicate !== undefined) {
+            logger.warn(`[proxy] Codex: config.toml declares [${duplicate}] more than once; leaving it untouched`);
+            return false;
+        }
         // 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
@@ -95,26 +176,11 @@ export async function setCodexProxySettings(baseUrl) {
             fs.mkdirSync(join(homedir(), ".neurolink"), { recursive: true });
             await writeFileAtomic(getCodexSnapshotPath(), JSON.stringify({ originalProviderLine }, null, 2), 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}`;
+        // Every proxy start applies. Rewriting a file that already matches only
+        // widens the window for racing Codex's own saves.
+        if (next !== original) {
+            await writeFileAtomic(getCodexConfigPath(), next);
         }
-        const trimmed = text.replace(/\s*$/, "\n");
-        await writeFileAtomic(getCodexConfigPath(), `${trimmed}\n${buildCodexProviderBlock(baseUrl)}`);
         return true;
     }
     catch (error) {
@@ -129,19 +195,23 @@ export async function clearCodexProxySettings(expectedBaseUrl) {
             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;
-            }
+        const inspected = inspectCodexConfig(original);
+        // Apply refuses such a config, so the selector pointing at the user's own
+        // provider is theirs as well.
+        if (inspected.foreign) {
+            return false;
+        }
+        // The managed table records its owner in `base_url`. Without this check a
+        // second proxy shutting down on another port would strip the table 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 &&
+            inspected.managedBaseUrls.length > 0 &&
+            !inspected.managedBaseUrls.includes(`${expectedBaseUrl}/backend-api/codex`)) {
+            return false;
         }
-        let text = stripCodexManagedConfig(original);
+        let text = stripCodexSelector(inspected.remainder);
         // Restore the user's original selector line if we snapshotted one.
         let restored = null;
         if (fs.existsSync(getCodexSnapshotPath())) {

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

@@ -18,6 +18,16 @@
  * 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.
+ *
+ * Ownership is decided by content, never by the block markers alone. Grok
+ * rewrites config.toml on its own saves (`/settings`, `grok mcp add`, ...)
+ * through a serializer that drops every comment, the markers included, and
+ * splits the inline `extra_headers` into a `[model.<id>.extra_headers]`
+ * sub-table (measured on Grok Build 1.0.40). A marker-only writer then kept
+ * the unmarked tables and appended a second copy of every id on the next
+ * proxy start, and TOML rejects a table declared twice, so Grok would not
+ * start. What marks an entry as ours is the placeholder key, a credential
+ * only the proxy accepts, and that survives Grok's rewrite.
  */
 import type { CliGrokProxyModelSpec, CliProxyClientApplyOptions, CliProxyClientConfigurator, ModelMapping } from "../../types/index.js";
 declare function getGrokConfigDir(): string;
@@ -26,7 +36,11 @@ 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>;
+/**
+ * `userModelIds` are ids the user defines themselves. Writing the proxy's
+ * entry beside theirs would declare the table twice, so theirs wins.
+ */
+declare function buildGrokManagedBlock(baseUrl: string, configPath?: string, userModelIds?: ReadonlySet<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;

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

@@ -18,6 +18,16 @@
  * 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.
+ *
+ * Ownership is decided by content, never by the block markers alone. Grok
+ * rewrites config.toml on its own saves (`/settings`, `grok mcp add`, ...)
+ * through a serializer that drops every comment, the markers included, and
+ * splits the inline `extra_headers` into a `[model.<id>.extra_headers]`
+ * sub-table (measured on Grok Build 1.0.40). A marker-only writer then kept
+ * the unmarked tables and appended a second copy of every id on the next
+ * proxy start, and TOML rejects a table declared twice, so Grok would not
+ * start. What marks an entry as ours is the placeholder key, a credential
+ * only the proxy accepts, and that survives Grok's rewrite.
  */
 import { readFileSync } from "fs";
 import { homedir } from "os";
@@ -26,9 +36,19 @@ 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";
+import { isUsableSnapshot, resolveSymlinkTarget, shouldCaptureSnapshot, writeFileAtomic, } from "./snapshot.js";
+import { dottedTableIds, findDuplicateTable, inlineTablePairs, maskTomlStrings, maskedStringValue, ownedLineCount, parseMaskedAssignment, readStringValue, splitTomlSections, tomlCodeLines, } from "./tomlSections.js";
 const GROK_BLOCK_BEGIN = "# >>> neurolink-proxy (managed) >>>";
 const GROK_BLOCK_END = "# <<< neurolink-proxy (managed) <<<";
+const GROK_BLOCK_NOTES = [
+    "# Proxy catalog. Built-in grok-4.6 / grok-4.5 stay on xAI.",
+    "# context_window is Grok's compaction limit and must be <= upstream.",
+];
+const GROK_MANAGED_COMMENT_LINES = new Set([
+    GROK_BLOCK_BEGIN,
+    GROK_BLOCK_END,
+    ...GROK_BLOCK_NOTES,
+]);
 const PLACEHOLDER_KEY = "neurolink-proxy";
 const ANTHROPIC_VERSION = "2023-06-01";
 function getGrokConfigDir() {
@@ -43,9 +63,6 @@ function getGrokConfigPath() {
 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);
 }
@@ -172,28 +189,148 @@ function buildGrokModelBlock(spec, baseUrl) {
     }
     return lines.join("\n");
 }
-async function buildGrokManagedBlock(baseUrl, configPath) {
-    const specs = await catalogGrokSpecs(configPath);
-    const body = specs
+/**
+ * `userModelIds` are ids the user defines themselves. Writing the proxy's
+ * entry beside theirs would declare the table twice, so theirs wins.
+ */
+async function buildGrokManagedBlock(baseUrl, configPath, userModelIds = new Set()) {
+    const catalog = await catalogGrokSpecs(configPath);
+    for (const spec of catalog) {
+        if (userModelIds.has(spec.id)) {
+            logger.debug(`[proxy] Grok: config.toml already defines [model.${tomlKey(spec.id)}]; keeping it and skipping the proxy's entry`);
+        }
+    }
+    const body = catalog
+        .filter((spec) => !userModelIds.has(spec.id))
         .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.",
+        ...GROK_BLOCK_NOTES,
         "",
         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 modelEntryId(section) {
+    return section.path !== null &&
+        section.path.length >= 2 &&
+        section.path[0] === "model"
+        ? section.path[1]
+        : null;
+}
+/** Where a model entry carries the placeholder key, as a path within it. */
+const PLACEHOLDER_KEY_PATHS = [
+    ["api_key"],
+    ["extra_headers", "x-api-key"],
+];
+function isPlaceholderKey(path, value) {
+    return (value === PLACEHOLDER_KEY &&
+        PLACEHOLDER_KEY_PATHS.some((keyPath) => keyPath.length === path.length &&
+            keyPath.every((part, index) => path[index] === part)));
+}
+/**
+ * Whether a section of a model entry sends the placeholder key: `api_key` on
+ * the model, or `x-api-key` in its `extra_headers`, spelled as a plain key, a
+ * dotted key, an inline table or the sub-table Grok's own save writes. The
+ * full key path must match, so a user's `legacy.api_key` is not the proxy's.
+ */
+function sectionSendsPlaceholderKey(section) {
+    const prefix = section.path?.slice(2) ?? [];
+    return tomlCodeLines(section).some(({ line, statement }) => {
+        if (!statement) {
+            return false;
+        }
+        const { masked, strings } = maskTomlStrings(line);
+        const assignment = parseMaskedAssignment(masked, strings);
+        if (!assignment) {
+            return false;
+        }
+        const path = [...prefix, ...assignment.path];
+        return (isPlaceholderKey(path, maskedStringValue(assignment.value, strings)) ||
+            inlineTablePairs(assignment.value, strings).some((pair) => isPlaceholderKey([...path, ...pair.path], maskedStringValue(pair.value, strings))));
+    });
 }
-function extractManagedBaseUrl(text) {
-    const match = text.match(new RegExp(`${escapeRegExp(GROK_BLOCK_BEGIN)}[\\s\\S]*?base_url\\s*=\\s*"([^"]*)"`));
-    return match?.[1];
+/**
+ * Which parts of a Grok config.toml the proxy owns.
+ *
+ * A model entry is a `[model.<id>]` table plus its `[model.<id>.*]`
+ * sub-tables, wherever they sit: Grok's save keeps them together, hand edits
+ * need not. It is the proxy's when it sends the placeholder key and is either
+ * in the current catalog or still carries the exact name the proxy gave it,
+ * which covers entries a later catalog dropped. A user's own model behind the
+ * proxy, under their own name, is theirs. Keys and values are read as TOML,
+ * never as raw text, so a string that merely mentions the placeholder cannot
+ * make a user's table look like the proxy's. `remainder` is the text with
+ * owned entries and the managed comment lines removed and every other byte
+ * kept, so a missing, orphaned or doubled marker cannot make an apply delete
+ * the user's content or leave an old copy of the catalog behind.
+ */
+function inspectGrokConfig(text, catalogIds) {
+    const sections = splitTomlSections(text);
+    // Models the user defines without a [model.<id>] table of their own.
+    const definedElsewhere = new Set([
+        ...dottedTableIds(sections, "model"),
+        ...sections.flatMap((section) => {
+            const id = section.arrayTable ? modelEntryId(section) : null;
+            return id !== null && section.path?.length === 2 ? [id] : [];
+        }),
+    ]);
+    const ids = sections.map((section) => section.arrayTable ? null : modelEntryId(section));
+    const isModelTable = (index) => ids[index] !== null && sections[index].path?.length === 2;
+    const tableFor = (index) => {
+        if (ids[index] === null || isModelTable(index)) {
+            return index;
+        }
+        const sameModel = (candidate) => isModelTable(candidate) && ids[candidate] === ids[index];
+        const before = sections.findLastIndex((_, candidate) => candidate < index && sameModel(candidate));
+        const after = sections.findIndex((_, candidate) => candidate > index && sameModel(candidate));
+        return before !== -1 ? before : after !== -1 ? after : index;
+    };
+    const entryOf = sections.map((_, index) => tableFor(index));
+    const ownedEntries = new Set(entryOf.filter((entry) => {
+        const id = ids[entry];
+        if (id === null) {
+            return false;
+        }
+        const sendsPlaceholder = sections.some((section, index) => entryOf[index] === entry &&
+            ids[index] !== null &&
+            sectionSendsPlaceholderKey(section));
+        if (!sendsPlaceholder) {
+            return false;
+        }
+        // A sub-table left without its table carries no name to check; it is
+        // the proxy's unless the model is defined some other way.
+        if (!isModelTable(entry)) {
+            return !definedElsewhere.has(id);
+        }
+        return (catalogIds.has(id) ||
+            readStringValue(sections[entry], "name") === displayNameFor(id));
+    }));
+    const owned = sections.map((_, index) => ids[index] !== null && ownedEntries.has(entryOf[index]));
+    const userModelIds = new Set([
+        ...definedElsewhere,
+        ...sections.flatMap((section, index) => {
+            const id = modelEntryId(section);
+            return id !== null && !owned[index] ? [id] : [];
+        }),
+    ]);
+    const managedBaseUrls = [
+        ...new Set(sections.flatMap((section, index) => {
+            const url = owned[index]
+                ? readStringValue(section, "base_url")
+                : undefined;
+            return url === undefined ? [] : [url];
+        })),
+    ];
+    const remainder = sections
+        .flatMap((section, index) => owned[index]
+        ? section.lines.slice(ownedLineCount(section, GROK_MANAGED_COMMENT_LINES))
+        : section.lines)
+        .filter((line) => !GROK_MANAGED_COMMENT_LINES.has(line.trim()))
+        .join("");
+    return { remainder, managedBaseUrls, userModelIds };
 }
 async function readGrokSnapshot() {
     const fs = await import("fs");
@@ -250,11 +387,26 @@ export async function setGrokProxySettings(baseUrl, options) {
                 : original.indexOf(GROK_BLOCK_END) + GROK_BLOCK_END.length)
             : undefined
         : undefined;
+    const inspected = original === null
+        ? null
+        : inspectGrokConfig(original, new Set(await catalogModelIds(options?.configPath)));
+    const block = await buildGrokManagedBlock(baseUrl, options?.configPath, inspected?.userModelIds);
+    const remainder = inspected?.remainder ?? "";
+    const next = remainder.trim().length === 0
+        ? block
+        : `${remainder.replace(/\s*$/, "\n")}\n${block}`;
+    // Grok refuses to load or save a config it cannot parse. Writing into one
+    // would only bury the user's own error under ours.
+    const duplicate = findDuplicateTable(next);
+    if (duplicate !== undefined) {
+        logger.warn(`[proxy] Grok: config.toml declares [${duplicate}] more than once; leaving it untouched`);
+        return false;
+    }
     if (existingSnapshot === null ||
         shouldCaptureSnapshot({
             hasSnapshot: existingSnapshot !== null,
             written: existingSnapshot?.writtenBaseUrl,
-            current: extractManagedBaseUrl(original ?? "") ?? currentBlock,
+            current: inspected?.managedBaseUrls[0] ?? currentBlock,
         })) {
         fs.mkdirSync(join(homedir(), ".neurolink"), { recursive: true });
         await writeFileAtomic(getGrokSnapshotPath(), JSON.stringify({
@@ -262,12 +414,11 @@ export async function setGrokProxySettings(baseUrl, options) {
             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);
+    // Every proxy start applies; an update starts one. Rewriting a file that
+    // already matches only widens the window for racing Grok's own saves.
+    if (next !== original) {
+        await writeFileAtomic(getGrokConfigPath(), next, original === null ? 0o600 : undefined);
+    }
     return true;
 }
 export async function clearGrokProxySettings(expectedBaseUrl) {
@@ -279,13 +430,16 @@ export async function clearGrokProxySettings(expectedBaseUrl) {
     catch {
         return false;
     }
-    if (!current.includes(GROK_BLOCK_BEGIN)) {
+    const inspected = inspectGrokConfig(current, new Set(await catalogModelIds()));
+    if (inspected.remainder === current) {
         return false;
     }
-    const configuredUrl = extractManagedBaseUrl(current);
+    // Another proxy's block is left alone. One entry the user repointed does
+    // not make the rest foreign, whichever entry happens to come first.
+    const configuredUrls = inspected.managedBaseUrls;
     if (expectedBaseUrl &&
-        configuredUrl !== undefined &&
-        configuredUrl !== expectedBaseUrl) {
+        configuredUrls.length > 0 &&
+        !configuredUrls.includes(expectedBaseUrl)) {
         logger.debug("[proxy] Grok clear: base URL is not the one we wrote, leaving it intact");
         return false;
     }
@@ -294,9 +448,13 @@ export async function clearGrokProxySettings(expectedBaseUrl) {
         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");
+    const remainder = inspected.remainder.replace(/\s*$/, "\n");
     if (!snapshot.originalExisted && remainder.trim().length === 0) {
-        fs.rmSync(getGrokConfigPath(), { force: true });
+        // Apply wrote through a symlink the user already had, so the link stays
+        // and the file apply created behind it goes.
+        fs.rmSync(await resolveSymlinkTarget(getGrokConfigPath()), {
+            force: true,
+        });
     }
     else {
         await writeFileAtomic(getGrokConfigPath(), remainder);

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

@@ -63,6 +63,11 @@ export declare function isProxyOwnedValue(args: {
     written: unknown;
     current: unknown;
 }): boolean;
+/**
+ * The path a chain of symlinks finally names, which need not exist. A path
+ * that is not a link comes back unchanged.
+ */
+export declare function resolveSymlinkTarget(filePath: string): Promise<string>;
 /**
  * Replace a file's contents without ever exposing a partial one.
  *
@@ -112,5 +117,12 @@ export declare function isProxyOwnedValue(args: {
  * is NOT atomic. Moving the temp file to `os.tmpdir()` would look like a
  * tidy-up and would quietly restore the exact window this function exists to
  * close, on Windows only, where nobody here would see it.
+ *
+ * A config kept in a dotfiles repository is often a symlink into it, a setup
+ * Grok documents and its own writer honours. A rename over the link would
+ * replace the link with a regular file and leave the repository's copy stale,
+ * so the write lands on the end of the link chain instead, which need not
+ * exist yet. The temp file is that target's sibling, so the rename stays
+ * atomic.
  */
 export declare function writeFileAtomic(filePath: string, contents: string, mode?: number): Promise<void>;

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

@@ -113,6 +113,31 @@ export function isProxyOwnedValue(args) {
     }
     return valuesMatch(args.current, args.written);
 }
+/**
+ * The path a chain of symlinks finally names, which need not exist. A path
+ * that is not a link comes back unchanged.
+ */
+export async function resolveSymlinkTarget(filePath) {
+    const fs = await import("fs");
+    const { dirname, resolve } = await import("path");
+    let target = filePath;
+    for (let hops = 0;; hops += 1) {
+        let isLink;
+        try {
+            isLink = fs.lstatSync(target).isSymbolicLink();
+        }
+        catch {
+            isLink = false;
+        }
+        if (!isLink) {
+            return target;
+        }
+        if (hops === 40) {
+            throw new Error(`${filePath}: too many levels of symbolic links`);
+        }
+        target = resolve(dirname(target), fs.readlinkSync(target));
+    }
+}
 /** Distinguishes concurrent writers within one process. */
 let atomicWriteCounter = 0;
 /**
@@ -164,12 +189,20 @@ let atomicWriteCounter = 0;
  * is NOT atomic. Moving the temp file to `os.tmpdir()` would look like a
  * tidy-up and would quietly restore the exact window this function exists to
  * close, on Windows only, where nobody here would see it.
+ *
+ * A config kept in a dotfiles repository is often a symlink into it, a setup
+ * Grok documents and its own writer honours. A rename over the link would
+ * replace the link with a regular file and leave the repository's copy stale,
+ * so the write lands on the end of the link chain instead, which need not
+ * exist yet. The temp file is that target's sibling, so the rename stays
+ * atomic.
  */
 export async function writeFileAtomic(filePath, contents, mode) {
     const fs = await import("fs");
     const { dirname, join, basename } = await import("path");
+    const target = await resolveSymlinkTarget(filePath);
     atomicWriteCounter += 1;
-    const tempPath = join(dirname(filePath), `.${basename(filePath)}.neurolink-${process.pid}-${atomicWriteCounter}.tmp`);
+    const tempPath = join(dirname(target), `.${basename(target)}.neurolink-${process.pid}-${atomicWriteCounter}.tmp`);
     // Which step failed changes what the user should do about it: a failed write
     // is usually a missing directory or a full disk and the config is untouched,
     // while a failed rename is a locked destination and the config is intact but
@@ -180,7 +213,7 @@ export async function writeFileAtomic(filePath, contents, mode) {
     let effectiveMode = mode;
     if (effectiveMode === undefined) {
         try {
-            effectiveMode = fs.statSync(filePath).mode & 0o777;
+            effectiveMode = fs.statSync(target).mode & 0o777;
         }
         catch {
             effectiveMode = 0o600;
@@ -192,12 +225,12 @@ export async function writeFileAtomic(filePath, contents, mode) {
         // caller sees an ENOENT naming a path it never asked to write. Creating
         // the directory first makes a first-run write behave like the plain
         // writeFileSync it replaced.
-        fs.mkdirSync(dirname(filePath), { recursive: true });
+        fs.mkdirSync(dirname(target), { recursive: true });
         fs.writeFileSync(tempPath, contents, { mode: effectiveMode });
         stage = "chmod";
         fs.chmodSync(tempPath, effectiveMode);
         stage = "rename";
-        fs.renameSync(tempPath, filePath);
+        fs.renameSync(tempPath, target);
     }
     catch (error) {
         // Never leave scratch in the user's config directory.