chatroom-cli 1.53.1 → 1.53.2

package/dist/index.js

@@ -79715,9 +79715,11 @@ var init_featureFlags = __esm(() => {
 });
 
 // ../../services/backend/config/reliability.ts
-var DAEMON_HEARTBEAT_INTERVAL_MS = 30000, AGENT_REQUEST_DEADLINE_MS = 120000, OBSERVATION_TTL_MS = 60000, OBSERVED_FULL_PUSH_INTERVAL_MS, OBSERVED_SAFETY_POLL_MS = 30000;
+var DAEMON_HEARTBEAT_INTERVAL_MS = 30000, AGENT_REQUEST_DEADLINE_MS = 120000, OBSERVATION_TTL_MS = 60000, OBSERVED_FULL_PUSH_INTERVAL_MS, OBSERVED_SAFETY_POLL_MS = 30000, WORKSPACE_RECENCY_WINDOW_MS, WORKSPACE_LIST_RECONCILE_MS;
 var init_reliability = __esm(() => {
   OBSERVED_FULL_PUSH_INTERVAL_MS = 5 * 60000;
+  WORKSPACE_RECENCY_WINDOW_MS = 7 * 24 * 60 * 60 * 1000;
+  WORKSPACE_LIST_RECONCILE_MS = 60 * 60 * 1000;
 });
 
 // src/commands/machine/daemon-start/capabilities-snapshot.ts
@@ -79987,34 +79989,30 @@ var init_command_discovery = __esm(() => {
 });
 
 // src/commands/machine/daemon-start/workspace-cache.ts
-function invalidateWorkspacesForMachineCache(ctx) {
-  delete ctx._workspacesCache;
-}
 async function getWorkspacesForMachine(ctx) {
-  const extended = ctx;
-  const now = Date.now();
-  const cached4 = extended._workspacesCache;
-  if (cached4 && now - cached4.fetchedAt < CACHE_TTL_MS) {
-    return cached4.workspaces;
+  const store = ctx.workspaceListStore;
+  if (store && store.updatedAt > 0) {
+    return store.workspaces;
   }
   try {
-    const workspaces = await ctx.deps.backend.query(api.workspaces.listWorkspacesForMachine, {
+    const workspaces = await ctx.deps.backend.query(api.workspaces.listRecentlyObservedWorkspacesForMachine, {
       sessionId: ctx.sessionId,
       machineId: ctx.machineId
     });
-    extended._workspacesCache = { fetchedAt: now, workspaces };
-    return workspaces;
+    const mapped = workspaces.map((ws) => ({ workingDir: ws.workingDir }));
+    if (store) {
+      store.workspaces = mapped;
+      store.updatedAt = Date.now();
+    }
+    return mapped;
   } catch (err) {
     console.warn(`[${formatTimestamp()}] ⚠️ Failed to query workspaces: ${getErrorMessage(err)}`);
     return [];
   }
 }
-var CACHE_TTL_MS;
 var init_workspace_cache = __esm(() => {
-  init_reliability();
   init_api3();
   init_convex_error();
-  CACHE_TTL_MS = DAEMON_HEARTBEAT_INTERVAL_MS;
 });
 
 // src/commands/machine/daemon-start/command-sync-heartbeat.ts
@@ -83159,7 +83157,45 @@ var init_output_store = __esm(() => {
   RUN_ID_RE = /^[a-z0-9]+$/i;
 });
 
-// src/commands/machine/daemon-start/handlers/process/log-observer-sync.ts
+// src/commands/machine/daemon-start/handlers/process/log-observer-subscription.ts
+function setsEqual(a, b) {
+  if (a.size !== b.size)
+    return false;
+  for (const id3 of a) {
+    if (!b.has(id3))
+      return false;
+  }
+  return true;
+}
+function formatRunIdShort(runId) {
+  return runId.length > 8 ? `${runId.slice(0, 8)}…` : runId;
+}
+function logObserverSetChangeIfNeeded(runs) {
+  const nextObserved = new Set;
+  const nextPending = new Set;
+  for (const run3 of runs) {
+    nextObserved.add(run3._id);
+    if (run3.pendingFullOutputSync) {
+      nextPending.add(run3._id);
+    }
+  }
+  if (setsEqual(observedRunIds, nextObserved) && setsEqual(pendingFullSyncRunIds, nextPending)) {
+    return;
+  }
+  const runSummaries = [...nextObserved].map(formatRunIdShort).join(", ") || "none";
+  console.log(`[${formatTimestamp()}] \uD83D\uDCDC Log observers updated: ${nextObserved.size} run(s) [${runSummaries}] pendingFull=${nextPending.size}`);
+}
+function applyObservedRuns(runs) {
+  logObserverSetChangeIfNeeded(runs);
+  observedRunIds.clear();
+  pendingFullSyncRunIds.clear();
+  for (const run3 of runs) {
+    observedRunIds.add(run3._id);
+    if (run3.pendingFullOutputSync) {
+      pendingFullSyncRunIds.add(run3._id);
+    }
+  }
+}
 function isRunLogObserved(runId) {
   return observedRunIds.has(runId);
 }
@@ -83169,77 +83205,41 @@ function consumePendingFullSync(runId) {
   pendingFullSyncRunIds.delete(runId);
   return true;
 }
-function startLogObserverPoll(ctx) {
+function startLogObserverSubscription(ctx, wsClient2) {
+  const queryArgs = {
+    sessionId: ctx.sessionId,
+    machineId: ctx.machineId
+  };
   let stopped = false;
-  let consecutiveIdlePolls = 0;
-  let pollInFlight = false;
-  let timeoutHandle = null;
-  const scheduleNext = (delayMs) => {
+  const unsubscribe = wsClient2.onUpdate(api.daemon.commands.listRunsWithLogObservers, queryArgs, (runs) => {
     if (stopped)
       return;
-    if (timeoutHandle)
-      clearTimeout(timeoutHandle);
-    timeoutHandle = setTimeout(() => {
-      poll4();
-    }, delayMs);
-    timeoutHandle.unref?.();
-  };
-  const poll4 = async () => {
-    if (stopped || pollInFlight)
-      return;
-    const hasLocalObservers = observedRunIds.size > 0;
-    if (!hasLocalObservers && consecutiveIdlePolls >= IDLE_SKIP_AFTER_CONSECUTIVE) {
-      scheduleNext(IDLE_POLL_INTERVAL_MS);
-      return;
-    }
-    pollInFlight = true;
-    try {
-      const runs = await ctx.deps.backend.query(api.commands.listRunsWithLogObservers, {
-        sessionId: ctx.sessionId,
-        machineId: ctx.machineId
-      });
-      observedRunIds.clear();
-      pendingFullSyncRunIds.clear();
-      for (const run3 of runs) {
-        observedRunIds.add(run3._id);
-        if (run3.pendingFullOutputSync) {
-          pendingFullSyncRunIds.add(run3._id);
-        }
-      }
-      const isActive2 = runs.length > 0 || hasLocalObservers;
-      if (isActive2) {
-        consecutiveIdlePolls = 0;
-        scheduleNext(ACTIVE_POLL_INTERVAL_MS);
-      } else {
-        consecutiveIdlePolls++;
-        scheduleNext(consecutiveIdlePolls >= IDLE_SKIP_AFTER_CONSECUTIVE ? IDLE_POLL_INTERVAL_MS : ACTIVE_POLL_INTERVAL_MS);
-      }
-    } catch (err) {
-      console.warn(`[${formatTimestamp()}] ⚠️ Log-observer poll failed: ${getErrorMessage(err)}`);
-      scheduleNext(ACTIVE_POLL_INTERVAL_MS);
-    } finally {
-      pollInFlight = false;
-    }
-  };
-  poll4();
+    applyObservedRuns(runs ?? []);
+  }, (err) => {
+    console.warn(`[${formatTimestamp()}] ⚠️ Log-observer subscription error: ${getErrorMessage(err)}`);
+  });
+  console.log(`[${formatTimestamp()}] \uD83D\uDCDC Log-observer subscription started`);
   return {
     stop: () => {
       stopped = true;
-      if (timeoutHandle)
-        clearTimeout(timeoutHandle);
+      unsubscribe();
       observedRunIds.clear();
       pendingFullSyncRunIds.clear();
+      console.log(`[${formatTimestamp()}] \uD83D\uDCDC Log-observer subscription stopped`);
     }
   };
 }
-var observedRunIds, pendingFullSyncRunIds, ACTIVE_POLL_INTERVAL_MS, IDLE_POLL_INTERVAL_MS = 15000, IDLE_SKIP_AFTER_CONSECUTIVE = 3;
-var init_log_observer_sync = __esm(() => {
+var observedRunIds, pendingFullSyncRunIds;
+var init_log_observer_subscription = __esm(() => {
   init_api3();
   init_convex_error();
-  init_state2();
   observedRunIds = new Set;
   pendingFullSyncRunIds = new Set;
-  ACTIVE_POLL_INTERVAL_MS = OUTPUT_FLUSH_INTERVAL_MS;
+});
+
+// src/commands/machine/daemon-start/handlers/process/log-observer-sync.ts
+var init_log_observer_sync = __esm(() => {
+  init_log_observer_subscription();
 });
 
 // src/commands/machine/daemon-start/handlers/process/spawner.ts
@@ -85246,6 +85246,62 @@ var init_observed_sync = __esm(() => {
   init_convex_error();
 });
 
+// src/commands/machine/daemon-start/workspace-list-subscription.ts
+function toSyncWorkspaces(workspaces) {
+  return workspaces.map((ws) => ({ workingDir: ws.workingDir }));
+}
+function applyWorkspaceList(ctx, workspaces) {
+  if (!ctx.workspaceListStore)
+    return;
+  ctx.workspaceListStore.workspaces = toSyncWorkspaces(workspaces);
+  ctx.workspaceListStore.updatedAt = Date.now();
+}
+function startWorkspaceListSubscription(ctx, wsClient2) {
+  ctx.workspaceListStore = { workspaces: [], updatedAt: 0 };
+  const queryArgs = {
+    sessionId: ctx.sessionId,
+    machineId: ctx.machineId,
+    recencyWindowMs: WORKSPACE_RECENCY_WINDOW_MS
+  };
+  let stopped = false;
+  let reconcileInFlight = false;
+  const unsubscribe = wsClient2.onUpdate(api.workspaces.listRecentlyObservedWorkspacesForMachine, queryArgs, (workspaces) => {
+    if (stopped)
+      return;
+    applyWorkspaceList(ctx, workspaces ?? []);
+  }, (err) => {
+    console.warn(`[${formatTimestamp()}] ⚠️ Workspace-list subscription error: ${getErrorMessage(err)}`);
+  });
+  const reconcileTimer = setInterval(() => {
+    if (stopped || reconcileInFlight)
+      return;
+    reconcileInFlight = true;
+    ctx.deps.backend.query(api.workspaces.listRecentlyObservedWorkspacesForMachine, queryArgs).then((workspaces) => {
+      if (!stopped)
+        applyWorkspaceList(ctx, workspaces ?? []);
+    }).catch((err) => {
+      console.warn(`[${formatTimestamp()}] ⚠️ Workspace-list reconcile failed: ${getErrorMessage(err)}`);
+    }).finally(() => {
+      reconcileInFlight = false;
+    });
+  }, WORKSPACE_LIST_RECONCILE_MS);
+  console.log(`[${formatTimestamp()}] \uD83D\uDCC2 Workspace-list subscription started`);
+  return {
+    stop: () => {
+      stopped = true;
+      unsubscribe();
+      clearInterval(reconcileTimer);
+      delete ctx.workspaceListStore;
+      console.log(`[${formatTimestamp()}] \uD83D\uDCC2 Workspace-list subscription stopped`);
+    }
+  };
+}
+var init_workspace_list_subscription = __esm(() => {
+  init_reliability();
+  init_api3();
+  init_convex_error();
+});
+
 // src/infrastructure/git/git-writer.ts
 import { exec as exec5 } from "node:child_process";
 import { promisify as promisify5 } from "node:util";
@@ -85961,7 +86017,6 @@ async function startCommandLoop(ctx) {
     }).then(() => {
       heartbeatCount++;
       console.log(`[${formatTimestamp()}] \uD83D\uDC93 Daemon heartbeat #${heartbeatCount} OK`);
-      invalidateWorkspacesForMachineCache(ctx);
       if (!ctx.observedSyncEnabled) {
         pushGitState(ctx).catch((err) => {
           console.warn(`[${formatTimestamp()}] ⚠️  Git state push failed: ${getErrorMessage(err)}`);
@@ -85981,8 +86036,9 @@ async function startCommandLoop(ctx) {
   let gitSubscriptionHandle = null;
   let fileContentSubscriptionHandle = null;
   let fileTreeSubscriptionHandle = null;
+  let workspaceListSubscriptionHandle = null;
   let observedSyncSubscriptionHandle = null;
-  let logObserverPollHandle = null;
+  let logObserverSubscriptionHandle = null;
   let pendingPromptSubscriptionHandle = null;
   let pendingHarnessSessionSubscriptionHandle = null;
   let commandSubscriptionHandle = null;
@@ -86006,10 +86062,12 @@ async function startCommandLoop(ctx) {
       fileContentSubscriptionHandle.stop();
     if (fileTreeSubscriptionHandle)
       fileTreeSubscriptionHandle.stop();
+    if (workspaceListSubscriptionHandle)
+      workspaceListSubscriptionHandle.stop();
     if (observedSyncSubscriptionHandle)
       observedSyncSubscriptionHandle.stop();
-    if (logObserverPollHandle)
-      logObserverPollHandle.stop();
+    if (logObserverSubscriptionHandle)
+      logObserverSubscriptionHandle.stop();
     if (pendingPromptSubscriptionHandle)
       pendingPromptSubscriptionHandle.stop();
     if (pendingHarnessSessionSubscriptionHandle)
@@ -86035,10 +86093,11 @@ async function startCommandLoop(ctx) {
   gitSubscriptionHandle = startGitRequestSubscription(ctx, wsClient2);
   fileContentSubscriptionHandle = startFileContentSubscription(ctx, wsClient2);
   fileTreeSubscriptionHandle = startFileTreeSubscription(ctx, wsClient2);
+  workspaceListSubscriptionHandle = startWorkspaceListSubscription(ctx, wsClient2);
   if (ctx.observedSyncEnabled) {
     observedSyncSubscriptionHandle = startObservedSyncSubscription(ctx, wsClient2);
   }
-  logObserverPollHandle = startLogObserverPoll(ctx);
+  logObserverSubscriptionHandle = startLogObserverSubscription(ctx, wsClient2);
   if (featureFlags.directHarnessWorkers) {
     const sessionRepository = new ConvexSessionRepository({
       backend: ctx.deps.backend,
@@ -86128,8 +86187,8 @@ var init_command_loop = __esm(() => {
   init_manager();
   init_init2();
   init_log_observer_sync();
-  init_workspace_cache();
   init_observed_sync();
+  init_workspace_list_subscription();
   init_api3();
   init_client2();
   init_local_actions();
@@ -87304,8 +87363,8 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
   if (!sessionId)
     return;
   const client4 = await getConvexClient2();
-  sendLifecycleHeartbeat2(client4, { sessionId, chatroomId, role, action: actionCommand.name() });
+  sendLifecycleHeartbeat2(client4, { sessionId, chatroomId, role });
 });
 program2.parse();
 
-//# debugId=D59205F0E7B31DAD64756E2164756E21
+//# debugId=C18F126578765BC664756E2164756E21