@walkeros/cli 0.3.1

package/dist/index.js

@@ -0,0 +1,1940 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/bundle/index.ts
+import path6 from "path";
+
+// src/core/logger.ts
+import chalk from "chalk";
+function createLogger(options = {}) {
+  const { verbose = false, silent = false, json = false } = options;
+  const shouldLog = !silent && !json;
+  const shouldDebug = verbose && !silent && !json;
+  return {
+    log: (color, ...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);
+      }
+    },
+    info: (...args) => {
+      if (shouldLog) {
+        const message = args.map((arg) => String(arg)).join(" ");
+        console.log(chalk.blue(message));
+      }
+    },
+    success: (...args) => {
+      if (shouldLog) {
+        const message = args.map((arg) => String(arg)).join(" ");
+        console.log(chalk.green(message));
+      }
+    },
+    warning: (...args) => {
+      if (shouldLog) {
+        const message = args.map((arg) => String(arg)).join(" ");
+        console.log(chalk.yellow(message));
+      }
+    },
+    warn: (...args) => {
+      if (shouldLog) {
+        const message = args.map((arg) => String(arg)).join(" ");
+        console.log(chalk.yellow(message));
+      }
+    },
+    error: (...args) => {
+      if (!json) {
+        const message = args.map((arg) => String(arg)).join(" ");
+        console.error(chalk.red(message));
+      }
+    },
+    debug: (...args) => {
+      if (shouldDebug) {
+        const message = args.map((arg) => String(arg)).join(" ");
+        console.log(chalk.gray(message));
+      }
+    },
+    gray: (...args) => {
+      if (shouldLog) {
+        const message = args.map((arg) => String(arg)).join(" ");
+        console.log(chalk.gray(message));
+      }
+    }
+  };
+}
+
+// src/core/timer.ts
+function createTimer() {
+  let startTime = 0;
+  let endTime = 0;
+  return {
+    start() {
+      startTime = Date.now();
+      endTime = 0;
+    },
+    end() {
+      endTime = Date.now();
+      return endTime - startTime;
+    },
+    getElapsed() {
+      const currentTime = endTime || Date.now();
+      return currentTime - startTime;
+    },
+    format() {
+      const elapsed = this.getElapsed();
+      return (elapsed / 1e3).toFixed(2) + "s";
+    }
+  };
+}
+
+// src/core/output.ts
+function createJsonOutput(success, data, error, duration) {
+  return {
+    success,
+    ...data && { data },
+    ...error && { error },
+    ...duration && { duration }
+  };
+}
+function createSuccessOutput(data, duration) {
+  return createJsonOutput(true, data, void 0, duration);
+}
+function createErrorOutput(error, duration) {
+  return createJsonOutput(false, void 0, error, duration);
+}
+function formatBytes(bytes) {
+  return (bytes / 1024).toFixed(2);
+}
+
+// src/core/docker.ts
+import { spawn } from "child_process";
+var DOCKER_IMAGE = process.env.WALKEROS_DOCKER_IMAGE || "walkeros/cli:latest";
+function buildDockerCommand(command, args, options = {}) {
+  const cwd = process.cwd();
+  const cmd = [
+    "docker",
+    "run",
+    "--rm",
+    // Mount current directory
+    "-v",
+    `${cwd}:/workspace`,
+    "-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(DOCKER_IMAGE);
+  cmd.push(command, ...args);
+  return cmd;
+}
+async function executeInDocker(command, args, options = {}) {
+  const dockerCmd = buildDockerCommand(command, args, options);
+  return new Promise((resolve2, 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) {
+        resolve2();
+      } else {
+        reject(new Error(`Docker command exited with code ${code}`));
+      }
+    });
+  });
+}
+async function isDockerAvailable() {
+  return new Promise((resolve2) => {
+    const proc = spawn("docker", ["--version"], {
+      stdio: "ignore"
+    });
+    proc.on("error", () => resolve2(false));
+    proc.on("exit", (code) => resolve2(code === 0));
+  });
+}
+
+// src/core/execution.ts
+function getExecutionMode(options) {
+  return options.local ? "local" : "docker";
+}
+async function executeCommand(localHandler, dockerCommand, dockerArgs, options, logger) {
+  const mode = getExecutionMode(options);
+  if (options.dryRun) {
+    if (mode === "docker") {
+      const cmd = `docker run walkeros/cli:latest ${dockerCommand} ${dockerArgs.join(" ")}`;
+      logger?.info(`[DRY-RUN] Would execute: ${cmd}`);
+    } else {
+      logger?.info(
+        `[DRY-RUN] Would execute locally: ${dockerCommand} ${dockerArgs.join(" ")}`
+      );
+    }
+    return;
+  }
+  if (mode === "local") {
+    if (logger && !options.silent) {
+      logger.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 (logger && !options.silent) {
+      logger.info("\u{1F433} Executing in Docker container...");
+    }
+    await executeInDocker(dockerCommand, dockerArgs, options);
+  }
+}
+
+// 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 && validatePlatform(data.flow.platform);
+}
+
+// src/config/utils.ts
+import fs from "fs-extra";
+import path from "path";
+async function loadJsonConfig(configPath) {
+  const absolutePath = path.resolve(configPath);
+  if (!await fs.pathExists(absolutePath)) {
+    throw new Error(`Configuration file not found: ${absolutePath}`);
+  }
+  try {
+    const rawConfig = await fs.readJson(absolutePath);
+    return rawConfig;
+  } catch (error) {
+    throw new Error(
+      `Invalid JSON in config file: ${configPath}. ${error instanceof Error ? error.message : error}`
+    );
+  }
+}
+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}`);
+}
+
+// src/config/defaults.ts
+function getDefaultBuildOptions(platform, code, output) {
+  const common = {
+    code,
+    packages: {},
+    minify: false,
+    sourcemap: false,
+    cache: true
+  };
+  if (platform === "web") {
+    return {
+      ...common,
+      platform: "browser",
+      format: "iife",
+      target: "es2020",
+      output: output || "./dist/walker.js",
+      globalName: "walkerOS"
+    };
+  }
+  return {
+    ...common,
+    platform: "node",
+    format: "esm",
+    target: "node18",
+    output: output || "./dist/bundle.js"
+  };
+}
+function ensureBuildOptions(buildOptions, flowPlatform) {
+  const defaults = getDefaultBuildOptions(
+    flowPlatform,
+    buildOptions.code || "",
+    buildOptions.output
+  );
+  if (!buildOptions.code && !defaults.code) {
+    throw new Error("BuildOptions.code is required");
+  }
+  if (!buildOptions.output && !defaults.output) {
+    throw new Error("BuildOptions.output is required");
+  }
+  return {
+    ...defaults,
+    ...buildOptions,
+    code: buildOptions.code || defaults.code,
+    output: buildOptions.output || defaults.output,
+    packages: buildOptions.packages || defaults.packages
+  };
+}
+
+// src/config/parser.ts
+import path2 from "path";
+function parseBundleConfig(data) {
+  if (!isObject(data)) {
+    throw new Error(`Invalid config: expected object, got ${typeof data}`);
+  }
+  if (!("flow" in data) || !isObject(data.flow)) {
+    throw new Error(
+      `Invalid config: missing "flow" field. Expected format: { flow: { platform: "web" | "server", ... }, build: { ... } }`
+    );
+  }
+  if (!("build" in data) || !isObject(data.build)) {
+    throw new Error(
+      `Invalid config: missing "build" field. Expected format: { flow: { platform: "web" | "server", ... }, build: { ... } }`
+    );
+  }
+  const flowData = data.flow;
+  if (!("platform" in flowData) || flowData.platform !== "web" && flowData.platform !== "server") {
+    throw new Error(
+      `Invalid config: flow.platform must be "web" or "server", got "${flowData.platform}"`
+    );
+  }
+  const buildData = data.build;
+  if ("packages" in buildData && !isObject(buildData.packages)) {
+    throw new Error(
+      `Invalid config: build.packages must be an object, got ${typeof buildData.packages}`
+    );
+  }
+  const config = data;
+  return normalizeConfigs(config, "/unknown/path");
+}
+function normalizeConfigs(config, configPath) {
+  const flowConfig = config.flow;
+  const platform = flowConfig.platform;
+  if (!validatePlatform(platform)) {
+    throw new Error(
+      `Invalid platform "${platform}". Must be "web" or "server".`
+    );
+  }
+  const buildDefaults = platform === "web" ? {
+    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 buildConfig = {
+    ...buildDefaults,
+    ...config.build
+  };
+  if (configPath && buildConfig.template && !path2.isAbsolute(buildConfig.template)) {
+    if (buildConfig.template.startsWith("./") || buildConfig.template.startsWith("../")) {
+      const configDir = path2.dirname(configPath);
+      buildConfig.template = path2.resolve(configDir, buildConfig.template);
+    }
+  }
+  const buildOptions = ensureBuildOptions(buildConfig, platform);
+  return {
+    flowConfig,
+    buildOptions
+  };
+}
+
+// src/config/loader.ts
+function loadBundleConfig(rawConfig, options) {
+  if (isMultiEnvConfig(rawConfig)) {
+    return loadMultiEnvironmentConfig(rawConfig, options);
+  }
+  if (isSingleEnvConfig(rawConfig)) {
+    return loadSingleEnvironmentConfig(rawConfig, options);
+  }
+  const configType = isObject(rawConfig) ? "platform" in rawConfig ? `invalid platform value: "${rawConfig.platform}"` : 'missing "flow" and "build" fields' : `not an object (got ${typeof rawConfig})`;
+  throw new Error(
+    `Invalid configuration format at ${options.configPath}.
+Configuration ${configType}.
+
+Expected either:
+  1. Multi-environment: { version: 1, environments: { prod: { flow: {...}, build: {...} } } }
+  2. Single-environment: { flow: { platform: "web" | "server", ... }, build: { packages: {...}, ... } }`
+  );
+}
+function loadMultiEnvironmentConfig(setup, options) {
+  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];
+  const { flowConfig, buildOptions } = normalizeConfigs(
+    envConfig,
+    options.configPath
+  );
+  if (options.logger) {
+    options.logger.info(
+      `\u{1F4E6} Using environment: ${selectedEnv} (${availableEnvironments.length} total)`
+    );
+  }
+  return {
+    flowConfig,
+    buildOptions,
+    environment: selectedEnv,
+    isMultiEnvironment: true,
+    availableEnvironments
+  };
+}
+function loadSingleEnvironmentConfig(config, options) {
+  const { flowConfig, buildOptions } = normalizeConfigs(
+    config,
+    options.configPath
+  );
+  if (options.logger && options.environment) {
+    options.logger.warn(
+      `--env flag specified but configuration is single-environment. Ignoring flag.`
+    );
+  }
+  return {
+    flowConfig,
+    buildOptions,
+    environment: "default",
+    isMultiEnvironment: false
+  };
+}
+function loadAllEnvironments(rawConfig, options) {
+  if (!isMultiEnvConfig(rawConfig)) {
+    throw new Error(
+      `--all flag requires a multi-environment configuration (Setup format).
+Your configuration appears to be single-environment.`
+    );
+  }
+  const setup = rawConfig;
+  const environments = Object.keys(setup.environments);
+  if (options.logger) {
+    options.logger.info(
+      `\u{1F4E6} Loading all ${environments.length} environments: ${environments.join(", ")}`
+    );
+  }
+  return environments.map(
+    (envName) => loadMultiEnvironmentConfig(setup, {
+      ...options,
+      environment: envName
+    })
+  );
+}
+
+// src/commands/bundle/bundler.ts
+import esbuild from "esbuild";
+import path5 from "path";
+import fs4 from "fs-extra";
+
+// src/commands/bundle/package-manager.ts
+import pacote from "pacote";
+import path3 from "path";
+import fs2 from "fs-extra";
+function getPackageDirectory(baseDir, packageName, version) {
+  return path3.join(baseDir, "node_modules", packageName);
+}
+function getCachedPackagePath(pkg, tempDir) {
+  const cacheDir = path3.join(".tmp", "cache", "packages");
+  const safeName = pkg.name.replace(/\//g, "-").replace(/@/g, "");
+  return path3.join(cacheDir, `${safeName}-${pkg.version}`);
+}
+async function isPackageCached(pkg, tempDir) {
+  const cachedPath = getCachedPackagePath(pkg, tempDir);
+  return fs2.pathExists(cachedPath);
+}
+function validateNoDuplicatePackages(packages) {
+  const packageMap = /* @__PURE__ */ new Map();
+  for (const pkg of packages) {
+    if (!packageMap.has(pkg.name)) {
+      packageMap.set(pkg.name, []);
+    }
+    packageMap.get(pkg.name).push(pkg.version);
+  }
+  const conflicts = [];
+  for (const [name, versions] of packageMap.entries()) {
+    const uniqueVersions = [...new Set(versions)];
+    if (uniqueVersions.length > 1) {
+      conflicts.push(`${name}: [${uniqueVersions.join(", ")}]`);
+    }
+  }
+  if (conflicts.length > 0) {
+    throw new Error(
+      `Version conflicts detected:
+${conflicts.map((c) => `  - ${c}`).join("\n")}
+
+Each package must use the same version across all declarations. Please update your configuration to use consistent versions.`
+    );
+  }
+}
+async function resolveDependencies(pkg, packageDir, logger, visited = /* @__PURE__ */ new Set()) {
+  const dependencies = [];
+  const pkgKey = `${pkg.name}@${pkg.version}`;
+  if (visited.has(pkgKey)) {
+    return dependencies;
+  }
+  visited.add(pkgKey);
+  try {
+    const packageJsonPath = path3.join(packageDir, "package.json");
+    if (await fs2.pathExists(packageJsonPath)) {
+      const packageJson = await fs2.readJson(packageJsonPath);
+      const deps = {
+        ...packageJson.dependencies,
+        ...packageJson.peerDependencies
+      };
+      for (const [name, versionSpec] of Object.entries(deps)) {
+        if (typeof versionSpec === "string") {
+          dependencies.push({ name, version: versionSpec });
+        }
+      }
+    }
+  } catch (error) {
+    logger.debug(`Failed to read dependencies for ${pkgKey}: ${error}`);
+  }
+  return dependencies;
+}
+async function downloadPackages(packages, targetDir, logger, useCache = true) {
+  const packagePaths = /* @__PURE__ */ new Map();
+  const downloadQueue = [...packages];
+  const processed = /* @__PURE__ */ new Set();
+  validateNoDuplicatePackages(packages);
+  await fs2.ensureDir(targetDir);
+  while (downloadQueue.length > 0) {
+    const pkg = downloadQueue.shift();
+    const pkgKey = `${pkg.name}@${pkg.version}`;
+    if (processed.has(pkgKey)) {
+      continue;
+    }
+    processed.add(pkgKey);
+    const packageSpec = `${pkg.name}@${pkg.version}`;
+    const packageDir = getPackageDirectory(targetDir, pkg.name, pkg.version);
+    const cachedPath = getCachedPackagePath(pkg, targetDir);
+    if (useCache && await isPackageCached(pkg, targetDir)) {
+      logger.debug(`Using cached ${packageSpec}...`);
+      try {
+        await fs2.ensureDir(path3.dirname(packageDir));
+        await fs2.copy(cachedPath, packageDir);
+        packagePaths.set(pkg.name, packageDir);
+        const deps = await resolveDependencies(pkg, packageDir, logger);
+        for (const dep of deps) {
+          const depKey = `${dep.name}@${dep.version}`;
+          if (!processed.has(depKey)) {
+            downloadQueue.push(dep);
+          }
+        }
+        continue;
+      } catch (error) {
+        logger.debug(
+          `Failed to use cache for ${packageSpec}, downloading fresh: ${error}`
+        );
+      }
+    }
+    logger.debug(`Downloading ${packageSpec}...`);
+    try {
+      await fs2.ensureDir(path3.dirname(packageDir));
+      const cacheDir = process.env.NPM_CACHE_DIR || path3.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
+      });
+      if (useCache) {
+        try {
+          await fs2.ensureDir(path3.dirname(cachedPath));
+          await fs2.copy(packageDir, cachedPath);
+          logger.debug(`Cached ${packageSpec} for future use`);
+        } catch (cacheError) {
+          logger.debug(`Failed to cache ${packageSpec}: ${cacheError}`);
+        }
+      }
+      packagePaths.set(pkg.name, packageDir);
+      const deps = await resolveDependencies(pkg, packageDir, logger);
+      for (const dep of deps) {
+        const depKey = `${dep.name}@${dep.version}`;
+        if (!processed.has(depKey)) {
+          downloadQueue.push(dep);
+        }
+      }
+    } catch (error) {
+      throw new Error(`Failed to download ${packageSpec}: ${error}`);
+    }
+  }
+  return packagePaths;
+}
+
+// src/commands/bundle/template-engine.ts
+import fs3 from "fs-extra";
+import path4 from "path";
+import Handlebars from "handlebars";
+
+// src/commands/bundle/serializer.ts
+function serializeToJS(value, options = {}) {
+  const { indent = 2, singleQuotes = false } = options;
+  const quote = singleQuotes ? "'" : '"';
+  function serialize(val, currentIndent = 0) {
+    if (val === null) return "null";
+    if (val === void 0) return "undefined";
+    if (typeof val === "boolean" || typeof val === "number") {
+      return String(val);
+    }
+    if (typeof val === "string") {
+      if (val.includes("=>")) {
+        const arrowPatterns = [
+          /^\s*\([^)]*\)\s*=>/,
+          // (param) => or () =>
+          /^\s*\w+\s*=>/,
+          // param =>
+          /^\s*\([^)]*\)\s*=>\s*\{/,
+          // (param) => {
+          /^\s*\w+\s*=>\s*\{/
+          // param => {
+        ];
+        if (arrowPatterns.some((pattern) => pattern.test(val))) {
+          return val;
+        }
+      }
+      return quote + val.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/"/g, '\\"') + quote;
+    }
+    if (Array.isArray(val)) {
+      if (val.length === 0) return "[]";
+      const nextIndent = currentIndent + indent;
+      const spacing = " ".repeat(nextIndent);
+      const items = val.map((item) => spacing + serialize(item, nextIndent)).join(",\n");
+      return `[
+${items}
+${" ".repeat(currentIndent)}]`;
+    }
+    if (isObject(val)) {
+      const entries = Object.entries(val);
+      if (entries.length === 0) return "{}";
+      const nextIndent = currentIndent + indent;
+      const spacing = " ".repeat(nextIndent);
+      const props = entries.map(([key, value2]) => {
+        const needsQuotes = /[^a-zA-Z0-9_$]/.test(key) || /^[0-9]/.test(key);
+        const keyStr = needsQuotes ? quote + key + quote : key;
+        return spacing + keyStr + ": " + serialize(value2, nextIndent);
+      }).join(",\n");
+      return `{
+${props}
+${" ".repeat(currentIndent)}}`;
+    }
+    return String(val);
+  }
+  return serialize(value);
+}
+function serializeConfig(config) {
+  if (!config || Object.keys(config).length === 0) {
+    return "{}";
+  }
+  return serializeToJS(config, { indent: 2, singleQuotes: true });
+}
+function processTemplateVariables(variables) {
+  const processed = { ...variables };
+  if (isObject(processed.sources)) {
+    const sourcesObj = processed.sources;
+    const processedSources = {};
+    for (const [name, source] of Object.entries(sourcesObj)) {
+      const typedSource = source;
+      const { env: _, ...sourceWithoutEnv } = typedSource;
+      processedSources[name] = {
+        ...sourceWithoutEnv,
+        config: isObject(typedSource.config) ? serializeConfig(typedSource.config) : typedSource.config,
+        // Pass through string configs unchanged
+        ...typedSource.env !== void 0 && { env: typedSource.env }
+      };
+    }
+    processed.sources = processedSources;
+  }
+  if (isObject(processed.destinations)) {
+    const destinationsObj = processed.destinations;
+    const processedDestinations = {};
+    for (const [name, dest] of Object.entries(destinationsObj)) {
+      const typedDest = dest;
+      const { env: _, ...destWithoutEnv } = typedDest;
+      processedDestinations[name] = {
+        ...destWithoutEnv,
+        config: isObject(typedDest.config) ? serializeConfig(typedDest.config) : typedDest.config,
+        ...typedDest.env !== void 0 && { env: typedDest.env }
+      };
+    }
+    processed.destinations = processedDestinations;
+  }
+  if (isObject(processed.collector)) {
+    processed.collector = serializeConfig(
+      processed.collector
+    );
+  }
+  return processed;
+}
+
+// src/commands/bundle/template-engine.ts
+var TemplateEngine = class {
+  handlebars;
+  constructor() {
+    this.handlebars = Handlebars.create();
+  }
+  /**
+   * Load template content from file path
+   */
+  async loadTemplate(templatePath) {
+    const resolvedPath = path4.resolve(templatePath);
+    if (!await fs3.pathExists(resolvedPath)) {
+      throw new Error(`Template file not found: ${resolvedPath}`);
+    }
+    return await fs3.readFile(resolvedPath, "utf-8");
+  }
+  /**
+   * Apply template with user code and variable substitution
+   */
+  applyTemplate(template, userCode, sources, destinations, collector, build) {
+    const processedVariables = processTemplateVariables({
+      sources,
+      destinations,
+      collector
+    });
+    const templateData = {
+      CODE: userCode,
+      build: build || {},
+      ...processedVariables
+    };
+    const compiledTemplate = this.handlebars.compile(template);
+    return compiledTemplate(templateData);
+  }
+  /**
+   * Process template with user code
+   */
+  async process(templatePath, userCode, sources, destinations, collector, build) {
+    const template = await this.loadTemplate(templatePath);
+    return this.applyTemplate(
+      template,
+      userCode,
+      sources,
+      destinations,
+      collector,
+      build
+    );
+  }
+};
+
+// src/commands/bundle/bundler.ts
+async function bundleCore(flowConfig, buildOptions, logger, showStats = false) {
+  const bundleStartTime = Date.now();
+  const TEMP_DIR = buildOptions.tempDir ? path5.isAbsolute(buildOptions.tempDir) ? buildOptions.tempDir : path5.resolve(buildOptions.tempDir) : getTempDir();
+  try {
+    if (!buildOptions.tempDir) {
+      await fs4.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"
+      })
+    );
+    const packagePaths = await downloadPackages(
+      packagesArray,
+      TEMP_DIR,
+      logger,
+      buildOptions.cache
+    );
+    for (const [pkgName, pkgPath] of packagePaths.entries()) {
+      if (pkgName.startsWith("@walkeros/")) {
+        const pkgJsonPath = path5.join(pkgPath, "package.json");
+        const pkgJson = await fs4.readJSON(pkgJsonPath);
+        if (!pkgJson.exports && pkgJson.module) {
+          pkgJson.exports = {
+            ".": {
+              import: pkgJson.module,
+              require: pkgJson.main
+            }
+          };
+          await fs4.writeJSON(pkgJsonPath, pkgJson, { spaces: 2 });
+        }
+      }
+    }
+    const packageJsonPath = path5.join(TEMP_DIR, "package.json");
+    await fs4.writeFile(
+      packageJsonPath,
+      JSON.stringify({ type: "module" }, null, 2)
+    );
+    logger.info("\u{1F4DD} Creating entry point...");
+    const entryContent = await createEntryPoint(
+      flowConfig,
+      buildOptions,
+      packagePaths
+    );
+    const entryPath = path5.join(TEMP_DIR, "entry.js");
+    await fs4.writeFile(entryPath, entryContent);
+    logger.info("\u26A1 Bundling with esbuild...");
+    const outputPath = path5.resolve(buildOptions.output);
+    await fs4.ensureDir(path5.dirname(outputPath));
+    const esbuildOptions = createEsbuildOptions(
+      buildOptions,
+      entryPath,
+      outputPath,
+      TEMP_DIR,
+      packagePaths,
+      logger
+    );
+    try {
+      await esbuild.build(esbuildOptions);
+    } catch (buildError) {
+      throw createBuildError(buildError, buildOptions.code);
+    }
+    logger.gray(`Output: ${outputPath}`);
+    let stats;
+    if (showStats) {
+      stats = await collectBundleStats(
+        outputPath,
+        buildOptions.packages,
+        bundleStartTime,
+        entryContent
+      );
+    }
+    if (!buildOptions.tempDir) {
+      await fs4.remove(TEMP_DIR);
+      logger.debug("Cleaned up temporary files");
+    }
+    return stats;
+  } catch (error) {
+    if (!buildOptions.tempDir) {
+      await fs4.remove(TEMP_DIR).catch(() => {
+      });
+    }
+    throw error;
+  }
+}
+async function collectBundleStats(outputPath, packages, startTime, entryContent) {
+  const stats = await fs4.stat(outputPath);
+  const totalSize = stats.size;
+  const buildTime = Date.now() - startTime;
+  const packageStats = Object.entries(packages).map(([name, pkg]) => {
+    const importPattern = new RegExp(`from\\s+['"]${name}['"]`, "g");
+    const namedImportPattern = new RegExp(
+      `import\\s+\\{[^}]*\\}\\s+from\\s+['"]${name}['"]`,
+      "g"
+    );
+    const hasImports = importPattern.test(entryContent) || namedImportPattern.test(entryContent);
+    const packagesCount = Object.keys(packages).length;
+    const estimatedSize = hasImports ? Math.floor(totalSize / packagesCount) : 0;
+    return {
+      name: `${name}@${pkg.version || "latest"}`,
+      size: estimatedSize
+    };
+  });
+  const hasWildcardImports = /import\s+\*\s+as\s+\w+\s+from/.test(entryContent);
+  const treeshakingEffective = !hasWildcardImports;
+  return {
+    totalSize,
+    packages: packageStats,
+    buildTime,
+    treeshakingEffective
+  };
+}
+function createEsbuildOptions(buildOptions, entryPath, outputPath, tempDir, packagePaths, logger) {
+  const alias = {};
+  const baseOptions = {
+    entryPoints: [entryPath],
+    bundle: true,
+    format: buildOptions.format,
+    platform: buildOptions.platform,
+    outfile: outputPath,
+    absWorkingDir: tempDir,
+    // Resolve modules from temp directory
+    // alias removed - not needed with absWorkingDir
+    mainFields: ["module", "main"],
+    // Prefer ESM over CJS
+    treeShaking: true,
+    logLevel: "error",
+    minify: buildOptions.minify,
+    sourcemap: buildOptions.sourcemap,
+    resolveExtensions: [".mjs", ".js", ".ts", ".json"],
+    // Prefer .mjs
+    // Enhanced minification options when minify is enabled
+    ...buildOptions.minify && {
+      minifyWhitespace: buildOptions.minifyOptions?.whitespace ?? true,
+      minifyIdentifiers: buildOptions.minifyOptions?.identifiers ?? true,
+      minifySyntax: buildOptions.minifyOptions?.syntax ?? true,
+      legalComments: buildOptions.minifyOptions?.legalComments ?? "none",
+      keepNames: buildOptions.minifyOptions?.keepNames ?? false,
+      charset: "utf8"
+    }
+  };
+  if (buildOptions.platform === "browser") {
+    baseOptions.define = {
+      "process.env.NODE_ENV": '"production"',
+      global: "globalThis"
+    };
+    baseOptions.external = buildOptions.external || [];
+  } else if (buildOptions.platform === "node") {
+    const nodeBuiltins = [
+      "crypto",
+      "fs",
+      "path",
+      "os",
+      "util",
+      "stream",
+      "buffer",
+      "events",
+      "http",
+      "https",
+      "url",
+      "querystring",
+      "zlib"
+    ];
+    const npmPackages = [
+      "zod",
+      "zod/*",
+      "express",
+      "express/*",
+      "cors",
+      "cors/*"
+    ];
+    baseOptions.external = buildOptions.external ? [...nodeBuiltins, ...npmPackages, ...buildOptions.external] : [...nodeBuiltins, ...npmPackages];
+  }
+  if (buildOptions.target) {
+    baseOptions.target = buildOptions.target;
+  } else if (buildOptions.platform === "node") {
+    baseOptions.target = "node18";
+  } else {
+    baseOptions.target = "es2018";
+  }
+  if (buildOptions.globalName && buildOptions.format === "iife") {
+    baseOptions.globalName = buildOptions.globalName;
+  }
+  return baseOptions;
+}
+function packageNameToVariable(packageName) {
+  return packageName.replace("@", "_").replace(/[/-]/g, "_").split("_").map(
+    (part, i) => i === 0 ? part : part.charAt(0).toUpperCase() + part.slice(1)
+  ).join("");
+}
+async function createEntryPoint(flowConfig, buildOptions, packagePaths) {
+  const importStatements = [];
+  const examplesMappings = [];
+  const destinationPackages = /* @__PURE__ */ new Set();
+  const destinations = flowConfig.destinations;
+  if (destinations) {
+    for (const [destKey, destConfig] of Object.entries(destinations)) {
+      if (typeof destConfig === "object" && destConfig !== null && "package" in destConfig && typeof destConfig.package === "string") {
+        destinationPackages.add(destConfig.package);
+      }
+    }
+  }
+  for (const [packageName, packageConfig] of Object.entries(
+    buildOptions.packages
+  )) {
+    if (packageConfig.imports && packageConfig.imports.length > 0) {
+      const uniqueImports = [...new Set(packageConfig.imports)];
+      const defaultImports = [];
+      const namedImports = [];
+      for (const imp of uniqueImports) {
+        if (imp.startsWith("default as ")) {
+          defaultImports.push(imp.replace("default as ", ""));
+        } else {
+          namedImports.push(imp);
+        }
+      }
+      if (defaultImports.length > 0) {
+        for (const defaultImport of defaultImports) {
+          importStatements.push(
+            `import ${defaultImport} from '${packageName}';`
+          );
+        }
+      }
+      if (namedImports.length > 0) {
+        const importList = namedImports.join(", ");
+        importStatements.push(
+          `import { ${importList} } from '${packageName}';`
+        );
+      }
+      const examplesImport = uniqueImports.find(
+        (imp) => imp.includes("examples as ")
+      );
+      if (examplesImport) {
+        const examplesVarName = examplesImport.split(" as ")[1];
+        const destinationMatch = packageName.match(
+          /@walkeros\/web-destination-(.+)$/
+        );
+        if (destinationMatch) {
+          const destinationName = destinationMatch[1];
+          examplesMappings.push(
+            `  ${destinationName}: typeof ${examplesVarName} !== 'undefined' ? ${examplesVarName} : undefined`
+          );
+        }
+      }
+    } else {
+      const varName = packageNameToVariable(packageName);
+      importStatements.push(
+        `import * as ${varName} from '${packageName}'; // Consider specifying explicit imports`
+      );
+    }
+    if (destinationPackages.has(packageName)) {
+      const destinationMatch = packageName.match(
+        /@walkeros\/(?:(?:web|server)-)?destination-(.+)$/
+      );
+      if (destinationMatch) {
+        const destinationName = destinationMatch[1];
+        const examplesVarName = `${destinationName.replace(/-/g, "_")}_examples`;
+        const isDemoPackage = packageName.includes("-demo");
+        if (isDemoPackage) {
+          importStatements.push(
+            `import { examples as ${examplesVarName} } from '${packageName}';`
+          );
+        } else {
+          importStatements.push(
+            `import * as ${examplesVarName} from '${packageName}/examples';`
+          );
+        }
+        examplesMappings.push(`  ${destinationName}: ${examplesVarName}`);
+      }
+    }
+  }
+  const examplesObject = examplesMappings.length > 0 ? `const examples = {
+${examplesMappings.join(",\n")}
+};
+
+` : "";
+  const importsCode = importStatements.join("\n");
+  let templatedCode;
+  if (buildOptions.template) {
+    const templateEngine = new TemplateEngine();
+    const flowWithProps = flowConfig;
+    templatedCode = await templateEngine.process(
+      buildOptions.template,
+      buildOptions.code,
+      // Pass user code as parameter
+      flowWithProps.sources || {},
+      flowWithProps.destinations || {},
+      flowWithProps.collector || {},
+      buildOptions
+      // Pass build config to template
+    );
+  } else {
+    templatedCode = buildOptions.code;
+  }
+  let wrappedCode = templatedCode;
+  const hasExport = /^\s*export\s/m.test(templatedCode);
+  if (!hasExport) {
+    if (buildOptions.format === "esm") {
+      wrappedCode = `export default ${templatedCode}`;
+    } else if (buildOptions.platform === "browser" && buildOptions.globalName) {
+      wrappedCode = `window['${buildOptions.globalName}'] = ${templatedCode}`;
+    }
+  }
+  let finalCode = importsCode ? `${importsCode}
+
+${examplesObject}${wrappedCode}` : `${examplesObject}${wrappedCode}`;
+  if (examplesObject && buildOptions.format === "esm") {
+    finalCode += `
+
+export { examples };`;
+  }
+  return finalCode;
+}
+function createBuildError(buildError, code) {
+  if (!buildError.errors || buildError.errors.length === 0) {
+    return new Error(`Build failed: ${buildError.message || buildError}`);
+  }
+  const firstError = buildError.errors[0];
+  const location = firstError.location;
+  if (location && location.file && location.file.includes("entry.js")) {
+    const line = location.line;
+    const column = location.column;
+    const codeLines = code.split("\n");
+    const errorLine = codeLines[line - 1] || "";
+    return new Error(
+      `Code syntax error at line ${line}, column ${column}:
+  ${errorLine}
+  ${" ".repeat(column - 1)}^
+${firstError.text}`
+    );
+  }
+  return new Error(
+    `Build error: ${firstError.text}
+` + (location ? `  at ${location.file}:${location.line}:${location.column}` : "")
+  );
+}
+
+// src/commands/bundle/stats.ts
+function displayStats(stats, logger) {
+  logger.info("\n\u{1F4CA} Bundle Statistics");
+  logger.info("\u2500".repeat(50));
+  const sizeKB = formatBytes(stats.totalSize);
+  logger.info(`Total Size: ${sizeKB} KB`);
+  const timeSeconds = (stats.buildTime / 1e3).toFixed(2);
+  logger.info(`Build Time: ${timeSeconds}s`);
+  const treeshakingStatus = stats.treeshakingEffective ? "\u2705 Effective" : "\u26A0\uFE0F  Not optimal (consider using named imports)";
+  logger.info(`Tree-shaking: ${treeshakingStatus}`);
+  if (stats.packages.length > 0) {
+    logger.info(`
+Package Breakdown:`);
+    stats.packages.forEach((pkg) => {
+      if (pkg.size > 0) {
+        const pkgSizeKB = formatBytes(pkg.size);
+        logger.info(`  \u2022 ${pkg.name}: ${pkgSizeKB} KB`);
+      }
+    });
+  }
+  logger.info("\u2500".repeat(50));
+}
+
+// src/commands/bundle/index.ts
+async function bundleCommand(options) {
+  const timer = createTimer();
+  timer.start();
+  const logger = createLogger({
+    verbose: options.verbose,
+    silent: options.silent ?? false,
+    json: options.json
+  });
+  const dockerArgs = [options.config];
+  if (options.env) dockerArgs.push("--env", options.env);
+  if (options.all) dockerArgs.push("--all");
+  if (options.stats) dockerArgs.push("--stats");
+  if (options.json) dockerArgs.push("--json");
+  if (options.cache === false) dockerArgs.push("--no-cache");
+  if (options.verbose) dockerArgs.push("--verbose");
+  if (options.silent) dockerArgs.push("--silent");
+  await executeCommand(
+    async () => {
+      try {
+        if (options.env && options.all) {
+          throw new Error("Cannot use both --env and --all flags together");
+        }
+        logger.info("\u{1F4E6} Reading configuration...");
+        const configPath = path6.resolve(options.config);
+        const rawConfig = await loadJsonConfig(configPath);
+        const configsToBundle = options.all ? loadAllEnvironments(rawConfig, { configPath, logger }) : [
+          loadBundleConfig(rawConfig, {
+            configPath,
+            environment: options.env,
+            logger
+          })
+        ];
+        const results = [];
+        for (const {
+          flowConfig,
+          buildOptions,
+          environment,
+          isMultiEnvironment
+        } of configsToBundle) {
+          try {
+            if (options.cache !== void 0) {
+              buildOptions.cache = options.cache;
+            }
+            if (isMultiEnvironment || options.all) {
+              logger.info(`
+\u{1F527} Building environment: ${environment}`);
+            } else {
+              logger.info("\u{1F527} Starting bundle process...");
+            }
+            const shouldCollectStats = options.stats || options.json;
+            const stats = await bundleCore(
+              flowConfig,
+              buildOptions,
+              logger,
+              shouldCollectStats
+            );
+            results.push({
+              environment,
+              success: true,
+              stats
+            });
+            if (!options.json && !options.all && options.stats && stats) {
+              displayStats(stats, logger);
+            }
+          } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            results.push({
+              environment,
+              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(
+            {
+              environments: results,
+              summary: {
+                total: results.length,
+                success: successCount,
+                failed: failureCount
+              }
+            },
+            duration
+          ) : createErrorOutput(
+            `${failureCount} environment(s) failed to build`,
+            duration
+          );
+          outputLogger.log("white", JSON.stringify(output, null, 2));
+        } else {
+          if (options.all) {
+            logger.info(`
+\u{1F4CA} Build Summary:`);
+            logger.info(`   Total: ${results.length}`);
+            logger.success(`   \u2705 Success: ${successCount}`);
+            if (failureCount > 0) {
+              logger.error(`   \u274C Failed: ${failureCount}`);
+            }
+          }
+          if (failureCount === 0) {
+            logger.success(
+              `
+\u2705 Bundle created successfully in ${timer.format()}`
+            );
+          } else {
+            throw new Error(`${failureCount} environment(s) failed to build`);
+          }
+        }
+      } catch (error) {
+        const duration = timer.getElapsed() / 1e3;
+        const errorMessage = error instanceof Error ? error.message : String(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 {
+          logger.error("\u274C Bundle failed:");
+          logger.error(errorMessage);
+        }
+        process.exit(1);
+      }
+    },
+    "bundle",
+    dockerArgs,
+    options,
+    logger
+  );
+}
+async function bundle(configOrPath, options = {}) {
+  let rawConfig;
+  if (typeof configOrPath === "string") {
+    rawConfig = await loadJsonConfig(configOrPath);
+  } else {
+    rawConfig = configOrPath;
+  }
+  const { flowConfig, buildOptions } = parseBundleConfig(rawConfig);
+  if (options.cache !== void 0) {
+    buildOptions.cache = options.cache;
+  }
+  const logger = createLogger({
+    silent: options.silent ?? false,
+    verbose: options.verbose ?? false
+  });
+  return await bundleCore(
+    flowConfig,
+    buildOptions,
+    logger,
+    options.stats ?? false
+  );
+}
+
+// src/commands/simulate/simulator.ts
+import path7 from "path";
+import fs5 from "fs-extra";
+
+// src/commands/simulate/tracker.ts
+var CallTracker = class {
+  calls = /* @__PURE__ */ new Map();
+  /**
+   * Wrap a function to track its calls
+   */
+  wrapFunction(name, fn) {
+    const self = this;
+    const targetFn = fn || (() => {
+    });
+    return new Proxy(targetFn, {
+      apply(_target, thisArg, args) {
+        self.logCall(name, args);
+        return targetFn.apply(thisArg, args);
+      }
+    });
+  }
+  /**
+   * Wrap an environment object, tracking specified paths
+   *
+   * @param env - Environment object (from destination's examples/env.ts)
+   * @param paths - Paths to track (e.g., ['gtag:window.gtag', 'gtag:window.dataLayer.push'])
+   */
+  wrapEnv(env, paths) {
+    const wrapped = {};
+    for (const [key, value] of Object.entries(env)) {
+      if (typeof value === "object" && value !== null) {
+        wrapped[key] = Array.isArray(value) ? [...value] : { ...value };
+      } else {
+        wrapped[key] = value;
+      }
+    }
+    for (const fullPath of paths) {
+      const [destKey, ...pathParts] = fullPath.split(":");
+      const path9 = pathParts.join(":");
+      if (!path9) continue;
+      const cleanPath = path9.replace(/^call:/, "");
+      const parts = cleanPath.split(".");
+      let current = wrapped;
+      let source = env;
+      for (let i = 0; i < parts.length - 1; i++) {
+        const part = parts[i];
+        if (!current[part]) {
+          current[part] = {};
+        }
+        current = current[part];
+        source = source && typeof source[part] === "object" && source[part] !== null ? source[part] : void 0;
+      }
+      const finalKey = parts[parts.length - 1];
+      const originalFn = source?.[finalKey];
+      current[finalKey] = this.wrapFunction(
+        `${destKey}:${cleanPath}`,
+        typeof originalFn === "function" ? originalFn : void 0
+      );
+    }
+    return wrapped;
+  }
+  logCall(fullPath, args) {
+    const [destKey, ...pathParts] = fullPath.split(":");
+    const apiPath = pathParts.join(":");
+    if (!this.calls.has(destKey)) {
+      this.calls.set(destKey, []);
+    }
+    this.calls.get(destKey).push({
+      type: "call",
+      path: apiPath,
+      args,
+      timestamp: Date.now()
+    });
+  }
+  getCalls() {
+    return Object.fromEntries(this.calls);
+  }
+  reset() {
+    this.calls.clear();
+  }
+};
+
+// src/commands/simulate/simulator.ts
+function generateId() {
+  return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+}
+async function simulateCore(configPath, event, options = {}) {
+  const logger = createLogger({
+    verbose: options.verbose || false,
+    silent: options.silent || false,
+    json: options.json || false
+  });
+  try {
+    logger.info("\u{1F3AF} Starting walkerOS simulation...");
+    logger.info("\u{1F4E6} Loading bundle configuration...");
+    const fullConfigPath = path7.resolve(configPath);
+    const rawConfig = await loadJsonConfig(fullConfigPath);
+    parseBundleConfig(rawConfig);
+    logger.info(`\u{1F680} Executing simulation with event: ${JSON.stringify(event)}`);
+    const result = await executeSimulation(event, fullConfigPath);
+    if (result.success) {
+      logger.info(`\u2705 Simulation completed successfully`);
+    } else {
+      logger.error(`\u274C Simulation failed: ${result.error}`);
+    }
+    return result;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger.error(`\u{1F4A5} Simulation error: ${errorMessage}`);
+    return {
+      success: false,
+      error: errorMessage
+    };
+  }
+}
+function parseEventInput(eventString = "") {
+  if (!eventString) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(eventString);
+    return isObject(parsed) ? parsed : {};
+  } catch {
+    return { name: eventString };
+  }
+}
+function formatSimulationResult(result, options = {}) {
+  if (options.json) {
+    const output = {
+      result: result.elbResult,
+      usage: result.usage,
+      duration: result.duration
+    };
+    return JSON.stringify(output, null, 2);
+  }
+  if (result.success) {
+    return "\u2705 Simulation completed successfully";
+  } else {
+    return `\u274C Simulation failed: ${result.error}`;
+  }
+}
+async function executeSimulation(event, configPath) {
+  const startTime = Date.now();
+  let bundlePath;
+  const tempDir = getTempDir();
+  try {
+    await fs5.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 tracker = new CallTracker();
+    const envSetupCode = [];
+    const destinations = flowConfig.destinations;
+    if (destinations) {
+      for (const [key, dest] of Object.entries(destinations)) {
+        const destName = key.replace(/-/g, "_");
+        envSetupCode.push(`
+  // Inject tracked env for destination '${key}' using examples from bundle
+  if (examples && examples['${key}'] && examples['${key}'].env) {
+    const mockEnv = examples['${key}'].env.push;
+    const trackPaths = examples['${key}'].env.simulation || [];
+    if (mockEnv) {
+      const wrappedPaths = trackPaths.map((p) => '${key}:' + p);
+      const trackedEnv = __simulationTracker.wrapEnv(mockEnv, wrappedPaths);
+      if (config.destinations && config.destinations['${key}']) {
+        config.destinations['${key}'].env = trackedEnv;
+      }
+    }
+  }
+`);
+      }
+    }
+    const modifiedCode = `
+// Inject tracked envs into destination configs
+${envSetupCode.join("\n")}
+
+${buildOptions.code || ""}
+`;
+    const tempOutput = path7.join(
+      tempDir,
+      `simulation-bundle-${generateId()}.mjs`
+    );
+    const simulationBuildOptions = {
+      ...buildOptions,
+      code: modifiedCode,
+      output: tempOutput,
+      tempDir,
+      // Use same temp dir for bundle
+      format: "esm",
+      // Force node platform for simulation since we're running in Node.js
+      platform: "node"
+    };
+    await bundleCore(
+      flowConfig,
+      simulationBuildOptions,
+      createLogger({ silent: true }),
+      false
+    );
+    bundlePath = tempOutput;
+    const globalWithSim = globalThis;
+    if (!globalWithSim.window) {
+      globalWithSim.window = {};
+    }
+    if (!globalWithSim.document) {
+      globalWithSim.document = {};
+    }
+    const timestamp = Date.now();
+    const moduleUrl = `file://${bundlePath}?t=${timestamp}`;
+    const module = await import(moduleUrl);
+    const importedExamples = module.examples;
+    const destinations2 = flowConfig.destinations;
+    if (importedExamples && destinations2) {
+      for (const [key, dest] of Object.entries(destinations2)) {
+        const destEnv = importedExamples[key]?.env?.push;
+        if (destEnv) {
+          if (destEnv.window && typeof globalWithSim.window === "object" && globalWithSim.window !== null) {
+            Object.assign(globalWithSim.window, destEnv.window);
+          }
+          if (destEnv.document && typeof globalWithSim.document === "object" && globalWithSim.document !== null) {
+            Object.assign(globalWithSim.document, destEnv.document);
+          }
+        }
+      }
+    }
+    const flowResult = await module.default({ tracker });
+    if (!flowResult || typeof flowResult.elb !== "function") {
+      throw new Error(
+        "Bundle did not export valid flow object with elb function"
+      );
+    }
+    const { elb } = flowResult;
+    const elbResult = await elb(event);
+    const usage = tracker.getCalls();
+    const duration = Date.now() - startTime;
+    return {
+      success: true,
+      elbResult,
+      usage,
+      duration,
+      logs: []
+    };
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+      duration
+    };
+  } finally {
+    if (tempDir) {
+      await fs5.remove(tempDir).catch(() => {
+      });
+    }
+    const globalWithSim = globalThis;
+    delete globalWithSim.window;
+    delete globalWithSim.document;
+  }
+}
+
+// src/commands/simulate/index.ts
+async function simulateCommand(options) {
+  const logger = createLogger({
+    verbose: options.verbose,
+    silent: options.silent ?? false,
+    json: options.json
+  });
+  const dockerArgs = [options.config];
+  if (options.event) dockerArgs.push("--event", options.event);
+  if (options.json) dockerArgs.push("--json");
+  if (options.verbose) dockerArgs.push("--verbose");
+  if (options.silent) dockerArgs.push("--silent");
+  await executeCommand(
+    async () => {
+      const startTime = Date.now();
+      try {
+        const event = parseEventInput(options.event);
+        const 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 = error instanceof Error ? error.message : String(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,
+    logger
+  );
+}
+async function simulate(configOrPath, event, options = {}) {
+  if (typeof configOrPath !== "string") {
+    throw new Error(
+      "simulate() currently only supports config file paths. Config object support will be added in a future version. Please provide a path to a configuration file."
+    );
+  }
+  return await simulateCore(configOrPath, event, {
+    json: options.json ?? false,
+    verbose: options.verbose ?? false
+  });
+}
+
+// src/commands/run/index.ts
+import path8 from "path";
+import os from "os";
+import {
+  runFlow,
+  runServeMode
+} from "@walkeros/docker";
+
+// src/commands/run/validators.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+var VALID_MODES = ["collect", "serve"];
+function validateMode(mode) {
+  if (!VALID_MODES.includes(mode)) {
+    throw new Error(
+      `Invalid mode: "${mode}"
+   Valid modes: ${VALID_MODES.join(", ")}
+   Example: walkeros run collect ./flow.json`
+    );
+  }
+}
+function validateFlowFile(filePath) {
+  const absolutePath = resolve(filePath);
+  if (!existsSync(absolutePath)) {
+    throw new Error(
+      `Flow file not found: ${filePath}
+   Resolved path: ${absolutePath}
+   Make sure the file exists and the path is correct`
+    );
+  }
+  return absolutePath;
+}
+function validatePort(port) {
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(
+      `Invalid port: ${port}
+   Port must be an integer between 1 and 65535
+   Example: --port 8080`
+    );
+  }
+}
+
+// src/commands/run/index.ts
+async function runCommand(mode, options) {
+  const timer = createTimer();
+  timer.start();
+  const logger = createLogger({
+    verbose: options.verbose,
+    silent: options.silent ?? false,
+    json: options.json
+  });
+  const dockerArgs = [mode, options.config];
+  if (options.port !== void 0)
+    dockerArgs.push("--port", String(options.port));
+  if (options.host) dockerArgs.push("--host", options.host);
+  if (options.staticDir) dockerArgs.push("--static-dir", options.staticDir);
+  if (options.json) dockerArgs.push("--json");
+  if (options.verbose) dockerArgs.push("--verbose");
+  if (options.silent) dockerArgs.push("--silent");
+  await executeCommand(
+    async () => {
+      try {
+        validateMode(mode);
+        const configPath = validateFlowFile(options.config);
+        if (options.port !== void 0) {
+          validatePort(options.port);
+        }
+        const isPreBuilt = configPath.endsWith(".mjs") || configPath.endsWith(".js") || configPath.endsWith(".cjs");
+        let flowPath;
+        if (isPreBuilt) {
+          flowPath = path8.resolve(configPath);
+          if (!options.json) {
+            logger.info(`\u{1F4E6} Using pre-built flow: ${path8.basename(flowPath)}`);
+          }
+        } else {
+          if (!options.json) {
+            logger.info("\u{1F528} Building flow bundle...");
+          }
+          const rawConfig = await loadJsonConfig(configPath);
+          const tempPath = path8.join(
+            os.tmpdir(),
+            `walkeros-${Date.now()}-${Math.random().toString(36).slice(2, 9)}.mjs`
+          );
+          const existingBuild = typeof rawConfig === "object" && rawConfig !== null && "build" in rawConfig && typeof rawConfig.build === "object" ? rawConfig.build : {};
+          const configWithOutput = {
+            ...rawConfig,
+            build: {
+              ...existingBuild,
+              output: tempPath
+            }
+          };
+          await bundle(configWithOutput, {
+            cache: true,
+            verbose: options.verbose,
+            silent: options.json
+          });
+          flowPath = tempPath;
+          if (!options.json) {
+            logger.success("\u2705 Bundle ready");
+          }
+        }
+        if (!options.json) {
+          const modeLabel = mode === "collect" ? "Collector" : "Server";
+          logger.info(`\u{1F680} Starting ${modeLabel}...`);
+        }
+        switch (mode) {
+          case "collect": {
+            const config = {
+              port: options.port,
+              host: options.host
+            };
+            await runFlow(flowPath, config);
+            break;
+          }
+          case "serve": {
+            const config = {
+              port: options.port,
+              host: options.host,
+              staticDir: options.staticDir
+            };
+            await runServeMode(config);
+            break;
+          }
+          default:
+            throw new Error(`Unknown mode: ${mode}`);
+        }
+      } catch (error) {
+        const duration = timer.getElapsed() / 1e3;
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (options.json) {
+          const output = {
+            success: false,
+            mode,
+            error: errorMessage,
+            duration
+          };
+          console.log(JSON.stringify(output, null, 2));
+        } else {
+          logger.error("\u274C Run failed:");
+          logger.error(errorMessage);
+        }
+        process.exit(1);
+      }
+    },
+    "run",
+    dockerArgs,
+    options,
+    logger
+  );
+}
+async function run(mode, options) {
+  const startTime = Date.now();
+  try {
+    validateMode(mode);
+    let flowFile;
+    if (typeof options.config === "string") {
+      flowFile = validateFlowFile(options.config);
+    } else {
+      throw new Error("Programmatic run() requires config file path");
+    }
+    if (options.port !== void 0) {
+      validatePort(options.port);
+    }
+    const isPreBuilt = flowFile.endsWith(".mjs") || flowFile.endsWith(".js") || flowFile.endsWith(".cjs");
+    let flowPath;
+    if (isPreBuilt) {
+      flowPath = path8.resolve(flowFile);
+    } else {
+      const rawConfig = await loadJsonConfig(flowFile);
+      const tempPath = path8.join(
+        os.tmpdir(),
+        `walkeros-${Date.now()}-${Math.random().toString(36).slice(2, 9)}.mjs`
+      );
+      const existingBuild = typeof rawConfig === "object" && rawConfig !== null && "build" in rawConfig && typeof rawConfig.build === "object" ? rawConfig.build : {};
+      const configWithOutput = {
+        ...rawConfig,
+        build: {
+          ...existingBuild,
+          output: tempPath
+        }
+      };
+      await bundle(configWithOutput, {
+        cache: true,
+        verbose: options.verbose,
+        silent: true
+      });
+      flowPath = tempPath;
+    }
+    switch (mode) {
+      case "collect": {
+        const config = {
+          port: options.port,
+          host: options.host
+        };
+        await runFlow(flowPath, config);
+        break;
+      }
+      case "serve": {
+        const config = {
+          port: options.port,
+          host: options.host,
+          staticDir: options.staticDir
+        };
+        await runServeMode(config);
+        break;
+      }
+      default:
+        throw new Error(`Unknown mode: ${mode}`);
+    }
+    return {
+      success: true,
+      exitCode: 0,
+      duration: Date.now() - startTime
+    };
+  } catch (error) {
+    return {
+      success: false,
+      exitCode: 1,
+      duration: Date.now() - startTime,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+// src/index.ts
+import { fileURLToPath } from "url";
+var program = new Command();
+program.name("walkeros").description("walkerOS CLI - Bundle and deploy walkerOS components").version("0.1.0");
+program.command("bundle").description("Bundle NPM packages with custom code").option(
+  "-c, --config <path>",
+  "configuration file path",
+  "bundle.config.json"
+).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 (options) => {
+  await bundleCommand({
+    config: options.config,
+    env: options.env,
+    all: options.all,
+    stats: options.stats,
+    json: options.json,
+    cache: options.cache,
+    verbose: options.verbose,
+    local: options.local,
+    dryRun: options.dryRun,
+    silent: options.silent
+  });
+});
+program.command("simulate").description("Simulate event processing and capture API calls").option(
+  "-c, --config <path>",
+  "Bundle configuration file",
+  "bundle.config.json"
+).option("-e, --event <json>", "Event to simulate (JSON string)").option("--json", "Output results as JSON").option("-v, --verbose", "Verbose output").option("--local", "execute in local Node.js instead of Docker").option("--dry-run", "preview command without executing").option("--silent", "suppress output").action(async (options) => {
+  await simulateCommand({
+    config: options.config,
+    event: options.event,
+    json: options.json,
+    verbose: options.verbose,
+    local: options.local,
+    dryRun: options.dryRun,
+    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)").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) => {
+  await runCommand("collect", {
+    config: file,
+    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 (static file server for browser bundles)").option("-p, --port <number>", "Port to listen on (default: 8080)", parseInt).option("-h, --host <address>", "Host address (default: 0.0.0.0)").option("--static-dir <dir>", "Static directory for serve mode").option("--json", "Output results as JSON").option("-v, --verbose", "Verbose output").option("--local", "execute in local Node.js instead of Docker").option("--dry-run", "preview command without executing").option("--silent", "suppress output").action(async (file, options) => {
+  await runCommand("serve", {
+    config: file,
+    port: options.port,
+    host: options.host,
+    staticDir: options.staticDir,
+    json: options.json,
+    verbose: options.verbose,
+    local: options.local,
+    dryRun: options.dryRun,
+    silent: options.silent
+  });
+});
+var isMainModule = process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1];
+if (isMainModule) {
+  program.parse();
+}
+export {
+  bundle,
+  bundleCommand,
+  run,
+  runCommand,
+  simulate,
+  simulateCommand
+};
+//# sourceMappingURL=index.js.map