@walkeros/cli 0.3.6 → 0.4.1

package/dist/index.js

@@ -77,6 +77,13 @@ function createLogger(options = {}) {
     }
   };
 }
+function createCommandLogger(options) {
+  return createLogger({
+    verbose: options.verbose,
+    silent: options.silent ?? false,
+    json: options.json
+  });
+}
 
 // src/core/timer.ts
 function createTimer() {
@@ -200,6 +207,59 @@ function getTempDir(tempDir = ".tmp") {
   const basePath = path.isAbsolute(tempDir) ? tempDir : path.join(process.cwd(), tempDir);
   return path.join(basePath, `cli-${Date.now()}-${randomId}`);
 }
+async function loadJsonFromSource(source, options) {
+  const paramName = options?.name || "input";
+  if (!source || source.trim() === "") {
+    if (options?.required) {
+      throw new Error(`${paramName} is required`);
+    }
+    if (options?.fallback !== void 0) {
+      return options.fallback;
+    }
+    return {};
+  }
+  const trimmedSource = source.trim();
+  if (isUrl(trimmedSource)) {
+    try {
+      const tempPath = await downloadFromUrl(trimmedSource);
+      try {
+        const data = await fs.readJson(tempPath);
+        return data;
+      } finally {
+        try {
+          await fs.remove(tempPath);
+        } catch {
+        }
+      }
+    } catch (error) {
+      throw new Error(
+        `Failed to load ${paramName} from URL ${trimmedSource}: ${getErrorMessage(error)}`
+      );
+    }
+  }
+  const resolvedPath = path.resolve(trimmedSource);
+  if (await fs.pathExists(resolvedPath)) {
+    try {
+      const data = await fs.readJson(resolvedPath);
+      return data;
+    } catch (error) {
+      throw new Error(
+        `Failed to parse ${paramName} from file ${trimmedSource}: ${getErrorMessage(error)}`
+      );
+    }
+  }
+  try {
+    const parsed = JSON.parse(trimmedSource);
+    return parsed;
+  } catch (jsonError) {
+    if (!trimmedSource.startsWith("{") && !trimmedSource.startsWith("[")) {
+      return { name: trimmedSource };
+    }
+    throw new Error(
+      `Failed to parse ${paramName}. Input appears to be JSON but contains errors: ${jsonError instanceof Error ? jsonError.message : String(jsonError)}`
+    );
+  }
+}
 
 // src/core/docker.ts
 function readPackageVersion() {
@@ -218,6 +278,13 @@ function readPackageVersion() {
 var CLI_VERSION = readPackageVersion();
 var CLI_DOCKER_IMAGE = process.env.WALKEROS_CLI_DOCKER_IMAGE || `walkeros/cli:${CLI_VERSION}`;
 var RUNTIME_DOCKER_IMAGE = process.env.WALKEROS_RUNTIME_DOCKER_IMAGE || `walkeros/docker:${DOCKER_VERSION}`;
+function buildCommonDockerArgs(options) {
+  const args = [options.config];
+  if (options.json) args.push("--json");
+  if (options.verbose) args.push("--verbose");
+  if (options.silent) args.push("--silent");
+  return args;
+}
 function buildDockerCommand(command, args, options = {}, configFile) {
   const cwd = process.cwd();
   const cmd = ["docker", "run", "--rm"];
@@ -380,6 +447,10 @@ async function executeCommand(localHandler, dockerCommand, dockerArgs, options,
   }
 }
 
+// src/core/temp-manager.ts
+import { getHashServer } from "@walkeros/server-core";
+import fs2 from "fs-extra";
+
 // src/core/asset-resolver.ts
 import { fileURLToPath as fileURLToPath2 } from "url";
 import path3 from "path";
@@ -389,6 +460,10 @@ function getPackageRoot() {
     const srcIndex = currentFile.indexOf("/src/");
     return currentFile.substring(0, srcIndex);
   }
+  if (currentFile.includes("/dist/")) {
+    const distIndex = currentFile.indexOf("/dist/");
+    return currentFile.substring(0, distIndex);
+  }
   return path3.resolve(currentFile, "../..");
 }
 function resolveAsset(assetPath, assetType, baseDir) {
@@ -406,6 +481,11 @@ function resolveAsset(assetPath, assetType, baseDir) {
   return path3.resolve(resolveBase, assetPath);
 }
 
+// src/core/utils.ts
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
 // src/config/validators.ts
 function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && Object.prototype.toString.call(value) === "[object Object]";
@@ -417,94 +497,79 @@ function isMultiEnvConfig(data) {
   return isObject(data) && "version" in data && data.version === 1 && "environments" in data && isObject(data.environments);
 }
 function isSingleEnvConfig(data) {
-  return isObject(data) && "flow" in data && "build" in data && isObject(data.flow) && isObject(data.build) && "platform" in data.flow && validatePlatform(data.flow.platform);
+  return isObject(data) && "flow" in data && "build" in data && isObject(data.flow) && isObject(data.build) && "platform" in data.flow;
 }
 
-// src/config/defaults.ts
-function getDefaultBuildOptions(platform, code, output) {
-  const common = {
-    code,
-    packages: {},
-    minify: false,
-    sourcemap: false,
-    cache: true
-  };
-  if (platform === "web") {
+// src/config/parser.ts
+import path4 from "path";
+function parseConfigStructure(rawConfig, options = {}) {
+  if (isMultiEnvConfig(rawConfig)) {
+    const setup = rawConfig;
+    const availableEnvironments = Object.keys(setup.environments);
+    if (!options.environment) {
+      throw new Error(
+        `Multi-environment configuration detected. Please specify an environment using --env flag.
+Available environments: ${availableEnvironments.join(", ")}`
+      );
+    }
+    const selectedEnv = options.environment;
+    if (!setup.environments[selectedEnv]) {
+      throw new Error(
+        `Environment "${selectedEnv}" not found in configuration.
+Available environments: ${availableEnvironments.join(", ")}`
+      );
+    }
+    const envConfig = setup.environments[selectedEnv];
     return {
-      ...common,
-      platform: "browser",
-      format: "iife",
-      target: "es2020",
-      output: output || "./dist/walker.js",
-      globalName: "walkerOS"
+      flowConfig: envConfig.flow,
+      buildOptions: envConfig.build,
+      metadata: {
+        environment: selectedEnv,
+        isMultiEnvironment: true,
+        availableEnvironments
+      }
     };
   }
-  return {
-    ...common,
-    platform: "node",
-    format: "esm",
-    target: "node18",
-    output: output || "./dist/bundle.js"
-  };
-}
-function ensureBuildOptions(buildOptions, flowPlatform) {
-  const defaults = getDefaultBuildOptions(
-    flowPlatform,
-    buildOptions.code || "",
-    buildOptions.output
-  );
-  if (!buildOptions.output && !defaults.output) {
-    throw new Error("BuildOptions.output is required");
+  if (isSingleEnvConfig(rawConfig)) {
+    const config = rawConfig;
+    return {
+      flowConfig: config.flow,
+      buildOptions: config.build,
+      metadata: {
+        environment: "default",
+        isMultiEnvironment: false
+      }
+    };
   }
-  return {
-    ...defaults,
-    ...buildOptions,
-    code: buildOptions.code || defaults.code || "",
-    output: buildOptions.output || defaults.output,
-    packages: buildOptions.packages || defaults.packages
-  };
-}
+  const configPath = options.configPath || "configuration";
+  const configType = isObject(rawConfig) ? "platform" in rawConfig ? `invalid platform value: "${rawConfig.platform}"` : 'missing "flow" and "build" fields' : `not an object (got ${typeof rawConfig})`;
+  throw new Error(
+    `Invalid configuration format at ${configPath}.
+Configuration ${configType}.
 
-// src/config/parser.ts
-import path4 from "path";
-function parseBundleConfig(data) {
-  if (!isObject(data)) {
-    throw new Error(`Invalid config: expected object, got ${typeof data}`);
-  }
-  if (!("flow" in data) || !isObject(data.flow)) {
-    throw new Error(
-      `Invalid config: missing "flow" field. Expected format: { flow: { platform: "web" | "server", ... }, build: { ... } }`
-    );
-  }
-  if (!("build" in data) || !isObject(data.build)) {
-    throw new Error(
-      `Invalid config: missing "build" field. Expected format: { flow: { platform: "web" | "server", ... }, build: { ... } }`
-    );
-  }
-  const flowData = data.flow;
-  if (!("platform" in flowData) || flowData.platform !== "web" && flowData.platform !== "server") {
-    throw new Error(
-      `Invalid config: flow.platform must be "web" or "server", got "${flowData.platform}"`
-    );
-  }
-  const buildData = data.build;
-  if ("packages" in buildData && !isObject(buildData.packages)) {
+Expected either:
+  1. Multi-environment: { version: 1, environments: { prod: { flow: {...}, build: {...} } } }
+  2. Single-environment: { flow: { platform: "web" | "server", ... }, build: { packages: {...}, ... } }`
+  );
+}
+function normalizeAndValidate(flowConfig, buildOptions, configPath) {
+  if (!isObject(flowConfig) || !("platform" in flowConfig)) {
     throw new Error(
-      `Invalid config: build.packages must be an object, got ${typeof buildData.packages}`
+      `Invalid flow config: missing "platform" field. Expected "web" or "server".`
     );
   }
-  const config = data;
-  return normalizeConfigs(config, "/unknown/path");
-}
-function normalizeConfigs(config, configPath) {
-  const flowConfig = config.flow;
   const platform = flowConfig.platform;
   if (!validatePlatform(platform)) {
     throw new Error(
       `Invalid platform "${platform}". Must be "web" or "server".`
     );
   }
-  const buildDefaults = platform === "web" ? {
+  if (!isObject(buildOptions)) {
+    throw new Error(
+      `Invalid build options: expected object, got ${typeof buildOptions}`
+    );
+  }
+  const platformDefaults = platform === "web" ? {
     platform: "browser",
     format: "iife",
     target: "es2020",
@@ -521,43 +586,97 @@ function normalizeConfigs(config, configPath) {
     tempDir: ".tmp",
     cache: true
   };
-  const buildConfig = {
-    ...buildDefaults,
-    ...config.build
+  const merged = {
+    ...platformDefaults,
+    ...buildOptions
   };
-  if (buildConfig.template === void 0) {
-    buildConfig.template = platform === "server" ? "server.hbs" : "web.hbs";
+  if (merged.template === void 0) {
+    merged.template = platform === "server" ? "server.hbs" : "web.hbs";
   }
-  if (configPath && buildConfig.template && !path4.isAbsolute(buildConfig.template)) {
-    if (buildConfig.template.startsWith("./") || buildConfig.template.startsWith("../")) {
-      const configDir = path4.dirname(configPath);
-      buildConfig.template = path4.resolve(configDir, buildConfig.template);
+  if (merged.format === "iife" && merged.platform === "browser") {
+    if (merged.windowCollector === void 0) {
+      merged.windowCollector = "collector";
+    }
+    if (merged.windowElb === void 0) {
+      merged.windowElb = "elb";
     }
   }
-  const buildOptions = ensureBuildOptions(buildConfig, platform);
+  if (configPath && merged.template && !path4.isAbsolute(merged.template) && (merged.template.startsWith("./") || merged.template.startsWith("../"))) {
+    const configDir = path4.dirname(configPath);
+    merged.template = path4.resolve(configDir, merged.template);
+  }
+  if (!merged.output || merged.output === "") {
+    merged.output = platform === "web" ? "./dist/walker.js" : "./dist/bundle.js";
+  }
+  if (configPath && configPath !== "/unknown/path" && merged.output && !path4.isAbsolute(merged.output)) {
+    const configDir = path4.dirname(configPath);
+    merged.output = path4.resolve(configDir, merged.output);
+  }
+  if (!merged.packages) {
+    merged.packages = {};
+  }
+  if (merged.code === void 0 || merged.code === "") {
+    merged.code = "";
+  }
   return {
     flowConfig,
-    buildOptions
+    buildOptions: merged
   };
 }
+function parseBundleConfig(data) {
+  if (!isObject(data)) {
+    throw new Error(`Invalid config: expected object, got ${typeof data}`);
+  }
+  if (!("flow" in data) || !isObject(data.flow)) {
+    throw new Error(
+      `Invalid config: missing "flow" field. Expected format: { flow: { platform: "web" | "server", ... }, build: { ... } }`
+    );
+  }
+  if (!("build" in data) || !isObject(data.build)) {
+    throw new Error(
+      `Invalid config: missing "build" field. Expected format: { flow: { platform: "web" | "server", ... }, build: { ... } }`
+    );
+  }
+  const buildData = data.build;
+  if ("packages" in buildData && !isObject(buildData.packages)) {
+    throw new Error(
+      `Invalid config: build.packages must be an object, got ${typeof buildData.packages}`
+    );
+  }
+  return normalizeAndValidate(data.flow, data.build, "/unknown/path");
+}
+function normalizeConfigs(config, configPath) {
+  return normalizeAndValidate(config.flow, config.build, configPath);
+}
 
 // src/config/loader.ts
 function loadBundleConfig(rawConfig, options) {
-  if (isMultiEnvConfig(rawConfig)) {
-    return loadMultiEnvironmentConfig(rawConfig, options);
+  const { flowConfig, buildOptions, metadata } = parseConfigStructure(
+    rawConfig,
+    {
+      configPath: options.configPath,
+      environment: options.environment
+    }
+  );
+  const normalized = normalizeAndValidate(
+    flowConfig,
+    buildOptions,
+    options.configPath
+  );
+  if (metadata.isMultiEnvironment && options.logger) {
+    options.logger.info(
+      `\u{1F4E6} Using environment: ${metadata.environment} (${metadata.availableEnvironments?.length || 0} total)`
+    );
   }
-  if (isSingleEnvConfig(rawConfig)) {
-    return loadSingleEnvironmentConfig(rawConfig, options);
+  if (!metadata.isMultiEnvironment && options.environment && options.logger) {
+    options.logger.warn(
+      `--env flag specified but configuration is single-environment. Ignoring flag.`
+    );
   }
-  const configType = isObject(rawConfig) ? "platform" in rawConfig ? `invalid platform value: "${rawConfig.platform}"` : 'missing "flow" and "build" fields' : `not an object (got ${typeof rawConfig})`;
-  throw new Error(
-    `Invalid configuration format at ${options.configPath}.
-Configuration ${configType}.
-
-Expected either:
-  1. Multi-environment: { version: 1, environments: { prod: { flow: {...}, build: {...} } } }
-  2. Single-environment: { flow: { platform: "web" | "server", ... }, build: { packages: {...}, ... } }`
-  );
+  return {
+    ...normalized,
+    ...metadata
+  };
 }
 function loadMultiEnvironmentConfig(setup, options) {
   const availableEnvironments = Object.keys(setup.environments);
@@ -592,23 +711,6 @@ Available environments: ${availableEnvironments.join(", ")}`
     availableEnvironments
   };
 }
-function loadSingleEnvironmentConfig(config, options) {
-  const { flowConfig, buildOptions } = normalizeConfigs(
-    config,
-    options.configPath
-  );
-  if (options.logger && options.environment) {
-    options.logger.warn(
-      `--env flag specified but configuration is single-environment. Ignoring flag.`
-    );
-  }
-  return {
-    flowConfig,
-    buildOptions,
-    environment: "default",
-    isMultiEnvironment: false
-  };
-}
 function loadAllEnvironments(rawConfig, options) {
   if (!isMultiEnvConfig(rawConfig)) {
     throw new Error(
@@ -634,12 +736,12 @@ Your configuration appears to be single-environment.`
 // src/commands/bundle/bundler.ts
 import esbuild from "esbuild";
 import path6 from "path";
-import fs4 from "fs-extra";
+import fs5 from "fs-extra";
 
 // src/commands/bundle/package-manager.ts
 import pacote from "pacote";
 import path5 from "path";
-import fs2 from "fs-extra";
+import fs3 from "fs-extra";
 function getPackageDirectory(baseDir, packageName, version) {
   return path5.join(baseDir, "node_modules", packageName);
 }
@@ -650,7 +752,7 @@ function getCachedPackagePath(pkg, tempDir) {
 }
 async function isPackageCached(pkg, tempDir) {
   const cachedPath = getCachedPackagePath(pkg, tempDir);
-  return fs2.pathExists(cachedPath);
+  return fs3.pathExists(cachedPath);
 }
 function validateNoDuplicatePackages(packages) {
   const packageMap = /* @__PURE__ */ new Map();
@@ -685,8 +787,8 @@ async function resolveDependencies(pkg, packageDir, logger, visited = /* @__PURE
   visited.add(pkgKey);
   try {
     const packageJsonPath = path5.join(packageDir, "package.json");
-    if (await fs2.pathExists(packageJsonPath)) {
-      const packageJson2 = await fs2.readJson(packageJsonPath);
+    if (await fs3.pathExists(packageJsonPath)) {
+      const packageJson2 = await fs3.readJson(packageJsonPath);
       const deps = {
         ...packageJson2.dependencies,
         ...packageJson2.peerDependencies
@@ -707,7 +809,7 @@ async function downloadPackages(packages, targetDir, logger, useCache = true) {
   const downloadQueue = [...packages];
   const processed = /* @__PURE__ */ new Set();
   validateNoDuplicatePackages(packages);
-  await fs2.ensureDir(targetDir);
+  await fs3.ensureDir(targetDir);
   while (downloadQueue.length > 0) {
     const pkg = downloadQueue.shift();
     const pkgKey = `${pkg.name}@${pkg.version}`;
@@ -721,8 +823,8 @@ async function downloadPackages(packages, targetDir, logger, useCache = true) {
     if (useCache && await isPackageCached(pkg, targetDir)) {
       logger.debug(`Using cached ${packageSpec}...`);
       try {
-        await fs2.ensureDir(path5.dirname(packageDir));
-        await fs2.copy(cachedPath, packageDir);
+        await fs3.ensureDir(path5.dirname(packageDir));
+        await fs3.copy(cachedPath, packageDir);
         packagePaths.set(pkg.name, packageDir);
         const deps = await resolveDependencies(pkg, packageDir, logger);
         for (const dep of deps) {
@@ -740,7 +842,7 @@ async function downloadPackages(packages, targetDir, logger, useCache = true) {
     }
     logger.debug(`Downloading ${packageSpec}...`);
     try {
-      await fs2.ensureDir(path5.dirname(packageDir));
+      await fs3.ensureDir(path5.dirname(packageDir));
       const cacheDir = process.env.NPM_CACHE_DIR || path5.join(process.cwd(), ".npm-cache");
       await pacote.extract(packageSpec, packageDir, {
         // Force npm registry download, prevent workspace resolution
@@ -754,8 +856,8 @@ async function downloadPackages(packages, targetDir, logger, useCache = true) {
       });
       if (useCache) {
         try {
-          await fs2.ensureDir(path5.dirname(cachedPath));
-          await fs2.copy(packageDir, cachedPath);
+          await fs3.ensureDir(path5.dirname(cachedPath));
+          await fs3.copy(packageDir, cachedPath);
           logger.debug(`Cached ${packageSpec} for future use`);
         } catch (cacheError) {
           logger.debug(`Failed to cache ${packageSpec}: ${cacheError}`);
@@ -777,7 +879,7 @@ async function downloadPackages(packages, targetDir, logger, useCache = true) {
 }
 
 // src/commands/bundle/template-engine.ts
-import fs3 from "fs-extra";
+import fs4 from "fs-extra";
 import Handlebars from "handlebars";
 
 // src/commands/bundle/serializer.ts
@@ -885,6 +987,7 @@ var TemplateEngine = class {
   handlebars;
   constructor() {
     this.handlebars = Handlebars.create();
+    this.handlebars.registerHelper("eq", (a, b) => a === b);
   }
   /**
    * Load template content from file path
@@ -893,10 +996,10 @@ var TemplateEngine = class {
    */
   async loadTemplate(templatePath) {
     const resolvedPath = resolveAsset(templatePath, "template");
-    if (!await fs3.pathExists(resolvedPath)) {
+    if (!await fs4.pathExists(resolvedPath)) {
       throw new Error(`Template file not found: ${resolvedPath}`);
     }
-    return await fs3.readFile(resolvedPath, "utf-8");
+    return await fs4.readFile(resolvedPath, "utf-8");
   }
   /**
    * Apply template with user code and variable substitution
@@ -937,7 +1040,7 @@ async function bundleCore(flowConfig, buildOptions, logger, showStats = false) {
   const TEMP_DIR = buildOptions.tempDir ? path6.isAbsolute(buildOptions.tempDir) ? buildOptions.tempDir : path6.resolve(buildOptions.tempDir) : getTempDir();
   try {
     if (!buildOptions.tempDir) {
-      await fs4.emptyDir(TEMP_DIR);
+      await fs5.emptyDir(TEMP_DIR);
     }
     logger.debug("Cleaned temporary directory");
     logger.info("\u{1F4E5} Downloading packages...");
@@ -956,7 +1059,7 @@ async function bundleCore(flowConfig, buildOptions, logger, showStats = false) {
     for (const [pkgName, pkgPath] of packagePaths.entries()) {
       if (pkgName.startsWith("@walkeros/")) {
         const pkgJsonPath = path6.join(pkgPath, "package.json");
-        const pkgJson = await fs4.readJSON(pkgJsonPath);
+        const pkgJson = await fs5.readJSON(pkgJsonPath);
         if (!pkgJson.exports && pkgJson.module) {
           pkgJson.exports = {
             ".": {
@@ -964,12 +1067,12 @@ async function bundleCore(flowConfig, buildOptions, logger, showStats = false) {
               require: pkgJson.main
             }
           };
-          await fs4.writeJSON(pkgJsonPath, pkgJson, { spaces: 2 });
+          await fs5.writeJSON(pkgJsonPath, pkgJson, { spaces: 2 });
         }
       }
     }
     const packageJsonPath = path6.join(TEMP_DIR, "package.json");
-    await fs4.writeFile(
+    await fs5.writeFile(
       packageJsonPath,
       JSON.stringify({ type: "module" }, null, 2)
     );
@@ -980,10 +1083,10 @@ async function bundleCore(flowConfig, buildOptions, logger, showStats = false) {
       packagePaths
     );
     const entryPath = path6.join(TEMP_DIR, "entry.js");
-    await fs4.writeFile(entryPath, entryContent);
+    await fs5.writeFile(entryPath, entryContent);
     logger.info("\u26A1 Bundling with esbuild...");
     const outputPath = path6.resolve(buildOptions.output);
-    await fs4.ensureDir(path6.dirname(outputPath));
+    await fs5.ensureDir(path6.dirname(outputPath));
     const esbuildOptions = createEsbuildOptions(
       buildOptions,
       entryPath,
@@ -1011,20 +1114,20 @@ async function bundleCore(flowConfig, buildOptions, logger, showStats = false) {
       );
     }
     if (!buildOptions.tempDir) {
-      await fs4.remove(TEMP_DIR);
+      await fs5.remove(TEMP_DIR);
       logger.debug("Cleaned up temporary files");
     }
     return stats;
   } catch (error) {
     if (!buildOptions.tempDir) {
-      await fs4.remove(TEMP_DIR).catch(() => {
+      await fs5.remove(TEMP_DIR).catch(() => {
       });
     }
     throw error;
   }
 }
 async function collectBundleStats(outputPath, packages, startTime, entryContent) {
-  const stats = await fs4.stat(outputPath);
+  const stats = await fs5.stat(outputPath);
   const totalSize = stats.size;
   const buildTime = Date.now() - startTime;
   const packageStats = Object.entries(packages).map(([name, pkg]) => {
@@ -1111,9 +1214,6 @@ function createEsbuildOptions(buildOptions, entryPath, outputPath, tempDir, pack
   } else {
     baseOptions.target = "es2018";
   }
-  if (buildOptions.globalName && buildOptions.format === "iife") {
-    baseOptions.globalName = buildOptions.globalName;
-  }
   return baseOptions;
 }
 function packageNameToVariable(packageName) {
@@ -1121,9 +1221,7 @@ function packageNameToVariable(packageName) {
     (part, i) => i === 0 ? part : part.charAt(0).toUpperCase() + part.slice(1)
   ).join("");
 }
-async function createEntryPoint(flowConfig, buildOptions, packagePaths) {
-  const importStatements = [];
-  const examplesMappings = [];
+function detectDestinationPackages(flowConfig) {
   const destinationPackages = /* @__PURE__ */ new Set();
   const destinations = flowConfig.destinations;
   if (destinations) {
@@ -1133,9 +1231,12 @@ async function createEntryPoint(flowConfig, buildOptions, packagePaths) {
       }
     }
   }
-  for (const [packageName, packageConfig] of Object.entries(
-    buildOptions.packages
-  )) {
+  return destinationPackages;
+}
+function generateImportStatements(packages, destinationPackages) {
+  const importStatements = [];
+  const examplesMappings = [];
+  for (const [packageName, packageConfig] of Object.entries(packages)) {
     if (packageConfig.imports && packageConfig.imports.length > 0) {
       const uniqueImports = [...new Set(packageConfig.imports)];
       const defaultImports = [];
@@ -1181,38 +1282,14 @@ async function createEntryPoint(flowConfig, buildOptions, packagePaths) {
         `import * as ${varName} from '${packageName}'; // Consider specifying explicit imports`
       );
     }
-    if (destinationPackages.has(packageName)) {
-      const destinationMatch = packageName.match(
-        /@walkeros\/(?:(?:web|server)-)?destination-(.+)$/
-      );
-      if (destinationMatch) {
-        const destinationName = destinationMatch[1];
-        const examplesVarName = `${destinationName.replace(/-/g, "_")}_examples`;
-        const isDemoPackage = packageName.includes("-demo");
-        if (isDemoPackage) {
-          importStatements.push(
-            `import { examples as ${examplesVarName} } from '${packageName}';`
-          );
-        } else {
-          importStatements.push(
-            `import * as ${examplesVarName} from '${packageName}/examples';`
-          );
-        }
-        examplesMappings.push(`  ${destinationName}: ${examplesVarName}`);
-      }
-    }
   }
-  const examplesObject = examplesMappings.length > 0 ? `const examples = {
-${examplesMappings.join(",\n")}
-};
-
-` : "";
-  const importsCode = importStatements.join("\n");
-  let templatedCode;
+  return { importStatements, examplesMappings };
+}
+async function processTemplate(flowConfig, buildOptions) {
   if (buildOptions.template) {
     const templateEngine = new TemplateEngine();
     const flowWithProps = flowConfig;
-    templatedCode = await templateEngine.process(
+    return await templateEngine.process(
       buildOptions.template,
       buildOptions.code || "",
       // Pass user code as parameter (empty if undefined)
@@ -1223,27 +1300,53 @@ ${examplesMappings.join(",\n")}
       // Pass build config to template
     );
   } else {
-    templatedCode = buildOptions.code || "";
+    return buildOptions.code || "";
   }
-  let wrappedCode = templatedCode;
-  const hasExport = /^\s*export\s/m.test(templatedCode);
-  if (!hasExport) {
-    if (buildOptions.format === "esm") {
-      wrappedCode = `export default ${templatedCode}`;
-    } else if (buildOptions.platform === "browser" && buildOptions.globalName) {
-      wrappedCode = `window['${buildOptions.globalName}'] = ${templatedCode}`;
+}
+function wrapCodeForFormat(code, format, hasTemplate) {
+  if (hasTemplate) {
+    return code;
+  }
+  if (format === "esm") {
+    const hasExport = /^\s*export\s/m.test(code);
+    if (!hasExport) {
+      return `export default ${code}`;
     }
   }
+  return code;
+}
+function assembleFinalCode(importStatements, examplesObject, wrappedCode, format) {
+  const importsCode = importStatements.join("\n");
   let finalCode = importsCode ? `${importsCode}
 
 ${examplesObject}${wrappedCode}` : `${examplesObject}${wrappedCode}`;
-  if (examplesObject && buildOptions.format === "esm") {
+  if (examplesObject && format === "esm") {
     finalCode += `
 
 export { examples };`;
   }
   return finalCode;
 }
+async function createEntryPoint(flowConfig, buildOptions, packagePaths) {
+  const destinationPackages = detectDestinationPackages(flowConfig);
+  const { importStatements } = generateImportStatements(
+    buildOptions.packages,
+    destinationPackages
+  );
+  const examplesObject = "";
+  const templatedCode = await processTemplate(flowConfig, buildOptions);
+  const wrappedCode = wrapCodeForFormat(
+    templatedCode,
+    buildOptions.format,
+    !!buildOptions.template
+  );
+  return assembleFinalCode(
+    importStatements,
+    examplesObject,
+    wrappedCode,
+    buildOptions.format
+  );
+}
 function createBuildError(buildError, code) {
   if (!buildError.errors || buildError.errors.length === 0) {
     return new Error(`Build failed: ${buildError.message || buildError}`);
@@ -1295,19 +1398,12 @@ Package Breakdown:`);
 async function bundleCommand(options) {
   const timer = createTimer();
   timer.start();
-  const logger = createLogger({
-    verbose: options.verbose,
-    silent: options.silent ?? false,
-    json: options.json
-  });
-  const dockerArgs = [options.config];
+  const logger = createCommandLogger(options);
+  const dockerArgs = buildCommonDockerArgs(options);
   if (options.env) dockerArgs.push("--env", options.env);
   if (options.all) dockerArgs.push("--all");
   if (options.stats) dockerArgs.push("--stats");
-  if (options.json) dockerArgs.push("--json");
   if (options.cache === false) dockerArgs.push("--no-cache");
-  if (options.verbose) dockerArgs.push("--verbose");
-  if (options.silent) dockerArgs.push("--silent");
   await executeCommand(
     async () => {
       try {
@@ -1357,7 +1453,7 @@ async function bundleCommand(options) {
               displayStats(stats, logger);
             }
           } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
+            const errorMessage = getErrorMessage(error);
             results.push({
               environment,
               success: false,
@@ -1409,7 +1505,7 @@ async function bundleCommand(options) {
         }
       } catch (error) {
         const duration = timer.getElapsed() / 1e3;
-        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorMessage = getErrorMessage(error);
         if (options.json) {
           const outputLogger = createLogger({ silent: false, json: false });
           const output = createErrorOutput(errorMessage, duration);
@@ -1439,10 +1535,7 @@ async function bundle(configOrPath, options = {}) {
   if (options.cache !== void 0) {
     buildOptions.cache = options.cache;
   }
-  const logger = createLogger({
-    silent: options.silent ?? false,
-    verbose: options.verbose ?? false
-  });
+  const logger = createCommandLogger(options);
   return await bundleCore(
     flowConfig,
     buildOptions,
@@ -1453,7 +1546,7 @@ async function bundle(configOrPath, options = {}) {
 
 // src/commands/simulate/simulator.ts
 import path7 from "path";
-import fs5 from "fs-extra";
+import fs7 from "fs-extra";
 
 // src/commands/simulate/tracker.ts
 var CallTracker = class {
@@ -1489,9 +1582,9 @@ var CallTracker = class {
     }
     for (const fullPath of paths) {
       const [destKey, ...pathParts] = fullPath.split(":");
-      const path9 = pathParts.join(":");
-      if (!path9) continue;
-      const cleanPath = path9.replace(/^call:/, "");
+      const path11 = pathParts.join(":");
+      if (!path11) continue;
+      const cleanPath = path11.replace(/^call:/, "");
       const parts = cleanPath.split(".");
       let current = wrapped;
       let source = env;
@@ -1533,6 +1626,146 @@ var CallTracker = class {
   }
 };
 
+// src/commands/simulate/jsdom-executor.ts
+import { JSDOM, VirtualConsole } from "jsdom";
+import fs6 from "fs-extra";
+function buildSandboxFromEnvs(envs, destinations, tracker) {
+  const baseBrowserMocks = {
+    Image: class MockImage {
+      src = "";
+      onload = (() => {
+      });
+      onerror = (() => {
+      });
+    },
+    fetch: async () => ({ ok: true, json: async () => ({}) }),
+    location: { href: "http://localhost" },
+    navigator: { userAgent: "Mozilla/5.0 (walkerOS Simulation)" }
+  };
+  const sandbox = {
+    window: { ...baseBrowserMocks },
+    document: {}
+  };
+  for (const [destKey, destConfig] of Object.entries(destinations)) {
+    const destEnv = envs[destKey];
+    if (!destEnv?.push) continue;
+    const mockEnv = destEnv.push;
+    const trackPaths = destEnv.simulation || [];
+    const trackedEnv = tracker.wrapEnv(
+      mockEnv,
+      trackPaths.map((p) => `${destKey}:${p}`)
+    );
+    if (trackedEnv.window && typeof trackedEnv.window === "object") {
+      Object.assign(sandbox.window, trackedEnv.window);
+    }
+    if (trackedEnv.document && typeof trackedEnv.document === "object") {
+      Object.assign(sandbox.document, trackedEnv.document);
+    }
+  }
+  return sandbox;
+}
+function waitForWindowProperty(window, prop, timeout = 5e3) {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+    const check = () => {
+      if (window[prop] !== void 0) {
+        resolve();
+      } else if (Date.now() - start > timeout) {
+        reject(
+          new Error(
+            `Timeout waiting for window.${prop}. IIFE may have failed to execute or assign to window.`
+          )
+        );
+      } else {
+        setImmediate(check);
+      }
+    };
+    check();
+  });
+}
+async function executeInJSDOM(bundlePath, destinations, event, tracker, envs, timeout = 1e4) {
+  const start = Date.now();
+  const virtualConsole = new VirtualConsole();
+  const dom = new JSDOM("<!DOCTYPE html><html><body></body></html>", {
+    url: "http://localhost",
+    runScripts: "dangerously",
+    // Allow script execution
+    resources: "usable",
+    virtualConsole
+  });
+  const { window } = dom;
+  const sandbox = buildSandboxFromEnvs(envs, destinations, tracker);
+  Object.assign(window, sandbox.window);
+  Object.assign(window.document, sandbox.document);
+  const bundleCode = await fs6.readFile(bundlePath, "utf8");
+  try {
+    window.eval(bundleCode);
+  } catch (error) {
+    throw new Error(`Bundle execution failed: ${getErrorMessage(error)}`);
+  }
+  try {
+    await waitForWindowProperty(
+      window,
+      "collector",
+      timeout
+    );
+    await waitForWindowProperty(
+      window,
+      "elb",
+      timeout
+    );
+  } catch (error) {
+    throw new Error(
+      `Window property assignment failed: ${getErrorMessage(error)}`
+    );
+  }
+  const { collector, elb } = window;
+  let elbResult;
+  try {
+    elbResult = await elb(event.name, event.data);
+  } catch (error) {
+    throw new Error(`Event execution failed: ${getErrorMessage(error)}`);
+  }
+  return {
+    collector,
+    elb,
+    elbResult,
+    usage: tracker.getCalls(),
+    duration: Date.now() - start
+  };
+}
+
+// src/commands/simulate/env-loader.ts
+async function loadDestinationEnvs(destinations) {
+  const envs = {};
+  for (const [destKey, destConfig] of Object.entries(destinations)) {
+    const typedConfig = destConfig;
+    if (!typedConfig.package) {
+      continue;
+    }
+    try {
+      const packageName = typedConfig.package;
+      const isDemoPackage = packageName.includes("-demo");
+      const importPath = isDemoPackage ? packageName : `${packageName}/dev`;
+      const module = await import(importPath);
+      const examplesModule = module.examples || module.default?.examples;
+      const envModule = examplesModule?.env;
+      if (envModule?.push) {
+        envs[destKey] = {
+          init: envModule.init,
+          push: envModule.push,
+          simulation: envModule.simulation || []
+        };
+      }
+    } catch (error) {
+      console.warn(
+        `Warning: Could not load env for destination "${destKey}": ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  return envs;
+}
+
 // src/commands/simulate/simulator.ts
 function generateId() {
   return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
@@ -1558,7 +1791,7 @@ async function simulateCore(configPath, event, options = {}) {
     }
     return result;
   } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
+    const errorMessage = getErrorMessage(error);
     logger.error(`\u{1F4A5} Simulation error: ${errorMessage}`);
     return {
       success: false,
@@ -1566,17 +1799,6 @@ async function simulateCore(configPath, event, options = {}) {
     };
   }
 }
-function parseEventInput(eventString = "") {
-  if (!eventString) {
-    return {};
-  }
-  try {
-    const parsed = JSON.parse(eventString);
-    return isObject(parsed) ? parsed : {};
-  } catch {
-    return { name: eventString };
-  }
-}
 function formatSimulationResult(result, options = {}) {
   if (options.json) {
     const output = {
@@ -1597,7 +1819,13 @@ async function executeSimulation(event, configPath) {
   let bundlePath;
   const tempDir = getTempDir();
   try {
-    await fs5.ensureDir(tempDir);
+    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 fs7.ensureDir(tempDir);
     const rawConfig = await loadJsonConfig(configPath);
     const { flowConfig, buildOptions } = parseBundleConfig(rawConfig);
     const packagesArray = Object.entries(buildOptions.packages).map(
@@ -1614,46 +1842,25 @@ async function executeSimulation(event, configPath) {
       buildOptions.cache
     );
     const tracker = new CallTracker();
-    const envSetupCode = [];
-    const destinations = flowConfig.destinations;
-    if (destinations) {
-      for (const [key, dest] of Object.entries(destinations)) {
-        const destName = key.replace(/-/g, "_");
-        envSetupCode.push(`
-  // Inject tracked env for destination '${key}' using examples from bundle
-  if (examples && examples['${key}'] && examples['${key}'].env) {
-    const mockEnv = examples['${key}'].env.push;
-    const trackPaths = examples['${key}'].env.simulation || [];
-    if (mockEnv) {
-      const wrappedPaths = trackPaths.map((p) => '${key}:' + p);
-      const trackedEnv = __simulationTracker.wrapEnv(mockEnv, wrappedPaths);
-      if (config.destinations && config.destinations['${key}']) {
-        config.destinations['${key}'].env = trackedEnv;
-      }
-    }
-  }
-`);
-      }
-    }
-    const modifiedCode = `
-// Inject tracked envs into destination configs
-${envSetupCode.join("\n")}
-
-${buildOptions.code || ""}
-`;
     const tempOutput = path7.join(
       tempDir,
-      `simulation-bundle-${generateId()}.mjs`
+      `simulation-bundle-${generateId()}.js`
     );
+    const destinations = flowConfig.destinations;
     const simulationBuildOptions = {
       ...buildOptions,
-      code: modifiedCode,
+      code: buildOptions.code || "",
+      // No code modification - use original
       output: tempOutput,
       tempDir,
       // Use same temp dir for bundle
-      format: "esm",
-      // Force node platform for simulation since we're running in Node.js
-      platform: "node"
+      format: "iife",
+      // ← Test actual production format!
+      platform: "browser",
+      // ← Browser platform for IIFE
+      windowCollector: "collector",
+      // ← Ensure window assignment
+      windowElb: "elb"
     };
     await bundleCore(
       flowConfig,
@@ -1662,40 +1869,19 @@ ${buildOptions.code || ""}
       false
     );
     bundlePath = tempOutput;
-    const globalWithSim = globalThis;
-    if (!globalWithSim.window) {
-      globalWithSim.window = {};
-    }
-    if (!globalWithSim.document) {
-      globalWithSim.document = {};
-    }
-    const timestamp = Date.now();
-    const moduleUrl = `file://${bundlePath}?t=${timestamp}`;
-    const module = await import(moduleUrl);
-    const importedExamples = module.examples;
-    const destinations2 = flowConfig.destinations;
-    if (importedExamples && destinations2) {
-      for (const [key, dest] of Object.entries(destinations2)) {
-        const destEnv = importedExamples[key]?.env?.push;
-        if (destEnv) {
-          if (destEnv.window && typeof globalWithSim.window === "object" && globalWithSim.window !== null) {
-            Object.assign(globalWithSim.window, destEnv.window);
-          }
-          if (destEnv.document && typeof globalWithSim.document === "object" && globalWithSim.document !== null) {
-            Object.assign(globalWithSim.document, destEnv.document);
-          }
-        }
-      }
-    }
-    const flowResult = await module.default({ tracker });
-    if (!flowResult || typeof flowResult.elb !== "function") {
-      throw new Error(
-        "Bundle did not export valid flow object with elb function"
-      );
-    }
-    const { elb } = flowResult;
-    const elbResult = await elb(event);
-    const usage = tracker.getCalls();
+    const envs = await loadDestinationEnvs(destinations || {});
+    const result = await executeInJSDOM(
+      tempOutput,
+      destinations || {},
+      typedEvent,
+      tracker,
+      envs,
+      // Pass dynamically loaded envs
+      1e4
+      // 10s timeout
+    );
+    const elbResult = result.elbResult;
+    const usage = result.usage;
     const duration = Date.now() - startTime;
     return {
       success: true,
@@ -1708,37 +1894,29 @@ ${buildOptions.code || ""}
     const duration = Date.now() - startTime;
     return {
       success: false,
-      error: error instanceof Error ? error.message : String(error),
+      error: getErrorMessage(error),
       duration
     };
   } finally {
     if (tempDir) {
-      await fs5.remove(tempDir).catch(() => {
+      await fs7.remove(tempDir).catch(() => {
       });
     }
-    const globalWithSim = globalThis;
-    delete globalWithSim.window;
-    delete globalWithSim.document;
   }
 }
 
 // src/commands/simulate/index.ts
 async function simulateCommand(options) {
-  const logger = createLogger({
-    verbose: options.verbose,
-    silent: options.silent ?? false,
-    json: options.json
-  });
-  const dockerArgs = [options.config];
+  const logger = createCommandLogger(options);
+  const dockerArgs = buildCommonDockerArgs(options);
   if (options.event) dockerArgs.push("--event", options.event);
-  if (options.json) dockerArgs.push("--json");
-  if (options.verbose) dockerArgs.push("--verbose");
-  if (options.silent) dockerArgs.push("--silent");
   await executeCommand(
     async () => {
       const startTime = Date.now();
       try {
-        const event = parseEventInput(options.event);
+        const event = await loadJsonFromSource(options.event, {
+          name: "event"
+        });
         const result = await simulateCore(options.config, event, {
           json: options.json,
           verbose: options.verbose,
@@ -1757,7 +1935,7 @@ async function simulateCommand(options) {
           process.exit(1);
         }
       } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorMessage = getErrorMessage(error);
         if (options.json) {
           const outputLogger = createLogger({ silent: false, json: false });
           const errorOutput = JSON.stringify(
@@ -1796,13 +1974,249 @@ async function simulate(configOrPath, event, options = {}) {
   });
 }
 
-// src/commands/run/index.ts
+// src/commands/push/index.ts
 import path8 from "path";
 import os2 from "os";
-import {
-  runFlow,
-  runServeMode
-} from "@walkeros/docker";
+import { JSDOM as JSDOM2, VirtualConsole as VirtualConsole2 } from "jsdom";
+import fs8 from "fs-extra";
+async function pushCommand(options) {
+  const logger = createCommandLogger(options);
+  const dockerArgs = buildCommonDockerArgs(options);
+  dockerArgs.push("--event", options.event);
+  if (options.env) dockerArgs.push("--env", options.env);
+  await executeCommand(
+    async () => {
+      const startTime = Date.now();
+      try {
+        logger.info("\u{1F4E5} Loading event...");
+        const event = await loadJsonFromSource(options.event, {
+          name: "event"
+        });
+        if (!event || typeof event !== "object" || !("name" in event) || typeof event.name !== "string") {
+          throw new Error(
+            'Event must be an object with a "name" property (string)'
+          );
+        }
+        if (!event.name.includes(" ")) {
+          logger.warn(
+            `Event name "${event.name}" should follow "ENTITY ACTION" format (e.g., "page view")`
+          );
+        }
+        logger.info("\u{1F4E6} Loading flow configuration...");
+        const configPath = path8.resolve(options.config);
+        const rawConfig = await loadJsonConfig(configPath);
+        const { flowConfig, buildOptions, environment, isMultiEnvironment } = loadBundleConfig(rawConfig, {
+          configPath: options.config,
+          environment: options.env,
+          logger
+        });
+        const platform = flowConfig.platform;
+        logger.info("\u{1F528} Bundling flow configuration...");
+        const tempPath = path8.join(
+          os2.tmpdir(),
+          `walkeros-push-${Date.now()}-${Math.random().toString(36).slice(2, 9)}.${platform === "web" ? "js" : "mjs"}`
+        );
+        const configWithOutput = {
+          flow: flowConfig,
+          build: {
+            ...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 bundle(configWithOutput, {
+          cache: true,
+          verbose: options.verbose,
+          silent: !options.verbose
+        });
+        logger.debug(`Bundle created: ${tempPath}`);
+        let result;
+        if (platform === "web") {
+          logger.info("\u{1F310} Executing in web environment (JSDOM)...");
+          result = await executeWebPush(tempPath, event, logger);
+        } else if (platform === "server") {
+          logger.info("\u{1F5A5}\uFE0F  Executing in server environment (Node.js)...");
+          result = await executeServerPush(tempPath, event, logger);
+        } else {
+          throw new Error(`Unsupported platform: ${platform}`);
+        }
+        const duration = Date.now() - startTime;
+        if (options.json) {
+          const outputLogger = createLogger({ silent: false, json: false });
+          outputLogger.log(
+            "white",
+            JSON.stringify(
+              {
+                success: result.success,
+                event: result.elbResult,
+                duration
+              },
+              null,
+              2
+            )
+          );
+        } else {
+          if (result.success) {
+            logger.success("\u2705 Event pushed successfully");
+            if (result.elbResult && typeof result.elbResult === "object") {
+              const pushResult = result.elbResult;
+              if ("id" in pushResult && pushResult.id) {
+                logger.info(`   Event ID: ${pushResult.id}`);
+              }
+              if ("entity" in pushResult && pushResult.entity) {
+                logger.info(`   Entity: ${pushResult.entity}`);
+              }
+              if ("action" in pushResult && pushResult.action) {
+                logger.info(`   Action: ${pushResult.action}`);
+              }
+            }
+            logger.info(`   Duration: ${duration}ms`);
+          } else {
+            logger.error(`\u274C Push failed: ${result.error}`);
+            process.exit(1);
+          }
+        }
+        try {
+          await fs8.remove(tempPath);
+        } catch {
+        }
+      } catch (error) {
+        const duration = Date.now() - startTime;
+        const errorMessage = getErrorMessage(error);
+        if (options.json) {
+          const outputLogger = createLogger({ silent: false, json: false });
+          outputLogger.log(
+            "white",
+            JSON.stringify(
+              {
+                success: false,
+                error: errorMessage,
+                duration
+              },
+              null,
+              2
+            )
+          );
+        } else {
+          logger.error(`\u274C Push command failed: ${errorMessage}`);
+        }
+        process.exit(1);
+      }
+    },
+    "push",
+    dockerArgs,
+    options,
+    logger,
+    options.config
+  );
+}
+async function executeWebPush(bundlePath, event, logger) {
+  const startTime = Date.now();
+  try {
+    const virtualConsole = new VirtualConsole2();
+    const dom = new JSDOM2("<!DOCTYPE html><html><body></body></html>", {
+      url: "http://localhost",
+      runScripts: "dangerously",
+      resources: "usable",
+      virtualConsole
+    });
+    const { window } = dom;
+    logger.debug("Loading bundle...");
+    const bundleCode = await fs8.readFile(bundlePath, "utf8");
+    window.eval(bundleCode);
+    logger.debug("Waiting for elb...");
+    await waitForWindowProperty2(
+      window,
+      "elb",
+      5e3
+    );
+    const windowObj = window;
+    const elb = windowObj.elb;
+    logger.info(`Pushing event: ${event.name}`);
+    const eventData = event.data || {};
+    const elbResult = await elb(event.name, eventData);
+    return {
+      success: true,
+      elbResult,
+      duration: Date.now() - startTime
+    };
+  } catch (error) {
+    return {
+      success: false,
+      duration: Date.now() - startTime,
+      error: getErrorMessage(error)
+    };
+  }
+}
+async function executeServerPush(bundlePath, event, logger, timeout = 6e4) {
+  const startTime = Date.now();
+  try {
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(
+        () => reject(new Error(`Server push timeout after ${timeout}ms`)),
+        timeout
+      );
+    });
+    const executePromise = (async () => {
+      logger.debug("Importing bundle...");
+      const flowModule = await import(bundlePath);
+      if (!flowModule.default || typeof flowModule.default !== "function") {
+        throw new Error("Bundle does not export default factory function");
+      }
+      logger.debug("Calling factory function...");
+      const result = await flowModule.default();
+      if (!result || !result.elb || typeof result.elb !== "function") {
+        throw new Error(
+          "Factory function did not return valid result with elb"
+        );
+      }
+      const { elb } = result;
+      logger.info(`Pushing event: ${event.name}`);
+      const eventData = event.data || {};
+      const elbResult = await elb(event.name, eventData);
+      return {
+        success: true,
+        elbResult,
+        duration: Date.now() - startTime
+      };
+    })();
+    return await Promise.race([executePromise, timeoutPromise]);
+  } catch (error) {
+    return {
+      success: false,
+      duration: Date.now() - startTime,
+      error: getErrorMessage(error)
+    };
+  }
+}
+function waitForWindowProperty2(window, prop, timeout = 5e3) {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+    const check = () => {
+      if (window[prop] !== void 0) {
+        resolve();
+      } else if (Date.now() - start > timeout) {
+        reject(
+          new Error(
+            `Timeout waiting for window.${prop}. IIFE may have failed to execute.`
+          )
+        );
+      } else {
+        setImmediate(check);
+      }
+    };
+    check();
+  });
+}
+
+// src/commands/run/index.ts
+import path10 from "path";
 
 // src/commands/run/validators.ts
 import { existsSync } from "fs";
@@ -1837,58 +2251,108 @@ function validatePort(port) {
   }
 }
 
+// src/commands/run/utils.ts
+import path9 from "path";
+import os3 from "os";
+async function prepareBundleForRun(configPath, options) {
+  const rawConfig = await loadJsonConfig(configPath);
+  const tempPath = path9.join(
+    os3.tmpdir(),
+    `walkeros-${Date.now()}-${Math.random().toString(36).slice(2, 9)}.mjs`
+  );
+  const existingBuild = typeof rawConfig === "object" && rawConfig !== null && "build" in rawConfig && typeof rawConfig.build === "object" ? rawConfig.build : {};
+  const configWithOutput = {
+    ...rawConfig,
+    build: {
+      ...existingBuild,
+      output: tempPath
+    }
+  };
+  await bundle(configWithOutput, {
+    cache: true,
+    verbose: options.verbose,
+    silent: options.silent
+  });
+  return tempPath;
+}
+function isPreBuiltConfig(configPath) {
+  return configPath.endsWith(".mjs") || configPath.endsWith(".js") || configPath.endsWith(".cjs");
+}
+
+// src/commands/run/execution.ts
+import { runFlow, runServeMode } from "@walkeros/docker";
+async function executeRunLocal(mode, flowPath, options) {
+  switch (mode) {
+    case "collect": {
+      if (!flowPath) {
+        throw new Error("Flow path is required for collect mode");
+      }
+      const config = {
+        port: options.port,
+        host: options.host
+      };
+      await runFlow(flowPath, config);
+      break;
+    }
+    case "serve": {
+      const config = {
+        port: options.port,
+        host: options.host,
+        serveName: options.serveName,
+        servePath: options.servePath,
+        filePath: flowPath || void 0
+      };
+      await runServeMode(config);
+      break;
+    }
+    default:
+      throw new Error(`Unknown mode: ${mode}`);
+  }
+}
+
 // src/commands/run/index.ts
 async function runCommand(mode, options) {
   const timer = createTimer();
   timer.start();
-  const logger = createLogger({
-    verbose: options.verbose,
-    silent: options.silent ?? false,
-    json: options.json
-  });
+  const logger = createCommandLogger(options);
   try {
     validateMode(mode);
     const configPath = validateFlowFile(options.config);
     if (options.port !== void 0) {
       validatePort(options.port);
     }
-    const isPreBuilt = configPath.endsWith(".mjs") || configPath.endsWith(".js") || configPath.endsWith(".cjs");
+    const isPreBuilt = isPreBuiltConfig(configPath);
     let flowPath = null;
     if (mode === "collect") {
       if (isPreBuilt) {
-        flowPath = path8.resolve(configPath);
+        flowPath = path10.resolve(configPath);
         if (!options.json && !options.silent) {
-          logger.info(`\u{1F4E6} Using pre-built flow: ${path8.basename(flowPath)}`);
+          logger.info(`\u{1F4E6} Using pre-built flow: ${path10.basename(flowPath)}`);
         }
       } else {
         if (!options.json && !options.silent) {
           logger.info("\u{1F528} Building flow bundle...");
         }
-        const rawConfig = await loadJsonConfig(configPath);
-        const tempPath = path8.join(
-          os2.tmpdir(),
-          `walkeros-${Date.now()}-${Math.random().toString(36).slice(2, 9)}.mjs`
-        );
-        const existingBuild = typeof rawConfig === "object" && rawConfig !== null && "build" in rawConfig && typeof rawConfig.build === "object" ? rawConfig.build : {};
-        const configWithOutput = {
-          ...rawConfig,
-          build: {
-            ...existingBuild,
-            output: tempPath
-          }
-        };
-        await bundle(configWithOutput, {
-          cache: true,
+        flowPath = await prepareBundleForRun(configPath, {
           verbose: options.verbose,
           silent: options.json || options.silent
         });
-        flowPath = tempPath;
         if (!options.json && !options.silent) {
           logger.success("\u2705 Bundle ready");
         }
       }
     }
     const executionMode = getExecutionMode(options);
+    if (options.dryRun) {
+      if (executionMode === "docker") {
+        logger.info(
+          `[DRY-RUN] Would execute in Docker: run ${mode} with runtime image`
+        );
+      } else {
+        logger.info(`[DRY-RUN] Would execute locally: run ${mode}`);
+      }
+      return;
+    }
     if (executionMode === "docker") {
       const dockerAvailable = await isDockerAvailable();
       if (!dockerAvailable) {
@@ -1911,36 +2375,16 @@ async function runCommand(mode, options) {
         const modeLabel = mode === "collect" ? "Collector" : "Server";
         logger.info(`\u{1F5A5}\uFE0F  Starting ${modeLabel} locally...`);
       }
-      switch (mode) {
-        case "collect": {
-          if (!flowPath) {
-            throw new Error("Flow path is required for collect mode");
-          }
-          const config = {
-            port: options.port,
-            host: options.host
-          };
-          await runFlow(flowPath, config);
-          break;
-        }
-        case "serve": {
-          const config = {
-            port: options.port,
-            host: options.host,
-            serveName: options.serveName,
-            servePath: options.servePath,
-            filePath: flowPath || void 0
-          };
-          await runServeMode(config);
-          break;
-        }
-        default:
-          throw new Error(`Unknown mode: ${mode}`);
-      }
+      await executeRunLocal(mode, flowPath, {
+        port: options.port,
+        host: options.host,
+        serveName: options.serveName,
+        servePath: options.servePath
+      });
     }
   } catch (error) {
     const duration = timer.getElapsed() / 1e3;
-    const errorMessage = error instanceof Error ? error.message : String(error);
+    const errorMessage = getErrorMessage(error);
     if (options.json) {
       const output = {
         success: false,
@@ -1969,54 +2413,22 @@ async function run(mode, options) {
     if (options.port !== void 0) {
       validatePort(options.port);
     }
-    const isPreBuilt = flowFile.endsWith(".mjs") || flowFile.endsWith(".js") || flowFile.endsWith(".cjs");
+    const isPreBuilt = isPreBuiltConfig(flowFile);
     let flowPath;
     if (isPreBuilt) {
-      flowPath = path8.resolve(flowFile);
+      flowPath = path10.resolve(flowFile);
     } else {
-      const rawConfig = await loadJsonConfig(flowFile);
-      const tempPath = path8.join(
-        os2.tmpdir(),
-        `walkeros-${Date.now()}-${Math.random().toString(36).slice(2, 9)}.mjs`
-      );
-      const existingBuild = typeof rawConfig === "object" && rawConfig !== null && "build" in rawConfig && typeof rawConfig.build === "object" ? rawConfig.build : {};
-      const configWithOutput = {
-        ...rawConfig,
-        build: {
-          ...existingBuild,
-          output: tempPath
-        }
-      };
-      await bundle(configWithOutput, {
-        cache: true,
+      flowPath = await prepareBundleForRun(flowFile, {
         verbose: options.verbose,
         silent: true
       });
-      flowPath = tempPath;
-    }
-    switch (mode) {
-      case "collect": {
-        const config = {
-          port: options.port,
-          host: options.host
-        };
-        await runFlow(flowPath, config);
-        break;
-      }
-      case "serve": {
-        const config = {
-          port: options.port,
-          host: options.host,
-          serveName: options.serveName,
-          servePath: options.servePath,
-          filePath: flowPath
-        };
-        await runServeMode(config);
-        break;
-      }
-      default:
-        throw new Error(`Unknown mode: ${mode}`);
     }
+    await executeRunLocal(mode, flowPath, {
+      port: options.port,
+      host: options.host,
+      serveName: options.serveName,
+      servePath: options.servePath
+    });
     return {
       success: true,
       exitCode: 0,
@@ -2027,7 +2439,7 @@ async function run(mode, options) {
       success: false,
       exitCode: 1,
       duration: Date.now() - startTime,
-      error: error instanceof Error ? error.message : String(error)
+      error: getErrorMessage(error)
     };
   }
 }
@@ -2058,7 +2470,10 @@ program.command("bundle [file]").description("Bundle NPM packages with custom co
     silent: options.silent
   });
 });
-program.command("simulate [file]").description("Simulate event processing and capture API calls").option("-e, --event <json>", "Event to simulate (JSON string)").option("--json", "Output results as JSON").option("-v, --verbose", "Verbose output").option("--local", "execute in local Node.js instead of Docker").option("--dry-run", "preview command without executing").option("--silent", "suppress output").action(async (file, options) => {
+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("--local", "execute in local Node.js instead of Docker").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,
@@ -2069,6 +2484,20 @@ program.command("simulate [file]").description("Simulate event processing and ca
     silent: options.silent
   });
 });
+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("--env <name>", "Environment name (for multi-environment configs)").option("--json", "Output results as JSON").option("-v, --verbose", "Verbose output").option("-s, --silent", "Suppress output").option("--local", "Execute in local Node.js instead of Docker").action(async (file, options) => {
+  await pushCommand({
+    config: file || "bundle.config.json",
+    event: options.event,
+    env: options.env,
+    json: options.json,
+    verbose: options.verbose,
+    silent: options.silent,
+    local: options.local
+  });
+});
 var runCmd = program.command("run").description("Run walkerOS flows in collect or serve mode");
 runCmd.command("collect [file]").description(
   "Run collector mode (event collection endpoint). Defaults to server-collect.mjs if no file specified."
@@ -2085,10 +2514,10 @@ runCmd.command("collect [file]").description(
   });
 });
 runCmd.command("serve [file]").description(
-  "Run serve mode (single-file server for browser bundles). Defaults to baked-in web-serve.mjs if no file specified."
+  "Run serve mode (single-file server for browser bundles). Defaults to baked-in web-serve.js if no file specified."
 ).option("-p, --port <number>", "Port to listen on (default: 8080)", parseInt).option("-h, --host <address>", "Host address (default: 0.0.0.0)").option("--name <filename>", "Filename in URL (default: walker.js)").option("--path <directory>", "URL directory path (e.g., libs/v1)").option("--json", "Output results as JSON").option("-v, --verbose", "Verbose output").option("--local", "execute in local Node.js instead of Docker").option("--dry-run", "preview command without executing").option("--silent", "suppress output").action(async (file, options) => {
   await runCommand("serve", {
-    config: file || "web-serve.mjs",
+    config: file || "web-serve.js",
     port: options.port,
     host: options.host,
     serveName: options.name,
@@ -2104,6 +2533,7 @@ program.parse();
 export {
   bundle,
   bundleCommand,
+  pushCommand,
   run,
   runCommand,
   simulate,