baychat 0.36.0 → 0.38.0

package/dist/launch/policy.js

@@ -136,7 +136,7 @@ function resolveSpotFolder(spot) {
 function parseSpot(entry) {
     if (!entry || typeof entry !== "object")
         return null;
-    const { id, label, path: p, runtimes, maxSessions, unattendedCodex } = entry;
+    const { id, label, path: p, runtimes, maxSessions, unattendedCodex, agentStarts } = entry;
     if (typeof id !== "string" || !exports.SPOT_ID_RE.test(id))
         return null;
     if (typeof label !== "string" || label.trim().length === 0 || label.length > exports.SPOT_LABEL_MAX)
@@ -150,5 +150,15 @@ function parseSpot(entry) {
         return null;
     if (unattendedCodex !== undefined && unattendedCodex !== true)
         return null;
-    return { id, label, path: p, runtimes: [...new Set(runtimes)], maxSessions, ...(unattendedCodex ? { unattendedCodex } : {}) };
+    if (agentStarts !== undefined && agentStarts !== true)
+        return null;
+    return {
+        id,
+        label,
+        path: p,
+        runtimes: [...new Set(runtimes)],
+        maxSessions,
+        ...(unattendedCodex ? { unattendedCodex } : {}),
+        ...(agentStarts ? { agentStarts } : {}),
+    };
 }

package/dist/main.js

@@ -6,6 +6,9 @@ const approve_hook_1 = require("./approve-hook");
 const denied_hook_1 = require("./denied-hook");
 const permissions_command_1 = require("./permissions-command");
 const context_hooks_command_1 = require("./context-hooks-command");
+const channel_check_1 = require("./channel/channel-check");
+const notify_hook_1 = require("./notify-hook");
+const notify_answer_1 = require("./notify-answer");
 const session_name_1 = require("./session-name");
 const start_command_1 = require("./start-command");
 const update_command_1 = require("./update-command");
@@ -337,6 +340,16 @@ async function main() {
             return await (0, permissions_command_1.cmdPermissions)(args);
         case "context-hooks":
             return await (0, context_hooks_command_1.cmdContextHooks)(args);
+        case "notify-hook":
+            // The plugin's Notification hook: a question stuck in the terminal → one line on the owner's
+            // phone. Never throws, always 0, prints nothing (notify-hook.ts).
+            return await (0, notify_hook_1.cmdNotifyHook)(args);
+        case "notify-answer":
+            // Started detached by notify-hook: answers one terminal dialog from the phone (notify-answer.ts).
+            return await (0, notify_answer_1.cmdNotifyAnswer)(args);
+        case "channel-check":
+            // The plugin's SessionStart (compact) hook. Never throws, always 0 (channel/channel-check.ts).
+            return await (0, channel_check_1.cmdChannelCheck)();
         case "doctor":
             // Deliberately placed with the setup commands: it is the thing you run
             // when one of them did not take, and the one command that inspects all

package/dist/notify-answer.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SETTLE_MS = exports.ANSWER_DEADLINE_MS = void 0;
+exports.readDialog = readDialog;
+exports.answerFromPhone = answerFromPhone;
+exports.paneAnswerDeps = paneAnswerDeps;
+exports.cmdNotifyAnswer = cmdNotifyAnswer;
+// `baychat notify-answer` — answering a terminal dialog from the phone (vps, 29 Oct: "the keys").
+//
+// notify-hook starts this, detached, when the stuck question is in a session BayChat knows (its
+// claude-sessions link) running in a tmux pane, and the pane shows a numbered dialog. It puts the
+// dialog's own question and answers on a card in the session's private chat with its owner, and
+// on a tap presses that ONE number in the pane — measured on the real dialog (29 Oct): a digit
+// selects and confirms, no Enter.
+//
+// THE RULE THE WHOLE THING RESTS ON: a key is pressed only while `capture-pane` still shows THE
+// SAME question. A `1` landing in an ordinary input line would be typed as text and sent as a
+// message. So the pane is read again right before the key; a different screen sends nothing and
+// says "already answered in the terminal". While waiting, the pane is looked at between windows:
+// answered at the keyboard first → the card is taken back. Keys: the digits of the dialog's own
+// options and nothing else — never text, never Enter, never a key a message could name. The card
+// is answerable by the owner only (the device credential's own user), and the pane must still be
+// running Claude Code (`verifyPane`).
+const child_process_1 = require("child_process");
+const api_1 = require("./api");
+const approval_wait_1 = require("./approval-wait");
+const config_1 = require("./config");
+const terminal_pane_1 = require("./relay/terminal-pane");
+/** How long the phone may take: the same hour a permission card waits. */
+exports.ANSWER_DEADLINE_MS = 60 * 60_000;
+/** One wait on the card between looks at the terminal. */
+const WINDOW_MS = 20_000;
+/** A breath between looks, so a card answered and a screen changing at the same moment settle. */
+const GAP_MS = 1_000;
+/**
+ * Between the two looks right before a key. Found on the real dialog (29 Oct): a screen read just
+ * after a key can still show the old dialog, and a `1` then landed in the input line.
+ */
+exports.SETTLE_MS = 700;
+const OPTION = /^\s*(?:❯\s*)?([1-9])\.\s+(\S.*?)\s*$/;
+const DECORATION = /^[\s│╌─━┃┄┈|]*$/;
+/**
+ * The open dialog on a captured screen, or undefined. A dialog is a run of options numbered from
+ * 1 with "Esc to cancel" right under it, and the question is the nearest line above ending in "?"
+ * (a conversation's own numbered list has no "Esc to cancel" under it, so it is never one).
+ */
+function readDialog(screen) {
+    const lines = screen.split("\n");
+    for (let end = lines.length - 1; end >= 0; end--) {
+        if (!/Esc to cancel/.test(lines[end]))
+            continue;
+        // The options: the numbered run directly above "Esc to cancel".
+        const options = [];
+        let i = end - 1;
+        while (i >= 0 && DECORATION.test(lines[i]) && lines[i].trim() === "")
+            i--;
+        let first = i;
+        while (i >= 0 && OPTION.test(lines[i])) {
+            first = i;
+            i--;
+        }
+        for (let k = first; k < end; k++) {
+            const m = OPTION.exec(lines[k]);
+            if (m)
+                options.push(m[2]);
+        }
+        if (options.length === 0)
+            return undefined;
+        // In order from 1: "1. …", "2. …".
+        for (let k = first, n = 1; k < end; k++) {
+            const m = OPTION.exec(lines[k]);
+            if (!m)
+                continue;
+            if (Number(m[1]) !== n++)
+                return undefined;
+        }
+        for (let q = first - 1; q >= Math.max(0, first - 15); q--) {
+            const text = lines[q].trim();
+            if (text.endsWith("?") && !text.startsWith("│"))
+                return { question: text, options };
+        }
+        return undefined;
+    }
+    return undefined;
+}
+const sameDialog = (screen, dialog) => readDialog(screen)?.question === dialog.question;
+/**
+ * One dialog, answered from the phone or left to the terminal. Returns what happened, for the log.
+ * NEVER THROWS (a failing capture counts as "the dialog is gone": send nothing).
+ */
+async function answerFromPhone(run, deps) {
+    const { session, dialog } = run;
+    const capture = async () => {
+        try {
+            return await deps.capture();
+        }
+        catch {
+            return "";
+        }
+    };
+    const until = deps.now() + exports.ANSWER_DEADLINE_MS;
+    let outcome = await deps.ask({ session, question: `${session} is waiting on a question in its terminal:\n${dialog.question}`, options: dialog.options }, Math.min(until, deps.now() + WINDOW_MS));
+    for (;;) {
+        if (outcome.kind === "answered") {
+            const index = outcome.index;
+            if (index === null || !Number.isInteger(index) || index < 0 || index >= dialog.options.length)
+                return "not an answer";
+            // Right before the key: the same question on screen on two looks a settle apart, or nothing
+            // is sent.
+            const first = sameDialog(await capture(), dialog);
+            if (first)
+                await deps.sleep(exports.SETTLE_MS);
+            if (!first || !sameDialog(await capture(), dialog)) {
+                await deps.notice(`${session}: your answer was not sent. The question was already answered in the terminal.`);
+                return "already answered";
+            }
+            const key = String(index + 1);
+            const pressed = await deps.press(key);
+            return pressed.ok ? `sent ${key}` : `refused: ${pressed.reason}`;
+        }
+        if (outcome.kind !== "deadline")
+            return outcome.kind === "failed" ? `failed: ${outcome.reason}` : outcome.kind;
+        // Nobody tapped yet. Answered at the keyboard meanwhile? Then the card goes.
+        if (!sameDialog(await capture(), dialog)) {
+            await deps.withdraw(outcome.requestId);
+            return "answered in the terminal";
+        }
+        if (deps.now() >= until) {
+            await deps.withdraw(outcome.requestId);
+            return "no answer";
+        }
+        await deps.sleep(GAP_MS);
+        outcome = await deps.poll(outcome.requestId, Math.min(until, deps.now() + WINDOW_MS));
+    }
+}
+function tmux(handle, args) {
+    return new Promise((resolve, reject) => {
+        (0, child_process_1.execFile)("tmux", ["-S", handle.socket, ...args], { timeout: 5_000, encoding: "utf8" }, (err, out) => (err ? reject(err) : resolve(String(out))));
+    });
+}
+/** The real dependencies, for a tmux pane. */
+function paneAnswerDeps(device, handle) {
+    const log = (line) => process.stderr.write(`${line}\n`);
+    const waitDeps = { now: Date.now, sleep: (ms) => new Promise((r) => setTimeout(r, ms)), log };
+    return {
+        capture: () => tmux(handle, ["capture-pane", "-p", "-t", handle.pane]),
+        press: async (key) => {
+            if (!/^[1-9]$/.test(key))
+                return { ok: false, reason: `"${key}" is not a dialog answer` };
+            const check = (0, terminal_pane_1.verifyPane)(handle, "claude");
+            if (!check.ok)
+                return check;
+            try {
+                // `-l`: the digit as a character, never read as a key name.
+                await tmux(handle, ["send-keys", "-t", handle.pane, "-l", "--", key]);
+                return { ok: true };
+            }
+            catch (err) {
+                return { ok: false, reason: err instanceof Error ? err.message : String(err) };
+            }
+        },
+        ask: (q, deadline) => (0, approval_wait_1.askOwnerAndWait)(device, q, deadline, waitDeps, "baychat notify-answer"),
+        poll: (id, deadline) => (0, approval_wait_1.waitOnOwnerQuestion)(device, id, deadline, waitDeps, "baychat notify-answer"),
+        withdraw: (id) => (0, approval_wait_1.withdrawOwnerQuestion)(device, id, log),
+        notice: async (text) => {
+            try {
+                await (0, api_1.apiRequest)(device, "POST", "/api/device-api/notify", { text });
+            }
+            catch {
+                // The answer was not sent either way; the note is a courtesy.
+            }
+        },
+        now: Date.now,
+        sleep: waitDeps.sleep,
+    };
+}
+/**
+ * `baychat notify-answer <session> <base64 JSON dialog>` — started detached by notify-hook inside
+ * the session's own environment (so `$TMUX_PANE` is the session's pane). Exits 0 always.
+ */
+async function cmdNotifyAnswer(argv = []) {
+    try {
+        const [session, encoded] = argv;
+        const dialog = JSON.parse(Buffer.from(encoded ?? "", "base64").toString("utf8"));
+        const handle = (0, terminal_pane_1.detectPane)();
+        const device = (0, config_1.loadDeviceCredentials)();
+        if (!session || !device || handle?.kind !== "tmux" || !dialog?.question || !Array.isArray(dialog.options))
+            return 0;
+        const outcome = await answerFromPhone({ session, dialog }, paneAnswerDeps(device, handle));
+        process.stderr.write(`baychat notify-answer: ${outcome}\n`);
+    }
+    catch (err) {
+        process.stderr.write(`baychat notify-answer: ${err instanceof Error ? err.message : String(err)}\n`);
+    }
+    return 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.
+    }
+}