create-harness-vibe-coding 0.8.18 → 0.8.19

package/src/wf-ui-server/__tests__/task-parser.test.mjs

@@ -0,0 +1,200 @@
+import test, { describe, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { parseArchivedTasks, parseTaskCapsule, parseTaskList } from '../task-parser.mjs';
+
+describe('task-parser', () => {
+  let baseDir;
+
+  before(() => {
+    baseDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tp-test-'));
+
+    // task-alpha — fully populated, latest updatedAt
+    const dirA = path.join(baseDir, 'task-alpha');
+    fs.mkdirSync(dirA, { recursive: true });
+    fs.writeFileSync(path.join(dirA, 'STATE.json'), JSON.stringify({
+      schemaVersion: 1,
+      taskId: 'task-alpha',
+      status: 'active',
+      mode: 'wf',
+      tier: 'standard',
+      phase: 'wave-1-synthesis',
+      gate: 'E-GATE',
+      updatedAt: '2026-07-29T08:00:00.000Z',
+      activeQuestion: null,
+      nextAction: 'Proceed to dispatch',
+      acceptance: [{ id: 'AC-001', text: 'Task A acceptance', status: 'passed' }],
+      links: { dependsOn: ['task-beta'], blocks: [], related: [] }
+    }));
+    fs.writeFileSync(path.join(dirA, 'PLAN.md'), '# Plan A');
+    fs.writeFileSync(path.join(dirA, 'PROGRESS.md'), '# Progress A');
+
+    // task-beta — completed, no plan/progress files
+    const dirB = path.join(baseDir, 'task-beta');
+    fs.mkdirSync(dirB, { recursive: true });
+    fs.writeFileSync(path.join(dirB, 'STATE.json'), JSON.stringify({
+      schemaVersion: 1,
+      taskId: 'task-beta',
+      status: 'completed',
+      mode: 'direct',
+      tier: 'none',
+      phase: 'closed',
+      gate: null,
+      updatedAt: '2026-07-28T12:00:00.000Z',
+      activeQuestion: null,
+      nextAction: null,
+      acceptance: [],
+      links: { dependsOn: [], blocks: ['task-alpha'], related: [] }
+    }));
+
+    // task-gamma — earliest updatedAt, has active question
+    const dirC = path.join(baseDir, 'task-gamma');
+    fs.mkdirSync(dirC, { recursive: true });
+    fs.writeFileSync(path.join(dirC, 'STATE.json'), JSON.stringify({
+      schemaVersion: 2,
+      taskId: 'task-gamma',
+      status: 'pending',
+      mode: 'direct',
+      tier: 'none',
+      phase: 'intake',
+      gate: null,
+      updatedAt: '2026-07-27T10:00:00.000Z',
+      activeQuestion: 'What to build?',
+      nextAction: 'Define goal',
+      acceptance: [],
+      links: { dependsOn: [], blocks: [], related: ['task-alpha'] }
+    }));
+
+    // not-a-capsule — directory with no STATE.json
+    const dirNoState = path.join(baseDir, 'not-a-capsule');
+    fs.mkdirSync(dirNoState, { recursive: true });
+    fs.writeFileSync(path.join(dirNoState, 'some-file.txt'), 'hello');
+
+    // task-bad-json — malformed STATE.json
+    const dirBadJson = path.join(baseDir, 'task-bad-json');
+    fs.mkdirSync(dirBadJson, { recursive: true });
+    fs.writeFileSync(path.join(dirBadJson, 'STATE.json'), '{ invalid json }');
+
+    // task-no-schema — STATE.json missing schemaVersion
+    const dirNoSchema = path.join(baseDir, 'task-no-schema');
+    fs.mkdirSync(dirNoSchema, { recursive: true });
+    fs.writeFileSync(path.join(dirNoSchema, 'STATE.json'), JSON.stringify({
+      taskId: 'task-no-schema',
+      status: 'active',
+      phase: 'unknown'
+    }));
+  });
+
+  after(() => {
+    fs.rmSync(baseDir, { recursive: true, force: true });
+  });
+
+test('parseTaskCapsule parses a valid task capsule directory with STATE.json', () => {
+  const result = parseTaskCapsule(path.join(baseDir, 'task-alpha'));
+
+  assert.notEqual(result, null);
+  assert.equal(result.taskId, 'task-alpha');
+  assert.equal(result.status, 'active');
+  assert.equal(result.phase, 'wave-1-synthesis');
+  assert.equal(result.gate, 'E-GATE');
+  assert.equal(result.updatedAt, '2026-07-29T08:00:00.000Z');
+  assert.equal(result.activeQuestion, null);
+  assert.ok(Array.isArray(result.acceptance));
+  assert.equal(result.acceptance.length, 1);
+  assert.equal(result.acceptance[0].id, 'AC-001');
+  assert.equal(result.acceptance[0].status, 'passed');
+  assert.deepEqual(result.dependsOn, ['task-beta']);
+  assert.deepEqual(result.blocks, []);
+  assert.equal(result.hasPlan, true);
+  assert.equal(result.hasProgress, true);
+});
+
+test('parseTaskCapsule returns null for directory without STATE.json', () => {
+  const result = parseTaskCapsule(path.join(baseDir, 'not-a-capsule'));
+  assert.equal(result, null);
+});
+
+test('parseTaskCapsule throws on malformed JSON in STATE.json', () => {
+  assert.throws(
+    () => parseTaskCapsule(path.join(baseDir, 'task-bad-json')),
+    /malformed|JSON|parse|SyntaxError/i
+  );
+});
+
+test('parseTaskCapsule throws on missing schemaVersion field', () => {
+  assert.throws(
+    () => parseTaskCapsule(path.join(baseDir, 'task-no-schema')),
+    /schemaVersion/i
+  );
+});
+
+test('parseTaskList returns capsules sorted by updatedAt desc', () => {
+  const results = parseTaskList(baseDir);
+
+  assert.ok(results.length > 1);
+  for (let i = 1; i < results.length; i++) {
+    const prev = new Date(results[i - 1].updatedAt).getTime();
+    const curr = new Date(results[i].updatedAt).getTime();
+    assert.ok(prev >= curr, `Expected ${results[i - 1].taskId} (${results[i - 1].updatedAt}) >= ${results[i].taskId} (${results[i].updatedAt})`);
+  }
+
+  // Strict order: task-alpha (T+08:00), task-beta (T-1d 12:00), task-gamma (T-2d 10:00)
+  assert.equal(results[0].taskId, 'task-alpha');
+  assert.equal(results[1].taskId, 'task-beta');
+  assert.equal(results[2].taskId, 'task-gamma');
+});
+
+test('parseTaskList skips non-capsule directories', () => {
+  const results = parseTaskList(baseDir);
+  const taskIds = results.map(r => r.taskId);
+
+  assert.ok(taskIds.includes('task-alpha'));
+  assert.ok(taskIds.includes('task-beta'));
+  assert.ok(taskIds.includes('task-gamma'));
+  assert.ok(!taskIds.includes('not-a-capsule'));
+});
+
+test('parseTaskList handles completed capsule without PLAN.md or PROGRESS.md', () => {
+  const results = parseTaskList(baseDir);
+  const beta = results.find(r => r.taskId === 'task-beta');
+
+  assert.ok(beta);
+  assert.equal(beta.status, 'completed');
+  assert.equal(beta.phase, 'closed');
+  assert.equal(beta.hasPlan, false);
+  assert.equal(beta.hasProgress, false);
+});
+
+test('parseTaskList includes capsule with activeQuestion as string', () => {
+  const results = parseTaskList(baseDir);
+  const gamma = results.find(r => r.taskId === 'task-gamma');
+
+  assert.ok(gamma);
+  assert.equal(gamma.activeQuestion, 'What to build?');
+  assert.equal(gamma.gate, null);
+  assert.deepEqual(gamma.dependsOn, []);
+  assert.deepEqual(gamma.blocks, []);
+});
+
+test('parseArchivedTasks reads YYYY/MM/DD archive layout', () => {
+  const archiveDir = path.join(baseDir, '_archive', '2026', '07', '30', 'task-archived-alpha');
+  fs.mkdirSync(archiveDir, { recursive: true });
+  fs.writeFileSync(path.join(archiveDir, 'STATE.json'), JSON.stringify({
+    schemaVersion: 1,
+    taskId: 'task-archived-alpha',
+    status: 'archived',
+    phase: 'archived',
+    updatedAt: '2026-07-30T10:00:00.000Z',
+    defaultRuntime: 'codex',
+  }));
+
+  const archived = parseArchivedTasks(baseDir);
+  const match = archived.find(task => task.taskId === 'task-archived-alpha');
+  assert.ok(match);
+  assert.equal(match.archivedYear, '2026');
+  assert.equal(match.archivedPath, '2026/07/30');
+  assert.equal(match.defaultRuntime, 'codex');
+});
+});

package/src/wf-ui-server/__tests__/terminal-store.test.mjs

@@ -0,0 +1,138 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {
+  appendSessionEvent,
+  appendTerminalData,
+  globTerminalEvents,
+  listTerminalSessions,
+  persistSession,
+  readTerminalRange,
+  recordInputRequest,
+} from '../terminal-store.mjs';
+
+function makeSession() {
+  const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'terminal-store-'));
+  const session = {
+    taskId: 'task-alpha',
+    sessionId: 'session-abc',
+    runtime: 'codex',
+    status: 'running',
+    attachMode: false,
+    updatedAt: '2026-07-30T00:00:00.000Z',
+  };
+  return { projectRoot, session };
+}
+
+test('persistSession writes task-scoped STATE.json', () => {
+  const { projectRoot, session } = makeSession();
+  try {
+    persistSession(projectRoot, session);
+    const statePath = path.join(projectRoot, 'Harness', 'tasks', 'task-alpha', 'sessions', 'session-abc', 'STATE.json');
+    assert.ok(fs.existsSync(statePath));
+    assert.equal(JSON.parse(fs.readFileSync(statePath, 'utf8')).runtime, 'codex');
+  } finally {
+    fs.rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test('persistSession writes unbound sessions under Harness/a2a/sessions', () => {
+  const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'terminal-store-'));
+  const session = {
+    taskId: null,
+    sessionId: 'session-unbound',
+    runtime: 'opencode',
+    status: 'running',
+    attachMode: true,
+    updatedAt: '2026-07-30T00:00:00.000Z',
+  };
+  try {
+    persistSession(projectRoot, session);
+    appendTerminalData(projectRoot, session, 'hello-a2a');
+    const statePath = path.join(projectRoot, 'Harness', 'a2a', 'sessions', 'session-unbound', 'STATE.json');
+    assert.ok(fs.existsSync(statePath));
+    assert.equal(JSON.parse(fs.readFileSync(statePath, 'utf8')).taskId, null);
+    const range = readTerminalRange(projectRoot, { sessionId: 'session-unbound', tail: 1 });
+    assert.equal(range.taskId, null);
+    assert.equal(range.entries[0].data, 'hello-a2a');
+  } finally {
+    fs.rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test('appendTerminalData creates monotonic seq and bounded range reads', () => {
+  const { projectRoot, session } = makeSession();
+  try {
+    persistSession(projectRoot, session);
+    appendTerminalData(projectRoot, session, 'one');
+    appendTerminalData(projectRoot, session, 'two');
+    const range = readTerminalRange(projectRoot, { sessionId: 'session-abc', fromSeq: 2, tail: 10 });
+    assert.equal(range.entries.length, 1);
+    assert.equal(range.entries[0].seq, 2);
+    assert.equal(range.entries[0].data, 'two');
+  } finally {
+    fs.rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test('globTerminalEvents reads event and terminal files by glob', () => {
+  const { projectRoot, session } = makeSession();
+  try {
+    persistSession(projectRoot, session);
+    appendSessionEvent(projectRoot, session, { type: 'session.running' });
+    appendTerminalData(projectRoot, session, 'hello');
+    const rows = globTerminalEvents(projectRoot, { pattern: 'Harness/tasks/**/sessions/**/events.jsonl' });
+    assert.equal(rows.length, 1);
+    assert.equal(rows[0].type, 'session.running');
+  } finally {
+    fs.rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test('globTerminalEvents reads Harness/a2a session events', () => {
+  const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'terminal-store-'));
+  const session = {
+    taskId: null,
+    sessionId: 'session-a2a-glob',
+    runtime: 'claude',
+    status: 'running',
+    attachMode: true,
+    updatedAt: '2026-07-30T00:00:00.000Z',
+  };
+  try {
+    persistSession(projectRoot, session);
+    appendSessionEvent(projectRoot, session, { type: 'session.running' });
+    const rows = globTerminalEvents(projectRoot, { pattern: 'Harness/a2a/sessions/**/events.jsonl' });
+    assert.equal(rows.length, 1);
+    assert.equal(rows[0].taskId, null);
+  } finally {
+    fs.rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test('recordInputRequest is attach-gated', () => {
+  const { projectRoot, session } = makeSession();
+  try {
+    persistSession(projectRoot, session);
+    assert.throws(() => recordInputRequest(projectRoot, 'session-abc', 'hello'), /watch mode/);
+    persistSession(projectRoot, { ...session, attachMode: true });
+    const event = recordInputRequest(projectRoot, 'session-abc', 'hello');
+    assert.equal(event.type, 'terminal.input.requested');
+  } finally {
+    fs.rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test('listTerminalSessions returns persisted sessions', () => {
+  const { projectRoot, session } = makeSession();
+  try {
+    persistSession(projectRoot, session);
+    const sessions = listTerminalSessions(projectRoot);
+    assert.equal(sessions.length, 1);
+    assert.equal(sessions[0].sessionId, 'session-abc');
+  } finally {
+    fs.rmSync(projectRoot, { recursive: true, force: true });
+  }
+});

package/src/wf-ui-server/__tests__/token.test.mjs

@@ -0,0 +1,48 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import crypto from 'node:crypto';
+import { generateToken, validateToken } from '../token.mjs';
+
+test('generateToken returns a string of at least 32 hex characters', () => {
+  const token = generateToken();
+  assert.equal(typeof token, 'string');
+  assert.ok(token.length >= 32);
+  assert.ok(/^[0-9a-f]+$/.test(token));
+});
+
+test('two consecutive generateToken calls produce different tokens', () => {
+  const a = generateToken();
+  const b = generateToken();
+  assert.notEqual(a, b);
+});
+
+test('validateToken returns true for a matching token', () => {
+  const token = generateToken();
+  assert.equal(validateToken(token, token), true);
+});
+
+test('validateToken returns false for a non-matching token', () => {
+  const token = generateToken();
+  assert.equal(validateToken(token, token + 'x'), false);
+  assert.equal(validateToken('x' + token, token), false);
+});
+
+test('validateToken returns false for empty expected token', () => {
+  const token = generateToken();
+  assert.equal(validateToken(token, ''), false);
+  assert.equal(validateToken(token, null), false);
+  assert.equal(validateToken(token, undefined), false);
+});
+
+test('validateToken is timing-safe: equal-length comparison produces no early exit on mismatch', () => {
+  // Verify that both same-length mismatches and length-mismatches return false.
+  // This confirms there is no length-based early return that leaks information.
+  const a = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';
+  const b = 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb';
+  const c = 'cccccccccccccccccccccccccccccccc';
+  assert.equal(validateToken(a, b), false);
+  assert.equal(validateToken(a, c), false);
+  assert.equal(validateToken(b, c), false);
+  // Same-length match still works
+  assert.equal(validateToken(a, a), true);
+});