dsh-offwork 1.1.2 → 1.2.2

package/pet-interactions.js

@@ -1,5 +1,13 @@
 // Ephemeral UI navigation only. Business data stays in its existing stores.
-export const PET_EDITOR_SCREENS = ['water', 'schedule', 'appearance'];
+export const PET_EDITOR_SCREENS = [
+  'water',
+  'schedule',
+  'appearance',
+  'wrap',
+  'preferences',
+  'data',
+  'reminders',
+];
 export const initialPetUI = { screen: null, back: null, menu: null, pending: null };
 export function petUIReducer(state, action) {
   switch (action.type) {
@@ -32,11 +40,22 @@ export function petUIReducer(state, action) {
         };
       const back = action.root
         ? null
-        : PET_EDITOR_SCREENS.includes(action.screen)
-          ? PET_EDITOR_SCREENS.includes(state.screen)
-            ? state.back
-            : state.screen
-          : state.back;
+        : action.screen === state.back
+          ? null
+          : action.screen === 'data'
+            ? 'preferences'
+            : action.screen === 'wrap'
+              ? 'income'
+              : state.screen === 'preferences' &&
+                  ['schedule', 'water', 'appearance'].includes(action.screen)
+                ? 'preferences'
+                : action.screen === 'preferences'
+                  ? state.screen
+                  : PET_EDITOR_SCREENS.includes(action.screen)
+                    ? PET_EDITOR_SCREENS.includes(state.screen)
+                      ? state.back
+                      : state.screen
+                    : state.back;
       return { screen: action.screen, back, menu: null, pending: null };
     }
     default:
@@ -54,6 +73,11 @@ export function appearanceValues(view) {
 }
 export const PET_INTERACTION_MESSAGES = {
   zh: {
+    companionPreferencesTitle: '设置',
+    companionDataTitle: '备份与恢复',
+    companionWrapTitle: '今日收尾',
+    companionRemindersTitle: '待处理提醒',
+    quickMore: '更多',
     petHome: '喝水',
     petWaterCard: '喝水',
     waterCountdown: '喝水倒计时',
@@ -64,6 +88,7 @@ export const PET_INTERACTION_MESSAGES = {
     timerIdle: '未开始',
     timerRunning: '计时中',
     timerPaused: '已暂停',
+    timerSnoozed: '稍后提醒',
     timerDue: '已到时',
     timerStart: '开始计时',
     timerPause: '暂停计时',
@@ -85,8 +110,9 @@ export const PET_INTERACTION_MESSAGES = {
     timerFinished: '已结束',
     timerUnavailable: '暂不可用',
     petCountdownCard: '下班倒计时',
+    petCountdownBefore: '上班倒计时',
     petCountdownGroup: '计时概览',
-    petEarningsCard: '收入',
+    petEarningsCard: '收入明细',
     petWaterAlert: '查看喝水提醒',
     petPausedHint: '提醒已暂停，手动恢复后重新计时。',
     petMenu: '宠物菜单',
@@ -112,6 +138,11 @@ export const PET_INTERACTION_MESSAGES = {
     petDismissReminder: '收起提醒',
   },
   en: {
+    companionPreferencesTitle: 'Settings',
+    companionDataTitle: 'Backup and restore',
+    companionWrapTitle: 'Wrap up today',
+    companionRemindersTitle: 'Pending reminders',
+    quickMore: 'More',
     petHome: 'Water',
     petWaterCard: 'Water',
     waterCountdown: 'Water countdown',
@@ -122,6 +153,7 @@ export const PET_INTERACTION_MESSAGES = {
     timerIdle: 'Not started',
     timerRunning: 'Running',
     timerPaused: 'Paused',
+    timerSnoozed: 'Snoozed',
     timerDue: 'Time is up',
     timerStart: 'Start timer',
     timerPause: 'Pause timer',
@@ -144,8 +176,9 @@ export const PET_INTERACTION_MESSAGES = {
     timerFinished: 'Finished',
     timerUnavailable: 'Unavailable',
     petCountdownCard: 'Shift countdown',
+    petCountdownBefore: 'Until work starts',
     petCountdownGroup: 'Timer overview',
-    petEarningsCard: 'Earnings',
+    petEarningsCard: 'Earnings details',
     petWaterAlert: 'View water reminder',
     petPausedHint: 'Reminders paused. Resume manually to start a fresh interval.',
     petMenu: 'Pet menu',

package/pet-surfaces.js

@@ -175,7 +175,7 @@ export const PET_SURFACE_STYLE = `
 .owc-v2 .owc-pet-natural>.owc-form:last-child,.owc-v2 .owc-pet-natural>.owc-water-form:last-child{padding-bottom:0}
 .owc-v2 .owc-pet-scroll .owc-save{background:var(--owc-surface);padding:12px 0;border-top:1px solid var(--owc-border);gap:8px;flex-wrap:wrap}
 .owc-v2 .owc-save button{min-width:72px}
-.owc-v2 .owc-appearance-preview{height:260px;display:flex;align-items:center;justify-content:center;border-radius:12px;background:var(--owc-subtle);margin-bottom:16px;overflow:hidden}
+.owc-v2 .owc-appearance-preview{height:190px;display:flex;align-items:center;justify-content:center;border-radius:12px;background:var(--owc-subtle);margin-bottom:16px;overflow:hidden}
 .owc-v2 .owc-appearance-preview .owc-pet-art{flex:none;animation:none}
 .owc-v2 .owc-appearance-preview .owc-pet-art *{animation:none!important}
 .owc-v2 .owc-preview-actions{display:flex;gap:6px;flex-wrap:wrap}

package/pet-view.js

@@ -33,6 +33,8 @@ export const PET_MODELS = Object.freeze({
   'xiaoxie-original': { ...PET_MODEL, widthScale: 1, heightScale: 1.1, label: 'petDroplet' },
 });
 export function petModel(id) {
+  if (id === 'custom-image')
+    return { id, renderer: 'image', widthScale: 1.3125, heightScale: 1.75, label: 'petCharacter' };
   return Object.hasOwn(PET_MODELS, id) ? PET_MODELS[id] : PET_MODELS['whale-dress'];
 }
 

package/settings-api.js

@@ -0,0 +1,126 @@
+import { mkdir, readFile, writeFile, rename, unlink } from 'node:fs/promises';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+export const SETTINGS_ROUTE = '/offwork-clock/settings';
+export function createSettingsAccess(directory) {
+  const file = join(directory, 'agent-access.json');
+  let queue = Promise.resolve();
+  return {
+    async get() {
+      try {
+        const value = JSON.parse(await readFile(file, 'utf8'));
+        if (value.schema !== 1 || typeof value.allowed !== 'boolean')
+          throw new Error('Invalid access policy');
+        return value.allowed;
+      } catch (error) {
+        if (error.code === 'ENOENT') return false;
+        throw error;
+      }
+    },
+    set(allowed) {
+      const result = queue.then(async () => {
+        if (typeof allowed !== 'boolean') throw new Error('Invalid access policy');
+        await mkdir(directory, { recursive: true, mode: 0o700 });
+        const temp = join(directory, `.access-${randomUUID()}.tmp`);
+        try {
+          await writeFile(temp, JSON.stringify({ schema: 1, allowed }), {
+            mode: 0o600,
+            flag: 'wx',
+          });
+          await rename(temp, file);
+        } finally {
+          await unlink(temp).catch(() => {});
+        }
+        return allowed;
+      });
+      queue = result.catch(() => {});
+      return result;
+    },
+  };
+}
+
+// Served under the Harness host's existing access boundary. Never enables CORS.
+// A custom header is required even for GET; cross-origin browsers cannot send it
+// without a successful preflight. Same-site subdomains are not trusted.
+export function createSettingsHandler(operate, access, authorize = () => 401) {
+  return async (req, res) => {
+    const send = (status, body) => {
+      if (res.destroyed || res.writableEnded) return;
+      res.writeHead(status, {
+        'Content-Type': 'application/json; charset=utf-8',
+        'Cache-Control': 'no-store',
+        'X-Content-Type-Options': 'nosniff',
+      });
+      res.end(JSON.stringify(body));
+    };
+    if (!['GET', 'POST'].includes(req.method))
+      return send(405, { ok: false, error: 'Method not allowed' });
+    const site = req.headers['sec-fetch-site'];
+    let originOK = true;
+    if (req.headers.origin) {
+      try {
+        originOK = new URL(req.headers.origin).host === req.headers.host;
+      } catch {
+        originOK = false;
+      }
+    }
+    if (
+      req.headers['x-offwork-client'] !== '1' ||
+      (site && !['same-origin', 'none'].includes(site)) ||
+      !originOK
+    )
+      return send(403, { ok: false, error: 'Same-origin client required' });
+    const rejection = authorize(req);
+    if (rejection) return send(rejection, { ok: false, error: 'Authenticated owner required' });
+    try {
+      if (req.method === 'GET') {
+        const result = await operate('get');
+        return send(result.ok ? 200 : 422, { ...result, agentAccess: await access.get() });
+      }
+      if (!/^application\/json(?:;|$)/i.test(req.headers['content-type'] || ''))
+        return send(415, { ok: false, error: 'JSON required' });
+      const chunks = [];
+      let size = 0;
+      for await (const chunk of req) {
+        size += chunk.length;
+        if (size > 16384) return send(413, { ok: false, error: 'Request too large' });
+        chunks.push(chunk);
+      }
+      const body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+      if (!body || typeof body !== 'object' || Array.isArray(body))
+        throw new Error('Invalid request');
+      if (body.action === 'access') {
+        if (Object.keys(body).some((k) => !['action', 'allowed'].includes(k)))
+          throw new Error('Unknown field');
+        return send(200, { ok: true, agentAccess: await access.set(body.allowed) });
+      }
+      if (
+        body.action !== 'set' ||
+        Object.keys(body).some((k) => !['action', 'settings'].includes(k))
+      )
+        throw new Error('Invalid action');
+      const result = await operate('set', body.settings);
+      send(result.ok ? 200 : 422, result);
+    } catch {
+      send(400, {
+        ok: false,
+        error: '无法读取或保存设置，请检查配置和访问权限。 / Unable to read or save settings.',
+      });
+    }
+  };
+}
+export function registerSettingsRoute(ctx, operate, access) {
+  ctx.inject?.(['webServer', 'connection'], (webCtx) => {
+    const authorize = (request) => {
+      if (typeof webCtx.connection?.admit !== 'function') return 503;
+      const admission = webCtx.connection.admit(request);
+      if ('rejection' in admission) return admission.rejection;
+      return admission.peer.principal.kind === 'owner' ? undefined : 403;
+    };
+    const handler = createSettingsHandler(operate, access, authorize);
+    webCtx.effect(() =>
+      webCtx.webServer.register({ kind: 'exact', path: SETTINGS_ROUTE, handler }),
+    );
+  });
+}

package/tests/companion-state.test.mjs

@@ -0,0 +1,267 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { IDBFactory } from 'fake-indexeddb';
+import { defaultCountdown, transitionCountdown } from '../countdown.js';
+import { defaultHydration, transitionHydration } from '../hydration.js';
+import { createStateStore } from '../hydration-store.js';
+import {
+  defaultCompanionState,
+  validateCompanionState,
+  companionEvents,
+  companionPending,
+  companionTransition,
+  reconcileCompanion,
+  companionDaySummary,
+  validateBrowserBackup,
+  companionBackupStamp,
+  companionStateStamp,
+  createCompanionRecoveryStore,
+} from '../companion-state.js';
+const at = Date.parse('2026-11-12T09:00:00Z');
+const event = { id: 'smoking:1', kind: 'smoking', label: 'Smoking', dueAt: at };
+const fresh = () => reconcileCompanion(defaultCompanionState(), [event], at);
+
+test('closing, snoozing and quiet mode have distinct persistent semantics', () => {
+  let state = fresh();
+  state = companionTransition(state, { type: 'dismiss', id: event.id }, at);
+  assert.equal(companionPending(state, [event], at).length, 0);
+  assert.equal(state.deliveries[event.id].dueAt, at);
+  state = companionTransition(state, { type: 'snooze', id: event.id }, at);
+  assert.equal(companionPending(state, [event], at + 599999).length, 0);
+  assert.equal(companionPending(state, [event], at + 600000).length, 1);
+  state = companionTransition(
+    state,
+    { type: 'preferences', patch: { quietUntil: at + 700000 } },
+    at,
+  );
+  assert.equal(companionPending(state, [event], at + 600000).length, 0);
+  assert.equal(companionPending(state, [event], at + 700000).length, 1);
+});
+test('only one tab owns a reminder; lease can recover after a crash', async () => {
+  const idb = new IDBFactory();
+  const stores = ['a', 'b'].map(() =>
+    createStateStore(idb, 'race', defaultCompanionState, validateCompanionState),
+  );
+  await stores[0].update(() => fresh());
+  const winners = [];
+  await Promise.all(
+    stores.map((s, i) =>
+      s.update((value) => {
+        const next = companionTransition(
+          value,
+          { type: 'claim', id: event.id, owner: String(i) },
+          at,
+        );
+        if (next.deliveries[event.id].owner === String(i)) winners.push(i);
+        return next;
+      }),
+    ),
+  );
+  assert.equal(winners.length, 1);
+  const loser = String(1 - winners[0]);
+  const next = await stores[1].update((s) =>
+    companionTransition(s, { type: 'claim', id: event.id, owner: loser }, at + 8000),
+  );
+  assert.equal(next.deliveries[event.id].owner, loser);
+  stores.forEach((s) => s.close());
+});
+test('notification claims are atomic across tabs and snooze permits one new notification', async () => {
+  const idb = new IDBFactory();
+  const a = createStateStore(idb, 'notification', defaultCompanionState, validateCompanionState),
+    b = createStateStore(idb, 'notification', defaultCompanionState, validateCompanionState);
+  await a.update(() => fresh());
+  let sent = 0;
+  await Promise.all(
+    [a, b].map((store) =>
+      store.update((s) => {
+        if (!s.deliveries[event.id].notifiedAt) sent++;
+        return companionTransition(s, { type: 'notify', id: event.id }, at);
+      }),
+    ),
+  );
+  assert.equal(sent, 1);
+  let state = await a.update((s) => companionTransition(s, { type: 'snooze', id: event.id }, at));
+  assert.equal(state.deliveries[event.id].notifiedAt, 0);
+  state = companionTransition(state, { type: 'notify', id: event.id }, at + 1);
+  assert.equal(state.deliveries[event.id].notifiedAt, 0);
+  a.close();
+  b.close();
+});
+test('legacy water/smoking clocks are observed without modifying them', () => {
+  let smoking = transitionCountdown(defaultCountdown(), { type: 'start' }, at - 3600000);
+  let water = transitionHydration(
+    defaultHydration(),
+    { type: 'preferences', enabled: true, interval: 5 },
+    at - 300000,
+    'test',
+  );
+  const before = JSON.stringify({ smoking, water });
+  const events = companionEvents(
+    defaultCompanionState(),
+    { smoking, water, smokingReady: true, waterReady: true },
+    at,
+  );
+  assert.deepEqual(events.map((e) => e.kind).sort(), ['smoking', 'water']);
+  assert.equal(JSON.stringify({ smoking, water }), before);
+  water.claim = { owner: 'older-client', until: at + 8000, sequence: water.sequence };
+  assert.equal(
+    companionEvents(
+      defaultCompanionState(),
+      { water, waterReady: true, waterOwner: 'new-client' },
+      at,
+    ).length,
+    0,
+  );
+  assert.equal(
+    companionEvents(
+      defaultCompanionState(),
+      { water, waterReady: true, waterOwner: 'new-client' },
+      at + 8000,
+    ).length,
+    1,
+  );
+});
+test('wrap-up completion suppresses this shift only and leaves water/custom clocks intact', () => {
+  let state = defaultCompanionState();
+  state.preferences.wrapEnabled = true;
+  const shift = {
+    isWorkday: true,
+    shiftDate: '2026-11-12',
+    shiftStart: at - 3600000,
+    shiftEnd: at + 300000,
+  };
+  const inputs = { shift };
+  assert.equal(companionEvents(state, inputs, at).length, 1);
+  state = companionTransition(
+    state,
+    {
+      type: 'journal',
+      date: shift.shiftDate,
+      done: 'One change',
+      next: 'Review',
+      base: 0,
+      end: true,
+    },
+    at,
+  );
+  assert.equal(companionEvents(state, inputs, at).length, 0);
+  assert.equal(state.preferences.wrapEnabled, true);
+  assert.equal(
+    companionEvents(state, { shift: { ...shift, shiftDate: '2026-11-13' } }, at).length,
+    1,
+  );
+  assert.equal(companionEvents(state, { shift: { ...shift, isWorkday: false } }, at).length, 0);
+});
+test('notes reject a stale tab and repeating end does not duplicate history', () => {
+  let s = companionTransition(
+    defaultCompanionState(),
+    { type: 'journal', date: '2026-11-12', done: 'A', next: 'B', base: 0, end: true },
+    at,
+  );
+  assert.throws(
+    () =>
+      companionTransition(
+        s,
+        { type: 'journal', date: '2026-11-12', done: 'stale', next: '', base: 0, end: false },
+        at + 1,
+      ),
+    /another tab/,
+  );
+  s = companionTransition(
+    s,
+    { type: 'journal', date: '2026-11-12', done: 'A2', next: 'B', base: at, end: true },
+    at + 1,
+  );
+  assert.equal(s.history.length, 1);
+});
+test('custom timers are independent and actions reject stale per-timer revisions', () => {
+  let s = defaultCompanionState();
+  for (const id of ['tea', 'rest'])
+    s = companionTransition(s, { type: 'add-timer', id, name: id, minutes: 5 }, at);
+  s = companionTransition(
+    s,
+    { type: 'timer', id: 'tea', revision: 0, operation: { type: 'start' } },
+    at,
+  );
+  assert.equal(s.timers[1].clock.status, 'idle');
+  assert.throws(
+    () =>
+      companionTransition(
+        s,
+        { type: 'timer', id: 'tea', revision: 0, operation: { type: 'stop' } },
+        at,
+      ),
+    /changed/,
+  );
+  assert.equal(companionEvents(s, {}, at + 300000)[0].timerId, 'tea');
+});
+test('restore validates data, requires current revision, and resets permissions and leases', () => {
+  let s = fresh();
+  s.revision = 8;
+  const backup = fresh();
+  backup.preferences.sound = true;
+  backup.preferences.notifications = true;
+  backup.deliveries[event.id].owner = 'old';
+  backup.deliveries[event.id].leaseUntil = at + 1000;
+  assert.throws(
+    () => companionTransition(s, { type: 'restore', value: backup, base: 7 }, at),
+    /changed/,
+  );
+  const restored = companionTransition(s, { type: 'restore', value: backup, base: 8 }, at);
+  assert.equal(restored.preferences.sound, false);
+  assert.equal(restored.preferences.notifications, false);
+  assert.equal(restored.deliveries[event.id].owner, '');
+  assert.throws(() => validateCompanionState({ ...s, schema: 999 }));
+  assert.throws(() =>
+    validateCompanionState({
+      ...s,
+      preferences: { ...s.preferences, image: 'https://evil.example/image.svg' },
+    }),
+  );
+});
+test('actual event history is bounded, idempotent and counted in chosen timezone', () => {
+  let s = defaultCompanionState();
+  const e = {
+    id: 'drink:1',
+    label: 'Water',
+    type: 'water',
+    at: Date.parse('2026-11-12T23:00:00Z'),
+  };
+  s = companionTransition(s, { type: 'record', event: e }, at);
+  s = companionTransition(s, { type: 'record', event: e }, at);
+  assert.equal(s.history.length, 1);
+  assert.equal(companionDaySummary(s, '2026-11-13', 'Asia/Shanghai').water, 1);
+  assert.equal(companionDaySummary(s, '2026-11-12', 'Asia/Shanghai').water, 0);
+});
+
+test('backup preview ignores leases but detects user changes; recovery survives reopening', async () => {
+  const b = validateBrowserBackup({
+    format: 'dsh-offwork-browser',
+    version: 1,
+    createdAt: at,
+    companion: fresh(),
+    water: defaultHydration(),
+    smoking: defaultCountdown(),
+    view: {},
+  });
+  const stamp = companionBackupStamp(b);
+  b.water.claim = { owner: 'other-tab', until: at + 8000, sequence: 0 };
+  b.companion.revision++;
+  assert.equal(companionBackupStamp(b), stamp);
+  const restored = companionTransition(
+    b.companion,
+    { type: 'restore', value: b.companion, base: 0, stamp: companionStateStamp(b.companion) },
+    at,
+  );
+  assert.equal(restored.revision, b.companion.revision);
+  b.water.count++;
+  assert.notEqual(companionBackupStamp(b), stamp);
+  const idb = new IDBFactory();
+  let store = createCompanionRecoveryStore(idb, createStateStore);
+  await store.update((s) => ({ ...s, bundle: b }));
+  store.close();
+  store = createCompanionRecoveryStore(idb, createStateStore);
+  assert.equal((await store.update((s) => s)).bundle.water.count, 1);
+  store.close();
+  assert.throws(() => validateBrowserBackup({ ...b, water: { ...b.water, schema: 999 } }));
+});

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);
@@ -149,7 +150,7 @@ async function adapters(t) {
   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'])
+  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)),
@@ -157,28 +158,34 @@ async function adapters(t) {
   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/pet-interactions.test.mjs

@@ -65,6 +65,25 @@ test('dirty navigation retains the root destination for explicit save or discard
   assert.equal(next.screen, 'appearance');
 });
 
+test('contextual backup and wrap-up return to their owning cards', () => {
+  const settings = go(initialPetUI, 'preferences', { root: true });
+  const backup = go(settings, 'data');
+  assert.equal(backup.back, 'preferences');
+  assert.equal(go(backup, backup.back).screen, 'preferences');
+  assert.equal(
+    go(backup, backup.back).back,
+    null,
+    'back must not bounce between settings and backup',
+  );
+  const appearance = go(settings, 'appearance');
+  assert.equal(appearance.back, 'preferences');
+  const wrap = go(go(initialPetUI, 'income'), 'wrap');
+  assert.equal(wrap.back, 'income');
+  const pending = go(wrap, 'smoking', { dirty: true });
+  assert.equal(pending.screen, 'wrap');
+  assert.equal(go(pending, pending.pending.screen, { discard: true }).screen, 'smoking');
+});
+
 test('appearance snapshots omit position and salary preferences', () => {
   assert.deepEqual(
     appearanceValues({