@aion0/forge 0.10.39 → 0.10.40

package/RELEASE_NOTES.md

@@ -1,12 +1,11 @@
-# Forge v0.10.39
+# Forge v0.10.40
 
 Released: 2026-06-05
 
-## Changes since v0.10.38
+## Changes since v0.10.39
 
 ### Other
-- feat(chat): auto-link bug/MR/CVE refs in AI output (#32)
-- fix(chat): heal orphan tool_use blocks in session history
+- fix(server): portable port-pid lookup so Linux without lsof can stop (#33)
 
 
-**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.10.38...v0.10.39
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.10.39...v0.10.40

package/bin/forge-server.mjs

@@ -289,17 +289,59 @@ if (!isStop) {
   }
 }
 
+// ── Find pids listening on a TCP port (portable) ──
+// macOS ships lsof; minimal Linux containers (RHEL/CentOS/Alpine) often
+// don't. Try lsof → ss (iproute2, ~universal on modern Linux) → fuser
+// (psmisc) in order. Empty result means no listener, period.
+//
+// Without this, `forge server stop` on Linux silently leaked next-server
+// because `lsof -ti:8403` threw ENOENT and the whole stop path was
+// wrapped in try/catch — the port lookup just disappeared.
+function findPortPids(port) {
+  // 1) lsof
+  try {
+    const out = execSync(`lsof -ti:${port}`, {
+      encoding: 'utf-8', timeout: 3000, stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+    if (out) return [...new Set(out.split('\n').map(s => s.trim()).filter(Boolean))];
+  } catch { /* fall through */ }
+  // 2) ss -tlnp — line looks like:
+  //    LISTEN 0 511 *:8403 ... users:(("next-server",pid=903438,fd=14))
+  try {
+    const out = execSync(`ss -tlnp 2>/dev/null`, {
+      encoding: 'utf-8', timeout: 3000, stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    const pids = new Set();
+    for (const line of out.split('\n')) {
+      // Match port at end of local-address field, before either whitespace
+      // (IPv4 `*:8403 `) or end-of-field (IPv6 `[::]:8403 `).
+      if (!new RegExp(`:${port}\\b`).test(line)) continue;
+      for (const m of line.matchAll(/pid=(\d+)/g)) pids.add(m[1]);
+    }
+    if (pids.size) return [...pids];
+  } catch { /* fall through */ }
+  // 3) fuser
+  try {
+    const out = execSync(`fuser ${port}/tcp 2>/dev/null`, {
+      encoding: 'utf-8', timeout: 3000, stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    const pids = out.trim().split(/\s+/).filter(p => /^\d+$/.test(p));
+    if (pids.length) return [...new Set(pids)];
+  } catch { /* nothing more */ }
+  return [];
+}
+
 // ── Reset terminal server (kill port + tmux sessions) ──
 if (resetTerminal) {
   console.log(`[forge] Resetting terminal server (port ${terminalPort})...`);
-  try {
-    const pids = execSync(`lsof -ti:${terminalPort}`, { encoding: 'utf-8' }).trim();
-    for (const pid of pids.split('\n').filter(Boolean)) {
-      try { execSync(`kill ${pid.trim()}`); } catch {}
+  const pids = findPortPids(terminalPort);
+  if (pids.length === 0) {
+    console.log(`[forge] No process on port ${terminalPort}`);
+  } else {
+    for (const pid of pids) {
+      try { process.kill(parseInt(pid), 'SIGTERM'); } catch {}
     }
     console.log(`[forge] Killed terminal server on port ${terminalPort}`);
-  } catch {
-    console.log(`[forge] No process on port ${terminalPort}`);
   }
 }
 
@@ -338,14 +380,10 @@ function cleanupOrphans() {
   try {
     // Kill processes on our ports
     for (const port of [webPort, terminalPort]) {
-      try {
-        const pids = execSync(`lsof -ti:${port}`, { encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
-        for (const pid of pids.split('\n').filter(Boolean)) {
-          const p = pid.trim();
-          if (p === myPid || protectedPids.has(p)) continue;
-          try { process.kill(parseInt(p), 'SIGTERM'); } catch {}
-        }
-      } catch {}
+      for (const p of findPortPids(port)) {
+        if (p === myPid || protectedPids.has(p)) continue;
+        try { process.kill(parseInt(p), 'SIGTERM'); } catch {}
+      }
     }
     // Kill standalone processes: our instance's + orphans without any tag
     try {
@@ -365,11 +403,25 @@ function cleanupOrphans() {
     // imported lib/task-manager (directly or via lib/pipeline) starts its
     // own setInterval task runner that never exits — those run in parallel
     // with the real runner and silently steal tasks. Detect via lsof on
-    // workflow.db, exclude our own next-server + standalones.
+    // workflow.db (Mac), with a fuser fallback for lsof-less Linux.
     try {
       const dbPath = join(DATA_DIR, 'workflow.db');
-      const lsofOut = execSync(`lsof -t "${dbPath}"`, { encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
-      for (const pid of lsofOut.split('\n').map(s => s.trim()).filter(Boolean)) {
+      let holders = [];
+      try {
+        const out = execSync(`lsof -t "${dbPath}"`, {
+          encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        holders = out.split('\n').map(s => s.trim()).filter(Boolean);
+      } catch {
+        try {
+          // `fuser <file>` writes pids to stderr, not stdout. Merge streams.
+          const out = execSync(`fuser "${dbPath}" 2>&1`, {
+            encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'],
+          });
+          holders = out.replace(/^.*?:/, '').trim().split(/\s+/).filter(p => /^\d+$/.test(p));
+        } catch { /* both unavailable — zombie scan disabled */ }
+      }
+      for (const pid of holders) {
         if (pid === myPid || protectedPids.has(pid)) continue;
         let cmd = '';
         try {
@@ -458,25 +510,35 @@ async function stopServer() {
   } catch {}
   try { unlinkSync(PID_FILE); } catch {}
 
-  // Also kill by port (in case PID file is stale)
-  const portPids = [];
-  try {
-    const pids = execSync(`lsof -ti:${webPort}`, { encoding: 'utf-8', timeout: 3000 }).trim();
-    for (const p of pids.split('\n').filter(Boolean)) {
-      const pid = parseInt(p.trim());
-      try { process.kill(pid, 'SIGTERM'); stopped = true; portPids.push(pid); } catch {}
-    }
-    if (pids) console.log(`[forge] Killed processes on port ${webPort}`);
-  } catch {}
+  // Also kill by port (in case PID file is stale). Use findPortPids
+  // so Linux-without-lsof still works.
+  const portPids = findPortPids(webPort);
+  for (const p of portPids) {
+    const pid = parseInt(p);
+    try { process.kill(pid, 'SIGTERM'); stopped = true; } catch {}
+  }
+  if (portPids.length > 0) console.log(`[forge] Killed processes on port ${webPort}`);
 
-  // Force kill after 2 seconds if SIGTERM didn't work
+  // Force kill survivors after 2 seconds.
   if (portPids.length > 0) {
     await new Promise(r => setTimeout(r, 2000));
     for (const pid of portPids) {
-      try { process.kill(pid, 'SIGKILL'); } catch {}
+      try { process.kill(parseInt(pid), 'SIGKILL'); } catch {}
     }
   }
 
+  // Final verify — if anything still listens on the port (e.g. a child
+  // re-bound, or our SIGKILL hit EPERM), surface it loudly. Silent leak
+  // is exactly the bug we're fixing.
+  const survivors = findPortPids(webPort);
+  if (survivors.length > 0) {
+    console.warn(
+      `[forge] WARNING: port ${webPort} still bound by pid(s) ${survivors.join(', ')} after stop. ` +
+      `Likely a different user / cron-launched / sudo'd instance. ` +
+      `Run: kill ${survivors.join(' ')}  (or with sudo) to free it.`,
+    );
+  }
+
   if (!stopped) {
     console.log('[forge] No running server found');
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aion0/forge",
-  "version": "0.10.39",
+  "version": "0.10.40",
   "description": "Unified AI workflow platform — multi-model task orchestration, persistent sessions, web terminal, remote access",
   "type": "module",
   "scripts": {