baychat 0.37.0 → 0.39.0

package/dist/notify-hook.js

@@ -0,0 +1,227 @@
+"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.NOTICE_MAX = exports.CARD_PENDING_MAX_MS = exports.NOTIFY_MIN_GAP_MS = exports.NOTIFY_TYPES = void 0;
+exports.lastToolUse = lastToolUse;
+exports.decideNotify = decideNotify;
+exports.cmdNotifyHook = cmdNotifyHook;
+// `baychat notify-hook` — the stuck-question safety net (29 Oct).
+//
+// WHY THIS EXISTS. Branding's Claude Code sat on a terminal dialog ("Jelly Fish" was made by
+// someone else. Let Claude read it?) and nothing reached Karmen's phone: its approve-hook could not
+// name its session (the claude-sessions link was gone), so it left the prompt to the terminal in
+// silence. Messages piled up unread, because Claude Code reads nothing while a question is open.
+//
+// WHAT CLAUDE CODE GIVES US: the `Notification` event, in every session, joined or not, about 6 s
+// after a permission dialog or an MCP form appears (`permission_prompt`, `elicitation_dialog`,
+// `elicitation_url_dialog`; reproduced 29 Oct). Watch-only: its output answers nothing, and its
+// `message` does not hold the question ("Claude needs your permission"), so the question is read
+// from the model's last tool call in the transcript. `idle_prompt` is not taken: it fires a minute
+// after every normal answer.
+//
+// WHAT IT DOES: one line to the owner's phone — "<session> (<folder>) is waiting on a question in its
+// terminal: <what>" — through `POST /api/device-api/notify` (the owner's private chat with BayBrain,
+// a system line and a push). Once per prompt, at most one a minute per session, and nothing while
+// approve-hook's own card for this session is on the phone (notify-state.ts). Prints nothing and
+// exits 0 on every path: a Notification hook can block nothing, and must never stand in the way.
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const api_1 = require("./api");
+const approve_hook_1 = require("./approve-hook");
+const config_1 = require("./config");
+const hook_stdin_1 = require("./hook-stdin");
+const notify_answer_1 = require("./notify-answer");
+const notify_state_1 = require("./notify-state");
+const terminal_pane_1 = require("./relay/terminal-pane");
+/** The notifications that mean "a question is open in the terminal". */
+exports.NOTIFY_TYPES = ["permission_prompt", "elicitation_dialog", "elicitation_url_dialog"];
+/** At most one notice a minute per Claude Code session. */
+exports.NOTIFY_MIN_GAP_MS = 60_000;
+/** A card marker older than this is a hook that died mid-wait, not a card on the phone. */
+exports.CARD_PENDING_MAX_MS = 60 * 60_000;
+/** The server's cap (terminal-notice.service.ts). */
+exports.NOTICE_MAX = 300;
+/** How much of the transcript's end is read for the last tool call. */
+const TAIL_BYTES = 256 * 1024;
+/** The model's last tool call in transcript JSONL text, or undefined. */
+function lastToolUse(text) {
+    const lines = text.split("\n");
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const line = lines[i];
+        if (!line.includes('"tool_use"'))
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue; // the cut-off first line of a tail, or a line being written
+        }
+        if (entry.type !== "assistant" || !Array.isArray(entry.message?.content))
+            continue;
+        const blocks = entry.message.content;
+        for (let j = blocks.length - 1; j >= 0; j--) {
+            const b = blocks[j];
+            if (b?.type === "tool_use" && typeof b.id === "string" && typeof b.name === "string")
+                return { id: b.id, name: b.name, input: b.input };
+        }
+    }
+    return undefined;
+}
+function readTail(file) {
+    let fd;
+    try {
+        fd = fs.openSync(file, "r");
+        const size = fs.fstatSync(fd).size;
+        const length = Math.min(size, TAIL_BYTES);
+        const buf = Buffer.alloc(length);
+        fs.readSync(fd, buf, 0, length, size - length);
+        return buf.toString("utf8");
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        if (fd !== undefined)
+            fs.closeSync(fd);
+    }
+}
+const str = (v) => (typeof v === "string" ? v : "");
+/** `/home/k/projects/branding` → `~/projects/branding`. */
+function shortPath(cwd) {
+    const home = os.homedir();
+    return cwd && home && (cwd === home || cwd.startsWith(`${home}/`)) ? `~${cwd.slice(home.length)}` : cwd;
+}
+function clip(text, max) {
+    return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
+}
+async function postNotice(device, text) {
+    await (0, api_1.apiRequest)(device, "POST", "/api/device-api/notify", { text });
+}
+/** This process's own tmux pane (the hook runs inside the session), as text; undefined elsewhere. */
+function readOwnPane() {
+    const handle = (0, terminal_pane_1.detectPane)();
+    if (handle?.kind !== "tmux")
+        return Promise.resolve(undefined);
+    return new Promise((resolve) => {
+        (0, child_process_1.execFile)("tmux", ["-S", handle.socket, "capture-pane", "-p", "-t", handle.pane], { timeout: 5_000, encoding: "utf8" }, (err, out) => resolve(err ? undefined : String(out)));
+    });
+}
+/** `baychat notify-answer <session> <dialog>`, detached, in this session's environment (its pane). */
+function startAnswerProcess(session, dialog) {
+    const entry = process.argv[1];
+    if (!entry)
+        return false;
+    try {
+        const encoded = Buffer.from(JSON.stringify(dialog), "utf8").toString("base64");
+        (0, child_process_1.spawn)(process.execPath, [entry, "notify-answer", session, encoded], { detached: true, stdio: "ignore", env: process.env }).unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** One hook run. NEVER THROWS: every failure is a skip with its reason. */
+async function decideNotify(rawStdin, deps = {}) {
+    const now = deps.now ?? Date.now;
+    const opts = { dir: deps.stateDir };
+    try {
+        let input;
+        try {
+            input = JSON.parse(rawStdin);
+        }
+        catch {
+            return { skipped: "not a question" };
+        }
+        const type = str(input.notification_type);
+        if (input.hook_event_name !== "Notification" || !exports.NOTIFY_TYPES.includes(type))
+            return { skipped: "not a question" };
+        const sessionId = str(input.session_id);
+        const card = (0, notify_state_1.cardPendingSince)(sessionId, opts);
+        if (card !== undefined && now() - card < exports.CARD_PENDING_MAX_MS)
+            return { skipped: "a card is already on the phone" };
+        // What is being asked: the model's last tool call for a permission dialog, else Claude Code's own words.
+        const tool = type === "permission_prompt" ? lastToolUse(readTail(str(input.transcript_path)) ?? "") : undefined;
+        const what = tool ? (0, approve_hook_1.describeToolRequest)(tool.name, tool.input) : str(input.message) || "a question";
+        const key = tool ? `tool:${tool.id}` : `${type}:${str(input.message)}`;
+        const last = (0, notify_state_1.readLastNotice)(sessionId, opts);
+        if (last?.lastKey === key)
+            return { skipped: "already sent for this prompt" };
+        if (last && now() - last.lastAt < exports.NOTIFY_MIN_GAP_MS)
+            return { skipped: "one a minute per session" };
+        const device = (deps.loadDevice ?? config_1.loadDeviceCredentials)();
+        if (!device)
+            return { skipped: "not logged in" };
+        const session = (deps.link ?? approve_hook_1.linkFromClaude)()?.session;
+        // A session BayChat knows, in a tmux pane showing a numbered dialog: a card the owner can
+        // ANSWER, by a detached `notify-answer` that presses the chosen number (notify-answer.ts).
+        if (session) {
+            const screen = await (deps.readScreen ?? readOwnPane)();
+            const dialog = screen ? (0, notify_answer_1.readDialog)(screen) : undefined;
+            if (dialog && (deps.startAnswer ?? startAnswerProcess)(session, dialog)) {
+                (0, notify_state_1.writeLastNotice)(sessionId, { lastAt: now(), lastKey: key }, opts);
+                return { sent: true, answerable: true };
+            }
+        }
+        const who = session || "A Claude Code session";
+        const where = shortPath(str(input.cwd));
+        const head = `${who}${where ? ` (${where})` : ""} is waiting on a question in its terminal: `;
+        const text = clip(`${head}${what.replace(/\s+/g, " ").trim()}`, exports.NOTICE_MAX);
+        await (deps.post ?? postNotice)(device, text);
+        (0, notify_state_1.writeLastNotice)(sessionId, { lastAt: now(), lastKey: key }, opts);
+        return { sent: true };
+    }
+    catch (err) {
+        return { skipped: err instanceof Error ? err.message : String(err) };
+    }
+}
+/**
+ * `baychat notify-hook [--dry-run]` — always exits 0 and prints nothing; why it skipped goes to
+ * stderr. `--dry-run` writes the line it would send to stderr instead of sending it (and still
+ * needs a login, so it shows the real path up to the request).
+ */
+async function cmdNotifyHook(argv = [], stdin = process.stdin) {
+    try {
+        const dryRun = argv.includes("--dry-run");
+        const outcome = await decideNotify(await (0, hook_stdin_1.readStdin)(stdin), dryRun ? { post: async (_d, text) => void process.stderr.write(`baychat notify-hook (dry run): ${text}\n`) } : {});
+        if ("skipped" in outcome && outcome.skipped !== "not a question")
+            process.stderr.write(`baychat notify-hook: ${outcome.skipped}\n`);
+    }
+    catch {
+        // Nothing: a Notification hook must never stand in the way of the session.
+    }
+    return 0;
+}

package/dist/notify-state.js

@@ -0,0 +1,136 @@
+"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.notifyStateDir = void 0;
+exports.stateKey = stateKey;
+exports.markCardPending = markCardPending;
+exports.clearCardPending = clearCardPending;
+exports.cardPendingSince = cardPendingSince;
+exports.readLastNotice = readLastNotice;
+exports.writeLastNotice = writeLastNotice;
+/**
+ * What notify-hook remembers per Claude Code session, under `<config>/notify-state/`:
+ *
+ *  - `<session_id>.json` — the last notice sent: `{ lastAt, lastKey }`, for "once per prompt, at
+ *    most once a minute" (notify-hook.ts).
+ *  - `<session_id>.card` — approve-hook has a card on the owner's phone for this session right now.
+ *    Written when the card goes out and removed when the hook is done, so the same prompt never
+ *    reaches the phone twice (a card AND a "waiting" line). Its age bounds it: a hook killed
+ *    mid-wait leaves a file that stops counting after an hour.
+ *
+ * Small files, private to the user, never read by anything else. Every function swallows its own
+ * errors: a hook's bookkeeping must never stand in the way of the session.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("./config");
+const notifyStateDir = () => path.join((0, config_1.configDir)(), "notify-state");
+exports.notifyStateDir = notifyStateDir;
+/** A Claude Code session id as a file name: its own characters only, or nothing. */
+function stateKey(sessionId) {
+    return /^[A-Za-z0-9_-]{1,128}$/.test(sessionId) ? sessionId : undefined;
+}
+function file(sessionId, ext, dir) {
+    const key = stateKey(sessionId);
+    if (!key)
+        return undefined;
+    try {
+        return path.join(dir ?? (0, exports.notifyStateDir)(), `${key}.${ext}`);
+    }
+    catch {
+        // No config directory to keep it in: no bookkeeping, never an error on approve-hook's path.
+        return undefined;
+    }
+}
+function markCardPending(sessionId, opts = {}) {
+    const f = file(sessionId, "card", opts.dir);
+    if (!f)
+        return;
+    try {
+        fs.mkdirSync(path.dirname(f), { recursive: true, mode: 0o700 });
+        fs.writeFileSync(f, String((opts.now ?? Date.now)()), { mode: 0o600 });
+    }
+    catch {
+        // Bookkeeping only.
+    }
+}
+function clearCardPending(sessionId, opts = {}) {
+    const f = file(sessionId, "card", opts.dir);
+    if (!f)
+        return;
+    try {
+        fs.rmSync(f, { force: true });
+    }
+    catch {
+        // Bookkeeping only.
+    }
+}
+/** When the pending card was marked, or undefined when there is none. */
+function cardPendingSince(sessionId, opts = {}) {
+    const f = file(sessionId, "card", opts.dir);
+    if (!f)
+        return undefined;
+    try {
+        const at = Number(fs.readFileSync(f, "utf8").trim());
+        return Number.isFinite(at) ? at : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function readLastNotice(sessionId, opts = {}) {
+    const f = file(sessionId, "json", opts.dir);
+    if (!f)
+        return undefined;
+    try {
+        const v = JSON.parse(fs.readFileSync(f, "utf8"));
+        return typeof v.lastAt === "number" && typeof v.lastKey === "string" ? { lastAt: v.lastAt, lastKey: v.lastKey } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeLastNotice(sessionId, notice, opts = {}) {
+    const f = file(sessionId, "json", opts.dir);
+    if (!f)
+        return;
+    try {
+        fs.mkdirSync(path.dirname(f), { recursive: true, mode: 0o700 });
+        fs.writeFileSync(f, JSON.stringify(notice), { mode: 0o600 });
+    }
+    catch {
+        // Bookkeeping only: at worst the next prompt's notice is not rate-limited.
+    }
+}