@walkeros/cli 4.0.0-next-1777882869103 → 4.0.0

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # @walkeros/cli
 
-## 4.0.0-next-1777882869103
+## 4.0.0
 
 ### Major Changes
 
@@ -232,6 +232,31 @@
 
 ### Patch Changes
 
+- ca237ef: Fix `walkeros push` deadlock for web flows whose destinations await
+  real timers during init.
+
+  Previously, async-drain timer interception captured every `setTimeout` into a
+  pending map and only fired them via a post-`fn` flush. If a destination's init
+  awaited one of those captured timers (e.g.,
+  `@walkeros/web-destination-amplitude`'s engagement plugin awaits a 10s
+  setTimeout to give up on a CDN script load), `init` never resolved,
+  `await collector.push` deadlocked, and Node exited with
+  `Detected unsettled top-level await` (exit 13).
+
+  A drain pump now runs alongside `fn(flowModule)` for non-`--simulate` runs:
+  each tick fires every captured non-cleared timer using a real `setImmediate`
+  reference. Timers fire in delay-ascending order, intervals re-register,
+  callback errors are reported via `console.warn`. Bounded by max-iterations
+  (1000) and wall-clock (30s) caps.
+
+  `--simulate <step>` continues to use the post-`fn` flush path so snapshot
+  ordering remains stable.
+
+  Behavior change (edge case): a destination using `setTimeout` for retry
+  backoff under `walkeros push` (real, non-simulate) now sees its timer fire
+  instantly. This was already the documented contract for `--simulate <step>`
+  snapshots; it now extends to real `push` for consistency.
+
 - 6422b9b: Validate device-code and token responses from the auth server with
   Zod schemas at the trust boundary in `login/index.ts`. Malformed responses now
   surface as structured errors instead of being trusted into config writes or
@@ -271,10 +296,10 @@
 - Updated dependencies [8e06b1f]
 - Updated dependencies [3d50dd6]
 - Updated dependencies [1ef33d9]
-  - @walkeros/core@4.0.0-next-1777882869103
-  - @walkeros/collector@4.0.0-next-1777882869103
-  - @walkeros/server-destination-api@4.0.0-next-1777882869103
-  - @walkeros/server-core@4.0.0-next-1777882869103
+  - @walkeros/core@4.0.0
+  - @walkeros/collector@4.0.0
+  - @walkeros/server-destination-api@4.0.0
+  - @walkeros/server-core@4.0.0
 
 ## 3.4.2
 

package/dist/cli.js

@@ -4050,22 +4050,22 @@ import {
   mkdirSync as mkdirSync3,
   copyFileSync,
   writeFileSync as writeFileSync3,
-  readFileSync as readFileSync4
+  readFileSync as readFileSync3
 } from "fs";
-import { join as join4 } from "path";
+import { join as join3 } from "path";
 function writeCache(cacheDir, bundlePath, configContent, version) {
   mkdirSync3(cacheDir, { recursive: true });
-  copyFileSync(bundlePath, join4(cacheDir, "bundle.mjs"));
-  writeFileSync3(join4(cacheDir, "config.json"), configContent, "utf-8");
+  copyFileSync(bundlePath, join3(cacheDir, "bundle.mjs"));
+  writeFileSync3(join3(cacheDir, "config.json"), configContent, "utf-8");
   const meta = { version, timestamp: Date.now() };
-  writeFileSync3(join4(cacheDir, "meta.json"), JSON.stringify(meta), "utf-8");
+  writeFileSync3(join3(cacheDir, "meta.json"), JSON.stringify(meta), "utf-8");
 }
 function readCache(cacheDir) {
   try {
-    const metaPath = join4(cacheDir, "meta.json");
-    const bundlePath = join4(cacheDir, "bundle.mjs");
+    const metaPath = join3(cacheDir, "meta.json");
+    const bundlePath = join3(cacheDir, "bundle.mjs");
     if (!existsSync3(metaPath) || !existsSync3(bundlePath)) return null;
-    const meta = JSON.parse(readFileSync4(metaPath, "utf-8"));
+    const meta = JSON.parse(readFileSync3(metaPath, "utf-8"));
     return { bundlePath, version: meta.version };
   } catch {
     return null;
@@ -4073,9 +4073,9 @@ function readCache(cacheDir) {
 }
 function readCacheConfig(cacheDir) {
   try {
-    const configPath = join4(cacheDir, "config.json");
+    const configPath = join3(cacheDir, "config.json");
     if (!existsSync3(configPath)) return null;
-    return readFileSync4(configPath, "utf-8");
+    return readFileSync3(configPath, "utf-8");
   } catch {
     return null;
   }
@@ -4577,11 +4577,6 @@ function printBanner(version) {
   console.error("");
 }
 
-// src/telemetry/emitter.ts
-import { readFileSync as readFileSync3 } from "fs";
-import { join as join3, dirname as dirname2 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-
 // ../collector/dist/index.mjs
 init_dist();
 init_dist();
@@ -5214,7 +5209,7 @@ function Re2(e3, n4) {
 }
 async function Ge(e3) {
   const n4 = G({ globalsStatic: {}, sessionStatic: {}, run: true }, e3, { merge: false, extend: false }), t3 = { level: e3.logger?.level, handler: e3.logger?.handler }, o2 = _e(t3), s4 = { ...n4.globalsStatic, ...e3.globals }, i2 = { allowed: false, config: n4, consent: e3.consent || {}, custom: e3.custom || {}, destinations: {}, transformers: {}, stores: {}, globals: s4, hooks: e3.hooks || {}, logger: o2, on: {}, queue: [], round: 0, session: void 0, status: { startedAt: Date.now(), in: 0, out: 0, failed: 0, sources: {}, destinations: {} }, timing: Date.now(), user: e3.user || {}, sources: {}, pending: { sources: {}, destinations: {} }, push: void 0, command: void 0 };
-  i2.push = Re2(i2, (e4) => ({ timing: Math.round((Date.now() - i2.timing) / 10) / 100, source: { type: "collector", schema: "4", version: "4.0.0-next-1777882869103" }, ...e4 })), i2.command = (function(e4, n5) {
+  i2.push = Re2(i2, (e4) => ({ timing: Math.round((Date.now() - i2.timing) / 10) / 100, source: { type: "collector", schema: "4", version: "4.0.0" }, ...e4 })), i2.command = (function(e4, n5) {
     return Je(async (t4, o3, s5) => await Te(async () => await n5(e4, t4, o3, s5), () => ye({ ok: false }))(), "Command", e4.hooks, e4.logger);
   })(i2, qe);
   const c3 = e3.stores || {};
@@ -5414,6 +5409,7 @@ function maybePrintFirstRunNotice() {
 }
 
 // src/telemetry/emitter.ts
+init_config_file();
 var SEND_TIMEOUT_MS = 1e3;
 async function createEmitter(opts) {
   if (!isTelemetryEnabled()) {
@@ -5431,7 +5427,7 @@ async function createEmitter(opts) {
   }
   const device = maybeDevice;
   const debug = isDebugMode();
-  const endpoint = process.env.TELEMETRY_ENDPOINT || loadFlowJsonEndpoint();
+  const endpoint = resolveTelemetryEndpoint();
   if (!endpoint && !debug) {
     return {
       async send() {
@@ -5506,15 +5502,10 @@ async function createEmitter(opts) {
     }
   };
 }
-function loadFlowJsonEndpoint() {
-  try {
-    const here = dirname2(fileURLToPath2(import.meta.url));
-    const raw = JSON.parse(readFileSync3(join3(here, "flow.json"), "utf-8"));
-    const url = raw.flows?.default?.destinations?.api?.config?.url;
-    if (url && !url.startsWith("$")) return url;
-  } catch {
-  }
-  return void 0;
+function resolveTelemetryEndpoint() {
+  const appUrl = resolveAppUrl();
+  if (!appUrl) return void 0;
+  return `${appUrl.replace(/\/$/, "")}/api/telemetry`;
 }
 async function withTimeout(p2, ms) {
   return Promise.race([
@@ -5822,7 +5813,51 @@ function installTimerInterception(options = {}) {
     }
     pending.clear();
   }
-  return { flush, countPending, restore };
+  return { flush, countPending, restore, pending };
+}
+
+// src/commands/push/async-drain-pump.ts
+var realSetImmediate = setImmediate;
+var DEFAULT_MAX_ITERATIONS = 1e3;
+var DEFAULT_MAX_WALL_MS = 3e4;
+var intervalRequeueCounter = -1;
+function startDrainPump(pending, options = {}) {
+  const maxIterations = options.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+  const maxWallMs = options.maxWallMs ?? DEFAULT_MAX_WALL_MS;
+  const start = Date.now();
+  let running = true;
+  let iterations = 0;
+  const tick = () => {
+    if (!running) return;
+    if (iterations >= maxIterations) return;
+    if (Date.now() - start > maxWallMs) return;
+    if (pending.size === 0) {
+      realSetImmediate(tick);
+      return;
+    }
+    iterations += 1;
+    const snapshot = [...pending.values()].filter((t3) => !t3.cleared).sort((a4, b2) => a4.delay - b2.delay);
+    for (const timer of snapshot) {
+      pending.delete(timer.id);
+      try {
+        timer.callback(...timer.args);
+      } catch (err) {
+        console.warn(`[async-drain] timer ${timer.id} threw during pump:`, err);
+      }
+      if (timer.type === "interval" && !timer.cleared) {
+        const requeued = {
+          ...timer,
+          id: intervalRequeueCounter--
+        };
+        pending.set(requeued.id, requeued);
+      }
+    }
+    realSetImmediate(tick);
+  };
+  realSetImmediate(tick);
+  return () => {
+    running = false;
+  };
 }
 
 // src/commands/push/flow-context.ts
@@ -5834,7 +5869,8 @@ async function withFlowContext(options, fn) {
     snapshotCode,
     timeout,
     networkCalls,
-    asyncDrain
+    asyncDrain,
+    drainPump
   } = options;
   const startTime = Date.now();
   const g2 = global;
@@ -5897,7 +5933,13 @@ async function withFlowContext(options, fn) {
       __devExports: module.__devExports
     };
     if (timerControl) {
-      const result = await fn(flowModule);
+      const stopPump = drainPump ? startDrainPump(timerControl.pending) : null;
+      let result;
+      try {
+        result = await fn(flowModule);
+      } finally {
+        if (stopPump) stopPump();
+      }
       await timerControl.flush(asyncDrain?.timeout ?? 5e3);
       return result;
     } else if (timeout) {
@@ -6041,6 +6083,145 @@ async function prepareFlow(input) {
 
 // src/commands/push/index.ts
 init_dev();
+
+// src/commands/push/plan-simulate.ts
+function planSimulate(flags) {
+  if (flags.length === 0) return { kind: "none", ids: [] };
+  const parsed = flags.map((flag) => {
+    const step = parseStep(flag);
+    if (step.chainType) {
+      throw new Error(
+        `--simulate "${flag}": chain syntax (${step.type}.${step.name}.${step.chainType}.\u2026) is not supported for --simulate. Use --mock for path-specific overrides.`
+      );
+    }
+    return step;
+  });
+  const types = new Set(parsed.map((p2) => p2.type));
+  if (types.size > 1) {
+    const sorted = [...types].sort();
+    throw new Error(
+      `Cannot --simulate ${sorted.join(" and ")} in the same invocation. Run separate commands for each step type.`
+    );
+  }
+  const [type] = types;
+  const ids = [...new Set(parsed.map((p2) => p2.name))];
+  if ((type === "source" || type === "transformer") && ids.length > 1) {
+    throw new Error(
+      `--simulate ${type}.* expects a single target; got ${ids.length}. Run one --simulate ${type}.NAME per invocation.`
+    );
+  }
+  return { kind: type, ids };
+}
+
+// src/commands/push/dispatch-simulate.ts
+function dispatchSimulate(flags) {
+  const plan = planSimulate(flags);
+  return { route: plan.kind, ids: plan.ids };
+}
+
+// src/commands/push/run.ts
+init_core();
+init_config();
+async function runPushCommand(options) {
+  const startTime = Date.now();
+  try {
+    const plan = dispatchSimulate(options.simulate ?? []);
+    let config;
+    if (isStdinPiped() && !options.config) {
+      config = await readStdinToTempFile("push");
+    } else {
+      config = options.config || "bundle.config.json";
+    }
+    let resolvedEvent = options.event;
+    if (typeof options.event === "string") {
+      resolvedEvent = await loadJsonFromSource(options.event, {
+        name: "event"
+      });
+    }
+    let result;
+    switch (plan.route) {
+      case "none":
+        result = await push(config, resolvedEvent, {
+          flow: options.flow,
+          json: options.json,
+          verbose: options.verbose,
+          silent: options.silent,
+          platform: options.platform,
+          mock: options.mock,
+          snapshot: options.snapshot
+        });
+        break;
+      case "source":
+        result = await simulateSource(config, resolvedEvent, {
+          sourceId: plan.ids[0],
+          flow: options.flow,
+          silent: options.silent,
+          verbose: options.verbose,
+          snapshot: options.snapshot
+        });
+        break;
+      case "transformer":
+        result = await simulateTransformer(
+          config,
+          resolvedEvent,
+          {
+            transformerId: plan.ids[0],
+            flow: options.flow,
+            mock: options.mock,
+            silent: options.silent,
+            verbose: options.verbose,
+            snapshot: options.snapshot
+          }
+        );
+        break;
+      case "destination":
+        result = await runDestinationSimulationLoop(
+          config,
+          resolvedEvent,
+          plan.ids,
+          options
+        );
+        break;
+    }
+    return result;
+  } catch (error) {
+    return {
+      success: false,
+      duration: Date.now() - startTime,
+      error: getErrorMessage(error)
+    };
+  }
+}
+async function runDestinationSimulationLoop(config, event, destinationIds, options) {
+  const startTime = Date.now();
+  const perDestination = {};
+  for (const destinationId of destinationIds) {
+    const r3 = await simulateDestination(config, event, {
+      destinationId,
+      flow: options.flow,
+      mock: options.mock,
+      silent: options.silent,
+      verbose: options.verbose,
+      snapshot: options.snapshot
+    });
+    perDestination[destinationId] = r3;
+    if (!r3.success) {
+      return {
+        success: false,
+        duration: Date.now() - startTime,
+        error: `simulate destination.${destinationId}: ${r3.error ?? "unknown error"}`,
+        perDestination
+      };
+    }
+  }
+  return {
+    success: true,
+    duration: Date.now() - startTime,
+    perDestination
+  };
+}
+
+// src/commands/push/index.ts
 function resolveBeforeChain(before, transformers, ingest, event) {
   if (!before) return [];
   const next = before;
@@ -6119,108 +6300,32 @@ async function pushCore(inputPath, event, options = {}) {
   }
 }
 async function pushCommand(options) {
-  const logger = createCLILogger({ ...options, stderr: true });
-  const startTime = Date.now();
-  try {
-    let config;
-    if (isStdinPiped() && !options.config) {
-      config = await readStdinToTempFile("push");
-    } else {
-      config = options.config || "bundle.config.json";
-    }
-    let resolvedEvent = options.event;
-    if (typeof options.event === "string") {
-      resolvedEvent = await loadJsonFromSource(options.event, {
-        name: "event"
-      });
-    }
-    const simulateFlag = options.simulate?.[0];
-    let result;
-    if (simulateFlag?.startsWith("source.")) {
-      result = await simulateSource(config, resolvedEvent, {
-        sourceId: simulateFlag.replace("source.", ""),
-        flow: options.flow,
-        silent: options.silent,
-        verbose: options.verbose,
-        snapshot: options.snapshot
-      });
-    } else if (simulateFlag?.startsWith("transformer.")) {
-      result = await simulateTransformer(
-        config,
-        resolvedEvent,
-        {
-          transformerId: simulateFlag.replace("transformer.", ""),
-          flow: options.flow,
-          mock: options.mock,
-          silent: options.silent,
-          verbose: options.verbose,
-          snapshot: options.snapshot
-        }
-      );
-    } else if (simulateFlag?.startsWith("destination.")) {
-      result = await simulateDestination(
-        config,
-        resolvedEvent,
-        {
-          destinationId: simulateFlag.replace("destination.", ""),
-          flow: options.flow,
-          mock: options.mock,
-          silent: options.silent,
-          verbose: options.verbose,
-          snapshot: options.snapshot
-        }
-      );
-    } else {
-      result = await push(config, resolvedEvent, {
-        flow: options.flow,
-        json: options.json,
-        verbose: options.verbose,
-        silent: options.silent,
-        platform: options.platform,
-        mock: options.mock,
-        snapshot: options.snapshot
-      });
-    }
-    const duration = Date.now() - startTime;
-    let output;
-    if (options.json) {
-      output = JSON.stringify({ ...result, duration }, null, 2);
-    } else {
-      const lines = [];
-      if (result.success) {
-        lines.push("Event pushed successfully");
-        if (result.elbResult && typeof result.elbResult === "object") {
-          const pushResult = result.elbResult;
-          if ("id" in pushResult && pushResult.id)
-            lines.push(`  Event ID: ${pushResult.id}`);
-          if ("entity" in pushResult && pushResult.entity)
-            lines.push(`  Entity: ${pushResult.entity}`);
-          if ("action" in pushResult && pushResult.action)
-            lines.push(`  Action: ${pushResult.action}`);
-        }
-        lines.push(`  Duration: ${duration}ms`);
-      } else {
-        lines.push(`Error: ${result.error}`);
-      }
-      output = lines.join("\n");
-    }
-    await writeResult(output + "\n", { output: options.output });
-    process.exit(result.success ? 0 : 1);
-  } catch (error) {
-    const duration = Date.now() - startTime;
-    const errorMessage = getErrorMessage(error);
-    if (options.json) {
-      const errorOutput = JSON.stringify(
-        { success: false, error: errorMessage, duration },
-        null,
-        2
-      );
-      await writeResult(errorOutput + "\n", { output: options.output });
+  const result = await runPushCommand(options);
+  const duration = result.duration;
+  let output;
+  if (options.json) {
+    output = JSON.stringify({ ...result, duration }, null, 2);
+  } else {
+    const lines = [];
+    if (result.success) {
+      lines.push("Event pushed successfully");
+      if (result.elbResult && typeof result.elbResult === "object") {
+        const pushResult = result.elbResult;
+        if ("id" in pushResult && pushResult.id)
+          lines.push(`  Event ID: ${pushResult.id}`);
+        if ("entity" in pushResult && pushResult.entity)
+          lines.push(`  Entity: ${pushResult.entity}`);
+        if ("action" in pushResult && pushResult.action)
+          lines.push(`  Action: ${pushResult.action}`);
+      }
+      lines.push(`  Duration: ${duration}ms`);
     } else {
-      logger.error(`Error: ${errorMessage}`);
+      lines.push(`Error: ${result.error}`);
     }
-    process.exit(1);
+    output = lines.join("\n");
   }
+  await writeResult(output + "\n", { output: options.output });
+  process.exit(result.success ? 0 : 1);
 }
 async function push(configOrPath, event, options = {}) {
   if (typeof configOrPath !== "string") {
@@ -6319,7 +6424,12 @@ async function executeDestinationPush(esmPath, event, logger, platform, override
       snapshotCode,
       timeout,
       networkCalls,
-      asyncDrain: { timeout: 5e3 }
+      asyncDrain: { timeout: 5e3 },
+      // Real push (non-simulate) needs the pump so destinations whose init
+      // awaits a captured setTimeout (e.g., amplitude engagement plugin)
+      // don't deadlock. Simulate routes use their own withFlowContext call
+      // sites without `drainPump`, preserving snapshot ordering.
+      drainPump: true
     },
     async (module) => {
       const config = module.wireConfig(module.__configData ?? void 0);
@@ -6719,12 +6829,12 @@ init_auth();
 import path17 from "path";
 import { writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join5 } from "path";
+import { join as join4 } from "path";
 
 // src/runtime/resolve-bundle.ts
 init_stdin();
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname3 } from "path";
+import { dirname as dirname2 } from "path";
 function getDefaultWritePath() {
   if (existsSync2("/app/flow")) return "/app/flow/bundle.mjs";
   return "/tmp/walkeros-bundle.mjs";
@@ -6733,7 +6843,7 @@ function isUrl2(value) {
   return value.startsWith("http://") || value.startsWith("https://");
 }
 function writeBundleToDisk(writePath, content) {
-  const dir = dirname3(writePath);
+  const dir = dirname2(writePath);
   if (!existsSync2(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
@@ -7009,7 +7119,7 @@ function createHealthServer(port, logger) {
 }
 
 // src/runtime/runner.ts
-import { resolve as resolve2, dirname as dirname4 } from "path";
+import { resolve as resolve2, dirname as dirname3 } from "path";
 
 // src/runtime/load-bundle.ts
 import { resolve } from "path";
@@ -7040,7 +7150,7 @@ async function loadBundle(file, context2, logger) {
 // src/runtime/runner.ts
 async function loadFlow(file, config, logger, loggerConfig, healthServer) {
   const absolutePath = resolve2(file);
-  const flowDir = dirname4(absolutePath);
+  const flowDir = dirname3(absolutePath);
   process.chdir(flowDir);
   const flowContext = {
     ...config,
@@ -7433,8 +7543,8 @@ async function injectSecrets(api, logger) {
 // src/commands/run/index.ts
 function defaultCacheDir() {
   const xdgCache = process.env.XDG_CACHE_HOME;
-  const base = xdgCache || join5(homedir2(), ".cache");
-  return join5(base, "walkeros");
+  const base = xdgCache || join4(homedir2(), ".cache");
+  return join4(base, "walkeros");
 }
 async function lazyPrepareBundleForRun(configPath, options) {
   const { prepareBundleForRun: prepareBundleForRun2 } = await Promise.resolve().then(() => (init_utils3(), utils_exports));
@@ -8122,7 +8232,7 @@ function validateMapping(input) {
 // src/commands/validate/validators/entry.ts
 init_dist();
 import Ajv from "ajv";
-var CLIENT_HEADER = "walkeros-cli/4.0.0-next-1777882869103";
+var CLIENT_HEADER = "walkeros-cli/4.0.0";
 var SECTIONS = ["destinations", "sources", "transformers"];
 function resolveEntry(path18, flowConfig) {
   const flows = flowConfig.flows;
@@ -9274,7 +9384,7 @@ program.command("push [file]").description("Push an event through the flow with
   "event to push (JSON string, file path, or URL)"
 ).option("-o, --output <path>", "write result to file").option("-f, --flow <name>", "flow name for multi-flow configs").option("-p, --platform <platform>", "platform override (web or server)").option("--json", "output as JSON").option("-v, --verbose", "verbose output").option("-s, --silent", "suppress output").option(
   "--simulate <step>",
-  "simulate a destination step (repeatable)",
+  "simulate a step (repeatable for destination.*; format: source.NAME | destination.NAME | transformer.NAME)",
   (val, arr) => {
     arr.push(val);
     return arr;

package/dist/index.d.ts

@@ -336,6 +336,11 @@ interface PushResult {
     }>>;
     /** Network calls captured during web simulation (fetch + sendBeacon) */
     networkCalls?: NetworkCall[];
+    /**
+     * Per-destination simulation results when --simulate destination.* is
+     * called with multiple ids. Undefined for single-target or non-simulate runs.
+     */
+    perDestination?: Record<string, PushResult>;
     duration: number;
     error?: string;
 }
@@ -360,7 +365,11 @@ declare const PushOptionsSchema: z.ZodObject<{
 type PushOptions = z.infer<typeof PushOptionsSchema>;
 
 /**
- * CLI command handler for push command
+ * CLI command handler for push command.
+ *
+ * Thin wrapper around `runPushCommand`: delegates result production to the
+ * pure helper, then formats output and decides the exit code. Tests target
+ * `runPushCommand` directly to avoid `process.exit` killing Jest workers.
  */
 declare function pushCommand(options: PushCommandOptions): Promise<void>;
 /**