@bridge4dev/runner 0.49.0 → 0.50.0

package/dist/agent-versions.d.ts

@@ -58,8 +58,39 @@ export interface ProbeResult {
     stdout: string;
     stderr: string;
 }
-/** Run one probe. Rejects on a non-zero exit, a timeout or a missing binary. */
-export type ProbeRunner = (file: string, argv: readonly string[], timeoutMs: number) => Promise<ProbeResult>;
+export interface ProbeOptions {
+    /**
+     * Keep the output of a command that exited non-zero.
+     *
+     * **This is the bug the flag exists for, and it is worth stating in full.**
+     * `codex doctor --json` exits 1 whenever ANY of its checks fails — and three
+     * of them are network checks (`network.provider_reachability`,
+     * `network.websocket_reachability`, `updates.status`) that have nothing to
+     * do with the question we are asking. Measured on a live machine
+     * (codex-cli 0.153.4): with the network reachable, exit 0; with it blocked,
+     * **exit 1 while `runtime.provenance` still reports `status: ok` and
+     * `install method: npm (…)` on stdout**.
+     *
+     * So a passing hiccup on somebody's dev server used to throw away an answer
+     * we already held, the machine reported «install method unknown», and the
+     * «Update» button disappeared from that agent's row for the hour the
+     * measurement is cached. It came back on its own later, which is why it read
+     * as a permanent property of three machines rather than as a fault.
+     *
+     * A verdict about the machine's health is not a verdict about whether the
+     * command told us what we asked. Timeouts and «no such binary» are still
+     * failures — those really are «no answer».
+     */
+    tolerateExitCode?: boolean;
+}
+/** Run one probe. Rejects on a timeout, a missing binary, or (by default) a non-zero exit. */
+export type ProbeRunner = (file: string, argv: readonly string[], timeoutMs: number, options?: ProbeOptions) => Promise<ProbeResult>;
+/**
+ * Exported for its own tests: the interesting behaviour of this function is
+ * entirely in how it reads `execFile`'s error, and a stub `ProbeRunner` — which
+ * is what every other test here uses — cannot reproduce that by construction.
+ */
+export declare const runProbe: ProbeRunner;
 /**
  * Fold whatever an agent calls its install method into the five values the
  * product reasons about.

package/dist/agent-versions.js

@@ -26,12 +26,30 @@ let cached = null;
 export function invalidateAgentVersions() {
     cached = null;
 }
-const runProbe = (file, argv, timeoutMs) => new Promise((resolve, reject) => {
+/**
+ * Exported for its own tests: the interesting behaviour of this function is
+ * entirely in how it reads `execFile`'s error, and a stub `ProbeRunner` — which
+ * is what every other test here uses — cannot reproduce that by construction.
+ */
+export const runProbe = (file, argv, timeoutMs, options) => new Promise((resolve, reject) => {
     const child = execFile(file, [...argv], { timeout: timeoutMs, maxBuffer: PROBE_MAX_BUFFER }, (error, stdout, stderr) => {
-        if (error)
-            reject(error);
-        else
+        if (!error) {
+            resolve({ stdout, stderr });
+            return;
+        }
+        /*
+         * `killed` is how Node reports the timeout it was given, and a process
+         * we killed produced a TRUNCATED page of JSON — parsing that would be
+         * reading half an answer. A missing binary never runs at all and has no
+         * numeric exit code, so it falls through to `reject` too.
+         */
+        const exited = typeof error.code === 'number';
+        const killed = error.killed === true;
+        if (options?.tolerateExitCode && exited && !killed) {
             resolve({ stdout, stderr });
+            return;
+        }
+        reject(error);
     });
     // `claude doctor` reads stdin. An `execFile` child inherits an open pipe
     // nobody ever writes to, so without this EOF the probe would sit there
@@ -117,10 +135,16 @@ export async function measureAgent(runtime, run = runProbe) {
     }
     // The install method is a nice-to-have: it decides whether a BUTTON appears,
     // never whether the version is shown. A doctor that failed leaves `unknown`.
+    //
+    // `tolerateExitCode` — see `ProbeOptions`. The diagnostics command grades the
+    // whole machine and fails its own exit code over an unreachable endpoint,
+    // while answering our question perfectly on stdout.
     let managedBy = 'unknown';
     try {
         const probe = runtime.managedByProbe;
-        const { stdout, stderr } = await run(binary, probe.argv, PROBE_TIMEOUT_MS);
+        const { stdout, stderr } = await run(binary, probe.argv, PROBE_TIMEOUT_MS, {
+            tolerateExitCode: true,
+        });
         const output = `${stdout}\n${stderr}`;
         const source = probe.jsonPath ? readJsonPath(stdout, probe.jsonPath) : output;
         managedBy = normalizeManagedBy(source ? matchProbe(probe, source) : null);

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const RUNNER_VERSION = "0.49.0";
+export declare const RUNNER_VERSION = "0.50.0";
 //# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -1,3 +1,3 @@
 // Kept in sync with package.json by the release script (manual for now).
-export const RUNNER_VERSION = '0.49.0';
+export const RUNNER_VERSION = '0.50.0';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bridge4dev/runner",
-  "version": "0.49.0",
+  "version": "0.50.0",
   "description": "DevBridge dev runner — connects a dev server to DevBridge and runs agent sessions (Claude Code / Codex)",
   "homepage": "https://bridge4.dev",
   "license": "MIT",