@zvec/zvec-grep 0.1.5 → 0.1.6

package/dist/cli/install.js

@@ -0,0 +1,845 @@
+import { randomUUID } from "node:crypto";
+import { constants as fileSystemConstants } from "node:fs";
+import { access, chmod, lstat, mkdir, open, readFile, readlink, rename, stat, unlink, } from "node:fs/promises";
+import { homedir } from "node:os";
+import { delimiter, dirname, resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { resolveServerUrl } from "../client/mode-router.js";
+const AGENT_INSTALLERS = [
+    {
+        id: "claude",
+        label: "Claude Code",
+        executable: "claude",
+        install: installClaudeIntegration,
+        uninstall: uninstallClaudeIntegration,
+    },
+    {
+        id: "codex",
+        label: "Codex",
+        executable: "codex",
+        install: installCodexIntegration,
+        uninstall: uninstallCodexIntegration,
+    },
+    {
+        id: "opencode",
+        label: "OpenCode",
+        executable: "opencode",
+        install: installOpenCodeIntegration,
+        uninstall: uninstallOpenCodeIntegration,
+    },
+    {
+        id: "cursor",
+        label: "Cursor",
+        executable: "cursor",
+        install: installCursorIntegration,
+        uninstall: uninstallCursorIntegration,
+    },
+];
+const ZVEC_GREP_CONFIG_START = "# ZVEC_GREP_START";
+const ZVEC_GREP_CONFIG_END = "# ZVEC_GREP_END";
+const ZVEC_GREP_AGENTS_START = "<!-- ZVEC_GREP_START -->";
+const ZVEC_GREP_AGENTS_END = "<!-- ZVEC_GREP_END -->";
+const CLAUDE_MCP_PERMISSION = "mcp__zvec_grep__*";
+const DEFAULT_MCP_TOOL_TIMEOUT_SECONDS = 600;
+export async function runInstall(parsed) {
+    printInstallHeader();
+    const installers = await resolveInstallers(parsed, "install");
+    if (installers.length === 0) {
+        console.log("\nNo agent integrations selected.");
+        return;
+    }
+    console.log("\nInstalling integrations\n");
+    for (const installer of installers) {
+        await installer.install({
+            force: parsed.options.force === true,
+            mcpToolTimeoutSeconds: parsed.options.installMcpToolTimeoutSeconds ??
+                DEFAULT_MCP_TOOL_TIMEOUT_SECONDS,
+            mcpTokenEnv: parsed.options.installMcpTokenEnv,
+        });
+        console.log(`  ${installSuccessMark()} ${installer.label}`);
+        console.log("    MCP       configured");
+        console.log("");
+    }
+    const server = await ensureInstalledServer();
+    if (server.ready) {
+        console.log(`  ${installSuccessMark()} Server`);
+        console.log(`    ready at ${server.serverUrl ?? resolveServerUrl()}`);
+    }
+    else {
+        console.log(`  ${installMutedMark()} Server`);
+        console.log("    not started; run `zg server on`");
+    }
+    console.log("\nzvec-grep is ready\n");
+    console.log(`  Agents       ${installers.map((installer) => installer.label).join(", ")}`);
+    console.log("  Remote data  Authorization requested on first remote use");
+    console.log("\nRestart the selected agents or start a new session to load the integration.");
+}
+export async function runUninstall(parsed) {
+    printInstallHeader();
+    const installers = await resolveInstallers(parsed, "uninstall");
+    if (installers.length === 0) {
+        console.log("\nNo agent integrations selected.");
+        return;
+    }
+    console.log("\nRemoving integrations\n");
+    for (const installer of installers) {
+        await installer.uninstall();
+        console.log(`  ${installSuccessMark()} ${installer.label}`);
+        console.log("    integration removed");
+    }
+    console.log("\nRestart the selected agents or start a new session to apply the change.");
+}
+async function installCodexIntegration(options) {
+    const codexHome = resolveCodexHome();
+    const configPath = resolve(codexHome, "config.toml");
+    const agentsPath = resolve(codexHome, "AGENTS.md");
+    await writeMarkedFile({
+        path: configPath,
+        startMarker: ZVEC_GREP_CONFIG_START,
+        endMarker: ZVEC_GREP_CONFIG_END,
+        block: codexConfigBlock(options.mcpToolTimeoutSeconds, options.mcpTokenEnv),
+        force: options.force,
+        hasConflict: hasCodexMcpServerConfig,
+        conflictMessage: `Existing [mcp_servers.zvec_grep] found in ${configPath}. Re-run with --force after removing or moving that table into the zvec-grep managed block.`,
+        removeConflict: removeCodexMcpServerConfig,
+    });
+    await writeMarkedFile({
+        path: agentsPath,
+        startMarker: ZVEC_GREP_AGENTS_START,
+        endMarker: ZVEC_GREP_AGENTS_END,
+        block: agentGuidanceBlock(),
+        force: true,
+    });
+    return { files: [configPath, agentsPath] };
+}
+async function installClaudeIntegration(options) {
+    const configDirectory = resolveClaudeConfigDirectory();
+    const mcpConfigPath = resolveClaudeMcpConfigPath();
+    const settingsPath = resolve(configDirectory, "settings.json");
+    const guidancePath = resolve(configDirectory, "CLAUDE.md");
+    await updateClaudeMcpConfig({
+        path: mcpConfigPath,
+        force: options.force,
+        tokenEnv: options.mcpTokenEnv,
+    });
+    await updateClaudePermissionSettings(settingsPath, true);
+    await writeMarkedFile({
+        path: guidancePath,
+        startMarker: ZVEC_GREP_AGENTS_START,
+        endMarker: ZVEC_GREP_AGENTS_END,
+        block: agentGuidanceBlock(),
+        force: true,
+    });
+    return { files: [mcpConfigPath, settingsPath, guidancePath] };
+}
+async function uninstallClaudeIntegration() {
+    const configDirectory = resolveClaudeConfigDirectory();
+    const mcpConfigPath = resolveClaudeMcpConfigPath();
+    const settingsPath = resolve(configDirectory, "settings.json");
+    const guidancePath = resolve(configDirectory, "CLAUDE.md");
+    await removeClaudeMcpConfig(mcpConfigPath);
+    await updateClaudePermissionSettings(settingsPath, false);
+    await removeMarkedFile({
+        path: guidancePath,
+        startMarker: ZVEC_GREP_AGENTS_START,
+        endMarker: ZVEC_GREP_AGENTS_END,
+    });
+    return { files: [mcpConfigPath, settingsPath, guidancePath] };
+}
+async function uninstallCodexIntegration() {
+    const codexHome = resolveCodexHome();
+    const configPath = resolve(codexHome, "config.toml");
+    const agentsPath = resolve(codexHome, "AGENTS.md");
+    await removeMarkedFile({
+        path: configPath,
+        startMarker: ZVEC_GREP_CONFIG_START,
+        endMarker: ZVEC_GREP_CONFIG_END,
+    });
+    await removeMarkedFile({
+        path: agentsPath,
+        startMarker: ZVEC_GREP_AGENTS_START,
+        endMarker: ZVEC_GREP_AGENTS_END,
+    });
+    return { files: [configPath, agentsPath] };
+}
+async function installOpenCodeIntegration(options) {
+    const configPath = resolveOpenCodeConfigPath();
+    const guidancePath = resolve(dirname(configPath), "AGENTS.md");
+    await installJsonMcpServer({
+        path: configPath,
+        containerKey: "mcp",
+        server: {
+            type: "remote",
+            url: resolveServerUrl(),
+            enabled: true,
+            timeout: options.mcpToolTimeoutSeconds * 1_000,
+            oauth: false,
+            ...(options.mcpTokenEnv
+                ? {
+                    headers: {
+                        Authorization: `Bearer {env:${options.mcpTokenEnv}}`,
+                    },
+                }
+                : {}),
+        },
+        force: options.force,
+        label: "OpenCode",
+    });
+    await writeMarkedFile({
+        path: guidancePath,
+        startMarker: ZVEC_GREP_AGENTS_START,
+        endMarker: ZVEC_GREP_AGENTS_END,
+        block: agentGuidanceBlock({
+            search: "zvec_grep_zvec_grep_search",
+        }),
+        force: true,
+    });
+    return { files: [configPath, guidancePath] };
+}
+async function uninstallOpenCodeIntegration() {
+    const configPath = resolveOpenCodeConfigPath();
+    const guidancePath = resolve(dirname(configPath), "AGENTS.md");
+    await uninstallJsonMcpServer(configPath, "mcp");
+    await removeMarkedFile({
+        path: guidancePath,
+        startMarker: ZVEC_GREP_AGENTS_START,
+        endMarker: ZVEC_GREP_AGENTS_END,
+    });
+    return { files: [configPath, guidancePath] };
+}
+async function installCursorIntegration(options) {
+    const configPath = resolveCursorConfigPath();
+    await installJsonMcpServer({
+        path: configPath,
+        containerKey: "mcpServers",
+        server: {
+            url: resolveServerUrl(),
+            ...(options.mcpTokenEnv
+                ? {
+                    headers: {
+                        Authorization: `Bearer \${${options.mcpTokenEnv}}`,
+                    },
+                }
+                : {}),
+        },
+        force: options.force,
+        label: "Cursor",
+    });
+    return { files: [configPath] };
+}
+async function uninstallCursorIntegration() {
+    const configPath = resolveCursorConfigPath();
+    await uninstallJsonMcpServer(configPath, "mcpServers");
+    return { files: [configPath] };
+}
+async function resolveInstallers(parsed, action) {
+    const detected = await detectAgentInstallers();
+    const targetTokens = [
+        ...(parsed.options.installTargets ?? []),
+        ...parsed.positionals,
+    ];
+    if (targetTokens.length > 0) {
+        return installersFromTokens(targetTokens, detected);
+    }
+    if (parsed.options.yes === true ||
+        !process.stdin.isTTY ||
+        !process.stdout.isTTY) {
+        return installersFromTokens(["auto"], detected);
+    }
+    return promptInstallers(action, detected);
+}
+async function promptInstallers(action, detected) {
+    console.log(action === "install"
+        ? "\nChoose agent integrations\n"
+        : "\nChoose integrations to remove\n");
+    const selected = await promptInstallerSelection(detected);
+    return AGENT_INSTALLERS.filter((installer) => selected.has(installer.id));
+}
+function installersFromTokens(tokens, detected = new Set()) {
+    const normalized = tokens.flatMap(splitTargetTokens);
+    if (normalized.length === 0) {
+        return installersFromTokens(["auto"], detected);
+    }
+    const selected = new Map();
+    for (const token of normalized) {
+        const input = token.toLowerCase();
+        const lower = input === "cc" || input === "claude-code" ? "claude" : input;
+        if (lower === "none") {
+            return [];
+        }
+        if (lower === "auto") {
+            for (const installer of AGENT_INSTALLERS) {
+                if (detected.has(installer.id)) {
+                    selected.set(installer.id, installer);
+                }
+            }
+            continue;
+        }
+        if (lower === "all") {
+            for (const installer of AGENT_INSTALLERS) {
+                selected.set(installer.id, installer);
+            }
+            continue;
+        }
+        const numbered = /^\d+$/.test(lower) ? Number(lower) : Number.NaN;
+        if (Number.isInteger(numbered) &&
+            numbered >= 1 &&
+            numbered <= AGENT_INSTALLERS.length) {
+            const installer = AGENT_INSTALLERS[numbered - 1];
+            selected.set(installer.id, installer);
+            continue;
+        }
+        const installer = AGENT_INSTALLERS.find((candidate) => candidate.id === lower || candidate.label.toLowerCase() === lower);
+        if (!installer) {
+            throw new Error(`Unknown install target: ${token}`);
+        }
+        selected.set(installer.id, installer);
+    }
+    return [...selected.values()];
+}
+async function detectAgentInstallers() {
+    const detected = new Set();
+    const checks = await Promise.all(AGENT_INSTALLERS.map(async (installer) => ({
+        installer,
+        available: await executableIsAvailable(installer.executable),
+    })));
+    for (const check of checks) {
+        if (check.available) {
+            detected.add(check.installer.id);
+        }
+    }
+    return detected;
+}
+async function executableIsAvailable(executable) {
+    const path = process.env.PATH ?? "";
+    const extensions = process.platform === "win32"
+        ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";")
+        : [""];
+    for (const pathEntry of path.split(delimiter)) {
+        const directory = pathEntry || process.cwd();
+        for (const extension of extensions) {
+            try {
+                await access(resolve(directory, `${executable}${extension.toLowerCase()}`), fileSystemConstants.X_OK);
+                return true;
+            }
+            catch {
+                // Continue searching PATH.
+            }
+        }
+    }
+    return false;
+}
+async function promptInstallerSelection(detected) {
+    if (typeof process.stdin.setRawMode !== "function") {
+        return promptInstallerLineSelection(detected);
+    }
+    let activeIndex = Math.max(0, AGENT_INSTALLERS.findIndex((installer) => detected.has(installer.id)));
+    let renderedLineCount = 0;
+    const render = () => {
+        const lines = installerSelectionLines(activeIndex, detected);
+        if (renderedLineCount > 0) {
+            process.stdout.write(`\u001b[${renderedLineCount}A`);
+        }
+        for (const line of lines) {
+            process.stdout.write(`\u001b[2K${line}\n`);
+        }
+        renderedLineCount = lines.length;
+    };
+    render();
+    return new Promise((resolveSelection) => {
+        const wasRaw = process.stdin.isRaw === true;
+        const finish = (result) => {
+            process.stdin.removeListener("data", onData);
+            process.stdin.setRawMode(wasRaw);
+            if (!wasRaw)
+                process.stdin.pause();
+            process.stdout.write("\n");
+            resolveSelection(result);
+        };
+        const onData = (chunk) => {
+            const key = chunk.toString();
+            if (key === "\u0003" || key === "\u001b") {
+                finish(new Set());
+                return;
+            }
+            if (key === "\u001b[A") {
+                activeIndex =
+                    (activeIndex - 1 + AGENT_INSTALLERS.length) % AGENT_INSTALLERS.length;
+                render();
+                return;
+            }
+            if (key === "\u001b[B") {
+                activeIndex = (activeIndex + 1) % AGENT_INSTALLERS.length;
+                render();
+                return;
+            }
+            if (key.includes("\r") || key.includes("\n")) {
+                finish(new Set([AGENT_INSTALLERS[activeIndex].id]));
+            }
+        };
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.on("data", onData);
+    });
+}
+export function installerSelectionLines(activeIndex, detected) {
+    const labelWidth = Math.max(...AGENT_INSTALLERS.map((installer) => installer.label.length));
+    return [
+        ...AGENT_INSTALLERS.map((installer, index) => {
+            const marker = index === activeIndex ? installSuccess("●") : installDim("○");
+            const label = installer.label.padEnd(labelWidth);
+            const status = detected.has(installer.id)
+                ? installDim("detected")
+                : installDim("not found");
+            return `  ${marker} ${label}  ${status}`;
+        }),
+        "",
+        installDim("  Use ↑↓ to move · Enter to select"),
+    ];
+}
+async function promptInstallerLineSelection(detected) {
+    AGENT_INSTALLERS.forEach((installer, index) => {
+        console.log(`  ${index + 1}. ${installer.label} (${detected.has(installer.id) ? "detected" : "not found"})`);
+    });
+    const defaults = [...detected].join(",") || "none";
+    const readline = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        const answer = await readline.question(`Agents [${defaults}]: `);
+        const value = answer.trim() || defaults;
+        return new Set(installersFromTokens(splitTargetTokens(value), detected).map((installer) => installer.id));
+    }
+    finally {
+        readline.close();
+    }
+}
+function printInstallHeader() {
+    console.log(installAccent("zvec-grep setup"));
+    console.log(installDim("─".repeat(40)));
+}
+function installSuccessMark() {
+    return installSuccess("✓");
+}
+function installMutedMark() {
+    return installDim("○");
+}
+function installSuccess(value) {
+    return installStyle("32", value);
+}
+function installAccent(value) {
+    return installStyle("36", value);
+}
+function installDim(value) {
+    return installStyle("2", value);
+}
+function installStyle(code, value) {
+    return process.stdout.isTTY && process.env.NO_COLOR === undefined
+        ? `\u001b[${code}m${value}\u001b[0m`
+        : value;
+}
+async function ensureInstalledServer() {
+    if (process.env.ZVEC_GREP_INSTALL_SKIP_SERVER === "1") {
+        return { running: false, ready: false };
+    }
+    const { startServer } = await import("../daemon/server-controller.js");
+    return startServer({ cliPath: process.argv[1] });
+}
+function splitTargetTokens(value) {
+    return value
+        .split(/[,\s]+/)
+        .map((target) => target.trim())
+        .filter((target) => target.length > 0);
+}
+function resolveCodexHome() {
+    return resolve(process.env.CODEX_HOME ?? resolve(homedir(), ".codex"));
+}
+function resolveClaudeConfigDirectory() {
+    return resolve(process.env.CLAUDE_CONFIG_DIR ?? resolve(homedir(), ".claude"));
+}
+function resolveClaudeMcpConfigPath() {
+    return process.env.CLAUDE_CONFIG_DIR
+        ? resolve(process.env.CLAUDE_CONFIG_DIR, ".claude.json")
+        : resolve(homedir(), ".claude.json");
+}
+function resolveOpenCodeConfigPath() {
+    return resolve(process.env.OPENCODE_CONFIG ??
+        resolve(homedir(), ".config", "opencode", "opencode.json"));
+}
+function resolveCursorConfigPath() {
+    return resolve(process.env.CURSOR_CONFIG_DIR ?? resolve(homedir(), ".cursor"), "mcp.json");
+}
+async function installJsonMcpServer(options) {
+    const config = await readJsonObject(options.path);
+    const existingContainer = config[options.containerKey];
+    if (existingContainer !== undefined && !isJsonObject(existingContainer)) {
+        throw new Error(`Expected ${options.containerKey} in ${options.path} to be a JSON object`);
+    }
+    const container = { ...(existingContainer ?? {}) };
+    const existingServer = container.zvec_grep;
+    if (existingServer !== undefined &&
+        !isManagedJsonMcpServer(existingServer) &&
+        !options.force) {
+        throw new Error(`Existing unmanaged zvec_grep MCP server found in ${options.path}. Re-run with --force to replace it for ${options.label}.`);
+    }
+    container.zvec_grep = options.server;
+    config[options.containerKey] = container;
+    await writeTextFileAtomic(options.path, `${JSON.stringify(config, null, 2)}\n`);
+}
+async function uninstallJsonMcpServer(path, containerKey) {
+    const existing = await readTextFileIfExists(path);
+    if (!existing)
+        return;
+    const config = parseJsonObject(path, existing);
+    const container = config[containerKey];
+    if (!isJsonObject(container))
+        return;
+    if (!isManagedJsonMcpServer(container.zvec_grep))
+        return;
+    const nextContainer = { ...container };
+    delete nextContainer.zvec_grep;
+    if (Object.keys(nextContainer).length === 0) {
+        delete config[containerKey];
+    }
+    else {
+        config[containerKey] = nextContainer;
+    }
+    await writeTextFileAtomic(path, `${JSON.stringify(config, null, 2)}\n`);
+}
+async function updateClaudeMcpConfig(options) {
+    const root = await readJsonObject(options.path);
+    const currentServers = root.mcpServers;
+    if (currentServers !== undefined &&
+        !isJsonObject(currentServers) &&
+        !options.force) {
+        throw new Error(`Invalid mcpServers configuration in ${options.path}. Re-run with --force to replace it.`);
+    }
+    const mcpServers = isJsonObject(currentServers) ? currentServers : {};
+    const current = mcpServers.zvec_grep;
+    if (current !== undefined &&
+        (!isJsonObject(current) || current.url !== resolveServerUrl()) &&
+        !options.force) {
+        throw new Error(`Existing Claude Code MCP server "zvec_grep" found in ${options.path}. Re-run with --force to replace it.`);
+    }
+    const existingServer = isJsonObject(current) ? current : {};
+    const existingHeaders = isJsonObject(existingServer.headers)
+        ? existingServer.headers
+        : {};
+    mcpServers.zvec_grep = {
+        ...existingServer,
+        type: "http",
+        url: resolveServerUrl(),
+        ...(options.tokenEnv
+            ? {
+                headers: {
+                    ...existingHeaders,
+                    Authorization: `Bearer \${${options.tokenEnv}}`,
+                },
+            }
+            : {}),
+    };
+    root.mcpServers = mcpServers;
+    await writeJsonObject(options.path, root);
+}
+async function removeClaudeMcpConfig(path) {
+    const source = await readTextFileIfExists(path);
+    if (!source.trim())
+        return;
+    const root = parseJsonObject(path, source);
+    if (!isJsonObject(root.mcpServers))
+        return;
+    const current = root.mcpServers.zvec_grep;
+    if (!isJsonObject(current) || current.url !== resolveServerUrl())
+        return;
+    delete root.mcpServers.zvec_grep;
+    if (Object.keys(root.mcpServers).length === 0) {
+        delete root.mcpServers;
+    }
+    await writeJsonObject(path, root);
+}
+async function updateClaudePermissionSettings(path, grant) {
+    const source = await readTextFileIfExists(path);
+    if (!source.trim() && !grant)
+        return;
+    const root = source.trim() ? parseJsonObject(path, source) : {};
+    const currentPermissions = root.permissions;
+    if (currentPermissions !== undefined && !isJsonObject(currentPermissions)) {
+        throw new Error(`Invalid permissions configuration in ${path}.`);
+    }
+    const permissions = isJsonObject(currentPermissions)
+        ? currentPermissions
+        : {};
+    const currentAllow = permissions.allow;
+    if (currentAllow !== undefined && !Array.isArray(currentAllow)) {
+        throw new Error(`Invalid permissions.allow configuration in ${path}.`);
+    }
+    if (Array.isArray(currentAllow) &&
+        currentAllow.some((item) => typeof item !== "string")) {
+        throw new Error(`Invalid permissions.allow rule in ${path}.`);
+    }
+    const allow = Array.isArray(currentAllow)
+        ? currentAllow.slice()
+        : [];
+    if (grant) {
+        if (!allow.includes(CLAUDE_MCP_PERMISSION)) {
+            allow.push(CLAUDE_MCP_PERMISSION);
+        }
+        permissions.allow = allow;
+        root.permissions = permissions;
+    }
+    else {
+        const retained = allow.filter((item) => item !== CLAUDE_MCP_PERMISSION);
+        if (retained.length > 0)
+            permissions.allow = retained;
+        else
+            delete permissions.allow;
+        if (Object.keys(permissions).length > 0)
+            root.permissions = permissions;
+        else
+            delete root.permissions;
+    }
+    await writeJsonObject(path, root);
+}
+async function readJsonObject(path) {
+    const source = await readTextFileIfExists(path);
+    return source.trim() ? parseJsonObject(path, source) : {};
+}
+function parseJsonObject(path, source) {
+    let parsed;
+    try {
+        parsed = JSON.parse(source);
+    }
+    catch (error) {
+        throw new Error(`Invalid JSON in ${path}.`, { cause: error });
+    }
+    if (!isJsonObject(parsed)) {
+        throw new Error(`Expected a JSON object in ${path}.`);
+    }
+    return parsed;
+}
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isManagedJsonMcpServer(value) {
+    return isJsonObject(value) && value.url === resolveServerUrl();
+}
+async function writeJsonObject(path, value) {
+    await writeTextFileAtomic(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+async function writeMarkedFile(options) {
+    let existing = await readTextFileIfExists(options.path);
+    const next = replaceMarkedBlock(existing, options.startMarker, options.endMarker, options.block);
+    if (next === null) {
+        existing = removeOrphanedMarkers(existing, options.startMarker, options.endMarker);
+    }
+    if (next === null && options.hasConflict?.(existing)) {
+        if (!options.force) {
+            throw new Error(options.conflictMessage ??
+                `Existing unmanaged configuration found in ${options.path}`);
+        }
+        existing = options.removeConflict
+            ? options.removeConflict(existing)
+            : existing;
+    }
+    await writeTextFileAtomic(options.path, next ?? appendMarkedBlock(existing, options.block));
+}
+async function removeMarkedFile(options) {
+    const existing = await readTextFileIfExists(options.path);
+    if (!existing) {
+        return;
+    }
+    const next = replaceMarkedBlock(existing, options.startMarker, options.endMarker, "") ??
+        removeOrphanedMarkers(existing, options.startMarker, options.endMarker);
+    if (next === existing) {
+        return;
+    }
+    await writeTextFileAtomic(options.path, next);
+}
+async function writeTextFileAtomic(path, content) {
+    const targetPath = await resolveAtomicWriteTarget(path);
+    await mkdir(dirname(targetPath), { recursive: true });
+    const mode = await fileModeIfExists(targetPath);
+    const temporaryPath = `${targetPath}.${process.pid}.${randomUUID()}.tmp`;
+    let temporaryFile;
+    try {
+        temporaryFile = await open(temporaryPath, "wx", mode);
+        await temporaryFile.writeFile(content, "utf8");
+        await temporaryFile.sync();
+        await temporaryFile.close();
+        temporaryFile = undefined;
+        if (mode !== undefined) {
+            await chmod(temporaryPath, mode);
+        }
+        await rename(temporaryPath, targetPath);
+    }
+    catch (error) {
+        await temporaryFile?.close().catch(() => undefined);
+        await unlink(temporaryPath).catch(() => undefined);
+        throw error;
+    }
+}
+async function resolveAtomicWriteTarget(path, visited = new Set()) {
+    const absolutePath = resolve(path);
+    if (visited.has(absolutePath)) {
+        throw new Error(`Cannot atomically write through circular symbolic link: ${path}`);
+    }
+    try {
+        const file = await lstat(absolutePath);
+        if (!file.isSymbolicLink()) {
+            return absolutePath;
+        }
+        visited.add(absolutePath);
+        const link = await readlink(absolutePath);
+        return resolveAtomicWriteTarget(resolve(dirname(absolutePath), link), visited);
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT") {
+            return absolutePath;
+        }
+        throw error;
+    }
+}
+async function fileModeIfExists(path) {
+    try {
+        return (await stat(path)).mode & 0o777;
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT") {
+            return undefined;
+        }
+        throw error;
+    }
+}
+async function readTextFileIfExists(path) {
+    try {
+        return await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return "";
+        }
+        throw error;
+    }
+}
+function isNodeError(error) {
+    return typeof error === "object" && error !== null && "code" in error;
+}
+function replaceMarkedBlock(existing, startMarker, endMarker, block) {
+    const lines = existing.split(/\r?\n/);
+    const markerLines = new Set();
+    const ranges = [];
+    let pendingStart;
+    for (const [index, line] of lines.entries()) {
+        const trimmed = line.trim();
+        if (trimmed === startMarker) {
+            markerLines.add(index);
+            pendingStart = index;
+            continue;
+        }
+        if (trimmed === endMarker) {
+            markerLines.add(index);
+            if (pendingStart !== undefined) {
+                ranges.push({ start: pendingStart, end: index });
+                pendingStart = undefined;
+            }
+        }
+    }
+    const first = ranges[0];
+    if (!first) {
+        return null;
+    }
+    const before = retainedMarkedLines(lines, 0, first.start, markerLines, [])
+        .join("\n")
+        .trimEnd();
+    const after = retainedMarkedLines(lines, first.end + 1, lines.length, markerLines, ranges.slice(1))
+        .join("\n")
+        .trim();
+    return ([before, block.trim(), after.trim()]
+        .filter((part) => part.length > 0)
+        .join("\n\n") + "\n");
+}
+function retainedMarkedLines(lines, start, end, markerLines, removedRanges) {
+    const retained = [];
+    for (let index = start; index < end; index += 1) {
+        if (markerLines.has(index)) {
+            continue;
+        }
+        if (removedRanges.some((range) => index >= range.start && index <= range.end)) {
+            continue;
+        }
+        retained.push(lines[index]);
+    }
+    return retained;
+}
+function removeOrphanedMarkers(existing, startMarker, endMarker) {
+    return (existing
+        .split(/\r?\n/)
+        .filter((line) => {
+        const trimmed = line.trim();
+        return trimmed !== startMarker && trimmed !== endMarker;
+    })
+        .join("\n")
+        .trimEnd() + "\n");
+}
+function appendMarkedBlock(existing, block) {
+    const prefix = existing.trimEnd();
+    return `${prefix.length > 0 ? `${prefix}\n\n` : ""}${block.trim()}\n`;
+}
+function hasCodexMcpServerConfig(existing) {
+    return existing.split(/\r?\n/).some((line) => {
+        const tableName = tomlTableName(line);
+        return tableName !== undefined && isCodexMcpServerTableName(tableName);
+    });
+}
+function removeCodexMcpServerConfig(existing) {
+    const lines = existing.split(/\r?\n/);
+    const kept = [];
+    let skipping = false;
+    for (const line of lines) {
+        const tableName = tomlTableName(line);
+        if (tableName !== undefined) {
+            skipping = isCodexMcpServerTableName(tableName);
+        }
+        if (!skipping) {
+            kept.push(line);
+        }
+    }
+    return kept.join("\n").trimEnd() + "\n";
+}
+function tomlTableName(line) {
+    return line.match(/^\s*\[([^\]]+)\]\s*(?:#.*)?$/)?.[1]?.trim();
+}
+function isCodexMcpServerTableName(tableName) {
+    return /^(?:mcp_servers|"mcp_servers"|'mcp_servers')\s*\.\s*(?:zvec_grep|"zvec_grep"|'zvec_grep')(?:\s*\.|$)/.test(tableName);
+}
+function codexConfigBlock(mcpToolTimeoutSeconds, tokenEnv) {
+    return `${ZVEC_GREP_CONFIG_START}
+[mcp_servers.zvec_grep]
+url = "${resolveServerUrl()}"
+${tokenEnv
+        ? `bearer_token_env_var = "${tokenEnv}"
+`
+        : ""}tool_timeout_sec = ${mcpToolTimeoutSeconds}
+default_tools_approval_mode = "approve"
+${ZVEC_GREP_CONFIG_END}`;
+}
+function agentGuidanceBlock(toolNames) {
+    const searchTool = toolNames?.search ?? "zvec_grep_search";
+    return `${ZVEC_GREP_AGENTS_START}
+## zvec-grep
+
+Choose the initial search tool by the scope of the requested answer, not merely by whether the question contains an identifier.
+
+Use native Grep or rg first when the answer can be obtained by locating a specific definition, reference, filename, configuration key, error message, literal, source fragment, or regex.
+
+Use \`${searchTool}\` first when the answer requires architecture, lifecycle, system design, conceptual discovery, data or control flow, comparison across implementations, design rationale, or performance analysis.
+
+When exact symbols are present but the answer spans multiple components, files, stages, or implementations, treat it as a mixed task: use \`${searchTool}\` with the concept and known symbols, then use native Grep or rg for focused follow-up.
+
+Before using broad file reads or a sub-agent for conceptual repository discovery, make at least one appropriate \`${searchTool}\` call.
+
+Do not launch a sub-agent solely to locate code. Stop discovery when the evidence covers all components requested by the question.
+${ZVEC_GREP_AGENTS_END}`;
+}
+//# sourceMappingURL=install.js.map