@hienlh/ppm 0.9.81 → 0.9.83

package/src/lib/account-crypto.ts

@@ -1,25 +1,30 @@
 import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from "node:crypto";
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { resolve } from "node:path";
-import { homedir } from "node:os";
+import { getPpmDir } from "../services/ppm-dir.ts";
 
 const ALGO = "aes-256-gcm";
 
-let keyPath = resolve(homedir(), ".ppm", "account.key");
+let _keyPathOverride: string | null = null;
+
+function getKeyPath(): string {
+  return _keyPathOverride ?? resolve(getPpmDir(), "account.key");
+}
 
 /** Override key path (for tests) */
 export function setKeyPath(path: string): void {
-  keyPath = path;
+  _keyPathOverride = path;
   _key = null; // invalidate cached key
 }
 
 function loadOrCreateKey(): Buffer {
-  if (existsSync(keyPath)) {
-    return Buffer.from(readFileSync(keyPath, "utf-8").trim(), "hex");
+  const kp = getKeyPath();
+  if (existsSync(kp)) {
+    return Buffer.from(readFileSync(kp, "utf-8").trim(), "hex");
   }
   const key = randomBytes(32);
-  mkdirSync(resolve(keyPath, ".."), { recursive: true });
-  writeFileSync(keyPath, key.toString("hex"), { mode: 0o600 });
+  mkdirSync(resolve(kp, ".."), { recursive: true });
+  writeFileSync(kp, key.toString("hex"), { mode: 0o600 });
   return key;
 }
 

package/src/providers/claude-agent-sdk.ts

@@ -20,7 +20,7 @@ import { getSessionProjectPath, setSessionMetadata, getSessionTitles } from "../
 import { accountSelector } from "../services/account-selector.service.ts";
 import { accountService, type AccountWithTokens } from "../services/account.service.ts";
 import { resolve } from "node:path";
-import { existsSync, readdirSync, unlinkSync } from "node:fs";
+import { existsSync, readdirSync, unlinkSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 
 const CLAUDE_PROJECTS_DIR = resolve(homedir(), ".claude/projects");
@@ -322,13 +322,30 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       // Overlay DB titles (user-set) over SDK titles
       const ids = sdkSessions.map((s) => s.sessionId);
       const dbTitles = getSessionTitles(ids);
-      return sdkSessions.map((s) => ({
+      const sessions: SessionInfo[] = sdkSessions.map((s) => ({
         id: s.sessionId,
         providerId: this.id,
         title: dbTitles[s.sessionId] ?? s.customTitle ?? s.summary ?? s.firstPrompt ?? "Chat",
         createdAt: new Date(s.lastModified).toISOString(),
         updatedAt: new Date(s.lastModified).toISOString(),
       }));
+
+      // SDK's listSessions drops sessions whose first user message exceeds its
+      // 64KB head buffer (e.g. large pasted docs). Scan JSONL dir to recover them.
+      if (dir && offset === 0) {
+        const knownIds = new Set(sessions.map((s) => s.id));
+        const missing = findMissingSessions(dir, knownIds, this.id);
+        if (missing.length > 0) {
+          const missingIds = missing.map((s) => s.id);
+          const missingDbTitles = getSessionTitles(missingIds);
+          for (const s of missing) {
+            s.title = missingDbTitles[s.id] ?? s.title;
+          }
+          sessions.push(...missing);
+        }
+      }
+
+      return sessions;
     } catch {
       return Array.from(this.activeSessions.values()).map((s) => ({
         id: s.id,
@@ -343,15 +360,28 @@ export class ClaudeAgentSdkProvider implements AIProvider {
   async getSessionInfoById(sessionId: string, dir?: string): Promise<SessionInfo | null> {
     try {
       const info = await sdkGetSessionInfo(sessionId, { dir });
-      if (!info) return null;
-      const dbTitles = getSessionTitles([info.sessionId]);
-      return {
-        id: info.sessionId,
-        providerId: this.id,
-        title: dbTitles[info.sessionId] ?? info.customTitle ?? info.summary ?? info.firstPrompt ?? "Chat",
-        createdAt: new Date(info.lastModified).toISOString(),
-        updatedAt: new Date(info.lastModified).toISOString(),
-      };
+      if (info) {
+        const dbTitles = getSessionTitles([info.sessionId]);
+        return {
+          id: info.sessionId,
+          providerId: this.id,
+          title: dbTitles[info.sessionId] ?? info.customTitle ?? info.summary ?? info.firstPrompt ?? "Chat",
+          createdAt: new Date(info.lastModified).toISOString(),
+          updatedAt: new Date(info.lastModified).toISOString(),
+        };
+      }
+      // SDK can't find the session (large first message, active session, etc.)
+      // — try direct JSONL lookup
+      if (dir) {
+        const missing = findMissingSessions(dir, new Set(), this.id);
+        const match = missing.find((s) => s.id === sessionId);
+        if (match) {
+          const dbTitles = getSessionTitles([sessionId]);
+          match.title = dbTitles[sessionId] ?? match.title;
+          return match;
+        }
+      }
+      return null;
     } catch {
       return null;
     }
@@ -479,10 +509,32 @@ export class ClaudeAgentSdkProvider implements AIProvider {
   }
 
   async *sendMessage(
-    sessionId: string,
+    _sessionId: string,
     message: string,
     opts?: import("./provider.interface.ts").SendMessageOpts & { forkSession?: boolean; priority?: 'now' | 'next' | 'later'; images?: Array<{ data: string; mediaType: string }> },
   ): AsyncIterable<ChatEvent> {
+    // SDK requires valid UUID session IDs. Short/random IDs can leak from
+    // tab derivation or URL parsing — migrate to a real UUID early.
+    const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    let sessionId = _sessionId;
+    if (!UUID_RE.test(sessionId)) {
+      const newId = crypto.randomUUID();
+      console.warn(`[sdk] session=${sessionId} is not a valid UUID — migrating to ${newId}`);
+      // Migrate internal maps
+      const oldMeta = this.activeSessions.get(sessionId);
+      if (oldMeta) {
+        this.activeSessions.delete(sessionId);
+        oldMeta.id = newId;
+        this.activeSessions.set(newId, oldMeta);
+      }
+      const oldCount = this.messageCount.get(sessionId);
+      if (oldCount != null) { this.messageCount.set(newId, oldCount); this.messageCount.delete(sessionId); }
+      const oldStream = this.streamingSessions.get(sessionId);
+      if (oldStream) { this.streamingSessions.set(newId, oldStream); this.streamingSessions.delete(sessionId); }
+      yield { type: "session_migrated" as const, oldSessionId: sessionId, newSessionId: newId };
+      sessionId = newId;
+    }
+
     // Follow-up: push into existing streaming session, yield nothing
     const existingStream = this.streamingSessions.get(sessionId);
     if (existingStream) {
@@ -617,6 +669,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
     let resultSubtype: string | undefined;
     let resultNumTurns: number | undefined;
     let resultContextWindowPct: number | undefined;
+    let lastAssistantUuid: string | undefined;
     let yieldedDone = false;
     try {
       // Session ID is the canonical ID for both PPM and SDK (no dual-ID mapping).
@@ -977,6 +1030,8 @@ export class ClaudeAgentSdkProvider implements AIProvider {
         // Partial assistant message — streaming text deltas
         if ((msg as any).type === "partial" || (msg as any).type === "stream_event") {
           const partial = msg as any;
+          // Track assistant UUID from top-level messages (not subagent children)
+          if (!parentId && partial.uuid) lastAssistantUuid = partial.uuid;
           // Handle stream_event (raw API events) for text deltas
           if ((msg as any).type === "stream_event") {
             const event = partial.event;
@@ -1014,6 +1069,8 @@ export class ClaudeAgentSdkProvider implements AIProvider {
 
         // Full assistant message
         if (msg.type === "assistant") {
+          // Track assistant UUID from top-level messages (not subagent children)
+          if (!parentId && (msg as any).uuid) lastAssistantUuid = (msg as any).uuid;
           // SDK assistant messages can carry an error field for auth/billing/rate-limit failures
           let assistantError = (msg as any).error as string | undefined;
 
@@ -1361,6 +1418,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
             resultSubtype: resultSubtype as any,
             numTurns: resultNumTurns,
             contextWindowPct: resultContextWindowPct,
+            lastMessageUuid: lastAssistantUuid,
           };
 
           // Reset per-turn state for next turn
@@ -1370,6 +1428,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
           resultSubtype = undefined;
           resultNumTurns = undefined;
           resultContextWindowPct = undefined;
+          lastAssistantUuid = undefined;
           sdkEventCount = 0;
           continue; // Wait for next turn from generator
         }
@@ -1438,6 +1497,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
         resultSubtype: resultSubtype as any,
         numTurns: resultNumTurns,
         contextWindowPct: resultContextWindowPct,
+        lastMessageUuid: lastAssistantUuid,
       };
     }
   }
@@ -1551,6 +1611,7 @@ function parseSessionMessage(msg: { uuid: string; type: string; message: unknown
     content: textContent,
     events: events.length > 0 ? events : undefined,
     timestamp: new Date().toISOString(),
+    sdkUuid: msg.uuid,
   };
 }
 
@@ -1602,6 +1663,81 @@ function extractText(message: unknown): string {
   return "";
 }
 
+/**
+ * Scan a JSONL project directory for sessions that the SDK's listSessions missed.
+ * The SDK uses a 64KB head buffer; sessions with very large first messages
+ * (e.g., pasted API docs) can't be parsed and are silently dropped.
+ * We extract title from queue-operation content or first user message.
+ */
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+function findMissingSessions(
+  dir: string,
+  knownIds: Set<string>,
+  providerId: string,
+): SessionInfo[] {
+  let resolvedDir: string;
+  try { resolvedDir = require("node:fs").realpathSync(dir).normalize("NFC"); } catch { resolvedDir = dir; }
+  // Match SDK's path encoding: replace all non-alphanumeric chars with "-"
+  const encodedDir = resolvedDir.replace(/[^a-zA-Z0-9]/g, "-");
+  let jsonlDir = resolve(CLAUDE_PROJECTS_DIR, encodedDir);
+  // SDK truncates to 200 chars + hash for long paths; try prefix match as fallback
+  if (!existsSync(jsonlDir) && encodedDir.length > 200) {
+    const prefix = encodedDir.slice(0, 200);
+    try {
+      const match = readdirSync(CLAUDE_PROJECTS_DIR).find((d) => d.startsWith(prefix + "-"));
+      if (match) jsonlDir = resolve(CLAUDE_PROJECTS_DIR, match);
+      else return [];
+    } catch { return []; }
+  }
+  if (!existsSync(jsonlDir)) return [];
+
+  const results: SessionInfo[] = [];
+  for (const file of readdirSync(jsonlDir)) {
+    if (!file.endsWith(".jsonl")) continue;
+    const id = file.slice(0, -6);
+    if (!UUID_RE.test(id) || knownIds.has(id)) continue;
+
+    try {
+      const filePath = resolve(jsonlDir, file);
+      const stat = statSync(filePath);
+      // Read first 512 bytes — enough to extract title from queue-operation content
+      const buf = Buffer.alloc(512);
+      const { openSync, readSync, closeSync } = require("node:fs") as typeof import("node:fs");
+      const fd = openSync(filePath, "r");
+      const bytesRead = readSync(fd, buf, 0, 512, 0);
+      closeSync(fd);
+      const head = buf.toString("utf-8", 0, bytesRead);
+
+      let title = "Chat";
+      // Extract "content" value via string search (JSON may be truncated)
+      const idx = head.indexOf('"content":"');
+      if (idx >= 0) {
+        const start = idx + 11; // length of '"content":"'
+        // Read up to 120 chars or next unescaped quote
+        let end = start;
+        while (end < head.length && end - start < 200) {
+          if (head[end] === "\\" ) { end += 2; continue; }
+          if (head[end] === '"') break;
+          end++;
+        }
+        const raw = head.slice(start, end).replace(/\\n/g, " ").replace(/\\"/g, '"').trim();
+        if (raw.length > 0) {
+          title = raw.length > 120 ? raw.slice(0, 120) + "…" : raw;
+        }
+      }
+
+      results.push({
+        id,
+        providerId,
+        title,
+        createdAt: new Date(stat.mtime).toISOString(),
+        updatedAt: new Date(stat.mtime).toISOString(),
+      });
+    } catch { /* skip unreadable files */ }
+  }
+  return results;
+}
+
 /** Strip SDK teammate-message XML tags from assistant text */
 const TEAMMATE_MSG_RE = /<teammate-message[^>]*>[\s\S]*?<\/teammate-message>/g;
 function stripTeammateXml(text: string): string {

package/src/server/index.ts

@@ -29,10 +29,10 @@ async function setupLogFile() {
   (globalThis as any).__PPM_LOG_SETUP__ = true;
 
   const { resolve } = await import("node:path");
-  const { homedir } = await import("node:os");
   const { appendFileSync, mkdirSync, existsSync } = await import("node:fs");
+  const { getPpmDir } = await import("../services/ppm-dir.ts");
 
-  const ppmDir = process.env.PPM_HOME || resolve(homedir(), ".ppm");
+  const ppmDir = getPpmDir();
   if (!existsSync(ppmDir)) mkdirSync(ppmDir, { recursive: true });
   const logPath = resolve(ppmDir, "ppm.log");
 
@@ -104,9 +104,9 @@ app.get("/api/info", (c) => c.json(ok({
 // Public: recent logs for bug reports (last 30 lines)
 app.get("/api/logs/recent", async (c) => {
   const { resolve } = await import("node:path");
-  const { homedir } = await import("node:os");
   const { existsSync, readFileSync } = await import("node:fs");
-  const logFile = resolve(homedir(), ".ppm", "ppm.log");
+  const { getPpmDir } = await import("../services/ppm-dir.ts");
+  const logFile = resolve(getPpmDir(), "ppm.log");
   if (!existsSync(logFile)) return c.json(ok({ logs: "" }));
   const content = readFileSync(logFile, "utf-8");
   const lines = content.split("\n").slice(-30).join("\n").trim();
@@ -234,12 +234,12 @@ export async function startServer(options: {
 
   {
     const { resolve } = await import("node:path");
-    const { homedir } = await import("node:os");
     const { writeFileSync, readFileSync, mkdirSync, existsSync, openSync } = await import("node:fs");
     const { isCompiledBinary } = await import("../services/autostart-generator.ts");
     const { writeCmd, acquireLock, releaseLock } = await import("../services/supervisor-state.ts");
+    const { getPpmDir } = await import("../services/ppm-dir.ts");
 
-    const ppmDir = process.env.PPM_HOME || resolve(homedir(), ".ppm");
+    const ppmDir = getPpmDir();
     if (!existsSync(ppmDir)) mkdirSync(ppmDir, { recursive: true });
     const pidFile = resolve(ppmDir, "ppm.pid");
     const statusFile = resolve(ppmDir, "status.json");
@@ -490,9 +490,9 @@ if (process.argv.includes("__serve__")) {
   // Also write server version to status.json so supervisor heartbeat reports the actual running version.
   try {
     const { resolve: r } = await import("node:path");
-    const { homedir: h } = await import("node:os");
     const { readFileSync: rf, writeFileSync: wf, renameSync: rn } = await import("node:fs");
-    const statusFile = r(h(), ".ppm", "status.json");
+    const { getPpmDir: gd } = await import("../services/ppm-dir.ts");
+    const statusFile = r(gd(), "status.json");
     const status = JSON.parse(rf(statusFile, "utf-8"));
     // Write running server version — source of truth for heartbeat
     status.serverVersion = VERSION;

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 { renameSession as sdkRenameSession } from "@anthropic-ai/claude-agent-sdk";
-import { listSlashItems } from "../../services/slash-items.service.ts";
+import { listSlashItems, searchSlashItems } from "../../services/slash-items.service.ts";
 import { getCachedUsage, refreshUsageNow } from "../../services/claude-usage.service.ts";
 import { getSessionLog } from "../../services/session-log.service.ts";
 import { getSessionProjectPath, setSessionMetadata, setSessionTitle, getPinnedSessionIds, pinSession, unpinSession, deleteSessionMapping, deleteSessionMetadata, deleteSessionTitle } from "../../services/db.service.ts";
@@ -19,7 +19,9 @@ export const chatRoutes = new Hono<Env>();
 chatRoutes.get("/slash-items", (c) => {
   try {
     const projectPath = c.get("projectPath");
-    const items = listSlashItems(projectPath);
+    const q = c.req.query("q");
+    let items = listSlashItems(projectPath);
+    if (q) items = searchSlashItems(items, q);
     return c.json(ok(items));
   } catch (e) {
     return c.json(err((e as Error).message), 500);

package/src/server/routes/port-forwarding.ts

@@ -19,11 +19,67 @@ interface ActiveTunnel {
   url: string;
   process: import("bun").Subprocess;
   startedAt: number;
+  probeFailures: number;
 }
 
+const MAX_PROBE_FAILURES = 2;
+
 /** Active tunnels keyed by port — exported for testing */
 export const activeTunnels = new Map<number, ActiveTunnel>();
 
+/** Spawn cloudflared tunnel for a port, extract URL from stderr */
+async function spawnTunnelProcess(port: number): Promise<{ process: import("bun").Subprocess; url: string }> {
+  const bin = await ensureCloudflared();
+  const proc = Bun.spawn(
+    [bin, "tunnel", "--url", `http://127.0.0.1:${port}`],
+    { stderr: "pipe", stdout: "ignore", stdin: "ignore" },
+  );
+
+  const reader = proc.stderr.getReader();
+  const decoder = new TextDecoder();
+  const url = await new Promise<string>((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      try { proc.kill(); } catch {}
+      reject(new Error("Tunnel timed out after 30s"));
+    }, 30_000);
+
+    let buffer = "";
+    let found = false;
+    const read = async () => {
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          if (found) continue;
+          buffer += decoder.decode(value, { stream: true });
+          const match = buffer.match(TUNNEL_URL_REGEX);
+          if (match) {
+            found = true;
+            buffer = "";
+            clearTimeout(timeout);
+            resolve(match[0]);
+          }
+        }
+        if (!found) {
+          clearTimeout(timeout);
+          reject(new Error("cloudflared exited without tunnel URL"));
+        }
+      } catch (e) {
+        if (!found) { clearTimeout(timeout); reject(e); }
+      }
+    };
+    read();
+  });
+
+  return { process: proc, url };
+}
+
+/** Register tunnel in map with auto-cleanup on exit */
+function registerTunnel(port: number, proc: import("bun").Subprocess, url: string) {
+  activeTunnels.set(port, { port, url, process: proc, startedAt: Date.now(), probeFailures: 0 });
+  proc.exited.then(() => activeTunnels.delete(port)).catch(() => activeTunnels.delete(port));
+}
+
 /** Start a tunnel for a localhost port */
 portForwardingRoutes.post("/tunnel", async (c) => {
   const body = await c.req.json<{ port: number }>().catch(() => null);
@@ -39,54 +95,8 @@ portForwardingRoutes.post("/tunnel", async (c) => {
   }
 
   try {
-    const bin = await ensureCloudflared();
-    const proc = Bun.spawn(
-      [bin, "tunnel", "--url", `http://127.0.0.1:${port}`],
-      { stderr: "pipe", stdout: "ignore", stdin: "ignore" },
-    );
-
-    // Read stderr to find tunnel URL
-    const reader = proc.stderr.getReader();
-    const decoder = new TextDecoder();
-    const url = await new Promise<string>((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        try { proc.kill(); } catch {}
-        reject(new Error("Tunnel timed out after 30s"));
-      }, 30_000);
-
-      let buffer = "";
-      let found = false;
-      const read = async () => {
-        try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) break;
-            if (found) continue;
-            buffer += decoder.decode(value, { stream: true });
-            const match = buffer.match(TUNNEL_URL_REGEX);
-            if (match) {
-              found = true;
-              buffer = "";
-              clearTimeout(timeout);
-              resolve(match[0]);
-            }
-          }
-          if (!found) {
-            clearTimeout(timeout);
-            reject(new Error("cloudflared exited without tunnel URL"));
-          }
-        } catch (e) {
-          if (!found) { clearTimeout(timeout); reject(e); }
-        }
-      };
-      read();
-    });
-
-    activeTunnels.set(port, { port, url, process: proc, startedAt: Date.now() });
-
-    // Auto-cleanup when process exits
-    proc.exited.then(() => activeTunnels.delete(port)).catch(() => activeTunnels.delete(port));
-
+    const { process: proc, url } = await spawnTunnelProcess(port);
+    registerTunnel(port, proc, url);
     console.log(`[preview] tunnel started for port ${port} → ${url}`);
     return c.json(ok({ port, url }));
   } catch (e: any) {
@@ -123,27 +133,68 @@ function isProcessAlive(proc: import("bun").Subprocess): boolean {
   try { process.kill(proc.pid, 0); return true; } catch { return false; }
 }
 
-/** Remove ghost tunnels (process died or target port no longer listening) */
+/** Probe tunnel URL to check if it's still accessible (DNS + connection) */
+async function probeTunnelUrl(url: string): Promise<boolean> {
+  try {
+    await fetch(url, { method: "HEAD", signal: AbortSignal.timeout(8_000), redirect: "follow" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+let cleanupRunning = false;
+
+/** Remove ghost tunnels and auto-restart tunnels with expired URLs */
 async function cleanupGhostTunnels() {
-  for (const [port, tunnel] of activeTunnels) {
-    // Check if cloudflared process is still running
-    if (!isProcessAlive(tunnel.process)) {
-      console.log(`[preview] ghost cleanup: tunnel for port ${port} — process dead`);
-      activeTunnels.delete(port);
-      continue;
-    }
-    // Check if target port is still listening
-    try {
-      const conn = await Bun.connect({ hostname: "127.0.0.1", port, socket: {
-        data() {}, open(s) { s.end(); }, error() {}, close() {},
-      }});
-      conn.end();
-    } catch {
-      // Port not listening — kill tunnel
-      console.log(`[preview] ghost cleanup: tunnel for port ${port} — port not listening`);
-      try { tunnel.process.kill(); } catch {}
-      activeTunnels.delete(port);
+  if (cleanupRunning) return;
+  cleanupRunning = true;
+  try {
+    for (const [port, tunnel] of activeTunnels) {
+      // Check if cloudflared process is still running
+      if (!isProcessAlive(tunnel.process)) {
+        console.log(`[preview] ghost cleanup: port ${port} — process dead`);
+        activeTunnels.delete(port);
+        continue;
+      }
+      // Check if target port is still listening
+      try {
+        const conn = await Bun.connect({ hostname: "127.0.0.1", port, socket: {
+          data() {}, open(s) { s.end(); }, error() {}, close() {},
+        }});
+        conn.end();
+      } catch {
+        console.log(`[preview] ghost cleanup: port ${port} — port not listening`);
+        try { tunnel.process.kill(); } catch {}
+        activeTunnels.delete(port);
+        continue;
+      }
+
+      // Probe tunnel URL to detect expired Quick Tunnel URLs
+      const alive = await probeTunnelUrl(tunnel.url);
+      if (alive) {
+        tunnel.probeFailures = 0;
+        continue;
+      }
+
+      tunnel.probeFailures++;
+      console.log(`[preview] tunnel probe failed for port ${port} (${tunnel.probeFailures}/${MAX_PROBE_FAILURES})`);
+
+      if (tunnel.probeFailures >= MAX_PROBE_FAILURES) {
+        console.log(`[preview] tunnel URL expired for port ${port}, restarting...`);
+        try { tunnel.process.kill(); } catch {}
+        activeTunnels.delete(port);
+        try {
+          const { process: proc, url } = await spawnTunnelProcess(port);
+          registerTunnel(port, proc, url);
+          console.log(`[preview] tunnel restarted for port ${port} → ${url}`);
+        } catch (e: any) {
+          console.warn(`[preview] tunnel restart failed for port ${port}: ${e.message}`);
+        }
+      }
     }
+  } finally {
+    cleanupRunning = false;
   }
 }
 

package/src/server/routes/upgrade.ts

@@ -1,6 +1,5 @@
 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 {
@@ -10,8 +9,7 @@ import {
   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");
+import { getPpmDir } from "../../services/ppm-dir.ts";
 
 export const upgradeRoutes = new Hono();
 
@@ -19,8 +17,8 @@ export const upgradeRoutes = new Hono();
 upgradeRoutes.get("/", (c) => {
   let availableVersion: string | null = null;
   try {
-    if (existsSync(STATUS_FILE)) {
-      const data = JSON.parse(readFileSync(STATUS_FILE, "utf-8"));
+    if (existsSync(resolve(getPpmDir(), "status.json"))) {
+      const data = JSON.parse(readFileSync(resolve(getPpmDir(), "status.json"), "utf-8"));
       const candidate = data.availableVersion ?? null;
       // Only report if actually newer than current version
       if (candidate && compareSemver(VERSION, candidate) < 0) {

package/src/server/ws/chat.ts

@@ -582,6 +582,22 @@ export const chatWebSocket = {
         entry.permissionMode = parsed.permissionMode;
       }
 
+      // Intercept PPM-handled built-in commands (e.g. /skills, /version)
+      const content = parsed.content.trim();
+      const slashMatch = content.match(/^\/(\S+)/);
+      if (slashMatch) {
+        const { isPpmHandled, executeBuiltin } = await import("../../services/slash-discovery/index.ts");
+        const cmdName = slashMatch[1]!;
+        if (isPpmHandled(cmdName)) {
+          const response = executeBuiltin(cmdName, entry.projectPath ?? "");
+          if (response) {
+            broadcast(sessionId, { type: "text", content: response });
+            broadcast(sessionId, { type: "done", resultSubtype: "builtin", numTurns: 0 });
+            return;
+          }
+        }
+      }
+
       const provider = providerRegistry.get(providerId);
 
       if (!entry.isStreamingActive) {

package/src/services/cloud-ws.service.ts

@@ -4,7 +4,7 @@
  */
 import { appendFileSync } from "node:fs";
 import { resolve } from "node:path";
-import { homedir } from "node:os";
+import { getPpmDir } from "./ppm-dir.ts";
 
 // ─── Types (must match Cloud's ws-types.ts) ─────────
 interface WsMessage {
@@ -237,6 +237,6 @@ function scheduleReconnect(source = "unknown"): void {
 
 function log(level: string, msg: string): void {
   const ts = new Date().toISOString();
-  const logFile = resolve(process.env.PPM_HOME || resolve(homedir(), ".ppm"), "ppm.log");
+  const logFile = resolve(getPpmDir(), "ppm.log");
   try { appendFileSync(logFile, `[${ts}] [${level}] [cloud-ws] ${msg}\n`); } catch {}
 }