ninja-terminals 2.3.1 → 2.3.2

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

@@ -60,18 +60,33 @@ if (hasFlag('--setup')) {
 
   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`);
     }
   }
 
@@ -88,8 +103,8 @@ if (hasFlag('--setup')) {
   // Get npm root for copying orchestrator prompt
   const npmRoot = path.dirname(require.resolve('ninja-terminals/package.json'));
 
-  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 +154,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'];

package/lib/nameGenerator.ts

@@ -0,0 +1,101 @@
+/**
+ * VeryRealNames - Absurd but plausible name generator
+ * Names sound like they COULD be real... but aren't
+ */
+
+const FIRST_NAMES = [
+  // Old-timey gems
+  'Hank', 'Gertrude', 'Chester', 'Mildred', 'Barnaby', 'Ethel', 'Cornelius', 'Bertha',
+  'Thaddeus', 'Gladys', 'Reginald', 'Edna', 'Archibald', 'Myrtle', 'Beauregard', 'Agatha',
+  'Wilbur', 'Prudence', 'Mortimer', 'Hortense', 'Bartholomew', 'Eunice', 'Horatio', 'Blanche',
+  'Cuthbert', 'Delphine', 'Engelbert', 'Geraldine', 'Humphrey', 'Imogene',
+  // Slightly unusual but real
+  'Grover', 'Cletus', 'Melvin', 'Dorcas', 'Floyd', 'Beulah', 'Lester', 'Opal',
+  'Merle', 'Velma', 'Elmer', 'Lurleen', 'Durwood', 'Wanda', 'Gus', 'Bernice',
+  'Norbert', 'Doreen', 'Seymour', 'Fern', 'Murray', 'Irma', 'Roscoe', 'Hazel',
+  // Fancy yet awkward
+  'Percival', 'Millicent', 'Fitzgerald', 'Clementine', 'Montgomery', 'Josephine',
+  'Wellington', 'Cordelia', 'Pemberton', 'Henrietta', 'Thurgood', 'Philomena',
+];
+
+const LAST_NAMES = [
+  // Food-adjacent
+  'Pancely', 'Biscuitson', 'Crumbsworth', 'Gravyton', 'Stewbottom', 'Butterham',
+  'Cheesley', 'Meatworth', 'Croutonski', 'Souperton', 'Hamsworth', 'Loafman',
+  'Brisketson', 'Cabbagely', 'Noodleman', 'Porridge', 'Beefington', 'Dumpling',
+  // Animal-infused
+  'Wombleton', 'Badgerly', 'Gooseman', 'Ducksworth', 'Weaselton', 'Moosebury',
+  'Ferretson', 'Hedgewood', 'Squirrelman', 'Toadsworth', 'Pigglesworth', 'Newterson',
+  'Crabshaw', 'Lobsterman', 'Clamsworthy', 'Oysterton',
+  // Body part blends
+  'Finklebottom', 'Rumplesworth', 'Kneely', 'Elbowton', 'Thumbleton', 'Noseberg',
+  'Earlington', 'Toesworth', 'Chinley', 'Knuckleton', 'Shoulderby', 'Ankleman',
+  // Silly suffixes
+  'Wobbleford', 'Snickerton', 'Puddlesworth', 'Bumblesby', 'Giggleston', 'Fumbleby',
+  'Tumblewood', 'Mumbleston', 'Bumbleworth', 'Crumbleford', 'Stumblebrook',
+  // Object-based
+  'Lampsworth', 'Chairington', 'Tableson', 'Doorknobby', 'Carpetman', 'Curtainsby',
+  'Bucketworth', 'Brickleton', 'Plungerby', 'Sockington',
+];
+
+export interface GeneratedName {
+  firstName: string;
+  lastName: string;
+  fullName: string;
+}
+
+/**
+ * Generate a single absurd-but-plausible name
+ */
+export function generateName(): GeneratedName {
+  const firstName = FIRST_NAMES[Math.floor(Math.random() * FIRST_NAMES.length)];
+  const lastName = LAST_NAMES[Math.floor(Math.random() * LAST_NAMES.length)];
+
+  return {
+    firstName,
+    lastName,
+    fullName: `${firstName} ${lastName}`,
+  };
+}
+
+/**
+ * Generate multiple unique names
+ */
+export function generateNames(count: number): GeneratedName[] {
+  const names: GeneratedName[] = [];
+  const seen = new Set<string>();
+
+  const maxPossible = FIRST_NAMES.length * LAST_NAMES.length;
+  const targetCount = Math.min(count, maxPossible);
+
+  while (names.length < targetCount) {
+    const name = generateName();
+    if (!seen.has(name.fullName)) {
+      seen.add(name.fullName);
+      names.push(name);
+    }
+  }
+
+  return names;
+}
+
+/**
+ * Get all available first names
+ */
+export function getFirstNames(): readonly string[] {
+  return FIRST_NAMES;
+}
+
+/**
+ * Get all available last names
+ */
+export function getLastNames(): readonly string[] {
+  return LAST_NAMES;
+}
+
+/**
+ * Get total possible unique combinations
+ */
+export function getTotalCombinations(): number {
+  return FIRST_NAMES.length * LAST_NAMES.length;
+}

package/lib/pre-dispatch.js

@@ -41,11 +41,13 @@ async function loadToolRatings() {
 
 /**
  * Generate tool guidance strings from ratings.
+ * Limited to top 5 warnings + top 5 recommendations to avoid flooding terminals.
  * @param {Map<string, object>} ratings
  * @returns {string[]}
  */
 function generateToolGuidance(ratings) {
-  const guidance = [];
+  const warnings = [];
+  const recommendations = [];
 
   for (const [tool, stats] of ratings) {
     const { rating, composite, success_rate } = stats;
@@ -54,16 +56,24 @@ function generateToolGuidance(ratings) {
       // Low-rated tool: suggest avoidance
       const alt = TOOL_ALTERNATIVES[tool];
       if (alt) {
-        guidance.push(`Avoid ${tool} for ${alt.useCase}, prefer ${alt.preferred} (${tool} has ${rating} rating: ${composite})`);
+        warnings.push({ tool, msg: `Avoid ${tool} for ${alt.useCase}, prefer ${alt.preferred} (${rating} rating)`, composite });
       } else {
-        guidance.push(`Use ${tool} cautiously — ${rating} rating (${composite}), success rate: ${(success_rate * 100).toFixed(0)}%`);
+        warnings.push({ tool, msg: `Use ${tool} cautiously — ${rating} rating, success: ${(success_rate * 100).toFixed(0)}%`, composite });
       }
     } else if (rating === 'S' || rating === 'A') {
       // High-rated tool: recommend preference
-      guidance.push(`Prefer ${tool} — reliable (${rating} rating: ${composite})`);
+      recommendations.push({ tool, msg: `Prefer ${tool} — ${rating} rating`, composite });
     }
   }
 
+  // Sort and limit: worst 5 warnings, best 5 recommendations
+  warnings.sort((a, b) => a.composite - b.composite);
+  recommendations.sort((a, b) => b.composite - a.composite);
+
+  const guidance = [];
+  for (const w of warnings.slice(0, 5)) guidance.push(w.msg);
+  for (const r of recommendations.slice(0, 5)) guidance.push(r.msg);
+
   return guidance;
 }