dsh-offwork 0.0.0-stage → 1.0.0

package/tests/host.test.mjs

@@ -0,0 +1,172 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile, writeFile, stat, readdir, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join, resolve, dirname, basename } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { createOperations, DEFAULT_SETTINGS, validateSettings } from '../index.js';
+
+const source = new URL('../index.js', import.meta.url);
+const prefix = 'offwork-clock-host-';
+async function fixture(t) {
+  const root = resolve(tmpdir());
+  const dir = await mkdtemp(join(root, prefix));
+  t.after(async () => {
+    // Never recursively remove anything except our unique direct temporary child.
+    assert.equal(dirname(resolve(dir)), root);
+    assert.ok(basename(dir).startsWith(prefix));
+    assert.notEqual(resolve(dir), root);
+    await rm(dir, { recursive: true, force: true });
+  });
+  const file = join(dir, 'data.json');
+  return { dir, file, operate: createOperations(file) };
+}
+
+function valid(patch) { return validateSettings({ ...DEFAULT_SETTINGS, ...patch }); }
+
+test('defaults remain unsaved; real writes persist privately and can be reopened', async t => {
+  const { dir, file, operate } = await fixture(t);
+  const initial = await operate('get');
+  assert.deepEqual(initial, { ok: true, settings: DEFAULT_SETTINGS, configured: false });
+  initial.settings.weekdays.push(6);
+  assert.deepEqual((await operate('get')).settings.weekdays, [1, 2, 3, 4, 5]);
+  assert.deepEqual(await readdir(dir), []);
+  const saved = await operate('set', { payMode: 'daily', dailySalary: 500 });
+  assert.equal(saved.ok, true);
+  assert.equal(saved.configured, true);
+  assert.deepEqual(JSON.parse(await readFile(file, 'utf8')), saved.settings);
+  assert.equal((await stat(file)).mode & 0o777, 0o600);
+  assert.deepEqual(await createOperations(pathToFileURL(file))('get'), saved);
+  assert.deepEqual(await readdir(dir), ['data.json']);
+});
+
+test('legacy configuration gains only new defaults, without rewriting on get', async t => {
+  const { file, operate } = await fixture(t);
+  const { payMode, dailySalary, ...legacy } = DEFAULT_SETTINGS;
+  legacy.monthlySalary = 12345;
+  const bytes = JSON.stringify(legacy);
+  await writeFile(file, bytes);
+  const migrated = await operate('get');
+  assert.deepEqual(migrated, { ok: true, configured: true, settings: { ...DEFAULT_SETTINGS, monthlySalary: 12345 } });
+  assert.equal(await readFile(file, 'utf8'), bytes);
+  assert.equal((await operate('set', { dailySalary: 700 })).settings.monthlySalary, 12345);
+  assert.equal(JSON.parse(await readFile(file, 'utf8')).payMode, 'monthly');
+});
+
+test('malformed, unknown and incomplete saved data are never overwritten', async t => {
+  const { file, operate, dir } = await fixture(t);
+  for (const bytes of ['{broken', 'null', '[]', JSON.stringify({ ...DEFAULT_SETTINGS, surprise: true }), JSON.stringify({ start: '09:00' })]) {
+    await writeFile(file, bytes);
+    assert.equal((await operate('get')).ok, false);
+    assert.equal((await operate('set', { monthlySalary: 5 })).ok, false);
+    assert.equal(await readFile(file, 'utf8'), bytes);
+    assert.deepEqual(await readdir(dir), ['data.json']);
+  }
+});
+
+test('day and overnight shifts normalize breaks against shift start', () => {
+  for (const patch of [
+    { start: '22:00', end: '06:00', breakStart: '02:00', breakEnd: '03:00' },
+    { start: '22:00', end: '06:00', breakStart: '23:30', breakEnd: '00:30' },
+    { start: '22:00', end: '06:00', breakStart: '22:00', breakEnd: '23:00' },
+    { start: '22:00', end: '06:00', breakStart: '05:00', breakEnd: '06:00' },
+    { start: '22:00', end: '06:00', breakStart: '12:00', breakEnd: '12:00' },
+    { breakStart: '00:00', breakEnd: '00:00' },
+  ]) assert.doesNotThrow(() => valid(patch));
+  for (const patch of [
+    { start: '09:00', end: '09:00' },
+    { start: '22:00', end: '06:00' },
+    { start: '22:00', end: '06:00', breakStart: '02:00', breakEnd: '01:00' },
+    { start: '22:00', end: '06:00', breakStart: '22:00', breakEnd: '06:00' },
+    { breakStart: '18:00', breakEnd: '19:00' },
+    { breakStart: '12:00', breakEnd: '11:00' },
+    { payMode: 'hourly' }, { dailySalary: -1 }, { dailySalary: Infinity },
+    { monthlySalary: NaN }, { workdaysPerMonth: 0 }, { start: '9:00' },
+    { weekdays: [1, 1] }, { timezone: 'not/a-zone' }, { surprise: true },
+  ]) assert.throws(() => valid(patch), JSON.stringify(patch));
+});
+
+test('invalid patches and actions do not create files; queue recovers', async t => {
+  const { dir, operate } = await fixture(t);
+  for (const [action, patch] of [['wat'], ['get', {}], ['set'], ['set', []], ['set', { unknown: 1 }], ['set', { payMode: 'weekly' }]]) {
+    assert.equal((await operate(action, patch)).ok, false);
+  }
+  assert.deepEqual(await readdir(dir), []);
+  assert.equal((await operate('set', {})).configured, true);
+});
+
+test('concurrent partial sets serialize and preserve preceding updates', async t => {
+  const { file, operate, dir } = await fixture(t);
+  const patches = [{ monthlySalary: 22222 }, { dailySalary: 999 }, { payMode: 'daily' }, { timezone: 'UTC' }];
+  const pending = patches.map(patch => operate('set', patch));
+  pending.push(operate('set', { unknown: true }));
+  for (let i = 0; i < 30; i++) pending.push(operate('set', { dailySalary: 1000 + i }));
+  const results = await Promise.all(pending);
+  assert.equal(results[4].ok, false);
+  assert.ok(results.filter((_, i) => i !== 4).every(result => result.ok));
+  const expected = { ...DEFAULT_SETTINGS, ...Object.assign({}, ...patches), dailySalary: 1029 };
+  assert.deepEqual(JSON.parse(await readFile(file, 'utf8')), expected);
+  assert.deepEqual((await operate('get')).settings, expected);
+  assert.deepEqual(await readdir(dir), ['data.json']);
+});
+
+async function adapters(t) {
+  const fixtureData = await fixture(t);
+  // Import an isolated copy: apply() keeps its real default data URL beside the module,
+  // 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'));
+  const module = await import(pathToFileURL(moduleFile).href);
+  let command;
+  let tool;
+  module.apply({
+    effect: effect => effect(),
+    commands: { register(definition) { command = definition; return () => {}; } },
+    tools: { register(definition) { tool = definition; return () => {}; } },
+  });
+  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 };
+}
+
+test('command and tool share results, validation, storage and a write queue', async t => {
+  const { tool, command, runCommand, file } = await adapters(t);
+  assert.equal(command.recordInput, false);
+  assert.deepEqual(await runCommand('get'), await tool.execute({ action: 'get' }));
+  const written = await runCommand('set {"payMode":"daily","dailySalary":600}');
+  assert.deepEqual(await tool.execute({ action: 'get' }), written);
+  const second = await tool.execute({ action: 'set', settings: { monthlySalary: 25000 } });
+  assert.deepEqual(await runCommand('get'), second);
+  assert.deepEqual(await runCommand('set {"unknown":1}'), await tool.execute({ action: 'set', settings: { unknown: 1 } }));
+  await Promise.all([
+    runCommand('set {"dailySalary":750}'),
+    tool.execute({ action: 'set', settings: { timezone: 'UTC' } }),
+  ]);
+  const stored = JSON.parse(await readFile(file, 'utf8'));
+  assert.equal(stored.dailySalary, 750);
+  assert.equal(stored.timezone, 'UTC');
+  for (const raw of ['get {}', 'set', 'set {bad', 'wat']) assert.equal((await runCommand(raw)).ok, false);
+  for (const args of [null, [], { action: 'get', unknown: true }]) assert.equal((await tool.execute(args)).ok, false);
+});
+
+test('tool schemas expose new fields, configured flag, and typed literal branches', async t => {
+  const { tool } = await adapters(t);
+  const input = tool.parameters.properties.settings;
+  assert.equal(input.additionalProperties, false);
+  assert.deepEqual(input.properties.payMode.enum, ['monthly', 'daily']);
+  assert.equal(input.properties.dailySalary.type, 'number');
+  const [success, failure] = tool.output.schema.oneOf;
+  assert.deepEqual(success.properties.ok, { type: 'boolean', const: true });
+  assert.deepEqual(failure.properties.ok, { type: 'boolean', const: false });
+  assert.ok(success.required.includes('configured'));
+  assert.equal(success.properties.configured.type, 'boolean');
+  assert.deepEqual(success.properties.settings.required, Object.keys(DEFAULT_SETTINGS));
+  assert.equal(success.additionalProperties, false);
+  assert.equal(failure.additionalProperties, false);
+  const result = await tool.execute({ action: 'get' });
+  assert.deepEqual(tool.output.render({}, result), [{ type: 'text', text: JSON.stringify(result) }]);
+});

package/tests/ui.test.mjs

@@ -0,0 +1,75 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { formatDuration, clampPosition, normalizeView, clampOpacity, decodeCommand, changedSettings } from '../ui-utils.js';
+test('duration rounds countdown upward and supports >24 hours', () => {
+  assert.equal(formatDuration(0), '00:00:00'); assert.equal(formatDuration(3661), '01:01:01');
+  assert.equal(formatDuration(.1), '00:00:01'); assert.equal(formatDuration(90000), '25:00:00');
+  assert.equal(formatDuration(NaN), '--:--:--'); assert.equal(formatDuration(-1), '--:--:--');
+});
+test('position stays visible when viewport shrinks', () => {
+  assert.deepEqual(clampPosition({ x: 9000, y: -20 }, { width: 800, height: 600 }, { width: 330, height: 400 }), { x: 458, y: 12 });
+  assert.deepEqual(clampPosition(null, { width: 200, height: 200 }, { width: 330, height: 400 }), { x: 12, y: 12 });
+});
+test('view defaults: compact, salary hidden, 82% glass', () => {
+  assert.deepEqual(normalizeView(null), { mini: true, masked: true, opacity: 0.82, position: null });
+  assert.deepEqual(normalizeView({ mini: false, masked: false, opacity: 0.5, position: { x: 1, y: 2 } }),
+    { mini: false, masked: false, opacity: 0.5, position: { x: 1, y: 2 } });
+  assert.equal(normalizeView({ mini: 'yes' }).mini, true);
+  assert.equal(normalizeView({ masked: 'false' }).masked, true);
+});
+test('malformed positions and opacity are repaired, not trusted', () => {
+  assert.deepEqual(normalizeView({ mini: 'yes', masked: true, position: { x: 'oops', y: 2 } }), { mini: true, masked: true, opacity: 0.82, position: null });
+  assert.equal(normalizeView({ opacity: 0 }).opacity, 0.3);
+  assert.equal(normalizeView({ opacity: 9 }).opacity, 1);
+  assert.equal(normalizeView({ opacity: 'x' }).opacity, 0.82);
+  assert.equal(clampOpacity(0.55), 0.55);
+});
+test('salary stays hidden until explicitly revealed, including on first paint', () => {
+  assert.equal(normalizeView(null).masked, true);
+  assert.equal(normalizeView({}).masked, true);
+  assert.equal(normalizeView({ masked: false }).masked, false);
+});
+test('RPC decodes every failure layer and real command envelopes', () => {
+  const response = (data, kind = 'success') => ({ ok: true, value: { result: { kind, text: JSON.stringify(data) } } });
+  assert.deepEqual(decodeCommand(response({ ok: true, settings: { monthlySalary: 1000 }, configured: true })).settings, { monthlySalary: 1000 });
+  assert.throws(() => decodeCommand({ ok: false, error: { message: 'permission denied' } }), /permission denied/);
+  assert.throws(() => decodeCommand({ ok: true }), /Command unavailable/);
+  assert.throws(() => decodeCommand(response({ ok: false, error: 'bad shift' }, 'error')), /bad shift/);
+  assert.throws(() => decodeCommand({ ok: true, value: { result: { kind: 'success', text: 'oops' } } }), /Invalid/);
+});
+test('partial saves preserve unrelated edits from another caller', () => {
+  assert.deepEqual(changedSettings({ salary: 1, days: [1, 2], start: '09:00' }, { salary: 2, days: [1, 2], start: '09:00' }), { salary: 2 });
+});
+test('Client uses the exact tested engine and a single surface', async () => {
+  const source = await readFile(new URL('../client.source.js', import.meta.url), 'utf8');
+  const built = await readFile(new URL('../client.js', import.meta.url), 'utf8');
+  const engine = (await readFile(new URL('../clock.js', import.meta.url), 'utf8')).replace(/^export /gm, '');
+  assert.ok(built.includes(engine));
+  assert.match(source, /prefers-reduced-motion:reduce/);
+  assert.match(source, /prefers-reduced-transparency:reduce/);
+  assert.match(source, /visibilitychange/); assert.match(source, /removeEventListener\('storage'/);
+  assert.match(source, /ro\?\.disconnect/); assert.match(source, /generation\.current/);
+  assert.doesNotMatch(source, /document\.body|window\.open|fetch\(/);
+  assert.match(source, /money\(safeState\.earned\)/);
+  assert.match(source, /owc-glass/);
+  assert.match(source, /--owc-alpha/);
+  assert.match(source, /type: 'range'/);
+  assert.match(source, /dragState/);
+  assert.ok(source.includes('onPointerMove: dragMove'));
+});
+test('compact strip stacks time above amount', async () => {
+  const source = await readFile(new URL('../client.source.js', import.meta.url), 'utf8');
+  const css = source.slice(source.indexOf('.owc-pill{'), source.indexOf('.owc-pill{') + 200);
+  assert.match(css, /flex-direction:column/);
+  assert.match(source, /className: 'owc-pill-top'/);
+  assert.match(source, /className: 'owc-pill-bottom'/);
+  assert.ok(source.indexOf("className: 'owc-pill-time'") < source.indexOf("className: 'owc-pill-money'"));
+});
+test('compact strip keeps both drag surface and expand action; panel keeps collapse', async () => {
+  const source = await readFile(new URL('../client.source.js', import.meta.url), 'utf8');
+  assert.match(source, /onPointerDown: dragDown/);
+  assert.match(source, /mini: false/);
+  assert.match(source, /mini: true/);
+  assert.match(source, /hasPointerCapture/);
+});

package/tools/build.mjs

@@ -0,0 +1,13 @@
+import { readFile, writeFile } from 'node:fs/promises';
+const root = new URL('../', import.meta.url);
+const [entry, clock, utils] = await Promise.all(['client.source.js','clock.js','ui-utils.js'].map(name=>readFile(new URL(name,root),'utf8')));
+if (entry.split('/* PURE_MODULES */').length !== 2) throw new Error('Expected exactly one pure-module marker');
+const pure = [clock,utils].map(text=>text.replace(/^export /gm,'')).join('\n');
+const result = '// Generated by tools/build.mjs; edit client.source.js, clock.js or ui-utils.js.\n'+entry.replace('/* PURE_MODULES */',pure);
+if(process.argv.includes('--check')) {
+  if(await readFile(new URL('client.js',root),'utf8')!==result) throw new Error('Client artifact is stale');
+  console.log('Client artifact matches tested source');
+} else {
+  await writeFile(new URL('client.js',root),result);
+  console.log('Built client.js from one calculation source');
+}

package/ui-utils.js

@@ -0,0 +1,51 @@
+// Small pure helpers shared by the browser artifact and its tests.
+export function formatDuration(seconds) {
+  if (!Number.isFinite(seconds) || seconds < 0) return '--:--:--';
+  const n = Math.ceil(seconds);
+  return [Math.floor(n / 3600), Math.floor(n % 3600 / 60), n % 60]
+    .map(part => String(part).padStart(2, '0')).join(':');
+}
+
+export function clampPosition(position, viewport, size) {
+  const width = Math.max(0, viewport.width), height = Math.max(0, viewport.height);
+  const edge = Math.min(12, width / 2, height / 2);
+  const maxX = Math.max(edge, width - size.width - edge);
+  const maxY = Math.max(edge, height - size.height - edge);
+  return {
+    x: Math.max(edge, Math.min(Number.isFinite(position?.x) ? position.x : maxX, maxX)),
+    y: Math.max(edge, Math.min(Number.isFinite(position?.y) ? position.y : 88, maxY)),
+  };
+}
+
+export function clampOpacity(value, fallback = 0.82) {
+  const number = Number(value);
+  if (!Number.isFinite(number)) return fallback;
+  return Math.min(1, Math.max(0.3, number));
+}
+
+export function normalizeView(value) {
+  return {
+    mini: value?.mini !== false,
+    masked: value?.masked !== false,
+    opacity: clampOpacity(value?.opacity),
+    position: Number.isFinite(value?.position?.x) && Number.isFinite(value?.position?.y)
+      ? { x: value.position.x, y: value.position.y } : null,
+  };
+}
+
+export function decodeCommand(rpc) {
+  if (!rpc || rpc.ok !== true) throw new Error(rpc?.error?.message || 'RPC unavailable');
+  const result = rpc.value?.result;
+  if (!result || typeof result.text !== 'string') throw new Error('Command unavailable');
+  let data;
+  try { data = JSON.parse(result.text); }
+  catch { throw new Error('Invalid command response'); }
+  if (result.kind !== 'success' || data?.ok !== true) throw new Error(data?.error || 'Request failed');
+  if (!data.settings || typeof data.settings !== 'object') throw new Error('Missing settings');
+  return data;
+}
+
+export function changedSettings(original, draft) {
+  return Object.fromEntries(Object.entries(draft)
+    .filter(([key, value]) => JSON.stringify(value) !== JSON.stringify(original[key])));
+}