@frod.io/bridge 0.7.2 → 0.7.4

package/README.md

@@ -1,7 +1,8 @@
 # Frod.io bridge — your computer is a desk
 
-You already have Claude Code on your computer, with your own sign-in, skills,
-memory and tools. The bridge makes that Claude a **session of the platform**:
+You already have at least one supported coding runtime on your computer —
+Claude Code, Codex, or Grok Build — with its own sign-in, settings and tools.
+The bridge makes those ready runtimes available to **sessions of the platform**:
 agents you choose run on your computer, take `@mentions` from Teams and
 Telegram, read their Inbox, sit in the Office, run blueprint steps and file
 into the map — governed and metered like every other agent — and nothing of
@@ -20,7 +21,11 @@ npx @frod.io/bridge@latest join <code> --api https://api.agentic.frod.io [--name
 
 `npx` only bootstraps the command. `join` itself:
 
-- checks that `claude` is installed and signed in (`claude auth login`);
+- checks Claude Code, Codex, and Grok Build once each, and offers exactly the
+  **READY set**: a runtime is READY only when it is installed and its sign-in
+  check explicitly says it is signed in. The computer may therefore join with
+  Codex only, Claude Code only, Grok Build only, or any mixed-ready set; it
+  does not need Claude Code when Codex or Grok Build is READY;
 - exchanges the code for a token and keeps it in your OS keychain — macOS's
   `security`, set up so the item trusts `/usr/bin/security` and never pops a
   dialog; Linux's `secret-tool`; anywhere else a 0600 file, and it says so;
@@ -38,6 +43,22 @@ npx @frod.io/bridge@latest join <code> --api https://api.agentic.frod.io [--name
 Pass `--no-install` to join without any of the install/run-at-login steps —
 useful if you'd rather run `install` or `run` by hand afterwards.
 
+An installed runtime whose sign-in result is false is not READY. Neither is a
+runtime whose probe is unreadable, invalid, ambiguous, timed out, or unable to
+run; an unreadable result never becomes READY by assumption. Other READY
+runtimes still let the computer join, and only those READY runtimes are
+offered. If none is READY, `join` stops before exchanging the code and always
+starts its refusal with this exact text:
+
+```text
+No supported runtime is ready. Sign in and try again: Claude Code (`claude auth login`), Codex (`codex login`), and Grok Build (`grok login`).
+```
+
+That core always names all three runtimes and all three sign-in commands. It
+may then add `Install Claude Code.`, `Install Codex.`, or `Install Grok Build.`
+in that order, but only for a runtime the probe established is absent. An
+installed-but-signed-out or unreadable runtime receives no install hint.
+
 **You join once.** A computer is *yours* on the platform, not an agent's.
 Every further agent is attached in Mission Control — on that agent's page,
 **Join from your computer → Attach an existing computer** — and the change
@@ -82,15 +103,15 @@ For every agent on your computer the workspace owner chooses:
   from the token counts Claude Code reports (the ledger says *billed to
   subscription (list rate)*), and its **working folder** (`<workdir>/sessions/<id>`,
   or the run checkout for a repository step).
-- That this computer is **connected or offline**, its name, OS and Claude Code
-  version, and how many sessions it is running (up to `--max-sessions`, across
-  all its agents).
+- That this computer is **connected or offline**, its name, OS, the versions of
+  its READY runtimes, and how many sessions it is running (up to
+  `--max-sessions`, across all its agents).
 - Every permission decision, and — under *Never ask* — every call that would
   have asked.
 
 ## What it never sees
 
-- Your Claude sign-in, your `~/.claude` settings, skills, plugins and MCP
+- Your runtime sign-ins and local runtime settings, skills, plugins and MCP
   servers — they load as they always do; the platform only *adds* its own
   system prompt and its own tools on top.
 - Any file outside the session folder unless the agent asks and a person
@@ -177,7 +198,7 @@ Disconnect**), which takes the computer off the floor at once.
 | the OS keychain, item `io.frod.bridge` | the host token |
 | `~/.frod/bridge/versions/<version>/` | one installed copy of the package |
 | `~/.frod/bridge/current` | a symlink (junction on Windows) to the version that's running |
-| `~/.frod/sessions.json` | which Claude Code session each platform session ran as (for resume) |
+| `~/.frod/sessions.json` | which local runtime session each platform session ran as (for resume) |
 | `~/.frod/bridge.log` | the log — tokens are redacted before anything is written |
 | `<workdir>/sessions/<id>` | a session's folder (the default) |
 | the folder the owner chose | a session's folder when the agent's binding names a **working folder on this computer** (see below) |
@@ -216,14 +237,13 @@ is spelled.
 
 The bridge talks to a tool through one small interface — `start`, `prompt`,
 `cancel`, `stop` (`src/adapters/types.ts`). **`claude`**
-(`src/adapters/claude.ts`) is required — `join` checks it's installed and
-signed in, and it drives Claude Code's headless CLI with your subscription.
-**`codex`** (`src/adapters/codex.ts`) and **`grok`** (`src/adapters/grok.ts`)
-are optional: each is offered only when it's installed *and* signed in on
-this computer. Which agent runs on which adapter is decided in Mission
-Control, not here. Grok Build runs in its `workspace` sandbox, and the bridge
-answers its permission questions by the same Ask / Never-ask policy as the
-others. Each adapter is one file.
+(`src/adapters/claude.ts`), **`codex`** (`src/adapters/codex.ts`), and
+**`grok`** (`src/adapters/grok.ts`) are peers: each is offered only when its
+runtime is installed and explicitly signed in. At least one must be READY;
+none is mandatory by itself. Which agent runs on which offered adapter is
+decided in Mission Control, not here. Grok Build runs in its `workspace`
+sandbox, and the bridge answers its permission questions by the same Ask /
+Never-ask policy as the others. Each adapter is one file.
 
 ## Running at login
 
@@ -242,6 +262,31 @@ others. Each adapter is one file.
   (`schtasks /Create`), also pointing at `current`. If it refuses, the exact
   command is printed. Not yet proven on a real Windows machine.
 
+## Changelog
+
+### 0.7.4 — unreleased
+
+- `join` is runtime-neutral: it admits a computer when at least one of Claude
+  Code, Codex, or Grok Build is installed and explicitly signed in, and offers
+  exactly that READY set.
+- All three runtime probes use the same tri-state sign-in contract: `true` is
+  ready, explicit signed-out is `false`, and unreadable or unestablished state
+  is unknown rather than ready.
+- Configuration, announced adapters, version-bearing runtime segments, and
+  capacity sampling come from that READY set. The version string keeps the
+  compatibility-only `claude ?` sentinel when Claude Code is not READY; the
+  sentinel never offers Claude Code.
+- This release is waiting for owner review at the merge queue. It has not been
+  merged, published, signed, tagged, announced, deployed, or rolled out; only
+  the owner may perform those release and rollout actions in the owner-present
+  rollout window.
+
+### 0.7.3 — historical
+
+- The previous bridge release retained the Claude-required join preflight.
+  Its behavior is historical and is superseded by the unreleased 0.7.4 rule
+  above.
+
 ## Publishing
 
 `.github/workflows/deploy-bridge.yml` runs on every push to `main` that

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// @frod.io/bridge 0.7.2. One file; do not edit: the source is apps/bridge/src in the platform repository.
+// @frod.io/bridge 0.7.4. One file; do not edit: the source is apps/bridge/src in the platform repository.
 import { createRequire as __createRequire } from 'node:module';
 const require = __createRequire(import.meta.url);
 var __create = Object.create;
@@ -3706,9 +3706,10 @@ var require_websocket_server = __commonJS({
 
 // src/cli.ts
 import { execFileSync as execFileSync7 } from "node:child_process";
-import { existsSync as existsSync12, mkdirSync as mkdirSync9 } from "node:fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync9, realpathSync as realpathSync4 } from "node:fs";
 import { homedir as homedir7, hostname as hostname2, platform as platform6 } from "node:os";
 import { dirname as dirname5, join as join11, resolve as resolve6 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { spawn as spawn6 } from "node:child_process";
 
 // src/config.ts
@@ -4482,24 +4483,23 @@ var ClaudeAdapter = class {
     writeChildren([...this.live.values()].map((l) => l.child?.pid).filter((p) => typeof p === "number"));
   }
   /** `claude --version`, and whether the CLI says it is signed in. Never throws. */
-  static check(claudePath) {
-    let version = null;
-    let loggedIn = null;
-    let detail = "";
+  static check(claudePath, commands = {}) {
+    const versionCommand = commands.version ?? ((path) => execFileSync2(path, ["--version"], { env: cleanEnv(process.env), stdio: ["ignore", "pipe", "ignore"], timeout: 15e3 }).toString());
+    const authStatusCommand = commands.authStatus ?? ((path) => execFileSync2(path, ["auth", "status"], { env: cleanEnv(process.env), stdio: ["ignore", "pipe", "ignore"], timeout: 15e3 }).toString());
+    let version;
     try {
-      version = execFileSync2(claudePath, ["--version"], { env: cleanEnv(process.env), stdio: ["ignore", "pipe", "ignore"], timeout: 15e3 }).toString().trim();
+      version = versionCommand(claudePath).trim();
+      if (!/\d+\.\d+\.\d+/.test(version)) throw new Error("answered without a valid version");
     } catch (err) {
-      detail += `--version failed: ${err instanceof Error ? err.message : String(err)}. `;
+      return { version: null, loggedIn: null, detail: `--version failed: ${err instanceof Error ? err.message : String(err)}` };
     }
     try {
-      const raw = execFileSync2(claudePath, ["auth", "status"], { env: cleanEnv(process.env), stdio: ["ignore", "pipe", "ignore"], timeout: 15e3 }).toString();
-      const parsed = JSON.parse(raw);
-      loggedIn = parsed.loggedIn === true;
-      detail += `auth: ${parsed.authMethod ?? "?"}${parsed.subscriptionType ? ` (${parsed.subscriptionType})` : ""}. `;
+      const parsed = JSON.parse(authStatusCommand(claudePath));
+      const loggedIn = parsed.loggedIn === true ? true : parsed.loggedIn === false ? false : null;
+      return { version, loggedIn, detail: `auth: ${parsed.authMethod ?? "?"}${parsed.subscriptionType ? ` (${parsed.subscriptionType})` : ""}` };
     } catch (err) {
-      detail += `auth status failed: ${err instanceof Error ? err.message : String(err)}. `;
+      return { version, loggedIn: null, detail: `auth status failed: ${err instanceof Error ? err.message : String(err)}` };
     }
-    return { version, loggedIn, detail: detail.trim() };
   }
   async start(spec, o) {
     if (!existsSync4(o.sessionDir)) mkdirSync2(o.sessionDir, { recursive: true, mode: 448 });
@@ -5045,19 +5045,30 @@ var CodexAdapter = class _CodexAdapter {
     return "The Codex adapter needs the `codex` CLI on this computer and a signed-in account (`codex login`).";
   }
   /** The version and whether somebody is signed in — the same shape ClaudeAdapter.check returns. */
-  static check(codexPath) {
-    let version = null;
+  static check(codexPath, commands = {}) {
+    const versionCommand = commands.version ?? ((path) => execFileSync3(path, ["--version"], { stdio: ["ignore", "pipe", "ignore"], timeout: 2e4 }).toString());
+    const loginStatusCommand = commands.loginStatus ?? ((path) => {
+      const res = spawnSync(path, ["login", "status"], { encoding: "utf8", timeout: 3e4 });
+      if (res.error) throw res.error;
+      return `${res.stdout ?? ""}${res.stderr ?? ""}`;
+    });
+    let version;
     try {
-      version = execFileSync3(codexPath, ["--version"], { stdio: ["ignore", "pipe", "ignore"], timeout: 2e4 }).toString().trim().split(/\s+/).pop() ?? null;
-    } catch {
-      return { version: null, loggedIn: null, detail: `${codexPath} did not run \u2014 Codex is not installed here` };
+      const raw = versionCommand(codexPath).trim();
+      version = /(\d+\.\d+\.\d+[0-9A-Za-z.-]*)/.exec(raw)?.[1] ?? "";
+      if (!version) throw new Error("answered without a valid version");
+    } catch (err) {
+      return { version: null, loggedIn: null, detail: `${codexPath} did not run \u2014 ${err instanceof Error ? err.message : String(err)}` };
     }
-    const res = spawnSync(codexPath, ["login", "status"], { encoding: "utf8", timeout: 3e4 });
-    const out = `${res.stdout ?? ""}${res.stderr ?? ""}`.trim();
-    if (res.error || !out) {
-      return { version, loggedIn: false, detail: out || "could not read the sign-in state \u2014 run `codex login`" };
+    try {
+      const out = loginStatusCommand(codexPath).trim();
+      const detail = out.split("\n").find((line) => line.trim().length > 0)?.trim() || "could not read the sign-in state \u2014 run `codex login`";
+      if (/\b(?:not logged in|not signed in|not authenticated|unauthenticated)\b/i.test(out)) return { version, loggedIn: false, detail };
+      if (/\blogged in\b/i.test(out)) return { version, loggedIn: true, detail };
+      return { version, loggedIn: null, detail };
+    } catch (err) {
+      return { version, loggedIn: null, detail: `could not read the sign-in state: ${err instanceof Error ? err.message : String(err)}` };
     }
-    return { version, loggedIn: /logged in/i.test(out), detail: out.split("\n")[0] ?? "" };
   }
   /**
    * A session's credential tier. `codex login status` says how the person
@@ -5754,23 +5765,32 @@ var GrokAdapter = class _GrokAdapter {
    * says "You are not authenticated." and opens no browser, so this is safe
    * to run unattended at every start.
    */
-  static check(grokPath) {
+  static check(grokPath, commands = {}) {
     const env = { ...process.env, GROK_DISABLE_AUTOUPDATER: "1" };
-    let version = null;
+    const versionCommand = commands.version ?? ((path) => execFileSync4(path, ["--version"], { env, stdio: ["ignore", "pipe", "ignore"], timeout: 2e4 }).toString());
+    const modelsCommand = commands.models ?? ((path) => {
+      const res = spawnSync2(path, ["models"], { env, encoding: "utf8", timeout: 3e4, stdio: ["ignore", "pipe", "pipe"] });
+      if (res.error) throw res.error;
+      return `${res.stdout ?? ""}
+${res.stderr ?? ""}`;
+    });
+    let version;
     try {
-      const out2 = execFileSync4(grokPath, ["--version"], { env, stdio: ["ignore", "pipe", "ignore"], timeout: 2e4 }).toString();
-      version = /(\d+\.\d+\.\d+[0-9A-Za-z.-]*)/.exec(out2)?.[1] ?? null;
-    } catch {
-      return { version: null, loggedIn: null, detail: `${grokPath} did not run \u2014 Grok Build is not installed here` };
+      const out = versionCommand(grokPath);
+      version = /(\d+\.\d+\.\d+[0-9A-Za-z.-]*)/.exec(out)?.[1] ?? "";
+      if (!version) throw new Error("answered without a valid version");
+    } catch (err) {
+      return { version: null, loggedIn: null, detail: `${grokPath} did not run \u2014 ${err instanceof Error ? err.message : String(err)}` };
+    }
+    try {
+      const out = modelsCommand(grokPath).trim();
+      const first = out.split("\n").map((line) => line.trim()).find((line) => line.length > 0) ?? "";
+      if (/\b(?:not logged in|not signed in|not authenticated|unauthenticated)\b/i.test(out)) return { version, loggedIn: false, detail: "not signed in \u2014 run `grok login`" };
+      if (/\blogged in\b/i.test(out)) return { version, loggedIn: true, detail: first };
+      return { version, loggedIn: null, detail: first || "could not read the sign-in state \u2014 run `grok login`" };
+    } catch (err) {
+      return { version, loggedIn: null, detail: `could not read the sign-in state: ${err instanceof Error ? err.message : String(err)}` };
     }
-    const res = spawnSync2(grokPath, ["models"], { env, encoding: "utf8", timeout: 3e4, stdio: ["ignore", "pipe", "pipe"] });
-    const out = `${res.stdout ?? ""}
-${res.stderr ?? ""}`.trim();
-    const first = out.split("\n").map((l) => l.trim()).find((l) => l.length > 0) ?? "";
-    if (res.error || !out) return { version, loggedIn: false, detail: first || "could not read the sign-in state \u2014 run `grok login`" };
-    if (/logged in/i.test(out)) return { version, loggedIn: true, detail: first };
-    if (/not authenticated/i.test(out)) return { version, loggedIn: false, detail: "not signed in \u2014 run `grok login`" };
-    return { version, loggedIn: false, detail: first };
   }
   /** A grok.com sign-in is the subscription; anything else that runs is a key (`XAI_API_KEY`). */
   credentialTier() {
@@ -6481,6 +6501,9 @@ function workdirRequestFor(spec) {
 }
 
 // src/connection.ts
+var RECONCILE_INTERVAL_MS = 6e4;
+var RECONCILE_WAIT_MS = 1500;
+var STOP_BOUND_MS = 1e4;
 var HostConnection = class {
   constructor(o) {
     this.o = o;
@@ -6498,6 +6521,7 @@ var HostConnection = class {
   /** Which runtime started each session — a turn must reach the one holding it. */
   sessionAdapter = /* @__PURE__ */ new Map();
   attempt = 0;
+  reconcileTimer = null;
   connectedAt = null;
   /** Requests this computer sent to the pod (night 2: permissions), by id. */
   nextRequestId = 1;
@@ -6593,6 +6617,7 @@ var HostConnection = class {
         const reason = reasonBuf.toString();
         this.connectedAt = null;
         this.ws = null;
+        this.stopReconciling();
         this.failPending(`the connection closed (${code})`);
         void this.endAllSessions(`connection closed (${code}${reason ? ` ${reason}` : ""})`);
         if (final && (code === 4403 || code === 4404 || final.reason.startsWith("Another computer") || final.reason.startsWith("This computer left") || final.reason.startsWith("This computer was disconnected") || /access was revoked/.test(final.reason))) {
@@ -6634,6 +6659,8 @@ var HostConnection = class {
       const hosted = hostedAgentsWords({ bindings, agentName: this.o.config.agentName });
       log.event("host.welcome", { host: params.hostName ?? this.o.config.name, host_id: params.hostId ?? null, person: params.person?.name ?? null, workspace: params.workspaceId, agents: bindings.map((b) => `${b.agentName}: ${bindingWords(b)}`), ping_ms: params.pingIntervalMs });
       log.info(`Connected \u2014 ${this.o.config.name} hosts ${hosted}`);
+      this.reconcile("welcome");
+      this.startReconciling();
       if (typeof params.hostId === "string") {
         this.o.onWelcome?.({ hostId: params.hostId, hostName: String(params.hostName ?? this.o.config.name), person: params.person ?? null, bindings, bridge: params.bridge });
       }
@@ -6673,7 +6700,13 @@ var HostConnection = class {
         const spec = params;
         if (this.draining || this.stopping) return fail(`${this.o.config.name} is restarting${this.draining ? " to update itself" : ""} \u2014 try again in a moment`);
         if (this.sessions.size >= this.o.config.maxSessions && !this.sessions.has(sid)) {
-          return fail(`${this.o.config.name} is busy (${this.sessions.size} of ${this.o.config.maxSessions} sessions)`);
+          const before = this.sessions.size;
+          this.reconcile("desk full");
+          await sleep(RECONCILE_WAIT_MS);
+          log.event("session.reconciled", { session: sid, before, after: this.sessions.size, max: this.o.config.maxSessions });
+          if (this.sessions.size >= this.o.config.maxSessions) {
+            return fail(`${this.o.config.name} is busy (${this.sessions.size} of ${this.o.config.maxSessions} sessions)`);
+          }
         }
         this.sessions.add(sid);
         this.sessionsChanged();
@@ -6774,7 +6807,10 @@ var HostConnection = class {
         return;
       }
       if (method === "session/stop") {
-        await this.adapterOf(sid).stop(sid);
+        const reason = typeof params.reason === "string" ? params.reason : "stopped";
+        if (reason === "unknown_session") log.event("session.forgotten_by_pod", { session: sid });
+        await this.adapterOf(sid).stop(sid, reason);
+        this.forget(sid);
         return;
       }
       if (method === "session/permission_decided") {
@@ -6869,15 +6905,50 @@ var HostConnection = class {
   }
   async endAllSessions(reason) {
     if (this.sessions.size === 0) return;
-    log.warn(`Stopping ${this.sessions.size} session(s): ${reason}`);
-    for (const sid of [...this.sessions]) {
-      await this.adapterOf(sid).stop(sid, "host_disconnected").catch(() => {
-      });
-      this.sessions.delete(sid);
-      this.checkouts.delete(sid);
+    const sids = [...this.sessions];
+    log.warn(`Stopping ${sids.length} session(s): ${reason}`);
+    for (const sid of sids) this.forget(sid, { keepAdapter: true });
+    await Promise.all(sids.map(async (sid) => {
+      const adapter = this.sessionAdapter.get(sid) ?? this.adapterOf(sid);
       this.sessionAdapter.delete(sid);
+      await Promise.race([
+        adapter.stop(sid, "host_disconnected").catch(() => {
+        }),
+        sleep(STOP_BOUND_MS).then(() => log.warn(`[${sid.slice(0, 8)}] did not stop within ${STOP_BOUND_MS / 1e3} s \u2014 slot freed anyway`))
+      ]);
+    }));
+  }
+  /** Free a session's slot and everything this computer remembered about it. Idempotent. */
+  forget(sid, opts = {}) {
+    const had = this.sessions.delete(sid);
+    this.checkouts.delete(sid);
+    this.doorCheckouts.forget(sid);
+    this.sessionDirs.delete(sid);
+    if (!opts.keepAdapter) this.sessionAdapter.delete(sid);
+    if (had) this.sessionsChanged();
+  }
+  /**
+   * No tails: ask the pod about every lane this computer holds. A known
+   * session gets silence; a forgotten one gets `session/stop` back, which
+   * frees its slot through the ordinary path. Sent only while connected.
+   */
+  reconcile(why) {
+    if (this.sessions.size === 0 || !this.ws || this.ws.readyState !== wrapper_default.OPEN) return;
+    log.event("sessions.reconcile", { why, held: this.sessions.size, max: this.o.config.maxSessions });
+    for (const sid of this.sessions) {
+      this.send({ sid, msg: { jsonrpc: "2.0", method: "session/heartbeat", params: { sessionId: sid } } });
+    }
+  }
+  startReconciling() {
+    this.stopReconciling();
+    this.reconcileTimer = setInterval(() => this.reconcile("interval"), RECONCILE_INTERVAL_MS);
+    this.reconcileTimer.unref?.();
+  }
+  stopReconciling() {
+    if (this.reconcileTimer) {
+      clearInterval(this.reconcileTimer);
+      this.reconcileTimer = null;
     }
-    this.sessionsChanged();
   }
   send(frame) {
     const ws = this.ws;
@@ -7779,7 +7850,7 @@ function samplesInWords(samples) {
 }
 
 // src/cli.ts
-var VERSION = "0.7.2";
+var VERSION = "0.7.4";
 function arg(flag, argv) {
   const i = argv.indexOf(flag);
   return i >= 0 ? argv[i + 1] : void 0;
@@ -7791,7 +7862,7 @@ function findClaude() {
     return execFileSync7("/usr/bin/which", ["claude"], { stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
   } catch {
   }
-  throw new Error("claude was not found. Install Claude Code and sign in (claude auth login), then try again.");
+  return null;
 }
 function findCodex() {
   const candidates = [process.env.FROD_CODEX_PATH, join11(homedir7(), ".local", "bin", "codex"), "/opt/homebrew/bin/codex", "/usr/local/bin/codex"].filter((c) => !!c);
@@ -7813,33 +7884,54 @@ function findGrok() {
     return null;
   }
 }
-function buildAdapters(cfg, permissions) {
-  const adapters = {
-    claude: new ClaudeAdapter({ claudePath: cfg.claudePath, permissions })
+var RUNTIME_ORDER = ["claude", "codex", "grok"];
+var RUNTIME_LABELS = { claude: "Claude Code", codex: "Codex", grok: "Grok Build" };
+var INSTALL_HINTS = { claude: "Install Claude Code.", codex: "Install Codex.", grok: "Install Grok Build." };
+var RUNTIME_PREFLIGHT_REFUSAL = "No supported runtime is ready. Sign in and try again: Claude Code (`claude auth login`), Codex (`codex login`), and Grok Build (`grok login`).";
+function checkedRuntime(name, path) {
+  if (!path) return { path: null, version: null, loggedIn: null, detail: `not installed on this computer` };
+  try {
+    const check = name === "claude" ? ClaudeAdapter.check(path) : name === "codex" ? CodexAdapter.check(path) : GrokAdapter.check(path);
+    return { path, ...check };
+  } catch (err) {
+    return { path, version: null, loggedIn: null, detail: `could not run: ${err instanceof Error ? err.message : String(err)}` };
+  }
+}
+var DEFAULT_RUNTIME_PROBES = {
+  claude: (preferredPath) => checkedRuntime("claude", preferredPath ?? findClaude()),
+  codex: (preferredPath) => checkedRuntime("codex", preferredPath ?? findCodex()),
+  grok: (preferredPath) => checkedRuntime("grok", preferredPath ?? findGrok())
+};
+function probeAllRuntimes(probes, preferred) {
+  return {
+    claude: probes.claude(preferred?.claudePath),
+    codex: probes.codex(preferred?.codexPath),
+    grok: probes.grok(preferred?.grokPath)
   };
-  const codexPath = cfg.codexPath ?? findCodex();
-  let codexDetail = "not installed on this computer";
-  let codexVersion = null;
-  if (codexPath) {
-    const c = CodexAdapter.check(codexPath);
-    codexDetail = `${c.version ?? "unknown version"} \u2014 ${c.detail}`;
-    if (c.loggedIn) {
-      adapters.codex = new CodexAdapter({ codexPath });
-      codexVersion = c.version;
-    }
-  }
-  const grokPath = cfg.grokPath ?? findGrok();
-  let grokDetail = "not installed on this computer";
-  let grokVersion = null;
-  if (grokPath) {
-    const g = GrokAdapter.check(grokPath);
-    grokDetail = `${g.version ?? "unknown version"} \u2014 ${g.detail}`;
-    if (g.loggedIn) {
-      adapters.grok = new GrokAdapter({ grokPath });
-      grokVersion = g.version;
-    }
-  }
-  return { adapters, names: Object.keys(adapters), codexDetail, codexVersion, grokDetail, grokVersion };
+}
+function isReady(probe) {
+  return probe.path !== null && probe.version !== null && probe.loggedIn === true;
+}
+function readyNames(probes) {
+  return RUNTIME_ORDER.filter((name) => isReady(probes[name]));
+}
+function runtimePreflightRefusal(probes) {
+  const hints = RUNTIME_ORDER.filter((name) => probes[name].path === null).map((name) => INSTALL_HINTS[name]);
+  return `${RUNTIME_PREFLIGHT_REFUSAL}${hints.length > 0 ? ` ${hints.join(" ")}` : ""}`;
+}
+function versionForReadySet(probes) {
+  return runtimeVersionString2(
+    isReady(probes.claude) ? probes.claude.version : null,
+    isReady(probes.codex) ? probes.codex.version : null,
+    isReady(probes.grok) ? probes.grok.version : null
+  );
+}
+function buildAdapters(probes, permissions) {
+  const adapters = {};
+  if (isReady(probes.claude)) adapters.claude = new ClaudeAdapter({ claudePath: probes.claude.path, permissions });
+  if (isReady(probes.codex)) adapters.codex = new CodexAdapter({ codexPath: probes.codex.path });
+  if (isReady(probes.grok)) adapters.grok = new GrokAdapter({ grokPath: probes.grok.path });
+  return { adapters, names: readyNames(probes) };
 }
 function runtimeVersionString2(claudeVersion, codexVersion, grokVersion = null) {
   return runtimeVersionString(VERSION, claudeVersion, codexVersion, grokVersion);
@@ -7853,37 +7945,42 @@ function tokenFor(cfg) {
   if (!token) throw new Error("The host token is missing from the keychain. Ask for a new join code and join again.");
   return token;
 }
-async function cmdJoin(argv) {
+async function cmdJoin(argv, overrides = {}) {
+  const deps = {
+    readConfig,
+    probes: DEFAULT_RUNTIME_PROBES,
+    join: join3,
+    storeToken,
+    ensureWorkdir: (path) => {
+      if (!existsSync12(path)) mkdirSync9(path, { recursive: true, mode: 448 });
+    },
+    writeConfig,
+    reportGitAccess,
+    install: cmdInstall,
+    now: () => (/* @__PURE__ */ new Date()).toISOString(),
+    ...overrides
+  };
   const code = argv[0];
   const apiUrl = arg("--api", argv) ?? process.env.FROD_API_URL;
   if (!code || !apiUrl) throw new Error(`Usage: join <code> --api https://api.agentic.frod.io [--name "Wafeek's Mac"] [--workdir <dir>] [--max-sessions N]`);
-  const existing = readConfig();
+  const existing = deps.readConfig();
   const refusal = existing ? secondJoinWords(existing) : null;
   if (refusal) throw new Error(refusal);
   const safeApi = assertSafeEndpoint(apiUrl);
   const name = arg("--name", argv) ?? defaultName();
   const workdir = resolve6(arg("--workdir", argv) ?? join11(homedir7(), "frod-work"));
   const maxSessions = Math.max(1, Math.min(20, Number(arg("--max-sessions", argv) ?? 2)));
-  const claudePath = findClaude();
-  const check = ClaudeAdapter.check(claudePath);
-  log.info(`Claude Code: ${check.version ?? "unknown version"} \u2014 ${check.detail}`);
-  if (check.loggedIn === false) throw new Error("Claude Code is not signed in on this computer. Run `claude auth login` first.");
+  const probes = probeAllRuntimes(deps.probes);
+  for (const runtime of RUNTIME_ORDER) {
+    const probe = probes[runtime];
+    log.info(`${RUNTIME_LABELS[runtime]}: ${probe.version ?? (probe.path ? "unknown version" : "not installed")} \u2014 ${probe.detail}`);
+  }
+  const adapters = readyNames(probes);
+  if (adapters.length === 0) throw new Error(runtimePreflightRefusal(probes));
   log.info(`Joining ${safeApi} as "${name}"\u2026`);
-  const codexAtJoin = (() => {
-    const cp = findCodex();
-    if (!cp) return null;
-    const c = CodexAdapter.check(cp);
-    return c.loggedIn ? c.version : null;
-  })();
-  const grokAtJoin = (() => {
-    const gp = findGrok();
-    if (!gp) return null;
-    const g = GrokAdapter.check(gp);
-    return g.loggedIn ? g.version : null;
-  })();
-  const joined = await join3(safeApi, code, name, { os: platform6(), version: runtimeVersionString2(check.version, codexAtJoin, grokAtJoin) });
-  const store = storeToken(joined.hostId, joined.token);
-  if (!existsSync12(workdir)) mkdirSync9(workdir, { recursive: true, mode: 448 });
+  const joined = await deps.join(safeApi, code, name, { os: platform6(), version: versionForReadySet(probes) });
+  const store = deps.storeToken(joined.hostId, joined.token);
+  deps.ensureWorkdir(workdir);
   const cfg = {
     apiUrl: safeApi,
     hostId: joined.hostId,
@@ -7893,26 +7990,28 @@ async function cmdJoin(argv) {
     name,
     workdir,
     maxSessions,
-    adapters: ["claude"],
-    claudePath,
+    adapters,
+    claudePath: isReady(probes.claude) ? probes.claude.path : null,
+    codexPath: isReady(probes.codex) ? probes.codex.path : void 0,
+    grokPath: isReady(probes.grok) ? probes.grok.path : void 0,
     tokenStore: store,
     keychainAccount: joined.hostId,
-    joinedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    joinedAt: deps.now(),
     dormant: null,
     bindings: joined.bindings ?? []
   };
-  writeConfig(cfg);
+  deps.writeConfig(cfg);
   log.info(`Joined. This computer is now "${name}" \u2014 ${joined.person?.name ?? "your"} computer in ${joined.workspaceName ?? joined.workspaceId} \u2014 hosting ${hostedAgentsWords(cfg)}.`);
   for (const b of cfg.bindings ?? []) log.info(`  ${b.agentName}: ${bindingWords(b)}`);
   log.info(`Token kept in ${store === "keychain" ? "the OS keychain" : `a 0600 file under ${dirname5(CONFIG_PATH)} (no keychain available on this computer \u2014 stated, not hidden)`}; it expires ${joined.expiresAt.slice(0, 10)}.`);
   log.info(`Settings: ${CONFIG_PATH}. Sessions work under ${workdir}/sessions. Up to ${maxSessions} at a time, across every agent this computer hosts.`);
   log.info(`To host more agents from here: open the agent's page in Mission Control \u2192 "Join from your computer" \u2192 "Attach an existing computer". No second join.`);
-  await reportGitAccess(arg("--repo", argv));
+  await deps.reportGitAccess(arg("--repo", argv));
   if (argv.includes("--no-install")) {
     log.info("Next: `install` to run at login, or `run` to run now.");
     return;
   }
-  await cmdInstall();
+  await deps.install();
 }
 async function reportGitAccess(repoUrl) {
   let version = "not found";
@@ -7948,24 +8047,30 @@ async function cmdRun() {
   ClaudeAdapter.reapOrphans();
   const pruned = pruneRunDirs(cfg.workdir);
   if (pruned > 0) log.event("repo.runs_pruned", { count: pruned });
+  const probes = probeAllRuntimes(DEFAULT_RUNTIME_PROBES, cfg);
+  const ready = readyNames(probes);
+  if (ready.length === 0) throw new Error(runtimePreflightRefusal(probes));
   const permissions = new PermissionServer();
   await permissions.start();
-  const { adapters, names, codexDetail, codexVersion, grokDetail, grokVersion } = buildAdapters(cfg, permissions);
-  const check = ClaudeAdapter.check(cfg.claudePath);
-  log.info(`Runtimes this computer hosts: ${names.join(", ")}. Codex: ${codexDetail}. Grok Build: ${grokDetail}.`);
-  if (JSON.stringify(cfg.adapters ?? []) !== JSON.stringify(names)) {
-    cfg.adapters = names;
+  const { adapters, names } = buildAdapters(probes, permissions);
+  log.info(`Runtimes this computer hosts: ${names.join(", ")}. ${RUNTIME_ORDER.map((name) => `${RUNTIME_LABELS[name]}: ${probes[name].version ?? (probes[name].path ? "unknown version" : "not installed")} \u2014 ${probes[name].detail}`).join(". ")}.`);
+  const runtimeConfigBefore = JSON.stringify({ adapters: cfg.adapters ?? [], claudePath: cfg.claudePath, codexPath: cfg.codexPath, grokPath: cfg.grokPath });
+  cfg.adapters = names;
+  cfg.claudePath = isReady(probes.claude) ? probes.claude.path : null;
+  cfg.codexPath = isReady(probes.codex) ? probes.codex.path : void 0;
+  cfg.grokPath = isReady(probes.grok) ? probes.grok.path : void 0;
+  if (runtimeConfigBefore !== JSON.stringify({ adapters: cfg.adapters, claudePath: cfg.claudePath, codexPath: cfg.codexPath, grokPath: cfg.grokPath })) {
     writeConfig(cfg);
   }
-  log.event("bridge.start", { version: VERSION, name: cfg.name, host_id: cfg.hostId, agents: (cfg.bindings ?? []).map((b) => b.agentName), api: cfg.apiUrl, claude: check.version, logged_in: check.loggedIn, max_sessions: cfg.maxSessions, os: platform6(), runs_from: runLocation().installedVersion ? `versions/${runLocation().installedVersion}` : runLocation().packageRoot });
-  const codexPath = adapters.codex ? cfg.codexPath ?? findCodex() : null;
-  const grokPath = adapters.grok ? cfg.grokPath ?? findGrok() : null;
+  log.event("bridge.start", { version: VERSION, name: cfg.name, host_id: cfg.hostId, agents: (cfg.bindings ?? []).map((b) => b.agentName), api: cfg.apiUrl, claude: probes.claude.version, logged_in: probes.claude.loggedIn, max_sessions: cfg.maxSessions, os: platform6(), runs_from: runLocation().installedVersion ? `versions/${runLocation().installedVersion}` : runLocation().packageRoot });
+  const codexPath = isReady(probes.codex) ? probes.codex.path : null;
+  const grokPath = isReady(probes.grok) ? probes.grok.path : null;
   let sampling = false;
   const sampleAndSend = async () => {
     if (sampling) return;
     sampling = true;
     try {
-      const { at, samples } = await sampleCapacity({ claude: check.loggedIn !== false, codexPath, grokPath });
+      const { at, samples } = await sampleCapacity({ claude: isReady(probes.claude), codexPath, grokPath });
       conn.sendHost("host/capacity", { at, samples });
       log.event("capacity.sampled", { at, words: samplesInWords(samples) });
     } catch (err) {
@@ -8010,7 +8115,7 @@ async function cmdRun() {
     config: cfg,
     token,
     adapters,
-    version: runtimeVersionString2(check.version, codexVersion, grokVersion),
+    version: versionForReadySet(probes),
     onFinal: (reason2) => {
       writeConfig({ ...cfg, dormant: { reason: reason2, at: (/* @__PURE__ */ new Date()).toISOString() } });
       log.warn(dormantWords({ reason: reason2, at: (/* @__PURE__ */ new Date()).toISOString() }, hostedAgentsWords(cfg)));
@@ -8067,17 +8172,14 @@ async function cmdStatus(argv) {
   if (cfg.dormant) log.warn(dormantWords(cfg.dormant, hostedAgentsWords(cfg)));
   log.info(`Token: ${cfg.tokenStore}; settings ${CONFIG_PATH}; sessions under ${cfg.workdir}/sessions; up to ${cfg.maxSessions} at a time across every agent here.`);
   log.info(`Working folders an agent may be given here: ${allowedRootsOf(cfg).join(", ")} (add more under "allowedRoots" in ${CONFIG_PATH}).`);
-  const check = ClaudeAdapter.check(cfg.claudePath);
-  log.info(`Claude Code: ${check.version ?? "unknown"} \u2014 ${check.detail}`);
+  const probes = probeAllRuntimes(DEFAULT_RUNTIME_PROBES, cfg);
+  for (const runtime of RUNTIME_ORDER) {
+    const probe = probes[runtime];
+    log.info(`${RUNTIME_LABELS[runtime]}: ${probe.version ?? (probe.path ? "unknown version" : "not installed")} \u2014 ${probe.detail}`);
+  }
   const loc = runLocation();
   log.info(`Software: ${VERSION}, running from ${loc.installedVersion ? `${VERSIONS_DIR}/${loc.installedVersion}` : `${loc.packageRoot} (not an installed version \u2014 it will not update itself; run \`npx @frod.io/bridge@latest install\`)`}; current \u2192 ${currentVersion() ?? "none"}.`);
   if (platform6() === "darwin") log.info(`Runs at login: ${launchdLoaded() ? "yes (launchd)" : "no \u2014 run install"}`);
-  const codexPath = cfg.codexPath ?? findCodex();
-  const codexCheck = codexPath ? CodexAdapter.check(codexPath) : null;
-  log.info(`Codex: ${codexCheck ? `${codexCheck.version ?? "unknown"} \u2014 ${codexCheck.detail}` : CodexAdapter.notYet}`);
-  const grokPath = cfg.grokPath ?? findGrok();
-  const grokCheck = grokPath ? GrokAdapter.check(grokPath) : null;
-  log.info(`Grok Build: ${grokCheck ? `${grokCheck.version ?? "unknown"} \u2014 ${grokCheck.detail}` : GrokAdapter.notYet}`);
   log.info("Which agent runs on which runtime is the platform's to say \u2014 attach or detach agents in Mission Control.");
   await reportGitAccess(arg("--repo", argv));
   const token = readToken(cfg.keychainAccount, cfg.tokenStore);
@@ -8212,10 +8314,19 @@ async function main() {
       process.exit(cmd ? 2 : 0);
   }
 }
-main().catch((err) => {
-  log.error(err instanceof Error ? err.message : String(err));
-  process.exit(1);
-});
+var isEntrypoint = false;
+try {
+  isEntrypoint = !!process.argv[1] && realpathSync4(process.argv[1]) === realpathSync4(fileURLToPath2(import.meta.url));
+} catch {
+}
+if (isEntrypoint) {
+  main().catch((err) => {
+    log.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  });
+}
 export {
+  RUNTIME_PREFLIGHT_REFUSAL,
+  cmdJoin,
   runtimeVersionString2 as runtimeVersionString
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frod.io/bridge",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "type": "module",
   "description": "Your computer is a desk: hosts a Frod.io agent's sessions with your own Claude Code, Codex or Grok Build. Installs and updates itself.",
   "license": "UNLICENSED",
@@ -32,11 +32,14 @@
     "pack:check": "npm pack --dry-run"
   },
   "devDependencies": {
+    "@eslint/js": "^9.39.3",
     "@types/node": "^22.0.0",
     "@types/ws": "^8.18.1",
     "esbuild": "^0.27.3",
+    "eslint": "^9.0.0",
     "tsx": "^4.19.0",
     "typescript": "^5.7.0",
+    "typescript-eslint": "^8.56.1",
     "vitest": "^4.0.18",
     "ws": "^8.21.3"
   }