@walkeros/cli 0.6.0 → 0.6.1-next-1766186076625

package/dist/index.js

@@ -108,6 +108,23 @@ function createCommandLogger(options) {
   });
 }
 
+// src/core/collector-logger.ts
+function createCollectorLoggerConfig(cliLogger, verbose) {
+  return {
+    level: verbose ? "DEBUG" : "ERROR",
+    handler: (level, message, context, scope) => {
+      const scopePath = scope.length > 0 ? `[${scope.join(":")}] ` : "";
+      const hasContext = Object.keys(context).length > 0;
+      const contextStr = hasContext ? ` ${JSON.stringify(context)}` : "";
+      if (level === 0) {
+        cliLogger.error(`${scopePath}${message}${contextStr}`);
+      } else if (verbose) {
+        cliLogger.debug(`${scopePath}${message}${contextStr}`);
+      }
+    }
+  };
+}
+
 // src/core/timer.ts
 function createTimer() {
   let startTime = 0;
@@ -374,6 +391,33 @@ async function copyLocalPackage(localPkg, targetDir, logger2) {
   return packageDir;
 }
 
+// src/core/input-detector.ts
+import fs3 from "fs-extra";
+async function detectInput(inputPath, platformOverride) {
+  const content = await loadContent(inputPath);
+  try {
+    JSON.parse(content);
+    return { type: "config", content };
+  } catch {
+    const platform = platformOverride ?? detectPlatformFromPath(inputPath);
+    return { type: "bundle", content, platform };
+  }
+}
+function detectPlatformFromPath(inputPath) {
+  const cleanPath = inputPath.split("?")[0];
+  return cleanPath.endsWith(".mjs") ? "server" : "web";
+}
+async function loadContent(inputPath) {
+  if (isUrl(inputPath)) {
+    const response = await fetch(inputPath);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch ${inputPath}: ${response.status}`);
+    }
+    return response.text();
+  }
+  return fs3.readFile(inputPath, "utf8");
+}
+
 // src/config/validators.ts
 import { schemas } from "@walkeros/core/dev";
 var { safeParseSetup } = schemas;
@@ -428,7 +472,7 @@ function getDefaultOutput(platform) {
 
 // src/config/loader.ts
 import path5 from "path";
-import fs3 from "fs-extra";
+import fs4 from "fs-extra";
 import { getFlowConfig, getPlatform } from "@walkeros/core";
 var DEFAULT_INCLUDE_FOLDER = "./shared";
 function loadBundleConfig(rawConfig, options) {
@@ -449,7 +493,7 @@ function loadBundleConfig(rawConfig, options) {
   let includes = setup.include;
   if (!includes) {
     const defaultIncludePath = path5.resolve(configDir, DEFAULT_INCLUDE_FOLDER);
-    if (fs3.pathExistsSync(defaultIncludePath)) {
+    if (fs4.pathExistsSync(defaultIncludePath)) {
       includes = [DEFAULT_INCLUDE_FOLDER];
     }
   }
@@ -508,17 +552,21 @@ function loadAllFlows(rawConfig, options) {
     })
   );
 }
+async function loadFlowConfig(configPath, options) {
+  const rawConfig = await loadJsonConfig(configPath);
+  return loadBundleConfig(rawConfig, { configPath, ...options });
+}
 
 // src/commands/bundle/bundler.ts
 import esbuild from "esbuild";
 import path8 from "path";
-import fs6 from "fs-extra";
+import fs7 from "fs-extra";
 import { packageNameToVariable } from "@walkeros/core";
 
 // src/commands/bundle/package-manager.ts
 import pacote from "pacote";
 import path6 from "path";
-import fs4 from "fs-extra";
+import fs5 from "fs-extra";
 
 // src/core/cache-utils.ts
 import { getHashServer } from "@walkeros/server-core";
@@ -568,7 +616,7 @@ async function getCachedPackagePath(pkg, tmpDir) {
 }
 async function isPackageCached(pkg, tmpDir) {
   const cachedPath = await getCachedPackagePath(pkg, tmpDir);
-  return fs4.pathExists(cachedPath);
+  return fs5.pathExists(cachedPath);
 }
 function validateNoDuplicatePackages(packages) {
   const packageMap = /* @__PURE__ */ new Map();
@@ -603,8 +651,8 @@ async function resolveDependencies(pkg, packageDir, logger2, visited = /* @__PUR
   visited.add(pkgKey);
   try {
     const packageJsonPath = path6.join(packageDir, "package.json");
-    if (await fs4.pathExists(packageJsonPath)) {
-      const packageJson = await fs4.readJson(packageJsonPath);
+    if (await fs5.pathExists(packageJsonPath)) {
+      const packageJson = await fs5.readJson(packageJsonPath);
       const deps = {
         ...packageJson.dependencies,
         ...packageJson.peerDependencies
@@ -632,7 +680,7 @@ async function downloadPackages(packages, targetDir, logger2, useCache = true, c
     }
   }
   validateNoDuplicatePackages(packages);
-  await fs4.ensureDir(targetDir);
+  await fs5.ensureDir(targetDir);
   while (downloadQueue.length > 0) {
     const pkg = downloadQueue.shift();
     const pkgKey = `${pkg.name}@${pkg.version}`;
@@ -669,8 +717,8 @@ async function downloadPackages(packages, targetDir, logger2, useCache = true, c
         logger2.debug(`Downloading ${packageSpec} (cached)`);
       }
       try {
-        await fs4.ensureDir(path6.dirname(packageDir));
-        await fs4.copy(cachedPath, packageDir);
+        await fs5.ensureDir(path6.dirname(packageDir));
+        await fs5.copy(cachedPath, packageDir);
         packagePaths.set(pkg.name, packageDir);
         const deps = await resolveDependencies(pkg, packageDir, logger2);
         for (const dep of deps) {
@@ -687,7 +735,7 @@ async function downloadPackages(packages, targetDir, logger2, useCache = true, c
       }
     }
     try {
-      await fs4.ensureDir(path6.dirname(packageDir));
+      await fs5.ensureDir(path6.dirname(packageDir));
       const cacheDir = process.env.NPM_CACHE_DIR || getTmpPath(void 0, "cache", "npm");
       await withTimeout(
         pacote.extract(packageSpec, packageDir, {
@@ -704,15 +752,15 @@ async function downloadPackages(packages, targetDir, logger2, useCache = true, c
         `Package download timed out after ${PACKAGE_DOWNLOAD_TIMEOUT_MS / 1e3}s: ${packageSpec}`
       );
       if (userSpecifiedPackages.has(pkg.name)) {
-        const pkgStats = await fs4.stat(path6.join(packageDir, "package.json"));
+        const pkgStats = await fs5.stat(path6.join(packageDir, "package.json"));
         const pkgJsonSize = pkgStats.size;
         const sizeKB = (pkgJsonSize / 1024).toFixed(1);
         logger2.debug(`Downloading ${packageSpec} (${sizeKB} KB)`);
       }
       if (useCache) {
         try {
-          await fs4.ensureDir(path6.dirname(cachedPath));
-          await fs4.copy(packageDir, cachedPath);
+          await fs5.ensureDir(path6.dirname(cachedPath));
+          await fs5.copy(packageDir, cachedPath);
         } catch (cacheError) {
         }
       }
@@ -732,7 +780,7 @@ async function downloadPackages(packages, targetDir, logger2, useCache = true, c
 }
 
 // src/core/build-cache.ts
-import fs5 from "fs-extra";
+import fs6 from "fs-extra";
 import path7 from "path";
 async function getBuildCachePath(configContent, tmpDir) {
   const cacheDir = getTmpPath(tmpDir, "cache", "builds");
@@ -741,17 +789,17 @@ async function getBuildCachePath(configContent, tmpDir) {
 }
 async function isBuildCached(configContent, tmpDir) {
   const cachePath = await getBuildCachePath(configContent, tmpDir);
-  return fs5.pathExists(cachePath);
+  return fs6.pathExists(cachePath);
 }
 async function cacheBuild(configContent, buildOutput, tmpDir) {
   const cachePath = await getBuildCachePath(configContent, tmpDir);
-  await fs5.ensureDir(path7.dirname(cachePath));
-  await fs5.writeFile(cachePath, buildOutput, "utf-8");
+  await fs6.ensureDir(path7.dirname(cachePath));
+  await fs6.writeFile(cachePath, buildOutput, "utf-8");
 }
 async function getCachedBuild(configContent, tmpDir) {
   const cachePath = await getBuildCachePath(configContent, tmpDir);
-  if (await fs5.pathExists(cachePath)) {
-    return await fs5.readFile(cachePath, "utf-8");
+  if (await fs6.pathExists(cachePath)) {
+    return await fs6.readFile(cachePath, "utf-8");
   }
   return null;
 }
@@ -762,8 +810,8 @@ async function copyIncludes(includes, sourceDir, outputDir, logger2) {
     const sourcePath = path8.resolve(sourceDir, include);
     const folderName = path8.basename(include);
     const destPath = path8.join(outputDir, folderName);
-    if (await fs6.pathExists(sourcePath)) {
-      await fs6.copy(sourcePath, destPath);
+    if (await fs7.pathExists(sourcePath)) {
+      await fs7.copy(sourcePath, destPath);
       logger2.debug(`Copied ${include} to output`);
     } else {
       logger2.debug(`Include folder not found: ${include}`);
@@ -793,13 +841,13 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
       if (cachedBuild) {
         logger2.debug("Using cached build");
         const outputPath = path8.resolve(buildOptions.output);
-        await fs6.ensureDir(path8.dirname(outputPath));
-        await fs6.writeFile(outputPath, cachedBuild);
-        const stats = await fs6.stat(outputPath);
+        await fs7.ensureDir(path8.dirname(outputPath));
+        await fs7.writeFile(outputPath, cachedBuild);
+        const stats = await fs7.stat(outputPath);
         const sizeKB = (stats.size / 1024).toFixed(1);
         logger2.log(`Output: ${outputPath} (${sizeKB} KB, cached)`);
         if (showStats) {
-          const stats2 = await fs6.stat(outputPath);
+          const stats2 = await fs7.stat(outputPath);
           const packageStats = Object.entries(buildOptions.packages).map(
             ([name, pkg]) => ({
               name: `${name}@${pkg.version || "latest"}`,
@@ -819,7 +867,7 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
     }
   }
   try {
-    await fs6.ensureDir(TEMP_DIR);
+    await fs7.ensureDir(TEMP_DIR);
     logger2.debug("Downloading packages");
     const packagesArray = Object.entries(buildOptions.packages).map(
       ([name, packageConfig]) => ({
@@ -840,7 +888,7 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
     for (const [pkgName, pkgPath] of packagePaths.entries()) {
       if (pkgName.startsWith("@walkeros/")) {
         const pkgJsonPath = path8.join(pkgPath, "package.json");
-        const pkgJson = await fs6.readJSON(pkgJsonPath);
+        const pkgJson = await fs7.readJSON(pkgJsonPath);
         if (!pkgJson.exports && pkgJson.module) {
           pkgJson.exports = {
             ".": {
@@ -848,12 +896,12 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
               require: pkgJson.main
             }
           };
-          await fs6.writeJSON(pkgJsonPath, pkgJson, { spaces: 2 });
+          await fs7.writeJSON(pkgJsonPath, pkgJson, { spaces: 2 });
         }
       }
     }
     const packageJsonPath = path8.join(TEMP_DIR, "package.json");
-    await fs6.writeFile(
+    await fs7.writeFile(
       packageJsonPath,
       JSON.stringify({ type: "module" }, null, 2)
     );
@@ -864,12 +912,12 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
       packagePaths
     );
     const entryPath = path8.join(TEMP_DIR, "entry.js");
-    await fs6.writeFile(entryPath, entryContent);
+    await fs7.writeFile(entryPath, entryContent);
     logger2.debug(
       `Running esbuild (target: ${buildOptions.target || "es2018"}, format: ${buildOptions.format})`
     );
     const outputPath = path8.resolve(buildOptions.output);
-    await fs6.ensureDir(path8.dirname(outputPath));
+    await fs7.ensureDir(path8.dirname(outputPath));
     const esbuildOptions = createEsbuildOptions(
       buildOptions,
       entryPath,
@@ -886,13 +934,13 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
         buildOptions.code || ""
       );
     }
-    const outputStats = await fs6.stat(outputPath);
+    const outputStats = await fs7.stat(outputPath);
     const sizeKB = (outputStats.size / 1024).toFixed(1);
     const buildTime = ((Date.now() - bundleStartTime) / 1e3).toFixed(1);
     logger2.log(`Output: ${outputPath} (${sizeKB} KB, ${buildTime}s)`);
     if (buildOptions.cache !== false) {
       const configContent = generateCacheKeyContent(flowConfig, buildOptions);
-      const buildOutput = await fs6.readFile(outputPath, "utf-8");
+      const buildOutput = await fs7.readFile(outputPath, "utf-8");
       await cacheBuild(configContent, buildOutput);
       logger2.debug("Build cached for future use");
     }
@@ -920,7 +968,7 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
   }
 }
 async function collectBundleStats(outputPath, packages, startTime, entryContent) {
-  const stats = await fs6.stat(outputPath);
+  const stats = await fs7.stat(outputPath);
   const totalSize = stats.size;
   const buildTime = Date.now() - startTime;
   const packageStats = Object.entries(packages).map(([name, pkg]) => {
@@ -1248,6 +1296,11 @@ function generatePlatformWrapper(configObject, userCode, buildOptions) {
 ` : "";
     return `export default async function(context = {}) {
   const config = ${configObject};${codeSection}
+  // Apply context overrides (e.g., logger config from CLI)
+  if (context.logger) {
+    config.logger = { ...config.logger, ...context.logger };
+  }
+
   return await startFlow(config);
 }`;
   }
@@ -1415,7 +1468,7 @@ async function bundle(configOrPath, options = {}) {
 
 // src/commands/simulate/simulator.ts
 import path10 from "path";
-import fs8 from "fs-extra";
+import fs9 from "fs-extra";
 import { getPlatform as getPlatform2 } from "@walkeros/core";
 
 // src/commands/simulate/tracker.ts
@@ -1498,7 +1551,7 @@ var CallTracker = class {
 
 // src/commands/simulate/jsdom-executor.ts
 import { JSDOM, VirtualConsole } from "jsdom";
-import fs7 from "fs-extra";
+import fs8 from "fs-extra";
 function buildSandboxFromEnvs(envs, destinations, tracker) {
   const baseBrowserMocks = {
     Image: class MockImage {
@@ -1567,7 +1620,7 @@ async function executeInJSDOM(bundlePath, destinations, event, tracker, envs, ti
   const sandbox = buildSandboxFromEnvs(envs, destinations, tracker);
   Object.assign(window, sandbox.window);
   Object.assign(window.document, sandbox.document);
-  const bundleCode = await fs7.readFile(bundlePath, "utf8");
+  const bundleCode = await fs8.readFile(bundlePath, "utf8");
   try {
     window.eval(bundleCode);
   } catch (error) {
@@ -1638,7 +1691,7 @@ function injectGlobalMocks(mocks) {
     }
   };
 }
-async function executeInNode(bundlePath, destinations, event, tracker, envs, timeout = 3e4) {
+async function executeInNode(bundlePath, destinations, event, tracker, envs, timeout = 3e4, context = {}) {
   const start = Date.now();
   const globalMocks = buildGlobalMocksFromEnvs(envs, destinations, tracker);
   const cleanupMocks = injectGlobalMocks(globalMocks);
@@ -1649,16 +1702,19 @@ async function executeInNode(bundlePath, destinations, event, tracker, envs, tim
       if (!module.default || typeof module.default !== "function") {
         throw new Error("Bundle does not export default factory function");
       }
-      const result = await module.default();
-      if (!result || !result.elb || typeof result.elb !== "function") {
+      const result = await module.default(context);
+      if (!result || !result.collector || typeof result.collector.push !== "function") {
         throw new Error(
-          "Factory function did not return valid result with elb"
+          "Factory function did not return valid result with collector"
         );
       }
       const { collector, elb } = result;
       let elbResult;
       try {
-        elbResult = await elb(event.name, event.data);
+        elbResult = await collector.push({
+          name: event.name,
+          data: event.data
+        });
       } catch (error) {
         throw new Error(`Event execution failed: ${getErrorMessage(error)}`);
       }
@@ -1716,29 +1772,21 @@ async function loadDestinationEnvs(destinations) {
 function generateId() {
   return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
 }
-async function simulateCore(configPath, event, options = {}) {
+async function simulateCore(inputPath, event, options = {}) {
   const logger2 = createLogger({
     verbose: options.verbose || false,
     silent: options.silent || false,
     json: options.json || false
   });
   try {
-    logger2.info("\u{1F3AF} Starting walkerOS simulation...");
-    logger2.info("\u{1F4E6} Loading bundle configuration...");
-    const fullConfigPath = path10.resolve(configPath);
-    const rawConfig = await loadJsonConfig(fullConfigPath);
-    loadBundleConfig(rawConfig, { configPath: fullConfigPath });
-    logger2.info(`\u{1F680} Executing simulation with event: ${JSON.stringify(event)}`);
-    const result = await executeSimulation(event, fullConfigPath);
-    if (result.success) {
-      logger2.info(`\u2705 Simulation completed successfully`);
-    } else {
-      logger2.error(`\u274C Simulation failed: ${result.error}`);
-    }
+    logger2.debug(`Simulating event: ${JSON.stringify(event)}`);
+    const result = await executeSimulation(event, inputPath, options.platform, {
+      logger: logger2,
+      verbose: options.verbose
+    });
     return result;
   } catch (error) {
     const errorMessage = getErrorMessage(error);
-    logger2.error(`\u{1F4A5} Simulation error: ${errorMessage}`);
     return {
       success: false,
       error: errorMessage
@@ -1755,87 +1803,43 @@ function formatSimulationResult(result, options = {}) {
     return JSON.stringify(output, null, 2);
   }
   if (result.success) {
-    return "\u2705 Simulation completed successfully";
+    return "Simulation completed";
   } else {
-    return `\u274C Simulation failed: ${result.error}`;
+    return `Simulation failed: ${result.error}`;
   }
 }
-async function executeSimulation(event, configPath) {
+async function executeSimulation(event, inputPath, platformOverride, options = {}) {
   const startTime = Date.now();
-  let bundlePath;
   const tempDir = getTmpPath();
+  const collectorLoggerConfig = options.logger ? createCollectorLoggerConfig(options.logger, options.verbose) : void 0;
   try {
+    await fs9.ensureDir(tempDir);
+    const detected = await detectInput(inputPath, platformOverride);
     if (!isObject(event) || !("name" in event) || typeof event.name !== "string") {
       throw new Error(
         'Event must be an object with a "name" property of type string'
       );
     }
     const typedEvent = event;
-    await fs8.ensureDir(tempDir);
-    const rawConfig = await loadJsonConfig(configPath);
-    const { flowConfig, buildOptions } = loadBundleConfig(rawConfig, {
-      configPath
-    });
-    const platform = getPlatform2(flowConfig);
-    const tracker = new CallTracker();
-    const tempOutput = path10.join(
-      tempDir,
-      `simulation-bundle-${generateId()}.${platform === "web" ? "js" : "mjs"}`
-    );
-    const destinations = flowConfig.destinations;
-    const simulationBuildOptions = {
-      ...buildOptions,
-      code: buildOptions.code || "",
-      output: tempOutput,
-      tempDir,
-      ...platform === "web" ? {
-        format: "iife",
-        platform: "browser",
-        windowCollector: "collector",
-        windowElb: "elb"
-      } : {
-        format: "esm",
-        platform: "node"
-      }
-    };
-    await bundleCore(
-      flowConfig,
-      simulationBuildOptions,
-      createLogger({ silent: true }),
-      false
-    );
-    bundlePath = tempOutput;
-    const envs = await loadDestinationEnvs(destinations || {});
-    let result;
-    if (platform === "web") {
-      result = await executeInJSDOM(
-        tempOutput,
-        destinations || {},
+    if (detected.type === "config") {
+      return await executeConfigSimulation(
+        detected.content,
+        inputPath,
         typedEvent,
-        tracker,
-        envs,
-        1e4
+        tempDir,
+        startTime,
+        collectorLoggerConfig
       );
     } else {
-      result = await executeInNode(
-        tempOutput,
-        destinations || {},
+      return await executeBundleSimulation(
+        detected.content,
+        detected.platform,
         typedEvent,
-        tracker,
-        envs,
-        3e4
+        tempDir,
+        startTime,
+        collectorLoggerConfig
       );
     }
-    const elbResult = result.elbResult;
-    const usage = result.usage;
-    const duration = Date.now() - startTime;
-    return {
-      success: true,
-      elbResult,
-      usage,
-      duration,
-      logs: []
-    };
   } catch (error) {
     const duration = Date.now() - startTime;
     return {
@@ -1845,11 +1849,109 @@ async function executeSimulation(event, configPath) {
     };
   } finally {
     if (tempDir) {
-      await fs8.remove(tempDir).catch(() => {
+      await fs9.remove(tempDir).catch(() => {
       });
     }
   }
 }
+async function executeConfigSimulation(_content, configPath, typedEvent, tempDir, startTime, loggerConfig2) {
+  const { flowConfig, buildOptions } = await loadFlowConfig(configPath);
+  const platform = getPlatform2(flowConfig);
+  const tracker = new CallTracker();
+  const tempOutput = path10.join(
+    tempDir,
+    `simulation-bundle-${generateId()}.${platform === "web" ? "js" : "mjs"}`
+  );
+  const destinations = flowConfig.destinations;
+  const simulationBuildOptions = {
+    ...buildOptions,
+    code: buildOptions.code || "",
+    output: tempOutput,
+    tempDir,
+    ...platform === "web" ? {
+      format: "iife",
+      platform: "browser",
+      windowCollector: "collector",
+      windowElb: "elb"
+    } : {
+      format: "esm",
+      platform: "node"
+    }
+  };
+  await bundleCore(
+    flowConfig,
+    simulationBuildOptions,
+    createLogger({ silent: true }),
+    false
+  );
+  const envs = await loadDestinationEnvs(destinations || {});
+  let result;
+  if (platform === "web") {
+    result = await executeInJSDOM(
+      tempOutput,
+      destinations || {},
+      typedEvent,
+      tracker,
+      envs,
+      1e4
+    );
+  } else {
+    result = await executeInNode(
+      tempOutput,
+      destinations || {},
+      typedEvent,
+      tracker,
+      envs,
+      3e4,
+      loggerConfig2 ? { logger: loggerConfig2 } : {}
+    );
+  }
+  const duration = Date.now() - startTime;
+  return {
+    success: true,
+    elbResult: result.elbResult,
+    usage: result.usage,
+    duration,
+    logs: []
+  };
+}
+async function executeBundleSimulation(bundleContent, platform, typedEvent, tempDir, startTime, loggerConfig2) {
+  const tempOutput = path10.join(
+    tempDir,
+    `bundle-${generateId()}.${platform === "server" ? "mjs" : "js"}`
+  );
+  await fs9.writeFile(tempOutput, bundleContent, "utf8");
+  const tracker = new CallTracker();
+  let result;
+  if (platform === "web") {
+    result = await executeInJSDOM(
+      tempOutput,
+      {},
+      typedEvent,
+      tracker,
+      {},
+      1e4
+    );
+  } else {
+    result = await executeInNode(
+      tempOutput,
+      {},
+      typedEvent,
+      tracker,
+      {},
+      3e4,
+      loggerConfig2 ? { logger: loggerConfig2 } : {}
+    );
+  }
+  const duration = Date.now() - startTime;
+  return {
+    success: true,
+    elbResult: result.elbResult,
+    usage: result.usage,
+    duration,
+    logs: []
+  };
+}
 
 // src/commands/simulate/index.ts
 async function simulateCommand(options) {
@@ -1914,12 +2016,15 @@ async function simulate(configOrPath, event, options = {}) {
 // src/commands/push/index.ts
 import path11 from "path";
 import { JSDOM as JSDOM2, VirtualConsole as VirtualConsole2 } from "jsdom";
-import fs9 from "fs-extra";
-import { getPlatform as getPlatform3 } from "@walkeros/core";
+import fs10 from "fs-extra";
+import {
+  getPlatform as getPlatform3
+} from "@walkeros/core";
 import { schemas as schemas2 } from "@walkeros/core/dev";
 async function pushCommand(options) {
   const logger2 = createCommandLogger(options);
   const startTime = Date.now();
+  let tempDir;
   try {
     logger2.debug("Loading event");
     const event = await loadJsonFromSource(options.event, {
@@ -1943,49 +2048,33 @@ async function pushCommand(options) {
         `Warning: Event name "${validatedEvent.name}" should follow "ENTITY ACTION" format (e.g., "page view")`
       );
     }
-    logger2.debug("Loading flow configuration");
-    const configPath = path11.resolve(options.config);
-    const rawConfig = await loadJsonConfig(configPath);
-    const { flowConfig, buildOptions, flowName, isMultiFlow } = loadBundleConfig(rawConfig, {
-      configPath: options.config,
-      flowName: options.flow,
-      logger: logger2
-    });
-    const platform = getPlatform3(flowConfig);
-    logger2.debug("Bundling flow configuration");
-    const configDir = path11.dirname(configPath);
-    const tempDir = path11.join(
-      configDir,
-      ".tmp",
-      `push-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
-    );
-    await fs9.ensureDir(tempDir);
-    const tempPath = path11.join(
-      tempDir,
-      `bundle.${platform === "web" ? "js" : "mjs"}`
-    );
-    const pushBuildOptions = {
-      ...buildOptions,
-      output: tempPath,
-      // Web uses IIFE for browser-like execution, server uses ESM
-      format: platform === "web" ? "iife" : "esm",
-      platform: platform === "web" ? "browser" : "node",
-      ...platform === "web" && {
-        windowCollector: "collector",
-        windowElb: "elb"
-      }
-    };
-    await bundleCore(flowConfig, pushBuildOptions, logger2, false);
-    logger2.debug(`Bundle created: ${tempPath}`);
+    logger2.debug("Detecting input type");
+    const detected = await detectInput(options.config, options.platform);
     let result;
-    if (platform === "web") {
-      logger2.debug("Executing in web environment (JSDOM)");
-      result = await executeWebPush(tempPath, validatedEvent, logger2);
-    } else if (platform === "server") {
-      logger2.debug("Executing in server environment (Node.js)");
-      result = await executeServerPush(tempPath, validatedEvent, logger2);
+    if (detected.type === "config") {
+      result = await executeConfigPush(
+        options,
+        validatedEvent,
+        logger2,
+        (dir) => {
+          tempDir = dir;
+        }
+      );
     } else {
-      throw new Error(`Unsupported platform: ${platform}`);
+      const collectorLoggerConfig = createCollectorLoggerConfig(
+        logger2,
+        options.verbose
+      );
+      result = await executeBundlePush(
+        detected.content,
+        detected.platform,
+        validatedEvent,
+        logger2,
+        (dir) => {
+          tempDir = dir;
+        },
+        { logger: collectorLoggerConfig }
+      );
     }
     const duration = Date.now() - startTime;
     if (options.json) {
@@ -2015,10 +2104,6 @@ async function pushCommand(options) {
         process.exit(1);
       }
     }
-    try {
-      await fs9.remove(tempDir);
-    } catch {
-    }
   } catch (error) {
     const duration = Date.now() - startTime;
     const errorMessage = getErrorMessage(error);
@@ -2032,6 +2117,81 @@ async function pushCommand(options) {
       logger2.error(`Error: ${errorMessage}`);
     }
     process.exit(1);
+  } finally {
+    if (tempDir) {
+      await fs10.remove(tempDir).catch(() => {
+      });
+    }
+  }
+}
+async function executeConfigPush(options, validatedEvent, logger2, setTempDir) {
+  logger2.debug("Loading flow configuration");
+  const { flowConfig, buildOptions } = await loadFlowConfig(options.config, {
+    flowName: options.flow,
+    logger: logger2
+  });
+  const platform = getPlatform3(flowConfig);
+  logger2.debug("Bundling flow configuration");
+  const configDir = buildOptions.configDir || process.cwd();
+  const tempDir = path11.join(
+    configDir,
+    ".tmp",
+    `push-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
+  );
+  setTempDir(tempDir);
+  await fs10.ensureDir(tempDir);
+  const tempPath = path11.join(
+    tempDir,
+    `bundle.${platform === "web" ? "js" : "mjs"}`
+  );
+  const pushBuildOptions = {
+    ...buildOptions,
+    output: tempPath,
+    format: platform === "web" ? "iife" : "esm",
+    platform: platform === "web" ? "browser" : "node",
+    ...platform === "web" && {
+      windowCollector: "collector",
+      windowElb: "elb"
+    }
+  };
+  await bundleCore(flowConfig, pushBuildOptions, logger2, false);
+  logger2.debug(`Bundle created: ${tempPath}`);
+  if (platform === "web") {
+    logger2.debug("Executing in web environment (JSDOM)");
+    return executeWebPush(tempPath, validatedEvent, logger2);
+  } else if (platform === "server") {
+    logger2.debug("Executing in server environment (Node.js)");
+    const collectorLoggerConfig = createCollectorLoggerConfig(
+      logger2,
+      options.verbose
+    );
+    return executeServerPush(tempPath, validatedEvent, logger2, 6e4, {
+      logger: collectorLoggerConfig
+    });
+  } else {
+    throw new Error(`Unsupported platform: ${platform}`);
+  }
+}
+async function executeBundlePush(bundleContent, platform, validatedEvent, logger2, setTempDir, context = {}) {
+  const tempDir = path11.join(
+    process.cwd(),
+    ".tmp",
+    `push-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
+  );
+  setTempDir(tempDir);
+  await fs10.ensureDir(tempDir);
+  const tempPath = path11.join(
+    tempDir,
+    `bundle.${platform === "server" ? "mjs" : "js"}`
+  );
+  await fs10.writeFile(tempPath, bundleContent, "utf8");
+  logger2.debug(`Bundle written to: ${tempPath}`);
+  if (platform === "web") {
+    logger2.debug("Executing in web environment (JSDOM)");
+    return executeWebPush(tempPath, validatedEvent, logger2);
+  } else {
+    logger2.debug("Executing in server environment (Node.js)");
+    return executeServerPush(tempPath, validatedEvent, logger2, 6e4, context);
   }
 }
 async function executeWebPush(bundlePath, event, logger2) {
@@ -2046,18 +2206,21 @@ async function executeWebPush(bundlePath, event, logger2) {
     });
     const { window } = dom;
     logger2.debug("Loading bundle...");
-    const bundleCode = await fs9.readFile(bundlePath, "utf8");
+    const bundleCode = await fs10.readFile(bundlePath, "utf8");
     window.eval(bundleCode);
-    logger2.debug("Waiting for elb...");
+    logger2.debug("Waiting for collector...");
     await waitForWindowProperty2(
       window,
-      "elb",
+      "collector",
       5e3
     );
     const windowObj = window;
-    const elb = windowObj.elb;
+    const collector = windowObj.collector;
     logger2.log(`Pushing event: ${event.name}`);
-    const elbResult = await elb(event.name, event.data);
+    const elbResult = await collector.push({
+      name: event.name,
+      data: event.data
+    });
     return {
       success: true,
       elbResult,
@@ -2071,7 +2234,7 @@ async function executeWebPush(bundlePath, event, logger2) {
     };
   }
 }
-async function executeServerPush(bundlePath, event, logger2, timeout = 6e4) {
+async function executeServerPush(bundlePath, event, logger2, timeout = 6e4, context = {}) {
   const startTime = Date.now();
   try {
     const timeoutPromise = new Promise((_, reject) => {
@@ -2087,15 +2250,18 @@ async function executeServerPush(bundlePath, event, logger2, timeout = 6e4) {
         throw new Error("Bundle does not export default factory function");
       }
       logger2.debug("Calling factory function...");
-      const result = await flowModule.default();
-      if (!result || !result.elb || typeof result.elb !== "function") {
+      const result = await flowModule.default(context);
+      if (!result || !result.collector || typeof result.collector.push !== "function") {
         throw new Error(
-          "Factory function did not return valid result with elb"
+          "Factory function did not return valid result with collector"
         );
       }
-      const { elb } = result;
+      const { collector } = result;
       logger2.log(`Pushing event: ${event.name}`);
-      const elbResult = await elb(event.name, event.data);
+      const elbResult = await collector.push({
+        name: event.name,
+        data: event.data
+      });
       return {
         success: true,
         elbResult,
@@ -2187,7 +2353,7 @@ function validatePort(port) {
 
 // src/commands/run/utils.ts
 import path12 from "path";
-import fs10 from "fs-extra";
+import fs11 from "fs-extra";
 async function prepareBundleForRun(configPath, options) {
   const configDir = path12.dirname(path12.resolve(configPath));
   const tempDir = path12.join(
@@ -2195,7 +2361,7 @@ async function prepareBundleForRun(configPath, options) {
     ".tmp",
     `run-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
   );
-  await fs10.ensureDir(tempDir);
+  await fs11.ensureDir(tempDir);
   const tempPath = path12.join(tempDir, "bundle.mjs");
   await bundle(configPath, {
     cache: true,
@@ -2219,7 +2385,7 @@ import { createLogger as createLogger2, Level } from "@walkeros/core";
 // src/runtime/runner.ts
 import { pathToFileURL as pathToFileURL2 } from "url";
 import { resolve, dirname as dirname2 } from "path";
-async function runFlow(file, config, logger2) {
+async function runFlow(file, config, logger2, loggerConfig2) {
   logger2.info(`Loading flow from ${file}`);
   try {
     const absolutePath = resolve(file);
@@ -2232,7 +2398,8 @@ async function runFlow(file, config, logger2) {
         `Invalid flow bundle: ${file} must export a default function`
       );
     }
-    const result = await module.default(config);
+    const flowContext = loggerConfig2 ? { ...config, logger: loggerConfig2 } : config;
+    const result = await module.default(flowContext);
     if (!result || !result.collector) {
       logger2.throw(`Invalid flow bundle: ${file} must return { collector }`);
     }
@@ -2338,7 +2505,8 @@ async function runServeMode(config, logger2) {
 
 // src/commands/run/execution.ts
 var logLevel = process.env.VERBOSE === "true" ? Level.DEBUG : Level.INFO;
-var logger = createLogger2({ level: logLevel });
+var loggerConfig = { level: logLevel };
+var logger = createLogger2(loggerConfig);
 async function executeRunLocal(mode, flowPath, options) {
   switch (mode) {
     case "collect": {
@@ -2349,7 +2517,7 @@ async function executeRunLocal(mode, flowPath, options) {
         port: options.port,
         host: options.host
       };
-      await runFlow(flowPath, config, logger.scope("runner"));
+      await runFlow(flowPath, config, logger.scope("runner"), loggerConfig);
       break;
     }
     case "serve": {
@@ -2467,20 +2635,20 @@ async function run(mode, options) {
 }
 
 // src/commands/cache.ts
-import fs11 from "fs-extra";
+import fs12 from "fs-extra";
 function registerCacheCommand(program2) {
   const cache = program2.command("cache").description("Manage the CLI cache");
   cache.command("clear").description("Clear all cached packages and builds").option("--packages", "Clear only package cache").option("--builds", "Clear only build cache").option("--tmp-dir <dir>", "Custom temp directory").option("--silent", "Suppress output").action(async (options) => {
     const logger2 = createLogger({ silent: options.silent });
     const tmpDir = options.tmpDir;
     if (options.packages) {
-      await fs11.remove(getTmpPath(tmpDir, "cache", "packages"));
+      await fs12.remove(getTmpPath(tmpDir, "cache", "packages"));
       logger2.log("Package cache cleared");
     } else if (options.builds) {
-      await fs11.remove(getTmpPath(tmpDir, "cache", "builds"));
+      await fs12.remove(getTmpPath(tmpDir, "cache", "builds"));
       logger2.log("Build cache cleared");
     } else {
-      await fs11.remove(getTmpPath(tmpDir, "cache"));
+      await fs12.remove(getTmpPath(tmpDir, "cache"));
       logger2.log("All caches cleared");
     }
   });
@@ -2500,13 +2668,13 @@ function registerCleanCommand(program2) {
   program2.command("clean").description("Clear the entire temp directory (.tmp/)").option("--tmp-dir <dir>", "Custom temp directory").option("--silent", "Suppress output").action(async (options) => {
     const logger2 = createLogger({ silent: options.silent });
     const tmpDir = options.tmpDir || getDefaultTmpRoot();
-    await fs11.remove(tmpDir);
+    await fs12.remove(tmpDir);
     logger2.log(`Temp directory cleared: ${tmpDir}`);
   });
 }
 async function countEntries(dir) {
-  if (!await fs11.pathExists(dir)) return 0;
-  const entries = await fs11.readdir(dir);
+  if (!await fs12.pathExists(dir)) return 0;
+  const entries = await fs12.readdir(dir);
   return entries.length;
 }
 
@@ -2535,10 +2703,11 @@ program.command("bundle [file]").description("Bundle NPM packages with custom co
 program.command("simulate [file]").description("Simulate event processing and capture API calls").option(
   "-e, --event <source>",
   "Event to simulate (JSON string, file path, or URL)"
-).option("--json", "Output results as JSON").option("-v, --verbose", "Verbose output").option("--dry-run", "preview command without executing").option("--silent", "suppress output").action(async (file, options) => {
+).option("-p, --platform <platform>", "Platform override (web or server)").option("--json", "Output results as JSON").option("-v, --verbose", "Verbose output").option("--dry-run", "preview command without executing").option("--silent", "suppress output").action(async (file, options) => {
   await simulateCommand({
     config: file || "bundle.config.json",
     event: options.event,
+    platform: options.platform,
     json: options.json,
     verbose: options.verbose,
     dryRun: options.dryRun,
@@ -2548,11 +2717,12 @@ program.command("simulate [file]").description("Simulate event processing and ca
 program.command("push [file]").description("Push an event through the flow with real API execution").requiredOption(
   "-e, --event <source>",
   "Event to push (JSON string, file path, or URL)"
-).option("--flow <name>", "Flow name (for multi-flow configs)").option("--json", "Output results as JSON").option("-v, --verbose", "Verbose output").option("-s, --silent", "Suppress output").action(async (file, options) => {
+).option("--flow <name>", "Flow name (for multi-flow configs)").option("-p, --platform <platform>", "Platform override (web or server)").option("--json", "Output results as JSON").option("-v, --verbose", "Verbose output").option("-s, --silent", "Suppress output").action(async (file, options) => {
   await pushCommand({
     config: file || "bundle.config.json",
     event: options.event,
     flow: options.flow,
+    platform: options.platform,
     json: options.json,
     verbose: options.verbose,
     silent: options.silent