ninja-terminals 2.4.6 → 2.4.9

package/cli.js

@@ -185,7 +185,7 @@ MCP tools available after restart:
 }
 
 const port      = parseInt(getArg('--port',      '3300'),  10);
-const terminals = parseInt(getArg('--terminals', '2'),     10);  // Free tier default
+const terminals = parseInt(getArg('--terminals', '4'),     10);  // Default fleet size
 const cwd       = getArg('--cwd', process.cwd());
 const token     = getArg('--token', null);
 const offline   = hasFlag('--offline');

package/lib/runtime-session.js

@@ -5,10 +5,16 @@ const http = require('http');
 const net = require('net');
 const os = require('os');
 const path = require('path');
-const { spawn } = require('child_process');
+const { spawn, execSync } = require('child_process');
 
-const SESSION_DIR = path.join(os.homedir(), '.ninja');
+// NINJA_HOME lets a second, isolated Ninja runtime coexist with another agent's default
+// runtime: it gets its own session.json/lock so the two never SIGTERM each other on launch.
+// Defaults to ~/.ninja, so existing single-runtime behavior is unchanged.
+const SESSION_DIR = path.join(process.env.NINJA_HOME || os.homedir(), '.ninja');
 const SESSION_FILE = path.join(SESSION_DIR, 'session.json');
+// Per-port session files live here, one per running runtime. session.json above
+// stays as a "most-recent" pointer so existing readers keep working unchanged.
+const SESSIONS_DIR = path.join(SESSION_DIR, 'sessions');
 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');
@@ -18,6 +24,10 @@ function ensureSessionDir() {
   fs.mkdirSync(SESSION_DIR, { recursive: true, mode: 0o700 });
 }
 
+function sessionFileForPort(port) {
+  return path.join(SESSIONS_DIR, `${port}.json`);
+}
+
 // Probe a single host: 'free' (bindable), 'inuse' (EADDRINUSE), or
 // 'unavailable' (stack absent / other error — don't treat as a collision).
 function probePort(port, host) {
@@ -54,6 +64,81 @@ async function findAvailablePort(preferredPort, host = '127.0.0.1', maxAttempts
   throw new Error(`No available port found from ${start} to ${Math.min(start + maxAttempts - 1, 65535)}`);
 }
 
+// Terminate a previous Ninja runtime recorded in the session file so a new
+// launch REPLACES it instead of orphaning it (which caused servers to pile up
+// and the port to climb 3300 -> 3301 -> 3302 on each relaunch). Verifies the
+// PID is actually a Ninja process before killing (guards against PID reuse).
+// Returns true if it killed something. selfPid is skipped (don't kill caller).
+async function killStaleRuntime(session, selfPid = process.pid) {
+  const pid = session && session.pid;
+  if (!pid || pid === selfPid) return false;
+
+  // Is the process even alive?
+  try { process.kill(pid, 0); } catch { return false; }
+
+  // NEVER kill a HEALTHY runtime — it may be another instance doing real work.
+  // Only a dead/hung runtime is a "stale" one worth reclaiming. This is the
+  // guard that stops a new launch from SIGTERMing a live parallel fleet.
+  if (session.port) {
+    const health = await healthCheckSession(
+      { host: session.host || '127.0.0.1', port: session.port },
+      1500,
+    );
+    if (health.ok) return false;
+  }
+
+  // Verify it's a Ninja server (avoid killing an unrelated reused PID).
+  if (process.platform !== 'win32') {
+    try {
+      const cmd = execSync(`ps -p ${pid} -o command=`, { encoding: 'utf8' }).trim();
+      if (!/server\.js|cli\.js|ninja/i.test(cmd)) return false;
+    } catch { return false; }
+  }
+
+  try {
+    process.kill(pid, 'SIGTERM');
+    // Give it a moment to release its port so the new server can reclaim it.
+    await new Promise((resolve) => setTimeout(resolve, 800));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Reclaim the preferred port from any *Ninja* server still holding it. The
+// pid-based killStaleRuntime only knows the single pid in session.json, so
+// orphans on climbed ports (3301/3302 from earlier crashed relaunches) survive
+// and findAvailablePort climbs past them — each climb is a new server and a new
+// browser tab (the 2/4/6-tab pile-up). Sweeping the port itself kills them all.
+// Only SIGTERMs processes verified as Ninja; a non-Ninja listener is left alone
+// (caller then climbs past it as before). POSIX-only (lsof); no-op elsewhere.
+async function reclaimPort(port, selfPid = process.pid) {
+  if (process.platform === 'win32') return 0;
+  // Never reclaim a HEALTHY fleet. If the port answers /health, it's a live
+  // Ninja instance — leave it alone and let the caller climb to the next port.
+  // Only sweep when the listener is dead/hung (a true orphan).
+  const holder = await healthCheckSession({ host: '127.0.0.1', port }, 1500);
+  if (holder.ok) return 0;
+  let pids;
+  try {
+    pids = execSync(`lsof -ti tcp:${port} -sTCP:LISTEN`, { encoding: 'utf8' })
+      .split('\n').map((s) => parseInt(s, 10)).filter((p) => p && p !== selfPid);
+  } catch {
+    return 0; // lsof absent or nothing on the port
+  }
+  let killed = 0;
+  for (const pid of new Set(pids)) {
+    try {
+      const cmd = execSync(`ps -p ${pid} -o command=`, { encoding: 'utf8' }).trim();
+      if (!/server\.js|cli\.js|ninja/i.test(cmd)) continue; // not ours — leave it
+      process.kill(pid, 'SIGTERM');
+      killed++;
+    } catch { /* gone already / not killable */ }
+  }
+  if (killed) await new Promise((resolve) => setTimeout(resolve, 800)); // let ports release
+  return killed;
+}
+
 function writeRuntimeSession(session) {
   ensureSessionDir();
   const payload = {
@@ -63,10 +148,36 @@ function writeRuntimeSession(session) {
     createdAt: new Date().toISOString(),
     ...session,
   };
-  fs.writeFileSync(SESSION_FILE, JSON.stringify(payload, null, 2) + '\n', { mode: 0o600 });
+  const json = JSON.stringify(payload, null, 2) + '\n';
+  // Pointer: "most-recent runtime" — keeps every existing reader working.
+  fs.writeFileSync(SESSION_FILE, json, { mode: 0o600 });
+  // Per-port file: lets parallel fleets coexist without clobbering each other.
+  if (payload.port) {
+    fs.mkdirSync(SESSIONS_DIR, { recursive: true, mode: 0o700 });
+    fs.writeFileSync(sessionFileForPort(payload.port), json, { mode: 0o600 });
+  }
   return payload;
 }
 
+// All currently-recorded runtimes (one per per-port file). Most-recent first.
+function listRuntimeSessions() {
+  let files;
+  try {
+    files = fs.readdirSync(SESSIONS_DIR).filter((f) => f.endsWith('.json'));
+  } catch {
+    return [];
+  }
+  const sessions = files.map((f) => {
+    try {
+      return JSON.parse(fs.readFileSync(path.join(SESSIONS_DIR, f), 'utf8'));
+    } catch {
+      return null;
+    }
+  }).filter(Boolean);
+  sessions.sort((a, b) => String(b.updatedAt || b.createdAt || '').localeCompare(String(a.updatedAt || a.createdAt || '')));
+  return sessions;
+}
+
 function updateRuntimeSession(patch) {
   const current = readRuntimeSession() || {};
   return writeRuntimeSession({ ...current, ...patch, updatedAt: new Date().toISOString() });
@@ -81,7 +192,29 @@ function readRuntimeSession() {
   }
 }
 
-function clearRuntimeSession() {
+// Remove a runtime's record on shutdown. With a port, only THIS runtime's
+// per-port file is removed; the shared pointer is repointed to a surviving
+// fleet (sync, best-effort — no health check, this runs in process 'exit')
+// instead of being deleted, so other live fleets stay discoverable. Called
+// with no port it keeps the old behavior (delete the pointer).
+function clearRuntimeSession(port) {
+  if (port) {
+    try { fs.unlinkSync(sessionFileForPort(port)); } catch { /* already gone */ }
+    let pointer = null;
+    try { pointer = JSON.parse(fs.readFileSync(SESSION_FILE, 'utf8')); } catch { /* none */ }
+    // Only touch the pointer if it was pointing at us.
+    if (!pointer || pointer.port === port) {
+      const survivors = listRuntimeSessions();
+      if (survivors.length) {
+        try {
+          fs.writeFileSync(SESSION_FILE, JSON.stringify(survivors[0], null, 2) + '\n', { mode: 0o600 });
+        } catch { /* best effort */ }
+      } else {
+        try { fs.unlinkSync(SESSION_FILE); } catch { /* already gone */ }
+      }
+    }
+    return;
+  }
   try {
     fs.unlinkSync(SESSION_FILE);
   } catch {
@@ -321,16 +454,20 @@ function hasVisualAfter(afterTimestamp, options = {}) {
 module.exports = {
   SESSION_DIR,
   SESSION_FILE,
+  SESSIONS_DIR,
   TOKEN_FILE,
   LEDGER_FILE,
   VERIFICATION_LEDGER_FILE,
   VISUAL_LEDGER_FILE,
   VALID_VISUAL_STAGES,
   findAvailablePort,
+  killStaleRuntime,
+  reclaimPort,
   writeRuntimeSession,
   updateRuntimeSession,
   readRuntimeSession,
   clearRuntimeSession,
+  listRuntimeSessions,
   writeAuthToken,
   readAuthToken,
   healthCheckSession,

package/mcp-server.js

@@ -7,6 +7,7 @@
  * Also starts HTTP server on port 3300 for browser UI.
  */
 
+const pkg = require('./package.json');
 const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
 const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
 const {
@@ -359,7 +360,7 @@ httpServer.on('upgrade', (req, socket, head) => {
 app.get('/health', (_req, res) => {
   res.json({
     status: 'ok',
-    version: '2.1.5-mcp',
+    version: `${pkg.version}-mcp`,
     terminals: terminals.size,
     mode: 'mcp',
   });
@@ -510,7 +511,7 @@ app.post('/api/terminals/:id/input', async (req, res) => {
 // ── MCP Server Setup ────────────────────────────────────────
 
 const mcpServer = new Server(
-  { name: 'ninja-terminals', version: '2.1.5' },
+  { name: 'ninja-terminals', version: pkg.version },
   { capabilities: { tools: {} } }
 );
 

package/ninja-ensure.js

@@ -11,6 +11,7 @@ const {
   readRuntimeSession,
   healthCheckSession,
   writeRuntimeSession,
+  killStaleRuntime,
   requestJson,
 } = require('./lib/runtime-session');
 const {
@@ -310,9 +311,18 @@ async function main() {
     if (health.ok && !fresh && sessionMatchesLaunchConfig(existingSession, requestedCwd, launchConfig)) {
       session = existingSession;
       action = 'reuse';
+    } else if (health.ok && fresh) {
+      // --fresh explicitly asked to start over: only safe to reclaim a runtime
+      // that isn't healthy. killStaleRuntime health-gates, so a live fleet is
+      // never killed here either — we just start alongside it.
+      const killed = await killStaleRuntime(existingSession);
+      if (killed) log(`Terminated dead previous runtime (pid ${existingSession.pid})`);
     } 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');
+      // A healthy fleet is running but doesn't match this launch (different
+      // project/mode, or older than the reuse window). Do NOT kill it — that
+      // would destroy a parallel instance's work. Start a new server alongside;
+      // it climbs to the next free port and the two coexist.
+      log('A different healthy Ninja fleet is running — starting a new one alongside it (it will use the next free port).');
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ninja-terminals",
-  "version": "2.4.6",
+  "version": "2.4.9",
   "description": "MCP server for multi-terminal Claude Code orchestration with DAG task management, parallel execution, and self-improvement",
   "main": "server.js",
   "bin": {

package/public/app.js

@@ -1033,7 +1033,8 @@ function setupAddTerminal() {
   if (!btn) return;
 
   // Store last used directory
-  let lastCwd = localStorage.getItem('ninja-last-cwd') || '/Users/davidmini/Desktop/Projects';
+  // ponytail: empty default → server falls back to its own process.cwd(); never hardcode an author machine path
+  let lastCwd = localStorage.getItem('ninja-last-cwd') || '';
   let lastAgentType = localStorage.getItem('ninja-last-agent-type') || 'claude';
 
   if (preset) {

package/public/index.html

@@ -9,6 +9,11 @@
   <link href="https://fonts.googleapis.com/css2?family=Bebas+Neue&family=Space+Grotesk:wght@400;600;700&display=swap" rel="stylesheet">
   <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xterm/xterm@5.5.0/css/xterm.min.css">
   <link rel="stylesheet" href="style.css">
+  <!-- PostHog analytics -->
+  <script>
+    !function(t,e){var o,n,p,r;e.__SV||(window.posthog=e,e._i=[],e.init=function(i,s,a){function g(t,e){var o=e.split(".");2==o.length&&(t=t[o[0]],e=o[1]),t[e]=function(){t.push([e].concat(Array.prototype.slice.call(arguments,0)))}}(p=t.createElement("script")).type="text/javascript",p.crossOrigin="anonymous",p.async=!0,p.src=s.api_host.replace(".i.posthog.com","-assets.i.posthog.com")+"/static/array.js",(r=t.getElementsByTagName("script")[0]).parentNode.insertBefore(p,r);var u=e;for(void 0!==a?u=e[a]=[]:a="posthog",u.people=u.people||[],u.toString=function(t){var e="posthog";return"posthog"!==a&&(e+="."+a),t||(e+=" (stub)"),e},u.people.toString=function(){return u.toString(1)+".people (stub)"},o="init capture register register_once register_for_session unregister unregister_for_session getFeatureFlag getFeatureFlagPayload isFeatureEnabled reloadFeatureFlags updateEarlyAccessFeatureEnrollment getEarlyAccessFeatures on onFeatureFlags onSessionId getSurveys getActiveMatchingSurveys renderSurvey canRenderSurvey getNextSurveyStep identify setPersonProperties group resetGroups setPersonPropertiesForFlags resetPersonPropertiesForFlags setGroupPropertiesForFlags resetGroupPropertiesForFlags reset get_distinct_id getGroups get_session_id get_session_replay_url alias set_config startSessionRecording stopSessionRecording sessionRecordingStarted captureException loadToolbar get_property getSessionProperty createPersonProfile opt_in_capturing opt_out_capturing has_opted_in_capturing has_opted_out_capturing clear_opt_in_out_capturing debug getPageViewId captureTraceFeedback captureTraceMetric".split(" "),n=0;n<o.length;n++)g(u,o[n]);e._i.push([i,s,a])},e.__SV=1)}(document,window.posthog||[]);
+    posthog.init('phc_AmUYDCH793ekSGYpDxfoH8raVceuXjxnPxqF844i7u7A',{api_host:'https://us.i.posthog.com',defaults:'2025-05-24'})
+  </script>
 </head>
 <body>
   <!-- Learnings Modal -->

package/server.js

@@ -1,3 +1,4 @@
+const pkg = require('./package.json');
 const express = require('express');
 const http = require('http');
 const { WebSocketServer } = require('ws');
@@ -26,6 +27,9 @@ const { runPostSession } = require('./lib/post-session');
 const {
   SESSION_FILE,
   findAvailablePort,
+  killStaleRuntime,
+  reclaimPort,
+  readRuntimeSession,
   writeRuntimeSession,
   updateRuntimeSession,
   clearRuntimeSession,
@@ -179,8 +183,10 @@ function spawnTerminal(label, scope = [], cwd = null, tier = 'pro', agentType =
   // Resolve working directory — custom cwd or default to PROJECT_DIR
   // Validate cwd to prevent broken paths like "\" from corrupting terminal startup
   let workDir = cwd || PROJECT_DIR;
-  if (!workDir || workDir.length < 2 || !path.isAbsolute(workDir)) {
-    console.warn(`[spawn] Invalid cwd "${workDir}", falling back to PROJECT_DIR`);
+  // ponytail: must also exist on disk — a hardcoded/stale absolute path passes isAbsolute
+  // but kills pty.spawn ("Connection closed"). Fall back instead of dying.
+  if (!workDir || workDir.length < 2 || !path.isAbsolute(workDir) || !fs.existsSync(workDir)) {
+    console.warn(`[spawn] Invalid or missing cwd "${workDir}", falling back to PROJECT_DIR`);
     workDir = PROJECT_DIR;
   }
   const settingsDir = workDir;
@@ -496,7 +502,7 @@ app.post('/api/upload', requireAuth, upload.single('file'), (req, res) => {
 app.get('/health', (_req, res) => {
   res.json({
     status: 'ok',
-    version: '2.0.0',
+    version: pkg.version,
     terminals: terminals.size,
     sseClients: sse.clientCount,
     uptime: process.uptime(),
@@ -1305,6 +1311,18 @@ app.post('/api/auth/register', async (req, res) => {
 // ── Start ───────────────────────────────────────────────────
 
 async function startServer() {
+  // Clean up only DEAD runtimes — never a healthy one. killStaleRuntime and
+  // reclaimPort both health-gate: a runtime that answers /health is a live
+  // parallel fleet (possibly another instance doing real work) and is left
+  // untouched; this server then climbs to the next free port and coexists.
+  // Only dead/hung leftovers get reclaimed (keeps the no-orphan-pileup win).
+  const previous = readRuntimeSession();
+  const replaced = await killStaleRuntime(previous);
+  if (replaced) console.log(`[runtime] cleaned up dead Ninja runtime (pid ${previous.pid})`);
+
+  const reclaimed = await reclaimPort(PREFERRED_PORT);
+  if (reclaimed) console.log(`[runtime] reclaimed port ${PREFERRED_PORT} from ${reclaimed} dead Ninja orphan(s)`);
+
   const selectedPort = await findAvailablePort(PREFERRED_PORT);
   if (selectedPort !== PREFERRED_PORT) {
     console.log(`[port] ${PREFERRED_PORT} is unavailable; using ${selectedPort}`);
@@ -1353,7 +1371,7 @@ async function startServer() {
 process.on('exit', () => {
   try {
     const addr = server.address();
-    if (addr && addr.port) clearRuntimeSession();
+    if (addr && addr.port) clearRuntimeSession(addr.port);
   } catch {
     // ignore shutdown cleanup failures
   }