ninja-terminals 2.3.1 → 2.3.3

package/agent-send.js

@@ -0,0 +1,395 @@
+#!/usr/bin/env node
+'use strict';
+
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const {
+  SESSION_FILE,
+  LEDGER_FILE,
+  VERIFICATION_LEDGER_FILE,
+  readRuntimeSession,
+  healthCheckSession,
+  requestJson,
+  appendLedgerEntry,
+  readLedgerEntries,
+  appendVerificationEntry,
+  readVerificationEntries,
+} = require('./lib/runtime-session');
+
+const USAGE = `
+Usage:
+  agent-send --status
+  agent-send --task-status [terminal-id]
+  agent-send --ledger [N]
+  agent-send --output <terminal-id> [--lines N]
+  agent-send --verifications [N]
+  agent-send <terminal-id> <message...>
+
+Sends a message to a Ninja Terminal via PTY stdin.
+
+Environment:
+  NINJA_HOST        Server host (default: localhost)
+  NINJA_PORT        Server port (overrides ${SESSION_FILE})
+  NINJA_AUTH_TOKEN  Auth token (or use ${SESSION_FILE} / ~/.ninja/token)
+
+Files:
+  ${SESSION_FILE}              Runtime session (port, host, token)
+  ${LEDGER_FILE}               Dispatch history (NDJSON)
+  ${VERIFICATION_LEDGER_FILE}  Output/status verification history (NDJSON)
+
+Examples:
+  agent-send --status              # Check process status (logged as verification)
+  agent-send --task-status         # Check all terminals task status
+  agent-send --task-status 1       # Check terminal 1 task status
+  agent-send --ledger              # Show last 20 dispatches
+  agent-send --output 1            # Read terminal 1 output (logged as verification)
+  agent-send --output 1 --lines 50 # Read last 50 lines
+  agent-send --verifications       # Show verification ledger
+  agent-send 2 "Hello from agent"
+`;
+
+function getToken(session) {
+  // 1. Environment variable
+  if (process.env.NINJA_AUTH_TOKEN) {
+    return process.env.NINJA_AUTH_TOKEN;
+  }
+
+  // 2. Runtime session file written by Ninja Terminals after browser auth
+  if (session && session.authToken) {
+    return session.authToken;
+  }
+
+  // 3. Token file
+  const tokenPath = path.join(os.homedir(), '.ninja', 'token');
+  if (fs.existsSync(tokenPath)) {
+    return fs.readFileSync(tokenPath, 'utf8').trim();
+  }
+
+  return null;
+}
+
+function resolveTarget(session) {
+  const port = process.env.NINJA_PORT || session?.port;
+  const host = process.env.NINJA_HOST || session?.host || 'localhost';
+
+  if (!port) {
+    throw new Error(`No live Ninja Terminal session found.
+
+Start Ninja Terminals first. Expected runtime file:
+  ${SESSION_FILE}
+
+Or set NINJA_PORT explicitly.`);
+  }
+
+  return { host, port: parseInt(port, 10) };
+}
+
+async function printStatus(session, token) {
+  const target = resolveTarget(session);
+  const health = await healthCheckSession({ ...session, ...target });
+  if (!health.ok) {
+    throw new Error(`Ninja Terminal health check failed on ${target.host}:${target.port}: ${health.error}`);
+  }
+
+  console.log(`Ninja Terminal: http://${target.host}:${target.port}`);
+  console.log(`Session file: ${SESSION_FILE}`);
+  console.log(`Health: ok (${health.response.terminals} terminals)`);
+
+  if (!token) {
+    console.log('Auth: missing token. Run: ninja-login');
+    return;
+  }
+
+  const res = await requestJson({
+    host: target.host,
+    port: target.port,
+    path: '/api/terminals',
+    token,
+  });
+
+  if (res.statusCode === 200 && Array.isArray(res.body)) {
+    for (const t of res.body) {
+      console.log(`T${t.id} ${t.label || ''} ${t.status || 'unknown'} ${t.taskName ? `— ${t.taskName}` : ''}`.trim());
+    }
+  } else {
+    console.log(`Terminals: unavailable (HTTP ${res.statusCode})`);
+  }
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const invokedAs = path.basename(process.argv[1] || '');
+  const session = readRuntimeSession();
+  const token = getToken(session);
+
+  if (invokedAs === 'ninja-status') {
+    await printStatus(session, token);
+    appendVerificationEntry({ type: 'status', command: 'ninja-status' });
+    return;
+  }
+
+  if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+    console.log(USAGE);
+    process.exit(args.length === 0 ? 1 : 0);
+  }
+
+  if (args[0] === '--status' || args[0] === 'status') {
+    await printStatus(session, token);
+    appendVerificationEntry({ type: 'status', command: 'agent-send --status' });
+    return;
+  }
+
+  if (args[0] === '--ledger' || args[0] === 'ledger') {
+    const limit = parseInt(args[1], 10) || 20;
+    const entries = readLedgerEntries(limit);
+    if (entries.length === 0) {
+      console.log('No dispatch ledger entries found.');
+      console.log(`Ledger file: ${LEDGER_FILE}`);
+      return;
+    }
+    console.log(`Last ${entries.length} dispatch(es):\n`);
+    for (const e of entries) {
+      const status = e.success ? '✓' : '✗';
+      const preview = e.messagePreview || '';
+      console.log(`${status} ${e.timestamp} T${e.terminalId} ${e.command || 'dispatch'}`);
+      if (preview) console.log(`  "${preview.slice(0, 80)}${preview.length > 80 ? '...' : ''}"`);
+      if (!e.success && e.error) console.log(`  Error: ${e.error}`);
+    }
+    return;
+  }
+
+  if (args[0] === '--output' || args[0] === 'output') {
+    const terminalId = args[1];
+    if (!terminalId) {
+      console.error('Error: --output requires terminal ID');
+      process.exit(1);
+    }
+    const linesIdx = args.indexOf('--lines');
+    const lines = linesIdx >= 0 ? parseInt(args[linesIdx + 1], 10) || 50 : 50;
+
+    const target = resolveTarget(session);
+    if (!token) {
+      console.error('Error: Auth token required for output read');
+      process.exit(1);
+    }
+
+    const res = await requestJson({
+      host: target.host,
+      port: target.port,
+      path: `/api/terminals/${terminalId}/output?lines=${lines}`,
+      token,
+    });
+
+    if (res.statusCode === 200 && res.body) {
+      const output = res.body.lines || res.body;
+      if (Array.isArray(output)) {
+        for (const line of output) {
+          console.log(line);
+        }
+      } else {
+        console.log(JSON.stringify(res.body, null, 2));
+      }
+      appendVerificationEntry({
+        type: 'output_read',
+        terminalId,
+        lines,
+        command: 'agent-send --output',
+      });
+    } else {
+      console.error(`Error: HTTP ${res.statusCode}`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (args[0] === '--verifications' || args[0] === 'verifications') {
+    const limit = parseInt(args[1], 10) || 20;
+    const entries = readVerificationEntries(limit);
+    if (entries.length === 0) {
+      console.log('No verification ledger entries found.');
+      console.log(`Ledger file: ${VERIFICATION_LEDGER_FILE}`);
+      return;
+    }
+    console.log(`Last ${entries.length} verification(s):\n`);
+    for (const e of entries) {
+      console.log(`${e.timestamp} ${e.type} ${e.terminalId ? `T${e.terminalId}` : ''} ${e.command || ''}`.trim());
+      if (e.statusMarker) console.log(`  Marker: ${e.statusMarker}`);
+    }
+    return;
+  }
+
+  if (args[0] === '--task-status' || args[0] === 'task-status') {
+    const terminalId = args[1];
+    const target = resolveTarget(session);
+
+    if (!token) {
+      console.error('Error: Auth token required for task-status');
+      process.exit(1);
+    }
+
+    const apiPath = terminalId
+      ? `/api/terminals/${terminalId}/task-status`
+      : '/api/terminals/task-status';
+
+    const res = await requestJson({
+      host: target.host,
+      port: target.port,
+      path: apiPath,
+      token,
+    });
+
+    if (res.statusCode === 200 && res.body) {
+      const data = Array.isArray(res.body) ? res.body : [res.body];
+
+      // Task status icons
+      const icons = {
+        done: '\u2713',    // ✓
+        blocked: '\u26A0', // ⚠
+        error: '\u2717',   // ✗
+        running: '\u25CB', // ○
+        pending: '\u25CB', // ○
+        unknown: '?',
+      };
+
+      console.log('');
+      for (const t of data) {
+        const taskIcon = icons[t.taskStatus] || '?';
+        const processLabel = (t.processStatus || 'unknown').toUpperCase();
+        const taskLabel = (t.taskStatus || 'unknown').toUpperCase();
+        console.log(`T${t.id} ${t.label || ''}`);
+        console.log(`  PROCESS: ${processLabel}`);
+        console.log(`  TASK:    ${taskIcon} ${taskLabel}${t.message ? ` — ${t.message}` : ''}`);
+        if (t.marker) console.log(`  Marker:  ${t.marker}`);
+        console.log('');
+      }
+
+      appendVerificationEntry({
+        type: 'task_status',
+        terminalId: terminalId || 'all',
+        command: 'agent-send --task-status',
+      });
+    } else {
+      console.error(`Error: HTTP ${res.statusCode}`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (args.length < 2) {
+    console.error('Error: Missing arguments. Need <terminal-id> <message>');
+    console.log(USAGE);
+    process.exit(1);
+  }
+
+  const terminalId = args[0];
+  const message = args.slice(1).join(' ');
+
+  if (!/^\d+$/.test(terminalId)) {
+    console.error(`Error: terminal-id must be numeric, got: ${terminalId}`);
+    process.exit(1);
+  }
+
+  if (!token) {
+    appendLedgerEntry({
+      terminalId,
+      messagePreview: message.slice(0, 160),
+      command: invokedAs === 'ninja-dispatch' ? 'ninja-dispatch' : 'agent-send',
+      success: false,
+      error: 'No auth token found',
+    });
+    console.error(`Error: No auth token found.
+
+Run: ninja-login
+
+Or set NINJA_AUTH_TOKEN environment variable.
+`);
+    process.exit(1);
+  }
+
+  const { host, port } = resolveTarget(session);
+  const health = await healthCheckSession({ ...session, host, port });
+  if (!health.ok) {
+    appendLedgerEntry({
+      terminalId,
+      messagePreview: message.slice(0, 160),
+      host,
+      port,
+      command: invokedAs === 'ninja-dispatch' ? 'ninja-dispatch' : 'agent-send',
+      success: false,
+      error: `Health check failed: ${health.error}`,
+    });
+    throw new Error(`Ninja Terminal health check failed on ${host}:${port}: ${health.error}`);
+  }
+
+  // Build JSON body - server handles delayed Enter for proper Claude Code submission
+  const body = JSON.stringify({ text: message });
+
+  const options = {
+    hostname: host,
+    port: parseInt(port, 10),
+    path: `/api/terminals/${terminalId}/input`,
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Content-Length': Buffer.byteLength(body),
+      'Authorization': `Bearer ${token}`
+    }
+  };
+
+  const ledgerBase = {
+    terminalId,
+    messagePreview: message.slice(0, 160),
+    host,
+    port,
+    url: `http://${host}:${port}`,
+    cwd: session?.cwd || null,
+    command: invokedAs === 'ninja-dispatch' ? 'ninja-dispatch' : 'agent-send',
+  };
+
+  const req = http.request(options, (res) => {
+    let data = '';
+    res.on('data', chunk => { data += chunk; });
+    res.on('end', () => {
+      if (res.statusCode === 200) {
+        try {
+          const result = JSON.parse(data);
+          if (result.ok) {
+            appendLedgerEntry({ ...ledgerBase, success: true });
+            console.log(`Sent to terminal ${terminalId}`);
+            if (result.guidanceInjected) {
+              console.log('(guidance was injected)');
+            }
+          } else {
+            appendLedgerEntry({ ...ledgerBase, success: false, error: `Server rejected: ${data}` });
+            console.error('Server returned:', data);
+            process.exit(1);
+          }
+        } catch {
+          appendLedgerEntry({ ...ledgerBase, success: true });
+          console.log('Response:', data);
+        }
+      } else {
+        appendLedgerEntry({ ...ledgerBase, success: false, error: `HTTP ${res.statusCode}: ${data}` });
+        console.error(`HTTP ${res.statusCode}: ${data}`);
+        process.exit(1);
+      }
+    });
+  });
+
+  req.on('error', (err) => {
+    appendLedgerEntry({ ...ledgerBase, success: false, error: err.message });
+    console.error(`Connection error: ${err.message}`);
+    console.error(`Is Ninja Terminal running on ${host}:${port}?`);
+    process.exit(1);
+  });
+
+  req.write(body);
+  req.end();
+}
+
+main().catch((err) => {
+  console.error(`Error: ${err.message}`);
+  process.exit(1);
+});

package/cli.js

@@ -54,24 +54,43 @@ if (hasFlag('--version') || hasFlag('-v')) {
 
 // ── Setup command ───────────────────────────────────────────
 if (hasFlag('--setup')) {
+  runSetup().then(() => process.exit(0)).catch(e => { console.error(e); process.exit(1); });
+}
+
+async function runSetup() {
   const fs = require('fs');
   const path = require('path');
   const os = require('os');
 
   console.log('\n🥷 NINJA TERMINALS SETUP\n');
 
-  // 1. Find or create .mcp.json
-  const projectMcp = path.join(process.cwd(), '.mcp.json');
-  const globalMcp = path.join(os.homedir(), '.mcp.json');
-  const mcpPath = fs.existsSync(projectMcp) ? projectMcp : globalMcp;
+  // 1. Find or create .claude/settings.json (Claude Code format)
+  const projectClaudeDir = path.join(process.cwd(), '.claude');
+  const globalClaudeDir = path.join(os.homedir(), '.claude');
+  const projectSettings = path.join(projectClaudeDir, 'settings.json');
+  const globalSettings = path.join(globalClaudeDir, 'settings.json');
+
+  // Prefer project-level if .claude dir exists, else use global
+  let settingsPath, claudeDir;
+  if (fs.existsSync(projectClaudeDir)) {
+    settingsPath = projectSettings;
+    claudeDir = projectClaudeDir;
+  } else {
+    settingsPath = globalSettings;
+    claudeDir = globalClaudeDir;
+    // Create global .claude dir if needed
+    if (!fs.existsSync(claudeDir)) {
+      fs.mkdirSync(claudeDir, { recursive: true });
+    }
+  }
 
   let mcpConfig = { mcpServers: {} };
-  if (fs.existsSync(mcpPath)) {
+  if (fs.existsSync(settingsPath)) {
     try {
-      mcpConfig = JSON.parse(fs.readFileSync(mcpPath, 'utf-8'));
+      mcpConfig = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
       if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
     } catch (e) {
-      console.log(`⚠️  Could not parse ${mcpPath}, creating new config`);
+      console.log(`⚠️  Could not parse ${settingsPath}, creating new config`);
     }
   }
 
@@ -85,11 +104,16 @@ if (hasFlag('--setup')) {
     }
   };
 
-  // Get npm root for copying orchestrator prompt
-  const npmRoot = path.dirname(require.resolve('ninja-terminals/package.json'));
+  // Get npm root for copying orchestrator prompt (works in dev and installed mode)
+  let npmRoot;
+  try {
+    npmRoot = path.dirname(require.resolve('ninja-terminals/package.json'));
+  } catch {
+    npmRoot = __dirname; // Dev mode fallback
+  }
 
-  fs.writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2) + '\n');
-  console.log(`✅ Added ninja-terminals to ${mcpPath}`);
+  fs.writeFileSync(settingsPath, JSON.stringify(mcpConfig, null, 2) + '\n');
+  console.log(`✅ Added ninja-terminals to ${settingsPath}`);
 
   // 3. Copy orchestrator prompt to CLAUDE.md
   const claudeMd = path.join(process.cwd(), 'CLAUDE.md');
@@ -139,7 +163,7 @@ if (hasFlag('--setup')) {
   }
 
   // Save updated config with all MCPs
-  fs.writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2) + '\n');
+  fs.writeFileSync(settingsPath, JSON.stringify(mcpConfig, null, 2) + '\n');
 
   // 5. Check for Claude in Chrome (optional but recommended)
   const chromeExt = mcpConfig.mcpServers['claude-in-chrome'];
@@ -151,28 +175,108 @@ if (hasFlag('--setup')) {
 
   console.log(`
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+✅ MCP configured!
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`);
+
+  // Now prompt for login
+  const readline = require('readline');
+  const https = require('https');
+  const { execSync } = require('child_process');
+  const { writeAuthToken } = require('./lib/runtime-session');
+
+  const BACKEND_URL = process.env.NINJA_BACKEND_URL || 'https://emtchat-backend.onrender.com';
+
+  function prompt(question) {
+    return new Promise((resolve) => {
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      rl.question(question, (answer) => { rl.close(); resolve(answer); });
+    });
+  }
+
+  function promptPassword(question) {
+    return new Promise((resolve) => {
+      try { execSync('stty -echo', { stdio: 'pipe' }); } catch {}
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      process.stdout.write(question);
+      rl.question('', (answer) => {
+        try { execSync('stty echo', { stdio: 'pipe' }); } catch {}
+        console.log();
+        rl.close();
+        resolve(answer);
+      });
+    });
+  }
+
+  function postJson(url, body) {
+    return new Promise((resolve, reject) => {
+      const parsed = new URL(url);
+      const payload = JSON.stringify(body);
+      const req = https.request({
+        hostname: parsed.hostname,
+        port: parsed.port || 443,
+        path: parsed.pathname,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) },
+      }, (res) => {
+        let data = '';
+        res.on('data', chunk => { data += chunk; });
+        res.on('end', () => {
+          try { resolve({ status: res.statusCode, body: JSON.parse(data) }); }
+          catch { resolve({ status: res.statusCode, body: data }); }
+        });
+      });
+      req.on('error', reject);
+      req.write(payload);
+      req.end();
+    });
+  }
+
+  async function doLogin() {
+    console.log('Login to your Ninja Terminals account:\n');
+    const username = await prompt('Username or email: ');
+    const password = await promptPassword('Password: ');
+
+    if (!username || !password) {
+      console.log('\n⚠️  Skipped login. Run `npx ninja-login` later to authenticate.');
+      return false;
+    }
+
+    console.log('Authenticating...');
+    try {
+      const res = await postJson(`${BACKEND_URL}/api/auth/login`, { username, password });
+      if (res.status === 200 && res.body.token) {
+        writeAuthToken(res.body.token);
+        console.log(`\n✅ Logged in as ${username}`);
+        console.log(`   Token saved to ~/.ninja/token`);
+        return true;
+      } else {
+        console.log(`\n❌ Login failed: ${res.body.message || res.body.error || 'Unknown error'}`);
+        console.log('   Run `npx ninja-login` to try again.');
+        return false;
+      }
+    } catch (err) {
+      console.log(`\n❌ Connection failed: ${err.message}`);
+      console.log('   Run `npx ninja-login` to try again.');
+      return false;
+    }
+  }
+
+  await doLogin();
+
+  console.log(`
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ✨ Setup complete!
 
-MCPs configured:
-  • ninja-terminals - orchestrates parallel Claude Code instances
-  • playwright - browser automation (screenshots, clicks, reading)
-  • fetch - API calls to /api/terminals
-
-Next steps:
-1. Restart Claude Code to load MCP servers
-2. Run: npx ninja-terminals
-3. Or use MCP tools directly in Claude Code
-
-MCP tools available after restart:
-  mcp__ninja-terminals__spawn_terminal
-  mcp__ninja-terminals__send_input
-  mcp__ninja-terminals__list_terminals
-  ... and 9 more
+Next: Restart Claude Code, then tell Claude:
+      "use ninja terminals"
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 `);
-  process.exit(0);
 }
 
+// If setup mode was requested, we're done (setup function calls process.exit)
+if (!hasFlag('--setup')) {
+
 const port      = parseInt(getArg('--port',      '3300'),  10);
 const terminals = parseInt(getArg('--terminals', '2'),     10);  // Free tier default
 const cwd       = getArg('--cwd', process.cwd());
@@ -252,3 +356,5 @@ setTimeout(() => {
 // ── Start the server ─────────────────────────────────────────
 
 require('./server.js');
+
+} // end if (!hasFlag('--setup'))