@walkeros/cli 0.3.1 → 0.3.2

package/dist/index.js

@@ -4,7 +4,7 @@
 import { Command } from "commander";
 
 // src/commands/bundle/index.ts
-import path6 from "path";
+import path7 from "path";
 
 // src/core/logger.ts
 import chalk from "chalk";
@@ -123,19 +123,19 @@ function formatBytes(bytes) {
 
 // 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 = {}) {
+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",
-    // Mount current directory
-    "-v",
-    `${cwd}:/workspace`,
-    "-w",
-    "/workspace"
-  ];
+  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?.();
@@ -152,12 +152,18 @@ function buildDockerCommand(command, args, options = {}) {
   if (options.silent) {
     cmd.push("-e", "SILENT=true");
   }
-  cmd.push(DOCKER_IMAGE);
+  cmd.push(CLI_DOCKER_IMAGE);
   cmd.push(command, ...args);
   return cmd;
 }
-async function executeInDocker(command, args, options = {}) {
-  const dockerCmd = buildDockerCommand(command, args, options);
+async function executeInDocker(command, args, options = {}, configFile) {
+  const containerArgs = [...args, "--local"];
+  const dockerCmd = buildDockerCommand(
+    command,
+    containerArgs,
+    options,
+    configFile
+  );
   return new Promise((resolve2, reject) => {
     const proc = spawn(dockerCmd[0], dockerCmd.slice(1), {
       stdio: options.silent ? "ignore" : "inherit",
@@ -184,12 +190,65 @@ async function isDockerAvailable() {
     proc.on("exit", (code) => resolve2(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((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}`));
+      }
+    });
+  });
+}
 
 // src/core/execution.ts
 function getExecutionMode(options) {
   return options.local ? "local" : "docker";
 }
-async function executeCommand(localHandler, dockerCommand, dockerArgs, options, logger) {
+async function executeCommand(localHandler, dockerCommand, dockerArgs, options, logger, configFile) {
   const mode = getExecutionMode(options);
   if (options.dryRun) {
     if (mode === "docker") {
@@ -217,7 +276,7 @@ async function executeCommand(localHandler, dockerCommand, dockerArgs, options,
     if (logger && !options.silent) {
       logger.info("\u{1F433} Executing in Docker container...");
     }
-    await executeInDocker(dockerCommand, dockerArgs, options);
+    await executeInDocker(dockerCommand, dockerArgs, options, configFile);
   }
 }
 
@@ -237,9 +296,9 @@ function isSingleEnvConfig(data) {
 
 // src/config/utils.ts
 import fs from "fs-extra";
-import path from "path";
+import path2 from "path";
 async function loadJsonConfig(configPath) {
-  const absolutePath = path.resolve(configPath);
+  const absolutePath = path2.resolve(configPath);
   if (!await fs.pathExists(absolutePath)) {
     throw new Error(`Configuration file not found: ${absolutePath}`);
   }
@@ -254,8 +313,8 @@ async function loadJsonConfig(configPath) {
 }
 function getTempDir(tempDir = ".tmp") {
   const randomId = Math.random().toString(36).substring(2, 11);
-  const basePath = path.isAbsolute(tempDir) ? tempDir : path.join(process.cwd(), tempDir);
-  return path.join(basePath, `cli-${Date.now()}-${randomId}`);
+  const basePath = path2.isAbsolute(tempDir) ? tempDir : path2.join(process.cwd(), tempDir);
+  return path2.join(basePath, `cli-${Date.now()}-${randomId}`);
 }
 
 // src/config/defaults.ts
@@ -307,7 +366,7 @@ function ensureBuildOptions(buildOptions, flowPlatform) {
 }
 
 // src/config/parser.ts
-import path2 from "path";
+import path3 from "path";
 function parseBundleConfig(data) {
   if (!isObject(data)) {
     throw new Error(`Invalid config: expected object, got ${typeof data}`);
@@ -366,10 +425,10 @@ function normalizeConfigs(config, configPath) {
     ...buildDefaults,
     ...config.build
   };
-  if (configPath && buildConfig.template && !path2.isAbsolute(buildConfig.template)) {
+  if (configPath && buildConfig.template && !path3.isAbsolute(buildConfig.template)) {
     if (buildConfig.template.startsWith("./") || buildConfig.template.startsWith("../")) {
-      const configDir = path2.dirname(configPath);
-      buildConfig.template = path2.resolve(configDir, buildConfig.template);
+      const configDir = path3.dirname(configPath);
+      buildConfig.template = path3.resolve(configDir, buildConfig.template);
     }
   }
   const buildOptions = ensureBuildOptions(buildConfig, platform);
@@ -471,20 +530,20 @@ Your configuration appears to be single-environment.`
 
 // src/commands/bundle/bundler.ts
 import esbuild from "esbuild";
-import path5 from "path";
+import path6 from "path";
 import fs4 from "fs-extra";
 
 // src/commands/bundle/package-manager.ts
 import pacote from "pacote";
-import path3 from "path";
+import path4 from "path";
 import fs2 from "fs-extra";
 function getPackageDirectory(baseDir, packageName, version) {
-  return path3.join(baseDir, "node_modules", packageName);
+  return path4.join(baseDir, "node_modules", packageName);
 }
 function getCachedPackagePath(pkg, tempDir) {
-  const cacheDir = path3.join(".tmp", "cache", "packages");
+  const cacheDir = path4.join(".tmp", "cache", "packages");
   const safeName = pkg.name.replace(/\//g, "-").replace(/@/g, "");
-  return path3.join(cacheDir, `${safeName}-${pkg.version}`);
+  return path4.join(cacheDir, `${safeName}-${pkg.version}`);
 }
 async function isPackageCached(pkg, tempDir) {
   const cachedPath = getCachedPackagePath(pkg, tempDir);
@@ -522,7 +581,7 @@ async function resolveDependencies(pkg, packageDir, logger, visited = /* @__PURE
   }
   visited.add(pkgKey);
   try {
-    const packageJsonPath = path3.join(packageDir, "package.json");
+    const packageJsonPath = path4.join(packageDir, "package.json");
     if (await fs2.pathExists(packageJsonPath)) {
       const packageJson = await fs2.readJson(packageJsonPath);
       const deps = {
@@ -559,7 +618,7 @@ async function downloadPackages(packages, targetDir, logger, useCache = true) {
     if (useCache && await isPackageCached(pkg, targetDir)) {
       logger.debug(`Using cached ${packageSpec}...`);
       try {
-        await fs2.ensureDir(path3.dirname(packageDir));
+        await fs2.ensureDir(path4.dirname(packageDir));
         await fs2.copy(cachedPath, packageDir);
         packagePaths.set(pkg.name, packageDir);
         const deps = await resolveDependencies(pkg, packageDir, logger);
@@ -578,8 +637,8 @@ async function downloadPackages(packages, targetDir, logger, useCache = true) {
     }
     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 fs2.ensureDir(path4.dirname(packageDir));
+      const cacheDir = process.env.NPM_CACHE_DIR || path4.join(process.cwd(), ".npm-cache");
       await pacote.extract(packageSpec, packageDir, {
         // Force npm registry download, prevent workspace resolution
         registry: "https://registry.npmjs.org",
@@ -592,7 +651,7 @@ async function downloadPackages(packages, targetDir, logger, useCache = true) {
       });
       if (useCache) {
         try {
-          await fs2.ensureDir(path3.dirname(cachedPath));
+          await fs2.ensureDir(path4.dirname(cachedPath));
           await fs2.copy(packageDir, cachedPath);
           logger.debug(`Cached ${packageSpec} for future use`);
         } catch (cacheError) {
@@ -616,7 +675,7 @@ async function downloadPackages(packages, targetDir, logger, useCache = true) {
 
 // src/commands/bundle/template-engine.ts
 import fs3 from "fs-extra";
-import path4 from "path";
+import path5 from "path";
 import Handlebars from "handlebars";
 
 // src/commands/bundle/serializer.ts
@@ -729,7 +788,7 @@ var TemplateEngine = class {
    * Load template content from file path
    */
   async loadTemplate(templatePath) {
-    const resolvedPath = path4.resolve(templatePath);
+    const resolvedPath = path5.resolve(templatePath);
     if (!await fs3.pathExists(resolvedPath)) {
       throw new Error(`Template file not found: ${resolvedPath}`);
     }
@@ -771,7 +830,7 @@ var TemplateEngine = class {
 // 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();
+  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);
@@ -792,7 +851,7 @@ async function bundleCore(flowConfig, buildOptions, logger, showStats = false) {
     );
     for (const [pkgName, pkgPath] of packagePaths.entries()) {
       if (pkgName.startsWith("@walkeros/")) {
-        const pkgJsonPath = path5.join(pkgPath, "package.json");
+        const pkgJsonPath = path6.join(pkgPath, "package.json");
         const pkgJson = await fs4.readJSON(pkgJsonPath);
         if (!pkgJson.exports && pkgJson.module) {
           pkgJson.exports = {
@@ -805,7 +864,7 @@ async function bundleCore(flowConfig, buildOptions, logger, showStats = false) {
         }
       }
     }
-    const packageJsonPath = path5.join(TEMP_DIR, "package.json");
+    const packageJsonPath = path6.join(TEMP_DIR, "package.json");
     await fs4.writeFile(
       packageJsonPath,
       JSON.stringify({ type: "module" }, null, 2)
@@ -816,11 +875,11 @@ async function bundleCore(flowConfig, buildOptions, logger, showStats = false) {
       buildOptions,
       packagePaths
     );
-    const entryPath = path5.join(TEMP_DIR, "entry.js");
+    const entryPath = path6.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 outputPath = path6.resolve(buildOptions.output);
+    await fs4.ensureDir(path6.dirname(outputPath));
     const esbuildOptions = createEsbuildOptions(
       buildOptions,
       entryPath,
@@ -935,14 +994,7 @@ function createEsbuildOptions(buildOptions, entryPath, outputPath, tempDir, pack
       "querystring",
       "zlib"
     ];
-    const npmPackages = [
-      "zod",
-      "zod/*",
-      "express",
-      "express/*",
-      "cors",
-      "cors/*"
-    ];
+    const npmPackages = ["express", "express/*", "cors", "cors/*"];
     baseOptions.external = buildOptions.external ? [...nodeBuiltins, ...npmPackages, ...buildOptions.external] : [...nodeBuiltins, ...npmPackages];
   }
   if (buildOptions.target) {
@@ -1156,7 +1208,7 @@ async function bundleCommand(options) {
           throw new Error("Cannot use both --env and --all flags together");
         }
         logger.info("\u{1F4E6} Reading configuration...");
-        const configPath = path6.resolve(options.config);
+        const configPath = path7.resolve(options.config);
         const rawConfig = await loadJsonConfig(configPath);
         const configsToBundle = options.all ? loadAllEnvironments(rawConfig, { configPath, logger }) : [
           loadBundleConfig(rawConfig, {
@@ -1265,7 +1317,8 @@ async function bundleCommand(options) {
     "bundle",
     dockerArgs,
     options,
-    logger
+    logger,
+    options.config
   );
 }
 async function bundle(configOrPath, options = {}) {
@@ -1292,7 +1345,7 @@ async function bundle(configOrPath, options = {}) {
 }
 
 // src/commands/simulate/simulator.ts
-import path7 from "path";
+import path8 from "path";
 import fs5 from "fs-extra";
 
 // src/commands/simulate/tracker.ts
@@ -1329,9 +1382,9 @@ var CallTracker = class {
     }
     for (const fullPath of paths) {
       const [destKey, ...pathParts] = fullPath.split(":");
-      const path9 = pathParts.join(":");
-      if (!path9) continue;
-      const cleanPath = path9.replace(/^call:/, "");
+      const path10 = pathParts.join(":");
+      if (!path10) continue;
+      const cleanPath = path10.replace(/^call:/, "");
       const parts = cleanPath.split(".");
       let current = wrapped;
       let source = env;
@@ -1386,7 +1439,7 @@ async function simulateCore(configPath, event, options = {}) {
   try {
     logger.info("\u{1F3AF} Starting walkerOS simulation...");
     logger.info("\u{1F4E6} Loading bundle configuration...");
-    const fullConfigPath = path7.resolve(configPath);
+    const fullConfigPath = path8.resolve(configPath);
     const rawConfig = await loadJsonConfig(fullConfigPath);
     parseBundleConfig(rawConfig);
     logger.info(`\u{1F680} Executing simulation with event: ${JSON.stringify(event)}`);
@@ -1481,7 +1534,7 @@ ${envSetupCode.join("\n")}
 
 ${buildOptions.code || ""}
 `;
-    const tempOutput = path7.join(
+    const tempOutput = path8.join(
       tempDir,
       `simulation-bundle-${generateId()}.mjs`
     );
@@ -1620,7 +1673,8 @@ async function simulateCommand(options) {
     "simulate",
     dockerArgs,
     options,
-    logger
+    logger,
+    options.config
   );
 }
 async function simulate(configOrPath, event, options = {}) {
@@ -1636,7 +1690,7 @@ async function simulate(configOrPath, event, options = {}) {
 }
 
 // src/commands/run/index.ts
-import path8 from "path";
+import path9 from "path";
 import os from "os";
 import {
   runFlow,
@@ -1686,104 +1740,112 @@ async function runCommand(mode, options) {
     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");
-          }
+  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)}`);
         }
-        if (!options.json) {
-          const modeLabel = mode === "collect" ? "Collector" : "Server";
-          logger.info(`\u{1F680} Starting ${modeLabel}...`);
+      } else {
+        if (!options.json && !options.silent) {
+          logger.info("\u{1F528} Building flow bundle...");
         }
-        switch (mode) {
-          case "collect": {
-            const config = {
-              port: options.port,
-              host: options.host
-            };
-            await runFlow(flowPath, config);
-            break;
+        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
           }
-          case "serve": {
-            const config = {
-              port: options.port,
-              host: options.host,
-              staticDir: options.staticDir
-            };
-            await runServeMode(config);
-            break;
+        };
+        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, {
+        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");
           }
-          default:
-            throw new Error(`Unknown mode: ${mode}`);
+          const config = {
+            port: options.port,
+            host: options.host
+          };
+          await runFlow(flowPath, config);
+          break;
         }
-      } 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
+        case "serve": {
+          const config = {
+            port: options.port,
+            host: options.host,
+            staticDir: options.staticDir
           };
-          console.log(JSON.stringify(output, null, 2));
-        } else {
-          logger.error("\u274C Run failed:");
-          logger.error(errorMessage);
+          await runServeMode(config);
+          break;
         }
-        process.exit(1);
+        default:
+          throw new Error(`Unknown mode: ${mode}`);
       }
-    },
-    "run",
-    dockerArgs,
-    options,
-    logger
-  );
+    }
+  } 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();
@@ -1801,10 +1863,10 @@ async function run(mode, options) {
     const isPreBuilt = flowFile.endsWith(".mjs") || flowFile.endsWith(".js") || flowFile.endsWith(".cjs");
     let flowPath;
     if (isPreBuilt) {
-      flowPath = path8.resolve(flowFile);
+      flowPath = path9.resolve(flowFile);
     } else {
       const rawConfig = await loadJsonConfig(flowFile);
-      const tempPath = path8.join(
+      const tempPath = path9.join(
         os.tmpdir(),
         `walkeros-${Date.now()}-${Math.random().toString(36).slice(2, 9)}.mjs`
       );
@@ -1863,16 +1925,12 @@ async function run(mode, options) {
 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(
+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 (options) => {
+).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: options.config,
+    config: file || "bundle.config.json",
     env: options.env,
     all: options.all,
     stats: options.stats,
@@ -1884,13 +1942,9 @@ program.command("bundle").description("Bundle NPM packages with custom code").op
     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) => {
+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: options.config,
+    config: file || "bundle.config.json",
     event: options.event,
     json: options.json,
     verbose: options.verbose,