ninja-terminals 2.3.1 → 2.3.2

package/ninja-codex.js

@@ -0,0 +1,474 @@
+#!/usr/bin/env node
+'use strict';
+
+const { spawnSync } = require('child_process');
+const path = require('path');
+const {
+  readAuthToken,
+  readRuntimeSession,
+  requestJson,
+} = require('./lib/runtime-session');
+
+const USAGE = `
+Usage:
+  ninja-codex ensure [args...]
+  ninja-codex visual [args...]
+  ninja-codex dispatch <terminal-id> <message...>
+  ninja-codex status
+  ninja-codex task-status [terminal-id]
+  ninja-codex output <terminal-id> [--lines N]
+  ninja-codex gate [--since <duration|iso>] [--json]
+  ninja-codex run --terminal <id> --task "<message>" [--timeout 120000] [--expect-task done] [--lines 80]
+  ninja-codex squad --task "<message>" [--terminals 1,2,3,4] [--roles implement,test,review,docs] [--timeout 180000]
+
+Codex wrapper around the Ninja evidence loop.
+
+The run workflow:
+  1. ninja-ensure
+  2. ninja-codex-visual --record pre-dispatch
+  3. agent-send <terminal-id> <task>
+  4. wait for semantic task status done/blocked/error
+  5. agent-send --task-status <terminal-id>
+  6. agent-send --output <terminal-id>
+  7. ninja-codex-visual --record post-output --terminal <id> --expect-task <state>
+  8. ninja-gate --since <workflow start timestamp>
+
+The squad workflow dispatches role-scoped variants of one task to multiple
+terminals, waits for all semantic task statuses to finish, collects output from
+each terminal, records per-terminal visual evidence, then runs ninja-gate.
+`;
+
+const COMPLETE_TASK_STATES = ['done', 'blocked', 'error'];
+const READY_PROCESS_STATES = ['idle', 'stuck', 'done', 'blocked', 'error'];
+const DEFAULT_SQUAD_TERMINALS = ['1', '2', '3', '4'];
+const DEFAULT_SQUAD_ROLES = ['implementer', 'tester', 'reviewer', 'documenter'];
+
+function script(name) {
+  return path.join(__dirname, name);
+}
+
+function runNode(scriptName, args, options = {}) {
+  const res = spawnSync(process.execPath, [script(scriptName), ...args], {
+    cwd: __dirname,
+    stdio: options.capture ? ['ignore', 'pipe', 'pipe'] : 'inherit',
+    encoding: 'utf8',
+  });
+
+  if (options.capture) {
+    return res;
+  }
+
+  if (res.status !== 0) {
+    process.exit(res.status || 1);
+  }
+  return res;
+}
+
+function parseRunArgs(argv) {
+  const opts = {
+    terminalId: null,
+    task: null,
+    timeoutMs: 120000,
+    readyTimeoutMs: 60000,
+    pollMs: 2000,
+    expectTask: 'done',
+    lines: 80,
+    screenshot: false,
+    noOpen: false,
+  };
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--terminal') {
+      opts.terminalId = argv[++i];
+    } else if (arg === '--task') {
+      opts.task = argv[++i];
+    } else if (arg === '--timeout') {
+      opts.timeoutMs = Number.parseInt(argv[++i], 10);
+    } else if (arg === '--ready-timeout') {
+      opts.readyTimeoutMs = Number.parseInt(argv[++i], 10);
+    } else if (arg === '--poll') {
+      opts.pollMs = Number.parseInt(argv[++i], 10);
+    } else if (arg === '--expect-task') {
+      opts.expectTask = argv[++i];
+    } else if (arg === '--lines') {
+      opts.lines = Number.parseInt(argv[++i], 10);
+    } else if (arg === '--screenshot') {
+      opts.screenshot = true;
+    } else if (arg === '--no-open') {
+      opts.noOpen = true;
+    } else {
+      throw new Error(`Unknown run argument: ${arg}`);
+    }
+  }
+
+  if (!opts.terminalId || !/^\d+$/.test(String(opts.terminalId))) {
+    throw new Error('run requires --terminal <numeric-id>');
+  }
+  if (!opts.task) throw new Error('run requires --task "<message>"');
+  if (!Number.isInteger(opts.timeoutMs) || opts.timeoutMs < 1000) {
+    throw new Error('--timeout must be an integer >= 1000');
+  }
+  if (!Number.isInteger(opts.readyTimeoutMs) || opts.readyTimeoutMs < 1000) {
+    throw new Error('--ready-timeout must be an integer >= 1000');
+  }
+  if (!Number.isInteger(opts.pollMs) || opts.pollMs < 250) {
+    throw new Error('--poll must be an integer >= 250');
+  }
+  if (!Number.isInteger(opts.lines) || opts.lines < 1) {
+    throw new Error('--lines must be an integer >= 1');
+  }
+
+  return opts;
+}
+
+function parseList(value, flagName) {
+  if (!value) throw new Error(`${flagName} requires a comma-separated value`);
+  return String(value)
+    .split(',')
+    .map(v => v.trim())
+    .filter(Boolean);
+}
+
+function parseSquadArgs(argv) {
+  const opts = {
+    terminalIds: DEFAULT_SQUAD_TERMINALS.slice(),
+    roles: DEFAULT_SQUAD_ROLES.slice(),
+    task: null,
+    timeoutMs: 180000,
+    readyTimeoutMs: 120000,
+    pollMs: 2000,
+    expectTask: null,
+    lines: 80,
+    screenshot: false,
+    noOpen: false,
+  };
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--terminals') {
+      opts.terminalIds = parseList(argv[++i], '--terminals');
+    } else if (arg === '--roles') {
+      opts.roles = parseList(argv[++i], '--roles');
+    } else if (arg === '--task') {
+      opts.task = argv[++i];
+    } else if (arg === '--timeout') {
+      opts.timeoutMs = Number.parseInt(argv[++i], 10);
+    } else if (arg === '--ready-timeout') {
+      opts.readyTimeoutMs = Number.parseInt(argv[++i], 10);
+    } else if (arg === '--poll') {
+      opts.pollMs = Number.parseInt(argv[++i], 10);
+    } else if (arg === '--expect-task') {
+      opts.expectTask = argv[++i];
+    } else if (arg === '--lines') {
+      opts.lines = Number.parseInt(argv[++i], 10);
+    } else if (arg === '--screenshot') {
+      opts.screenshot = true;
+    } else if (arg === '--no-open') {
+      opts.noOpen = true;
+    } else {
+      throw new Error(`Unknown squad argument: ${arg}`);
+    }
+  }
+
+  if (opts.terminalIds.length === 0) throw new Error('squad requires at least one terminal');
+  for (const terminalId of opts.terminalIds) {
+    if (!/^\d+$/.test(String(terminalId))) {
+      throw new Error(`--terminals must contain numeric ids, got: ${terminalId}`);
+    }
+  }
+  if (!opts.task) throw new Error('squad requires --task "<message>"');
+  if (!Number.isInteger(opts.timeoutMs) || opts.timeoutMs < 1000) {
+    throw new Error('--timeout must be an integer >= 1000');
+  }
+  if (!Number.isInteger(opts.readyTimeoutMs) || opts.readyTimeoutMs < 1000) {
+    throw new Error('--ready-timeout must be an integer >= 1000');
+  }
+  if (!Number.isInteger(opts.pollMs) || opts.pollMs < 250) {
+    throw new Error('--poll must be an integer >= 250');
+  }
+  if (!Number.isInteger(opts.lines) || opts.lines < 1) {
+    throw new Error('--lines must be an integer >= 1');
+  }
+
+  return opts;
+}
+
+function squadPrompt({ role, terminalId, task }) {
+  return [
+    `You are T${terminalId}, the ${role} in a Codex terminal squad.`,
+    `Task: ${task}`,
+    '',
+    'Work independently in your assigned role. Keep changes scoped to your role.',
+    'When finished, print exactly one final status line at the start of a new line.',
+    'The final line format is: the word STATUS, then a colon, then DONE, then a short result.',
+    '',
+    'If blocked, use the same format with BLOCKED instead of DONE and include a short reason.',
+  ].join('\n');
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function getToken(session) {
+  return process.env.NINJA_AUTH_TOKEN || session?.authToken || readAuthToken();
+}
+
+function resolveRuntimeSession() {
+  const session = readRuntimeSession() || {};
+  const port = process.env.NINJA_PORT || session.port;
+  if (!port) throw new Error('No Ninja session found. Run ninja-codex ensure first.');
+  return {
+    ...session,
+    host: process.env.NINJA_HOST || session.host || 'localhost',
+    port: Number.parseInt(port, 10),
+    authToken: process.env.NINJA_AUTH_TOKEN || session.authToken,
+  };
+}
+
+function primeRuntimeEnv() {
+  const session = resolveRuntimeSession();
+  process.env.NINJA_HOST = session.host || 'localhost';
+  process.env.NINJA_PORT = String(session.port);
+  const token = getToken(session);
+  if (token) process.env.NINJA_AUTH_TOKEN = token;
+  return session;
+}
+
+async function fetchTaskStatus(terminalId) {
+  const session = resolveRuntimeSession();
+  const token = getToken(session);
+  if (!token) throw new Error('No Ninja auth token. Run: ninja-login');
+
+  const res = await requestJson({
+    host: session.host || 'localhost',
+    port: session.port,
+    path: `/api/terminals/${terminalId}/task-status`,
+    token,
+    timeoutMs: 3000,
+  });
+
+  if (res.statusCode !== 200 || !res.body) {
+    throw new Error(`Task status API failed: HTTP ${res.statusCode}`);
+  }
+  return res.body;
+}
+
+async function fetchProcessStatus(terminalId) {
+  const session = resolveRuntimeSession();
+  const token = getToken(session);
+  if (!token) throw new Error('No Ninja auth token. Run: ninja-login');
+
+  const res = await requestJson({
+    host: session.host || 'localhost',
+    port: session.port,
+    path: `/api/terminals/${terminalId}/status`,
+    token,
+    timeoutMs: 3000,
+  });
+
+  if (res.statusCode !== 200 || !res.body) {
+    throw new Error(`Process status API failed: HTTP ${res.statusCode}`);
+  }
+  return res.body;
+}
+
+async function fetchOutputLines(terminalId, lines = 40) {
+  const session = resolveRuntimeSession();
+  const token = getToken(session);
+  if (!token) throw new Error('No Ninja auth token. Run: ninja-login');
+
+  const res = await requestJson({
+    host: session.host || 'localhost',
+    port: session.port,
+    path: `/api/terminals/${terminalId}/output?lines=${lines}`,
+    token,
+    timeoutMs: 3000,
+  });
+
+  if (res.statusCode !== 200 || !res.body) return [];
+  return Array.isArray(res.body.lines) ? res.body.lines : [];
+}
+
+function hasPromptVisible(lines) {
+  const text = lines.join('\n');
+  return text.includes('❯') && text.includes('⏵⏵');
+}
+
+async function waitForTerminalReady(terminalId, opts) {
+  const deadline = Date.now() + opts.readyTimeoutMs;
+  let last = null;
+
+  while (Date.now() < deadline) {
+    last = await fetchProcessStatus(terminalId);
+    if (last.status && READY_PROCESS_STATES.includes(last.status)) {
+      return last;
+    }
+    const lines = await fetchOutputLines(terminalId, 40);
+    if (hasPromptVisible(lines)) {
+      return { ...last, readiness: 'prompt-visible' };
+    }
+    await sleep(opts.pollMs);
+  }
+
+  throw new Error(`Timed out waiting for T${terminalId} to become dispatch-ready. Last status: ${last?.status || 'unknown'}`);
+}
+
+async function waitForTaskComplete(terminalId, opts, afterTs) {
+  const deadline = Date.now() + opts.timeoutMs;
+  let last = null;
+
+  while (Date.now() < deadline) {
+    last = await fetchTaskStatus(terminalId);
+    const state = last.taskStatus || 'unknown';
+    const updatedAt = last.updatedAt || last.taskStatusUpdatedAt || last.timestamp || null;
+    if (COMPLETE_TASK_STATES.includes(state) && updatedAt && updatedAt > afterTs) return last;
+    await sleep(opts.pollMs);
+  }
+
+  throw new Error(`Timed out waiting for T${terminalId} task completion. Last status: ${last?.taskStatus || 'unknown'}`);
+}
+
+async function runWorkflow(argv) {
+  const opts = parseRunArgs(argv);
+  const sinceTs = new Date().toISOString();
+
+  runNode('ninja-ensure.js', opts.noOpen ? ['--no-open'] : []);
+  primeRuntimeEnv();
+  const readyStatus = await waitForTerminalReady(opts.terminalId, opts);
+  console.log(`T${opts.terminalId} process status ready: ${readyStatus.status}`);
+  runNode('ninja-codex-visual.js', [
+    '--record', 'pre-dispatch',
+    '--note', `Codex workflow pre-dispatch: T${opts.terminalId} target visible`,
+  ]);
+  const dispatchTs = new Date().toISOString();
+  runNode('agent-send.js', [String(opts.terminalId), opts.task]);
+
+  const finalStatus = await waitForTaskComplete(opts.terminalId, opts, dispatchTs);
+  console.log(`T${opts.terminalId} semantic task status: ${finalStatus.taskStatus}`);
+
+  runNode('agent-send.js', ['--task-status', String(opts.terminalId)]);
+  runNode('agent-send.js', ['--output', String(opts.terminalId), '--lines', String(opts.lines)]);
+
+  const visualArgs = [
+    '--record', 'post-output',
+    '--terminal', String(opts.terminalId),
+    '--expect-task', opts.expectTask || finalStatus.taskStatus,
+    '--note', `Codex workflow post-output: T${opts.terminalId} task ${finalStatus.taskStatus}`,
+  ];
+  if (opts.screenshot) visualArgs.push('--screenshot');
+  runNode('ninja-codex-visual.js', visualArgs);
+
+  runNode('ninja-gate.js', ['--since', sinceTs]);
+}
+
+async function runSquadWorkflow(argv) {
+  const opts = parseSquadArgs(argv);
+  const sinceTs = new Date().toISOString();
+
+  runNode('ninja-ensure.js', opts.noOpen ? ['--no-open'] : []);
+  primeRuntimeEnv();
+
+  console.log(`Waiting for squad readiness: ${opts.terminalIds.map(id => `T${id}`).join(', ')}`);
+  const readyResults = await Promise.all(opts.terminalIds.map(async (terminalId) => {
+    const status = await waitForTerminalReady(terminalId, opts);
+    return { terminalId, status };
+  }));
+  for (const result of readyResults) {
+    const readiness = result.status.readiness ? ` (${result.status.readiness})` : '';
+    console.log(`T${result.terminalId} process status ready: ${result.status.status}${readiness}`);
+  }
+
+  runNode('ninja-codex-visual.js', [
+    '--record', 'pre-dispatch',
+    '--note', `Codex squad pre-dispatch: ${opts.terminalIds.map(id => `T${id}`).join(', ')} visible`,
+  ]);
+
+  const dispatchTs = new Date().toISOString();
+  for (let i = 0; i < opts.terminalIds.length; i++) {
+    const terminalId = String(opts.terminalIds[i]);
+    const role = opts.roles[i] || `worker-${terminalId}`;
+    runNode('agent-send.js', [terminalId, squadPrompt({ role, terminalId, task: opts.task })]);
+  }
+
+  const finalStatuses = await Promise.all(opts.terminalIds.map(async (terminalId) => {
+    const finalStatus = await waitForTaskComplete(terminalId, opts, dispatchTs);
+    console.log(`T${terminalId} semantic task status: ${finalStatus.taskStatus}`);
+    return { terminalId: String(terminalId), finalStatus };
+  }));
+
+  runNode('agent-send.js', ['--task-status']);
+  for (const { terminalId, finalStatus } of finalStatuses) {
+    runNode('agent-send.js', ['--output', terminalId, '--lines', String(opts.lines)]);
+
+    const visualArgs = [
+      '--record', 'post-output',
+      '--terminal', terminalId,
+      '--expect-task', opts.expectTask || finalStatus.taskStatus,
+      '--note', `Codex squad post-output: T${terminalId} task ${finalStatus.taskStatus}`,
+    ];
+    if (opts.screenshot) visualArgs.push('--screenshot');
+    runNode('ninja-codex-visual.js', visualArgs);
+  }
+
+  runNode('ninja-gate.js', ['--since', sinceTs]);
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const cmd = args[0];
+  const rest = args.slice(1);
+
+  if (!cmd || cmd === '--help' || cmd === '-h') {
+    console.log(USAGE);
+    process.exit(cmd ? 0 : 1);
+  }
+
+  if (cmd === 'ensure') {
+    runNode('ninja-ensure.js', rest);
+  } else if (cmd === 'visual') {
+    runNode('ninja-codex-visual.js', rest);
+  } else if (cmd === 'dispatch') {
+    if (rest.length < 2) throw new Error('dispatch requires <terminal-id> <message...>');
+    runNode('agent-send.js', [rest[0], rest.slice(1).join(' ')]);
+  } else if (cmd === 'status') {
+    runNode('agent-send.js', ['--status']);
+  } else if (cmd === 'task-status') {
+    runNode('agent-send.js', ['--task-status', ...rest]);
+  } else if (cmd === 'output') {
+    if (!rest[0]) throw new Error('output requires <terminal-id>');
+    runNode('agent-send.js', ['--output', ...rest]);
+  } else if (cmd === 'gate') {
+    runNode('ninja-gate.js', rest);
+  } else if (cmd === 'run') {
+    await runWorkflow(rest);
+  } else if (cmd === 'squad') {
+    await runSquadWorkflow(rest);
+  } else {
+    throw new Error(`Unknown command: ${cmd}`);
+  }
+}
+
+if (require.main === module) {
+  main().catch((err) => {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  COMPLETE_TASK_STATES,
+  READY_PROCESS_STATES,
+  DEFAULT_SQUAD_ROLES,
+  DEFAULT_SQUAD_TERMINALS,
+  hasPromptVisible,
+  fetchProcessStatus,
+  parseRunArgs,
+  parseSquadArgs,
+  primeRuntimeEnv,
+  resolveRuntimeSession,
+  squadPrompt,
+  waitForTerminalReady,
+  waitForTaskComplete,
+};