@walkeros/cli 0.5.1-next.0 → 0.6.0

package/dist/index.js

@@ -2,81 +2,100 @@
 
 // src/index.ts
 import { Command } from "commander";
+import chalk2 from "chalk";
+
+// src/version.ts
 import { readFileSync } from "fs";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { fileURLToPath } from "url";
 import { dirname, join } from "path";
-import { VERSION as DOCKER_VERSION2 } from "@walkeros/docker";
+var versionFilename = fileURLToPath(import.meta.url);
+var versionDirname = dirname(versionFilename);
+function findPackageJson() {
+  const paths = [
+    join(versionDirname, "../package.json"),
+    // dist/ or src/
+    join(versionDirname, "../../package.json")
+    // src/core/ (not used, but safe)
+  ];
+  for (const p of paths) {
+    try {
+      return readFileSync(p, "utf-8");
+    } catch {
+    }
+  }
+  return JSON.stringify({ version: "0.0.0" });
+}
+var VERSION = JSON.parse(findPackageJson()).version;
 
 // src/commands/bundle/index.ts
 import path9 from "path";
 
 // 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);
       }
     }
   };
@@ -132,15 +151,26 @@ function formatBytes(bytes) {
   return (bytes / 1024).toFixed(2);
 }
 
-// src/core/docker.ts
-import { spawn } from "child_process";
-import path2 from "path";
-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);
@@ -161,12 +191,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) {
@@ -183,7 +210,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}`);
     }
@@ -204,11 +231,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() === "") {
@@ -239,7 +261,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);
@@ -263,193 +285,11 @@ async function loadJsonFromSource(source, options) {
   }
 }
 
-// src/core/docker.ts
-var CLI_VERSION = true ? "0.5.0" : "0.0.0";
-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"];
-  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) {
-  const containerArgs = [...args, "--local"];
-  const dockerCmd = buildDockerCommand(
-    command,
-    containerArgs,
-    options,
-    configFile
-  );
-  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);
-      }
-    });
-  });
-}
-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 fs2 from "fs-extra";
-
 // src/core/asset-resolver.ts
-import { fileURLToPath } from "url";
-import { existsSync } from "fs";
-import path3 from "path";
 var cachedAssetDir;
 function getAssetDir() {
   if (cachedAssetDir) return cachedAssetDir;
-  const currentFile = fileURLToPath(import.meta.url);
+  const currentFile = fileURLToPath2(import.meta.url);
   let dir = path3.dirname(currentFile);
   while (dir !== path3.dirname(dir)) {
     if (existsSync(path3.join(dir, "examples"))) {
@@ -462,6 +302,9 @@ function getAssetDir() {
   return cachedAssetDir;
 }
 function resolveAsset(assetPath, assetType, baseDir) {
+  if (isUrl(assetPath)) {
+    return assetPath;
+  }
   if (!assetPath.includes("/") && !assetPath.includes("\\")) {
     const assetDir = getAssetDir();
     return path3.join(assetDir, "examples", assetPath);
@@ -479,22 +322,22 @@ function getErrorMessage(error) {
 
 // src/core/local-packages.ts
 import path4 from "path";
-import fs3 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 fs3.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 fs3.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 fs3.pathExists(distPath);
+  const hasDistFolder = await fs2.pathExists(distPath);
   if (!hasDistFolder) {
     logger2.warn(
       `\u26A0\uFE0F  ${packageName}: No dist/ folder found. Using package root.`
@@ -509,18 +352,18 @@ async function resolveLocalPackage(packageName, localPath, configDir, logger2) {
 }
 async function copyLocalPackage(localPkg, targetDir, logger2) {
   const packageDir = path4.join(targetDir, "node_modules", localPkg.name);
-  await fs3.ensureDir(path4.dirname(packageDir));
-  await fs3.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 fs3.copy(localPkg.distPath, path4.join(packageDir, "dist"));
+    await fs2.copy(localPkg.distPath, path4.join(packageDir, "dist"));
   } else {
-    const entries = await fs3.readdir(localPkg.absolutePath);
+    const entries = await fs2.readdir(localPkg.absolutePath);
     for (const entry of entries) {
       if (!["node_modules", ".turbo", ".git"].includes(entry)) {
-        await fs3.copy(
+        await fs2.copy(
           path4.join(localPkg.absolutePath, entry),
           path4.join(packageDir, entry)
         );
@@ -541,8 +384,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}`);
@@ -561,7 +404,6 @@ var WEB_BUILD_DEFAULTS = {
   minify: true,
   sourcemap: false,
   cache: true,
-  tempDir: ".tmp",
   windowCollector: "collector",
   windowElb: "elb"
 };
@@ -571,8 +413,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",
@@ -587,7 +428,7 @@ function getDefaultOutput(platform) {
 
 // src/config/loader.ts
 import path5 from "path";
-import fs4 from "fs-extra";
+import fs3 from "fs-extra";
 import { getFlowConfig, getPlatform } from "@walkeros/core";
 var DEFAULT_INCLUDE_FOLDER = "./shared";
 function loadBundleConfig(rawConfig, options) {
@@ -603,18 +444,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 (fs4.pathExistsSync(defaultIncludePath)) {
+    if (fs3.pathExistsSync(defaultIncludePath)) {
       includes = [DEFAULT_INCLUDE_FOLDER];
     }
   }
@@ -677,16 +512,16 @@ function loadAllFlows(rawConfig, options) {
 // src/commands/bundle/bundler.ts
 import esbuild from "esbuild";
 import path8 from "path";
-import fs7 from "fs-extra";
+import fs6 from "fs-extra";
 import { packageNameToVariable } from "@walkeros/core";
 
 // src/commands/bundle/package-manager.ts
 import pacote from "pacote";
 import path6 from "path";
-import fs5 from "fs-extra";
+import fs4 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");
@@ -699,10 +534,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);
@@ -712,21 +547,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 fs5.pathExists(cachedPath);
+async function isPackageCached(pkg, tmpDir) {
+  const cachedPath = await getCachedPackagePath(pkg, tmpDir);
+  return fs4.pathExists(cachedPath);
 }
 function validateNoDuplicatePackages(packages) {
   const packageMap = /* @__PURE__ */ new Map();
@@ -761,11 +603,11 @@ async function resolveDependencies(pkg, packageDir, logger2, visited = /* @__PUR
   visited.add(pkgKey);
   try {
     const packageJsonPath = path6.join(packageDir, "package.json");
-    if (await fs5.pathExists(packageJsonPath)) {
-      const packageJson2 = await fs5.readJson(packageJsonPath);
+    if (await fs4.pathExists(packageJsonPath)) {
+      const packageJson = await fs4.readJson(packageJsonPath);
       const deps = {
-        ...packageJson2.dependencies,
-        ...packageJson2.peerDependencies
+        ...packageJson.dependencies,
+        ...packageJson.peerDependencies
       };
       for (const [name, versionSpec] of Object.entries(deps)) {
         if (typeof versionSpec === "string") {
@@ -782,6 +624,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) {
@@ -789,7 +632,7 @@ async function downloadPackages(packages, targetDir, logger2, useCache = true, c
     }
   }
   validateNoDuplicatePackages(packages);
-  await fs5.ensureDir(targetDir);
+  await fs4.ensureDir(targetDir);
   while (downloadQueue.length > 0) {
     const pkg = downloadQueue.shift();
     const pkgKey = `${pkg.name}@${pkg.version}`;
@@ -820,12 +663,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 fs5.ensureDir(path6.dirname(packageDir));
-        await fs5.copy(cachedPath, packageDir);
+        await fs4.ensureDir(path6.dirname(packageDir));
+        await fs4.copy(cachedPath, packageDir);
         packagePaths.set(pkg.name, packageDir);
         const deps = await resolveDependencies(pkg, packageDir, logger2);
         for (const dep of deps) {
@@ -841,27 +686,34 @@ async function downloadPackages(packages, targetDir, logger2, useCache = true, c
         );
       }
     }
-    logger2.debug(`Downloading ${packageSpec}...`);
     try {
-      await fs5.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 fs4.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 fs4.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 fs5.ensureDir(path6.dirname(cachedPath));
-          await fs5.copy(packageDir, cachedPath);
-          logger2.debug(`Cached ${packageSpec} for future use`);
+          await fs4.ensureDir(path6.dirname(cachedPath));
+          await fs4.copy(packageDir, cachedPath);
         } catch (cacheError) {
-          logger2.debug(`Failed to cache ${packageSpec}: ${cacheError}`);
         }
       }
       packagePaths.set(pkg.name, packageDir);
@@ -880,26 +732,26 @@ async function downloadPackages(packages, targetDir, logger2, useCache = true, c
 }
 
 // src/core/build-cache.ts
-import fs6 from "fs-extra";
+import fs5 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 fs6.pathExists(cachePath);
+async function isBuildCached(configContent, tmpDir) {
+  const cachePath = await getBuildCachePath(configContent, tmpDir);
+  return fs5.pathExists(cachePath);
 }
-async function cacheBuild(configContent, buildOutput, cacheDir = BUILD_CACHE_DIR) {
-  const cachePath = await getBuildCachePath(configContent, cacheDir);
-  await fs6.ensureDir(path7.dirname(cachePath));
-  await fs6.writeFile(cachePath, buildOutput, "utf-8");
+async function cacheBuild(configContent, buildOutput, tmpDir) {
+  const cachePath = await getBuildCachePath(configContent, tmpDir);
+  await fs5.ensureDir(path7.dirname(cachePath));
+  await fs5.writeFile(cachePath, buildOutput, "utf-8");
 }
-async function getCachedBuild(configContent, cacheDir = BUILD_CACHE_DIR) {
-  const cachePath = await getBuildCachePath(configContent, cacheDir);
-  if (await fs6.pathExists(cachePath)) {
-    return await fs6.readFile(cachePath, "utf-8");
+async function getCachedBuild(configContent, tmpDir) {
+  const cachePath = await getBuildCachePath(configContent, tmpDir);
+  if (await fs5.pathExists(cachePath)) {
+    return await fs5.readFile(cachePath, "utf-8");
   }
   return null;
 }
@@ -910,8 +762,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 fs7.pathExists(sourcePath)) {
-      await fs7.copy(sourcePath, destPath);
+    if (await fs6.pathExists(sourcePath)) {
+      await fs6.copy(sourcePath, destPath);
       logger2.debug(`Copied ${include} to output`);
     } else {
       logger2.debug(`Include folder not found: ${include}`);
@@ -932,21 +784,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 fs7.ensureDir(path8.dirname(outputPath));
-        await fs7.writeFile(outputPath, cachedBuild);
-        logger2.gray(`Output: ${outputPath}`);
-        logger2.success("\u2705 Build completed (from cache)");
+        await fs6.ensureDir(path8.dirname(outputPath));
+        await fs6.writeFile(outputPath, cachedBuild);
+        const stats = await fs6.stat(outputPath);
+        const sizeKB = (stats.size / 1024).toFixed(1);
+        logger2.log(`Output: ${outputPath} (${sizeKB} KB, cached)`);
         if (showStats) {
-          const stats = await fs7.stat(outputPath);
+          const stats2 = await fs6.stat(outputPath);
           const packageStats = Object.entries(buildOptions.packages).map(
             ([name, pkg]) => ({
               name: `${name}@${pkg.version || "latest"}`,
@@ -955,7 +808,7 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
             })
           );
           return {
-            totalSize: stats.size,
+            totalSize: stats2.size,
             packages: packageStats,
             buildTime: Date.now() - bundleStartTime,
             treeshakingEffective: true
@@ -966,11 +819,8 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
     }
   }
   try {
-    if (!buildOptions.tempDir) {
-      await fs7.emptyDir(TEMP_DIR);
-    }
-    logger2.debug("Cleaned temporary directory");
-    logger2.info("\u{1F4E5} Downloading packages...");
+    await fs6.ensureDir(TEMP_DIR);
+    logger2.debug("Downloading packages");
     const packagesArray = Object.entries(buildOptions.packages).map(
       ([name, packageConfig]) => ({
         name,
@@ -990,7 +840,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 fs7.readJSON(pkgJsonPath);
+        const pkgJson = await fs6.readJSON(pkgJsonPath);
         if (!pkgJson.exports && pkgJson.module) {
           pkgJson.exports = {
             ".": {
@@ -998,26 +848,28 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
               require: pkgJson.main
             }
           };
-          await fs7.writeJSON(pkgJsonPath, pkgJson, { spaces: 2 });
+          await fs6.writeJSON(pkgJsonPath, pkgJson, { spaces: 2 });
         }
       }
     }
     const packageJsonPath = path8.join(TEMP_DIR, "package.json");
-    await fs7.writeFile(
+    await fs6.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 fs7.writeFile(entryPath, entryContent);
-    logger2.info("\u26A1 Bundling with esbuild...");
+    await fs6.writeFile(entryPath, entryContent);
+    logger2.debug(
+      `Running esbuild (target: ${buildOptions.target || "es2018"}, format: ${buildOptions.format})`
+    );
     const outputPath = path8.resolve(buildOptions.output);
-    await fs7.ensureDir(path8.dirname(outputPath));
+    await fs6.ensureDir(path8.dirname(outputPath));
     const esbuildOptions = createEsbuildOptions(
       buildOptions,
       entryPath,
@@ -1034,10 +886,13 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
         buildOptions.code || ""
       );
     }
-    logger2.gray(`Output: ${outputPath}`);
+    const outputStats = await fs6.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 fs7.readFile(outputPath, "utf-8");
+      const buildOutput = await fs6.readFile(outputPath, "utf-8");
       await cacheBuild(configContent, buildOutput);
       logger2.debug("Build cached for future use");
     }
@@ -1059,21 +914,13 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
         logger2
       );
     }
-    if (!buildOptions.tempDir) {
-      await fs7.remove(TEMP_DIR);
-      logger2.debug("Cleaned up temporary files");
-    }
     return stats;
   } catch (error) {
-    if (!buildOptions.tempDir) {
-      await fs7.remove(TEMP_DIR).catch(() => {
-      });
-    }
     throw error;
   }
 }
 async function collectBundleStats(outputPath, packages, startTime, entryContent) {
-  const stats = await fs7.stat(outputPath);
+  const stats = await fs6.stat(outputPath);
   const totalSize = stats.size;
   const buildTime = Date.now() - startTime;
   const packageStats = Object.entries(packages).map(([name, pkg]) => {
@@ -1434,130 +1281,111 @@ 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;
+        }
+        const configBasename = path9.basename(configPath);
+        if (isMultiFlow || options.all) {
+          logger2.log(`Bundling ${configBasename} (flow: ${flowName})...`);
+        } else {
+          logger2.log(`Bundling ${configBasename}...`);
         }
-        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 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;
-            }
-          }
-        }
-        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
-          );
-          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`);
-          }
+          success: true,
+          stats
+        });
+        if (!options.json && !options.all && options.stats && stats) {
+          displayStats(stats, 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;
@@ -1587,7 +1415,7 @@ async function bundle(configOrPath, options = {}) {
 
 // src/commands/simulate/simulator.ts
 import path10 from "path";
-import fs9 from "fs-extra";
+import fs8 from "fs-extra";
 import { getPlatform as getPlatform2 } from "@walkeros/core";
 
 // src/commands/simulate/tracker.ts
@@ -1624,9 +1452,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;
@@ -1670,7 +1498,7 @@ var CallTracker = class {
 
 // src/commands/simulate/jsdom-executor.ts
 import { JSDOM, VirtualConsole } from "jsdom";
-import fs8 from "fs-extra";
+import fs7 from "fs-extra";
 function buildSandboxFromEnvs(envs, destinations, tracker) {
   const baseBrowserMocks = {
     Image: class MockImage {
@@ -1707,11 +1535,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(
@@ -1739,7 +1567,7 @@ async function executeInJSDOM(bundlePath, destinations, event, tracker, envs, ti
   const sandbox = buildSandboxFromEnvs(envs, destinations, tracker);
   Object.assign(window, sandbox.window);
   Object.assign(window.document, sandbox.document);
-  const bundleCode = await fs8.readFile(bundlePath, "utf8");
+  const bundleCode = await fs7.readFile(bundlePath, "utf8");
   try {
     window.eval(bundleCode);
   } catch (error) {
@@ -1878,10 +1706,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;
@@ -1938,7 +1763,7 @@ function formatSimulationResult(result, options = {}) {
 async function executeSimulation(event, configPath) {
   const startTime = Date.now();
   let bundlePath;
-  const tempDir = getTempDir();
+  const tempDir = getTmpPath();
   try {
     if (!isObject(event) || !("name" in event) || typeof event.name !== "string") {
       throw new Error(
@@ -1946,7 +1771,7 @@ async function executeSimulation(event, configPath) {
       );
     }
     const typedEvent = event;
-    await fs9.ensureDir(tempDir);
+    await fs8.ensureDir(tempDir);
     const rawConfig = await loadJsonConfig(configPath);
     const { flowConfig, buildOptions } = loadBundleConfig(rawConfig, {
       configPath
@@ -2020,7 +1845,7 @@ async function executeSimulation(event, configPath) {
     };
   } finally {
     if (tempDir) {
-      await fs9.remove(tempDir).catch(() => {
+      await fs8.remove(tempDir).catch(() => {
       });
     }
   }
@@ -2029,59 +1854,50 @@ async function executeSimulation(event, configPath) {
 // 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") {
@@ -2098,153 +1914,125 @@ async function simulate(configOrPath, event, options = {}) {
 // src/commands/push/index.ts
 import path11 from "path";
 import { JSDOM as JSDOM2, VirtualConsole as VirtualConsole2 } from "jsdom";
-import fs10 from "fs-extra";
+import fs9 from "fs-extra";
 import { getPlatform as getPlatform3 } from "@walkeros/core";
 import { schemas as schemas2 } from "@walkeros/core/dev";
 async function pushCommand(options) {
   const logger2 = createCommandLogger(options);
-  const 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")`
-          );
-        }
-        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 fs10.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"
+  const startTime = Date.now();
+  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("Loading flow configuration");
+    const configPath = path11.resolve(options.config);
+    const rawConfig = await loadJsonConfig(configPath);
+    const { flowConfig, buildOptions, flowName, isMultiFlow } = loadBundleConfig(rawConfig, {
+      configPath: options.config,
+      flowName: options.flow,
+      logger: logger2
+    });
+    const platform = getPlatform3(flowConfig);
+    logger2.debug("Bundling flow configuration");
+    const configDir = path11.dirname(configPath);
+    const tempDir = path11.join(
+      configDir,
+      ".tmp",
+      `push-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
+    );
+    await fs9.ensureDir(tempDir);
+    const tempPath = path11.join(
+      tempDir,
+      `bundle.${platform === "web" ? "js" : "mjs"}`
+    );
+    const pushBuildOptions = {
+      ...buildOptions,
+      output: tempPath,
+      // Web uses IIFE for browser-like execution, server uses ESM
+      format: platform === "web" ? "iife" : "esm",
+      platform: platform === "web" ? "browser" : "node",
+      ...platform === "web" && {
+        windowCollector: "collector",
+        windowElb: "elb"
+      }
+    };
+    await bundleCore(flowConfig, pushBuildOptions, logger2, false);
+    logger2.debug(`Bundle created: ${tempPath}`);
+    let result;
+    if (platform === "web") {
+      logger2.debug("Executing in web environment (JSDOM)");
+      result = await executeWebPush(tempPath, validatedEvent, logger2);
+    } else if (platform === "server") {
+      logger2.debug("Executing in server environment (Node.js)");
+      result = await executeServerPush(tempPath, validatedEvent, logger2);
+    } else {
+      throw new Error(`Unsupported platform: ${platform}`);
+    }
+    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 fs10.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
-  );
+    }
+    try {
+      await fs9.remove(tempDir);
+    } catch {
+    }
+  } 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);
+  }
 }
 async function executeWebPush(bundlePath, event, logger2) {
   const startTime = Date.now();
@@ -2258,7 +2046,7 @@ async function executeWebPush(bundlePath, event, logger2) {
     });
     const { window } = dom;
     logger2.debug("Loading bundle...");
-    const bundleCode = await fs10.readFile(bundlePath, "utf8");
+    const bundleCode = await fs9.readFile(bundlePath, "utf8");
     window.eval(bundleCode);
     logger2.debug("Waiting for elb...");
     await waitForWindowProperty2(
@@ -2268,7 +2056,7 @@ async function executeWebPush(bundlePath, event, logger2) {
     );
     const windowObj = window;
     const elb = windowObj.elb;
-    logger2.info(`Pushing event: ${event.name}`);
+    logger2.log(`Pushing event: ${event.name}`);
     const elbResult = await elb(event.name, event.data);
     return {
       success: true,
@@ -2306,7 +2094,7 @@ async function executeServerPush(bundlePath, event, logger2, timeout = 6e4) {
         );
       }
       const { elb } = result;
-      logger2.info(`Pushing event: ${event.name}`);
+      logger2.log(`Pushing event: ${event.name}`);
       const elbResult = await elb(event.name, event.data);
       return {
         success: true,
@@ -2324,11 +2112,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(
@@ -2399,7 +2187,7 @@ function validatePort(port) {
 
 // src/commands/run/utils.ts
 import path12 from "path";
-import fs11 from "fs-extra";
+import fs10 from "fs-extra";
 async function prepareBundleForRun(configPath, options) {
   const configDir = path12.dirname(path12.resolve(configPath));
   const tempDir = path12.join(
@@ -2407,7 +2195,7 @@ async function prepareBundleForRun(configPath, options) {
     ".tmp",
     `run-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
   );
-  await fs11.ensureDir(tempDir);
+  await fs10.ensureDir(tempDir);
   const tempPath = path12.join(tempDir, "bundle.mjs");
   await bundle(configPath, {
     cache: true,
@@ -2427,7 +2215,128 @@ 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) {
+  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 result = await module.default(config);
+    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.FILE || 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 });
 async function executeRunLocal(mode, flowPath, options) {
@@ -2475,76 +2384,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);
   }
@@ -2594,56 +2467,59 @@ async function run(mode, options) {
 }
 
 // src/commands/cache.ts
-import fs12 from "fs-extra";
-import path14 from "path";
-var CACHE_DIR = path14.join(".tmp", "cache");
+import fs11 from "fs-extra";
 function registerCacheCommand(program2) {
   const cache = program2.command("cache").description("Manage the CLI cache");
-  cache.command("clear").description("Clear all cached packages and builds").option("--packages", "Clear only package cache").option("--builds", "Clear only build cache").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 fs12.remove(path14.join(CACHE_DIR, "packages"));
-      console.log("Package cache cleared");
+      await fs11.remove(getTmpPath(tmpDir, "cache", "packages"));
+      logger2.log("Package cache cleared");
     } else if (options.builds) {
-      await fs12.remove(path14.join(CACHE_DIR, "builds"));
-      console.log("Build cache cleared");
+      await fs11.remove(getTmpPath(tmpDir, "cache", "builds"));
+      logger2.log("Build cache cleared");
     } else {
-      await fs12.remove(CACHE_DIR);
-      console.log("All caches cleared");
+      await fs11.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 fs11.remove(tmpDir);
+    logger2.log(`Temp directory cleared: ${tmpDir}`);
   });
 }
 async function countEntries(dir) {
-  if (!await fs12.pathExists(dir)) return 0;
-  const entries = await fs12.readdir(dir);
+  if (!await fs11.pathExists(dir)) return 0;
+  const entries = await fs11.readdir(dir);
   return entries.length;
 }
 
 // src/index.ts
-var __filename = fileURLToPath2(import.meta.url);
-var __dirname = dirname(__filename);
-var packageJson = JSON.parse(
-  readFileSync(join(__dirname, "../package.json"), "utf-8")
-);
-var VERSION = packageJson.version;
 var program = new Command();
 program.name("walkeros").description("walkerOS CLI - Bundle and deploy walkerOS components").version(VERSION);
 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").action(async (file, options) => {
   await bundleCommand({
     config: file || "bundle.config.json",
     flow: options.flow,
@@ -2652,7 +2528,6 @@ 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
   });
@@ -2660,13 +2535,12 @@ program.command("bundle [file]").description("Bundle NPM packages with custom co
 program.command("simulate [file]").description("Simulate event processing and capture API calls").option(
   "-e, --event <source>",
   "Event to simulate (JSON string, file path, or URL)"
-).option("--json", "Output results as JSON").option("-v, --verbose", "Verbose output").option("--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("--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,
     json: options.json,
     verbose: options.verbose,
-    local: options.local,
     dryRun: options.dryRun,
     silent: options.silent
   });
@@ -2674,35 +2548,33 @@ 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("--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,
     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,
@@ -2711,12 +2583,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,