@botbuddy/cli 1.8.6 → 1.8.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbuddy/cli",
-  "version": "1.8.6",
+  "version": "1.8.7",
   "description": "BotBuddy — Swarm coordination CLI for multi-agent workflows",
   "type": "module",
   "bin": {

package/src/pw/daemon.mjs

@@ -1,13 +1,62 @@
 import { spawn } from "node:child_process";
 import net from "node:net";
 import { createRequire } from "node:module";
-import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, statSync, unlinkSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
+import { normaliseLane } from "./args.mjs";
 export const daemonDir = (env = process.env) => env.BB_PW_DAEMON_DIR || join(homedir(), ".botbuddy", "pw-daemon");
 export function resolveCliBin(env = process.env) { if (env.BB_PW_CLI_BIN) return { cmd: "node", args: [env.BB_PW_CLI_BIN] }; const require = createRequire(import.meta.url); const pkg = require.resolve("@playwright/cli/package.json"), meta = JSON.parse(readFileSync(pkg, "utf8")), bin = typeof meta.bin === "string" ? meta.bin : meta.bin["playwright-cli"] || Object.values(meta.bin)[0]; return { cmd: "node", args: [join(dirname(pkg), bin)] }; }
 export function spawnExec(plan, env = process.env) { const { cmd, args } = resolveCliBin(env); return new Promise((resolve) => { const child = spawn(cmd, [...args, ...plan.execArgv], { stdio: "inherit", env: { ...env, PWTEST_DAEMON_SESSION_DIR: daemonDir(env) } }); child.on("exit", (code) => resolve(code ?? 1)); child.on("error", () => resolve(127)); }); }
-export function readSession(session, env = process.env) { const root = daemonDir(env); if (!existsSync(root)) return null; for (const item of readdirSync(root)) { try { return JSON.parse(readFileSync(join(root, item, `${session}.session`), "utf8")); } catch {} } return null; }
-export function sendToDaemon(socketPath, positional, { connect = net.createConnection, cwd = process.cwd(), timeoutMs = 30000 } = {}) { return new Promise((resolve) => { let done = false, buffer = "", socket; const finish = (value) => { if (!done) { done = true; socket?.destroy(); resolve(value); } }; socket = connect(socketPath, () => socket.write(JSON.stringify({ id: 1, method: "run", params: { args: { _: positional }, cwd } }) + "\n")); socket.on("data", (data) => { buffer += String(data); const newline = buffer.indexOf("\n"); if (newline < 0) return; try { const reply = JSON.parse(buffer.slice(0, newline)), text = reply.result?.text ?? ""; finish(reply.error || /^### Error\b/m.test(text) ? { ok: false, error: reply.error?.message ?? reply.error ?? text } : { ok: true, text }); } catch { finish({ ok: false, error: "bb-pw: malformed daemon reply" }); } }); socket.on("error", (error) => finish({ ok: false, error: error.message })); setTimeout(() => finish({ ok: false, error: "bb-pw: daemon socket timeout" }), timeoutMs).unref(); }); }
+// BOT-1522: playwright-cli keeps one sub-dir per invocation context under the
+// daemon dir, and only ever cleans up its OWN sub-dir's `<session>.session`. A
+// lane opened from another worktree whose daemon has since exited leaves a file
+// pointing at a socket that no longer exists — and it can sort before today's
+// live one. Selection is therefore by liveness, never by readdir order, and the
+// caller gets a remediation naming the lane and the command, never a raw syscall.
+export const laneOf = (session) => normaliseLane(session ?? "");
+// Any connect-phase failure means the daemon is not there to answer; name the
+// shape in prose so the syscall code never reaches the operator (AC-3/AC-6).
+const CONNECT_FAILURE = { ENOENT: "its socket is gone", ECONNREFUSED: "its socket refused the connection", ENOTSOCK: "its socket refused the connection", ECONNRESET: "the connection dropped", EPIPE: "the connection dropped" };
+const connectFailure = (error) => (error?.code ? CONNECT_FAILURE[error.code] ?? "the connection failed" : null);
+export function notRunningMessage(session, ignored = [], detail = null) {
+  const why = ignored.length ? `ignored stale session file(s): ${ignored.map((entry) => `${entry.file} [${entry.reason}]`).join(", ")}` : detail ?? "no session file found";
+  return `bb-pw: ${session} daemon is not running (${why}). Run \`bb-pw ${laneOf(session) || "<lane>"} open <url>\` first, then retry.`;
+}
+// Every `<root>/<sub>/<session>.session`, newest first. A file whose socket path
+// is ABSENT on disk is provably dead (the daemon's tmp dir is gone) and is
+// pruned; one whose socket EXISTS is kept — the daemon may be starting — and
+// liveness is decided by connecting (resolveSession), not by the file. Corrupt
+// JSON is left alone: it is not provably dead. Only this session's file is read,
+// so another lane's live daemon in the same sub-dir is never touched.
+export function scanSessions(session, env = process.env, { prune = true } = {}) {
+  const root = daemonDir(env), candidates = [], ignored = [];
+  if (!existsSync(root)) return { candidates, ignored };
+  for (const item of readdirSync(root)) {
+    const file = join(root, item, `${session}.session`);
+    let data; try { data = JSON.parse(readFileSync(file, "utf8")); } catch { continue; }
+    if (!data?.socketPath) { ignored.push({ file, reason: "no socket path" }); continue; }
+    if (!existsSync(data.socketPath)) { ignored.push({ file, reason: "socket missing" }); if (prune) { try { unlinkSync(file); } catch {} } continue; }
+    let mtimeMs = 0; try { mtimeMs = statSync(file).mtimeMs; } catch {}
+    candidates.push({ file, data, mtimeMs });
+  }
+  // Newest first; a deterministic path tiebreak so an mtime tie never falls back to readdir order.
+  candidates.sort((a, b) => b.mtimeMs - a.mtimeMs || b.file.localeCompare(a.file));
+  return { candidates, ignored };
+}
+// Synchronous, back-compatible, READ-ONLY reader (reap.mjs): the newest session
+// whose socket path exists on disk. Pruning belongs to the socket path (socketRun).
+export function readSession(session, env = process.env) { return scanSessions(session, env, { prune: false }).candidates[0]?.data ?? null; }
+export function sendToDaemon(socketPath, positional, { connect = net.createConnection, cwd = process.cwd(), timeoutMs = 30000, session = null } = {}) { return new Promise((resolve) => { let done = false, buffer = "", socket; const finish = (value) => { if (!done) { done = true; socket?.destroy(); resolve(value); } }; socket = connect(socketPath, () => socket.write(JSON.stringify({ id: 1, method: "run", params: { args: { _: positional }, cwd } }) + "\n")); socket.on("data", (data) => { buffer += String(data); const newline = buffer.indexOf("\n"); if (newline < 0) return; try { const reply = JSON.parse(buffer.slice(0, newline)), text = reply.result?.text ?? ""; finish(reply.error || /^### Error\b/m.test(text) ? { ok: false, error: reply.error?.message ?? reply.error ?? text } : { ok: true, text }); } catch { finish({ ok: false, error: "bb-pw: malformed daemon reply" }); } }); socket.on("error", (error) => { const why = session ? connectFailure(error) : null; finish({ ok: false, error: why ? notRunningMessage(session, [], why) : error.message }); }); setTimeout(() => finish({ ok: false, error: "bb-pw: daemon socket timeout" }), timeoutMs).unref(); }); }
 export function socketAlive(socketPath, { connect = net.createConnection, timeoutMs = 1000 } = {}) { return new Promise((resolve) => { if (!socketPath) return resolve(false); let done = false, socket; const finish = (value) => { if (!done) { done = true; socket?.destroy(); resolve(value); } }; socket = connect(socketPath, () => finish(true)); socket.on("error", () => finish(false)); setTimeout(() => finish(false), timeoutMs).unref(); }); }
-export async function socketRun(plan, env = process.env) { const session = readSession(plan.session, env); return session?.socketPath ? sendToDaemon(session.socketPath, plan.socketArgs) : { ok: false, error: `bb-pw: no open daemon for ${plan.session}; open it first` }; }
+// Authoritative, async: the newest candidate whose socket actually ANSWERS.
+export async function resolveSession(session, env = process.env, { alive = socketAlive } = {}) {
+  const { candidates, ignored } = scanSessions(session, env);
+  for (const candidate of candidates) { if (await alive(candidate.data.socketPath)) return { session: candidate.data, ignored }; ignored.push({ file: candidate.file, reason: "did not answer" }); }
+  return { session: null, ignored };
+}
+export async function socketRun(plan, env = process.env, { alive, send = sendToDaemon } = {}) {
+  const { session, ignored } = await resolveSession(plan.session, env, { alive });
+  if (!session) return { ok: false, error: notRunningMessage(plan.session, ignored) };
+  return send(session.socketPath, plan.socketArgs, { session: plan.session });
+}

package/src/pw/run.mjs

@@ -7,6 +7,7 @@ import { canonicalizeHostString } from "./host.mjs";
 import { resolveAgentProfile } from "../wait-profile.mjs";
 import { readProfileIdentity } from "../agent-credential-store.mjs";
 import { loadConfig, getConfig } from "../config.mjs";
+import { VERSION } from "../version.mjs";
 // BOT-1488: canonicalize the raw hostname the SAME way acquire_resources does
 // server-side, so the lane name bb-pw builds/matches/prints is the one the lock
 // kernel actually stored ("jonos-mbp:8", not "Jonos-MBP.localdomain:8").
@@ -68,8 +69,22 @@ async function gate({ env, host, lane, deps }) {
     return { allowed: false, message: `bb-pw: could not verify lane lock ${laneName} (${error.message}). Set BB_PW_NO_LOCK=1 for local-only work.` };
   }
 }
+// BOT-1522: a stale global install (1.6.1 on the reporting host) replayed the
+// pre-BOT-1488 refusal and was indistinguishable from a code regression. Every
+// non-zero exit now names the bundled version, and --version exists at all, so
+// an agent can tell "old binary" from "real bug" without reading the source.
+const versionLine = () => `bb-pw (@botbuddy/cli v${VERSION})`;
 export async function runPw(argv, deps = {}) {
+  const stderr = deps.stderr ?? process.stderr;
+  const code = await runPwInner(argv, deps);
+  // Neutral: a refusal may be correct policy, not staleness — the line only lets
+  // the reader compare this binary against cli/package.json in their checkout.
+  if (code !== 0) stderr.write(`${versionLine()} — if your checkout's cli/package.json is newer, this global is stale: npm i -g @botbuddy/cli@latest, or run node cli/bin/bb-pw.mjs from the repo.\n`);
+  return code;
+}
+async function runPwInner(argv, deps = {}) {
   const env = deps.env ?? process.env, stdout = deps.stdout ?? process.stdout, stderr = deps.stderr ?? process.stderr; let args = [...argv]; if (["--help", "-h"].includes(args[0])) { help(stdout); return 0; }
+  if (["--version", "-v"].includes(args[0])) { stdout.write(`${versionLine()}\n`); return 0; }
   while (args[0] === "--profile" || args[0] === "--session-id") { const flag = args[0]; if (!args[1]) { stderr.write(`bb-pw: ${flag} needs a value\n`); return 2; } deps = flag === "--profile" ? { ...deps, profile: args[1] } : { ...deps, sessionId: args[1] }; args = args.slice(2); }
   let plan; try { plan = planInvocation(args, env); } catch (error) { stderr.write(`${error.message}\n`); return 2; }
   const { spawnExec, socketRun } = deps.daemon ?? await import("./daemon.mjs");

package/src/botbuddy-release-repair.json

@@ -1 +0,0 @@
-{"schema_version":1,"source_version":"1.8.3","source_identity":"8304ea6fbec329d54d6361cb6cbf5a6789331b0851d09caf151f0663ade18ec2"}