@hienlh/ppm 0.9.0-beta.9 → 0.9.1

package/src/server/index.ts

@@ -19,6 +19,7 @@ import { browserPreviewRoutes } from "./routes/browser-preview.ts";
 import { initAdapters } from "../services/database/init-adapters.ts";
 import { terminalWebSocket } from "./ws/terminal.ts";
 import { chatWebSocket } from "./ws/chat.ts";
+import { extensionWebSocket } from "./ws/extensions.ts";
 import { ok, err } from "../types/api.ts";
 
 /** Tee console.log/error to ~/.ppm/ppm.log while preserving terminal output */
@@ -149,6 +150,10 @@ app.route("/api/postgres", postgresRoutes);
 app.route("/api/db", databaseRoutes);
 app.route("/api/accounts", accountsRoutes);
 
+// Extensions management
+import { extensionRoutes } from "./routes/extensions.ts";
+app.route("/api/extensions", extensionRoutes);
+
 // Upgrade routes (check for updates, apply upgrade)
 import { upgradeRoutes } from "./routes/upgrade.ts";
 app.route("/api/upgrade", upgradeRoutes);
@@ -162,51 +167,43 @@ app.route("/", staticRoutes);
 
 export async function startServer(options: {
   port?: string;
-  foreground?: boolean;
-  daemon?: boolean; // compat, ignored (daemon is now default)
   share?: boolean;
   config?: string;
   profile?: string;
 }) {
+  // Tunnel always enabled — cloudflared shares the server publicly
+  options.share = true;
+
   // Load config
   configService.load(options.config);
   const port = parseInt(options.port ?? String(configService.get("port")), 10);
   const host = configService.get("host");
 
-  // Setup log file (both foreground and daemon modes)
   await setupLogFile();
 
   // Bootstrap CLI providers (checks binary availability)
   const { bootstrapProviders } = await import("../providers/registry.ts");
   await bootstrapProviders();
 
-  // Check if port is already in use before starting.
-  // Skip in hot-reload mode — Bun.serve() replaces the previous server on the same port,
-  // but a net.createServer() probe would see it as "in use" and exit prematurely.
-  // globalThis persists across bun --hot reloads, so we use a flag set after first start.
-  const isHotReload = !!(globalThis as any).__PPM_SERVER_STARTED__;
-  if (!isHotReload) {
-    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);
-    }
+  // Check if port is already in use before spawning supervisor
+  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) {
+  {
     const { resolve } = await import("node:path");
     const { homedir } = await import("node:os");
     const { writeFileSync, readFileSync, mkdirSync, existsSync, openSync } = await import("node:fs");
@@ -272,7 +269,6 @@ export async function startServer(options: {
       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 {
@@ -297,7 +293,6 @@ export async function startServer(options: {
       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
@@ -353,130 +348,6 @@ export async function startServer(options: {
 
     process.exit(0);
   }
-
-  // Foreground mode — with WebSocket support
-  const server = Bun.serve({
-    port,
-    hostname: host,
-    fetch(req, server) {
-      const url = new URL(req.url);
-
-      // WebSocket upgrade: /ws/project/:projectName/terminal/:id
-      if (url.pathname.startsWith("/ws/project/")) {
-        const parts = url.pathname.split("/");
-        const projectName = parts[3] ?? "";
-        const wsType = parts[4] ?? "";
-        const id = parts[5] ?? "";
-
-        if (wsType === "terminal") {
-          const upgraded = server.upgrade(req, {
-            data: { type: "terminal", id, projectName },
-          });
-          if (upgraded) return undefined;
-          return new Response("WebSocket upgrade failed", { status: 400 });
-        }
-
-        if (wsType === "chat") {
-          const sessionId = id;
-          const upgraded = server.upgrade(req, {
-            data: { type: "chat", sessionId, projectName },
-          });
-          if (upgraded) return undefined;
-          return new Response("WebSocket upgrade failed", { status: 400 });
-        }
-      }
-
-      return app.fetch(req, server);
-    },
-    websocket: {
-      idleTimeout: 960,
-      sendPong: true,
-      perMessageDeflate: false, // Disable compression — Cloudflare tunnels can mangle compressed frames
-      open(ws: any) {
-        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 === "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,
-  });
-
-  // Mark server as started — survives bun --hot reloads (globalThis persists)
-  (globalThis as any).__PPM_SERVER_STARTED__ = true;
-
-  // Start background usage polling
-  import("../services/claude-usage.service.ts").then(({ startUsagePolling }) => startUsagePolling()).catch(() => {});
-
-  // Start background account token refresh
-  import("../services/account.service.ts").then(({ accountService }) => accountService.startAutoRefresh()).catch(() => {});
-
-  console.log(`\n  PPM ready\n`);
-  console.log(`  ➜  Local:   http://localhost:${server.port}/`);
-
-  const { networkInterfaces } = await import("node:os");
-  const nets = networkInterfaces();
-  for (const name of Object.keys(nets)) {
-    for (const net of nets[name] ?? []) {
-      if (net.family === "IPv4" && !net.internal) {
-        console.log(`  ➜  Network: http://${net.address}:${server.port}/`);
-      }
-    }
-  }
-
-  // Share tunnel in foreground mode
-  if (options.share) {
-    try {
-      const { tunnelService } = await import("../services/tunnel.service.ts");
-      console.log("\n  Starting share tunnel...");
-      const shareUrl = await tunnelService.startTunnel(server.port!);
-      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: run 'ppm config set auth.enabled true' or restart without --share.`);
-      }
-      const qr = await import("qrcode-terminal");
-      console.log();
-      qr.generate(shareUrl, { small: true });
-    } catch (err: unknown) {
-      const msg = err instanceof Error ? err.message : String(err);
-      console.error(`  ✗  Share failed: ${msg}`);
-    }
-  }
-
-  console.log(`\n  Auth: ${configService.get("auth").enabled ? "enabled" : "disabled"}`);
-  if (configService.get("auth").enabled) {
-    console.log(`  Token: ${configService.get("auth").token}`);
-  }
-  console.log();
-
-  // Graceful shutdown — stop server + tunnel + preview tunnels + DB on exit
-  const shutdown = () => {
-    try { server.stop(true); } catch {}
-    try {
-      import("../services/tunnel.service.ts").then(({ tunnelService }) => tunnelService.stopTunnel()).catch(() => {});
-    } catch {}
-    try {
-      import("./routes/browser-preview.ts").then(({ stopAllPreviewTunnels }) => stopAllPreviewTunnels()).catch(() => {});
-    } catch {}
-    try {
-      import("../services/db.service.ts").then(({ closeDb }) => closeDb()).catch(() => {});
-    } catch {}
-  };
-  process.on("SIGINT", () => { shutdown(); process.exit(0); });
-  process.on("SIGTERM", () => { shutdown(); process.exit(0); });
-  process.on("exit", shutdown);
 }
 
 // Internal entry point for daemon child process
@@ -500,12 +371,16 @@ if (process.argv.includes("__serve__")) {
 
   // Sync externally-started tunnel URL + PID into tunnelService
   // so GET /api/tunnel reflects the correct state and Share button doesn't start a duplicate.
+  // 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 } = await import("node:fs");
+    const { readFileSync: rf, writeFileSync: wf } = await import("node:fs");
     const statusFile = r(h(), ".ppm", "status.json");
     const status = JSON.parse(rf(statusFile, "utf-8"));
+    // Write running server version — source of truth for heartbeat
+    status.serverVersion = VERSION;
+    wf(statusFile, JSON.stringify(status));
     if (status.shareUrl) {
       const { tunnelService } = await import("../services/tunnel.service.ts");
       tunnelService.setExternalUrl(status.shareUrl);
@@ -525,6 +400,20 @@ if (process.argv.includes("__serve__")) {
         return new Response("WebSocket upgrade failed", { status: 400 });
       }
 
+      if (url.pathname === "/ws/extensions") {
+        // Auth check for extension WS
+        const authConfig = configService.get("auth");
+        if (authConfig.enabled) {
+          const token = url.searchParams.get("token");
+          if (token !== authConfig.token) {
+            return new Response("Unauthorized", { status: 401 });
+          }
+        }
+        const upgraded = server.upgrade(req, { data: { type: "extensions" } });
+        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] ?? "";
@@ -557,14 +446,17 @@ if (process.argv.includes("__serve__")) {
       perMessageDeflate: false,
       open(ws: any) {
         if (ws.data?.type === "chat") chatWebSocket.open(ws);
+        else if (ws.data?.type === "extensions") extensionWebSocket.open(ws);
         else terminalWebSocket.open(ws);
       },
       message(ws: any, msg: any) {
         if (ws.data?.type === "chat") chatWebSocket.message(ws, msg);
+        else if (ws.data?.type === "extensions") extensionWebSocket.message(ws, msg);
         else terminalWebSocket.message(ws, msg);
       },
       close(ws: any) {
         if (ws.data?.type === "chat") chatWebSocket.close(ws);
+        else if (ws.data?.type === "extensions") extensionWebSocket.close(ws);
         else terminalWebSocket.close(ws);
       },
     } as Parameters<typeof Bun.serve>[0] extends { websocket?: infer W } ? W : never,
@@ -573,5 +465,13 @@ if (process.argv.includes("__serve__")) {
   // Start background account token refresh in daemon child
   import("../services/account.service.ts").then(({ accountService }) => accountService.startAutoRefresh()).catch(() => {});
 
+  // Start background usage limit polling (every 5 min)
+  import("../services/claude-usage.service.ts").then(({ startUsagePolling }) => startUsagePolling()).catch(() => {});
+
+  // Discover + activate enabled extensions
+  import("../services/extension.service.ts").then(({ extensionService }) => extensionService.startup()).catch((e) => {
+    console.error("[ExtService] Startup error:", e);
+  });
+
   console.log(`Server child ready on port ${port}`);
 }

package/src/server/routes/chat.ts

@@ -8,7 +8,7 @@ import { renameSession as sdkRenameSession } from "@anthropic-ai/claude-agent-sd
 import { listSlashItems } from "../../services/slash-items.service.ts";
 import { getCachedUsage, refreshUsageNow } from "../../services/claude-usage.service.ts";
 import { getSessionLog } from "../../services/session-log.service.ts";
-import { getSessionMapping, setSessionTitle } from "../../services/db.service.ts";
+import { getSessionMapping, getSessionProjectPath, setSessionMapping, setSessionTitle, getPinnedSessionIds, pinSession, unpinSession, deleteSessionMapping, deleteSessionTitle } from "../../services/db.service.ts";
 import { ok, err } from "../../types/api.ts";
 
 type Env = { Variables: { projectPath: string; projectName: string } };
@@ -76,7 +76,16 @@ chatRoutes.get("/sessions", async (c) => {
     const projectPath = c.get("projectPath");
     const providerId = c.req.query("providerId");
     const sessions = await chatService.listSessions(providerId, projectPath);
-    return c.json(ok(sessions));
+    // Enrich with pin status
+    const pinnedIds = getPinnedSessionIds();
+    const enriched = sessions.map((s) => ({ ...s, pinned: pinnedIds.has(s.id) }));
+    // Sort: pinned first (by pinned_at implicit via Set order), then unpinned by createdAt
+    enriched.sort((a, b) => {
+      if (a.pinned && !b.pinned) return -1;
+      if (!a.pinned && b.pinned) return 1;
+      return new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime();
+    });
+    return c.json(ok(enriched));
   } catch (e) {
     return c.json(err((e as Error).message), 500);
   }
@@ -116,7 +125,13 @@ chatRoutes.delete("/sessions/:id", async (c) => {
   try {
     const id = c.req.param("id");
     const providerId = c.req.query("providerId") ?? "claude";
+    const sdkId = getSessionMapping(id) ?? id;
+    // Provider-specific cleanup (JSONL, process, etc.)
     await chatService.deleteSession(providerId, id);
+    // Shared DB cleanup
+    deleteSessionMapping(id);
+    deleteSessionTitle(sdkId);
+    unpinSession(sdkId);
     return c.json(ok({ deleted: id }));
   } catch (e) {
     return c.json(err((e as Error).message), 404);
@@ -146,6 +161,28 @@ chatRoutes.patch("/sessions/:id", async (c) => {
   }
 });
 
+/** PUT /chat/sessions/:id/pin — pin a session */
+chatRoutes.put("/sessions/:id/pin", (c) => {
+  try {
+    const id = c.req.param("id");
+    pinSession(id);
+    return c.json(ok({ id, pinned: true }));
+  } catch (e) {
+    return c.json(err((e as Error).message), 500);
+  }
+});
+
+/** DELETE /chat/sessions/:id/pin — unpin a session */
+chatRoutes.delete("/sessions/:id/pin", (c) => {
+  try {
+    const id = c.req.param("id");
+    unpinSession(id);
+    return c.json(ok({ id, pinned: false }));
+  } catch (e) {
+    return c.json(err((e as Error).message), 500);
+  }
+});
+
 /** POST /chat/sessions/:id/fork — fork session into a new one (for rewind/branch) */
 chatRoutes.post("/sessions/:id/fork", async (c) => {
   try {
@@ -153,16 +190,31 @@ chatRoutes.post("/sessions/:id/fork", async (c) => {
     const projectName = c.get("projectName");
     const projectPath = c.get("projectPath");
     const providerId = c.req.query("providerId") ?? "claude";
-    // Create a new PPM session that will fork from sourceId on first message
-    const session = await chatService.createSession(providerId, {
-      projectName,
-      projectPath,
-      title: "Forked Chat",
-    });
-    // Store fork source so WS handler knows to use forkSession on first message
+    const body = await c.req.json<{ messageId?: string }>().catch(() => ({} as { messageId?: string }));
     const provider = providerRegistry.get(providerId);
-    provider?.setForkSource?.(session.id, sourceId);
-    return c.json(ok({ ...session, forkedFrom: sourceId }), 201);
+    if (!provider) return c.json(err("Provider not found"), 404);
+
+    if (body.messageId) {
+      // Mid-fork at a specific message
+      if (!provider.forkAtMessage) {
+        return c.json(err("Provider does not support forking"), 400);
+      }
+      const result = await provider.forkAtMessage(sourceId, body.messageId, {
+        title: "Forked Chat", dir: projectPath,
+      });
+      const session = await chatService.createSession(providerId, {
+        projectName, projectPath, title: "Forked Chat",
+      });
+      setSessionMapping(session.id, result.sessionId);
+      provider.markAsResumed?.(session.id);
+      return c.json(ok({ ...session, forkedFrom: sourceId }), 201);
+    } else {
+      // No messageId (fork at first message) — create a fresh empty session
+      const session = await chatService.createSession(providerId, {
+        projectName, projectPath, title: "Forked Chat",
+      });
+      return c.json(ok({ ...session, forkedFrom: sourceId }), 201);
+    }
   } catch (e) {
     return c.json(err((e as Error).message), 500);
   }
@@ -180,6 +232,24 @@ chatRoutes.get("/sessions/:id/logs", (c) => {
   }
 });
 
+/** GET /chat/sessions/:id/debug — session debug info (IDs, JSONL path) */
+chatRoutes.get("/sessions/:id/debug", (c) => {
+  const ppmId = c.req.param("id");
+  const sdkId = getSessionMapping(ppmId) ?? ppmId;
+  // Resolve JSONL path: ~/.claude/projects/<encoded-cwd>/<sdkId>.jsonl
+  const homedir = process.env.HOME ?? process.env.USERPROFILE ?? "";
+  const provider = providerRegistry.get("claude") as any;
+  // Try in-memory first, fall back to DB-persisted project_path
+  const projectPath = provider?.activeSessions?.get(ppmId)?.projectPath
+    ?? getSessionProjectPath(ppmId)
+    ?? "";
+  const encodedCwd = projectPath ? projectPath.replace(/\//g, "-") : "";
+  const jsonlDir = encodedCwd ? resolve(homedir, ".claude", "projects", encodedCwd) : "";
+  const jsonlPath = jsonlDir ? resolve(jsonlDir, `${sdkId}.jsonl`) : "";
+  const jsonlExists = jsonlPath ? existsSync(jsonlPath) : false;
+  return c.json(ok({ ppmSessionId: ppmId, sdkSessionId: sdkId, jsonlPath: jsonlExists ? jsonlPath : null, jsonlDir, projectPath }));
+});
+
 /** POST /chat/upload — upload files for chat attachments, returns server-side paths */
 chatRoutes.post("/upload", async (c) => {
   try {

package/src/server/routes/extensions.ts

@@ -0,0 +1,81 @@
+import { Hono } from "hono";
+import { extensionService } from "../../services/extension.service.ts";
+import { contributionRegistry } from "../../services/contribution-registry.ts";
+import { ok, err } from "../../types/api.ts";
+
+export const extensionRoutes = new Hono();
+
+// GET /api/extensions — list all extensions
+extensionRoutes.get("/", (c) => {
+  const extensions = extensionService.list();
+  return c.json(ok(extensions));
+});
+
+// GET /api/extensions/contributions — all contribution points (for UI)
+extensionRoutes.get("/contributions", (c) => {
+  return c.json(ok(contributionRegistry.getAll()));
+});
+
+// GET /api/extensions/:id — get single extension info
+extensionRoutes.get("/:id{.+}", (c) => {
+  const id = c.req.param("id");
+  const ext = extensionService.get(id);
+  if (!ext) return c.json(err("Extension not found"), 404);
+  return c.json(ok(ext));
+});
+
+// POST /api/extensions/install — install extension
+extensionRoutes.post("/install", async (c) => {
+  const body = await c.req.json<{ name?: string }>().catch(() => ({}) as { name?: string });
+  if (!body.name) return c.json(err("Missing 'name' field"), 400);
+
+  try {
+    const manifest = await extensionService.install(body.name);
+    return c.json(ok(manifest), 201);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return c.json(err(msg), 500);
+  }
+});
+
+// POST /api/extensions/dev-link — symlink local extension for development
+extensionRoutes.post("/dev-link", async (c) => {
+  const body = await c.req.json<{ path?: string }>().catch(() => ({}) as { path?: string });
+  if (!body.path) return c.json(err("Missing 'path' field"), 400);
+
+  try {
+    const manifest = await extensionService.devLink(body.path);
+    return c.json(ok(manifest), 201);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return c.json(err(msg), 500);
+  }
+});
+
+// DELETE /api/extensions/:id — remove extension
+extensionRoutes.delete("/:id{.+}", async (c) => {
+  const id = c.req.param("id");
+  try {
+    await extensionService.remove(id);
+    return c.json(ok({ removed: id }));
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return c.json(err(msg), 500);
+  }
+});
+
+// PATCH /api/extensions/:id — enable/disable
+extensionRoutes.patch("/:id{.+}", async (c) => {
+  const id = c.req.param("id");
+  const body = await c.req.json<{ enabled?: boolean }>().catch(() => ({}) as { enabled?: boolean });
+  if (body.enabled === undefined) return c.json(err("Missing 'enabled' field"), 400);
+
+  try {
+    await extensionService.setEnabled(id, body.enabled);
+    const ext = extensionService.get(id);
+    return c.json(ok(ext));
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return c.json(err(msg), 500);
+  }
+});

package/src/server/routes/project-scoped.ts

@@ -4,6 +4,7 @@ import { chatRoutes } from "./chat.ts";
 import { gitRoutes } from "./git.ts";
 import { fileRoutes } from "./files.ts";
 import { sqliteRoutes } from "./sqlite.ts";
+import { workspaceRoutes } from "./workspace.ts";
 
 type Env = { Variables: { projectPath: string; projectName: string } };
 
@@ -27,3 +28,4 @@ projectScopedRouter.route("/chat", chatRoutes);
 projectScopedRouter.route("/git", gitRoutes);
 projectScopedRouter.route("/files", fileRoutes);
 projectScopedRouter.route("/sqlite", sqliteRoutes);
+projectScopedRouter.route("/workspace", workspaceRoutes);

package/src/server/routes/settings.ts

@@ -252,6 +252,33 @@ settingsRoutes.post("/telegram/test", async (c) => {
   }
 });
 
+// ── Auth / Password ──────────────────────────────────────────────────
+
+/** PUT /settings/auth/password — change the access password (token) */
+settingsRoutes.put("/auth/password", async (c) => {
+  try {
+    const { password, confirm } = await c.req.json<{ password: string; confirm: string }>();
+    if (typeof password !== "string" || !password.trim()) {
+      return c.json(err("Password is required"), 400);
+    }
+    if (password !== confirm) {
+      return c.json(err("Passwords do not match"), 400);
+    }
+    const trimmed = password.trim();
+    if (trimmed.length < 4) {
+      return c.json(err("Password must be at least 4 characters"), 400);
+    }
+
+    const auth = configService.get("auth");
+    configService.set("auth", { ...auth, token: trimmed });
+    configService.save();
+
+    return c.json(ok({ token: trimmed }));
+  } catch (e) {
+    return c.json(err((e as Error).message), 400);
+  }
+});
+
 // ── Proxy ────────────────────────────────────────────────────────────
 
 /** GET /settings/proxy — proxy status */

package/src/server/routes/workspace.ts

@@ -0,0 +1,35 @@
+import { Hono } from "hono";
+import { getWorkspace, setWorkspace } from "../../services/db.service.ts";
+import { ok, err } from "../../types/api.ts";
+
+type Env = { Variables: { projectPath: string; projectName: string } };
+
+export const workspaceRoutes = new Hono<Env>();
+
+/** GET /workspace — load saved workspace layout */
+workspaceRoutes.get("/", (c) => {
+  try {
+    const projectName = c.get("projectName");
+    const row = getWorkspace(projectName);
+    if (!row) return c.json(ok(null));
+    return c.json(ok({
+      layout: JSON.parse(row.layout_json),
+      updatedAt: row.updated_at,
+    }));
+  } catch (e) {
+    return c.json(err((e as Error).message), 500);
+  }
+});
+
+/** PUT /workspace — save workspace layout */
+workspaceRoutes.put("/", async (c) => {
+  try {
+    const projectName = c.get("projectName");
+    const body = await c.req.json<{ layout: unknown }>();
+    if (!body.layout) return c.json(err("Missing layout"), 400);
+    const updatedAt = setWorkspace(projectName, JSON.stringify(body.layout));
+    return c.json(ok({ updatedAt }));
+  } catch (e) {
+    return c.json(err((e as Error).message), 500);
+  }
+});

package/src/server/ws/chat.ts

@@ -11,7 +11,7 @@ const CLEANUP_TIMEOUT_MS = 5 * 60_000; // 5min after Claude done + no FE
 const MAX_TURN_EVENTS = 10_000; // memory safety cap
 const BUFFERABLE_TYPES = new Set([
   "text", "thinking", "tool_use", "tool_result",
-  "approval_request", "error", "done", "account_info",
+  "approval_request", "error", "done", "account_info", "account_retry",
 ]);
 
 type ChatWsSocket = {
@@ -218,8 +218,14 @@ async function startSessionConsumer(sessionId: string, providerId: string, conte
         continue;
       }
 
-      // System events → transition connecting → thinking
+      // System events → transition connecting → thinking, forward compact events
       if (evType === "system") {
+        const sub = (ev as any).subtype;
+        if (sub === "compacting") {
+          broadcast(sessionId, { type: "compact_status", status: "compacting" });
+        } else if (sub === "compact_done") {
+          broadcast(sessionId, { type: "compact_status", status: "done" });
+        }
         if (!firstEventReceived) {
           if (heartbeat) clearInterval(heartbeat);
           setPhase(sessionId, "thinking");
@@ -228,7 +234,7 @@ async function startSessionConsumer(sessionId: string, providerId: string, conte
       }
 
       // First content event — stop heartbeat, transition phase
-      const isMetadataEvent = evType === "account_info" || evType === "streaming_status";
+      const isMetadataEvent = evType === "account_info" || evType === "account_retry" || evType === "streaming_status";
       if (!firstEventReceived && !isMetadataEvent) {
         firstEventReceived = true;
         const waitMs = Date.now() - startTime;