@walkeros/cli 0.7.0-next.0 → 1.0.0

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // src/index.ts
 import { Command } from "commander";
-import { VERSION as DOCKER_VERSION2 } from "@walkeros/docker";
+import chalk2 from "chalk";
 
 // src/version.ts
 import { readFileSync } from "fs";
@@ -29,74 +29,74 @@ var VERSION = JSON.parse(findPackageJson()).version;
 
 // src/commands/bundle/index.ts
 import path9 from "path";
+import fs8 from "fs-extra";
 
 // src/core/logger.ts
 import chalk from "chalk";
+var BRAND_COLOR = "#01b5e2";
 function createLogger(options = {}) {
   const { verbose = false, silent = false, json = false } = options;
   const shouldLog = !silent && !json;
   const shouldDebug = verbose && !silent && !json;
   return {
-    log: (color, ...args) => {
+    log: (...args) => {
       if (shouldLog) {
         const message = args.map((arg) => String(arg)).join(" ");
-        const colorMap = {
-          red: chalk.red,
-          green: chalk.green,
-          blue: chalk.blue,
-          yellow: chalk.yellow,
-          gray: chalk.gray,
-          grey: chalk.gray,
-          cyan: chalk.cyan,
-          magenta: chalk.magenta,
-          white: chalk.white,
-          black: chalk.black
-        };
-        const colorFn = colorMap[color];
-        const coloredMessage = colorFn ? colorFn(message) : message;
-        console.log(coloredMessage);
+        console.log(message);
       }
     },
-    info: (...args) => {
+    brand: (...args) => {
       if (shouldLog) {
         const message = args.map((arg) => String(arg)).join(" ");
-        console.log(chalk.blue(message));
+        console.log(chalk.hex(BRAND_COLOR)(message));
       }
     },
-    success: (...args) => {
-      if (shouldLog) {
+    error: (...args) => {
+      if (!json) {
         const message = args.map((arg) => String(arg)).join(" ");
-        console.log(chalk.green(message));
+        console.error(chalk.red(message));
       }
     },
-    warning: (...args) => {
+    debug: (...args) => {
+      if (shouldDebug) {
+        const message = args.map((arg) => String(arg)).join(" ");
+        console.log(`  ${message}`);
+      }
+    },
+    json: (data) => {
+      if (!silent) {
+        console.log(JSON.stringify(data, null, 2));
+      }
+    },
+    // Backward-compatible methods (all use default terminal color per design)
+    info: (...args) => {
       if (shouldLog) {
         const message = args.map((arg) => String(arg)).join(" ");
-        console.log(chalk.yellow(message));
+        console.log(message);
       }
     },
-    warn: (...args) => {
+    success: (...args) => {
       if (shouldLog) {
         const message = args.map((arg) => String(arg)).join(" ");
-        console.log(chalk.yellow(message));
+        console.log(message);
       }
     },
-    error: (...args) => {
-      if (!json) {
+    warning: (...args) => {
+      if (shouldLog) {
         const message = args.map((arg) => String(arg)).join(" ");
-        console.error(chalk.red(message));
+        console.log(message);
       }
     },
-    debug: (...args) => {
-      if (shouldDebug) {
+    warn: (...args) => {
+      if (shouldLog) {
         const message = args.map((arg) => String(arg)).join(" ");
-        console.log(chalk.gray(message));
+        console.log(message);
       }
     },
     gray: (...args) => {
       if (shouldLog) {
         const message = args.map((arg) => String(arg)).join(" ");
-        console.log(chalk.gray(message));
+        console.log(message);
       }
     }
   };
@@ -109,6 +109,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;
@@ -152,16 +169,26 @@ function formatBytes(bytes) {
   return (bytes / 1024).toFixed(2);
 }
 
-// src/core/docker.ts
-import { spawn } from "child_process";
-import path2 from "path";
-import fs2 from "fs-extra";
-import { VERSION as DOCKER_VERSION } from "@walkeros/docker";
+// src/core/tmp.ts
+import path from "path";
+var DEFAULT_TMP_ROOT = ".tmp";
+function getTmpPath(tmpDir, ...segments) {
+  const root = tmpDir || DEFAULT_TMP_ROOT;
+  const absoluteRoot = path.isAbsolute(root) ? root : path.resolve(root);
+  return path.join(absoluteRoot, ...segments);
+}
+function getDefaultTmpRoot() {
+  return DEFAULT_TMP_ROOT;
+}
+
+// src/core/asset-resolver.ts
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { existsSync } from "fs";
+import path3 from "path";
 
 // src/config/utils.ts
 import fs from "fs-extra";
-import path from "path";
-import os from "os";
+import path2 from "path";
 function isUrl(str) {
   try {
     const url = new URL(str);
@@ -182,12 +209,9 @@ async function downloadFromUrl(url) {
       );
     }
     const content = await response.text();
-    const urlObj = new URL(url);
-    const urlFilename = path.basename(urlObj.pathname);
-    const extension = path.extname(urlFilename) || ".json";
-    const randomId = Math.random().toString(36).substring(2, 11);
-    const filename = `walkeros-download-${Date.now()}-${randomId}${extension}`;
-    const tempPath = path.join(os.tmpdir(), filename);
+    const downloadsDir = getTmpPath(void 0, "downloads");
+    await fs.ensureDir(downloadsDir);
+    const tempPath = path2.join(downloadsDir, "flow.json");
     await fs.writeFile(tempPath, content, "utf-8");
     return tempPath;
   } catch (error) {
@@ -204,7 +228,7 @@ async function loadJsonConfig(configPath) {
     absolutePath = await downloadFromUrl(configPath);
     isTemporary = true;
   } else {
-    absolutePath = path.resolve(configPath);
+    absolutePath = path2.resolve(configPath);
     if (!await fs.pathExists(absolutePath)) {
       throw new Error(`Configuration file not found: ${absolutePath}`);
     }
@@ -225,11 +249,6 @@ async function loadJsonConfig(configPath) {
     }
   }
 }
-function getTempDir(tempDir = ".tmp") {
-  const randomId = Math.random().toString(36).substring(2, 11);
-  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() === "") {
@@ -260,7 +279,7 @@ async function loadJsonFromSource(source, options) {
       );
     }
   }
-  const resolvedPath = path.resolve(trimmedSource);
+  const resolvedPath = path2.resolve(trimmedSource);
   if (await fs.pathExists(resolvedPath)) {
     try {
       const data = await fs.readJson(resolvedPath);
@@ -284,203 +303,7 @@ async function loadJsonFromSource(source, options) {
   }
 }
 
-// src/core/docker.ts
-var CLI_DOCKER_IMAGE = process.env.WALKEROS_CLI_DOCKER_IMAGE || `walkeros/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"];
-  if (configFile && !isUrl(configFile)) {
-    const configPath = path2.resolve(cwd, configFile);
-    cmd.push("-v", `${configPath}:/config/flow.json:ro`);
-    args = args.map((arg) => arg === configFile ? "/config/flow.json" : arg);
-  }
-  cmd.push("-v", `${cwd}:/workspace`);
-  cmd.push("-w", "/workspace");
-  if (process.platform !== "win32") {
-    try {
-      const uid = process.getuid?.();
-      const gid = process.getgid?.();
-      if (uid !== void 0 && gid !== void 0) {
-        cmd.push("--user", `${uid}:${gid}`);
-      }
-    } catch {
-    }
-  }
-  if (options.verbose) {
-    cmd.push("-e", "VERBOSE=true");
-  }
-  if (options.silent) {
-    cmd.push("-e", "SILENT=true");
-  }
-  cmd.push(CLI_DOCKER_IMAGE);
-  cmd.push(command, ...args);
-  return cmd;
-}
-async function executeInDocker(command, args, options = {}, configFile) {
-  let tempFile;
-  let effectiveConfigFile = configFile;
-  try {
-    if (configFile && isUrl(configFile)) {
-      tempFile = await downloadFromUrl(configFile);
-      effectiveConfigFile = tempFile;
-    }
-    const containerArgs = [...args, "--local"];
-    const dockerCmd = buildDockerCommand(
-      command,
-      containerArgs,
-      options,
-      effectiveConfigFile
-    );
-    return await new Promise((resolve, reject) => {
-      const proc = spawn(dockerCmd[0], dockerCmd.slice(1), {
-        stdio: options.silent ? "ignore" : "inherit",
-        shell: false
-      });
-      proc.on("error", (error) => {
-        reject(new Error(`Docker execution failed: ${error.message}`));
-      });
-      proc.on("exit", (code) => {
-        if (code === 0) {
-          resolve();
-        } else {
-          process.exit(code || 1);
-        }
-      });
-    });
-  } finally {
-    if (tempFile) {
-      try {
-        await fs2.remove(tempFile);
-      } catch {
-      }
-    }
-  }
-}
-async function isDockerAvailable() {
-  return new Promise((resolve) => {
-    const proc = spawn("docker", ["--version"], {
-      stdio: "ignore"
-    });
-    proc.on("error", () => resolve(false));
-    proc.on("exit", (code) => resolve(code === 0));
-  });
-}
-function buildDockerRunCommand(mode, flowPath, options = {}) {
-  const cwd = process.cwd();
-  const cmd = ["docker", "run", "--rm"];
-  cmd.push("-e", `MODE=${mode}`);
-  if (mode === "collect" && flowPath) {
-    const absoluteFlowPath = path2.resolve(cwd, flowPath);
-    const flowDir = path2.dirname(absoluteFlowPath);
-    const flowFile = path2.basename(absoluteFlowPath);
-    cmd.push("-v", `${flowDir}:/app/dist:ro`);
-    cmd.push("-e", `FLOW=/app/dist/${flowFile}`);
-  }
-  if (mode === "serve" && flowPath) {
-    const absoluteFilePath = path2.resolve(cwd, flowPath);
-    cmd.push("-v", `${absoluteFilePath}:/app/bundle.mjs:ro`);
-    cmd.push("-e", "FILE_PATH=/app/bundle.mjs");
-  }
-  const port = options.port !== void 0 ? options.port : 8080;
-  cmd.push("-p", `${port}:${port}`);
-  cmd.push("-e", `PORT=${port}`);
-  if (options.host) {
-    cmd.push("-e", `HOST=${options.host}`);
-  }
-  if (options.serveName) {
-    cmd.push("-e", `SERVE_NAME=${options.serveName}`);
-  }
-  if (options.servePath) {
-    cmd.push("-e", `SERVE_PATH=${options.servePath}`);
-  }
-  if (process.platform !== "win32") {
-    try {
-      const uid = process.getuid?.();
-      const gid = process.getgid?.();
-      if (uid !== void 0 && gid !== void 0) {
-        cmd.push("--user", `${uid}:${gid}`);
-      }
-    } catch {
-    }
-  }
-  cmd.push(RUNTIME_DOCKER_IMAGE);
-  return cmd;
-}
-async function executeRunInDocker(mode, flowPath, options = {}) {
-  const dockerCmd = buildDockerRunCommand(mode, flowPath, options);
-  return new Promise((resolve, reject) => {
-    const proc = spawn(dockerCmd[0], dockerCmd.slice(1), {
-      stdio: options.silent ? "ignore" : "inherit",
-      shell: false
-    });
-    proc.on("error", (error) => {
-      reject(new Error(`Docker execution failed: ${error.message}`));
-    });
-    proc.on("exit", (code) => {
-      if (code === 0) {
-        resolve();
-      } else {
-        process.exit(code || 1);
-      }
-    });
-  });
-}
-
-// src/core/execution.ts
-function getExecutionMode(options) {
-  if (options.local || process.env.WALKEROS_CONTAINER === "true") {
-    return "local";
-  }
-  return "docker";
-}
-async function executeCommand(localHandler, dockerCommand, dockerArgs, options, logger2, configFile) {
-  const mode = getExecutionMode(options);
-  if (options.dryRun) {
-    if (mode === "docker") {
-      const cmd = `docker run walkeros/cli:latest ${dockerCommand} ${dockerArgs.join(" ")}`;
-      logger2?.info(`[DRY-RUN] Would execute: ${cmd}`);
-    } else {
-      logger2?.info(
-        `[DRY-RUN] Would execute locally: ${dockerCommand} ${dockerArgs.join(" ")}`
-      );
-    }
-    return;
-  }
-  if (mode === "local") {
-    if (logger2 && !options.silent) {
-      logger2.info("\u{1F5A5}\uFE0F  Executing locally...");
-    }
-    await localHandler();
-  } else {
-    const dockerAvailable = await isDockerAvailable();
-    if (!dockerAvailable) {
-      throw new Error(
-        "Docker is not available. Please install Docker or use --local flag to execute locally."
-      );
-    }
-    if (logger2 && !options.silent) {
-      logger2.info("\u{1F433} Executing in Docker container...");
-    }
-    await executeInDocker(dockerCommand, dockerArgs, options, configFile);
-  }
-}
-
-// src/core/temp-manager.ts
-import { getHashServer } from "@walkeros/server-core";
-import fs3 from "fs-extra";
-
 // src/core/asset-resolver.ts
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { existsSync } from "fs";
-import path3 from "path";
 var cachedAssetDir;
 function getAssetDir() {
   if (cachedAssetDir) return cachedAssetDir;
@@ -517,22 +340,22 @@ function getErrorMessage(error) {
 
 // src/core/local-packages.ts
 import path4 from "path";
-import fs4 from "fs-extra";
+import fs2 from "fs-extra";
 async function resolveLocalPackage(packageName, localPath, configDir, logger2) {
   const absolutePath = path4.isAbsolute(localPath) ? localPath : path4.resolve(configDir, localPath);
-  if (!await fs4.pathExists(absolutePath)) {
+  if (!await fs2.pathExists(absolutePath)) {
     throw new Error(
       `Local package path not found: ${localPath} (resolved to ${absolutePath})`
     );
   }
   const pkgJsonPath = path4.join(absolutePath, "package.json");
-  if (!await fs4.pathExists(pkgJsonPath)) {
+  if (!await fs2.pathExists(pkgJsonPath)) {
     throw new Error(
       `No package.json found at ${absolutePath}. Is this a valid package directory?`
     );
   }
   const distPath = path4.join(absolutePath, "dist");
-  const hasDistFolder = await fs4.pathExists(distPath);
+  const hasDistFolder = await fs2.pathExists(distPath);
   if (!hasDistFolder) {
     logger2.warn(
       `\u26A0\uFE0F  ${packageName}: No dist/ folder found. Using package root.`
@@ -547,18 +370,18 @@ async function resolveLocalPackage(packageName, localPath, configDir, logger2) {
 }
 async function copyLocalPackage(localPkg, targetDir, logger2) {
   const packageDir = path4.join(targetDir, "node_modules", localPkg.name);
-  await fs4.ensureDir(path4.dirname(packageDir));
-  await fs4.copy(
+  await fs2.ensureDir(path4.dirname(packageDir));
+  await fs2.copy(
     path4.join(localPkg.absolutePath, "package.json"),
     path4.join(packageDir, "package.json")
   );
   if (localPkg.hasDistFolder) {
-    await fs4.copy(localPkg.distPath, path4.join(packageDir, "dist"));
+    await fs2.copy(localPkg.distPath, path4.join(packageDir, "dist"));
   } else {
-    const entries = await fs4.readdir(localPkg.absolutePath);
+    const entries = await fs2.readdir(localPkg.absolutePath);
     for (const entry of entries) {
       if (!["node_modules", ".turbo", ".git"].includes(entry)) {
-        await fs4.copy(
+        await fs2.copy(
           path4.join(localPkg.absolutePath, entry),
           path4.join(packageDir, entry)
         );
@@ -569,6 +392,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;
@@ -579,8 +429,8 @@ function validateFlowSetup(data) {
   const result = safeParseSetup(data);
   if (!result.success) {
     const errors = result.error.issues.map((issue) => {
-      const path15 = issue.path.length > 0 ? issue.path.map(String).join(".") : "root";
-      return `  - ${path15}: ${issue.message}`;
+      const path14 = issue.path.length > 0 ? issue.path.map(String).join(".") : "root";
+      return `  - ${path14}: ${issue.message}`;
     }).join("\n");
     throw new Error(`Invalid configuration:
 ${errors}`);
@@ -599,7 +449,6 @@ var WEB_BUILD_DEFAULTS = {
   minify: true,
   sourcemap: false,
   cache: true,
-  tempDir: ".tmp",
   windowCollector: "collector",
   windowElb: "elb"
 };
@@ -609,8 +458,7 @@ var SERVER_BUILD_DEFAULTS = {
   target: "node20",
   minify: true,
   sourcemap: false,
-  cache: true,
-  tempDir: ".tmp"
+  cache: true
 };
 var DEFAULT_OUTPUT_PATHS = {
   web: "./dist/walker.js",
@@ -625,7 +473,7 @@ function getDefaultOutput(platform) {
 
 // src/config/loader.ts
 import path5 from "path";
-import fs5 from "fs-extra";
+import fs4 from "fs-extra";
 import { getFlowConfig, getPlatform } from "@walkeros/core";
 var DEFAULT_INCLUDE_FOLDER = "./shared";
 function loadBundleConfig(rawConfig, options) {
@@ -641,18 +489,12 @@ function loadBundleConfig(rawConfig, options) {
   }
   const buildDefaults = getBuildDefaults(platform);
   const packages = flowConfig.packages || {};
-  let output = getDefaultOutput(platform);
-  if (options.buildOverrides?.output) {
-    output = options.buildOverrides.output;
-  }
-  const configDir = path5.dirname(options.configPath);
-  if (!path5.isAbsolute(output)) {
-    output = path5.resolve(configDir, output);
-  }
+  const output = options.buildOverrides?.output || getDefaultOutput(platform);
+  const configDir = isUrl(options.configPath) ? process.cwd() : path5.dirname(options.configPath);
   let includes = setup.include;
   if (!includes) {
     const defaultIncludePath = path5.resolve(configDir, DEFAULT_INCLUDE_FOLDER);
-    if (fs5.pathExistsSync(defaultIncludePath)) {
+    if (fs4.pathExistsSync(defaultIncludePath)) {
       includes = [DEFAULT_INCLUDE_FOLDER];
     }
   }
@@ -711,20 +553,24 @@ 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 fs8 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 fs6 from "fs-extra";
+import fs5 from "fs-extra";
 
 // src/core/cache-utils.ts
-import { getHashServer as getHashServer2 } from "@walkeros/server-core";
+import { getHashServer } from "@walkeros/server-core";
 var HASH_LENGTH = 12;
 function isMutableVersion(version) {
   return version === "latest" || version.includes("^") || version.includes("~") || version.includes("*") || version.includes("x");
@@ -737,10 +583,10 @@ async function getPackageCacheKey(packageName, version, date) {
   if (isMutableVersion(version)) {
     const dateStr = date ?? getTodayDate();
     const input2 = `${safeName}@${version}:${dateStr}`;
-    return getHashServer2(input2, HASH_LENGTH);
+    return getHashServer(input2, HASH_LENGTH);
   }
   const input = `${safeName}@${version}`;
-  return getHashServer2(input, HASH_LENGTH);
+  return getHashServer(input, HASH_LENGTH);
 }
 function normalizeJson(content) {
   const parsed = JSON.parse(content);
@@ -750,21 +596,28 @@ async function getFlowConfigCacheKey(content, date) {
   const dateStr = date ?? getTodayDate();
   const normalized = normalizeJson(content);
   const input = `${normalized}:${dateStr}`;
-  return getHashServer2(input, HASH_LENGTH);
+  return getHashServer(input, HASH_LENGTH);
 }
 
 // src/commands/bundle/package-manager.ts
+var PACKAGE_DOWNLOAD_TIMEOUT_MS = 6e4;
+async function withTimeout(promise, ms, errorMessage) {
+  const timeout = new Promise(
+    (_, reject) => setTimeout(() => reject(new Error(errorMessage)), ms)
+  );
+  return Promise.race([promise, timeout]);
+}
 function getPackageDirectory(baseDir, packageName, version) {
   return path6.join(baseDir, "node_modules", packageName);
 }
-async function getCachedPackagePath(pkg, tempDir) {
-  const cacheDir = path6.join(".tmp", "cache", "packages");
+async function getCachedPackagePath(pkg, tmpDir) {
+  const cacheDir = getTmpPath(tmpDir, "cache", "packages");
   const cacheKey = await getPackageCacheKey(pkg.name, pkg.version);
   return path6.join(cacheDir, cacheKey);
 }
-async function isPackageCached(pkg, tempDir) {
-  const cachedPath = await getCachedPackagePath(pkg, tempDir);
-  return fs6.pathExists(cachedPath);
+async function isPackageCached(pkg, tmpDir) {
+  const cachedPath = await getCachedPackagePath(pkg, tmpDir);
+  return fs5.pathExists(cachedPath);
 }
 function validateNoDuplicatePackages(packages) {
   const packageMap = /* @__PURE__ */ new Map();
@@ -799,8 +652,8 @@ async function resolveDependencies(pkg, packageDir, logger2, visited = /* @__PUR
   visited.add(pkgKey);
   try {
     const packageJsonPath = path6.join(packageDir, "package.json");
-    if (await fs6.pathExists(packageJsonPath)) {
-      const packageJson = await fs6.readJson(packageJsonPath);
+    if (await fs5.pathExists(packageJsonPath)) {
+      const packageJson = await fs5.readJson(packageJsonPath);
       const deps = {
         ...packageJson.dependencies,
         ...packageJson.peerDependencies
@@ -820,6 +673,7 @@ async function downloadPackages(packages, targetDir, logger2, useCache = true, c
   const packagePaths = /* @__PURE__ */ new Map();
   const downloadQueue = [...packages];
   const processed = /* @__PURE__ */ new Set();
+  const userSpecifiedPackages = new Set(packages.map((p) => p.name));
   const localPackageMap = /* @__PURE__ */ new Map();
   for (const pkg of packages) {
     if (pkg.path) {
@@ -827,7 +681,7 @@ async function downloadPackages(packages, targetDir, logger2, useCache = true, c
     }
   }
   validateNoDuplicatePackages(packages);
-  await fs6.ensureDir(targetDir);
+  await fs5.ensureDir(targetDir);
   while (downloadQueue.length > 0) {
     const pkg = downloadQueue.shift();
     const pkgKey = `${pkg.name}@${pkg.version}`;
@@ -858,12 +712,14 @@ async function downloadPackages(packages, targetDir, logger2, useCache = true, c
     }
     const packageSpec = `${pkg.name}@${pkg.version}`;
     const packageDir = getPackageDirectory(targetDir, pkg.name, pkg.version);
-    const cachedPath = await getCachedPackagePath(pkg, targetDir);
-    if (useCache && await isPackageCached(pkg, targetDir)) {
-      logger2.debug(`Using cached ${packageSpec}...`);
+    const cachedPath = await getCachedPackagePath(pkg);
+    if (useCache && await isPackageCached(pkg)) {
+      if (userSpecifiedPackages.has(pkg.name)) {
+        logger2.debug(`Downloading ${packageSpec} (cached)`);
+      }
       try {
-        await fs6.ensureDir(path6.dirname(packageDir));
-        await fs6.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) {
@@ -879,27 +735,34 @@ async function downloadPackages(packages, targetDir, logger2, useCache = true, c
         );
       }
     }
-    logger2.debug(`Downloading ${packageSpec}...`);
     try {
-      await fs6.ensureDir(path6.dirname(packageDir));
-      const cacheDir = process.env.NPM_CACHE_DIR || path6.join(process.cwd(), ".npm-cache");
-      await pacote.extract(packageSpec, packageDir, {
-        // Force npm registry download, prevent workspace resolution
-        registry: "https://registry.npmjs.org",
-        // Force online fetching from registry (don't use cached workspace packages)
-        preferOnline: true,
-        // Cache for performance
-        cache: cacheDir,
-        // Don't resolve relative to workspace context
-        where: void 0
-      });
+      await fs5.ensureDir(path6.dirname(packageDir));
+      const cacheDir = process.env.NPM_CACHE_DIR || getTmpPath(void 0, "cache", "npm");
+      await withTimeout(
+        pacote.extract(packageSpec, packageDir, {
+          // Force npm registry download, prevent workspace resolution
+          registry: "https://registry.npmjs.org",
+          // Force online fetching from registry (don't use cached workspace packages)
+          preferOnline: true,
+          // Cache for performance
+          cache: cacheDir,
+          // Don't resolve relative to workspace context
+          where: void 0
+        }),
+        PACKAGE_DOWNLOAD_TIMEOUT_MS,
+        `Package download timed out after ${PACKAGE_DOWNLOAD_TIMEOUT_MS / 1e3}s: ${packageSpec}`
+      );
+      if (userSpecifiedPackages.has(pkg.name)) {
+        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 fs6.ensureDir(path6.dirname(cachedPath));
-          await fs6.copy(packageDir, cachedPath);
-          logger2.debug(`Cached ${packageSpec} for future use`);
+          await fs5.ensureDir(path6.dirname(cachedPath));
+          await fs5.copy(packageDir, cachedPath);
         } catch (cacheError) {
-          logger2.debug(`Failed to cache ${packageSpec}: ${cacheError}`);
         }
       }
       packagePaths.set(pkg.name, packageDir);
@@ -918,26 +781,26 @@ async function downloadPackages(packages, targetDir, logger2, useCache = true, c
 }
 
 // src/core/build-cache.ts
-import fs7 from "fs-extra";
+import fs6 from "fs-extra";
 import path7 from "path";
-var BUILD_CACHE_DIR = path7.join(".tmp", "cache", "builds");
-async function getBuildCachePath(configContent, cacheDir = BUILD_CACHE_DIR) {
+async function getBuildCachePath(configContent, tmpDir) {
+  const cacheDir = getTmpPath(tmpDir, "cache", "builds");
   const cacheKey = await getFlowConfigCacheKey(configContent);
   return path7.join(cacheDir, `${cacheKey}.js`);
 }
-async function isBuildCached(configContent, cacheDir = BUILD_CACHE_DIR) {
-  const cachePath = await getBuildCachePath(configContent, cacheDir);
-  return fs7.pathExists(cachePath);
+async function isBuildCached(configContent, tmpDir) {
+  const cachePath = await getBuildCachePath(configContent, tmpDir);
+  return fs6.pathExists(cachePath);
 }
-async function cacheBuild(configContent, buildOutput, cacheDir = BUILD_CACHE_DIR) {
-  const cachePath = await getBuildCachePath(configContent, cacheDir);
-  await fs7.ensureDir(path7.dirname(cachePath));
-  await fs7.writeFile(cachePath, buildOutput, "utf-8");
+async function cacheBuild(configContent, buildOutput, tmpDir) {
+  const cachePath = await getBuildCachePath(configContent, tmpDir);
+  await fs6.ensureDir(path7.dirname(cachePath));
+  await fs6.writeFile(cachePath, buildOutput, "utf-8");
 }
-async function getCachedBuild(configContent, cacheDir = BUILD_CACHE_DIR) {
-  const cachePath = await getBuildCachePath(configContent, cacheDir);
-  if (await fs7.pathExists(cachePath)) {
-    return await fs7.readFile(cachePath, "utf-8");
+async function getCachedBuild(configContent, tmpDir) {
+  const cachePath = await getBuildCachePath(configContent, tmpDir);
+  if (await fs6.pathExists(cachePath)) {
+    return await fs6.readFile(cachePath, "utf-8");
   }
   return null;
 }
@@ -948,8 +811,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 fs8.pathExists(sourcePath)) {
-      await fs8.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}`);
@@ -970,21 +833,22 @@ function generateCacheKeyContent(flowConfig, buildOptions) {
 }
 async function bundleCore(flowConfig, buildOptions, logger2, showStats = false) {
   const bundleStartTime = Date.now();
-  const TEMP_DIR = buildOptions.tempDir ? path8.isAbsolute(buildOptions.tempDir) ? buildOptions.tempDir : path8.resolve(buildOptions.tempDir) : getTempDir();
+  const TEMP_DIR = buildOptions.tempDir || getTmpPath();
   if (buildOptions.cache !== false) {
     const configContent = generateCacheKeyContent(flowConfig, buildOptions);
     const cached = await isBuildCached(configContent);
     if (cached) {
       const cachedBuild = await getCachedBuild(configContent);
       if (cachedBuild) {
-        logger2.info("\u2728 Using cached build");
+        logger2.debug("Using cached build");
         const outputPath = path8.resolve(buildOptions.output);
-        await fs8.ensureDir(path8.dirname(outputPath));
-        await fs8.writeFile(outputPath, cachedBuild);
-        logger2.gray(`Output: ${outputPath}`);
-        logger2.success("\u2705 Build completed (from cache)");
+        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 stats = await fs8.stat(outputPath);
+          const stats2 = await fs7.stat(outputPath);
           const packageStats = Object.entries(buildOptions.packages).map(
             ([name, pkg]) => ({
               name: `${name}@${pkg.version || "latest"}`,
@@ -993,7 +857,7 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
             })
           );
           return {
-            totalSize: stats.size,
+            totalSize: stats2.size,
             packages: packageStats,
             buildTime: Date.now() - bundleStartTime,
             treeshakingEffective: true
@@ -1004,11 +868,8 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
     }
   }
   try {
-    if (!buildOptions.tempDir) {
-      await fs8.emptyDir(TEMP_DIR);
-    }
-    logger2.debug("Cleaned temporary directory");
-    logger2.info("\u{1F4E5} Downloading packages...");
+    await fs7.ensureDir(TEMP_DIR);
+    logger2.debug("Downloading packages");
     const packagesArray = Object.entries(buildOptions.packages).map(
       ([name, packageConfig]) => ({
         name,
@@ -1028,7 +889,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 fs8.readJSON(pkgJsonPath);
+        const pkgJson = await fs7.readJSON(pkgJsonPath);
         if (!pkgJson.exports && pkgJson.module) {
           pkgJson.exports = {
             ".": {
@@ -1036,26 +897,28 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
               require: pkgJson.main
             }
           };
-          await fs8.writeJSON(pkgJsonPath, pkgJson, { spaces: 2 });
+          await fs7.writeJSON(pkgJsonPath, pkgJson, { spaces: 2 });
         }
       }
     }
     const packageJsonPath = path8.join(TEMP_DIR, "package.json");
-    await fs8.writeFile(
+    await fs7.writeFile(
       packageJsonPath,
       JSON.stringify({ type: "module" }, null, 2)
     );
-    logger2.info("\u{1F4DD} Creating entry point...");
+    logger2.debug("Creating entry point");
     const entryContent = await createEntryPoint(
       flowConfig,
       buildOptions,
       packagePaths
     );
     const entryPath = path8.join(TEMP_DIR, "entry.js");
-    await fs8.writeFile(entryPath, entryContent);
-    logger2.info("\u26A1 Bundling with esbuild...");
+    await fs7.writeFile(entryPath, entryContent);
+    logger2.debug(
+      `Running esbuild (target: ${buildOptions.target || "es2018"}, format: ${buildOptions.format})`
+    );
     const outputPath = path8.resolve(buildOptions.output);
-    await fs8.ensureDir(path8.dirname(outputPath));
+    await fs7.ensureDir(path8.dirname(outputPath));
     const esbuildOptions = createEsbuildOptions(
       buildOptions,
       entryPath,
@@ -1072,10 +935,13 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
         buildOptions.code || ""
       );
     }
-    logger2.gray(`Output: ${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 fs8.readFile(outputPath, "utf-8");
+      const buildOutput = await fs7.readFile(outputPath, "utf-8");
       await cacheBuild(configContent, buildOutput);
       logger2.debug("Build cached for future use");
     }
@@ -1097,21 +963,13 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
         logger2
       );
     }
-    if (!buildOptions.tempDir) {
-      await fs8.remove(TEMP_DIR);
-      logger2.debug("Cleaned up temporary files");
-    }
     return stats;
   } catch (error) {
-    if (!buildOptions.tempDir) {
-      await fs8.remove(TEMP_DIR).catch(() => {
-      });
-    }
     throw error;
   }
 }
 async function collectBundleStats(outputPath, packages, startTime, entryContent) {
-  const stats = await fs8.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]) => {
@@ -1439,6 +1297,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);
 }`;
   }
@@ -1472,130 +1335,118 @@ async function bundleCommand(options) {
   const timer = createTimer();
   timer.start();
   const logger2 = createCommandLogger(options);
-  const dockerArgs = buildCommonDockerArgs(options);
-  if (options.flow) dockerArgs.push("--flow", options.flow);
-  if (options.all) dockerArgs.push("--all");
-  if (options.stats) dockerArgs.push("--stats");
-  if (options.cache === false) dockerArgs.push("--no-cache");
-  await executeCommand(
-    async () => {
+  if (options.dryRun) {
+    logger2.log(`[DRY-RUN] Would execute bundle with config: ${options.config}`);
+    return;
+  }
+  try {
+    if (options.flow && options.all) {
+      throw new Error("Cannot use both --flow and --all flags together");
+    }
+    const configPath = resolveAsset(options.config, "config");
+    const rawConfig = await loadJsonConfig(configPath);
+    const configsToBundle = options.all ? loadAllFlows(rawConfig, { configPath, logger: logger2 }) : [
+      loadBundleConfig(rawConfig, {
+        configPath,
+        flowName: options.flow,
+        logger: logger2
+      })
+    ];
+    const results = [];
+    for (const {
+      flowConfig,
+      buildOptions,
+      flowName,
+      isMultiFlow
+    } of configsToBundle) {
       try {
-        if (options.flow && options.all) {
-          throw new Error("Cannot use both --flow and --all flags together");
+        if (options.cache !== void 0) {
+          buildOptions.cache = options.cache;
         }
-        logger2.info("\u{1F4E6} Reading configuration...");
-        const configPath = resolveAsset(options.config, "config");
-        const rawConfig = await loadJsonConfig(configPath);
-        const configsToBundle = options.all ? loadAllFlows(rawConfig, { configPath, logger: logger2 }) : [
-          loadBundleConfig(rawConfig, {
-            configPath,
-            flowName: options.flow,
-            logger: logger2
-          })
-        ];
-        const results = [];
-        for (const {
+        const configBasename = path9.basename(configPath);
+        if (isMultiFlow || options.all) {
+          logger2.log(`Bundling ${configBasename} (flow: ${flowName})...`);
+        } else {
+          logger2.log(`Bundling ${configBasename}...`);
+        }
+        const shouldCollectStats = options.stats || options.json;
+        const stats = await bundleCore(
           flowConfig,
           buildOptions,
+          logger2,
+          shouldCollectStats
+        );
+        results.push({
           flowName,
-          isMultiFlow
-        } of configsToBundle) {
-          try {
-            if (options.cache !== void 0) {
-              buildOptions.cache = options.cache;
-            }
-            if (isMultiFlow || options.all) {
-              logger2.info(`
-\u{1F527} Building flow: ${flowName}`);
-            } else {
-              logger2.info("\u{1F527} Starting bundle process...");
-            }
-            const shouldCollectStats = options.stats || options.json;
-            const stats = await bundleCore(
-              flowConfig,
-              buildOptions,
-              logger2,
-              shouldCollectStats
-            );
-            results.push({
-              flowName,
-              success: true,
-              stats
-            });
-            if (!options.json && !options.all && options.stats && stats) {
-              displayStats(stats, logger2);
-            }
-          } catch (error) {
-            const errorMessage = getErrorMessage(error);
-            results.push({
-              flowName,
-              success: false,
-              error: errorMessage
-            });
-            if (!options.all) {
-              throw error;
-            }
-          }
+          success: true,
+          stats
+        });
+        if (!options.json && !options.all && options.stats && stats) {
+          displayStats(stats, logger2);
         }
-        const duration = timer.end() / 1e3;
-        const successCount = results.filter((r) => r.success).length;
-        const failureCount = results.filter((r) => !r.success).length;
-        if (options.json) {
-          const outputLogger = createLogger({ silent: false, json: false });
-          const output = failureCount === 0 ? createSuccessOutput(
-            {
-              flows: results,
-              summary: {
-                total: results.length,
-                success: successCount,
-                failed: failureCount
-              }
-            },
-            duration
-          ) : createErrorOutput(
-            `${failureCount} flow(s) failed to build`,
-            duration
+        if (options.dockerfile && !options.all) {
+          const dockerfilePath = path9.join(
+            path9.dirname(buildOptions.output),
+            "Dockerfile"
           );
-          outputLogger.log("white", JSON.stringify(output, null, 2));
-        } else {
-          if (options.all) {
-            logger2.info(`
-\u{1F4CA} Build Summary:`);
-            logger2.info(`   Total: ${results.length}`);
-            logger2.success(`   \u2705 Success: ${successCount}`);
-            if (failureCount > 0) {
-              logger2.error(`   \u274C Failed: ${failureCount}`);
-            }
-          }
-          if (failureCount === 0) {
-            logger2.success(
-              `
-\u2705 Bundle created successfully in ${timer.format()}`
-            );
-          } else {
-            throw new Error(`${failureCount} flow(s) failed to build`);
-          }
+          await generateDockerfile(dockerfilePath, buildOptions.output, logger2);
         }
       } catch (error) {
-        const duration = timer.getElapsed() / 1e3;
         const errorMessage = getErrorMessage(error);
-        if (options.json) {
-          const outputLogger = createLogger({ silent: false, json: false });
-          const output = createErrorOutput(errorMessage, duration);
-          outputLogger.log("white", JSON.stringify(output, null, 2));
-        } else {
-          logger2.error("\u274C Bundle failed:");
-          logger2.error(errorMessage);
+        results.push({
+          flowName,
+          success: false,
+          error: errorMessage
+        });
+        if (!options.all) {
+          throw error;
         }
-        process.exit(1);
       }
-    },
-    "bundle",
-    dockerArgs,
-    options,
-    logger2,
-    options.config
-  );
+    }
+    const duration = timer.end() / 1e3;
+    const successCount = results.filter((r) => r.success).length;
+    const failureCount = results.filter((r) => !r.success).length;
+    if (options.json) {
+      const output = failureCount === 0 ? createSuccessOutput(
+        {
+          flows: results,
+          summary: {
+            total: results.length,
+            success: successCount,
+            failed: failureCount
+          }
+        },
+        duration
+      ) : createErrorOutput(
+        `${failureCount} flow(s) failed to build`,
+        duration
+      );
+      logger2.json(output);
+    } else {
+      if (options.all) {
+        logger2.log(
+          `
+Build Summary: ${successCount}/${results.length} succeeded`
+        );
+        if (failureCount > 0) {
+          logger2.error(`Failed: ${failureCount}`);
+        }
+      }
+      if (failureCount > 0) {
+        throw new Error(`${failureCount} flow(s) failed to build`);
+      }
+    }
+  } catch (error) {
+    const duration = timer.getElapsed() / 1e3;
+    const errorMessage = getErrorMessage(error);
+    if (options.json) {
+      const output = createErrorOutput(errorMessage, duration);
+      logger2.json(output);
+    } else {
+      logger2.error(`Error: ${errorMessage}`);
+    }
+    process.exit(1);
+  }
 }
 async function bundle(configOrPath, options = {}) {
   let rawConfig;
@@ -1622,6 +1473,21 @@ async function bundle(configOrPath, options = {}) {
     options.stats ?? false
   );
 }
+async function generateDockerfile(dockerfilePath, bundleOutput, logger2) {
+  const bundleFilename = path9.basename(bundleOutput);
+  const dockerfile = `# Generated by walkeros CLI
+FROM walkeros/flow:latest
+
+COPY ${bundleFilename} /app/flow/bundle.mjs
+
+ENV MODE=collect
+ENV BUNDLE=/app/flow/bundle.mjs
+
+EXPOSE 8080
+`;
+  await fs8.writeFile(dockerfilePath, dockerfile);
+  logger2.log(`Dockerfile: ${dockerfilePath}`);
+}
 
 // src/commands/simulate/simulator.ts
 import path10 from "path";
@@ -1662,9 +1528,9 @@ var CallTracker = class {
     }
     for (const fullPath of paths) {
       const [destKey, ...pathParts] = fullPath.split(":");
-      const path15 = pathParts.join(":");
-      if (!path15) continue;
-      const cleanPath = path15.replace(/^call:/, "");
+      const path14 = pathParts.join(":");
+      if (!path14) continue;
+      const cleanPath = path14.replace(/^call:/, "");
       const parts = cleanPath.split(".");
       let current = wrapped;
       let source = env;
@@ -1745,11 +1611,11 @@ function buildSandboxFromEnvs(envs, destinations, tracker) {
   return sandbox;
 }
 function waitForWindowProperty(window, prop, timeout = 5e3) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve3, reject) => {
     const start = Date.now();
     const check = () => {
       if (window[prop] !== void 0) {
-        resolve();
+        resolve3();
       } else if (Date.now() - start > timeout) {
         reject(
           new Error(
@@ -1848,7 +1714,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);
@@ -1859,16 +1725,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)}`);
       }
@@ -1916,10 +1785,7 @@ async function loadDestinationEnvs(destinations) {
           simulation: envModule.simulation || []
         };
       }
-    } catch (error) {
-      console.warn(
-        `Warning: Could not load env for destination "${destKey}": ${error instanceof Error ? error.message : String(error)}`
-      );
+    } catch {
     }
   }
   return envs;
@@ -1929,29 +1795,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
@@ -1968,87 +1826,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 = getTempDir();
+  const tempDir = getTmpPath();
+  const collectorLoggerConfig = options.logger ? createCollectorLoggerConfig(options.logger, options.verbose) : void 0;
   try {
+    await fs10.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 fs10.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 {
@@ -2063,63 +1877,152 @@ async function executeSimulation(event, configPath) {
     }
   }
 }
+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 fs10.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) {
   const logger2 = createCommandLogger(options);
-  const dockerArgs = buildCommonDockerArgs(options);
-  if (options.event) dockerArgs.push("--event", options.event);
-  await executeCommand(
-    async () => {
-      const startTime = Date.now();
-      try {
-        const event = await loadJsonFromSource(options.event, {
-          name: "event"
-        });
-        const result = await simulateCore(options.config, event, {
-          json: options.json,
-          verbose: options.verbose,
-          silent: options.silent
-        });
-        const resultWithDuration = {
-          ...result,
-          duration: (Date.now() - startTime) / 1e3
-        };
-        const outputLogger = createLogger({ silent: false, json: false });
-        const output = formatSimulationResult(resultWithDuration, {
-          json: options.json
-        });
-        outputLogger.log("white", output);
-        if (!result.success) {
-          process.exit(1);
-        }
-      } catch (error) {
-        const errorMessage = getErrorMessage(error);
-        if (options.json) {
-          const outputLogger = createLogger({ silent: false, json: false });
-          const errorOutput = JSON.stringify(
-            {
-              success: false,
-              error: errorMessage,
-              duration: (Date.now() - startTime) / 1e3
-            },
-            null,
-            2
-          );
-          outputLogger.log("white", errorOutput);
-        } else {
-          const errorLogger = createLogger({ silent: false, json: false });
-          errorLogger.error(`\u274C Simulate command failed: ${errorMessage}`);
-        }
-        process.exit(1);
-      }
-    },
-    "simulate",
-    dockerArgs,
-    options,
-    logger2,
-    options.config
-  );
+  if (options.dryRun) {
+    logger2.log(
+      `[DRY-RUN] Would execute simulate with config: ${options.config}`
+    );
+    return;
+  }
+  const startTime = Date.now();
+  try {
+    const event = await loadJsonFromSource(options.event, {
+      name: "event"
+    });
+    const result = await simulateCore(options.config, event, {
+      json: options.json,
+      verbose: options.verbose,
+      silent: options.silent
+    });
+    const resultWithDuration = {
+      ...result,
+      duration: (Date.now() - startTime) / 1e3
+    };
+    if (options.json) {
+      logger2.json(resultWithDuration);
+    } else {
+      const output = formatSimulationResult(resultWithDuration, {
+        json: false
+      });
+      logger2.log(output);
+    }
+    if (!result.success) {
+      process.exit(1);
+    }
+  } catch (error) {
+    const errorMessage = getErrorMessage(error);
+    if (options.json) {
+      logger2.json({
+        success: false,
+        error: errorMessage,
+        duration: (Date.now() - startTime) / 1e3
+      });
+    } else {
+      logger2.error(`Error: ${errorMessage}`);
+    }
+    process.exit(1);
+  }
 }
 async function simulate(configOrPath, event, options = {}) {
   if (typeof configOrPath !== "string") {
@@ -2137,152 +2040,182 @@ async function simulate(configOrPath, event, options = {}) {
 import path11 from "path";
 import { JSDOM as JSDOM2, VirtualConsole as VirtualConsole2 } from "jsdom";
 import fs11 from "fs-extra";
-import { getPlatform as getPlatform3 } from "@walkeros/core";
+import {
+  getPlatform as getPlatform3
+} from "@walkeros/core";
 import { schemas as schemas2 } from "@walkeros/core/dev";
 async function pushCommand(options) {
   const logger2 = createCommandLogger(options);
-  const dockerArgs = buildCommonDockerArgs(options);
-  dockerArgs.push("--event", options.event);
-  if (options.flow) dockerArgs.push("--flow", options.flow);
-  await executeCommand(
-    async () => {
-      const startTime = Date.now();
-      try {
-        logger2.info("\u{1F4E5} Loading event...");
-        const event = await loadJsonFromSource(options.event, {
-          name: "event"
-        });
-        const eventResult = schemas2.PartialEventSchema.safeParse(event);
-        if (!eventResult.success) {
-          const errors = eventResult.error.issues.map((issue) => `${String(issue.path.join("."))}: ${issue.message}`).join(", ");
-          throw new Error(`Invalid event: ${errors}`);
-        }
-        const parsedEvent = eventResult.data;
-        if (!parsedEvent.name) {
-          throw new Error('Invalid event: Missing required "name" property');
-        }
-        const validatedEvent = {
-          name: parsedEvent.name,
-          data: parsedEvent.data || {}
-        };
-        if (!validatedEvent.name.includes(" ")) {
-          logger2.warn(
-            `Event name "${validatedEvent.name}" should follow "ENTITY ACTION" format (e.g., "page view")`
-          );
+  const startTime = Date.now();
+  let tempDir;
+  try {
+    logger2.debug("Loading event");
+    const event = await loadJsonFromSource(options.event, {
+      name: "event"
+    });
+    const eventResult = schemas2.PartialEventSchema.safeParse(event);
+    if (!eventResult.success) {
+      const errors = eventResult.error.issues.map((issue) => `${String(issue.path.join("."))}: ${issue.message}`).join(", ");
+      throw new Error(`Invalid event: ${errors}`);
+    }
+    const parsedEvent = eventResult.data;
+    if (!parsedEvent.name) {
+      throw new Error('Invalid event: Missing required "name" property');
+    }
+    const validatedEvent = {
+      name: parsedEvent.name,
+      data: parsedEvent.data || {}
+    };
+    if (!validatedEvent.name.includes(" ")) {
+      logger2.log(
+        `Warning: Event name "${validatedEvent.name}" should follow "ENTITY ACTION" format (e.g., "page view")`
+      );
+    }
+    logger2.debug("Detecting input type");
+    const detected = await detectInput(options.config, options.platform);
+    let result;
+    if (detected.type === "config") {
+      result = await executeConfigPush(
+        options,
+        validatedEvent,
+        logger2,
+        (dir) => {
+          tempDir = dir;
         }
-        logger2.info("\u{1F4E6} 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.info("\u{1F528} 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 fs11.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"
+      );
+    } else {
+      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) {
+      logger2.json({
+        success: result.success,
+        event: result.elbResult,
+        duration
+      });
+    } else {
+      if (result.success) {
+        logger2.log("Event pushed successfully");
+        if (result.elbResult && typeof result.elbResult === "object") {
+          const pushResult = result.elbResult;
+          if ("id" in pushResult && pushResult.id) {
+            logger2.log(`  Event ID: ${pushResult.id}`);
           }
-        };
-        await bundleCore(flowConfig, pushBuildOptions, logger2, false);
-        logger2.debug(`Bundle created: ${tempPath}`);
-        let result;
-        if (platform === "web") {
-          logger2.info("\u{1F310} Executing in web environment (JSDOM)...");
-          result = await executeWebPush(tempPath, validatedEvent, logger2);
-        } else if (platform === "server") {
-          logger2.info("\u{1F5A5}\uFE0F  Executing in server environment (Node.js)...");
-          result = await executeServerPush(tempPath, validatedEvent, logger2);
-        } 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) {
-            logger2.success("\u2705 Event pushed successfully");
-            if (result.elbResult && typeof result.elbResult === "object") {
-              const pushResult = result.elbResult;
-              if ("id" in pushResult && pushResult.id) {
-                logger2.info(`   Event ID: ${pushResult.id}`);
-              }
-              if ("entity" in pushResult && pushResult.entity) {
-                logger2.info(`   Entity: ${pushResult.entity}`);
-              }
-              if ("action" in pushResult && pushResult.action) {
-                logger2.info(`   Action: ${pushResult.action}`);
-              }
-            }
-            logger2.info(`   Duration: ${duration}ms`);
-          } else {
-            logger2.error(`\u274C Push failed: ${result.error}`);
-            process.exit(1);
+          if ("entity" in pushResult && pushResult.entity) {
+            logger2.log(`  Entity: ${pushResult.entity}`);
+          }
+          if ("action" in pushResult && pushResult.action) {
+            logger2.log(`  Action: ${pushResult.action}`);
           }
         }
-        try {
-          await fs11.remove(tempDir);
-        } 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 {
-          logger2.error(`\u274C Push command failed: ${errorMessage}`);
-        }
+        logger2.log(`  Duration: ${duration}ms`);
+      } else {
+        logger2.error(`Error: ${result.error}`);
         process.exit(1);
       }
-    },
-    "push",
-    dockerArgs,
-    options,
-    logger2,
-    options.config
+    }
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    const errorMessage = getErrorMessage(error);
+    if (options.json) {
+      logger2.json({
+        success: false,
+        error: errorMessage,
+        duration
+      });
+    } else {
+      logger2.error(`Error: ${errorMessage}`);
+    }
+    process.exit(1);
+  } finally {
+    if (tempDir) {
+      await fs11.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 fs11.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 fs11.ensureDir(tempDir);
+  const tempPath = path11.join(
+    tempDir,
+    `bundle.${platform === "server" ? "mjs" : "js"}`
+  );
+  await fs11.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) {
   const startTime = Date.now();
@@ -2298,16 +2231,19 @@ async function executeWebPush(bundlePath, event, logger2) {
     logger2.debug("Loading bundle...");
     const bundleCode = await fs11.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;
-    logger2.info(`Pushing event: ${event.name}`);
-    const elbResult = await elb(event.name, event.data);
+    const collector = windowObj.collector;
+    logger2.log(`Pushing event: ${event.name}`);
+    const elbResult = await collector.push({
+      name: event.name,
+      data: event.data
+    });
     return {
       success: true,
       elbResult,
@@ -2321,7 +2257,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) => {
@@ -2337,15 +2273,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;
-      logger2.info(`Pushing event: ${event.name}`);
-      const elbResult = await elb(event.name, event.data);
+      const { collector } = result;
+      logger2.log(`Pushing event: ${event.name}`);
+      const elbResult = await collector.push({
+        name: event.name,
+        data: event.data
+      });
       return {
         success: true,
         elbResult,
@@ -2362,11 +2301,11 @@ async function executeServerPush(bundlePath, event, logger2, timeout = 6e4) {
   }
 }
 function waitForWindowProperty2(window, prop, timeout = 5e3) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve3, reject) => {
     const start = Date.now();
     const check = () => {
       if (window[prop] !== void 0) {
-        resolve();
+        resolve3();
       } else if (Date.now() - start > timeout) {
         reject(
           new Error(
@@ -2465,9 +2404,134 @@ function isPreBuiltConfig(configPath) {
 
 // src/commands/run/execution.ts
 import { createLogger as createLogger2, Level } from "@walkeros/core";
-import { runFlow, runServeMode } from "@walkeros/docker";
+
+// src/runtime/runner.ts
+import { pathToFileURL as pathToFileURL2 } from "url";
+import { resolve, dirname as dirname2 } from "path";
+async function runFlow(file, config, logger2, loggerConfig2) {
+  logger2.info(`Loading flow from ${file}`);
+  try {
+    const absolutePath = resolve(file);
+    const flowDir = dirname2(absolutePath);
+    process.chdir(flowDir);
+    const fileUrl = pathToFileURL2(absolutePath).href;
+    const module = await import(fileUrl);
+    if (!module.default || typeof module.default !== "function") {
+      logger2.throw(
+        `Invalid flow bundle: ${file} must export a default function`
+      );
+    }
+    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 }`);
+    }
+    const { collector } = result;
+    logger2.info("Flow running");
+    if (config?.port) {
+      logger2.info(`Port: ${config.port}`);
+    }
+    const shutdown = async (signal) => {
+      logger2.info(`Received ${signal}, shutting down gracefully...`);
+      try {
+        if (collector.command) {
+          await collector.command("shutdown");
+        }
+        logger2.info("Shutdown complete");
+        process.exit(0);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger2.error(`Error during shutdown: ${message}`);
+        process.exit(1);
+      }
+    };
+    process.on("SIGTERM", () => shutdown("SIGTERM"));
+    process.on("SIGINT", () => shutdown("SIGINT"));
+    await new Promise(() => {
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger2.error(`Failed to run flow: ${message}`);
+    if (error instanceof Error && error.stack) {
+      logger2.debug("Stack trace:", { stack: error.stack });
+    }
+    throw error;
+  }
+}
+
+// src/runtime/serve.ts
+import express from "express";
+import { resolve as resolve2 } from "path";
+async function runServeMode(config, logger2) {
+  const port = process.env.PORT ? parseInt(process.env.PORT, 10) : config?.port || 8080;
+  const host = process.env.HOST || config?.host || "0.0.0.0";
+  const file = resolve2(
+    process.env.BUNDLE || config?.file || "./dist/walker.js"
+  );
+  const serveName = process.env.SERVE_NAME || config?.serveName || "walker.js";
+  const servePath = process.env.SERVE_PATH || config?.servePath || "";
+  const urlPath = servePath ? `/${servePath}/${serveName}` : `/${serveName}`;
+  logger2.info("Starting single-file server...");
+  logger2.info(`File: ${file}`);
+  logger2.info(`URL: http://${host}:${port}${urlPath}`);
+  try {
+    const app = express();
+    app.get("/health", (req, res) => {
+      res.json({
+        status: "ok",
+        version: VERSION,
+        timestamp: Date.now(),
+        mode: "serve",
+        file,
+        url: urlPath
+      });
+    });
+    app.get(urlPath, (req, res) => {
+      res.type("application/javascript");
+      res.sendFile(file, { dotfiles: "allow" }, (err) => {
+        if (err && !res.headersSent) {
+          const errCode = err.code;
+          const errStatus = err.status || err.statusCode;
+          if (errCode !== "ECONNABORTED") {
+            logger2.error(
+              `sendFile error for ${file}: ${err.message} (code: ${errCode}, status: ${errStatus})`
+            );
+          }
+          if (errStatus === 404 || errCode === "ENOENT" || errCode === "EISDIR" || errCode === "ENOTDIR") {
+            res.status(404).send("File not found");
+          } else if (errCode !== "ECONNABORTED") {
+            res.status(500).send("Internal server error");
+          }
+        }
+      });
+    });
+    const server = app.listen(port, host, () => {
+      logger2.info(`Server listening on http://${host}:${port}`);
+      logger2.info(`GET ${urlPath} - Bundle file`);
+      logger2.info(`GET /health - Health check`);
+    });
+    const shutdownHandler = (signal) => {
+      logger2.info(`Received ${signal}, shutting down...`);
+      server.close(() => {
+        logger2.info("Server closed");
+        process.exit(0);
+      });
+    };
+    process.on("SIGTERM", () => shutdownHandler("SIGTERM"));
+    process.on("SIGINT", () => shutdownHandler("SIGINT"));
+    await new Promise(() => {
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger2.error(`Server failed: ${message}`);
+    process.exit(1);
+  }
+}
+
+// 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": {
@@ -2478,7 +2542,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": {
@@ -2513,76 +2577,40 @@ async function runCommand(mode, options) {
     if (mode === "collect") {
       if (isPreBuilt) {
         flowPath = path13.resolve(configPath);
-        if (!options.json && !options.silent) {
-          logger2.info(`\u{1F4E6} Using pre-built flow: ${path13.basename(flowPath)}`);
-        }
+        logger2.debug(`Using pre-built flow: ${path13.basename(flowPath)}`);
       } else {
-        if (!options.json && !options.silent) {
-          logger2.info("\u{1F528} Building flow bundle...");
-        }
+        logger2.debug("Building flow bundle");
         flowPath = await prepareBundleForRun(configPath, {
           verbose: options.verbose,
           silent: options.json || options.silent
         });
-        if (!options.json && !options.silent) {
-          logger2.success("\u2705 Bundle ready");
-        }
+        logger2.debug("Bundle ready");
       }
     }
-    const executionMode = getExecutionMode(options);
     if (options.dryRun) {
-      if (executionMode === "docker") {
-        logger2.info(
-          `[DRY-RUN] Would execute in Docker: run ${mode} with runtime image`
-        );
-      } else {
-        logger2.info(`[DRY-RUN] Would execute locally: run ${mode}`);
-      }
+      logger2.log(`[DRY-RUN] Would execute locally: run ${mode}`);
       return;
     }
-    if (executionMode === "docker") {
-      const dockerAvailable = await isDockerAvailable();
-      if (!dockerAvailable) {
-        throw new Error(
-          "Docker is not available. Please install Docker or use --local flag to execute locally."
-        );
-      }
-      if (!options.json && !options.silent) {
-        logger2.info("\u{1F433} Executing in production runtime container...");
-      }
-      await executeRunInDocker(mode, flowPath, {
-        port: options.port,
-        host: options.host,
-        serveName: options.serveName,
-        servePath: options.servePath,
-        silent: options.silent
-      });
-    } else {
-      if (!options.json && !options.silent) {
-        const modeLabel = mode === "collect" ? "Collector" : "Server";
-        logger2.info(`\u{1F5A5}\uFE0F  Starting ${modeLabel} locally...`);
-      }
-      await executeRunLocal(mode, flowPath, {
-        port: options.port,
-        host: options.host,
-        serveName: options.serveName,
-        servePath: options.servePath
-      });
-    }
+    const modeLabel = mode === "collect" ? "Collector" : "Server";
+    logger2.log(`Starting ${modeLabel}...`);
+    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 = getErrorMessage(error);
     if (options.json) {
-      const output = {
+      logger2.json({
         success: false,
         mode,
         error: errorMessage,
         duration
-      };
-      console.log(JSON.stringify(output, null, 2));
+      });
     } else {
-      logger2.error("\u274C Run failed:");
-      logger2.error(errorMessage);
+      logger2.error(`Error: ${errorMessage}`);
     }
     process.exit(1);
   }
@@ -2633,30 +2661,40 @@ async function run(mode, options) {
 
 // src/commands/cache.ts
 import fs13 from "fs-extra";
-import path14 from "path";
-var CACHE_DIR = path14.join(".tmp", "cache");
 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").action(async (options) => {
+  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 fs13.remove(path14.join(CACHE_DIR, "packages"));
-      console.log("Package cache cleared");
+      await fs13.remove(getTmpPath(tmpDir, "cache", "packages"));
+      logger2.log("Package cache cleared");
     } else if (options.builds) {
-      await fs13.remove(path14.join(CACHE_DIR, "builds"));
-      console.log("Build cache cleared");
+      await fs13.remove(getTmpPath(tmpDir, "cache", "builds"));
+      logger2.log("Build cache cleared");
     } else {
-      await fs13.remove(CACHE_DIR);
-      console.log("All caches cleared");
+      await fs13.remove(getTmpPath(tmpDir, "cache"));
+      logger2.log("All caches cleared");
     }
   });
-  cache.command("info").description("Show cache statistics").action(async () => {
-    const packagesDir = path14.join(CACHE_DIR, "packages");
-    const buildsDir = path14.join(CACHE_DIR, "builds");
+  cache.command("info").description("Show cache statistics").option("--tmp-dir <dir>", "Custom temp directory").option("--silent", "Suppress output").action(async (options) => {
+    const logger2 = createLogger({ silent: options.silent });
+    const tmpDir = options.tmpDir;
+    const packagesDir = getTmpPath(tmpDir, "cache", "packages");
+    const buildsDir = getTmpPath(tmpDir, "cache", "builds");
     const packageCount = await countEntries(packagesDir);
     const buildCount = await countEntries(buildsDir);
-    console.log(`Cache directory: ${CACHE_DIR}`);
-    console.log(`Cached packages: ${packageCount}`);
-    console.log(`Cached builds: ${buildCount}`);
+    logger2.log(`Cache directory: ${getTmpPath(tmpDir, "cache")}`);
+    logger2.log(`Cached packages: ${packageCount}`);
+    logger2.log(`Cached builds: ${buildCount}`);
+  });
+}
+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 fs13.remove(tmpDir);
+    logger2.log(`Temp directory cleared: ${tmpDir}`);
   });
 }
 async function countEntries(dir) {
@@ -2671,11 +2709,10 @@ program.name("walkeros").description("walkerOS CLI - Bundle and deploy walkerOS
 program.hook("preAction", (thisCommand, actionCommand) => {
   const options = actionCommand.opts();
   if (!options.silent && !options.json) {
-    console.log(`\u{1F680} walkerOS CLI v${VERSION}`);
-    console.log(`\u{1F433} Using Docker runtime: walkeros/docker:${DOCKER_VERSION2}`);
+    console.log(`${chalk2.hex("#01b5e2")("walkerOS")} v${VERSION}`);
   }
 });
-program.command("bundle [file]").description("Bundle NPM packages with custom code").option("-f, --flow <name>", "flow to build (for multi-flow configs)").option("--all", "build all flows (for multi-flow configs)").option("-s, --stats", "show bundle statistics").option("--json", "output statistics in JSON format (implies --stats)").option("--no-cache", "disable package caching and download fresh packages").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("bundle [file]").description("Bundle NPM packages with custom code").option("-f, --flow <name>", "flow to build (for multi-flow configs)").option("--all", "build all flows (for multi-flow configs)").option("-s, --stats", "show bundle statistics").option("--json", "output statistics in JSON format (implies --stats)").option("--no-cache", "disable package caching and download fresh packages").option("-v, --verbose", "verbose output").option("--dry-run", "preview command without executing").option("--silent", "suppress output").option("--dockerfile", "generate Dockerfile alongside bundle").action(async (file, options) => {
   await bundleCommand({
     config: file || "bundle.config.json",
     flow: options.flow,
@@ -2684,21 +2721,21 @@ program.command("bundle [file]").description("Bundle NPM packages with custom co
     json: options.json,
     cache: options.cache,
     verbose: options.verbose,
-    local: options.local,
     dryRun: options.dryRun,
-    silent: options.silent
+    silent: options.silent,
+    dockerfile: options.dockerfile
   });
 });
 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) => {
+).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,
-    local: options.local,
     dryRun: options.dryRun,
     silent: options.silent
   });
@@ -2706,35 +2743,34 @@ 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").option("--local", "Execute in local Node.js instead of Docker").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,
-    local: options.local
+    silent: options.silent
   });
 });
 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."
-).option("-p, --port <number>", "Port to listen on (default: 8080)", parseInt).option("-h, --host <address>", "Host address (default: 0.0.0.0)").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) => {
+).option("-p, --port <number>", "Port to listen on (default: 8080)", parseInt).option("-h, --host <address>", "Host address (default: 0.0.0.0)").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 runCommand("collect", {
     config: file || "server-collect.mjs",
     port: options.port,
     host: options.host,
     json: options.json,
     verbose: options.verbose,
-    local: options.local,
     dryRun: options.dryRun,
     silent: options.silent
   });
 });
 runCmd.command("serve [file]").description(
   "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) => {
+).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("--dry-run", "preview command without executing").option("--silent", "suppress output").action(async (file, options) => {
   await runCommand("serve", {
     config: file || "web-serve.js",
     port: options.port,
@@ -2743,12 +2779,12 @@ runCmd.command("serve [file]").description(
     servePath: options.path,
     json: options.json,
     verbose: options.verbose,
-    local: options.local,
     dryRun: options.dryRun,
     silent: options.silent
   });
 });
 registerCacheCommand(program);
+registerCleanCommand(program);
 program.parse();
 export {
   bundle,