lody 0.71.3 → 0.71.4

package/dist/chunks/{review-viewer-S-XYMgL_.js → review-viewer-B9Tm-8O4.js}

@@ -3,7 +3,7 @@ import { readFile, mkdir, writeFile, rename } from "node:fs/promises";
 import os__default from "node:os";
 import path__default from "node:path";
 import process from "node:process";
-const reviewViewerVersion = "0.71.3";
+const reviewViewerVersion = "0.71.4";
 const reviewViewerSha256 = "e395b367a7644fe83bc050d0c646810914a2844824fd2b5d11d24ae4f55b6893";
 const reviewViewerFileName = "standalone.html";
 const DEFAULT_CDN_BASES = ["https://cdn.jsdelivr.net/npm", "https://unpkg.com"];

package/dist/claude-acp.js

@@ -34404,7 +34404,12 @@ ${content.text}
         sessions
       };
     }
+    static TITLE_POLL_INTERVAL_MS = 2e3;
     async maybeUpdateSessionTitle(sessionId, session) {
+      if (session.titleLookupInFlight) {
+        return;
+      }
+      session.titleLookupInFlight = true;
       let info;
       try {
         info = await mGe(sessionId, {
@@ -34413,8 +34418,10 @@ ${content.text}
       } catch (error) {
         this.logger.error(`Session ${sessionId}: failed to read session info: ${error}`);
         return;
+      } finally {
+        session.titleLookupInFlight = false;
       }
-      const rawTitle = info?.customTitle ?? info?.summary;
+      const rawTitle = info?.customTitle;
       if (!rawTitle) {
         return;
       }
@@ -34423,6 +34430,7 @@ ${content.text}
         return;
       }
       session.lastTitle = title;
+      this.stopSessionTitlePolling(session);
       await this.client.sessionUpdate({
         sessionId,
         update: {
@@ -34432,6 +34440,22 @@ ${content.text}
         }
       });
     }
+    startSessionTitlePolling(sessionId, session) {
+      if (session.lastTitle || session.titlePollTimer) {
+        return;
+      }
+      void this.maybeUpdateSessionTitle(sessionId, session);
+      session.titlePollTimer = setInterval(() => {
+        void this.maybeUpdateSessionTitle(sessionId, session);
+      }, ClaudeAcpAgent.TITLE_POLL_INTERVAL_MS);
+      session.titlePollTimer.unref();
+    }
+    stopSessionTitlePolling(session) {
+      if (session.titlePollTimer) {
+        clearInterval(session.titlePollTimer);
+        session.titlePollTimer = void 0;
+      }
+    }
     async authenticate(_params) {
       if (_params.methodId === "gateway" || _params.methodId === "gateway-bedrock") {
         this.gatewayAuthRequest = _params;
@@ -34971,7 +34995,9 @@ Compacting failed${reason}`
                 }
                 case "session_state_changed": {
                   session.lastSessionState = message.state;
-                  if (message.state === "idle") {
+                  if (message.state === "running") {
+                    this.startSessionTitlePolling(params.sessionId, session);
+                  } else if (message.state === "idle") {
                     if (session.cancelled && session.activeTurn && !session.activeTurn.settled) {
                       settleActive({
                         stopReason: "cancelled",
@@ -34989,6 +35015,7 @@ Compacting failed${reason}`
                       this.logger.error(`Session ${params.sessionId}: SDK went idle without emitting a result for the active turn; failing the in-flight prompt (issue #825)`);
                       failActive(RequestError.internalError(errorKindData("no_result"), TURN_NO_RESULT_MESSAGE));
                     }
+                    this.stopSessionTitlePolling(session);
                     await this.maybeUpdateSessionTitle(params.sessionId, session);
                   }
                   break;
@@ -35715,6 +35742,7 @@ ${message.api_refusal_explanation}` : "";
       }
       session.queryClosed = true;
       session.consumer = void 0;
+      this.stopSessionTitlePolling(session);
       session.settingsManager.dispose();
       session.input.end();
       session.query.close();

package/dist/index.js

@@ -4190,7 +4190,7 @@ let __tla = Promise.all([
     }
   }
   const name$1 = "lody";
-  const version$7 = "0.71.3";
+  const version$7 = "0.71.4";
   const description$1 = "Lody Agent CLI tool for managing remote command execution";
   const type$2 = "module";
   const main$4 = "dist/index.js";
@@ -103186,8 +103186,13 @@ ${value}`;
     return proxyFromEnvExports.getProxyForUrl(targetUrl);
   };
   function resolveProxyUrl(targetUrl) {
-    const proxyUrl = getProxyForUrlWithWsFallback(targetUrl);
+    const rawProxyUrl = getProxyForUrlWithWsFallback(targetUrl);
+    if (!rawProxyUrl) {
+      return {};
+    }
+    const proxyUrl = normalizeProxyUrl(rawProxyUrl);
     if (!proxyUrl) {
+      warnUnsupportedProxyUrl(rawProxyUrl);
       return {};
     }
     return {
@@ -103195,6 +103200,33 @@ ${value}`;
       proxyUrlRedacted: redactProxyUrl(proxyUrl)
     };
   }
+  const SCHEME_PREFIX_RE = /^[a-z][a-z0-9+.-]*:\/\//i;
+  const warnedProxyUrls = /* @__PURE__ */ new Set();
+  function normalizeProxyUrl(rawProxyUrl) {
+    const trimmed2 = rawProxyUrl.trim();
+    if (!trimmed2) {
+      return void 0;
+    }
+    const candidate = SCHEME_PREFIX_RE.test(trimmed2) ? trimmed2 : `http://${trimmed2}`;
+    let parsed;
+    try {
+      parsed = new URL(candidate);
+    } catch {
+      return void 0;
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      return void 0;
+    }
+    return candidate;
+  }
+  function warnUnsupportedProxyUrl(rawProxyUrl) {
+    const redacted = redactProxyUrl(rawProxyUrl);
+    if (warnedProxyUrls.has(redacted)) {
+      return;
+    }
+    warnedProxyUrls.add(redacted);
+    getLogger("proxy").warn(`[proxy] ignoring unsupported proxy URL ${redacted}: only http:// and https:// proxies are supported (e.g. socks proxies are not); using a direct connection instead`);
+  }
   const DEFAULT_CONNECT_TIMEOUT_MS = 15e3;
   const DEFAULT_MAX_CONCURRENT_STREAMS = 100;
   const DISABLED_TRANSPORT_VALUES = /* @__PURE__ */ new Set([
@@ -106445,6 +106477,7 @@ ${value}`;
   const JSON_RPC_VERSION$1 = "2.0";
   const LORO_STREAMS_RPC_VERSION = "1";
   const LORO_STREAMS_RPC_RETENTION_SECONDS = 86400;
+  const DEFAULT_LIVE_IDLE_TIMEOUT_MS = 12e4;
   const LORO_STREAMS_RPC_ERROR_CODES = {
     rpcVersionMismatch: "rpc_version_mismatch",
     methodUnavailable: "method_unavailable",
@@ -106970,57 +107003,101 @@ ${value}`;
       },
       readJsonLive: async (streamId, state2, onBatch, liveOptions) => {
         const { client: streamClient, context: context2 } = getStreamClient(streamId, "live");
-        for await (const event of streamClient.live({
-          offset: state2.nextOffset ?? "now",
-          mode: options.liveMode ?? "sse",
-          signal: liveOptions?.signal
-        })) {
-          switch (event.type) {
-            case "data":
-              state2.nextOffset = event.nextOffset;
-              state2.cursor = event.cursor;
-              await onBatch({
-                messages: parseJsonLivePayload(event.payload, streamId, "live read"),
-                nextOffset: event.nextOffset,
-                cursor: event.cursor,
-                upToDate: false
-              });
-              break;
-            case "up_to_date": {
-              state2.nextOffset = event.nextOffset;
-              state2.cursor = event.cursor;
-              await onBatch({
-                messages: [],
-                nextOffset: event.nextOffset,
-                cursor: event.cursor,
-                upToDate: true
-              });
-              break;
-            }
-            case "eof": {
-              state2.nextOffset = event.nextOffset;
-              state2.cursor = void 0;
-              await onBatch({
-                messages: [],
-                nextOffset: event.nextOffset,
-                cursor: void 0,
-                upToDate: true
-              });
-              return;
+        const watchdog = createLiveIdleWatchdog(options.liveIdleTimeoutMs ?? DEFAULT_LIVE_IDLE_TIMEOUT_MS, liveOptions?.signal);
+        try {
+          for await (const event of streamClient.live({
+            offset: state2.nextOffset ?? "now",
+            mode: options.liveMode ?? "sse",
+            signal: watchdog.signal
+          })) {
+            watchdog.reset();
+            switch (event.type) {
+              case "data":
+                state2.nextOffset = event.nextOffset;
+                state2.cursor = event.cursor;
+                await onBatch({
+                  messages: parseJsonLivePayload(event.payload, streamId, "live read"),
+                  nextOffset: event.nextOffset,
+                  cursor: event.cursor,
+                  upToDate: false
+                });
+                break;
+              case "up_to_date": {
+                state2.nextOffset = event.nextOffset;
+                state2.cursor = event.cursor;
+                await onBatch({
+                  messages: [],
+                  nextOffset: event.nextOffset,
+                  cursor: event.cursor,
+                  upToDate: true
+                });
+                break;
+              }
+              case "eof": {
+                state2.nextOffset = event.nextOffset;
+                state2.cursor = void 0;
+                await onBatch({
+                  messages: [],
+                  nextOffset: event.nextOffset,
+                  cursor: void 0,
+                  upToDate: true
+                });
+                return;
+              }
+              case "reconnecting":
+              case "reconnected":
+                break;
+              case "error":
+                throw toLoroGatewayError("read live updates from", streamId, event.error, context2);
             }
-            case "reconnecting":
-            case "reconnected":
-              break;
-            case "error":
-              throw toLoroGatewayError("read live updates from", streamId, event.error, context2);
           }
+        } finally {
+          watchdog.dispose();
         }
       }
     };
   }
+  function createLiveIdleWatchdog(timeoutMs, parentSignal) {
+    const controller = new AbortController();
+    const armed = Number.isFinite(timeoutMs) && timeoutMs > 0;
+    let timer2;
+    const onParentAbort = () => controller.abort();
+    if (parentSignal) {
+      if (parentSignal.aborted) {
+        controller.abort();
+      } else {
+        parentSignal.addEventListener("abort", onParentAbort, {
+          once: true
+        });
+      }
+    }
+    const reset = () => {
+      if (!armed || controller.signal.aborted) {
+        return;
+      }
+      if (timer2 !== void 0) {
+        clearTimeout(timer2);
+      }
+      timer2 = setTimeout(() => controller.abort(), timeoutMs);
+      timer2.unref?.();
+    };
+    const dispose = () => {
+      if (timer2 !== void 0) {
+        clearTimeout(timer2);
+        timer2 = void 0;
+      }
+      parentSignal?.removeEventListener("abort", onParentAbort);
+    };
+    reset();
+    return {
+      signal: controller.signal,
+      reset,
+      dispose
+    };
+  }
   function selectJsonStreamOperationBaseUrl(baseUrl, streamId, operation, shardUrls) {
     const shardCandidates = operation === "append" ? shardUrls?.largePost ?? shardUrls?.other : operation === "live" ? shardUrls?.catchup ?? shardUrls?.bootstrap ?? shardUrls?.other : shardUrls?.other;
-    const shardBaseUrl = operation === "append" ? selectRandomShardUrl(shardCandidates) : selectStableShardUrl(shardCandidates, streamId);
+    const shardBaseUrl = selectStableShardUrl(shardCandidates, streamId);
     if (!shardBaseUrl) return baseUrl;
     try {
       const selected = new URL(shardBaseUrl);
@@ -107041,16 +107118,6 @@ ${value}`;
     }
     return candidates[(hash2 >>> 0) % candidates.length];
   }
-  function selectRandomShardUrl(candidates) {
-    if (!candidates || candidates.length === 0) return void 0;
-    const crypto2 = globalThis.crypto;
-    if (crypto2?.getRandomValues) {
-      const value = new Uint32Array(1);
-      crypto2.getRandomValues(value);
-      return candidates[(value[0] ?? 0) % candidates.length];
-    }
-    return candidates[Math.floor(Math.random() * candidates.length)];
-  }
   const delay$4 = async (ms2) => {
     await new Promise((resolve2) => setTimeout(resolve2, ms2));
   };
@@ -130961,9 +131028,6 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
     return null;
   };
   const isWorkspaceDirty = async (runGit2) => {
-    if (!await isInsideGitWorktree$1(runGit2)) {
-      return false;
-    }
     try {
       const status = await runGit2([
         "status",
@@ -130971,7 +131035,7 @@ The postId is ${normalizedFeedbackPostId}. Use the feedback-progress-reporter sk
       ]);
       return status.trim().length > 0;
     } catch {
-      return false;
+      return void 0;
     }
   };
   const listUntrackedFiles = async (runGit2, filePaths) => {
@@ -143417,7 +143481,7 @@ ${entry.text}`).join("\n\n");
       } catch (error2) {
         this.deps.logger.debug(`[${sessionId}] Failed to compute git diff stats:`, error2);
       }
-      let workspaceDirty = false;
+      let workspaceDirty;
       try {
         workspaceDirty = await isWorkspaceDirty(runGit2);
         this.deps.logger.debug(`[${sessionId}] Workspace dirty: ${workspaceDirty}`);
@@ -143428,9 +143492,11 @@ ${entry.text}`).join("\n\n");
         const sessionDoc = await this.deps.workspaceDocument.getOrCreateSessionDoc(sessionId);
         const workspace = await this.resolveWorkspaceSessionContext(sessionId, sessionDoc);
         const metaPatch = {
-          diffStats,
-          workspaceDirty
+          diffStats
         };
+        if (workspaceDirty !== void 0) {
+          metaPatch.workspaceDirty = workspaceDirty;
+        }
         await this.deps.workspaceDocument.repo.upsertDocMeta(workspace.ownerRoomId, metaPatch);
       } catch (error2) {
         this.deps.logger.debug(`[${sessionId}] Failed to persist session meta diffStats: ${formatErrorMessage(error2)}`);
@@ -153402,7 +153468,10 @@ ${escapeHtmlScriptContent(VISUAL_ANNOTATION_INSPECTOR_BROWSER_SCRIPT)}
               return {
                 ...entry,
                 userTurnId: entry.userTurnId ?? userTurnId,
-                modelInfo: modelInfo ?? entry.modelInfo
+                modelInfo: modelInfo ?? entry.modelInfo,
+                finished: false,
+                endedAt: void 0,
+                permissionWaitMs: void 0
               };
             });
           }
@@ -203396,7 +203465,7 @@ ${page}${helpTipBottom}${choiceDescription}${ansiEscapes.cursorHide}`;
       data = createReviewBundleSnapshot(bundle);
     }
     const { injectReviewSnapshot } = await import("./chunks/index-VoI6Ds2-.js");
-    const { resolveReviewViewerTemplate } = await import("./chunks/review-viewer-S-XYMgL_.js");
+    const { resolveReviewViewerTemplate } = await import("./chunks/review-viewer-B9Tm-8O4.js");
     const template = await resolveReviewViewerTemplate();
     const html = injectReviewSnapshot(template, data);
     const outputPath = options.output ? path__default$1.resolve(options.output) : defaultHtmlOutputPath(inputPath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lody",
-  "version": "0.71.3",
+  "version": "0.71.4",
   "description": "Lody Agent CLI tool for managing remote command execution",
   "type": "module",
   "main": "dist/index.js",
@@ -75,14 +75,14 @@
     "ws": "^8.18.3",
     "zod": "^4.1.5",
     "zstd-stream": "^1.1.0",
+    "@lody/cli-supervisor": "0.0.1",
     "@lody/convex": "0.0.1",
     "@lody/loro-streams-rpc": "0.0.1",
-    "acp-extension-claude": "0.59.0",
-    "@lody/code-review-helper": "0.0.0",
-    "@lody/cli-supervisor": "0.0.1",
     "@lody/shared": "0.0.1",
+    "@lody/code-review-helper": "0.0.0",
+    "acp-extension-claude": "0.59.0",
+    "lody-code-review-viewer": "0.71.4",
     "acp-extension-core": "0.0.5",
-    "lody-code-review-viewer": "0.71.3",
     "acp-extension-codex": "1.2.1"
   },
   "files": [