@loucompanion/forge-bridge 0.1.1-dev.8dcbc6245e51 → 0.1.1-dev.9219f8477b8a

package/dist/cli/cli.service.js

@@ -1,32 +1,56 @@
 import fs from "node:fs/promises";
 import { execFile } from "node:child_process";
+import os from "node:os";
 import path from "node:path";
+import { createInterface } from "node:readline/promises";
 import { promisify } from "node:util";
+import { resolveCursorAgentDirectLaunch } from "../shared/cursor-agent/cursor-agent.launch.js";
 import { redactSecrets, redactText } from "../shared/redaction/redaction.js";
 import { defaultBridgeServiceConfig, ForgeBridgeService } from "../bridge/bridge.service.js";
-import { addRepoMapping, applyLocalConfigDefaults, readLocalConfigSync, removeRepoMapping, resolveLocalConfigPath } from "./local-config.js";
+import { forgeBridgeVersion } from "../version.js";
+import { addRepoMapping, applyLocalConfigDefaults, providerStatusesFor, readLocalConfigSync, removeRepoMapping, resolveLocalConfigPath, writeLocalConfig } from "./local-config.js";
 import { BridgeSessionService } from "../session/session.service.js";
+import { parseCompletionMcpArgs, runCompletionMcpServer } from "../session/phase-completion.js";
 import { failureResult, parseRunOnceDispatchPacket } from "../session/session.types.js";
 const apiKeySecretGrantEnv = "FORGE_API_KEY_SECRET_GRANT";
 const execFileAsync = promisify(execFile);
 export class ForgeBridgeCliService {
     sessions;
     bridgeFactory;
-    constructor(sessions = new BridgeSessionService(), bridgeFactory = (config) => new ForgeBridgeService(config)) {
+    pairRunner;
+    constructor(sessions = new BridgeSessionService(), bridgeFactory = (config) => new ForgeBridgeService(config), pairRunner = claimBridgeRunner) {
         this.sessions = sessions;
         this.bridgeFactory = bridgeFactory;
+        this.pairRunner = pairRunner;
     }
     async run(argv, io = { stdout: process.stdout, stderr: process.stderr }) {
+        if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h") {
+            io.stdout.write(helpText());
+            return 0;
+        }
+        if (argv[0] === "help") {
+            io.stdout.write(argv[1] ? commandHelpText(argv[1]) : helpText());
+            return 0;
+        }
+        if (argv[1] === "--help" || argv[1] === "-h") {
+            io.stdout.write(commandHelpText(argv[0]));
+            return 0;
+        }
+        if (argv[0] === "version" || argv[0] === "--version" || argv[0] === "-v") {
+            io.stdout.write(`forge-bridge ${defaultBridgeServiceConfig().version ?? forgeBridgeVersion}\n`);
+            return 0;
+        }
         const args = parseArgs(argv);
         if (!args.ok) {
             io.stderr.write(`${args.error}\n`);
             return 2;
         }
         if (args.command === "connect") {
+            const config = await withDetectedCliProviders(args.config);
             const missing = [
-                ["server", args.config.serverUrl],
-                ["runner id", args.config.runnerId],
-                ["device token", args.config.deviceToken]
+                ["server", config.serverUrl],
+                ["runner id", config.runnerId],
+                ["device token", config.deviceToken]
             ].find(([, value]) => !value);
             if (missing) {
                 io.stderr.write(`forge-bridge connect requires ${missing[0]}.\n`);
@@ -37,7 +61,8 @@ export class ForgeBridgeCliService {
             process.once("SIGINT", stop);
             process.once("SIGTERM", stop);
             try {
-                await this.bridgeFactory(args.config).run(controller.signal);
+                io.stdout.write(connectStartupText(config));
+                await this.bridgeFactory(config).run(controller.signal);
                 return 0;
             }
             finally {
@@ -58,6 +83,27 @@ export class ForgeBridgeCliService {
                 return 2;
             }
         }
+        if (args.command === "pair") {
+            try {
+                const current = readLocalConfigSync();
+                const code = await resolvePairingCode(args.code);
+                const repoRoot = await resolvePairRepoRoot(args.repoRoot, current.defaultRepoRoot);
+                await fs.mkdir(repoRoot, { recursive: true });
+                const pairArgs = await withDetectedPairCliProviders({ ...args, code, repoRoot });
+                const claim = await this.pairRunner(pairArgs);
+                const next = pairedConfig(current, pairArgs, claim);
+                await writeLocalConfig(next);
+                io.stdout.write(`Paired runner ${claim.runnerId}.\n`);
+                io.stdout.write(`Repo folder: ${repoRoot}\n`);
+                io.stdout.write(`Config: ${resolveLocalConfigPath()}\n`);
+                io.stdout.write("Start the bridge with: forge-bridge connect\n");
+                return 0;
+            }
+            catch (error) {
+                io.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+                return 1;
+            }
+        }
         if (args.command === "remove-repo") {
             try {
                 const result = await removeRepoMapping(args.label);
@@ -76,6 +122,15 @@ export class ForgeBridgeCliService {
         if (args.command === "cleanup") {
             return await cleanupRepos(args.config, args.mode, args.force, io);
         }
+        if (args.command === "mcp") {
+            const parsed = parseCompletionMcpArgs(args.argv);
+            if (!parsed.ok) {
+                io.stderr.write(`${parsed.error}\n`);
+                return 2;
+            }
+            await runCompletionMcpServer(parsed.config);
+            return 0;
+        }
         let redactionSecrets = readEnvSecretValuesForRedaction();
         try {
             const dispatchJson = await fs.readFile(args.dispatchPath, "utf8");
@@ -139,24 +194,31 @@ function parseEnvSecretGrant(raw) {
     };
 }
 function exactSecrets(dispatch) {
-    return dispatch.apiKeySecretGrant?.secret ? [dispatch.apiKeySecretGrant.secret] : [];
+    return exactSecretValues(dispatch.apiKeySecretGrant?.secret, process.env.FORGE_DEVICE_TOKEN);
 }
 function readEnvSecretValuesForRedaction() {
+    const secrets = [];
     const raw = process.env[apiKeySecretGrantEnv];
-    if (!raw) {
-        return [];
-    }
-    try {
-        return [parseEnvSecretGrant(raw).secret];
-    }
-    catch {
-        return [];
+    if (raw) {
+        try {
+            secrets.push(parseEnvSecretGrant(raw).secret);
+        }
+        catch {
+            // Ignore malformed grant env here; command handling will report the parse error.
+        }
     }
+    return exactSecretValues(...secrets, process.env.FORGE_DEVICE_TOKEN);
+}
+function exactSecretValues(...values) {
+    return values.filter((value) => typeof value === "string" && value.length > 0);
 }
 export function parseArgs(argv) {
     if (argv[0] === "connect") {
         return parseConnectArgs(argv);
     }
+    if (argv[0] === "pair") {
+        return parsePairArgs(argv);
+    }
     if (argv[0] === "add-repo") {
         if (!argv[1] || !argv[2] || argv.length > 3) {
             return { ok: false, error: "Usage: forge-bridge add-repo <label> <path>" };
@@ -185,10 +247,13 @@ export function parseArgs(argv) {
     if (argv[0] === "cleanup") {
         return parseCleanupArgs(argv);
     }
+    if (argv[0] === "mcp") {
+        return { ok: true, command: "mcp", argv };
+    }
     if (argv[0] !== "run-once") {
         return {
             ok: false,
-            error: "Usage: forge-bridge run-once --dispatch <dispatch-json-path> --result <result-json-path> | forge-bridge connect --server <url> --runner-id <id> --device-token <token> | forge-bridge add-repo <label> <path> | forge-bridge remove-repo <label> | forge-bridge status [--check-updates] | forge-bridge cleanup [--stale|--merged|--all|--force]"
+            error: usage()
         };
     }
     let dispatchPath = null;
@@ -223,7 +288,7 @@ function parseConnectArgs(argv) {
     let heartbeatIntervalMs = null;
     const cliProviders = [];
     const projectLabels = [];
-    let cleanupWorktrees = true;
+    let cleanupWorktrees = null;
     for (let index = 1; index < argv.length; index += 1) {
         const arg = argv[index];
         if (arg === "--server") {
@@ -253,6 +318,9 @@ function parseConnectArgs(argv) {
         else if (arg === "--no-cleanup-worktrees") {
             cleanupWorktrees = false;
         }
+        else if (arg === "--cleanup-worktrees") {
+            cleanupWorktrees = true;
+        }
         else {
             return { ok: false, error: `Unknown argument: ${arg}` };
         }
@@ -261,7 +329,7 @@ function parseConnectArgs(argv) {
     if (serverUrl === null && !process.env.FORGE_URL?.trim() && !localConfig.serverUrl?.trim()) {
         return { ok: false, error: "forge-bridge connect requires --server or FORGE_URL." };
     }
-    const overrides = { cleanupWorktrees };
+    const overrides = {};
     if (serverUrl !== null)
         overrides.serverUrl = serverUrl;
     if (runnerId !== null)
@@ -276,12 +344,79 @@ function parseConnectArgs(argv) {
         overrides.projectLabels = projectLabels;
     if (heartbeatIntervalMs !== null)
         overrides.heartbeatIntervalMs = heartbeatIntervalMs;
+    if (cleanupWorktrees !== null)
+        overrides.cleanupWorktrees = cleanupWorktrees;
     return {
         ok: true,
         command: "connect",
         config: configuredBridgeServiceConfig(overrides, localConfig)
     };
 }
+function parsePairArgs(argv) {
+    const localConfig = readLocalConfigSync();
+    const defaultConfig = configuredBridgeServiceConfig({}, localConfig);
+    let serverUrl = defaultConfig.serverUrl;
+    let code = null;
+    let name = null;
+    let fingerprint = null;
+    let repoRoot = null;
+    let cleanupWorktrees = null;
+    const cliProviders = [];
+    const projectLabels = [];
+    for (let index = 1; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === "--server") {
+            serverUrl = argv[++index] ?? "";
+        }
+        else if (arg === "--code") {
+            code = argv[++index] ?? null;
+        }
+        else if (arg === "--name") {
+            name = argv[++index] ?? null;
+        }
+        else if (arg === "--fingerprint") {
+            fingerprint = argv[++index] ?? null;
+        }
+        else if (arg === "--repo-root") {
+            repoRoot = argv[++index] ?? null;
+        }
+        else if (arg === "--cli-provider") {
+            cliProviders.push(...splitCsv(argv[++index] ?? ""));
+        }
+        else if (arg === "--project-label") {
+            projectLabels.push(...splitCsv(argv[++index] ?? ""));
+        }
+        else if (arg === "--cleanup-worktrees") {
+            cleanupWorktrees = true;
+        }
+        else if (arg === "--no-cleanup-worktrees") {
+            cleanupWorktrees = false;
+        }
+        else if (!arg.startsWith("-") && code === null) {
+            code = arg;
+        }
+        else {
+            return { ok: false, error: `Unknown argument: ${arg}` };
+        }
+    }
+    if (!serverUrl.trim()) {
+        return { ok: false, error: "forge-bridge pair requires --server or configured serverUrl." };
+    }
+    const defaultName = `Local bridge ${os.hostname()}`;
+    const user = os.userInfo().username;
+    return {
+        ok: true,
+        command: "pair",
+        serverUrl,
+        code: normalizePairingCode(code),
+        name: name?.trim() || defaultName,
+        fingerprint: fingerprint?.trim() || `local-bridge:${os.hostname()}:${user}`,
+        repoRoot: repoRoot?.trim() ? path.resolve(repoRoot) : undefined,
+        cleanupWorktrees: cleanupWorktrees ?? localConfig.cleanupWorktrees ?? false,
+        cliProviders: cliProviders.length > 0 ? cliProviders : localConfig.cliProviders && localConfig.cliProviders.length > 0 ? [...localConfig.cliProviders] : ["codex"],
+        projectLabels: projectLabels.length > 0 ? projectLabels : localConfig.projectLabels ? [...localConfig.projectLabels] : []
+    };
+}
 function parseCleanupArgs(argv) {
     let mode = "stale";
     let force = false;
@@ -317,6 +452,293 @@ function splitCsv(value) {
         .map((entry) => entry.trim())
         .filter((entry) => entry.length > 0);
 }
+async function claimBridgeRunner(args) {
+    if (!args.code) {
+        throw new Error("Pairing code is required.");
+    }
+    const response = await fetch(new URL("/api/runners/claim", normalizeServerUrl(args.serverUrl)), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            code: args.code,
+            name: args.name,
+            fingerprint: args.fingerprint,
+            cliProviders: args.cliProviders,
+            projectLabels: args.projectLabels
+        })
+    });
+    if (!response.ok) {
+        throw new Error(`Pairing failed (${response.status}): ${await response.text()}`);
+    }
+    const value = await response.json();
+    if (!value.runnerId || !value.deviceToken) {
+        throw new Error("Pairing response did not include runner credentials.");
+    }
+    return {
+        runnerId: value.runnerId,
+        deviceToken: value.deviceToken
+    };
+}
+function pairedConfig(current, args, claim) {
+    return {
+        ...current,
+        schemaVersion: 2,
+        serverUrl: args.serverUrl,
+        runnerId: claim.runnerId,
+        deviceToken: claim.deviceToken,
+        deviceName: args.name,
+        defaultRepoRoot: args.repoRoot ?? current.defaultRepoRoot,
+        cleanupWorktrees: args.cleanupWorktrees,
+        cliProviders: [...args.cliProviders],
+        providerStatuses: current.providerStatuses ?? providerStatusesFor(args.cliProviders),
+        projectLabels: [...args.projectLabels],
+        supportsApiSecretGrant: current.supportsApiSecretGrant ?? true,
+        supportsManagedWorktrees: current.supportsManagedWorktrees ?? true,
+        supportsManagedForgeArtifacts: current.supportsManagedForgeArtifacts ?? true,
+        supportsRunnerAuthoredPhaseArtifacts: current.supportsRunnerAuthoredPhaseArtifacts ?? true,
+        supportsDraftRunOnce: current.supportsDraftRunOnce ?? true,
+        repoMappings: current.repoMappings ?? []
+    };
+}
+async function resolvePairingCode(code) {
+    const normalized = normalizePairingCode(code);
+    if (normalized) {
+        return normalized;
+    }
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new Error("Pairing code is required. Run `forge-bridge pair <code>` or use an interactive terminal.");
+    }
+    const prompt = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await prompt.question("Pairing code: ");
+        const clean = normalizePairingCode(answer);
+        if (!clean) {
+            throw new Error("Pairing code is required.");
+        }
+        return clean;
+    }
+    finally {
+        prompt.close();
+    }
+}
+async function resolvePairRepoRoot(repoRoot, configuredRoot) {
+    const fallback = path.resolve(repoRoot ?? configuredRoot ?? path.join(os.homedir(), "ForgeRepos"));
+    if (repoRoot?.trim()) {
+        return fallback;
+    }
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        return fallback;
+    }
+    const prompt = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await prompt.question(`Repo folder [${fallback}]: `);
+        return path.resolve(answer.trim() || fallback);
+    }
+    finally {
+        prompt.close();
+    }
+}
+function normalizePairingCode(code) {
+    return code?.replace(/[\s-]/g, "").trim() ?? "";
+}
+function normalizeServerUrl(serverUrl) {
+    return serverUrl.endsWith("/") ? serverUrl : `${serverUrl}/`;
+}
+function usage() {
+    return helpText();
+}
+function helpText() {
+    const version = defaultBridgeServiceConfig().version ?? forgeBridgeVersion;
+    return [
+        `🛠 Forge Bridge ${version} — Local provider runners for Forge.`,
+        "",
+        "Usage: forge-bridge [options] [command]",
+        "",
+        "Options:",
+        "  -h, --help       Display help for command",
+        "  -v, --version    Output the version number",
+        "",
+        "Commands:",
+        "  Hint: commands suffixed with * have detailed help. Run <command> --help for details.",
+        "  connect *        Start the runner bridge and wait for Forge dispatches",
+        "  pair *           Pair this machine with Forge and save runner credentials",
+        "  status *         Show config, runner identity, repos, provider CLIs, and updates",
+        "  add-repo *       Map a Forge repo label/name to a local checkout path",
+        "  remove-repo *    Remove a saved repo mapping",
+        "  cleanup *        Prune managed bridge worktrees",
+        "  version *        Print the installed bridge package version",
+        "  help *           Display help for command",
+        "  run-once *       Internal: run one dispatch packet from JSON",
+        "  mcp *            Internal: run the phase-completion MCP server",
+        "",
+        "Examples:",
+        "  npm install -g @loucompanion/forge-bridge@next",
+        "  forge-bridge pair 1234-5678 --server https://srv1493013.tail66073d.ts.net:8443 --repo-root \"%USERPROFILE%\\ForgeRepos\"",
+        "  forge-bridge connect",
+        "  forge-bridge status --check-updates",
+        "  forge-bridge add-repo Forge D:\\Programming\\repos\\Forge",
+        "  forge-bridge cleanup --stale",
+        "",
+        "Troubleshooting:",
+        "  If Forge says the bridge is old: npm install -g @loucompanion/forge-bridge@next",
+        "  If connect shows 502/500: leave it open; it reconnects with backoff while dev restarts.",
+        "  If a provider is missing: run forge-bridge status --check-updates and verify CLI login.",
+        "",
+        "Docs:",
+        "  https://github.com/coleman399/Forge/tree/develop/tools/forge-bridge#readme",
+        "",
+    ].join("\n");
+}
+function commandHelpText(command) {
+    switch (command) {
+        case "pair":
+            return [
+                "Forge Bridge — pair",
+                "Pair this machine with Forge and save runner credentials.",
+                "",
+                "Usage:",
+                "  forge-bridge pair [code] [options]",
+                "",
+                "Options:",
+                "  --server <url>              Forge server URL.",
+                "  --repo-root <path>          Folder where bridge-managed repos/worktrees live.",
+                "  --name <name>               Display name for this runner.",
+                "  --fingerprint <value>       Stable device fingerprint override.",
+                "  --cli-provider <list>       Comma-separated providers, e.g. codex,cursor.",
+                "  --cleanup-worktrees         Enable managed worktree cleanup.",
+                "  --no-cleanup-worktrees      Disable managed worktree cleanup.",
+                "",
+                "Example:",
+                "  forge-bridge pair 1234-5678 --server https://forge.example.com --repo-root \"%USERPROFILE%\\ForgeRepos\"",
+                "",
+            ].join("\n");
+        case "connect":
+            return [
+                "Forge Bridge — connect",
+                "Start the runner bridge and keep it connected for Forge dispatches.",
+                "",
+                "Usage:",
+                "  forge-bridge connect [options]",
+                "",
+                "Options:",
+                "  --server <url>              Forge server URL; saved config is used when omitted.",
+                "  --runner-id <id>            Runner id; saved config is used when omitted.",
+                "  --device-token <token>      Device token; saved config is used when omitted.",
+                "  --repo-root <path>          Override repo/worktree folder for this run.",
+                "  --cli-provider <list>       Comma-separated providers, e.g. codex,cursor.",
+                "  --heartbeat-interval-ms <n> Heartbeat interval in milliseconds.",
+                "  --cleanup-worktrees         Enable managed worktree cleanup for this run.",
+                "  --no-cleanup-worktrees      Disable managed worktree cleanup for this run.",
+                "",
+                "Example:",
+                "  forge-bridge connect",
+                "",
+            ].join("\n");
+        case "status":
+            return [
+                "Forge Bridge — status",
+                "Show saved configuration, paired runner identity, repo mappings, detected provider CLIs, and optional update info.",
+                "",
+                "Usage:",
+                "  forge-bridge status [--check-updates]",
+                "",
+                "Example:",
+                "  forge-bridge status --check-updates",
+                "",
+            ].join("\n");
+        case "add-repo":
+            return [
+                "Forge Bridge — add-repo",
+                "Map a Forge repo label/name to an existing local checkout.",
+                "",
+                "Usage:",
+                "  forge-bridge add-repo <label> <path>",
+                "",
+                "Example:",
+                "  forge-bridge add-repo Forge D:\\Programming\\repos\\Forge",
+                "",
+            ].join("\n");
+        case "remove-repo":
+            return [
+                "Forge Bridge — remove-repo",
+                "Remove a saved local repo mapping.",
+                "",
+                "Usage:",
+                "  forge-bridge remove-repo <label>",
+                "",
+            ].join("\n");
+        case "cleanup":
+            return [
+                "Forge Bridge — cleanup",
+                "Prune managed bridge worktrees under the configured repo folder.",
+                "",
+                "Usage:",
+                "  forge-bridge cleanup [--stale|--merged|--all] [--force]",
+                "",
+                "Examples:",
+                "  forge-bridge cleanup --stale",
+                "  forge-bridge cleanup --all --force",
+                "",
+            ].join("\n");
+        case "run-once":
+            return [
+                "Forge Bridge — run-once",
+                "Internal command used by Forge to run a single dispatch packet.",
+                "",
+                "Usage:",
+                "  forge-bridge run-once --dispatch <dispatch-json-path> --result <result-json-path>",
+                "",
+            ].join("\n");
+        case "mcp":
+            return [
+                "Forge Bridge — mcp",
+                "Internal MCP server used by provider CLIs to report Forge phase artifacts.",
+                "",
+                "Usage:",
+                "  forge-bridge mcp --worktree <path> --work-item-id <id> --phase <phase>",
+                "",
+            ].join("\n");
+        case "version":
+            return [
+                "Forge Bridge — version",
+                "Print the installed bridge package version.",
+                "",
+                "Usage:",
+                "  forge-bridge version",
+                "",
+            ].join("\n");
+        default:
+            return [
+                `Unknown forge-bridge command: ${command}`,
+                "",
+                "Run `forge-bridge help` to see available commands.",
+                "",
+            ].join("\n");
+    }
+}
+function connectStartupText(config) {
+    const runner = config.runnerId
+        ? `${config.runnerId}${config.deviceName ? ` (${config.deviceName})` : ""}`
+        : "not configured";
+    return [
+        `Forge Bridge ${config.version}`,
+        "Starting runner bridge...",
+        "",
+        "Startup:",
+        `  server: ${config.serverUrl || "not configured"}`,
+        `  runner: ${runner}`,
+        `  config: ${resolveLocalConfigPath()}`,
+        `  repo folder: ${config.defaultRepoRoot || "not configured"}`,
+        `  providers: ${formatList(config.cliProviders)}`,
+        `  cleanup worktrees: ${config.cleanupWorktrees ? "enabled" : "disabled"}`,
+        "",
+        "Press Ctrl+C to stop.",
+        "",
+    ].join("\n");
+}
+function formatList(values) {
+    return values.length > 0 ? values.join(", ") : "none";
+}
 async function writeJsonAtomic(outputPath, value) {
     await fs.mkdir(path.dirname(outputPath), { recursive: true });
     const tempPath = `${outputPath}.${process.pid}.${Date.now()}.tmp`;
@@ -343,7 +765,8 @@ async function writeStatus(config, checkUpdates, io) {
     }
     io.stdout.write("Detected CLIs:\n");
     for (const cli of detected) {
-        io.stdout.write(`  ${cli.provider}: ${cli.found ? cli.version || "found" : "not found"}\n`);
+        const models = cli.models.length > 0 ? `, ${cli.models.length} models` : "";
+        io.stdout.write(`  ${cli.provider}: ${cli.found ? `${cli.version || "found"}${models}` : "not found"}\n`);
     }
     if (checkUpdates) {
         io.stdout.write("Update check: no update channel configured.\n");
@@ -385,16 +808,198 @@ async function cleanupRepos(config, mode, force, io) {
 async function detectCliProviders(providers) {
     const results = [];
     for (const provider of providers) {
-        try {
-            const result = await execFileAsync(provider, ["--version"], { timeout: 2000 });
-            results.push({ provider, found: true, version: `${result.stdout || result.stderr}`.trim().split(/\r?\n/, 1)[0] ?? "" });
-        }
-        catch {
-            results.push({ provider, found: false, version: "" });
+        let detected = null;
+        for (const probe of cliProbeCommandsFor(provider)) {
+            try {
+                detected = await execVersionCommand(probe);
+                break;
+            }
+            catch {
+                // Try the next provider-specific probe.
+            }
         }
+        results.push({
+            provider,
+            found: detected !== null,
+            version: detected ? versionLine(`${detected.stdout || detected.stderr}`) : "",
+            models: detected ? await detectCliModels(provider) : []
+        });
     }
     return results;
 }
+function cliProbeCommandsFor(provider) {
+    const normalized = provider.toLowerCase();
+    if (normalized === "codex") {
+        return [
+            { command: "codex", args: ["-V"] },
+            { command: "codex", args: ["--version"] }
+        ];
+    }
+    if (normalized === "cursor") {
+        return [
+            { command: "cursor-agent", args: ["-v"] },
+            { command: "agent", args: ["-v"] },
+            { command: "cursor-agent", args: ["--version"] },
+            { command: "agent", args: ["--version"] }
+        ];
+    }
+    return [
+        { command: provider, args: ["--version"] },
+        { command: provider, args: ["-V"] }
+    ];
+}
+async function execVersionCommand(probe, timeout = 2000) {
+    const directLaunch = process.platform === "win32"
+        ? await resolveCursorAgentDirectLaunch(probe.command, probe.args)
+        : null;
+    if (directLaunch) {
+        return await execFileAsync(directLaunch.command, [...directLaunch.args], { timeout });
+    }
+    try {
+        return await execFileAsync(probe.command, probe.args, { timeout });
+    }
+    catch (error) {
+        if (process.platform !== "win32") {
+            throw error;
+        }
+        return await execFileAsync(process.env.ComSpec ?? "cmd.exe", ["/d", "/s", "/c", windowsCommandLine(probe)], { timeout });
+    }
+}
+function windowsCommandLine(probe) {
+    return [probe.command, ...probe.args].map(quoteWindowsCommandLineArg).join(" ");
+}
+function quoteWindowsCommandLineArg(value) {
+    if (value.length > 0 && !/[\s"]/.test(value)) {
+        return value;
+    }
+    return `"${value.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/g, "$1$1")}"`;
+}
+function versionLine(output) {
+    const lines = output
+        .trim()
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    return lines.at(-1) ?? "";
+}
+async function detectCliModels(provider) {
+    const normalized = provider.toLowerCase();
+    try {
+        if (normalized === "codex") {
+            const result = await execFileAsync("codex", ["debug", "models"], { timeout: 5000, maxBuffer: 10 * 1024 * 1024 });
+            return parseCodexModelCatalog(result.stdout);
+        }
+        if (normalized === "cursor") {
+            const result = await execVersionCommand({ command: "cursor-agent", args: ["models"] }, 10_000);
+            return parseCursorModelList(`${result.stdout || result.stderr}`);
+        }
+    }
+    catch {
+        return [];
+    }
+    return [];
+}
+export function parseCodexModelCatalog(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!isRecord(parsed) || !Array.isArray(parsed.models)) {
+            return [];
+        }
+        const entries = parsed.models
+            .map((entry, index) => {
+            if (!isRecord(entry) || typeof entry.slug !== "string") {
+                return null;
+            }
+            const visibility = typeof entry.visibility === "string" ? entry.visibility.toLowerCase() : "list";
+            if (visibility !== "list") {
+                return null;
+            }
+            const priority = typeof entry.priority === "number" && Number.isFinite(entry.priority) ? entry.priority : index;
+            return { slug: entry.slug, priority, index };
+        })
+            .filter((entry) => entry !== null)
+            .sort((left, right) => left.priority - right.priority || left.index - right.index)
+            .map((entry) => entry.slug);
+        return uniqueModels(entries);
+    }
+    catch {
+        return [];
+    }
+}
+export function parseCursorModelList(raw) {
+    return uniqueModels(raw
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0 && !line.toLowerCase().startsWith("available models"))
+        .map((line) => line.split(/\s+-\s+/, 1)[0]?.trim() ?? "")
+        .filter((model) => model.length > 0));
+}
+function uniqueModels(models) {
+    const seen = new Set();
+    const result = [];
+    for (const model of models) {
+        const trimmed = model.trim();
+        const key = trimmed.toLowerCase();
+        if (!trimmed || seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        result.push(trimmed);
+    }
+    return result;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+async function withDetectedCliProviders(config) {
+    const detected = await detectCliProviders(configuredProviderCandidates(config.cliProviders));
+    const found = detected.filter((result) => result.found);
+    if (found.length === 0) {
+        return config;
+    }
+    const cliProviders = uniqueProviders([...config.cliProviders, ...found.map((result) => result.provider)]);
+    const providerStatuses = { ...config.providerStatuses };
+    for (const result of found) {
+        const existing = providerStatuses[result.provider];
+        providerStatuses[result.provider] = {
+            signedIn: existing?.signedIn ?? true,
+            version: result.version || existing?.version || "",
+            models: result.models.length > 0
+                ? result.models
+                : existing?.models ?? providerStatusesFor([result.provider])[result.provider]?.models ?? []
+        };
+    }
+    return {
+        ...config,
+        cliProviders,
+        providerStatuses
+    };
+}
+async function withDetectedPairCliProviders(args) {
+    const detectedConfig = await withDetectedCliProviders({
+        ...defaultBridgeServiceConfig({
+            serverUrl: args.serverUrl,
+            cliProviders: [...args.cliProviders],
+            providerStatuses: providerStatusesFor(args.cliProviders),
+            projectLabels: [...args.projectLabels],
+            cleanupWorktrees: args.cleanupWorktrees,
+            defaultRepoRoot: args.repoRoot ?? defaultBridgeServiceConfig().defaultRepoRoot
+        })
+    });
+    return {
+        ...args,
+        cliProviders: detectedConfig.cliProviders
+    };
+}
+function configuredProviderCandidates(providers) {
+    return uniqueProviders([...providers, "codex", "cursor"]);
+}
+function uniqueProviders(providers) {
+    return providers
+        .map((provider) => provider.trim())
+        .filter((provider) => provider.length > 0)
+        .filter((provider, index, all) => all.findIndex((candidate) => candidate.toLowerCase() === provider.toLowerCase()) === index);
+}
 async function runGit(cwd, args) {
     await execFileAsync("git", args, { cwd, timeout: 10_000 });
 }