@bivy/bivy 0.18.4 → 0.18.5-staging.2

package/bin/bivy.mjs

@@ -194,6 +194,9 @@ function commandPath(extraPath = "") {
     path.join(os.homedir(), ".local", "bin"),
     extraPath,
     process.env.PATH || "",
+    // npm global executables normally live beside the Node binary (including
+    // nvm/fnm installs). Services need this even without shell initialization.
+    path.dirname(process.execPath),
   ].filter(Boolean);
   return [...new Set(parts.flatMap((part) => String(part).split(path.delimiter)).filter(Boolean))].join(path.delimiter);
 }

package/dist/agents/claude-code/runtime.js

@@ -18,7 +18,7 @@ import { randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
 import { withExactCapabilitySurface } from "../../runtime/types.js";
 import { mapToolCall, mapToolResult } from "../../runtime/tool-call-map.js";
-import { spawnSync } from "node:child_process";
+import { resolveExecutable } from "../../executable.js";
 import fs from "node:fs";
 import { depCacheEnv } from "../../harness/dep-cache.js";
 import os from "node:os";
@@ -33,23 +33,9 @@ import { bivySessionEnv } from "../../runtime/session-env.js";
 /** Binary names a live Claude Code process could be running under (see
  *  native-process-scan.ts's best-effort cwd match). */
 const CLAUDE_BIN_NAMES = ["claude"];
-const CLAUDE_CLI_PATH_CACHE = new Map();
 /** Resolve the operator-installed Claude Code CLI; never use the SDK's bundled fallback. */
 export function claudeCliPath() {
-    const command = process.env.BIVY_CLAUDE_COMMAND?.trim() || "claude";
-    const key = `${command}\0${process.env.PATH ?? ""}`;
-    if (CLAUDE_CLI_PATH_CACHE.has(key))
-        return CLAUDE_CLI_PATH_CACHE.get(key);
-    const result = spawnSync(process.platform === "win32" ? "where" : "command", process.platform === "win32" ? [command] : ["-v", command], {
-        shell: process.platform !== "win32",
-        encoding: "utf8",
-    });
-    const resolved = result.status === 0 ? result.stdout.split(/\r?\n/)[0]?.trim() || undefined : undefined;
-    CLAUDE_CLI_PATH_CACHE.set(key, resolved);
-    return resolved;
-}
-export function invalidateClaudeCliProbe() {
-    CLAUDE_CLI_PATH_CACHE.clear();
+    return resolveExecutable(process.env.BIVY_CLAUDE_COMMAND?.trim() || "claude") ?? undefined;
 }
 export function claudeCliAvailable() {
     return Boolean(claudeCliPath());

package/dist/agents/codex/integration.js

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 // Copyright (c) 2026 Petter André Sjulstad
-import { spawn, spawnSync } from "node:child_process";
+import { spawn } from "node:child_process";
+import { resolveExecutable } from "../../executable.js";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { defineAgentIntegration } from "../definition.js";
@@ -10,25 +11,11 @@ import { deleteCodexSession, discoverNativeCodexSessions, loadCodexTranscript, w
 import { ProtocolRuntime } from "../../runtime/protocol.js";
 import { codexSlashCommands } from "../../runtime/slash-commands.js";
 export const CODEX_TESTED_VERSION = "0.156.1";
-const CODEX_AVAILABLE_CACHE = new Map();
 function codexCommand() {
     return process.env.BIVY_CODEX_BIN?.trim() || "codex";
 }
 export function codexCommandAvailable() {
-    const command = codexCommand();
-    const cached = CODEX_AVAILABLE_CACHE.get(command);
-    if (cached !== undefined)
-        return cached;
-    const result = spawnSync(process.platform === "win32" ? "where" : "command", process.platform === "win32" ? [command] : ["-v", command], {
-        shell: process.platform !== "win32",
-        stdio: "ignore",
-    });
-    const available = result.status === 0;
-    CODEX_AVAILABLE_CACHE.set(command, available);
-    return available;
-}
-export function invalidateCodexCommandProbe() {
-    CODEX_AVAILABLE_CACHE.clear();
+    return resolveExecutable(codexCommand()) !== null;
 }
 async function suggestCodexSessionName(firstPrompt, context) {
     const prompt = firstPrompt.trim();

package/dist/agents/pi/integration.js

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 // Copyright (c) 2026 Petter André Sjulstad
-import { spawnSync } from "node:child_process";
+import { resolveExecutable } from "../../executable.js";
 import os from "node:os";
 import path from "node:path";
 import { defineAgentIntegration } from "../definition.js";
@@ -36,22 +36,8 @@ export async function listNativePiSessions() {
         firstMessage: session.firstMessage,
     }));
 }
-const PI_COMMAND_CACHE = new Map();
 export function piCommandAvailable() {
-    const command = piCommand();
-    const cached = PI_COMMAND_CACHE.get(command);
-    if (cached !== undefined)
-        return cached;
-    const result = spawnSync(process.platform === "win32" ? "where" : "command", process.platform === "win32" ? [command] : ["-v", command], {
-        shell: process.platform !== "win32",
-        stdio: "ignore",
-    });
-    const available = result.status === 0;
-    PI_COMMAND_CACHE.set(command, available);
-    return available;
-}
-export function invalidatePiCommandProbe() {
-    PI_COMMAND_CACHE.clear();
+    return resolveExecutable(piCommand()) !== null;
 }
 export function piBridgeInstalled() {
     try {

package/dist/executable.js

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Petter André Sjulstad
+import fs from "node:fs";
+import path from "node:path";
+/** Resolve without a shell or a lifetime cache: installs, removals and PATH
+ * changes must be visible to a running daemon as well as its terminals. */
+export function resolveExecutable(command, env = process.env, cwd = process.cwd()) {
+    if (!command.trim())
+        return null;
+    const win = process.platform === "win32";
+    const isExecutable = (file) => {
+        try {
+            if (!fs.statSync(file).isFile())
+                return false;
+            fs.accessSync(file, win ? fs.constants.F_OK : fs.constants.X_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    const exts = win ? (env.PATHEXT || ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean) : [""];
+    const withExts = (file) => exts.map((ext) => (ext && !file.toLowerCase().endsWith(ext.toLowerCase()) ? file + ext : file));
+    const explicit = command.includes("/") || (win && command.includes("\\"));
+    const bases = explicit
+        ? [path.resolve(cwd, command)]
+        : (env.PATH || "").split(path.delimiter).filter(Boolean).map((dir) => path.resolve(cwd, dir, command));
+    for (const base of bases) {
+        for (const candidate of withExts(base)) {
+            if (isExecutable(candidate))
+                return candidate;
+        }
+    }
+    return null;
+}

package/dist/model-auth-key-recovery.js

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Petter André Sjulstad
+/** Validate keys against the vault before caching them or sharing them with peers.
+ * A stale local key must not hide a fresh peer wrap; an unusable wrap must never
+ * be persisted as though key recovery succeeded. No credential data is changed.
+ */
+export function recoverModelAuthKey(options) {
+    if (options.localKey) {
+        try {
+            return { key: options.localKey, value: options.decrypt(options.localKey) };
+        }
+        catch { /* Try the peer's replacement before requesting another wrap. */ }
+    }
+    if (options.unwrap) {
+        try {
+            const key = options.unwrap();
+            return { key, value: options.decrypt(key) };
+        }
+        catch { /* The caller must reject this exact wrap and request a new one. */ }
+    }
+    return undefined;
+}

package/dist/runtime/host.js

@@ -66,8 +66,9 @@ export class RuntimeHost {
         const info = this.list(canonical).find((candidate) => candidate.id === canonical);
         if (!info)
             throw new Error(`Unknown agent: ${wantId}`);
-        if (info.status !== "available")
-            throw new Error(`${info.displayName} is not available on this node yet.`);
+        if (info.status !== "available") {
+            throw new Error(`${info.displayName} is not available on this node. ${info.notes || "Install this agent on the node before starting a session."}`);
+        }
         return canonical;
     }
     get(requested, fallback, sandbox) {

package/dist/runtime/index.js

@@ -4,12 +4,13 @@
 // This is the seam where additional runtimes (Claude Agent SDK, generic RPC,
 // …) are registered without touching the daemon.
 import { spawnSync } from "node:child_process";
+import { resolveExecutable as resolveCommandPath } from "../executable.js";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { ClaudeCodeRuntime, claudeRuntimeFromEnv, claudeSdkInstalled, invalidateClaudeCliProbe } from "../agents/claude-code/runtime.js";
+import { ClaudeCodeRuntime, claudeRuntimeFromEnv, claudeSdkInstalled } from "../agents/claude-code/runtime.js";
 import { claudeCodeIntegration } from "../agents/claude-code/integration.js";
-import { codexAppServerRuntime, codexIntegration, invalidateCodexCommandProbe, } from "../agents/codex/integration.js";
-import { invalidatePiCommandProbe, piAgentDir, piCommandAvailable, piIntegration, LazyPiRuntime } from "../agents/pi/integration.js";
+import { codexAppServerRuntime, codexIntegration, } from "../agents/codex/integration.js";
+import { piAgentDir, piCommandAvailable, piIntegration, LazyPiRuntime } from "../agents/pi/integration.js";
 import { deleteCodexSession, loadCodexTranscript } from "./codex-sessions.js";
 import { deleteOpenCodeSession, exportOpenCodeSession, importOpenCodeSession, loadOpenCodeTranscript, writeOpenCodeHistory } from "./opencode-sessions.js";
 import { discoverNativeGrokSessions, listGrokSessions, loadGrokTranscript } from "./grok-sessions.js";
@@ -70,27 +71,9 @@ function cliSlashCommands(spec) {
 }
 export * from "./types.js";
 export { NodeCredentialResolver, createCredentialStore } from "./credentials.js";
-// Memoized CLI probes. `commandAvailable`/`resolveCommandPath`/`probeHelpText`
-// each shell out with a BLOCKING spawnSync, and the runtime catalog that calls
-// them (cliAgentInfo → prefersAcp/acpSupportedByBinary) is rebuilt often — on
-// every advertise and every runtimes.list send. Re-probing per build stalled the
-// event loop for seconds at a time (a synchronous spawn storm). A CLI's presence
-// is effectively constant for the daemon's run, so cache per command for the
-// process lifetime and clear on install (invalidateCliProbeCache).
-const COMMAND_AVAILABLE_CACHE = new Map();
+// Filesystem lookup stays fresh without spawning a shell on every catalog build.
 function commandAvailable(command) {
-    if (!command.trim())
-        return false;
-    const cached = COMMAND_AVAILABLE_CACHE.get(command);
-    if (cached !== undefined)
-        return cached;
-    const result = spawnSync(process.platform === "win32" ? "where" : "command", process.platform === "win32" ? [command] : ["-v", command], {
-        shell: process.platform !== "win32",
-        stdio: "ignore",
-    });
-    const available = result.status === 0;
-    COMMAND_AVAILABLE_CACHE.set(command, available);
-    return available;
+    return resolveCommandPath(command) !== null;
 }
 function genericCliInfo() {
     const options = processRuntimeFromEnv();
@@ -421,29 +404,6 @@ function cliThinkingConfig(id, spec) {
 // installed binary doesn't actually mention. It never UPGRADES — adding a
 // capability needs the exact arg template, which help text can't safely supply — so
 // probing can only make the catalog MORE honest, never invent a no-op control.
-/**
- * Absolute path of a command on the current PATH, or null when it isn't there.
- * Used to key the help-probe cache: caching by the bare NAME would keep serving a
- * stale answer after the binary behind that name changed (a CLI upgraded or
- * installed while the daemon is running, or a different PATH entry winning).
- * Memoized per command (see COMMAND_AVAILABLE_CACHE) — it spawnSyncs, and is hit
- * on every catalog build.
- */
-const COMMAND_PATH_CACHE = new Map();
-function resolveCommandPath(command) {
-    if (!command.trim())
-        return null;
-    const cached = COMMAND_PATH_CACHE.get(command);
-    if (cached !== undefined)
-        return cached;
-    const res = spawnSync(process.platform === "win32" ? "where" : "command", process.platform === "win32" ? [command] : ["-v", command], {
-        shell: process.platform !== "win32",
-        encoding: "utf8",
-    });
-    const resolved = res.status !== 0 ? null : ((res.stdout ?? "").split(/\r?\n/)[0]?.trim() || null);
-    COMMAND_PATH_CACHE.set(command, resolved);
-    return resolved;
-}
 const HELP_PROBE_CACHE = new Map();
 function probeHelpText(command) {
     const key = resolveCommandPath(command) ?? command;
@@ -461,21 +421,10 @@ function probeHelpText(command) {
     HELP_PROBE_CACHE.set(key, text);
     return text;
 }
-/**
- * Drop every memoized CLI probe (availability, resolved path, --help text). These
- * probes shell out with a blocking spawnSync and are cached for the process
- * lifetime to keep the frequently-rebuilt runtime catalog off the event loop, so a
- * CLI installed/updated mid-run wouldn't otherwise be noticed until a restart.
- * Call this right after Bivy installs a runtime so the next catalog build re-probes
- * and reflects the new binary immediately.
- */
+/** Refresh expensive help probes after Bivy installs or updates an agent.
+ * Executable availability itself is never cached. */
 export function invalidateCliProbeCache() {
-    COMMAND_AVAILABLE_CACHE.clear();
-    COMMAND_PATH_CACHE.clear();
     HELP_PROBE_CACHE.clear();
-    invalidatePiCommandProbe();
-    invalidateClaudeCliProbe();
-    invalidateCodexCommandProbe();
 }
 // A resume template mixes launch flags (`-p`, `--force`) with the resume-specific
 // token(s) (`--resume`, `threads continue`, `-s`, `--restore`, …). Only the latter

package/dist/server.js

@@ -149,6 +149,7 @@ import { redactSecrets } from "./redact.js";
 import { getSttConfig, isSttProvider, removeSttKey, setSttKey, setSttProvider, transcribeAudio, MAX_AUDIO_BYTES, } from "./stt.js";
 import { synthesizeOpenAiSpeech } from "./tts.js";
 import { seal, open } from "./e2e.js";
+import { recoverModelAuthKey } from "./model-auth-key-recovery.js";
 import { RunDelegationService, parseDelegationSource } from "./run-tools.js";
 import { ControlPlaneTaskPoller, resolveControlPlaneTaskConfig, } from "./control-plane-tasks.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -239,7 +240,7 @@ process.chdir(appDir);
 // dirs here makes commands work from agent shells without requiring a user shell
 // profile.
 const userLocalPrefix = process.env.BIVY_NPM_GLOBAL_PREFIX || path.join(process.env.HOME ?? os.homedir(), ".local");
-process.env.PATH = [path.join(repoRoot, "bin"), path.join(userLocalPrefix, "bin"), process.env.PATH || ""].filter(Boolean).join(path.delimiter);
+process.env.PATH = [path.join(repoRoot, "bin"), path.join(userLocalPrefix, "bin"), process.env.PATH || "", path.dirname(process.execPath)].filter(Boolean).join(path.delimiter);
 const piDir = path.join(appDir, "pi");
 // The node's shared, agent-neutral credential vault (auth.enc/auth.key). NOT
 // inside any one agent's dir — every runtime (Pi, Codex, Claude, …) reads the
@@ -3365,20 +3366,31 @@ async function syncModelAuthFromControlPlane() {
         }
         const targetVault = hostedCustody ? hostedData.hostedVault : data.vault;
         let vaultKeyB64 = hostedCustody ? readHostedModelAuthVaultKey() : readLocalModelAuthVaultKey();
-        if (!hostedCustody && !vaultKeyB64 && data.wrappedKey?.wrappedKey) {
-            vaultKeyB64 = pairingStore.unwrapFromNodePublicKey(data.wrappedKey.wrappedByPublicKey, data.wrappedKey.wrappedKey);
-            writeLocalModelAuthVaultKey(vaultKeyB64);
-        }
         // Hosted runners may decrypt ONLY the separately encrypted snapshot of
         // records that the user explicitly granted to unattended execution.
         if (hostedCustody && !vaultKeyB64 && hostedData.hostedKey && hostedData.hostedVault && Buffer.from(hostedData.hostedKey, "base64").length === 32) {
             vaultKeyB64 = hostedData.hostedKey;
             writeHostedModelAuthVaultKey(vaultKeyB64);
         }
-        if (targetVault?.ciphertext && vaultKeyB64) {
+        if (targetVault?.ciphertext && (vaultKeyB64 || (!hostedCustody && data.wrappedKey))) {
             let decrypted;
             try {
-                decrypted = decryptModelAuthEnvelope(targetVault.ciphertext, vaultKeyB64);
+                if (hostedCustody) {
+                    decrypted = decryptModelAuthEnvelope(targetVault.ciphertext, vaultKeyB64);
+                }
+                else {
+                    const wrapped = data.wrappedKey;
+                    const recovered = recoverModelAuthKey({
+                        localKey: vaultKeyB64,
+                        unwrap: wrapped ? () => pairingStore.unwrapFromNodePublicKey(wrapped.wrappedByPublicKey, wrapped.wrappedKey) : undefined,
+                        decrypt: (key) => decryptModelAuthEnvelope(targetVault.ciphertext, key),
+                    });
+                    if (!recovered)
+                        throw new Error("No available key can decrypt the account vault");
+                    vaultKeyB64 = recovered.key;
+                    decrypted = recovered.value;
+                    writeLocalModelAuthVaultKey(vaultKeyB64);
+                }
             }
             catch (error) {
                 // Most commonly this node cached the previous generation while another
@@ -3394,7 +3406,10 @@ async function syncModelAuthFromControlPlane() {
                 else {
                     forgetLocalModelAuthVaultKey();
                     lastPushedModelAuthCiphertext = "";
-                    await modelAuthFetch("/node/model-auth-key/request", { method: "POST", body: JSON.stringify({ publicKey: pairingStore.nodePublicKeyB64() }) });
+                    await modelAuthFetch("/node/model-auth-key/request", {
+                        method: "POST",
+                        body: JSON.stringify({ publicKey: pairingStore.nodePublicKeyB64(), rejectedWrappedKey: data.wrappedKey?.wrappedKey }),
+                    });
                     ensureModelAuthColdStart();
                 }
                 console.warn("[auth-sync] cached vault key is stale; requested the rotated key:", error.message);

package/dist/terminal.js

@@ -2,6 +2,7 @@
 // Copyright (c) 2026 Petter André Sjulstad
 import { randomUUID } from "node:crypto";
 import fs from "node:fs";
+import { resolveExecutable } from "./executable.js";
 import { createRequire } from "node:module";
 import path from "node:path";
 import { depCacheEnv } from "./harness/dep-cache.js";
@@ -70,41 +71,7 @@ function defaultShell() {
  * Resolving up front lets open() throw a clear, catchable error — and hands the
  * PTY an unambiguous absolute path.
  */
-export function resolveExecutable(command, env, cwd) {
-    const win = process.platform === "win32";
-    const isExecutable = (file) => {
-        try {
-            if (!fs.statSync(file).isFile())
-                return false;
-            if (win)
-                return true;
-            fs.accessSync(file, fs.constants.X_OK);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    };
-    // On Windows a bare name may need a PATHEXT suffix (claude → claude.cmd).
-    const exts = win ? (env.PATHEXT || ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean) : [""];
-    const withExts = (file) => exts.map((ext) => (ext && !file.toLowerCase().endsWith(ext.toLowerCase()) ? file + ext : file));
-    // A command with an explicit path is resolved directly (against the workspace
-    // for a relative one), never via PATH — same as exec.
-    if (command.includes("/") || (win && command.includes("\\"))) {
-        for (const candidate of withExts(path.resolve(cwd, command))) {
-            if (isExecutable(candidate))
-                return candidate;
-        }
-        return null;
-    }
-    for (const dir of (env.PATH || "").split(path.delimiter).filter(Boolean)) {
-        for (const candidate of withExts(path.join(dir, command))) {
-            if (isExecutable(candidate))
-                return candidate;
-        }
-    }
-    return null;
-}
+export { resolveExecutable } from "./executable.js";
 /**
  * Restore the execute bit on node-pty's bundled `spawn-helper` binary.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bivy/bivy",
-  "version": "0.18.4",
+  "version": "0.18.5-staging.2",
   "type": "module",
   "license": "AGPL-3.0-only",
   "description": "Run coding agents on machines you own. Open-source, self-hostable agent workspace.",