autonag 0.1.0

package/dist/cli.js

@@ -0,0 +1,1168 @@
+#!/usr/bin/env node
+
+// cli.ts
+import { join } from "path";
+import { homedir } from "os";
+import { mkdirSync, existsSync, readFileSync, writeFileSync } from "fs";
+import JSON5 from "json5";
+
+// apiClient.ts
+var ApiError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "ApiError";
+  }
+  status;
+};
+function createApiClient(baseUrl, defaultToken) {
+  async function apiFetch(path, options = {}, token) {
+    const tok = token ?? defaultToken;
+    const headers = {
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+    if (tok) headers["Authorization"] = `Bearer ${tok}`;
+    const res = await fetch(`${baseUrl}${path}`, { ...options, headers });
+    if (!res.ok) {
+      let message = `HTTP ${res.status}`;
+      try {
+        const body = await res.json();
+        if (body.error) message = body.error;
+      } catch {
+      }
+      throw new ApiError(res.status, message);
+    }
+    return res.json();
+  }
+  return {
+    registerDevice: (nickname) => apiFetch(
+      "/devices/request",
+      { method: "POST", body: JSON.stringify({ nickname }) }
+    ),
+    getMe: (token) => apiFetch(
+      "/devices/me",
+      {},
+      token
+    ),
+    requestInstance: (nickname, token) => apiFetch(
+      "/instances/request",
+      { method: "POST", body: JSON.stringify({ nickname }) },
+      token
+    ),
+    requestInstanceAccess: (instanceId, token, inviteCode) => apiFetch(
+      `/instances/${instanceId}/access/request`,
+      { method: "POST", body: JSON.stringify(inviteCode ? { inviteCode } : {}) },
+      token
+    ),
+    getInvite: (code) => apiFetch(
+      `/invites/${code}`
+    ),
+    createInvite: (instanceId, token) => apiFetch(
+      `/instances/${instanceId}/invites`,
+      { method: "POST", body: JSON.stringify({}) },
+      token
+    ),
+    listInstances: (token) => apiFetch(
+      "/instances",
+      {},
+      token
+    ),
+    addTimer: (instanceId, token, name, expiry, recurrence, description) => apiFetch(
+      `/instances/${instanceId}/timers`,
+      { method: "POST", body: JSON.stringify({ name, expiry, ...description ? { description } : {}, ...recurrence ? { recurrence } : {} }) },
+      token
+    ),
+    renameTimer: (instanceId, token, timerId, name) => apiFetch(
+      `/instances/${instanceId}/timers/${timerId}/name`,
+      { method: "PATCH", body: JSON.stringify({ name }) },
+      token
+    ),
+    updateExpiry: (instanceId, token, timerId, expiry) => apiFetch(
+      `/instances/${instanceId}/timers/${timerId}/expiry`,
+      { method: "PATCH", body: JSON.stringify({ expiry }) },
+      token
+    ),
+    completeTimer: (instanceId, token, timerId, closeReason) => apiFetch(
+      `/instances/${instanceId}/timers/${timerId}/complete`,
+      { method: "POST", body: JSON.stringify({ closeReason }) },
+      token
+    ),
+    removeTimer: (instanceId, token, timerId) => apiFetch(
+      `/instances/${instanceId}/timers/${timerId}`,
+      { method: "DELETE" },
+      token
+    ),
+    setShush: (instanceId, token, expiry) => apiFetch(
+      `/instances/${instanceId}/shush`,
+      { method: "POST", body: JSON.stringify({ expiry }) },
+      token
+    ),
+    clearShush: (instanceId, token) => apiFetch(
+      `/instances/${instanceId}/shush`,
+      { method: "DELETE" },
+      token
+    ),
+    listEvents: (instanceId, token, opts = {}) => {
+      const { from = 1, before, limit = 200 } = opts;
+      const params = before !== void 0 ? `before=${before}&limit=${limit}` : `from=${from}&limit=${limit}`;
+      return apiFetch(
+        `/instances/${instanceId}/events?${params}`,
+        {},
+        token
+      );
+    },
+    getTimerHistory: (instanceId, token, timerId, opts = {}) => {
+      const params = new URLSearchParams();
+      if (opts.after !== void 0) params.set("after", String(opts.after));
+      if (opts.limit !== void 0) params.set("limit", String(opts.limit));
+      if (opts.from !== void 0) params.set("from", String(opts.from));
+      if (opts.to !== void 0) params.set("to", String(opts.to));
+      const qs = params.toString();
+      return apiFetch(
+        `/instances/${instanceId}/timers/${timerId}/history${qs ? `?${qs}` : ""}`,
+        {},
+        token
+      );
+    },
+    skipEvent: (instanceId, token, eventId) => apiFetch(
+      `/instances/${instanceId}/events/${eventId}/skip`,
+      { method: "POST" },
+      token
+    ),
+    unskipEvent: (instanceId, token, eventId) => apiFetch(
+      `/instances/${instanceId}/events/${eventId}/skip`,
+      { method: "DELETE" },
+      token
+    ),
+    listComments: (instanceId, token, threadId) => apiFetch(
+      `/instances/${instanceId}/threads/${threadId}/comments`,
+      {},
+      token
+    ),
+    addComment: (instanceId, token, threadId, text) => apiFetch(
+      `/instances/${instanceId}/threads/${threadId}/comments`,
+      { method: "POST", body: JSON.stringify({ text }) },
+      token
+    ),
+    getState: (instanceId, token) => apiFetch(
+      `/instances/${instanceId}/state`,
+      {},
+      token
+    ),
+    batchActions: (instanceId, token, actions) => apiFetch(
+      `/instances/${instanceId}/actions`,
+      { method: "POST", body: JSON.stringify({ actions }) },
+      token
+    )
+  };
+}
+
+// cli.ts
+var CONFIG_PATH = join(homedir(), ".config", "autonag", "client.json5");
+function loadConfig() {
+  if (!existsSync(CONFIG_PATH)) return { server: "http://localhost:3000" };
+  let raw;
+  try {
+    raw = readFileSync(CONFIG_PATH, "utf8");
+  } catch (e) {
+    console.error(`Cannot read config file ${CONFIG_PATH}: ${e}`);
+    process.exit(1);
+  }
+  try {
+    return JSON5.parse(raw);
+  } catch (e) {
+    console.error(`Config file ${CONFIG_PATH} is not valid JSON5: ${e}`);
+    process.exit(1);
+  }
+}
+function saveConfig(config) {
+  mkdirSync(join(CONFIG_PATH, ".."), { recursive: true });
+  writeFileSync(CONFIG_PATH, JSON5.stringify(config, null, 2));
+}
+function parseExpiry(input) {
+  if (input.startsWith("unix-ms:")) {
+    const n = Number(input.slice(8));
+    if (!Number.isInteger(n) || n <= 0) {
+      console.error(`Invalid expiry "${input}". Use unix-ms:<positive-integer>`);
+      process.exit(1);
+    }
+    return n;
+  }
+  if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(Z|[+-]\d{2}:\d{2})$/.test(input)) {
+    const ms = Date.parse(input);
+    if (isNaN(ms)) {
+      console.error(`Invalid datetime "${input}"`);
+      process.exit(1);
+    }
+    return ms;
+  }
+  const match = input.match(/^(?:(\d+)d)?(?:(\d+)h)?(?:(\d+)m)?(?:(\d+)s)?$/);
+  if (match && (match[1] || match[2] || match[3] || match[4])) {
+    const d = parseInt(match[1] ?? "0");
+    const h = parseInt(match[2] ?? "0");
+    const m = parseInt(match[3] ?? "0");
+    const s = parseInt(match[4] ?? "0");
+    return Date.now() + (d * 86400 + h * 3600 + m * 60 + s) * 1e3;
+  }
+  console.error(`Cannot parse expiry "${input}". Use: 1d, 30m, 2h, 90s (relative duration), 2026-05-01T09:00:00Z (ISO 8601 with timezone), or unix-ms:<n>`);
+  process.exit(1);
+}
+function fmtCountdown(ms) {
+  const sign = ms < 0 ? "-" : "";
+  const abs = Math.abs(ms);
+  const totalSec = Math.floor(abs / 1e3);
+  const d = Math.floor(totalSec / 86400);
+  const h = Math.floor(totalSec % 86400 / 3600);
+  const m = Math.floor(totalSec % 3600 / 60);
+  const s = totalSec % 60;
+  if (d > 0) return `${sign}${d}d ${h}h`;
+  if (h > 0) return `${sign}${h}h ${m}m`;
+  if (m > 0) return `${sign}${m}m ${s}s`;
+  return `${sign}${s}s`;
+}
+function fmtDate(ms) {
+  return new Date(ms).toLocaleString();
+}
+function shortId(id) {
+  return id.slice(0, 8);
+}
+function col(s, w) {
+  return s.slice(0, w).padEnd(w);
+}
+async function resolveTimerId(prefix, cfg2) {
+  if (/^[0-9a-f-]{36}$/.test(prefix)) return prefix;
+  const api = createApiClient(cfg2.server, cfg2.token);
+  const state = await api.getState(cfg2.instanceId, cfg2.token);
+  const matches = state.timers.filter((t) => t.id.startsWith(prefix));
+  if (matches.length === 0) {
+    console.error(`Timer not found: ${prefix}`);
+    process.exit(1);
+  }
+  if (matches.length > 1) {
+    console.error(`Ambiguous prefix "${prefix}" matches: ${matches.map((t) => shortId(t.id) + "\u2026").join(", ")}`);
+    process.exit(1);
+  }
+  return matches[0].id;
+}
+async function resolveEventId(prefix, cfg2) {
+  if (/^[0-9a-f-]{36}$/.test(prefix)) return prefix;
+  const api = createApiClient(cfg2.server, cfg2.token);
+  const allIds = [];
+  let from = 1;
+  while (true) {
+    const { events, latestSeq } = await api.listEvents(cfg2.instanceId, cfg2.token, { from, limit: 200 });
+    allIds.push(...events.map((e) => e.id));
+    if (events.length < 200 || events[events.length - 1].seq >= latestSeq) break;
+    from = events[events.length - 1].seq + 1;
+  }
+  const matches = allIds.filter((id) => id.startsWith(prefix));
+  if (matches.length === 0) {
+    console.error(`Event not found: ${prefix}`);
+    process.exit(1);
+  }
+  if (matches.length > 1) {
+    console.error(`Ambiguous prefix "${prefix}" matches: ${matches.map((id) => shortId(id) + "\u2026").join(", ")}`);
+    process.exit(1);
+  }
+  return matches[0];
+}
+async function resolveInstanceId(prefix, cfg2) {
+  if (/^[0-9a-f-]{36}$/.test(prefix)) return prefix;
+  const api = createApiClient(cfg2.server, cfg2.token);
+  const { instances } = await api.listInstances(cfg2.token);
+  const matches = instances.filter((i) => i.id.startsWith(prefix));
+  if (matches.length === 0) {
+    console.error(`Instance not found: ${prefix}`);
+    process.exit(1);
+  }
+  if (matches.length > 1) {
+    console.error(`Ambiguous prefix "${prefix}" matches: ${matches.map((i) => `"${i.nickname}" (${shortId(i.id)}\u2026)`).join(", ")}`);
+    process.exit(1);
+  }
+  return matches[0].id;
+}
+function requireToken(cfg2) {
+  if (!cfg2.token) {
+    console.error("Not registered. Run: autonag register <nickname>");
+    process.exit(1);
+  }
+}
+function requireInstance(cfg2) {
+  if (!cfg2.instanceId) {
+    console.error("No instance selected. Run: autonag instances select <id>");
+    process.exit(1);
+  }
+}
+async function cmdRegister(nickname, cfg2) {
+  const api = createApiClient(cfg2.server);
+  const { device, token } = await api.registerDevice(nickname);
+  cfg2.token = token;
+  cfg2.deviceId = device.id;
+  saveConfig(cfg2);
+  console.log(`Registered as "${nickname}" (${shortId(device.id)}\u2026)`);
+  console.log(`Token saved to ${CONFIG_PATH}`);
+  console.log(`Waiting for admin approval \u2014 run "autonag status" to check.`);
+}
+async function cmdStatus(cfg2) {
+  console.log(`Server:   ${cfg2.server}`);
+  console.log(`Config:   ${CONFIG_PATH}`);
+  if (!cfg2.token) {
+    console.log(`Auth:     not registered (run: autonag register <nickname>)`);
+    return;
+  }
+  const api = createApiClient(cfg2.server, cfg2.token);
+  try {
+    const { device: d } = await api.getMe(cfg2.token);
+    const status = d.approvedAt ? `approved ${fmtDate(d.approvedAt)}` : "PENDING APPROVAL";
+    console.log(`Auth:     ${d.nickname} (${shortId(d.id)}\u2026) [${status}]`);
+  } catch (e) {
+    if (e instanceof ApiError && e.status === 401) {
+      console.log(`Auth:     token invalid or expired`);
+    } else throw e;
+  }
+  console.log(`Instance: ${cfg2.instanceId ?? "none selected (run: autonag instances select <id>)"}`);
+}
+async function cmdInstancesList(cfg2) {
+  requireToken(cfg2);
+  const api = createApiClient(cfg2.server, cfg2.token);
+  const { instances } = await api.listInstances(cfg2.token);
+  if (instances.length === 0) {
+    console.log("No accessible instances.");
+    return;
+  }
+  for (const i of instances) {
+    const status = i.approvedAt ? "active" : "PENDING";
+    const marker = i.id === cfg2.instanceId ? " *" : "  ";
+    console.log(`${marker} ${shortId(i.id)}\u2026  "${i.nickname}"  [${status}]`);
+  }
+  console.log(`
+* = current default`);
+}
+async function cmdInstancesRequest(nickname, cfg2) {
+  requireToken(cfg2);
+  const api = createApiClient(cfg2.server, cfg2.token);
+  const { instance } = await api.requestInstance(nickname, cfg2.token);
+  console.log(`Requested instance "${instance.nickname}" (${shortId(instance.id)}\u2026)`);
+  console.log(`Waiting for admin approval.`);
+}
+async function cmdInstancesSelect(id, cfg2) {
+  requireToken(cfg2);
+  const instanceId = await resolveInstanceId(id, cfg2);
+  cfg2.instanceId = instanceId;
+  saveConfig(cfg2);
+  console.log(`Default instance set to ${instanceId}`);
+}
+async function cmdInstancesJoin(code, cfg2) {
+  requireToken(cfg2);
+  const api = createApiClient(cfg2.server, cfg2.token);
+  const { invite } = await api.getInvite(code);
+  if (!invite.valid) {
+    console.error(`Invite is not valid: ${invite.reason ?? "expired or already used"}`);
+    process.exit(1);
+  }
+  await api.requestInstanceAccess(invite.instanceId, cfg2.token, code);
+  console.log(`Joined instance "${invite.instanceNickname}" (${shortId(invite.instanceId)}\u2026)`);
+  console.log(`Run: autonag instances select ${invite.instanceId}`);
+}
+async function cmdTimersList(cfg2) {
+  requireToken(cfg2);
+  requireInstance(cfg2);
+  const api = createApiClient(cfg2.server, cfg2.token);
+  const state = await api.getState(cfg2.instanceId, cfg2.token);
+  const now = Date.now();
+  const timers = [...state.timers].sort((a, b) => a.currentExpiry - b.currentExpiry);
+  if (timers.length === 0) {
+    console.log("No active timers.");
+  } else {
+    console.log(`${"ID".padEnd(10)}  ${"Name".padEnd(24)}  ${"Remaining".padEnd(16)}  Recur`);
+    console.log("-".repeat(60));
+    for (const t of timers) {
+      const remaining = t.currentExpiry - now;
+      const label = remaining < 0 ? `OVERDUE ${fmtCountdown(remaining)}` : `in ${fmtCountdown(remaining)}`;
+      const recur = t.recurrence ? "\u21BB" : "";
+      console.log(`${col(shortId(t.id) + "\u2026", 10)}  ${col(t.name, 24)}  ${col(label, 16)}  ${recur}`);
+    }
+  }
+  console.log();
+  printAlarmStatus(state, now);
+}
+function printAlarmStatus(state, now) {
+  const { alarm, shush } = state;
+  const shushed = !!(shush && shush.expiry > now);
+  const colorLabel = {
+    blue: "off",
+    green: "green",
+    yellow: "yellow",
+    red: "red",
+    flashing: "FLASHING"
+  };
+  if (alarm.startsAt !== null) {
+    const diff = alarm.startsAt - now;
+    const colorStr = colorLabel[alarm.color] ?? alarm.color;
+    const timeStr = diff <= 0 ? `overdue ${fmtCountdown(diff)}` : `in ${fmtCountdown(diff)}`;
+    console.log(`[${colorStr}] "${alarm.urgentName}" \u2014 ${timeStr}`);
+  }
+  if (alarm.on) {
+    console.log(`Alarm: ringing.`);
+  } else if (shushed) {
+    const overdue = alarm.startsAt !== null && alarm.startsAt <= now;
+    const shushEndsAfterTimer = alarm.startsAt !== null && shush.expiry >= alarm.startsAt;
+    const necessary = overdue || shushEndsAfterTimer;
+    if (necessary) {
+      const ringIn = fmtCountdown(shush.expiry - now);
+      console.log(`Alarm: off. Will ring in ${ringIn}: Shush expires: ${alarm.urgentName}.`);
+    } else if (alarm.startsAt !== null) {
+      const ringIn = fmtCountdown(alarm.startsAt - now);
+      const remaining = fmtCountdown(shush.expiry - now);
+      console.log(`Alarm: off. Will ring in ${ringIn}: ${alarm.urgentName}. (Shushed unnecessarily for ${remaining}.)`);
+    } else {
+      const remaining = fmtCountdown(shush.expiry - now);
+      console.log(`Alarm: off. Shushed (unnecessarily) for ${remaining}.`);
+    }
+  } else if (alarm.startsAt !== null) {
+    const ringIn = fmtCountdown(alarm.startsAt - now);
+    console.log(`Alarm: off. Will ring in ${ringIn}: ${alarm.urgentName}.`);
+  } else {
+    console.log(`Alarm: off.`);
+  }
+}
+async function cmdAlarm(cfg2) {
+  requireToken(cfg2);
+  requireInstance(cfg2);
+  const api = createApiClient(cfg2.server, cfg2.token);
+  const state = await api.getState(cfg2.instanceId, cfg2.token);
+  printAlarmStatus(state, Date.now());
+}
+async function cmdTimersAdd(name, expiryStr, cfg2, opts) {
+  requireToken(cfg2);
+  requireInstance(cfg2);
+  const api = createApiClient(cfg2.server, cfg2.token);
+  const expiry = parseExpiry(expiryStr);
+  const recurrence = opts.days !== void 0 ? {
+    periodDays: opts.days,
+    anchorTime: opts.anchor ?? "09:00",
+    timezone: opts.tz ?? Intl.DateTimeFormat().resolvedOptions().timeZone,
+    skipWeekends: opts.skipWeekends ?? false
+  } : void 0;
+  await api.addTimer(cfg2.instanceId, cfg2.token, name, expiry, recurrence, opts.desc);
+  const recurNote = recurrence ? ` (recurs every ${opts.days}d)` : "";
+  console.log(`Timer "${name}" added, expires ${fmtDate(expiry)}${recurNote}`);
+}
+async function cmdTimersRename(id, name, cfg2) {
+  requireToken(cfg2);
+  requireInstance(cfg2);
+  const timerId = await resolveTimerId(id, cfg2);
+  const api = createApiClient(cfg2.server, cfg2.token);
+  await api.renameTimer(cfg2.instanceId, cfg2.token, timerId, name);
+  console.log(`Timer ${shortId(timerId)}\u2026 renamed to "${name}"`);
+}
+async function cmdTimersSnooze(id, expiryStr, cfg2) {
+  requireToken(cfg2);
+  requireInstance(cfg2);
+  const timerId = await resolveTimerId(id, cfg2);
+  const api = createApiClient(cfg2.server, cfg2.token);
+  const expiry = parseExpiry(expiryStr);
+  await api.updateExpiry(cfg2.instanceId, cfg2.token, timerId, expiry);
+  console.log(`Timer ${shortId(timerId)}\u2026 snoozed until ${fmtDate(expiry)}`);
+}
+async function cmdTimersComplete(id, reason, cfg2) {
+  requireToken(cfg2);
+  requireInstance(cfg2);
+  const api = createApiClient(cfg2.server, cfg2.token);
+  const state = await api.getState(cfg2.instanceId, cfg2.token);
+  const timerId = await resolveTimerId(id, cfg2);
+  const timer = state.timers.find((t) => t.id === timerId);
+  if (timer?.recurrence) {
+    await api.batchActions(cfg2.instanceId, cfg2.token, [{ type: "recurTimer", timerId, closeReason: reason }]);
+    const newState = await api.getState(cfg2.instanceId, cfg2.token);
+    const updated = newState.timers.find((t) => t.id === timerId);
+    if (updated) {
+      console.log(`Timer "${timer.name}" recurred \u2014 next: ${fmtDate(updated.currentExpiry)}`);
+    } else {
+      console.log(`Timer ${shortId(timerId)}\u2026 recurred`);
+    }
+  } else {
+    await api.completeTimer(cfg2.instanceId, cfg2.token, timerId, reason);
+    console.log(`Timer ${shortId(timerId)}\u2026 completed (${reason})`);
+  }
+}
+async function cmdTimersRemove(id, cfg2) {
+  requireToken(cfg2);
+  requireInstance(cfg2);
+  const timerId = await resolveTimerId(id, cfg2);
+  const api = createApiClient(cfg2.server, cfg2.token);
+  await api.removeTimer(cfg2.instanceId, cfg2.token, timerId);
+  console.log(`Timer ${shortId(timerId)}\u2026 removed`);
+}
+async function cmdTimersDescribe(id, text, cfg2) {
+  requireToken(cfg2);
+  requireInstance(cfg2);
+  const timerId = await resolveTimerId(id, cfg2);
+  const api = createApiClient(cfg2.server, cfg2.token);
+  await api.batchActions(cfg2.instanceId, cfg2.token, [{ type: "updateDescription", timerId, description: text }]);
+  console.log(`Timer ${shortId(timerId)}\u2026 description updated`);
+}
+async function cmdTimersRecurrenceSet(id, days, cfg2, opts) {
+  requireToken(cfg2);
+  requireInstance(cfg2);
+  const timerId = await resolveTimerId(id, cfg2);
+  const api = createApiClient(cfg2.server, cfg2.token);
+  const recurrence = {
+    periodDays: days,
+    anchorTime: opts.anchor ?? "09:00",
+    timezone: opts.tz ?? Intl.DateTimeFormat().resolvedOptions().timeZone,
+    skipWeekends: opts.skipWeekends ?? false
+  };
+  await api.batchActions(cfg2.instanceId, cfg2.token, [{ type: "updateRecurrence", timerId, recurrence }]);
+  console.log(`Timer ${shortId(timerId)}\u2026 recurrence set to every ${days}d at ${recurrence.anchorTime} (${recurrence.timezone})`);
+}
+async function cmdTimersRecurrenceRemove(id, cfg2) {
+  requireToken(cfg2);
+  requireInstance(cfg2);
+  const timerId = await resolveTimerId(id, cfg2);
+  const api = createApiClient(cfg2.server, cfg2.token);
+  await api.batchActions(cfg2.instanceId, cfg2.token, [{ type: "removeRecurrence", timerId }]);
+  console.log(`Timer ${shortId(timerId)}\u2026 recurrence removed`);
+}
+async function cmdTimersHistory(id, cfg2) {
+  requireToken(cfg2);
+  requireInstance(cfg2);
+  const timerId = await resolveTimerId(id, cfg2);
+  const api = createApiClient(cfg2.server, cfg2.token);
+  const allEntries = [];
+  let cursor = 0;
+  while (cursor !== null) {
+    const { events, nextCursor } = await api.getTimerHistory(cfg2.instanceId, cfg2.token, timerId, { after: cursor });
+    for (const ev of events) {
+      const p = ev.payload;
+      const date = ev.type === "TimerRecurred" ? p["occurredAt"] ?? ev.timestamp : ev.timestamp;
+      allEntries.push({ date, closeReason: p["closeReason"] });
+    }
+    cursor = nextCursor;
+  }
+  if (allEntries.length === 0) {
+    console.log("No history yet.");
+    return;
+  }
+  console.log(`${"Date".padEnd(22)}  Reason`);
+  console.log("-".repeat(36));
+  for (const e of allEntries) {
+    console.log(`${col(fmtDate(e.date), 22)}  ${e.closeReason}`);
+  }
+}
+async function cmdShush(durationStr, cfg2) {
+  requireToken(cfg2);
+  requireInstance(cfg2);
+  const api = createApiClient(cfg2.server, cfg2.token);
+  const expiry = durationStr ? parseExpiry(durationStr) : Date.now() + 30 * 60 * 1e3;
+  await api.setShush(cfg2.instanceId, cfg2.token, expiry);
+  console.log(`Alarm silenced until ${fmtDate(expiry)}`);
+}
+async function cmdUnshush(cfg2) {
+  requireToken(cfg2);
+  requireInstance(cfg2);
+  const api = createApiClient(cfg2.server, cfg2.token);
+  await api.clearShush(cfg2.instanceId, cfg2.token);
+  console.log(`Shush cleared`);
+}
+async function cmdEventsList(fromSeq, cfg2) {
+  requireToken(cfg2);
+  requireInstance(cfg2);
+  const api = createApiClient(cfg2.server, cfg2.token);
+  const { events } = await api.listEvents(cfg2.instanceId, cfg2.token, { from: fromSeq });
+  if (events.length === 0) {
+    console.log("No events.");
+    return;
+  }
+  console.log(`${"seq".padEnd(6)}  ${"ID".padEnd(10)}  ${"Type".padEnd(28)}  ${"Time".padEnd(20)}  Skipped`);
+  console.log("-".repeat(78));
+  for (const e of events) {
+    const skipped = e.skipped ? "yes" : "";
+    console.log(`${String(e.seq).padEnd(6)}  ${col(shortId(e.id) + "\u2026", 10)}  ${col(e.type, 28)}  ${col(fmtDate(e.timestamp), 20)}  ${skipped}`);
+  }
+}
+async function cmdEventsSkip(id, cfg2) {
+  requireToken(cfg2);
+  requireInstance(cfg2);
+  const eventId = await resolveEventId(id, cfg2);
+  const api = createApiClient(cfg2.server, cfg2.token);
+  await api.skipEvent(cfg2.instanceId, cfg2.token, eventId);
+  console.log(`Event ${shortId(eventId)}\u2026 skipped`);
+}
+async function cmdEventsUnskip(id, cfg2) {
+  requireToken(cfg2);
+  requireInstance(cfg2);
+  const eventId = await resolveEventId(id, cfg2);
+  const api = createApiClient(cfg2.server, cfg2.token);
+  await api.unskipEvent(cfg2.instanceId, cfg2.token, eventId);
+  console.log(`Event ${shortId(eventId)}\u2026 unskipped`);
+}
+async function cmdCommentsList(id, cfg2) {
+  requireToken(cfg2);
+  requireInstance(cfg2);
+  const timerId = await resolveTimerId(id, cfg2);
+  const api = createApiClient(cfg2.server, cfg2.token);
+  const { comments } = await api.listComments(cfg2.instanceId, cfg2.token, timerId);
+  if (comments.length === 0) {
+    console.log("No comments.");
+    return;
+  }
+  for (const c of comments) {
+    console.log(`[${fmtDate(c.createdAt)}] ${c.text}`);
+  }
+}
+async function cmdCommentsAdd(id, text, cfg2) {
+  requireToken(cfg2);
+  requireInstance(cfg2);
+  const timerId = await resolveTimerId(id, cfg2);
+  const api = createApiClient(cfg2.server, cfg2.token);
+  await api.addComment(cfg2.instanceId, cfg2.token, timerId, text);
+  console.log(`Comment added`);
+}
+function cmdTutorial() {
+  console.log(`# autonag tutorial
+
+autonag is a recurring-task tracker with an alarm. Timers count down; when
+they expire, your alarm client starts ringing. You mark them done \u2014 if the
+timer is recurring, the next occurrence is automatically scheduled.
+
+## Config
+
+Your config lives at \`~/.config/autonag/client.json5\`. It is a JSON5 file
+(JSON with comments and trailing commas), so you can annotate it. After
+registration it looks something like:
+
+\`\`\`json5
+{
+  server: 'https://your-server.example',
+  token: '\u2026',
+  deviceId: '\u2026',
+  instanceId: '\u2026',
+}
+\`\`\`
+
+Edit it directly in a text editor whenever you need to change the server
+URL or switch instances. To use a different config file:
+
+\`\`\`
+autonag --config /path/to/other.json5 timers list
+\`\`\`
+
+## First-time setup
+
+Register this device \u2014 give it a short nickname so the admin knows who you are:
+
+\`\`\`
+autonag register myphone
+\`\`\`
+
+Your auth token and device ID are saved to the config. The device starts in
+PENDING state until an admin approves it. Check your status:
+
+\`\`\`
+autonag status
+\`\`\`
+
+## Getting an instance
+
+Timers live in an instance. Create a new one:
+
+\`\`\`
+autonag instances request home
+\`\`\`
+
+When the admin approves it, it shows up in your list:
+
+\`\`\`
+autonag instances list
+\`\`\`
+
+Set it as your default:
+
+\`\`\`
+autonag instances select <id>
+\`\`\`
+
+To join an instance someone else owns, ask them for an invite code. They
+generate one with:
+
+\`\`\`
+autonag instances invite
+\`\`\`
+
+Then you join with the code they share:
+
+\`\`\`
+autonag instances join <code>
+\`\`\`
+
+Invite codes are single-use and expire after 7 days. The instance is not
+discoverable by name \u2014 you need the code.
+
+## Adding timers
+
+One-shot reminder due in 2 days:
+
+\`\`\`
+autonag timers add "Doctor follow-up" 2d
+\`\`\`
+
+Recurring task every 7 days at 9 AM:
+
+\`\`\`
+autonag timers add "Weekly review" 7d --days 7 --anchor 09:00
+\`\`\`
+
+The first argument after the name is the initial expiry. \`--days\` makes it
+recurring; \`--anchor\` sets the time of day; \`--tz\` overrides the timezone.
+
+## Checking timers
+
+\`\`\`
+autonag timers list
+\`\`\`
+
+\`\`\`
+ID          Name                      Remaining         Recur
+------------------------------------------------------------
+a1b2c3d4\u2026   Doctor follow-up          in 1d 23h
+e5f6a7b8\u2026   Weekly review             in 6d 23h         \u21BB
+\`\`\`
+
+The \u21BB symbol marks recurring timers.
+
+## Completing a timer
+
+Mark a timer done with a reason (pass, fail, or any custom string):
+
+\`\`\`
+autonag timers complete e5f6 pass
+\`\`\`
+
+For a one-shot timer this removes it. For a recurring timer it schedules
+the next occurrence and tells you when:
+
+\`\`\`
+Timer "Weekly review" recurred \u2014 next: 4/24/2026, 9:00:00 AM
+\`\`\`
+
+To permanently stop a recurring timer, remove the recurrence first:
+
+\`\`\`
+autonag timers recurrence remove e5f6
+autonag timers complete e5f6 done
+\`\`\`
+
+## Snoozing
+
+Push a timer's deadline out:
+
+\`\`\`
+autonag timers snooze e5f6 3d
+\`\`\`
+
+## Silencing the alarm
+
+Silence the alarm for 30 minutes (the default):
+
+\`\`\`
+autonag shush
+\`\`\`
+
+Or for a specific duration:
+
+\`\`\`
+autonag shush 2h
+\`\`\`
+
+Resume:
+
+\`\`\`
+autonag unshush
+\`\`\`
+
+## History
+
+See every time a recurring timer was completed:
+
+\`\`\`
+autonag timers history e5f6
+\`\`\`
+
+## Notes and comments
+
+Attach a description to a timer:
+
+\`\`\`
+autonag timers describe e5f6 "Prep the agenda before this"
+\`\`\`
+
+Add timestamped comments (good for logging what happened):
+
+\`\`\`
+autonag comments add e5f6 "Completed but flagged the follow-up"
+\`\`\`
+
+## Event log
+
+Every action is recorded. View the log:
+
+\`\`\`
+autonag events list
+\`\`\`
+
+You can skip events to undo them \u2014 state is recomputed as if the
+skipped event never happened:
+
+\`\`\`
+autonag events skip <event-id>
+autonag events unskip <event-id>
+\`\`\`
+
+---
+Run \`autonag --help\` for a full command reference.`);
+}
+var HELP = `autonag client CLI
+
+Usage: autonag [options] <command> [args]
+
+Options:
+  -h, --help              Show this help
+  -s, --server <url>      Server URL (default: http://localhost:3000)
+  -i, --instance <id>     Instance ID (overrides saved default)
+  -c, --config <path>     Config file (default: ~/.config/autonag/client.json5)
+
+  tutorial                Walk through setup and daily workflow
+
+Auth:
+  register <nickname>     Register this device and save token
+  status                  Show auth status and saved config
+
+Instances:
+  instances list
+  instances request <nickname>    Create a new instance
+  instances join <code>           Join an existing instance via invite code
+  instances invite                Create an invite code for this instance
+  instances select <id>
+
+Timers:
+  timers list
+  timers add <name> <expiry> [--desc <text>] [--days <n>] [--anchor <HH:MM>] [--tz <tz>] [--skip-weekends]
+  timers rename <id> <name>
+  timers snooze <id> <expiry>         Update expiry: 1d, 30m, 2h, 90s | 2026-05-01T09:00:00Z | unix-ms:<n>
+  timers complete <id> <reason>       Complete or recur (reason: pass, fail, or custom)
+  timers remove <id>
+  timers describe <id> <text>         Set description
+  timers recurrence set <id> <days> [--anchor <HH:MM>] [--tz <tz>] [--skip-weekends]
+  timers recurrence remove <id>
+  timers history <id>                 Show completion history
+
+Alarm:
+  alarm show              Show current alarm state
+
+Shush:
+  shush [duration]        Silence alarm (default: 30m)
+  unshush                 Clear shush
+
+Events:
+  events list [--from <seq>]
+  events skip <id>
+  events unskip <id>
+
+Comments:
+  comments list <timerId>
+  comments add <timerId> <text>
+
+Config saved to ~/.config/autonag/client.json5`;
+function parseFlags(args, schema) {
+  const positional = [];
+  const flags = {};
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a.startsWith("--")) {
+      const key = a.slice(2);
+      if (!(key in schema)) {
+        console.error(`Unknown flag: --${key}`);
+        process.exit(1);
+      }
+      const type = schema[key];
+      if (type === "boolean") {
+        flags[key] = true;
+      } else {
+        const next = args[i + 1];
+        if (!next || next.startsWith("--")) {
+          console.error(`Flag --${key} requires a value`);
+          process.exit(1);
+        }
+        if (type === "int") {
+          const n = Number(next);
+          if (!Number.isInteger(n)) {
+            console.error(`Flag --${key} must be an integer, got: "${next}"`);
+            process.exit(1);
+          }
+          flags[key] = n;
+        } else {
+          flags[key] = next;
+        }
+        i++;
+      }
+    } else {
+      positional.push(a);
+    }
+  }
+  return { positional, flags };
+}
+var rawArgs = process.argv.slice(2);
+var topArgs = [];
+var serverOverride;
+var instanceOverride;
+for (let i = 0; i < rawArgs.length; i++) {
+  const a = rawArgs[i];
+  if (a === "-h" || a === "--help") {
+    console.log(HELP);
+    process.exit(0);
+  } else if (a === "-s" || a === "--server") {
+    if (!rawArgs[i + 1] || rawArgs[i + 1].startsWith("-")) {
+      console.error("Flag -s/--server requires a URL");
+      process.exit(1);
+    }
+    serverOverride = rawArgs[++i];
+  } else if (a === "-i" || a === "--instance") {
+    if (!rawArgs[i + 1] || rawArgs[i + 1].startsWith("-")) {
+      console.error("Flag -i/--instance requires an ID");
+      process.exit(1);
+    }
+    instanceOverride = rawArgs[++i];
+  } else if (a === "-c" || a === "--config") {
+    if (!rawArgs[i + 1] || rawArgs[i + 1].startsWith("-")) {
+      console.error("Flag -c/--config requires a path");
+      process.exit(1);
+    }
+    CONFIG_PATH = rawArgs[++i];
+  } else topArgs.push(a);
+}
+var cfg = loadConfig();
+if (serverOverride) cfg.server = serverOverride;
+if (instanceOverride) cfg.instanceId = instanceOverride;
+var [cmd, sub, ...rest] = topArgs;
+try {
+  if (!cmd || cmd === "help") {
+    parseFlags(rest, {});
+    console.log(HELP);
+  } else if (cmd === "tutorial") {
+    parseFlags(rest, {});
+    cmdTutorial();
+  } else if (cmd === "register") {
+    parseFlags(rest, {});
+    if (!sub) {
+      console.error("Usage: autonag register <nickname>");
+      process.exit(1);
+    }
+    await cmdRegister(sub, cfg);
+  } else if (cmd === "status") {
+    parseFlags(rest, {});
+    await cmdStatus(cfg);
+  } else if (cmd === "instances") {
+    if (!sub || sub === "list") {
+      parseFlags(rest, {});
+      await cmdInstancesList(cfg);
+    } else if (sub === "request") {
+      const { positional } = parseFlags(rest, {});
+      if (!positional[0]) {
+        console.error("Usage: autonag instances request <nickname>");
+        process.exit(1);
+      }
+      await cmdInstancesRequest(positional[0], cfg);
+    } else if (sub === "join") {
+      const { positional } = parseFlags(rest, {});
+      if (!positional[0]) {
+        console.error("Usage: autonag instances join <code>");
+        process.exit(1);
+      }
+      await cmdInstancesJoin(positional[0], cfg);
+    } else if (sub === "invite") {
+      parseFlags(rest, {});
+      requireToken(cfg);
+      requireInstance(cfg);
+      const api = createApiClient(cfg.server, cfg.token);
+      const { invite } = await api.createInvite(cfg.instanceId, cfg.token);
+      console.log(`Invite code: ${invite.code}`);
+      console.log(`Expires: ${fmtDate(invite.expiresAt)}`);
+      console.log(`Share this code \u2014 it can only be used once.`);
+    } else if (sub === "select") {
+      const { positional } = parseFlags(rest, {});
+      if (!positional[0]) {
+        console.error("Usage: autonag instances select <id>");
+        process.exit(1);
+      }
+      await cmdInstancesSelect(positional[0], cfg);
+    } else {
+      console.error(`Unknown subcommand: instances ${sub}`);
+      process.exit(1);
+    }
+  } else if (cmd === "timers") {
+    if (!sub || sub === "list") {
+      parseFlags(rest, {});
+      await cmdTimersList(cfg);
+    } else if (sub === "add") {
+      const { positional, flags } = parseFlags(rest, {
+        desc: "string",
+        days: "int",
+        anchor: "string",
+        tz: "string",
+        "skip-weekends": "boolean"
+      });
+      if (!positional[0] || !positional[1]) {
+        console.error("Usage: autonag timers add <name> <expiry> [--desc <text>] [--days <n>] [--anchor <HH:MM>] [--tz <tz>] [--skip-weekends]");
+        process.exit(1);
+      }
+      await cmdTimersAdd(positional[0], positional[1], cfg, {
+        desc: flags.desc,
+        days: flags.days,
+        anchor: flags.anchor,
+        tz: flags.tz,
+        skipWeekends: flags["skip-weekends"] === true
+      });
+    } else if (sub === "rename") {
+      const { positional } = parseFlags(rest, {});
+      if (!positional[0] || !positional[1]) {
+        console.error("Usage: autonag timers rename <id> <name>");
+        process.exit(1);
+      }
+      await cmdTimersRename(positional[0], positional[1], cfg);
+    } else if (sub === "snooze") {
+      const { positional } = parseFlags(rest, {});
+      if (!positional[0] || !positional[1]) {
+        console.error("Usage: autonag timers snooze <id> <expiry>");
+        process.exit(1);
+      }
+      await cmdTimersSnooze(positional[0], positional[1], cfg);
+    } else if (sub === "complete") {
+      const { positional } = parseFlags(rest, {});
+      if (!positional[0] || !positional[1]) {
+        console.error("Usage: autonag timers complete <id> <reason>");
+        process.exit(1);
+      }
+      await cmdTimersComplete(positional[0], positional[1], cfg);
+    } else if (sub === "remove") {
+      const { positional } = parseFlags(rest, {});
+      if (!positional[0]) {
+        console.error("Usage: autonag timers remove <id>");
+        process.exit(1);
+      }
+      await cmdTimersRemove(positional[0], cfg);
+    } else if (sub === "describe") {
+      const { positional } = parseFlags(rest, {});
+      if (!positional[0] || !positional[1]) {
+        console.error("Usage: autonag timers describe <id> <text>");
+        process.exit(1);
+      }
+      await cmdTimersDescribe(positional[0], positional[1], cfg);
+    } else if (sub === "recurrence") {
+      const recSub = rest[0];
+      if (recSub === "set") {
+        const { positional, flags } = parseFlags(rest, { anchor: "string", tz: "string", "skip-weekends": "boolean" });
+        if (!positional[1] || !positional[2]) {
+          console.error("Usage: autonag timers recurrence set <id> <days> [--anchor <HH:MM>] [--tz <tz>] [--skip-weekends]");
+          process.exit(1);
+        }
+        const days = Number(positional[2]);
+        if (!Number.isInteger(days) || days <= 0) {
+          console.error(`<days> must be a positive integer, got: "${positional[2]}"`);
+          process.exit(1);
+        }
+        await cmdTimersRecurrenceSet(positional[1], days, cfg, {
+          anchor: flags.anchor,
+          tz: flags.tz,
+          skipWeekends: flags["skip-weekends"] === true
+        });
+      } else if (recSub === "remove") {
+        const { positional } = parseFlags(rest, {});
+        if (!positional[1]) {
+          console.error("Usage: autonag timers recurrence remove <id>");
+          process.exit(1);
+        }
+        await cmdTimersRecurrenceRemove(positional[1], cfg);
+      } else {
+        console.error("Usage: autonag timers recurrence set|remove ...");
+        process.exit(1);
+      }
+    } else if (sub === "history") {
+      const { positional } = parseFlags(rest, {});
+      if (!positional[0]) {
+        console.error("Usage: autonag timers history <id>");
+        process.exit(1);
+      }
+      await cmdTimersHistory(positional[0], cfg);
+    } else {
+      console.error(`Unknown subcommand: timers ${sub}`);
+      process.exit(1);
+    }
+  } else if (cmd === "alarm") {
+    if (sub !== "show") {
+      console.error("Usage: autonag alarm show");
+      process.exit(1);
+    }
+    parseFlags(rest, {});
+    await cmdAlarm(cfg);
+  } else if (cmd === "shush") {
+    parseFlags(rest, {});
+    await cmdShush(sub, cfg);
+  } else if (cmd === "unshush") {
+    parseFlags(rest, {});
+    await cmdUnshush(cfg);
+  } else if (cmd === "events") {
+    if (!sub || sub === "list") {
+      const { flags } = parseFlags(rest, { from: "int" });
+      await cmdEventsList(flags.from ?? 1, cfg);
+    } else if (sub === "skip") {
+      const { positional } = parseFlags(rest, {});
+      if (!positional[0]) {
+        console.error("Usage: autonag events skip <id>");
+        process.exit(1);
+      }
+      await cmdEventsSkip(positional[0], cfg);
+    } else if (sub === "unskip") {
+      const { positional } = parseFlags(rest, {});
+      if (!positional[0]) {
+        console.error("Usage: autonag events unskip <id>");
+        process.exit(1);
+      }
+      await cmdEventsUnskip(positional[0], cfg);
+    } else {
+      console.error(`Unknown subcommand: events ${sub}`);
+      process.exit(1);
+    }
+  } else if (cmd === "comments") {
+    if (!sub || sub === "list") {
+      const { positional } = parseFlags(rest, {});
+      if (!positional[0]) {
+        console.error("Usage: autonag comments list <timerId>");
+        process.exit(1);
+      }
+      await cmdCommentsList(positional[0], cfg);
+    } else if (sub === "add") {
+      const { positional } = parseFlags(rest, {});
+      if (!positional[0] || !positional[1]) {
+        console.error("Usage: autonag comments add <timerId> <text>");
+        process.exit(1);
+      }
+      await cmdCommentsAdd(positional[0], positional[1], cfg);
+    } else {
+      console.error(`Unknown subcommand: comments ${sub}`);
+      process.exit(1);
+    }
+  } else {
+    console.error(`Unknown command: ${cmd}`);
+    console.error(`Run "autonag --help" for usage.`);
+    process.exit(1);
+  }
+} catch (e) {
+  if (e instanceof ApiError) {
+    console.error(`Error: ${e.message}`);
+    process.exit(1);
+  }
+  throw e;
+}
+//# sourceMappingURL=cli.js.map