@wix/agent-skills 1.35.1 → 1.36.1

package/skills/wix-replatform/scripts/replatform-console.js

@@ -1,146 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-// Local-only browser control surface. The CLI remains the migration authority; this process
-// translates a deliberately small HTTP API into argument-array CLI invocations.
-const http = require('node:http');
-const fs = require('node:fs/promises');
-const path = require('node:path');
-const crypto = require('node:crypto');
-const { spawn } = require('node:child_process');
-
-const ROOT = path.resolve(process.env.REPLATFORM_MIGRATIONS_DIR || path.join(process.cwd(), 'migrations'));
-const CLI = path.join(__dirname, 'replatform.js');
-const PUBLIC = path.join(__dirname, '..', 'console');
-const token = crypto.randomBytes(32).toString('base64url');
-const clients = new Map();
-const active = new Map();
-const MAX_BODY = 52 * 1024 * 1024;
-const safeProject = (value) => typeof value === 'string' && /^[A-Za-z0-9][A-Za-z0-9_-]{0,99}$/.test(value);
-const projectPath = (project) => { if (!safeProject(project)) throw new Error('invalid project name'); return path.join(ROOT, project); };
-const cursorPath = (project) => path.join(projectPath(project), 'state', 'runner', 'console-cursor.json');
-
-function parseArgs() {
-  const args = process.argv.slice(2); let port = 4310;
-  for (let i = 0; i < args.length; i += 1) {
-    if (args[i] === '--port') port = Number(args[++i]);
-    else if (args[i] === '--host' && args[++i] !== '127.0.0.1') throw new Error('the console only binds to 127.0.0.1');
-    else if (args[i] !== '--host') throw new Error(`unknown option: ${args[i]}`);
-  }
-  if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error('port must be 1–65535');
-  return port;
-}
-function send(res, status, body) { res.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' }); res.end(JSON.stringify(body)); }
-function originOK(req) { const origin = req.headers.origin; return !origin || origin === `http://127.0.0.1:${server.address().port}`; }
-function authorized(req, url, mutation = false) { return url.searchParams.get('token') === token && (!mutation || originOK(req)); }
-async function body(req) {
-  const chunks = []; let size = 0;
-  for await (const chunk of req) { size += chunk.length; if (size > MAX_BODY) throw new Error('request body is too large'); chunks.push(chunk); }
-  try { return JSON.parse(Buffer.concat(chunks).toString('utf8') || '{}'); } catch { throw new Error('request body must be JSON'); }
-}
-function invoke(args, { onLine } = {}) {
-  return new Promise((resolve) => {
-    const child = spawn(process.execPath, [CLI, ...args], { cwd: process.cwd(), env: process.env, stdio: ['ignore', 'pipe', 'pipe'] });
-    let stdout = ''; let stderr = ''; let partial = '';
-    child.stdout.on('data', (chunk) => { stdout += chunk; partial += chunk; const lines = partial.split('\n'); partial = lines.pop(); for (const line of lines) if (line) onLine?.(line); });
-    child.stderr.on('data', (chunk) => { stderr += chunk; });
-    child.once('close', (code, signal) => resolve({ child, code, signal, stdout, stderr }));
-  });
-}
-async function json(args) {
-  const result = await invoke(args); const line = result.stdout.trim().split('\n').filter(Boolean).at(-1);
-  let value = null; try { value = line ? JSON.parse(line) : null; } catch { /* protocol failure is returned below */ }
-  if (result.code !== 0) throw new Error(value?.message || result.stderr.trim() || `CLI failed (${result.code})`);
-  if (!value) throw new Error('CLI returned no JSON result'); return value;
-}
-function broadcast(project, event) {
-  if (event.eventId) fs.mkdir(path.dirname(cursorPath(project)), { recursive: true }).then(() => fs.writeFile(cursorPath(project), `${JSON.stringify({ schemaVersion: 1, eventId: event.eventId, timestamp: event.timestamp || new Date().toISOString() })}\n`, 'utf8')).catch(() => {});
-  for (const res of clients.get(project) || []) res.write(`id: ${event.eventId || ''}\nevent: migration\ndata: ${JSON.stringify(event)}\n\n`);
-}
-function launch(project, args) {
-  if (active.has(project)) throw new Error('this project already has a console-owned run');
-  const child = spawn(process.execPath, [CLI, ...args], { cwd: process.cwd(), env: process.env, stdio: ['ignore', 'pipe', 'pipe'] });
-  active.set(project, child); let partial = ''; let stderr = ''; let sawResult = false;
-  child.stdout.on('data', (chunk) => { partial += chunk; const lines = partial.split('\n'); partial = lines.pop(); for (const line of lines) {
-    try { const event = JSON.parse(line); if (event.type === 'result') sawResult = true; broadcast(project, event); } catch { broadcast(project, { type: 'protocol_error', message: 'The CLI emitted invalid JSONL.' }); }
-  }});
-  child.stderr.on('data', (chunk) => { stderr += chunk; });
-  child.once('close', (code) => {
-    active.delete(project);
-    if (partial) try { const event = JSON.parse(partial); if (event.type === 'result') sawResult = true; broadcast(project, event); } catch {}
-    if (!sawResult) broadcast(project, { schemaVersion: 1, eventId: `evt_console_${crypto.randomUUID()}`, timestamp: new Date().toISOString(), type: 'result', state: 'failed', message: stderr.trim() || `CLI exited with ${code}`, result: { schemaVersion: 1, runId: null, outcome: 'failed', nextAction: 'Inspect the console diagnostics and correct the reported input or local prerequisite.' } });
-  });
-  return child;
-}
-function runArgs(project, options, resume = false) {
-  const args = [resume ? 'resume' : 'run', projectPath(project), '--format', 'jsonl'];
-  if (resume) return args;
-  const pick = [['sourceUrl', '--source-url'], ['sourceMode', '--source-mode'], ['deliveryMode', '--delivery-mode'], ['destination', '--destination'], ['managementImportMode', '--management-import-mode'], ['agent', '--agent'], ['wallTimeout', '--wall-timeout'], ['idleTimeout', '--idle-timeout'], ['statusInterval', '--status-interval']];
-  for (const [key, flag] of pick) if (options[key] !== undefined && options[key] !== '') args.push(flag, String(options[key]));
-  for (const name of options.files || []) { if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,200}$/.test(name)) throw new Error('invalid uploaded file name'); args.push('--file', path.join(projectPath(project), 'intake', name)); }
-  if (options.oneClick) args.push('--one-click'); if (options.dryRun) args.push('--dry-run'); return args;
-}
-function scrubStatus(value) { if (value?.eventStream) delete value.eventStream.path; return value; }
-function setupCredentialInstructions(project, request) {
-  if (request?.kind !== 'manual_action' || request.stage !== 'setup_provisioning' || request.response?.mode !== 'none') return null;
-  return {
-    command: `cd ${projectPath(project)}\nbash ./scripts/mint-token.sh`,
-    confirmation: 'Wait for the success message confirming that WIX_AUTH_TOKEN was written. The token itself must not be displayed.',
-  };
-}
-async function replay(project, cursor, res) {
-  const args = ['tail', projectPath(project), '--format', 'jsonl']; if (cursor) args.push('--since', cursor);
-  const result = await invoke(args); for (const line of result.stdout.trim().split('\n').filter(Boolean)) { try { const event = JSON.parse(line); res.write(`id: ${event.eventId || ''}\nevent: migration\ndata: ${JSON.stringify(event)}\n\n`); } catch {} }
-}
-async function staticFile(res, name) {
-  const map = { '/': 'index.html', '/app.js': 'app.js', '/app.css': 'app.css', '/json.css': 'json.css', '/account.css': 'account.css' }; const file = map[name];
-  if (!file) return false; const content = await fs.readFile(path.join(PUBLIC, file));
-  res.writeHead(200, { 'content-type': file.endsWith('.js') ? 'text/javascript; charset=utf-8' : file.endsWith('.css') ? 'text/css; charset=utf-8' : 'text/html; charset=utf-8', 'cache-control': 'no-store' }); res.end(content); return true;
-}
-const server = http.createServer(async (req, res) => {
-  const url = new URL(req.url, `http://${req.headers.host}`); const mutation = ['POST', 'PUT', 'DELETE'].includes(req.method);
-  try {
-    // Static assets contain no state or secret. The shell itself remains token-gated.
-    if (req.method === 'GET' && (url.pathname === '/app.js' || url.pathname === '/app.css' || url.pathname === '/json.css' || url.pathname === '/account.css')) return staticFile(res, url.pathname);
-    if (!authorized(req, url, mutation)) return send(res, 403, { error: 'Local console token or origin was rejected.' });
-    if (req.method === 'GET' && !url.pathname.startsWith('/api/')) { if (await staticFile(res, url.pathname)) return; return send(res, 404, { error: 'Not found' }); }
-    if (req.method === 'GET' && url.pathname === '/api/projects') return send(res, 200, await json(['projects', '--format', 'json']));
-    // This transient, token-gated response must never enter migration artifacts or event logs.
-    if (req.method === 'GET' && url.pathname === '/api/account') return send(res, 200, await json(['account', '--format', 'json']));
-    const project = url.searchParams.get('project');
-    if (req.method === 'GET' && url.pathname === '/api/status') return send(res, 200, scrubStatus(await json(['status', projectPath(project), '--format', 'json'])));
-    if (req.method === 'GET' && url.pathname === '/api/tasks') return send(res, 200, await json(['tasks', projectPath(project), '--format', 'json']));
-    if (req.method === 'GET' && url.pathname === '/api/doctor') return send(res, 200, await json(['doctor', '--agent', url.searchParams.get('agent') || 'auto', '--format', 'json']));
-    if (req.method === 'GET' && url.pathname === '/api/requests') return send(res, 200, await json(['requests', projectPath(project), '--format', 'json']));
-    if (req.method === 'GET' && url.pathname === '/api/show') {
-      const item = url.searchParams.get('item'); const cursor = url.searchParams.get('cursor') || '0';
-      const value = await json(['show', projectPath(project), item, '--cursor', cursor, '--max-bytes', '262144', '--format', 'json']);
-      const instructions = /^uar_[0-9a-f-]+$/.test(item || '') ? setupCredentialInstructions(project, value) : null;
-      return send(res, 200, instructions ? { ...value, operatorInstructions: instructions } : value);
-    }
-    if (req.method === 'GET' && url.pathname === '/api/events') {
-      projectPath(project); res.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-cache', connection: 'keep-alive' }); res.write('retry: 2000\n\n');
-      await replay(project, req.headers['last-event-id'] || url.searchParams.get('cursor'), res);
-      const set = clients.get(project) || new Set(); set.add(res); clients.set(project, set); req.once('close', () => { set.delete(res); if (!set.size) clients.delete(project); }); return;
-    }
-    const data = await body(req);
-    if (req.method === 'POST' && url.pathname === '/api/upload') {
-      const dir = path.join(projectPath(data.project), 'intake'); const name = path.basename(String(data.name || ''));
-      if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,200}$/.test(name) || !/^[A-Za-z0-9+/=]*$/.test(data.contentBase64 || '')) throw new Error('invalid upload');
-      const content = Buffer.from(data.contentBase64, 'base64'); if (!content.length || content.length > 50 * 1024 * 1024) throw new Error('upload must be between 1 byte and 50 MB');
-      await fs.mkdir(dir, { recursive: true }); await fs.writeFile(path.join(dir, name), content, { flag: 'wx' }); return send(res, 201, { name });
-    }
-    if (req.method === 'POST' && url.pathname === '/api/run') { const projectName = data.project; launch(projectName, runArgs(projectName, data.options || {}, data.resume === true)); return send(res, 202, { project: projectName, outcome: 'starting' }); }
-    if (req.method === 'POST' && url.pathname === '/api/answer') {
-      projectPath(data.project); const args = ['answer', '--project', projectPath(data.project), '--request-id', String(data.requestId), '--format', 'json'];
-      if (data.choice !== undefined) args.push('--choice', String(data.choice)); else if (data.text !== undefined) args.push('--text', String(data.text)); else if (data.acknowledged === true) args.push('--acknowledge'); else throw new Error('an answer is required');
-      if (data.note !== undefined && data.choice === undefined && data.acknowledged !== true) throw new Error('a note requires a choice or acknowledgement');
-      if (data.note !== undefined) args.push('--note', String(data.note));
-      if (data.continue) { const streamArgs = args.filter((item, index) => !(item === '--format' || (index && args[index - 1] === '--format'))); streamArgs.push('--format', 'jsonl', '--continue'); launch(data.project, streamArgs); return send(res, 202, { project: data.project, outcome: 'resuming' }); }
-      return send(res, 200, await json(args));
-    }
-    if (req.method === 'POST' && url.pathname === '/api/cancel') return send(res, 200, await json(['cancel', projectPath(data.project), '--reason', String(data.reason || 'canceled by operator'), '--format', 'json']));
-    return send(res, 404, { error: 'Not found' });
-  } catch (error) { return send(res, 400, { error: error.message || String(error) }); }
-});
-server.listen(parseArgs(), '127.0.0.1', () => console.log(`RePlatform console: http://127.0.0.1:${server.address().port}/?token=${token}`));

package/skills/wix-replatform/scripts/replatform.js

@@ -1,436 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const fs = require('node:fs/promises');
-const fssync = require('node:fs');
-const path = require('node:path');
-const { spawn } = require('node:child_process');
-const { Command, Option } = require('commander');
-const {
-  RunController, readActive, findRun, requestCancellation, defaultEventsPath, readJson, exitCode,
-} = require('../lib/run-controller.js');
-const { loadArtifacts } = require('../lib/orchestration-state.js');
-const { determineNextStep } = require('../lib/orchestration-router.js');
-const { listUserActions, readUserAction, answerUserAction } = require('../lib/user-actions.js');
-const { writeJsonAtomic } = require('../lib/orchestration-state.js');
-const { chooseAdapter } = require('../lib/agent-adapters/index.js');
-const { defaultProbeWixCli } = require('../lib/orchestration-preflight.js');
-const { readTaskState } = require('../lib/task-state.js');
-const { applyUserActionEffect } = require('../lib/user-action-effects.js');
-
-const VERSION = '0.1.0';
-
-function duration(value, { allowOff = false, min = 0, max = Infinity } = {}) {
-  if (allowOff && (value === undefined || value === 'off')) return null;
-  if (!/^\d+(ms|s|m|h|d)$/.test(String(value))) throw new Error(`invalid duration: ${value}`);
-  const [, amount, unit] = String(value).match(/^(\d+)(ms|s|m|h|d)$/);
-  const multiplier = { ms: 1, s: 1000, m: 60000, h: 3600000, d: 86400000 }[unit];
-  const result = Number(amount) * multiplier;
-  if (result < min || result > max) throw new Error(`duration out of allowed range: ${value}`);
-  return result;
-}
-
-function positive(value, name, fallback) {
-  if (value === undefined) return fallback;
-  if (!/^\d+$/.test(String(value)) || Number(value) < 1) throw new Error(`${name} must be a positive integer`);
-  return Number(value);
-}
-
-function output(value, format = 'text', text = null) {
-  if (format === 'json') process.stdout.write(`${JSON.stringify(value)}\n`);
-  else if (format === 'jsonl') process.stdout.write(`${JSON.stringify(value)}\n`);
-  else process.stdout.write(`${text || JSON.stringify(value, null, 2)}\n`);
-}
-
-function rootDir() { return path.resolve(process.env.REPLATFORM_MIGRATIONS_DIR || path.join(process.cwd(), 'migrations')); }
-async function resolveProject(value) {
-  if (!value) throw new Error('project is required (or set --project)');
-  if (/^rpr_[0-9a-f-]+$/.test(value)) {
-    const record = await findRun(rootDir(), value);
-    if (!record) throw new Error(`run ID not found: ${value}`);
-    return { projectDir: record.projectDir, runId: value };
-  }
-  const candidate = path.resolve(value);
-  // A value with path syntax is a path even before `run` creates its project directory.
-  // Only a bare name is resolved beneath the configured migrations root.
-  if (path.isAbsolute(value) || value.includes(path.sep) || value.startsWith('.')) return { projectDir: candidate, runId: null };
-  if (fssync.existsSync(candidate)) return { projectDir: candidate, runId: null };
-  return { projectDir: path.join(rootDir(), value), runId: null };
-}
-function projectArg(args, index = 1) { return args.project || args._[index]; }
-
-function runtimeOptions(args) {
-  const format = args.format === 'event-stream' ? 'jsonl' : (args.format || 'jsonl');
-  if (!['text', 'json', 'jsonl'].includes(format)) throw new Error('format must be text, json, jsonl, or event-stream');
-  const statusIntervalMs = args.statusInterval === 'off' || (args.detach && args.statusInterval === undefined)
-    ? null : duration(args.statusInterval || '60s', { min: 10000, max: 300000 });
-  if (!['auto', 'codex', 'claude'].includes(args.agent || 'auto')) throw new Error('agent must be auto, codex, or claude');
-  if (args.sourceUrl !== undefined) {
-    let source;
-    try { source = new URL(args.sourceUrl); } catch { throw new Error('source-url must be an https URL'); }
-    if (source.protocol !== 'https:' || source.username || source.password) throw new Error('source-url must be a credential-free https URL');
-  }
-  if (args.sourceMode !== undefined && !['public_content', 'authenticated_api', 'private_data', 'files_only'].includes(args.sourceMode)) throw new Error('invalid source-mode');
-  if (args.deliveryMode !== undefined && !['management', 'website', 'management_and_website'].includes(args.deliveryMode)) throw new Error('invalid delivery-mode');
-  if (args.managementImportMode !== undefined && !['standard', 'quick'].includes(args.managementImportMode)) throw new Error('invalid management-import-mode');
-  if (args.destination !== undefined && !(args.destination === 'new' || /^existing:[A-Za-z0-9_-]+$/.test(args.destination))) throw new Error('destination must be new or existing:<site-id>');
-  // An explicit new-site type, and Harmony's optional business type.
-  if (args.siteType !== undefined && !['headless', 'studio', 'harmony'].includes(args.siteType)) throw new Error('site-type must be headless, studio, or harmony');
-  if (args.siteBusinessType !== undefined && !['store', 'bookings', 'other'].includes(args.siteBusinessType)) throw new Error('site-business-type must be store, bookings, or other');
-  if (args.siteBusinessType !== undefined && args.siteType !== 'harmony') throw new Error('site-business-type is valid only with --site-type harmony');
-  if (args.siteType !== undefined && args.destination !== undefined && args.destination !== 'new') throw new Error('site-type applies only to --destination new');
-  return {
-    agent: args.agent || 'auto', agentPath: args.agentPath, sourceUrl: args.sourceUrl, sourceMode: args.sourceMode,
-    deliveryMode: args.deliveryMode, destination: args.destination, managementImportMode: args.managementImportMode,
-    siteType: args.siteType, siteBusinessType: args.siteBusinessType,
-    fileInputPaths: args.file?.length ? args.file.map((filePath) => path.resolve(filePath)) : undefined,
-    oneClick: args.oneClick, dryRun: args.dryRun, eventsFile: args.eventsFile ? path.resolve(args.eventsFile) : null, vendorEvents: args.vendorEvents ? path.resolve(args.vendorEvents) : null,
-    statusIntervalMs, wallTimeoutMs: duration(args.wallTimeout || 'off', { allowOff: true, min: 60000, max: 7 * 86400000 }),
-    idleTimeoutMs: duration(args.idleTimeout || '15m', { min: 60000, max: 2 * 3600000 }),
-    maxAgentTurns: positive(args.maxAgentTurns, 'max-agent-turns', 12),
-    maxNoProgressContinuations: positive(args.maxNoProgressContinuations, 'max-no-progress-continuations', 1),
-    format,
-  };
-}
-
-function applyApproval(projectDir, request, answer) {
-  return applyUserActionEffect(projectDir, request, answer);
-}
-
-async function runCommand(args, { resume = false, internalRunId = null } = {}) {
-  const target = await resolveProject(projectArg(args));
-  const options = runtimeOptions(args);
-  if (resume && [args.sourceUrl, args.sourceMode, args.file, args.deliveryMode, args.destination, args.managementImportMode, args.siteType, args.siteBusinessType, args.oneClick].some((value) => value !== undefined)) throw new Error('resume does not accept intake mutation options');
-  const controller = new RunController(target.projectDir, { ...options, resume, runId: internalRunId || undefined, onEvent: (event) => {
-    if (options.format === 'jsonl') process.stdout.write(`${JSON.stringify(event)}\n`);
-  } });
-  if (args.detach && !internalRunId) {
-    // The child receives a serialized, already parsed invocation; no shell or prompt is built.
-    const encoded = Buffer.from(JSON.stringify({ project: target.projectDir, options: { ...options, resume, runId: controller.id } })).toString('base64url');
-    const child = spawn(process.execPath, [__filename, '__supervise', encoded], { detached: true, stdio: 'ignore' });
-    child.unref();
-    const result = { schemaVersion: 1, runId: controller.id, project: path.basename(target.projectDir), outcome: 'running', nextAction: `replatform status ${controller.id}` };
-    // Allocate a lookup record before returning; the supervisor will replace it immediately.
-    await fs.mkdir(path.join(target.projectDir, 'state', 'runner', 'runs'), { recursive: true });
-    await writeJsonAtomic(path.join(target.projectDir, 'state', 'runner', 'runs', `${controller.id}.json`), { schemaVersion: 1, runId: controller.id, projectDir: target.projectDir, pid: child.pid, status: 'starting', updatedAt: new Date().toISOString() });
-    output(result, options.format, `Started detached run ${controller.id}.\nStatus: replatform status ${controller.id}`);
-    return 0;
-  }
-  const result = await controller.run();
-  if (options.format === 'json') output(result, 'json');
-  else if (options.format === 'text') output(result, 'text', `${result.outcome}: ${result.router?.reason || 'run finished'}${result.requestId ? `\nRequest: ${result.requestId}\nAnswer: ${result.nextAction}` : ''}`);
-  return exitCode(result);
-}
-
-async function statusCommand(args) {
-  const target = await resolveProject(projectArg(args));
-  const active = await readActive(target.projectDir);
-  const artifacts = await loadArtifacts(target.projectDir);
-  const router = artifacts.run ? await determineNextStep(target.projectDir, artifacts) : null;
-  const historyDir = path.join(target.projectDir, 'state', 'runner', 'runs');
-  let latestRun = target.runId ? await findRun(rootDir(), target.runId) : null;
-  if (!latestRun) {
-    try {
-      const records = await Promise.all((await fs.readdir(historyDir)).filter((name) => name.endsWith('.json')).map((name) => readJson(path.join(historyDir, name))));
-      latestRun = records.filter(Boolean).sort((a, b) => String(b.updatedAt || '').localeCompare(String(a.updatedAt || '')))[0] || null;
-    } catch (error) { if (error.code !== 'ENOENT') throw error; }
-  }
-  const eventPath = active?.eventPath || latestRun?.eventPath || defaultEventsPath(target.projectDir);
-  let lastEvent = null;
-  try { const lines = (await fs.readFile(eventPath, 'utf8')).trim().split('\n').filter(Boolean); if (lines.length) lastEvent = JSON.parse(lines.at(-1)); } catch (error) { if (error.code !== 'ENOENT') throw error; }
-  const result = { schemaVersion: 1, project: path.basename(target.projectDir), activeRun: active ? { runId: active.runId, pid: active.pid, childPid: active.childPid, status: active.status } : null, orchestration: artifacts.run ? { status: artifacts.run.status, state: artifacts.run.currentState } : null, router, eventStream: { path: eventPath, lastEventId: lastEvent?.eventId || null, lastEventAt: lastEvent?.timestamp || null }, latestResult: latestRun?.result || null };
-  output(result, args.format || 'text', active ? `Run ${active.runId}: ${active.status}` : `No active run. ${router?.reason || 'No orchestration state.'}`);
-  return 0;
-}
-
-async function tailCommand(args) {
-  const target = await resolveProject(projectArg(args));
-  const active = await readActive(target.projectDir);
-  const eventFile = active?.eventPath || defaultEventsPath(target.projectDir);
-  const since = args.since;
-  let passedCursor = !since || !/^evt_[0-9a-f-]+$/.test(since);
-  const shouldPrint = (item) => {
-    if (!since) return true;
-    if (/^evt_[0-9a-f-]+$/.test(since)) {
-      if (!passedCursor && item.eventId === since) { passedCursor = true; return false; }
-      return passedCursor;
-    }
-    return Date.parse(item.timestamp) >= Date.now() - duration(since, { min: 0, max: 365 * 86400000 });
-  };
-  const print = async () => {
-    let text; try { text = await fs.readFile(eventFile, 'utf8'); } catch (error) { if (error.code === 'ENOENT') return false; throw error; }
-    const lines = text.trim().split('\n').filter(Boolean);
-    for (const line of lines) {
-      const item = JSON.parse(line); if (!shouldPrint(item)) continue;
-      if ((args.format || 'jsonl') === 'text') process.stdout.write(`${item.timestamp} ${item.type}: ${item.message}\n`);
-      else process.stdout.write(`${line}\n`);
-    }
-    return lines.length;
-  };
-  let known = await print();
-  if (!args.follow) return 0;
-  while (true) {
-    await new Promise((resolve) => setTimeout(resolve, 1000));
-    let text = ''; try { text = await fs.readFile(eventFile, 'utf8'); } catch { continue; }
-    const lines = text.trim().split('\n').filter(Boolean);
-    for (const line of lines.slice(known)) {
-      const item = JSON.parse(line); if (shouldPrint(item)) process.stdout.write(`${line}\n`);
-    }
-    known = lines.length;
-    const current = await readActive(target.projectDir); if (!current) break;
-  }
-  return 0;
-}
-
-function allowedArtifact(requests, target) {
-  const normalized = target.replaceAll('\\', '/');
-  if (normalized.includes('..') || normalized.startsWith('/') || /^(config|state|source|raw)(\/|$)/.test(normalized)) return false;
-  return normalized.includes('/review/') || requests.some((request) => request.artifactRefs.some((ref) => ref.path === normalized));
-}
-async function showCommand(args) {
-  const target = await resolveProject(projectArg(args));
-  const id = args._[2]; if (!id) throw new Error('show requires request-id-or-artifact');
-  if (/^uar_[0-9a-f-]+$/.test(id)) { const request = await readUserAction(target.projectDir, id); output(request, args.format || 'text'); return 0; }
-  const requests = await listUserActions(target.projectDir, {});
-  if (!allowedArtifact(requests.map((row) => ({ ...row, artifactRefs: [] })), id)) {
-    // Index rows intentionally omit refs; read each action before authorizing an artifact.
-    const full = []; for (const row of requests) full.push(await readUserAction(target.projectDir, row.requestId));
-    if (!allowedArtifact(full, id)) throw new Error('artifact is not user-reviewable');
-  }
-  const fullPath = path.resolve(target.projectDir, id);
-  const root = `${path.resolve(target.projectDir)}${path.sep}`;
-  if (!fullPath.startsWith(root)) throw new Error('artifact escapes project');
-  const content = await fs.readFile(fullPath);
-  const max = positive(args.maxBytes, 'max-bytes', 1048576);
-  const cursor = args.cursor === undefined ? 0 : Number(args.cursor);
-  if (!Number.isInteger(cursor) || cursor < 0 || cursor > content.length) throw new Error('cursor must be a valid byte offset');
-  const emitted = content.subarray(cursor, cursor + max); const truncated = cursor + emitted.length < content.length;
-  const fullRequests = []; for (const row of requests) fullRequests.push(await readUserAction(target.projectDir, row.requestId));
-  const mediaType = fullRequests.flatMap((request) => request.artifactRefs).find((ref) => ref.path === id.replaceAll('\\', '/'))?.mediaType || 'text/plain';
-  const result = { schemaVersion: 1, path: id.replaceAll('\\', '/'), mediaType, totalBytes: content.length, cursor, emittedBytes: emitted.length, truncated, nextCursor: truncated ? cursor + emitted.length : null, content: emitted.toString('utf8') };
-  output(result, args.format || 'text', `${result.content}${truncated ? `\nTRUNCATED: showed ${emitted.length}B of ${content.length}B; rerun with --max-bytes ${content.length} or larger.` : ''}`);
-  return 0;
-}
-
-async function requestsCommand(args) {
-  const target = await resolveProject(projectArg(args));
-  const rows = await listUserActions(target.projectDir, { status: args.status || 'pending' });
-  const actions = await Promise.all(rows.map((row) => readUserAction(target.projectDir, row.requestId)));
-  const text = actions.map((action) => {
-    const answer = action.response.mode === 'choice'
-      ? `--choice <${action.choices.map((choice) => choice.id).join('|')}>`
-      : action.response.mode === 'text' ? '--text "<answer>"' : '--acknowledge';
-    const choices = action.response.mode === 'choice'
-      ? `\n  Choices: ${action.choices.map((choice) => `${choice.id} (${choice.label})`).join(', ')}` : '';
-    const next = action.response.mode === 'none'
-      ? `After completing it: replatform answer --project ${target.projectDir} --request-id ${action.requestId} --acknowledge --continue`
-      : `Answer: replatform answer --project ${target.projectDir} --request-id ${action.requestId} ${answer}`;
-    const prompt = action.response.mode === 'none' ? `\n  Required action: ${action.prompt}` : '';
-    return `${action.requestId}: ${action.title} (${action.status})\n  Response: ${action.response.mode}${choices}${prompt}\n  Show: replatform show --project ${target.projectDir} ${action.requestId}\n  Next: ${next}`;
-  }).join('\n\n') || 'No matching user actions.';
-  output(actions, args.format || 'text', text);
-  return 0;
-}
-
-async function tasksCommand(args) {
-  const target = await resolveProject(projectArg(args));
-  const state = await readTaskState(target.projectDir);
-  const active = await readActive(target.projectDir);
-  const result = state || { schemaVersion: 1, runId: active?.runId || target.runId || null, updatedAt: null, tasks: [], agents: [] };
-  output(result, args.format || 'text', result.tasks.length
-    ? result.tasks.map((task) => `${task.state}: ${task.title}`).join('\n')
-    : 'No durable work state has been recorded for this run.');
-  return 0;
-}
-
-async function answerCommand(args) {
-  const target = await resolveProject(projectArg(args)); const requestId = args._[2];
-  if (!requestId) throw new Error('answer requires request id');
-  const variants = [args.choice !== undefined, args.text !== undefined, args.textFile !== undefined, args.acknowledge === true].filter(Boolean).length;
-  if (variants !== 1) throw new Error('answer requires exactly one of --choice, --text, --text-file, --acknowledge');
-  if (args.note !== undefined && args.choice === undefined && !args.acknowledge) throw new Error('note is supported only with a choice or acknowledgement');
-  const answer = args.acknowledge ? { acknowledged: true, ...(args.note !== undefined ? { note: args.note } : {}) } : args.choice !== undefined ? { choice: args.choice, ...(args.note !== undefined ? { note: args.note } : {}) } : { text: args.textFile ? await fs.readFile(path.resolve(args.textFile), 'utf8') : args.text };
-  const result = await answerUserAction(target.projectDir, requestId, answer, { applyEffect: (request, normalized) => applyApproval(target.projectDir, request, normalized) });
-  if (!args.continue) { output(result, args.format || 'text', `Answered ${requestId}. Resume: replatform resume ${target.projectDir}`); return 0; }
-  args._ = ['run', target.projectDir]; args.project = target.projectDir; return runCommand(args, { resume: true });
-}
-
-async function doctorCommand(args) {
-  const value = projectArg(args); const target = value ? await resolveProject(value) : null;
-  const ids = args.agent && args.agent !== 'auto' ? [args.agent] : ['codex', 'claude'];
-  const adapters = ids.map((id) => chooseAdapter(id, { agentPath: args.agentPath }));
-  const active = target ? await readActive(target.projectDir) : null;
-  const result = { schemaVersion: 1, node: process.version, project: target?.projectDir || null, writable: target ? await fs.access(target.projectDir, fssync.constants.W_OK).then(() => true).catch(() => false) : null, adapters, activeRun: active };
-  output(result, args.format || 'text', adapters.map((a) => `${a.id || args.agent}: ${a.ok ? 'available' : a.reason}`).join('\n'));
-  return adapters.some((item) => item.ok) ? 0 : 2;
-}
-
-async function projectsCommand(args) {
-  const root = rootDir();
-  let entries;
-  try { entries = await fs.readdir(root, { withFileTypes: true }); } catch (error) {
-    if (error.code === 'ENOENT') { output({ schemaVersion: 1, projects: [] }, args.format || 'text', 'No migration projects.'); return 0; }
-    throw error;
-  }
-  const projects = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory() || entry.name.startsWith('.')) continue;
-    const projectDir = path.join(root, entry.name); const artifacts = await loadArtifacts(projectDir);
-    if (!artifacts.run && !fssync.existsSync(path.join(projectDir, 'state', 'runner'))) continue;
-    const active = await readActive(projectDir);
-    const router = artifacts.run ? await determineNextStep(projectDir, artifacts) : null;
-    projects.push({ project: entry.name, activeRun: active ? { runId: active.runId, status: active.status } : null, orchestration: artifacts.run ? { status: artifacts.run.status, state: artifacts.run.currentState } : null, router: router ? { state: router.nextState, reason: router.reason } : null });
-  }
-  projects.sort((a, b) => a.project.localeCompare(b.project));
-  output({ schemaVersion: 1, projects }, args.format || 'text', projects.map((item) => item.project).join('\n') || 'No migration projects.');
-  return 0;
-}
-
-async function accountCommand(args) {
-  const wixCli = await defaultProbeWixCli();
-  const result = {
-    schemaVersion: 1,
-    available: wixCli.available,
-    authState: wixCli.authState,
-    ...(wixCli.identity || wixCli.email ? { identity: wixCli.identity || wixCli.email } : {}),
-    ...(wixCli.reason ? { reason: wixCli.reason } : {}),
-  };
-  const confirmed = result.authState === 'authenticated' && Boolean(result.identity);
-  output(result, args.format || 'text', confirmed
-    ? `Authenticated Wix CLI identity: ${result.identity}`
-    : `Wix CLI identity could not be confirmed: ${result.reason || 'unknown'}`);
-  return confirmed ? 0 : 2;
-}
-
-function commandArgs(command, positional, options) {
-  return { ...options, _: [command, ...(positional === undefined ? [] : [positional])] };
-}
-
-function addRuntimeOptions(command, { intake = false } = {}) {
-  command
-    .addHelpText('after', '\nThis command is non-interactive: it never prompts, opens a pager/editor/browser/login, or waits for stdin.\n')
-    .addOption(new Option('--agent <id>', 'auto selects a compatible adapter (Codex first); codex and claude require that exact adapter.').choices(['auto', 'codex', 'claude']).default('auto'))
-    .option('--agent-path <path>', 'adapter executable override (testing/development)')
-    .addOption(new Option('--format <format>', 'jsonl streams lifecycle events (default); json emits one final result; text is human-readable; event-stream aliases jsonl.').choices(['text', 'json', 'jsonl', 'event-stream']).default('jsonl'))
-    .option('--status-interval <duration>', 'liveness heartbeat interval: 60s foreground by default, off detached; use off to disable')
-    .option('--events-file <path>', 'write normalized JSONL events to this file')
-    .option('--vendor-events <path>', 'write raw vendor events to this diagnostic file')
-    .option('--wall-timeout <duration>', 'whole-run deadline; use off to disable')
-    .option('--idle-timeout <duration>', 'maximum time without observed progress')
-    .option('--max-agent-turns <count>', 'maximum agent turns in this supervisor run')
-    .option('--max-no-progress-continuations <count>', 'maximum same-route retries')
-    .option('--detach', 'start the supervisor in the background')
-    .option('--no-resume-agent-session', 'do not reuse an adapter session when supported');
-  if (intake) {
-    command
-      .option('--source-url <https-url>', 'source URL; credentials are rejected')
-      .addOption(new Option('--source-mode <mode>', 'public_content reads public pages; authenticated_api uses normal source API access; private_data needs protected credentials; files_only imports supplied files.').choices(['public_content', 'authenticated_api', 'private_data', 'files_only']))
-      .option('--file <path>', 'input file for files_only mode; repeat for each source file', (value, previous) => [...(previous || []), value])
-      .addOption(new Option('--delivery-mode <mode>', 'management migrates backend data; website migrates the frontend only; management_and_website performs both.').choices(['management', 'website', 'management_and_website']))
-      .option('--destination <strategy>', 'new creates a site; existing:<site-id> adopts the named existing site')
-      .addOption(new Option('--site-type <type>', 'type of a new destination site: headless (website in code), studio or harmony (website designed in a Wix editor). Required before a new site is created; never defaulted.').choices(['headless', 'studio', 'harmony']))
-      .addOption(new Option('--site-business-type <type>', 'with --site-type harmony only: store, bookings or other records the business context for the run. It does not change how the site is created: Harmony always starts from the blank template.').choices(['store', 'bookings', 'other']))
-      .addOption(new Option('--management-import-mode <mode>', 'standard uses the full discovery/mapping flow; quick uses a public adapter and bounded plan.').choices(['standard', 'quick']))
-      .option('--one-click', 'record an explicit user one-click decision')
-      .option('--dry-run', 'request the existing dry-run execution path');
-  }
-  return command;
-}
-
-async function cancelCommand(args) {
-  const target = await resolveProject(projectArg(args));
-  const gracePeriodMs = duration(args.gracePeriod || '60s', { min: 5000, max: 600000 });
-  const result = await requestCancellation(target.projectDir, { reason: args.reason || 'canceled by operator', gracePeriodMs });
-  if (args.wait !== false) {
-    const deadline = Date.now() + gracePeriodMs + 5000;
-    while (Date.now() < deadline && await readActive(target.projectDir)) await new Promise((resolve) => setTimeout(resolve, 250));
-    const record = await readJson(path.join(target.projectDir, 'state', 'runner', 'runs', `${result.active.runId}.json`));
-    if (record?.result) { output(record.result, args.format || 'text', `${record.result.outcome}: cancellation finished.`); return exitCode(record.result); }
-  }
-  output(result, args.format || 'text', `Cancellation requested for ${result.active.runId}.`);
-  return 0;
-}
-
-function setExit(handler) {
-  return async (...values) => { process.exitCode = await handler(...values); };
-}
-
-function createProgram() {
-  const program = new Command();
-  program
-    .name('replatform')
-    .description('Non-interactive supervisor for artifact-first RePlatform migrations.')
-    .version(VERSION, '--version', 'print the CLI version')
-    .showHelpAfterError('(all commands are non-interactive; they never prompt, open a pager, or wait for stdin)')
-    .addHelpText('after', '\nPurpose: the CLI supervises an agent using wix-replatform; it does not replace the skill or migration receipts.\nFull guide: CLI.md alongside this installed wix-replatform bundle.\nExit codes: 0 completed, 1 failed, 2 invalid input, 3 waiting for user, 4 blocked, 5 canceled/interrupted, 6 timeout.\n');
-
-  addRuntimeOptions(program.command('run [project]').description('Start a non-interactive foreground supervised migration run.').option('--project <path>', 'project directory'), { intake: true })
-    .action(setExit((project, options) => runCommand(commandArgs('run', project, options))));
-  addRuntimeOptions(program.command('resume [project]').description('Resume an unfinalized migration project non-interactively.').option('--project <path>', 'project directory'), { intake: false })
-    .action(setExit((project, options) => runCommand(commandArgs('resume', project, options), { resume: true })));
-  program.command('status [project-or-run-id]').description('Read durable orchestration and runner state.').option('--project <path>', 'project directory').addOption(new Option('--format <format>', 'stdout format').choices(['text', 'json']).default('text'))
-    .action(setExit((project, options) => statusCommand(commandArgs('status', project, options))));
-  program.command('tail [project-or-run-id]').description('Render normalized runner events without a pager.').option('--project <path>', 'project directory').option('--follow', 'wait for events until the run terminates').option('--since <event-id-or-duration>', 'exclusive event cursor or inclusive duration window').addOption(new Option('--format <format>', 'stdout format').choices(['jsonl', 'text']).default('jsonl'))
-    .action(setExit((project, options) => tailCommand(commandArgs('tail', project, options))));
-  program.command('cancel <project-or-run-id>').description('Request supervised cancellation of a live run.').option('--project <path>', 'project directory').option('--grace-period <duration>', 'grace period before forced termination', '60s').option('--no-wait', 'return after durable acknowledgement').option('--reason <text>', 'operator-visible reason', 'canceled by operator').addOption(new Option('--format <format>', 'stdout format').choices(['text', 'json']).default('text'))
-    .action(setExit((project, options) => cancelCommand(commandArgs('cancel', project, options))));
-  program.command('doctor [project-or-run-id]').description('Check local agent and project-run capability without exposing credentials.').option('--project <path>', 'project directory').addOption(new Option('--agent <id>', 'agent adapter').choices(['auto', 'codex', 'claude']).default('auto')).option('--agent-path <path>', 'adapter executable override').addOption(new Option('--format <format>', 'stdout format').choices(['text', 'json']).default('text'))
-    .action(setExit((project, options) => doctorCommand(commandArgs('doctor', project, options))));
-  program.command('requests [project-or-run-id]').description('List durable human actions.').option('--project <path>', 'project directory').addOption(new Option('--status <status>', 'request status').choices(['pending', 'answered', 'canceled']).default('pending')).option('--since <duration>', 'only actions since this duration').addOption(new Option('--format <format>', 'stdout format').choices(['text', 'json']).default('text'))
-    .action(setExit((project, options) => requestsCommand(commandArgs('requests', project, options))));
-  program.command('tasks [project-or-run-id]').description('Read persisted operator-facing work state.').option('--project <path>', 'project directory').addOption(new Option('--format <format>', 'stdout format').choices(['text', 'json']).default('text'))
-    .action(setExit((project, options) => tasksCommand(commandArgs('tasks', project, options))));
-  program.command('show [project-or-run-id] [request-id-or-artifact]').description('Print a durable action or authorized review artifact. With --project, supply the item positionally.').option('--project <path>', 'project directory').option('--max-bytes <count>', 'maximum emitted bytes', '1048576').option('--cursor <byte-offset>', 'artifact byte offset', '0').addOption(new Option('--format <format>', 'stdout format').choices(['text', 'json']).default('text'))
-    .action(setExit((first, second, options) => {
-      const item = second || (options.project ? first : null);
-      const project = options.project || (second ? first : null);
-      if (!item) throw new Error('show requires request-id-or-artifact');
-      return showCommand({ ...options, project, _: ['show', project, item] });
-    }));
-  addRuntimeOptions(program.command('answer [project-or-run-id] [request-id]').description('Record one immutable human response. With --project, supply the request ID positionally or through --request-id.').option('--project <path>', 'project directory').option('--request-id <id>', 'durable user-action request ID').option('--choice <choice-id>', 'declared choice ID').option('--note <text>', 'optional reviewer or acknowledgement note').option('--text <text>', 'free-text answer').option('--text-file <path>', 'UTF-8 answer file').option('--acknowledge', 'state that a required manual action was completed; the resumed stage must verify it').option('--continue', 'start a foreground resume after recording the answer'), { intake: false })
-    .action(setExit((first, second, options) => {
-      const requestId = options.requestId || second || (options.project ? first : null);
-      const project = options.project || (second ? first : null);
-      if (!requestId) throw new Error('answer requires request-id (positional or --request-id)');
-      return answerCommand({ ...options, project, _: ['answer', project, requestId] });
-    }));
-  program.command('projects').description('List migration projects beneath the configured migrations root.').addOption(new Option('--format <format>', 'stdout format').choices(['text', 'json']).default('text'))
-    .action(setExit((options) => projectsCommand(options)));
-  program.command('account').description('Report the identity currently authenticated in the local Wix CLI.').addOption(new Option('--format <format>', 'stdout format').choices(['text', 'json']).default('text'))
-    .action(setExit((options) => accountCommand(options)));
-  program.command('completion <shell>').description('Print static completion for bash, zsh, or fish.')
-    .action((shell) => {
-      if (!['bash', 'zsh', 'fish'].includes(shell)) throw new Error('completion requires bash, zsh, or fish');
-      const commands = 'run resume status tail cancel doctor requests tasks show answer projects account help completion';
-      if (shell === 'bash') process.stdout.write(`_replatform() { COMPREPLY=( $(compgen -W '${commands}' -- "${'${COMP_WORDS[1]}'}") ); }\ncomplete -F _replatform replatform\n`);
-      if (shell === 'zsh') process.stdout.write(`#compdef replatform\n_arguments '1:command:(${commands})' '*::arg:->args'\n`);
-      if (shell === 'fish') process.stdout.write(`${commands.split(' ').map((item) => `complete -c replatform -f -a ${item}`).join('\n')}\n`);
-    });
-  program.command('__supervise <payload>', { hidden: true }).action(setExit(async (payload) => {
-    const data = JSON.parse(Buffer.from(payload, 'base64url').toString('utf8'));
-    const controller = new RunController(data.project, { ...data.options, onEvent: () => {} });
-    return exitCode(await controller.run());
-  }));
-  return program;
-}
-
-async function main(argv = process.argv.slice(2)) {
-  const program = createProgram();
-  // Commander remains the single formatter. JSON wraps its generated help for callers
-  // that need discovery without parsing terminal columns.
-  if (argv[0] === 'help' && argv.includes('--format')) {
-    const format = argv[argv.indexOf('--format') + 1];
-    if (!['text', 'json'].includes(format)) throw new Error('help format must be text or json');
-    const requested = argv.slice(1).find((item) => !item.startsWith('-'));
-    const target = requested ? program.commands.find((command) => command.name() === requested) : program;
-    if (requested && !target) throw new Error(`unknown command: ${requested}`);
-    const helpText = target.helpInformation();
-    output({ schemaVersion: 1, command: requested || null, help: helpText }, format, helpText);
-    return 0;
-  }
-  await program.parseAsync(['node', 'replatform', ...argv]);
-  return process.exitCode || 0;
-}
-
-if (require.main === module) main().catch((error) => { process.stderr.write(`${error.message}\n`); process.exitCode = 2; });
-module.exports = { main, createProgram, duration, runtimeOptions, resolveProject, allowedArtifact, accountCommand, tasksCommand };