@hienlh/ppm 0.7.22 → 0.7.23

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [0.7.23] - 2026-03-22
+
+### Fixed
+- **Restart from PPM terminal**: restart command now spawns a detached worker process so it survives when the old server (and its terminals) are killed — previously running `ppm restart` inside a PPM terminal would kill the restart process itself before the new server could be spawned, causing persistent 502
+- **Restart server script path**: save server entry script path in `status.json` during `ppm start` so restart always uses the stable installed location instead of a potentially ephemeral `bunx` cache path
+
 ## [0.7.22] - 2026-03-22
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hienlh/ppm",
-  "version": "0.7.22",
+  "version": "0.7.23",
   "description": "Personal Project Manager — mobile-first web IDE with AI assistance",
   "author": "hienlh",
   "license": "MIT",

package/src/cli/commands/restart.ts

@@ -1,6 +1,6 @@
 import { resolve } from "node:path";
 import { homedir } from "node:os";
-import { readFileSync, writeFileSync, existsSync, openSync, unlinkSync } from "node:fs";
+import { readFileSync, writeFileSync, existsSync, openSync } from "node:fs";
 
 const PPM_DIR = resolve(homedir(), ".ppm");
 const STATUS_FILE = resolve(PPM_DIR, "status.json");
@@ -28,62 +28,121 @@ export async function restartServer(options: { config?: string }) {
     process.exit(1);
   }
 
+  // Resolve server script: prefer saved path (stable install), fall back to import.meta.dir
+  const savedScript = status.serverScript as string | undefined;
+  const serverScript = savedScript && existsSync(savedScript)
+    ? savedScript
+    : resolve(import.meta.dir, "../../server/index.ts");
+
+  const { configService } = await import("../../services/config.service.ts");
+  configService.load(options.config);
+  const port = status.port as number ?? configService.get("port");
+  const host = status.host as string ?? configService.get("host");
+
   // Write restarting flag so tunnel cleanup handler skips killing cloudflared
   writeFileSync(RESTARTING_FLAG, "");
 
-  // Kill old server process
-  try {
-    process.kill(serverPid);
-    console.log(`  Stopped server (PID: ${serverPid})`);
-  } catch {
-    console.log(`  Server already stopped (PID: ${serverPid})`);
-  }
+  // Generate a self-contained restart worker script.
+  // This runs as a detached process so it survives even if the current process
+  // (and the PPM server hosting its terminal) is killed.
+  const params = JSON.stringify({
+    serverPid, port, host, serverScript,
+    config: options.config ?? "",
+    statusFile: STATUS_FILE,
+    pidFile: PID_FILE,
+    restartingFlag: RESTARTING_FLAG,
+    ppmDir: PPM_DIR,
+  });
 
-  // Brief pause for port release
-  await Bun.sleep(500);
+  const workerPath = resolve(PPM_DIR, ".restart-worker.ts");
+  writeFileSync(workerPath, `
+import { readFileSync, writeFileSync, openSync, unlinkSync, appendFileSync, existsSync } from "node:fs";
+import { createServer } from "node:net";
 
-  // Set DB profile before loading config
-  const { setDbProfile } = await import("../../services/db.service.ts");
-  if (options.config && /dev/i.test(options.config)) {
-    setDbProfile("dev");
-  }
+const P = ${params};
 
-  // Reload config for new server
-  const { configService } = await import("../../services/config.service.ts");
-  configService.load(options.config);
-  const port = status.port as number ?? configService.get("port");
-  const host = status.host as string ?? configService.get("host");
+async function main() {
+  const log = (level: string, msg: string) => {
+    const ts = new Date().toISOString();
+    try { appendFileSync(P.ppmDir + "/ppm.log", "[" + ts + "] [" + level + "] " + msg + "\\n"); } catch {}
+  };
+
+  // Kill old server
+  try { process.kill(P.serverPid); log("INFO", "Restart: killed old server PID " + P.serverPid); } catch {}
 
-  // Spawn new server child process
-  const ppmDir = resolve(homedir(), ".ppm");
-  const logFile = resolve(ppmDir, "ppm.log");
-  const logFd = openSync(logFile, "a");
+  // Wait for port to be free (up to 5s)
+  const start = Date.now();
+  while (Date.now() - start < 5000) {
+    const inUse: boolean = await new Promise((res) => {
+      const t = createServer()
+        .once("error", () => res(true))
+        .once("listening", () => { t.close(() => res(false)); })
+        .listen(P.port, P.host);
+    });
+    if (!inUse) break;
+    await Bun.sleep(200);
+  }
+
+  // Spawn new server
+  const logFd = openSync(P.ppmDir + "/ppm.log", "a");
   const child = Bun.spawn({
-    cmd: [
-      process.execPath, "run",
-      resolve(import.meta.dir, "../../server/index.ts"), "__serve__",
-      String(port), host, options.config ?? "",
-    ],
+    cmd: [process.execPath, "run", P.serverScript, "__serve__", String(P.port), P.host, P.config],
     stdio: ["ignore", logFd, logFd],
     env: process.env,
   });
   child.unref();
 
-  // Update status with new server PID, keep tunnel info
-  status.pid = child.pid;
-  writeFileSync(STATUS_FILE, JSON.stringify(status));
-  writeFileSync(PID_FILE, String(child.pid));
+  // Update status.json with new PID, keep tunnel info
+  try {
+    const status = JSON.parse(readFileSync(P.statusFile, "utf-8"));
+    status.pid = child.pid;
+    status.serverScript = P.serverScript;
+    writeFileSync(P.statusFile, JSON.stringify(status));
+    writeFileSync(P.pidFile, String(child.pid));
+  } catch {}
 
   // Remove restarting flag
-  try { unlinkSync(RESTARTING_FLAG); } catch {}
+  try { unlinkSync(P.restartingFlag); } catch {}
 
-  const { VERSION } = await import("../../version.ts");
-  console.log(`\n  PPM v${VERSION} restarted (PID: ${child.pid})\n`);
-  console.log(`  ➜  Local:   http://localhost:${port}/`);
-  if (status.shareUrl) {
-    console.log(`  ➜  Share:   ${status.shareUrl}  (tunnel kept alive)`);
+  // Health check (up to 10s)
+  let ready = false;
+  const hStart = Date.now();
+  while (Date.now() - hStart < 10000) {
+    try {
+      const res = await fetch("http://127.0.0.1:" + P.port + "/api/health", { signal: AbortSignal.timeout(1000) });
+      if (res.ok) { ready = true; break; }
+    } catch {}
+    await Bun.sleep(300);
   }
-  console.log();
+
+  if (ready) {
+    log("INFO", "Restart complete — new server PID " + child.pid);
+  } else {
+    let alive = false;
+    try { process.kill(child.pid, 0); alive = true; } catch {}
+    log("ERROR", "Restart failed — server " + (alive ? "not responding on port " + P.port : "crashed on startup"));
+  }
+
+  // Cleanup worker file
+  try { unlinkSync(P.ppmDir + "/.restart-worker.ts"); } catch {}
+  process.exit(0);
+}
+
+main();
+`);
+
+  // Spawn worker as a fully detached process
+  const logFd = openSync(resolve(PPM_DIR, "ppm.log"), "a");
+  const worker = Bun.spawn({
+    cmd: [process.execPath, "run", workerPath],
+    stdio: ["ignore", logFd, logFd],
+    env: process.env,
+  });
+  worker.unref();
+
+  const { VERSION } = await import("../../version.ts");
+  console.log(`\n  PPM v${VERSION} restarting... (worker PID: ${worker.pid})`);
+  console.log(`  Server will restart in background. Check: ppm status\n`);
 
   process.exit(0);
 }

package/src/server/index.ts

@@ -293,8 +293,8 @@ export async function startServer(options: {
       process.exit(1);
     }
 
-    // Write status file with both PIDs
-    const status = { pid: childPid, port, host, shareUrl, tunnelPid };
+    // Write status file with both PIDs + server script path for restart
+    const status = { pid: childPid, port, host, shareUrl, tunnelPid, serverScript: script };
     writeFileSync(statusFile, JSON.stringify(status));
     writeFileSync(pidFile, String(childPid));