@hienlh/ppm 0.9.68 → 0.9.69

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [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.69",
   "description": "Personal Project Manager — mobile-first web IDE with AI assistance",
   "author": "hienlh",
   "license": "MIT",

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

@@ -710,16 +710,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 +728,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 +770,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 +819,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 +863,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 +890,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 +1042,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 +1093,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 +1193,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 +1225,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);

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 ───────────────────────────────────────