@walkeros/cli 4.0.0-next-1777882869103 → 4.0.0

package/dist/index.js

@@ -3401,7 +3401,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((t) => !t.cleared).sort((a, b) => a.delay - b.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
@@ -3413,7 +3457,8 @@ async function withFlowContext(options, fn) {
     snapshotCode,
     timeout,
     networkCalls,
-    asyncDrain
+    asyncDrain,
+    drainPump
   } = options;
   const startTime = Date.now();
   const g = global;
@@ -3476,7 +3521,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) {
@@ -3620,6 +3671,145 @@ async function prepareFlow(input) {
 
 // src/commands/push/index.ts
 import { schemas as schemas3 } from "@walkeros/core/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((p) => p.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((p) => p.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 r = await simulateDestination(config, event, {
+      destinationId,
+      flow: options.flow,
+      mock: options.mock,
+      silent: options.silent,
+      verbose: options.verbose,
+      snapshot: options.snapshot
+    });
+    perDestination[destinationId] = r;
+    if (!r.success) {
+      return {
+        success: false,
+        duration: Date.now() - startTime,
+        error: `simulate destination.${destinationId}: ${r.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;
@@ -3698,108 +3888,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}`);
+  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}`);
       }
-      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 });
+      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") {
@@ -3898,7 +4012,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);
@@ -5752,7 +5871,7 @@ function validateMapping(input) {
 // src/commands/validate/validators/entry.ts
 import Ajv from "ajv";
 import { fetchPackageSchema } from "@walkeros/core";
-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(path19, flowConfig) {
   const flows = flowConfig.flows;
@@ -7525,9 +7644,6 @@ __export(telemetry_exports, {
 });
 
 // src/telemetry/emitter.ts
-import { readFileSync as readFileSync4 } from "fs";
-import { join as join6, dirname as dirname5 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
 import { startFlow } from "@walkeros/collector";
 import { destinationAPI } from "@walkeros/server-destination-api";
 
@@ -7591,6 +7707,7 @@ function maybePrintFirstRunNotice() {
 }
 
 // src/telemetry/emitter.ts
+init_config_file();
 var SEND_TIMEOUT_MS = 1e3;
 async function createEmitter(opts) {
   if (!isTelemetryEnabled()) {
@@ -7608,7 +7725,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() {
@@ -7683,15 +7800,10 @@ async function createEmitter(opts) {
     }
   };
 }
-function loadFlowJsonEndpoint() {
-  try {
-    const here = dirname5(fileURLToPath2(import.meta.url));
-    const raw = JSON.parse(readFileSync4(join6(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 withTimeout2(p, ms) {
   return Promise.race([