chatroom-cli 1.49.2 → 1.50.0

package/dist/index.js

@@ -82750,6 +82750,24 @@ class TempFileOutputStore {
       totalBytes: this.state.totalBytes
     };
   }
+  async getLastNLines(maxLines) {
+    let source;
+    try {
+      source = await readFile8(this.state.filePath, "utf-8");
+    } catch {
+      source = this.state.inMemory;
+    }
+    const lines = source.split(`
+`);
+    const slice = lines.length > maxLines ? lines.slice(-maxLines) : lines;
+    const content = slice.join(`
+`);
+    return {
+      content,
+      totalBytes: Buffer.byteLength(content, "utf-8"),
+      lineCount: slice.length
+    };
+  }
   async getFullOutput() {
     try {
       return await readFile8(this.state.filePath, "utf-8");
@@ -82778,39 +82796,96 @@ async function cleanOrphanTempFiles() {
     await rm(TEMP_DIR, { recursive: true, force: true });
   } catch {}
 }
-var TAIL_WINDOW_BYTES, TEMP_DIR, RUN_ID_RE;
+var TAIL_WINDOW_BYTES, TEMP_DIR, RUN_ID_RE, MAX_TAIL_LINES_V2 = 50;
 var init_output_store = __esm(() => {
   TAIL_WINDOW_BYTES = 32 * 1024;
   TEMP_DIR = join17(tmpdir(), "chatroom-cli", "runs");
   RUN_ID_RE = /^[a-z0-9]+$/i;
 });
 
+// src/commands/machine/daemon-start/handlers/process/log-observer-sync.ts
+function isRunLogObserved(runId) {
+  return observedRunIds.has(runId);
+}
+function consumePendingFullSync(runId) {
+  if (!pendingFullSyncRunIds.has(runId))
+    return false;
+  pendingFullSyncRunIds.delete(runId);
+  return true;
+}
+function startLogObserverPoll(ctx) {
+  let stopped = false;
+  const poll4 = async () => {
+    if (stopped)
+      return;
+    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);
+        }
+      }
+    } catch (err) {
+      console.warn(`[${formatTimestamp()}] ⚠️ Log-observer poll failed: ${getErrorMessage(err)}`);
+    }
+  };
+  poll4();
+  const handle = setInterval(() => {
+    poll4();
+  }, OUTPUT_FLUSH_INTERVAL_MS);
+  handle.unref?.();
+  return {
+    stop: () => {
+      stopped = true;
+      clearInterval(handle);
+      observedRunIds.clear();
+      pendingFullSyncRunIds.clear();
+    }
+  };
+}
+var observedRunIds, pendingFullSyncRunIds;
+var init_log_observer_sync = __esm(() => {
+  init_api3();
+  init_convex_error();
+  init_state2();
+  observedRunIds = new Set;
+  pendingFullSyncRunIds = new Set;
+});
+
 // src/commands/machine/daemon-start/handlers/process/spawner.ts
 import { spawn as spawn4 } from "node:child_process";
-async function flushTail(ctx, tracked) {
-  const tail = tracked.store.getTail();
+async function flushTailV2(ctx, tracked) {
+  if (!isRunLogObserved(tracked.runId))
+    return;
+  const tail = await tracked.store.getLastNLines(MAX_TAIL_LINES_V2);
   if (tail.content.length === 0)
     return;
   const compressed = encodeOutput(tail.content);
   try {
-    await ctx.deps.backend.mutation(api.commands.updateRunTail, {
+    await ctx.deps.backend.mutation(api.commands.updateRunTailV2, {
       sessionId: ctx.sessionId,
       machineId: ctx.machineId,
       runId: tracked.runId,
       tailOutput: {
         compression: compressed.compression,
         content: compressed.content,
-        byteLength: tail.content.length,
+        byteLength: tail.totalBytes,
         totalBytesWritten: tail.totalBytes,
-        updatedAt: Date.now()
+        updatedAt: Date.now(),
+        lineCount: tail.lineCount
       }
     });
   } catch (err) {
     console.warn(`[${formatTimestamp()}] ⚠️ Failed to flush tail for run ${tracked.runId}: ${getErrorMessage(err)}`);
   }
 }
-async function flushFinalChunks(ctx, tracked, runId) {
-  await flushTail(ctx, tracked);
+async function appendFullOutputChunks(ctx, tracked, runId) {
   let fullOutput;
   try {
     fullOutput = await tracked.store.getFullOutput();
@@ -82834,11 +82909,31 @@ async function flushFinalChunks(ctx, tracked, runId) {
       });
       chunkIndex++;
     } catch (err) {
-      console.error(`[${formatTimestamp()}] ❌ Failed to flush final chunk ${chunkIndex} for run ${tracked.runId}: ${getErrorMessage(err)}`);
+      console.error(`[${formatTimestamp()}] ❌ Failed to flush chunk ${chunkIndex} for run ${tracked.runId}: ${getErrorMessage(err)}`);
       return;
     }
   }
 }
+async function flushFinalChunks(ctx, tracked, runId) {
+  await flushTailV2(ctx, tracked);
+  if (consumePendingFullSync(tracked.runId)) {
+    await appendFullOutputChunks(ctx, tracked, runId);
+  }
+}
+async function syncFullOutputOnRequest(ctx, tracked, runId) {
+  if (!consumePendingFullSync(tracked.runId))
+    return;
+  await appendFullOutputChunks(ctx, tracked, runId);
+  try {
+    await ctx.deps.backend.mutation(api.commands.clearPendingFullOutputSync, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      runId
+    });
+  } catch (err) {
+    console.warn(`[${formatTimestamp()}] ⚠️ Failed to clear pending full sync for ${tracked.runId}: ${getErrorMessage(err)}`);
+  }
+}
 async function spawnCommandProcess(ctx, event, commandKey) {
   const { workingDir, commandName, script, runId } = event;
   const runIdStr = runId.toString();
@@ -82860,7 +82955,8 @@ async function spawnCommandProcess(ctx, event, commandKey) {
     store,
     startedAt: Date.now(),
     flushTimer: setInterval(() => {
-      flushTail(ctx, tracked).catch(() => {});
+      flushTailV2(ctx, tracked).catch(() => {});
+      syncFullOutputOnRequest(ctx, tracked, runId).catch(() => {});
     }, OUTPUT_FLUSH_INTERVAL_MS),
     softTimeoutTimer: null,
     terminationIntent: null
@@ -82927,7 +83023,7 @@ async function spawnCommandProcess(ctx, event, commandKey) {
     }
   };
   child.on("exit", (code2, signal) => {
-    console.log(`[${formatTimestamp()}] \uD83C\uDFC1 Command exited: ${commandName} (code=${code2}, signal=${signal})`);
+    console.log(`[${formatTimestamp()}] \uD83D\uDCCB Command exited: ${commandName} (code=${code2}, signal=${signal})`);
     finalize(code2, signal).catch(() => {});
   });
   child.on("error", async (err) => {
@@ -82946,6 +83042,7 @@ var init_spawner = __esm(() => {
   init_manager();
   init_killer();
   init_output_store();
+  init_log_observer_sync();
 });
 
 // src/commands/machine/daemon-start/handlers/command-runner.ts
@@ -85277,6 +85374,7 @@ async function startCommandLoop(ctx) {
   let fileContentSubscriptionHandle = null;
   let fileTreeSubscriptionHandle = null;
   let observedSyncSubscriptionHandle = null;
+  let logObserverPollHandle = null;
   let pendingPromptSubscriptionHandle = null;
   let pendingHarnessSessionSubscriptionHandle = null;
   let commandSubscriptionHandle = null;
@@ -85302,6 +85400,8 @@ async function startCommandLoop(ctx) {
       fileTreeSubscriptionHandle.stop();
     if (observedSyncSubscriptionHandle)
       observedSyncSubscriptionHandle.stop();
+    if (logObserverPollHandle)
+      logObserverPollHandle.stop();
     if (pendingPromptSubscriptionHandle)
       pendingPromptSubscriptionHandle.stop();
     if (pendingHarnessSessionSubscriptionHandle)
@@ -85330,6 +85430,7 @@ async function startCommandLoop(ctx) {
   if (ctx.observedSyncEnabled) {
     observedSyncSubscriptionHandle = startObservedSyncSubscription(ctx, wsClient2);
   }
+  logObserverPollHandle = startLogObserverPoll(ctx);
   if (featureFlags.directHarnessWorkers) {
     const sessionRepository = new ConvexSessionRepository({
       backend: ctx.deps.backend,
@@ -85418,6 +85519,7 @@ var init_command_loop = __esm(() => {
   init_command_runner();
   init_manager();
   init_init2();
+  init_log_observer_sync();
   init_observed_sync();
   init_api3();
   init_client2();
@@ -86597,4 +86699,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=4BF4F3B3AF6C84CB64756E2164756E21
+//# debugId=3E031CCB2CBFFA9464756E2164756E21