baychat 0.40.0 → 0.41.1

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "baychat",
-  "version": "0.40.0",
+  "version": "0.41.1",
   "displayName": "BayChat",
   "description": "Wakes this Claude Code session the moment a BayChat message arrives: no Monitor, no 30-minute deadline. Uses the baychat CLI already on this computer (npm install -g baychat, then baychat login).",
   "author": {

package/README.md

@@ -171,6 +171,14 @@ it asks every time, lists every installed agent and marks the last one chosen; E
 `--runtime claude` (or `codex`, …) skips the question. With no terminal (the relay, a script) it
 never asks: it starts the last choice, or the best-supported installed agent.
 
+**`baychat start` always opens a new session; `baychat attach` goes back to one.** Since 0.41.1
+`start` never resumes an open session (it used to reattach to one called `baychat`, so the agent
+you picked could be ignored). `baychat start polish` names the new session `polish` (`polish-2`
+when that is taken); with no name it is `<agent>-<pid>`. `baychat attach` lists the BayChat
+sessions open on this computer — name, agent, how long running — and attaches to the one you pick
+(`baychat attach polish` goes straight there). Only sessions BayChat started are listed, never
+your own tmux or screen sessions.
+
 To keep the system Node at 20 for other projects, run only `baychat` on Node 22 (Linux/WSL with
 systemd; details in [`CLAUDE_CODE_CHANNEL.md`](../../docs/features/CLAUDE_CODE_CHANNEL.md)):
 unpack Node 22 into `~/.local/node22`, then put a wrapper `~/.local/bin/baychat` ahead of npm's
@@ -918,6 +926,10 @@ instruction):
 | `get_note` | Read one note in full (and the version to edit from) |
 | `create_note` | Write a note for the project or the chat; it lands on the shelf (people pin) |
 | `update_note` | Edit a note from the version you read; if someone saved since, nothing is overwritten and you get theirs to merge |
+| `list_board_cards` | The to-dos on the boards of the chat's project, by column, with the board's table fields and each to-do's values; `mine` marks the ones you may move or edit |
+| `add_board_card` | Add a to-do: yours by default (claim the work you are doing); one for a person or nobody is only a suggestion until a person accepts it |
+| `move_board_card` | Move one of your to-dos to another column (Doing, Done, Blocked) |
+| `update_board_card` | Edit the title, notes, dates or table values of one of your to-dos (money in integer cents) |
 | `get_conversation_summary` | The rolling catch-up summary (decisions, tasks, questions, facts + source ids) |
 | `get_messages` | Recent messages enriched with sender, mentions, and `shouldRespond` |
 | `send_message` | Send a message into a conversation |

package/dist/attach-command.js

@@ -0,0 +1,250 @@
+"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.SESSION_AGENT_VAR = void 0;
+exports.findOpenSessions = findOpenSessions;
+exports.attachArgv = attachArgv;
+exports.cmdAttachWith = cmdAttachWith;
+exports.cmdAttach = cmdAttach;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const multiplexer_launch_1 = require("./multiplexer-launch");
+const started_1 = require("./relay/launcher/started");
+/**
+ * `baychat attach [name]` — back into a BayChat session already open on this computer.
+ *
+ * Karmen, 9 Nov 2026: `baychat start` always opens a NEW session (it used to reattach to one
+ * called `baychat`, and dropped her into an old Codex after she had picked Claude). Going back to
+ * a running session is this command: a numbered list of the sessions open here — name, agent,
+ * how long it has run — and the one picked is attached. One open: straight in. None: say so.
+ * No terminal: print the list, attach nothing.
+ *
+ * ── ONLY OURS, NEVER A PERSON'S OWN ──────────────────────────────────────────────────
+ *
+ * A tmux or screen session counts only when BayChat made it, proven, never guessed from a name:
+ *  - tmux: the agent in it carries `BAYCHAT_TMUX_SESSION=<that very session>` — set by `baychat
+ *    start` and `baychat claude` since October, so sessions started before this command exist
+ *    are found too;
+ *  - screen: the agent carries `BAYCHAT_SESSION_AGENT` (set by `start` from 0.41.1);
+ *  - a session started from the app: the relay launcher's own record (`launch/started.json`).
+ * The variable is read from the agent process's environment (Linux `/proc`, macOS `ps -E`) — on
+ * the pane's process or its child, because a pane may run a shell that started the agent.
+ */
+/** Set on the agent by `baychat start`: which agent it is, for `attach`'s list (and screen's proof). */
+exports.SESSION_AGENT_VAR = "BAYCHAT_SESSION_AGENT";
+function findOpenSessions(input) {
+    /** The pane's process, then its children: the first one carrying BayChat's variables. */
+    const agentEnv = (pid) => [pid, ...input.childrenOf(pid)].map((p) => input.envOf(p)).find((env) => env && (env[multiplexer_launch_1.TMUX_SESSION_VAR] || env[exports.SESSION_AGENT_VAR] || env.STY));
+    const launched = (multiplexer, name) => input.launcher.find((l) => l.multiplexer === multiplexer && l.name === name);
+    const found = [];
+    const seen = new Set();
+    for (const line of (input.tmuxPanes ?? "").split("\n")) {
+        const [session, pidText, command, created] = line.split("\t");
+        if (!session || seen.has(session))
+            continue;
+        const pid = Number(pidText);
+        const env = Number.isInteger(pid) ? agentEnv(pid) : undefined;
+        const record = launched("tmux", session);
+        if (!record && env?.[multiplexer_launch_1.TMUX_SESSION_VAR] !== session)
+            continue;
+        seen.add(session);
+        const createdSecs = Number(created);
+        found.push({
+            multiplexer: "tmux",
+            name: session,
+            agent: record?.runtime ?? env?.[exports.SESSION_AGENT_VAR] ?? (command || "agent"),
+            ...(Number.isFinite(createdSecs) && createdSecs > 0 ? { runningSeconds: Math.max(0, Math.floor(input.now / 1000 - createdSecs)) } : {}),
+        });
+    }
+    for (const line of (input.screenList ?? "").split("\n")) {
+        const match = /^\s+(\d+)\.(\S+)\s/.exec(line);
+        if (!match)
+            continue;
+        const pid = Number(match[1]);
+        const target = `${match[1]}.${match[2]}`;
+        const env = agentEnv(pid);
+        const record = launched("screen", match[2]);
+        if (!record && !(env?.[exports.SESSION_AGENT_VAR] && env.STY === target))
+            continue;
+        const elapsed = input.elapsedSecondsOf(pid);
+        found.push({
+            multiplexer: "screen",
+            name: target,
+            agent: record?.runtime ?? env?.[exports.SESSION_AGENT_VAR] ?? "agent",
+            ...(elapsed !== undefined ? { runningSeconds: elapsed } : {}),
+        });
+    }
+    return found.sort((a, b) => (b.runningSeconds ?? 0) - (a.runningSeconds ?? 0));
+}
+/** The command that puts this terminal into `session`. Inside tmux already, switch instead of nesting. */
+function attachArgv(session, insideTmux) {
+    if (session.multiplexer === "screen")
+        return ["screen", ["-r", session.name]];
+    return ["tmux", [insideTmux ? "switch-client" : "attach", "-t", `=${session.name}`]];
+}
+function age(seconds) {
+    if (seconds === undefined)
+        return "";
+    if (seconds < 60)
+        return "just started";
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes} min`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 48)
+        return minutes % 60 ? `${hours} h ${minutes % 60} min` : `${hours} h`;
+    return `${Math.floor(hours / 24)} days`;
+}
+async function cmdAttachWith(args, deps) {
+    const sessions = deps.sessions();
+    if (sessions.length === 0) {
+        deps.say("No BayChat sessions are open on this computer. Start one with `baychat start`.");
+        return 1;
+    }
+    const named = args.find((a) => !a.startsWith("-"));
+    if (named) {
+        const session = sessions.find((s) => s.name === named || s.name.endsWith(`.${named}`));
+        if (!session) {
+            deps.say(`"${named}" is not one of the BayChat sessions open here. Run \`baychat attach\` to see them.`);
+            return 1;
+        }
+        return attach(session, deps);
+    }
+    const width = Math.max(...sessions.map((s) => s.name.length));
+    const lines = sessions.map((s, i) => `  ${i + 1}. ${s.name.padEnd(width)}  ${s.agent.padEnd(8)}  ${age(s.runningSeconds)}`.trimEnd());
+    if (!deps.atTerminal) {
+        deps.say("BayChat sessions open on this computer:");
+        lines.forEach((line) => deps.say(line));
+        return 0;
+    }
+    if (sessions.length === 1)
+        return attach(sessions[0], deps);
+    deps.say("BayChat sessions open on this computer:");
+    lines.forEach((line) => deps.say(line));
+    const answer = (await deps.ask(`Attach to which one? 1-${sessions.length}: `)).trim();
+    const picked = sessions[Number(answer) - 1] ?? sessions.find((s) => s.name === answer);
+    if (!picked) {
+        deps.say("Not one of the options.");
+        return 1;
+    }
+    return attach(picked, deps);
+}
+function attach(session, deps) {
+    const [file, argv] = attachArgv(session, deps.insideTmux);
+    const result = deps.run(file, argv);
+    if (result.error) {
+        deps.say(`Could not attach to ${session.name}: ${result.error.message}`);
+        return 1;
+    }
+    return result.status ?? 0;
+}
+function cmdAttach(args) {
+    return cmdAttachWith(args, {
+        sessions: () => findOpenSessions({
+            tmuxPanes: capture("tmux", ["list-panes", "-a", "-F", "#{session_name}\t#{pane_pid}\t#{pane_current_command}\t#{session_created}"]),
+            screenList: capture("screen", ["-ls"], true),
+            launcher: (0, started_1.loadStarted)(),
+            envOf: processEnv,
+            childrenOf: processChildren,
+            elapsedSecondsOf: processElapsed,
+            now: Date.now(),
+        }),
+        atTerminal: !!process.stdin.isTTY && !!process.stdout.isTTY,
+        insideTmux: !!process.env.TMUX,
+        ask: multiplexer_launch_1.askLine,
+        run: (file, args) => {
+            const r = (0, child_process_1.spawnSync)(file, args, { stdio: "inherit" });
+            return { status: r.status, ...(r.error ? { error: r.error } : {}) };
+        },
+        say: (line) => console.log(line),
+    });
+}
+/** A program's stdout, or undefined when it is not installed. `anyStatus`: screen -ls exits 1 with sessions listed. */
+function capture(file, args, anyStatus = false) {
+    const r = (0, child_process_1.spawnSync)(file, args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    if (r.error)
+        return undefined;
+    if (r.status !== 0 && !anyStatus)
+        return "";
+    return r.stdout ?? "";
+}
+/** A process's environment: Linux reads /proc; macOS asks `ps -E` and keeps only BayChat's variables and STY. */
+function processEnv(pid) {
+    try {
+        const raw = fs.readFileSync(`/proc/${pid}/environ`, "utf8");
+        return Object.fromEntries(raw.split("\0").filter(Boolean).map((kv) => [kv.slice(0, kv.indexOf("=")), kv.slice(kv.indexOf("=") + 1)]));
+    }
+    catch {
+        // Not Linux, or not ours to read.
+    }
+    if (process.platform !== "darwin")
+        return undefined;
+    try {
+        const line = (0, child_process_1.execFileSync)("ps", ["-E", "-ww", "-o", "command=", "-p", String(pid)], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+        const env = {};
+        for (const m of line.matchAll(/\b(BAYCHAT_[A-Z_]+|STY)=(\S+)/g))
+            env[m[1]] = m[2];
+        return env;
+    }
+    catch {
+        return undefined;
+    }
+}
+function processChildren(pid) {
+    try {
+        return fs.readFileSync(`/proc/${pid}/task/${pid}/children`, "utf8").trim().split(/\s+/).filter(Boolean).map(Number);
+    }
+    catch {
+        // Not Linux: ask pgrep.
+    }
+    try {
+        return (0, child_process_1.execFileSync)("pgrep", ["-P", String(pid)], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim().split(/\s+/).filter(Boolean).map(Number);
+    }
+    catch {
+        return [];
+    }
+}
+function processElapsed(pid) {
+    try {
+        const out = (0, child_process_1.execFileSync)("ps", ["-o", "etime=", "-p", String(pid)], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+        // [[dd-]hh:]mm:ss
+        const [days, rest] = out.includes("-") ? out.split("-") : ["0", out];
+        const parts = rest.split(":").map(Number).reverse();
+        return Number(days) * 86400 + (parts[2] ?? 0) * 3600 + (parts[1] ?? 0) * 60 + (parts[0] ?? 0);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/cli-help.js

@@ -29,8 +29,11 @@ Usage:
   baychat setup                         Look again and set up any agent app installed since;
                                         starts nothing
   baychat start [name] [--runtime <runtime>]
-                                        Start a session (what bare \`baychat\` does), with
-                                        a name for it
+                                        Start a NEW session (what bare \`baychat\` does),
+                                        with a name for it; never returns to an old one
+  baychat attach [name]                 Go back to a BayChat session open on this computer:
+                                        lists them (name, agent, how long running) and
+                                        attaches to the one you pick
   baychat update                        Bring this machine onto the current version —
                                         the package, every connected client's config, and
                                         the relay daemon (which otherwise keeps running

package/dist/launch/claude-trust.js

@@ -176,7 +176,9 @@ function trustProblemText(reason, file) {
 }
 /**
  * Set `projects[folder].hasTrustDialogAccepted = true` and nothing else. `folder` should be the
- * realpath (the spot's stored path). Called ONLY from `baychat launch add` after a person said y.
+ * realpath (the spot's stored path). Called from `baychat launch add` after a person said y, and from
+ * the relay for the owner's "Allow… in this folder" on their phone — only for a folder that person
+ * opened to it (`phoneMayAllow`, relay/launcher/spot-request.ts).
  */
 function trustFolder(folder, file = claudeConfigPath()) {
     // Write through a symlinked ~/.claude.json (dotfile managers) instead of replacing the link.

package/dist/launch/codex-trust.js

@@ -0,0 +1,177 @@
+"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.codexConfigPath = void 0;
+exports.isCodexFolderTrusted = isCodexFolderTrusted;
+exports.codexTrustProblemText = codexTrustProblemText;
+exports.trustCodexFolder = trustCodexFolder;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const codex_launch_1 = require("../relay/launcher/codex-launch");
+Object.defineProperty(exports, "codexConfigPath", { enumerable: true, get: function () { return codex_launch_1.codexConfigPath; } });
+function read(file) {
+    try {
+        return { ok: true, raw: fs.readFileSync(file, "utf8") };
+    }
+    catch (err) {
+        return { ok: false, reason: err.code === "ENOENT" ? "CONFIG_MISSING" : "CONFIG_UNREADABLE" };
+    }
+}
+/** Read-only, by the relay's own rule: the folder's own table says trusted. */
+function isCodexFolderTrusted(folder, file = (0, codex_launch_1.codexConfigPath)()) {
+    const r = read(file);
+    if (!r.ok)
+        return false;
+    // codexLaunchProblem also wants the MCP entry; ask it only about trust by handing it a config that has one.
+    const withEntry = `[mcp_servers.baychat]\n${r.raw}`;
+    return (0, codex_launch_1.codexLaunchProblem)(folder, () => withEntry) === undefined;
+}
+/** A sentence for each problem, for the person at the terminal. */
+function codexTrustProblemText(reason, file) {
+    switch (reason) {
+        case "CONFIG_MISSING":
+            return `${file} does not exist yet (Codex has not run on this computer).`;
+        case "CONFIG_UNREADABLE":
+            return `${file} could not be read.`;
+        case "PATH_UNSAFE":
+            return "the folder's name has a line break, or both a quote and a backslash, which BayChat will not write into Codex's config.";
+        case "CONFIG_UNKNOWN_FORM":
+            return `${file} already names this folder in a form BayChat does not edit, so it was left alone. Set the trust in Codex itself.`;
+        case "CONFIG_CHANGING":
+            return `${file} kept changing while BayChat tried to write it (is Codex busy?).`;
+        case "WRITE_FAILED":
+            return `${file} could not be written.`;
+    }
+}
+/** The folder as a TOML key: a basic string, else a literal string, else null (neither can hold it). */
+function tomlKey(folder) {
+    if (/[\n\r]/.test(folder))
+        return null;
+    if (!/["\\]/.test(folder))
+        return `"${folder}"`;
+    if (!folder.includes("'"))
+        return `'${folder}'`;
+    return null;
+}
+/**
+ * The config with `folder` trusted: its table's level set in place, or one table appended — or null when the
+ * folder is already a key in some other form, where an appended table would be a duplicate key.
+ */
+function withTrust(raw, folder) {
+    const header = new RegExp(`^[ \\t]*\\[projects\\.${(0, codex_launch_1.codexProjectKeyRe)(folder)}\\][ \\t]*$`, "m");
+    const found = header.exec(raw);
+    if (found) {
+        const start = found.index + found[0].length;
+        const next = raw.slice(start).search(/^[ \t]*\[/m);
+        const end = next === -1 ? raw.length : start + next;
+        const body = raw.slice(start, end);
+        const level = /^([ \t]*trust_level[ \t]*=[ \t]*)("[^"\n]*"|'[^'\n]*')/m;
+        const nextBody = level.test(body) ? body.replace(level, '$1"trusted"') : `\ntrust_level = "trusted"${body}`;
+        return raw.slice(0, start) + nextBody + raw.slice(end);
+    }
+    const otherForm = new RegExp(`${(0, codex_launch_1.codexProjectKeyRe)(folder)}\\s*(?:=|\\.)`);
+    if (otherForm.test(raw))
+        return null;
+    const sep = raw === "" || raw.endsWith("\n") ? "" : "\n";
+    return `${raw}${sep}\n[projects.${tomlKey(folder)}]\ntrust_level = "trusted"\n`;
+}
+/**
+ * Trust `folder` (the spot's stored realpath) for Codex. Called from `baychat launch add` after a person at this
+ * computer said y, and from the relay for the owner's "Allow… in this folder" on their phone — only for a folder
+ * that person opened to it (`phoneMayAllow`, relay/launcher/spot-request.ts).
+ */
+function trustCodexFolder(folder, file = (0, codex_launch_1.codexConfigPath)()) {
+    if (tomlKey(folder) === null)
+        return { ok: false, reason: "PATH_UNSAFE" };
+    // Write through a symlinked config (dotfile managers) instead of replacing the link.
+    let target = file;
+    try {
+        target = fs.realpathSync(file);
+    }
+    catch {
+        // Missing: read() reports it below.
+    }
+    for (let attempt = 0; attempt < 3; attempt++) {
+        const r = read(target);
+        // A fresh Codex install has its folder but no config.toml yet (vps, 4 Nov): create it holding only this
+        // table, 0600, and only if nothing appeared there meanwhile (`wx`). No folder: Codex has not run here.
+        if (!r.ok && r.reason === "CONFIG_MISSING" && fs.existsSync(path.dirname(target))) {
+            try {
+                fs.writeFileSync(target, (withTrust("", folder) ?? "").replace(/^\n/, ""), { mode: 0o600, flag: "wx" });
+                fs.chmodSync(target, 0o600); // writeFile's mode is masked by the umask
+                return { ok: true, changed: true };
+            }
+            catch (err) {
+                if (err.code === "EEXIST")
+                    continue; // Codex wrote it first: start over.
+                return { ok: false, reason: "WRITE_FAILED" };
+            }
+        }
+        if (!r.ok)
+            return r;
+        if (isCodexFolderTrusted(folder, target))
+            return { ok: true, changed: false };
+        const text = withTrust(r.raw, folder);
+        if (text === null)
+            return { ok: false, reason: "CONFIG_UNKNOWN_FORM" };
+        let mode;
+        try {
+            mode = fs.statSync(target).mode & 0o777;
+            const bak = `${target}.bak`;
+            fs.copyFileSync(target, bak);
+            fs.chmodSync(bak, mode);
+        }
+        catch {
+            return { ok: false, reason: "WRITE_FAILED" };
+        }
+        const tmp = path.join(path.dirname(target), `.${path.basename(target)}.baychat-${process.pid}-${Date.now()}.tmp`);
+        try {
+            fs.writeFileSync(tmp, text, { mode });
+            fs.chmodSync(tmp, mode); // writeFile's mode is masked by the umask
+            // If Codex rewrote it since we read it, start over rather than rename our older copy over its newer one.
+            if (fs.readFileSync(target, "utf8") !== r.raw) {
+                fs.rmSync(tmp, { force: true });
+                continue;
+            }
+            fs.renameSync(tmp, target);
+            return { ok: true, changed: true };
+        }
+        catch {
+            fs.rmSync(tmp, { force: true });
+            return { ok: false, reason: "WRITE_FAILED" };
+        }
+    }
+    return { ok: false, reason: "CONFIG_CHANGING" };
+}