@miraland-labs/conduit-bridge 0.11.11 → 0.12.0

package/README.md

@@ -51,7 +51,7 @@ Optional local shortcuts after `init-ops` (same verbs):
 
 **Windows note:** `ops install` brings lanes online and prints a `runner --workspace …` command to keep open (no LaunchAgent). macOS/Linux install a background service.
 
-`ops.env` keys: `CONDUIT_URL`, `CONDUIT_ORG` (optional), `CONDUIT_WORKSPACE`, `CONDUIT_REPO` (optional), `CONDUIT_DRIVERS` (default `cursor`), `CONDUIT_ROLES` (default `implement research review`). Values expand `$HOME`, `%USERPROFILE%`, and `~`.
+`ops.env` keys: `CONDUIT_URL`, `CONDUIT_ORG` (optional), `CONDUIT_WORKSPACE`, `CONDUIT_REPO` (optional), `CONDUIT_DRIVERS` (default: auto-detect installed agents), `CONDUIT_ROLES` (default `implement research review`). Values expand `$HOME`, `%USERPROFILE%`, and `~`.
 
 ## Advanced CLI
 

package/dist/cli.js

@@ -359,7 +359,7 @@ async function initOps() {
 async function opsCommand() {
     const verb = process.argv[3];
     if (!verb || !OPS_VERBS.includes(verb)) {
-        throw new Error(`Usage: ${bridgeUsage("ops", "<connect|install|switch|online|offline|status|doctor|disconnect|uninstall>", "[driver…]")}`);
+        throw new Error(`Usage: ${bridgeUsage("ops", "<connect|install|switch|online|offline|status|doctor|disconnect|uninstall>", "[driver…]")} (install also takes --workspace <path> [--repo <url>])`);
     }
     await runOps(verb, process.argv.slice(4));
 }

package/dist/ops.js

@@ -9,6 +9,8 @@ import { dirname, join, resolve } from "node:path";
 import { parseArgs } from "node:util";
 import { ConduitClient } from "./client.js";
 import { loadConfig } from "./config.js";
+import { detectInstalledClients } from "./detect.js";
+import { driverIdsFromDetectedLabels } from "./drivers.js";
 import { describePreflightIssue, runBridgePreflight } from "./preflight.js";
 export const OPS_VERBS = [
     "connect", "install", "switch", "online", "offline", "status", "doctor", "disconnect", "uninstall",
@@ -73,7 +75,7 @@ export function loadOpsEnv(home = homedir(), cwd = process.cwd()) {
         CONDUIT_ORG: pick("CONDUIT_ORG", ""),
         CONDUIT_WORKSPACE: pick("CONDUIT_WORKSPACE", ""),
         CONDUIT_REPO: pick("CONDUIT_REPO", ""),
-        CONDUIT_DRIVERS: pick("CONDUIT_DRIVERS", "cursor"),
+        CONDUIT_DRIVERS: pick("CONDUIT_DRIVERS", ""),
         CONDUIT_ROLES: pick("CONDUIT_ROLES", "implement research review"),
         loadedFrom,
     };
@@ -120,12 +122,21 @@ export function writeOpsEnvFile(path, patch, existingText) {
     }
     writeFileSync(path, `${next.filter((line, index) => !(index === next.length - 1 && line === "")).join("\n").replace(/\n*$/, "\n")}`, { mode: 0o600 });
 }
-export function resolveDrivers(env, argv) {
+/** Explicit ids win; otherwise CONDUIT_DRIVERS; otherwise agents detected on PATH (fail when none). */
+export async function resolveDrivers(env, argv, detect = detectInstalledClients) {
     const fromArgs = argv.map((item) => item.trim()).filter(Boolean);
-    const drivers = fromArgs.length ? fromArgs : splitOpsList(env.CONDUIT_DRIVERS);
-    if (!drivers.length)
-        throw new Error("No drivers. Set CONDUIT_DRIVERS or pass ids.");
-    return drivers;
+    if (fromArgs.length)
+        return fromArgs;
+    const fromEnv = splitOpsList(env.CONDUIT_DRIVERS);
+    if (fromEnv.length)
+        return fromEnv;
+    const detected = driverIdsFromDetectedLabels(await detect());
+    if (detected.length) {
+        console.log(`CONDUIT_DRIVERS not set — using detected agents: ${detected.join(", ")}`);
+        return detected;
+    }
+    throw new Error("No coding agent found on this computer. Install one (Claude Code, Codex, Cursor, OpenCode, Pi, Kiro, Antigravity), " +
+        "then retry — or set CONDUIT_DRIVERS / pass driver ids explicitly.");
 }
 /** Quote args for a copy-pasteable shell/cmd line (paths with spaces). */
 export function shellQuoteArgs(args) {
@@ -171,7 +182,7 @@ export async function runOps(verb, argv = [], deps = {}) {
             console.log(`URL: ${env.CONDUIT_URL || "(unset)"}`);
             console.log(`Workspace: ${env.CONDUIT_WORKSPACE || "(unset)"}`);
             console.log(`Repo: ${env.CONDUIT_REPO || "(none)"}`);
-            console.log(`Drivers: ${env.CONDUIT_DRIVERS}`);
+            console.log(`Drivers: ${env.CONDUIT_DRIVERS || "(auto-detect installed agents)"}`);
             console.log(`Roles: ${env.CONDUIT_ROLES}`);
             console.log("");
         }
@@ -202,11 +213,45 @@ export async function runOps(verb, argv = [], deps = {}) {
     }
     // Lane toggles only need Bridge config + optional driver ids — not a full ops.env.
     if (verb === "online" || verb === "offline") {
-        const drivers = resolveDrivers(env, argv);
+        const drivers = await resolveDrivers(env, argv);
         runBridge(["drivers", verb, ...drivers]);
         return;
     }
-    requireOpsEnv(env);
+    // `ops install --workspace <path> [--repo <url>]` persists declared intent into ops.env so the
+    // Connect UI path works without hand-editing a config file first.
+    let installEnv = env;
+    let installArgv = argv;
+    if (verb === "install") {
+        const { values, positionals } = parseArgs({
+            args: argv,
+            options: {
+                workspace: { type: "string" },
+                repo: { type: "string" },
+            },
+            allowPositionals: true,
+        });
+        installArgv = positionals;
+        const declaredWorkspace = values.workspace?.trim();
+        const declaredRepo = values.repo?.trim();
+        if (declaredWorkspace || declaredRepo) {
+            const envPath = env.loadedFrom ?? defaultOpsEnvPath();
+            writeOpsEnvFile(envPath, {
+                ...(declaredWorkspace ? { CONDUIT_WORKSPACE: declaredWorkspace } : {}),
+                ...(declaredRepo ? { CONDUIT_REPO: declaredRepo } : {}),
+            });
+            console.log(`Saved ${[
+                declaredWorkspace ? `workspace ${declaredWorkspace}` : "",
+                declaredRepo ? `repo ${declaredRepo}` : "",
+            ].filter(Boolean).join(" and ")} to ${envPath}`);
+            installEnv = {
+                ...env,
+                ...(declaredWorkspace ? { CONDUIT_WORKSPACE: declaredWorkspace } : {}),
+                ...(declaredRepo ? { CONDUIT_REPO: declaredRepo } : {}),
+                loadedFrom: env.loadedFrom ?? envPath,
+            };
+        }
+    }
+    requireOpsEnv(verb === "install" ? installEnv : env);
     if (verb === "switch") {
         const { values } = parseArgs({
             args: argv,
@@ -278,10 +323,11 @@ export async function runOps(verb, argv = [], deps = {}) {
         return;
     }
     if (verb === "install") {
-        if (!env.CONDUIT_WORKSPACE)
-            throw new Error(`Set CONDUIT_WORKSPACE in ${defaultOpsEnvPath()}`);
-        const workspace = resolve(expandOpsValue(env.CONDUIT_WORKSPACE));
-        const drivers = resolveDrivers(env, argv);
+        if (!installEnv.CONDUIT_WORKSPACE) {
+            throw new Error(`No workspace declared. Rerun with --workspace /path/to/repo, or set CONDUIT_WORKSPACE in ${defaultOpsEnvPath()}`);
+        }
+        const workspace = resolve(expandOpsValue(installEnv.CONDUIT_WORKSPACE));
+        const drivers = await resolveDrivers(installEnv, installArgv);
         for (const id of drivers) {
             if (LOCAL_FUEL_DRIVERS.has(id))
                 runBridge(["drivers", "fuel", id, "local"]);
@@ -291,8 +337,8 @@ export async function runOps(verb, argv = [], deps = {}) {
         runBridge(["ops", "doctor"]);
         if (host === "win32") {
             const runnerArgs = ["runner", "--workspace", workspace];
-            if (env.CONDUIT_REPO)
-                runnerArgs.push("--ensure-checkout", env.CONDUIT_REPO);
+            if (installEnv.CONDUIT_REPO)
+                runnerArgs.push("--ensure-checkout", installEnv.CONDUIT_REPO);
             console.log("Windows: background install-service is not available.");
             console.log("Keep a terminal open and run:");
             console.log(`  npx @miraland-labs/conduit-bridge@latest ${shellQuoteArgs(runnerArgs)}`);
@@ -300,8 +346,8 @@ export async function runOps(verb, argv = [], deps = {}) {
             return;
         }
         const installArgs = ["install-service", "--workspace", workspace];
-        if (env.CONDUIT_REPO)
-            installArgs.push("--ensure-checkout", env.CONDUIT_REPO);
+        if (installEnv.CONDUIT_REPO)
+            installArgs.push("--ensure-checkout", installEnv.CONDUIT_REPO);
         console.log(`Installing runner for ${workspace} (drivers: ${drivers.join(", ")})`);
         runBridge(installArgs);
         console.log("Done. Check with: npx @miraland-labs/conduit-bridge@latest ops status");

package/dist/service.js

@@ -2,7 +2,7 @@ import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
 import { homedir, platform } from "node:os";
 import { dirname, join } from "node:path";
 import { realpathSync } from "node:fs";
-import { spawnSync } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 export const SERVICE_LABEL = "io.miraland.conduit-runner";
 function configDir() {
     return join(homedir(), ".config", "conduit");
@@ -118,6 +118,22 @@ function run(command, args) {
         throw new Error(`${command} ${args.join(" ")} failed: ${detail}`);
     }
 }
+function shellQuote(value) {
+    return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+/**
+ * `launchctl bootout` of a loaded service kills that service's whole process group — including
+ * this process when install-service runs from inside the runner it replaces (Connect on-shift
+ * auto-apply). Observed in the field (2026-08-05): the runner died at bootout, the bootstrap on
+ * the next line never ran, and the machine stayed Binding incomplete with the service unloaded.
+ * The swap therefore runs in a detached helper that survives the bootout; failures append to the
+ * runner log.
+ */
+export function launchdSwapCommand(domain, plistPath, log) {
+    const plist = shellQuote(plistPath);
+    const logQ = shellQuote(log);
+    return `sleep 1; launchctl bootout ${domain}/${SERVICE_LABEL} 2>>${logQ}; launchctl bootstrap ${domain} ${plist} 2>>${logQ} || launchctl load -w ${plist} 2>>${logQ}`;
+}
 export async function installRunnerService(options = {}) {
     const host = platform();
     if (host !== "darwin" && host !== "linux") {
@@ -129,12 +145,19 @@ export async function installRunnerService(options = {}) {
         await mkdir(dirname(plistPath), { recursive: true });
         await mkdir(dirname(logPath()), { recursive: true });
         await writeFile(plistPath, launchdPlist(programArguments, logPath()), { mode: 0o644 });
-        // Prefer modern bootout/bootstrap; fall back to load for older macOS.
-        spawnSync("launchctl", ["bootout", `gui/${process.getuid?.() ?? 501}/${SERVICE_LABEL}`], { encoding: "utf8" });
-        const boot = spawnSync("launchctl", ["bootstrap", `gui/${process.getuid?.() ?? 501}`, plistPath], { encoding: "utf8" });
-        if (boot.status !== 0) {
-            run("launchctl", ["load", "-w", plistPath]);
+        // Detached helper (bootout → bootstrap → load fallback): see launchdSwapCommand for why the
+        // swap must survive this process dying at bootout.
+        const domain = `gui/${process.getuid?.() ?? 501}`;
+        spawn("/bin/sh", ["-c", launchdSwapCommand(domain, plistPath, logPath())], { detached: true, stdio: "ignore" }).unref();
+        // Confirm the reloaded service when this process survives to see it (an interactive install).
+        // A self-replacing runner dies at the helper's bootout and the helper still finishes the swap.
+        let loaded = false;
+        for (let attempt = 0; attempt < 16 && !loaded; attempt++) {
+            await new Promise((resolveSleep) => setTimeout(resolveSleep, attempt === 0 ? 2000 : 500));
+            loaded = spawnSync("launchctl", ["print", `${domain}/${SERVICE_LABEL}`], { encoding: "utf8" }).status === 0;
         }
+        if (!loaded)
+            throw new Error(`launchd did not load ${SERVICE_LABEL}; see ${logPath()}`);
         await writeFile(serviceStatePath(), `${JSON.stringify({ platform: "darwin", programArguments, options, installed_at: new Date().toISOString() }, null, 2)}\n`, { mode: 0o600 });
         return { path: plistPath, platform: "darwin" };
     }

package/ops/env.example

@@ -11,6 +11,8 @@ CONDUIT_URL=https://api.conduit.miraland.io
 # CONDUIT_ORG=your-org-slug
 CONDUIT_WORKSPACE=$HOME/path/to/your-repo
 # CONDUIT_REPO=https://github.com/your-org/your-repo.git
-CONDUIT_DRIVERS=cursor
+# Leave CONDUIT_DRIVERS unset to auto-detect the coding agents installed on this computer.
+# Pin explicitly only when you want a subset, e.g.:
+# CONDUIT_DRIVERS=claude-code codex
 # Product-standard roles — leave all three so Start/retry plans can match without reconnect.
 CONDUIT_ROLES=implement research review

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miraland-labs/conduit-bridge",
-  "version": "0.11.11",
+  "version": "0.12.0",
   "description": "Conduit Bridge CLI — join, connect, disconnect, multi-driver lanes, and run Claude Code / Codex / Cursor / OpenCode / Pi / Kiro / Antigravity agents for a Conduit organization",
   "type": "module",
   "bin": {