ninja-terminals 2.4.0 → 2.4.2

package/lib/ninja-request.js

@@ -0,0 +1,247 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const NINJA_DIR = path.join(os.homedir(), '.ninja');
+const REQUEST_FILE = path.join(NINJA_DIR, 'ninja-request.json');
+const LEDGER_FILE = path.join(NINJA_DIR, 'dispatch-ledger.ndjson');
+const VERIFICATION_LEDGER_FILE = path.join(NINJA_DIR, 'verification-ledger.ndjson');
+const VISUAL_LEDGER_FILE = path.join(NINJA_DIR, 'visual-ledger.ndjson');
+
+const NINJA_PATTERNS = [
+  /(?:^|\b)(?:open|start|launch|spawn|bring up)\s+(?:the\s+)?ninja\s*terminals?\b/i,
+  /(?:^|\b)ninja\s*terminals?\s+(?:please|now)\b/i,
+];
+
+const MODE_PATTERNS = [
+  { mode: 'shell', pattern: /(?:terminals?|shell)\s+only/i, defaultCount: 4 },
+  { mode: 'claude', pattern: /claude\s+only/i, defaultCount: 4 },
+  { mode: 'codex', pattern: /codex\s+only/i, defaultCount: 4 },
+  { mode: 'opencode', pattern: /(?:open\s*code|opencode)\s+only/i, defaultCount: 4 },
+  { mode: 'mixed', pattern: /\bmixed\b/i, defaultCount: 4 },
+  { mode: 'duo', pattern: /\bduo\b/i, defaultCount: 2 },
+];
+
+const NUMBER_WORDS = new Map([
+  ['one', 1],
+  ['two', 2],
+  ['three', 3],
+  ['four', 4],
+  ['five', 5],
+  ['six', 6],
+  ['seven', 7],
+  ['eight', 8],
+]);
+
+function isNinjaRequest(prompt) {
+  if (!prompt) return false;
+  return NINJA_PATTERNS.some(pattern => pattern.test(prompt));
+}
+
+function inferNinjaLaunchConfig(prompt) {
+  const text = String(prompt || '');
+  const modeEntry = MODE_PATTERNS.find(entry => entry.pattern.test(text));
+  const mode = modeEntry ? modeEntry.mode : 'claude';
+  const defaultCount = modeEntry ? modeEntry.defaultCount : 4;
+
+  const numericCount = text.match(/\b(\d+)\s*(?:terminals?|instances?)\b/i);
+  const wordCount = text.match(/\b(one|two|three|four|five|six|seven|eight)\s*(?:terminals?|instances?)\b/i);
+  const requestedCount = numericCount
+    ? parseInt(numericCount[1], 10)
+    : wordCount
+      ? NUMBER_WORDS.get(wordCount[1].toLowerCase())
+      : null;
+
+  const terminalCount = Number.isInteger(requestedCount) && requestedCount > 0
+    ? requestedCount
+    : defaultCount;
+
+  return { mode, terminalCount };
+}
+
+function writeNinjaRequest(cwd, promptPreview) {
+  try {
+    fs.mkdirSync(NINJA_DIR, { recursive: true, mode: 0o700 });
+    const launchConfig = inferNinjaLaunchConfig(promptPreview);
+    const data = {
+      timestamp: new Date().toISOString(),
+      cwd: cwd || process.cwd(),
+      promptPreview: (promptPreview || '').slice(0, 200),
+      launchConfig,
+    };
+    fs.writeFileSync(REQUEST_FILE, JSON.stringify(data, null, 2) + '\n', { mode: 0o600 });
+    return data;
+  } catch (err) {
+    console.error(`Warning: Could not write ninja request: ${err.message}`);
+    return null;
+  }
+}
+
+function readNinjaRequest() {
+  try {
+    const raw = fs.readFileSync(REQUEST_FILE, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function clearNinjaRequest() {
+  try {
+    fs.unlinkSync(REQUEST_FILE);
+  } catch {
+    // already absent
+  }
+}
+
+function readLedgerAfter(afterTimestamp) {
+  try {
+    const raw = fs.readFileSync(LEDGER_FILE, 'utf8');
+    const lines = raw.trim().split('\n').filter(Boolean);
+    const entries = [];
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.timestamp && entry.timestamp > afterTimestamp) {
+          entries.push(entry);
+        }
+      } catch {
+        // skip malformed
+      }
+    }
+    return entries;
+  } catch {
+    return [];
+  }
+}
+
+function hasSuccessfulDispatchAfter(afterTimestamp) {
+  const entries = readLedgerAfter(afterTimestamp);
+  return entries.some(e => e.success === true);
+}
+
+function readVerificationLedgerAfter(afterTimestamp) {
+  try {
+    const raw = fs.readFileSync(VERIFICATION_LEDGER_FILE, 'utf8');
+    const lines = raw.trim().split('\n').filter(Boolean);
+    const entries = [];
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.timestamp && entry.timestamp > afterTimestamp) {
+          entries.push(entry);
+        }
+      } catch {
+        // skip malformed
+      }
+    }
+    return entries;
+  } catch {
+    return [];
+  }
+}
+
+function hasVerificationAfter(afterTimestamp) {
+  const entries = readVerificationLedgerAfter(afterTimestamp);
+  return entries.length > 0;
+}
+
+function getLastSuccessfulDispatchTimestamp(afterTimestamp) {
+  const entries = readLedgerAfter(afterTimestamp);
+  const successful = entries.filter(e => e.success === true);
+  if (successful.length === 0) return null;
+  return successful[successful.length - 1].timestamp;
+}
+
+function getLastVerificationTimestamp(afterTimestamp) {
+  const entries = readVerificationLedgerAfter(afterTimestamp);
+  if (entries.length === 0) return null;
+  return entries[entries.length - 1].timestamp;
+}
+
+function readVisualLedgerAfter(afterTimestamp) {
+  try {
+    const raw = fs.readFileSync(VISUAL_LEDGER_FILE, 'utf8');
+    const lines = raw.trim().split('\n').filter(Boolean);
+    const entries = [];
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.timestamp && entry.timestamp > afterTimestamp) {
+          entries.push(entry);
+        }
+      } catch {
+        // skip malformed
+      }
+    }
+    return entries;
+  } catch {
+    return [];
+  }
+}
+
+function readVisualLedgerBetween(startTs, endTs) {
+  try {
+    const raw = fs.readFileSync(VISUAL_LEDGER_FILE, 'utf8');
+    const lines = raw.trim().split('\n').filter(Boolean);
+    const entries = [];
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.timestamp && entry.timestamp > startTs && entry.timestamp < endTs) {
+          entries.push(entry);
+        }
+      } catch {
+        // skip malformed
+      }
+    }
+    return entries;
+  } catch {
+    return [];
+  }
+}
+
+function hasVisualBetween(startTs, endTs, options = {}) {
+  const entries = readVisualLedgerBetween(startTs, endTs);
+  return entries.some(e => {
+    if (options.stage && e.stage !== options.stage) return false;
+    if (options.stages && !options.stages.includes(e.stage)) return false;
+    if (options.source && e.source !== options.source) return false;
+    return true;
+  });
+}
+
+function hasVisualAfter(afterTimestamp, options = {}) {
+  const entries = readVisualLedgerAfter(afterTimestamp);
+  return entries.some(e => {
+    if (options.stage && e.stage !== options.stage) return false;
+    if (options.stages && !options.stages.includes(e.stage)) return false;
+    if (options.source && e.source !== options.source) return false;
+    return true;
+  });
+}
+
+module.exports = {
+  NINJA_DIR,
+  REQUEST_FILE,
+  LEDGER_FILE,
+  VERIFICATION_LEDGER_FILE,
+  VISUAL_LEDGER_FILE,
+  isNinjaRequest,
+  inferNinjaLaunchConfig,
+  writeNinjaRequest,
+  readNinjaRequest,
+  clearNinjaRequest,
+  readLedgerAfter,
+  hasSuccessfulDispatchAfter,
+  readVerificationLedgerAfter,
+  hasVerificationAfter,
+  getLastSuccessfulDispatchTimestamp,
+  getLastVerificationTimestamp,
+  readVisualLedgerAfter,
+  readVisualLedgerBetween,
+  hasVisualBetween,
+  hasVisualAfter,
+};

package/lib/settings-gen.js

@@ -192,22 +192,9 @@ function writeWorkerSettings(terminalId, projectDir, scope, options = {}) {
   const mergedAllow = [...new Set([...(existing.permissions?.allow || []), ...settings.permissions.allow])];
   const mergedDeny = [...new Set([...(existing.permissions?.deny || []), ...settings.permissions.deny])];
 
-  // Build hooks for self-improvement loop (matches Claude Code's nested format)
-  const ninjaDir = path.resolve(__dirname, '..');
-  const hooks = {
-    PostToolUse: [{
-      matcher: '',
-      hooks: [{
-        type: 'command',
-        command: path.join(ninjaDir, '.claude/hooks/track-tool.sh'),
-      }],
-    }],
-  };
-
   const merged = {
     ...existing,
     permissions: { allow: mergedAllow, deny: mergedDeny },
-    hooks,
     sandbox: settings.sandbox,
   };
 

package/mcp-server.js

@@ -40,10 +40,13 @@ const {
 } = require('./lib/runtime-session');
 
 // ── Config ──────────────────────────────────────────────────
-const PREFERRED_HTTP_PORT = parseInt(process.env.HTTP_PORT || '3300', 10);
+const PREFERRED_HTTP_PORT = parseInt(process.env.HTTP_PORT || process.env.PORT || '3300', 10);
 let HTTP_PORT = PREFERRED_HTTP_PORT;
-const CLAUDE_CMD = process.env.CLAUDE_CMD || 'claude --dangerously-skip-permissions';
-const SHELL = process.env.SHELL || '/bin/zsh';
+const CLAUDE_CMD = process.env.CLAUDE_CMD || process.env.CLAUDE_CHROME_CMD || 'claude --chrome --model claude-opus-4-5-20251101';
+// Windows has no $SHELL / /bin/zsh — default to PowerShell (handles drive
+// changes via `cd` and emits clean ANSI for status detection).
+const IS_WIN = process.platform === 'win32';
+const SHELL = IS_WIN ? (process.env.NINJA_SHELL || 'powershell.exe') : (process.env.SHELL || '/bin/zsh');
 const PROJECT_DIR = __dirname;
 const INJECT_GUIDANCE = process.env.INJECT_GUIDANCE !== 'false';
 
@@ -151,16 +154,27 @@ function spawnTerminal(label, scope = [], cwd = null, tier = 'pro') {
     env: {
       ...cleanEnv,
       TERM: 'xterm-256color',
+      COLORTERM: 'truecolor',
+      FORCE_COLOR: '1',
+      CLICOLOR_FORCE: '1',
       HOME: os.homedir(),
-      PATH: `${os.homedir()}/.local/bin:/opt/homebrew/bin:${process.env.PATH || ''}`,
+      // On Windows, keep the native PATH untouched (mac/linux bin dirs would
+      // corrupt it via the ';' delimiter). On POSIX, prepend the usual bins.
+      PATH: IS_WIN
+        ? (process.env.PATH || '')
+        : [`${os.homedir()}/.local/bin`, '/opt/homebrew/bin', process.env.PATH || '']
+            .filter(Boolean).join(path.delimiter),
       SHELL_SESSIONS_DISABLE: '1',
       NINJA_TERMINAL_ID: String(id),
     },
   });
 
-  // Launch claude after shell starts
+  // Launch claude after shell starts. Two separate writes (cd, then command)
+  // instead of `&&` — works across bash/zsh/PowerShell/cmd, which disagree on
+  // command chaining (`&&` is unsupported in Windows PowerShell 5).
   setTimeout(() => {
-    ptyProcess.write(`cd "${workDir}" && ${CLAUDE_CMD}\r`);
+    ptyProcess.write(`cd "${workDir}"\r`);
+    setTimeout(() => ptyProcess.write(`${CLAUDE_CMD}\r`), 250);
   }, 500);
 
   const terminal = {
@@ -940,37 +954,8 @@ async function main() {
     console.error(`Ninja Terminals server already running on port ${HTTP_PORT}`);
     console.error('MCP server starting in proxy mode (will use existing server)');
   } else {
-    HTTP_PORT = await findAvailablePort(PREFERRED_HTTP_PORT);
-    if (HTTP_PORT !== PREFERRED_HTTP_PORT) {
-      console.error(`Ninja Terminals preferred HTTP port ${PREFERRED_HTTP_PORT} unavailable; using ${HTTP_PORT}`);
-    }
-
-    // Standalone mode: start our own HTTP server
-    httpServer.listen(HTTP_PORT, () => {
-      const url = `http://localhost:${HTTP_PORT}`;
-      writeRuntimeSession({
-        port: HTTP_PORT,
-        url,
-        cwd: PROJECT_DIR,
-        terminals: parseInt(process.env.NINJA_TERMINAL_COUNT || '2', 10),
-        command: 'ninja-terminals-mcp',
-      });
-      ownsRuntimeSession = true;
-      console.error(`Ninja Terminals HTTP server running on ${url}`);
-
-      // Auto-spawn terminals based on tier (NINJA_TERMINAL_COUNT env var)
-      // Free = 2, Paid = 4
-      const terminalCount = parseInt(process.env.NINJA_TERMINAL_COUNT || '2', 10);
-      const labels = ['T1', 'T2', 'T3', 'T4', 'T5', 'T6', 'T7', 'T8'];
-
-      console.error(`Auto-spawning ${terminalCount} terminals...`);
-      for (let i = 0; i < terminalCount; i++) {
-        const label = labels[i] || `T${i + 1}`;
-        spawnTerminal(label, [], process.cwd(), 'pro');
-        console.error(`  Spawned ${label}`);
-      }
-      console.error(`All ${terminalCount} terminals ready`);
-    });
+    console.error('No live Ninja runtime found. MCP is staying request-only until ninja-ensure starts the runtime.');
+    console.error('No HTTP server, no session file, no terminal spawn on Claude startup.');
   }
 
   // Start MCP server on stdio

package/ninja-ensure.js

@@ -13,6 +13,10 @@ const {
   writeRuntimeSession,
   requestJson,
 } = require('./lib/runtime-session');
+const {
+  readNinjaRequest,
+  inferNinjaLaunchConfig,
+} = require('./lib/ninja-request');
 
 const LOG_FILE = path.join(SESSION_DIR, 'ninja-server.log');
 const PROJECT_ROOT = __dirname;
@@ -20,16 +24,21 @@ const PROJECT_ROOT = __dirname;
 const PROBE_PORTS = [3300, 3301, 3302, 3303, 3304, 3305, 3306, 3307, 3308, 3309, 3310];
 const AUTH_WAIT_MS = 15000;
 const AUTH_POLL_MS = 500;
+const MAX_SESSION_AGE_MS = parseInt(process.env.NINJA_MAX_SESSION_AGE_MS || '3600000', 10);
 
 const USAGE = `
 ninja-ensure — Start, discover, or recover a dispatch-ready Ninja Terminal runtime
 
 Usage:
-  ninja-ensure                Start/discover/recover, open browser, wait for auth
-  ninja-ensure --no-open      Start/discover/recover, don't open browser
-  ninja-ensure --allow-no-auth  Allow success without authToken (dispatch will fail)
-  ninja-ensure --dry-run      Report what would happen, no action
-  ninja-ensure --help         Show this help
+  ninja-ensure                     Start or reuse a matching runtime, open browser, wait for auth
+  ninja-ensure --no-open           Start or reuse a matching runtime, don't open browser
+  ninja-ensure --mode <mode>       Override fleet mode for this explicit launch
+  ninja-ensure --terminals <n>     Override terminal count for this explicit launch
+  ninja-ensure --fresh             Ignore any existing runtime/session and start fresh
+  ninja-ensure --recover-orphan    Probe for and recover an orphaned runtime if no session matches
+  ninja-ensure --allow-no-auth     Allow success without authToken (dispatch will fail)
+  ninja-ensure --dry-run           Report what would happen, no action
+  ninja-ensure --help              Show this help
 
 Dispatch-ready means:
   - Ninja Terminal server is running and healthy
@@ -48,6 +57,14 @@ function log(msg) {
   console.log(msg);
 }
 
+function getArgValue(args, flag) {
+  const index = args.indexOf(flag);
+  if (index < 0 || index + 1 >= args.length) return null;
+  const value = args[index + 1];
+  if (!value || value.startsWith('--')) return null;
+  return value;
+}
+
 function chromeHasUrl(url) {
   if (process.platform !== 'darwin') return false;
   try {
@@ -95,6 +112,40 @@ function openBrowser(url) {
   }
 }
 
+function normalizePathForCompare(value) {
+  if (!value) return null;
+  return path.resolve(String(value));
+}
+
+function getSessionAgeMs(session) {
+  if (!session) return null;
+  const rawTs = session.updatedAt || session.createdAt;
+  if (!rawTs) return null;
+  const ts = Date.parse(rawTs);
+  if (!Number.isFinite(ts)) return null;
+  return Date.now() - ts;
+}
+
+function sessionMatchesLaunchConfig(session, requestedCwd, launchConfig) {
+  if (!session || !session.launchConfig) return false;
+
+  const sessionMode = session.launchConfig.mode || 'claude';
+  const sessionCount = parseInt(session.launchConfig.terminalCount || session.terminals || 0, 10);
+  const sessionCwd = normalizePathForCompare(session.cwd);
+  const requestedPath = normalizePathForCompare(requestedCwd);
+
+  if (sessionMode !== launchConfig.mode) return false;
+  if (sessionCount !== launchConfig.terminalCount) return false;
+  if (!sessionCwd || !requestedPath || sessionCwd !== requestedPath) return false;
+
+  if (Number.isFinite(MAX_SESSION_AGE_MS) && MAX_SESSION_AGE_MS > 0) {
+    const ageMs = getSessionAgeMs(session);
+    if (ageMs == null || ageMs > MAX_SESSION_AGE_MS) return false;
+  }
+
+  return true;
+}
+
 function getTokenFromSources(session) {
   if (process.env.NINJA_AUTH_TOKEN) return process.env.NINJA_AUTH_TOKEN;
   if (session?.authToken) return session.authToken;
@@ -161,16 +212,17 @@ async function probeForOrphanedServer() {
   return found || null;
 }
 
-function recoverSessionFile(port, host = 'localhost') {
+function recoverSessionFile(port, host = 'localhost', cwd = process.cwd(), launchConfig = null) {
   const url = `http://${host}:${port}`;
   const session = writeRuntimeSession({
     port,
     url,
-    cwd: process.cwd(),
-    terminals: 4,
+    cwd,
+    terminals: launchConfig?.terminalCount || 4,
     command: 'ninja-ensure',
     recovered: true,
     recoveredAt: new Date().toISOString(),
+    launchConfig: launchConfig || inferNinjaLaunchConfig('open ninja terminals'),
     pid: null, // Don't claim a pid we don't own
   });
   return session;
@@ -189,14 +241,18 @@ async function waitForSession(timeoutMs = 20000, pollMs = 300) {
   return null;
 }
 
-async function startServer() {
+async function startServer({ cwd = process.cwd(), launchConfig = null } = {}) {
   fs.mkdirSync(SESSION_DIR, { recursive: true });
   const logStream = fs.openSync(LOG_FILE, 'a');
+  const effectiveLaunchConfig = launchConfig || inferNinjaLaunchConfig('open ninja terminals');
 
   const child = spawn('node', ['server.js'], {
     cwd: PROJECT_ROOT,
     env: {
       ...process.env,
+      DEFAULT_CWD: cwd,
+      NINJA_MODE: effectiveLaunchConfig.mode,
+      DEFAULT_TERMINALS: String(effectiveLaunchConfig.terminalCount || 4),
       NINJA_OPEN_BROWSER: 'false',
     },
     detached: true,
@@ -228,6 +284,21 @@ async function main() {
   const noOpen = args.includes('--no-open');
   const dryRun = args.includes('--dry-run');
   const allowNoAuth = args.includes('--allow-no-auth');
+  const fresh = args.includes('--fresh');
+  const recoverOrphan = args.includes('--recover-orphan');
+  const requestedMode = getArgValue(args, '--mode');
+  const requestedTerminalsRaw = getArgValue(args, '--terminals');
+  const requestedTerminals = requestedTerminalsRaw ? parseInt(requestedTerminalsRaw, 10) : null;
+  const request = readNinjaRequest();
+  const inferredLaunchConfig = request?.launchConfig || inferNinjaLaunchConfig(request?.promptPreview || '');
+  const launchConfig = {
+    mode: requestedMode || inferredLaunchConfig.mode,
+    terminalCount: Number.isInteger(requestedTerminals) && requestedTerminals > 0
+      ? requestedTerminals
+      : inferredLaunchConfig.terminalCount,
+  };
+  const requestedCwd = request?.cwd || process.cwd();
+  log(`Requested launch: mode=${launchConfig.mode}, terminals=${launchConfig.terminalCount}, cwd=${requestedCwd}${fresh ? ' (fresh)' : ''}${recoverOrphan ? ' (recover-orphan)' : ''}`);
 
   // Step 1: Check existing session file
   const existingSession = readRuntimeSession();
@@ -236,20 +307,23 @@ async function main() {
 
   if (existingSession?.port) {
     const health = await healthCheckSession(existingSession);
-    if (health.ok) {
+    if (health.ok && !fresh && sessionMatchesLaunchConfig(existingSession, requestedCwd, launchConfig)) {
       session = existingSession;
       action = 'reuse';
+    } else if (health.ok) {
+      log('Healthy session found, but it does not match the requested launch config');
+      log('Will start a fresh runtime for this explicit request');
     }
   }
 
-  // Step 2: If no healthy session, probe for orphaned server
-  if (!session) {
-    log('No healthy session file. Probing for orphaned Ninja server...');
+  // Step 2: If no reusable session, optionally probe for orphaned server
+  if (!session && recoverOrphan && !fresh) {
+    log('No reusable session file. Probing for orphaned Ninja server...');
     const orphaned = await probeForOrphanedServer();
     if (orphaned) {
       action = 'recover';
       if (!dryRun) {
-        session = recoverSessionFile(orphaned.port, orphaned.host);
+        session = recoverSessionFile(orphaned.port, orphaned.host, requestedCwd, launchConfig);
         log(`Recovered orphaned runtime: http://${orphaned.host}:${orphaned.port}`);
       } else {
         session = { port: orphaned.port, host: orphaned.host, url: `http://${orphaned.host}:${orphaned.port}` };
@@ -257,6 +331,8 @@ async function main() {
     } else {
       action = 'start';
     }
+  } else if (!session) {
+    action = 'start';
   }
 
   // Dry run reporting
@@ -270,7 +346,7 @@ async function main() {
       log(`[dry-run] Would repair session file: ${SESSION_FILE}`);
       log(`[dry-run] authToken will be missing (browser sync required)`);
     } else {
-      log(`[dry-run] No runtime found on probed ports`);
+      log(`[dry-run] No reusable runtime found`);
       log(`[dry-run] Would start new server from ${PROJECT_ROOT}`);
     }
     log(`[dry-run] Would open browser: ${!noOpen}`);
@@ -279,7 +355,7 @@ async function main() {
 
   // Step 3: Start new server if needed
   if (action === 'start') {
-    session = await startServer();
+    session = await startServer({ cwd: requestedCwd, launchConfig });
     log(`Server ready on ${session.url}`);
   } else if (action === 'reuse') {
     log(`Runtime already active: ${session.url}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ninja-terminals",
-  "version": "2.4.0",
+  "version": "2.4.2",
   "description": "MCP server for multi-terminal Claude Code orchestration with DAG task management, parallel execution, and self-improvement",
   "main": "server.js",
   "bin": {
@@ -49,8 +49,7 @@
     "ninja-logout.js",
     "ninja-whoami.js",
     "CLAUDE.md",
-    "ORCHESTRATOR-PROMPT.md",
-    "hooks/"
+    "ORCHESTRATOR-PROMPT.md"
   ],
   "keywords": [
     "claude",