@walkeros/cli 0.3.5 → 0.4.0

package/dist/index.js

@@ -1,2026 +1,132 @@
-#!/usr/bin/env node
-
-// src/index.ts
-import { Command } from "commander";
-
-// src/commands/bundle/index.ts
-import path7 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";
-import path from "path";
-var CLI_DOCKER_IMAGE = process.env.WALKEROS_CLI_DOCKER_IMAGE || "walkeros/cli:latest";
-var RUNTIME_DOCKER_IMAGE = process.env.WALKEROS_RUNTIME_DOCKER_IMAGE || "walkeros/docker:latest";
-function buildDockerCommand(command, args, options = {}, configFile) {
-  const cwd = process.cwd();
-  const cmd = ["docker", "run", "--rm"];
-  if (configFile) {
-    const configPath = path.resolve(cwd, configFile);
-    cmd.push("-v", `${configPath}:/config/flow.json:ro`);
-    args = args.map((arg) => arg === configFile ? "/config/flow.json" : arg);
-  }
-  cmd.push("-v", `${cwd}:/workspace`);
-  cmd.push("-w", "/workspace");
-  if (process.platform !== "win32") {
-    try {
-      const uid = process.getuid?.();
-      const gid = process.getgid?.();
-      if (uid !== void 0 && gid !== void 0) {
-        cmd.push("--user", `${uid}:${gid}`);
-      }
-    } catch {
-    }
-  }
-  if (options.verbose) {
-    cmd.push("-e", "VERBOSE=true");
-  }
-  if (options.silent) {
-    cmd.push("-e", "SILENT=true");
-  }
-  cmd.push(CLI_DOCKER_IMAGE);
-  cmd.push(command, ...args);
-  return cmd;
-}
-async function executeInDocker(command, args, options = {}, configFile) {
-  const containerArgs = [...args, "--local"];
-  const dockerCmd = buildDockerCommand(
-    command,
-    containerArgs,
-    options,
-    configFile
-  );
-  return new Promise((resolve, reject) => {
-    const proc = spawn(dockerCmd[0], dockerCmd.slice(1), {
-      stdio: options.silent ? "ignore" : "inherit",
-      shell: false
-    });
-    proc.on("error", (error) => {
-      reject(new Error(`Docker execution failed: ${error.message}`));
-    });
-    proc.on("exit", (code) => {
-      if (code === 0) {
-        resolve();
-      } else {
-        reject(new Error(`Docker command exited with code ${code}`));
-      }
-    });
-  });
-}
-async function isDockerAvailable() {
-  return new Promise((resolve) => {
-    const proc = spawn("docker", ["--version"], {
-      stdio: "ignore"
-    });
-    proc.on("error", () => resolve(false));
-    proc.on("exit", (code) => resolve(code === 0));
-  });
-}
-function buildDockerRunCommand(mode, flowPath, options = {}) {
-  const cwd = process.cwd();
-  const cmd = ["docker", "run", "--rm"];
-  cmd.push("-e", `MODE=${mode}`);
-  if (mode === "collect" && flowPath) {
-    const absoluteFlowPath = path.resolve(cwd, flowPath);
-    cmd.push("-v", `${absoluteFlowPath}:/app/flow.mjs:ro`);
-    cmd.push("-e", "FLOW=/app/flow.mjs");
-  }
-  if (options.port !== void 0) {
-    cmd.push("-p", `${options.port}:${options.port}`);
-    cmd.push("-e", `PORT=${options.port}`);
-  }
-  if (options.host) {
-    cmd.push("-e", `HOST=${options.host}`);
-  }
-  if (mode === "serve" && options.staticDir) {
-    const absoluteStaticDir = path.resolve(cwd, options.staticDir);
-    cmd.push("-v", `${absoluteStaticDir}:/app/dist:ro`);
-    cmd.push("-e", "STATIC_DIR=/app/dist");
-  }
-  if (process.platform !== "win32") {
-    try {
-      const uid = process.getuid?.();
-      const gid = process.getgid?.();
-      if (uid !== void 0 && gid !== void 0) {
-        cmd.push("--user", `${uid}:${gid}`);
-      }
-    } catch {
-    }
-  }
-  cmd.push(RUNTIME_DOCKER_IMAGE);
-  return cmd;
-}
-async function executeRunInDocker(mode, flowPath, options = {}) {
-  const dockerCmd = buildDockerRunCommand(mode, flowPath, options);
-  return new Promise((resolve, reject) => {
-    const proc = spawn(dockerCmd[0], dockerCmd.slice(1), {
-      stdio: options.silent ? "ignore" : "inherit",
-      shell: false
-    });
-    proc.on("error", (error) => {
-      reject(new Error(`Docker execution failed: ${error.message}`));
-    });
-    proc.on("exit", (code) => {
-      if (code === 0) {
-        resolve();
-      } else {
-        reject(new Error(`Docker command exited with code ${code}`));
-      }
-    });
-  });
-}
-
-// src/core/execution.ts
-function getExecutionMode(options) {
-  if (options.local || process.env.WALKEROS_CONTAINER === "true") {
-    return "local";
-  }
-  return "docker";
-}
-async function executeCommand(localHandler, dockerCommand, dockerArgs, options, logger, configFile) {
-  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, configFile);
-  }
-}
-
-// src/core/asset-resolver.ts
-import { fileURLToPath } from "url";
-import path2 from "path";
-function getPackageRoot() {
-  const currentFile = fileURLToPath(import.meta.url);
-  if (currentFile.includes("/src/")) {
-    const srcIndex = currentFile.indexOf("/src/");
-    return currentFile.substring(0, srcIndex);
-  }
-  return path2.resolve(currentFile, "../..");
-}
-function resolveAsset(assetPath, assetType, baseDir) {
-  const packageRoot = getPackageRoot();
-  if (!assetPath.includes("/") && !assetPath.includes("\\")) {
-    if (assetType === "template") {
-      return path2.join(packageRoot, "templates", assetPath);
-    }
-    return path2.join(packageRoot, "examples", assetPath);
-  }
-  if (path2.isAbsolute(assetPath)) {
-    return assetPath;
-  }
-  const resolveBase = baseDir || process.cwd();
-  return path2.resolve(resolveBase, assetPath);
-}
-
-// 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 path3 from "path";
-async function loadJsonConfig(configPath) {
-  const absolutePath = path3.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 = path3.isAbsolute(tempDir) ? tempDir : path3.join(process.cwd(), tempDir);
-  return path3.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.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 path4 from "path";
-function parseBundleConfig(data) {
-  if (!isObject(data)) {
-    throw new Error(`Invalid config: expected object, got ${typeof data}`);
-  }
-  if (!("flow" in data) || !isObject(data.flow)) {
-    throw new Error(
-      `Invalid config: missing "flow" field. Expected format: { flow: { platform: "web" | "server", ... }, build: { ... } }`
-    );
-  }
-  if (!("build" in data) || !isObject(data.build)) {
-    throw new Error(
-      `Invalid config: missing "build" field. Expected format: { flow: { platform: "web" | "server", ... }, build: { ... } }`
-    );
-  }
-  const flowData = data.flow;
-  if (!("platform" in flowData) || flowData.platform !== "web" && flowData.platform !== "server") {
-    throw new Error(
-      `Invalid config: flow.platform must be "web" or "server", got "${flowData.platform}"`
-    );
-  }
-  const buildData = data.build;
-  if ("packages" in buildData && !isObject(buildData.packages)) {
-    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 (buildConfig.template === void 0) {
-    buildConfig.template = platform === "server" ? "server.hbs" : "web.hbs";
-  }
-  if (configPath && buildConfig.template && !path4.isAbsolute(buildConfig.template)) {
-    if (buildConfig.template.startsWith("./") || buildConfig.template.startsWith("../")) {
-      const configDir = path4.dirname(configPath);
-      buildConfig.template = path4.resolve(configDir, buildConfig.template);
-    }
-  }
-  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 path6 from "path";
-import fs4 from "fs-extra";
-
-// src/commands/bundle/package-manager.ts
-import pacote from "pacote";
-import path5 from "path";
-import fs2 from "fs-extra";
-function getPackageDirectory(baseDir, packageName, version) {
-  return path5.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 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 = path5.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(path5.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(path5.dirname(packageDir));
-      const cacheDir = process.env.NPM_CACHE_DIR || path5.join(process.cwd(), ".npm-cache");
-      await pacote.extract(packageSpec, packageDir, {
-        // Force npm registry download, prevent workspace resolution
-        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(path5.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 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
-   *
-   * @param templatePath - Template path (bare name, relative, or absolute)
-   */
-  async loadTemplate(templatePath) {
-    const resolvedPath = resolveAsset(templatePath, "template");
-    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 ? path6.isAbsolute(buildOptions.tempDir) ? buildOptions.tempDir : path6.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 = path6.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 = path6.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 = path6.join(TEMP_DIR, "entry.js");
-    await fs4.writeFile(entryPath, entryContent);
-    logger.info("\u26A1 Bundling with esbuild...");
-    const outputPath = path6.resolve(buildOptions.output);
-    await fs4.ensureDir(path6.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 = ["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 (empty if undefined)
-      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 = path7.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,
-    options.config
-  );
-}
-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 path8 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);
-      }
+import { Command } from 'commander';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { bundleCommand } from './commands/bundle';
+import { simulateCommand } from './commands/simulate';
+import { runCommand } from './commands/run';
+// Get package version dynamically
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJson = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf-8'));
+const VERSION = packageJson.version;
+// === CLI Commands ===
+// Export CLI command handlers
+export { bundleCommand, simulateCommand, runCommand };
+// === Programmatic API ===
+// High-level functions for library usage
+export { bundle } from './commands/bundle';
+export { simulate } from './commands/simulate';
+export { run } from './commands/run';
+const program = new Command();
+program
+    .name('walkeros')
+    .description('walkerOS CLI - Bundle and deploy walkerOS components')
+    .version(VERSION);
+// Bundle command
+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) => {
+    await bundleCommand({
+        config: file || 'bundle.config.json',
+        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,
     });
-  }
-  /**
-   * 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 path10 = pathParts.join(":");
-      if (!path10) continue;
-      const cleanPath = path10.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()
+});
+// Simulate command
+program
+    .command('simulate [file]')
+    .description('Simulate event processing and capture API calls')
+    .option('-e, --event <source>', 'Event to simulate (JSON string, file path, or URL)')
+    .option('--json', 'Output results as JSON')
+    .option('-v, --verbose', 'Verbose output')
+    .option('--local', 'execute in local Node.js instead of Docker')
+    .option('--dry-run', 'preview command without executing')
+    .option('--silent', 'suppress output')
+    .action(async (file, options) => {
+    await simulateCommand({
+        config: file || 'bundle.config.json',
+        event: options.event,
+        json: options.json,
+        verbose: options.verbose,
+        local: options.local,
+        dryRun: options.dryRun,
+        silent: options.silent,
     });
-  }
-  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 = path8.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 = path8.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,
-    options.config
-  );
-}
-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 path9 from "path";
-import os from "os";
-import {
-  runFlow,
-  runServeMode
-} from "@walkeros/docker";
-
-// src/commands/run/validators.ts
-import { existsSync } from "fs";
-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 = resolveAsset(filePath, "bundle");
-  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
-  });
-  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 = null;
-    if (mode === "collect") {
-      if (isPreBuilt) {
-        flowPath = path9.resolve(configPath);
-        if (!options.json && !options.silent) {
-          logger.info(`\u{1F4E6} Using pre-built flow: ${path9.basename(flowPath)}`);
-        }
-      } else {
-        if (!options.json && !options.silent) {
-          logger.info("\u{1F528} Building flow bundle...");
-        }
-        const rawConfig = await loadJsonConfig(configPath);
-        const tempPath = path9.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 || options.silent
-        });
-        flowPath = tempPath;
-        if (!options.json && !options.silent) {
-          logger.success("\u2705 Bundle ready");
-        }
-      }
-    }
-    const executionMode = getExecutionMode(options);
-    if (executionMode === "docker") {
-      const dockerAvailable = await isDockerAvailable();
-      if (!dockerAvailable) {
-        throw new Error(
-          "Docker is not available. Please install Docker or use --local flag to execute locally."
-        );
-      }
-      if (!options.json && !options.silent) {
-        logger.info("\u{1F433} Executing in production runtime container...");
-      }
-      await executeRunInDocker(mode, flowPath, {
+});
+// Run command with subcommands
+const runCmd = program
+    .command('run')
+    .description('Run walkerOS flows in collect or serve mode');
+// Run collect subcommand
+runCmd
+    .command('collect [file]')
+    .description('Run collector mode (event collection endpoint). Defaults to server-collect.mjs if no file specified.')
+    .option('-p, --port <number>', 'Port to listen on (default: 8080)', parseInt)
+    .option('-h, --host <address>', 'Host address (default: 0.0.0.0)')
+    .option('--json', 'Output results as JSON')
+    .option('-v, --verbose', 'Verbose output')
+    .option('--local', 'execute in local Node.js instead of Docker')
+    .option('--dry-run', 'preview command without executing')
+    .option('--silent', 'suppress output')
+    .action(async (file, options) => {
+    await runCommand('collect', {
+        config: file || 'server-collect.mjs',
         port: options.port,
         host: options.host,
-        staticDir: options.staticDir,
-        silent: options.silent
-      });
-    } else {
-      if (!options.json && !options.silent) {
-        const modeLabel = mode === "collect" ? "Collector" : "Server";
-        logger.info(`\u{1F5A5}\uFE0F  Starting ${modeLabel} locally...`);
-      }
-      switch (mode) {
-        case "collect": {
-          if (!flowPath) {
-            throw new Error("Flow path is required for collect mode");
-          }
-          const config = {
-            port: options.port,
-            host: options.host
-          };
-          await runFlow(flowPath, config);
-          break;
-        }
-        case "serve": {
-          const config = {
-            port: options.port,
-            host: options.host,
-            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);
-  }
-}
-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 = path9.resolve(flowFile);
-    } else {
-      const rawConfig = await loadJsonConfig(flowFile);
-      const tempPath = path9.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,
+        json: options.json,
         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
-var program = new Command();
-program.name("walkeros").description("walkerOS CLI - Bundle and deploy walkerOS components").version("0.3.4");
-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) => {
-  await bundleCommand({
-    config: file || "bundle.config.json",
-    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 [file]").description("Simulate event processing and capture API calls").option("-e, --event <json>", "Event to simulate (JSON string)").option("--json", "Output results as JSON").option("-v, --verbose", "Verbose output").option("--local", "execute in local Node.js instead of Docker").option("--dry-run", "preview command without executing").option("--silent", "suppress output").action(async (file, options) => {
-  await simulateCommand({
-    config: file || "bundle.config.json",
-    event: options.event,
-    json: options.json,
-    verbose: options.verbose,
-    local: options.local,
-    dryRun: options.dryRun,
-    silent: options.silent
-  });
-});
-var runCmd = program.command("run").description("Run walkerOS flows in collect or serve mode");
-runCmd.command("collect [file]").description(
-  "Run collector mode (event collection endpoint). Defaults to server-collect.mjs if no file specified."
-).option("-p, --port <number>", "Port to listen on (default: 8080)", parseInt).option("-h, --host <address>", "Host address (default: 0.0.0.0)").option("--json", "Output results as JSON").option("-v, --verbose", "Verbose output").option("--local", "execute in local Node.js instead of Docker").option("--dry-run", "preview command without executing").option("--silent", "suppress output").action(async (file, options) => {
-  await runCommand("collect", {
-    config: file || "server-collect.mjs",
-    port: options.port,
-    host: options.host,
-    json: options.json,
-    verbose: options.verbose,
-    local: options.local,
-    dryRun: options.dryRun,
-    silent: options.silent
-  });
+        local: options.local,
+        dryRun: options.dryRun,
+        silent: options.silent,
+    });
 });
-runCmd.command("serve [file]").description(
-  "Run serve mode (static file server for browser bundles). Defaults to web-serve.mjs if no file specified."
-).option("-p, --port <number>", "Port to listen on (default: 8080)", parseInt).option("-h, --host <address>", "Host address (default: 0.0.0.0)").option("--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 || "web-serve.mjs",
-    port: options.port,
-    host: options.host,
-    staticDir: options.staticDir,
-    json: options.json,
-    verbose: options.verbose,
-    local: options.local,
-    dryRun: options.dryRun,
-    silent: options.silent
-  });
+// Run serve subcommand
+runCmd
+    .command('serve [file]')
+    .description('Run serve mode (single-file server for browser bundles). Defaults to baked-in web-serve.js if no file specified.')
+    .option('-p, --port <number>', 'Port to listen on (default: 8080)', parseInt)
+    .option('-h, --host <address>', 'Host address (default: 0.0.0.0)')
+    .option('--name <filename>', 'Filename in URL (default: walker.js)')
+    .option('--path <directory>', 'URL directory path (e.g., libs/v1)')
+    .option('--json', 'Output results as JSON')
+    .option('-v, --verbose', 'Verbose output')
+    .option('--local', 'execute in local Node.js instead of Docker')
+    .option('--dry-run', 'preview command without executing')
+    .option('--silent', 'suppress output')
+    .action(async (file, options) => {
+    await runCommand('serve', {
+        config: file || 'web-serve.js',
+        port: options.port,
+        host: options.host,
+        serveName: options.name,
+        servePath: options.path,
+        json: options.json,
+        verbose: options.verbose,
+        local: options.local,
+        dryRun: options.dryRun,
+        silent: options.silent,
+    });
 });
+// Run the CLI
+// Note: This file is marked as a bin script in package.json,
+// so it's always executed directly (never imported as a library)
 program.parse();
-export {
-  bundle,
-  bundleCommand,
-  run,
-  runCommand,
-  simulate,
-  simulateCommand
-};
 //# sourceMappingURL=index.js.map