@lovinka/vitrinka 1.1.1 → 1.4.0

package/skills/vitrinka/tests/snap.test.ts

@@ -0,0 +1,175 @@
+// snap.test.ts — snap's adopt path (web --file): dated dir + NN filename + manifest add +
+// verify prompt, plus the offline-marker warn-once behavior. No capture tools, no network
+// (no .vitrinka config in these fixtures → the detached push is skipped by design).
+// The warn-once behavior WITH a .vitrinka config + real failing pushes lives in push.test.ts.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { makeTmp, runCli, writeFakeBin, noWebpPath, PNG } from './_helpers.ts';
+import { chooseEncoding } from '../../../pkg/src/cli.ts';
+
+// ---------- chooseEncoding: the pure WebP-normalization decision ----------
+
+test('chooseEncoding: no cwebp → keep the original regardless of --hq', () => {
+  assert.equal(chooseEncoding({ hq: false, cwebpAvailable: false }), 'original');
+  assert.equal(chooseEncoding({ hq: true, cwebpAvailable: false, pngSize: 100, losslessSize: 50 }), 'original');
+});
+
+test('chooseEncoding: normal capture → lossy q85 WebP when cwebp is present', () => {
+  assert.equal(chooseEncoding({ hq: false, cwebpAvailable: true }), 'lossy');
+});
+
+test('chooseEncoding: --hq never goes lossy; lossless only when smaller than the PNG', () => {
+  // lossless smaller → take it (pixel-identical, fewer bytes)
+  assert.equal(chooseEncoding({ hq: true, cwebpAvailable: true, pngSize: 1000, losslessSize: 800 }), 'lossless');
+  // lossless not smaller (or equal) → keep the original PNG, full fidelity
+  assert.equal(chooseEncoding({ hq: true, cwebpAvailable: true, pngSize: 1000, losslessSize: 1200 }), 'original');
+  assert.equal(chooseEncoding({ hq: true, cwebpAvailable: true, pngSize: 1000, losslessSize: 1000 }), 'original');
+  // sizes unknown (stat raced) → degrade to keeping the original
+  assert.equal(chooseEncoding({ hq: true, cwebpAvailable: true }), 'original');
+});
+
+// Filename assertions below expect the captured/adopted extension to survive —
+// pin PATH with a failing cwebp so the WebP normalization keeps the original.
+const NO_WEBP = { PATH: noWebpPath() };
+
+function today(): string {
+  const d = new Date();
+  const p2 = (n: number) => String(n).padStart(2, '0');
+  return `${d.getFullYear()}-${p2(d.getMonth() + 1)}-${p2(d.getDate())}`;
+}
+
+test('snap web --file adopts the shot: sequence, kebab filename, manifest entry, verify prompt', () => {
+  const proj = makeTmp();
+  writeFileSync(join(proj, 'src.png'), PNG);
+
+  const r = runCli(['snap', 'web', '--file', 'src.png', '--route', '/login',
+    '--note', 'error state after submit', '--label', 'VSTUP', '--title', 'Login Error'], { cwd: proj, env: NO_WEBP });
+  assert.equal(r.status, 0);
+
+  const day = today();
+  const shotPath = join(proj, '.screenshots', day, '01-web-login-error.png');
+  assert.equal(existsSync(shotPath), true);
+  assert.deepEqual(readFileSync(shotPath), PNG);
+  assert.match(r.stdout, /saved .*01-web-login-error\.png {2}\(shot 1\)/);
+  assert.match(r.stdout, /NOW READ THE IMAGE TO VERIFY/);
+  assert.match(r.stdout, /remote-init/); // no .vitrinka yet → publish hint instead of share URL
+
+  const m = JSON.parse(readFileSync(join(proj, '.screenshots', 'manifest.json'), 'utf8'));
+  assert.equal(m.shots.length, 1);
+  assert.deepEqual(
+    { ...m.shots[0], ts: 'TS' },
+    { file: `${day}/01-web-login-error.png`, surface: 'web', route: '/login',
+      note: 'error state after submit', label: 'VSTUP', title: 'Login Error', ts: 'TS' },
+  );
+  assert.equal(existsSync(join(proj, '.screenshots', 'index.html')), true);
+
+  // second snap → 02
+  const r2 = runCli(['snap', 'web', '--file', 'src.png', '--route', '/login', '--note', 'fixed', '--title', 'Login OK'], { cwd: proj, env: NO_WEBP });
+  assert.equal(r2.status, 0);
+  assert.equal(existsSync(join(proj, '.screenshots', day, '02-web-login-ok.png')), true);
+  assert.match(r2.stdout, /\(shot 2\)/);
+});
+
+test('snap prints the 1-based manifest position (--select numbering), not the per-day filename NN', () => {
+  const proj = makeTmp();
+  writeFileSync(join(proj, 'src.png'), PNG);
+  const root = join(proj, '.screenshots');
+  // A set resumed the next day: 2 shots already in the manifest under an older dated dir.
+  mkdirSync(join(root, '2020-01-01'), { recursive: true });
+  writeFileSync(join(root, 'manifest.json'), JSON.stringify({
+    version: 1,
+    shots: [
+      { file: '2020-01-01/01-web-a.png', surface: 'web', route: '/a', note: 'n', ts: '2020-01-01T10:00:00Z' },
+      { file: '2020-01-01/02-web-b.png', surface: 'web', route: '/b', note: 'n', ts: '2020-01-01T10:01:00Z' },
+    ],
+  }, null, 2) + '\n');
+
+  const r = runCli(['snap', 'web', '--file', 'src.png', '--route', '/c', '--note', 'today'], { cwd: proj, env: NO_WEBP });
+  assert.equal(r.status, 0);
+  // Filename sequence restarts per dated dir (01), but the position --select addresses is global (3).
+  assert.match(r.stdout, /saved .*01-web-c\.png {2}\(shot 3\)/);
+});
+
+test('snap web without --file exits 2 (MCP captures web; snap adopts)', () => {
+  const proj = makeTmp();
+  const r = runCli(['snap', 'web', '--route', '/x', '--note', 'n'], { cwd: proj });
+  assert.equal(r.status, 2);
+  assert.match(r.stderr, /--file <path> is required/);
+});
+
+test('snap validates surface / --route / --note', () => {
+  const proj = makeTmp();
+  writeFileSync(join(proj, 'src.png'), PNG);
+  const bad = runCli(['snap', 'tv', '--file', 'src.png', '--route', '/x', '--note', 'n'], { cwd: proj });
+  assert.equal(bad.status, 2);
+  assert.match(bad.stderr, /surface must be ios\|android\|macos\|web/);
+  const noRoute = runCli(['snap', 'web', '--file', 'src.png', '--note', 'n'], { cwd: proj });
+  assert.equal(noRoute.status, 2);
+  assert.match(noRoute.stderr, /--route is required/);
+  const noNote = runCli(['snap', 'web', '--file', 'src.png', '--route', '/x'], { cwd: proj });
+  assert.equal(noNote.status, 2);
+  assert.match(noNote.stderr, /--note is required/);
+});
+
+test('snap surfaces a pre-existing offline marker exactly once', () => {
+  const proj = makeTmp();
+  writeFileSync(join(proj, 'src.png'), PNG);
+  const root = join(proj, '.screenshots');
+  mkdirSync(root, { recursive: true });
+  writeFileSync(join(root, '.vitrinka-offline'), JSON.stringify({ ts: '2026-07-03T10:00:00Z', error: 'fetch failed (boom)' }) + '\n');
+
+  const r1 = runCli(['snap', 'web', '--file', 'src.png', '--route', '/a', '--note', 'n1'], { cwd: proj });
+  assert.equal(r1.status, 0);
+  assert.match(r1.stderr, /vitrinka unreachable on a previous push \(fetch failed \(boom\)\)/);
+
+  const r2 = runCli(['snap', 'web', '--file', 'src.png', '--route', '/b', '--note', 'n2'], { cwd: proj });
+  assert.equal(r2.status, 0);
+  assert.doesNotMatch(r2.stderr, /vitrinka unreachable/); // marker remembers it was shown
+  const marker = JSON.parse(readFileSync(join(root, '.vitrinka-offline'), 'utf8'));
+  assert.equal(marker.warned, true);
+  assert.equal(marker.error, 'fetch failed (boom)');
+});
+
+// --open + --settle: the navigate-and-wait lives INSIDE snap so a capture is
+// one command (agent harnesses block `sleep …; openurl …; sleep …; snap` chains).
+test('snap ios --open deep-links via simctl, settles, then captures — one command', () => {
+  const proj = makeTmp();
+  const bin = join(makeTmp(), 'bin');
+  const log = join(makeTmp(), 'xcrun.log');
+  writeFileSync(log, '');
+  // Fake xcrun: logs every invocation; `openurl` no-ops, `screenshot` writes a PNG.
+  writeFakeBin(bin, 'xcrun', `
+const fs = require('node:fs');
+const a = process.argv.slice(2);
+fs.appendFileSync(${JSON.stringify(log)}, JSON.stringify(a) + '\\n');
+if (a[1] === 'io' && a[3] === 'screenshot') fs.writeFileSync(a[4], Buffer.from('${PNG.toString('base64')}', 'base64'));
+`);
+  const env = { PATH: `${bin}:${noWebpPath()}` };
+
+  const t0 = Date.now();
+  const r = runCli(['snap', 'ios', '--udid', 'FAKE-UDID',
+    '--open', 'fixitapp:///dev/journey-preview?kind=COMPLETED&invoice=PAID', '--settle', '1',
+    '--route', 'dev/journey-preview', '--note', 'settled capture'], { cwd: proj, env });
+  assert.equal(r.status, 0, r.stderr);
+  assert.ok(Date.now() - t0 >= 1000, 'must actually settle before capturing');
+
+  const calls = readFileSync(log, 'utf8').trim().split('\n').map((l) => JSON.parse(l));
+  assert.equal(calls.length, 2);
+  assert.deepEqual(calls[0], ['simctl', 'openurl', 'FAKE-UDID',
+    'fixitapp:///dev/journey-preview?kind=COMPLETED&invoice=PAID']);
+  assert.deepEqual(calls[1].slice(0, 4), ['simctl', 'io', 'FAKE-UDID', 'screenshot']);
+  assert.match(r.stdout, /\(shot 1\)/);
+});
+
+test('snap rejects --open with web or --file', () => {
+  const proj = makeTmp();
+  writeFileSync(join(proj, 'src.png'), PNG);
+  const web = runCli(['snap', 'web', '--file', 'src.png', '--open', 'http://x', '--route', '/x', '--note', 'n'], { cwd: proj });
+  assert.equal(web.status, 2);
+  assert.match(web.stderr, /--open is not supported/);
+  const adopt = runCli(['snap', 'ios', '--udid', 'U', '--file', 'src.png', '--open', 'app://x', '--route', '/x', '--note', 'n'], { cwd: proj });
+  assert.equal(adopt.status, 2);
+  assert.match(adopt.stderr, /--open cannot be combined with --file/);
+});

package/skills/vitrinka/tests/watch.test.ts

@@ -0,0 +1,204 @@
+// watch.test.ts — the /vitrinka:listen native-Monitor notifier: the pure
+// watermark/diff core (computeAnnouncements + announceLine) and a --once smoke
+// test against a loopback stub. Loopback-only, no external network; the CLI is
+// run async (execFile) so the in-process stub can answer (spawnSync would
+// starve its event loop — see index.test.ts).
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { execFile } from 'node:child_process';
+import { createServer } from 'node:http';
+import { announceLine, computeAnnouncements, deriveWatchScope } from '../../../pkg/src/cli.ts';
+import { CLI } from './_helpers.ts';
+
+test('announceLine: id, intent, board, prompt trimmed to one line ≤100 chars', () => {
+  assert.equal(
+    announceLine({ id: 7, intent: 'fix', board: 'fixit-audit', prompt: 'hero contrast too low' }),
+    '№7 [fix] fixit-audit: hero contrast too low',
+  );
+  // Multi-line / whitespace collapses to a single line.
+  assert.equal(
+    announceLine({ id: 8, intent: 'redesign', board: 'b', prompt: 'line one\n   line two\t tabbed' }),
+    '№8 [redesign] b: line one line two tabbed',
+  );
+  // >100 chars → truncated with an ellipsis.
+  const long = 'x'.repeat(150);
+  const line = announceLine({ id: 9, intent: 'other', board: 'b', prompt: long });
+  assert.equal(line, `№9 [other] b: ${'x'.repeat(100)}…`);
+  // intent "other" with a custom label uses the label; missing intent → "other".
+  assert.equal(announceLine({ id: 1, intent: 'other', intentOther: 'a11y', board: 'b', prompt: 'p' }),
+    '№1 [a11y] b: p');
+  assert.equal(announceLine({ id: 2, board: 'b', prompt: 'p' }), '№2 [other] b: p');
+});
+
+test('computeAnnouncements: fresh items announce once; an unchanged re-poll is silent', () => {
+  const q = [
+    { id: 1, intent: 'fix', board: 'b', prompt: 'a', status: 'open', updatedAt: 't1' },
+    { id: 2, intent: 'fix', board: 'b', prompt: 'c', status: 'open', updatedAt: 't1' },
+  ];
+  const first = computeAnnouncements({}, q);
+  assert.deepEqual(first.lines, ['№1 [fix] b: a', '№2 [fix] b: c']);
+  assert.deepEqual(first.nextMap, {
+    1: { status: 'open', updatedAt: 't1' },
+    2: { status: 'open', updatedAt: 't1' },
+  });
+  // Same queue, same watermark → nothing new.
+  const second = computeAnnouncements(first.nextMap, q);
+  assert.deepEqual(second.lines, []);
+  assert.deepEqual(second.nextMap, first.nextMap);
+});
+
+test('computeAnnouncements: an item that leaves the queue drops, and re-announces when it reappears', () => {
+  const item = { id: 1, intent: 'fix', board: 'b', prompt: 'a', status: 'open', updatedAt: 't1' };
+  const s1 = computeAnnouncements({}, [item]);
+  assert.deepEqual(s1.lines, ['№1 [fix] b: a']);
+  // Item claimed → gone from the open queue → dropped from the watermark.
+  const s2 = computeAnnouncements(s1.nextMap, []);
+  assert.deepEqual(s2.lines, []);
+  assert.deepEqual(s2.nextMap, {});
+  // Re-queued (reopened) → absent from the map → announced again.
+  const s3 = computeAnnouncements(s2.nextMap, [item]);
+  assert.deepEqual(s3.lines, ['№1 [fix] b: a']);
+});
+
+test('computeAnnouncements: a still-open item re-announces when updatedAt changes (prompt revision)', () => {
+  const s1 = computeAnnouncements({}, [
+    { id: 1, intent: 'fix', board: 'b', prompt: 'v1', status: 'open', updatedAt: 't1' },
+  ]);
+  assert.deepEqual(s1.lines, ['№1 [fix] b: v1']);
+  const s2 = computeAnnouncements(s1.nextMap, [
+    { id: 1, intent: 'fix', board: 'b', prompt: 'v2', status: 'open', updatedAt: 't2' },
+  ]);
+  assert.deepEqual(s2.lines, ['№1 [fix] b: v2']);
+  assert.deepEqual(s2.nextMap, { 1: { status: 'open', updatedAt: 't2' } });
+});
+
+// runWatchOnce runs `cli.ts watch --once --base <stub>` async and resolves with
+// the exit code + captured stdout.
+function runWatchOnce(base: string, extra: string[] = []): Promise<{ status: number; stdout: string; stderr: string }> {
+  return new Promise((res) => {
+    execFile(process.execPath, [CLI, 'watch', '--once', '--base', base, ...extra],
+      { encoding: 'utf8', env: { ...process.env, HOME: '/nonexistent-home-for-token-isolation' } },
+      (err, stdout, stderr) => res({ status: err ? (err as { code?: number }).code ?? 1 : 0, stdout, stderr }));
+  });
+}
+
+// A minimal fake vitrinka work API: /work/wait answers per `waitBody`, /work
+// answers per `listBody`. Records the request paths.
+function fakeWorkApi(waitBody: unknown, listBody: unknown) {
+  const requests: string[] = [];
+  const srv = createServer((req, res) => {
+    requests.push(req.url || '');
+    req.resume();
+    req.on('end', () => {
+      const body = (req.url || '').startsWith('/api/v1/work/wait') ? waitBody : listBody;
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(body));
+    });
+  });
+  return { srv, requests };
+}
+
+test('watch --once: work in the window → announces the open queue, exit 0', async () => {
+  const { srv, requests } = fakeWorkApi(
+    { work: [{ id: 1, board: 'b', capsule: '…' }], pending: 1 },
+    { work: [{ id: 1, intent: 'fix', board: 'b', prompt: 'hero contrast', status: 'open', updatedAt: 't1' }] },
+  );
+  await new Promise<void>((r) => srv.listen(0, '127.0.0.1', () => r()));
+  const port = (srv.address() as { port: number }).port;
+  try {
+    const r = await runWatchOnce(`http://127.0.0.1:${port}`);
+    assert.equal(r.status, 0, r.stderr);
+    assert.equal(r.stdout.trim(), '№1 [fix] b: hero contrast');
+    assert.ok(requests.some((u) => u.startsWith('/api/v1/work/wait')));
+    assert.ok(requests.some((u) => u.startsWith('/api/v1/work?')));
+  } finally {
+    srv.close();
+  }
+});
+
+test('watch --once: idle window → prints nothing, exit 3', async () => {
+  const { srv } = fakeWorkApi({ idle: true }, { work: [] });
+  await new Promise<void>((r) => srv.listen(0, '127.0.0.1', () => r()));
+  const port = (srv.address() as { port: number }).port;
+  try {
+    const r = await runWatchOnce(`http://127.0.0.1:${port}`);
+    assert.equal(r.status, 3);
+    assert.equal(r.stdout.trim(), '');
+  } finally {
+    srv.close();
+  }
+});
+
+test('watch --once: board filter is forwarded to the work API', async () => {
+  const { srv, requests } = fakeWorkApi({ idle: true }, { work: [] });
+  await new Promise<void>((r) => srv.listen(0, '127.0.0.1', () => r()));
+  const port = (srv.address() as { port: number }).port;
+  try {
+    await runWatchOnce(`http://127.0.0.1:${port}`, ['--board', 'fixit-audit']);
+    assert.ok(requests.some((u) => u.startsWith('/api/v1/work/wait') && u.includes('board=fixit-audit')));
+  } finally {
+    srv.close();
+  }
+});
+
+test('watch --once: project+branch scope is forwarded to both endpoints', async () => {
+  const { srv, requests } = fakeWorkApi({ idle: true }, { work: [] });
+  await new Promise<void>((r) => srv.listen(0, '127.0.0.1', () => r()));
+  const port = (srv.address() as { port: number }).port;
+  try {
+    await runWatchOnce(`http://127.0.0.1:${port}`, ['--project', 'fixit', '--branch', 'main']);
+    assert.ok(requests.some((u) => u.startsWith('/api/v1/work/wait') && u.includes('project=fixit') && u.includes('branch=main')));
+  } finally {
+    srv.close();
+  }
+});
+
+test('deriveWatchScope: --all wins → firehose (leases nothing-conflicting scope)', () => {
+  assert.deepEqual(deriveWatchScope({ all: true } as never, { repoProject: 'fixit', repoBranch: 'main' }),
+    { kind: 'all', label: 'all boards' });
+});
+
+test('deriveWatchScope: --board wins over inferred project', () => {
+  assert.deepEqual(deriveWatchScope({ board: 'fixit-audit' } as never, { repoProject: 'fixit', repoBranch: 'main' }),
+    { kind: 'board', board: 'fixit-audit', label: 'board fixit-audit' });
+});
+
+test('deriveWatchScope: default = repo project + current branch (sanitized)', () => {
+  assert.deepEqual(deriveWatchScope({} as never, { repoProject: 'FixIt', repoBranch: 'feat/Cool_Thing' }),
+    { kind: 'project', project: 'fixit', branch: 'feat-cool_thing', label: 'fixit/feat-cool_thing' });
+});
+
+test('deriveWatchScope: --project / --branch override the inference', () => {
+  assert.deepEqual(deriveWatchScope({ project: 'reservine', branch: 'dev' } as never,
+    { repoProject: 'fixit', repoBranch: 'main' }),
+    { kind: 'project', project: 'reservine', branch: 'dev', label: 'reservine/dev' });
+});
+
+// runWatch runs the PERSISTENT `watch` (no --once) and resolves on process exit.
+function runWatch(base: string, extra: string[] = []): Promise<{ status: number; stdout: string; stderr: string }> {
+  return new Promise((res) => {
+    execFile(process.execPath, [CLI, 'watch', '--base', base, ...extra],
+      { encoding: 'utf8', env: { ...process.env, HOME: '/nonexistent-home-for-token-isolation' } },
+      (err, stdout, stderr) => res({ status: err ? (err as { code?: number }).code ?? 1 : 0, stdout, stderr }));
+  });
+}
+
+test('watch: a 409 (scope already held) prints the holder and exits 2', async () => {
+  const holder = { actor: 'lukas', session: 'mac:42', scopeKind: 'board', scope: 'fixit-audit', lastSeen: '2026-07-06T10:00:00Z' };
+  const srv = createServer((req, res) => {
+    req.resume();
+    req.on('end', () => {
+      res.writeHead(409, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'listener scope already active', live: true, holder }));
+    });
+  });
+  await new Promise<void>((r) => srv.listen(0, '127.0.0.1', () => r()));
+  const port = (srv.address() as { port: number }).port;
+  try {
+    const r = await runWatch(`http://127.0.0.1:${port}`, ['--board', 'fixit-audit']);
+    assert.equal(r.status, 2, r.stderr);
+    assert.match(r.stdout, /listener already active \(live\): lukas@mac:42 on fixit-audit/);
+  } finally {
+    srv.close();
+  }
+});