create-harness-vibe-coding 0.8.19 → 0.9.3

package/src/wf-ui-server/__tests__/workflow-skill-group-enable-disable.test.mjs

@@ -0,0 +1,186 @@
+import { describe, it, after } from 'node:test';
+import assert from 'node:assert';
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+
+import { createCapabilityNode, getCapabilityNode, capabilityStateRefs } from '../workflow-capability-node-store.mjs';
+import * as SkillGroupNode from '../workflow-node-types/skill-group-node.mjs';
+
+function tempProjectRoot() {
+  const id = crypto.randomBytes(4).toString('hex');
+  const dir = path.join(process.cwd(), `.tmp-skill-enable-${id}`);
+  fs.mkdirSync(path.join(dir, 'Harness', 'a2a'), { recursive: true });
+  return dir;
+}
+
+function cleanup(dir) {
+  try { fs.rmSync(dir, { recursive: true, force: true }); } catch {}
+}
+
+function seedSkillGroup(root, overrides = {}) {
+  return createCapabilityNode(root, {
+    type: 'skill-group',
+    title: overrides.title || 'Test Skill Pack',
+    description: 'Test pack',
+    sourceGroup: { id: 'family:test', label: 'Test', kind: 'family' },
+    skills: overrides.skills || [
+      { id: 'skill:wf-ui', name: 'wf-ui', title: 'WF-UI', source: 'project' },
+      { id: 'skill:browser-lab', name: 'browser-lab', title: 'Browser Lab', source: 'project' },
+      { id: 'skill:api-lab', name: 'api-lab', title: 'API Lab', source: 'project' },
+    ],
+  });
+}
+
+describe('skill-group setSkillEnabled (W38)', () => {
+  const roots = [];
+  after(() => roots.forEach(cleanup));
+
+  it('toggles a skill enabled flag and persists (revision increments)', () => {
+    const root = tempProjectRoot();
+    roots.push(root);
+    const created = seedSkillGroup(root);
+    const nodeId = created.node.nodeId;
+
+    const before = getCapabilityNode(root, nodeId);
+    const wfUiBefore = before.state.skills.find(s => s.name === 'wf-ui');
+    assert.equal(wfUiBefore.enabled, true, 'skills default to enabled');
+
+    const result = SkillGroupNode.setSkillEnabled(nodeId, root, { skillId: 'skill:wf-ui', enabled: false });
+
+    assert.equal(result.enabled, false);
+    assert.equal(result.revision, before.node.revision + 1, 'revision must increment after toggle');
+
+    const after = getCapabilityNode(root, nodeId);
+    assert.equal(after.node.revision, before.node.revision + 1, 'revision must persist');
+    const wfUiAfter = after.state.skills.find(s => s.name === 'wf-ui');
+    assert.equal(wfUiAfter.enabled, false, 'disabled skill persists enabled:false');
+
+    const browserLab = after.state.skills.find(s => s.name === 'browser-lab');
+    assert.equal(browserLab.enabled, true, 'unrelated skills stay enabled');
+
+    // group composition is unchanged (ids stay, only the flag flips)
+    assert.deepEqual(after.state.skillNames, ['wf-ui', 'browser-lab', 'api-lab']);
+
+    // read action reflects the flag too
+    const readResult = SkillGroupNode.read(nodeId, root);
+    const wfUiRead = readResult.skills.find(s => s.name === 'wf-ui');
+    assert.equal(wfUiRead.enabled, false);
+  });
+
+  it('rejects a missing skillId', () => {
+    const root = tempProjectRoot();
+    roots.push(root);
+    const created = seedSkillGroup(root);
+    const nodeId = created.node.nodeId;
+
+    assert.throws(
+      () => SkillGroupNode.setSkillEnabled(nodeId, root, { enabled: false }),
+      (err) => {
+        assert.equal(err.code, 'SKILL_ID_REQUIRED');
+        assert.equal(err.statusCode, 400);
+        return true;
+      },
+    );
+
+    // blank/whitespace skillId is also rejected
+    assert.throws(
+      () => SkillGroupNode.setSkillEnabled(nodeId, root, { skillId: '   ', enabled: false }),
+      (err) => {
+        assert.equal(err.code, 'SKILL_ID_REQUIRED');
+        return true;
+      },
+    );
+
+    // rejected call must not mutate persisted state
+    const after = getCapabilityNode(root, nodeId);
+    assert.equal(after.node.revision, 1);
+  });
+
+  it('reflects enabled:false in capability refs (agent-context source) without leaking bodies', () => {
+    const root = tempProjectRoot();
+    roots.push(root);
+    const created = seedSkillGroup(root);
+    const nodeId = created.node.nodeId;
+
+    SkillGroupNode.setSkillEnabled(nodeId, root, { skillId: 'skill:browser-lab', enabled: false });
+
+    const refs = capabilityStateRefs(root);
+    const ref = refs[nodeId];
+    assert.ok(ref, 'capability ref must exist for the skill-group node');
+
+    const browserLab = ref.skills.find(s => s.name === 'browser-lab');
+    assert.equal(browserLab.enabled, false, 'disabled skill surfaces enabled:false in capability refs');
+    const wfUi = ref.skills.find(s => s.name === 'wf-ui');
+    assert.equal(wfUi.enabled, true);
+
+    // ids remain (group composition unchanged; only flag flips)
+    assert.deepEqual(ref.skillNames, ['wf-ui', 'browser-lab', 'api-lab']);
+
+    // body-free / absolute-path-free guarantee
+    const serialized = JSON.stringify(refs);
+    assert.ok(!serialized.includes('SKILL.md'), 'must not leak SKILL.md body');
+    assert.ok(!serialized.includes(root), 'must not leak absolute project path');
+    for (const skill of ref.skills) {
+      const keys = Object.keys(skill).sort();
+      assert.deepEqual(keys, ['enabled', 'id', 'name', 'source', 'state', 'title'], `unexpected skill fields: ${keys.join(',')}`);
+    }
+  });
+
+  it('toggle is idempotent (repeated same-value call does not bump revision)', () => {
+    const root = tempProjectRoot();
+    roots.push(root);
+    const created = seedSkillGroup(root);
+    const nodeId = created.node.nodeId;
+
+    const first = SkillGroupNode.setSkillEnabled(nodeId, root, { skillId: 'skill:api-lab', enabled: false });
+    assert.equal(first.enabled, false);
+    const revisionAfterFirst = first.revision;
+
+    const second = SkillGroupNode.setSkillEnabled(nodeId, root, { skillId: 'skill:api-lab', enabled: false });
+    assert.equal(second.enabled, false);
+    assert.equal(second.revision, revisionAfterFirst, 'idempotent call must not increment revision');
+
+    const fresh = getCapabilityNode(root, nodeId);
+    assert.equal(fresh.node.revision, revisionAfterFirst, 'persisted revision unchanged after no-op');
+    const apiLab = fresh.state.skills.find(s => s.name === 'api-lab');
+    assert.equal(apiLab.enabled, false);
+
+    // flipping back to true bumps revision again (not a no-op)
+    const toggled = SkillGroupNode.setSkillEnabled(nodeId, root, { skillId: 'skill:api-lab', enabled: true });
+    assert.equal(toggled.enabled, true);
+    assert.equal(toggled.revision, revisionAfterFirst + 1, 'real toggle must increment revision');
+  });
+
+  it('rejects an unknown skillId', () => {
+    const root = tempProjectRoot();
+    roots.push(root);
+    const created = seedSkillGroup(root);
+    const nodeId = created.node.nodeId;
+
+    assert.throws(
+      () => SkillGroupNode.setSkillEnabled(nodeId, root, { skillId: 'skill:does-not-exist', enabled: false }),
+      (err) => {
+        assert.equal(err.code, 'SKILL_NOT_FOUND');
+        assert.equal(err.statusCode, 404);
+        return true;
+      },
+    );
+  });
+
+  it('rejects non-boolean enabled', () => {
+    const root = tempProjectRoot();
+    roots.push(root);
+    const created = seedSkillGroup(root);
+    const nodeId = created.node.nodeId;
+
+    assert.throws(
+      () => SkillGroupNode.setSkillEnabled(nodeId, root, { skillId: 'skill:wf-ui', enabled: 'nope' }),
+      (err) => {
+        assert.equal(err.code, 'INVALID_ENABLED');
+        assert.equal(err.statusCode, 400);
+        return true;
+      },
+    );
+  });
+});

package/src/wf-ui-server/__tests__/workflow-skills-hub.test.mjs

@@ -0,0 +1,125 @@
+import { describe, it, after } from 'node:test';
+import assert from 'node:assert';
+import http from 'node:http';
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+
+function tempProjectRoot() {
+  const id = crypto.randomBytes(4).toString('hex');
+  const dir = path.join(process.cwd(), `.tmp-skills-hub-${id}`);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.mkdirSync(path.join(dir, 'Harness', 'a2a'), { recursive: true });
+  fs.writeFileSync(path.join(dir, 'Harness', 'a2a', 'workflow-map.json'), JSON.stringify({
+    schemaVersion: 1,
+    version: 1,
+    nodes: [],
+    edges: [],
+    positions: {},
+    undoStack: [],
+    redoStack: [],
+    deletedNodes: [],
+  }));
+  return dir;
+}
+
+function writeSkill(root, relDir, frontmatter, body = '# Skill\n') {
+  const dir = path.join(root, relDir);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, 'SKILL.md'), `---\n${frontmatter}\n---\n\n${body}`, 'utf8');
+}
+
+function cleanup(dir) {
+  try { fs.rmSync(dir, { recursive: true, force: true }); } catch {}
+}
+
+function jsonRequest(url) {
+  return new Promise((resolve, reject) => {
+    const req = http.request(url, { method: 'GET' }, (res) => {
+      let data = '';
+      res.on('data', chunk => { data += chunk; });
+      res.on('end', () => {
+        try { resolve({ status: res.statusCode, body: JSON.parse(data) }); }
+        catch { resolve({ status: res.statusCode, body: data }); }
+      });
+    });
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+describe('Workflow Skills Hub', () => {
+  const roots = [];
+  after(() => roots.forEach(cleanup));
+
+  it('indexes project .agents and .claude skills without exposing absolute paths', async () => {
+    const root = tempProjectRoot();
+    roots.push(root);
+    writeSkill(root, '.agents/skills/wf-ui', 'name: wf-ui\ndescription: Open the local workflow control panel.', '# WF UI\n');
+    writeSkill(root, '.claude/skills/wf-ui', 'name: wf-ui\ndescription: Claude mirror for wf-ui.', '# WF UI Mirror\n');
+    writeSkill(root, '.agents/skills/custom-pack/review', 'name: custom-pack:review\ndescription: Review helper.', '# Review Skill\n');
+
+    const hub = await import('../workflow-skills-hub.mjs');
+    const result = hub.listSkillsHub(root, { scope: 'project' });
+
+    assert.equal(result.ok, true);
+    assert.equal(result.schemaVersion, 1);
+    assert.equal(result.kind, 'skills-hub');
+    assert.deepEqual(result.query, { scope: 'project', q: '', limit: 250 });
+    assert.equal(result.nodeSemantics.role, 'agent-attached-capability-provider');
+    assert.ok(result.summary.skillCount >= 2);
+
+    const wfUi = result.skills.find(skill => skill.name === 'wf-ui');
+    assert.ok(wfUi, 'wf-ui skill should be indexed');
+    assert.equal(wfUi.id, 'skill:wf-ui');
+    assert.equal(wfUi.attachable, true);
+    assert.equal(wfUi.state, 'indexed');
+    assert.ok(wfUi.sources.length >= 2, 'duplicate skill mirrors should merge into one skill with multiple sources');
+    assert.ok(wfUi.sources.every(source => !path.isAbsolute(source.path)), `absolute path leaked: ${JSON.stringify(wfUi.sources)}`);
+
+    const custom = result.skills.find(skill => skill.name === 'custom-pack:review');
+    assert.ok(custom, 'colon names should be valid skill ids');
+    assert.equal(custom.id, 'skill:custom-pack:review');
+    assert.ok(result.groups.some(group => group.id === 'family:custom' || group.id === 'family:custom-pack'));
+  });
+
+  it('GET /api/workflow/skills-hub returns a searchable project-scoped hub index', async () => {
+    const root = tempProjectRoot();
+    roots.push(root);
+    writeSkill(root, '.agents/skills/browser-lab', 'name: browser-lab\ndescription: Browser automation helper.', '# Browser Lab\n');
+    writeSkill(root, '.agents/skills/api-lab', 'name: api-lab\ndescription: Backend API helper.', '# API Lab\n');
+
+    const mod = await import('../server.mjs');
+    const sessionMock = { getAll: () => [], get: () => null, create: () => {}, stop: () => null, update: () => {}, remove: () => {}, withLock: (_k, fn) => Promise.resolve().then(fn) };
+    const server = mod.createServer({ projectRoot: root, sessionRegistry: sessionMock, token: '' });
+    await new Promise(resolve => server.listen(0, resolve));
+    try {
+      const baseUrl = `http://127.0.0.1:${server.address().port}`;
+      const all = await jsonRequest(`${baseUrl}/api/workflow/skills-hub?scope=project`);
+      assert.equal(all.status, 200, JSON.stringify(all.body));
+      assert.equal(all.body.ok, true);
+      assert.ok(all.body.skills.some(skill => skill.name === 'browser-lab'));
+      assert.ok(all.body.skills.some(skill => skill.name === 'api-lab'));
+      assert.deepEqual(all.body.nodeSemantics, {
+        role: 'agent-attached-capability-provider',
+        defaultConnection: 'bidirectional capability/status port to Agent nodes',
+        executor: 'agent',
+      });
+
+      const filtered = await jsonRequest(`${baseUrl}/api/workflow/skills-hub?scope=project&q=browser`);
+      assert.equal(filtered.status, 200, JSON.stringify(filtered.body));
+      assert.deepEqual(filtered.body.skills.map(skill => skill.name), ['browser-lab']);
+
+      const defaultScope = await jsonRequest(`${baseUrl}/api/workflow/skills-hub`);
+      assert.equal(defaultScope.status, 200, JSON.stringify(defaultScope.body));
+      assert.equal(defaultScope.body.query.scope, 'project');
+      assert.ok(defaultScope.body.roots.every(root => root.scope === 'project'));
+
+      const badScope = await jsonRequest(`${baseUrl}/api/workflow/skills-hub?scope=..%2Fuser`);
+      assert.equal(badScope.status, 400, JSON.stringify(badScope.body));
+      assert.equal(badScope.body.error.code, 'INVALID_SCOPE');
+    } finally {
+      server.close();
+    }
+  });
+});

package/src/wf-ui-server/__tests__/workflow-state-reconcile.test.mjs

@@ -0,0 +1,139 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { makeHarnessTempRoot } from '../../../tests/support/temp-root.js';
+import {
+  appendTerminalData,
+  buildSessionIndex,
+  downgradeOrphanedDiskSessions,
+  flushTerminalBuffer,
+  getSessionIndexSummary,
+  persistSession,
+  readTerminalRange,
+} from '../terminal-store.mjs';
+import { stateFingerprint } from '../a2a-store.mjs';
+
+function makeRoot(prefix) {
+  const root = makeHarnessTempRoot(prefix);
+  fs.mkdirSync(path.join(root, 'Harness', 'tasks'), { recursive: true });
+  fs.mkdirSync(path.join(root, 'Harness', 'a2a', 'sessions'), { recursive: true });
+  return root;
+}
+
+function sessionRecord(sessionId, patch = {}) {
+  return { taskId: null, sessionId, runtime: 'codex', role: 'Main Agent', ...patch };
+}
+
+test('S1 batched terminal writes: buffered appends land on disk in order at flush', () => {
+  const root = makeRoot('wfui-batch-');
+  try {
+    const session = sessionRecord('session-batch-1');
+    persistSession(root, session);
+    const diskFile = path.join(root, 'Harness', 'a2a', 'sessions', 'session-batch-1', 'terminal.jsonl');
+
+    const entries = [];
+    for (let i = 0; i < 5; i++) entries.push(appendTerminalData(root, session, `chunk-${i}`, 'stdout'));
+    // The 500ms timer has not fired: nothing on disk yet.
+    assert.equal(fs.existsSync(diskFile), false, 'buffered appends must not hit disk before flush');
+
+    const flushed = flushTerminalBuffer(root, session.sessionId);
+    assert.equal(flushed, 5);
+    const lines = fs.readFileSync(diskFile, 'utf8').trim().split('\n').map((line) => JSON.parse(line));
+    assert.deepEqual(lines.map((line) => line.data), ['chunk-0', 'chunk-1', 'chunk-2', 'chunk-3', 'chunk-4']);
+    assert.deepEqual(lines.map((line) => line.seq), entries.map((entry) => entry.seq));
+    const state = JSON.parse(fs.readFileSync(path.join(root, 'Harness', 'a2a', 'sessions', 'session-batch-1', 'STATE.json'), 'utf8'));
+    assert.equal(state.terminalSeq, entries[4].seq);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('S2 reads flush first: readTerminalRange sees buffered entries', () => {
+  const root = makeRoot('wfui-batch-');
+  try {
+    const session = sessionRecord('session-batch-2');
+    persistSession(root, session);
+    appendTerminalData(root, session, 'visible-after-flush', 'stdout');
+    const { entries } = readTerminalRange(root, { sessionId: session.sessionId });
+    assert.equal(entries.length, 1);
+    assert.equal(entries[0].data, 'visible-after-flush');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('S3 startup downgrade: orphaned live sessions persist as stopped; stopped untouched', () => {
+  const root = makeRoot('wfui-down-');
+  try {
+    persistSession(root, sessionRecord('session-orphan-run', { status: 'running', wsClientCount: 3, attachMode: true }));
+    persistSession(root, sessionRecord('session-orphan-start', { status: 'starting' }));
+    persistSession(root, sessionRecord('session-already-stopped', { status: 'stopped' }));
+
+    const downgraded = downgradeOrphanedDiskSessions(root);
+    assert.deepEqual(downgraded.sort(), ['session-orphan-run', 'session-orphan-start']);
+
+    const run = JSON.parse(fs.readFileSync(path.join(root, 'Harness', 'a2a', 'sessions', 'session-orphan-run', 'STATE.json'), 'utf8'));
+    assert.equal(run.status, 'stopped');
+    assert.equal(run.blockedReason, 'not-managed-by-current-wf-ui');
+    assert.equal(run.wsClientCount, 0);
+    assert.equal(run.attachMode, false);
+    assert.ok(run.orphanedAt);
+    const stopped = JSON.parse(fs.readFileSync(path.join(root, 'Harness', 'a2a', 'sessions', 'session-already-stopped', 'STATE.json'), 'utf8'));
+    assert.equal(stopped.status, 'stopped');
+    assert.equal(stopped.orphanedAt, undefined);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('S4 session index: built at startup, maintained by persistSession, summarized cheaply', () => {
+  const root = makeRoot('wfui-idx-');
+  try {
+    persistSession(root, sessionRecord('session-idx-a', { status: 'stopped' }));
+    assert.equal(buildSessionIndex(root), 1);
+    assert.equal(getSessionIndexSummary().count, 1);
+    const first = getSessionIndexSummary().latestUpdatedAt;
+    assert.ok(first);
+    persistSession(root, sessionRecord('session-idx-b', { status: 'running' }));
+    const summary = getSessionIndexSummary();
+    assert.equal(summary.count, 2);
+    assert.ok(summary.latestUpdatedAt >= first);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('S5 fingerprint: stable when nothing changes, moves when a session writes', () => {
+  const root = makeRoot('wfui-fp-');
+  try {
+    const before = stateFingerprint(root);
+    persistSession(root, sessionRecord('session-fp-1', { status: 'running' }));
+    const after = stateFingerprint(root);
+    assert.notEqual(after, before);
+    assert.equal(stateFingerprint(root), after, 'fingerprint must be deterministic without changes');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('S6 fingerprint must NOT churn with streamed terminal output', () => {
+  // Regression: every terminal chunk used to bump the index updatedAt, so the
+  // snapshot fingerprint changed on each 5s poll while a terminal streamed ->
+  // full snapshot rebuild + canvas re-render -> UI stutter (selection/scroll/
+  // typing hitches). Terminal activity must leave the fingerprint alone.
+  const root = makeRoot('wfui-fp2-');
+  try {
+    const session = sessionRecord('session-fp2-stream', { status: 'running' });
+    persistSession(root, session);
+    const stable = stateFingerprint(root);
+    for (let i = 0; i < 20; i++) appendTerminalData(root, session, `stream-chunk-${i}`, 'stdout');
+    flushTerminalBuffer(root, session.sessionId);
+    assert.equal(stateFingerprint(root), stable, 'streaming must not move the fingerprint');
+
+    persistSession(root, { ...session, status: 'exited' });
+    assert.notEqual(stateFingerprint(root), stable, 'a real status write must move it');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});