tmux-ide 2.7.0 → 2.8.0

package/packages/daemon/src/tui/chrome/events.ts

@@ -13,8 +13,8 @@
  * file, and appends.
  */
 import { appendFileSync, existsSync, mkdirSync, renameSync, statSync } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
+import { stateHome } from "../../lib/state-home.ts";
 import type { AgentStatus } from "../detect/classify.ts";
 
 /** A single session-level status transition. `from` is null the first time a session is seen. */
@@ -86,9 +86,9 @@ export function formatEventLine(
   return `${isoTime(ev.ts)} ${ev.session} ${from} → ${paint(ev.to, ev.to)}`;
 }
 
-/** Absolute path to the fleet event log. */
+/** Absolute path to the fleet event log (under the `TMUX_IDE_HOME`-aware home). */
 export function eventsPath(): string {
-  return join(homedir(), ".tmux-ide", "events.jsonl");
+  return join(stateHome(), "events.jsonl");
 }
 
 /**
@@ -106,7 +106,7 @@ export function appendEvents(
   if (events.length === 0) return;
   const path = eventsPath();
   try {
-    mkdirSync(join(homedir(), ".tmux-ide"), { recursive: true });
+    mkdirSync(stateHome(), { recursive: true });
     if (existsSync(path) && shouldRotate(statSync(path).size)) {
       renameSync(path, `${path}.1`);
     }

package/packages/daemon/src/tui/chrome/front-door.ts

@@ -0,0 +1,39 @@
+/**
+ * The chrome front door (M25.1) — the tiny, LEAF constants + argv builders the
+ * unified app needs to get a session watched without importing the chrome/data
+ * graph (app.tsx deliberately never imports the sync fleet-scan modules that
+ * {@link ./updater.ts} pulls in; see the FleetSession note there).
+ *
+ * "Watched" means: stamped with {@link ADOPTED_OPTION} so the background
+ * updater enumerates it (VERIFIED inert for a session that never ran `adopt` —
+ * none of adopt's status-row/border options are set, so the updater's status/
+ * chip var writes land on options nothing reads), and the updater itself
+ * ensured up. The sync twin of that flow lives in `updater.ts`
+ * (`startUpdaterIfNeeded`); the app uses these argvs with async execFile (the
+ * render-loop law).
+ */
+
+/** Per-session marker option set on adopt so the updater can enumerate adopted
+ *  sessions. (Owned here; re-exported by `updater.ts` for its callers.) */
+export const ADOPTED_OPTION = "@tmux_ide_adopted";
+
+/** The hidden internal session that hosts the updater loop. */
+export const UPDATER_SESSION = "_tmux-ide-chrome";
+
+/** PURE — stamp `session` watched (see the header: inert re: chrome painting). */
+export function adoptMarkArgv(session: string): string[] {
+  return ["set-option", "-t", session, ADOPTED_OPTION, "1"];
+}
+
+/** PURE — the existence probe for the updater session (`=` exact-match, so a
+ *  user session that merely starts with the name can't shadow it). Exit 0 =
+ *  running. */
+export function updaterProbeArgv(): string[] {
+  return ["has-session", "-t", `=${UPDATER_SESSION}`];
+}
+
+/** PURE — the argv that spawns the updater loop, detached. `exec` replaces the
+ *  shell so the pane IS the loop; killing the session stops it. */
+export function updaterSpawnArgv(): string[] {
+  return ["new-session", "-d", "-s", UPDATER_SESSION, "exec tmux-ide chrome-updater"];
+}

package/packages/daemon/src/tui/chrome/notify-prefs.ts

@@ -0,0 +1,58 @@
+/**
+ * Notification PREFERENCES — the pure shapes and parsing, hoisted out of
+ * {@link ./notify.ts} (which is io: node:child_process, node:fs, tmux).
+ *
+ * Why the split: `settings-model.ts` is pure and only needs `NotificationPrefs`
+ * + `parseHHMM`, but importing them from notify.ts dragged the whole io graph in
+ * behind them. That's invisible in the daemon (node has `process`), and it broke
+ * the moment a pure surface was imported anywhere else — the web host loads
+ * these same modules in a browser, where `process` does not exist.
+ *
+ * The rule this restores is the repo's own: pure core, thin io. Anything a pure
+ * module needs belongs in a pure module.
+ *
+ * notify.ts re-exports these, so existing importers are untouched.
+ */
+import type { NotificationSound } from "../../lib/app-config.ts";
+
+/** A local-time window, `HH:MM`–`HH:MM`. */
+export interface QuietHours {
+  /** Local `HH:MM` the window opens (e.g. `22:00`). */
+  start: string;
+  /** Local `HH:MM` the window closes (e.g. `08:00`). */
+  end: string;
+}
+
+export interface NotificationPrefs {
+  /** Master switch — false silences every channel. */
+  enabled: boolean;
+  /** In-terminal status-line toasts. */
+  toast: boolean;
+  /** System banners (native macOS helper, Linux `notify-send`). */
+  macos: boolean;
+  /** Terminal-native banners — OSC 9/99 escapes to eligible client ttys (M25.2). */
+  terminal: boolean;
+  /** Seconds the OS-level channels wait + re-verify before firing (0 = immediate). */
+  delaySeconds: number;
+  /** Sound channel — ping sound + BEL routing (M25.2). */
+  sound: NotificationSound;
+  /** Ping when an agent goes `blocked`. */
+  onBlocked: boolean;
+  /** Ping when an agent goes `done`. */
+  onDone: boolean;
+  /** Optional local-time window that suppresses every OS-LEVEL channel (banner,
+   *  terminal escape, sound, BEL — since M25.2). In-app toasts and the event
+   *  log stay on. */
+  quietHours: QuietHours | null;
+}
+
+/** PURE — parse `HH:MM` to minutes-since-midnight, or null when malformed / out of range. */
+export function parseHHMM(value: unknown): number | null {
+  if (typeof value !== "string") return null;
+  const m = /^(\d{2}):(\d{2})$/.exec(value.trim());
+  if (!m) return null;
+  const hours = Number(m[1]);
+  const minutes = Number(m[2]);
+  if (hours > 23 || minutes > 59) return null;
+  return hours * 60 + minutes;
+}

package/packages/daemon/src/tui/chrome/notify-state.ts

@@ -0,0 +1,76 @@
+/**
+ * Persistence for the notification debounce map (M25.1) — `lastNotified`
+ * survives updater restarts, so a respawned updater can't re-ping inside the
+ * debounce window (the old in-memory map made every restart an amnesty).
+ *
+ * Same split and same home discipline as {@link ../../lib/update-check.ts}:
+ * {@link serializeLastNotified} + {@link parseLastNotified} are PURE (and prune
+ * entries older than the debounce window — a stamp that can no longer suppress
+ * anything is dead weight); {@link loadLastNotified} / {@link saveLastNotified}
+ * are the thin, never-throwing io wrappers over
+ * `<TMUX_IDE_HOME>/notify-state.json`.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { stateHome } from "../../lib/state-home.ts";
+import { NOTIFY_DEBOUNCE_MS } from "./notify.ts";
+
+/** Absolute path to the persisted debounce map. */
+export function notifyStatePath(): string {
+  return join(stateHome(), "notify-state.json");
+}
+
+/** PURE — the JSON body for a debounce map, dropping entries whose timestamp
+ *  is already outside the debounce window (they can't suppress anything). */
+export function serializeLastNotified(map: ReadonlyMap<string, number>, nowMs: number): string {
+  const lastNotified: Record<string, number> = {};
+  for (const [key, ts] of map) {
+    if (nowMs - ts < NOTIFY_DEBOUNCE_MS) lastNotified[key] = ts;
+  }
+  return JSON.stringify({ lastNotified });
+}
+
+/** PURE — parse a persisted body back into the map, pruning stale entries.
+ *  Malformed input (or a FUTURE timestamp beyond the window — clock skew)
+ *  yields an empty/partial map, never a throw. */
+export function parseLastNotified(json: string, nowMs: number): Map<string, number> {
+  const out = new Map<string, number>();
+  try {
+    const parsed = JSON.parse(json) as { lastNotified?: unknown };
+    const raw = parsed?.lastNotified;
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) return out;
+    for (const [key, ts] of Object.entries(raw as Record<string, unknown>)) {
+      if (typeof ts !== "number") continue;
+      if (nowMs - ts >= NOTIFY_DEBOUNCE_MS) continue; // expired
+      if (ts - nowMs > NOTIFY_DEBOUNCE_MS) continue; // absurd future stamp
+      out.set(key, ts);
+    }
+  } catch {
+    // unreadable state just means a fresh debounce map
+  }
+  return out;
+}
+
+/** io — load the persisted map (empty when missing/unreadable). Never throws. */
+export function loadLastNotified(nowMs: number = Date.now()): Map<string, number> {
+  const path = notifyStatePath();
+  if (!existsSync(path)) return new Map();
+  try {
+    return parseLastNotified(readFileSync(path, "utf-8"), nowMs);
+  } catch {
+    return new Map();
+  }
+}
+
+/** io — persist the map (creating the home if needed). Best-effort. */
+export function saveLastNotified(
+  map: ReadonlyMap<string, number>,
+  nowMs: number = Date.now(),
+): void {
+  try {
+    mkdirSync(stateHome(), { recursive: true });
+    writeFileSync(notifyStatePath(), serializeLastNotified(map, nowMs));
+  } catch {
+    // an unwritable map just means a restart re-arms the debounce — never fatal
+  }
+}