@hienlh/ppm 0.13.97 → 0.13.99

package/src/server/index.ts

@@ -633,50 +633,35 @@ if (process.argv.includes("__serve__")) {
     setInterval(() => cleanupOldProxyRequests(30), 24 * 60 * 60 * 1000);
   }
 
-  // On Windows, check for zombie sockets before binding.
-  // After an upgrade, the old server's socket can stay in LISTENING state
-  // because SIGTERM maps to TerminateProcess (graceful handler never fires).
-  let actualPort = port;
+  // On Windows the supervisor reaps the previous server's whole process tree
+  // before respawning, so the port is released cleanly. A lingering bind can
+  // still appear for a moment during an upgrade handoff, so wait for it to
+  // free instead of moving to a different port — shifting would split-brain
+  // the tunnel and supervisor, which still target the original port (this was
+  // the recurring "dies after upgrade" failure on Windows).
   if (process.platform === "win32") {
-    const portInUse = await new Promise<boolean>((resolve) => {
+    const isPortInUse = () => new Promise<boolean>((resolve) => {
       const net = require("node:net") as typeof import("node:net");
       const tester = net.createServer()
         .once("error", (e: NodeJS.ErrnoException) => resolve(e.code === "EADDRINUSE"))
         .once("listening", () => tester.close(() => resolve(false)))
         .listen(port, host);
     });
-    if (portInUse) {
-      try {
-        const { execSync } = require("node:child_process") as typeof import("node:child_process");
-        const out = execSync(`netstat -ano | findstr "0.0.0.0:${port}.*LISTENING"`, { encoding: "utf-8", timeout: 5000 });
-        const match = out.trim().match(/LISTENING\s+(\d+)/);
-        if (match?.[1]) {
-          const ownerPid = parseInt(match[1], 10);
-          let isZombie = false;
-          try { process.kill(ownerPid, 0); } catch { isZombie = true; }
-          if (isZombie) {
-            console.warn(`[serve] Port ${port} held by dead process (PID: ${ownerPid}) — zombie socket`);
-            for (let candidate = port + 1; candidate <= port + 20; candidate++) {
-              const busy = await new Promise<boolean>((resolve) => {
-                const net = require("node:net") as typeof import("node:net");
-                const tester = net.createServer()
-                  .once("error", (e: NodeJS.ErrnoException) => resolve(e.code === "EADDRINUSE"))
-                  .once("listening", () => tester.close(() => resolve(false)))
-                  .listen(candidate, host);
-              });
-              if (!busy) { actualPort = candidate; break; }
-            }
-            if (actualPort !== port) {
-              console.warn(`[serve] Auto-selected port ${actualPort} instead`);
-            }
-          }
-        }
-      } catch {}
+    const deadline = Date.now() + 10_000;
+    while (await isPortInUse()) {
+      if (Date.now() > deadline) {
+        console.error(`\n  ✗  Port ${port} is still in use after waiting 10s.`);
+        console.error(`     A stale process may be holding it. Run 'ppm stop', then start again.`);
+        console.error(`     If it persists, run PowerShell as Admin: netsh int tcp reset (then restart).\n`);
+        process.exit(1); // supervisor will back off and respawn on the same port
+      }
+      console.warn(`[serve] Port ${port} still releasing, waiting...`);
+      await Bun.sleep(250);
     }
   }
 
   const server = Bun.serve({
-    port: actualPort,
+    port,
     hostname: host,
     fetch(req, server) {
       const url = new URL(req.url);
@@ -780,22 +765,6 @@ if (process.argv.includes("__serve__")) {
     })
     .catch(() => {});
 
-  // If we auto-selected a different port, update status.json so supervisor
-  // health checks and tunnel proxy point at the correct port.
-  if (actualPort !== port) {
-    try {
-      const { resolve: r } = await import("node:path");
-      const { readFileSync: rf, writeFileSync: wf, renameSync: rn } = await import("node:fs");
-      const { getPpmDir: gd } = await import("../services/ppm-dir.ts");
-      const sf = r(gd(), "status.json");
-      const st = JSON.parse(rf(sf, "utf-8"));
-      st.port = actualPort;
-      const tmp = sf + ".tmp." + process.pid;
-      wf(tmp, JSON.stringify(st));
-      rn(tmp, sf);
-    } catch {}
-  }
-
   // Graceful shutdown: close the listening socket so the port is released
   const gracefulShutdown = () => {
     try { server.stop(true); } catch {}
@@ -819,5 +788,5 @@ if (process.argv.includes("__serve__")) {
     }, 200);
   }
 
-  console.log(`Server child ready on port ${actualPort}`);
+  console.log(`Server child ready on port ${port}`);
 }

package/src/server/ws/chat.ts

@@ -832,6 +832,17 @@ export const chatWebSocket = {
     console.log(`[chat] session=${sessionId} FE disconnected (phase=${entry.phase}, clients=${entry.clients.size})`);
 
     if (entry.clients.size === 0) {
+      // No clients listening anymore. If Claude is idle (turn finished, no pending
+      // approval), tear down the persistent streaming query so the next message
+      // recreates it via the resume path — picking up fresh MCP/config while
+      // preserving context from JSONL, and freeing the idle subprocess (RAM).
+      const provider = providerRegistry.get(entry.providerId);
+      const idle = entry.phase === "idle" && !entry.isStreamingActive && !entry.pendingApprovalEvent;
+      const hasLiveStream = provider?.hasStreamingSession?.(sessionId) ?? false;
+      if (idle && hasLiveStream) {
+        provider?.abortQuery?.(sessionId, "tab_closed");
+        logSessionEvent(sessionId, "INFO", "Streaming query torn down (all clients gone, idle) — next message resumes with fresh config");
+      }
       startCleanupTimer(sessionId);
     }
   },

package/src/services/supervisor.ts

@@ -86,31 +86,45 @@ function backoffDelay(restartCount: number): number {
   return Math.min(BACKOFF_BASE_MS * 2 ** (restartCount - 1), BACKOFF_MAX_MS);
 }
 
-// ─── Graceful server shutdown (Windows-safe) ──────────────────────────
-// On Windows, SIGTERM maps to TerminateProcess — graceful handlers never fire.
-// Instead, write a shutdown file that the server child polls for.
+// ─── Process-tree kill (orphan-safe) ───────────────────────────────────
+// The server child spawns grandchildren (Claude SDK subprocesses). On
+// Windows a forced single-PID kill leaves those grandchildren alive; they
+// keep the inherited TCP listening socket handle open, leaving the port in
+// a zombie LISTENING state owned by a dead PID. Killing the whole tree
+// releases the socket — the Windows analog of POSIX process-group kill.
+function killProcessTree(pid: number): void {
+  if (process.platform === "win32") {
+    try {
+      const { execFileSync } = require("node:child_process") as typeof import("node:child_process");
+      execFileSync("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore", timeout: 5000 });
+    } catch {
+      // Already dead, or taskkill unavailable — fall back to single-PID kill.
+      try { process.kill(pid, "SIGKILL"); } catch {}
+    }
+  } else {
+    try { process.kill(-pid, "SIGKILL"); } catch { try { process.kill(pid, "SIGKILL"); } catch {} }
+  }
+}
+
+// ─── Server shutdown ───────────────────────────────────────────────────
+// On Windows the server's Claude SDK grandchildren are node-spawned (the
+// provider forces `executable: "node"`), so they live OUTSIDE Bun's job
+// object. If the server child exits gracefully on its own, those
+// grandchildren orphan and keep the inherited listening socket open →
+// zombie port. They can only be reaped by tree-killing WHILE the parent is
+// still alive, so on Windows we tree-kill immediately rather than waiting
+// for a graceful self-exit (which would let the orphans escape). This
+// mirrors the POSIX process-group kill used on macOS/Linux.
 function requestServerShutdown(child: Subprocess, timeoutMs: number = 2000): Promise<void> {
   return new Promise<void>((resolve) => {
     const pid = child.pid;
     if (process.platform === "win32") {
-      try { writeFileSync(serverShutdownFile(), String(Date.now())); } catch {}
-      const deadline = Date.now() + timeoutMs;
-      const poll = setInterval(() => {
-        try { process.kill(pid, 0); } catch {
-          clearInterval(poll);
-          resolve();
-          return;
-        }
-        if (Date.now() > deadline) {
-          clearInterval(poll);
-          try { process.kill(pid, "SIGKILL"); } catch {}
-          resolve();
-        }
-      }, 100);
+      killProcessTree(pid);
+      resolve();
     } else {
       try { child.kill("SIGTERM"); } catch {}
       setTimeout(() => {
-        try { process.kill(pid, "SIGKILL"); } catch {}
+        killProcessTree(pid);
         resolve();
       }, timeoutMs).unref();
       resolve();
@@ -351,10 +365,11 @@ function startServerHealthCheck(port: number) {
       log("WARN", `Server unresponsive (${healthFailCount} failures), killing`);
       const pid = serverChild.pid;
       if (process.platform === "win32") {
-        try { writeFileSync(serverShutdownFile(), String(Date.now())); } catch {}
+        killProcessTree(pid);
+      } else {
+        try { serverChild.kill("SIGTERM"); } catch {}
+        setTimeout(() => { killProcessTree(pid); }, 1000).unref();
       }
-      try { serverChild.kill("SIGTERM"); } catch {}
-      setTimeout(() => { try { process.kill(pid, "SIGKILL"); } catch {} }, 1000).unref();
       healthFailCount = 0;
       // spawnServer loop handles respawn via exited promise
     }
@@ -519,9 +534,10 @@ async function selfReplace(): Promise<{ success: boolean; error?: string }> {
     }
 
     // ── Non-systemd path: spawn new supervisor directly (macOS/Windows) ─
-    // Poll until port is actually free (max 10s) — never guess with fixed sleep
-    // On Windows, reusePort lets the new server bind over zombie sockets,
-    // so we only need a brief wait for the killed process to release.
+    // Poll until port is actually free (max 10s) — never guess with fixed sleep.
+    // The tree-kill above already reaped the server's grandchildren, so the
+    // listening socket is released; this loop just waits for the OS to finish
+    // tearing it down before the new supervisor binds.
     const portFreeStart = Date.now();
     const portTimeout = process.platform === "win32" ? 3_000 : 10_000;
     while (Date.now() - portFreeStart < portTimeout) {
@@ -860,12 +876,13 @@ export function shutdown() {
 
   if (serverChild) {
     log("INFO", `Killing server child (PID: ${serverChild.pid})`);
+    const pid = serverChild.pid;
     if (process.platform === "win32") {
-      try { writeFileSync(serverShutdownFile(), String(Date.now())); } catch {}
+      killProcessTree(pid);
+    } else {
+      try { serverChild.kill("SIGTERM"); } catch {}
+      setTimeout(() => { killProcessTree(pid); }, 2000).unref();
     }
-    const pid = serverChild.pid;
-    try { serverChild.kill("SIGTERM"); } catch {}
-    setTimeout(() => { try { process.kill(pid, "SIGKILL"); } catch {} }, 2000).unref();
   }
   if (tunnelChild) {
     log("INFO", `Killing tunnel child (PID: ${tunnelChild.pid})`);

package/src/web/stores/panel-store.ts

@@ -345,7 +345,11 @@ export const usePanelStore = create<PanelStore>()((set, get) => {
         if (newTabs.length === 0 && gridPanelCount > 1) {
           const { [pid]: _, ...rest } = s.panels;
           const newGrid = gridRemovePanel(s.grid, pid);
-          const newFocused = s.focusedPanelId === pid ? Object.keys(rest)[0]! : s.focusedPanelId;
+          // Focus must land on a panel still in the grid — Object.keys(rest)
+          // can return keep-alive panels from other projects (off-grid).
+          const newFocused = s.focusedPanelId === pid
+            ? (newGrid.flat()[0] ?? Object.keys(rest)[0]!)
+            : s.focusedPanelId;
           return { panels: rest, grid: newGrid, focusedPanelId: newFocused };
         }
 

package/dist/web/assets/keybindings-store-zLledTJ_.js

@@ -1 +0,0 @@
-import"./vendor-markdown-0Mxgxy0L.js";import"./api-client-bbJLzRVE.js";import{L as e}from"./index-lVDR594A.js";export{e as useKeybindingsStore};

package/dist/web/assets/notification-store-XwGVhPdW.js

@@ -1 +0,0 @@
-import"./vendor-markdown-0Mxgxy0L.js";import"./api-client-bbJLzRVE.js";import{W as e}from"./index-lVDR594A.js";export{e as useNotificationStore};