@hienlh/ppm 0.2.1 → 0.2.4

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,
 })));
 
@@ -117,6 +118,24 @@ export async function startServer(options: {
   // Setup log file (both foreground and daemon modes)
   await setupLogFile();
 
+  // Check if port is already in use before starting
+  const portInUse = await new Promise<boolean>((resolve) => {
+    const net = require("node:net") as typeof import("node:net");
+    const tester = net.createServer()
+      .once("error", (err: NodeJS.ErrnoException) => {
+        resolve(err.code === "EADDRINUSE");
+      })
+      .once("listening", () => {
+        tester.close(() => resolve(false));
+      })
+      .listen(port, host);
+  });
+  if (portInUse) {
+    console.error(`\n  ✗  Port ${port} is already in use.`);
+    console.error(`     Run 'ppm stop' first or use a different port with --port.\n`);
+    process.exit(1);
+  }
+
   const isDaemon = !options.foreground;
 
   if (isDaemon) {
@@ -129,55 +148,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);
@@ -221,21 +272,27 @@ export async function startServer(options: {
       idleTimeout: 960,
       sendPong: true,
       open(ws: any) {
-        if (ws.data?.type === "chat") chatWebSocket.open(ws);
+        if (ws.data?.type === "health") {
+          ws.send(JSON.stringify({ type: "health", status: "ok" }));
+        } else if (ws.data?.type === "chat") chatWebSocket.open(ws);
         else terminalWebSocket.open(ws);
       },
       message(ws: any, msg: any) {
-        if (ws.data?.type === "chat") chatWebSocket.message(ws, msg);
+        if (ws.data?.type === "health") {
+          // Respond to ping with pong
+          ws.send(JSON.stringify({ type: "health", status: "ok" }));
+        } else if (ws.data?.type === "chat") chatWebSocket.message(ws, msg);
         else terminalWebSocket.message(ws, msg);
       },
       close(ws: any) {
+        if (ws.data?.type === "health") return;
         if (ws.data?.type === "chat") chatWebSocket.close(ws);
         else terminalWebSocket.close(ws);
       },
     } 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 +338,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,
@@ -298,6 +348,12 @@ if (process.argv.includes("__serve__")) {
     fetch(req, server) {
       const url = new URL(req.url);
 
+      if (url.pathname === "/ws/health") {
+        const upgraded = server.upgrade(req, { data: { type: "health" } });
+        if (upgraded) return undefined;
+        return new Response("WebSocket upgrade failed", { status: 400 });
+      }
+
       if (url.pathname.startsWith("/ws/project/")) {
         const parts = url.pathname.split("/");
         const projectName = parts[3] ?? "";
@@ -342,27 +398,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/server/routes/chat.ts

@@ -5,7 +5,7 @@ import { tmpdir } from "node:os";
 import { chatService } from "../../services/chat.service.ts";
 import { providerRegistry } from "../../providers/registry.ts";
 import { listSlashItems } from "../../services/slash-items.service.ts";
-import { fetchClaudeUsage } from "../../services/claude-usage.service.ts";
+import { waitForFreshUsage } from "../../services/claude-usage.service.ts";
 import { ok, err } from "../../types/api.ts";
 
 type Env = { Variables: { projectPath: string; projectName: string } };
@@ -23,24 +23,19 @@ chatRoutes.get("/slash-items", (c) => {
   }
 });
 
-/** GET /chat/usage — get current usage/rate-limit info via ccburn */
+/** GET /chat/usage — await fresh data from ccburn (async, non-blocking to event loop) */
 chatRoutes.get("/usage", async (c) => {
-  try {
-    const usage = await fetchClaudeUsage();
-    return c.json(ok({
-      fiveHour: usage.session?.utilization,
-      sevenDay: usage.weekly?.utilization,
-      fiveHourResetsAt: usage.session?.resetsAt,
-      sevenDayResetsAt: usage.weekly?.resetsAt,
-      // Extra detail for popup
-      session: usage.session,
-      weekly: usage.weekly,
-      weeklyOpus: usage.weeklyOpus,
-      weeklySonnet: usage.weeklySonnet,
-    }));
-  } catch (e) {
-    return c.json(err((e as Error).message), 500);
-  }
+  const usage = await waitForFreshUsage();
+  return c.json(ok({
+    fiveHour: usage.session?.utilization,
+    sevenDay: usage.weekly?.utilization,
+    fiveHourResetsAt: usage.session?.resetsAt,
+    sevenDayResetsAt: usage.weekly?.resetsAt,
+    session: usage.session,
+    weekly: usage.weekly,
+    weeklyOpus: usage.weeklyOpus,
+    weeklySonnet: usage.weeklySonnet,
+  }));
 });
 
 /** GET /chat/providers — list available AI providers */

package/src/server/routes/projects.ts

@@ -45,6 +45,18 @@ projectRoutes.get("/suggest-dirs", (c) => {
   }
 });
 
+/** PATCH /api/projects/:name — update a project's name/path */
+projectRoutes.patch("/:name", async (c) => {
+  try {
+    const name = c.req.param("name");
+    const body = await c.req.json<{ name?: string; path?: string }>();
+    const updated = projectService.update(name, body);
+    return c.json(ok(updated));
+  } catch (e) {
+    return c.json(err((e as Error).message), 400);
+  }
+});
+
 /** DELETE /api/projects/:name — remove a project by name */
 projectRoutes.delete("/:name", (c) => {
   try {

package/src/server/routes/static.ts

@@ -17,10 +17,10 @@ staticRoutes.use(
 );
 
 /** SPA fallback — serve index.html for all unmatched routes */
-staticRoutes.get("*", (c) => {
+staticRoutes.get("*", async (c) => {
   const indexPath = resolve(DIST_DIR, "index.html");
   if (existsSync(indexPath)) {
-    return c.html(Bun.file(indexPath).text());
+    return c.html(await Bun.file(indexPath).text());
   }
   return c.text("Frontend not built. Run: bun run build:web", 404);
 });

package/src/services/claude-usage.service.ts

@@ -1,15 +1,13 @@
-import { execFileSync } from "node:child_process";
-import { existsSync } from "node:fs";
-import { resolve, dirname } from "node:path";
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
 
 export interface LimitBucket {
   utilization: number;
-  budgetPace: number;
   resetsAt: string;
   resetsInMinutes: number | null;
   resetsInHours: number | null;
   windowHours: number;
-  status: string;
 }
 
 export interface ClaudeUsage {
@@ -20,94 +18,115 @@ export interface ClaudeUsage {
   weeklySonnet?: LimitBucket;
 }
 
-/** Cache to avoid spawning ccburn too often */
+const API_URL = "https://api.anthropic.com/api/oauth/usage";
+const API_BETA = "oauth-2025-04-20";
+const USER_AGENT = "claude-code/1.0";
+const CACHE_TTL = 30_000; // 30s
+const FETCH_TIMEOUT = 10_000; // 10s
+
+/** Cached data + timestamp */
 let cache: { data: ClaudeUsage; timestamp: number } | null = null;
-const CACHE_TTL = 30_000; // 30 seconds
 
-/** Cached resolved path */
-let ccburnBin: string | undefined;
+/** Cached OAuth token (read once from Keychain/file) */
+let tokenCache: { token: string; timestamp: number } | null = null;
+const TOKEN_TTL = 300_000; // re-read token every 5min
 
 /**
- * Resolve ccburn binary. Checks:
- * 1. node_modules/.bin/ccburn (relative to cwd — works for dev & prod)
- * 2. Sibling to compiled binary (dist/node_modules/.bin/ccburn)
- * 3. import.meta.dir based resolution
+ * Read OAuth access token from macOS Keychain, fallback to credentials file.
  */
-function getCcburnPath(): string {
-  if (ccburnBin) return ccburnBin;
-  const candidates = [
-    resolve(process.cwd(), "node_modules/.bin/ccburn"),
-    resolve(dirname(process.argv[1] ?? ""), "../node_modules/.bin/ccburn"),
-    resolve(dirname(process.argv[1] ?? ""), "node_modules/.bin/ccburn"),
-  ];
-  for (const p of candidates) {
-    if (existsSync(p)) {
-      ccburnBin = p;
-      return p;
+function getAccessToken(): string {
+  if (tokenCache && Date.now() - tokenCache.timestamp < TOKEN_TTL) {
+    return tokenCache.token;
+  }
+
+  let creds: Record<string, any> | null = null;
+
+  // macOS Keychain
+  if (process.platform === "darwin") {
+    try {
+      const proc = Bun.spawnSync(["security", "find-generic-password", "-s", "Claude Code-credentials", "-w"]);
+      if (proc.exitCode === 0) {
+        creds = JSON.parse(proc.stdout.toString().trim());
+      }
+    } catch { /* fallback to file */ }
+  }
+
+  // Fallback: ~/.claude/.credentials.json
+  if (!creds) {
+    const credPath = resolve(homedir(), ".claude", ".credentials.json");
+    if (existsSync(credPath)) {
+      creds = JSON.parse(readFileSync(credPath, "utf-8"));
     }
   }
-  throw new Error("ccburn not found — run: bun install");
+
+  const token = creds?.claudeAiOauth?.accessToken;
+  if (!token) throw new Error("No Claude OAuth token found");
+
+  tokenCache = { token, timestamp: Date.now() };
+  return token;
 }
 
 /**
- * Fetch current usage/rate-limit info via ccburn (bundled dependency).
- * ccburn handles credential retrieval (Keychain on macOS, etc.)
- * and calls Anthropic's internal usage endpoint.
+ * Fetch usage from Anthropic OAuth API — native async, zero process spawn.
  */
-export async function fetchClaudeUsage(): Promise<ClaudeUsage> {
+async function fetchUsageFromApi(): Promise<ClaudeUsage> {
+  const token = getAccessToken();
+  const res = await fetch(API_URL, {
+    headers: {
+      Accept: "application/json",
+      Authorization: `Bearer ${token}`,
+      "anthropic-beta": API_BETA,
+      "User-Agent": USER_AGENT,
+    },
+    signal: AbortSignal.timeout(FETCH_TIMEOUT),
+  });
+
+  if (!res.ok) {
+    throw new Error(`Usage API returned ${res.status}`);
+  }
+
+  const raw = (await res.json()) as Record<string, any>;
+  const now = new Date().toISOString();
+  const data: ClaudeUsage = { timestamp: now };
+
+  if (raw.five_hour) data.session = parseApiBucket(raw.five_hour, 5);
+  if (raw.seven_day) data.weekly = parseApiBucket(raw.seven_day, 168);
+  if (raw.seven_day_opus) data.weeklyOpus = parseApiBucket(raw.seven_day_opus, 168);
+  if (raw.seven_day_sonnet) data.weeklySonnet = parseApiBucket(raw.seven_day_sonnet, 168);
+
+  return data;
+}
+
+/** Parse an API bucket (utilization is 0-100 from API, normalize to 0-1) */
+function parseApiBucket(raw: Record<string, any>, windowHours: number): LimitBucket {
+  const utilization = (raw.utilization ?? 0) / 100;
+  const resetsAt = raw.resets_at ?? "";
+  const diff = resetsAt ? new Date(resetsAt).getTime() - Date.now() : 0;
+  const totalMins = diff > 0 ? Math.ceil(diff / 60_000) : 0;
+
+  return {
+    utilization,
+    resetsAt,
+    resetsInMinutes: windowHours <= 5 ? totalMins : null,
+    resetsInHours: windowHours > 5 ? Math.round((totalMins / 60) * 100) / 100 : null,
+    windowHours,
+  };
+}
+
+/**
+ * Get cached usage or fetch fresh data.
+ * Fully async, never blocks event loop — just a native fetch().
+ */
+export async function waitForFreshUsage(): Promise<ClaudeUsage> {
   if (cache && Date.now() - cache.timestamp < CACHE_TTL) {
     return cache.data;
   }
 
   try {
-    const bin = getCcburnPath();
-    const raw = execFileSync(bin, ["--json"], {
-      encoding: "utf-8",
-      timeout: 10_000,
-      stdio: ["pipe", "pipe", "pipe"],
-    }).trim();
-
-    // Extract JSON (skip any warnings before it)
-    const jsonStart = raw.indexOf("{");
-    const jsonStr = jsonStart > 0 ? raw.slice(jsonStart) : raw;
-    if (!jsonStr) return cache?.data ?? {};
-
-    const json = JSON.parse(jsonStr) as Record<string, unknown>;
-    const limits = json.limits as Record<string, unknown> | undefined;
-    if (!limits) return cache?.data ?? {};
-
-    const data: ClaudeUsage = {
-      timestamp: json.timestamp as string | undefined,
-    };
-
-    if (limits.session && typeof limits.session === "object") {
-      data.session = parseBucket(limits.session as Record<string, unknown>);
-    }
-    if (limits.weekly && typeof limits.weekly === "object") {
-      data.weekly = parseBucket(limits.weekly as Record<string, unknown>);
-    }
-    if (limits.weekly_opus && typeof limits.weekly_opus === "object") {
-      data.weeklyOpus = parseBucket(limits.weekly_opus as Record<string, unknown>);
-    }
-    if (limits.weekly_sonnet && typeof limits.weekly_sonnet === "object") {
-      data.weeklySonnet = parseBucket(limits.weekly_sonnet as Record<string, unknown>);
-    }
-
+    const data = await fetchUsageFromApi();
     cache = { data, timestamp: Date.now() };
     return data;
   } catch {
     return cache?.data ?? {};
   }
 }
-
-function parseBucket(raw: Record<string, unknown>): LimitBucket {
-  return {
-    utilization: (raw.utilization as number) ?? 0,
-    budgetPace: (raw.budget_pace as number) ?? 0,
-    resetsAt: (raw.resets_at as string) ?? "",
-    resetsInMinutes: (raw.resets_in_minutes as number) ?? null,
-    resetsInHours: (raw.resets_in_hours as number) ?? null,
-    windowHours: (raw.window_hours as number) ?? 0,
-    status: (raw.status as string) ?? "",
-  };
-}

package/src/services/project.service.ts

@@ -40,6 +40,49 @@ class ProjectService {
     return entry;
   }
 
+  /** Update a project's name and/or path */
+  update(
+    currentName: string,
+    updates: { name?: string; path?: string },
+  ): ProjectConfig {
+    const projects = configService.get("projects");
+    const idx = projects.findIndex((p) => p.name === currentName);
+    if (idx === -1) {
+      throw new Error(`Project not found: ${currentName}`);
+    }
+
+    const current = projects[idx]!;
+    const newName = updates.name?.trim() || current.name;
+    const newPath = updates.path ? resolve(updates.path) : current.path;
+
+    // Validate new path exists
+    if (updates.path && !existsSync(newPath)) {
+      throw new Error(`Path does not exist: ${newPath}`);
+    }
+
+    // Check name uniqueness (skip self)
+    if (
+      newName !== currentName &&
+      projects.some((p) => p.name === newName)
+    ) {
+      throw new Error(`Project "${newName}" already exists`);
+    }
+
+    // Check path uniqueness (skip self)
+    if (
+      newPath !== current.path &&
+      projects.some((p, i) => i !== idx && resolve(p.path) === newPath)
+    ) {
+      throw new Error(`Path "${newPath}" already registered`);
+    }
+
+    const updated: ProjectConfig = { path: newPath, name: newName };
+    projects[idx] = updated;
+    configService.set("projects", projects);
+    configService.save();
+    return updated;
+  }
+
   /** Remove a project by name or path */
   remove(nameOrPath: string): void {
     const projects = configService.get("projects");

package/src/types/chat.ts

@@ -41,12 +41,10 @@ export interface SessionInfo {
 
 export interface LimitBucket {
   utilization: number;
-  budgetPace: number;
   resetsAt: string;
   resetsInMinutes: number | null;
   resetsInHours: number | null;
   windowHours: number;
-  status: string;
 }
 
 export interface UsageInfo {

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;