@hienlh/ppm 0.9.68 → 0.9.70

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [0.9.70] - 2026-04-09
+
+### Fixed
+- **SDK subprocess crash on resume**: Resumed sessions with existing JSONL files would crash (exit code 1) because `--session-id` was used instead of `--resume`. Now always uses `--resume` for resumed sessions.
+- **Session lookup**: Use targeted `getSessionInfo()` with correct project dir instead of listing all sessions.
+- **SDK stderr capture**: Subprocess stderr is now logged on crash for diagnostics.
+- **Thinking budget option**: Fixed `thinkingBudgetTokens` → `maxThinkingTokens` (correct SDK option name).
+
+## [0.9.69] - 2026-04-09
+
+### Fixed
+- **Cloud WS replaced loop**: `isConnected()` now returns true during 500ms auth handshake, preventing Cloud monitor from killing valid connections. Fixed `disconnect()` not resetting `reconnecting` flag.
+- **Token refresh buffer**: Increased OAuth token refresh buffer from 60s to 1 hour to prevent 401 errors mid-conversation.
+- **SDK retry stale closures**: Extracted `closeCurrentStream()` helper that reads from session map instead of captured variables, preventing retry paths from closing already-replaced streams. Fixed phantom session entries from retry init events.
+
 ## [0.9.68] - 2026-04-08
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hienlh/ppm",
-  "version": "0.9.68",
+  "version": "0.9.70",
   "description": "Personal Project Manager — mobile-first web IDE with AI assistance",
   "author": "hienlh",
   "license": "MIT",

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

@@ -280,18 +280,33 @@ export class ClaudeAgentSdkProvider implements AIProvider {
     // Restore project_path from DB so resumed sessions can find JSONL
     const dbProjectPath = getSessionProjectPath(sessionId) ?? undefined;
 
+    // Try targeted lookup first (searches all project dirs), then fall back to list scan
     try {
-      const sdkSessions = await sdkListSessions({ limit: 100 });
-      const found = sdkSessions.find(
-        (s) => s.sessionId === sessionId || s.sessionId === mappedSdkId,
-      );
-      if (found) {
+      const lookupId = mappedSdkId ?? sessionId;
+      const info = await sdkGetSessionInfo(lookupId, { dir: dbProjectPath });
+      if (!info && mappedSdkId) {
+        // Try the original PPM session ID as well
+        const info2 = await sdkGetSessionInfo(sessionId, { dir: dbProjectPath });
+        if (info2) {
+          const meta: Session = {
+            id: sessionId,
+            providerId: this.id,
+            title: info2.customTitle ?? info2.summary ?? "Resumed Chat",
+            projectPath: dbProjectPath,
+            createdAt: new Date(info2.lastModified).toISOString(),
+          };
+          this.activeSessions.set(sessionId, meta);
+          this.messageCount.set(sessionId, 1);
+          return meta;
+        }
+      }
+      if (info) {
         const meta: Session = {
           id: sessionId,
           providerId: this.id,
-          title: found.customTitle ?? found.summary ?? "Resumed Chat",
+          title: info.customTitle ?? info.summary ?? "Resumed Chat",
           projectPath: dbProjectPath,
-          createdAt: new Date(found.lastModified).toISOString(),
+          createdAt: new Date(info.lastModified).toISOString(),
         };
         this.activeSessions.set(sessionId, meta);
         this.messageCount.set(sessionId, 1);
@@ -301,8 +316,11 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       // SDK not available
     }
 
-    // Session not found in SDK history — treat as new so first message
-    // creates a fresh SDK session instead of trying to resume.
+    // Session not found in SDK list — it may still have a JSONL on disk
+    // (sdkListSessions may not search the correct project directory).
+    // Use messageCount=1 so sendMessage uses --resume instead of --session-id.
+    // --resume gracefully fails if no JSONL exists, while --session-id crashes
+    // when a JSONL file for the same ID is already present on disk.
     const meta: Session = {
       id: sessionId,
       providerId: this.id,
@@ -311,7 +329,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       createdAt: new Date().toISOString(),
     };
     this.activeSessions.set(sessionId, meta);
-    this.messageCount.set(sessionId, 0);
+    this.messageCount.set(sessionId, 1);
     return meta;
   }
 
@@ -677,6 +695,14 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       const mcpServers = mcpConfigService.list();
       const hasMcp = Object.keys(mcpServers).length > 0;
 
+      // Buffer subprocess stderr for crash diagnostics
+      let stderrBuffer = "";
+      const stderrCallback = (chunk: string) => {
+        stderrBuffer += chunk;
+        // Keep only last 2KB to avoid unbounded growth
+        if (stderrBuffer.length > 2048) stderrBuffer = stderrBuffer.slice(-2048);
+      };
+
       const queryOptions: Record<string, any> = {
         // On Windows, child_process.spawn("bun") fails with ENOENT — force node
         ...(process.platform === "win32" && { executable: "node" }),
@@ -697,9 +723,10 @@ export class ClaudeAgentSdkProvider implements AIProvider {
         maxTurns: providerConfig.max_turns ?? 1000,
         ...(providerConfig.max_budget_usd && { maxBudgetUsd: providerConfig.max_budget_usd }),
         ...(providerConfig.thinking_budget_tokens != null && {
-          thinkingBudgetTokens: providerConfig.thinking_budget_tokens,
+          maxThinkingTokens: providerConfig.thinking_budget_tokens,
         }),
         includePartialMessages: true,
+        stderr: stderrCallback,
       };
 
       // Crash retry: if subprocess exits with non-zero code before producing events,
@@ -710,16 +737,17 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       crashRetryLoop: for (;;) {
       try {
       // Streaming input: create message channel and persistent query
-      const { generator: streamGen, controller: streamCtrl } = createMessageChannel();
       const firstMsg = {
         type: 'user' as const,
         message: buildMessageParam(message),
         parent_tool_use_id: null,
         session_id: sessionId,
       };
-      streamCtrl.push(firstMsg);
 
-      const q = query({
+      const { generator: streamGen, controller: initialCtrl } = createMessageChannel();
+      initialCtrl.push(firstMsg);
+
+      const initialQuery = query({
         prompt: streamGen,
         options: {
           ...queryOptions,
@@ -727,9 +755,19 @@ export class ClaudeAgentSdkProvider implements AIProvider {
           canUseTool,
         } as any,
       });
-      this.streamingSessions.set(sessionId, { meta, query: q, controller: streamCtrl });
-      this.activeQueries.set(sessionId, q);
-      let eventSource: AsyncIterable<any> = q;
+      this.streamingSessions.set(sessionId, { meta, query: initialQuery, controller: initialCtrl });
+      this.activeQueries.set(sessionId, initialQuery);
+      let eventSource: AsyncIterable<any> = initialQuery;
+
+      // Helper: close the CURRENT streaming session (not stale closure refs).
+      // All retry paths must use this instead of closing captured variables directly.
+      const closeCurrentStream = () => {
+        const ss = this.streamingSessions.get(sessionId);
+        if (ss) {
+          ss.controller.done();
+          ss.query.close();
+        }
+      };
 
       let lastPartialText = "";
       /** Number of tool_use blocks pending results (top-level tools only, not subagent children) */
@@ -759,9 +797,8 @@ export class ClaudeAgentSdkProvider implements AIProvider {
           if ((msg as any).type === "result" && (msg as any).subtype === "error_during_execution" && ((msg as any).num_turns ?? 0) === 0 && retryCount < MAX_RETRIES) {
             retryCount++;
             console.warn(`[sdk] transient error on first event — retrying (attempt ${retryCount}/${MAX_RETRIES})`);
-            // Close failed query and old channel, create new channel + query for retry
-            streamCtrl.done();
-            q.close();
+            // Close current streaming session (uses streamingSessions, not stale closure refs)
+            closeCurrentStream();
             const { generator: retryGen, controller: retryCtrl } = createMessageChannel();
             retryCtrl.push(firstMsg);
             const retryOpts = { ...queryOptions, sessionId: undefined, resume: undefined };
@@ -809,9 +846,13 @@ export class ClaudeAgentSdkProvider implements AIProvider {
               } else {
                 console.log(`[sdk] session=${sessionId} ignoring retry init sdk_id=${initMsg.session_id} (mapping already set)`);
               }
-              const oldMeta = this.activeSessions.get(sessionId);
-              if (oldMeta) {
-                this.activeSessions.set(initMsg.session_id, { ...oldMeta, id: initMsg.session_id });
+              // Only create activeSessions alias for first-time SDK id mapping.
+              // Retry init events create phantom entries that pollute the map.
+              if (isFirstMessage) {
+                const oldMeta = this.activeSessions.get(sessionId);
+                if (oldMeta) {
+                  this.activeSessions.set(initMsg.session_id, { ...oldMeta, id: initMsg.session_id });
+                }
               }
             }
           }
@@ -849,8 +890,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
                 console.log(`[sdk] session=${sessionId} intercepted api_retry 401 — refreshing token for ${account.id} (${label})`);
                 yield { type: "account_retry" as const, reason: "Token refreshed", accountId: refreshedAccount.id, accountLabel: label };
                 const retryEnv = this.buildQueryEnv(meta.projectPath, refreshedAccount);
-                streamCtrl.done();
-                q.close();
+                closeCurrentStream();
                 const { generator: earlyAuthGen, controller: earlyAuthCtrl } = createMessageChannel();
                 const currentSdkId = getSessionMapping(sessionId);
                 const canResume = !!currentSdkId;
@@ -877,8 +917,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
                 console.log(`[sdk] session=${sessionId} refresh failed — switching to ${nextAcc.id} (${label})`);
                 yield { type: "account_retry" as const, reason: "Switching account", accountId: nextAcc.id, accountLabel: label };
                 const switchEnv = this.buildQueryEnv(meta.projectPath, nextAcc);
-                streamCtrl.done();
-                q.close();
+                closeCurrentStream();
                 const { generator: switchGen, controller: switchCtrl } = createMessageChannel();
                 const currentSdkId = getSessionMapping(sessionId);
                 const canResume = !!currentSdkId;
@@ -1030,8 +1069,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
                   // Re-resolve sdkId: the init event may have mapped ppmId → real SDK session_id
                   // after sdkId was originally resolved. Using the stale value would try to
                   // resume a non-existent session, causing the SDK to hang forever.
-                  streamCtrl.done();
-                  q.close();
+                  closeCurrentStream();
                   const { generator: authRetryGen, controller: authRetryCtrl } = createMessageChannel();
                   const currentSdkId = getSessionMapping(sessionId);
                   const canResume = !!currentSdkId;
@@ -1082,10 +1120,9 @@ export class ClaudeAgentSdkProvider implements AIProvider {
               }
               yield { type: "error", message: `Rate limited. Auto-retrying in ${backoff / 1000}s... (${rateLimitRetryCount}/${MAX_RATE_LIMIT_RETRIES})` };
               await new Promise((r) => setTimeout(r, backoff));
-              // Close failed query and recreate with (potentially new) account env.
+              // Close current streaming session and recreate with (potentially new) account env.
               // Re-resolve sdkId to pick up init-event mapping (see auth retry comment).
-              streamCtrl.done();
-              q.close();
+              closeCurrentStream();
               const rlRetryEnv = this.buildQueryEnv(meta.projectPath, account);
               const { generator: rlRetryGen, controller: rlRetryCtrl } = createMessageChannel();
               const rlCurrentSdkId = getSessionMapping(sessionId);
@@ -1183,8 +1220,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
                 yield { type: "error", message: `Rate limited. Auto-retrying in ${backoff / 1000}s... (${rateLimitRetryCount}/${MAX_RATE_LIMIT_RETRIES})` };
                 await new Promise((r) => setTimeout(r, backoff));
                 // Re-resolve sdkId to pick up init-event mapping (see auth retry comment).
-                streamCtrl.done();
-                q.close();
+                closeCurrentStream();
                 const rlRetryEnv = this.buildQueryEnv(meta.projectPath, account);
                 const { generator: rlRetryGen, controller: rlRetryCtrl } = createMessageChannel();
                 const rlCurrentSdkId2 = getSessionMapping(sessionId);
@@ -1216,8 +1252,7 @@ export class ClaudeAgentSdkProvider implements AIProvider {
                     console.log(`[sdk] 401 in result on account ${account.id} (${label}) — token refreshed, retrying`);
                     yield { type: "account_retry" as const, reason: "Token refreshed", accountId: refreshedAccount.id, accountLabel: label };
                     // Re-resolve sdkId to pick up init-event mapping (see auth retry comment).
-                    streamCtrl.done();
-                    q.close();
+                    closeCurrentStream();
                     const retryEnv = this.buildQueryEnv(meta.projectPath, refreshedAccount);
                     const { generator: authRetryGen2, controller: authRetryCtrl2 } = createMessageChannel();
                     const authCurrentSdkId2 = getSessionMapping(sessionId);
@@ -1383,7 +1418,8 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       break crashRetryLoop; // Normal completion — exit crash retry loop
     } catch (crashErr) {
       const crashMsg = (crashErr as Error).message ?? String(crashErr);
-      console.error(`[sdk] session=${sessionId} cwd=${meta.projectPath} error: ${crashMsg}`);
+      const stderrInfo = stderrBuffer.trim() ? ` stderr: ${stderrBuffer.trim().slice(-500)}` : "";
+      console.error(`[sdk] session=${sessionId} cwd=${meta.projectPath} error: ${crashMsg}${stderrInfo}`);
 
       // Clean up crashed subprocess before retry or error
       this.activeQueries.delete(sessionId);
@@ -1396,12 +1432,14 @@ export class ClaudeAgentSdkProvider implements AIProvider {
       } else if (crashMsg.includes("exited with code") && crashRetryCount < MAX_CRASH_RETRIES) {
         // Subprocess crashed — auto-retry once before surfacing the error
         crashRetryCount++;
-        console.warn(`[sdk] session=${sessionId} subprocess crashed: ${crashMsg} — auto-retrying (attempt ${crashRetryCount}/${MAX_CRASH_RETRIES})`);
+        console.warn(`[sdk] session=${sessionId} subprocess crashed: ${crashMsg} — auto-retrying (attempt ${crashRetryCount}/${MAX_CRASH_RETRIES})${stderrInfo}`);
+        stderrBuffer = ""; // Reset for retry
         await new Promise((r) => setTimeout(r, 1000));
         continue crashRetryLoop;
       } else if (crashMsg.includes("exited with code")) {
-        console.warn(`[sdk] session=${sessionId} subprocess crashed after retry: ${crashMsg}`);
-        yield { type: "error", message: `SDK subprocess crashed. Send another message to auto-recover.` };
+        console.warn(`[sdk] session=${sessionId} subprocess crashed after retry: ${crashMsg}${stderrInfo}`);
+        const userHint = stderrInfo ? ` (${stderrBuffer.trim().slice(-200)})` : "";
+        yield { type: "error", message: `SDK subprocess crashed.${userHint} Send another message to auto-recover.` };
       } else {
         yield { type: "error", message: `SDK error: ${crashMsg}` };
       }

package/src/services/account.service.ts

@@ -125,7 +125,9 @@ class AccountService {
 
   /**
    * Ensure the access token for an OAuth account is still fresh.
-   * If it's expired or about to expire (within 60s), refresh it proactively.
+   * If it's expired or about to expire (within 1 hour), refresh it proactively.
+   * The generous buffer prevents 401 errors mid-conversation — the SDK subprocess
+   * may run for a long time before the token is actually sent to the API.
    * Returns the refreshed account with fresh tokens, or null if refresh failed.
    */
   async ensureFreshToken(id: string): Promise<AccountWithTokens | null> {
@@ -135,9 +137,10 @@ class AccountService {
     if (!acc.accessToken.startsWith("sk-ant-oat")) return acc;
     if (!acc.expiresAt) return acc;
     const nowS = Math.floor(Date.now() / 1000);
-    if (acc.expiresAt - nowS > 60) return acc; // still fresh
+    const REFRESH_BUFFER_S = 3600; // 1 hour — refresh proactively before expiry
+    if (acc.expiresAt - nowS > REFRESH_BUFFER_S) return acc; // still fresh
     try {
-      console.log(`[accounts] Pre-flight refresh for ${acc.email ?? id} (expires in ${acc.expiresAt - nowS}s)`);
+      console.log(`[accounts] Pre-flight refresh for ${acc.email ?? id} (expires in ${acc.expiresAt - nowS}s, buffer=${REFRESH_BUFFER_S}s)`);
       await this.refreshAccessToken(id, false);
       return this.getWithTokens(id);
     } catch (e) {

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

@@ -99,6 +99,7 @@ export function connect(opts: {
 
 export function disconnect(): void {
   shouldConnect = false;
+  reconnecting = false; // prevent stale flag from blocking future doConnect()
   if (reconnectTimer) { clearTimeout(reconnectTimer); reconnectTimer = null; }
   if (heartbeatTimer) { clearInterval(heartbeatTimer); heartbeatTimer = null; }
   if (ws) {
@@ -122,8 +123,12 @@ export function onCommand(handler: CommandHandler): void {
   commandHandler = handler;
 }
 
+/** Returns true if WS is authenticated and ready, or still in auth handshake */
 export function isConnected(): boolean {
-  return connected;
+  // Also treat "connecting/open but auth pending" as connected to prevent
+  // external monitors from killing a valid WS during the 500ms auth delay.
+  if (connected) return true;
+  return ws !== null && ws.readyState <= WebSocket.OPEN;
 }
 
 // ─── Internal ───────────────────────────────────────