@walkeros/cli 0.4.2 → 0.5.1-next.0

package/dist/index.js

@@ -5,6 +5,7 @@ import { Command } from "commander";
 import { readFileSync } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { dirname, join } from "path";
+import { VERSION as DOCKER_VERSION2 } from "@walkeros/docker";
 
 // src/commands/bundle/index.ts
 import path9 from "path";
@@ -263,7 +264,7 @@ async function loadJsonFromSource(source, options) {
 }
 
 // src/core/docker.ts
-var CLI_VERSION = true ? "0.4.2" : "0.0.0";
+var CLI_VERSION = true ? "0.5.0" : "0.0.0";
 var CLI_DOCKER_IMAGE = process.env.WALKEROS_CLI_DOCKER_IMAGE || `walkeros/cli:${CLI_VERSION}`;
 var RUNTIME_DOCKER_IMAGE = process.env.WALKEROS_RUNTIME_DOCKER_IMAGE || `walkeros/docker:${DOCKER_VERSION}`;
 function buildCommonDockerArgs(options) {
@@ -323,7 +324,7 @@ async function executeInDocker(command, args, options = {}, configFile) {
       if (code === 0) {
         resolve();
       } else {
-        reject(new Error(`Docker command exited with code ${code}`));
+        process.exit(code || 1);
       }
     });
   });
@@ -392,7 +393,7 @@ async function executeRunInDocker(mode, flowPath, options = {}) {
       if (code === 0) {
         resolve();
       } else {
-        reject(new Error(`Docker command exited with code ${code}`));
+        process.exit(code || 1);
       }
     });
   });
@@ -405,22 +406,22 @@ function getExecutionMode(options) {
   }
   return "docker";
 }
-async function executeCommand(localHandler, dockerCommand, dockerArgs, options, logger, configFile) {
+async function executeCommand(localHandler, dockerCommand, dockerArgs, options, logger2, configFile) {
   const mode = getExecutionMode(options);
   if (options.dryRun) {
     if (mode === "docker") {
       const cmd = `docker run walkeros/cli:latest ${dockerCommand} ${dockerArgs.join(" ")}`;
-      logger?.info(`[DRY-RUN] Would execute: ${cmd}`);
+      logger2?.info(`[DRY-RUN] Would execute: ${cmd}`);
     } else {
-      logger?.info(
+      logger2?.info(
         `[DRY-RUN] Would execute locally: ${dockerCommand} ${dockerArgs.join(" ")}`
       );
     }
     return;
   }
   if (mode === "local") {
-    if (logger && !options.silent) {
-      logger.info("\u{1F5A5}\uFE0F  Executing locally...");
+    if (logger2 && !options.silent) {
+      logger2.info("\u{1F5A5}\uFE0F  Executing locally...");
     }
     await localHandler();
   } else {
@@ -430,8 +431,8 @@ async function executeCommand(localHandler, dockerCommand, dockerArgs, options,
         "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...");
+    if (logger2 && !options.silent) {
+      logger2.info("\u{1F433} Executing in Docker container...");
     }
     await executeInDocker(dockerCommand, dockerArgs, options, configFile);
   }
@@ -451,7 +452,7 @@ function getAssetDir() {
   const currentFile = fileURLToPath(import.meta.url);
   let dir = path3.dirname(currentFile);
   while (dir !== path3.dirname(dir)) {
-    if (existsSync(path3.join(dir, "templates"))) {
+    if (existsSync(path3.join(dir, "examples"))) {
       cachedAssetDir = dir;
       return dir;
     }
@@ -463,9 +464,6 @@ function getAssetDir() {
 function resolveAsset(assetPath, assetType, baseDir) {
   if (!assetPath.includes("/") && !assetPath.includes("\\")) {
     const assetDir = getAssetDir();
-    if (assetType === "template") {
-      return path3.join(assetDir, "templates", assetPath);
-    }
     return path3.join(assetDir, "examples", assetPath);
   }
   if (path3.isAbsolute(assetPath)) {
@@ -482,7 +480,7 @@ function getErrorMessage(error) {
 // src/core/local-packages.ts
 import path4 from "path";
 import fs3 from "fs-extra";
-async function resolveLocalPackage(packageName, localPath, configDir, logger) {
+async function resolveLocalPackage(packageName, localPath, configDir, logger2) {
   const absolutePath = path4.isAbsolute(localPath) ? localPath : path4.resolve(configDir, localPath);
   if (!await fs3.pathExists(absolutePath)) {
     throw new Error(
@@ -498,7 +496,7 @@ async function resolveLocalPackage(packageName, localPath, configDir, logger) {
   const distPath = path4.join(absolutePath, "dist");
   const hasDistFolder = await fs3.pathExists(distPath);
   if (!hasDistFolder) {
-    logger.warn(
+    logger2.warn(
       `\u26A0\uFE0F  ${packageName}: No dist/ folder found. Using package root.`
     );
   }
@@ -509,7 +507,7 @@ async function resolveLocalPackage(packageName, localPath, configDir, logger) {
     hasDistFolder
   };
 }
-async function copyLocalPackage(localPkg, targetDir, logger) {
+async function copyLocalPackage(localPkg, targetDir, logger2) {
   const packageDir = path4.join(targetDir, "node_modules", localPkg.name);
   await fs3.ensureDir(path4.dirname(packageDir));
   await fs3.copy(
@@ -529,7 +527,7 @@ async function copyLocalPackage(localPkg, targetDir, logger) {
       }
     }
   }
-  logger.info(`\u{1F4E6} Using local: ${localPkg.name} from ${localPkg.absolutePath}`);
+  logger2.info(`\u{1F4E6} Using local: ${localPkg.name} from ${localPkg.absolutePath}`);
   return packageDir;
 }
 
@@ -560,7 +558,6 @@ var WEB_BUILD_DEFAULTS = {
   format: "iife",
   platform: "browser",
   target: "es2020",
-  template: "web.hbs",
   minify: true,
   sourcemap: false,
   cache: true,
@@ -572,7 +569,6 @@ var SERVER_BUILD_DEFAULTS = {
   format: "esm",
   platform: "node",
   target: "node20",
-  template: "server.hbs",
   minify: true,
   sourcemap: false,
   cache: true,
@@ -681,7 +677,8 @@ function loadAllFlows(rawConfig, options) {
 // src/commands/bundle/bundler.ts
 import esbuild from "esbuild";
 import path8 from "path";
-import fs8 from "fs-extra";
+import fs7 from "fs-extra";
+import { packageNameToVariable } from "@walkeros/core";
 
 // src/commands/bundle/package-manager.ts
 import pacote from "pacote";
@@ -755,7 +752,7 @@ Each package must use the same version across all declarations. Please update yo
     );
   }
 }
-async function resolveDependencies(pkg, packageDir, logger, visited = /* @__PURE__ */ new Set()) {
+async function resolveDependencies(pkg, packageDir, logger2, visited = /* @__PURE__ */ new Set()) {
   const dependencies = [];
   const pkgKey = `${pkg.name}@${pkg.version}`;
   if (visited.has(pkgKey)) {
@@ -777,11 +774,11 @@ async function resolveDependencies(pkg, packageDir, logger, visited = /* @__PURE
       }
     }
   } catch (error) {
-    logger.debug(`Failed to read dependencies for ${pkgKey}: ${error}`);
+    logger2.debug(`Failed to read dependencies for ${pkgKey}: ${error}`);
   }
   return dependencies;
 }
-async function downloadPackages(packages, targetDir, logger, useCache = true, configDir) {
+async function downloadPackages(packages, targetDir, logger2, useCache = true, configDir) {
   const packagePaths = /* @__PURE__ */ new Map();
   const downloadQueue = [...packages];
   const processed = /* @__PURE__ */ new Set();
@@ -808,11 +805,11 @@ async function downloadPackages(packages, targetDir, logger, useCache = true, co
         pkg.name,
         pkg.path,
         configDir || process.cwd(),
-        logger
+        logger2
       );
-      const installedPath = await copyLocalPackage(localPkg, targetDir, logger);
+      const installedPath = await copyLocalPackage(localPkg, targetDir, logger2);
       packagePaths.set(pkg.name, installedPath);
-      const deps = await resolveDependencies(pkg, installedPath, logger);
+      const deps = await resolveDependencies(pkg, installedPath, logger2);
       for (const dep of deps) {
         const depKey = `${dep.name}@${dep.version}`;
         if (!processed.has(depKey)) {
@@ -825,12 +822,12 @@ async function downloadPackages(packages, targetDir, logger, useCache = true, co
     const packageDir = getPackageDirectory(targetDir, pkg.name, pkg.version);
     const cachedPath = await getCachedPackagePath(pkg, targetDir);
     if (useCache && await isPackageCached(pkg, targetDir)) {
-      logger.debug(`Using cached ${packageSpec}...`);
+      logger2.debug(`Using cached ${packageSpec}...`);
       try {
         await fs5.ensureDir(path6.dirname(packageDir));
         await fs5.copy(cachedPath, packageDir);
         packagePaths.set(pkg.name, packageDir);
-        const deps = await resolveDependencies(pkg, packageDir, logger);
+        const deps = await resolveDependencies(pkg, packageDir, logger2);
         for (const dep of deps) {
           const depKey = `${dep.name}@${dep.version}`;
           if (!processed.has(depKey)) {
@@ -839,12 +836,12 @@ async function downloadPackages(packages, targetDir, logger, useCache = true, co
         }
         continue;
       } catch (error) {
-        logger.debug(
+        logger2.debug(
           `Failed to use cache for ${packageSpec}, downloading fresh: ${error}`
         );
       }
     }
-    logger.debug(`Downloading ${packageSpec}...`);
+    logger2.debug(`Downloading ${packageSpec}...`);
     try {
       await fs5.ensureDir(path6.dirname(packageDir));
       const cacheDir = process.env.NPM_CACHE_DIR || path6.join(process.cwd(), ".npm-cache");
@@ -862,13 +859,13 @@ async function downloadPackages(packages, targetDir, logger, useCache = true, co
         try {
           await fs5.ensureDir(path6.dirname(cachedPath));
           await fs5.copy(packageDir, cachedPath);
-          logger.debug(`Cached ${packageSpec} for future use`);
+          logger2.debug(`Cached ${packageSpec} for future use`);
         } catch (cacheError) {
-          logger.debug(`Failed to cache ${packageSpec}: ${cacheError}`);
+          logger2.debug(`Failed to cache ${packageSpec}: ${cacheError}`);
         }
       }
       packagePaths.set(pkg.name, packageDir);
-      const deps = await resolveDependencies(pkg, packageDir, logger);
+      const deps = await resolveDependencies(pkg, packageDir, logger2);
       for (const dep of deps) {
         const depKey = `${dep.name}@${dep.version}`;
         if (!processed.has(depKey)) {
@@ -882,164 +879,8 @@ async function downloadPackages(packages, targetDir, logger, useCache = true, co
   return packagePaths;
 }
 
-// src/commands/bundle/template-engine.ts
-import fs6 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();
-    this.handlebars.registerHelper("eq", (a, b) => a === b);
-  }
-  /**
-   * 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 fs6.pathExists(resolvedPath)) {
-      throw new Error(`Template file not found: ${resolvedPath}`);
-    }
-    return await fs6.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/core/build-cache.ts
-import fs7 from "fs-extra";
+import fs6 from "fs-extra";
 import path7 from "path";
 var BUILD_CACHE_DIR = path7.join(".tmp", "cache", "builds");
 async function getBuildCachePath(configContent, cacheDir = BUILD_CACHE_DIR) {
@@ -1048,32 +889,32 @@ async function getBuildCachePath(configContent, cacheDir = BUILD_CACHE_DIR) {
 }
 async function isBuildCached(configContent, cacheDir = BUILD_CACHE_DIR) {
   const cachePath = await getBuildCachePath(configContent, cacheDir);
-  return fs7.pathExists(cachePath);
+  return fs6.pathExists(cachePath);
 }
 async function cacheBuild(configContent, buildOutput, cacheDir = BUILD_CACHE_DIR) {
   const cachePath = await getBuildCachePath(configContent, cacheDir);
-  await fs7.ensureDir(path7.dirname(cachePath));
-  await fs7.writeFile(cachePath, buildOutput, "utf-8");
+  await fs6.ensureDir(path7.dirname(cachePath));
+  await fs6.writeFile(cachePath, buildOutput, "utf-8");
 }
 async function getCachedBuild(configContent, cacheDir = BUILD_CACHE_DIR) {
   const cachePath = await getBuildCachePath(configContent, cacheDir);
-  if (await fs7.pathExists(cachePath)) {
-    return await fs7.readFile(cachePath, "utf-8");
+  if (await fs6.pathExists(cachePath)) {
+    return await fs6.readFile(cachePath, "utf-8");
   }
   return null;
 }
 
 // src/commands/bundle/bundler.ts
-async function copyIncludes(includes, sourceDir, outputDir, logger) {
+async function copyIncludes(includes, sourceDir, outputDir, logger2) {
   for (const include of includes) {
     const sourcePath = path8.resolve(sourceDir, include);
     const folderName = path8.basename(include);
     const destPath = path8.join(outputDir, folderName);
-    if (await fs8.pathExists(sourcePath)) {
-      await fs8.copy(sourcePath, destPath);
-      logger.debug(`Copied ${include} to output`);
+    if (await fs7.pathExists(sourcePath)) {
+      await fs7.copy(sourcePath, destPath);
+      logger2.debug(`Copied ${include} to output`);
     } else {
-      logger.debug(`Include folder not found: ${include}`);
+      logger2.debug(`Include folder not found: ${include}`);
     }
   }
 }
@@ -1089,7 +930,7 @@ function generateCacheKeyContent(flowConfig, buildOptions) {
   };
   return JSON.stringify(configForCache);
 }
-async function bundleCore(flowConfig, buildOptions, logger, showStats = false) {
+async function bundleCore(flowConfig, buildOptions, logger2, showStats = false) {
   const bundleStartTime = Date.now();
   const TEMP_DIR = buildOptions.tempDir ? path8.isAbsolute(buildOptions.tempDir) ? buildOptions.tempDir : path8.resolve(buildOptions.tempDir) : getTempDir();
   if (buildOptions.cache !== false) {
@@ -1098,14 +939,14 @@ async function bundleCore(flowConfig, buildOptions, logger, showStats = false) {
     if (cached) {
       const cachedBuild = await getCachedBuild(configContent);
       if (cachedBuild) {
-        logger.info("\u2728 Using cached build");
+        logger2.info("\u2728 Using cached build");
         const outputPath = path8.resolve(buildOptions.output);
-        await fs8.ensureDir(path8.dirname(outputPath));
-        await fs8.writeFile(outputPath, cachedBuild);
-        logger.gray(`Output: ${outputPath}`);
-        logger.success("\u2705 Build completed (from cache)");
+        await fs7.ensureDir(path8.dirname(outputPath));
+        await fs7.writeFile(outputPath, cachedBuild);
+        logger2.gray(`Output: ${outputPath}`);
+        logger2.success("\u2705 Build completed (from cache)");
         if (showStats) {
-          const stats = await fs8.stat(outputPath);
+          const stats = await fs7.stat(outputPath);
           const packageStats = Object.entries(buildOptions.packages).map(
             ([name, pkg]) => ({
               name: `${name}@${pkg.version || "latest"}`,
@@ -1126,10 +967,10 @@ async function bundleCore(flowConfig, buildOptions, logger, showStats = false) {
   }
   try {
     if (!buildOptions.tempDir) {
-      await fs8.emptyDir(TEMP_DIR);
+      await fs7.emptyDir(TEMP_DIR);
     }
-    logger.debug("Cleaned temporary directory");
-    logger.info("\u{1F4E5} Downloading packages...");
+    logger2.debug("Cleaned temporary directory");
+    logger2.info("\u{1F4E5} Downloading packages...");
     const packagesArray = Object.entries(buildOptions.packages).map(
       ([name, packageConfig]) => ({
         name,
@@ -1141,7 +982,7 @@ async function bundleCore(flowConfig, buildOptions, logger, showStats = false) {
     const packagePaths = await downloadPackages(
       packagesArray,
       TEMP_DIR,
-      logger,
+      logger2,
       buildOptions.cache,
       buildOptions.configDir
       // For resolving relative local paths
@@ -1149,7 +990,7 @@ async function bundleCore(flowConfig, buildOptions, logger, showStats = false) {
     for (const [pkgName, pkgPath] of packagePaths.entries()) {
       if (pkgName.startsWith("@walkeros/")) {
         const pkgJsonPath = path8.join(pkgPath, "package.json");
-        const pkgJson = await fs8.readJSON(pkgJsonPath);
+        const pkgJson = await fs7.readJSON(pkgJsonPath);
         if (!pkgJson.exports && pkgJson.module) {
           pkgJson.exports = {
             ".": {
@@ -1157,33 +998,33 @@ async function bundleCore(flowConfig, buildOptions, logger, showStats = false) {
               require: pkgJson.main
             }
           };
-          await fs8.writeJSON(pkgJsonPath, pkgJson, { spaces: 2 });
+          await fs7.writeJSON(pkgJsonPath, pkgJson, { spaces: 2 });
         }
       }
     }
     const packageJsonPath = path8.join(TEMP_DIR, "package.json");
-    await fs8.writeFile(
+    await fs7.writeFile(
       packageJsonPath,
       JSON.stringify({ type: "module" }, null, 2)
     );
-    logger.info("\u{1F4DD} Creating entry point...");
+    logger2.info("\u{1F4DD} Creating entry point...");
     const entryContent = await createEntryPoint(
       flowConfig,
       buildOptions,
       packagePaths
     );
     const entryPath = path8.join(TEMP_DIR, "entry.js");
-    await fs8.writeFile(entryPath, entryContent);
-    logger.info("\u26A1 Bundling with esbuild...");
+    await fs7.writeFile(entryPath, entryContent);
+    logger2.info("\u26A1 Bundling with esbuild...");
     const outputPath = path8.resolve(buildOptions.output);
-    await fs8.ensureDir(path8.dirname(outputPath));
+    await fs7.ensureDir(path8.dirname(outputPath));
     const esbuildOptions = createEsbuildOptions(
       buildOptions,
       entryPath,
       outputPath,
       TEMP_DIR,
       packagePaths,
-      logger
+      logger2
     );
     try {
       await esbuild.build(esbuildOptions);
@@ -1193,12 +1034,12 @@ async function bundleCore(flowConfig, buildOptions, logger, showStats = false) {
         buildOptions.code || ""
       );
     }
-    logger.gray(`Output: ${outputPath}`);
+    logger2.gray(`Output: ${outputPath}`);
     if (buildOptions.cache !== false) {
       const configContent = generateCacheKeyContent(flowConfig, buildOptions);
-      const buildOutput = await fs8.readFile(outputPath, "utf-8");
+      const buildOutput = await fs7.readFile(outputPath, "utf-8");
       await cacheBuild(configContent, buildOutput);
-      logger.debug("Build cached for future use");
+      logger2.debug("Build cached for future use");
     }
     let stats;
     if (showStats) {
@@ -1215,24 +1056,24 @@ async function bundleCore(flowConfig, buildOptions, logger, showStats = false) {
         buildOptions.include,
         buildOptions.configDir || process.cwd(),
         outputDir,
-        logger
+        logger2
       );
     }
     if (!buildOptions.tempDir) {
-      await fs8.remove(TEMP_DIR);
-      logger.debug("Cleaned up temporary files");
+      await fs7.remove(TEMP_DIR);
+      logger2.debug("Cleaned up temporary files");
     }
     return stats;
   } catch (error) {
     if (!buildOptions.tempDir) {
-      await fs8.remove(TEMP_DIR).catch(() => {
+      await fs7.remove(TEMP_DIR).catch(() => {
       });
     }
     throw error;
   }
 }
 async function collectBundleStats(outputPath, packages, startTime, entryContent) {
-  const stats = await fs8.stat(outputPath);
+  const stats = await fs7.stat(outputPath);
   const totalSize = stats.size;
   const buildTime = Date.now() - startTime;
   const packageStats = Object.entries(packages).map(([name, pkg]) => {
@@ -1258,7 +1099,7 @@ async function collectBundleStats(outputPath, packages, startTime, entryContent)
     treeshakingEffective
   };
 }
-function createEsbuildOptions(buildOptions, entryPath, outputPath, tempDir, packagePaths, logger) {
+function createEsbuildOptions(buildOptions, entryPath, outputPath, tempDir, packagePaths, logger2) {
   const alias = {};
   const baseOptions = {
     entryPoints: [entryPath],
@@ -1326,11 +1167,6 @@ function createEsbuildOptions(buildOptions, entryPath, outputPath, tempDir, pack
   }
   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("");
-}
 function detectDestinationPackages(flowConfig) {
   const destinationPackages = /* @__PURE__ */ new Set();
   const destinations = flowConfig.destinations;
@@ -1343,10 +1179,57 @@ function detectDestinationPackages(flowConfig) {
   }
   return destinationPackages;
 }
-function generateImportStatements(packages, destinationPackages) {
+function detectSourcePackages(flowConfig) {
+  const sourcePackages = /* @__PURE__ */ new Set();
+  const sources = flowConfig.sources;
+  if (sources) {
+    for (const [sourceKey, sourceConfig] of Object.entries(sources)) {
+      if (typeof sourceConfig === "object" && sourceConfig !== null && "package" in sourceConfig && typeof sourceConfig.package === "string") {
+        sourcePackages.add(sourceConfig.package);
+      }
+    }
+  }
+  return sourcePackages;
+}
+function detectExplicitCodeImports(flowConfig) {
+  const explicitCodeImports = /* @__PURE__ */ new Map();
+  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" && "code" in destConfig && typeof destConfig.code === "string") {
+        const isAutoGenerated = destConfig.code.startsWith("_");
+        if (!isAutoGenerated) {
+          if (!explicitCodeImports.has(destConfig.package)) {
+            explicitCodeImports.set(destConfig.package, /* @__PURE__ */ new Set());
+          }
+          explicitCodeImports.get(destConfig.package).add(destConfig.code);
+        }
+      }
+    }
+  }
+  const sources = flowConfig.sources;
+  if (sources) {
+    for (const [sourceKey, sourceConfig] of Object.entries(sources)) {
+      if (typeof sourceConfig === "object" && sourceConfig !== null && "package" in sourceConfig && typeof sourceConfig.package === "string" && "code" in sourceConfig && typeof sourceConfig.code === "string") {
+        const isAutoGenerated = sourceConfig.code.startsWith("_");
+        if (!isAutoGenerated) {
+          if (!explicitCodeImports.has(sourceConfig.package)) {
+            explicitCodeImports.set(sourceConfig.package, /* @__PURE__ */ new Set());
+          }
+          explicitCodeImports.get(sourceConfig.package).add(sourceConfig.code);
+        }
+      }
+    }
+  }
+  return explicitCodeImports;
+}
+function generateImportStatements(packages, destinationPackages, sourcePackages, explicitCodeImports) {
   const importStatements = [];
   const examplesMappings = [];
+  const usedPackages = /* @__PURE__ */ new Set([...destinationPackages, ...sourcePackages]);
   for (const [packageName, packageConfig] of Object.entries(packages)) {
+    const isUsedByDestOrSource = usedPackages.has(packageName);
+    const hasExplicitCode = explicitCodeImports.has(packageName);
     if (packageConfig.imports && packageConfig.imports.length > 0) {
       const uniqueImports = [...new Set(packageConfig.imports)];
       const defaultImports = [];
@@ -1386,76 +1269,45 @@ function generateImportStatements(packages, destinationPackages) {
           );
         }
       }
-    } else {
-      const varName = packageNameToVariable(packageName);
+    } else if (hasExplicitCode) {
+      const codes = Array.from(explicitCodeImports.get(packageName));
       importStatements.push(
-        `import * as ${varName} from '${packageName}'; // Consider specifying explicit imports`
+        `import { ${codes.join(", ")} } from '${packageName}';`
       );
+    } else if (isUsedByDestOrSource) {
+      const varName = packageNameToVariable(packageName);
+      importStatements.push(`import ${varName} from '${packageName}';`);
     }
   }
   return { importStatements, examplesMappings };
 }
-async function processTemplate(flowConfig, buildOptions) {
-  if (buildOptions.template) {
-    const templateEngine = new TemplateEngine();
-    const flowWithProps = flowConfig;
-    return 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 {
-    return buildOptions.code || "";
-  }
-}
-function wrapCodeForFormat(code, format, hasTemplate) {
-  if (hasTemplate) {
-    return code;
-  }
-  if (format === "esm") {
-    const hasExport = /^\s*export\s/m.test(code);
-    if (!hasExport) {
-      return `export default ${code}`;
-    }
-  }
-  return code;
-}
-function assembleFinalCode(importStatements, examplesObject, wrappedCode, format) {
-  const importsCode = importStatements.join("\n");
-  let finalCode = importsCode ? `${importsCode}
-
-${examplesObject}${wrappedCode}` : `${examplesObject}${wrappedCode}`;
-  if (examplesObject && format === "esm") {
-    finalCode += `
-
-export { examples };`;
-  }
-  return finalCode;
-}
 async function createEntryPoint(flowConfig, buildOptions, packagePaths) {
   const destinationPackages = detectDestinationPackages(flowConfig);
+  const sourcePackages = detectSourcePackages(flowConfig);
+  const explicitCodeImports = detectExplicitCodeImports(flowConfig);
   const { importStatements } = generateImportStatements(
     buildOptions.packages,
-    destinationPackages
-  );
-  const examplesObject = "";
-  const templatedCode = await processTemplate(flowConfig, buildOptions);
-  const wrappedCode = wrapCodeForFormat(
-    templatedCode,
-    buildOptions.format,
-    !!buildOptions.template
+    destinationPackages,
+    sourcePackages,
+    explicitCodeImports
   );
-  return assembleFinalCode(
-    importStatements,
-    examplesObject,
-    wrappedCode,
-    buildOptions.format
+  const importsCode = importStatements.join("\n");
+  const hasFlow = destinationPackages.size > 0 || sourcePackages.size > 0;
+  if (!hasFlow) {
+    const userCode = buildOptions.code || "";
+    return importsCode ? `${importsCode}
+
+${userCode}` : userCode;
+  }
+  const configObject = buildConfigObject(flowConfig, explicitCodeImports);
+  const wrappedCode = generatePlatformWrapper(
+    configObject,
+    buildOptions.code || "",
+    buildOptions
   );
+  return importsCode ? `${importsCode}
+
+${wrappedCode}` : wrappedCode;
 }
 function createBuildError(buildError, code) {
   if (!buildError.errors || buildError.errors.length === 0) {
@@ -1480,35 +1332,108 @@ ${firstError.text}`
 ` + (location ? `  at ${location.file}:${location.line}:${location.column}` : "")
   );
 }
+function buildConfigObject(flowConfig, explicitCodeImports) {
+  const flowWithProps = flowConfig;
+  const sources = flowWithProps.sources || {};
+  const destinations = flowWithProps.destinations || {};
+  const sourcesEntries = Object.entries(sources).map(([key, source]) => {
+    const hasExplicitCode = source.code && explicitCodeImports.has(source.package);
+    const codeVar = hasExplicitCode ? source.code : packageNameToVariable(source.package);
+    const configStr = source.config ? processConfigValue(source.config) : "{}";
+    const envStr = source.env ? `,
+      env: ${processConfigValue(source.env)}` : "";
+    return `    ${key}: {
+      code: ${codeVar},
+      config: ${configStr}${envStr}
+    }`;
+  });
+  const destinationsEntries = Object.entries(destinations).map(
+    ([key, dest]) => {
+      const hasExplicitCode = dest.code && explicitCodeImports.has(dest.package);
+      const codeVar = hasExplicitCode ? dest.code : packageNameToVariable(dest.package);
+      const configStr = dest.config ? processConfigValue(dest.config) : "{}";
+      const envStr = dest.env ? `,
+      env: ${processConfigValue(dest.env)}` : "";
+      return `    ${key}: {
+      code: ${codeVar},
+      config: ${configStr}${envStr}
+    }`;
+    }
+  );
+  const collectorStr = flowWithProps.collector ? `,
+  ...${processConfigValue(flowWithProps.collector)}` : "";
+  return `{
+  sources: {
+${sourcesEntries.join(",\n")}
+  },
+  destinations: {
+${destinationsEntries.join(",\n")}
+  }${collectorStr}
+}`;
+}
+function processConfigValue(value) {
+  return JSON.stringify(value, null, 2);
+}
+function generatePlatformWrapper(configObject, userCode, buildOptions) {
+  if (buildOptions.platform === "browser") {
+    const windowAssignments = [];
+    if (buildOptions.windowCollector) {
+      windowAssignments.push(
+        `  if (typeof window !== 'undefined') window['${buildOptions.windowCollector}'] = collector;`
+      );
+    }
+    if (buildOptions.windowElb) {
+      windowAssignments.push(
+        `  if (typeof window !== 'undefined') window['${buildOptions.windowElb}'] = elb;`
+      );
+    }
+    const assignments = windowAssignments.length > 0 ? "\n" + windowAssignments.join("\n") : "";
+    return `(async () => {
+  const config = ${configObject};
+
+  ${userCode}
+
+  const { collector, elb } = await startFlow(config);${assignments}
+})();`;
+  } else {
+    const codeSection = userCode ? `
+  ${userCode}
+` : "";
+    return `export default async function(context = {}) {
+  const config = ${configObject};${codeSection}
+  return await startFlow(config);
+}`;
+  }
+}
 
 // src/commands/bundle/stats.ts
-function displayStats(stats, logger) {
-  logger.info("\n\u{1F4CA} Bundle Statistics");
-  logger.info("\u2500".repeat(50));
+function displayStats(stats, logger2) {
+  logger2.info("\n\u{1F4CA} Bundle Statistics");
+  logger2.info("\u2500".repeat(50));
   const sizeKB = formatBytes(stats.totalSize);
-  logger.info(`Total Size: ${sizeKB} KB`);
+  logger2.info(`Total Size: ${sizeKB} KB`);
   const timeSeconds = (stats.buildTime / 1e3).toFixed(2);
-  logger.info(`Build Time: ${timeSeconds}s`);
+  logger2.info(`Build Time: ${timeSeconds}s`);
   const treeshakingStatus = stats.treeshakingEffective ? "\u2705 Effective" : "\u26A0\uFE0F  Not optimal (consider using named imports)";
-  logger.info(`Tree-shaking: ${treeshakingStatus}`);
+  logger2.info(`Tree-shaking: ${treeshakingStatus}`);
   if (stats.packages.length > 0) {
-    logger.info(`
+    logger2.info(`
 Package Breakdown:`);
     stats.packages.forEach((pkg) => {
       if (pkg.size > 0) {
         const pkgSizeKB = formatBytes(pkg.size);
-        logger.info(`  \u2022 ${pkg.name}: ${pkgSizeKB} KB`);
+        logger2.info(`  \u2022 ${pkg.name}: ${pkgSizeKB} KB`);
       }
     });
   }
-  logger.info("\u2500".repeat(50));
+  logger2.info("\u2500".repeat(50));
 }
 
 // src/commands/bundle/index.ts
 async function bundleCommand(options) {
   const timer = createTimer();
   timer.start();
-  const logger = createCommandLogger(options);
+  const logger2 = createCommandLogger(options);
   const dockerArgs = buildCommonDockerArgs(options);
   if (options.flow) dockerArgs.push("--flow", options.flow);
   if (options.all) dockerArgs.push("--all");
@@ -1520,14 +1445,14 @@ async function bundleCommand(options) {
         if (options.flow && options.all) {
           throw new Error("Cannot use both --flow and --all flags together");
         }
-        logger.info("\u{1F4E6} Reading configuration...");
+        logger2.info("\u{1F4E6} Reading configuration...");
         const configPath = resolveAsset(options.config, "config");
         const rawConfig = await loadJsonConfig(configPath);
-        const configsToBundle = options.all ? loadAllFlows(rawConfig, { configPath, logger }) : [
+        const configsToBundle = options.all ? loadAllFlows(rawConfig, { configPath, logger: logger2 }) : [
           loadBundleConfig(rawConfig, {
             configPath,
             flowName: options.flow,
-            logger
+            logger: logger2
           })
         ];
         const results = [];
@@ -1542,16 +1467,16 @@ async function bundleCommand(options) {
               buildOptions.cache = options.cache;
             }
             if (isMultiFlow || options.all) {
-              logger.info(`
+              logger2.info(`
 \u{1F527} Building flow: ${flowName}`);
             } else {
-              logger.info("\u{1F527} Starting bundle process...");
+              logger2.info("\u{1F527} Starting bundle process...");
             }
             const shouldCollectStats = options.stats || options.json;
             const stats = await bundleCore(
               flowConfig,
               buildOptions,
-              logger,
+              logger2,
               shouldCollectStats
             );
             results.push({
@@ -1560,7 +1485,7 @@ async function bundleCommand(options) {
               stats
             });
             if (!options.json && !options.all && options.stats && stats) {
-              displayStats(stats, logger);
+              displayStats(stats, logger2);
             }
           } catch (error) {
             const errorMessage = getErrorMessage(error);
@@ -1596,16 +1521,16 @@ async function bundleCommand(options) {
           outputLogger.log("white", JSON.stringify(output, null, 2));
         } else {
           if (options.all) {
-            logger.info(`
+            logger2.info(`
 \u{1F4CA} Build Summary:`);
-            logger.info(`   Total: ${results.length}`);
-            logger.success(`   \u2705 Success: ${successCount}`);
+            logger2.info(`   Total: ${results.length}`);
+            logger2.success(`   \u2705 Success: ${successCount}`);
             if (failureCount > 0) {
-              logger.error(`   \u274C Failed: ${failureCount}`);
+              logger2.error(`   \u274C Failed: ${failureCount}`);
             }
           }
           if (failureCount === 0) {
-            logger.success(
+            logger2.success(
               `
 \u2705 Bundle created successfully in ${timer.format()}`
             );
@@ -1621,8 +1546,8 @@ async function bundleCommand(options) {
           const output = createErrorOutput(errorMessage, duration);
           outputLogger.log("white", JSON.stringify(output, null, 2));
         } else {
-          logger.error("\u274C Bundle failed:");
-          logger.error(errorMessage);
+          logger2.error("\u274C Bundle failed:");
+          logger2.error(errorMessage);
         }
         process.exit(1);
       }
@@ -1630,7 +1555,7 @@ async function bundleCommand(options) {
     "bundle",
     dockerArgs,
     options,
-    logger,
+    logger2,
     options.config
   );
 }
@@ -1651,18 +1576,18 @@ async function bundle(configOrPath, options = {}) {
   if (options.cache !== void 0) {
     buildOptions.cache = options.cache;
   }
-  const logger = createCommandLogger(options);
+  const logger2 = createCommandLogger(options);
   return await bundleCore(
     flowConfig,
     buildOptions,
-    logger,
+    logger2,
     options.stats ?? false
   );
 }
 
 // src/commands/simulate/simulator.ts
 import path10 from "path";
-import fs10 from "fs-extra";
+import fs9 from "fs-extra";
 import { getPlatform as getPlatform2 } from "@walkeros/core";
 
 // src/commands/simulate/tracker.ts
@@ -1745,7 +1670,7 @@ var CallTracker = class {
 
 // src/commands/simulate/jsdom-executor.ts
 import { JSDOM, VirtualConsole } from "jsdom";
-import fs9 from "fs-extra";
+import fs8 from "fs-extra";
 function buildSandboxFromEnvs(envs, destinations, tracker) {
   const baseBrowserMocks = {
     Image: class MockImage {
@@ -1814,7 +1739,7 @@ async function executeInJSDOM(bundlePath, destinations, event, tracker, envs, ti
   const sandbox = buildSandboxFromEnvs(envs, destinations, tracker);
   Object.assign(window, sandbox.window);
   Object.assign(window.document, sandbox.document);
-  const bundleCode = await fs9.readFile(bundlePath, "utf8");
+  const bundleCode = await fs8.readFile(bundlePath, "utf8");
   try {
     window.eval(bundleCode);
   } catch (error) {
@@ -1967,28 +1892,28 @@ function generateId() {
   return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
 }
 async function simulateCore(configPath, event, options = {}) {
-  const logger = createLogger({
+  const logger2 = 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...");
+    logger2.info("\u{1F3AF} Starting walkerOS simulation...");
+    logger2.info("\u{1F4E6} Loading bundle configuration...");
     const fullConfigPath = path10.resolve(configPath);
     const rawConfig = await loadJsonConfig(fullConfigPath);
     loadBundleConfig(rawConfig, { configPath: fullConfigPath });
-    logger.info(`\u{1F680} Executing simulation with event: ${JSON.stringify(event)}`);
+    logger2.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`);
+      logger2.info(`\u2705 Simulation completed successfully`);
     } else {
-      logger.error(`\u274C Simulation failed: ${result.error}`);
+      logger2.error(`\u274C Simulation failed: ${result.error}`);
     }
     return result;
   } catch (error) {
     const errorMessage = getErrorMessage(error);
-    logger.error(`\u{1F4A5} Simulation error: ${errorMessage}`);
+    logger2.error(`\u{1F4A5} Simulation error: ${errorMessage}`);
     return {
       success: false,
       error: errorMessage
@@ -2021,7 +1946,7 @@ async function executeSimulation(event, configPath) {
       );
     }
     const typedEvent = event;
-    await fs10.ensureDir(tempDir);
+    await fs9.ensureDir(tempDir);
     const rawConfig = await loadJsonConfig(configPath);
     const { flowConfig, buildOptions } = loadBundleConfig(rawConfig, {
       configPath
@@ -2095,7 +2020,7 @@ async function executeSimulation(event, configPath) {
     };
   } finally {
     if (tempDir) {
-      await fs10.remove(tempDir).catch(() => {
+      await fs9.remove(tempDir).catch(() => {
       });
     }
   }
@@ -2103,7 +2028,7 @@ async function executeSimulation(event, configPath) {
 
 // src/commands/simulate/index.ts
 async function simulateCommand(options) {
-  const logger = createCommandLogger(options);
+  const logger2 = createCommandLogger(options);
   const dockerArgs = buildCommonDockerArgs(options);
   if (options.event) dockerArgs.push("--event", options.event);
   await executeCommand(
@@ -2154,7 +2079,7 @@ async function simulateCommand(options) {
     "simulate",
     dockerArgs,
     options,
-    logger,
+    logger2,
     options.config
   );
 }
@@ -2173,11 +2098,11 @@ async function simulate(configOrPath, event, options = {}) {
 // src/commands/push/index.ts
 import path11 from "path";
 import { JSDOM as JSDOM2, VirtualConsole as VirtualConsole2 } from "jsdom";
-import fs11 from "fs-extra";
+import fs10 from "fs-extra";
 import { getPlatform as getPlatform3 } from "@walkeros/core";
 import { schemas as schemas2 } from "@walkeros/core/dev";
 async function pushCommand(options) {
-  const logger = createCommandLogger(options);
+  const logger2 = createCommandLogger(options);
   const dockerArgs = buildCommonDockerArgs(options);
   dockerArgs.push("--event", options.event);
   if (options.flow) dockerArgs.push("--flow", options.flow);
@@ -2185,7 +2110,7 @@ async function pushCommand(options) {
     async () => {
       const startTime = Date.now();
       try {
-        logger.info("\u{1F4E5} Loading event...");
+        logger2.info("\u{1F4E5} Loading event...");
         const event = await loadJsonFromSource(options.event, {
           name: "event"
         });
@@ -2203,27 +2128,27 @@ async function pushCommand(options) {
           data: parsedEvent.data || {}
         };
         if (!validatedEvent.name.includes(" ")) {
-          logger.warn(
+          logger2.warn(
             `Event name "${validatedEvent.name}" should follow "ENTITY ACTION" format (e.g., "page view")`
           );
         }
-        logger.info("\u{1F4E6} Loading flow configuration...");
+        logger2.info("\u{1F4E6} Loading flow configuration...");
         const configPath = path11.resolve(options.config);
         const rawConfig = await loadJsonConfig(configPath);
         const { flowConfig, buildOptions, flowName, isMultiFlow } = loadBundleConfig(rawConfig, {
           configPath: options.config,
           flowName: options.flow,
-          logger
+          logger: logger2
         });
         const platform = getPlatform3(flowConfig);
-        logger.info("\u{1F528} Bundling flow configuration...");
+        logger2.info("\u{1F528} Bundling flow configuration...");
         const configDir = path11.dirname(configPath);
         const tempDir = path11.join(
           configDir,
           ".tmp",
           `push-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
         );
-        await fs11.ensureDir(tempDir);
+        await fs10.ensureDir(tempDir);
         const tempPath = path11.join(
           tempDir,
           `bundle.${platform === "web" ? "js" : "mjs"}`
@@ -2239,15 +2164,15 @@ async function pushCommand(options) {
             windowElb: "elb"
           }
         };
-        await bundleCore(flowConfig, pushBuildOptions, logger, false);
-        logger.debug(`Bundle created: ${tempPath}`);
+        await bundleCore(flowConfig, pushBuildOptions, logger2, false);
+        logger2.debug(`Bundle created: ${tempPath}`);
         let result;
         if (platform === "web") {
-          logger.info("\u{1F310} Executing in web environment (JSDOM)...");
-          result = await executeWebPush(tempPath, validatedEvent, logger);
+          logger2.info("\u{1F310} Executing in web environment (JSDOM)...");
+          result = await executeWebPush(tempPath, validatedEvent, logger2);
         } else if (platform === "server") {
-          logger.info("\u{1F5A5}\uFE0F  Executing in server environment (Node.js)...");
-          result = await executeServerPush(tempPath, validatedEvent, logger);
+          logger2.info("\u{1F5A5}\uFE0F  Executing in server environment (Node.js)...");
+          result = await executeServerPush(tempPath, validatedEvent, logger2);
         } else {
           throw new Error(`Unsupported platform: ${platform}`);
         }
@@ -2268,27 +2193,27 @@ async function pushCommand(options) {
           );
         } else {
           if (result.success) {
-            logger.success("\u2705 Event pushed successfully");
+            logger2.success("\u2705 Event pushed successfully");
             if (result.elbResult && typeof result.elbResult === "object") {
               const pushResult = result.elbResult;
               if ("id" in pushResult && pushResult.id) {
-                logger.info(`   Event ID: ${pushResult.id}`);
+                logger2.info(`   Event ID: ${pushResult.id}`);
               }
               if ("entity" in pushResult && pushResult.entity) {
-                logger.info(`   Entity: ${pushResult.entity}`);
+                logger2.info(`   Entity: ${pushResult.entity}`);
               }
               if ("action" in pushResult && pushResult.action) {
-                logger.info(`   Action: ${pushResult.action}`);
+                logger2.info(`   Action: ${pushResult.action}`);
               }
             }
-            logger.info(`   Duration: ${duration}ms`);
+            logger2.info(`   Duration: ${duration}ms`);
           } else {
-            logger.error(`\u274C Push failed: ${result.error}`);
+            logger2.error(`\u274C Push failed: ${result.error}`);
             process.exit(1);
           }
         }
         try {
-          await fs11.remove(tempDir);
+          await fs10.remove(tempDir);
         } catch {
         }
       } catch (error) {
@@ -2309,7 +2234,7 @@ async function pushCommand(options) {
             )
           );
         } else {
-          logger.error(`\u274C Push command failed: ${errorMessage}`);
+          logger2.error(`\u274C Push command failed: ${errorMessage}`);
         }
         process.exit(1);
       }
@@ -2317,11 +2242,11 @@ async function pushCommand(options) {
     "push",
     dockerArgs,
     options,
-    logger,
+    logger2,
     options.config
   );
 }
-async function executeWebPush(bundlePath, event, logger) {
+async function executeWebPush(bundlePath, event, logger2) {
   const startTime = Date.now();
   try {
     const virtualConsole = new VirtualConsole2();
@@ -2332,10 +2257,10 @@ async function executeWebPush(bundlePath, event, logger) {
       virtualConsole
     });
     const { window } = dom;
-    logger.debug("Loading bundle...");
-    const bundleCode = await fs11.readFile(bundlePath, "utf8");
+    logger2.debug("Loading bundle...");
+    const bundleCode = await fs10.readFile(bundlePath, "utf8");
     window.eval(bundleCode);
-    logger.debug("Waiting for elb...");
+    logger2.debug("Waiting for elb...");
     await waitForWindowProperty2(
       window,
       "elb",
@@ -2343,7 +2268,7 @@ async function executeWebPush(bundlePath, event, logger) {
     );
     const windowObj = window;
     const elb = windowObj.elb;
-    logger.info(`Pushing event: ${event.name}`);
+    logger2.info(`Pushing event: ${event.name}`);
     const elbResult = await elb(event.name, event.data);
     return {
       success: true,
@@ -2358,7 +2283,7 @@ async function executeWebPush(bundlePath, event, logger) {
     };
   }
 }
-async function executeServerPush(bundlePath, event, logger, timeout = 6e4) {
+async function executeServerPush(bundlePath, event, logger2, timeout = 6e4) {
   const startTime = Date.now();
   try {
     const timeoutPromise = new Promise((_, reject) => {
@@ -2368,12 +2293,12 @@ async function executeServerPush(bundlePath, event, logger, timeout = 6e4) {
       );
     });
     const executePromise = (async () => {
-      logger.debug("Importing bundle...");
+      logger2.debug("Importing bundle...");
       const flowModule = await import(bundlePath);
       if (!flowModule.default || typeof flowModule.default !== "function") {
         throw new Error("Bundle does not export default factory function");
       }
-      logger.debug("Calling factory function...");
+      logger2.debug("Calling factory function...");
       const result = await flowModule.default();
       if (!result || !result.elb || typeof result.elb !== "function") {
         throw new Error(
@@ -2381,7 +2306,7 @@ async function executeServerPush(bundlePath, event, logger, timeout = 6e4) {
         );
       }
       const { elb } = result;
-      logger.info(`Pushing event: ${event.name}`);
+      logger2.info(`Pushing event: ${event.name}`);
       const elbResult = await elb(event.name, event.data);
       return {
         success: true,
@@ -2474,7 +2399,7 @@ function validatePort(port) {
 
 // src/commands/run/utils.ts
 import path12 from "path";
-import fs12 from "fs-extra";
+import fs11 from "fs-extra";
 async function prepareBundleForRun(configPath, options) {
   const configDir = path12.dirname(path12.resolve(configPath));
   const tempDir = path12.join(
@@ -2482,7 +2407,7 @@ async function prepareBundleForRun(configPath, options) {
     ".tmp",
     `run-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
   );
-  await fs12.ensureDir(tempDir);
+  await fs11.ensureDir(tempDir);
   const tempPath = path12.join(tempDir, "bundle.mjs");
   await bundle(configPath, {
     cache: true,
@@ -2501,7 +2426,10 @@ function isPreBuiltConfig(configPath) {
 }
 
 // src/commands/run/execution.ts
+import { createLogger as createLogger2, Level } from "@walkeros/core";
 import { runFlow, runServeMode } from "@walkeros/docker";
+var logLevel = process.env.VERBOSE === "true" ? Level.DEBUG : Level.INFO;
+var logger = createLogger2({ level: logLevel });
 async function executeRunLocal(mode, flowPath, options) {
   switch (mode) {
     case "collect": {
@@ -2512,7 +2440,7 @@ async function executeRunLocal(mode, flowPath, options) {
         port: options.port,
         host: options.host
       };
-      await runFlow(flowPath, config);
+      await runFlow(flowPath, config, logger.scope("runner"));
       break;
     }
     case "serve": {
@@ -2521,9 +2449,9 @@ async function executeRunLocal(mode, flowPath, options) {
         host: options.host,
         serveName: options.serveName,
         servePath: options.servePath,
-        filePath: flowPath || void 0
+        file: flowPath || void 0
       };
-      await runServeMode(config);
+      await runServeMode(config, logger.scope("serve"));
       break;
     }
     default:
@@ -2535,7 +2463,7 @@ async function executeRunLocal(mode, flowPath, options) {
 async function runCommand(mode, options) {
   const timer = createTimer();
   timer.start();
-  const logger = createCommandLogger(options);
+  const logger2 = createCommandLogger(options);
   try {
     validateMode(mode);
     const configPath = validateFlowFile(options.config);
@@ -2548,29 +2476,29 @@ async function runCommand(mode, options) {
       if (isPreBuilt) {
         flowPath = path13.resolve(configPath);
         if (!options.json && !options.silent) {
-          logger.info(`\u{1F4E6} Using pre-built flow: ${path13.basename(flowPath)}`);
+          logger2.info(`\u{1F4E6} Using pre-built flow: ${path13.basename(flowPath)}`);
         }
       } else {
         if (!options.json && !options.silent) {
-          logger.info("\u{1F528} Building flow bundle...");
+          logger2.info("\u{1F528} Building flow bundle...");
         }
         flowPath = await prepareBundleForRun(configPath, {
           verbose: options.verbose,
           silent: options.json || options.silent
         });
         if (!options.json && !options.silent) {
-          logger.success("\u2705 Bundle ready");
+          logger2.success("\u2705 Bundle ready");
         }
       }
     }
     const executionMode = getExecutionMode(options);
     if (options.dryRun) {
       if (executionMode === "docker") {
-        logger.info(
+        logger2.info(
           `[DRY-RUN] Would execute in Docker: run ${mode} with runtime image`
         );
       } else {
-        logger.info(`[DRY-RUN] Would execute locally: run ${mode}`);
+        logger2.info(`[DRY-RUN] Would execute locally: run ${mode}`);
       }
       return;
     }
@@ -2582,7 +2510,7 @@ async function runCommand(mode, options) {
         );
       }
       if (!options.json && !options.silent) {
-        logger.info("\u{1F433} Executing in production runtime container...");
+        logger2.info("\u{1F433} Executing in production runtime container...");
       }
       await executeRunInDocker(mode, flowPath, {
         port: options.port,
@@ -2594,7 +2522,7 @@ async function runCommand(mode, options) {
     } else {
       if (!options.json && !options.silent) {
         const modeLabel = mode === "collect" ? "Collector" : "Server";
-        logger.info(`\u{1F5A5}\uFE0F  Starting ${modeLabel} locally...`);
+        logger2.info(`\u{1F5A5}\uFE0F  Starting ${modeLabel} locally...`);
       }
       await executeRunLocal(mode, flowPath, {
         port: options.port,
@@ -2615,8 +2543,8 @@ async function runCommand(mode, options) {
       };
       console.log(JSON.stringify(output, null, 2));
     } else {
-      logger.error("\u274C Run failed:");
-      logger.error(errorMessage);
+      logger2.error("\u274C Run failed:");
+      logger2.error(errorMessage);
     }
     process.exit(1);
   }
@@ -2666,20 +2594,20 @@ async function run(mode, options) {
 }
 
 // src/commands/cache.ts
-import fs13 from "fs-extra";
+import fs12 from "fs-extra";
 import path14 from "path";
 var CACHE_DIR = path14.join(".tmp", "cache");
 function registerCacheCommand(program2) {
   const cache = program2.command("cache").description("Manage the CLI cache");
   cache.command("clear").description("Clear all cached packages and builds").option("--packages", "Clear only package cache").option("--builds", "Clear only build cache").action(async (options) => {
     if (options.packages) {
-      await fs13.remove(path14.join(CACHE_DIR, "packages"));
+      await fs12.remove(path14.join(CACHE_DIR, "packages"));
       console.log("Package cache cleared");
     } else if (options.builds) {
-      await fs13.remove(path14.join(CACHE_DIR, "builds"));
+      await fs12.remove(path14.join(CACHE_DIR, "builds"));
       console.log("Build cache cleared");
     } else {
-      await fs13.remove(CACHE_DIR);
+      await fs12.remove(CACHE_DIR);
       console.log("All caches cleared");
     }
   });
@@ -2694,8 +2622,8 @@ function registerCacheCommand(program2) {
   });
 }
 async function countEntries(dir) {
-  if (!await fs13.pathExists(dir)) return 0;
-  const entries = await fs13.readdir(dir);
+  if (!await fs12.pathExists(dir)) return 0;
+  const entries = await fs12.readdir(dir);
   return entries.length;
 }
 
@@ -2708,6 +2636,13 @@ var packageJson = JSON.parse(
 var VERSION = packageJson.version;
 var program = new Command();
 program.name("walkeros").description("walkerOS CLI - Bundle and deploy walkerOS components").version(VERSION);
+program.hook("preAction", (thisCommand, actionCommand) => {
+  const options = actionCommand.opts();
+  if (!options.silent && !options.json) {
+    console.log(`\u{1F680} walkerOS CLI v${VERSION}`);
+    console.log(`\u{1F433} Using Docker runtime: walkeros/docker:${DOCKER_VERSION2}`);
+  }
+});
 program.command("bundle [file]").description("Bundle NPM packages with custom code").option("-f, --flow <name>", "flow to build (for multi-flow configs)").option("--all", "build all flows (for multi-flow configs)").option("-s, --stats", "show bundle statistics").option("--json", "output statistics in JSON format (implies --stats)").option("--no-cache", "disable package caching and download fresh packages").option("-v, --verbose", "verbose output").option("--local", "execute in local Node.js instead of Docker").option("--dry-run", "preview command without executing").option("--silent", "suppress output").action(async (file, options) => {
   await bundleCommand({
     config: file || "bundle.config.json",