baychat 0.29.9 → 0.31.0

package/dist/auto-update/policy.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HELD_FRESH_MS = exports.QUIET_MS = exports.CARD_POLL_MS = exports.ASK_AGAIN_MS = exports.CHECK_INTERVAL_MS = exports.AUTO_UPDATE_ENV = void 0;
+exports.planUpdate = planUpdate;
+exports.autoUpdateOffReason = autoUpdateOffReason;
+exports.nextCheckAt = nextCheckAt;
+exports.installAllowedAt = installAllowedAt;
+exports.busyReason = busyReason;
+const self_upgrade_1 = require("../self-upgrade");
+/** Longest reason a card or terminal line carries when several releases each said something. */
+const REASON_MAX_CHARS = 300;
+function planUpdate(current, release) {
+    const order = (0, self_upgrade_1.compareVersions)(current, release.version);
+    // Already there, newer (a local build), or a version that does not parse (a dev build like
+    // 0.31.0-dev): never install over it.
+    if (order === undefined || order >= 0)
+        return { kind: "current" };
+    // Every release this machine would cross that asked for the person, newest first.
+    const crossed = Object.entries(release.attention)
+        .filter(([version]) => (0, self_upgrade_1.compareVersions)(version, current) === 1 && ((0, self_upgrade_1.compareVersions)(version, release.version) ?? 1) <= 0)
+        .sort(([a], [b]) => (0, self_upgrade_1.compareVersions)(b, a) ?? 0)
+        .map(([, reason]) => reason);
+    const major = (v) => Number(v.split(".")[0]);
+    if (major(release.version) > major(current))
+        crossed.push(`a new major version (${major(release.version)}.x)`);
+    if (crossed.length === 0)
+        return { kind: "auto", version: release.version };
+    return { kind: "ask", version: release.version, reason: clip(crossed.join("; "), REASON_MAX_CHARS) };
+}
+/** Environment values that switch automatic updates off (for CI and companies). */
+const ENV_OFF = new Set(["0", "off", "false", "no"]);
+exports.AUTO_UPDATE_ENV = "BAYCHAT_AUTO_UPDATE";
+/** Why automatic updates are off, or undefined when they are on. The environment wins. */
+function autoUpdateOffReason(env, setting) {
+    const raw = env[exports.AUTO_UPDATE_ENV];
+    if (raw !== undefined && ENV_OFF.has(raw.trim().toLowerCase()))
+        return `${exports.AUTO_UPDATE_ENV}=${raw.trim()}`;
+    if (setting === "off")
+        return "baychat update --auto off";
+    return undefined;
+}
+// ─── Timing ───────────────────────────────────────────────────────────────────────────────
+const MINUTE = 60_000;
+const HOUR = 60 * MINUTE;
+const DAY = 24 * HOUR;
+/** About once a day — invisible on the registry, and soon enough that nobody runs `update`. */
+exports.CHECK_INTERVAL_MS = DAY;
+/** Spread across an hour so a fleet of relays started together never asks npm together. */
+const CHECK_SPREAD_MS = HOUR;
+/** The first check after a start: soon, but not in the busy first minutes. */
+const FIRST_CHECK_MIN_MS = 5 * MINUTE;
+const FIRST_CHECK_SPREAD_MS = 10 * MINUTE;
+/** A check that failed (offline, npm down) is tried again sooner than a day, then backs off. */
+const CHECK_RETRY_MS = HOUR;
+/** A failed install of one version waits a day, then two, … up to a week. A newer version resets it. */
+const INSTALL_RETRY_MS = DAY;
+const INSTALL_RETRY_MAX_MS = 7 * DAY;
+/** "Later" on the card: asked again after this long. */
+exports.ASK_AGAIN_MS = 3 * DAY;
+/** How often a waiting card is looked at. A tap on "Update now" lands within this. */
+exports.CARD_POLL_MS = 5 * MINUTE;
+/** No message for this long before a restart: an agent woken just now is likely mid-turn. */
+exports.QUIET_MS = 10 * MINUTE;
+/** A held message younger than this is a session mid-turn; an older one is a session that died. */
+exports.HELD_FRESH_MS = 30 * MINUTE;
+/**
+ * When the next registry check is due. `random` is in [0, 1) and spreads relays apart; it is a
+ * parameter so a test can pin it.
+ */
+function nextCheckAt(timing, startedAt, random) {
+    const firstAfterStart = startedAt + FIRST_CHECK_MIN_MS + random * FIRST_CHECK_SPREAD_MS;
+    if (timing.lastCheckAt === undefined)
+        return firstAfterStart;
+    const failures = timing.checkFailures ?? 0;
+    const wait = failures > 0 ? Math.min(CHECK_RETRY_MS * 2 ** (failures - 1), exports.CHECK_INTERVAL_MS) : exports.CHECK_INTERVAL_MS + random * CHECK_SPREAD_MS;
+    return Math.max(timing.lastCheckAt + wait, firstAfterStart);
+}
+/** When installing `version` may be tried again after failing; 0 when nothing holds it back. */
+function installAllowedAt(failure, version) {
+    if (!failure || failure.version !== version || failure.count < 1)
+        return 0;
+    return failure.at + Math.min(INSTALL_RETRY_MS * 2 ** (failure.count - 1), INSTALL_RETRY_MAX_MS);
+}
+/**
+ * Why the relay must not restart now, or undefined when it may. Fail closed on everything the
+ * relay can see: a restart is never worth an interrupted turn, a lost session command, or a card
+ * whose answer would arrive at a relay that is not there.
+ */
+function busyReason({ activity, cardsWaiting, dependents, now }) {
+    if (activity.deliveries.length)
+        return `delivering to ${activity.deliveries.join(", ")}`;
+    if (activity.headless.length)
+        return `a headless turn is running for ${activity.headless.join(", ")}`;
+    if (activity.acp.length)
+        return `an agent turn is running for ${activity.acp.join(", ")}`;
+    if (activity.launching)
+        return "a session is being started from BayChat";
+    if (cardsWaiting > 0)
+        return `${cardsWaiting} card(s) on the phone are waiting for an answer`;
+    if (activity.heldAt.some((at) => now - Date.parse(at) < exports.HELD_FRESH_MS))
+        return "a session is mid-turn with messages waiting for it";
+    if (activity.lastActivityAt !== undefined && now - activity.lastActivityAt < exports.QUIET_MS)
+        return "messages arrived in the last 10 minutes";
+    if (dependents.length)
+        return `processes the relay started are still running (pid ${dependents.slice(0, 3).join(", ")})`;
+    return undefined;
+}
+function clip(text, max) {
+    return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
+}

package/dist/auto-update/relay-glue.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startRelayUpdater = startRelayUpdater;
+const api_1 = require("../api");
+const config_1 = require("../config");
+const self_restart_1 = require("../relay/self-restart");
+const session_reply_1 = require("../relay/session-reply");
+const self_upgrade_1 = require("../self-upgrade");
+const refresh_clients_1 = require("../refresh-clients");
+const waiting_cards_1 = require("../waiting-cards");
+const policy_1 = require("./policy");
+const store_1 = require("./store");
+const updater_1 = require("./updater");
+/**
+ * The automatic update wired to a real relay: npm, the disk, the device API for the card, and the
+ * init system for the restart. Everything that decides is in `updater.ts` and `policy.ts`; this
+ * file only connects it. Run by the SUPERVISING relay only — a per-Bay child restarts with it.
+ */
+function startRelayUpdater(opts) {
+    const supervisor = (0, self_restart_1.detectSupervisor)(self_restart_1.realSupervisorProbe);
+    const install = (0, self_upgrade_1.classifyInstall)((0, self_upgrade_1.currentEntry)());
+    const current = (0, self_upgrade_1.ownVersion)();
+    const deps = {
+        now: Date.now,
+        random: Math.random,
+        log: opts.log,
+        current,
+        ability: { install, supervised: supervisor !== undefined, root: process.getuid?.() === 0, platform: process.platform },
+        env: process.env,
+        setting: store_1.loadAutoSetting,
+        loadState: store_1.loadAutoUpdateState,
+        saveState: store_1.saveAutoUpdateState,
+        notify: store_1.writeUpdateNotice,
+        lookupLatest: () => (0, self_upgrade_1.lookupLatest)(self_upgrade_1.realNpm),
+        installVersion: (version) => installGlobal(install, version, current, opts.log),
+        busyReason: () => (0, policy_1.busyReason)({
+            activity: opts.daemon.activity(),
+            cardsWaiting: (0, waiting_cards_1.countWaitingCards)(),
+            dependents: supervisor === "systemd" ? (0, self_restart_1.processesEndedByRestart)(self_restart_1.realSupervisorProbe) : [],
+            now: Date.now(),
+        }),
+        restart: async () => restartUnder(supervisor, opts.shutdown),
+        refreshClients: async () => {
+            const device = (0, config_1.loadDeviceCredentials)();
+            if (device)
+                for (const line of (0, refresh_clients_1.refreshConnectedClients)(device, opts.log))
+                    opts.log(`auto-update: ${line}`);
+        },
+        cards: deviceCards(opts.daemon, opts.log),
+    };
+    const updater = new updater_1.AutoUpdater(deps);
+    updater.start();
+    return updater;
+}
+/**
+ * Install `version` over the running global copy, holding the install lock. If npm failed in a way
+ * that left something other than the running version on disk, put the running version back, so a
+ * relay that restarts later (a reboot) still starts working code.
+ */
+async function installGlobal(install, version, current, log) {
+    if (install.kind !== "global")
+        return { ok: false, reason: `a ${install.kind} copy is never updated automatically` };
+    const unlock = (0, store_1.acquireUpdateLock)();
+    if (!unlock)
+        return { ok: false, reason: "another update of baychat is running" };
+    try {
+        const deps = { npm: self_upgrade_1.realNpm, readVersion: self_upgrade_1.readPackageVersion, install };
+        const installed = await (0, self_upgrade_1.installRelease)(deps, version);
+        if (installed.ok || (0, self_upgrade_1.readPackageVersion)(install.packageRoot) === current)
+            return installed;
+        const restored = await (0, self_upgrade_1.installRelease)(deps, current);
+        log(`auto-update: ${restored.ok ? `put ${current} back on disk` : `could not put ${current} back (${restored.reason})`}`);
+        return installed;
+    }
+    finally {
+        unlock();
+    }
+}
+function restartUnder(supervisor, shutdown) {
+    // `mode` is never "auto" without a supervisor, so this is an invariant, not a branch.
+    if (!supervisor)
+        throw new Error("refusing to restart: no init system would start the relay again");
+    (0, self_restart_1.arrangeRestart)(supervisor);
+    shutdown();
+}
+/** The decision card, over the device API — the same endpoint the hooks use, owner-only answers. */
+function deviceCards(daemon, log) {
+    const device = () => {
+        const creds = (0, config_1.loadDeviceCredentials)();
+        if (!creds)
+            throw new Error("this computer is not signed in to BayChat");
+        return creds;
+    };
+    return {
+        async ask(question) {
+            const session = daemon.hostedLiveSessions()[0];
+            if (!session)
+                return undefined; // A card goes to the private chat with a session; none is live.
+            try {
+                const reply = await (0, api_1.apiRequest)(device(), "POST", "/api/device-api/approvals", {
+                    session,
+                    question,
+                    options: [...updater_1.UPDATE_OPTIONS],
+                    direct: true,
+                    wait: 1,
+                });
+                if (typeof reply.requestId !== "string" || !reply.requestId)
+                    return undefined;
+                return {
+                    requestId: reply.requestId,
+                    conversationId: typeof reply.conversationId === "string" ? reply.conversationId : undefined,
+                    session: typeof reply.sessionName === "string" ? reply.sessionName : session,
+                };
+            }
+            catch (err) {
+                log(`auto-update: could not put the update card up (${err instanceof Error ? err.message : String(err)})`);
+                return undefined;
+            }
+        },
+        async answer(requestId) {
+            try {
+                const reply = await (0, api_1.apiRequest)(device(), "GET", `/api/device-api/approvals/${encodeURIComponent(requestId)}?wait=1`);
+                if (reply.status === "waiting")
+                    return { kind: "waiting" };
+                if (reply.status === "answered")
+                    return { kind: reply.answerIndex === updater_1.UPDATE_NOW_INDEX ? "update" : "later" };
+                return { kind: "gone" };
+            }
+            catch (err) {
+                // The card no longer exists for us: gone. A blip: ask again on the next poll.
+                if (err instanceof api_1.ApiError && (err.status === 404 || err.status === 403))
+                    return { kind: "gone" };
+                return { kind: "waiting" };
+            }
+        },
+        async withdraw(requestId) {
+            await (0, api_1.apiRequest)(device(), "POST", `/api/device-api/approvals/${encodeURIComponent(requestId)}/withdraw`, {});
+        },
+        async say(conversationId, session, text) {
+            await (0, session_reply_1.postSessionReply)(device(), conversationId, session, text);
+        },
+    };
+}

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);
+}