@event4u/agent-switch 2.1.0 → 2.3.0

package/dist/gui-settings.js

@@ -0,0 +1,67 @@
+/**
+ * GUI preferences that must outlive the webview's `localStorage` — the Pet
+ * intro once-flag (D36) and the launch-at-login preference. The GUI can only
+ * reach the filesystem through this CLI, so it reads and writes them with
+ * `agent-switch gui-settings`; `doctor` reads the autostart preference from the
+ * same file.
+ *
+ * Additive file (`<ROOT>/gui-settings.json`): absent keys mean "never decided",
+ * so an upgrade starts with nothing stored and the GUI migrates its old
+ * `localStorage` flags in once.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { ROOT, ensureRoot } from "./profiles.js";
+export const GUI_SETTINGS_FILE = path.join(ROOT, "gui-settings.json");
+function normalizeAutostart(raw) {
+    const r = (raw ?? {});
+    const at = typeof r.at === "string" ? r.at : "";
+    if (r.state === "enabled" && (r.by === "first-run" || r.by === "user"))
+        return { state: "enabled", by: r.by, at };
+    if (r.state === "disabled" && r.by === "user")
+        return { state: "disabled", by: "user", at };
+    return { state: "unset" };
+}
+export function readGuiSettings(file = GUI_SETTINGS_FILE) {
+    let raw = {};
+    try {
+        raw = JSON.parse(fs.readFileSync(file, "utf8")) ?? {};
+    }
+    catch {
+        /* absent / unparsable → nothing decided */
+    }
+    const d = raw.autostartDegraded;
+    return {
+        petWelcomed: raw.petWelcomed === true,
+        autostart: normalizeAutostart(raw.autostart),
+        autostartDegraded: d && typeof d === "object" && typeof d.reason === "string"
+            ? { at: typeof d.at === "string" ? d.at : "", reason: d.reason }
+            : null,
+    };
+}
+export function writeGuiSettings(next, file = GUI_SETTINGS_FILE) {
+    if (file === GUI_SETTINGS_FILE)
+        ensureRoot();
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(next, null, 2) + "\n", { mode: 0o600 });
+    fs.renameSync(tmp, file);
+}
+/**
+ * Apply one update. Guards the two invariants the roadmap pins: the pet intro
+ * flag only ever goes false → true, and a first-run default never replaces a
+ * stored choice (only `by: "user"` may overwrite one).
+ */
+export function applyGuiSetting(cur, u, now = new Date()) {
+    const at = now.toISOString();
+    if (u.key === "pet-welcomed")
+        return { ...cur, petWelcomed: true };
+    if (u.key === "autostart-degraded") {
+        return { ...cur, autostartDegraded: u.reason ? { at, reason: u.reason } : null };
+    }
+    if (u.state === "disabled" && u.by !== "user")
+        throw new Error("only the user can turn launch-at-login off");
+    if (u.by === "first-run" && cur.autostart.state !== "unset")
+        return cur;
+    const autostart = u.state === "enabled" ? { state: "enabled", by: u.by, at } : { state: "disabled", by: "user", at };
+    return { ...cur, autostart, autostartDegraded: null };
+}

package/dist/history.js

@@ -56,3 +56,23 @@ export function seriesFor(samples, windowKey) {
         .map((s) => s.windows.find((w) => w.key === windowKey)?.utilization)
         .filter((u) => typeof u === "number");
 }
+/** The last snapshot read for a profile, kept unthrottled next to the history:
+ *  `dir` trusts usage only while it is minutes old, and the history keeps at
+ *  most one sample an hour. Holds the snapshot only, never a token. */
+export const LATEST_FILE = "usage-latest.json";
+export function writeLatestSnapshot(file, snapshot) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(snapshot) + "\n", { mode: 0o600 });
+    fs.renameSync(tmp, file);
+}
+export function readLatestSnapshot(file) {
+    try {
+        const snapshot = JSON.parse(fs.readFileSync(file, "utf8"));
+        const capturedMs = Date.parse(snapshot?.capturedAt);
+        return Array.isArray(snapshot?.windows) && !isNaN(capturedMs) ? { snapshot, capturedMs } : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/hooks.js

@@ -122,6 +122,27 @@ export function readEvents(file) {
         return [];
     }
 }
+/**
+ * Sessions waiting on the user: their last hook event is `Notification` (a
+ * permission prompt, or a long wait for input) and the transcript has not been
+ * written since — a reply or an approval writes to it. `Stop` alone is not
+ * waiting: it ends every turn.
+ */
+export function waitingSessions(events, mtimeMs) {
+    const last = new Map();
+    for (const e of events)
+        if (e.sessionId)
+            last.set(e.sessionId, e);
+    // sessionId → when it started waiting.
+    const out = new Map();
+    for (const [id, e] of last) {
+        const written = mtimeMs(id);
+        // Two seconds of slack: the notification and the transcript line that led to it land together.
+        if (e.event === "Notification" && written !== null && Date.parse(e.at) + 2000 >= written)
+            out.set(id, e.at);
+    }
+    return out;
+}
 /** Append one event, trimming the ring to EVENT_RING_CAP. Tolerant of a
  *  malformed existing file (starts fresh). */
 export function appendEvent(file, rec) {