dsh-offwork 1.1.1 → 1.2.2

package/tests/host.test.mjs

@@ -4,6 +4,7 @@ import { mkdtemp, readFile, writeFile, stat, readdir, rm } from 'node:fs/promise
 import { tmpdir } from 'node:os';
 import { join, resolve, dirname, basename } from 'node:path';
 import { pathToFileURL } from 'node:url';
+import { createSettingsAccess } from '../settings-api.js';
 import { createOperations, DEFAULT_SETTINGS, validateSettings } from '../index.js';
 
 const source = new URL('../index.js', import.meta.url);
@@ -148,31 +149,43 @@ async function adapters(t) {
   // and neither adapter can accidentally reach the user's actual data.json.
   const moduleFile = join(fixtureData.dir, 'host.mjs');
   await writeFile(moduleFile, await readFile(source, 'utf8'));
+  await writeFile(join(fixtureData.dir, 'package.json'), '{"type":"module"}');
+  for (const name of ['media-server.js', 'media-manifest.js', 'settings-api.js'])
+    await writeFile(
+      join(fixtureData.dir, name),
+      await readFile(new URL('../' + name, import.meta.url)),
+    );
   const module = await import(pathToFileURL(moduleFile).href);
   let command;
   let tool;
-  module.apply({
-    effect: (effect) => effect(),
-    commands: {
-      register(definition) {
-        command = definition;
-        return () => {};
+  const access = createSettingsAccess(fixtureData.dir);
+  await access.set(true);
+  module.installOperations(
+    {
+      effect: (effect) => effect(),
+      commands: {
+        register(definition) {
+          command = definition;
+          return () => {};
+        },
       },
-    },
-    tools: {
-      register(definition) {
-        tool = definition;
-        return () => {};
+      tools: {
+        register(definition) {
+          tool = definition;
+          return () => {};
+        },
       },
     },
-  });
+    fixtureData.operate,
+    access,
+  );
   const runCommand = async (rawInput) => {
     const response = await command.handler({ rawInput });
     const result = JSON.parse(response.text);
     assert.equal(response.kind, result.ok ? 'success' : 'error');
     return result;
   };
-  return { ...fixtureData, tool, command, runCommand };
+  return { ...fixtureData, tool, command, runCommand, access };
 }
 
 test('command and tool share results, validation, storage and a write queue', async (t) => {

package/tests/hydration-extras.test.mjs

@@ -4,223 +4,187 @@ import { calculate } from '../clock.js';
 import {
   defaultHydration,
   validateHydration,
-  hydrationContext,
+  migrateHydration,
   hydrationView,
   transitionHydration,
   HYDRATION_ACTION_LIMIT,
 } from '../hydration.js';
-
-const settings = {
-  payMode: 'monthly',
-  monthlySalary: 12000,
-  workdaysPerMonth: 20,
-  start: '09:00',
-  end: '18:00',
-  breakStart: '12:00',
-  breakEnd: '13:00',
-  weekdays: [1, 2, 3, 4, 5],
-  timezone: 'Asia/Shanghai',
+const time = (value) => Date.parse(value.includes('T') ? value : `2026-11-06T${value}:00+08:00`);
+const act = (state, at, action) => transitionHydration(state, action, time(at), 'a');
+const view = (state, at) => hydrationView(state, time(at));
+const enable = (at = '09:00', interval = 60) =>
+  act(defaultHydration(), at, { type: 'preferences', enabled: true, interval });
+const legacy = (at = '09:00', schema = 2) => {
+  const settings = {
+    timezone: 'Asia/Shanghai',
+    start: '09:00',
+    end: '18:00',
+    breakStart: '12:00',
+    breakEnd: '13:00',
+    weekdays: [1, 2, 3, 4, 5],
+    payMode: 'daily',
+    dailySalary: 1,
+  };
+  const clock = calculate(settings, time(at));
+  return {
+    schema,
+    revision: 12,
+    enabled: true,
+    interval: 60,
+    shift: {
+      id: JSON.stringify([settings.timezone, clock.shiftDate]),
+      config: JSON.stringify([
+        settings.timezone,
+        settings.start,
+        settings.end,
+        settings.breakStart,
+        settings.breakEnd,
+        settings.weekdays,
+      ]),
+      schedule: JSON.stringify([
+        settings.start,
+        settings.end,
+        settings.breakStart,
+        settings.breakEnd,
+        settings.weekdays,
+        clock.shiftStart,
+        clock.shiftEnd,
+      ]),
+      count: 7,
+      paused: false,
+      due: clock.elapsed * 1000 + 3600000,
+      sequence: 3,
+      claim: { owner: 'old', until: time(at) + 8000, sequence: 3 },
+      ...(schema === 2 ? { quietUntil: 0, recentActions: ['old-drink'] } : {}),
+    },
+  };
 };
-const time = (text) => Date.parse(text.includes('T') ? text : `2026-11-04T${text}:00+08:00`);
-const context = (text, patch = {}) => {
-  const config = { ...settings, ...patch };
-  return hydrationContext(config, calculate(config, time(text)));
-};
-const act = (s, at, a, patch = {}, owner = 'a') =>
-  transitionHydration(s, context(at, patch), a, time(at), owner);
-const view = (s, at, patch = {}) => hydrationView(s, context(at, patch), time(at));
-const enabled = (at = '09:00', interval = 60, patch = {}) =>
-  act(defaultHydration(), at, { type: 'preferences', enabled: true, interval }, patch);
-const manual = (at, id, patch = {}, extra = {}) => ({
-  type: 'manual-drink',
-  actionId: id,
-  shiftId: context(at, patch).id,
-  ...extra,
-});
-
-test('manual check-in restarts an enabled timer and retries are idempotent', () => {
-  const initial = enabled();
-  const action = manual('09:40', 'glass-1');
-  const next = act(initial, '09:40', action);
-  assert.equal(next.shift.count, 1);
-  assert.equal(view(next, '09:40').remaining, 3600000);
-  assert.deepEqual(act(next, '09:45', action), next);
-  assert.equal(initial.shift.count, 0);
-});
-
-test('manual check-ins work with reminders off, preserve pause, and ignore off-hours', () => {
-  let state = act(defaultHydration(), '10:00', manual('10:00', 'off'));
-  assert.equal(state.enabled, false);
-  assert.equal(state.shift.count, 1);
-  state = act(state, '10:00', { type: 'preferences', enabled: true });
-  state = act(state, '10:10', { type: 'pause' });
-  const due = state.shift.due;
-  state = act(state, '10:20', manual('10:20', 'paused'));
-  assert.equal(state.shift.count, 2);
-  assert.equal(state.shift.paused, true);
-  assert.equal(state.shift.due, due);
-  for (const at of ['08:00', '18:00', '2026-11-07T10:00:00+08:00']) {
-    const result = act(defaultHydration(), at, manual(at, at));
-    assert.equal(result.shift, null);
+test('manual drinking is available before work, at lunch, after work and on days off without a schedule', () => {
+  for (const at of ['08:00', '12:30', '20:00', '2026-11-07T10:00:00+08:00']) {
+    const result = act(defaultHydration(), at, { type: 'manual-drink', actionId: at });
+    assert.equal(result.count, 1);
+    assert.equal(result.enabled, false);
+    assert.equal(result.dueAt, 0);
   }
 });
-
-test('lunch check-in starts a full working interval after lunch', () => {
-  const state = act(enabled('11:00', 5), '12:30', manual('12:30', 'lunch'));
-  assert.equal(state.shift.count, 1);
-  assert.equal(view(state, '12:59').phase, 'break');
-  assert.equal(view(state, '13:00').remaining, 300000);
-  assert.equal(view(state, '13:05').phase, 'due');
-});
-
-test('manual and prompted confirmation of the same due event count once in either order', () => {
-  const initial = act(enabled(), '10:00', { type: 'claim' });
+test('manual retries deduplicate and successful records reset only an enabled, unpaused timer', () => {
+  const action = { type: 'manual-drink', actionId: 'cup' };
+  const first = act(enable(), '09:15', action);
+  assert.equal(first.dueAt, time('10:15'));
+  assert.deepEqual(act(first, '09:20', action), first);
+  const paused = act(first, '09:21', { type: 'pause' });
+  const second = act(paused, '20:00', { type: 'manual-drink', actionId: 'next' });
+  assert.equal(second.count, 2);
+  assert.equal(second.paused, true);
+  assert.equal(second.dueAt, paused.dueAt);
+});
+test('manual and prompted acknowledgments of the same overdue event count once in either order', () => {
+  const initial = act(enable(), '10:00', { type: 'claim' });
   const eventId = view(initial, '10:00').eventId;
-  const actions = [manual('10:00', 'due', {}, { eventId }), { type: 'drink', eventId }];
+  const actions = [
+    { type: 'manual-drink', actionId: 'same', eventId },
+    { type: 'drink', eventId },
+  ];
   for (const order of [actions, [...actions].reverse()]) {
-    let state = initial;
-    for (const action of order) state = act(state, '10:00', action);
-    assert.equal(state.shift.count, 1);
-    assert.equal(state.shift.claim, null);
+    const result = order.reduce((s, a) => act(s, '10:00', a), initial);
+    assert.equal(result.count, 1);
+    assert.equal(result.claim, null);
   }
 });
-
-test('manual request IDs are bounded, distinct records count, and old-shift retries cannot count tomorrow', () => {
-  let state = enabled();
+test('recent action IDs are bounded and persist across calendar dates', () => {
+  let state = defaultHydration();
   for (let i = 0; i < HYDRATION_ACTION_LIMIT + 3; i++)
-    state = act(state, '09:10', manual('09:10', String(i)));
-  assert.equal(state.shift.count, HYDRATION_ACTION_LIMIT + 3);
-  assert.equal(state.shift.recentActions.length, HYDRATION_ACTION_LIMIT);
-  assert.equal(validateHydration(state).shift.count, state.shift.count);
-  const tomorrow = act(state, '2026-11-05T09:10:00+08:00', manual('09:10', 'old'));
-  assert.equal(tomorrow.shift.count, 0);
-});
-
-test('quiet time suppresses a due prompt, keeps its work deadline, and resumes once at expiry', () => {
-  let state = act(enabled('09:00', 5), '09:05', { type: 'claim' });
-  const oldEvent = view(state, '09:05').eventId;
-  const due = state.shift.due;
-  state = act(state, '09:05', { type: 'quiet', minutes: 30 });
-  assert.equal(state.shift.due, due);
-  assert.equal(state.shift.claim, null);
-  assert.equal(view(state, '09:34').phase, 'quiet');
-  assert.equal(view(state, '09:34').quietRemaining, 60000);
-  assert.equal(act(state, '09:10', { type: 'claim' }).shift.claim, null);
-  assert.equal(act(state, '09:10', { type: 'drink', eventId: oldEvent }).shift.count, 0);
-  assert.equal(view(state, '09:35').phase, 'due');
-  const resumed = act(state, '09:35', { type: 'claim' });
-  assert.equal(resumed.shift.quietUntil, 0);
-  assert.equal(resumed.shift.claim.owner, 'a');
-  assert.equal(view(resumed, '10:30').eventId, view(resumed, '09:35').eventId);
-});
-
-test('quiet time uses natural minutes across lunch and never prompts during lunch', () => {
-  let state = act(enabled('11:00', 5), '11:50', { type: 'quiet', minutes: 30 });
-  assert.equal(view(state, '12:10').quietRemaining, 600000);
-  assert.equal(view(state, '12:20').phase, 'break');
-  assert.equal(view(state, '13:00').phase, 'due');
-  state = act(state, '12:30', manual('12:30', 'lunch-quiet'));
-  assert.equal(view(state, '13:00').remaining, 300000);
-});
-
-test('manual and quiet actions commute and a check-in does not end quiet time', () => {
-  const actions = [manual('09:10', 'concurrent'), { type: 'quiet', minutes: 30 }];
-  for (const order of [actions, [...actions].reverse()]) {
-    let state = enabled('09:00', 5);
-    for (const a of order) state = act(state, '09:10', a);
-    assert.equal(state.shift.count, 1);
-    assert.equal(state.shift.quietUntil, time('09:40'));
-    assert.equal(state.shift.due, context('09:15').elapsed);
-    assert.equal(view(state, '09:14').phase, 'quiet');
+    state = act(state, '21:00', { type: 'manual-drink', actionId: 'cup-' + i });
+  assert.equal(state.count, HYDRATION_ACTION_LIMIT + 3);
+  assert.equal(state.recentActions.length, HYDRATION_ACTION_LIMIT);
+  const tomorrow = act(state, '2026-11-07T10:00:00+08:00', { type: 'tick' });
+  assert.deepEqual(tomorrow, state);
+});
+test('quiet time does not end at the end of a work shift or at midnight', () => {
+  for (const [at, end] of [
+    ['17:50', '18:50'],
+    ['23:50', '2026-11-07T00:50:00+08:00'],
+  ]) {
+    const state = act(enable(at, 5), at, { type: 'quiet', minutes: 60 });
+    assert.equal(state.quietUntil, time(end));
+    assert.equal(view(state, new Date(time(end) - 60000).toISOString()).phase, 'quiet');
+    assert.equal(view(state, end).phase, 'due');
   }
 });
-
-test('quiet duration replaces instead of adding, and can be ended early', () => {
-  let state = act(enabled(), '09:05', { type: 'quiet', minutes: 30 });
-  state = act(state, '09:10', { type: 'quiet', minutes: 60 });
-  assert.equal(state.shift.quietUntil, time('10:10'));
-  state = act(state, '09:20', { type: 'end-quiet' });
-  assert.equal(view(state, '09:20').phase, 'countdown');
-  assert.equal(state.shift.due, 3600000);
-  for (const minutes of [0, 10, 31, 90])
-    assert.throws(() => act(enabled(), '09:10', { type: 'quiet', minutes }));
-});
-
-test('pause and disable clear quiet time, expiry never cancels a full-shift pause', () => {
-  const quiet = act(enabled(), '09:05', { type: 'quiet', minutes: 60 });
-  const paused = act(quiet, '09:10', { type: 'pause' });
-  assert.equal(paused.shift.quietUntil, 0);
-  assert.equal(view(paused, '11:00').phase, 'paused');
-  assert.equal(act(paused, '09:15', { type: 'quiet', minutes: 30 }).shift.quietUntil, 0);
-  const off = act(quiet, '09:10', { type: 'preferences', enabled: false });
-  assert.equal(off.shift.quietUntil, 0);
-  const resumed = act(paused, '09:20', { type: 'resume' });
-  assert.equal(view(resumed, '09:20').remaining, 3600000);
-});
-
-test('quiet mode ends at shift end and does not leak into another shift, including overnight', () => {
-  let state = act(enabled('17:00', 5), '17:50', { type: 'quiet', minutes: 60 });
-  assert.equal(state.shift.quietUntil, time('18:00'));
-  assert.equal(view(state, '18:00').phase, 'waiting');
-  state = act(state, '2026-11-05T09:00:00+08:00', { type: 'tick' });
-  assert.equal(state.shift.quietUntil, 0);
-  const night = { start: '22:00', end: '06:00', breakStart: '02:00', breakEnd: '03:00' };
-  let overnight = enabled('2026-11-04T22:00:00+08:00', 5, night);
-  overnight = act(overnight, '2026-11-04T23:50:00+08:00', { type: 'quiet', minutes: 30 }, night);
-  assert.equal(view(overnight, '2026-11-05T00:10:00+08:00', night).quietRemaining, 600000);
-  assert.equal(view(overnight, '2026-11-05T00:20:00+08:00', night).phase, 'due');
-});
-
-test('same-shift schedule edits preserve quiet intent, clamp to new end and reject stale manual changes', () => {
-  const state = act(enabled('17:00', 5), '17:05', { type: 'quiet', minutes: 30 });
-  const patch = { end: '17:20' };
-  const updated = act(state, '17:10', { type: 'tick', baseSchedule: state.shift.schedule }, patch);
-  assert.equal(updated.shift.quietUntil, time('17:20'));
-  assert.deepEqual(act(updated, '17:11', manual('17:11', 'stale')), updated);
-  assert.deepEqual(act(updated, '17:11', { type: 'quiet', minutes: 60 }), updated);
-});
-
-test('schema 1 migrates with preferences, count, pause and due intact while revoking the lease', () => {
-  const legacy = act(enabled('09:00', 5), '09:05', { type: 'claim' });
-  legacy.schema = 1;
-  legacy.shift.count = 7;
-  legacy.shift.paused = true;
-  delete legacy.shift.quietUntil;
-  delete legacy.shift.recentActions;
-  const upgraded = validateHydration(legacy);
-  assert.equal(upgraded.schema, 2);
-  assert.equal(upgraded.interval, 5);
-  assert.equal(upgraded.shift.count, 7);
-  assert.equal(upgraded.shift.paused, true);
-  assert.equal(upgraded.shift.due, legacy.shift.due);
-  assert.equal(upgraded.shift.claim, null);
-  assert.equal(upgraded.shift.sequence, legacy.shift.sequence + 1);
-  assert.equal(upgraded.shift.quietUntil, 0);
-  assert.deepEqual(upgraded.shift.recentActions, []);
-  assert.deepEqual(validateHydration(upgraded), upgraded);
-});
-
-test('stale pause and resume actions do not postpone a timer or pause disabled reminders', () => {
-  let state = act(enabled(), '09:10', { type: 'pause' });
-  state = act(state, '09:20', { type: 'resume' });
-  assert.deepEqual(act(state, '09:30', { type: 'resume' }), state);
-  state = act(state, '09:30', { type: 'preferences', enabled: false });
-  assert.deepEqual(act(state, '09:40', { type: 'pause' }), state);
-});
-
-test('malformed new fields and malformed legacy data are rejected', () => {
+test('quiet operations invalidate old reminders; a successful drink keeps the chosen quiet deadline', () => {
+  let state = act(enable(), '10:00', { type: 'claim' });
+  const eventId = view(state, '10:00').eventId;
+  state = act(state, '10:00', { type: 'quiet', minutes: 30 });
+  assert.equal(state.claim, null);
+  assert.equal(act(state, '10:01', { type: 'drink', eventId }).count, 0);
+  state = act(state, '10:10', { type: 'manual-drink', actionId: 'quiet-cup' });
+  assert.equal(state.count, 1);
+  assert.equal(state.quietUntil, time('10:30'));
+  assert.equal(state.dueAt, time('11:10'));
+  const ended = act(state, '10:11', { type: 'end-quiet' });
+  assert.equal(ended.quietUntil, 0);
+  assert.equal(ended.dueAt, state.dueAt);
+});
+test('pause and disable end quiet time, while resume starts a full interval', () => {
+  const state = act(enable(), '09:10', { type: 'quiet', minutes: 60 });
+  const paused = act(state, '09:20', { type: 'pause' });
+  assert.equal(paused.quietUntil, 0);
+  assert.equal(act(paused, '09:21', { type: 'quiet', minutes: 30 }).quietUntil, 0);
+  assert.equal(act(state, '09:20', { type: 'preferences', enabled: false }).quietUntil, 0);
+  assert.equal(act(paused, '22:00', { type: 'resume' }).dueAt, time('23:00'));
+  assert.throws(() => act(enable(), '09:00', { type: 'quiet', minutes: 20 }));
+});
+for (const schema of [1, 2])
+  test(`schema ${schema} migration retains preferences/count and converts a matching shift remainder once`, () => {
+    const old = legacy('09:00', schema),
+      snapshot = structuredClone(old);
+    const now = time('09:20');
+    const next = migrateHydration(old, now);
+    assert.equal(next.schema, 3);
+    assert.equal(next.count, 7);
+    assert.equal(next.enabled, true);
+    assert.equal(next.interval, 60);
+    assert.equal(next.dueAt, time('10:00'));
+    assert.equal(next.claim, null);
+    assert.ok(next.sequence > old.shift.sequence);
+    assert.deepEqual(next.recentActions, schema === 2 ? ['old-drink'] : []);
+    assert.deepEqual(old, snapshot);
+    assert.deepEqual(validateHydration(JSON.parse(JSON.stringify(next))), next);
+  });
+test('migration turns remaining paid minutes during lunch into natural minutes without losing quiet settings', () => {
+  const old = legacy('11:50');
+  old.shift.quietUntil = time('13:30');
+  const next = migrateHydration(old, time('12:20'));
+  assert.equal(next.dueAt, time('13:10'));
+  assert.equal(next.quietUntil, time('13:30'));
+  assert.equal(next.count, 7);
+});
+test('migration preserves an already-overdue event; old-day records and pause retain counts without guessing past drinks', () => {
+  assert.equal(migrateHydration(legacy(), time('10:30')).dueAt, time('10:30'));
+  const old = legacy();
+  old.shift.paused = true;
+  const paused = migrateHydration(old, time('2026-11-07T10:00:00+08:00'));
+  assert.equal(paused.paused, true);
+  assert.equal(paused.count, 7);
+  assert.equal(view(paused, '2026-11-07T10:00:00+08:00').phase, 'paused');
+  old.shift.paused = false;
+  const next = migrateHydration(old, time('2026-11-07T10:00:00+08:00'));
+  assert.equal(next.count, 7);
+  assert.equal(next.dueAt, time('2026-11-07T11:00:00+08:00'));
+});
+test('legacy malformed/future data is rejected; incomplete historical schedule text retains records with a full new interval', () => {
   for (const patch of [
-    { quietUntil: -1 },
-    { quietUntil: NaN },
-    { recentActions: null },
-    { recentActions: ['same', 'same'] },
-    { recentActions: Array.from({ length: 65 }, (_, i) => String(i)) },
-  ]) {
-    const state = enabled();
-    Object.assign(state.shift, patch);
-    assert.throws(() => validateHydration(state));
-  }
-  const legacy = enabled();
-  legacy.schema = 1;
-  assert.throws(() => validateHydration(legacy));
+    { schema: 99 },
+    { revision: -1 },
+    { interval: 1 },
+    { enabled: 0 },
+    { shift: {} },
+    { other: true },
+  ])
+    assert.throws(() => migrateHydration({ ...legacy(), ...patch }, time('09:00')));
+  const old = legacy();
+  old.shift.config = 'unavailable old schedule';
+  const next = migrateHydration(old, time('09:20'));
+  assert.equal(next.count, 7);
+  assert.equal(next.dueAt, time('10:20'));
 });