baychat 0.24.0 → 0.25.0

package/dist/relay/fresh-start.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FRESH_START_COMMAND = exports.FRESH_START_FEATURE = void 0;
+exports.parseFreshStart = parseFreshStart;
+exports.freshStartPlan = freshStartPlan;
+exports.freshStartLine = freshStartLine;
+exports.freshStartPrompt = freshStartPrompt;
+exports.freshStartMessage = freshStartMessage;
+exports.noteRequestAsChat = noteRequestAsChat;
+exports.isNoteRequestFor = isNoteRequestFor;
+exports.postHandoffReport = postHandoffReport;
+const api_1 = require("../api");
+/**
+ * "Fresh start with a handoff" — the relay's half (protocol 1.17; the server's half is
+ * apps/api/src/services/handoff.service.ts).
+ *
+ * The app asks; the server puts two directed commands on ONE session's feed, in turn:
+ *
+ *   phase "note"   — BayChat's own instruction to write a handoff note with
+ *                    `create_note { …, handoffId }`. The relay hands it to the session as an
+ *                    ordinary wake (the only way to make its agent act), after checking that it
+ *                    COULD clear this session afterwards — if it could not, it says so at once
+ *                    and the session is never asked to write anything.
+ *   phase "clear"  — sent only once the note is saved. The relay clears the session and starts
+ *                    the fresh one from the note, then reports `fresh` (or `failed` with a code)
+ *                    on `POST /api/device-api/handoff`.
+ *
+ * How each runtime is cleared — the same doors `/clear` and `/new` already use:
+ *
+ *   Claude Code  `/clear` typed into its tmux/screen pane. The fresh session's first prompt is
+ *                typed after it: ONE fixed line naming the note (`get_note <id>`), never the
+ *                note's text — the relay types nothing into a terminal that came from a chat
+ *                (session-commands.ts). The session reads the note through BayChat's tools.
+ *   Codex        `/new` typed into its pane (a new thread), then the same line.
+ *   ACP          no terminal: the running turn is stopped and the ACP session forgotten (the next
+ *                prompt opens `session/new`), and that next prompt IS the note, in full.
+ *   anything else, or Claude Code / Codex outside a multiplexer: refused before the note is
+ *                asked for (NO_TERMINAL / RUNTIME_UNSUPPORTED).
+ */
+exports.FRESH_START_FEATURE = "freshstart";
+/**
+ * The row a fresh-start step is filed under among a batch's commands. It has no trigger anybody
+ * can type: it only ever arrives as a directed event from the app, never from chat text.
+ */
+exports.FRESH_START_COMMAND = {
+    id: "freshstart",
+    trigger: "",
+    summary: "Fresh start with a handoff — from the app's memory sheet only.",
+};
+/** Ids travel into a typed line; they are server-made (cuid), and anything else is refused. */
+const ID = /^[A-Za-z0-9_-]{1,64}$/;
+/** The fresh-start command a directed message carries, or undefined when it carries none. */
+function parseFreshStart(message) {
+    const metadata = message.metadata;
+    if (!metadata || typeof metadata !== "object")
+        return undefined;
+    if (metadata.type !== "session.command" || metadata.command !== "freshstart")
+        return undefined;
+    const { handoffId, phase, note, expiresAt } = metadata;
+    if (typeof handoffId !== "string" || !ID.test(handoffId))
+        return undefined;
+    if (phase === "note")
+        return { handoffId, phase };
+    if (phase !== "clear")
+        return undefined;
+    const n = note;
+    if (!n || typeof n.id !== "string" || !ID.test(n.id) || typeof n.title !== "string" || typeof n.body !== "string") {
+        return undefined;
+    }
+    const expires = typeof expiresAt === "string" ? Date.parse(expiresAt) : NaN;
+    return { handoffId, phase, note: { id: n.id, title: n.title, body: n.body }, ...(Number.isFinite(expires) ? { expiresAt: expires } : {}) };
+}
+/** How this relay would clear this session — decided BEFORE the note is asked for. */
+function freshStartPlan(target) {
+    if (target.acp)
+        return { kind: "acp" };
+    if (target.runtime === "claude" || target.runtime === "codex") {
+        if (!target.pane)
+            return { kind: "refuse", reason: "NO_TERMINAL" };
+        return { kind: "type", clearKeys: target.runtime === "codex" ? "/new" : "/clear" };
+    }
+    return { kind: "refuse", reason: "RUNTIME_UNSUPPORTED" };
+}
+/** A session name is typed only when it is plainly a name; otherwise the line leaves it out. */
+const PLAIN_NAME = /^[\p{L}\p{N} ._-]{1,60}$/u;
+/**
+ * The one line typed into a freshly cleared Claude Code / Codex session. Built from the note id
+ * (checked by `parseFreshStart`) and the session's own registered name (checked here), never from
+ * anything a chat message said.
+ */
+function freshStartLine(noteId, session) {
+    const who = PLAIN_NAME.test(session) ? ` You are the BayChat session "${session}".` : "";
+    return (`Fresh start from BayChat.${who} Your handoff note is note ${noteId}: read it with get_note, ` +
+        `then carry on from it. If BayChat messages have stopped reaching you, rejoin with the baychat skill first.`);
+}
+/** What an ACP session reads as the first prompt of its fresh conversation: the note itself. */
+function freshStartPrompt(note) {
+    return `Fresh start. Your handoff note:\n\n# ${note.title.replace(/\s+/g, " ").trim()}\n\n${note.body}`;
+}
+/**
+ * A copy of the command without what rode on it: the brief, the notes delta and the notice were
+ * already carried to the next chat message (daemon `deliver`), so a copy that kept them would
+ * hand the session the same text twice.
+ */
+function bare(command) {
+    const { projectBrief: _brief, projectNotes: _notes, notice: _notice, ...rest } = command;
+    return rest;
+}
+/** The first message handed to a fresh ACP session, shaped like the command that asked for it. */
+function freshStartMessage(command, fresh) {
+    return {
+        ...bare(command),
+        id: `handoff_${fresh.handoffId}`,
+        content: freshStartPrompt(fresh.note),
+        metadata: { type: "handoff.fresh", handoffId: fresh.handoffId },
+    };
+}
+/**
+ * The note request as the session reads it: an ordinary chat message, no longer marked as a
+ * directed command (so nothing downstream mistakes it for keystrokes or drops it).
+ */
+function noteRequestAsChat(command, handoffId) {
+    return { ...bare(command), metadata: { type: "handoff.request", handoffId } };
+}
+/** Is this the note request of that fresh start (so a fresh session is never asked again)? */
+function isNoteRequestFor(message, handoffId) {
+    const metadata = message.metadata;
+    return !!metadata && metadata.type === "handoff.request" && metadata.handoffId === handoffId;
+}
+/**
+ * Tell the server how a step went. NEVER THROWS: a report that cannot be made is logged and the
+ * server's own timeout fails the run five minutes later (nothing is cleared by a missing report).
+ */
+async function postHandoffReport(auth, session, report, log, request = api_1.apiRequest) {
+    try {
+        await request(auth, "POST", "/api/device-api/handoff", { session, ...report });
+    }
+    catch (err) {
+        log(`could not report fresh start ${report.handoffId} for ${session}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}

package/dist/relay/message-format.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanTerminalText = void 0;
 exports.formatWakeAction = formatWakeAction;
-exports.cleanTerminalText = cleanTerminalText;
 exports.formatRelayMessage = formatRelayMessage;
 const tool_defs_1 = require("../tool-defs");
 /** Keep the pickup instruction on every wake transport, without acknowledging
@@ -15,21 +15,40 @@ function formatWakeAction(session, conversationId, messages) {
         `WAKE action for session=${JSON.stringify(session)}, conversationId=${JSON.stringify(conversationId)}: ${tool_defs_1.MESSAGE_PICKUP_INSTRUCTION}`,
     ];
 }
-/** A readable terminal line with server routing kept separate from chat text.
- * Strip terminal control sequences and indent every content continuation so a
- * message cannot impersonate another sender or a relay status line.
- */
-function cleanTerminalText(text) {
-    return text
-        .replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, "")
-        .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
-        .replace(/[\x00-\x08\x0b-\x1f\x7f]/g, "");
-}
-function formatRelayMessage(message) {
-    const sender = cleanTerminalText(message.sender?.name || message.senderId)
+// Moved to ./terminal-text so project-brief.ts can use it without an import cycle; re-exported
+// here because callers (session-command.ts) import it from this module.
+var terminal_text_1 = require("./terminal-text");
+Object.defineProperty(exports, "cleanTerminalText", { enumerable: true, get: function () { return terminal_text_1.cleanTerminalText; } });
+const terminal_text_2 = require("./terminal-text");
+const project_brief_1 = require("./project-brief");
+const project_notes_1 = require("./project-notes");
+const context_notice_1 = require("./context-notice");
+/** A label (a name, a Bay's name) as one line of plain text: no escapes, no controls, no bidi
+ * marks, no line breaks — so it cannot start a row of its own or forge a relay line. */
+function oneLine(text) {
+    return (0, terminal_text_2.cleanTerminalText)(text)
+        .replace(/[\u0080-\u009f\u200e\u200f\u202a-\u202e\u2066-\u2069]/g, "")
         .replace(/\s+/g, " ")
         .trim();
+}
+function formatRelayMessage(message) {
+    const sender = oneLine(message.sender?.name || message.senderId);
+    // A sender visiting from another Bay says so (protocol v1.14): its name, and the Bay's and
+    // sponsor's names, were written in that other Bay — labels, not the room's own.
+    const visiting = message.sender?.visiting;
+    const origin = visiting
+        ? ` [visiting from another Bay: ${oneLine(visiting.homeBay)}, brought by ${oneLine(visiting.sponsor.name)}]`
+        : "";
     const flag = message.shouldRespond ? " [shouldRespond=true]" : "";
-    const content = cleanTerminalText(message.content).replace(/\n/g, "\n    ");
-    return `  (${message.id}) @${sender} [${message.senderType}]${flag}: ${content}`;
+    const content = (0, terminal_text_2.cleanTerminalText)(message.content).replace(/\n/g, "\n    ");
+    const line = `  (${message.id}) @${sender} [${message.senderType}]${origin}${flag}: ${content}`;
+    // BayChat's memory notice, the project brief and the notes delta this message arrived with go
+    // in front of it (./context-notice.ts, ./project-brief.ts, ./project-notes.ts): the server hands
+    // each once, so this is the one chance the session has to read them.
+    const preface = [
+        ...(message.notice ? [(0, context_notice_1.formatContextNotice)(message.notice)] : []),
+        ...(message.projectBrief ? [(0, project_brief_1.formatProjectBrief)(message.projectBrief)] : []),
+        ...(message.projectNotes ? [(0, project_notes_1.formatNotesDelta)(message.projectNotes)] : []),
+    ];
+    return preface.length > 0 ? `${preface.join("\n")}\n${line}` : line;
 }

package/dist/relay/project-brief.js

@@ -0,0 +1,195 @@
+"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.CarriedBriefs = void 0;
+exports.projectBriefFrom = projectBriefFrom;
+exports.formatProjectBrief = formatProjectBrief;
+exports.carryBrief = carryBrief;
+exports.carriedBriefsPath = carriedBriefsPath;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("../config");
+const terminal_text_1 = require("./terminal-text");
+/** What the server sends beside an event: `project` metadata and, sometimes, `brief`. */
+function projectBriefFrom(project, brief) {
+    if (brief === undefined)
+        return undefined;
+    if (brief !== null && typeof brief !== "string")
+        return undefined;
+    if (!project || typeof project !== "object")
+        return undefined;
+    const { name, version } = project;
+    if (typeof name !== "string" || typeof version !== "number" || !Number.isFinite(version))
+        return undefined;
+    return { name, version, text: brief };
+}
+/** One line of plain text: no escapes, no controls, no bidi marks, no line breaks. */
+function label(text) {
+    return (0, terminal_text_1.cleanTerminalText)(text)
+        .replace(/[\u0080-\u009f\u200E\u200F\u202A-\u202E\u2066-\u2069]/g, "")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+/**
+ * The block that goes in front of the message, as lines (no trailing newline).
+ *
+ * `indent` is the depth every line of the brief is pushed to — deeper than any structural column
+ * of the surrounding output (4 for the wake transports, 6 for the ACP prompt).
+ */
+function formatProjectBrief(brief, indent = "    ") {
+    const header = `Project brief ("${label(brief.name)}", v${Math.trunc(brief.version)}):`;
+    if (brief.text === null) {
+        return [`${header} removed — the earlier brief no longer applies.`, "---"].join("\n");
+    }
+    const body = (0, terminal_text_1.cleanTerminalText)(brief.text)
+        .replace(/\r\n|[\r\u2028\u2029\u0085]/g, "\n")
+        .replace(/[\u202A-\u202E\u2066-\u2069\u200E\u200F]/g, "")
+        .split("\n")
+        .map((line) => `${indent}${line}`);
+    return [header, ...body, "---"].join("\n");
+}
+/** Is `next` at least as new as `held`? (A brief is replaced only by one of a newer version.) */
+function supersedes(next, held) {
+    return !held || next.version >= held.version;
+}
+/**
+ * Hand a brief whose own message will not reach the session to one that will: the first of
+ * `later` in the same conversation, unless that one already carries a newer brief.
+ *
+ * @returns true when it found a home; false means the caller must keep it for later.
+ */
+function carryBrief(brief, conversationId, later) {
+    const next = later.find((m) => m.conversationId === conversationId);
+    if (!next)
+        return false;
+    if (supersedes(brief, next.projectBrief))
+        next.projectBrief = brief;
+    return true;
+}
+function carriedBriefsPath() {
+    return path.join((0, config_1.configDir)(), "carried-briefs.json");
+}
+/**
+ * Briefs that arrived on a message that never reached the session (a session command) and had
+ * no later message in the same batch to ride — kept until the next message for that
+ * (session, chat) goes out.
+ *
+ * ON DISK, like the held store (held.ts) and the ACP queue: the server handed the brief once and
+ * will not again, so a relay restart between the command and the next message must not lose it.
+ * Plaintext, 0600, next to the relay's other state. Loaded lazily; a file that cannot be read is
+ * an empty store (said once on stderr), a write that fails is said and the store keeps working in
+ * memory.
+ */
+class CarriedBriefs {
+    file;
+    held;
+    constructor(file = carriedBriefsPath()) {
+        this.file = file;
+    }
+    keep(session, conversationId, brief) {
+        const held = this.load();
+        const key = `${session}\u0000${conversationId}`;
+        if (!supersedes(brief, held.get(key)))
+            return;
+        held.set(key, brief);
+        this.save();
+    }
+    /** Forget every brief kept for this session (it started fresh or ended; the server re-sends). */
+    forget(session) {
+        const held = this.load();
+        let changed = false;
+        for (const key of [...held.keys()]) {
+            if (key.startsWith(`${session}\u0000`)) {
+                held.delete(key);
+                changed = true;
+            }
+        }
+        if (changed)
+            this.save();
+    }
+    /** Put any kept brief on the first message of each chat in this batch (mutates the batch). */
+    apply(session, batch) {
+        const held = this.load();
+        let changed = false;
+        for (const message of batch) {
+            const key = `${session}\u0000${message.conversationId}`;
+            const kept = held.get(key);
+            if (!kept)
+                continue;
+            held.delete(key);
+            changed = true;
+            if (supersedes(kept, message.projectBrief))
+                message.projectBrief = kept;
+        }
+        if (changed)
+            this.save();
+    }
+    load() {
+        if (this.held)
+            return this.held;
+        this.held = new Map();
+        let raw;
+        try {
+            raw = JSON.parse(fs.readFileSync(this.file, "utf8"));
+        }
+        catch (err) {
+            // Absent is the ordinary case (nothing was ever carried); anything else is said.
+            if (err.code !== "ENOENT") {
+                process.stderr.write(`baychat relay: could not read carried project briefs — ${err instanceof Error ? err.message : String(err)}\n`);
+            }
+            return this.held;
+        }
+        if (raw && typeof raw === "object") {
+            for (const [key, value] of Object.entries(raw)) {
+                const v = value;
+                if (v && typeof v.name === "string" && typeof v.version === "number" && (v.text === null || typeof v.text === "string")) {
+                    this.held.set(key, { name: v.name, version: v.version, text: v.text });
+                }
+            }
+        }
+        return this.held;
+    }
+    save() {
+        try {
+            fs.mkdirSync(path.dirname(this.file), { recursive: true });
+            fs.writeFileSync(this.file, JSON.stringify(Object.fromEntries(this.held ?? new Map())), { mode: 0o600 });
+            fs.chmodSync(this.file, 0o600);
+        }
+        catch (err) {
+            process.stderr.write(`baychat relay: could not persist carried project briefs — ${err instanceof Error ? err.message : String(err)}\n`);
+        }
+    }
+}
+exports.CarriedBriefs = CarriedBriefs;