dsh-autorestart 0.3.6 → 0.6.0

package/lib/checkpoint.js

@@ -105,6 +105,8 @@ const TOP_LEVEL_KEYS = new Set([
   'sessions',
   'parkedGoals',
   'disarmedGoals',
+  'seenFeatureVersions',
+  'sleep',
   'updatedAt',
 ]);
 
@@ -172,6 +174,8 @@ export function createEmptyState(now = Date.now()) {
     phase: 'idle',
     restart: null,
     sessions: {},
+    seenFeatureVersions: {},
+    sleep: null,
     updatedAt: now,
   };
 }
@@ -277,6 +281,59 @@ function normalizeDisarmedGoals(raw) {
   return { disarmedGoals, changed };
 }
 
+/**
+ * Normalize the record of the feature announcements the user has already seen.
+ *
+ * The shape is `{ [feature]: version }`: the id of the feature and the version
+ * of the plugin that announced it. A record whose version is not a string is
+ * dropped — an unreadable record must never hide an announcement for ever,
+ * so a broken entry makes the announcement show up again instead.
+ *
+ * @param {unknown} raw
+ * @returns {{ seenFeatureVersions: Record<string, string>, changed: boolean }}
+ */
+function normalizeSeenFeatureVersions(raw) {
+  if (!isObject(raw)) {
+    return { seenFeatureVersions: {}, changed: raw !== null && raw !== undefined };
+  }
+  const seenFeatureVersions = {};
+  let changed = false;
+  for (const [feature, version] of Object.entries(raw)) {
+    if (typeof version !== 'string' || version === '') {
+      changed = true;
+      continue;
+    }
+    seenFeatureVersions[feature] = version;
+  }
+  return { seenFeatureVersions, changed };
+}
+
+/**
+ * Normalize the recorded shutdown intent.
+ *
+ * The intent is the user's "shut the machine down when the work is done" — it
+ * has to survive a restart, so it lives in the checkpoint file. A record that
+ * is broken is DROPPED: asking the user once more is much better than a
+ * machine that switches itself off for ever because of a half-written file.
+ *
+ * @param {unknown} raw
+ * @returns {{ sleep: { armed: true, armedAt: number, countdownSeconds: number|null }|null, changed: boolean }}
+ */
+function normalizeSleep(raw) {
+  if (raw == null) return { sleep: null, changed: false };
+  if (!isObject(raw)) return { sleep: null, changed: true };
+  if (raw.armed !== true) return { sleep: null, changed: true };
+  const armedAt = isFiniteNumber(raw.armedAt) ? raw.armedAt : null;
+  if (armedAt === null) return { sleep: null, changed: true };
+  const countdownSeconds = isFiniteNumber(raw.countdownSeconds) && raw.countdownSeconds >= 0
+    ? Math.trunc(raw.countdownSeconds)
+    : null;
+  return {
+    sleep: { armed: true, armedAt, countdownSeconds },
+    changed: raw.countdownSeconds !== countdownSeconds,
+  };
+}
+
 /**
  * Normalize the handoff record of a session: `{ handedOffTo, handoffAt, carriedChars }`.
  * A missing record stays `null`; a corrupt one is dropped instead of being thrown on.
@@ -536,6 +593,23 @@ export function normalizeState(raw, now = Date.now()) {
     if (disarmed.changed) repaired = true;
   }
 
+  // The record of the feature announcements the user has already seen. It
+  // survives a restart of the Host: an announcement that was shown once must
+  // not come back with the next boot.
+  if (raw.seenFeatureVersions != null) {
+    const seen = normalizeSeenFeatureVersions(raw.seenFeatureVersions);
+    state.seenFeatureVersions = seen.seenFeatureVersions;
+    if (seen.changed) repaired = true;
+  }
+
+  // The recorded shutdown intent: it has to survive a restart, so the machine
+  // goes off AFTER the restart and the work that resumed with it.
+  if (raw.sleep != null) {
+    const sleep = normalizeSleep(raw.sleep);
+    state.sleep = sleep.sleep;
+    if (sleep.changed) repaired = true;
+  }
+
   return { state, repaired };
 }
 
@@ -1197,6 +1271,48 @@ export function cancelRestart(state, { now = Date.now() } = {}) {
   return state;
 }
 
+/**
+ * Record the shutdown intent: "switch the machine off when the work is done".
+ *
+ * The intent lives in the checkpoint file, so it survives a restart: a
+ * shutdown that is asked for while a restart is pending waits for that
+ * restart (and for the sessions that resume with it) before the machine goes
+ * off.
+ *
+ * Mutates `state` in place and returns it.
+ *
+ * @param {object} state
+ * @param {{ armedAt?: number, countdownSeconds?: number|null }} [options]
+ * @returns {object} state
+ */
+export function armSleep(state, { armedAt = Date.now(), countdownSeconds = null } = {}) {
+  state.sleep = {
+    armed: true,
+    armedAt: isFiniteNumber(armedAt) ? armedAt : Date.now(),
+    countdownSeconds: isFiniteNumber(countdownSeconds) && countdownSeconds >= 0
+      ? Math.trunc(countdownSeconds)
+      : null,
+  };
+  state.updatedAt = state.sleep.armedAt;
+  return state;
+}
+
+/**
+ * Forget the shutdown intent: the machine stays on (or it already went off).
+ *
+ * Mutates `state` in place and returns it.
+ *
+ * @param {object} state
+ * @param {{ now?: number }} [options]
+ * @returns {object} state
+ */
+export function clearSleep(state, { now = Date.now() } = {}) {
+  if (state.sleep === null || state.sleep === undefined) return state;
+  state.sleep = null;
+  state.updatedAt = now;
+  return state;
+}
+
 /**
  * Set the lifecycle phase, ignoring unknown values.
  * Mutates `state` in place and returns it.