roger-roger 0.1.0

package/skills/roger-roger/scripts/daemon.mjs

@@ -0,0 +1,604 @@
+#!/usr/bin/env node
+// The one process that does the work. Agents come and go; this stays.
+//
+// It owns the Slack connection (always, not just while a question is open, so a message sent at any
+// moment is taken in straight away), the speakers (one announcement at a time, with the Windows
+// audio player kept warm), every state file, and the register of which agent sessions are running.
+// Agents reach it over a local socket and are otherwise thin: parse a command, ask, print the answer.
+//
+// Only one can run: binding the socket is the mutual exclusion. A second daemon fails to bind and
+// leaves. The lock file next to it is only for `status` to read.
+
+import crypto from "node:crypto";
+import fs from "node:fs";
+import net from "node:net";
+import os from "node:os";
+import path from "node:path";
+import { EventEmitter } from "node:events";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import {
+  CHECKS, EDIT, EDIT_CALLBACK, NOTE_CALLBACK, OTHER, OTHER_CALLBACK, SUBMIT, applyQuietHours,
+  rogerRogerHome, checkedIndices, editModal, legacyHome, loadConfigSafely, machineEnv, noteModal, otherModal, parseActionId,
+  parseProgressActionId, parseRouteActionId, pidAlive, progressBlocks, reminderText, slackAppToken,
+  slackToken, stripTags,
+} from "./lib.mjs";
+import { lineReader, send, socketPath, PROTOCOL_VERSION } from "./protocol.mjs";
+import { connectSocket, openModal, permalink, postToChannel, updateMessage } from "./slack.mjs";
+import { closeAudio, playAlert, warmUpAudio } from "./audio.mjs";
+import { FROM_HOOKS, HANDLERS, owedTo, startTray } from "./handlers.mjs";
+import * as progressStore from "./progress.mjs";
+import * as tray from "./tray.mjs";
+import * as sessions from "./sessions.mjs";
+import * as inbox from "./inbox.mjs";
+import { labelPane } from "./herdr.mjs";
+import { expire, isExpired, list, patchPending, read, settle, undeliveredFor } from "./decisions.mjs";
+
+const TICK_MS = 2_000;
+const HEARTBEAT_STALE_MS = 30_000;
+const SCRIPTS_DIR = path.dirname(fileURLToPath(import.meta.url));
+
+const lockPath = () => path.join(rogerRogerHome(), "daemon.json");
+const logPath = () => path.join(rogerRogerHome(), "daemon.log");
+
+function log(line) {
+  try {
+    fs.appendFileSync(logPath(), `${new Date().toISOString()} [${process.pid}] ${line}\n`);
+  } catch {
+    // Logging must never take the daemon down.
+  }
+}
+
+// A broken config file is the user's to fix and the log's to mention, not a reason to stop serving.
+const loadConfig = () => loadConfigSafely(undefined, log);
+
+/**
+ * A fingerprint of the skill's scripts. A daemon started before the skill was updated would keep
+ * serving with old code, so it compares this each tick and hands over to a fresh one when it changes.
+ */
+function codeStamp() {
+  try {
+    return fs.readdirSync(SCRIPTS_DIR)
+      .filter((f) => f.endsWith(".mjs"))
+      .map((f) => `${f}:${fs.statSync(path.join(SCRIPTS_DIR, f)).mtimeMs}`)
+      .sort()
+      .join("|");
+  } catch {
+    return "";
+  }
+}
+
+export function readLock() {
+  try {
+    return JSON.parse(fs.readFileSync(lockPath(), "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+/** For `status`: is a daemon up? The socket is the real answer, this is the cheap one. */
+export function daemonRunning() {
+  const lock = readLock();
+  return Boolean(lock && pidAlive(lock.pid) && Date.now() - lock.heartbeat < HEARTBEAT_STALE_MS);
+}
+
+const bus = new EventEmitter();
+bus.setMaxListeners(0);
+
+// What a tray icon draws. Written whenever anything moves, at most once a second: a tray watches
+// this one file rather than speaking the daemon's protocol itself.
+let snapshotAt = 0;
+let snapshotTimer = null;
+function refreshTray({ ifStaleMs = 0 } = {}) {
+  // The tick calls this to keep "quiet for" honest while nothing is happening; everything else
+  // calls it because something just did.
+  if (ifStaleMs && Date.now() - snapshotAt < ifStaleMs) return;
+  const wait = Math.max(0, 1000 - (Date.now() - snapshotAt));
+  if (snapshotTimer) return;
+  snapshotTimer = setTimeout(() => {
+    snapshotTimer = null;
+    snapshotAt = Date.now();
+    try {
+      tray.write(tray.snapshot({ config: loadConfig(), daemon: { pid: process.pid, slackConnected: state.slackConnected } }));
+    } catch (e) {
+      log(`could not write the tray snapshot: ${e.message}`);
+    }
+  }, wait);
+  snapshotTimer.unref();
+}
+
+const changed = (why) => {
+  refreshTray();
+  bus.emit("change", why);
+};
+
+const state = {
+  startedAt: Date.now(),
+  socket: null, // Slack Socket Mode
+  socketRetryAt: 0,
+  socketFailures: 0,
+  slackConnected: false,
+  clients: 0,
+  waiters: new Map(), // decision id → how many agents are blocked on it right now
+  activity: new Map(), // session id → when it last ran something other than `listen`
+  inFlight: 0, // requests being served; a handover waits for them rather than cutting them off
+};
+
+/** Is an agent actually sitting on this question? Settling it decides what Slack says if not. */
+const hasWaiter = (id) => (state.waiters.get(id) ?? 0) > 0;
+
+// ---------------------------------------------------------------- serving agents
+
+function ctxFor(connection, identity, about) {
+  const session = identity?.id ? sessions.decorate(sessions.register(identity, about ?? {})) : null;
+  // A session in a Herdr pane gets its name on the tab and the agent, once, in the background.
+  if (session) labelPane(session, { log, touch: sessions.touch }).catch((e) => log(`herdr: ${e.message}`));
+  let lastSync = Date.now(); // the Slack socket is live, so a catch-up is only for after downtime
+  return {
+    config: loadConfig(),
+    session,
+    identity,
+    log,
+    daemon: true,
+    emit: (event, data) => send(connection, { n: 1, event, data }),
+    /** When this agent last ran a real command. A parked `listen` gives up once it is awake again. */
+    lastActivity() {
+      return session ? state.activity.get(session.id) ?? 0 : 0;
+    },
+    /** Register this connection as waiting on a question; the returned function gives it back. */
+    waiting(id) {
+      state.waiters.set(id, (state.waiters.get(id) ?? 0) + 1);
+      return () => {
+        const left = (state.waiters.get(id) ?? 1) - 1;
+        if (left > 0) state.waiters.set(id, left);
+        else state.waiters.delete(id);
+      };
+    },
+    /** Wait, but wake early when anything changes — an answer, a button, a message. */
+    idle(ms) {
+      if (connection.destroyed) throw Object.assign(new Error("client went away"), { aborted: true });
+      return new Promise((resolve) => {
+        const done = () => {
+          clearTimeout(timer);
+          bus.off("change", done);
+          connection.off("close", done);
+          resolve();
+        };
+        const timer = setTimeout(done, ms);
+        bus.once("change", done);
+        connection.once("close", done);
+      });
+    },
+    /** Slack is connected live, so this is a no-op unless the connection has been down. */
+    async catchUp() {
+      if (state.slackConnected || Date.now() - lastSync < 15_000) return;
+      lastSync = Date.now();
+      await inbox.sync({ log }).catch((e) => log(`inbox sync failed: ${e.message}`));
+    },
+  };
+}
+
+const LOCAL = {
+  ping: () => ({ data: { ok: true, pid: process.pid, protocol: PROTOCOL_VERSION, startedAt: new Date(state.startedAt).toISOString() } }),
+  status: (ctx) => ({
+    data: {
+      ok: true,
+      pid: process.pid,
+      startedAt: new Date(state.startedAt).toISOString(),
+      slackConnected: state.slackConnected,
+      sessions: sessions.live().map((s) => ({ nickname: s.nickname, swatch: s.swatch, project: s.project, state: s.state, queued: s.queue?.length ?? 0, owes: undeliveredFor(s.id).length, me: s.id === ctx.session?.id })),
+      me: ctx.session
+        ? {
+          nickname: ctx.session.nickname,
+          swatch: ctx.session.swatch,
+          colour: ctx.session.colour,
+          ...(ctx.session.herdr ? { herdr: { tab: ctx.session.herdr.tab, pane: ctx.session.herdr.pane, labelled: ctx.session.herdrLabel ?? null } } : {}),
+        }
+        : null,
+    },
+  }),
+  stop: () => {
+    setTimeout(() => shutdown("asked to stop"), 50);
+    return { data: { ok: true, stopping: true } };
+  },
+};
+
+async function onRequest(connection, message) {
+  const { n, cmd, args = {}, session } = message;
+  const reply = (body) => send(connection, { n: n ?? 1, ...body });
+  const handler = LOCAL[cmd] ?? HANDLERS[cmd];
+  if (!handler) return reply({ ok: false, error: `unknown command "${cmd}"`, code: 2 });
+  let ctx;
+  try {
+    ctx = ctxFor(connection, session?.identity, session?.about);
+  } catch (e) {
+    return reply({ ok: false, error: `could not register the session: ${e.message}`, code: 1 });
+  }
+  // Running anything at all means the agent is back; that releases a `listen` it left parked.
+  if (cmd !== "listen" && !FROM_HOOKS.has(cmd) && ctx.session) state.activity.set(ctx.session.id, Date.now());
+  // From here the command is ours. If we die before answering, the caller must not run it again —
+  // a notification that was already posted would arrive twice.
+  reply({ event: "received" });
+  state.inFlight++;
+  try {
+    const { data, code = 0 } = (await handler(ctx, args)) ?? {};
+    // Whatever the user said while this agent wasn't listening rides back on whatever it ran.
+    const body = FROM_HOOKS.has(cmd) ? data : await owedTo(ctx, data).catch((e) => {
+      log(`handing over what was owed failed: ${e.message}`);
+      return data;
+    });
+    changed(cmd);
+    reply({ ok: true, data: body, code });
+  } catch (e) {
+    if (e.aborted) return; // the agent's command was interrupted; nobody is listening
+    log(`${cmd} failed: ${e.stack ?? e.message}`);
+    // Only a number is an exit code. Slack and Node errors carry text codes (`ratelimited`, `EPERM`),
+    // and the CLI reads anything that isn't a number as "the daemon wasn't there" and runs the
+    // command again itself — which is how one post became two.
+    reply({ ok: false, error: e.message, code: typeof e.code === "number" ? e.code : 1 });
+  } finally {
+    state.inFlight--;
+  }
+}
+
+function onConnection(connection) {
+  state.clients++;
+  connection.setEncoding("utf8");
+  connection.on("error", () => {});
+  connection.on("close", () => state.clients--);
+  connection.on("data", lineReader(
+    (message) => onRequest(connection, message).catch((e) => log(`request crashed: ${e.stack ?? e.message}`)),
+    (e) => log(`bad request line: ${e.message}`),
+  ));
+}
+
+// ---------------------------------------------------------------- Slack
+
+async function onInteractive(payload) {
+  const callback = payload.view?.callback_id;
+  if (payload.type === "view_submission" && callback === NOTE_CALLBACK) {
+    const text = (payload.view.state?.values?.note?.text?.value ?? "").trim();
+    if (text) await onProgressNote(payload.view.private_metadata, text, payload.user?.id ?? null);
+    return changed("note");
+  }
+  if (payload.type === "view_submission" && (callback === OTHER_CALLBACK || callback === EDIT_CALLBACK)) {
+    const id = payload.view.private_metadata;
+    const edited = callback === EDIT_CALLBACK;
+    // A draft keeps its own line breaks and spacing; a typed answer is trimmed.
+    const raw = payload.view.state?.values?.answer?.text?.value ?? "";
+    const text = edited ? raw : raw.trim();
+    if (!text.trim() || read(id)?.status !== "pending") return;
+    const settled = await settle(id, {
+      status: "answered",
+      answer: { index: null, choice: null, text, by: payload.user?.id ?? null, ...(edited ? { edited: true } : {}) },
+    }, log, { waiting: hasWaiter(id) });
+    if (settled) log(`${id}: answered with ${edited ? "an edited draft" : "text"}`);
+    return changed("answer");
+  }
+  if (payload.type !== "block_actions") return;
+  for (const action of payload.actions ?? []) {
+    const routed = parseRouteActionId(action.action_id);
+    if (routed) {
+      await inbox.resolvePick(routed.ts, routed.sessionId, log);
+      changed("routed");
+      continue;
+    }
+    const progressAction = parseProgressActionId(action.action_id);
+    if (progressAction?.action === "note") {
+      const current = progressStore.current(progressAction.key);
+      if (current) await openModal(payload.trigger_id, noteModal({ key: progressAction.key, headline: current.headline }));
+      continue;
+    }
+    if (progressAction) {
+      await onProgressAction(progressAction, payload.user?.id ?? null);
+      changed("control");
+      continue;
+    }
+    const parsed = parseActionId(action.action_id);
+    if (!parsed) continue;
+    const decision = read(parsed.id);
+    if (!decision || decision.status !== "pending") continue;
+    if (parsed.index === OTHER) {
+      await openModal(payload.trigger_id, otherModal(decision));
+      continue;
+    }
+    if (parsed.index === EDIT && decision.draft) {
+      await openModal(payload.trigger_id, editModal(decision));
+      continue;
+    }
+    // Ticking a checkbox is just the user making up their mind; Submit is the answer.
+    if (parsed.index === CHECKS) continue;
+    if (parsed.index === SUBMIT) {
+      const indices = checkedIndices(payload.state, parsed.id).filter((i) => decision.choices[i] !== undefined);
+      const choices = indices.map((i) => decision.choices[i]);
+      const settled = await settle(parsed.id, { status: "answered", answer: { indices, choices, by: payload.user?.id ?? null } }, log, { waiting: hasWaiter(parsed.id) });
+      if (settled) log(`${parsed.id}: answered ${JSON.stringify(choices)}`);
+      changed("answer");
+      continue;
+    }
+    const choice = decision.choices[parsed.index];
+    if (choice === undefined) continue;
+    const settled = await settle(parsed.id, { status: "answered", answer: { index: parsed.index, choice, by: payload.user?.id ?? null } }, log, { waiting: hasWaiter(parsed.id) });
+    if (settled) log(`${parsed.id}: answered "${choice}"`);
+    changed("answer");
+  }
+}
+
+/** Pause / Resume / Stop on a progress message: record it for the agent, and show it in the message. */
+async function onProgressAction({ key, action }, by) {
+  const current = progressStore.current(key);
+  if (!current) return;
+  const control = { state: action === "resume" ? "running" : action, by, at: new Date().toISOString() };
+  log(`progress ${key}: ${action}`);
+  await saveAndRender(key, { ...current, control });
+}
+
+async function onProgressNote(key, text, by) {
+  const current = progressStore.current(key);
+  if (!current) return;
+  log(`progress ${key}: note`);
+  await saveAndRender(key, { ...current, notes: [...(current.notes ?? []), { text, by, at: new Date().toISOString() }] });
+}
+
+async function saveAndRender(key, next) {
+  progressStore.save(key, next);
+  try {
+    await updateMessage(next.channel, next.ts, { text: stripTags(next.headline), blocks: progressBlocks({ ...next, key }), color: next.colour });
+  } catch (e) {
+    log(`progress ${key}: could not update message: ${e.message}`);
+  }
+}
+
+async function onEvent(event) {
+  if (event.type === "message" && event.channel_type === "im") {
+    await inbox.ingest(event, { log, live: true, waiting: hasWaiter });
+    changed("message");
+  }
+}
+
+/** Keep the Slack connection up whenever tokens exist, whether or not anything is pending. */
+async function keepSlackConnected() {
+  if (state.socket || Date.now() < state.socketRetryAt) return;
+  if (!slackToken() || !slackAppToken() || typeof WebSocket !== "function") return;
+  try {
+    state.socket = await connectSocket({
+      onInteractive,
+      onEvent,
+      log,
+      onClose: () => {
+        state.socket = null;
+        state.slackConnected = false;
+        state.socketRetryAt = Date.now() + 2_000;
+      },
+    });
+    state.slackConnected = true;
+    state.socketFailures = 0;
+    log("slack connected");
+    // Anything sent while nothing was listening: take it in now.
+    await inbox.sync({ log }).catch((e) => log(`inbox sync failed: ${e.message}`));
+    changed("slack");
+  } catch (e) {
+    state.socketFailures++;
+    state.socketRetryAt = Date.now() + Math.min(60_000, 5_000 * state.socketFailures);
+    log(`socket connect failed: ${e.message}`);
+  }
+}
+
+/** Send the next reminder for a decision if its time has come. */
+async function remindIfDue(decision) {
+  const due = decision.reminders ?? [];
+  const sent = decision.remindersSent ?? 0;
+  if (sent >= due.length || Date.now() < Date.parse(due[sent])) return;
+  // Record first, so a crash mid-reminder can't make it repeat forever.
+  if (!patchPending(decision.id, { remindersSent: sent + 1 })) return;
+
+  let config;
+  try {
+    config = loadConfig();
+  } catch {
+    config = null;
+  }
+  if (!config) return;
+  const { methods } = applyQuietHours(config.methods, config);
+  log(`${decision.id}: reminder ${sent + 1} of ${due.length}`);
+
+  const slackJob = methods.includes("slack")
+    ? permalink(decision.channel, decision.ts)
+        .then((link) => postToChannel(decision.channel, { text: reminderText({ question: decision.question, permalink: link, count: sent + 1 }), color: decision.colour }))
+        .catch((e) => log(`${decision.id}: reminder post failed: ${e.message}`))
+    : null;
+  try {
+    await playAlert({ methods, config, text: "[neutral] Quick reminder. I'm still waiting for your answer in Slack." });
+  } catch (e) {
+    log(`${decision.id}: reminder audio failed: ${e.message}`);
+  }
+  await slackJob;
+}
+
+// ---------------------------------------------------------------- the process
+
+function writeLock() {
+  fs.mkdirSync(rogerRogerHome(), { recursive: true });
+  fs.writeFileSync(lockPath(), JSON.stringify({
+    pid: process.pid,
+    socket: socketPath(),
+    startedAt: state.startedAt,
+    heartbeat: Date.now(),
+    protocol: PROTOCOL_VERSION,
+  }, null, 2) + "\n");
+}
+
+function releaseLock() {
+  if (readLock()?.pid === process.pid) fs.rmSync(lockPath(), { force: true });
+}
+
+let stopping = false;
+function shutdown(why, { restart = false } = {}) {
+  if (stopping) return;
+  stopping = true;
+  log(`daemon stopping: ${why}`);
+  try {
+    state.socket?.close();
+    server?.close();
+    fs.rmSync(socketPath(), { force: true }); // unix socket file; a no-op for a named pipe
+  } catch {
+    // Going down anyway.
+  }
+  releaseLock();
+  closeAudio();
+  // A tray left drawing the last snapshot would show agents and questions that nobody is keeping
+  // track of any more. Saying there is no daemon lets it say so too.
+  if (snapshotTimer) clearTimeout(snapshotTimer);
+  try {
+    tray.write(tray.snapshot({ config: loadConfig(), daemon: null }));
+  } catch {
+    // Going down anyway.
+  }
+  if (restart) {
+    const child = spawn(process.execPath, [fileURLToPath(import.meta.url)], { cwd: os.homedir(), detached: true, stdio: "ignore", windowsHide: true, env: machineEnv() });
+    child.unref();
+  }
+  // Let anything mid-flight finish answering first. A command cut off here used to be repeated by
+  // the CLI, which is how one notification became two. Parked long polls just get the full wait.
+  const deadline = Date.now() + 5_000;
+  const drain = () => {
+    if (state.inFlight <= 0 || Date.now() >= deadline) return process.exit(0);
+    setTimeout(drain, 50).unref();
+  };
+  setTimeout(drain, 100).unref();
+}
+
+let server = null;
+
+/**
+ * The daemon from before the rename, if it is still running. It holds its own Socket Mode connection
+ * to the same Slack app, and Slack shares events out between connections — so with both up, about
+ * half of the user's clicks and messages would go to a process that no longer answers for anything.
+ * It speaks the same protocol, so it is asked to stop the same way `daemon stop` would.
+ */
+async function stopLegacyDaemon() {
+  if (process.env.ROGER_ROGER_HOME) return; // a test or a second account; the old one isn't ours
+  const home = legacyHome();
+  const target = process.platform === "win32"
+    ? `\\\\.\\pipe\\attention-${crypto.createHash("sha1").update(home.toLowerCase()).digest("hex").slice(0, 12)}`
+    : path.join(home, "daemon.sock");
+  await new Promise((resolve) => {
+    const socket = net.createConnection(target);
+    const done = () => (socket.destroy(), resolve());
+    const timer = setTimeout(done, 3_000);
+    socket.once("error", () => (clearTimeout(timer), resolve()));
+    socket.once("connect", () => {
+      log("the daemon from before the rename is still running; asking it to stop");
+      send(socket, { n: 1, cmd: "stop", args: {} });
+      socket.setEncoding("utf8");
+      socket.on("data", lineReader((message) => {
+        if (message.n === 1 && !message.event) (clearTimeout(timer), done());
+      }));
+    });
+  });
+}
+
+function configMtime() {
+  try {
+    return fs.statSync(path.join(rogerRogerHome(), "config.json")).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+
+/** Bring the tray up with the daemon, unless the user said not to or it was never installed. */
+async function autostartTray() {
+  if (process.env.ROGER_ROGER_NO_TRAY === "1" || loadConfig()?.tray === "off") return;
+  try {
+    const started = await startTray();
+    if (started.starting) log(`tray started (pid ${started.pid})`);
+  } catch (e) {
+    log(`could not start the tray: ${e.message}`);
+  }
+}
+
+/** Bind the socket, or discover that another daemon owns it and step aside. */
+function listen() {
+  return new Promise((resolve, reject) => {
+    server = net.createServer(onConnection);
+    server.once("error", async (e) => {
+      if (e.code !== "EADDRINUSE") return reject(e);
+      // Either a daemon is already running, or a unix socket file was left behind by a dead one.
+      const alive = await new Promise((done) => {
+        const probe = net.createConnection(socketPath());
+        probe.once("connect", () => (probe.destroy(), done(true)));
+        probe.once("error", () => done(false));
+      });
+      if (alive) return reject(Object.assign(new Error("another daemon is already running"), { code: "TAKEN" }));
+      try {
+        fs.rmSync(socketPath(), { force: true });
+      } catch {
+        // Nothing else to try.
+      }
+      server = net.createServer(onConnection);
+      server.once("error", reject);
+      server.listen(socketPath(), resolve);
+    });
+    server.listen(socketPath(), resolve);
+  });
+}
+
+async function main() {
+  // The home may not exist yet: nothing has been set up, and this is the first command ever run.
+  // On macOS and Linux the socket lives in it, so binding would fail, and so would logging why.
+  try {
+    fs.mkdirSync(rogerRogerHome(), { recursive: true });
+  } catch {
+    // If it truly can't be made, listen() says so below.
+  }
+  try {
+    await listen();
+  } catch (e) {
+    if (e.code === "TAKEN") return; // someone beat us to it; that is a success, quietly
+    log(`could not listen on ${socketPath()}: ${e.message}`);
+    process.exitCode = 1;
+    return;
+  }
+  writeLock();
+  const stamp = codeStamp();
+  log(`daemon started on ${socketPath()}`);
+  warmUpAudio(); // so the first announcement of the day doesn't wait for a PowerShell to start
+  await stopLegacyDaemon().catch((e) => log(`could not stop the old daemon: ${e.message}`));
+  autostartTray();
+
+  for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) process.on(signal, () => shutdown(signal));
+
+  let configStamp = configMtime();
+  while (!stopping) {
+    writeLock();
+    // `setup` runs in the caller's process, not here. Noticing its write is what keeps the tray's
+    // settings from sitting on the old values until the next slow refresh.
+    const stampNow = configMtime();
+    if (stampNow !== configStamp) {
+      configStamp = stampNow;
+      changed("config");
+    }
+    if (codeStamp() !== stamp) return shutdown("the skill's code changed; a fresh daemon takes over", { restart: true });
+
+    for (const d of list().filter((d) => isExpired(d))) {
+      const settled = await expire(d, log, { waiting: hasWaiter(d.id) });
+      if (settled) {
+        log(`${d.id}: ${settled.answer?.auto ? `no answer, defaulted to ${JSON.stringify(settled.answer.choice ?? settled.answer.choices)}` : "expired"}`);
+        changed("expired");
+      }
+    }
+    for (const d of list().filter((d) => d.status === "pending")) await remindIfDue(d);
+    refreshTray({ ifStaleMs: 15_000 }); // nothing may be happening, but time still passes
+    await keepSlackConnected();
+
+    await new Promise((r) => setTimeout(r, TICK_MS));
+  }
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  main().catch((e) => {
+    log(`daemon crashed: ${e.stack ?? e.message}`);
+    releaseLock();
+    process.exit(1);
+  });
+}