ninja-terminals 2.3.1 → 2.3.2

package/lib/runtime-session.js

@@ -0,0 +1,337 @@
+'use strict';
+
+const fs = require('fs');
+const http = require('http');
+const net = require('net');
+const os = require('os');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const SESSION_DIR = path.join(os.homedir(), '.ninja');
+const SESSION_FILE = path.join(SESSION_DIR, 'session.json');
+const TOKEN_FILE = path.join(SESSION_DIR, 'token');
+const LEDGER_FILE = path.join(SESSION_DIR, 'dispatch-ledger.ndjson');
+const VERIFICATION_LEDGER_FILE = path.join(SESSION_DIR, 'verification-ledger.ndjson');
+const VISUAL_LEDGER_FILE = path.join(SESSION_DIR, 'visual-ledger.ndjson');
+
+function ensureSessionDir() {
+  fs.mkdirSync(SESSION_DIR, { recursive: true, mode: 0o700 });
+}
+
+function isPortAvailable(port, host = '127.0.0.1') {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once('error', () => resolve(false));
+    server.once('listening', () => {
+      server.close(() => resolve(true));
+    });
+    server.listen(port, host);
+  });
+}
+
+async function findAvailablePort(preferredPort, host = '127.0.0.1', maxAttempts = 50) {
+  const start = Number.parseInt(preferredPort, 10);
+  if (!Number.isInteger(start) || start < 1 || start > 65535) {
+    throw new Error(`Invalid preferred port: ${preferredPort}`);
+  }
+
+  for (let port = start; port < start + maxAttempts && port <= 65535; port++) {
+    if (await isPortAvailable(port, host)) return port;
+  }
+
+  throw new Error(`No available port found from ${start} to ${Math.min(start + maxAttempts - 1, 65535)}`);
+}
+
+function writeRuntimeSession(session) {
+  ensureSessionDir();
+  const payload = {
+    version: 1,
+    pid: process.pid,
+    host: 'localhost',
+    createdAt: new Date().toISOString(),
+    ...session,
+  };
+  fs.writeFileSync(SESSION_FILE, JSON.stringify(payload, null, 2) + '\n', { mode: 0o600 });
+  return payload;
+}
+
+function updateRuntimeSession(patch) {
+  const current = readRuntimeSession() || {};
+  return writeRuntimeSession({ ...current, ...patch, updatedAt: new Date().toISOString() });
+}
+
+function readRuntimeSession() {
+  try {
+    const raw = fs.readFileSync(SESSION_FILE, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function clearRuntimeSession() {
+  try {
+    fs.unlinkSync(SESSION_FILE);
+  } catch {
+    // already absent
+  }
+}
+
+function writeAuthToken(token) {
+  ensureSessionDir();
+  fs.writeFileSync(TOKEN_FILE, token, { mode: 0o600 });
+}
+
+function readAuthToken() {
+  try {
+    return fs.readFileSync(TOKEN_FILE, 'utf8').trim();
+  } catch {
+    return null;
+  }
+}
+
+function requestJson({ host = 'localhost', port, path: reqPath, token, method = 'GET', body = null, timeoutMs = 3000 }) {
+  return new Promise((resolve, reject) => {
+    const payload = body ? JSON.stringify(body) : null;
+    const headers = {};
+    if (payload) {
+      headers['Content-Type'] = 'application/json';
+      headers['Content-Length'] = Buffer.byteLength(payload);
+    }
+    if (token) headers.Authorization = `Bearer ${token}`;
+
+    const req = http.request({
+      hostname: host,
+      port,
+      path: reqPath,
+      method,
+      headers,
+      timeout: timeoutMs,
+    }, (res) => {
+      let data = '';
+      res.on('data', chunk => { data += chunk; });
+      res.on('end', () => {
+        let parsed = null;
+        try {
+          parsed = data ? JSON.parse(data) : null;
+        } catch {
+          parsed = data;
+        }
+        resolve({ statusCode: res.statusCode, body: parsed, raw: data });
+      });
+    });
+
+    req.on('timeout', () => {
+      req.destroy(new Error(`Request timed out after ${timeoutMs}ms`));
+    });
+    req.on('error', reject);
+    if (payload) req.write(payload);
+    req.end();
+  });
+}
+
+async function healthCheckSession(session, timeoutMs = 3000) {
+  if (!session || !session.port) return { ok: false, error: 'No runtime session port' };
+  try {
+    const res = await requestJson({
+      host: session.host || 'localhost',
+      port: session.port,
+      path: '/health',
+      timeoutMs,
+    });
+    if (
+      res.statusCode >= 200 &&
+      res.statusCode < 300 &&
+      res.body &&
+      res.body.status === 'ok' &&
+      Object.prototype.hasOwnProperty.call(res.body, 'terminals')
+    ) {
+      return { ok: true, response: res.body };
+    }
+    return { ok: false, error: `HTTP ${res.statusCode}`, response: res.body };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+function openBrowserTab(url) {
+  // Opt-in: only open browser if NINJA_OPEN_BROWSER=true
+  if (process.env.NINJA_OPEN_BROWSER !== '1' && process.env.NINJA_OPEN_BROWSER !== 'true') {
+    return false;
+  }
+
+  if (process.platform === 'darwin') {
+    const child = spawn('open', ['-a', 'Google Chrome', url], {
+      detached: true,
+      stdio: 'ignore',
+    });
+    child.on('error', () => {
+      const fallback = spawn('open', [url], { detached: true, stdio: 'ignore' });
+      fallback.unref();
+    });
+    child.unref();
+    return true;
+  }
+
+  const opener = process.platform === 'win32' ? 'start' : 'xdg-open';
+  const args = process.platform === 'win32' ? ['', url] : [url];
+  const child = spawn(opener, args, { detached: true, stdio: 'ignore', shell: process.platform === 'win32' });
+  child.unref();
+  return true;
+}
+
+// ── Dispatch Ledger ──────────────────────────────────────────
+
+function appendLedgerEntry(entry) {
+  ensureSessionDir();
+  const record = {
+    timestamp: new Date().toISOString(),
+    ...entry,
+  };
+  fs.appendFileSync(LEDGER_FILE, JSON.stringify(record) + '\n', { mode: 0o600 });
+  return record;
+}
+
+function readLedgerEntries(limit = 50) {
+  try {
+    const raw = fs.readFileSync(LEDGER_FILE, 'utf8');
+    const lines = raw.trim().split('\n').filter(Boolean);
+    const entries = lines.map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter(Boolean);
+    // Return last N entries (most recent)
+    return entries.slice(-limit);
+  } catch {
+    return [];
+  }
+}
+
+function clearLedger() {
+  try {
+    fs.unlinkSync(LEDGER_FILE);
+  } catch {
+    // already absent
+  }
+}
+
+// ── Verification Ledger ──────────────────────────────────────────
+// Records output/status checks after dispatch
+
+function appendVerificationEntry(entry) {
+  ensureSessionDir();
+  const record = {
+    timestamp: new Date().toISOString(),
+    ...entry,
+  };
+  fs.appendFileSync(VERIFICATION_LEDGER_FILE, JSON.stringify(record) + '\n', { mode: 0o600 });
+  return record;
+}
+
+function readVerificationEntries(limit = 50) {
+  try {
+    const raw = fs.readFileSync(VERIFICATION_LEDGER_FILE, 'utf8');
+    const lines = raw.trim().split('\n').filter(Boolean);
+    const entries = lines.map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter(Boolean);
+    return entries.slice(-limit);
+  } catch {
+    return [];
+  }
+}
+
+function clearVerificationLedger() {
+  try {
+    fs.unlinkSync(VERIFICATION_LEDGER_FILE);
+  } catch {
+    // already absent
+  }
+}
+
+// ── Visual Ledger ──────────────────────────────────────────
+// Records browser visual inspections via claude-in-chrome
+
+const VALID_VISUAL_STAGES = ['pre-dispatch', 'post-dispatch', 'post-output', 'final-visual'];
+
+function appendVisualEntry(entry) {
+  ensureSessionDir();
+  const record = {
+    timestamp: new Date().toISOString(),
+    ...entry,
+  };
+  fs.appendFileSync(VISUAL_LEDGER_FILE, JSON.stringify(record) + '\n', { mode: 0o600 });
+  return record;
+}
+
+function readVisualEntries(limit = 50) {
+  try {
+    const raw = fs.readFileSync(VISUAL_LEDGER_FILE, 'utf8');
+    const lines = raw.trim().split('\n').filter(Boolean);
+    const entries = lines.map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter(Boolean);
+    return entries.slice(-limit);
+  } catch {
+    return [];
+  }
+}
+
+function clearVisualLedger() {
+  try {
+    fs.unlinkSync(VISUAL_LEDGER_FILE);
+  } catch {
+    // already absent
+  }
+}
+
+function hasVisualAfter(afterTimestamp, options = {}) {
+  const entries = readVisualEntries(100);
+  return entries.some(e => {
+    if (!e.timestamp || e.timestamp <= afterTimestamp) return false;
+    if (options.stage && e.stage !== options.stage) return false;
+    if (options.terminalId && e.terminalId !== options.terminalId) return false;
+    return true;
+  });
+}
+
+module.exports = {
+  SESSION_DIR,
+  SESSION_FILE,
+  TOKEN_FILE,
+  LEDGER_FILE,
+  VERIFICATION_LEDGER_FILE,
+  VISUAL_LEDGER_FILE,
+  VALID_VISUAL_STAGES,
+  findAvailablePort,
+  writeRuntimeSession,
+  updateRuntimeSession,
+  readRuntimeSession,
+  clearRuntimeSession,
+  writeAuthToken,
+  readAuthToken,
+  healthCheckSession,
+  requestJson,
+  openBrowserTab,
+  appendLedgerEntry,
+  readLedgerEntries,
+  clearLedger,
+  appendVerificationEntry,
+  readVerificationEntries,
+  clearVerificationLedger,
+  appendVisualEntry,
+  readVisualEntries,
+  clearVisualLedger,
+  hasVisualAfter,
+};

package/lib/status-detect.js

@@ -37,7 +37,7 @@ const SPINNER_RE = /[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]|Thinking|Generating/i;
  * Detect the current operational status of a Claude Code terminal.
  *
  * @param {string[]} lines - Array of ANSI-stripped lines (from LineBuffer)
- * @returns {'idle'|'working'|'waiting_approval'|'compacting'|'done'|'blocked'|'error'}
+ * @returns {'idle'|'working'|'waiting_approval'|'compacting'|'done'|'blocked'|'error'|'exited'}
  */
 function detectStatus(lines) {
   if (!lines || lines.length === 0) return 'idle';
@@ -51,8 +51,18 @@ function detectStatus(lines) {
   const lastContentLine = contentLines.slice(-1)[0] || '';
   const last10 = trimmed.slice(-10);
 
+  // Closed or disconnected PTY session
+  if (/\[Connection closed\]|Connection closed/i.test(last50)) {
+    return 'exited';
+  }
+
+  // Rate-limit and explicit blocking menus are not active work
+  if (/out of (extra )?usage|rate-limit-options|Stop and wait for limit to reset|Upgrade your plan/i.test(last50)) {
+    return 'blocked';
+  }
+
   // Prompt detection — idle if prompt is visible and no recent tool work
-  const hasPrompt = last10.some(l => /^[>❯]$/.test(l));
+  const hasPrompt = last10.some(l => /^[>❯]/.test(l) || /Try\s+"[^"]+"/i.test(l));
   const hasShortcutsHint = last10.some(
     l => /\?.*for\s*shortcuts/i.test(l) || l === '?forshortcuts'
   );
@@ -74,8 +84,9 @@ function detectStatus(lines) {
   if (/auto-compact|compressing|compacting/i.test(last50)) return 'compacting';
 
   // Explicit status markers (convention for orchestrator scripts)
-  if (/STATUS: DONE/i.test(last50)) return 'done';
-  if (/STATUS: BLOCKED/i.test(last50)) return 'blocked';
+  if (/^\s*STATUS:\s*DONE/im.test(last50)) return 'done';
+  if (/^\s*STATUS:\s*BLOCKED/im.test(last50)) return 'blocked';
+  if (/^\s*STATUS:\s*ERROR/im.test(last50)) return 'error';
 
   // Active tool use
   if (TOOL_RE.test(last50)) return 'working';
@@ -221,9 +232,62 @@ function extractStructuredEvents(lines, terminalLabel) {
   return events;
 }
 
+// ---------------------------------------------------------------------------
+// Task Status Parsing (semantic status from worker output)
+// ---------------------------------------------------------------------------
+
+/**
+ * Valid task status states.
+ * @type {string[]}
+ */
+const VALID_TASK_STATES = ['pending', 'running', 'done', 'blocked', 'error', 'unknown'];
+
+/**
+ * Regex patterns for parsing STATUS: markers.
+ * Captures the status type and optional message.
+ */
+const TASK_STATUS_PATTERNS = [
+  { re: /^[\s⏺✢✳✶✻✽·]*STATUS:\s*DONE\s*[-—]?\s*(.*)/i, state: 'done' },
+  { re: /^[\s⏺✢✳✶✻✽·]*STATUS:\s*BLOCKED\s*[-—]?\s*(.*)/i, state: 'blocked' },
+  { re: /^[\s⏺✢✳✶✻✽·]*STATUS:\s*ERROR[:\s]*[-—]?\s*(.*)/i, state: 'error' },
+  { re: /^[\s⏺✢✳✶✻✽·]*STATUS:\s*RUNNING\s*[-—]?\s*(.*)/i, state: 'running' },
+];
+
+/**
+ * Parse terminal output for the most recent STATUS: marker.
+ * Scans from end to find the latest semantic task status.
+ *
+ * @param {string[]} lines - Array of ANSI-stripped lines
+ * @returns {{ state: string, marker: string, message: string } | null}
+ */
+function parseTaskStatus(lines) {
+  if (!lines || lines.length === 0) return null;
+
+  // Scan from the end — most recent status wins
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i].trim();
+    if (!line) continue;
+
+    for (const { re, state } of TASK_STATUS_PATTERNS) {
+      const match = line.match(re);
+      if (match) {
+        return {
+          state,
+          marker: match[0].trim(),
+          message: match[1]?.trim() || '',
+        };
+      }
+    }
+  }
+
+  return null;
+}
+
 module.exports = {
   stripAnsi,
   detectStatus,
   extractContextPct,
   extractStructuredEvents,
+  parseTaskStatus,
+  VALID_TASK_STATES,
 };