@miraland-labs/conduit-bridge 0.12.1 → 0.12.2

package/dist/service.js

@@ -128,11 +128,55 @@ function shellQuote(value) {
  * 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.
+ *
+ * Interactive `ops install` from a terminal must NOT use only the detached path: on some macOS
+ * hosts `launchctl bootstrap` returns EIO (5) from the helper while an in-process bootstrap of the
+ * same plist succeeds. Prefer a synchronous reload when we are not inside the runner service.
+ * Deprecated `launchctl load -w` also returns EIO on modern macOS — use enable + kickstart instead.
  */
 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}`;
+    const label = `${domain}/${SERVICE_LABEL}`;
+    return [
+        "sleep 1",
+        `launchctl bootout ${label} 2>>${logQ}`,
+        `launchctl bootstrap ${domain} ${plist} 2>>${logQ}`,
+        `launchctl enable ${label} 2>>${logQ}`,
+        `launchctl kickstart -k ${label} 2>>${logQ}`,
+    ].join("; ");
+}
+function launchdServiceLoaded(domain) {
+    return spawnSync("launchctl", ["print", `${domain}/${SERVICE_LABEL}`], { encoding: "utf8" }).status === 0;
+}
+function sleepMs(ms) {
+    return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
+}
+/** True when this process is the LaunchAgent we are about to boot out. */
+export function runningInsideRunnerLaunchAgent() {
+    return process.env.XPC_SERVICE_NAME === SERVICE_LABEL;
+}
+/**
+ * Boot out (ignore miss), bootstrap with retries, then enable + kickstart.
+ * Returns whether `launchctl print` sees the service.
+ */
+export function reloadLaunchdRunnerSync(domain, plistPath) {
+    const label = `${domain}/${SERVICE_LABEL}`;
+    spawnSync("launchctl", ["bootout", label], { encoding: "utf8" });
+    for (let attempt = 0; attempt < 6; attempt++) {
+        const boot = spawnSync("launchctl", ["bootstrap", domain, plistPath], { encoding: "utf8" });
+        if (boot.status === 0 || launchdServiceLoaded(domain))
+            break;
+        spawnSync("launchctl", ["bootout", label], { encoding: "utf8" });
+        // Brief backoff — EIO (5) is often transient right after bootout.
+        const start = Date.now();
+        while (Date.now() - start < 400 * (attempt + 1)) {
+            /* spin */
+        }
+    }
+    spawnSync("launchctl", ["enable", label], { encoding: "utf8" });
+    spawnSync("launchctl", ["kickstart", "-k", label], { encoding: "utf8" });
+    return launchdServiceLoaded(domain);
 }
 export async function installRunnerService(options = {}) {
     const host = platform();
@@ -145,16 +189,25 @@ 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 });
-        // 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 (runningInsideRunnerLaunchAgent()) {
+            // Detached helper must survive bootout of this process.
+            spawn("/bin/sh", ["-c", launchdSwapCommand(domain, plistPath, logPath())], { detached: true, stdio: "ignore" }).unref();
+            for (let attempt = 0; attempt < 20 && !loaded; attempt++) {
+                await sleepMs(attempt === 0 ? 2000 : 500);
+                loaded = launchdServiceLoaded(domain);
+            }
+        }
+        else {
+            // Interactive ops install: reload in-process (avoids helper EIO flakiness).
+            loaded = reloadLaunchdRunnerSync(domain, plistPath);
+            for (let attempt = 0; attempt < 10 && !loaded; attempt++) {
+                await sleepMs(500);
+                loaded = launchdServiceLoaded(domain);
+                if (!loaded)
+                    loaded = reloadLaunchdRunnerSync(domain, plistPath);
+            }
         }
         if (!loaded)
             throw new Error(`launchd did not load ${SERVICE_LABEL}; see ${logPath()}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miraland-labs/conduit-bridge",
-  "version": "0.12.1",
+  "version": "0.12.2",
   "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": {