create-harness-vibe-coding 0.8.19 → 0.9.3

package/src/wf-ui-server/action-registry.mjs

@@ -0,0 +1,277 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Shared loader for Harness/a2a/action-registry.json.
+ *
+ * Multiple backend modules (ontology, context) plus the CLI read the same
+ * registry. This module centralizes the resolved path, a cached sync read,
+ * validation-on-load, and small query helpers. Consumers wire in later waves.
+ */
+
+// ── Schema enums (exact contract from the action-registry schema; mirrors
+// ── the rules in __tests__/workflow-action-registry.test.mjs) ───────────────
+const NODE_TYPE_ENUM = [
+  'agent',
+  'markdown',
+  'excalidraw',
+  'file',
+  'display',
+  'timer',
+  'goal',
+  'skill-group',
+  'mcp-connector',
+  'github-trigger',
+  'node',
+  'graph',
+];
+const CATEGORY_ENUM = [
+  'lifecycle',
+  'terminal-io',
+  'config',
+  'communication',
+  'graph',
+  'discovery',
+  'resource',
+  'event',
+  'capability',
+  'workspace',
+];
+const PARAM_TYPE_ENUM = ['string', 'number', 'boolean', 'object', 'array'];
+
+// Cache keyed by resolved registry path. `loadActionRegistry` is sync and
+// request-time hot; callers that edit the file (only tests) must call
+// `clearActionRegistryCache` to force a re-read.
+const registryCache = new Map();
+
+/**
+ * Resolve the action-registry file path for a project root.
+ *
+ * @param {string} projectRoot - Absolute path to the project root
+ * @returns {string} Absolute path to Harness/a2a/action-registry.json
+ */
+export function resolveRegistryPath(projectRoot) {
+  return path.resolve(projectRoot, 'Harness', 'a2a', 'action-registry.json');
+}
+
+/**
+ * Load and validate the action registry synchronously, cached per resolved
+ * path. Throws a descriptive error when the file is missing, is invalid
+ * JSON, or fails schema validation.
+ *
+ * @param {string} projectRoot - Absolute path to the project root
+ * @returns {object} Parsed registry { schemaVersion, actions }
+ */
+export function loadActionRegistry(projectRoot) {
+  const registryPath = resolveRegistryPath(projectRoot);
+  const cached = registryCache.get(registryPath);
+  if (cached) {
+    return cached;
+  }
+
+  let raw;
+  try {
+    raw = fs.readFileSync(registryPath, 'utf8');
+  } catch (err) {
+    throw new Error(
+      `Action registry not found at ${registryPath} (expected Harness/a2a/action-registry.json): ${err.message}`,
+    );
+  }
+
+  let registry;
+  try {
+    registry = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`Action registry at ${registryPath} is invalid JSON: ${err.message}`);
+  }
+
+  const result = validateRegistry(registry);
+  if (!result.ok) {
+    throw new Error(
+      `Action registry at ${registryPath} failed validation (${result.errors.length} issue(s)): ${result.errors.slice(0, 5).join('; ')}`,
+    );
+  }
+
+  registryCache.set(registryPath, registry);
+  return registry;
+}
+
+/**
+ * Drop all cached registry reads. Only needed by tests that mutate the
+ * registry file between loads.
+ */
+export function clearActionRegistryCache() {
+  registryCache.clear();
+}
+
+/**
+ * Return the actions for a given node type, in registry order.
+ *
+ * @param {object} registry - Parsed registry from loadActionRegistry
+ * @param {string} nodeType - One of the node-type enum values
+ * @returns {Array<object>} Matching actions (empty array when none)
+ */
+export function actionsForNodeType(registry, nodeType) {
+  return registry.actions.filter((action) => action.nodeType === nodeType);
+}
+
+/**
+ * Look up a single action by id.
+ *
+ * @param {object} registry - Parsed registry from loadActionRegistry
+ * @param {string} id - Action id, e.g. 'agent.sendMessage'
+ * @returns {object|null} The action, or null when not found
+ */
+export function actionById(registry, id) {
+  return registry.actions.find((action) => action.id === id) ?? null;
+}
+
+/**
+ * Deduplicated CLI command list. One entry per distinct cli.command
+ * (first action declaring it wins), shaped for direct consumption by the
+ * CLI surface.
+ *
+ * @param {object} registry - Parsed registry from loadActionRegistry
+ * @returns {Array<{command: string, actionId: string, flags: Array<object>}>}
+ */
+export function cliCommands(registry) {
+  const seen = new Set();
+  const commands = [];
+  for (const action of registry.actions) {
+    if (!action.cli || seen.has(action.cli.command)) {
+      continue;
+    }
+    seen.add(action.cli.command);
+    commands.push({ command: action.cli.command, actionId: action.id, flags: action.cli.flags });
+  }
+  return commands;
+}
+
+/**
+ * Schema-validate a registry without throwing. Applies the same rules as
+ * __tests__/workflow-action-registry.test.mjs: schemaVersion, required
+ * fields, unique ids, nodeType/category enums, params shape, actor shape,
+ * special-flag consistency, and cli shape (when cli is present).
+ *
+ * @param {object} registry - Parsed registry
+ * @returns {{ok: boolean, errors: Array<string>}} Validation result
+ */
+export function validateRegistry(registry) {
+  const errors = [];
+
+  if (registry === null || typeof registry !== 'object' || Array.isArray(registry)) {
+    return { ok: false, errors: ['registry must be an object'] };
+  }
+
+  if (registry.schemaVersion !== 1) {
+    errors.push(`schemaVersion must be 1, got ${JSON.stringify(registry.schemaVersion)}`);
+  }
+  if (!Array.isArray(registry.actions) || registry.actions.length === 0) {
+    errors.push('actions must be a non-empty array');
+    return { ok: false, errors };
+  }
+
+  const ids = new Set();
+  for (const action of registry.actions) {
+    const label = typeof action.id === 'string' ? action.id : '<unknown id>';
+
+    // ── Required fields ──────────────────────────────────────────────────
+    if (typeof action.id !== 'string' || action.id.length === 0) {
+      errors.push(`${label}: id must be a non-empty string`);
+    }
+    if (typeof action.nodeType !== 'string') {
+      errors.push(`${label}: nodeType must be a string`);
+    }
+    if (typeof action.category !== 'string') {
+      errors.push(`${label}: category must be a string`);
+    }
+    if (typeof action.summary !== 'string' || action.summary.length === 0) {
+      errors.push(`${label}: summary must be a non-empty string`);
+    }
+    if (!Array.isArray(action.params)) {
+      errors.push(`${label}: params must be an array`);
+    }
+    if (!action.implementation || typeof action.implementation !== 'object') {
+      errors.push(`${label}: implementation must be an object`);
+    }
+
+    // ── Unique ids ──────────────────────────────────────────────────────
+    if (typeof action.id === 'string') {
+      if (ids.has(action.id)) {
+        errors.push(`${action.id}: duplicate action id`);
+      }
+      ids.add(action.id);
+    }
+
+    // ── Enum values ─────────────────────────────────────────────────────
+    if (typeof action.nodeType === 'string' && !NODE_TYPE_ENUM.includes(action.nodeType)) {
+      errors.push(`${label}: invalid nodeType ${action.nodeType}`);
+    }
+    if (typeof action.category === 'string' && !CATEGORY_ENUM.includes(action.category)) {
+      errors.push(`${label}: invalid category ${action.category}`);
+    }
+
+    // ── Actor shape ─────────────────────────────────────────────────────
+    if (!action.actor || typeof action.actor !== 'object') {
+      errors.push(`${label}: missing actor object`);
+    } else {
+      if (!('spawnGate' in action.actor) || !['root', null].includes(action.actor.spawnGate)) {
+        errors.push(`${label}: actor.spawnGate must be "root" or null`);
+      }
+      for (const key of ['edgeRequired', 'agentAuthored']) {
+        if (typeof action.actor[key] !== 'boolean') {
+          errors.push(`${label}: actor.${key} must be a boolean`);
+        }
+      }
+    }
+
+    // ── Params shape ────────────────────────────────────────────────────
+    if (Array.isArray(action.params)) {
+      const names = new Set();
+      for (const param of action.params) {
+        if (typeof param.name !== 'string' || param.name.length === 0) {
+          errors.push(`${label}: param missing non-empty name`);
+        } else if (names.has(param.name)) {
+          errors.push(`${label}: duplicate param ${param.name}`);
+        } else {
+          names.add(param.name);
+        }
+        if (typeof param.type !== 'string' || !PARAM_TYPE_ENUM.includes(param.type)) {
+          errors.push(`${label}: param ${param.name} has invalid type ${JSON.stringify(param.type)}`);
+        }
+        if (typeof param.required !== 'boolean') {
+          errors.push(`${label}: param ${param.name} missing required flag`);
+        }
+        if (typeof param.description !== 'string') {
+          errors.push(`${label}: param ${param.name} missing description`);
+        }
+      }
+    }
+
+    // ── Special-flag consistency ────────────────────────────────────────
+    const impl = action.implementation;
+    if (impl && typeof impl === 'object') {
+      if (impl.special === true) {
+        if (Object.prototype.hasOwnProperty.call(impl, 'adapter')) {
+          errors.push(`${label}: special action must not declare adapter`);
+        }
+        if (Object.prototype.hasOwnProperty.call(impl, 'export')) {
+          errors.push(`${label}: special action must not declare export`);
+        }
+      } else if (typeof impl.adapter !== 'string' || typeof impl.export !== 'string') {
+        errors.push(`${label}: non-special action needs string adapter and export`);
+      }
+    }
+
+    // ── cli shape (optional per action, but must be complete when present)
+    if (action.cli !== null && action.cli !== undefined) {
+      if (typeof action.cli !== 'object' || typeof action.cli.command !== 'string' || action.cli.command.length === 0) {
+        errors.push(`${label}: cli must be null or an object with a non-empty command`);
+      } else if (!Array.isArray(action.cli.flags)) {
+        errors.push(`${label}: cli.flags must be an array`);
+      }
+    }
+  }
+
+  return { ok: errors.length === 0, errors };
+}

package/src/wf-ui-server/bridge-store.mjs

@@ -0,0 +1,276 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { validateTaskId } from './security.mjs';
+
+const MAX_BRIDGE_LIMIT = 1000;
+
+function normalizeSessionId(sessionId) {
+  const text = String(sessionId || '').trim();
+  if (!validateTaskId(text)) throw new Error(`Invalid sessionId: ${sessionId}`);
+  return text;
+}
+
+function bridgesRoot(projectRoot) {
+  return path.join(projectRoot, 'Harness', 'a2a', 'bridges');
+}
+
+export function bridgeIdForSessions(leftSessionId, rightSessionId) {
+  const left = normalizeSessionId(leftSessionId);
+  const right = normalizeSessionId(rightSessionId);
+  return [left, right].sort().join('__');
+}
+
+function bridgePath(projectRoot, bridgeId) {
+  return path.join(bridgesRoot(projectRoot), `${bridgeId}.jsonl`);
+}
+
+function consumerStatePath(projectRoot, sessionId) {
+  return path.join(bridgesRoot(projectRoot), 'consumers', `${normalizeSessionId(sessionId)}.json`);
+}
+
+function readJsonl(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return [];
+    return fs.readFileSync(filePath, 'utf8')
+      .split(/\r?\n/)
+      .filter(Boolean)
+      .map(line => JSON.parse(line));
+  } catch {
+    return [];
+  }
+}
+
+function appendJsonl(filePath, data) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.appendFileSync(filePath, `${JSON.stringify(data)}\n`, 'utf8');
+}
+
+function readConsumerState(projectRoot, sessionId) {
+  try {
+    const filePath = consumerStatePath(projectRoot, sessionId);
+    if (!fs.existsSync(filePath)) return { schemaVersion: 2, consumedThroughSeq: 0, consumedThroughByBridge: {}, consumedEntries: [] };
+    const raw = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    const consumedThroughByBridge = {};
+    if (raw?.consumedThroughByBridge && typeof raw.consumedThroughByBridge === 'object' && !Array.isArray(raw.consumedThroughByBridge)) {
+      for (const [bridgeId, value] of Object.entries(raw.consumedThroughByBridge)) {
+        const seq = Number(value);
+        if (bridgeId && Number.isFinite(seq) && seq >= 0) consumedThroughByBridge[bridgeId] = Math.floor(seq);
+      }
+    }
+    return {
+      schemaVersion: 2,
+      consumedThroughSeq: Math.max(0, Number(raw?.consumedThroughSeq) || 0),
+      consumedThroughByBridge,
+      consumedEntries: Array.isArray(raw?.consumedEntries)
+        ? [...new Set(raw.consumedEntries.map(value => String(value || '').trim()).filter(Boolean))].slice(-5000)
+        : [],
+    };
+  } catch {
+    return { schemaVersion: 2, consumedThroughSeq: 0, consumedThroughByBridge: {}, consumedEntries: [] };
+  }
+}
+
+function writeConsumerState(projectRoot, sessionId, state) {
+  const filePath = consumerStatePath(projectRoot, sessionId);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify({
+    schemaVersion: 2,
+    consumedThroughSeq: Math.max(0, Number(state.consumedThroughSeq) || 0),
+    consumedThroughByBridge: Object.fromEntries(
+      Object.entries(state.consumedThroughByBridge || {})
+        .filter(([bridgeId, value]) => bridgeId && Number.isFinite(Number(value)) && Number(value) >= 0)
+        .map(([bridgeId, value]) => [bridgeId, Math.floor(Number(value))]),
+    ),
+    consumedEntries: [...new Set(state.consumedEntries || [])].slice(-5000),
+  }, null, 2)}\n`, 'utf8');
+}
+
+function entryCursor(entry) {
+  return `${String(entry?.bridgeId || '')}:${Number(entry?.seq || 0)}`;
+}
+
+export function acknowledgeBridgeMessages(projectRoot, sessionId, consumedThroughSeq, consumedThroughByBridge = null) {
+  const session = normalizeSessionId(sessionId);
+  const requested = Number(consumedThroughSeq);
+  const requestedByBridge = consumedThroughByBridge && typeof consumedThroughByBridge === 'object' && !Array.isArray(consumedThroughByBridge)
+    ? Object.fromEntries(Object.entries(consumedThroughByBridge)
+      .map(([bridgeId, value]) => [String(bridgeId || '').trim(), Number(value)])
+      .filter(([bridgeId, value]) => bridgeId && Number.isFinite(value) && value >= 0)
+      .map(([bridgeId, value]) => [bridgeId, Math.floor(value)]))
+    : {};
+  if ((!Number.isFinite(requested) || requested < 0) && Object.keys(requestedByBridge).length === 0) {
+    return {
+      sessionId: session,
+      ack: false,
+      consumed: false,
+      consumedThroughSeq: readConsumerState(projectRoot, session).consumedThroughSeq,
+      consumedCount: 0,
+    };
+  }
+  const state = readConsumerState(projectRoot, session);
+  const all = listBridgeMessagesForSession(projectRoot, session, {
+    deliveryMode: 'wakeup',
+    limit: MAX_BRIDGE_LIMIT,
+    includeConsumed: true,
+  }).entries;
+  const consumedEntries = new Set(state.consumedEntries);
+  const consumedThrough = { ...(state.consumedThroughByBridge || {}) };
+  const hasPerBridgeRequest = Object.keys(requestedByBridge).length > 0;
+  let consumedCount = 0;
+  for (const entry of all) {
+    const bridgeId = String(entry?.bridgeId || '').trim();
+    const bridgeRequested = hasPerBridgeRequest
+      ? (requestedByBridge[bridgeId] ?? null)
+      : (Number.isFinite(requested) ? Math.floor(requested) : null);
+    if (bridgeRequested !== null && Number(entry?.seq || 0) <= bridgeRequested) {
+      const cursor = entryCursor(entry);
+      if (!consumedEntries.has(cursor)) consumedCount += 1;
+      consumedEntries.add(cursor);
+      consumedThrough[bridgeId] = Math.max(Number(consumedThrough[bridgeId] || 0), bridgeRequested);
+    }
+  }
+  const next = {
+    consumedThroughSeq: Math.max(state.consumedThroughSeq, Number.isFinite(requested) ? Math.floor(requested) : 0),
+    consumedThroughByBridge: consumedThrough,
+    consumedEntries: [...consumedEntries],
+  };
+  writeConsumerState(projectRoot, session, next);
+  return {
+    sessionId: session,
+    ack: true,
+    consumed: true,
+    consumedThroughSeq: next.consumedThroughSeq,
+    consumedSeq: next.consumedThroughSeq,
+    consumedThroughByBridge: next.consumedThroughByBridge,
+    consumedCount,
+  };
+}
+
+export function listBridgeMessages(projectRoot, { fromSessionId, toSessionId, limit = 200 } = {}) {
+  const bridgeId = bridgeIdForSessions(fromSessionId, toSessionId);
+  const max = Math.min(Math.max(Number(limit) || 200, 1), MAX_BRIDGE_LIMIT);
+  const entries = readJsonl(bridgePath(projectRoot, bridgeId)).slice(-max);
+  return {
+    bridgeId,
+    fromSessionId: normalizeSessionId(fromSessionId),
+    toSessionId: normalizeSessionId(toSessionId),
+    entries,
+  };
+}
+
+// List bridge entries for any bridge this session participates in (used for
+// wakeup reads and cross-peer request aggregation; spec 6.1, 5).
+export function listBridgeMessagesForSession(projectRoot, sessionId, {
+  deliveryMode = '',
+  requestId = '',
+  threadId = '',
+  bridgeId = '',
+  afterSeq = null,
+  afterSeqByBridge = null,
+  limit = 200,
+  includeConsumed = false,
+} = {}) {
+  const session = normalizeSessionId(sessionId);
+  const max = Math.min(Math.max(Number(limit) || 200, 1), MAX_BRIDGE_LIMIT);
+  const dir = bridgesRoot(projectRoot);
+  const entries = [];
+  if (fs.existsSync(dir)) {
+    for (const file of fs.readdirSync(dir)) {
+      if (!file.endsWith('.jsonl')) continue;
+      const bridgeId = file.slice(0, -'.jsonl'.length);
+      if (!(bridgeId === session || bridgeId.startsWith(`${session}__`) || bridgeId.endsWith(`__${session}`))) continue;
+      entries.push(...readJsonl(path.join(dir, file)));
+    }
+  }
+  let filtered = entries;
+  if (bridgeId) filtered = filtered.filter(entry => String(entry?.bridgeId || '') === String(bridgeId));
+  if (deliveryMode) filtered = filtered.filter(entry => entry.deliveryMode === deliveryMode);
+  if (requestId) filtered = filtered.filter(entry => entry.requestId === requestId);
+  if (threadId) filtered = filtered.filter(entry => entry.threadId === threadId);
+  const cursorByBridge = afterSeqByBridge && typeof afterSeqByBridge === 'object' && !Array.isArray(afterSeqByBridge)
+    ? Object.fromEntries(Object.entries(afterSeqByBridge)
+      .map(([bridgeId, value]) => [String(bridgeId || '').trim(), Number(value)])
+      .filter(([bridgeId, value]) => bridgeId && Number.isFinite(value) && value >= 0))
+    : {};
+  if (Number.isFinite(Number(afterSeq)) || Object.keys(cursorByBridge).length > 0) {
+    filtered = filtered.filter((entry) => {
+      const bridgeId = String(entry?.bridgeId || '').trim();
+      const cursor = cursorByBridge[bridgeId] ?? (Number.isFinite(Number(afterSeq)) ? Number(afterSeq) : null);
+      return cursor === null || Number(entry.seq || 0) > cursor;
+    });
+  }
+  if (!includeConsumed) {
+    const state = readConsumerState(projectRoot, session);
+    const consumedEntries = new Set(state.consumedEntries);
+    filtered = filtered.filter(entry => !consumedEntries.has(entryCursor(entry)));
+  }
+  filtered.sort((a, b) => {
+    const tsA = String(a.ts || '');
+    const tsB = String(b.ts || '');
+    return tsA === tsB ? (Number(a.seq) || 0) - (Number(b.seq) || 0) : tsA.localeCompare(tsB);
+  });
+  const visible = filtered.slice(-max);
+  const nextCursorByBridge = {};
+  for (const entry of visible) {
+    const bridgeId = String(entry?.bridgeId || '').trim();
+    if (!bridgeId) continue;
+    nextCursorByBridge[bridgeId] = Math.max(Number(nextCursorByBridge[bridgeId] || 0), Number(entry.seq || 0));
+  }
+  return { sessionId: session, entries: visible, cursorByBridge: nextCursorByBridge };
+}
+
+export function recordBridgeMessage(projectRoot, {
+  fromSessionId,
+  toSessionId,
+  fromNodeId = '',
+  toNodeId = '',
+  data = '',
+  source = 'session-input',
+  messageId = '',
+  threadId = '',
+  topic = '',
+  replyTo = '',
+  requestId = '',
+  toRole = '',
+  contextRefs = [],
+  deliveryMode = 'direct',
+  recipientIndex = null,
+  recipientCount = null,
+} = {}) {
+  const from = normalizeSessionId(fromSessionId);
+  const to = normalizeSessionId(toSessionId);
+  if (from === to) return null;
+  const bridgeId = bridgeIdForSessions(from, to);
+  const filePath = bridgePath(projectRoot, bridgeId);
+  const current = readJsonl(filePath);
+  // Message ids are the bridge-level idempotency key. Returning the original
+  // persisted entry keeps retries from creating another mailbox sequence.
+  if (messageId) {
+    const existing = current.find(entry => entry.messageId === String(messageId));
+    if (existing) return existing;
+  }
+  const entry = {
+    seq: current.length + 1,
+    ts: new Date().toISOString(),
+    bridgeId,
+    cursor: `${bridgeId}:${current.length + 1}`,
+    messageId: String(messageId || ''),
+    threadId: String(threadId || ''),
+    topic: String(topic || ''),
+    replyTo: String(replyTo || ''),
+    requestId: String(requestId || ''),
+    toRole: String(toRole || ''),
+    contextRefs: Array.isArray(contextRefs) ? contextRefs : [],
+    deliveryMode: String(deliveryMode || 'direct'),
+    recipientIndex: Number.isFinite(Number(recipientIndex)) ? Number(recipientIndex) : null,
+    recipientCount: Number.isFinite(Number(recipientCount)) ? Number(recipientCount) : null,
+    fromSessionId: from,
+    toSessionId: to,
+    fromNodeId: String(fromNodeId || ''),
+    toNodeId: String(toNodeId || ''),
+    source,
+    data: String(data || ''),
+  };
+  appendJsonl(filePath, entry);
+  return entry;
+}