@vm0/cli 9.132.9 → 9.132.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vm0/cli",
-  "version": "9.132.9",
+  "version": "9.132.10",
   "description": "CLI application",
   "repository": {
     "type": "git",

package/zero.js

@@ -112,7 +112,7 @@ import {
   upsertZeroOrgModelProvider,
   withErrorHandler,
   zeroAgentCustomSkillNameSchema
-} from "./chunk-MPUU27KS.js";
+} from "./chunk-PUKA5E32.js";
 import {
   __toESM,
   init_esm_shims
@@ -13875,6 +13875,11 @@ var FEATURE_SWITCHES = {
     description: "Enable the PostHog analytics connector",
     enabled: false
   },
+  ["pwaOfflineCache" /* PwaOfflineCache */]: {
+    maintainer: "ethan@vm0.ai",
+    description: "Enable PWA offline caching (static asset cache-first, offline fallback page, and service worker updateViaCache: none)",
+    enabled: false
+  },
   ["mailchimpConnector" /* MailchimpConnector */]: {
     maintainer: "ethan@vm0.ai",
     description: "Enable the Mailchimp email marketing connector",
@@ -15271,6 +15276,12 @@ init_esm_shims();
 
 // src/commands/zero/run/shared.ts
 init_esm_shims();
+var TERMINAL_RUN_STATUSES = [
+  "completed",
+  "failed",
+  "timeout",
+  "cancelled"
+];
 function toRunResult(result) {
   const { checkpointId, agentSessionId, conversationId } = result;
   if (!checkpointId || !agentSessionId || !conversationId) {
@@ -15278,62 +15289,127 @@ function toRunResult(result) {
   }
   return { checkpointId, agentSessionId, conversationId };
 }
+function filterContiguousEvents(events, lastSequence) {
+  const contiguousEvents = [];
+  let expectedSequence = lastSequence + 1;
+  for (const event of events) {
+    if (event.sequenceNumber < expectedSequence) {
+      continue;
+    }
+    if (event.sequenceNumber !== expectedSequence) {
+      break;
+    }
+    contiguousEvents.push(event);
+    expectedSequence++;
+  }
+  return contiguousEvents;
+}
+var POLL_INTERVAL_MS = 1e3;
+var TERMINAL_DRAIN_POLL_INTERVAL_MS = 500;
+var TERMINAL_DRAIN_IDLE_MS = 1e3;
+var TERMINAL_DRAIN_MAX_MS = 3e3;
+function isTerminalRunResponse(runResponse) {
+  return TERMINAL_RUN_STATUSES.includes(
+    runResponse.status
+  );
+}
+function shouldDrainNextEventPage(eventsResponse, contiguousEvents) {
+  return eventsResponse.hasMore && contiguousEvents.length > 0 && contiguousEvents.length === eventsResponse.events.length;
+}
+function hasSequenceGap(eventsResponse, contiguousEvents) {
+  return eventsResponse.events.length > 0 && contiguousEvents.length < eventsResponse.events.length;
+}
+function shouldCompleteTerminalDrain(terminalSeenAt, lastTerminalProgressAt, blockedByGap) {
+  const now = Date.now();
+  const terminalElapsedMs = now - terminalSeenAt;
+  const terminalIdleMs = now - lastTerminalProgressAt;
+  return terminalElapsedMs >= TERMINAL_DRAIN_MAX_MS || !blockedByGap && terminalIdleMs >= TERMINAL_DRAIN_IDLE_MS;
+}
+function renderTerminalRunResult(runId, runResponse) {
+  if (runResponse.status === "completed") {
+    EventRenderer.renderRunCompleted(
+      runResponse.result ? toRunResult(runResponse.result) : void 0
+    );
+    return {
+      succeeded: true,
+      runId,
+      sessionId: runResponse.result?.agentSessionId,
+      checkpointId: runResponse.result?.checkpointId
+    };
+  }
+  if (runResponse.status === "failed") {
+    EventRenderer.renderRunFailed(runResponse.error, runId);
+    return { succeeded: false, runId };
+  }
+  if (runResponse.status === "timeout") {
+    console.error(source_default.red("\n\u2717 Run timed out"));
+    return { succeeded: false, runId };
+  }
+  console.error(source_default.yellow("\n\u2717 Run cancelled"));
+  return { succeeded: false, runId };
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    return setTimeout(resolve, ms);
+  });
+}
 async function pollZeroEvents(runId, options) {
   const renderer = new EventRenderer({ verbose: options?.verbose });
   let lastSequence = -1;
   let complete = false;
   let result = { succeeded: true, runId };
-  const pollIntervalMs = 1e3;
+  let terminalRunResponse;
+  let terminalSeenAt = 0;
+  let lastTerminalProgressAt = 0;
   while (!complete) {
     const eventsResponse = await getZeroRunAgentEvents(runId, {
       since: lastSequence,
       limit: 100,
       order: "asc"
     });
-    for (const event of eventsResponse.events) {
+    const contiguousEvents = filterContiguousEvents(
+      eventsResponse.events,
+      lastSequence
+    );
+    for (const event of contiguousEvents) {
       const eventData = event.eventData;
       const parsed = parseEvent(eventData);
       if (parsed) {
         renderer.render(parsed);
       }
     }
-    if (eventsResponse.events.length > 0) {
-      lastSequence = Math.max(
-        ...eventsResponse.events.map((e) => {
-          return e.sequenceNumber;
-        })
-      );
+    if (contiguousEvents.length > 0) {
+      lastSequence = contiguousEvents[contiguousEvents.length - 1].sequenceNumber;
+      if (terminalRunResponse) {
+        lastTerminalProgressAt = Date.now();
+      }
+    }
+    const blockedByGap = hasSequenceGap(eventsResponse, contiguousEvents);
+    if (shouldDrainNextEventPage(eventsResponse, contiguousEvents)) {
+      continue;
     }
     const runResponse = await getZeroRun(runId);
-    const runStatus = runResponse.status;
-    if (runStatus === "completed") {
-      complete = true;
-      EventRenderer.renderRunCompleted(
-        runResponse.result ? toRunResult(runResponse.result) : void 0
-      );
-      result = {
-        succeeded: true,
-        runId,
-        sessionId: runResponse.result?.agentSessionId,
-        checkpointId: runResponse.result?.checkpointId
-      };
-    } else if (runStatus === "failed") {
-      complete = true;
-      EventRenderer.renderRunFailed(runResponse.error, runId);
-      result = { succeeded: false, runId };
-    } else if (runStatus === "timeout") {
-      complete = true;
-      console.error(source_default.red("\n\u2717 Run timed out"));
-      result = { succeeded: false, runId };
-    } else if (runStatus === "cancelled") {
-      complete = true;
-      console.error(source_default.yellow("\n\u2717 Run cancelled"));
-      result = { succeeded: false, runId };
+    if (isTerminalRunResponse(runResponse)) {
+      if (!terminalRunResponse) {
+        terminalSeenAt = Date.now();
+        lastTerminalProgressAt = terminalSeenAt;
+      }
+      terminalRunResponse = runResponse;
+    }
+    if (terminalRunResponse) {
+      if (shouldCompleteTerminalDrain(
+        terminalSeenAt,
+        lastTerminalProgressAt,
+        blockedByGap
+      )) {
+        result = renderTerminalRunResult(runId, terminalRunResponse);
+        complete = true;
+      }
     }
     if (!complete) {
-      await new Promise((resolve) => {
-        return setTimeout(resolve, pollIntervalMs);
-      });
+      await sleep(
+        terminalRunResponse ? TERMINAL_DRAIN_POLL_INTERVAL_MS : POLL_INTERVAL_MS
+      );
     }
   }
   return result;
@@ -17788,7 +17864,7 @@ async function getScreenInfo() {
 init_esm_shims();
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import { setTimeout as sleep } from "timers/promises";
+import { setTimeout as sleep2 } from "timers/promises";
 var execFileAsync2 = promisify2(execFile2);
 async function leftClickDrag(startX, startY, endX, endY) {
   await execFileAsync2("cliclick", [
@@ -17921,7 +17997,7 @@ async function holdKey(keys, durationMs) {
     return `ku:${k}`;
   });
   await execFileAsync2("cliclick", downArgs);
-  await sleep(durationMs);
+  await sleep2(durationMs);
   await execFileAsync2("cliclick", upArgs);
 }
 async function typeText(text) {
@@ -18820,7 +18896,7 @@ function registerZeroCommands(prog, commands) {
 var program = new Command();
 program.name("zero").description(
   "Zero CLI \u2014 interact with the zero platform from inside the sandbox"
-).version("9.132.9").addHelpText(
+).version("9.132.10").addHelpText(
   "after",
   `
 Examples: