@walkeros/cli 0.4.1 → 0.4.2

package/dist/index.js

@@ -2,10 +2,13 @@
 
 // src/index.ts
 import { Command } from "commander";
-import { readFileSync as readFileSync2 } from "fs";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { readFileSync } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import { dirname, join } from "path";
 
+// src/commands/bundle/index.ts
+import path9 from "path";
+
 // src/core/logger.ts
 import chalk from "chalk";
 function createLogger(options = {}) {
@@ -131,8 +134,6 @@ function formatBytes(bytes) {
 // src/core/docker.ts
 import { spawn } from "child_process";
 import path2 from "path";
-import { readFileSync } from "fs";
-import { fileURLToPath } from "url";
 import { VERSION as DOCKER_VERSION } from "@walkeros/docker";
 
 // src/config/utils.ts
@@ -262,20 +263,7 @@ async function loadJsonFromSource(source, options) {
 }
 
 // src/core/docker.ts
-function readPackageVersion() {
-  const moduleFilename = fileURLToPath(import.meta.url);
-  const moduleDir = path2.dirname(moduleFilename);
-  const prodPath = path2.join(moduleDir, "../package.json");
-  try {
-    const pkg = JSON.parse(readFileSync(prodPath, "utf-8"));
-    return pkg.version;
-  } catch {
-    const devPath = path2.join(moduleDir, "../../package.json");
-    const pkg = JSON.parse(readFileSync(devPath, "utf-8"));
-    return pkg.version;
-  }
-}
-var CLI_VERSION = readPackageVersion();
+var CLI_VERSION = true ? "0.4.2" : "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) {
@@ -355,8 +343,10 @@ function buildDockerRunCommand(mode, flowPath, options = {}) {
   cmd.push("-e", `MODE=${mode}`);
   if (mode === "collect" && flowPath) {
     const absoluteFlowPath = path2.resolve(cwd, flowPath);
-    cmd.push("-v", `${absoluteFlowPath}:/app/flow.mjs:ro`);
-    cmd.push("-e", "FLOW=/app/flow.mjs");
+    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);
@@ -452,33 +442,36 @@ import { getHashServer } from "@walkeros/server-core";
 import fs2 from "fs-extra";
 
 // src/core/asset-resolver.ts
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { fileURLToPath } from "url";
+import { existsSync } from "fs";
 import path3 from "path";
-function getPackageRoot() {
-  const currentFile = fileURLToPath2(import.meta.url);
-  if (currentFile.includes("/src/")) {
-    const srcIndex = currentFile.indexOf("/src/");
-    return currentFile.substring(0, srcIndex);
-  }
-  if (currentFile.includes("/dist/")) {
-    const distIndex = currentFile.indexOf("/dist/");
-    return currentFile.substring(0, distIndex);
+var cachedAssetDir;
+function getAssetDir() {
+  if (cachedAssetDir) return cachedAssetDir;
+  const currentFile = fileURLToPath(import.meta.url);
+  let dir = path3.dirname(currentFile);
+  while (dir !== path3.dirname(dir)) {
+    if (existsSync(path3.join(dir, "templates"))) {
+      cachedAssetDir = dir;
+      return dir;
+    }
+    dir = path3.dirname(dir);
   }
-  return path3.resolve(currentFile, "../..");
+  cachedAssetDir = path3.dirname(currentFile);
+  return cachedAssetDir;
 }
 function resolveAsset(assetPath, assetType, baseDir) {
-  const packageRoot = getPackageRoot();
   if (!assetPath.includes("/") && !assetPath.includes("\\")) {
+    const assetDir = getAssetDir();
     if (assetType === "template") {
-      return path3.join(packageRoot, "templates", assetPath);
+      return path3.join(assetDir, "templates", assetPath);
     }
-    return path3.join(packageRoot, "examples", assetPath);
+    return path3.join(assetDir, "examples", assetPath);
   }
   if (path3.isAbsolute(assetPath)) {
     return assetPath;
   }
-  const resolveBase = baseDir || process.cwd();
-  return path3.resolve(resolveBase, assetPath);
+  return path3.resolve(baseDir || process.cwd(), assetPath);
 }
 
 // src/core/utils.ts
@@ -486,273 +479,257 @@ function getErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
-// src/config/validators.ts
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.prototype.toString.call(value) === "[object Object]";
-}
-function validatePlatform(platform) {
-  return platform === "web" || platform === "server";
-}
-function isMultiEnvConfig(data) {
-  return isObject(data) && "version" in data && data.version === 1 && "environments" in data && isObject(data.environments);
-}
-function isSingleEnvConfig(data) {
-  return isObject(data) && "flow" in data && "build" in data && isObject(data.flow) && isObject(data.build) && "platform" in data.flow;
-}
-
-// src/config/parser.ts
+// src/core/local-packages.ts
 import path4 from "path";
-function parseConfigStructure(rawConfig, options = {}) {
-  if (isMultiEnvConfig(rawConfig)) {
-    const setup = rawConfig;
-    const availableEnvironments = Object.keys(setup.environments);
-    if (!options.environment) {
-      throw new Error(
-        `Multi-environment configuration detected. Please specify an environment using --env flag.
-Available environments: ${availableEnvironments.join(", ")}`
-      );
-    }
-    const selectedEnv = options.environment;
-    if (!setup.environments[selectedEnv]) {
-      throw new Error(
-        `Environment "${selectedEnv}" not found in configuration.
-Available environments: ${availableEnvironments.join(", ")}`
-      );
-    }
-    const envConfig = setup.environments[selectedEnv];
-    return {
-      flowConfig: envConfig.flow,
-      buildOptions: envConfig.build,
-      metadata: {
-        environment: selectedEnv,
-        isMultiEnvironment: true,
-        availableEnvironments
-      }
-    };
-  }
-  if (isSingleEnvConfig(rawConfig)) {
-    const config = rawConfig;
-    return {
-      flowConfig: config.flow,
-      buildOptions: config.build,
-      metadata: {
-        environment: "default",
-        isMultiEnvironment: false
-      }
-    };
-  }
-  const configPath = options.configPath || "configuration";
-  const configType = isObject(rawConfig) ? "platform" in rawConfig ? `invalid platform value: "${rawConfig.platform}"` : 'missing "flow" and "build" fields' : `not an object (got ${typeof rawConfig})`;
-  throw new Error(
-    `Invalid configuration format at ${configPath}.
-Configuration ${configType}.
-
-Expected either:
-  1. Multi-environment: { version: 1, environments: { prod: { flow: {...}, build: {...} } } }
-  2. Single-environment: { flow: { platform: "web" | "server", ... }, build: { packages: {...}, ... } }`
-  );
-}
-function normalizeAndValidate(flowConfig, buildOptions, configPath) {
-  if (!isObject(flowConfig) || !("platform" in flowConfig)) {
+import fs3 from "fs-extra";
+async function resolveLocalPackage(packageName, localPath, configDir, logger) {
+  const absolutePath = path4.isAbsolute(localPath) ? localPath : path4.resolve(configDir, localPath);
+  if (!await fs3.pathExists(absolutePath)) {
     throw new Error(
-      `Invalid flow config: missing "platform" field. Expected "web" or "server".`
+      `Local package path not found: ${localPath} (resolved to ${absolutePath})`
     );
   }
-  const platform = flowConfig.platform;
-  if (!validatePlatform(platform)) {
+  const pkgJsonPath = path4.join(absolutePath, "package.json");
+  if (!await fs3.pathExists(pkgJsonPath)) {
     throw new Error(
-      `Invalid platform "${platform}". Must be "web" or "server".`
+      `No package.json found at ${absolutePath}. Is this a valid package directory?`
     );
   }
-  if (!isObject(buildOptions)) {
-    throw new Error(
-      `Invalid build options: expected object, got ${typeof buildOptions}`
+  const distPath = path4.join(absolutePath, "dist");
+  const hasDistFolder = await fs3.pathExists(distPath);
+  if (!hasDistFolder) {
+    logger.warn(
+      `\u26A0\uFE0F  ${packageName}: No dist/ folder found. Using package root.`
     );
   }
-  const platformDefaults = platform === "web" ? {
-    platform: "browser",
-    format: "iife",
-    target: "es2020",
-    minify: false,
-    sourcemap: false,
-    tempDir: ".tmp",
-    cache: true
-  } : {
-    platform: "node",
-    format: "esm",
-    target: "node20",
-    minify: false,
-    sourcemap: false,
-    tempDir: ".tmp",
-    cache: true
-  };
-  const merged = {
-    ...platformDefaults,
-    ...buildOptions
-  };
-  if (merged.template === void 0) {
-    merged.template = platform === "server" ? "server.hbs" : "web.hbs";
-  }
-  if (merged.format === "iife" && merged.platform === "browser") {
-    if (merged.windowCollector === void 0) {
-      merged.windowCollector = "collector";
-    }
-    if (merged.windowElb === void 0) {
-      merged.windowElb = "elb";
-    }
-  }
-  if (configPath && merged.template && !path4.isAbsolute(merged.template) && (merged.template.startsWith("./") || merged.template.startsWith("../"))) {
-    const configDir = path4.dirname(configPath);
-    merged.template = path4.resolve(configDir, merged.template);
-  }
-  if (!merged.output || merged.output === "") {
-    merged.output = platform === "web" ? "./dist/walker.js" : "./dist/bundle.js";
-  }
-  if (configPath && configPath !== "/unknown/path" && merged.output && !path4.isAbsolute(merged.output)) {
-    const configDir = path4.dirname(configPath);
-    merged.output = path4.resolve(configDir, merged.output);
-  }
-  if (!merged.packages) {
-    merged.packages = {};
-  }
-  if (merged.code === void 0 || merged.code === "") {
-    merged.code = "";
-  }
   return {
-    flowConfig,
-    buildOptions: merged
+    name: packageName,
+    absolutePath,
+    distPath: hasDistFolder ? distPath : absolutePath,
+    hasDistFolder
   };
 }
-function parseBundleConfig(data) {
-  if (!isObject(data)) {
-    throw new Error(`Invalid config: expected object, got ${typeof data}`);
-  }
-  if (!("flow" in data) || !isObject(data.flow)) {
-    throw new Error(
-      `Invalid config: missing "flow" field. Expected format: { flow: { platform: "web" | "server", ... }, build: { ... } }`
-    );
-  }
-  if (!("build" in data) || !isObject(data.build)) {
-    throw new Error(
-      `Invalid config: missing "build" field. Expected format: { flow: { platform: "web" | "server", ... }, build: { ... } }`
-    );
+async function copyLocalPackage(localPkg, targetDir, logger) {
+  const packageDir = path4.join(targetDir, "node_modules", localPkg.name);
+  await fs3.ensureDir(path4.dirname(packageDir));
+  await fs3.copy(
+    path4.join(localPkg.absolutePath, "package.json"),
+    path4.join(packageDir, "package.json")
+  );
+  if (localPkg.hasDistFolder) {
+    await fs3.copy(localPkg.distPath, path4.join(packageDir, "dist"));
+  } else {
+    const entries = await fs3.readdir(localPkg.absolutePath);
+    for (const entry of entries) {
+      if (!["node_modules", ".turbo", ".git"].includes(entry)) {
+        await fs3.copy(
+          path4.join(localPkg.absolutePath, entry),
+          path4.join(packageDir, entry)
+        );
+      }
+    }
   }
-  const buildData = data.build;
-  if ("packages" in buildData && !isObject(buildData.packages)) {
-    throw new Error(
-      `Invalid config: build.packages must be an object, got ${typeof buildData.packages}`
-    );
+  logger.info(`\u{1F4E6} Using local: ${localPkg.name} from ${localPkg.absolutePath}`);
+  return packageDir;
+}
+
+// src/config/validators.ts
+import { schemas } from "@walkeros/core/dev";
+var { safeParseSetup } = schemas;
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.prototype.toString.call(value) === "[object Object]";
+}
+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}`;
+    }).join("\n");
+    throw new Error(`Invalid configuration:
+${errors}`);
   }
-  return normalizeAndValidate(data.flow, data.build, "/unknown/path");
+  return result.data;
+}
+function getAvailableFlows(setup) {
+  return Object.keys(setup.flows);
+}
+
+// src/config/build-defaults.ts
+var WEB_BUILD_DEFAULTS = {
+  format: "iife",
+  platform: "browser",
+  target: "es2020",
+  template: "web.hbs",
+  minify: true,
+  sourcemap: false,
+  cache: true,
+  tempDir: ".tmp",
+  windowCollector: "collector",
+  windowElb: "elb"
+};
+var SERVER_BUILD_DEFAULTS = {
+  format: "esm",
+  platform: "node",
+  target: "node20",
+  template: "server.hbs",
+  minify: true,
+  sourcemap: false,
+  cache: true,
+  tempDir: ".tmp"
+};
+var DEFAULT_OUTPUT_PATHS = {
+  web: "./dist/walker.js",
+  server: "./dist/bundle.mjs"
+};
+function getBuildDefaults(platform) {
+  return platform === "web" ? WEB_BUILD_DEFAULTS : SERVER_BUILD_DEFAULTS;
 }
-function normalizeConfigs(config, configPath) {
-  return normalizeAndValidate(config.flow, config.build, configPath);
+function getDefaultOutput(platform) {
+  return DEFAULT_OUTPUT_PATHS[platform];
 }
 
 // src/config/loader.ts
+import path5 from "path";
+import fs4 from "fs-extra";
+import { getFlowConfig, getPlatform } from "@walkeros/core";
+var DEFAULT_INCLUDE_FOLDER = "./shared";
 function loadBundleConfig(rawConfig, options) {
-  const { flowConfig, buildOptions, metadata } = parseConfigStructure(
-    rawConfig,
-    {
-      configPath: options.configPath,
-      environment: options.environment
-    }
-  );
-  const normalized = normalizeAndValidate(
-    flowConfig,
-    buildOptions,
-    options.configPath
-  );
-  if (metadata.isMultiEnvironment && options.logger) {
-    options.logger.info(
-      `\u{1F4E6} Using environment: ${metadata.environment} (${metadata.availableEnvironments?.length || 0} total)`
-    );
-  }
-  if (!metadata.isMultiEnvironment && options.environment && options.logger) {
-    options.logger.warn(
-      `--env flag specified but configuration is single-environment. Ignoring flag.`
-    );
-  }
-  return {
-    ...normalized,
-    ...metadata
-  };
-}
-function loadMultiEnvironmentConfig(setup, options) {
-  const availableEnvironments = Object.keys(setup.environments);
-  if (!options.environment) {
+  const setup = validateFlowSetup(rawConfig);
+  const availableFlows = getAvailableFlows(setup);
+  const flowName = resolveFlow(setup, options.flowName, availableFlows);
+  const flowConfig = getFlowConfig(setup, flowName);
+  const platform = getPlatform(flowConfig);
+  if (!platform) {
     throw new Error(
-      `Multi-environment configuration detected. Please specify an environment using --env flag.
-Available environments: ${availableEnvironments.join(", ")}`
+      `Invalid configuration: flow "${flowName}" must have a "web" or "server" key.`
     );
   }
-  const selectedEnv = options.environment;
-  if (!setup.environments[selectedEnv]) {
-    throw new Error(
-      `Environment "${selectedEnv}" not found in configuration.
-Available environments: ${availableEnvironments.join(", ")}`
-    );
-  }
-  const envConfig = setup.environments[selectedEnv];
-  const { flowConfig, buildOptions } = normalizeConfigs(
-    envConfig,
-    options.configPath
-  );
-  if (options.logger) {
+  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);
+  }
+  let includes = setup.include;
+  if (!includes) {
+    const defaultIncludePath = path5.resolve(configDir, DEFAULT_INCLUDE_FOLDER);
+    if (fs4.pathExistsSync(defaultIncludePath)) {
+      includes = [DEFAULT_INCLUDE_FOLDER];
+    }
+  }
+  const buildOptions = {
+    ...buildDefaults,
+    packages,
+    output,
+    include: includes,
+    configDir,
+    ...options.buildOverrides
+  };
+  const isMultiFlow = availableFlows.length > 1;
+  if (isMultiFlow && options.logger) {
     options.logger.info(
-      `\u{1F4E6} Using environment: ${selectedEnv} (${availableEnvironments.length} total)`
+      `\u{1F4E6} Using flow: ${flowName} (${availableFlows.length} total)`
     );
   }
   return {
     flowConfig,
     buildOptions,
-    environment: selectedEnv,
-    isMultiEnvironment: true,
-    availableEnvironments
+    flowName,
+    isMultiFlow,
+    availableFlows
   };
 }
-function loadAllEnvironments(rawConfig, options) {
-  if (!isMultiEnvConfig(rawConfig)) {
+function resolveFlow(setup, requestedFlow, available) {
+  if (available.length === 1) {
+    return available[0];
+  }
+  if (!requestedFlow) {
+    throw new Error(
+      `Multiple flows found. Please specify a flow using --flow flag.
+Available flows: ${available.join(", ")}`
+    );
+  }
+  if (!available.includes(requestedFlow)) {
     throw new Error(
-      `--all flag requires a multi-environment configuration (Setup format).
-Your configuration appears to be single-environment.`
+      `Flow "${requestedFlow}" not found in configuration.
+Available flows: ${available.join(", ")}`
     );
   }
-  const setup = rawConfig;
-  const environments = Object.keys(setup.environments);
+  return requestedFlow;
+}
+function loadAllFlows(rawConfig, options) {
+  const setup = validateFlowSetup(rawConfig);
+  const flows = getAvailableFlows(setup);
   if (options.logger) {
     options.logger.info(
-      `\u{1F4E6} Loading all ${environments.length} environments: ${environments.join(", ")}`
+      `\u{1F4E6} Loading all ${flows.length} flows: ${flows.join(", ")}`
     );
   }
-  return environments.map(
-    (envName) => loadMultiEnvironmentConfig(setup, {
+  return flows.map(
+    (name) => loadBundleConfig(rawConfig, {
       ...options,
-      environment: envName
+      flowName: name
     })
   );
 }
 
 // src/commands/bundle/bundler.ts
 import esbuild from "esbuild";
+import path8 from "path";
+import fs8 from "fs-extra";
+
+// src/commands/bundle/package-manager.ts
+import pacote from "pacote";
 import path6 from "path";
 import fs5 from "fs-extra";
 
+// src/core/cache-utils.ts
+import { getHashServer as getHashServer2 } from "@walkeros/server-core";
+var HASH_LENGTH = 12;
+function isMutableVersion(version) {
+  return version === "latest" || version.includes("^") || version.includes("~") || version.includes("*") || version.includes("x");
+}
+function getTodayDate() {
+  return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+}
+async function getPackageCacheKey(packageName, version, date) {
+  const safeName = packageName.replace(/\//g, "-").replace(/@/g, "");
+  if (isMutableVersion(version)) {
+    const dateStr = date ?? getTodayDate();
+    const input2 = `${safeName}@${version}:${dateStr}`;
+    return getHashServer2(input2, HASH_LENGTH);
+  }
+  const input = `${safeName}@${version}`;
+  return getHashServer2(input, HASH_LENGTH);
+}
+function normalizeJson(content) {
+  const parsed = JSON.parse(content);
+  return JSON.stringify(parsed);
+}
+async function getFlowConfigCacheKey(content, date) {
+  const dateStr = date ?? getTodayDate();
+  const normalized = normalizeJson(content);
+  const input = `${normalized}:${dateStr}`;
+  return getHashServer2(input, HASH_LENGTH);
+}
+
 // src/commands/bundle/package-manager.ts
-import pacote from "pacote";
-import path5 from "path";
-import fs3 from "fs-extra";
 function getPackageDirectory(baseDir, packageName, version) {
-  return path5.join(baseDir, "node_modules", packageName);
+  return path6.join(baseDir, "node_modules", packageName);
 }
-function getCachedPackagePath(pkg, tempDir) {
-  const cacheDir = path5.join(".tmp", "cache", "packages");
-  const safeName = pkg.name.replace(/\//g, "-").replace(/@/g, "");
-  return path5.join(cacheDir, `${safeName}-${pkg.version}`);
+async function getCachedPackagePath(pkg, tempDir) {
+  const cacheDir = path6.join(".tmp", "cache", "packages");
+  const cacheKey = await getPackageCacheKey(pkg.name, pkg.version);
+  return path6.join(cacheDir, cacheKey);
 }
 async function isPackageCached(pkg, tempDir) {
-  const cachedPath = getCachedPackagePath(pkg, tempDir);
-  return fs3.pathExists(cachedPath);
+  const cachedPath = await getCachedPackagePath(pkg, tempDir);
+  return fs5.pathExists(cachedPath);
 }
 function validateNoDuplicatePackages(packages) {
   const packageMap = /* @__PURE__ */ new Map();
@@ -786,9 +763,9 @@ async function resolveDependencies(pkg, packageDir, logger, visited = /* @__PURE
   }
   visited.add(pkgKey);
   try {
-    const packageJsonPath = path5.join(packageDir, "package.json");
-    if (await fs3.pathExists(packageJsonPath)) {
-      const packageJson2 = await fs3.readJson(packageJsonPath);
+    const packageJsonPath = path6.join(packageDir, "package.json");
+    if (await fs5.pathExists(packageJsonPath)) {
+      const packageJson2 = await fs5.readJson(packageJsonPath);
       const deps = {
         ...packageJson2.dependencies,
         ...packageJson2.peerDependencies
@@ -804,12 +781,18 @@ async function resolveDependencies(pkg, packageDir, logger, visited = /* @__PURE
   }
   return dependencies;
 }
-async function downloadPackages(packages, targetDir, logger, useCache = true) {
+async function downloadPackages(packages, targetDir, logger, useCache = true, configDir) {
   const packagePaths = /* @__PURE__ */ new Map();
   const downloadQueue = [...packages];
   const processed = /* @__PURE__ */ new Set();
+  const localPackageMap = /* @__PURE__ */ new Map();
+  for (const pkg of packages) {
+    if (pkg.path) {
+      localPackageMap.set(pkg.name, pkg.path);
+    }
+  }
   validateNoDuplicatePackages(packages);
-  await fs3.ensureDir(targetDir);
+  await fs5.ensureDir(targetDir);
   while (downloadQueue.length > 0) {
     const pkg = downloadQueue.shift();
     const pkgKey = `${pkg.name}@${pkg.version}`;
@@ -817,14 +800,35 @@ async function downloadPackages(packages, targetDir, logger, useCache = true) {
       continue;
     }
     processed.add(pkgKey);
+    if (!pkg.path && localPackageMap.has(pkg.name)) {
+      pkg.path = localPackageMap.get(pkg.name);
+    }
+    if (pkg.path) {
+      const localPkg = await resolveLocalPackage(
+        pkg.name,
+        pkg.path,
+        configDir || process.cwd(),
+        logger
+      );
+      const installedPath = await copyLocalPackage(localPkg, targetDir, logger);
+      packagePaths.set(pkg.name, installedPath);
+      const deps = await resolveDependencies(pkg, installedPath, logger);
+      for (const dep of deps) {
+        const depKey = `${dep.name}@${dep.version}`;
+        if (!processed.has(depKey)) {
+          downloadQueue.push(dep);
+        }
+      }
+      continue;
+    }
     const packageSpec = `${pkg.name}@${pkg.version}`;
     const packageDir = getPackageDirectory(targetDir, pkg.name, pkg.version);
-    const cachedPath = getCachedPackagePath(pkg, targetDir);
+    const cachedPath = await getCachedPackagePath(pkg, targetDir);
     if (useCache && await isPackageCached(pkg, targetDir)) {
       logger.debug(`Using cached ${packageSpec}...`);
       try {
-        await fs3.ensureDir(path5.dirname(packageDir));
-        await fs3.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, logger);
         for (const dep of deps) {
@@ -842,8 +846,8 @@ async function downloadPackages(packages, targetDir, logger, useCache = true) {
     }
     logger.debug(`Downloading ${packageSpec}...`);
     try {
-      await fs3.ensureDir(path5.dirname(packageDir));
-      const cacheDir = process.env.NPM_CACHE_DIR || path5.join(process.cwd(), ".npm-cache");
+      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",
@@ -856,8 +860,8 @@ async function downloadPackages(packages, targetDir, logger, useCache = true) {
       });
       if (useCache) {
         try {
-          await fs3.ensureDir(path5.dirname(cachedPath));
-          await fs3.copy(packageDir, cachedPath);
+          await fs5.ensureDir(path6.dirname(cachedPath));
+          await fs5.copy(packageDir, cachedPath);
           logger.debug(`Cached ${packageSpec} for future use`);
         } catch (cacheError) {
           logger.debug(`Failed to cache ${packageSpec}: ${cacheError}`);
@@ -879,7 +883,7 @@ async function downloadPackages(packages, targetDir, logger, useCache = true) {
 }
 
 // src/commands/bundle/template-engine.ts
-import fs4 from "fs-extra";
+import fs6 from "fs-extra";
 import Handlebars from "handlebars";
 
 // src/commands/bundle/serializer.ts
@@ -996,10 +1000,10 @@ var TemplateEngine = class {
    */
   async loadTemplate(templatePath) {
     const resolvedPath = resolveAsset(templatePath, "template");
-    if (!await fs4.pathExists(resolvedPath)) {
+    if (!await fs6.pathExists(resolvedPath)) {
       throw new Error(`Template file not found: ${resolvedPath}`);
     }
-    return await fs4.readFile(resolvedPath, "utf-8");
+    return await fs6.readFile(resolvedPath, "utf-8");
   }
   /**
    * Apply template with user code and variable substitution
@@ -1034,32 +1038,118 @@ var TemplateEngine = class {
   }
 };
 
+// src/core/build-cache.ts
+import fs7 from "fs-extra";
+import path7 from "path";
+var BUILD_CACHE_DIR = path7.join(".tmp", "cache", "builds");
+async function getBuildCachePath(configContent, cacheDir = BUILD_CACHE_DIR) {
+  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 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 getCachedBuild(configContent, cacheDir = BUILD_CACHE_DIR) {
+  const cachePath = await getBuildCachePath(configContent, cacheDir);
+  if (await fs7.pathExists(cachePath)) {
+    return await fs7.readFile(cachePath, "utf-8");
+  }
+  return null;
+}
+
 // src/commands/bundle/bundler.ts
+async function copyIncludes(includes, sourceDir, outputDir, logger) {
+  for (const include of includes) {
+    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);
+      logger.debug(`Copied ${include} to output`);
+    } else {
+      logger.debug(`Include folder not found: ${include}`);
+    }
+  }
+}
+function generateCacheKeyContent(flowConfig, buildOptions) {
+  const configForCache = {
+    flow: flowConfig,
+    build: {
+      ...buildOptions,
+      // Exclude non-deterministic fields from cache key
+      tempDir: void 0,
+      output: void 0
+    }
+  };
+  return JSON.stringify(configForCache);
+}
 async function bundleCore(flowConfig, buildOptions, logger, showStats = false) {
   const bundleStartTime = Date.now();
-  const TEMP_DIR = buildOptions.tempDir ? path6.isAbsolute(buildOptions.tempDir) ? buildOptions.tempDir : path6.resolve(buildOptions.tempDir) : getTempDir();
+  const TEMP_DIR = buildOptions.tempDir ? path8.isAbsolute(buildOptions.tempDir) ? buildOptions.tempDir : path8.resolve(buildOptions.tempDir) : getTempDir();
+  if (buildOptions.cache !== false) {
+    const configContent = generateCacheKeyContent(flowConfig, buildOptions);
+    const cached = await isBuildCached(configContent);
+    if (cached) {
+      const cachedBuild = await getCachedBuild(configContent);
+      if (cachedBuild) {
+        logger.info("\u2728 Using cached build");
+        const outputPath = path8.resolve(buildOptions.output);
+        await fs8.ensureDir(path8.dirname(outputPath));
+        await fs8.writeFile(outputPath, cachedBuild);
+        logger.gray(`Output: ${outputPath}`);
+        logger.success("\u2705 Build completed (from cache)");
+        if (showStats) {
+          const stats = await fs8.stat(outputPath);
+          const packageStats = Object.entries(buildOptions.packages).map(
+            ([name, pkg]) => ({
+              name: `${name}@${pkg.version || "latest"}`,
+              size: 0
+              // Size estimation not available for cached builds
+            })
+          );
+          return {
+            totalSize: stats.size,
+            packages: packageStats,
+            buildTime: Date.now() - bundleStartTime,
+            treeshakingEffective: true
+          };
+        }
+        return;
+      }
+    }
+  }
   try {
     if (!buildOptions.tempDir) {
-      await fs5.emptyDir(TEMP_DIR);
+      await fs8.emptyDir(TEMP_DIR);
     }
     logger.debug("Cleaned temporary directory");
     logger.info("\u{1F4E5} Downloading packages...");
     const packagesArray = Object.entries(buildOptions.packages).map(
       ([name, packageConfig]) => ({
         name,
-        version: packageConfig.version || "latest"
+        version: packageConfig.version || "latest",
+        path: packageConfig.path
+        // Pass local path if defined
       })
     );
     const packagePaths = await downloadPackages(
       packagesArray,
       TEMP_DIR,
       logger,
-      buildOptions.cache
+      buildOptions.cache,
+      buildOptions.configDir
+      // For resolving relative local paths
     );
     for (const [pkgName, pkgPath] of packagePaths.entries()) {
       if (pkgName.startsWith("@walkeros/")) {
-        const pkgJsonPath = path6.join(pkgPath, "package.json");
-        const pkgJson = await fs5.readJSON(pkgJsonPath);
+        const pkgJsonPath = path8.join(pkgPath, "package.json");
+        const pkgJson = await fs8.readJSON(pkgJsonPath);
         if (!pkgJson.exports && pkgJson.module) {
           pkgJson.exports = {
             ".": {
@@ -1067,12 +1157,12 @@ async function bundleCore(flowConfig, buildOptions, logger, showStats = false) {
               require: pkgJson.main
             }
           };
-          await fs5.writeJSON(pkgJsonPath, pkgJson, { spaces: 2 });
+          await fs8.writeJSON(pkgJsonPath, pkgJson, { spaces: 2 });
         }
       }
     }
-    const packageJsonPath = path6.join(TEMP_DIR, "package.json");
-    await fs5.writeFile(
+    const packageJsonPath = path8.join(TEMP_DIR, "package.json");
+    await fs8.writeFile(
       packageJsonPath,
       JSON.stringify({ type: "module" }, null, 2)
     );
@@ -1082,11 +1172,11 @@ async function bundleCore(flowConfig, buildOptions, logger, showStats = false) {
       buildOptions,
       packagePaths
     );
-    const entryPath = path6.join(TEMP_DIR, "entry.js");
-    await fs5.writeFile(entryPath, entryContent);
+    const entryPath = path8.join(TEMP_DIR, "entry.js");
+    await fs8.writeFile(entryPath, entryContent);
     logger.info("\u26A1 Bundling with esbuild...");
-    const outputPath = path6.resolve(buildOptions.output);
-    await fs5.ensureDir(path6.dirname(outputPath));
+    const outputPath = path8.resolve(buildOptions.output);
+    await fs8.ensureDir(path8.dirname(outputPath));
     const esbuildOptions = createEsbuildOptions(
       buildOptions,
       entryPath,
@@ -1104,6 +1194,12 @@ async function bundleCore(flowConfig, buildOptions, logger, showStats = false) {
       );
     }
     logger.gray(`Output: ${outputPath}`);
+    if (buildOptions.cache !== false) {
+      const configContent = generateCacheKeyContent(flowConfig, buildOptions);
+      const buildOutput = await fs8.readFile(outputPath, "utf-8");
+      await cacheBuild(configContent, buildOutput);
+      logger.debug("Build cached for future use");
+    }
     let stats;
     if (showStats) {
       stats = await collectBundleStats(
@@ -1113,21 +1209,30 @@ async function bundleCore(flowConfig, buildOptions, logger, showStats = false) {
         entryContent
       );
     }
+    if (buildOptions.include && buildOptions.include.length > 0) {
+      const outputDir = path8.dirname(outputPath);
+      await copyIncludes(
+        buildOptions.include,
+        buildOptions.configDir || process.cwd(),
+        outputDir,
+        logger
+      );
+    }
     if (!buildOptions.tempDir) {
-      await fs5.remove(TEMP_DIR);
+      await fs8.remove(TEMP_DIR);
       logger.debug("Cleaned up temporary files");
     }
     return stats;
   } catch (error) {
     if (!buildOptions.tempDir) {
-      await fs5.remove(TEMP_DIR).catch(() => {
+      await fs8.remove(TEMP_DIR).catch(() => {
       });
     }
     throw error;
   }
 }
 async function collectBundleStats(outputPath, packages, startTime, entryContent) {
-  const stats = await fs5.stat(outputPath);
+  const stats = await fs8.stat(outputPath);
   const totalSize = stats.size;
   const buildTime = Date.now() - startTime;
   const packageStats = Object.entries(packages).map(([name, pkg]) => {
@@ -1206,6 +1311,11 @@ function createEsbuildOptions(buildOptions, entryPath, outputPath, tempDir, pack
     ];
     const npmPackages = ["express", "express/*", "cors", "cors/*"];
     baseOptions.external = buildOptions.external ? [...nodeBuiltins, ...npmPackages, ...buildOptions.external] : [...nodeBuiltins, ...npmPackages];
+    if (buildOptions.format === "esm") {
+      baseOptions.banner = {
+        js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`
+      };
+    }
   }
   if (buildOptions.target) {
     baseOptions.target = buildOptions.target;
@@ -1400,23 +1510,23 @@ async function bundleCommand(options) {
   timer.start();
   const logger = createCommandLogger(options);
   const dockerArgs = buildCommonDockerArgs(options);
-  if (options.env) dockerArgs.push("--env", options.env);
+  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 () => {
       try {
-        if (options.env && options.all) {
-          throw new Error("Cannot use both --env and --all flags together");
+        if (options.flow && options.all) {
+          throw new Error("Cannot use both --flow and --all flags together");
         }
         logger.info("\u{1F4E6} Reading configuration...");
-        const configPath = options.config;
+        const configPath = resolveAsset(options.config, "config");
         const rawConfig = await loadJsonConfig(configPath);
-        const configsToBundle = options.all ? loadAllEnvironments(rawConfig, { configPath, logger }) : [
+        const configsToBundle = options.all ? loadAllFlows(rawConfig, { configPath, logger }) : [
           loadBundleConfig(rawConfig, {
             configPath,
-            environment: options.env,
+            flowName: options.flow,
             logger
           })
         ];
@@ -1424,16 +1534,16 @@ async function bundleCommand(options) {
         for (const {
           flowConfig,
           buildOptions,
-          environment,
-          isMultiEnvironment
+          flowName,
+          isMultiFlow
         } of configsToBundle) {
           try {
             if (options.cache !== void 0) {
               buildOptions.cache = options.cache;
             }
-            if (isMultiEnvironment || options.all) {
+            if (isMultiFlow || options.all) {
               logger.info(`
-\u{1F527} Building environment: ${environment}`);
+\u{1F527} Building flow: ${flowName}`);
             } else {
               logger.info("\u{1F527} Starting bundle process...");
             }
@@ -1445,7 +1555,7 @@ async function bundleCommand(options) {
               shouldCollectStats
             );
             results.push({
-              environment,
+              flowName,
               success: true,
               stats
             });
@@ -1455,7 +1565,7 @@ async function bundleCommand(options) {
           } catch (error) {
             const errorMessage = getErrorMessage(error);
             results.push({
-              environment,
+              flowName,
               success: false,
               error: errorMessage
             });
@@ -1471,7 +1581,7 @@ async function bundleCommand(options) {
           const outputLogger = createLogger({ silent: false, json: false });
           const output = failureCount === 0 ? createSuccessOutput(
             {
-              environments: results,
+              flows: results,
               summary: {
                 total: results.length,
                 success: successCount,
@@ -1480,7 +1590,7 @@ async function bundleCommand(options) {
             },
             duration
           ) : createErrorOutput(
-            `${failureCount} environment(s) failed to build`,
+            `${failureCount} flow(s) failed to build`,
             duration
           );
           outputLogger.log("white", JSON.stringify(output, null, 2));
@@ -1500,7 +1610,7 @@ async function bundleCommand(options) {
 \u2705 Bundle created successfully in ${timer.format()}`
             );
           } else {
-            throw new Error(`${failureCount} environment(s) failed to build`);
+            throw new Error(`${failureCount} flow(s) failed to build`);
           }
         }
       } catch (error) {
@@ -1526,12 +1636,18 @@ async function bundleCommand(options) {
 }
 async function bundle(configOrPath, options = {}) {
   let rawConfig;
+  let configPath = path9.resolve(process.cwd(), "walkeros.config.json");
   if (typeof configOrPath === "string") {
-    rawConfig = await loadJsonConfig(configOrPath);
+    configPath = resolveAsset(configOrPath, "config");
+    rawConfig = await loadJsonConfig(configPath);
   } else {
     rawConfig = configOrPath;
   }
-  const { flowConfig, buildOptions } = parseBundleConfig(rawConfig);
+  const { flowConfig, buildOptions } = loadBundleConfig(rawConfig, {
+    configPath,
+    flowName: options.flowName,
+    buildOverrides: options.buildOverrides
+  });
   if (options.cache !== void 0) {
     buildOptions.cache = options.cache;
   }
@@ -1545,8 +1661,9 @@ async function bundle(configOrPath, options = {}) {
 }
 
 // src/commands/simulate/simulator.ts
-import path7 from "path";
-import fs7 from "fs-extra";
+import path10 from "path";
+import fs10 from "fs-extra";
+import { getPlatform as getPlatform2 } from "@walkeros/core";
 
 // src/commands/simulate/tracker.ts
 var CallTracker = class {
@@ -1582,9 +1699,9 @@ var CallTracker = class {
     }
     for (const fullPath of paths) {
       const [destKey, ...pathParts] = fullPath.split(":");
-      const path11 = pathParts.join(":");
-      if (!path11) continue;
-      const cleanPath = path11.replace(/^call:/, "");
+      const path15 = pathParts.join(":");
+      if (!path15) continue;
+      const cleanPath = path15.replace(/^call:/, "");
       const parts = cleanPath.split(".");
       let current = wrapped;
       let source = env;
@@ -1628,7 +1745,7 @@ var CallTracker = class {
 
 // src/commands/simulate/jsdom-executor.ts
 import { JSDOM, VirtualConsole } from "jsdom";
-import fs6 from "fs-extra";
+import fs9 from "fs-extra";
 function buildSandboxFromEnvs(envs, destinations, tracker) {
   const baseBrowserMocks = {
     Image: class MockImage {
@@ -1697,7 +1814,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 fs6.readFile(bundlePath, "utf8");
+  const bundleCode = await fs9.readFile(bundlePath, "utf8");
   try {
     window.eval(bundleCode);
   } catch (error) {
@@ -1735,6 +1852,85 @@ async function executeInJSDOM(bundlePath, destinations, event, tracker, envs, ti
   };
 }
 
+// src/commands/simulate/node-executor.ts
+import { pathToFileURL } from "url";
+function buildGlobalMocksFromEnvs(envs, destinations, tracker) {
+  const globalMocks = {};
+  for (const [destKey] of Object.entries(destinations)) {
+    const destEnv = envs[destKey];
+    if (!destEnv?.push) continue;
+    const mockEnv = destEnv.push;
+    const trackPaths = destEnv.simulation || [];
+    const trackedEnv = tracker.wrapEnv(
+      mockEnv,
+      trackPaths.map((p) => `${destKey}:${p}`)
+    );
+    Object.assign(globalMocks, trackedEnv);
+  }
+  return globalMocks;
+}
+function injectGlobalMocks(mocks) {
+  const originalValues = {};
+  for (const [key, value] of Object.entries(mocks)) {
+    originalValues[key] = globalThis[key];
+    globalThis[key] = value;
+  }
+  return () => {
+    for (const [key, value] of Object.entries(originalValues)) {
+      if (value === void 0) {
+        delete globalThis[key];
+      } else {
+        globalThis[key] = value;
+      }
+    }
+  };
+}
+async function executeInNode(bundlePath, destinations, event, tracker, envs, timeout = 3e4) {
+  const start = Date.now();
+  const globalMocks = buildGlobalMocksFromEnvs(envs, destinations, tracker);
+  const cleanupMocks = injectGlobalMocks(globalMocks);
+  try {
+    const executeWithTimeout = async () => {
+      const importUrl = process.env.JEST_WORKER_ID ? bundlePath : `${pathToFileURL(bundlePath).href}?t=${Date.now()}`;
+      const module = await import(importUrl);
+      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") {
+        throw new Error(
+          "Factory function did not return valid result with elb"
+        );
+      }
+      const { collector, elb } = result;
+      let elbResult;
+      try {
+        elbResult = await elb(event.name, event.data);
+      } catch (error) {
+        throw new Error(`Event execution failed: ${getErrorMessage(error)}`);
+      }
+      return {
+        collector,
+        elb,
+        elbResult,
+        usage: tracker.getCalls(),
+        duration: Date.now() - start
+      };
+    };
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(
+        () => reject(new Error(`Server simulation timeout after ${timeout}ms`)),
+        timeout
+      );
+    });
+    return await Promise.race([executeWithTimeout(), timeoutPromise]);
+  } catch (error) {
+    throw new Error(`Node execution failed: ${getErrorMessage(error)}`);
+  } finally {
+    cleanupMocks();
+  }
+}
+
 // src/commands/simulate/env-loader.ts
 async function loadDestinationEnvs(destinations) {
   const envs = {};
@@ -1779,9 +1975,9 @@ async function simulateCore(configPath, event, options = {}) {
   try {
     logger.info("\u{1F3AF} Starting walkerOS simulation...");
     logger.info("\u{1F4E6} Loading bundle configuration...");
-    const fullConfigPath = path7.resolve(configPath);
+    const fullConfigPath = path10.resolve(configPath);
     const rawConfig = await loadJsonConfig(fullConfigPath);
-    parseBundleConfig(rawConfig);
+    loadBundleConfig(rawConfig, { configPath: fullConfigPath });
     logger.info(`\u{1F680} Executing simulation with event: ${JSON.stringify(event)}`);
     const result = await executeSimulation(event, fullConfigPath);
     if (result.success) {
@@ -1825,42 +2021,32 @@ async function executeSimulation(event, configPath) {
       );
     }
     const typedEvent = event;
-    await fs7.ensureDir(tempDir);
+    await fs10.ensureDir(tempDir);
     const rawConfig = await loadJsonConfig(configPath);
-    const { flowConfig, buildOptions } = parseBundleConfig(rawConfig);
-    const packagesArray = Object.entries(buildOptions.packages).map(
-      ([name, packageConfig]) => ({
-        name,
-        version: (typeof packageConfig === "object" && packageConfig !== null && "version" in packageConfig && typeof packageConfig.version === "string" ? packageConfig.version : void 0) || "latest"
-      })
-    );
-    const packagePaths = await downloadPackages(
-      packagesArray,
-      tempDir,
-      // downloadPackages will add 'node_modules' subdirectory itself
-      createLogger({ silent: true }),
-      buildOptions.cache
-    );
+    const { flowConfig, buildOptions } = loadBundleConfig(rawConfig, {
+      configPath
+    });
+    const platform = getPlatform2(flowConfig);
     const tracker = new CallTracker();
-    const tempOutput = path7.join(
+    const tempOutput = path10.join(
       tempDir,
-      `simulation-bundle-${generateId()}.js`
+      `simulation-bundle-${generateId()}.${platform === "web" ? "js" : "mjs"}`
     );
     const destinations = flowConfig.destinations;
     const simulationBuildOptions = {
       ...buildOptions,
       code: buildOptions.code || "",
-      // No code modification - use original
       output: tempOutput,
       tempDir,
-      // Use same temp dir for bundle
-      format: "iife",
-      // ← Test actual production format!
-      platform: "browser",
-      // ← Browser platform for IIFE
-      windowCollector: "collector",
-      // ← Ensure window assignment
-      windowElb: "elb"
+      ...platform === "web" ? {
+        format: "iife",
+        platform: "browser",
+        windowCollector: "collector",
+        windowElb: "elb"
+      } : {
+        format: "esm",
+        platform: "node"
+      }
     };
     await bundleCore(
       flowConfig,
@@ -1870,16 +2056,26 @@ async function executeSimulation(event, configPath) {
     );
     bundlePath = tempOutput;
     const envs = await loadDestinationEnvs(destinations || {});
-    const result = await executeInJSDOM(
-      tempOutput,
-      destinations || {},
-      typedEvent,
-      tracker,
-      envs,
-      // Pass dynamically loaded envs
-      1e4
-      // 10s timeout
-    );
+    let result;
+    if (platform === "web") {
+      result = await executeInJSDOM(
+        tempOutput,
+        destinations || {},
+        typedEvent,
+        tracker,
+        envs,
+        1e4
+      );
+    } else {
+      result = await executeInNode(
+        tempOutput,
+        destinations || {},
+        typedEvent,
+        tracker,
+        envs,
+        3e4
+      );
+    }
     const elbResult = result.elbResult;
     const usage = result.usage;
     const duration = Date.now() - startTime;
@@ -1899,7 +2095,7 @@ async function executeSimulation(event, configPath) {
     };
   } finally {
     if (tempDir) {
-      await fs7.remove(tempDir).catch(() => {
+      await fs10.remove(tempDir).catch(() => {
       });
     }
   }
@@ -1975,15 +2171,16 @@ async function simulate(configOrPath, event, options = {}) {
 }
 
 // src/commands/push/index.ts
-import path8 from "path";
-import os2 from "os";
+import path11 from "path";
 import { JSDOM as JSDOM2, VirtualConsole as VirtualConsole2 } from "jsdom";
-import fs8 from "fs-extra";
+import fs11 from "fs-extra";
+import { getPlatform as getPlatform3 } from "@walkeros/core";
+import { schemas as schemas2 } from "@walkeros/core/dev";
 async function pushCommand(options) {
   const logger = createCommandLogger(options);
   const dockerArgs = buildCommonDockerArgs(options);
   dockerArgs.push("--event", options.event);
-  if (options.env) dockerArgs.push("--env", options.env);
+  if (options.flow) dockerArgs.push("--flow", options.flow);
   await executeCommand(
     async () => {
       const startTime = Date.now();
@@ -1992,57 +2189,65 @@ async function pushCommand(options) {
         const event = await loadJsonFromSource(options.event, {
           name: "event"
         });
-        if (!event || typeof event !== "object" || !("name" in event) || typeof event.name !== "string") {
-          throw new Error(
-            'Event must be an object with a "name" property (string)'
-          );
+        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}`);
         }
-        if (!event.name.includes(" ")) {
+        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(" ")) {
           logger.warn(
-            `Event name "${event.name}" should follow "ENTITY ACTION" format (e.g., "page view")`
+            `Event name "${validatedEvent.name}" should follow "ENTITY ACTION" format (e.g., "page view")`
           );
         }
         logger.info("\u{1F4E6} Loading flow configuration...");
-        const configPath = path8.resolve(options.config);
+        const configPath = path11.resolve(options.config);
         const rawConfig = await loadJsonConfig(configPath);
-        const { flowConfig, buildOptions, environment, isMultiEnvironment } = loadBundleConfig(rawConfig, {
+        const { flowConfig, buildOptions, flowName, isMultiFlow } = loadBundleConfig(rawConfig, {
           configPath: options.config,
-          environment: options.env,
+          flowName: options.flow,
           logger
         });
-        const platform = flowConfig.platform;
+        const platform = getPlatform3(flowConfig);
         logger.info("\u{1F528} Bundling flow configuration...");
-        const tempPath = path8.join(
-          os2.tmpdir(),
-          `walkeros-push-${Date.now()}-${Math.random().toString(36).slice(2, 9)}.${platform === "web" ? "js" : "mjs"}`
+        const configDir = path11.dirname(configPath);
+        const tempDir = path11.join(
+          configDir,
+          ".tmp",
+          `push-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
         );
-        const configWithOutput = {
-          flow: flowConfig,
-          build: {
-            ...buildOptions,
-            output: tempPath,
-            // Web uses IIFE for browser-like execution, server uses ESM
-            format: platform === "web" ? "iife" : "esm",
-            platform: platform === "web" ? "browser" : "node",
-            ...platform === "web" && {
-              windowCollector: "collector",
-              windowElb: "elb"
-            }
+        await 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"
           }
         };
-        await bundle(configWithOutput, {
-          cache: true,
-          verbose: options.verbose,
-          silent: !options.verbose
-        });
+        await bundleCore(flowConfig, pushBuildOptions, logger, false);
         logger.debug(`Bundle created: ${tempPath}`);
         let result;
         if (platform === "web") {
           logger.info("\u{1F310} Executing in web environment (JSDOM)...");
-          result = await executeWebPush(tempPath, event, logger);
+          result = await executeWebPush(tempPath, validatedEvent, logger);
         } else if (platform === "server") {
           logger.info("\u{1F5A5}\uFE0F  Executing in server environment (Node.js)...");
-          result = await executeServerPush(tempPath, event, logger);
+          result = await executeServerPush(tempPath, validatedEvent, logger);
         } else {
           throw new Error(`Unsupported platform: ${platform}`);
         }
@@ -2083,7 +2288,7 @@ async function pushCommand(options) {
           }
         }
         try {
-          await fs8.remove(tempPath);
+          await fs11.remove(tempDir);
         } catch {
         }
       } catch (error) {
@@ -2128,7 +2333,7 @@ async function executeWebPush(bundlePath, event, logger) {
     });
     const { window } = dom;
     logger.debug("Loading bundle...");
-    const bundleCode = await fs8.readFile(bundlePath, "utf8");
+    const bundleCode = await fs11.readFile(bundlePath, "utf8");
     window.eval(bundleCode);
     logger.debug("Waiting for elb...");
     await waitForWindowProperty2(
@@ -2139,8 +2344,7 @@ async function executeWebPush(bundlePath, event, logger) {
     const windowObj = window;
     const elb = windowObj.elb;
     logger.info(`Pushing event: ${event.name}`);
-    const eventData = event.data || {};
-    const elbResult = await elb(event.name, eventData);
+    const elbResult = await elb(event.name, event.data);
     return {
       success: true,
       elbResult,
@@ -2178,8 +2382,7 @@ async function executeServerPush(bundlePath, event, logger, timeout = 6e4) {
       }
       const { elb } = result;
       logger.info(`Pushing event: ${event.name}`);
-      const eventData = event.data || {};
-      const elbResult = await elb(event.name, eventData);
+      const elbResult = await elb(event.name, event.data);
       return {
         success: true,
         elbResult,
@@ -2216,23 +2419,40 @@ function waitForWindowProperty2(window, prop, timeout = 5e3) {
 }
 
 // src/commands/run/index.ts
-import path10 from "path";
+import path13 from "path";
+
+// src/commands/run/validators.ts
+import { existsSync as existsSync2 } from "fs";
+
+// src/schemas/primitives.ts
+import { z } from "@walkeros/core/dev";
+var RunModeSchema = z.enum(["collect", "serve"]).describe("CLI run mode: collect events or serve HTTP");
+var PortSchema = z.number().int("Port must be an integer").min(1, "Port must be at least 1").max(65535, "Port must be at most 65535").describe("HTTP server port number");
+var FilePathSchema = z.string().min(1, "File path cannot be empty").describe("Path to configuration file");
+
+// src/schemas/run.ts
+import { z as z2 } from "@walkeros/core/dev";
+var RunOptionsSchema = z2.object({
+  mode: RunModeSchema,
+  flow: FilePathSchema,
+  port: PortSchema.default(8080),
+  flowName: z2.string().optional().describe("Specific flow name to run")
+});
 
 // src/commands/run/validators.ts
-import { existsSync } from "fs";
-var VALID_MODES = ["collect", "serve"];
 function validateMode(mode) {
-  if (!VALID_MODES.includes(mode)) {
+  const result = RunModeSchema.safeParse(mode);
+  if (!result.success) {
     throw new Error(
       `Invalid mode: "${mode}"
-   Valid modes: ${VALID_MODES.join(", ")}
+   Valid modes: collect, serve
    Example: walkeros run collect ./flow.json`
     );
   }
 }
 function validateFlowFile(filePath) {
   const absolutePath = resolveAsset(filePath, "bundle");
-  if (!existsSync(absolutePath)) {
+  if (!existsSync2(absolutePath)) {
     throw new Error(
       `Flow file not found: ${filePath}
    Resolved path: ${absolutePath}
@@ -2242,7 +2462,8 @@ function validateFlowFile(filePath) {
   return absolutePath;
 }
 function validatePort(port) {
-  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+  const result = PortSchema.safeParse(port);
+  if (!result.success) {
     throw new Error(
       `Invalid port: ${port}
    Port must be an integer between 1 and 65535
@@ -2252,26 +2473,26 @@ function validatePort(port) {
 }
 
 // src/commands/run/utils.ts
-import path9 from "path";
-import os3 from "os";
+import path12 from "path";
+import fs12 from "fs-extra";
 async function prepareBundleForRun(configPath, options) {
-  const rawConfig = await loadJsonConfig(configPath);
-  const tempPath = path9.join(
-    os3.tmpdir(),
-    `walkeros-${Date.now()}-${Math.random().toString(36).slice(2, 9)}.mjs`
+  const configDir = path12.dirname(path12.resolve(configPath));
+  const tempDir = path12.join(
+    configDir,
+    ".tmp",
+    `run-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
   );
-  const existingBuild = typeof rawConfig === "object" && rawConfig !== null && "build" in rawConfig && typeof rawConfig.build === "object" ? rawConfig.build : {};
-  const configWithOutput = {
-    ...rawConfig,
-    build: {
-      ...existingBuild,
-      output: tempPath
-    }
-  };
-  await bundle(configWithOutput, {
+  await fs12.ensureDir(tempDir);
+  const tempPath = path12.join(tempDir, "bundle.mjs");
+  await bundle(configPath, {
     cache: true,
     verbose: options.verbose,
-    silent: options.silent
+    silent: options.silent,
+    buildOverrides: {
+      output: tempPath,
+      format: "esm",
+      platform: "node"
+    }
   });
   return tempPath;
 }
@@ -2325,9 +2546,9 @@ async function runCommand(mode, options) {
     let flowPath = null;
     if (mode === "collect") {
       if (isPreBuilt) {
-        flowPath = path10.resolve(configPath);
+        flowPath = path13.resolve(configPath);
         if (!options.json && !options.silent) {
-          logger.info(`\u{1F4E6} Using pre-built flow: ${path10.basename(flowPath)}`);
+          logger.info(`\u{1F4E6} Using pre-built flow: ${path13.basename(flowPath)}`);
         }
       } else {
         if (!options.json && !options.silent) {
@@ -2416,7 +2637,7 @@ async function run(mode, options) {
     const isPreBuilt = isPreBuiltConfig(flowFile);
     let flowPath;
     if (isPreBuilt) {
-      flowPath = path10.resolve(flowFile);
+      flowPath = path13.resolve(flowFile);
     } else {
       flowPath = await prepareBundleForRun(flowFile, {
         verbose: options.verbose,
@@ -2444,22 +2665,53 @@ 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) => {
+    if (options.packages) {
+      await fs13.remove(path14.join(CACHE_DIR, "packages"));
+      console.log("Package cache cleared");
+    } else if (options.builds) {
+      await fs13.remove(path14.join(CACHE_DIR, "builds"));
+      console.log("Build cache cleared");
+    } else {
+      await fs13.remove(CACHE_DIR);
+      console.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");
+    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}`);
+  });
+}
+async function countEntries(dir) {
+  if (!await fs13.pathExists(dir)) return 0;
+  const entries = await fs13.readdir(dir);
+  return entries.length;
+}
+
 // src/index.ts
-var __filename = fileURLToPath3(import.meta.url);
+var __filename = fileURLToPath2(import.meta.url);
 var __dirname = dirname(__filename);
 var packageJson = JSON.parse(
-  readFileSync2(join(__dirname, "../package.json"), "utf-8")
+  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.command("bundle [file]").description("Bundle NPM packages with custom code").option(
-  "-e, --env <name>",
-  "environment to build (for multi-environment configs)"
-).option("--all", "build all environments (for multi-environment 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("--local", "execute in local Node.js instead of Docker").option("--dry-run", "preview command without executing").option("--silent", "suppress output").action(async (file, options) => {
   await bundleCommand({
     config: file || "bundle.config.json",
-    env: options.env,
+    flow: options.flow,
     all: options.all,
     stats: options.stats,
     json: options.json,
@@ -2487,11 +2739,11 @@ 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("--env <name>", "Environment name (for multi-environment configs)").option("--json", "Output results as JSON").option("-v, --verbose", "Verbose output").option("-s, --silent", "Suppress output").option("--local", "Execute in local Node.js instead of Docker").action(async (file, options) => {
+).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) => {
   await pushCommand({
     config: file || "bundle.config.json",
     event: options.event,
-    env: options.env,
+    flow: options.flow,
     json: options.json,
     verbose: options.verbose,
     silent: options.silent,
@@ -2529,6 +2781,7 @@ runCmd.command("serve [file]").description(
     silent: options.silent
   });
 });
+registerCacheCommand(program);
 program.parse();
 export {
   bundle,