lody 0.45.0 → 0.45.1

package/dist/index.js

@@ -36820,7 +36820,7 @@ Mongoose Error Code: ${error2.code}` : ""}`
     return client;
   }
   const name = "lody";
-  const version$4 = "0.45.0";
+  const version$4 = "0.45.1";
   const description = "Lody Agent CLI tool for managing remote command execution";
   const type = "module";
   const main$3 = "dist/index.js";
@@ -113879,6 +113879,34 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
     async waitForRemoteSync() {
       await this.remoteSyncReady;
     }
+    async ensureDocRoomJoined() {
+      if (this.destroyed) {
+        return;
+      }
+      if (!this.docSub) {
+        this.remoteSyncReady = this.startDocRoomSync();
+      }
+      await this.remoteSyncReady;
+    }
+    getDocRoomStatus() {
+      return this.docSub?.status;
+    }
+    onDocRoomStatusChange(listener) {
+      return this.docSub?.onStatusChange(listener) ?? (() => {
+      });
+    }
+    async rejoinDocRoom() {
+      if (this.destroyed) {
+        return;
+      }
+      if (!this.docSub) {
+        await this.ensureDocRoomJoined();
+        return;
+      }
+      if (this.docSub.rejoin) {
+        await this.docSub.rejoin();
+      }
+    }
     async initOffline(initialState) {
       this.destroyed = false;
       this.handle = await this.repo.openPersistedDoc(this.roomId);
@@ -121853,9 +121881,6 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
     watchedSessions = /* @__PURE__ */ new Map();
     sessionCheckChains = /* @__PURE__ */ new Map();
     cancelCheckChains = /* @__PURE__ */ new Map();
-    dispatchRetryTimers = /* @__PURE__ */ new Map();
-    dispatchRetryAttempts = /* @__PURE__ */ new Map();
-    dispatchRetryStartedAt = /* @__PURE__ */ new Map();
     cancelSeenTurn = /* @__PURE__ */ new Map();
     metadataWatchHandle = null;
     userResolver;
@@ -121899,15 +121924,9 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       for (const watched of this.watchedSessions.values()) {
         watched.unsubscribe();
       }
-      for (const timer2 of this.dispatchRetryTimers.values()) {
-        clearTimeout(timer2);
-      }
       this.watchedSessions.clear();
       this.sessionCheckChains.clear();
       this.cancelCheckChains.clear();
-      this.dispatchRetryTimers.clear();
-      this.dispatchRetryAttempts.clear();
-      this.dispatchRetryStartedAt.clear();
       this.cancelSeenTurn.clear();
       this.userResolver.clear();
       this.started = false;
@@ -121983,14 +122002,15 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       }));
     }
     async reconcileSessionWatch(sessionId) {
-      const meta = await this.readSessionMeta(sessionId);
+      const roomId = getSessionRoomId(sessionId);
+      const record2 = await this.deps.workspaceDocument.repo.getDocMeta(roomId);
+      const meta = isLoroRepoDocDeleted(record2) ? void 0 : record2?.meta;
       const isOwned = meta?.machineId === this.deps.machineId && !meta?.isArchived;
       if (!isOwned) {
         const watched = this.watchedSessions.get(sessionId);
         watched?.unsubscribe();
         this.watchedSessions.delete(sessionId);
         this.cancelCheckChains.delete(sessionId);
-        this.clearDispatchRetry(sessionId);
         this.cancelSeenTurn.delete(sessionId);
         return;
       }
@@ -122001,7 +122021,6 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
           this.watchedSessions.delete(sessionId);
           this.deps.logger.debug(`[${sessionId}] Unwatching idle session (no pending work)`);
         }
-        this.clearDispatchRetry(sessionId);
         return;
       }
       if (!this.watchedSessions.has(sessionId)) {
@@ -122018,11 +122037,6 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       this.enqueueCancelCheck(sessionId);
       this.enqueueSessionCheck(sessionId);
     }
-    async readSessionMeta(sessionId) {
-      const roomId = getSessionRoomId(sessionId);
-      const record2 = await this.deps.workspaceDocument.repo.getDocMeta(roomId);
-      return isLoroRepoDocDeleted(record2) ? void 0 : record2?.meta;
-    }
     sessionNeedsActiveWatch(meta) {
       const statusType = meta.status?.type;
       if (statusType === "running" || statusType === "initializing" || statusType === "requestPermission") {
@@ -122037,7 +122051,7 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       if (meta.lastCanceledTurn && meta.lastCanceledTurn !== this.cancelSeenTurn.get(meta.id)) {
         return true;
       }
-      if (this.isDispatchRecoveryUnhealthy(meta)) {
+      if (meta.dispatchError?.code === SessionDispatchWatcher.DISPATCH_HISTORY_SYNC_TIMEOUT_CODE) {
         return false;
       }
       if (!meta.lastHandledUserMsgId) {
@@ -122045,147 +122059,6 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       }
       return false;
     }
-    static RECOVERABLE_DISPATCH_RETRY_INITIAL_DELAY_MS = 1e3;
-    static RECOVERABLE_DISPATCH_RETRY_MAX_DELAY_MS = 6e4;
-    static RECOVERABLE_DISPATCH_RETRY_MAX_ELAPSED_MS = 5 * 6e4;
-    static DISPATCH_RECOVERY_UNHEALTHY_CODE = "dispatch_recovery_unhealthy";
-    hasRecoverableDispatchSignal(meta) {
-      const statusType = meta.status?.type;
-      if (statusType === "running" || statusType === "initializing" || statusType === "requestPermission") {
-        return true;
-      }
-      if (meta.processingUserMsgId) {
-        return true;
-      }
-      return !!meta.latestUserMsgId && meta.latestUserMsgId !== meta.lastHandledUserMsgId;
-    }
-    isDispatchRecoveryUnhealthy(meta) {
-      return meta.dispatchError?.code === SessionDispatchWatcher.DISPATCH_RECOVERY_UNHEALTHY_CODE;
-    }
-    clearDispatchRetry(sessionId) {
-      const timer2 = this.dispatchRetryTimers.get(sessionId);
-      if (timer2) {
-        clearTimeout(timer2);
-        this.dispatchRetryTimers.delete(sessionId);
-      }
-      this.dispatchRetryAttempts.delete(sessionId);
-      this.dispatchRetryStartedAt.delete(sessionId);
-    }
-    scheduleRecoverableDispatchRetry(sessionId, meta) {
-      if (!this.hasRecoverableDispatchSignal(meta)) {
-        this.clearDispatchRetry(sessionId);
-        return;
-      }
-      if (this.dispatchRetryTimers.has(sessionId)) {
-        return;
-      }
-      const startedAt = this.dispatchRetryStartedAt.get(sessionId) ?? Date.now();
-      this.dispatchRetryStartedAt.set(sessionId, startedAt);
-      const elapsedMs = Date.now() - startedAt;
-      if (elapsedMs >= SessionDispatchWatcher.RECOVERABLE_DISPATCH_RETRY_MAX_ELAPSED_MS) {
-        void this.markDispatchRecoveryUnhealthy(sessionId, meta, elapsedMs).catch((error2) => {
-          this.deps.logger.error(`[${sessionId}] Failed to mark dispatch recovery unhealthy: ${formatErrorMessage(error2)}`);
-        });
-        return;
-      }
-      const attempt = this.dispatchRetryAttempts.get(sessionId) ?? 0;
-      const delayMs = this.calculateRecoverableDispatchRetryDelay(attempt);
-      const attemptNumber = attempt + 1;
-      this.dispatchRetryAttempts.set(sessionId, attemptNumber);
-      this.deps.logger.debug(`[${sessionId}] Dispatch metadata is present but no user turn is visible; rebuilding session doc watch in ${delayMs}ms (attempt=${attemptNumber}, elapsedMs=${elapsedMs})`);
-      const timer2 = setTimeout(() => {
-        this.dispatchRetryTimers.delete(sessionId);
-        if (!this.started) {
-          return;
-        }
-        this.refreshSessionDocWatch(sessionId, `recoverable-dispatch-missing-turn:${attemptNumber}`).catch((error2) => {
-          void this.handleDispatchRetryRefreshFailure(sessionId, meta, error2);
-        });
-      }, delayMs);
-      const maybeUnrefTimer = timer2;
-      maybeUnrefTimer.unref?.();
-      this.dispatchRetryTimers.set(sessionId, timer2);
-    }
-    calculateRecoverableDispatchRetryDelay(attempt) {
-      const exponentialDelayMs = Math.min(SessionDispatchWatcher.RECOVERABLE_DISPATCH_RETRY_INITIAL_DELAY_MS * 2 ** attempt, SessionDispatchWatcher.RECOVERABLE_DISPATCH_RETRY_MAX_DELAY_MS);
-      const halfDelayMs = exponentialDelayMs / 2;
-      return Math.floor(halfDelayMs + Math.random() * halfDelayMs);
-    }
-    async handleDispatchRetryRefreshFailure(sessionId, previousMeta, error2) {
-      this.deps.logger.error(`[${sessionId}] Failed to refresh session doc watch for dispatch retry: ${formatErrorMessage(error2)}`);
-      if (!this.started) {
-        return;
-      }
-      let meta = previousMeta;
-      try {
-        const freshMeta = await this.readSessionMeta(sessionId);
-        if (!freshMeta) {
-          this.clearDispatchRetry(sessionId);
-          return;
-        }
-        meta = freshMeta;
-      } catch (metaError) {
-        this.deps.logger.debug(`[${sessionId}] Failed to read fresh metadata after dispatch retry refresh failure; using previous retry signal: ${formatErrorMessage(metaError)}`);
-      }
-      if (!this.started) {
-        return;
-      }
-      if (meta.machineId !== this.deps.machineId || meta.isArchived) {
-        this.clearDispatchRetry(sessionId);
-        return;
-      }
-      this.scheduleRecoverableDispatchRetry(sessionId, meta);
-    }
-    async markDispatchRecoveryUnhealthy(sessionId, previousMeta, elapsedMs) {
-      this.clearDispatchRetry(sessionId);
-      if (!this.started) {
-        return;
-      }
-      let meta = previousMeta;
-      try {
-        const freshMeta = await this.readSessionMeta(sessionId);
-        if (!freshMeta) {
-          return;
-        }
-        meta = freshMeta;
-      } catch (error2) {
-        this.deps.logger.debug(`[${sessionId}] Failed to read fresh metadata before marking dispatch recovery unhealthy; using previous retry signal: ${formatErrorMessage(error2)}`);
-      }
-      if (!this.hasRecoverableDispatchSignal(meta) || meta.machineId !== this.deps.machineId || meta.isArchived) {
-        return;
-      }
-      this.deps.logger.warn(`[${sessionId}] Dispatch recovery could not find a user turn after ${elapsedMs}ms; marking recovery unhealthy`);
-      await this.deps.workspaceDocument.repo.upsertDocMeta?.(getSessionRoomId(sessionId), {
-        status: SessionStatusFactory.idle(),
-        latestUserMsgId: void 0,
-        processingUserMsgId: void 0,
-        dispatchError: {
-          code: SessionDispatchWatcher.DISPATCH_RECOVERY_UNHEALTHY_CODE,
-          message: "Dispatch recovery could not reconnect to this session after 5 minutes. Send a new message to retry.",
-          at: getServerNow()
-        }
-      });
-      const watched = this.watchedSessions.get(sessionId);
-      watched?.unsubscribe();
-      this.watchedSessions.delete(sessionId);
-      this.sessionCheckChains.delete(sessionId);
-      await this.deps.workspaceDocument.cleanSessionDoc(sessionId, {
-        preserveStatus: true
-      });
-    }
-    async refreshSessionDocWatch(sessionId, reason) {
-      const watched = this.watchedSessions.get(sessionId);
-      watched?.unsubscribe();
-      this.watchedSessions.delete(sessionId);
-      this.deps.logger.debug(`[${sessionId}] Refreshing session doc watch (${reason})`);
-      await this.deps.workspaceDocument.cleanSessionDoc(sessionId, {
-        preserveStatus: true
-      });
-      if (!this.started) {
-        return;
-      }
-      await this.reconcileSessionWatch(sessionId);
-    }
     async maybeHandleSession(sessionId) {
       const sessionDoc = await this.deps.workspaceDocument.getOrCreateSessionDoc(sessionId);
       const meta = await sessionDoc.getMetaState();
@@ -122208,10 +122081,11 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       }
       const nextUserTurn = await this.findOrAwaitDispatchableTurn(sessionId, sessionDoc, meta);
       if (!nextUserTurn) {
-        this.scheduleRecoverableDispatchRetry(sessionId, meta);
+        if (this.hasPendingUserTurnSignal(meta)) {
+          await this.markMissingUserTurnRecovery(sessionId, meta);
+        }
         return;
       }
-      this.clearDispatchRetry(sessionId);
       const freshMeta = await sessionDoc.getMetaState();
       if (!freshMeta) {
         return;
@@ -122407,6 +122281,27 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
     }
     static REALTIME_WAIT_TIMEOUT_MS = 3e4;
     static REMOTE_SYNC_TIMEOUT_MS = 15e3;
+    static HISTORY_SYNC_WAIT_TIMEOUT_MS = 5 * 6e4;
+    static HISTORY_RECONNECT_JITTER_MIN_MS = 500;
+    static HISTORY_RECONNECT_JITTER_MAX_MS = 1500;
+    static DISPATCH_HISTORY_SYNC_TIMEOUT_CODE = "dispatch_recovery_unhealthy";
+    static setUnrefTimeout(callback, delayMs) {
+      const timer2 = setTimeout(callback, delayMs);
+      if (typeof timer2 === "object" && "unref" in timer2) {
+        timer2.unref();
+      }
+      return timer2;
+    }
+    static sleep(delayMs) {
+      return new Promise((resolve2) => {
+        SessionDispatchWatcher.setUnrefTimeout(resolve2, delayMs);
+      });
+    }
+    static getReconnectJitterMs() {
+      const min2 = SessionDispatchWatcher.HISTORY_RECONNECT_JITTER_MIN_MS;
+      const max2 = SessionDispatchWatcher.HISTORY_RECONNECT_JITTER_MAX_MS;
+      return min2 + Math.floor(Math.random() * (max2 - min2 + 1));
+    }
     async findOrAwaitDispatchableTurn(sessionId, sessionDoc, meta) {
       const history = await sessionDoc.getHistory();
       let turn = findNextDispatchableUserTurn(history, meta);
@@ -122417,9 +122312,12 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       if (turn) {
         return turn;
       }
+      if (this.hasPendingUserTurnSignal(meta)) {
+        return await this.waitForPendingUserTurnHistorySync(sessionId, sessionDoc, meta);
+      }
       await Promise.race([
         sessionDoc.waitForRemoteSync(),
-        new Promise((resolve2) => setTimeout(resolve2, SessionDispatchWatcher.REMOTE_SYNC_TIMEOUT_MS))
+        new Promise((resolve2) => SessionDispatchWatcher.setUnrefTimeout(resolve2, SessionDispatchWatcher.REMOTE_SYNC_TIMEOUT_MS))
       ]);
       turn = await this.checkHistoryAndQueue(sessionDoc, meta);
       if (turn) {
@@ -122429,6 +122327,142 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       turn = await this.waitForDispatchableTurnFromMirror(sessionId, sessionDoc, meta);
       return turn;
     }
+    hasPendingUserTurnSignal(meta) {
+      if (meta.processingUserMsgId) {
+        return true;
+      }
+      return Boolean(meta.latestUserMsgId && meta.latestUserMsgId !== meta.lastHandledUserMsgId);
+    }
+    async waitForPendingUserTurnHistorySync(sessionId, sessionDoc, meta) {
+      this.deps.logger.debug(`[${sessionId}] Pending user turn metadata is visible but history is missing it; waiting up to ${SessionDispatchWatcher.HISTORY_SYNC_WAIT_TIMEOUT_MS / 1e3}s for history CRDT sync`);
+      try {
+        await sessionDoc.ensureDocRoomJoined();
+      } catch (error2) {
+        this.deps.logger.debug(`[${sessionId}] Failed to ensure session history room is joined before waiting: ${formatErrorMessage(error2)}`);
+      }
+      await sessionDoc.waitUntilSynced();
+      const freshMeta = await sessionDoc.getMetaState() ?? meta;
+      if (!this.hasPendingUserTurnSignal(freshMeta)) {
+        this.deps.logger.debug(`[${sessionId}] Pending user turn pointer cleared during pre-wait sync; exiting wait`);
+        return null;
+      }
+      const turnAfterJoin = await this.checkHistoryAndQueue(sessionDoc, freshMeta);
+      if (turnAfterJoin) {
+        return turnAfterJoin;
+      }
+      return await new Promise((resolve2) => {
+        let settled = false;
+        let reconnectAttempted = false;
+        let unsubscribeMirror;
+        let unsubscribeStatus;
+        const cleanup = () => {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          clearTimeout(timer2);
+          unsubscribeMirror?.();
+          unsubscribeStatus?.();
+        };
+        const checkForTurn = () => {
+          if (settled) {
+            return;
+          }
+          void this.checkHistoryAndQueue(sessionDoc, freshMeta).then((turn) => {
+            if (settled || !turn) {
+              return;
+            }
+            cleanup();
+            this.deps.logger.debug(`[${sessionId}] Found dispatchable turn after waiting for history CRDT sync`);
+            resolve2(turn);
+          }).catch((error2) => {
+            if (settled) {
+              return;
+            }
+            this.deps.logger.debug(`[${sessionId}] Error checking history during history sync wait: ${formatErrorMessage(error2)}`);
+          });
+        };
+        const attemptReconnectOnce = (reason) => {
+          if (settled || reconnectAttempted) {
+            return;
+          }
+          reconnectAttempted = true;
+          void (async () => {
+            const jitterMs = SessionDispatchWatcher.getReconnectJitterMs();
+            this.deps.logger.debug(`[${sessionId}] Session history room ${reason}; attempting one rejoin in ${jitterMs}ms`);
+            await SessionDispatchWatcher.sleep(jitterMs);
+            if (settled) {
+              return;
+            }
+            try {
+              await sessionDoc.rejoinDocRoom();
+            } catch (error2) {
+              this.deps.logger.debug(`[${sessionId}] Session history room rejoin failed: ${formatErrorMessage(error2)}`);
+            }
+            checkForTurn();
+          })();
+        };
+        const handleRoomStatus = (status) => {
+          if (settled || !status) {
+            return;
+          }
+          if (status === "disconnected" || status === "error") {
+            attemptReconnectOnce(status);
+          }
+        };
+        const timer2 = SessionDispatchWatcher.setUnrefTimeout(() => {
+          cleanup();
+          this.deps.logger.warn(`[${sessionId}] User turn did not arrive in history after ${SessionDispatchWatcher.HISTORY_SYNC_WAIT_TIMEOUT_MS / 1e3}s; entering dispatch recovery`);
+          resolve2(null);
+        }, SessionDispatchWatcher.HISTORY_SYNC_WAIT_TIMEOUT_MS);
+        unsubscribeMirror = sessionDoc.mirror?.subscribe(checkForTurn);
+        if (!unsubscribeMirror) {
+          this.deps.logger.debug(`[${sessionId}] Session mirror is unavailable during history sync wait`);
+        }
+        unsubscribeStatus = sessionDoc.onDocRoomStatusChange(handleRoomStatus);
+        const currentStatus = sessionDoc.getDocRoomStatus();
+        if (currentStatus) {
+          handleRoomStatus(currentStatus);
+        } else {
+          attemptReconnectOnce("has no active subscription");
+        }
+      });
+    }
+    async markMissingUserTurnRecovery(sessionId, previousMeta) {
+      const roomId = getSessionRoomId(sessionId);
+      let meta = previousMeta;
+      try {
+        const record2 = await this.deps.workspaceDocument.repo.getDocMeta(roomId);
+        if (!isLoroRepoDocDeleted(record2) && record2?.meta) {
+          meta = record2.meta;
+        }
+      } catch (error2) {
+        this.deps.logger.debug(`[${sessionId}] Failed to refresh metadata before dispatch recovery: ${formatErrorMessage(error2)}`);
+      }
+      if (meta.machineId !== this.deps.machineId || meta.isArchived || !this.hasPendingUserTurnSignal(meta)) {
+        return;
+      }
+      const pendingUserMsgId = meta.processingUserMsgId ?? meta.latestUserMsgId ?? meta.lastHandledUserMsgId;
+      const recoveryPatch = {
+        status: SessionStatusFactory.idle(),
+        dispatchError: {
+          code: SessionDispatchWatcher.DISPATCH_HISTORY_SYNC_TIMEOUT_CODE,
+          message: "Dispatch recovery could not reconnect to this session after 5 minutes. Send a new message to retry.",
+          at: getServerNow()
+        }
+      };
+      if (pendingUserMsgId) {
+        recoveryPatch.lastHandledUserMsgId = pendingUserMsgId;
+        recoveryPatch.latestUserMsgId = pendingUserMsgId;
+      }
+      await this.deps.workspaceDocument.repo.upsertDocMeta?.(roomId, recoveryPatch);
+      const watched = this.watchedSessions.get(sessionId);
+      watched?.unsubscribe();
+      this.watchedSessions.delete(sessionId);
+      await this.deps.workspaceDocument.cleanSessionDoc(sessionId, {
+        preserveStatus: true
+      });
+    }
     async waitForDispatchableTurnFromMirror(sessionId, sessionDoc, meta) {
       return new Promise((resolve2) => {
         let settled = false;
@@ -122437,7 +122471,7 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
           clearTimeout(timer2);
           unsubscribe2?.();
         };
-        const timer2 = setTimeout(() => {
+        const timer2 = SessionDispatchWatcher.setUnrefTimeout(() => {
           if (settled) return;
           cleanup();
           this.deps.logger.debug(`[${sessionId}] No dispatchable turn found after ${SessionDispatchWatcher.REALTIME_WAIT_TIMEOUT_MS / 1e3}s timeout`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lody",
-  "version": "0.45.0",
+  "version": "0.45.1",
   "description": "Lody Agent CLI tool for managing remote command execution",
   "type": "module",
   "main": "dist/index.js",
@@ -73,9 +73,9 @@
     "ws": "^8.18.3",
     "zod": "^4.1.5",
     "@lody/cli-supervisor": "0.0.1",
+    "@lody/shared": "0.0.1",
     "@lody/convex": "0.0.1",
     "@lody/loro-streams-rpc": "0.0.1",
-    "@lody/shared": "0.0.1",
     "loro-code": "0.0.1"
   },
   "files": [