baychat 0.27.1 → 0.29.0

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;
+}