baychat 0.30.0 → 0.32.0

package/dist/auto-update/store.js

@@ -0,0 +1,140 @@
+"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.loadAutoUpdateState = loadAutoUpdateState;
+exports.saveAutoUpdateState = saveAutoUpdateState;
+exports.loadAutoSetting = loadAutoSetting;
+exports.saveAutoSetting = saveAutoSetting;
+exports.writeUpdateNotice = writeUpdateNotice;
+exports.takeUpdateNotice = takeUpdateNotice;
+exports.acquireUpdateLock = acquireUpdateLock;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("../config");
+const parent_watch_1 = require("../relay/parent-watch");
+const STATE_FILE = "auto-update.json";
+const SETTING_FILE = "auto-update-setting.json";
+const NOTICE_FILE = "update-notice.json";
+const LOCK_FILE = "update.lock";
+function loadAutoUpdateState() {
+    const raw = readJson(STATE_FILE);
+    return raw && typeof raw === "object" ? raw : {};
+}
+function saveAutoUpdateState(state) {
+    writeJsonAtomic(STATE_FILE, state);
+}
+function loadAutoSetting() {
+    const raw = readJson(SETTING_FILE);
+    return raw?.auto === "off" ? "off" : "on";
+}
+function saveAutoSetting(auto) {
+    writeJsonAtomic(SETTING_FILE, { auto });
+}
+/** Leave one line for the next `baychat` command to print. Replaces any earlier one. */
+function writeUpdateNotice(text) {
+    writeJsonAtomic(NOTICE_FILE, { text, at: Date.now() });
+}
+/**
+ * The waiting notice, taken: read and deleted, so it is printed exactly once. Undefined when
+ * there is none, or when it cannot be deleted (printing it again on every command would be worse
+ * than not printing it).
+ */
+function takeUpdateNotice() {
+    const file = path.join((0, config_1.configDir)(), NOTICE_FILE);
+    const raw = readJson(NOTICE_FILE);
+    if (typeof raw?.text !== "string" || !raw.text.trim())
+        return undefined;
+    try {
+        fs.rmSync(file);
+    }
+    catch {
+        return undefined;
+    }
+    return raw.text.trim();
+}
+/**
+ * Hold the install lock: one npm install over this computer's baychat at a time, whether the
+ * relay or a person started it. Returns the release, or undefined when a live process holds it.
+ * A lock whose holder is gone (a crash) is taken over.
+ */
+function acquireUpdateLock(pid = process.pid) {
+    const file = path.join((0, config_1.configDir)(), LOCK_FILE);
+    for (let attempt = 0; attempt < 2; attempt++) {
+        try {
+            fs.mkdirSync((0, config_1.configDir)(), { recursive: true });
+            fs.writeFileSync(file, String(pid), { flag: "wx", mode: 0o600 });
+            return () => fs.rmSync(file, { force: true });
+        }
+        catch (err) {
+            if (err.code !== "EEXIST")
+                return undefined;
+            const holder = Number(readText(file));
+            if (Number.isInteger(holder) && holder > 1 && holder !== pid && (0, parent_watch_1.processIsAlive)(holder))
+                return undefined;
+            // The holder is gone: the lock is stale. Removed and tried once more.
+            fs.rmSync(file, { force: true });
+        }
+    }
+    return undefined;
+}
+function readJson(name) {
+    const text = readText(path.join((0, config_1.configDir)(), name));
+    if (text === undefined)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        // A torn or hand-edited file reads as absent: every reader has a safe default.
+        return undefined;
+    }
+}
+function readText(file) {
+    try {
+        return fs.readFileSync(file, "utf8");
+    }
+    catch {
+        // Missing is the ordinary first-run case; unreadable reads the same way.
+        return undefined;
+    }
+}
+/** Write via a temporary file and a rename, so a reader never sees half a file. */
+function writeJsonAtomic(name, value) {
+    const file = path.join((0, config_1.configDir)(), name);
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.mkdirSync((0, config_1.configDir)(), { recursive: true });
+    fs.writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+    fs.renameSync(tmp, file);
+}

package/dist/auto-update/updater.js

@@ -0,0 +1,324 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoUpdater = exports.TICK_MS = exports.UPDATE_NOW_INDEX = exports.UPDATE_OPTIONS = void 0;
+const self_upgrade_1 = require("../self-upgrade");
+const policy_1 = require("./policy");
+const self_restart_1 = require("../relay/self-restart");
+exports.UPDATE_OPTIONS = ["Update now", "Later"];
+exports.UPDATE_NOW_INDEX = 0;
+/** How often the state is looked at. Cheap: one small file and the clock. */
+exports.TICK_MS = 60_000;
+class AutoUpdater {
+    deps;
+    startedAt;
+    /** Spreads this relay's checks; fixed for its lifetime so the schedule does not wander. */
+    spread;
+    timer;
+    running = false;
+    stopped = false;
+    lastCardPoll = 0;
+    constructor(deps) {
+        this.deps = deps;
+        this.startedAt = deps.now();
+        this.spread = deps.random();
+    }
+    /** Finish an update the previous relay installed, then look at the state once a minute. */
+    start() {
+        void this.runExclusive(() => this.finishPendingUpdate());
+        this.timer = setInterval(() => void this.tick(), exports.TICK_MS);
+        this.timer.unref();
+    }
+    stop() {
+        this.stopped = true;
+        clearInterval(this.timer);
+    }
+    status() {
+        const state = this.deps.loadState();
+        const { mode, reason } = this.mode();
+        return {
+            mode,
+            reason,
+            current: this.deps.current,
+            latest: state.latest,
+            lastCheckAt: state.lastCheckAt,
+            waitingFor: state.waitingFor,
+            cardVersion: state.card?.requestId ? state.card.version : undefined,
+            failure: state.failure?.reason,
+        };
+    }
+    /** One look at the state. Never throws; never runs twice at once. */
+    async tick() {
+        await this.runExclusive(async () => {
+            if (this.stopped)
+                return;
+            const state = this.deps.loadState();
+            const { mode, reason } = this.mode();
+            if (state.mode !== mode || state.modeReason !== reason || state.current !== this.deps.current) {
+                Object.assign(state, { mode, modeReason: reason, current: this.deps.current });
+                this.deps.saveState(state);
+            }
+            // New files are on disk under old code: restarting onto them comes before anything else,
+            // whatever the setting says now — running half old, half new is the one state to avoid.
+            if (state.finish)
+                return this.finishPendingUpdate();
+            if (mode === "off" || mode === "none")
+                return;
+            const now = this.deps.now();
+            if (now >= (0, policy_1.nextCheckAt)(state, this.startedAt, this.spread))
+                await this.check(state, mode);
+            if (mode !== "auto")
+                return;
+            if (state.card?.requestId && now - this.lastCardPoll >= policy_1.CARD_POLL_MS)
+                await this.pollCard(state);
+            if (state.target)
+                await this.installTarget(state);
+        });
+    }
+    mode() {
+        const off = (0, policy_1.autoUpdateOffReason)(this.deps.env, this.deps.setting());
+        if (off)
+            return { mode: "off", reason: off };
+        const { install, supervised, root } = this.deps.ability;
+        if (install.kind === "source")
+            return { mode: "none", reason: "running from a checkout" };
+        if (install.kind === "npx")
+            return { mode: "notify", reason: "for an npx copy (use `npx baychat@latest`)" };
+        if (install.kind === "local")
+            return { mode: "notify", reason: "for a project install (update it there with `npm i baychat@latest`)" };
+        if (root)
+            return { mode: "notify", reason: "as root (install with `baychat update`)" };
+        if (!(0, self_restart_1.selfUpdateAllowedOn)(this.deps.ability.platform))
+            return { mode: "notify", reason: "on Windows (install with `baychat update`)" };
+        if (!supervised)
+            return { mode: "notify", reason: "for a relay started by hand (install with `baychat update`)" };
+        return { mode: "auto" };
+    }
+    /** Ask npm, and decide. */
+    async check(state, mode) {
+        const looked = await this.deps.lookupLatest();
+        state.lastCheckAt = this.deps.now();
+        if (!looked.ok) {
+            // Offline, npm down: quiet. Tried again within the hour, then less often.
+            state.checkFailures = (state.checkFailures ?? 0) + 1;
+            state.lastCheckError = looked.reason;
+            this.deps.log(`auto-update: could not ask npm (${looked.reason})`);
+            return this.deps.saveState(state);
+        }
+        state.checkFailures = 0;
+        state.lastCheckError = undefined;
+        state.latest = looked.release.version;
+        const plan = (0, policy_1.planUpdate)(this.deps.current, looked.release);
+        if (plan.kind === "current") {
+            // Updated some other way (`baychat update`), or nothing new: nothing may stay on the phone.
+            await this.dropCard(state);
+            state.target = undefined;
+            return this.deps.saveState(state);
+        }
+        if (mode === "notify") {
+            this.notifyOnce(state, `available:${plan.version}`, this.availableLine(plan.version));
+            return this.deps.saveState(state);
+        }
+        if (plan.kind === "auto") {
+            if (state.target?.version !== plan.version)
+                state.target = { version: plan.version, via: "auto" };
+            return this.deps.saveState(state);
+        }
+        await this.askOwner(state, plan.version, plan.reason);
+        this.deps.saveState(state);
+    }
+    /** The card for a version that needs the person. At most one per version, never while one waits. */
+    async askOwner(state, version, reason) {
+        if (state.target?.version === version)
+            return; // already said "Update now"
+        const card = state.card;
+        if (card?.version === version && (card.requestId || (card.laterUntil ?? 0) > this.deps.now()))
+            return;
+        if (card && card.version !== version)
+            await this.dropCard(state); // a newer version supersedes it
+        this.notifyOnce(state, `ask:${version}`, `baychat ${version} needs you: ${reason}. Run \`baychat update\` when you are ready.`);
+        const asked = await this.deps.cards.ask(`New BayChat for your computer (${version}): ${reason}`);
+        if (!asked) {
+            this.deps.log(`auto-update: ${version} needs the owner, and no card could be put up yet`);
+            return;
+        }
+        state.card = { version, reason, askedAt: this.deps.now(), ...asked };
+        this.deps.log(`auto-update: asked the owner about ${version} (${reason})`);
+    }
+    async pollCard(state) {
+        this.lastCardPoll = this.deps.now();
+        const card = state.card;
+        const answer = await this.deps.cards.answer(card.requestId);
+        if (answer.kind === "waiting")
+            return;
+        if (answer.kind === "update") {
+            this.deps.log(`auto-update: the owner chose to update to ${card.version}`);
+            state.target = { version: card.version, via: "card", conversationId: card.conversationId, session: card.session };
+            state.card = undefined;
+        }
+        else {
+            // "Later", or the card is gone (withdrawn, deleted): ask again in a few days, not before.
+            state.card = { ...card, requestId: undefined, laterUntil: this.deps.now() + policy_1.ASK_AGAIN_MS };
+        }
+        this.deps.saveState(state);
+    }
+    /** Install the decided version in a quiet moment, then restart onto it in another. */
+    async installTarget(state) {
+        const target = state.target;
+        if ((0, self_upgrade_1.compareVersions)(this.deps.current, target.version) !== -1) {
+            state.target = undefined;
+            return this.deps.saveState(state);
+        }
+        if (this.deps.now() < (0, policy_1.installAllowedAt)(state.failure, target.version))
+            return;
+        const busy = this.deps.busyReason();
+        if (busy)
+            return this.wait(state, busy);
+        this.deps.log(`auto-update: installing baychat ${target.version} (from ${this.deps.current})`);
+        const installed = await this.deps.installVersion(target.version);
+        if (!installed.ok) {
+            const count = state.failure?.version === target.version ? state.failure.count + 1 : 1;
+            state.failure = { version: target.version, count, at: this.deps.now(), reason: installed.reason };
+            state.waitingFor = undefined;
+            this.deps.log(`auto-update: install of ${target.version} failed (${installed.reason}); ${this.deps.current} keeps running`);
+            this.notifyOnce(state, `failed:${target.version}`, `BayChat could not update itself to ${target.version}: ${installed.reason}`);
+            return this.deps.saveState(state);
+        }
+        // The new code is on disk. From here the NEW relay finishes, whoever restarts it.
+        state.finish = { from: this.deps.current, to: installed.to, via: target.via, conversationId: target.conversationId, session: target.session };
+        state.target = undefined;
+        state.failure = undefined;
+        state.waitingFor = undefined;
+        this.deps.saveState(state);
+        await this.restartWhenQuiet();
+    }
+    /** Restart now if nothing is going on, else on a later tick (the `finish` step marks it owed). */
+    async restartWhenQuiet() {
+        const state = this.deps.loadState();
+        if (!state.finish)
+            return;
+        const busy = this.deps.busyReason();
+        if (busy)
+            return this.wait(state, busy);
+        state.finish.restarts = (state.finish.restarts ?? 0) + 1;
+        state.waitingFor = undefined;
+        this.deps.saveState(state);
+        this.deps.log(`auto-update: restarting onto baychat ${state.finish.to}`);
+        await this.deps.restart();
+    }
+    wait(state, busy) {
+        if (state.waitingFor === busy)
+            return;
+        state.waitingFor = busy;
+        this.deps.saveState(state);
+    }
+    /**
+     * Run at start. If the previous relay installed a version and this IS that version, finish it.
+     * If this is still the old code (its restart came up on the old files somehow), the install
+     * evidently did not land: forget it, and the next check decides again.
+     */
+    async finishPendingUpdate() {
+        const state = this.deps.loadState();
+        const finish = state.finish;
+        if (!finish)
+            return this.dropStaleCard(state);
+        if ((0, self_upgrade_1.compareVersions)(this.deps.current, finish.to) === -1) {
+            // Still the old code. Never restarted yet (the old relay died first): restart onto the new
+            // files. Restarted already and STILL old: the init system runs a different copy than the one
+            // updated. Give up on it rather than restart forever; the failure backs the next try off.
+            if (!finish.restarts)
+                return this.restartWhenQuiet();
+            const reason = `the relay restarted but still runs ${this.deps.current}`;
+            state.finish = undefined;
+            state.failure = { version: finish.to, count: 1, at: this.deps.now(), reason };
+            this.deps.log(`auto-update: ${reason}, not ${finish.to}`);
+            this.notifyOnce(state, `failed:${finish.to}`, `BayChat could not update itself to ${finish.to}: ${reason}. Run \`baychat update\`.`);
+            return this.deps.saveState(state);
+        }
+        state.finish = undefined;
+        state.lastUpdate = { from: finish.from, to: finish.to, at: this.deps.now() };
+        this.deps.saveState(state);
+        await this.refreshClientsQuietly();
+        this.notifyOnce(state, `updated:${finish.to}`, `BayChat updated itself to ${finish.to} (from ${finish.from}).`);
+        this.deps.saveState(state);
+        this.deps.log(`auto-update: now running baychat ${finish.to} (from ${finish.from})`);
+        await this.sayDone(finish);
+        await this.dropStaleCard(this.deps.loadState());
+    }
+    async refreshClientsQuietly() {
+        try {
+            await this.deps.refreshClients();
+        }
+        catch (err) {
+            this.deps.log(`auto-update: could not refresh client configs (${errText(err)})`);
+        }
+    }
+    /** The owner asked for this one: tell them, once, where they asked. A routine update stays quiet. */
+    async sayDone(finish) {
+        if (finish.via !== "card" || !finish.conversationId || !finish.session)
+            return;
+        try {
+            await this.deps.cards.say(finish.conversationId, finish.session, `Updated BayChat on this computer to ${finish.to}.`);
+        }
+        catch (err) {
+            this.deps.log(`auto-update: could not say the update was done (${errText(err)})`);
+        }
+    }
+    /** A card about a version this relay already runs (updated by hand meanwhile) comes off the phone. */
+    async dropStaleCard(state) {
+        if (!state.card || (0, self_upgrade_1.compareVersions)(this.deps.current, state.card.version) === -1)
+            return;
+        await this.dropCard(state);
+        this.deps.saveState(state);
+    }
+    async dropCard(state) {
+        const requestId = state.card?.requestId;
+        state.card = undefined;
+        if (!requestId)
+            return;
+        try {
+            await this.deps.cards.withdraw(requestId);
+        }
+        catch (err) {
+            this.deps.log(`auto-update: could not withdraw the update card (${errText(err)})`);
+        }
+    }
+    /** One line for the terminal, and never the same line twice. */
+    notifyOnce(state, key, text) {
+        if (state.noticeKey === key)
+            return;
+        state.noticeKey = key;
+        try {
+            this.deps.notify(text);
+        }
+        catch (err) {
+            this.deps.log(`auto-update: could not leave the terminal notice (${errText(err)})`);
+        }
+    }
+    availableLine(version) {
+        const { install } = this.deps.ability;
+        if (install.kind === "npx")
+            return `baychat ${version} is available. Use \`npx baychat@latest\`, or install it once with \`npm i -g baychat\` so it updates itself.`;
+        if (install.kind === "local")
+            return `baychat ${version} is available. Update it in ${install.packageRoot} with \`npm i baychat@latest\`.`;
+        return `baychat ${version} is available. Run \`baychat update\`.`;
+    }
+    async runExclusive(work) {
+        if (this.running)
+            return;
+        this.running = true;
+        try {
+            await work();
+        }
+        catch (err) {
+            // A bug in one look must not end the loop: the next tick starts from the state on disk.
+            this.deps.log(`auto-update: ${errText(err)}`);
+        }
+        finally {
+            this.running = false;
+        }
+    }
+}
+exports.AutoUpdater = AutoUpdater;
+function errText(err) {
+    return err instanceof Error ? err.message : String(err);
+}

package/dist/channel/feed.js

@@ -9,6 +9,9 @@ const READY_TIMEOUT_MS = 10_000;
 const WATCHDOG_MS = 2 * 60_000;
 /** A timer that fires this much later than asked means the computer slept: reconnect at once. */
 const SLEEP_GAP_MS = 60_000;
+/** The card's words, as one short line: they are the session's own, but this is paid output. */
+const APPROVAL_TEXT_MAX = 160;
+const REQUEST_ID = /^[A-Za-z0-9_-]{1,64}$/;
 class ChannelFeed {
     deps;
     state = "connecting";
@@ -248,7 +251,20 @@ class ChannelFeed {
             this.armWatchdog();
     }
     async pushMessages(frame) {
-        const items = (frame.messages ?? []).filter((m) => typeof m?.conversationId === "string" && typeof m?.messageId === "string");
+        const entries = (frame.messages ?? []).filter((m) => typeof m?.conversationId === "string" && typeof m?.messageId === "string");
+        // An answered decision is said as itself; anything that does not read as one stays an
+        // ordinary wake, so a malformed entry can never make the session miss a message.
+        const approvals = [];
+        const items = [];
+        for (const entry of entries) {
+            const approval = answeredApproval(entry);
+            if (approval)
+                approvals.push(approval);
+            else
+                items.push(entry);
+        }
+        for (const approval of approvals)
+            await this.pushApproval(approval);
         if (!items.length)
             return;
         const conversations = [...new Set(items.map((m) => m.conversationId))];
@@ -262,6 +278,15 @@ class ChannelFeed {
             message_ids: items.map((m) => m.messageId).join(","),
         }));
     }
+    async pushApproval(a) {
+        await this.deps.push(`Your decision "${a.question}" (${a.requestId}) in conversation ${a.conversationId} was answered: "${a.answer}". ` +
+            `Call await_approval with this requestId to confirm, then continue.`, this.meta({
+            event: "approval",
+            conversation_ids: a.conversationId,
+            message_ids: a.messageId,
+            request_id: a.requestId,
+        }));
+    }
     async pushReset() {
         await this.deps.push(`BayChat reset the feed for session "${this.deps.session}". Catch up on your joined conversations with get_messages; ` +
             `a reset never means there were no messages. The channel stays open.`, this.meta({ event: "reset" }));
@@ -282,6 +307,30 @@ class ChannelFeed {
     }
 }
 exports.ChannelFeed = ChannelFeed;
+/** An entry's `approval`, when it is a well-formed answered decision; else undefined. */
+function answeredApproval(entry) {
+    const a = entry.approval;
+    if (!a || typeof a !== "object" || a.status !== "answered")
+        return undefined;
+    if (typeof a.requestId !== "string" || !REQUEST_ID.test(a.requestId))
+        return undefined;
+    if (typeof a.question !== "string" || typeof a.answer !== "string")
+        return undefined;
+    const question = oneLine(a.question);
+    const answer = oneLine(a.answer);
+    if (!answer)
+        return undefined;
+    return { conversationId: entry.conversationId, messageId: entry.messageId, requestId: a.requestId, question, answer };
+}
+/** One line of plain text, no control characters or quotes that would blur where it ends. */
+function oneLine(text) {
+    const line = text
+        .replace(/[\u0000-\u001f\u007f-\u009f\u200e\u200f\u202a-\u202e\u2066-\u2069]/g, " ")
+        .replace(/"/g, "'")
+        .replace(/\s+/g, " ")
+        .trim();
+    return line.length > APPROVAL_TEXT_MAX ? `${line.slice(0, APPROVAL_TEXT_MAX - 1).trimEnd()}…` : line;
+}
 function parseFrame(data) {
     try {
         const parsed = JSON.parse(data);

package/dist/channel/permission.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PermissionRelay = exports.RELAY_OPTIONS = void 0;
 exports.composeRelayQuestion = composeRelayQuestion;
+const waiting_cards_1 = require("../waiting-cards");
 /** Button labels, and the ONLY index that means yes. Same as `baychat approve-hook`. */
 exports.RELAY_OPTIONS = ["Allow this once", "Deny"];
 const ALLOW_INDEX = 0;
@@ -40,6 +41,7 @@ class PermissionRelay {
             return; // Nobody is listening through this channel: the terminal alone decides.
         const pending = { claudeId: req.request_id, login: target.login, retired: false };
         this.current = pending;
+        let unmark = () => undefined;
         try {
             let reply = await this.deps.api(target.login, "POST", "/api/device-api/approvals", {
                 session: target.session,
@@ -55,6 +57,9 @@ class PermissionRelay {
                 this.deps.log("permission relay: BayChat returned no card id");
                 return;
             }
+            // Marked while the card waits, so the relay's automatic update never restarts BayChat
+            // under an open question (waiting-cards.ts).
+            unmark = (0, waiting_cards_1.markWaitingCard)(pending.cardId);
             let failures = 0;
             for (;;) {
                 if (pending.retired) {
@@ -87,6 +92,7 @@ class PermissionRelay {
             this.deps.log(`permission relay: could not ask BayChat (${err instanceof Error ? err.message : String(err)}); the terminal still decides`);
         }
         finally {
+            unmark();
             if (this.current === pending)
                 this.current = undefined;
         }

package/dist/channel/server.js

@@ -83,6 +83,7 @@ exports.CHANNEL_INSTRUCTIONS = `This is BayChat's wake-up channel. After join_se
     `If listen answers inactive or failed, use listen_messages and a native Monitor as before. ` +
     `event="reset" means catch up with get_messages; event="stopped" means the feed ended and says why; ` +
     `event="handoff" is BayChat's own request for a handoff note before a fresh start: do what it says. ` +
+    `event="approval" means the owner answered your request_approval card: call await_approval with its request_id, then continue. ` +
     `Tool-permission prompts are also offered to the session's owner as a BayChat card; answer in the terminal or ` +
     `on the phone, whichever is first. Answer in BayChat only; in the terminal write at most one short line, ` +
     `never the answer again (both are paid output).`;

package/dist/claude-onboarding.js

@@ -73,7 +73,9 @@ Read those conversations with \`get_messages\` and answer as below. There is no
 deadline and nothing to re-arm; the channel reconnects by itself. \`event="reset"\`
 means catch up with \`get_messages\`; \`event="stopped"\` says why the feed ended
 (for an expired session: \`join_session\` again with the same name and room, then
-\`listen\` again). Never open a Monitor beside an active channel.
+\`listen\` again); \`event="approval"\` means the owner answered your
+\`request_approval\` card: call \`await_approval\` with its \`request_id\`, then
+continue. Never open a Monitor beside an active channel.
 
 **With a Monitor:** keep the native Monitor (WebSocket or command) open between messages. On a \`messages\` event,
 read the indicated conversations with \`get_messages\`, deduplicate message IDs,

package/dist/cli-help.js

@@ -29,7 +29,12 @@ Usage:
   baychat update                        Bring this machine onto the current version —
                                         the package, every connected client's config, and
                                         the relay daemon (which otherwise keeps running
-                                        old code). \`baychat\` does this for you once a day
+                                        old code). The relay does this by itself about
+                                        once a day, in a quiet moment, and asks on your
+                                        phone first when a version needs you
+  baychat update --auto on|off          Switch those automatic updates on or off for this
+                                        computer (default on; BAYCHAT_AUTO_UPDATE=0 also
+                                        turns them off)
   baychat join [name] [group] [--sessions | --private | --group <title>] [--runtime <runtime>] [--bay <Bay>]
   baychat join --session <name> --group <title> --runtime codex
                                         Join and connect incoming messages in this terminal

package/dist/denied/after-hook.js

@@ -11,20 +11,26 @@ exports.cmdDeniedAfter = cmdDeniedAfter;
 // CLI, and it returns at once when no once-grant exists — the common case by far.
 //
 // The TTL sweep (grants.ts, ONCE_TTL_MS) is the backstop for a retried call that never finishes,
-// and every run here sweeps too.
+// and every run here sweeps too — including a grant whose deferred confirmation never finished,
+// which is taken back and the owner told (confirm.ts; it loads only the card client and config,
+// no MCP SDK and none of the CLI's commands).
 const hook_stdin_1 = require("../hook-stdin");
+const confirm_1 = require("./confirm");
 const grants_1 = require("./grants");
 const permission_rule_1 = require("./permission-rule");
 /** Handle one finished call. NEVER THROWS; diagnostics go to stderr. */
 async function afterCall(rawStdin, log = defaultLog) {
     try {
-        if (!(0, grants_1.hasOnceGrants)())
+        if (!(0, grants_1.hasGrantsToSweep)())
             return;
         const input = JSON.parse(rawStdin);
         const call = typeof input.tool_name === "string" ? (0, permission_rule_1.callKeyOf)(input.tool_name, input.tool_input) : undefined;
         if (call && typeof input.session_id === "string")
             await (0, grants_1.consumeOnceGrants)(input.session_id, call);
         await (0, grants_1.sweepExpiredGrants)();
+        if ((0, grants_1.hasStaleUnconfirmed)()) {
+            await (0, confirm_1.takeBackStaleUnconfirmed)({ log });
+        }
     }
     catch (err) {
         log(`baychat denied-after: ${err instanceof Error ? err.message : String(err)}`);