@miraland-labs/conduit-bridge 0.11.9 → 0.11.10

package/dist/cli.js

@@ -15,9 +15,10 @@ import { DRIVERS } from "./driver.js";
 import { driversHeartbeatReport, driverLabel, heartbeatStatusForDrivers, isSupportedDriverId, listDriverLanes, onlineDriverIds, seedDriversFromDetection, seedDriverLanes, setDriverFuel, setDriversOnline, } from "./drivers.js";
 import { buildWorkspaceBrief } from "./brief.js";
 import { ensureCheckout } from "./checkout.js";
+import { maybeApplyOnShiftIntent } from "./on-shift-apply.js";
+import { loadOpsEnv, OPS_VERBS, runOps } from "./ops.js";
 import { pumpExecutionSlots, renewLeases } from "./execution.js";
 import { installRunnerService, uninstallRunnerService } from "./service.js";
-import { OPS_VERBS, runOps } from "./ops.js";
 import { BRIDGE_PROTOCOL_VERSION, cachedBridgePreflight, unavailableWorkspacePreflight } from "./preflight.js";
 const [command] = process.argv.slice(2);
 /** Read our own package version so every runner start logs exactly which build is live. */
@@ -473,7 +474,30 @@ async function runner() {
             const preflight = workspace
                 ? await cachedBridgePreflight({ config, workspace, brief: currentBrief ?? undefined })
                 : unavailableWorkspacePreflight({ config });
-            await heartbeat(client, config, currentBrief, preflight);
+            const hb = await heartbeat(client, config, currentBrief, preflight);
+            const applied = await maybeApplyOnShiftIntent({
+                client,
+                currentWorkspace: workspace,
+                onShift: hb.on_shift,
+                runInstall: async (nextWorkspace, repo) => {
+                    let env;
+                    try {
+                        env = loadOpsEnv();
+                    }
+                    catch {
+                        env = undefined;
+                    }
+                    await runOps("install", [], {
+                        env: env
+                            ? { ...env, CONDUIT_WORKSPACE: nextWorkspace, CONDUIT_REPO: repo || env.CONDUIT_REPO }
+                            : undefined,
+                    });
+                },
+            });
+            if (applied) {
+                console.log("On-shift workspace applied; exiting so the background service restarts on the new checkout.");
+                process.exit(0);
+            }
             await renewLeases(client, config);
             if (workspace && onlineDriverIds(config).length) {
                 progressed = await pumpExecutionSlots(client, config, workspace, brief, timeoutMs, {
@@ -500,7 +524,7 @@ async function runner() {
 async function heartbeat(client, config, brief, preflight) {
     const online = onlineDriverIds(config);
     const status = heartbeatStatusForDrivers(online);
-    await client.request("/runner/v1/heartbeat", { method: "POST", body: JSON.stringify({
+    const response = await client.request("/runner/v1/heartbeat", { method: "POST", body: JSON.stringify({
             status,
             capabilities: config.capabilities,
             lease_capacity: config.leaseCapacity,
@@ -511,6 +535,10 @@ async function heartbeat(client, config, brief, preflight) {
             preflight,
             ...(brief ? { workspace_brief: brief } : {}),
         }) });
+    const onShift = response.on_shift && typeof response.on_shift === "object"
+        ? response.on_shift
+        : null;
+    return { on_shift: onShift };
 }
 async function disconnect() {
     const { values } = parseArgs({ args: process.argv.slice(3), options: { yes: { type: "boolean", short: "y" } } });

package/dist/on-shift-apply.js

@@ -0,0 +1,52 @@
+/**
+ * Phase 2: when Connect queued a workspace intent, Bridge applies it once
+ * (ops.env + install/restart) then acks so the next LaunchAgent start uses the new path.
+ */
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+import { defaultOpsEnvPath, expandOpsValue, loadOpsEnv, writeOpsEnvFile } from "./ops.js";
+function pathsEqual(left, right) {
+    return resolve(expandOpsValue(left)) === resolve(expandOpsValue(right));
+}
+/**
+ * If control-plane intent names a different workspace than this runner, apply and return true
+ * (caller should exit so install-service / LaunchAgent restarts).
+ */
+export async function maybeApplyOnShiftIntent(input) {
+    const intentPath = input.onShift?.on_shift_intent?.workspace_path?.trim();
+    if (!intentPath)
+        return false;
+    const target = resolve(expandOpsValue(intentPath));
+    const current = input.currentWorkspace ? resolve(expandOpsValue(input.currentWorkspace)) : null;
+    if (current && pathsEqual(current, target)) {
+        // Already on the declared path — leave intent for Bound clear on heartbeat.
+        return false;
+    }
+    const repo = (input.onShift?.on_shift_intent?.repository_url
+        ?? input.onShift?.expected_repository
+        ?? "").trim();
+    if (input.writeEnv) {
+        input.writeEnv(target, repo);
+    }
+    else {
+        let envPath = defaultOpsEnvPath(homedir());
+        try {
+            envPath = loadOpsEnv().loadedFrom ?? envPath;
+        }
+        catch {
+            // First apply may create ops.env at the default path.
+        }
+        writeOpsEnvFile(envPath, {
+            CONDUIT_WORKSPACE: target,
+            ...(repo ? { CONDUIT_REPO: repo } : {}),
+        });
+    }
+    // Ack before restart so a rebound service does not re-apply forever.
+    await input.client.request("/runner/v1/machine/ack-on-shift-intent", {
+        method: "POST",
+        body: "{}",
+    });
+    console.log(`Applying on-shift workspace intent: ${target}${repo ? ` (${repo})` : ""}`);
+    await input.runInstall(target, repo);
+    return true;
+}

package/dist/ops.js

@@ -232,13 +232,24 @@ export async function runOps(verb, argv = [], deps = {}) {
         const client = new ConduitClient(config);
         const result = await client.request("/runner/v1/machine/switch-project", {
             method: "POST",
-            body: JSON.stringify({ project_id: projectId }),
+            body: JSON.stringify({
+                project_id: projectId,
+                workspace_path: workspace,
+                ...(repo ? { repository_url: repo } : {}),
+            }),
         });
         console.log(`Control plane on-shift: ${String(result.project_id ?? projectId)} (${String(result.binding_status ?? "pending")})`);
         writeOpsEnvFile(envPath, {
             CONDUIT_WORKSPACE: workspace,
             ...(repo ? { CONDUIT_REPO: repo } : {}),
         });
+        // Local apply owns the checkout; clear queued intent so heartbeat does not re-apply.
+        try {
+            await client.request("/runner/v1/machine/ack-on-shift-intent", { method: "POST", body: "{}" });
+        }
+        catch {
+            // Older control planes omit ack — local ops.env still wins.
+        }
         console.log(`Updated ${envPath}`);
         console.log(`On-shift workspace: ${workspace}${repo ? ` (${repo})` : ""}`);
         // Same install path as ops install — restart runner against the new checkout.

package/package.json

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