@miraland-labs/conduit-bridge 0.14.3 → 0.14.5

package/dist/cli.js

@@ -4,7 +4,7 @@ import { resolve, dirname, join as pathJoin } from "node:path";
 import { hostname, homedir, platform, userInfo } from "node:os";
 import { spawn } from "node:child_process";
 import { createInterface } from "node:readline/promises";
-import { chmodSync, cpSync, existsSync, mkdirSync, readFileSync, readdirSync } from "node:fs";
+import { chmodSync, cpSync, existsSync, mkdirSync, readdirSync } from "node:fs";
 import { stdin as input, stdout as output } from "node:process";
 import { fileURLToPath } from "node:url";
 import { ConduitClient, ConduitRequestError } from "./client.js";
@@ -20,17 +20,8 @@ import { loadOpsEnv, OPS_VERBS, runOps } from "./ops.js";
 import { pumpExecutionSlots, renewLeases } from "./execution.js";
 import { installRunnerService, uninstallRunnerService } from "./service.js";
 import { BRIDGE_PROTOCOL_VERSION, cachedBridgePreflight, unavailableWorkspacePreflight } from "./preflight.js";
+import { bridgeVersion } from "./version.js";
 const [command] = process.argv.slice(2);
-/** Read our own package version so every runner start logs exactly which build is live. */
-function bridgeVersion() {
-    try {
-        const packagePath = pathJoin(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
-        return JSON.parse(readFileSync(packagePath, "utf8")).version ?? "unknown";
-    }
-    catch {
-        return "unknown";
-    }
-}
 /** Install-free form shown in help/output so clean laptops never need `conduit` on PATH. */
 const BRIDGE_NPX = "npx @miraland-labs/conduit-bridge";
 function bridgeUsage(...args) {
@@ -305,7 +296,7 @@ async function installService() {
         agentTimeoutMinutes: values["agent-timeout-minutes"],
         ensureCheckout: values["ensure-checkout"],
     });
-    console.log(`Installed Conduit runner service (${result.platform}): ${result.path}`);
+    console.log(`Installed Conduit Bridge v${bridgeVersion()} (protocol ${BRIDGE_PROTOCOL_VERSION}) runner service (${result.platform}): ${result.path}`);
     console.log(`Online lanes: ${onlineDriverIds(config).join(", ")}. Toggle with \`${bridgeUsage("drivers", "online|offline", "…")}\`.`);
     console.log("The runner keeps executing after this terminal closes. Laptop sleep still pauses work.");
 }
@@ -475,6 +466,11 @@ async function runner() {
                 ? await cachedBridgePreflight({ config, workspace, brief: currentBrief ?? undefined })
                 : unavailableWorkspacePreflight({ config });
             const hb = await heartbeat(client, config, currentBrief, preflight);
+            if (hb.staleBridge) {
+                console.error(`Bridge update required: running protocol ${BRIDGE_PROTOCOL_VERSION}; control plane requires protocol ${hb.requiredProtocol ?? "unknown"} (minimum Bridge ${hb.minimumVersion ?? "unknown"}). Reinstall the latest Bridge, then restart this runner.`);
+                await new Promise((resolveSleep) => setTimeout(resolveSleep, Math.max(intervalMs, 60_000)));
+                continue;
+            }
             const applied = await maybeApplyOnShiftIntent({
                 client,
                 currentWorkspace: workspace,
@@ -535,10 +531,18 @@ async function heartbeat(client, config, brief, preflight) {
             preflight,
             ...(brief ? { workspace_brief: brief } : {}),
         }) });
+    const compatibility = response.bridge_compatibility && typeof response.bridge_compatibility === "object"
+        ? response.bridge_compatibility
+        : null;
     const onShift = response.on_shift && typeof response.on_shift === "object"
         ? response.on_shift
         : null;
-    return { on_shift: onShift };
+    return {
+        on_shift: onShift,
+        staleBridge: response.stale_bridge === true,
+        ...(typeof compatibility?.minimum_version === "string" ? { minimumVersion: compatibility.minimum_version } : {}),
+        ...(typeof compatibility?.required_protocol === "number" ? { requiredProtocol: compatibility.required_protocol } : {}),
+    };
 }
 async function disconnect() {
     const { values } = parseArgs({ args: process.argv.slice(3), options: { yes: { type: "boolean", short: "y" } } });

package/dist/client.js

@@ -40,11 +40,15 @@ export class ConduitClient {
         return data;
     }
     async claim(taskId, attemptId, extras) {
-        const data = await this.request(`/runner/v1/tasks/${taskId}/claim`, { method: "POST", body: JSON.stringify({ attempt_id: attemptId, idempotency_key: `bridge:claim:${attemptId}` }) });
+        // The lease token is this machine's bearer credential for the attempt. The server stores only
+        // its hash, so the client mints it and re-sends the identical token if it ever retries the
+        // claim (the idempotency key is deterministic per attempt exactly so that replay works).
+        const leaseToken = `lease_${crypto.randomUUID()}${crypto.randomUUID()}`;
+        const data = await this.request(`/runner/v1/tasks/${taskId}/claim`, { method: "POST", body: JSON.stringify({ attempt_id: attemptId, lease_token: leaseToken, idempotency_key: `bridge:claim:${attemptId}` }) });
         const active = {
             taskId,
             attemptId,
-            leaseToken: String(data.lease_token),
+            leaseToken,
             leaseExpiresAt: String(data.lease_expires_at),
             phase: "claimed",
             ...(extras?.driverId ? { driverId: extras.driverId } : {}),

package/dist/ops.js

@@ -11,11 +11,27 @@ 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";
+import { BRIDGE_PROTOCOL_VERSION, describePreflightIssue, runBridgePreflight } from "./preflight.js";
+import { bridgeVersion } from "./version.js";
 export const OPS_VERBS = [
     "connect", "install", "switch", "online", "offline", "status", "doctor", "disconnect", "uninstall",
 ];
 const LOCAL_FUEL_DRIVERS = new Set(["cursor", "pi", "kiro", "antigravity"]);
+function bridgeVersionAtLeast(value, minimum) {
+    const parse = (input) => {
+        const match = /^(\d+)\.(\d+)\.(\d+)/.exec(input);
+        return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
+    };
+    const actual = parse(value);
+    const required = parse(minimum);
+    if (!actual || !required)
+        return false;
+    for (let index = 0; index < 3; index += 1) {
+        if (actual[index] !== required[index])
+            return actual[index] > required[index];
+    }
+    return true;
+}
 export function defaultOpsEnvPath(home = homedir()) {
     return join(home, ".config", "conduit", "ops.env");
 }
@@ -177,6 +193,27 @@ export async function runOps(verb, argv = [], deps = {}) {
         return;
     }
     if (verb === "status") {
+        const packageVersion = bridgeVersion();
+        console.log(`Bridge: v${packageVersion} (protocol ${BRIDGE_PROTOCOL_VERSION})`);
+        try {
+            const config = await (deps.loadBridgeConfig ?? loadConfig)();
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 5_000);
+            let compatibility;
+            try {
+                compatibility = await new ConduitClient(config).request("/runner/v1/compatibility", { signal: controller.signal });
+            }
+            finally {
+                clearTimeout(timeout);
+            }
+            const minimumVersion = typeof compatibility.minimum_version === "string" ? compatibility.minimum_version : "unknown";
+            const requiredProtocol = typeof compatibility.required_protocol === "number" ? compatibility.required_protocol : "unknown";
+            const compatible = minimumVersion === "unknown" || (bridgeVersionAtLeast(packageVersion, minimumVersion) && (requiredProtocol === "unknown" || BRIDGE_PROTOCOL_VERSION >= requiredProtocol));
+            console.log(`Control plane: requires Bridge ${minimumVersion} (protocol ${requiredProtocol})${compatible ? "" : " — UPDATE REQUIRED"}`);
+        }
+        catch {
+            console.log("Control plane: compatibility check unavailable (showing local Bridge only)");
+        }
         if (env.loadedFrom) {
             console.log(`Env: ${env.loadedFrom}`);
             console.log(`URL: ${env.CONDUIT_URL || "(unset)"}`);
@@ -368,6 +405,7 @@ export async function runOps(verb, argv = [], deps = {}) {
             const runnerArgs = ["runner", "--workspace", workspace];
             if (installEnv.CONDUIT_REPO)
                 runnerArgs.push("--ensure-checkout", installEnv.CONDUIT_REPO);
+            console.log(`Bridge: v${bridgeVersion()} (protocol ${BRIDGE_PROTOCOL_VERSION})`);
             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)}`);
@@ -377,6 +415,7 @@ export async function runOps(verb, argv = [], deps = {}) {
         const installArgs = ["install-service", "--workspace", workspace];
         if (installEnv.CONDUIT_REPO)
             installArgs.push("--ensure-checkout", installEnv.CONDUIT_REPO);
+        console.log(`Bridge: v${bridgeVersion()} (protocol ${BRIDGE_PROTOCOL_VERSION})`);
         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/preflight.js

@@ -16,7 +16,9 @@ function modelsFingerprint(config) {
     }).join(";");
     return createHash("sha256").update(canonical).digest("hex").slice(0, 16);
 }
-export const BRIDGE_PROTOCOL_VERSION = 4;
+// Protocol 5 makes the lease-token claim contract explicit. Older Bridges may report a green
+// preflight but cannot claim against the current control plane, so they must be admitted as stale.
+export const BRIDGE_PROTOCOL_VERSION = 5;
 const execFileAsync = promisify(execFile);
 async function defaultCommandRunner(command, args, cwd) {
     try {

package/dist/version.js

@@ -0,0 +1,13 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+/** Read the version of the Bridge package that is actually running. */
+export function bridgeVersion() {
+    try {
+        const packagePath = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+        return JSON.parse(readFileSync(packagePath, "utf8")).version ?? "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}

package/package.json

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