lody 0.46.0 → 0.46.2-next.1

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 ?? "production",
+      environment: options.environment ?? "staging",
       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.0";
+  const version$4 = "0.46.2-next.1";
   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("production");
+  const getRuntimeEnv = () => normalizeRuntimeEnv("staging");
   const isDevEnv = () => getRuntimeEnv() === "dev";
   const runtimeEnv = getRuntimeEnv();
-  const environment$1 = "production";
+  const environment$1 = "staging";
   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) || 0.2;
-  const profilesSampleRate = Number(process.env.SENTRY_PROFILES_SAMPLE_RATE) || 0.1;
+  const tracesSampleRate = Number(process.env.SENTRY_TRACES_SAMPLE_RATE) || 1;
+  const profilesSampleRate = Number(process.env.SENTRY_PROFILES_SAMPLE_RATE) || 0.25;
   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://nautical-curlew-181.convex.cloud";
+  let LODY_AUTH_URL = "https://impressive-guineapig-165.convex.cloud";
   let LODY_AUTH_SITE_URL = "";
-  let LODY_SERVER_URL = "https://api.lody.ai";
-  let SITE_URL = "https://lody.ai";
+  let LODY_SERVER_URL = "https://lody-server.lz-9c5.workers.dev";
+  let SITE_URL = "https://main.lody.pages.dev";
   let SITE_APP_BASE_PATH = "";
   const loadEnv = () => {
-    LODY_AUTH_URL = "https://nautical-curlew-181.convex.cloud";
+    LODY_AUTH_URL = "https://impressive-guineapig-165.convex.cloud";
     LODY_AUTH_SITE_URL = "";
-    LODY_SERVER_URL = "https://api.lody.ai";
-    SITE_URL = "https://lody.ai";
+    LODY_SERVER_URL = "https://lody-server.lz-9c5.workers.dev";
+    SITE_URL = "https://main.lody.pages.dev";
     SITE_APP_BASE_PATH = process.env["SITE_APP_BASE_PATH"] ?? "";
   };
   const MACHINE_ID_FILE_NAME = "machine-id";
@@ -74740,6 +74740,59 @@ Task description:
     }
     return CONTAINER_TYPES.includes(value.kind());
   }
+  class EphemeralStore {
+    constructor(timeout2 = 3e4) {
+      this.inner = new EphemeralStoreWasm(timeout2);
+      this.timeout = timeout2;
+    }
+    apply(bytes) {
+      this.inner.apply(bytes);
+      this.startTimerIfNotEmpty();
+    }
+    set(key2, value) {
+      this.inner.set(key2, value);
+      this.startTimerIfNotEmpty();
+    }
+    delete(key2) {
+      this.inner.delete(key2);
+    }
+    get(key2) {
+      return this.inner.get(key2);
+    }
+    getAllStates() {
+      return this.inner.getAllStates();
+    }
+    encode(key2) {
+      return this.inner.encode(key2);
+    }
+    encodeAll() {
+      return this.inner.encodeAll();
+    }
+    keys() {
+      return this.inner.keys();
+    }
+    destroy() {
+      clearInterval(this.timer);
+    }
+    subscribe(listener) {
+      return this.inner.subscribe(listener);
+    }
+    subscribeLocalUpdates(listener) {
+      return this.inner.subscribeLocalUpdates(listener);
+    }
+    startTimerIfNotEmpty() {
+      if (this.inner.isEmpty() || this.timer != null) {
+        return;
+      }
+      this.timer = setInterval(() => {
+        this.inner.removeOutdated();
+        if (this.inner.isEmpty()) {
+          clearInterval(this.timer);
+          this.timer = void 0;
+        }
+      }, this.timeout / 2);
+    }
+  }
   LoroDoc.prototype.toJsonWithReplacer = function(replacer) {
     const processed = /* @__PURE__ */ new Set();
     const doc = this;
@@ -82790,6 +82843,58 @@ ${tailedOutput}` : null;
     compress: compressStreamsSnapshot,
     decompress: decompressStreamsSnapshot
   };
+  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")
+    }),
+    object({
+      type: literal("requestPermission"),
+      requestId: string$2().optional(),
+      toolCallId: string$2().optional(),
+      toolTitle: string$2().optional()
+    }),
+    object({
+      type: literal("initializing"),
+      stage: _enum([
+        "git-clone",
+        "acp",
+        "resuming"
+      ]).optional(),
+      detail: string$2().optional()
+    })
+  ]);
+  const PresenceInstanceIdSchema = string$2().min(1).transform((value) => {
+    return value;
+  });
+  const PresenceMachineStateSchema = object({
+    kind: literal("machine"),
+    machineId: string$2().min(1).transform((value) => value),
+    instanceId: PresenceInstanceIdSchema,
+    updatedAt: number$3().finite()
+  });
+  const PresenceSessionStateSchema = object({
+    kind: literal("session"),
+    sessionId: string$2().min(1).transform((value) => value),
+    machineId: string$2().min(1).transform((value) => value),
+    instanceId: PresenceInstanceIdSchema,
+    status: ActiveSessionStatusSchema,
+    updatedAt: number$3().finite()
+  });
+  discriminatedUnion("kind", [
+    PresenceMachineStateSchema,
+    PresenceSessionStateSchema
+  ]);
+  const getLodyMachinePresenceKey = (machineId, instanceId) => `machine:${encodeURIComponent(machineId)}:${encodeURIComponent(instanceId)}`;
+  const getLodySessionPresenceKey = (sessionId, instanceId) => `session:${encodeURIComponent(sessionId)}:${encodeURIComponent(instanceId)}`;
+  const toLodyPresenceStreamUrl = (durableStreamUrl) => {
+    const url = new URL(durableStreamUrl);
+    url.searchParams.set("ephemeral", LODY_PRESENCE_CHANNEL);
+    return url.toString();
+  };
   const isLoroRepoDocDeleted = (value) => {
     if (!value || typeof value !== "object") {
       return false;
@@ -92966,6 +93071,368 @@ stream:${scope2.streamId}`;
       };
     }
   };
+  function createNoopAdapter() {
+    return {
+      emptyVersion: () => ({}),
+      mergeVersions: (base) => base,
+      exportSnapshot: () => new Uint8Array(),
+      applySnapshot: () => ({}),
+      exportUpdates: () => void 0,
+      applyRemoteUpdates: () => ({}),
+      subscribeLocalUpdates: () => () => void 0
+    };
+  }
+  function normalizeEphemeralUpdate(update2) {
+    if (update2 == null || update2.byteLength === 0) return null;
+    return update2;
+  }
+  function toError$1(error2) {
+    return error2 instanceof Error ? error2 : new Error(String(error2));
+  }
+  function closedSubscriptionError() {
+    return new Error("subscription closed");
+  }
+  var EphemeralStreamCrdt = class {
+    streamUrl;
+    adaptor;
+    client;
+    reconnectConfig;
+    heartbeatMs;
+    debug;
+    joinState;
+    constructor(options) {
+      this.streamUrl = options.streamUrl;
+      this.adaptor = options.adaptor;
+      this.reconnectConfig = {
+        ...DEFAULT_RECONNECT_CONFIG,
+        ...options.reconnectConfig
+      };
+      this.heartbeatMs = options.heartbeatMs ?? 15e3;
+      this.debug = options.debug ?? false;
+      this.client = new StreamsTransportClient({
+        streamUrl: options.streamUrl,
+        adapter: createNoopAdapter(),
+        authProvider: normalizeAuthProvider(options.auth),
+        fetchImpl: options.fetch ?? globalThis.fetch.bind(globalThis),
+        reconnectConfig: this.reconnectConfig
+      });
+    }
+    async join(params) {
+      const existing = this.joinState;
+      if (existing != null) try {
+        await existing.started;
+        return {
+          ok: true,
+          value: this.createSubscription(existing, params)
+        };
+      } catch (error2) {
+        return {
+          ok: false,
+          error: toTransportError(error2)
+        };
+      }
+      const state2 = this.createJoinState();
+      state2.started = this.startJoin(state2);
+      this.joinState = state2;
+      try {
+        await state2.started;
+        return {
+          ok: true,
+          value: this.createSubscription(state2, params)
+        };
+      } catch (error2) {
+        await this.disposeJoinState(state2);
+        return {
+          ok: false,
+          error: toTransportError(error2)
+        };
+      }
+    }
+    rejoin() {
+      const state2 = this.joinState;
+      if (state2 == null || state2.closed) return;
+      state2.retryAttempt = 0;
+      state2.retrySleepController.abort();
+      state2.retrySleepController = new AbortController();
+      const previousController = state2.requestController;
+      state2.requestController = new AbortController();
+      previousController?.abort();
+      if (state2.readStatus === "disconnected" || state2.readStatus === "error") {
+        this.setReadStatus(state2, "reconnecting");
+        this.runReadLoop(state2);
+      }
+      if (state2.writeStatus === "error") {
+        this.setWriteStatus(state2, "reconnecting");
+        this.flushPendingLocal(state2);
+      }
+    }
+    async close() {
+      const state2 = this.joinState;
+      if (state2 != null) await this.disposeJoinState(state2);
+    }
+    createJoinState() {
+      return {
+        refCount: 0,
+        closed: false,
+        status: "connecting",
+        readStatus: "connecting",
+        writeStatus: "connecting",
+        statusListeners: /* @__PURE__ */ new Set(),
+        pendingLocal: new Deque(),
+        syncWaiters: [],
+        flushingLocal: false,
+        retryAttempt: 0,
+        retrySleepController: new AbortController(),
+        firstOpenSettled: false,
+        started: Promise.resolve()
+      };
+    }
+    async startJoin(state2) {
+      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}`);
+    }
+    waitForFirstOpen(state2) {
+      return new Promise((resolve2, reject) => {
+        state2.firstOpenResolve = resolve2;
+        state2.firstOpenReject = reject;
+      });
+    }
+    createSubscription(state2, params) {
+      state2.refCount += 1;
+      const statusListener = params?.onStatusChange;
+      if (statusListener != null) {
+        state2.statusListeners.add(statusListener);
+        statusListener(state2.status);
+      }
+      let unsubscribed = false;
+      return {
+        unsubscribe: () => {
+          if (unsubscribed) return;
+          unsubscribed = true;
+          if (statusListener != null) state2.statusListeners.delete(statusListener);
+          state2.refCount = Math.max(0, state2.refCount - 1);
+          if (state2.refCount === 0 && !state2.closed) this.disposeJoinState(state2);
+        },
+        get connected() {
+          return state2.status === "joined";
+        },
+        get status() {
+          return state2.status;
+        },
+        onStatusChange: (listener) => this.onStatusChange(state2, listener),
+        waitUntilSynced: async () => {
+          if (state2.closed) throw closedSubscriptionError();
+          const remaining = state2.pendingLocal.length;
+          if (remaining === 0) return;
+          return new Promise((resolve2, reject) => {
+            state2.syncWaiters.push({
+              remaining,
+              resolve: resolve2,
+              reject
+            });
+          });
+        }
+      };
+    }
+    onStatusChange(state2, listener) {
+      state2.statusListeners.add(listener);
+      listener(state2.status);
+      return () => {
+        state2.statusListeners.delete(listener);
+      };
+    }
+    async disposeJoinState(state2) {
+      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());
+      this.rejectSyncWaiters(state2, closedSubscriptionError());
+      if (this.joinState === state2) this.joinState = void 0;
+    }
+    resolveFirstOpen(state2) {
+      if (state2.firstOpenSettled) return;
+      state2.firstOpenSettled = true;
+      state2.firstOpenResolve?.();
+    }
+    rejectFirstOpen(state2, error2) {
+      if (state2.firstOpenSettled) return;
+      state2.firstOpenSettled = true;
+      state2.firstOpenReject?.(error2);
+    }
+    async runReadLoop(state2) {
+      while (!state2.closed) {
+        state2.requestController ??= new AbortController();
+        const capturedController = state2.requestController;
+        try {
+          const result = await this.client.readEphemeralSse(async (bootstrap) => {
+            if (bootstrap.byteLength > 0) await this.adaptor.applyRemoteUpdates([
+              bootstrap
+            ]);
+            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
+            ]);
+          }, capturedController.signal);
+          if (state2.closed) return;
+          if (result.kind === "ok") {
+            state2.retryAttempt = 0;
+            this.setReadStatus(state2, "reconnecting");
+            await sleep$1(0);
+            continue;
+          }
+          if (result.kind === "unsupported") throw new Error("ephemeral stream requires SSE support");
+          if (result.kind === "not-found") throw new HttpError("ephemeral stream not found", 404);
+        } catch (error2) {
+          if (state2.closed) return;
+          if (capturedController.signal.aborted) {
+            state2.requestController = new AbortController();
+            this.setReadStatus(state2, "reconnecting");
+            continue;
+          }
+          const classified = classifyFetchError(error2);
+          if (!classified.retriable || isAuthOrProtocolError(error2)) {
+            this.logError("ephemeral live read failed", error2, {
+              streamUrl: this.streamUrl,
+              code: classified.code
+            });
+            this.setReadStatus(state2, "error");
+            this.rejectFirstOpen(state2, toError$1(error2));
+            return;
+          }
+          this.setReadStatus(state2, "reconnecting");
+          if (state2.retryAttempt >= this.reconnectConfig.maxAttempts) {
+            this.logError("ephemeral live reconnect exhausted", error2, {
+              streamUrl: this.streamUrl,
+              attempts: state2.retryAttempt
+            });
+            this.setReadStatus(state2, "disconnected");
+            this.rejectFirstOpen(state2, toError$1(error2));
+            return;
+          }
+          const delay2 = computeRetryDelay(state2.retryAttempt, this.reconnectConfig);
+          state2.retryAttempt += 1;
+          await sleep$1(delay2, state2.retrySleepController.signal);
+        }
+      }
+    }
+    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);
+    }
+    async flushPendingLocal(state2) {
+      if (state2.flushingLocal || state2.closed) return;
+      state2.flushingLocal = true;
+      try {
+        while (!state2.closed) {
+          const update2 = state2.pendingLocal.peekFront();
+          if (update2 == null) return;
+          let attempt = 0;
+          while (!state2.closed) try {
+            await this.client.appendEphemeralUpdate(update2);
+            state2.pendingLocal.popFront();
+            this.notifySyncWaiters(state2, 1);
+            this.setWriteStatus(state2, "ok");
+            break;
+          } catch (error2) {
+            const classified = classifyFetchError(error2);
+            if (!classified.retriable || isAuthOrProtocolError(error2)) {
+              this.rejectSyncWaiters(state2, new Error(`ephemeral append failed: ${classified.code}`));
+              this.setWriteStatus(state2, "error");
+              return;
+            }
+            if (attempt >= this.reconnectConfig.maxAttempts) {
+              this.rejectSyncWaiters(state2, new Error("ephemeral append retry budget exhausted"));
+              this.setWriteStatus(state2, "error");
+              return;
+            }
+            this.setWriteStatus(state2, "reconnecting");
+            const delay2 = computeRetryDelay(attempt, this.reconnectConfig);
+            attempt += 1;
+            await sleep$1(delay2, state2.retrySleepController.signal);
+          }
+        }
+      } finally {
+        state2.flushingLocal = false;
+      }
+    }
+    notifySyncWaiters(state2, flushedCount) {
+      let i2 = 0;
+      while (i2 < state2.syncWaiters.length) {
+        const waiter = state2.syncWaiters[i2];
+        waiter.remaining -= flushedCount;
+        if (waiter.remaining <= 0) {
+          state2.syncWaiters.splice(i2, 1);
+          waiter.resolve();
+        } else i2 += 1;
+      }
+    }
+    rejectSyncWaiters(state2, error2) {
+      for (const waiter of state2.syncWaiters.splice(0)) waiter.reject(error2);
+    }
+    setReadStatus(state2, readStatus) {
+      if (state2.readStatus === readStatus) return;
+      state2.readStatus = readStatus;
+      this.recomputeStatus(state2);
+    }
+    setWriteStatus(state2, writeStatus) {
+      if (state2.writeStatus === writeStatus) return;
+      state2.writeStatus = writeStatus;
+      this.recomputeStatus(state2);
+    }
+    recomputeStatus(state2) {
+      const status = this.computeStatus(state2);
+      if (state2.status === status) return;
+      state2.status = status;
+      for (const listener of state2.statusListeners) listener(status);
+    }
+    computeStatus(state2) {
+      if (state2.readStatus === "error" || state2.writeStatus === "error") return "error";
+      if (state2.readStatus === "disconnected") return "disconnected";
+      if (state2.readStatus === "connecting" || state2.writeStatus === "connecting") return "connecting";
+      if (state2.readStatus === "reconnecting" || state2.writeStatus === "reconnecting") return "reconnecting";
+      return "joined";
+    }
+    logError(message, error2, detail) {
+      if (!this.debug) return;
+      console.error(`[streams-crdt] ${message}`, error2, detail);
+    }
+  };
   function composeBeforeRemoteCursorSaveHooks(...hooks2) {
     const active2 = hooks2.filter((hook) => hook != null);
     if (active2.length === 0) return;
@@ -94494,6 +94961,15 @@ stream:${scope2.streamId}`;
       }
     };
   }
+  function EphemeralStoreAdaptor(store) {
+    return {
+      encodeAll: () => store.encodeAll(),
+      applyRemoteUpdates: (updates) => {
+        for (const update2 of updates) store.apply(update2);
+      },
+      subscribeLocalUpdates: (listener) => store.subscribeLocalUpdates(listener)
+    };
+  }
   function isAfter(entry2, current2) {
     return entry2.physicalTime > current2.physicalTime || entry2.physicalTime === current2.physicalTime && entry2.logicalCounter > current2.logicalCounter;
   }
@@ -95362,6 +95838,133 @@ stream:${scope2.streamId}`;
       }
     }
   };
+  const formatErrorMessage = (error2, options = {}) => {
+    if (error2 instanceof Error) {
+      return options.includeStack ? error2.stack ?? error2.message : error2.message;
+    }
+    if (typeof error2 === "string") {
+      return error2;
+    }
+    return inspect$2(error2, {
+      depth: 5,
+      maxArrayLength: 50,
+      breakLength: 120
+    });
+  };
+  class CliPresenceRuntime {
+    constructor(options) {
+      this.options = options;
+      const durableStreamUrl = createStreamUrl({
+        bucketId: LORO_STREAMS_BUCKET_ID,
+        streamId: getLoroMetaStreamId(options.workspaceId),
+        baseUrl: options.streamsBaseUrl
+      });
+      this.transport = new EphemeralStreamCrdt({
+        streamUrl: toLodyPresenceStreamUrl(durableStreamUrl),
+        auth: options.auth,
+        adaptor: EphemeralStoreAdaptor(this.store),
+        heartbeatMs: LODY_PRESENCE_STREAM_HEARTBEAT_MS
+      });
+      this.machineTimer = setInterval(() => {
+        this.writeMachineHeartbeat();
+      }, LODY_PRESENCE_HEARTBEAT_MS);
+      this.machineTimer.unref?.();
+    }
+    instanceId = v4();
+    store = new EphemeralStore(LODY_PRESENCE_TTL_MS);
+    transport;
+    machineTimer;
+    subscription = null;
+    machineId = null;
+    machineKey = null;
+    sessionKeys = /* @__PURE__ */ new Map();
+    started = false;
+    stopped = false;
+    start() {
+      if (this.started || this.stopped) return;
+      this.started = true;
+      void this.transport.join({
+        onStatusChange: (status) => {
+          this.options.logger.debug(`[${this.options.workspaceId}] Loro presence room status: ${status}`);
+        }
+      }).then((result) => {
+        if (this.stopped) {
+          if (result.ok) result.value.unsubscribe();
+          return;
+        }
+        if (result.ok) {
+          this.subscription = result.value;
+          return;
+        }
+        this.options.logger.debug(`[${this.options.workspaceId}] Failed to join Loro presence room: ${formatErrorMessage(result.error)}`);
+      }).catch((error2) => {
+        if (this.stopped) return;
+        this.options.logger.debug(`[${this.options.workspaceId}] Failed to start Loro presence room: ${formatErrorMessage(error2)}`);
+      });
+    }
+    async stop() {
+      if (this.stopped) return;
+      this.stopped = true;
+      clearInterval(this.machineTimer);
+      this.clearMachinePresence();
+      for (const sessionId of Array.from(this.sessionKeys.keys())) {
+        this.clearSessionPresence(sessionId);
+      }
+      this.subscription?.unsubscribe();
+      this.subscription = null;
+      await this.transport.close();
+      this.store.destroy();
+    }
+    setMachineOnline(machineId) {
+      if (this.stopped) return;
+      this.machineId = machineId;
+      this.machineKey = getLodyMachinePresenceKey(machineId, this.instanceId);
+      this.writeMachineHeartbeat();
+    }
+    writeMachineHeartbeat() {
+      if (this.stopped || !this.machineId || !this.machineKey) return;
+      const state2 = {
+        kind: "machine",
+        machineId: this.machineId,
+        instanceId: this.instanceId,
+        updatedAt: getServerNow()
+      };
+      this.store.set(this.machineKey, state2);
+    }
+    setSessionPresence(args2) {
+      if (this.stopped) return;
+      if (!args2.status || args2.status.type === "idle") {
+        this.clearSessionPresence(args2.sessionId);
+        return;
+      }
+      if (!args2.machineId) {
+        return;
+      }
+      const key2 = getLodySessionPresenceKey(args2.sessionId, this.instanceId);
+      this.sessionKeys.set(args2.sessionId, key2);
+      const state2 = {
+        kind: "session",
+        sessionId: args2.sessionId,
+        machineId: args2.machineId,
+        instanceId: this.instanceId,
+        status: args2.status,
+        updatedAt: getServerNow()
+      };
+      this.store.set(key2, state2);
+    }
+    clearSessionPresence(sessionId) {
+      const key2 = this.sessionKeys.get(sessionId);
+      if (!key2) return;
+      this.sessionKeys.delete(sessionId);
+      this.store.delete(key2);
+    }
+    clearMachinePresence() {
+      if (!this.machineKey) return;
+      this.store.delete(this.machineKey);
+      this.machineKey = null;
+      this.machineId = null;
+    }
+  }
   const findLatestUserHistoryEntry = (history) => {
     for (let i2 = history.length - 1; i2 >= 0; i2--) {
       const entry2 = history[i2];
@@ -112520,19 +113123,6 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
   const shutdown = shutdown$1;
   const unsafeOffer = unsafeOffer$1;
   const take$1 = take$2;
-  const formatErrorMessage = (error2, options = {}) => {
-    if (error2 instanceof Error) {
-      return options.includeStack ? error2.stack ?? error2.message : error2.message;
-    }
-    if (typeof error2 === "string") {
-      return error2;
-    }
-    return inspect$2(error2, {
-      depth: 5,
-      maxArrayLength: 50,
-      breakLength: 120
-    });
-  };
   const isRecoverableMetaRoomStatus = (status) => status === "disconnected" || status === "error";
   class LoroConnectionRecoveryController {
     recoveryEvents = runSync(unbounded());
@@ -113640,12 +114230,13 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
     };
   };
   class LoroDocumentManager {
-    constructor(repo, workspaceId, userId, metaSub, logger2, detachTransportLogger, initialTransportStatus = "disconnected", initialMetaSyncPromise = Promise.resolve(false), initialMetaSyncCompleted = false) {
+    constructor(repo, workspaceId, userId, metaSub, logger2, detachTransportLogger, initialTransportStatus = "disconnected", initialMetaSyncPromise = Promise.resolve(false), initialMetaSyncCompleted = false, presenceRuntime = null) {
       this.repo = repo;
       this.workspaceId = workspaceId;
       this.userId = userId;
       this.logger = logger2;
       this.detachTransportLogger = detachTransportLogger;
+      this.presenceRuntime = presenceRuntime;
       this.initialMetaSyncPromise = initialMetaSyncPromise.then((completed) => {
         if (completed) {
           this.initialMetaSyncCompleted = true;
@@ -113673,6 +114264,7 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
     connectionRecovery;
     initialMetaSyncCompleted = false;
     initialMetaSyncPromise;
+    presenceRuntime;
     static async create(workspaceId, userId, token2, logger2) {
       const authBaseUrl = LODY_AUTH_SITE_URL ? normalizeBaseUrl(LODY_AUTH_SITE_URL) : LODY_AUTH_URL ? deriveConvexSiteUrl(LODY_AUTH_URL) : null;
       if (!authBaseUrl) {
@@ -113770,7 +114362,14 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
       } else {
         initialMetaSync.resolve(false);
       }
-      manager = new LoroDocumentManager(repo, workspaceId, userId, metaSub, logger2, detachTransportLogger, transportAdapter.getStatus?.() ?? "disconnected", initialMetaSync.promise, initialMetaSyncCompleted);
+      const presenceRuntime = new CliPresenceRuntime({
+        workspaceId,
+        streamsBaseUrl: streamsTokenProvider.getGatewayBaseUrl() ?? streamsBaseUrl,
+        auth: streamsTokenProvider.createAuthCallback(),
+        logger: logger2
+      });
+      presenceRuntime.start();
+      manager = new LoroDocumentManager(repo, workspaceId, userId, metaSub, logger2, detachTransportLogger, transportAdapter.getStatus?.() ?? "disconnected", initialMetaSync.promise, initialMetaSyncCompleted, presenceRuntime);
       return manager;
     }
     setTransportStatus(status) {
@@ -113840,7 +114439,7 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
         return pending2;
       }
       const initPromise2 = (async () => {
-        const sessionDoc = new SessionDocument(this.repo, sessionId, this.logger);
+        const sessionDoc = new SessionDocument(this.repo, sessionId, this.logger, this.presenceRuntime);
         await sessionDoc.init();
         if (sessionDoc.isDestroyed) {
           throw new Error(`Session doc ${sessionId} was destroyed during init`);
@@ -113856,7 +114455,7 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
       }
     }
     async getSessionHistorySnapshot(sessionId) {
-      const sessionDoc = new SessionDocument(this.repo, sessionId, this.logger);
+      const sessionDoc = new SessionDocument(this.repo, sessionId, this.logger, null);
       await sessionDoc.init({
         skipAutoRead: true
       });
@@ -113887,6 +114486,11 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
         sessionMeta.title = sanitizedTitle;
       }
       await this.repo.upsertDocMeta(sessionDoc.roomId, sessionMeta);
+      this.presenceRuntime?.setSessionPresence({
+        sessionId,
+        machineId: sessionMeta.machineId,
+        status: sessionMeta.status
+      });
       return sessionId;
     }
     async getOrOpenSessionCode(options) {
@@ -113965,6 +114569,7 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
         ...machine,
         lastSeen: getServerNow()
       });
+      this.presenceRuntime?.setMachineOnline(machineId);
     }
     async updateRateLimits(machineId, cliType, limits) {
       if (!this.machine) {
@@ -113994,6 +114599,7 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
         return;
       }
       await this.machine.sendHeartbeat();
+      this.presenceRuntime?.writeMachineHeartbeat();
     }
     async restoreMachineDocument(machineId) {
       const machineRoomId = getMachineRoomId(machineId);
@@ -114019,6 +114625,11 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
       this.logger.debug(`Started watching document existence for machine ${machineId}`);
     }
     async cleanUp(options = {}) {
+      try {
+        await this.presenceRuntime?.stop();
+      } catch (error2) {
+        this.logger.debug(`[${this.workspaceId}] Failed to stop Loro presence runtime: ${formatErrorMessage(error2)}`);
+      }
       await this.connectionRecovery.cleanUp();
       for (const [sessionId, pending2] of this.pendingSessionDocs) {
         try {
@@ -114081,10 +114692,11 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
     }
   }
   class SessionDocument {
-    constructor(repo, sessionId, logger2 = getLogger("loro")) {
+    constructor(repo, sessionId, logger2 = getLogger("loro"), presenceRuntime = null) {
       this.repo = repo;
       this.sessionId = sessionId;
       this.logger = logger2;
+      this.presenceRuntime = presenceRuntime;
       this.roomId = getSessionRoomId(this.sessionId);
     }
     mirror = null;
@@ -114510,9 +115122,15 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
       }
       const current2 = await this.repo.getDocMeta(this.roomId);
       if (isLoroRepoDocDeleted(current2)) return;
+      const currentMeta = current2?.meta;
       await this.repo.upsertDocMeta(this.roomId, {
         lastRunningSeen: getServerNow()
       });
+      this.presenceRuntime?.setSessionPresence({
+        sessionId: this.sessionId,
+        machineId: currentMeta?.machineId,
+        status: currentMeta?.status
+      });
     }
     async getStatus() {
       if (!this.mirror) {
@@ -114538,6 +115156,7 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
         this.logger.debug(`[${this.sessionId}] setStatus: doc deleted, skipping`);
         return;
       }
+      const currentMeta = current2?.meta;
       this.logger.debug(`[${this.sessionId}] setStatus: calling upsertDocMeta (status.type=${status.type})`);
       const patch2 = {
         status
@@ -114546,6 +115165,11 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
         patch2.lastRunningSeen = getServerNow();
       }
       await withSlowOperationWarning(this.repo.upsertDocMeta(this.roomId, patch2), this.logger, `repo.upsertDocMeta(status=${status.type})`, this.sessionId);
+      this.presenceRuntime?.setSessionPresence({
+        sessionId: this.sessionId,
+        machineId: currentMeta?.machineId,
+        status
+      });
       this.logger.debug(`[${this.sessionId}] setStatus: upsertDocMeta complete`);
     }
     async getHistory() {
@@ -114789,7 +115413,7 @@ ${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
       this.historyAutoReadHandle?.dispose();
       this.historyAutoReadHandle = null;
       const status = await this.getStatus();
-      if (!options.preserveStatus && (status?.type === "running" || status?.type === "requestPermission")) {
+      if (!options.preserveStatus && (status?.type === "running" || status?.type === "requestPermission" || status?.type === "initializing")) {
         await this.setStatus(SessionStatusFactory.idle());
       }
       await this.repo.unloadDoc(this.roomId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lody",
-  "version": "0.46.0",
+  "version": "0.46.2-next.1",
   "description": "Lody Agent CLI tool for managing remote command execution",
   "type": "module",
   "main": "dist/index.js",
@@ -72,11 +72,11 @@
     "winston-transport": "^4.7.1",
     "ws": "^8.18.3",
     "zod": "^4.1.5",
-    "@lody/cli-supervisor": "0.0.1",
     "@lody/convex": "0.0.1",
+    "@lody/cli-supervisor": "0.0.1",
     "@lody/loro-streams-rpc": "0.0.1",
-    "loro-code": "0.0.1",
-    "@lody/shared": "0.0.1"
+    "@lody/shared": "0.0.1",
+    "loro-code": "0.0.1"
   },
   "files": [
     "dist",