@danielblomma/cortex-mcp 2.4.0 → 2.4.2

package/scaffold/mcp/dist/cli/query.js

@@ -0,0 +1,409 @@
+import { runContextRules } from "../rules.js";
+import { runPatternEvidence } from "../patternEvidence.js";
+import { runContextImpact, runContextRelated, runContextSearch } from "../search.js";
+const QUERY_COMMANDS = new Set(["search", "related", "impact", "rules", "explain", "pattern-evidence"]);
+const ENTITY_ID_PREFIXES = [
+    "file:",
+    "chunk:",
+    "rule:",
+    "adr:",
+    "module:",
+    "project:",
+];
+export async function runQueryCommand(args) {
+    const command = args[0] ?? "help";
+    const rest = args.slice(1);
+    if (command === "help" || command === "--help" || command === "-h") {
+        printHelp();
+        return;
+    }
+    if (!QUERY_COMMANDS.has(command)) {
+        throw new Error(`Unknown query command: ${command}`);
+    }
+    const json = wantsJson(rest);
+    try {
+        switch (command) {
+            case "search":
+                return await runSearch(rest);
+            case "related":
+                return await runRelated(rest);
+            case "impact":
+                return await runImpact(rest);
+            case "rules":
+                return await runRules(rest);
+            case "explain":
+                return await runExplain(rest);
+            case "pattern-evidence":
+                return await runPatternEvidenceCommand(rest);
+            default:
+                throw new Error(`Unknown query command: ${command}`);
+        }
+    }
+    catch (error) {
+        if (!json) {
+            throw error;
+        }
+        emitJson({
+            ok: false,
+            command,
+            error: {
+                code: "INVALID_ARGS",
+                message: error instanceof Error ? error.message : String(error),
+            },
+        });
+        process.exitCode = 1;
+    }
+}
+function printHelp() {
+    const lines = [
+        "Usage:",
+        "  cortex search <query> [--top-k <n>] [--preset <full|compact|minimal>] [--include-content] [--json]",
+        "  cortex related <entity-id> [--depth <n>] [--edges] [--metadata] [--json]",
+        "  cortex impact <query-or-entity-id> [--entity-id <id>] [--query <q>] [--depth <n>] [--top-k <n>] [--json]",
+        "  cortex rules [--scope <scope>] [--include-inactive] [--json]",
+        "  cortex explain <query-or-entity-id> [--top-k <n>] [--json]",
+        "  cortex pattern-evidence <file-path|entity-id> [--query <text>] [--top-k <n>] [--json]",
+        "",
+        "These commands read the local Cortex graph and emit MCP-equivalent data with --json.",
+    ];
+    process.stdout.write(lines.join("\n") + "\n");
+}
+function parseArgs(args) {
+    const flags = {};
+    const rest = [];
+    let i = 0;
+    while (i < args.length) {
+        const arg = args[i];
+        if (arg === "--") {
+            rest.push(...args.slice(i + 1));
+            break;
+        }
+        if (arg.startsWith("--")) {
+            const name = arg.slice(2);
+            const next = args[i + 1];
+            if (next === undefined || next.startsWith("--")) {
+                flags[name] = true;
+                i += 1;
+                continue;
+            }
+            flags[name] = next;
+            i += 2;
+            continue;
+        }
+        rest.push(arg);
+        i += 1;
+    }
+    return { flags, rest };
+}
+function wantsJson(args) {
+    return args.includes("--json");
+}
+function isFlagEnabled(flags, name) {
+    return flags[name] === true;
+}
+function optionalString(flags, name) {
+    const value = flags[name];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function parsePositiveIntFlag(flags, name, defaultValue, max) {
+    const raw = flags[name];
+    if (raw === undefined) {
+        return defaultValue;
+    }
+    if (typeof raw !== "string" || raw.trim().length === 0) {
+        throw new Error(`--${name} requires a numeric value`);
+    }
+    const normalized = raw.trim();
+    if (!/^[1-9]\d*$/.test(normalized)) {
+        throw new Error(`--${name} must be an integer from 1 to ${max}`);
+    }
+    const parsed = Number(normalized);
+    if (!Number.isInteger(parsed) || parsed <= 0 || parsed > max) {
+        throw new Error(`--${name} must be an integer from 1 to ${max}`);
+    }
+    return parsed;
+}
+function parsePreset(flags) {
+    const value = optionalString(flags, "preset") ?? optionalString(flags, "response-preset");
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "full" || value === "compact" || value === "minimal") {
+        return value;
+    }
+    throw new Error("--preset must be one of full, compact, minimal");
+}
+function parseCsvFlag(flags, name, allowed) {
+    const raw = optionalString(flags, name);
+    if (!raw) {
+        return undefined;
+    }
+    const allowedSet = new Set(allowed);
+    const parsed = raw.split(",").map((value) => value.trim()).filter(Boolean);
+    for (const value of parsed) {
+        if (!allowedSet.has(value)) {
+            throw new Error(`--${name} contains unsupported value: ${value}`);
+        }
+    }
+    return parsed;
+}
+function positionalText(rest, label) {
+    const value = rest.join(" ").trim();
+    if (!value) {
+        throw new Error(`${label} is required`);
+    }
+    return value;
+}
+function emitJson(value) {
+    process.stdout.write(JSON.stringify(value, null, 2) + "\n");
+}
+function emitEnvelope(command, input, data) {
+    emitJson({
+        ok: true,
+        command,
+        input,
+        context_source: data.context_source,
+        warning: data.warning,
+        data,
+    });
+}
+function printSummary(command, data) {
+    const source = data.context_source ? ` context_source=${String(data.context_source)}` : "";
+    const warning = data.warning ? ` warning=${String(data.warning)}` : "";
+    if (Array.isArray(data.results)) {
+        process.stdout.write(`${command}: ${data.results.length} results${source}${warning}\n`);
+        for (const result of data.results.slice(0, 10)) {
+            printEntityLine(result);
+        }
+        return;
+    }
+    if (Array.isArray(data.related)) {
+        process.stdout.write(`${command}: ${data.related.length} related${source}${warning}\n`);
+        for (const result of data.related.slice(0, 10)) {
+            printEntityLine(result);
+        }
+        return;
+    }
+    if (Array.isArray(data.rules)) {
+        process.stdout.write(`${command}: ${data.rules.length} rules${source}${warning}\n`);
+        for (const rule of data.rules.slice(0, 10)) {
+            if (rule && typeof rule === "object") {
+                const row = rule;
+                process.stdout.write(`- ${String(row.id ?? "")} priority=${String(row.priority ?? "")} scope=${String(row.scope ?? "")}\n`);
+            }
+        }
+        return;
+    }
+    process.stdout.write(`${command}: ok${source}${warning}\n`);
+}
+function printEntityLine(value) {
+    if (!value || typeof value !== "object") {
+        return;
+    }
+    const row = value;
+    const title = row.title ?? row.label ?? row.id ?? "";
+    const path = row.path ? ` ${String(row.path)}` : "";
+    process.stdout.write(`- ${String(title)}${path}\n`);
+}
+async function runSearch(args) {
+    const { flags, rest } = parseArgs(args);
+    const query = optionalString(flags, "query") ?? positionalText(rest, "query");
+    const input = {
+        query,
+        top_k: parsePositiveIntFlag(flags, "top-k", 5, 20),
+        include_deprecated: isFlagEnabled(flags, "include-deprecated"),
+        response_preset: parsePreset(flags),
+        include_scores: isFlagEnabled(flags, "scores") || isFlagEnabled(flags, "include-scores") || undefined,
+        include_matched_rules: isFlagEnabled(flags, "matched-rules") || isFlagEnabled(flags, "include-matched-rules") || undefined,
+        include_content: isFlagEnabled(flags, "include-content") || undefined,
+    };
+    const data = await runContextSearch(input);
+    if (isFlagEnabled(flags, "json")) {
+        emitEnvelope("search", input, data);
+        return;
+    }
+    printSummary("search", data);
+}
+async function runRelated(args) {
+    const { flags, rest } = parseArgs(args);
+    const entityId = optionalString(flags, "entity-id") ?? positionalText(rest, "entity-id");
+    const input = {
+        entity_id: entityId,
+        depth: parsePositiveIntFlag(flags, "depth", 1, 3),
+        include_edges: isFlagEnabled(flags, "edges") || isFlagEnabled(flags, "include-edges") || undefined,
+        response_preset: parsePreset(flags),
+        include_entity_metadata: isFlagEnabled(flags, "metadata") || isFlagEnabled(flags, "include-entity-metadata") || undefined,
+    };
+    const data = await runContextRelated(input);
+    if (isFlagEnabled(flags, "json")) {
+        emitEnvelope("related", input, data);
+        return;
+    }
+    printSummary("related", data);
+}
+async function runImpact(args) {
+    const { flags, rest } = parseArgs(args);
+    const explicitEntityId = optionalString(flags, "entity-id");
+    const explicitQuery = optionalString(flags, "query");
+    const positional = rest.length > 0 ? positionalText(rest, "query-or-entity-id") : undefined;
+    const seed = explicitEntityId ?? explicitQuery ?? positional;
+    if (!seed) {
+        throw new Error("Either --entity-id, --query, or a positional seed is required");
+    }
+    const relationTypes = parseCsvFlag(flags, "relation-types", [
+        "CALLS",
+        "CALLS_SQL",
+        "IMPORTS",
+        "USES_CONFIG_KEY",
+        "USES_RESOURCE_KEY",
+        "USES_SETTING_KEY",
+        "USES_CONFIG",
+        "TRANSFORMS_CONFIG",
+        "PART_OF",
+    ]);
+    const input = {
+        depth: parsePositiveIntFlag(flags, "depth", 2, 4),
+        top_k: parsePositiveIntFlag(flags, "top-k", 8, 20),
+        include_edges: !isFlagEnabled(flags, "no-edges"),
+        response_preset: parsePreset(flags),
+        include_scores: isFlagEnabled(flags, "scores") || isFlagEnabled(flags, "include-scores") || undefined,
+        include_reasons: isFlagEnabled(flags, "reasons") || isFlagEnabled(flags, "include-reasons") || undefined,
+        verbose_paths: isFlagEnabled(flags, "verbose-paths") || undefined,
+        max_path_hops_shown: parsePositiveIntFlag(flags, "max-path-hops-shown", 3, 8),
+        profile: parseProfile(flags),
+        sort_by: parseSortBy(flags),
+        relation_types: relationTypes,
+        path_must_include: parseCsvFlag(flags, "path-must-include", relationTypesAllowed()),
+        path_must_exclude: parseCsvFlag(flags, "path-must-exclude", relationTypesAllowed()),
+        result_domains: parseCsvFlag(flags, "result-domains", [
+            "code",
+            "config",
+            "resource",
+            "settings",
+            "sql",
+            "project",
+        ]),
+        result_entity_types: parseCsvFlag(flags, "result-entity-types", [
+            "File",
+            "Chunk",
+            "Module",
+            "Project",
+            "ADR",
+            "Rule",
+        ]),
+    };
+    if (explicitEntityId || (!explicitQuery && seedLooksLikeEntityId(seed))) {
+        input.entity_id = seed;
+    }
+    else {
+        input.query = seed;
+    }
+    const data = await runContextImpact(input);
+    if (isFlagEnabled(flags, "json")) {
+        emitEnvelope("impact", input, data);
+        return;
+    }
+    printSummary("impact", data);
+}
+function relationTypesAllowed() {
+    return [
+        "CALLS",
+        "CALLS_SQL",
+        "IMPORTS",
+        "USES_CONFIG_KEY",
+        "USES_RESOURCE_KEY",
+        "USES_SETTING_KEY",
+        "USES_CONFIG",
+        "TRANSFORMS_CONFIG",
+        "PART_OF",
+    ];
+}
+function seedLooksLikeEntityId(value) {
+    return ENTITY_ID_PREFIXES.some((prefix) => value.startsWith(prefix));
+}
+function parseProfile(flags) {
+    const value = optionalString(flags, "profile");
+    if (!value) {
+        return "all";
+    }
+    if (value === "all" || value === "config_only" || value === "config_to_sql" || value === "code_only" || value === "sql_only") {
+        return value;
+    }
+    throw new Error("--profile must be one of all, config_only, config_to_sql, code_only, sql_only");
+}
+function parseSortBy(flags) {
+    const value = optionalString(flags, "sort-by");
+    if (!value) {
+        return "impact_score";
+    }
+    if (value === "impact_score" || value === "shortest_path" || value === "semantic_score" || value === "graph_score" || value === "trust_score") {
+        return value;
+    }
+    throw new Error("--sort-by must be one of impact_score, shortest_path, semantic_score, graph_score, trust_score");
+}
+async function runRules(args) {
+    const { flags } = parseArgs(args);
+    const input = {
+        scope: optionalString(flags, "scope"),
+        include_inactive: isFlagEnabled(flags, "include-inactive"),
+    };
+    const data = await runContextRules(input);
+    if (isFlagEnabled(flags, "json")) {
+        emitEnvelope("rules", input, data);
+        return;
+    }
+    printSummary("rules", data);
+}
+async function runExplain(args) {
+    const { flags, rest } = parseArgs(args);
+    const target = optionalString(flags, "id") ?? optionalString(flags, "query") ?? positionalText(rest, "query-or-entity-id");
+    const input = {
+        query: target,
+        top_k: parsePositiveIntFlag(flags, "top-k", 3, 20),
+        include_deprecated: isFlagEnabled(flags, "include-deprecated"),
+        response_preset: parsePreset(flags) ?? "full",
+        include_scores: true,
+        include_matched_rules: true,
+        include_content: isFlagEnabled(flags, "include-content") || undefined,
+    };
+    const search = await runContextSearch(input);
+    const data = {
+        query: target,
+        entity_id: seedLooksLikeEntityId(target) ? target : undefined,
+        context_source: search.context_source,
+        warning: search.warning,
+        semantic_engine: search.semantic_engine,
+        ranking: search.ranking,
+        results: search.results,
+        explanation: "Scores and matched_rules come from the same local search ranking used by context.search.",
+    };
+    if (isFlagEnabled(flags, "json")) {
+        emitEnvelope("explain", input, data);
+        return;
+    }
+    printSummary("explain", data);
+}
+async function runPatternEvidenceCommand(args) {
+    const { flags, rest } = parseArgs(args);
+    const target = optionalString(flags, "target") ?? positionalText(rest, "file-path-or-entity-id");
+    const input = {
+        target,
+        query: optionalString(flags, "query"),
+        top_k: parsePositiveIntFlag(flags, "top-k", 3, 10),
+        include_deprecated: isFlagEnabled(flags, "include-deprecated"),
+    };
+    const data = await runPatternEvidence(input);
+    if (isFlagEnabled(flags, "json")) {
+        emitEnvelope("pattern-evidence", input, data);
+        return;
+    }
+    const tiers = Array.isArray(data.tiers) ? data.tiers : [];
+    process.stdout.write(`pattern-evidence: local_pattern_found=${String(data.local_pattern_found)}\n`);
+    for (const value of tiers) {
+        if (!value || typeof value !== "object")
+            continue;
+        const tier = value;
+        const evidence = Array.isArray(tier.evidence) ? tier.evidence : [];
+        process.stdout.write(`- ${String(tier.name ?? "")}: ${evidence.length}\n`);
+    }
+}

package/scaffold/mcp/dist/cli/run.js

@@ -0,0 +1,295 @@
+import { spawn } from "node:child_process";
+import { existsSync, closeSync, fchmodSync, lstatSync, openSync, readFileSync, renameSync, writeFileSync, unlinkSync, mkdirSync, } from "node:fs";
+import { join, dirname } from "node:path";
+import { platform, tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+import { getGovernManagedPath } from "../core/govern-paths.js";
+export const RUN_CLIS = ["claude", "codex", "copilot"];
+// Inline ANSI helper. Kept here (rather than imported from bin/style.mjs) so
+// the scaffold MCP stays self-contained — projects bundle scaffold/ on init
+// but do not pull bin/ into their tree. Style stays brand-aligned: cyan accent
+// (xterm-256 code 81), graceful degrade when the stream is not a TTY or when
+// NO_COLOR / CORTEX_NO_COLOR are set.
+function runHeaderSupportsColor() {
+    if (process.env.NO_COLOR)
+        return false;
+    if (process.env.CORTEX_NO_COLOR)
+        return false;
+    if (process.env.TERM === "dumb")
+        return false;
+    return Boolean(process.stderr.isTTY);
+}
+function runHeaderUnicodeOk() {
+    if (process.env.CORTEX_NO_UNICODE)
+        return false;
+    const locale = process.env.LC_ALL || process.env.LC_CTYPE || process.env.LANG || "";
+    if (!locale)
+        return process.platform !== "win32";
+    return /UTF-?8/i.test(locale);
+}
+export function buildRunHeader(label) {
+    const glyph = runHeaderUnicodeOk() ? "▸" : ">";
+    if (!runHeaderSupportsColor()) {
+        return `${glyph} ${label}`;
+    }
+    return `\x1b[38;5;81m${glyph}\x1b[0m ${label}`;
+}
+export const SHIM_MARKER = "# cortex-shim-v1";
+export function isCortexShim(filePath) {
+    try {
+        return readFileSync(filePath, "utf8").includes(SHIM_MARKER);
+    }
+    catch {
+        return false;
+    }
+}
+export function findRealBinary(name, excludePaths = []) {
+    const exclusions = new Set(excludePaths);
+    const pathDirs = (process.env.PATH ?? "").split(":");
+    for (const dir of pathDirs) {
+        if (!dir)
+            continue;
+        const candidate = join(dir, name);
+        if (exclusions.has(candidate))
+            continue;
+        if (!existsSync(candidate))
+            continue;
+        if (isCortexShim(candidate))
+            continue;
+        return candidate;
+    }
+    return null;
+}
+export function buildDarwinSandboxProfile(homeDir) {
+    return [
+        "(version 1)",
+        "(allow default)",
+        "; Cortex Tier 2 (wrap) profile for Copilot CLI.",
+        "; Deny writes to Copilot's mutable config locations so AI cannot",
+        "; reconfigure itself out of governance.",
+        `(deny file-write* (subpath "${homeDir}/.copilot"))`,
+        `(deny file-write* (subpath "${homeDir}/.copilot.local"))`,
+        '(deny file-write* (regex #"^/etc/copilot"))',
+        "",
+    ].join("\n");
+}
+export function buildLinuxBwrapArgs(homeDir, realBinary, args) {
+    return [
+        "--die-with-parent",
+        "--unshare-user",
+        "--ro-bind",
+        "/",
+        "/",
+        "--proc",
+        "/proc",
+        "--dev",
+        "/dev",
+        "--bind",
+        homeDir,
+        homeDir,
+        "--tmpfs",
+        `${homeDir}/.copilot`,
+        "--tmpfs",
+        `${homeDir}/.copilot.local`,
+        "--ro-bind",
+        "/etc",
+        "/etc",
+        "--",
+        realBinary,
+        ...args,
+    ];
+}
+function spawnAndWait(cmd, args, extraEnv) {
+    return new Promise((resolve) => {
+        const env = extraEnv ? { ...process.env, ...extraEnv } : process.env;
+        const child = spawn(cmd, args, { stdio: "inherit", env });
+        child.on("exit", (code, signal) => {
+            if (signal)
+                resolve(128);
+            else
+                resolve(code ?? 1);
+        });
+        child.on("error", (err) => {
+            console.error(`✗ Failed to spawn ${cmd}: ${err.message}`);
+            resolve(127);
+        });
+    });
+}
+export async function runAiCli(options) {
+    const { cli, args } = options;
+    const real = options.realBinary ?? findRealBinary(cli, options.excludePaths ?? []);
+    if (!real) {
+        const exclusions = options.excludePaths?.length
+            ? ` (excluding ${options.excludePaths.join(", ")})`
+            : "";
+        console.error(`✗ Could not find '${cli}' binary in PATH${exclusions}.`);
+        return 127;
+    }
+    if (cli !== "copilot") {
+        return spawnAndWait(real, args);
+    }
+    const home = process.env.HOME ?? "";
+    if (!home) {
+        console.error("✗ HOME not set — required for Copilot wrap profile.");
+        return 1;
+    }
+    const proxyPort = process.env.CORTEX_EGRESS_PROXY_PORT ?? "18888";
+    const proxyEnv = {
+        HTTPS_PROXY: `http://127.0.0.1:${proxyPort}`,
+        HTTP_PROXY: `http://127.0.0.1:${proxyPort}`,
+        https_proxy: `http://127.0.0.1:${proxyPort}`,
+        http_proxy: `http://127.0.0.1:${proxyPort}`,
+    };
+    const os = platform();
+    if (os === "darwin") {
+        const profile = buildDarwinSandboxProfile(home);
+        const tmpProfile = join(tmpdir(), `cortex-copilot-${randomUUID()}.sb`);
+        writeFileSync(tmpProfile, profile);
+        try {
+            process.stderr.write(buildRunHeader("cortex run copilot — Tier 2 wrap (sandbox-exec)") + "\n");
+            return await spawnAndWait("sandbox-exec", ["-f", tmpProfile, real, ...args], proxyEnv);
+        }
+        finally {
+            try {
+                unlinkSync(tmpProfile);
+            }
+            catch {
+                // best-effort cleanup
+            }
+        }
+    }
+    if (os === "linux") {
+        process.stderr.write(buildRunHeader("cortex run copilot — Tier 2 wrap (bwrap)") + "\n");
+        return spawnAndWait("bwrap", buildLinuxBwrapArgs(home, real, args), proxyEnv);
+    }
+    console.error(`✗ Tier 2 (wrap) for copilot not yet supported on ${os}.`);
+    return 1;
+}
+export function getDefaultCopilotShimPath(os) {
+    return getGovernManagedPath("copilot", os);
+}
+export function buildCopilotShim(realBinary) {
+    return [
+        "#!/bin/sh",
+        SHIM_MARKER,
+        "# Cortex Tier 2 wrap shim — re-execs through 'cortex run copilot'.",
+        "# Direct invocations of copilot are routed through cortex's OS sandbox.",
+        `# Real binary captured at install time: ${realBinary}`,
+        "",
+        'CORTEX="${CORTEX_BIN:-cortex}"',
+        'exec "$CORTEX" run copilot "$@"',
+        "",
+    ].join("\n");
+}
+export function installCopilotShim(options = {}) {
+    const shimPath = options.shimPath ?? getDefaultCopilotShimPath(platform());
+    const search = options.searchPath ?? process.env.PATH ?? "";
+    const real = options.realBinary ??
+        findRealBinaryIn(search, "copilot", [shimPath]);
+    if (!real) {
+        return {
+            ok: false,
+            message: `Copilot CLI not found in PATH (excluding ${shimPath}). ` +
+                "Install GitHub Copilot CLI first, then re-run cortex enterprise sync.",
+        };
+    }
+    try {
+        const existing = lstatSync(shimPath);
+        if (existing.isSymbolicLink() ||
+            !existing.isFile() ||
+            !isCortexShim(shimPath)) {
+            return {
+                ok: false,
+                message: `${shimPath} exists and is not a regular cortex shim — refusing to overwrite. ` +
+                    "Move/rename the existing path, then re-run.",
+            };
+        }
+    }
+    catch (err) {
+        if (err.code !== "ENOENT") {
+            return {
+                ok: false,
+                message: `Failed to inspect shim path ${shimPath}: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+    }
+    const temporaryPath = `${shimPath}.tmp.${process.pid}.${randomUUID()}`;
+    let fd = null;
+    try {
+        mkdirSync(dirname(shimPath), { recursive: true });
+        fd = openSync(temporaryPath, "wx", 0o700);
+        writeFileSync(fd, buildCopilotShim(real));
+        fchmodSync(fd, 0o755);
+        closeSync(fd);
+        fd = null;
+        renameSync(temporaryPath, shimPath);
+        const installed = lstatSync(shimPath);
+        if (!installed.isFile() || installed.isSymbolicLink()) {
+            throw new Error("installed shim is not a regular file");
+        }
+    }
+    catch (err) {
+        if (fd !== null) {
+            try {
+                closeSync(fd);
+            }
+            catch {
+                // Best effort.
+            }
+        }
+        try {
+            unlinkSync(temporaryPath);
+        }
+        catch {
+            // Best effort.
+        }
+        return {
+            ok: false,
+            message: `Failed to write shim at ${shimPath}: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    return {
+        ok: true,
+        message: `Installed copilot shim at ${shimPath} (real binary: ${real})`,
+        shimPath,
+        realBinary: real,
+    };
+}
+function findRealBinaryIn(searchPath, name, excludePaths) {
+    const exclusions = new Set(excludePaths);
+    for (const dir of searchPath.split(":")) {
+        if (!dir)
+            continue;
+        const candidate = join(dir, name);
+        if (exclusions.has(candidate))
+            continue;
+        if (!existsSync(candidate))
+            continue;
+        if (isCortexShim(candidate))
+            continue;
+        return candidate;
+    }
+    return null;
+}
+export function uninstallCopilotShim(shimPath) {
+    const target = shimPath ?? getDefaultCopilotShimPath(platform());
+    if (!existsSync(target)) {
+        return { ok: true, message: `${target} already absent.` };
+    }
+    if (!isCortexShim(target)) {
+        return {
+            ok: false,
+            message: `${target} is no longer a cortex shim — refusing to delete (would clobber a real binary).`,
+        };
+    }
+    try {
+        unlinkSync(target);
+    }
+    catch (err) {
+        return {
+            ok: false,
+            message: `Failed to remove ${target}: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    return { ok: true, message: `Removed copilot shim at ${target}` };
+}