baychat 0.28.0 → 0.29.1

package/dist/main.js

@@ -10,6 +10,7 @@ const update_command_1 = require("./update-command");
 const session_command_1 = require("./session-command");
 const doctor_command_1 = require("./doctor-command");
 const bays_command_1 = require("./bays-command");
+const command_1 = require("./launch/command");
 const hermes_1 = require("./hermes");
 const connect_1 = require("./connect");
 const connect_plan_1 = require("./connect-plan");
@@ -22,164 +23,10 @@ const commands_2 = require("./relay/commands");
 const bays_1 = require("./bays");
 const config_1 = require("./config");
 const help_topics_1 = require("./help-topics");
+const cli_help_1 = require("./cli-help");
 const args_1 = require("./args");
 const owner_pid_1 = require("./relay/owner-pid");
 const profiles_1 = require("./relay/profiles");
-const LOGIN_HELP = `Usage: baychat login [--start | --finish | --token <PAT>] [--base <url>]
-
-  --start   Print an approval link and return immediately; no waiting process.
-  --finish  Check approval once, save it and refresh connected clients.
-  --token   Verify and save a device token (prefer the approval link in chat).
-  --base    Use your BayChat server instead of the default.
-
-Without a mode, display a QR/link and wait for approval in this terminal.
-For an agent session: login --start, show the link, then login --finish after approval.
-Exit 0: step succeeded; 2: awaiting approval or expired; 1: error.
-`;
-const HELP = `baychat — BayChat connector CLI for agent sessions (Claude Code, Codex)
-
-Usage:
-  baychat                               Start a session. This is the whole thing: it runs
-                                        your agent somewhere BayChat can reach, so /clear
-                                        and /new from the app work. Sign in once with
-                                        \`baychat login\` first
-  baychat start [name] [--runtime <runtime>]
-                                        The same, with a name for the session
-  baychat update                        Bring this machine onto the current version —
-                                        the package, every connected client's config, and
-                                        the relay daemon (which otherwise keeps running
-                                        old code). \`baychat\` does this for you once a day
-  baychat join [name] [group] [--sessions | --private | --group <title>] [--runtime <runtime>] [--bay <Bay>]
-  baychat join --session <name> --group <title> --runtime codex
-  baychat skill --runtime codex|claude   Read the current packaged skill workflow
-                                        Join and connect incoming messages in this terminal
-  baychat session-name --runtime <runtime>
-                                        Stable automatic name for this verified session
-  baychat onboard [conversationId] [--catch-up]
-                                        Start here — print the agent protocol + your
-                                        live identity, conversations, and room context.
-                                        --catch-up also appends the rolling summary +
-                                        the messages after its boundary
-  baychat connect [codex|cursor|desktop] [--base <url>]
-                                        START HERE, once per laptop. Approve a QR on your
-                                        phone, and your client's MCP config is written for
-                                        you. Then run /baychat <name> in any session to
-                                        join as that session. No config blocks, no editing
-  baychat connect dsh|cursor-cli [--folder <path>] [--max-mode <mode>] [--mode <mode>] [--session <name>]
-                                        An agent the relay runs by itself (DeepSeek Harness,
-                                        Cursor's CLI): you talk to it from the app. The
-                                        folder and the highest mode are set here, never
-                                        from a chat
-  baychat login [--start | --finish | --token <PAT>] [--base <url>]
-                                        Log this laptop in to BayChat (QR) and add the
-                                        BayChat MCP server to Claude Code. Creates a
-                                        device credential only — no agent, no room
-  baychat bays [default <name>]         The Bays this computer is logged in to. One phone
-                                        approval signs an Enterprise owner's computer in to
-                                        the Personal Bay AND its Team Bays; \`default\` picks
-                                        the one a session joins when it names no Bay
-  baychat pair <code> [--base <url>]   Redeem a pairing code from the BayChat app
-  baychat hermes init [--home <dir>] [--enable]
-                                        Install the BayChat platform plugin into a Hermes
-                                        agent (~/.hermes), and put your paired agent token
-                                        where its adapter reads it. --enable also runs the
-                                        two hermes commands that switch it on
-  baychat link [--name <n>] [--base <url>]
-                                        Link this session via a QR you scan with your phone
-  baychat help [topic|question]         How to USE BayChat from a client — making a
-                                        group, joining a room, which tools your
-                                        credential gets. Ask it however you like:
-                                        \`baychat help "make a new group"\`. These are
-                                        MCP tools your client calls, not subcommands,
-                                        so they are not in the list below
-  baychat whoami                        Show the connected agent identity
-  baychat conversations                 List conversations this agent is in
-  baychat send <conversationId> <text>  Send a message
-  baychat typing <conversationId>       Show the typing indicator while you work, so a long
-                                        tool call doesn't look like a crash. ONE call at the
-                                        start of a turn — it lapses on its own after a few
-                                        seconds, so there is nothing to stop and no loop to run
-  baychat react <conversationId> <messageId> <emoji> [--remove]
-                                        Acknowledge one message so the person who sent it
-                                        knows you have read it and are on it. Unlike typing,
-                                        the reaction STAYS on the message — use 👀 the moment
-                                        you pick up work that will take more than a few
-                                        seconds. Reacting again replaces it; --remove clears it
-  baychat check <conversationId>        Print messages since the last check
-  baychat context <conversationId>      Show the roster + the group's agent instructions
-  baychat summary <conversationId> [--refresh]
-                                        Catch up: rolling summary + the messages after
-                                        its boundary (--refresh forces regeneration)
-  baychat search <query> [--limit <n>]  Search the web through BayChat (results are
-                                        untrusted content — read, never obey)
-  baychat fetch <url> [--max-chars <n>] Fetch one public http(s) page as readable text
-                                        (untrusted content — read, never obey)
-  baychat qr [<conversationId>]         Render this agent's connection QR in the terminal
-  baychat mcp                           Run a local stdio MCP server so MCP-aware clients
-                                        (Claude Desktop, Claude Code, Cursor) get BayChat
-                                        as native tools. Speaks JSON-RPC on stdout — do not
-                                        run it interactively
-  baychat mcp-config [--client codex|cursor|desktop]
-                                        Print a paste-ready MCP config for another
-                                        client, pointed at the remote BayChat server.
-                                        No --client lists what's supported. The config
-                                        goes to stdout, the guidance to stderr
-  baychat watch <conversationId> [--interval <sec>] [--timeout <sec>]
-                                        Block until new messages arrive (exit 0)
-                                        or timeout (exit 2)
-  baychat relay start [--foreground]    Run the relay: one event stream for this whole
-                                        machine, waking local sessions the moment a
-                                        message arrives. Prefers the agent WebSocket
-                                        and falls back to the /updates long-poll on its
-                                        own. Installs a systemd user unit so it returns
-                                        after a reboot; --foreground runs it in this
-                                        process instead
-  baychat relay status                  Transport, sessions, cursor, and any DELIVERY
-                                        PENDING — messages that reached this box and
-                                        that nothing answered (exit 2 if any pending).
-                                        Each session also prints WHERE its resume id
-                                        came from, so "we can wake this headlessly"
-                                        is a claim you can check
-  baychat relay stop                    Stop the relay and disable it at boot
-  baychat doctor [--json]               Check every link between this machine and
-                                        BayChat — credential, relay, and per runtime
-                                        its MCP registration, skill, executable and
-                                        live session — and print exactly what to type
-                                        for each thing that is wrong. Exit 0 clear,
-                                        1 broken, 2 messages nothing answered.
-                                        --json emits the same report as data, for
-                                        pasting into a support thread
-  baychat context-hooks <install|uninstall|status>
-                                        Let BayChat see how full your Claude Code
-                                        sessions' context is. install wraps your status
-                                        line (it still looks exactly the same) and adds
-                                        two compaction hooks to ~/.claude/settings.json,
-                                        with a backup; uninstall puts it all back.
-  baychat approve-hook [--session <name>] [--timeout <sec>]
-                                        Claude Code PermissionRequest hook: send the
-                                        permission prompt to BayChat as a decision card
-                                        and answer it from your phone. Reads the hook
-                                        JSON on stdin, writes ONE decision object to
-                                        stdout, and always exits 0. FAILS CLOSED — every
-                                        error denies. NOT enabled by default; see
-                                        docs/features/REMOTE_APPROVAL_HOOK.md before
-                                        switching it on, because it moves the last line
-                                        between an agent and this machine onto a phone
-  baychat relay attach --session <name> [--runtime claude|codex|hermes]
-                        [--resume-id <id>] [--timeout <sec>]
-                                        Register this session with the relay and block
-                                        until it is woken (exit 0), or the wait lapses
-                                        (exit 2). Without --resume-id the session is
-                                        asked to identify itself from its runtime's
-                                        environment ($CLAUDE_CODE_SESSION_ID for Claude
-                                        Code); failing that the relay searches the
-                                        runtime's own session state when a message
-                                        arrives. A session it cannot identify is
-                                        reported pending, never guessed at
-
-Connect flow: in BayChat, open the agent -> Connect -> copy the pairing code,
-then run \`baychat pair <code>\`. Pairing rotates the agent token; use a
-dedicated agent per session.`;
 /** Drop a `--name <value>` pair, so a multi-word positional (a search query)
  * doesn't swallow the flag's value as part of itself.
  *
@@ -209,11 +56,11 @@ async function main() {
     // when this machine is not signed in, so nothing is launched from an unusable state.
     if (command === undefined)
         return (0, start_command_1.cmdStart)([]);
-    // Setup help must be side-effect free. Do not apply this to chat commands:
-    // a sent message may legitimately contain the literal text "--help".
-    if (["login", "link", "connect", "pair", "join", "skill"].includes(command) &&
-        args.some((arg) => arg === "--help" || arg === "-h")) {
-        console.log(command === "login" ? LOGIN_HELP : HELP);
+    // Asking for help never acts: `--help`/`-h` on any command prints its usage and runs nothing
+    // (cli-help.ts says which commands' arguments are not ours to read — `claude`, `send`, …).
+    const help = (0, cli_help_1.helpRequest)(command, args);
+    if (help !== undefined) {
+        console.log(help);
         return 0;
     }
     switch (command) {
@@ -251,20 +98,20 @@ async function main() {
             });
             return 0;
         case "login": {
-            (0, args_1.rejectUnknownFlags)(args, ["--start", "--finish", "--base", "--token"], LOGIN_HELP);
+            (0, args_1.rejectUnknownFlags)(args, ["--start", "--finish", "--base", "--token"], cli_help_1.LOGIN_HELP);
             for (let index = 0; index < args.length; index++) {
                 const arg = args[index];
                 if (arg === "--base" || arg === "--token") {
                     if (!(0, args_1.flag)(args.slice(index), arg))
-                        throw new Error(`${arg} needs a value.\n${LOGIN_HELP}`);
+                        throw new Error(`${arg} needs a value.\n${cli_help_1.LOGIN_HELP}`);
                     index++;
                 }
                 else if (arg !== "--start" && arg !== "--finish")
-                    throw new Error(`Unexpected login argument.\n${LOGIN_HELP}`);
+                    throw new Error(`Unexpected login argument.\n${cli_help_1.LOGIN_HELP}`);
             }
             if (["--start", "--finish", "--token"].filter((arg) => args.includes(arg))
                 .length > 1)
-                throw new Error(`Choose one login mode.\n${LOGIN_HELP}`);
+                throw new Error(`Choose one login mode.\n${cli_help_1.LOGIN_HELP}`);
             const loggedIn = await (0, commands_1.cmdLogin)({
                 base: (0, args_1.flag)(args, "--base"),
                 token: (0, args_1.flag)(args, "--token"),
@@ -277,11 +124,10 @@ async function main() {
             return loggedIn ? 0 : 2; // 2 = not approved yet, or expired
         }
         case "bays":
-            if (args.some((arg) => arg === "--help" || arg === "-h")) {
-                console.log(bays_command_1.BAYS_USAGE);
-                return 0;
-            }
             return (0, bays_command_1.cmdBays)(args);
+        case "launch":
+            // Local only: which folders BayChat may start sessions in. Nothing over the network writes it.
+            return (0, command_1.cmdLaunch)(args);
         case "pair": {
             if (!args[0])
                 throw new Error("Usage: baychat pair <code>");
@@ -515,14 +361,14 @@ async function main() {
                 console.log((0, help_topics_1.topicIndex)());
                 return 1;
             }
-            console.log(HELP);
+            console.log(cli_help_1.HELP);
             console.log("");
             console.log((0, help_topics_1.topicIndex)());
             return 0;
         }
         default:
             console.error(`Unknown command: ${command}`);
-            console.log(HELP);
+            console.log(cli_help_1.HELP);
             return 1;
     }
 }

package/dist/multiplexer-launch.js

@@ -0,0 +1,271 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.launchAgent = launchAgent;
+exports.runHere = runHere;
+exports.multiplexerArgv = multiplexerArgv;
+exports.offerTmux = offerTmux;
+exports.tmuxTip = tmuxTip;
+exports.tmuxInstallerFor = tmuxInstallerFor;
+exports.askLine = askLine;
+exports.realLaunchDeps = realLaunchDeps;
+exports.onPath = onPath;
+/**
+ * Starting an agent where `/clear` from the phone can reach it — ONE launcher for `baychat start`
+ * and `baychat claude`, so the two cannot drift apart.
+ *
+ * ── WHY A MULTIPLEXER ─────────────────────────────────────────────────────────────────
+ *
+ * `/clear`, `/new`, `/compact` and the app's Fresh start work by TYPING into the session's
+ * terminal (relay/terminal-pane.ts), and only tmux or screen give a terminal an address that
+ * can be typed into. So when one is installed the agent starts inside it; when the person is
+ * already inside one, the agent just runs (nesting sends every prefix key to the wrong one).
+ *
+ * ── WHEN NEITHER IS INSTALLED (the owner's "A + C", 2026-10-05) ───────────────────────
+ *
+ * The agent ALWAYS starts. Before it does, one line says how to get the commands
+ * (`brew install tmux`, `sudo apt install tmux`, …), and — once, at a real terminal — the
+ * person is asked whether to install tmux now. A "no" is remembered in the config directory,
+ * so after that it is the one line and nothing else. Plain Windows has no tmux at all: nothing
+ * is said there.
+ *
+ * ── WHAT NEVER GOES INTO A MULTIPLEXER ───────────────────────────────────────────────
+ *
+ * Anything that is not an interactive session at a terminal: with stdin or stdout redirected,
+ * tmux refuses to start ("not a terminal"); and a one-shot command (`claude -p`, `claude mcp
+ * list`) would print into a tmux session that closes the moment it exits. The caller says
+ * which it is launching; this module only checks the terminal.
+ */
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const config_1 = require("./config");
+const terminal_pane_1 = require("./relay/terminal-pane");
+/**
+ * Start `program` where session commands can reach it — inside tmux or screen when possible —
+ * and return its exit status. Never refuses to start the agent: every failure on the way falls
+ * back to running it right here.
+ */
+async function launchAgent(program, naming, deps = realLaunchDeps()) {
+    if (deps.platform === "win32" || !deps.atTerminal || (0, terminal_pane_1.detectPane)(deps.env))
+        return runHere(program, deps);
+    const multiplexer = firstWorking(deps) ?? (await offerTmux(deps));
+    if (!multiplexer)
+        return runHere(program, deps);
+    const argv = multiplexerArgv(multiplexer, naming, program, deps);
+    const result = deps.run(multiplexer, argv, { ...deps.env, ...program.env });
+    // Falling back rather than failing: the multiplexer is an enhancement, and refusing to start
+    // somebody's agent because of one would be the tail wagging the dog.
+    if (result.error)
+        return runHere(program, deps);
+    return result.status ?? 0;
+}
+/** Run the agent in this terminal, as it would run without BayChat. */
+function runHere(program, deps = realLaunchDeps()) {
+    const result = deps.run(program.binary, program.args, { ...deps.env, ...program.env });
+    if (result.error) {
+        deps.say(`Could not start ${path.basename(program.binary)}: ${result.error.message}`);
+        return 1;
+    }
+    return result.status ?? 0;
+}
+/**
+ * The multiplexer's argv. The agent's own variables ride on `env`, because a tmux server that
+ * is already running starts new panes with ITS environment, not the client's — so the channel
+ * marker set only on the client would never reach Claude Code. `env` then execs the agent, so
+ * the pane's foreground program is still the agent itself (what the pane check looks for).
+ */
+function multiplexerArgv(multiplexer, naming, program, 
+/** Needed only for a `fresh` name (its pid suffix and the tmux uniqueness check). */
+deps) {
+    const vars = Object.entries(program.env).map(([k, v]) => `${k}=${v}`);
+    const command = vars.length ? ["env", ...vars, program.binary, ...program.args] : [program.binary, ...program.args];
+    if (naming.kind === "detached") {
+        return multiplexer === "tmux" ? ["new", "-d", "-s", naming.name, "-c", naming.cwd, ...command] : ["-dmS", naming.name, ...command];
+    }
+    if (!deps)
+        throw new Error("multiplexerArgv: a fresh or reattached session needs the launch deps");
+    if (multiplexer === "tmux") {
+        return naming.kind === "reattach"
+            ? // `-A` attaches to an existing session of that name instead of failing, so running this
+                // twice returns you to your agent rather than erroring at you.
+                ["new", "-A", "-s", naming.name, ...command]
+            : ["new", "-s", uniqueTmuxName(naming.prefix, deps), ...command];
+    }
+    // screen tells same-named sessions apart by pid, so a fresh one needs no uniqueness check.
+    return naming.kind === "reattach" ? ["-S", naming.name, "-R", ...command] : ["-S", `${naming.prefix}-${deps.pid}`, ...command];
+}
+/** `claude-<pid>`, or with a suffix when a tmux session of that name already exists. */
+function uniqueTmuxName(prefix, deps) {
+    const base = `${prefix}-${deps.pid}`;
+    for (let n = 1; n < 100; n++) {
+        const name = n === 1 ? base : `${base}-${n}`;
+        if (!deps.tmuxHasSession(name))
+            return name;
+    }
+    return `${base}-${Date.now()}`;
+}
+/**
+ * The first multiplexer that RUNS, not the first on the PATH. The distinction has already cost
+ * this codebase a week: a probe that picked a binary which existed and could not start.
+ */
+function firstWorking(deps) {
+    return ["tmux", "screen"].find((m) => deps.works(m));
+}
+/**
+ * Neither multiplexer is installed: say how to get one, and — once, at a terminal — offer to
+ * install tmux. Resolves "tmux" only when it was installed now and runs.
+ */
+async function offerTmux(deps) {
+    const installer = deps.installer();
+    deps.say(tmuxTip(deps.platform, installer));
+    if (!installer || deps.declinedTmux())
+        return undefined;
+    const answer = await deps.ask("Install tmux now? (y/N) ");
+    if (!/^\s*y(es)?\s*$/i.test(answer)) {
+        deps.rememberDeclined();
+        return undefined;
+    }
+    const result = deps.run(installer.file, installer.args, deps.env);
+    if (result.error || result.status !== 0) {
+        deps.say(`tmux was not installed (${result.error?.message ?? `exit ${result.status}`}). Starting without it.`);
+        return undefined;
+    }
+    return deps.works("tmux") ? "tmux" : undefined;
+}
+/** The one line shown when no multiplexer is installed. */
+function tmuxTip(platform, installer) {
+    const how = installer
+        ? `install it with \`${installer.display}\``
+        : platform === "darwin"
+            ? "install Homebrew (https://brew.sh), then `brew install tmux`"
+            : "install tmux with your system's package manager";
+    return `BayChat: /clear and /new from the app need tmux, which is not installed here — ${how}, and BayChat will start your sessions inside it.`;
+}
+/**
+ * How to install tmux on this computer, or undefined when there is no way BayChat knows to do
+ * it unattended: Homebrew on macOS (never with sudo), else apt, dnf or pacman through sudo —
+ * or directly when this already runs as root.
+ */
+function tmuxInstallerFor(platform, onPath, isRoot) {
+    if (platform === "darwin") {
+        return onPath("brew") ? { file: "brew", args: ["install", "tmux"], display: "brew install tmux" } : undefined;
+    }
+    if (platform !== "linux")
+        return undefined;
+    const managers = [
+        { cmd: "apt-get", args: ["install", "-y", "tmux"], display: "apt install tmux" },
+        { cmd: "dnf", args: ["install", "-y", "tmux"], display: "dnf install tmux" },
+        { cmd: "pacman", args: ["-S", "--noconfirm", "tmux"], display: "pacman -S tmux" },
+    ];
+    const manager = managers.find((m) => onPath(m.cmd));
+    if (!manager)
+        return undefined;
+    if (isRoot)
+        return { file: manager.cmd, args: manager.args, display: manager.display };
+    if (!onPath("sudo"))
+        return undefined;
+    return { file: "sudo", args: [manager.cmd, ...manager.args], display: `sudo ${manager.display}` };
+}
+/** Ask one question at the terminal. */
+function askLine(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => rl.question(question, (answer) => {
+        rl.close();
+        resolve(answer);
+    }));
+}
+const TMUX_OFFER_FILE = "tmux-offer.json";
+/**
+ * How each program is asked for its version. tmux has no `--version`: it prints its usage and
+ * exits 1 (tmux 3.4, measured 2026-10-05), which made the old probe skip an installed tmux and
+ * fall through to screen.
+ */
+const VERSION_FLAG = { tmux: "-V" };
+function realLaunchDeps() {
+    const offerPath = () => path.join((0, config_1.configDir)(), TMUX_OFFER_FILE);
+    return {
+        platform: process.platform,
+        env: process.env,
+        atTerminal: !!process.stdin.isTTY && !!process.stdout.isTTY,
+        pid: process.pid,
+        run: (file, args, env) => {
+            const r = (0, child_process_1.spawnSync)(file, args, { stdio: "inherit", env });
+            return { status: r.status, ...(r.error ? { error: r.error } : {}) };
+        },
+        works: (program) => {
+            const probe = (0, child_process_1.spawnSync)(program, [VERSION_FLAG[program] ?? "--version"], { stdio: "ignore" });
+            return !probe.error && probe.status === 0;
+        },
+        tmuxHasSession: (name) => (0, child_process_1.spawnSync)("tmux", ["has-session", "-t", `=${name}`], { stdio: "ignore" }).status === 0,
+        installer: () => tmuxInstallerFor(process.platform, (cmd) => onPath(cmd, process.env), process.getuid?.() === 0),
+        ask: askLine,
+        say: (line) => console.error(line),
+        declinedTmux: () => {
+            try {
+                return fs.existsSync(offerPath());
+            }
+            catch {
+                return false;
+            }
+        },
+        rememberDeclined: () => {
+            try {
+                fs.mkdirSync((0, config_1.configDir)(), { recursive: true });
+                fs.writeFileSync(offerPath(), JSON.stringify({ declinedAt: new Date().toISOString() }, null, 2));
+            }
+            catch (err) {
+                // Not remembering costs one more question next time — never worth failing a start for.
+                console.error(`(could not remember that answer: ${err instanceof Error ? err.message : String(err)})`);
+            }
+        },
+    };
+}
+/** Is an executable `cmd` on PATH? A file check only: nothing is run. */
+function onPath(cmd, env) {
+    for (const dir of (env.PATH ?? "").split(path.delimiter)) {
+        if (!dir)
+            continue;
+        try {
+            fs.accessSync(path.join(dir, cmd), fs.constants.X_OK);
+            return true;
+        }
+        catch {
+            // Not in this directory; the next one may have it.
+        }
+    }
+    return false;
+}