nightytidy 0.1.0

package/src/dashboard-standalone.js

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+
+// Standalone dashboard HTTP server for orchestrator mode.
+// Spawned as a detached process by orchestrator.js during --init-run.
+// Polls nightytidy-progress.json for state updates and serves the
+// browser dashboard with SSE push. Killed by --finish-run via PID.
+
+import { createServer } from 'http';
+import { readFileSync, writeFileSync } from 'fs';
+import { randomBytes } from 'crypto';
+import { getHTML } from './dashboard-html.js';
+
+const POLL_INTERVAL = 500;
+const MAX_BODY_BYTES = 1024; // 1 KB — stop endpoint only needs a small JSON body
+
+const projectDir = process.argv[2];
+if (!projectDir) {
+  process.stderr.write('Usage: dashboard-standalone.js <projectDir>\n');
+  process.exit(1);
+}
+
+const progressPath = `${projectDir}/nightytidy-progress.json`;
+const urlFilePath = `${projectDir}/nightytidy-dashboard.url`;
+const csrfToken = randomBytes(16).toString('hex');
+
+let currentState = null;
+let lastRawJson = '';
+let lastOutputLength = 0;
+let lastStepName = '';
+const sseClients = new Set();
+let pollIntervalId = null;
+
+const SECURITY_HEADERS = {
+  'X-Content-Type-Options': 'nosniff',
+  'X-Frame-Options': 'DENY',
+  'Content-Security-Policy': "default-src 'self'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; connect-src 'self'",
+};
+
+function pollProgress() {
+  try {
+    const raw = readFileSync(progressPath, 'utf8');
+
+    // Only push if file content actually changed (avoids redundant JSON.parse + stringify)
+    if (raw === lastRawJson) return;
+    lastRawJson = raw;
+
+    const state = JSON.parse(raw);
+    currentState = state;
+
+    // Reset output tracking when step changes
+    if (state.currentStepName !== lastStepName) {
+      lastOutputLength = 0;
+      lastStepName = state.currentStepName || '';
+    }
+
+    // Send only new output as SSE output event
+    if (state.currentStepOutput && state.currentStepOutput.length > lastOutputLength) {
+      const newChunk = state.currentStepOutput.slice(lastOutputLength);
+      lastOutputLength = state.currentStepOutput.length;
+      const outputPayload = `event: output\ndata: ${JSON.stringify(newChunk)}\n\n`;
+      for (const client of sseClients) {
+        try { client.write(outputPayload); } catch { sseClients.delete(client); }
+      }
+    }
+
+    const payload = `event: state\ndata: ${raw}\n\n`;
+    for (const client of sseClients) {
+      try { client.write(payload); } catch { sseClients.delete(client); }
+    }
+  } catch { /* file being written or invalid — skip this tick */ }
+}
+
+function handleRequest(req, res) {
+  if (req.method === 'GET' && req.url === '/') {
+    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8', ...SECURITY_HEADERS });
+    res.end(getHTML(csrfToken));
+  } else if (req.method === 'GET' && req.url === '/events') {
+    res.writeHead(200, {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      'Connection': 'keep-alive',
+    });
+    if (currentState) {
+      res.write(`event: state\ndata: ${JSON.stringify(currentState)}\n\n`);
+    }
+    sseClients.add(res);
+    res.on('close', () => sseClients.delete(res));
+  } else if (req.method === 'POST' && req.url === '/stop') {
+    // CSRF-protected stop endpoint — no-op in orchestrator mode (abort is handled externally)
+    let body = '';
+    req.on('data', chunk => {
+      body += chunk;
+      if (body.length > MAX_BODY_BYTES) {
+        req.destroy();
+        res.writeHead(413, { 'Content-Type': 'application/json', ...SECURITY_HEADERS });
+        res.end(JSON.stringify({ error: 'Request body too large' }));
+        return;
+      }
+    });
+    req.on('end', () => {
+      try {
+        const parsed = JSON.parse(body || '{}');
+        if (parsed.token !== csrfToken) {
+          res.writeHead(403, { 'Content-Type': 'application/json', ...SECURITY_HEADERS });
+          res.end(JSON.stringify({ error: 'Invalid token' }));
+          return;
+        }
+      } catch {
+        res.writeHead(403, { 'Content-Type': 'application/json', ...SECURITY_HEADERS });
+        res.end(JSON.stringify({ error: 'Invalid token' }));
+        return;
+      }
+      res.writeHead(200, { 'Content-Type': 'application/json', ...SECURITY_HEADERS });
+      res.end(JSON.stringify({ ok: true, message: 'Stop not supported in orchestrator mode' }));
+    });
+  } else {
+    res.writeHead(404, { 'Content-Type': 'text/plain', ...SECURITY_HEADERS });
+    res.end('Not found');
+  }
+}
+
+const server = createServer(handleRequest);
+
+// Prevent slow/malicious clients from holding connections indefinitely.
+// SSE connections excluded by design (headers written immediately, stay open).
+server.requestTimeout = 30_000;  // 30s — max time for entire request
+server.headersTimeout = 15_000;  // 15s — max time to receive headers
+
+server.listen(0, '127.0.0.1', () => {
+  const port = server.address().port;
+  const url = `http://localhost:${port}`;
+
+  try { writeFileSync(urlFilePath, url + '\n', 'utf8'); } catch { /* non-critical */ }
+
+  // Pre-populate currentState from progress file so SSE clients connecting
+  // before the first poll tick get immediate data instead of a blank dashboard.
+  try {
+    const raw = readFileSync(progressPath, 'utf8');
+    currentState = JSON.parse(raw);
+    lastRawJson = raw;
+  } catch { /* file may not exist yet — first poll will pick it up */ }
+
+  // Write port to stdout so the spawning process can capture it
+  process.stdout.write(JSON.stringify({ port, url, pid: process.pid }) + '\n');
+
+  pollIntervalId = setInterval(pollProgress, POLL_INTERVAL);
+});
+
+server.on('error', (err) => {
+  process.stderr.write(`Dashboard server error: ${err.message}\n`);
+  process.exit(1);
+});
+
+// Graceful shutdown with force-exit safety net.
+// server.close() waits for all connections to drain, but SSE connections
+// never close on their own. The 10s timeout guarantees termination even
+// if client.end() fails silently or new connections arrive after cleanup.
+const SHUTDOWN_FORCE_EXIT_MS = 10_000;
+
+process.on('SIGTERM', () => {
+  if (pollIntervalId) clearInterval(pollIntervalId);
+  for (const client of sseClients) { try { client.end(); } catch { /* ignore */ } }
+  sseClients.clear();
+  const forceTimer = setTimeout(() => process.exit(0), SHUTDOWN_FORCE_EXIT_MS);
+  forceTimer.unref();
+  server.close(() => process.exit(0));
+});

package/src/dashboard-tui.js

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+
+// Standalone TUI progress display for NightyTidy.
+// Spawned in a separate terminal window by dashboard.js.
+// Reads nightytidy-progress.json and renders a live terminal UI.
+//
+// Usage: node dashboard-tui.js <path-to-progress.json>
+
+import { readFileSync } from 'fs';
+import chalk from 'chalk';
+
+const POLL_INTERVAL = 1000;
+const EXIT_DELAY = 5000;
+const BAR_WIDTH = 30;
+const MAX_VISIBLE_STEPS = 16;
+const MAX_OUTPUT_LINES = 20;
+
+// Module-level state
+let progressFilePath = null;
+let lastJson = '';
+
+function readState() {
+  if (!progressFilePath) return null;
+  try {
+    const raw = readFileSync(progressFilePath, 'utf8');
+    if (raw === lastJson) return null; // no change
+    lastJson = raw;
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+export function formatMs(ms) {
+  if (!Number.isFinite(ms) || ms < 0) return '0s';
+
+  const s = Math.floor(ms / 1000);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ${String(s % 60).padStart(2, '0')}s`;
+  const h = Math.floor(m / 60);
+  return `${h}h ${String(m % 60).padStart(2, '0')}m`;
+}
+
+export function progressBar(done, total, hasActive = false) {
+  const effective = hasActive ? done + 0.5 : done;
+  const pct = total > 0 ? effective / total : 0;
+  const filled = Math.round(pct * BAR_WIDTH);
+  const empty = BAR_WIDTH - filled;
+  const bar = chalk.cyan('\u2588'.repeat(filled)) + chalk.dim('\u2591'.repeat(empty));
+  const label = `${done}/${total} (${Math.round(pct * 100)}%)`;
+  return `${bar}  ${label}`;
+}
+
+const STATUS_COLORS = {
+  starting: chalk.blue,
+  running: chalk.blue,
+  finishing: chalk.cyan,
+  completed: chalk.green,
+  stopped: chalk.yellow,
+  error: chalk.red,
+};
+
+function statusColor(status) {
+  const colorFn = STATUS_COLORS[status] || chalk.white;
+  return colorFn(status.charAt(0).toUpperCase() + status.slice(1));
+}
+
+function stepIcon(status) {
+  if (status === 'completed') return chalk.green('\u2713');
+  if (status === 'skipped') return chalk.dim('\u23ed');
+  if (status === 'failed') return chalk.red('\u2717');
+  if (status === 'running') return chalk.cyan('\u23f3');
+  return chalk.dim('\u25cb');
+}
+
+export function render(state) {
+  const lines = [];
+
+  // Header
+  lines.push('');
+  lines.push(chalk.cyan.bold('  NightyTidy \u2014 Live Progress'));
+  lines.push('');
+
+  // Status + elapsed
+  const elapsed = state.startTime ? formatMs(Date.now() - state.startTime) : '0s';
+  lines.push(`  Status: ${statusColor(state.status)}    Elapsed: ${chalk.white(elapsed)}`);
+  lines.push('');
+
+  // Progress bar
+  const done = state.completedCount + state.failedCount;
+  const hasActive = state.status === 'running' && state.currentStepIndex >= 0;
+  lines.push(`  ${progressBar(done, state.totalSteps, hasActive)}`);
+  lines.push('');
+
+  // Step list
+  const steps = state.steps || [];
+  const visible = steps.slice(0, MAX_VISIBLE_STEPS);
+
+  for (const step of visible) {
+    const icon = stepIcon(step.status);
+    const dur = step.duration ? chalk.dim(` ${formatMs(step.duration)}`) : '';
+    const running = step.status === 'running' ? chalk.dim(' \u2190 running') : '';
+    lines.push(`  ${icon} ${step.number}. ${step.name}${dur}${running}`);
+  }
+
+  if (steps.length > MAX_VISIBLE_STEPS) {
+    const remaining = steps.length - MAX_VISIBLE_STEPS;
+    lines.push(chalk.dim(`  ... (${remaining} more)`));
+  }
+
+  lines.push('');
+
+  // Claude output panel
+  if (state.currentStepOutput && state.status === 'running') {
+    lines.push(chalk.cyan.bold('  Claude Code Output'));
+    lines.push(chalk.dim('  ' + '\u2500'.repeat(50)));
+
+    const outputLines = state.currentStepOutput.split('\n');
+    const visible = outputLines.slice(-MAX_OUTPUT_LINES);
+
+    if (outputLines.length > MAX_OUTPUT_LINES) {
+      lines.push(chalk.dim(`  ... (${outputLines.length - MAX_OUTPUT_LINES} lines above)`));
+    }
+
+    for (const line of visible) {
+      lines.push('  ' + chalk.dim(line));
+    }
+    lines.push('');
+  }
+
+  // Counts
+  const parts = [];
+  if (state.completedCount > 0) parts.push(chalk.green(`${state.completedCount} passed`));
+  if (state.failedCount > 0) parts.push(chalk.red(`${state.failedCount} failed`));
+  if (parts.length > 0) lines.push(`  ${parts.join(', ')}`);
+
+  // Error message
+  if (state.error) {
+    lines.push('');
+    lines.push(chalk.red(`  Error: ${state.error}`));
+  }
+
+  // Footer
+  lines.push('');
+  if (['completed', 'stopped', 'error'].includes(state.status)) {
+    lines.push(chalk.dim('  Run finished. This window will close shortly.'));
+  } else {
+    lines.push(chalk.dim('  Press Ctrl+C to close this window.'));
+    lines.push(chalk.dim('  NightyTidy continues running in the background.'));
+  }
+  lines.push('');
+
+  // Clear screen and draw
+  process.stdout.write('\x1B[2J\x1B[H');
+  process.stdout.write(lines.join('\n'));
+}
+
+function startPolling(filePath) {
+  progressFilePath = filePath;
+  let lastState = null;
+
+  const interval = setInterval(() => {
+    try {
+      const newState = readState();
+      if (newState) lastState = newState;
+
+      if (lastState) {
+        render(lastState);
+
+        if (['completed', 'stopped', 'error'].includes(lastState.status)) {
+          clearInterval(interval);
+          setTimeout(() => process.exit(0), EXIT_DELAY);
+        }
+      }
+    } catch {
+      // Render or read failed — retry on next tick; don't crash the window
+    }
+  }, POLL_INTERVAL);
+
+  // Initial render attempt
+  try {
+    const initial = readState();
+    if (initial) {
+      lastState = initial;
+      render(initial);
+    }
+  } catch {
+    // Will retry on next interval
+  }
+}
+
+// Only run as main entry point — safe to import without side effects
+const isMain = process.argv[1]?.replace(/\\/g, '/').endsWith('dashboard-tui.js');
+
+if (isMain) {
+  // Prevent uncaught errors from silently closing the window
+  process.on('uncaughtException', (err) => {
+    try { process.stderr.write(`[dashboard-tui] uncaught: ${err?.message || err}\n`); } catch { /* ignore */ }
+  });
+
+  const path = process.argv[2];
+  if (!path) {
+    console.error('Usage: node dashboard-tui.js <progress-file-path>');
+    process.exit(1);
+  }
+  startPolling(path);
+}