@hienlh/ppm 0.8.52 → 0.8.54

package/src/cli/commands/stop.ts

@@ -2,8 +2,9 @@ import { resolve } from "node:path";
 import { homedir } from "node:os";
 import { readFileSync, unlinkSync, existsSync } from "node:fs";
 
-const PID_FILE = resolve(homedir(), ".ppm", "ppm.pid");
-const STATUS_FILE = resolve(homedir(), ".ppm", "status.json");
+const PPM_DIR = process.env.PPM_HOME || resolve(homedir(), ".ppm");
+const PID_FILE = resolve(PPM_DIR, "ppm.pid");
+const STATUS_FILE = resolve(PPM_DIR, "status.json");
 
 function killPid(pid: number, label: string): boolean {
   try {
@@ -54,53 +55,70 @@ export async function stopServer(options?: { all?: boolean }) {
   if (options?.all) {
     console.log("  Stopping all PPM and cloudflared processes...\n");
     const cfKilled = killAllByName("cloudflared");
-    // Kill bun processes listening on PPM ports (from status.json or common ports)
-    let serverKilled = 0;
+    let killed = 0;
     if (existsSync(STATUS_FILE)) {
       try {
         const data = JSON.parse(readFileSync(STATUS_FILE, "utf-8"));
-        if (data.pid) { killPid(data.pid, "server"); serverKilled++; }
+        // Kill supervisor first (cascades to server + tunnel children)
+        if (data.supervisorPid) { killPid(data.supervisorPid, "supervisor"); killed++; }
+        if (data.pid) { killPid(data.pid, "server"); killed++; }
+        if (data.tunnelPid) { killPid(data.tunnelPid, "tunnel"); killed++; }
       } catch {}
     }
     if (existsSync(PID_FILE)) {
       try {
         const pid = parseInt(readFileSync(PID_FILE, "utf-8").trim(), 10);
-        if (!isNaN(pid)) { killPid(pid, "server (pidfile)"); serverKilled++; }
+        if (!isNaN(pid)) { killPid(pid, "supervisor/server (pidfile)"); killed++; }
       } catch {}
     }
     cleanup();
-    console.log(`\n  Done. Killed ${cfKilled} cloudflared + ${serverKilled} server process(es).`);
+    console.log(`\n  Done. Killed ${cfKilled} cloudflared + ${killed} PPM process(es).`);
     return;
   }
 
-  let status: { pid?: number; tunnelPid?: number } | null = null;
+  let status: { pid?: number; tunnelPid?: number; supervisorPid?: number } | null = null;
 
   // Read status.json
   if (existsSync(STATUS_FILE)) {
     try { status = JSON.parse(readFileSync(STATUS_FILE, "utf-8")); } catch {}
   }
 
-  // Fallback to ppm.pid
+  // Fallback to ppm.pid (now stores supervisor PID)
   const pidFromFile = existsSync(PID_FILE)
     ? parseInt(readFileSync(PID_FILE, "utf-8").trim(), 10)
     : NaN;
 
-  const serverPid = status?.pid ?? (isNaN(pidFromFile) ? null : pidFromFile);
+  const supervisorPid = status?.supervisorPid ?? null;
+  const serverPid = status?.pid ?? null;
   const tunnelPid = status?.tunnelPid ?? null;
+  const fallbackPid = isNaN(pidFromFile) ? null : pidFromFile;
 
-  if (!serverPid && !tunnelPid) {
+  if (!supervisorPid && !serverPid && !tunnelPid && !fallbackPid) {
     console.log("No PPM daemon running.");
     cleanup();
     return;
   }
 
-  // Kill server process
-  if (serverPid) killPid(serverPid, "server");
+  // Kill supervisor first — its SIGTERM handler kills server + tunnel children
+  if (supervisorPid) {
+    killPid(supervisorPid, "supervisor");
+    // Give supervisor 2s to gracefully kill children
+    await Bun.sleep(2000);
+  } else if (fallbackPid) {
+    // Legacy: ppm.pid might be server PID (pre-supervisor) or supervisor PID
+    killPid(fallbackPid, "supervisor/server (pidfile)");
+    await Bun.sleep(1000);
+  }
 
-  // Kill tunnel process (independent from server)
-  if (tunnelPid) killPid(tunnelPid, "tunnel");
+  // Kill remaining children if supervisor didn't clean them up
+  if (serverPid) {
+    try { process.kill(serverPid, 0); killPid(serverPid, "server"); } catch {}
+  }
+  if (tunnelPid) {
+    try { process.kill(tunnelPid, 0); killPid(tunnelPid, "tunnel"); } catch {}
+  }
 
-  // Windows fallback: kill orphan cloudflared processes spawned by PPM
+  // Windows fallback: kill orphan cloudflared processes
   if (process.platform === "win32") {
     try {
       Bun.spawnSync(["taskkill", "/F", "/IM", "cloudflared.exe"], { stdout: "ignore", stderr: "ignore" });

package/src/cli/commands/upgrade.ts

@@ -0,0 +1,49 @@
+import { VERSION } from "../../version.ts";
+import {
+  checkForUpdate,
+  applyUpgrade,
+  getInstallMethod,
+  signalSupervisorUpgrade,
+} from "../../services/upgrade.service.ts";
+
+export async function upgradeCmd(options: { check?: boolean }) {
+  const method = getInstallMethod();
+
+  if (method === "binary") {
+    console.log("  Compiled binary detected — download new version from GitHub releases.");
+    process.exit(0);
+  }
+
+  const update = await checkForUpdate();
+
+  if (options.check) {
+    if (update.available) {
+      console.log(`  Update available: v${update.current} → v${update.latest}`);
+    } else {
+      console.log(`  Already on latest version (v${VERSION})`);
+    }
+    process.exit(0);
+  }
+
+  if (!update.available) {
+    console.log(`  Already on latest version (v${VERSION})`);
+    process.exit(0);
+  }
+
+  console.log(`  Upgrading from v${update.current} to v${update.latest}...`);
+  const result = await applyUpgrade();
+
+  if (!result.success) {
+    console.error(`  ✗  Upgrade failed: ${result.error}`);
+    process.exit(1);
+  }
+
+  console.log(`  ✓  Upgraded to v${result.newVersion}`);
+
+  const signal = signalSupervisorUpgrade();
+  if (signal.sent) {
+    console.log("  Restarting PPM...");
+  } else {
+    console.log("  Restart PPM manually with `ppm restart`");
+  }
+}

package/src/index.ts

@@ -121,6 +121,15 @@ registerGitCommands(program);
 const { registerChatCommands } = await import("./cli/commands/chat-cmd.ts");
 registerChatCommands(program);
 
+program
+  .command("upgrade")
+  .description("Check for and install PPM updates")
+  .option("--check", "Only check for updates, don't install")
+  .action(async (options) => {
+    const { upgradeCmd } = await import("./cli/commands/upgrade.ts");
+    await upgradeCmd(options);
+  });
+
 const { registerAutoStartCommands } = await import("./cli/commands/autostart.ts");
 registerAutoStartCommands(program);
 

package/src/server/index.ts

@@ -25,7 +25,7 @@ async function setupLogFile() {
   const { homedir } = await import("node:os");
   const { appendFileSync, mkdirSync, existsSync } = await import("node:fs");
 
-  const ppmDir = resolve(homedir(), ".ppm");
+  const ppmDir = process.env.PPM_HOME || resolve(homedir(), ".ppm");
   if (!existsSync(ppmDir)) mkdirSync(ppmDir, { recursive: true });
   const logPath = resolve(ppmDir, "ppm.log");
 
@@ -53,12 +53,29 @@ async function setupLogFile() {
   console.error = (...args: unknown[]) => { origError(...args); writeLog("ERROR", args); };
   console.warn = (...args: unknown[]) => { origWarn(...args); writeLog("WARN", args); };
 
-  // Capture uncaught errors
+  // Capture uncaught errors — count-based exit for supervisor restart
+  let exceptionCount = 0;
+  let lastExceptionTime = 0;
+
+  const handleFatalError = (label: string, detail: string) => {
+    writeLog("FATAL", [`${label}: ${detail}`]);
+    const now = Date.now();
+    if (now - lastExceptionTime < 60_000) exceptionCount++;
+    else exceptionCount = 1;
+    lastExceptionTime = now;
+
+    // 3+ fatal errors in 1 minute → exit and let supervisor restart fresh
+    if (exceptionCount >= 3) {
+      writeLog("FATAL", ["Too many errors in 1 min, exiting for supervisor restart"]);
+      process.exit(1);
+    }
+  };
+
   process.on("uncaughtException", (err) => {
-    writeLog("FATAL", [`Uncaught exception: ${err.stack ?? err.message}`]);
+    handleFatalError("Uncaught exception", err.stack ?? err.message);
   });
   process.on("unhandledRejection", (reason) => {
-    writeLog("FATAL", [`Unhandled rejection: ${reason}`]);
+    handleFatalError("Unhandled rejection", String(reason));
   });
 }
 
@@ -122,6 +139,10 @@ app.route("/api/postgres", postgresRoutes);
 app.route("/api/db", databaseRoutes);
 app.route("/api/accounts", accountsRoutes);
 
+// Upgrade routes (check for updates, apply upgrade)
+import { upgradeRoutes } from "./routes/upgrade.ts";
+app.route("/api/upgrade", upgradeRoutes);
+
 // Cloud device registry
 import { cloudRoutes } from "./routes/cloud.ts";
 app.route("/api/cloud", cloudRoutes);
@@ -168,110 +189,52 @@ export async function startServer(options: {
   if (isDaemon) {
     const { resolve } = await import("node:path");
     const { homedir } = await import("node:os");
-    const { writeFileSync, readFileSync, mkdirSync, existsSync } = await import("node:fs");
+    const { writeFileSync, readFileSync, mkdirSync, existsSync, openSync } = await import("node:fs");
+    const { isCompiledBinary } = await import("../services/autostart-generator.ts");
 
-    const ppmDir = resolve(homedir(), ".ppm");
+    const ppmDir = process.env.PPM_HOME || resolve(homedir(), ".ppm");
     if (!existsSync(ppmDir)) mkdirSync(ppmDir, { recursive: true });
     const pidFile = resolve(ppmDir, "ppm.pid");
     const statusFile = resolve(ppmDir, "status.json");
 
-    // If --share, download cloudflared and start tunnel as independent process
-    let shareUrl: string | undefined;
-    let tunnelPid: number | undefined;
+    // Kill any leftover processes from previous run
+    if (existsSync(statusFile)) {
+      try {
+        const prev = JSON.parse(readFileSync(statusFile, "utf-8"));
+        if (prev.supervisorPid) { try { process.kill(prev.supervisorPid); } catch {} }
+        else if (prev.pid) { try { process.kill(prev.pid); } catch {} }
+        if (prev.tunnelPid) { try { process.kill(prev.tunnelPid); } catch {} }
+      } catch {}
+    }
+
+    // Pre-download cloudflared if --share (so supervisor doesn't need to)
     if (options.share) {
+      console.log("  Ensuring cloudflared is available...");
       const { ensureCloudflared } = await import("../services/cloudflared.service.ts");
-      const bin = await ensureCloudflared();
-
-      // Kill any leftover tunnel from previous run
-      if (existsSync(statusFile)) {
-        try {
-          const prev = JSON.parse(readFileSync(statusFile, "utf-8"));
-          if (prev.tunnelPid) {
-            try { process.kill(prev.tunnelPid); } catch { /* already dead */ }
-          }
-        } catch {}
-      }
-
-      // Spawn new tunnel if no existing one
-      if (!shareUrl) {
-        console.log("  Starting share tunnel...");
-        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, "");
-
-        if (process.platform === "win32") {
-          // Windows: use PowerShell for detached tunnel process
-          const psCmd = [
-            `$p = Start-Process -PassThru -WindowStyle Hidden`,
-            `-FilePath '${bin.replace(/\\/g, "\\\\")}'`,
-            `-ArgumentList 'tunnel','--url','http://localhost:${port}'`,
-            `-RedirectStandardError '${tunnelLog.replace(/\\/g, "\\\\")}'`,
-            `; Write-Output $p.Id`,
-          ].join(" ");
-          const result = Bun.spawnSync({
-            cmd: ["powershell", "-NoProfile", "-Command", psCmd],
-            stdout: "pipe", stderr: "pipe",
-          });
-          tunnelPid = parseInt(result.stdout.toString().trim(), 10);
-          if (isNaN(tunnelPid)) tunnelPid = undefined;
-        } else {
-          const tfd = openFd(tunnelLog, "a");
-          const tunnelProc = Bun.spawn({
-            cmd: [bin, "tunnel", "--url", `http://localhost:${port}`],
-            stdio: ["ignore", "ignore", tfd],
-            env: process.env,
-          });
-          tunnelProc.unref();
-          tunnelPid = tunnelProc.pid;
-        }
-
-        // Parse URL from tunnel.log (poll stderr output)
-        const urlRegex = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/;
-        const pollStart = Date.now();
-        while (Date.now() - pollStart < 30_000) {
-          await Bun.sleep(500);
-          try {
-            const logContent = readFileSync(tunnelLog, "utf-8");
-            const match = logContent.match(urlRegex);
-            if (match) { shareUrl = match[0]; break; }
-          } catch {}
-        }
-        if (!shareUrl) console.warn("  ⚠  Tunnel started but URL not detected.");
-      }
+      await ensureCloudflared();
     }
 
-    // Write preliminary status.json so child process can read shareUrl on startup
-    // (child reads this before parent has a chance to write PID — fixes race condition)
-    writeFileSync(statusFile, JSON.stringify({
-      port, host,
-      shareUrl: shareUrl ?? null,
-      tunnelPid: tunnelPid ?? null,
-    }));
-
-    // Spawn server child process with log file
-    const { openSync } = await import("node:fs");
-    const { isCompiledBinary } = await import("../services/autostart-generator.ts");
+    // Spawn supervisor process (manages server + tunnel children)
     const isCompiledBin = isCompiledBinary();
     const logFile = resolve(ppmDir, "ppm.log");
     const logFd = openSync(logFile, "a");
-    const { resolve: resolvePath } = await import("node:path");
-    const script = resolvePath(import.meta.dir, "index.ts");
-    // Keep positional order: port, host, config, profile (empty strings kept as placeholders)
-    const args = ["__serve__", String(port), host, options.config ?? "", options.profile ?? ""];
-    // Windows PowerShell: strip trailing empty args to avoid ArgumentList validation error
-    while (args.length > 0 && args[args.length - 1] === "") args.pop();
+    const supervisorScript = resolve(import.meta.dir, "..", "services", "supervisor.ts");
+
+    const superviseArgs = [
+      "__supervise__", String(port), host,
+      options.config ?? "", options.profile ?? "",
+    ];
+    if (options.share) superviseArgs.push("--share");
+    // Strip trailing empty args (before --share flag)
+    while (superviseArgs.length > 1 && superviseArgs[superviseArgs.length - 1] === "") superviseArgs.pop();
 
-    let childPid: number;
+    let supervisorPid: number;
 
     if (process.platform === "win32") {
-      // Windows: Bun.spawn child may die when parent exits (same job object).
-      // Use PowerShell Start-Process to create a truly detached process.
       const bunExe = process.execPath.replace(/\\/g, "\\\\");
       const logEscaped = logFile.replace(/\\/g, "\\\\");
       const errLog = logFile.replace(/\.log$/, ".err.log").replace(/\\/g, "\\\\");
-      // Use "_" placeholder for empty args — PowerShell rejects empty strings in ArgumentList
-      const winArgs = isCompiledBin ? args : ["run", script, ...args];
+      const winArgs = isCompiledBin ? superviseArgs : ["run", supervisorScript, ...superviseArgs];
       const argStr = winArgs.map((a) => `'${a || "_"}'`).join(",");
       const psCmd = [
         `$p = Start-Process -PassThru -WindowStyle Hidden`,
@@ -283,48 +246,73 @@ export async function startServer(options: {
       ].join(" ");
       const result = Bun.spawnSync({
         cmd: ["powershell", "-NoProfile", "-Command", psCmd],
-        stdout: "pipe",
-        stderr: "pipe",
+        stdout: "pipe", stderr: "pipe",
       });
-      childPid = parseInt(result.stdout.toString().trim(), 10);
-      if (isNaN(childPid)) {
-        console.error("  ✗  Failed to start daemon on Windows.");
+      supervisorPid = parseInt(result.stdout.toString().trim(), 10);
+      if (isNaN(supervisorPid)) {
+        console.error("  ✗  Failed to start supervisor on Windows.");
         console.error(`     ${result.stderr.toString().trim()}`);
         console.error("     Try: ppm start -f (foreground mode)");
         process.exit(1);
       }
     } else {
-      // macOS/Linux: Bun.spawn + unref works fine
-      // Compiled binary: execPath IS the server, no "run script" needed
       const cmd = isCompiledBin
-        ? [process.execPath, ...args]
-        : [process.execPath, "run", script, ...args];
+        ? [process.execPath, ...superviseArgs]
+        : [process.execPath, "run", supervisorScript, ...superviseArgs];
       const child = Bun.spawn({
         cmd,
         stdio: ["ignore", logFd, logFd],
         env: process.env,
       });
       child.unref();
-      childPid = child.pid;
+      supervisorPid = child.pid;
     }
 
-    // Verify daemon is alive after brief startup
-    await Bun.sleep(500);
-    let alive = false;
-    try { process.kill(childPid, 0); alive = true; } catch {}
-    if (!alive) {
-      console.error("  ✗  Daemon exited immediately after start.");
+    // Wait for supervisor to start server child (poll status.json for pid)
+    const startWait = Date.now();
+    let serverPid: number | null = null;
+    while (Date.now() - startWait < 10_000) {
+      await Bun.sleep(500);
+      // Check supervisor is still alive
+      try { process.kill(supervisorPid, 0); } catch {
+        console.error("  ✗  Supervisor exited immediately after start.");
+        console.error("     Check logs: ppm logs");
+        console.error("     Or try: ppm start -f (foreground mode)");
+        process.exit(1);
+      }
+      // Check if server PID appeared in status.json
+      try {
+        const data = JSON.parse(readFileSync(statusFile, "utf-8"));
+        if (data.pid && data.supervisorPid) {
+          serverPid = data.pid;
+          break;
+        }
+      } catch {}
+    }
+
+    if (!serverPid) {
+      console.error("  ✗  Server did not start within 10 seconds.");
       console.error("     Check logs: ppm logs");
-      console.error("     Or try: ppm start -f (foreground mode)");
+      try { process.kill(supervisorPid); } catch {}
       process.exit(1);
     }
 
-    // Update status file with child PID + server script path for restart
-    const status = { pid: childPid, port, host, shareUrl: shareUrl ?? null, tunnelPid: tunnelPid ?? null, serverScript: script };
-    writeFileSync(statusFile, JSON.stringify(status));
-    writeFileSync(pidFile, String(childPid));
+    // Read final status for share URL
+    let shareUrl: string | null = null;
+    if (options.share) {
+      // Give tunnel a bit more time to establish
+      const tunnelWait = Date.now();
+      while (Date.now() - tunnelWait < 35_000) {
+        await Bun.sleep(500);
+        try {
+          const data = JSON.parse(readFileSync(statusFile, "utf-8"));
+          if (data.shareUrl) { shareUrl = data.shareUrl; break; }
+        } catch {}
+      }
+      if (!shareUrl) console.warn("  ⚠  Tunnel started but URL not detected yet. Check: ppm status");
+    }
 
-    console.log(`  Daemon started (PID: ${childPid})\n`);
+    console.log(`  Supervisor started (PID: ${supervisorPid}, server PID: ${serverPid})\n`);
     console.log(`  ➜  Local:   http://localhost:${port}/`);
     if (shareUrl) {
       console.log(`  ➜  Share:   ${shareUrl}`);

package/src/server/routes/upgrade.ts

@@ -0,0 +1,57 @@
+import { Hono } from "hono";
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+import { readFileSync, existsSync } from "node:fs";
+import { VERSION } from "../../version.ts";
+import {
+  getInstallMethod,
+  applyUpgrade,
+  signalSupervisorUpgrade,
+} from "../../services/upgrade.service.ts";
+import { ok, err } from "../../types/api.ts";
+
+const STATUS_FILE = resolve(process.env.PPM_HOME || resolve(homedir(), ".ppm"), "status.json");
+
+export const upgradeRoutes = new Hono();
+
+/** GET / — upgrade status (current version, available version, install method) */
+upgradeRoutes.get("/", (c) => {
+  let availableVersion: string | null = null;
+  try {
+    if (existsSync(STATUS_FILE)) {
+      const data = JSON.parse(readFileSync(STATUS_FILE, "utf-8"));
+      availableVersion = data.availableVersion ?? null;
+    }
+  } catch {}
+
+  return c.json(ok({
+    currentVersion: VERSION,
+    availableVersion,
+    installMethod: getInstallMethod(),
+  }));
+});
+
+/** POST /apply — install latest version + signal supervisor to self-replace */
+upgradeRoutes.post("/apply", async (c) => {
+  const result = await applyUpgrade();
+  if (!result.success) {
+    return c.json(err(result.error ?? "Upgrade failed"), 500);
+  }
+
+  // Signal supervisor to self-replace
+  const signal = signalSupervisorUpgrade();
+  if (!signal.sent) {
+    return c.json(ok({
+      success: true,
+      newVersion: result.newVersion,
+      restart: false,
+      message: "Upgraded. Restart manually with ppm restart",
+    }));
+  }
+
+  return c.json(ok({
+    success: true,
+    newVersion: result.newVersion,
+    restart: true,
+  }));
+});

package/src/services/autostart-generator.ts

@@ -90,10 +90,7 @@ ${programArgs}
     <key>RunAtLoad</key>
     <true/>
     <key>KeepAlive</key>
-    <dict>
-        <key>SuccessfulExit</key>
-        <false/>
-    </dict>
+    <true/>
     <key>StandardOutPath</key>
     <string>${escapeXml(logPath)}</string>
     <key>StandardErrorPath</key>
@@ -133,7 +130,7 @@ Wants=network-online.target
 [Service]
 Type=simple
 ExecStart=${execStart}
-Restart=on-failure
+Restart=always
 RestartSec=5
 ${envPath}
 WorkingDirectory=${homedir()}/.ppm

package/src/services/db.service.ts

@@ -3,7 +3,7 @@ import { resolve } from "node:path";
 import { homedir } from "node:os";
 import { mkdirSync, existsSync } from "node:fs";
 
-const PPM_DIR = resolve(homedir(), ".ppm");
+const PPM_DIR = process.env.PPM_HOME || resolve(homedir(), ".ppm");
 const CURRENT_SCHEMA_VERSION = 5;
 
 let db: Database | null = null;