@hienlh/ppm 0.8.58 → 0.8.60

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

@@ -502,22 +502,24 @@ export class ClaudeAgentSdkProvider implements AIProvider {
 
         // Log all system events for debugging SDK lifecycle
         if (msg.type === "system") {
-          console.log(`[sdk] session=${sessionId} system: subtype=${(msg as any).subtype ?? "none"} ${JSON.stringify(msg).slice(0, 500)}`);
-        }
-
-        // Capture SDK session metadata from init message
-        if (msg.type === "system" && (msg as any).subtype === "init") {
-          const initMsg = msg as any;
-          // SDK may assign a different session_id than our UUID
-          if (initMsg.session_id && initMsg.session_id !== sessionId) {
-            // Persist mapping so resume works after server restart
-            setSessionMapping(sessionId, initMsg.session_id);
-            // Update our in-memory mapping
-            const oldMeta = this.activeSessions.get(sessionId);
-            if (oldMeta) {
-              this.activeSessions.set(initMsg.session_id, { ...oldMeta, id: initMsg.session_id });
+          const subtype = (msg as any).subtype ?? "none";
+          console.log(`[sdk] session=${sessionId} system: subtype=${subtype} ${JSON.stringify(msg).slice(0, 500)}`);
+
+          // Capture SDK session metadata from init message
+          if (subtype === "init") {
+            const initMsg = msg as any;
+            if (initMsg.session_id && initMsg.session_id !== sessionId) {
+              setSessionMapping(sessionId, initMsg.session_id);
+              const oldMeta = this.activeSessions.get(sessionId);
+              if (oldMeta) {
+                this.activeSessions.set(initMsg.session_id, { ...oldMeta, id: initMsg.session_id });
+              }
             }
           }
+
+          // Yield system events so streaming loop can transition phases
+          // (e.g. connecting → thinking when hooks/init arrive)
+          yield { type: "system" as any, subtype } as any;
           continue;
         }
 

package/src/providers/mock-provider.ts

@@ -92,8 +92,13 @@ export class MockProvider implements AIProvider {
     const abortController = new AbortController();
     this.activeAborts.set(sessionId, abortController);
 
+    // Simulate SDK system events (hooks, init) — real SDK emits these before content
+    yield { type: "system" as any, subtype: "hook_started" } as any;
+    await sleep(50);
+    yield { type: "system" as any, subtype: "init" } as any;
+
     // Simulate thinking delay
-    await sleep(300);
+    await sleep(250);
 
     // Pick a response
     const responseText =

package/src/server/index.ts

@@ -13,7 +13,7 @@ import { postgresRoutes } from "./routes/postgres.ts";
 import { databaseRoutes } from "./routes/database.ts";
 import { fsBrowseRoutes } from "./routes/fs-browse.ts";
 import { accountsRoutes } from "./routes/accounts.ts";
-import { proxyRoutes, handleProxyRequest } from "./routes/proxy.ts";
+import { proxyRoutes } from "./routes/proxy.ts";
 import { initAdapters } from "../services/database/init-adapters.ts";
 import { terminalWebSocket } from "./ws/terminal.ts";
 import { chatWebSocket } from "./ws/chat.ts";
@@ -344,15 +344,9 @@ export async function startServer(options: {
   const server = Bun.serve({
     port,
     hostname: host,
-    async fetch(req, server) {
+    fetch(req, server) {
       const url = new URL(req.url);
 
-      // Proxy: handle before Hono to avoid SPA catch-all conflict
-      if (url.pathname.startsWith("/proxy")) {
-        const proxyRes = await handleProxyRequest(req);
-        if (proxyRes) return proxyRes;
-      }
-
       // WebSocket upgrade: /ws/project/:projectName/terminal/:id
       if (url.pathname.startsWith("/ws/project/")) {
         const parts = url.pathname.split("/");
@@ -505,15 +499,9 @@ if (process.argv.includes("__serve__")) {
   Bun.serve({
     port,
     hostname: host,
-    async fetch(req, server) {
+    fetch(req, server) {
       const url = new URL(req.url);
 
-      // Proxy: handle before Hono to avoid SPA catch-all conflict
-      if (url.pathname.startsWith("/proxy")) {
-        const proxyRes = await handleProxyRequest(req);
-        if (proxyRes) return proxyRes;
-      }
-
       if (url.pathname === "/ws/health") {
         const upgraded = server.upgrade(req, { data: { type: "health" } });
         if (upgraded) return undefined;

package/src/server/routes/proxy.ts

@@ -1,86 +1,79 @@
 import { Hono } from "hono";
 import { proxyService } from "../../services/proxy.service.ts";
+import { ok, err } from "../../types/api.ts";
 
 /**
  * Proxy routes — Anthropic-compatible API proxy.
- * External tools (Claude Code CLI, OpenCode, Cursor, etc.) send requests here
+ * External tools (opencode, cursor, etc.) send requests here
  * and PPM forwards them to Anthropic using account rotation.
  *
- * Mounted at /proxy — all paths are forwarded to api.anthropic.com.
+ * Mounted at /proxy — so /proxy/v1/messages maps to Anthropic's POST /v1/messages.
  * Uses its own auth (proxy auth key), NOT PPM's auth middleware.
- *
- * Usage with Claude Code CLI:
- *   ANTHROPIC_BASE_URL=http://host:port/proxy
- *   ANTHROPIC_API_KEY=<proxy-auth-key>
  */
+export const proxyRoutes = new Hono();
 
-/** Validate proxy auth key from Authorization or x-api-key header */
+/** Validate proxy auth key from Authorization header */
 function validateProxyAuth(authHeader: string | undefined): boolean {
   if (!authHeader) return false;
   const key = proxyService.getAuthKey();
   if (!key) return false;
+  // Accept both "Bearer <key>" and raw "<key>" (x-api-key style)
   const token = authHeader.startsWith("Bearer ") ? authHeader.slice(7) : authHeader;
   return token === key;
 }
 
-const CORS_HEADERS = {
-  "Access-Control-Allow-Origin": "*",
-  "Access-Control-Allow-Methods": "POST, GET, PUT, DELETE, PATCH, OPTIONS",
-  "Access-Control-Allow-Headers": "Content-Type, Authorization, x-api-key, anthropic-version, anthropic-beta",
-  "Access-Control-Max-Age": "86400",
-};
+/** CORS preflight for external tools */
+proxyRoutes.options("/*", (c) => {
+  return new Response(null, {
+    status: 204,
+    headers: {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "POST, GET, OPTIONS",
+      "Access-Control-Allow-Headers": "Content-Type, Authorization, x-api-key, anthropic-version, anthropic-beta",
+      "Access-Control-Max-Age": "86400",
+    },
+  });
+});
 
-/**
- * Standalone proxy request handler — called directly from Bun.serve fetch,
- * bypassing Hono routing to avoid SPA catch-all conflicts.
- * Returns a Response for /proxy/* requests, or null if path doesn't match.
- */
-export async function handleProxyRequest(req: Request): Promise<Response | null> {
-  const url = new URL(req.url);
-  if (!url.pathname.startsWith("/proxy/") && url.pathname !== "/proxy") return null;
+/** POST /proxy/v1/messages — Anthropic Messages API proxy */
+proxyRoutes.post("/v1/messages", async (c) => {
+  if (!proxyService.isEnabled()) {
+    return c.json({ type: "error", error: { type: "api_error", message: "Proxy is disabled" } }, 503);
+  }
 
-  // CORS preflight
-  if (req.method === "OPTIONS") {
-    return new Response(null, { status: 204, headers: CORS_HEADERS });
+  // Auth check — accept both Authorization and x-api-key headers
+  const authHeader = c.req.header("authorization") || c.req.header("x-api-key");
+  if (!validateProxyAuth(authHeader)) {
+    return c.json({ type: "error", error: { type: "authentication_error", message: "Invalid proxy auth key" } }, 401);
   }
 
+  const body = await c.req.text();
+  const headers: Record<string, string> = {};
+  for (const key of ["anthropic-version", "anthropic-beta", "content-type"]) {
+    const val = c.req.header(key);
+    if (val) headers[key] = val;
+  }
+
+  return proxyService.forward("/v1/messages", "POST", headers, body);
+});
+
+/** POST /proxy/v1/messages/count_tokens — token counting proxy */
+proxyRoutes.post("/v1/messages/count_tokens", async (c) => {
   if (!proxyService.isEnabled()) {
-    return Response.json(
-      { type: "error", error: { type: "api_error", message: "Proxy is disabled" } },
-      { status: 503, headers: { "Access-Control-Allow-Origin": "*" } },
-    );
+    return c.json({ type: "error", error: { type: "api_error", message: "Proxy is disabled" } }, 503);
   }
 
-  // Auth check
-  const authHeader = req.headers.get("authorization") || req.headers.get("x-api-key") || undefined;
+  const authHeader = c.req.header("authorization") || c.req.header("x-api-key");
   if (!validateProxyAuth(authHeader)) {
-    return Response.json(
-      { type: "error", error: { type: "authentication_error", message: "Invalid proxy auth key" } },
-      { status: 401, headers: { "Access-Control-Allow-Origin": "*" } },
-    );
+    return c.json({ type: "error", error: { type: "authentication_error", message: "Invalid proxy auth key" } }, 401);
   }
 
-  // Strip /proxy prefix to get the Anthropic API path
-  const path = url.pathname.replace(/^\/proxy/, "") || "/";
-  const method = req.method;
-
-  // Collect relevant headers to forward
+  const body = await c.req.text();
   const headers: Record<string, string> = {};
-  for (const key of ["anthropic-version", "anthropic-beta", "content-type", "accept"]) {
-    const val = req.headers.get(key);
+  for (const key of ["anthropic-version", "anthropic-beta", "content-type"]) {
+    const val = c.req.header(key);
     if (val) headers[key] = val;
   }
 
-  // Read body for methods that have one
-  const body = ["POST", "PUT", "PATCH"].includes(method) ? await req.text() : null;
-
-  return proxyService.forward(path, method, headers, body);
-}
-
-// Keep Hono sub-router for backward compat with app.route() + tests
-export const proxyRoutes = new Hono();
-proxyRoutes.all("/*", async (c) => {
-  const res = await handleProxyRequest(c.req.raw);
-  if (res) return res;
-  return c.notFound();
+  return proxyService.forward("/v1/messages/count_tokens", "POST", headers, body);
 });