create-harness-vibe-coding 0.8.17 → 0.8.19

package/src/wf-ui-server/peer-capsule.mjs

@@ -0,0 +1,213 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { validateTaskId } from './security.mjs';
+
+/**
+ * Validate a peer ID string.
+ * Same rules as taskId: alphanumeric, dash, underscore only, no path traversal.
+ * @param {string} peerId
+ * @returns {boolean}
+ */
+export function validatePeerId(peerId) {
+  // Peer IDs follow the same rules as task IDs
+  return validateTaskId(peerId);
+}
+
+/**
+ * Validate peer capsule identifiers and throw on invalid input.
+ * @param {string} taskId
+ * @param {string} peerId
+ * @throws {Error} If taskId or peerId is invalid
+ */
+function validateIds(taskId, peerId) {
+  if (!validateTaskId(taskId)) {
+    throw new Error(`Invalid taskId: '${taskId}'. Must match [a-zA-Z0-9_-]+`);
+  }
+  if (!validatePeerId(peerId)) {
+    throw new Error(`Invalid peerId: '${peerId}'. Must match [a-zA-Z0-9_-]+`);
+  }
+}
+
+/**
+ * Get the capsule directory path for a peer.
+ * @param {string} projectRoot
+ * @param {string} taskId
+ * @param {string} peerId
+ * @returns {string}
+ */
+function capsuleDir(projectRoot, taskId, peerId) {
+  return path.join(projectRoot, 'Harness', 'tasks', taskId, 'peers', peerId);
+}
+
+/**
+ * Create a peer capsule directory with REQUEST.json and STATE.json.
+ *
+ * @param {string} projectRoot
+ * @param {string} taskId
+ * @param {string} peerId
+ * @param {object} request - The request payload (must include runtime, taskId, peerId)
+ * @returns {{ capsuleDir: string, request: object, state: object }}
+ */
+export function createPeerCapsule(projectRoot, taskId, peerId, request) {
+  validateIds(taskId, peerId);
+
+  const dir = capsuleDir(projectRoot, taskId, peerId);
+  fs.mkdirSync(dir, { recursive: true });
+
+  const requestPayload = {
+    ...request,
+    taskId,
+    peerId,
+    createdAt: new Date().toISOString(),
+  };
+
+  fs.writeFileSync(path.join(dir, 'REQUEST.json'), JSON.stringify(requestPayload, null, 2), 'utf-8');
+
+  const state = {
+    status: 'starting',
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  };
+
+  fs.writeFileSync(path.join(dir, 'STATE.json'), JSON.stringify(state, null, 2), 'utf-8');
+
+  return { capsuleDir: dir, request: requestPayload, state };
+}
+
+/**
+ * Append an event to the peer's events.jsonl file.
+ *
+ * @param {string} projectRoot
+ * @param {string} taskId
+ * @param {string} peerId
+ * @param {object} event
+ */
+export function writePeerEvent(projectRoot, taskId, peerId, event) {
+  validateIds(taskId, peerId);
+
+  const dir = capsuleDir(projectRoot, taskId, peerId);
+  if (!fs.existsSync(dir)) {
+    throw new Error(`Capsule directory does not exist for ${taskId}/${peerId}`);
+  }
+
+  const eventLine = JSON.stringify({
+    ...event,
+    timestamp: event.timestamp || new Date().toISOString(),
+  });
+
+  fs.appendFileSync(path.join(dir, 'events.jsonl'), eventLine + '\n', 'utf-8');
+}
+
+/**
+ * Write a result payload to the peer's RESULT.json file.
+ *
+ * @param {string} projectRoot
+ * @param {string} taskId
+ * @param {string} peerId
+ * @param {object} result
+ */
+export function writePeerResult(projectRoot, taskId, peerId, result) {
+  validateIds(taskId, peerId);
+
+  const dir = capsuleDir(projectRoot, taskId, peerId);
+  if (!fs.existsSync(dir)) {
+    throw new Error(`Capsule directory does not exist for ${taskId}/${peerId}`);
+  }
+
+  const resultPayload = {
+    ...result,
+    completedAt: new Date().toISOString(),
+  };
+
+  fs.writeFileSync(path.join(dir, 'RESULT.json'), JSON.stringify(resultPayload, null, 2), 'utf-8');
+}
+
+/**
+ * Mark a peer as blocked: update STATE.json and write PROGRESS.md with the reason.
+ *
+ * @param {string} projectRoot
+ * @param {string} taskId
+ * @param {string} peerId
+ * @param {string} reason
+ */
+export function blockPeer(projectRoot, taskId, peerId, reason) {
+  validateIds(taskId, peerId);
+
+  const dir = capsuleDir(projectRoot, taskId, peerId);
+  if (!fs.existsSync(dir)) {
+    throw new Error(`Capsule directory does not exist for ${taskId}/${peerId}`);
+  }
+
+  const now = new Date().toISOString();
+
+  // Update STATE.json
+  const statePath = path.join(dir, 'STATE.json');
+  let state = {};
+  if (fs.existsSync(statePath)) {
+    state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+  }
+  state.status = 'blocked';
+  state.blockedReason = reason;
+  state.updatedAt = now;
+  fs.writeFileSync(statePath, JSON.stringify(state, null, 2), 'utf-8');
+
+  // Write PROGRESS.md
+  const progressContent = `# Peer Capsule: ${peerId}
+
+**Status:** BLOCKED
+
+**Block reason:** ${reason}
+
+**Timestamp:** ${now}
+`;
+  fs.writeFileSync(path.join(dir, 'PROGRESS.md'), progressContent, 'utf-8');
+}
+
+/**
+ * Read a peer capsule's files and return the full capsule.
+ *
+ * @param {string} projectRoot
+ * @param {string} taskId
+ * @param {string} peerId
+ * @returns {{ request: object|null, state: object|null, events: object[], result: object|null, progress: string|null }|null}
+ */
+export function getPeerCapsule(projectRoot, taskId, peerId) {
+  validateIds(taskId, peerId);
+
+  const dir = capsuleDir(projectRoot, taskId, peerId);
+  if (!fs.existsSync(dir)) {
+    return null;
+  }
+
+  const readJSON = (filePath) => {
+    if (!fs.existsSync(filePath)) return null;
+    try {
+      return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    } catch {
+      return null;
+    }
+  };
+
+  const readText = (filePath) => {
+    if (!fs.existsSync(filePath)) return null;
+    return fs.readFileSync(filePath, 'utf-8');
+  };
+
+  // Read events from jsonl
+  const eventsPath = path.join(dir, 'events.jsonl');
+  let events = [];
+  if (fs.existsSync(eventsPath)) {
+    const content = fs.readFileSync(eventsPath, 'utf-8').trim();
+    if (content) {
+      events = content.split('\n').map(line => JSON.parse(line));
+    }
+  }
+
+  return {
+    request: readJSON(path.join(dir, 'REQUEST.json')),
+    state: readJSON(path.join(dir, 'STATE.json')),
+    events,
+    result: readJSON(path.join(dir, 'RESULT.json')),
+    progress: readText(path.join(dir, 'PROGRESS.md')),
+  };
+}

package/src/wf-ui-server/pty-adapter.mjs

@@ -0,0 +1,155 @@
+import { ALLOWED_RUNTIMES, generateSessionId } from './session-registry.mjs';
+import path from 'node:path';
+import {
+  getRuntimeDefinition,
+  isRuntimeLaunchable,
+  resolveRuntimeCommand,
+  resolveRuntimeLaunchArgs,
+} from './runtime-detector.mjs';
+
+async function loadPtyModule() {
+  const attempts = [
+    {
+      id: 'node-pty',
+      hint: 'Install node-pty or @homebridge/node-pty-prebuilt-multiarch.',
+      load: () => import('node-pty'),
+    },
+    {
+      id: '@homebridge/node-pty-prebuilt-multiarch',
+      hint: 'Install optional dependency @homebridge/node-pty-prebuilt-multiarch and approve its build scripts for pnpm.',
+      load: () => import('@homebridge/node-pty-prebuilt-multiarch'),
+    },
+  ];
+
+  const errors = [];
+  for (const attempt of attempts) {
+    try {
+      const loaded = await attempt.load();
+      const module = loaded.default || loaded;
+      if (module && typeof module.spawn === 'function') {
+        return { module, provider: attempt.id };
+      }
+      errors.push(`${attempt.id}: spawn export missing`);
+    } catch (err) {
+      errors.push(`${attempt.id}: ${err.message}`);
+    }
+  }
+
+  return {
+    blocked: true,
+    reason: 'pty-adapter-missing',
+    hint: `No PTY backend could be loaded. ${attempts[1].hint}`,
+    details: errors,
+  };
+}
+
+export function resolvePtyCommand(executable, args) {
+  if (process.platform !== 'win32') return { executable, args };
+  const ext = path.extname(executable).toLowerCase();
+  if (ext !== '.cmd' && ext !== '.bat') return { executable, args };
+  return {
+    executable: 'cmd.exe',
+    args: ['/d', '/c', 'call', executable, ...args],
+  };
+}
+
+/**
+ * Spawn a PTY for a given runtime agent.
+ *
+ * Dynamically imports node-pty, then the prebuilt Homebridge fork. If both fail,
+ * returns a BLOCKED response. Never silently falls back to a fake terminal.
+ *
+ * @param {object} opts
+ * @param {string} opts.runtime - Agent runtime (claude, codex, opencode)
+ * @param {string|null} opts.taskId - Optional task ID for the session
+ * @param {string} opts.peerId - Peer identifier
+ * @param {string} opts.projectRoot - Project root directory
+ * @param {string} [opts.command] - Resolved executable command from detector
+ * @param {string[]} [opts.commandArgs] - Extra args appended after runtime launch args
+ * @param {string} [opts.model] - Optional model override for runtimes that support it
+ * @param {number} [opts.cols=120] - Terminal columns
+ * @param {number} [opts.rows=32] - Terminal rows
+ * @param {function} opts.onData - Callback for PTY output data (chunk) => void
+ * @param {function} opts.onExit - Callback for PTY exit ({ exitCode, signal }) => void
+ * @returns {Promise<{sessionId: string, pid: number, ptyProcess: object}|{blocked: boolean, reason: string, hint: string}>}
+ * @throws {Error} If runtime is not in ALLOWED_RUNTIMES
+ */
+export async function spawnPty({
+  runtime,
+  taskId,
+  peerId,
+  projectRoot,
+  sessionId,
+  command,
+  commandArgs = [],
+  model = '',
+  cols = 120,
+  rows = 32,
+  onData,
+  onExit,
+}) {
+  // Validate runtime before anything else
+  if (!ALLOWED_RUNTIMES.has(runtime)) {
+    throw new Error(`Invalid runtime '${runtime}'. Must be one of: ${[...ALLOWED_RUNTIMES].join(', ')}`);
+  }
+
+  const definition = getRuntimeDefinition(runtime);
+  if (!isRuntimeLaunchable(runtime)) {
+    return {
+      blocked: true,
+      reason: 'runtime-adapter-needed',
+      hint: `${definition?.label || runtime} is detectable but does not yet have a launch adapter.`,
+    };
+  }
+
+  const loadedPty = await loadPtyModule();
+  if (loadedPty.blocked) return loadedPty;
+  const nodePty = loadedPty.module;
+
+  const resolvedSessionId = sessionId || generateSessionId();
+
+  const requestedExecutable = command || resolveRuntimeCommand(runtime);
+  const requestedArgs = [...resolveRuntimeLaunchArgs(runtime, { model }), ...commandArgs];
+  const { executable, args: launchArgs } = resolvePtyCommand(requestedExecutable, requestedArgs);
+
+  let ptyProcess;
+  try {
+    ptyProcess = nodePty.spawn(executable, launchArgs, {
+      name: 'xterm-256color',
+      cols,
+      rows,
+      cwd: projectRoot || process.cwd(),
+      env: {
+        ...process.env,
+        HARNESS_PEER_RUNTIME: runtime,
+        CLAUDE_PEER_TASK_ID: taskId || '',
+        HARNESS_PEER_TASK_ID: taskId || '',
+        CLAUDE_PEER_ID: peerId,
+        HARNESS_PEER_SESSION_ID: resolvedSessionId,
+        TERM: 'xterm-256color',
+      },
+    });
+  } catch (err) {
+    return {
+      blocked: true,
+      reason: 'runtime-spawn-failed',
+      hint: `${runtime} executable not found or failed to start: ${err.message}`,
+    };
+  }
+
+  const pid = ptyProcess.pid;
+
+  ptyProcess.onData((data) => {
+    if (typeof onData === 'function') {
+      onData(data);
+    }
+  });
+
+  ptyProcess.onExit(({ exitCode, signal }) => {
+    if (typeof onExit === 'function') {
+      onExit({ exitCode, signal });
+    }
+  });
+
+  return { sessionId: resolvedSessionId, pid, ptyProcess, ptyProvider: loadedPty.provider };
+}

package/src/wf-ui-server/runtime-config.mjs

@@ -0,0 +1,153 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { getRuntimeDefinition } from './runtime-detector.mjs';
+
+function resolveConfigPath(projectRoot, configFile) {
+  const rawPath = configFile.resolvedPath || configFile.path;
+  return path.isAbsolute(rawPath) ? rawPath : path.join(projectRoot, rawPath);
+}
+
+function readJson(filePath) {
+  if (!fs.existsSync(filePath)) return {};
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function atomicWrite(filePath, content) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const tmpPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFileSync(tmpPath, content, 'utf8');
+  fs.renameSync(tmpPath, filePath);
+}
+
+function backupIfExists(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  const backupPath = `${filePath}.${Date.now()}.bak`;
+  fs.copyFileSync(filePath, backupPath);
+  return backupPath;
+}
+
+function getPathValue(object, dottedPath) {
+  const parts = String(dottedPath || '').split('.').filter(Boolean);
+  let current = object;
+  for (const part of parts) {
+    if (!current || typeof current !== 'object' || !(part in current)) return undefined;
+    current = current[part];
+  }
+  return current;
+}
+
+function setPathValue(object, dottedPath, value) {
+  const parts = String(dottedPath || '').split('.').filter(Boolean);
+  if (parts.length === 0) return;
+  let current = object;
+  for (const part of parts.slice(0, -1)) {
+    if (!current[part] || typeof current[part] !== 'object' || Array.isArray(current[part])) {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function readTomlFields(filePath, fields) {
+  if (!fs.existsSync(filePath)) return {};
+  const text = fs.readFileSync(filePath, 'utf8');
+  const values = {};
+  for (const [alias, field] of Object.entries(fields || {})) {
+    if (String(field).includes('.')) continue;
+    const match = text.match(new RegExp(`^\\s*${escapeRegExp(field)}\\s*=\\s*(.*?)\\s*(?:#.*)?$`, 'm'));
+    if (!match) continue;
+    const raw = match[1].trim();
+    values[alias] = raw.replace(/^['"]|['"]$/g, '');
+  }
+  return values;
+}
+
+function updateTomlField(text, field, value) {
+  if (String(field).includes('.')) return text;
+  const nextLine = `${field} = ${JSON.stringify(String(value))}`;
+  const regex = new RegExp(`^\\s*${escapeRegExp(field)}\\s*=\\s*.*$`, 'm');
+  if (regex.test(text)) return text.replace(regex, nextLine);
+  return `${text.replace(/\s*$/, '')}\n${nextLine}\n`;
+}
+
+function configFilesForRuntime(projectRoot, runtimeId) {
+  const definition = getRuntimeDefinition(runtimeId);
+  if (!definition) throw new Error(`Unknown runtime: ${runtimeId}`);
+  return (definition.configFiles || []).map((configFile) => {
+    const absolutePath = resolveConfigPath(projectRoot, configFile);
+    const fields = configFile.fields || {};
+    let values = {};
+    if (configFile.format === 'json') {
+      try {
+        const json = readJson(absolutePath);
+        values = Object.fromEntries(
+          Object.entries(fields)
+            .map(([alias, dottedPath]) => [alias, getPathValue(json, dottedPath)])
+            .filter(([, value]) => value !== undefined),
+        );
+      } catch {
+        values = {};
+      }
+    } else if (configFile.format === 'toml') {
+      values = readTomlFields(absolutePath, fields);
+    }
+
+    return {
+      scope: configFile.scope,
+      path: configFile.path,
+      absolutePath,
+      format: configFile.format,
+      fields,
+      values,
+      exists: fs.existsSync(absolutePath),
+      writable: Object.keys(fields).length > 0,
+    };
+  });
+}
+
+export function readRuntimeConfig(projectRoot, runtimeId) {
+  return {
+    runtime: runtimeId,
+    files: configFilesForRuntime(projectRoot, runtimeId),
+  };
+}
+
+export function writeRuntimeConfig(projectRoot, runtimeId, payload = {}) {
+  const scope = String(payload.scope || 'user');
+  const values = payload.values || {};
+  const configFile = configFilesForRuntime(projectRoot, runtimeId)
+    .find((candidate) => candidate.scope === scope && candidate.writable);
+
+  if (!configFile) throw new Error(`No writable ${scope} config is known for ${runtimeId}`);
+
+  const backupPath = backupIfExists(configFile.absolutePath);
+  if (configFile.format === 'json') {
+    const data = readJson(configFile.absolutePath);
+    for (const [alias, dottedPath] of Object.entries(configFile.fields)) {
+      if (values[alias] !== undefined) setPathValue(data, dottedPath, String(values[alias]));
+    }
+    atomicWrite(configFile.absolutePath, `${JSON.stringify(data, null, 2)}\n`);
+  } else if (configFile.format === 'toml') {
+    let text = fs.existsSync(configFile.absolutePath) ? fs.readFileSync(configFile.absolutePath, 'utf8') : '';
+    for (const [alias, field] of Object.entries(configFile.fields)) {
+      if (values[alias] !== undefined) text = updateTomlField(text, field, values[alias]);
+    }
+    atomicWrite(configFile.absolutePath, text);
+  } else {
+    throw new Error(`Unsupported config format: ${configFile.format}`);
+  }
+
+  return {
+    runtime: runtimeId,
+    scope,
+    path: configFile.path,
+    absolutePath: configFile.absolutePath,
+    backupPath,
+    values,
+  };
+}