@hienlh/ppm 0.2.4 → 0.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hienlh/ppm",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "Personal Project Manager — mobile-first web IDE with AI assistance",
   "module": "src/index.ts",
   "type": "module",

package/src/cli/commands/restart.ts

@@ -0,0 +1,75 @@
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+import { readFileSync, writeFileSync, existsSync, openSync } from "node:fs";
+
+const STATUS_FILE = resolve(homedir(), ".ppm", "status.json");
+const PID_FILE = resolve(homedir(), ".ppm", "ppm.pid");
+
+/** Restart only the server process, keeping the tunnel alive */
+export async function restartServer(options: { config?: string }) {
+  if (!existsSync(STATUS_FILE)) {
+    console.log("No PPM daemon running. Use 'ppm start' instead.");
+    process.exit(1);
+  }
+
+  let status: Record<string, unknown>;
+  try {
+    status = JSON.parse(readFileSync(STATUS_FILE, "utf-8"));
+  } catch {
+    console.log("Corrupt status file. Use 'ppm stop && ppm start' instead.");
+    process.exit(1);
+  }
+
+  const serverPid = status.pid as number | undefined;
+  if (!serverPid) {
+    console.log("No server PID found. Use 'ppm stop && ppm start' instead.");
+    process.exit(1);
+  }
+
+  // Kill old server process
+  try {
+    process.kill(serverPid);
+    console.log(`  Stopped server (PID: ${serverPid})`);
+  } catch {
+    console.log(`  Server already stopped (PID: ${serverPid})`);
+  }
+
+  // Brief pause for port release
+  await Bun.sleep(500);
+
+  // 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");
+
+  // Spawn new server child process
+  const ppmDir = resolve(homedir(), ".ppm");
+  const logFile = resolve(ppmDir, "ppm.log");
+  const logFd = openSync(logFile, "a");
+  const child = Bun.spawn({
+    cmd: [
+      process.execPath, "run",
+      resolve(import.meta.dir, "../../server/index.ts"), "__serve__",
+      String(port), host, options.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));
+
+  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)`);
+  }
+  console.log();
+
+  process.exit(0);
+}

package/src/index.ts

@@ -35,6 +35,15 @@ program
     await stopServer();
   });
 
+program
+  .command("restart")
+  .description("Restart the server (keeps tunnel alive)")
+  .option("-c, --config <path>", "Path to config file")
+  .action(async (options) => {
+    const { restartServer } = await import("./cli/commands/restart.ts");
+    await restartServer(options);
+  });
+
 program
   .command("status")
   .description("Show PPM daemon status")

package/src/server/index.ts

@@ -155,17 +155,12 @@ export async function startServer(options: {
       const { ensureCloudflared } = await import("../services/cloudflared.service.ts");
       const bin = await ensureCloudflared();
 
-      // Check if tunnel already running (reuse from previous server crash)
+      // Kill any leftover tunnel from previous run
       if (existsSync(statusFile)) {
         try {
           const prev = JSON.parse(readFileSync(statusFile, "utf-8"));
-          if (prev.tunnelPid && prev.shareUrl) {
-            try {
-              process.kill(prev.tunnelPid, 0); // Check alive
-              console.log(`  Reusing existing tunnel (PID: ${prev.tunnelPid})`);
-              shareUrl = prev.shareUrl;
-              tunnelPid = prev.tunnelPid;
-            } catch { /* tunnel dead, spawn new one */ }
+          if (prev.tunnelPid) {
+            try { process.kill(prev.tunnelPid); } catch { /* already dead */ }
           }
         } catch {}
       }
@@ -173,8 +168,10 @@ export async function startServer(options: {
       // Spawn new tunnel if no existing one
       if (!shareUrl) {
         console.log("  Starting share tunnel...");
-        const { openSync: openFd } = await import("node:fs");
+        const { openSync: openFd, writeFileSync: writeFs } = await import("node:fs");
         const tunnelLog = resolve(ppmDir, "tunnel.log");
+        // Truncate old log so we only match the new tunnel URL
+        writeFs(tunnelLog, "");
         const tfd = openFd(tunnelLog, "a");
         const tunnelProc = Bun.spawn({
           cmd: [bin, "tunnel", "--url", `http://localhost:${port}`],
@@ -231,6 +228,12 @@ export async function startServer(options: {
       qr.generate(shareUrl, { small: true });
     }
 
+    console.log(`  Commands:`);
+    console.log(`    ppm restart   Reload config (keeps tunnel URL)`);
+    console.log(`    ppm stop      Stop server & tunnel`);
+    console.log(`    ppm logs -f   Follow server logs`);
+    console.log();
+
     process.exit(0);
   }