lody 0.46.2-next.1 → 0.47.0

package/dist/index.js

@@ -22780,7 +22780,7 @@ Event: ${getEventDescription(event)}`);
     const mergedOptions = {
       ...options,
       dsn: options.dsn ?? "https://080f9de535ff335a1a0440d0e385f796@o4510491299086336.ingest.us.sentry.io/4510559045681152",
-      environment: options.environment ?? "staging",
+      environment: options.environment ?? "production",
       sendClientReports: options.sendClientReports ?? true,
       transport: options.transport ?? makeNodeTransport,
       stackParser: stackParserFromStackParserOptions(options.stackParser || defaultStackParser),
@@ -36820,7 +36820,7 @@ Mongoose Error Code: ${error2.code}` : ""}`
     return client;
   }
   const name = "lody";
-  const version$4 = "0.46.2-next.1";
+  const version$4 = "0.47.0";
   const description = "Lody Agent CLI tool for managing remote command execution";
   const type = "module";
   const main$3 = "dist/index.js";
@@ -37068,15 +37068,15 @@ Mongoose Error Code: ${error2.code}` : ""}`
         return "dev";
     }
   };
-  const getRuntimeEnv = () => normalizeRuntimeEnv("staging");
+  const getRuntimeEnv = () => normalizeRuntimeEnv("production");
   const isDevEnv = () => getRuntimeEnv() === "dev";
   const runtimeEnv = getRuntimeEnv();
-  const environment$1 = "staging";
+  const environment$1 = "production";
   const dsn = "https://080f9de535ff335a1a0440d0e385f796@o4510491299086336.ingest.us.sentry.io/4510559045681152";
   const postHogHost = process.env.LODY_POSTHOG_HOST ?? "https://us.i.posthog.com";
   const postHogKey = process.env.LODY_POSTHOG_KEY ?? "phc_LFS5i5WIwg4irAhrG5oJR04iYPhReVZ3DdFZOKqCkjG";
-  const tracesSampleRate = Number(process.env.SENTRY_TRACES_SAMPLE_RATE) || 1;
-  const profilesSampleRate = Number(process.env.SENTRY_PROFILES_SAMPLE_RATE) || 0.25;
+  const tracesSampleRate = Number(process.env.SENTRY_TRACES_SAMPLE_RATE) || 0.2;
+  const profilesSampleRate = Number(process.env.SENTRY_PROFILES_SAMPLE_RATE) || 0.1;
   const sentryEnabled = runtimeEnv !== "dev" && true;
   const postHogEnabled = runtimeEnv !== "dev" && process.env.LODY_POSTHOG_DISABLED !== "1";
   const release = `${name}@${version$4}`;
@@ -64608,16 +64608,16 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
     return _v4(options, buf, offset2);
   }
-  let LODY_AUTH_URL = "https://impressive-guineapig-165.convex.cloud";
+  let LODY_AUTH_URL = "https://nautical-curlew-181.convex.cloud";
   let LODY_AUTH_SITE_URL = "";
-  let LODY_SERVER_URL = "https://lody-server.lz-9c5.workers.dev";
-  let SITE_URL = "https://main.lody.pages.dev";
+  let LODY_SERVER_URL = "https://api.lody.ai";
+  let SITE_URL = "https://lody.ai";
   let SITE_APP_BASE_PATH = "";
   const loadEnv = () => {
-    LODY_AUTH_URL = "https://impressive-guineapig-165.convex.cloud";
+    LODY_AUTH_URL = "https://nautical-curlew-181.convex.cloud";
     LODY_AUTH_SITE_URL = "";
-    LODY_SERVER_URL = "https://lody-server.lz-9c5.workers.dev";
-    SITE_URL = "https://main.lody.pages.dev";
+    LODY_SERVER_URL = "https://api.lody.ai";
+    SITE_URL = "https://lody.ai";
     SITE_APP_BASE_PATH = process.env["SITE_APP_BASE_PATH"] ?? "";
   };
   const MACHINE_ID_FILE_NAME = "machine-id";
@@ -82846,7 +82846,6 @@ ${tailedOutput}` : null;
   const LODY_PRESENCE_CHANNEL = "presence";
   const LODY_PRESENCE_TTL_MS = 6e4;
   const LODY_PRESENCE_HEARTBEAT_MS = 2e4;
-  const LODY_PRESENCE_STREAM_HEARTBEAT_MS = 15e3;
   const ActiveSessionStatusSchema = discriminatedUnion("type", [
     object({
       type: literal("running")
@@ -91165,7 +91164,8 @@ ${val.stack}`;
         const requestUrl = this.subresourceEndpoint("/bootstrap");
         const response = await this.http.fetchAuthorized(requestUrl, {
           method: "GET",
-          headers: this.mergeHeaders(input2.headers)
+          headers: this.mergeHeaders(input2.headers),
+          signal: input2.signal
         }, this.timeoutConfig.connectTimeoutMs, "connect");
         if (!response.ok) return {
           ok: false,
@@ -92711,8 +92711,10 @@ stream:${scope2.streamId}`;
         }
       };
     }
-    async bootstrap() {
-      const result = await this.client.bootstrap();
+    async bootstrap(signal) {
+      const result = await this.client.bootstrap({
+        signal
+      });
       if (!result.ok) throw this.toTransportFailure(result.result);
       return {
         nextOffset: result.result.nextOffset,
@@ -93097,7 +93099,6 @@ stream:${scope2.streamId}`;
     adaptor;
     client;
     reconnectConfig;
-    heartbeatMs;
     debug;
     joinState;
     constructor(options) {
@@ -93107,7 +93108,6 @@ stream:${scope2.streamId}`;
         ...DEFAULT_RECONNECT_CONFIG,
         ...options.reconnectConfig
       };
-      this.heartbeatMs = options.heartbeatMs ?? 15e3;
       this.debug = options.debug ?? false;
       this.client = new StreamsTransportClient({
         streamUrl: options.streamUrl,
@@ -93188,18 +93188,15 @@ stream:${scope2.streamId}`;
       };
     }
     async startJoin(state2) {
+      state2.unsubscribeLocal = this.adaptor.subscribeLocalUpdates((update2) => {
+        this.enqueueLocal(state2, normalizeEphemeralUpdate(update2));
+      });
       state2.requestController = new AbortController();
       const firstOpen = this.waitForFirstOpen(state2);
       this.runReadLoop(state2);
       await firstOpen;
       if (state2.closed) return;
-      state2.unsubscribeLocal = this.adaptor.subscribeLocalUpdates((update2) => {
-        this.enqueueLocal(state2, normalizeEphemeralUpdate(update2));
-      });
       this.setWriteStatus(state2, "ok");
-      const fullState = normalizeEphemeralUpdate(await this.adaptor.encodeAll());
-      if (fullState != null) state2.pendingLocal.pushBack(fullState);
-      this.startHeartbeat(state2);
       await this.flushPendingLocal(state2);
       if (state2.status === "error" || state2.status === "disconnected") throw new Error(`ephemeral stream failed to join: ${state2.status}`);
     }
@@ -93257,7 +93254,6 @@ stream:${scope2.streamId}`;
       if (state2.closed) return;
       state2.closed = true;
       state2.unsubscribeLocal?.();
-      if (state2.heartbeatTimer != null) clearInterval(state2.heartbeatTimer);
       state2.requestController?.abort();
       state2.retrySleepController.abort();
       this.rejectFirstOpen(state2, closedSubscriptionError());
@@ -93285,7 +93281,6 @@ stream:${scope2.streamId}`;
             ]);
             this.setReadStatus(state2, "ok");
             this.resolveFirstOpen(state2);
-            if (state2.unsubscribeLocal != null) this.enqueueFullState(state2);
           }, async (update2) => {
             if (update2.byteLength > 0) await this.adaptor.applyRemoteUpdates([
               update2
@@ -93333,27 +93328,10 @@ stream:${scope2.streamId}`;
         }
       }
     }
-    startHeartbeat(state2) {
-      if (this.heartbeatMs === false || this.heartbeatMs <= 0) return;
-      state2.heartbeatTimer = setInterval(() => {
-        this.enqueueFullState(state2);
-      }, this.heartbeatMs);
-    }
-    async enqueueFullState(state2) {
-      try {
-        const update2 = await this.adaptor.encodeAll();
-        this.enqueueLocal(state2, normalizeEphemeralUpdate(update2));
-      } catch (error2) {
-        this.logError("ephemeral encodeAll failed", error2, {
-          streamUrl: this.streamUrl
-        });
-        this.setWriteStatus(state2, "error");
-      }
-    }
     enqueueLocal(state2, update2) {
       if (state2.closed || update2 == null || update2.byteLength === 0) return;
       state2.pendingLocal.pushBack(update2);
-      this.flushPendingLocal(state2);
+      if (state2.writeStatus !== "connecting") this.flushPendingLocal(state2);
     }
     async flushPendingLocal(state2) {
       if (state2.flushingLocal || state2.closed) return;
@@ -94115,7 +94093,7 @@ stream:${scope2.streamId}`;
     async startJoin(state2) {
       try {
         state2.requestController ??= new AbortController();
-        const joined = await this.performInitialJoinSync(state2.liveMode);
+        const joined = await this.performInitialJoinSync(state2.liveMode, state2.requestController?.signal);
         state2.cursor = joined.cursor;
         state2.streamCursor = joined.streamCursor;
         state2.liveMode = joined.liveMode;
@@ -94158,8 +94136,8 @@ stream:${scope2.streamId}`;
       }
       return cursor;
     }
-    async performInitialJoinSync(preferredLiveMode) {
-      const initial = await this.finalizeDirectLocalAppendIfNeeded(await this.resolveInitialRemoteState());
+    async performInitialJoinSync(preferredLiveMode, signal) {
+      const initial = await this.finalizeDirectLocalAppendIfNeeded(await this.resolveInitialRemoteState(signal));
       let cursor = initial.cursor;
       let localExportRefVersion = cursor.serverLowerBoundVersion;
       let streamCursor = initial.streamCursor;
@@ -94168,7 +94146,7 @@ stream:${scope2.streamId}`;
       localExportRefVersion = exportedLocal.nextRefVersion;
       if (exportedLocal.batch != null) {
         cursor = await this.appendLocalBatch(cursor, exportedLocal.batch);
-        const caughtUp = await this.catchup(cursor);
+        const caughtUp = await this.catchup(cursor, void 0, void 0, void 0, signal);
         cursor = caughtUp.cursor;
         streamCursor = caughtUp.streamCursor;
       }
@@ -94187,31 +94165,37 @@ stream:${scope2.streamId}`;
         serverLowerBoundVersion: this.adapter.emptyVersion()
       });
     }
-    async resolveInitialRemoteState() {
+    async resolveInitialRemoteState(signal) {
       const loaded = await this.remoteCursorStore.load(this.streamUrl);
       const cursor = loaded ?? this.createInitialCursor();
       try {
-        if (loaded == null) return await this.bootstrapState(cursor);
+        if (loaded == null) return await this.bootstrapState(cursor, {
+          signal
+        });
         const caughtUp = await this.catchupOrGone(cursor, {
-          goneStrategy: "return-gone"
+          goneStrategy: "return-gone",
+          signal
         });
-        if ("kind" in caughtUp) return await this.recoverFromGoneWithLocalBootstrap(cursor);
+        if ("kind" in caughtUp) return await this.recoverFromGoneWithLocalBootstrap(cursor, signal);
         return caughtUp;
       } catch (error2) {
         if (!isStreamNotFoundError(error2) || !this.createStreamIfMissing) throw error2;
         await this.ensureStreamExists();
-        return await this.bootstrapState(this.createInitialCursor());
+        return await this.bootstrapState(this.createInitialCursor(), {
+          signal
+        });
       }
     }
     async bootstrapState(cursor, options = {}) {
       const cursorManager = options.cursorManager ?? this.cursorManager;
-      const result = await this.client.bootstrap();
+      const result = await this.client.bootstrap(options.signal);
       let saved = await cursorManager.applyBootstrapPayload(cursor, result.snapshot, result.updates, result.nextOffset);
       let bootstrapCursor = result.streamCursor;
       if (!result.upToDate) {
         const caughtUp = await this.catchupOrGone(saved, {
           streamCursor: bootstrapCursor,
-          cursorManager
+          cursorManager,
+          signal: options.signal
         });
         if ("kind" in caughtUp) throw new Error("bootstrap catch-up unexpectedly returned gone");
         saved = caughtUp.cursor;
@@ -94222,11 +94206,12 @@ stream:${scope2.streamId}`;
         streamCursor: bootstrapCursor
       };
     }
-    async catchup(cursor, live, streamCursor, onRemoteVersionApplied) {
+    async catchup(cursor, live, streamCursor, onRemoteVersionApplied, signal) {
       const result = await this.catchupOrGone(cursor, {
         live,
         streamCursor,
-        onRemoteVersionApplied
+        onRemoteVersionApplied,
+        signal
       });
       if ("kind" in result) throw new Error("catchup unexpectedly returned gone");
       return result;
@@ -94238,7 +94223,7 @@ stream:${scope2.streamId}`;
       const cursorManager = options.cursorManager ?? this.cursorManager;
       while (true) {
         const requestOffset = current2.nextOffset;
-        const response = await this.client.readFromOffset(requestOffset, currentStreamCursor, options.live);
+        const response = await this.client.readFromOffset(requestOffset, currentStreamCursor, options.live, options.signal);
         if (response.kind === "gone") {
           if (goneStrategy === "return-gone") return StreamsCrdt2.GONE_CATCHUP;
           return await this.bootstrapState({
@@ -94246,7 +94231,8 @@ stream:${scope2.streamId}`;
             nextOffset: "-1",
             serverLowerBoundVersion: this.adapter.emptyVersion()
           }, {
-            cursorManager
+            cursorManager,
+            signal: options.signal
           });
         }
         const result = response.value;
@@ -94413,9 +94399,10 @@ stream:${scope2.streamId}`;
       if (isolated == null) return null;
       return this.createCursorManager(isolated, async (cursor) => cursor);
     }
-    async inferRemoteAndAppendLocal(bootstrapCursor, cursorManager) {
+    async inferRemoteAndAppendLocal(bootstrapCursor, cursorManager, signal) {
       const inferredRemote = await this.bootstrapState(bootstrapCursor, {
-        cursorManager
+        cursorManager,
+        signal
       });
       let pendingAppend;
       if (this.frozenLocalAppend != null) {
@@ -94425,23 +94412,26 @@ stream:${scope2.streamId}`;
         const localBatch = this.exportUpdates(inferredRemote.cursor.serverLowerBoundVersion);
         if (localBatch.batch != null) pendingAppend = await this.appendLocalBatchRemote(inferredRemote.cursor, localBatch.batch);
       }
-      const result = await this.bootstrapState(bootstrapCursor);
+      const result = await this.bootstrapState(bootstrapCursor, {
+        signal
+      });
       if (pendingAppend != null) this.commitProducerAck(pendingAppend.producerAck);
       return result;
     }
-    async recoverFromGoneWithLocalBootstrap(cursor) {
+    async recoverFromGoneWithLocalBootstrap(cursor, signal) {
       const isolatedCursorManager = await this.createIsolatedCursorManager();
       const bootstrapCursor = {
         ...cursor,
         nextOffset: "-1",
         serverLowerBoundVersion: this.adapter.emptyVersion()
       };
-      if (isolatedCursorManager != null) return await this.inferRemoteAndAppendLocal(bootstrapCursor, isolatedCursorManager);
+      if (isolatedCursorManager != null) return await this.inferRemoteAndAppendLocal(bootstrapCursor, isolatedCursorManager, signal);
       const preservedLocalSnapshot = this.adapter.exportSnapshot();
       let restoredLocalSnapshot = false;
       try {
         const inferredRemote = await this.bootstrapState(bootstrapCursor, {
-          cursorManager: this.volatileCursorManager
+          cursorManager: this.volatileCursorManager,
+          signal
         });
         await this.adapter.applySnapshot(preservedLocalSnapshot);
         restoredLocalSnapshot = true;
@@ -94453,7 +94443,9 @@ stream:${scope2.streamId}`;
           const localBatch = this.exportUpdates(inferredRemote.cursor.serverLowerBoundVersion);
           if (localBatch.batch != null) pendingAppend = await this.appendLocalBatchRemote(inferredRemote.cursor, localBatch.batch);
         }
-        const result = await this.bootstrapState(bootstrapCursor);
+        const result = await this.bootstrapState(bootstrapCursor, {
+          signal
+        });
         if (pendingAppend != null) this.commitProducerAck(pendingAppend.producerAck);
         return result;
       } catch (error2) {
@@ -94490,6 +94482,8 @@ stream:${scope2.streamId}`;
                 ...state2.cursor,
                 nextOffset: "-1",
                 serverLowerBoundVersion: this.adapter.emptyVersion()
+              }, {
+                signal: capturedController?.signal
               });
               state2.cursor = bootstrapped2.cursor;
               state2.streamCursor = bootstrapped2.streamCursor;
@@ -94962,12 +94956,25 @@ stream:${scope2.streamId}`;
     };
   }
   function EphemeralStoreAdaptor(store) {
+    let applyingRemoteDepth = 0;
     return {
-      encodeAll: () => store.encodeAll(),
       applyRemoteUpdates: (updates) => {
-        for (const update2 of updates) store.apply(update2);
+        applyingRemoteDepth += 1;
+        try {
+          for (const update2 of updates) store.apply(update2);
+        } finally {
+          applyingRemoteDepth -= 1;
+        }
       },
-      subscribeLocalUpdates: (listener) => store.subscribeLocalUpdates(listener)
+      subscribeLocalUpdates: (listener) => {
+        const unsubscribeLocalUpdates = store.subscribeLocalUpdates((update2) => {
+          if (applyingRemoteDepth > 0) return;
+          listener(update2);
+        });
+        return () => {
+          unsubscribeLocalUpdates();
+        };
+      }
     };
   }
   function isAfter(entry2, current2) {
@@ -95862,8 +95869,7 @@ stream:${scope2.streamId}`;
       this.transport = new EphemeralStreamCrdt({
         streamUrl: toLodyPresenceStreamUrl(durableStreamUrl),
         auth: options.auth,
-        adaptor: EphemeralStoreAdaptor(this.store),
-        heartbeatMs: LODY_PRESENCE_STREAM_HEARTBEAT_MS
+        adaptor: EphemeralStoreAdaptor(this.store)
       });
       this.machineTimer = setInterval(() => {
         this.writeMachineHeartbeat();
@@ -114202,7 +114208,7 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
       const agent = proxyUrl ? new distExports.HttpsProxyAgent(proxyUrl) : void 0;
       const logger2 = getLogger("loro:websocket");
       logger2.debug(`Creating WebSocket url=${sanitizeUrlForLogging(urlString)} proxy=${proxyUrl ? redactProxyUrl(proxyUrl) : "none"} agentValid=${!!agent}`);
-      if (global.Bun && proxyUrl) {
+      if (globalThis.Bun && proxyUrl) {
         logger2.debug("Bun does not support WebSocket proxy yet: https://github.com/oven-sh/bun/issues/14522");
       }
       super(urlString, protocols, {
@@ -115713,12 +115719,12 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
         }));
         return result.nextOffset;
       },
-      longPollJson: async (streamId, state2, options2) => {
+      longPollJson: async (streamId, state2, readOptions) => {
         const result = unwrapStreamResult("long-poll stream", streamId, await getStreamClient(streamId).readOnce({
           offset: state2.nextOffset ?? "now",
           cursor: state2.cursor,
           live: "long-poll",
-          signal: options2?.signal
+          signal: readOptions?.signal
         }));
         return {
           messages: result.payload === null ? [] : parseJsonBatchPayload(result.payload, streamId, "long-poll read"),
@@ -115727,13 +115733,13 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
           upToDate: result.upToDate
         };
       },
-      readJsonLive: async (streamId, state2, onBatch, options2) => {
+      readJsonLive: async (streamId, state2, onBatch, liveOptions) => {
         const pendingMessages = [];
         const streamClient = getStreamClient(streamId);
         for await (const event of streamClient.live({
           offset: state2.nextOffset ?? "now",
           mode: "auto",
-          signal: options2?.signal
+          signal: liveOptions?.signal
         })) {
           switch (event.type) {
             case "data":
@@ -117329,7 +117335,7 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
           throw err2;
         }
         logger2.debug(`[${sessionId}] ${operationName} failed after ${attempt + 1} attempt(s) with transport error: ${formatErrorMessage(err2)}`);
-        reportError(`agent-client:${operationName}`, err2 instanceof Error ? err2 : new Error(String(err2)));
+        void reportError(`agent-client:${operationName}`, err2 instanceof Error ? err2 : new Error(String(err2)));
         return void 0;
       }
     }
@@ -118931,6 +118937,7 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
       case "idle":
         return "idle";
     }
+    return "unknown";
   };
   class SessionHeartbeat {
     constructor(sessionId, workspaceDocument, logger2, options = {}) {
@@ -120749,11 +120756,7 @@ path=/${options.repoFullName}.git
     });
   }
   async function fetchAcpCapabilities(cliType, agentType, logger2, env2) {
-    const safeAgentType = agentType.replace(/[^a-zA-Z0-9._-]/g, "-");
-    const workdir = path__default.join(os__default.tmpdir(), "lody-acp-capabilities", `${cliType}-${safeAgentType}`);
-    fs__default.mkdirSync(workdir, {
-      recursive: true
-    });
+    const workdir = process.cwd();
     let capturedCommands;
     let commandsResolve;
     const commandsPromise = new Promise((resolve2) => {
@@ -121905,91 +121908,94 @@ $mem | ConvertTo-Json -Compress
       const runtime = this.createTurnRuntime(sessionId, turnId, userTurnId, session);
       this.registerTurnRuntime(runtime);
       const self2 = this;
-      const program2 = scoped(acquireRelease(succeed(runtime), (runtime2, exit2) => gen(function* () {
+      const program2 = scoped(acquireRelease(succeed(runtime), (turnRuntime, exit2) => gen(function* () {
         const wasInterrupted = isFailure(exit2) && isInterrupted(exit2.cause);
-        const wasCancelled = runtime2.cancelRequested || self2.isTurnCancelled(sessionId, runtime2.turnId) || wasInterrupted;
+        const wasCancelled = turnRuntime.cancelRequested || self2.isTurnCancelled(sessionId, turnRuntime.turnId) || wasInterrupted;
         if (wasCancelled) {
           yield* self2.finalizeCancelledTurnEffect({
             sessionId,
             sessionDoc,
-            turnId: runtime2.turnId,
+            turnId: turnRuntime.turnId,
             userTurnId,
-            session: runtime2.session,
-            pendingSession: runtime2.pendingSession,
-            terminateSession: runtime2.terminateSessionOnCancel,
-            reportTurnError: self2.shouldReportCancelledTurnError(runtime2)
+            session: turnRuntime.session,
+            pendingSession: turnRuntime.pendingSession,
+            terminateSession: turnRuntime.terminateSessionOnCancel,
+            reportTurnError: self2.shouldReportCancelledTurnError(turnRuntime)
           });
         }
-        self2.releaseTurnRuntime(sessionId, runtime2.turnId);
-      })).pipe(flatMap$1((runtime2) => gen(function* () {
-        yield* self2.tryPromise(() => self2.deps.createAssistantEntryForTurn(sessionId, sessionDoc, runtime2.turnId, runtime2.session?.agentClient?.currentModel, userTurnId));
+        self2.releaseTurnRuntime(sessionId, turnRuntime.turnId);
+      })).pipe(flatMap$1((turnRuntime) => gen(function* () {
+        yield* self2.tryPromise(() => self2.deps.createAssistantEntryForTurn(sessionId, sessionDoc, turnRuntime.turnId, turnRuntime.session?.agentClient?.currentModel, userTurnId));
         yield* self2.acquireSessionHeartbeat(sessionId);
         if (userTurnId) {
           yield* self2.tryPromise(() => self2.setDispatchProcessing(sessionId, sessionDoc, userTurnId));
         }
         const bindSession = (nextSession) => {
-          runtime2.session = nextSession;
-          runtime2.pendingSession = void 0;
+          runtime.session = nextSession;
+          runtime.pendingSession = void 0;
         };
         const trackPendingSession = (pendingSession, pendingOptions) => gen(function* () {
           const pending2 = yield* try_({
             try: () => typeof pendingSession === "function" ? pendingSession() : pendingSession,
             catch: (error2) => error2
           });
-          runtime2.pendingSession = pending2;
+          runtime.pendingSession = pending2;
           if (pendingOptions?.terminateOnCancel) {
-            runtime2.terminateSessionOnCancel = true;
+            runtime.terminateSessionOnCancel = true;
           }
           return yield* self2.tryPromise(() => pending2);
         });
         const abortIfCancelled = (cancelOptions) => gen(function* () {
           if (cancelOptions?.terminateSession) {
-            runtime2.terminateSessionOnCancel = true;
+            runtime.terminateSessionOnCancel = true;
           }
           const userTurnWasCancelled = yield* self2.tryPromise(() => self2.isUserTurnCancelled(sessionDoc, userTurnId));
-          if (!runtime2.cancelRequested && !self2.isTurnCancelled(sessionId, runtime2.turnId) && !userTurnWasCancelled) {
-            return;
+          if (!runtime.cancelRequested && !self2.isTurnCancelled(sessionId, runtime.turnId) && !userTurnWasCancelled) {
+            return void 0;
           }
           yield* self2.finalizeCancelledTurnEffect({
             sessionId,
             sessionDoc,
-            turnId: runtime2.turnId,
+            turnId: runtime.turnId,
             userTurnId,
-            session: runtime2.session,
-            pendingSession: runtime2.pendingSession,
-            terminateSession: cancelOptions?.terminateSession ?? runtime2.terminateSessionOnCancel,
-            reportTurnError: self2.shouldReportCancelledTurnError(runtime2)
+            session: runtime.session,
+            pendingSession: runtime.pendingSession,
+            terminateSession: cancelOptions?.terminateSession ?? runtime.terminateSessionOnCancel,
+            reportTurnError: self2.shouldReportCancelledTurnError(runtime)
           });
-          return yield* fail(new SessionTurnCancelled({
+          yield* fail(new SessionTurnCancelled({
             sessionId,
-            turnId: runtime2.turnId
+            turnId: runtime.turnId
           }));
+          return void 0;
         });
-        const patchAssistantEntry = () => self2.tryPromise(() => self2.deps.createAssistantEntryForTurn(sessionId, sessionDoc, runtime2.turnId, runtime2.session?.agentClient?.currentModel, userTurnId));
+        const patchAssistantEntry = () => self2.tryPromise(() => self2.deps.createAssistantEntryForTurn(sessionId, sessionDoc, runtime.turnId, runtime.session?.agentClient?.currentModel, userTurnId));
         const prompt2 = (promptBlocks) => gen(function* () {
-          const activeSession = runtime2.session;
+          const activeSession = runtime.session;
           const agentClient = activeSession?.agentClient;
           const acpSessionId = activeSession?.acpSessionId;
           if (!agentClient || !acpSessionId) {
-            return yield* fail(new Error("Agent session was not ready"));
+            yield* fail(new Error("Agent session was not ready"));
+            return void 0;
           }
-          runtime2.terminateSessionOnCancel = false;
-          runtime2.promptStarted = true;
+          runtime.terminateSessionOnCancel = false;
+          runtime.promptStarted = true;
           yield* acquireUseRelease(sync(() => {
-            runtime2.promptInFlight = true;
+            runtime.promptInFlight = true;
             return activeSession;
           }), () => self2.tryPromise((signal) => agentClient.prompt(acpSessionId, promptBlocks, {
             signal
           })).pipe(catchAll((error2) => sync(() => {
-            runtime2.promptFailed = true;
+            runtime.promptFailed = true;
           }).pipe(flatMap$1(() => fail(error2))))), () => sync(() => {
-            runtime2.promptInFlight = false;
+            runtime.promptInFlight = false;
           }));
-          self2.deps.clearActiveTurnId(sessionId, runtime2.turnId);
+          self2.deps.clearActiveTurnId(sessionId, runtime.turnId);
+          return void 0;
         });
         yield* body({
-          turnId: runtime2.turnId,
-          runtime: runtime2,
+          turnId: runtime.turnId,
+          runtime,
           bindSession,
           trackPendingSession,
           abortIfCancelled,
@@ -122662,7 +122668,8 @@ $mem | ConvertTo-Json -Compress
       }, ({ turnId, runtime, bindSession, trackPendingSession, abortIfCancelled, patchAssistantEntry, prompt: prompt2 }) => gen(function* () {
         yield* abortIfCancelled();
         if (project?.kind === "local" && !workdir) {
-          return yield* fail(new Error(`Local project not found in workspace: ${project.localProjectId}`));
+          yield* fail(new Error(`Local project not found in workspace: ${project.localProjectId}`));
+          return void 0;
         }
         if (shouldPrepareWorktree) {
           yield* self2.tryPromise(() => sessionDoc.setStatus(SessionStatusFactory.initializing("git-clone")));
@@ -122747,6 +122754,7 @@ $mem | ConvertTo-Json -Compress
         yield* abortIfCancelled();
         self2.clearTurnCancellation(sessionId, turnId);
         yield* self2.tryPromise(() => self2.deps.processMessageQueue(sessionId));
+        return void 0;
       }));
     }
     async cancelSession(message) {
@@ -123378,6 +123386,7 @@ $mem | ConvertTo-Json -Compress
         case "cli_token_invalid":
           return "CLI token is invalid or has been revoked.";
       }
+      return "Machine access was denied.";
     }
     async markDispatchAccessDenied(sessionId, sessionDoc, userTurnId, reason) {
       const message = this.getAccessDeniedMessage(reason);
@@ -124315,7 +124324,7 @@ $mem | ConvertTo-Json -Compress
         getActiveTurnId: (sessionId) => this.store.getActiveTurnId(sessionId),
         clearActiveTurnId: (sessionId, turnId) => this.clearActiveTurnIdIfMatches(sessionId, turnId),
         buildAcpPromptBlocks: async (args2) => await this.buildAcpPromptBlocks(args2),
-        applyAcpModeAndModel: async (session, config22) => await this.applyAcpModeAndModel(session, config22),
+        applyAcpModeAndModel: async (session, acpConfig) => await this.applyAcpModeAndModel(session, acpConfig),
         createAssistantEntryForTurn: async (sessionId, sessionDoc, turnId, modelInfo, userTurnId) => await this.createAssistantEntryForTurn(sessionId, sessionDoc, turnId, modelInfo, userTurnId),
         turnFinalization: {
           finalizeACPState: async (sessionId) => await this.finalizeACPState(sessionId),
@@ -124620,7 +124629,7 @@ $mem | ConvertTo-Json -Compress
     trackPendingContextWindowPersist(sessionId, promise) {
       const state2 = this.store.get(sessionId);
       state2.pendingContextWindowHandlers.add(promise);
-      promise.finally(() => {
+      void promise.finally(() => {
         state2.pendingContextWindowHandlers.delete(promise);
       });
     }
@@ -125088,7 +125097,7 @@ $mem | ConvertTo-Json -Compress
       }
     }
     setupSessionEventHandlers() {
-      this.sessionManager.on("output", async (output) => {
+      this.sessionManager.on("output", (output) => {
         this.logger.debug(`Output from session [${output.sessionId}]: <${output.data.length} bytes>`);
       });
       this.sessionManager.on("onACPUpdateMessage", (sessionId, update2) => {
@@ -125098,53 +125107,59 @@ $mem | ConvertTo-Json -Compress
         const promise = this.handleUsageUpdate(sessionId, acpSessionId, usage);
         const usageState = this.store.get(sessionId);
         usageState.pendingUsageHandlers.add(promise);
-        promise.finally(() => {
+        void promise.finally(() => {
           usageState.pendingUsageHandlers.delete(promise);
         });
       });
       this.sessionManager.on("onContextWindowUsageUpdate", (sessionId, usage) => {
         this.enqueueContextWindowUsageUpdate(sessionId, usage);
       });
-      this.sessionManager.on("onRateLimitUpdate", async (machineId, cliType, limits) => {
-        await this.workspaceDocument.updateRateLimits(machineId, cliType, limits);
+      this.sessionManager.on("onRateLimitUpdate", (machineId, cliType, limits) => {
+        void this.workspaceDocument.updateRateLimits(machineId, cliType, limits);
       });
-      this.sessionManager.on("error", async (event) => {
-        this.logger.error(`[${event.sessionId}] Session error event received:`, event);
-        const sessionId = event.sessionId;
-        this.stopMachineSessionHeartbeat(sessionId);
-        await this.finalizeACPState(sessionId);
-        await this.flushSessionUsage(sessionId);
-        const sessionDoc = await this.workspaceDocument.getOrCreateSessionDoc(sessionId);
-        await sessionDoc.setStatus(SessionStatusFactory.idle());
-        this.logger.debug(`[${sessionId}] Status set to idle (via error event)`);
+      this.sessionManager.on("error", (event) => {
+        void (async () => {
+          this.logger.error(`[${event.sessionId}] Session error event received:`, event);
+          const sessionId = event.sessionId;
+          this.stopMachineSessionHeartbeat(sessionId);
+          await this.finalizeACPState(sessionId);
+          await this.flushSessionUsage(sessionId);
+          const sessionDoc = await this.workspaceDocument.getOrCreateSessionDoc(sessionId);
+          await sessionDoc.setStatus(SessionStatusFactory.idle());
+          this.logger.debug(`[${sessionId}] Status set to idle (via error event)`);
+        })();
       });
-      this.sessionManager.on("exit", async (exit2) => {
-        const sessionId = exit2.sessionId;
-        this.logger.debug(`[${sessionId}] Session exit event received (exitCode=${exit2.exitCode})`);
-        if (!this.store.has(sessionId)) {
-          this.logger.debug(`[${sessionId}] Ignoring exit event for GC-cleaned session`);
-          return;
-        }
-        this.stopMachineSessionHeartbeat(sessionId);
-        await this.finalizeACPState(sessionId);
-        await this.flushSessionUsage(sessionId);
-        const session = await this.workspaceDocument.getOrCreateSessionDoc(sessionId);
-        await session.setStatus(SessionStatusFactory.idle());
-        this.logger.debug(`[${sessionId}] Status set to idle (via exit event)`);
-      });
-      this.sessionManager.on("terminated", async (event) => {
-        const sessionId = event.sessionId;
-        if (!this.store.has(sessionId)) {
-          this.logger.debug(`[${sessionId}] Ignoring terminated event for GC-cleaned session`);
-          return;
-        }
-        try {
+      this.sessionManager.on("exit", (exit2) => {
+        void (async () => {
+          const sessionId = exit2.sessionId;
+          this.logger.debug(`[${sessionId}] Session exit event received (exitCode=${exit2.exitCode})`);
+          if (!this.store.has(sessionId)) {
+            this.logger.debug(`[${sessionId}] Ignoring exit event for GC-cleaned session`);
+            return;
+          }
           this.stopMachineSessionHeartbeat(sessionId);
           await this.finalizeACPState(sessionId);
           await this.flushSessionUsage(sessionId);
-        } catch (error2) {
-          this.logger.error(`[${sessionId}] Failed to handle termination event: ${formatErrorMessage(error2)}`);
-        }
+          const session = await this.workspaceDocument.getOrCreateSessionDoc(sessionId);
+          await session.setStatus(SessionStatusFactory.idle());
+          this.logger.debug(`[${sessionId}] Status set to idle (via exit event)`);
+        })();
+      });
+      this.sessionManager.on("terminated", (event) => {
+        void (async () => {
+          const sessionId = event.sessionId;
+          if (!this.store.has(sessionId)) {
+            this.logger.debug(`[${sessionId}] Ignoring terminated event for GC-cleaned session`);
+            return;
+          }
+          try {
+            this.stopMachineSessionHeartbeat(sessionId);
+            await this.finalizeACPState(sessionId);
+            await this.flushSessionUsage(sessionId);
+          } catch (error2) {
+            this.logger.error(`[${sessionId}] Failed to handle termination event: ${formatErrorMessage(error2)}`);
+          }
+        })();
       });
     }
     setupArchiveWatcher() {
@@ -125416,7 +125431,7 @@ $mem | ConvertTo-Json -Compress
       const batchWindowMs = state2.acpFlushCountInTurn === 0 ? MessageHandler.ACP_INITIAL_UPDATE_BATCH_WINDOW_MS : MessageHandler.ACP_SUBSEQUENT_UPDATE_BATCH_WINDOW_MS;
       const timer2 = setTimeout(() => {
         state2.acpFlushTimer = null;
-        this.startACPUpdateFlush(sessionId);
+        void this.startACPUpdateFlush(sessionId);
       }, batchWindowMs);
       timer2.unref?.();
       state2.acpFlushTimer = timer2;
@@ -125429,7 +125444,7 @@ $mem | ConvertTo-Json -Compress
           if (state2.acpUpdateBuffer.length === 0) {
             return;
           }
-          this.startACPUpdateFlush(sessionId);
+          void this.startACPUpdateFlush(sessionId);
         }
         const inFlight = state2.acpFlushInFlight;
         if (!inFlight) {
@@ -125585,11 +125600,11 @@ $mem | ConvertTo-Json -Compress
       try {
         await handleACPUpdateMessage(sessionDoc, queue2, {
           logger: this.logger,
-          getCurrentSessionTurnId: (sessionId2) => {
-            const tid = this.store.getTurnId(sessionId2);
+          getCurrentSessionTurnId: (currentSessionId) => {
+            const tid = this.store.getTurnId(currentSessionId);
             if (!tid) {
-              captureException(new Error(`No turn id found for session ${sessionId2}`));
-              throw new Error(`No turn id found for session ${sessionId2}`);
+              void captureException(new Error(`No turn id found for session ${currentSessionId}`));
+              throw new Error(`No turn id found for session ${currentSessionId}`);
             }
             return tid;
           }
@@ -125967,7 +125982,7 @@ $mem | ConvertTo-Json -Compress
             });
             attachedTo = "new_entry";
           } else {
-            const message2 = latestAttachTarget.kind === "unavailable" ? `Session is ${latestAttachTarget.statusType} and the original assistant turn is no longer available for image upload` : "The original assistant turn is no longer available for image upload";
+            const failureMessage = latestAttachTarget.kind === "unavailable" ? `Session is ${latestAttachTarget.statusType} and the original assistant turn is no longer available for image upload` : "The original assistant turn is no longer available for image upload";
             this.captureSessionImageUploadEvent(analyticsUserId, "session/image_upload_failed", {
               entrypoint: dispatchContext.source === "local" ? "cli_command" : "session_runtime",
               session_id: sessionId,
@@ -125977,13 +125992,13 @@ $mem | ConvertTo-Json -Compress
               local_project_id: localProjectId,
               repo_full_name: repoFullName,
               failure_reason: "active_turn_unavailable",
-              error_message: message2
+              error_message: failureMessage
             });
             respond({
               success: false,
               workspaceId: this.workspaceId,
               error: "active_turn_unavailable",
-              message: message2
+              message: failureMessage
             });
             return;
           }
@@ -126000,7 +126015,7 @@ $mem | ConvertTo-Json -Compress
         });
         if (!replaced) {
           const latestAttachTarget = await this.resolveSessionImageUploadAttachTarget(sessionId, sessionDoc);
-          const message2 = latestAttachTarget.kind === "active_turn" ? "Session started a new assistant turn during image upload; retry after the turn completes" : latestAttachTarget.kind === "unavailable" ? `Session is ${latestAttachTarget.statusType} and no idle assistant entry can be created` : "Reserved assistant image entry is no longer available";
+          const failureMessage = latestAttachTarget.kind === "active_turn" ? "Session started a new assistant turn during image upload; retry after the turn completes" : latestAttachTarget.kind === "unavailable" ? `Session is ${latestAttachTarget.statusType} and no idle assistant entry can be created` : "Reserved assistant image entry is no longer available";
           this.captureSessionImageUploadEvent(analyticsUserId, "session/image_upload_failed", {
             entrypoint: dispatchContext.source === "local" ? "cli_command" : "session_runtime",
             session_id: sessionId,
@@ -126010,13 +126025,13 @@ $mem | ConvertTo-Json -Compress
             local_project_id: localProjectId,
             repo_full_name: repoFullName,
             failure_reason: "active_turn_unavailable",
-            error_message: message2
+            error_message: failureMessage
           });
           respond({
             success: false,
             workspaceId: this.workspaceId,
             error: "active_turn_unavailable",
-            message: message2
+            message: failureMessage
           });
           return;
         }
@@ -126254,20 +126269,22 @@ $mem | ConvertTo-Json -Compress
           });
         }
         checkForOutcome();
-        timeoutId = setTimeout(async () => {
-          if (resolved) return;
-          this.logger.warn(`Permission request timed out for session ${sessionId}`);
-          this.logger.debug(`[${sessionId}] Permission request ${requestId} timed out after ${PERMISSION_REQUEST_TIMEOUT_MS}ms`);
-          try {
-            await updatePermissionOutcomeInHistory(doc, requestId, {
+        timeoutId = setTimeout(() => {
+          void (async () => {
+            if (resolved) return;
+            this.logger.warn(`Permission request timed out for session ${sessionId}`);
+            this.logger.debug(`[${sessionId}] Permission request ${requestId} timed out after ${PERMISSION_REQUEST_TIMEOUT_MS}ms`);
+            try {
+              await updatePermissionOutcomeInHistory(doc, requestId, {
+                outcome: "cancelled"
+              }, this.logger);
+            } catch (error2) {
+              this.logger.error(`[${sessionId}] Failed to update permission timeout in history: ${formatErrorMessage(error2)}`);
+            }
+            void resolveWithOutcome({
               outcome: "cancelled"
-            }, this.logger);
-          } catch (error2) {
-            this.logger.error(`[${sessionId}] Failed to update permission timeout in history: ${formatErrorMessage(error2)}`);
-          }
-          void resolveWithOutcome({
-            outcome: "cancelled"
-          });
+            });
+          })();
         }, PERMISSION_REQUEST_TIMEOUT_MS);
       });
     }
@@ -127402,7 +127419,7 @@ $mem | ConvertTo-Json -Compress
   }
   const BROKER_STATE_FILE_PATH = path__default.join(os__default.homedir(), ".lody", "broker.json");
   const createGitCredentialBrokerHandler = (options) => {
-    return async (req, res) => {
+    const handleRequest = async (req, res) => {
       try {
         if (req.method === "GET" && req.url === "/health") {
           res.writeHead(200, {
@@ -127495,6 +127512,9 @@ $mem | ConvertTo-Json -Compress
         }));
       }
     };
+    return (req, res) => {
+      void handleRequest(req, res);
+    };
   };
   const DEFAULT_HEALTH_CHECK_INTERVAL_MS = 3e4;
   const HEALTH_CHECK_TIMEOUT_MS = 5e3;
@@ -127600,15 +127620,17 @@ $mem | ConvertTo-Json -Compress
       if (this.healthCheckTimer) {
         return;
       }
-      this.healthCheckTimer = setInterval(async () => {
-        if (this.isRecovering) {
-          return;
-        }
-        const isHealthy = await this.checkHealth();
-        if (!isHealthy && this.env) {
-          this.logger.debug("Git credential broker health check failed, attempting recovery...");
-          await this.recover();
-        }
+      this.healthCheckTimer = setInterval(() => {
+        void (async () => {
+          if (this.isRecovering) {
+            return;
+          }
+          const isHealthy = await this.checkHealth();
+          if (!isHealthy && this.env) {
+            this.logger.debug("Git credential broker health check failed, attempting recovery...");
+            await this.recover();
+          }
+        })();
       }, DEFAULT_HEALTH_CHECK_INTERVAL_MS);
       this.healthCheckTimer.unref();
     }
@@ -133609,37 +133631,14 @@ export PATH=${toSingleQuotedShellString(ghShimBinDir)}:"$PATH"
         args: callbacks.args ?? [],
         getStderrTail: () => stderrTail
       });
-      agentProcess.stdin?.on("error", (err2) => {
-        if (err2.code !== "EPIPE") {
-          this.logger.error(`[${this.sessionId}] Agent stdin error: ${err2.message}`);
-        }
-      });
-      const input2 = new WritableStream({
-        write(chunk) {
-          if (agentProcess.stdin && !agentProcess.stdin.destroyed) {
-            agentProcess.stdin.write(chunk);
-          }
-        },
-        close() {
-          if (agentProcess.stdin && !agentProcess.stdin.destroyed) {
-            agentProcess.stdin.end();
-          }
-        }
-      });
-      const output = new ReadableStream({
-        start(controller) {
-          if (!agentProcess.stdout) {
-            controller.error(new Error("Agent process stdout is not available"));
-            return;
-          }
-          agentProcess.stdout.on("data", (chunk) => {
-            controller.enqueue(chunk);
-          });
-          agentProcess.stdout.on("end", () => {
-            controller.close();
-          });
-        }
-      });
+      if (!agentProcess.stdin) {
+        throw new Error("Agent process stdin is not available");
+      }
+      if (!agentProcess.stdout) {
+        throw new Error("Agent process stdout is not available");
+      }
+      const input2 = createStdinWritableStream(agentProcess.stdin);
+      const output = createStdoutReadableStream(agentProcess.stdout);
       const stream2 = ndJsonStream(input2, output);
       this.logger.debug(`[${this.sessionId}] ndJsonStream created, calling createAcpClient`);
       const { client, acpSessionId } = await createAcpClient({
@@ -134820,11 +134819,11 @@ export PATH=${toSingleQuotedShellString(ghShimBinDir)}:"$PATH"
         responses
       });
     } catch (error2) {
-      const message2 = formatErrorMessage(error2);
-      config2.logger.debug(`Local session control dispatch failed: ${message2}`);
+      const errorMessage = formatErrorMessage(error2);
+      config2.logger.debug(`Local session control dispatch failed: ${errorMessage}`);
       jsonResponse(res, 500, {
         ok: false,
-        error: message2
+        error: errorMessage
       });
     }
   }
@@ -135021,21 +135020,23 @@ export PATH=${toSingleQuotedShellString(ghShimBinDir)}:"$PATH"
         }
         chunks.push(chunk);
       });
-      req.on("end", async () => {
-        if (res.headersSent || res.writableEnded || res.destroyed) {
-          return;
-        }
-        const raw = Buffer.concat(chunks).toString("utf8");
-        config2.logger.debug(`[local-control:${requestId}] request body received: bytes=${Buffer.byteLength(raw, "utf8")} path=${requestPath}`);
-        if (requestPath === SESSION_CONTROL_PATH$1) {
-          await handleSessionControlRequest(config2, raw, res, requestId);
-          return;
-        }
-        if (requestPath === IMAGE_UPLOAD_PATH) {
-          await handleImageUploadRequest(config2, raw, res, requestId);
-          return;
-        }
-        await handleProjectControlRequest(config2, raw, res, requestId);
+      req.on("end", () => {
+        void (async () => {
+          if (res.headersSent || res.writableEnded || res.destroyed) {
+            return;
+          }
+          const raw = Buffer.concat(chunks).toString("utf8");
+          config2.logger.debug(`[local-control:${requestId}] request body received: bytes=${Buffer.byteLength(raw, "utf8")} path=${requestPath}`);
+          if (requestPath === SESSION_CONTROL_PATH$1) {
+            await handleSessionControlRequest(config2, raw, res, requestId);
+            return;
+          }
+          if (requestPath === IMAGE_UPLOAD_PATH) {
+            await handleImageUploadRequest(config2, raw, res, requestId);
+            return;
+          }
+          await handleProjectControlRequest(config2, raw, res, requestId);
+        })();
       });
       req.on("error", (error2) => {
         config2.logger.debug(`[local-control:${requestId}] request stream error: ${error2.message}`);
@@ -136041,7 +136042,7 @@ export PATH=${toSingleQuotedShellString(ghShimBinDir)}:"$PATH"
       this.retryTimers.clear();
       this.unsubscribeWorkspaces?.();
       this.unsubscribeWorkspaces = null;
-      this.convex?.close();
+      void this.convex?.close();
       this.convex = null;
       const runtimes = Array.from(this.runtimes.values());
       this.runtimes.clear();
@@ -169751,7 +169752,7 @@ ${result.stderr}`;
       if (error2 instanceof Error && error2.name === "CommanderError") {
         process.exit(1);
       } else {
-        reportError("cli", error2, {
+        void reportError("cli", error2, {
           logger: cliLogger,
           fatal: true
         }).finally(() => process.exit(1));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lody",
-  "version": "0.46.2-next.1",
+  "version": "0.47.0",
   "description": "Lody Agent CLI tool for managing remote command execution",
   "type": "module",
   "main": "dist/index.js",
@@ -28,7 +28,7 @@
     "@better-auth/api-key": "1.5.5",
     "@convex-dev/better-auth": "0.11.2",
     "@loro-dev/flock-wasm": "^0.2.1",
-    "@loro-dev/streams-crdt": "0.8.0",
+    "@loro-dev/streams-crdt": "0.8.1",
     "@sentry/node": "^10.29.0",
     "@types/cross-spawn": "^6.0.6",
     "@types/iconv-lite": "^0.0.1",
@@ -73,8 +73,8 @@
     "ws": "^8.18.3",
     "zod": "^4.1.5",
     "@lody/convex": "0.0.1",
-    "@lody/cli-supervisor": "0.0.1",
     "@lody/loro-streams-rpc": "0.0.1",
+    "@lody/cli-supervisor": "0.0.1",
     "@lody/shared": "0.0.1",
     "loro-code": "0.0.1"
   },