@hienlh/ppm 0.2.1 → 0.2.2

package/CHANGELOG.md

@@ -0,0 +1,53 @@
+# Changelog
+
+## [0.2.2] - 2026-03-15
+
+### Added
+- Single source of truth for version (`src/version.ts` reads from `package.json`)
+- Version shown in daemon start output
+
+### Fixed
+- Version no longer hardcoded in multiple files
+
+## [0.2.1] - 2026-03-15
+
+### Added
+- `ppm logs` command — view daemon logs (`-n`, `-f`, `--clear`)
+- `ppm report` command — open GitHub issue pre-filled with env info + logs
+- Daemon stdout/stderr written to `~/.ppm/ppm.log`
+- Frontend health check — detects server crash, prompts bug report
+- Sensitive data (tokens, passwords, API keys) auto-redacted from logs
+- `/api/logs/recent` public endpoint for bug reports
+
+## [0.2.0] - 2026-03-15
+
+### Added
+- `--share` / `-s` flag — public URL via Cloudflare Quick Tunnel
+- Default daemon mode — `ppm start` runs in background
+- `--foreground` / `-f` flag — opt-in foreground mode
+- `ppm status` command with `--json` flag and QR code
+- `ppm init` — interactive setup (port, auth, password, share, AI settings)
+- Auto-init on first `ppm start`
+- Non-interactive init via flags (`-y`, `--port`, `--auth`, `--password`)
+- `device_name` config — shown in sidebar, login screen, page title
+- `/api/info` public endpoint (version + device name)
+- QR code for share URL in terminal
+- Auth warning when sharing with auth disabled
+- Cloudflared auto-download (macOS .tgz + Linux binary)
+- Tunnel runs as independent process — survives server crash
+- `ppm start --share` reuses existing tunnel if alive
+
+### Changed
+- `ppm start` defaults to daemon mode (was opt-in)
+- Status file `~/.ppm/status.json` replaces `ppm.pid` (with fallback)
+- `ppm stop` kills both server and tunnel, cleans up files
+
+## [0.1.6] - 2026-03-15
+
+### Added
+- Configurable AI provider settings via `ppm.yaml`, API, and UI
+- Chat tool UI improvements, diff viewer, git panels, editor enhancements
+
+### Fixed
+- Global focus-visible outline causing blue ring on all inputs
+- Unified input styles across app

package/package.json

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

package/src/cli/commands/report.ts

@@ -6,7 +6,7 @@ import { getRecentLogs } from "./logs.ts";
 const REPO = "hienlh/ppm";
 
 export async function reportBug() {
-  const version = "0.2.1";
+  const { VERSION: version } = await import("../../version.ts");
   const logs = getRecentLogs(30);
   const statusFile = resolve(homedir(), ".ppm", "status.json");
   let statusInfo = "(not running)";

package/src/cli/commands/status.ts

@@ -11,40 +11,46 @@ interface DaemonStatus {
   port: number | null;
   host: string | null;
   shareUrl: string | null;
+  tunnelPid: number | null;
+  tunnelAlive: boolean;
+}
+
+function isAlive(pid: number): boolean {
+  try { process.kill(pid, 0); return true; } catch { return false; }
 }
 
 function getDaemonStatus(): DaemonStatus {
-  const notRunning: DaemonStatus = { running: false, pid: null, port: null, host: null, shareUrl: null };
+  const dead: DaemonStatus = {
+    running: false, pid: null, port: null, host: null,
+    shareUrl: null, tunnelPid: null, tunnelAlive: false,
+  };
 
-  // Try status.json first
   if (existsSync(STATUS_FILE)) {
     try {
       const data = JSON.parse(readFileSync(STATUS_FILE, "utf-8"));
       const pid = data.pid as number;
-      // Check if process is actually alive
-      try {
-        process.kill(pid, 0); // signal 0 = check existence
-        return { running: true, pid, port: data.port, host: data.host, shareUrl: data.shareUrl ?? null };
-      } catch {
-        return notRunning; // stale status file
-      }
-    } catch {
-      return notRunning;
-    }
+      const tunnelPid = (data.tunnelPid as number) ?? null;
+      const tunnelAlive = tunnelPid ? isAlive(tunnelPid) : false;
+      return {
+        running: isAlive(pid),
+        pid,
+        port: data.port,
+        host: data.host,
+        shareUrl: data.shareUrl ?? null,
+        tunnelPid,
+        tunnelAlive,
+      };
+    } catch { return dead; }
   }
 
-  // Fallback to ppm.pid
   if (existsSync(PID_FILE)) {
     try {
       const pid = parseInt(readFileSync(PID_FILE, "utf-8").trim(), 10);
-      process.kill(pid, 0);
-      return { running: true, pid, port: null, host: null, shareUrl: null };
-    } catch {
-      return notRunning;
-    }
+      return { ...dead, running: isAlive(pid), pid };
+    } catch { return dead; }
   }
 
-  return notRunning;
+  return dead;
 }
 
 export async function showStatus(options: { json?: boolean }) {
@@ -55,14 +61,17 @@ export async function showStatus(options: { json?: boolean }) {
     return;
   }
 
-  if (!status.running) {
+  if (!status.running && !status.tunnelAlive) {
     console.log("  PPM is not running.");
     return;
   }
 
-  console.log(`\n  PPM daemon is running\n`);
-  console.log(`  PID:     ${status.pid}`);
+  console.log(`\n  PPM daemon status\n`);
+  console.log(`  Server:  ${status.running ? "running" : "stopped"} (PID: ${status.pid})`);
   if (status.port) console.log(`  Local:   http://localhost:${status.port}/`);
+  if (status.tunnelPid) {
+    console.log(`  Tunnel:  ${status.tunnelAlive ? "running" : "stopped"} (PID: ${status.tunnelPid})`);
+  }
   if (status.shareUrl) {
     console.log(`  Share:   ${status.shareUrl}`);
     const qr = await import("qrcode-terminal");

package/src/cli/commands/stop.ts

@@ -5,43 +5,51 @@ import { readFileSync, unlinkSync, existsSync } from "node:fs";
 const PID_FILE = resolve(homedir(), ".ppm", "ppm.pid");
 const STATUS_FILE = resolve(homedir(), ".ppm", "status.json");
 
+function killPid(pid: number, label: string): boolean {
+  try {
+    process.kill(pid);
+    console.log(`  Stopped ${label} (PID: ${pid})`);
+    return true;
+  } catch (e) {
+    const err = e as NodeJS.ErrnoException;
+    if (err.code !== "ESRCH") console.error(`  Failed to stop ${label}: ${err.message}`);
+    return false;
+  }
+}
+
 export async function stopServer() {
-  let pid: number | null = null;
+  let status: { pid?: number; tunnelPid?: number } | null = null;
 
-  // Try status.json first (new format)
+  // Read status.json
   if (existsSync(STATUS_FILE)) {
-    try {
-      const status = JSON.parse(readFileSync(STATUS_FILE, "utf-8"));
-      pid = status.pid;
-    } catch {}
+    try { status = JSON.parse(readFileSync(STATUS_FILE, "utf-8")); } catch {}
   }
 
-  // Fallback to ppm.pid (compat)
-  if (!pid && existsSync(PID_FILE)) {
-    pid = parseInt(readFileSync(PID_FILE, "utf-8").trim(), 10);
-  }
+  // Fallback to ppm.pid
+  const pidFromFile = existsSync(PID_FILE)
+    ? parseInt(readFileSync(PID_FILE, "utf-8").trim(), 10)
+    : NaN;
+
+  const serverPid = status?.pid ?? (isNaN(pidFromFile) ? null : pidFromFile);
+  const tunnelPid = status?.tunnelPid ?? null;
 
-  if (!pid || isNaN(pid)) {
+  if (!serverPid && !tunnelPid) {
     console.log("No PPM daemon running.");
-    // Cleanup stale files
-    if (existsSync(STATUS_FILE)) unlinkSync(STATUS_FILE);
-    if (existsSync(PID_FILE)) unlinkSync(PID_FILE);
+    cleanup();
     return;
   }
 
-  try {
-    process.kill(pid);
-    if (existsSync(STATUS_FILE)) unlinkSync(STATUS_FILE);
-    if (existsSync(PID_FILE)) unlinkSync(PID_FILE);
-    console.log(`PPM daemon stopped (PID: ${pid}).`);
-  } catch (e) {
-    const error = e as NodeJS.ErrnoException;
-    if (error.code === "ESRCH") {
-      console.log(`Process ${pid} not found. Cleaning up stale files.`);
-      if (existsSync(STATUS_FILE)) unlinkSync(STATUS_FILE);
-      if (existsSync(PID_FILE)) unlinkSync(PID_FILE);
-    } else {
-      console.error(`Failed to stop process ${pid}: ${error.message}`);
-    }
-  }
+  // Kill server process
+  if (serverPid) killPid(serverPid, "server");
+
+  // Kill tunnel process (independent from server)
+  if (tunnelPid) killPid(tunnelPid, "tunnel");
+
+  cleanup();
+  console.log("PPM stopped.");
+}
+
+function cleanup() {
+  if (existsSync(STATUS_FILE)) unlinkSync(STATUS_FILE);
+  if (existsSync(PID_FILE)) unlinkSync(PID_FILE);
 }

package/src/index.ts

@@ -1,12 +1,13 @@
 #!/usr/bin/env bun
 import { Command } from "commander";
+import { VERSION } from "./version.ts";
 
 const program = new Command();
 
 program
   .name("ppm")
   .description("Personal Project Manager — mobile-first web IDE")
-  .version("0.2.1");
+  .version(VERSION);
 
 program
   .command("start")

package/src/server/index.ts

@@ -1,6 +1,7 @@
 import { Hono } from "hono";
 import { cors } from "hono/cors";
 import { configService } from "../services/config.service.ts";
+import { VERSION } from "../version.ts";
 import { authMiddleware } from "./middleware/auth.ts";
 import { projectRoutes } from "./routes/projects.ts";
 import { settingsRoutes } from "./routes/settings.ts";
@@ -61,7 +62,7 @@ app.use("*", cors());
 // Public endpoints (before auth)
 app.get("/api/health", (c) => c.json(ok({ status: "running" })));
 app.get("/api/info", (c) => c.json(ok({
-  version: "0.2.1",
+  version: VERSION,
   device_name: configService.get("device_name") || null,
 })));
 
@@ -129,55 +130,87 @@ export async function startServer(options: {
     const pidFile = resolve(ppmDir, "ppm.pid");
     const statusFile = resolve(ppmDir, "status.json");
 
-    // If --share, download cloudflared in parent (shows progress to user)
+    // If --share, download cloudflared and start tunnel as independent process
+    let shareUrl: string | undefined;
+    let tunnelPid: number | undefined;
     if (options.share) {
       const { ensureCloudflared } = await import("../services/cloudflared.service.ts");
-      await ensureCloudflared();
+      const bin = await ensureCloudflared();
+
+      // Check if tunnel already running (reuse from previous server crash)
+      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 */ }
+          }
+        } catch {}
+      }
+
+      // Spawn new tunnel if no existing one
+      if (!shareUrl) {
+        console.log("  Starting share tunnel...");
+        const { openSync: openFd } = await import("node:fs");
+        const tunnelLog = resolve(ppmDir, "tunnel.log");
+        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.");
+      }
     }
 
-    // Spawn child process with log file
+    // Spawn server child process with log file
     const { openSync } = await import("node:fs");
     const logFile = resolve(ppmDir, "ppm.log");
     const logFd = openSync(logFile, "a");
     const child = Bun.spawn({
       cmd: [
         process.execPath, "run", import.meta.dir + "/index.ts", "__serve__",
-        String(port), host, options.config ?? "", options.share ? "share" : "",
+        String(port), host, options.config ?? "",
       ],
       stdio: ["ignore", logFd, logFd],
       env: process.env,
     });
     child.unref();
-    writeFileSync(pidFile, String(child.pid));
 
-    // Poll for status.json (child writes it when ready)
-    const startTime = Date.now();
-    let status: { pid: number; port: number; host: string; shareUrl?: string } | null = null;
-    while (Date.now() - startTime < 30_000) {
-      if (existsSync(statusFile)) {
-        try {
-          status = JSON.parse(readFileSync(statusFile, "utf-8"));
-          break;
-        } catch { /* file not fully written yet */ }
-      }
-      await Bun.sleep(200);
-    }
+    // Write status file with both PIDs
+    const status = { pid: child.pid, port, host, shareUrl, tunnelPid };
+    writeFileSync(statusFile, JSON.stringify(status));
+    writeFileSync(pidFile, String(child.pid));
 
-    if (status) {
-      console.log(`\n  PPM daemon started (PID: ${status.pid})\n`);
-      console.log(`  ➜  Local:   http://localhost:${status.port}/`);
-      if (status.shareUrl) {
-        console.log(`  ➜  Share:   ${status.shareUrl}`);
-        if (!configService.get("auth").enabled) {
-          console.log(`\n  ⚠  Warning: auth is disabled — your IDE is publicly accessible!`);
-          console.log(`     Enable auth in ~/.ppm/config.yaml or restart without --share.`);
-        }
-        const qr = await import("qrcode-terminal");
-        console.log();
-        qr.generate(status.shareUrl, { small: true });
+    console.log(`\n  PPM v${VERSION} daemon started (PID: ${child.pid})\n`);
+    console.log(`  ➜  Local:   http://localhost:${port}/`);
+    if (shareUrl) {
+      console.log(`  ➜  Share:   ${shareUrl}`);
+      if (!configService.get("auth").enabled) {
+        console.log(`\n  ⚠  Warning: auth is disabled — your IDE is publicly accessible!`);
+        console.log(`     Enable auth in ~/.ppm/config.yaml or restart without --share.`);
       }
-    } else {
-      console.log(`\n  PPM daemon started (PID: ${child.pid}) but status not confirmed.`);
+      const qr = await import("qrcode-terminal");
+      console.log();
+      qr.generate(shareUrl, { small: true });
     }
 
     process.exit(0);
@@ -235,7 +268,7 @@ export async function startServer(options: {
     } as Parameters<typeof Bun.serve>[0] extends { websocket?: infer W } ? W : never,
   });
 
-  console.log(`\n  PPM v0.2.1 ready\n`);
+  console.log(`\n  PPM v${VERSION} ready\n`);
   console.log(`  ➜  Local:   http://localhost:${server.port}/`);
 
   const { networkInterfaces } = await import("node:os");
@@ -281,16 +314,9 @@ if (process.argv.includes("__serve__")) {
   const port = parseInt(process.argv[idx + 1] ?? "8080", 10);
   const host = process.argv[idx + 2] ?? "0.0.0.0";
   const configPath = process.argv[idx + 3] || undefined;
-  const shareFlag = process.argv[idx + 4] === "share";
 
   configService.load(configPath);
-
-  const { resolve } = await import("node:path");
-  const { homedir } = await import("node:os");
-  const { writeFileSync, unlinkSync } = await import("node:fs");
-
-  const statusFile = resolve(homedir(), ".ppm", "status.json");
-  const pidFile = resolve(homedir(), ".ppm", "ppm.pid");
+  await setupLogFile();
 
   Bun.serve({
     port,
@@ -342,27 +368,5 @@ if (process.argv.includes("__serve__")) {
     } as Parameters<typeof Bun.serve>[0] extends { websocket?: infer W } ? W : never,
   });
 
-  // Start tunnel if --share was passed (eagerly import so cleanup doesn't race)
-  let shareUrl: string | undefined;
-  const tunnel = shareFlag
-    ? (await import("../services/tunnel.service.ts")).tunnelService
-    : null;
-  if (tunnel) {
-    try {
-      shareUrl = await tunnel.startTunnel(port);
-    } catch { /* non-fatal: server runs without share URL */ }
-  }
-
-  // Write status file for parent to read
-  writeFileSync(statusFile, JSON.stringify({ pid: process.pid, port, host, shareUrl }));
-
-  // Cleanup on exit
-  const cleanup = () => {
-    try { unlinkSync(statusFile); } catch {}
-    try { unlinkSync(pidFile); } catch {}
-    tunnel?.stopTunnel();
-    process.exit(0);
-  };
-  process.on("SIGINT", cleanup);
-  process.on("SIGTERM", cleanup);
+  console.log(`Server child ready on port ${port}`);
 }

package/src/version.ts

@@ -0,0 +1,7 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+const pkg = JSON.parse(readFileSync(resolve(import.meta.dir, "../package.json"), "utf-8"));
+
+/** App version from package.json — single source of truth */
+export const VERSION: string = pkg.version;