@walkeros/cli 1.4.0-next-1771334965900 → 2.0.0

package/dist/runtime/main.js

@@ -1,57 +1,118 @@
 #!/usr/bin/env node
 
+// src/runtime/env.ts
+function validateEnv(env) {
+  const token = env.WALKEROS_TOKEN;
+  const projectId = env.PROJECT_ID;
+  const flowId = env.FLOW_ID;
+  if (flowId && (!token || !projectId)) {
+    throw new Error("FLOW_ID requires WALKEROS_TOKEN and PROJECT_ID");
+  }
+  if (token && !projectId) {
+    throw new Error("WALKEROS_TOKEN requires PROJECT_ID");
+  }
+  return {
+    mode: env.MODE === "serve" ? "serve" : "collect",
+    port: parseInt(env.PORT || "8080", 10),
+    bundlePath: env.BUNDLE || "/app/flow/bundle.mjs",
+    cacheDir: env.CACHE_DIR || "/app/cache",
+    pollInterval: parseInt(env.POLL_INTERVAL || "30", 10),
+    heartbeatInterval: parseInt(env.HEARTBEAT_INTERVAL || "60", 10),
+    apiEnabled: !!(token && projectId),
+    remoteConfig: !!(token && projectId && flowId),
+    token,
+    projectId,
+    flowId
+  };
+}
+
+// src/runtime/resolve-bundle.ts
+import { writeFileSync } from "fs";
+
+// src/core/stdin.ts
+function isStdinPiped() {
+  return !process.stdin.isTTY;
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  const content = Buffer.concat(chunks).toString("utf-8");
+  if (!content.trim()) {
+    throw new Error("No input received on stdin");
+  }
+  return content;
+}
+
+// src/runtime/resolve-bundle.ts
+var TEMP_BUNDLE_PATH = "/tmp/walkeros-bundle.mjs";
+function isUrl(value) {
+  return value.startsWith("http://") || value.startsWith("https://");
+}
+async function fetchBundle(url) {
+  const response = await fetch(url, { signal: AbortSignal.timeout(3e4) });
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch bundle from ${url}: ${response.status} ${response.statusText}`
+    );
+  }
+  const content = await response.text();
+  if (!content.trim()) {
+    throw new Error(`Bundle fetched from ${url} is empty`);
+  }
+  writeFileSync(TEMP_BUNDLE_PATH, content, "utf-8");
+  return TEMP_BUNDLE_PATH;
+}
+async function readBundleFromStdin() {
+  const content = await readStdin();
+  writeFileSync(TEMP_BUNDLE_PATH, content, "utf-8");
+  return TEMP_BUNDLE_PATH;
+}
+async function resolveBundle(bundleEnv) {
+  if (isStdinPiped()) {
+    const path11 = await readBundleFromStdin();
+    return { path: path11, source: "stdin" };
+  }
+  if (isUrl(bundleEnv)) {
+    const path11 = await fetchBundle(bundleEnv);
+    return { path: path11, source: "url" };
+  }
+  return { path: bundleEnv, source: "file" };
+}
+
 // src/runtime/runner.ts
 import { pathToFileURL } from "url";
 import { resolve, dirname } from "path";
-async function runFlow(file, config, logger, loggerConfig) {
-  logger.info(`Loading flow from ${file}`);
+async function loadFlow(file, config, logger, loggerConfig) {
+  const absolutePath = resolve(file);
+  const flowDir = dirname(absolutePath);
+  process.chdir(flowDir);
+  const fileUrl = pathToFileURL(absolutePath).href;
+  const module = await import(`${fileUrl}?t=${Date.now()}`);
+  if (!module.default || typeof module.default !== "function") {
+    throw new Error(
+      `Invalid flow bundle: ${file} must export a default function`
+    );
+  }
+  const flowContext = loggerConfig ? { ...config, logger: loggerConfig } : config;
+  const result = await module.default(flowContext);
+  if (!result || !result.collector) {
+    throw new Error(`Invalid flow bundle: ${file} must return { collector }`);
+  }
+  return { collector: result.collector, file };
+}
+async function swapFlow(currentHandle, newFile, config, logger, loggerConfig) {
+  const newHandle = await loadFlow(newFile, config, logger, loggerConfig);
   try {
-    const absolutePath = resolve(file);
-    const flowDir = dirname(absolutePath);
-    process.chdir(flowDir);
-    const fileUrl = pathToFileURL(absolutePath).href;
-    const module = await import(fileUrl);
-    if (!module.default || typeof module.default !== "function") {
-      logger.throw(
-        `Invalid flow bundle: ${file} must export a default function`
-      );
-    }
-    const flowContext = loggerConfig ? { ...config, logger: loggerConfig } : config;
-    const result = await module.default(flowContext);
-    if (!result || !result.collector) {
-      logger.throw(`Invalid flow bundle: ${file} must return { collector }`);
+    if (currentHandle.collector.command) {
+      await currentHandle.collector.command("shutdown");
     }
-    const { collector } = result;
-    logger.info("Flow running");
-    if (config?.port) {
-      logger.info(`Port: ${config.port}`);
-    }
-    const shutdown = async (signal) => {
-      logger.info(`Received ${signal}, shutting down gracefully...`);
-      try {
-        if (collector.command) {
-          await collector.command("shutdown");
-        }
-        logger.info("Shutdown complete");
-        process.exit(0);
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        logger.error(`Error during shutdown: ${message}`);
-        process.exit(1);
-      }
-    };
-    process.on("SIGTERM", () => shutdown("SIGTERM"));
-    process.on("SIGINT", () => shutdown("SIGINT"));
-    await new Promise(() => {
-    });
   } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    logger.error(`Failed to run flow: ${message}`);
-    if (error instanceof Error && error.stack) {
-      logger.debug("Stack trace:", { stack: error.stack });
-    }
-    throw error;
+    logger.debug(`Old flow shutdown warning: ${error}`);
   }
+  logger.info("Flow swapped successfully");
+  return newHandle;
 }
 
 // src/runtime/serve.ts
@@ -81,6 +142,95 @@ function findPackageJson() {
 }
 var VERSION = JSON.parse(findPackageJson()).version;
 
+// src/runtime/heartbeat.ts
+import { randomBytes } from "crypto";
+var instanceId = randomBytes(8).toString("hex");
+function getInstanceId() {
+  return instanceId;
+}
+function createHeartbeat(config, logger) {
+  let timer = null;
+  const startTime2 = Date.now();
+  let configVersion = config.configVersion;
+  async function sendOnce() {
+    try {
+      await fetch(
+        `${config.appUrl}/api/projects/${config.projectId}/runners/heartbeat`,
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${config.token}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            instanceId,
+            flowId: config.flowId,
+            configVersion,
+            mode: config.mode,
+            cliVersion: VERSION,
+            uptime: Math.floor((Date.now() - startTime2) / 1e3)
+          }),
+          signal: AbortSignal.timeout(1e4)
+        }
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logger.debug(`Heartbeat failed: ${message}`);
+    }
+  }
+  function start() {
+    sendOnce();
+    const jitter = config.intervalMs * 0.1 * (Math.random() * 2 - 1);
+    timer = setInterval(() => sendOnce(), config.intervalMs + jitter);
+  }
+  function stop() {
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  }
+  function updateConfigVersion2(version) {
+    configVersion = version;
+  }
+  return { start, stop, sendOnce, updateConfigVersion: updateConfigVersion2 };
+}
+
+// src/runtime/status.ts
+var state = null;
+var startTime = Date.now();
+var currentStatus = "starting";
+var lastPollTime;
+var lastHeartbeatTime;
+function initStatus(initial) {
+  state = initial;
+  startTime = Date.now();
+  currentStatus = "starting";
+}
+function setRunning() {
+  currentStatus = "running";
+}
+function updateLastPoll() {
+  lastPollTime = (/* @__PURE__ */ new Date()).toISOString();
+}
+function updateConfigVersion(version) {
+  if (state) state.configVersion = version;
+}
+function getStatus() {
+  return {
+    status: currentStatus,
+    version: VERSION,
+    mode: state?.mode ?? "collect",
+    instanceId: getInstanceId(),
+    configVersion: state?.configVersion,
+    configSource: state?.configSource ?? "local",
+    apiEnabled: state?.apiEnabled ?? false,
+    lastPoll: lastPollTime,
+    lastHeartbeat: lastHeartbeatTime,
+    uptime: Math.floor((Date.now() - startTime) / 1e3),
+    port: state?.port ?? 8080
+  };
+}
+
 // src/runtime/serve.ts
 async function runServeMode(config, logger) {
   const port = process.env.PORT ? parseInt(process.env.PORT, 10) : config?.port || 8080;
@@ -106,6 +256,9 @@ async function runServeMode(config, logger) {
         url: urlPath
       });
     });
+    app.get("/status", (req, res) => {
+      res.json(getStatus());
+    });
     app.get(urlPath, (req, res) => {
       res.type("application/javascript");
       res.sendFile(file, { dotfiles: "allow" }, (err) => {
@@ -148,82 +301,104 @@ async function runServeMode(config, logger) {
   }
 }
 
-// src/runtime/resolve-bundle.ts
-import { writeFileSync } from "fs";
-
-// src/core/stdin.ts
-function isStdinPiped() {
-  return !process.stdin.isTTY;
-}
-async function readStdin() {
-  const chunks = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(chunk);
+// src/runtime/config-fetcher.ts
+async function fetchConfig(options) {
+  const url = `${options.appUrl}/api/projects/${options.projectId}/flows/${options.flowId}`;
+  const headers = {
+    Authorization: `Bearer ${options.token}`
+  };
+  if (options.lastEtag) {
+    headers["If-None-Match"] = options.lastEtag;
   }
-  const content = Buffer.concat(chunks).toString("utf-8");
-  if (!content.trim()) {
-    throw new Error("No input received on stdin");
+  const response = await fetch(url, {
+    headers,
+    signal: AbortSignal.timeout(3e4)
+  });
+  if (response.status === 304) {
+    return { changed: false };
   }
-  return content;
-}
-
-// src/runtime/resolve-bundle.ts
-var TEMP_BUNDLE_PATH = "/tmp/walkeros-bundle.mjs";
-function isUrl(value) {
-  return value.startsWith("http://") || value.startsWith("https://");
-}
-async function fetchBundle(url) {
-  const response = await fetch(url, { signal: AbortSignal.timeout(3e4) });
   if (!response.ok) {
     throw new Error(
-      `Failed to fetch bundle from ${url}: ${response.status} ${response.statusText}`
+      `Config fetch failed: ${response.status} ${response.statusText}`
     );
   }
-  const content = await response.text();
-  if (!content.trim()) {
-    throw new Error(`Bundle fetched from ${url} is empty`);
-  }
-  writeFileSync(TEMP_BUNDLE_PATH, content, "utf-8");
-  return TEMP_BUNDLE_PATH;
+  const data = await response.json();
+  const etag = response.headers.get("etag") || "";
+  const version = etag.replace(/"/g, "");
+  return {
+    content: data.content,
+    version,
+    etag,
+    changed: true
+  };
 }
-async function readBundleFromStdin() {
-  const content = await readStdin();
-  writeFileSync(TEMP_BUNDLE_PATH, content, "utf-8");
-  return TEMP_BUNDLE_PATH;
+
+// src/runtime/cache.ts
+import {
+  existsSync,
+  mkdirSync,
+  copyFileSync,
+  writeFileSync as writeFileSync2,
+  readFileSync as readFileSync2
+} from "fs";
+import { join as join2 } from "path";
+function writeCache(cacheDir, bundlePath, configContent, version) {
+  mkdirSync(cacheDir, { recursive: true });
+  copyFileSync(bundlePath, join2(cacheDir, "bundle.mjs"));
+  writeFileSync2(join2(cacheDir, "config.json"), configContent, "utf-8");
+  const meta = { version, timestamp: Date.now() };
+  writeFileSync2(join2(cacheDir, "meta.json"), JSON.stringify(meta), "utf-8");
 }
-async function resolveBundle(bundleEnv) {
-  if (isStdinPiped()) {
-    const path = await readBundleFromStdin();
-    return { path, source: "stdin" };
-  }
-  if (isUrl(bundleEnv)) {
-    const path = await fetchBundle(bundleEnv);
-    return { path, source: "url" };
+function readCache(cacheDir) {
+  try {
+    const metaPath = join2(cacheDir, "meta.json");
+    const bundlePath = join2(cacheDir, "bundle.mjs");
+    if (!existsSync(metaPath) || !existsSync(bundlePath)) return null;
+    const meta = JSON.parse(readFileSync2(metaPath, "utf-8"));
+    return { bundlePath, version: meta.version };
+  } catch {
+    return null;
   }
-  return { path: bundleEnv, source: "file" };
 }
 
-// src/runtime/register.ts
-async function registerRuntime(config) {
-  const url = `${config.appUrl}/api/projects/${config.projectId}/runtimes/register`;
-  const response = await fetch(url, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${config.deployToken}`,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({
-      flowId: config.flowId,
-      bundlePath: config.bundlePath
-    })
-  });
-  if (!response.ok) {
-    throw new Error(
-      `Registration failed: ${response.status} ${response.statusText}`
+// src/runtime/poller.ts
+function createPoller(config, logger) {
+  let timer = null;
+  let lastEtag;
+  async function pollOnce() {
+    try {
+      const result = await fetchConfig({
+        ...config.fetchOptions,
+        lastEtag
+      });
+      if (!result.changed) {
+        logger.debug("Config unchanged");
+        return;
+      }
+      logger.info(`New config version: ${result.version}`);
+      lastEtag = result.etag;
+      await config.onUpdate(result.content, result.version);
+      logger.info("Config updated successfully");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logger.error(`Poll error: ${message}`);
+    }
+  }
+  function start() {
+    lastEtag = void 0;
+    const jitter = config.intervalMs * 0.15 * (Math.random() * 2 - 1);
+    timer = setInterval(() => pollOnce(), config.intervalMs + jitter);
+    logger.info(
+      `Polling every ${Math.round((config.intervalMs + jitter) / 1e3)}s`
     );
   }
-  const data = await response.json();
-  return { bundleUrl: data.bundleUrl };
+  function stop() {
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  }
+  return { start, stop, pollOnce };
 }
 
 // src/core/logger.ts
@@ -302,91 +477,1651 @@ function createLogger(options = {}) {
     }
   };
 }
+function createCommandLogger(options) {
+  return createLogger({
+    verbose: options.verbose,
+    silent: options.silent ?? false,
+    json: options.json,
+    stderr: options.stderr
+  });
+}
 
-// src/runtime/main.ts
-function adaptLogger(cliLogger) {
-  return {
-    error: (message) => {
-      const msg = message instanceof Error ? message.message : message;
-      cliLogger.error(msg);
-    },
-    info: (message) => {
-      const msg = message instanceof Error ? message.message : message;
-      cliLogger.info(msg);
-    },
-    debug: (message) => {
-      const msg = message instanceof Error ? message.message : message;
-      cliLogger.debug(msg);
-    },
-    throw: (message) => {
-      const msg = message instanceof Error ? message.message : message;
-      cliLogger.error(msg);
-      throw message instanceof Error ? message : new Error(msg);
-    },
-    scope: (name) => {
-      return adaptLogger(cliLogger);
-    }
-  };
+// src/commands/run/utils.ts
+import path10 from "path";
+import fs10 from "fs-extra";
+
+// src/commands/bundle/index.ts
+import path9 from "path";
+import fs9 from "fs-extra";
+import { getPlatform as getPlatform2 } from "@walkeros/core";
+
+// src/core/output.ts
+import fs from "fs-extra";
+
+// src/core/tmp.ts
+import path from "path";
+var DEFAULT_TMP_ROOT = ".tmp";
+function getTmpPath(tmpDir, ...segments) {
+  const root = tmpDir || DEFAULT_TMP_ROOT;
+  const absoluteRoot = path.isAbsolute(root) ? root : path.resolve(root);
+  return path.join(absoluteRoot, ...segments);
 }
-async function main() {
-  const mode = process.env.MODE || "collect";
-  let bundleEnv = process.env.BUNDLE || "/app/flow/bundle.mjs";
-  const port = parseInt(process.env.PORT || "8080", 10);
-  const cliLogger = createLogger({ silent: false, verbose: true });
-  const logger = adaptLogger(cliLogger);
-  cliLogger.log(`Starting walkeros/flow in ${mode} mode`);
-  const appUrl = process.env.APP_URL;
-  const deployToken = process.env.DEPLOY_TOKEN;
-  const projectId = process.env.PROJECT_ID;
-  const flowId = process.env.FLOW_ID;
-  const bundlePath = process.env.BUNDLE_PATH;
-  if (appUrl && deployToken && projectId && flowId && bundlePath) {
-    try {
-      cliLogger.log("Registering with app...");
-      const result = await registerRuntime({
-        appUrl,
-        deployToken,
-        projectId,
-        flowId,
-        bundlePath
-      });
-      bundleEnv = result.bundleUrl;
-      cliLogger.log("Registered, bundle URL received");
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      cliLogger.error(`Registration failed: ${message}`);
-      process.exit(1);
-    }
+
+// src/core/asset-resolver.ts
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { existsSync as existsSync3 } from "fs";
+import path3 from "path";
+
+// src/config/utils.ts
+import fs2 from "fs-extra";
+import path2 from "path";
+
+// src/lib/config-file.ts
+import {
+  readFileSync as readFileSync3,
+  writeFileSync as writeFileSync3,
+  mkdirSync as mkdirSync2,
+  unlinkSync,
+  existsSync as existsSync2
+} from "fs";
+import { join as join3 } from "path";
+import { homedir } from "os";
+function getConfigDir() {
+  const xdgConfig = process.env.XDG_CONFIG_HOME;
+  const base = xdgConfig || join3(homedir(), ".config");
+  return join3(base, "walkeros");
+}
+function getConfigPath() {
+  return join3(getConfigDir(), "config.json");
+}
+function readConfig() {
+  const configPath = getConfigPath();
+  try {
+    const content = readFileSync3(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function resolveToken() {
+  const envToken = process.env.WALKEROS_TOKEN;
+  if (envToken) return { token: envToken, source: "env" };
+  const config = readConfig();
+  if (config?.token) return { token: config.token, source: "config" };
+  return null;
+}
+
+// src/core/auth.ts
+function getToken() {
+  const result = resolveToken();
+  return result?.token;
+}
+function getAuthHeaders() {
+  const token = getToken();
+  if (!token) return {};
+  return { Authorization: `Bearer ${token}` };
+}
+async function authenticatedFetch(url, init) {
+  const authHeaders = getAuthHeaders();
+  const existingHeaders = init?.headers instanceof Headers ? Object.fromEntries(init.headers.entries()) : Array.isArray(init?.headers) ? Object.fromEntries(init.headers) : init?.headers ?? {};
+  return fetch(url, {
+    ...init,
+    headers: { ...existingHeaders, ...authHeaders }
+  });
+}
+
+// src/config/utils.ts
+function isUrl2(str) {
+  try {
+    const url = new URL(str);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+async function downloadFromUrl(url) {
+  if (!isUrl2(url)) {
+    throw new Error(`Invalid URL: ${url}`);
   }
-  let file;
   try {
-    const resolved = await resolveBundle(bundleEnv);
-    file = resolved.path;
-    if (resolved.source === "stdin") {
-      cliLogger.log("Bundle: received via stdin pipe");
-    } else if (resolved.source === "url") {
-      cliLogger.log(`Bundle: fetched from ${bundleEnv}`);
-    } else {
-      cliLogger.log(`Bundle: ${file}`);
+    const response = await authenticatedFetch(url);
+    if (!response.ok) {
+      throw new Error(
+        `Failed to download ${url}: ${response.status} ${response.statusText}`
+      );
     }
+    const content = await response.text();
+    const downloadsDir = getTmpPath(void 0, "downloads");
+    await fs2.ensureDir(downloadsDir);
+    const tempPath = path2.join(downloadsDir, "flow.json");
+    await fs2.writeFile(tempPath, content, "utf-8");
+    return tempPath;
   } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    cliLogger.error(`Failed to resolve bundle: ${message}`);
-    process.exit(1);
+    if (error instanceof Error) {
+      throw new Error(`Failed to download from URL: ${error.message}`);
+    }
+    throw error;
   }
-  cliLogger.log(`Port: ${port}`);
-  try {
-    if (mode === "collect") {
-      await runFlow(file, { port }, logger);
-    } else if (mode === "serve") {
-      await runServeMode({ file, port }, logger);
-    } else {
-      cliLogger.error(`Unknown mode: ${mode}. Use 'collect' or 'serve'.`);
-      process.exit(1);
+}
+async function loadJsonConfig(configPath) {
+  let absolutePath;
+  let isTemporary = false;
+  if (isUrl2(configPath)) {
+    absolutePath = await downloadFromUrl(configPath);
+    isTemporary = true;
+  } else {
+    absolutePath = path2.resolve(configPath);
+    if (!await fs2.pathExists(absolutePath)) {
+      throw new Error(`Configuration file not found: ${absolutePath}`);
     }
+  }
+  try {
+    const rawConfig = await fs2.readJson(absolutePath);
+    return rawConfig;
   } catch (error) {
-    cliLogger.error(`Failed to start: ${error}`);
-    process.exit(1);
+    throw new Error(
+      `Invalid JSON in config file: ${configPath}. ${error instanceof Error ? error.message : error}`
+    );
+  } finally {
+    if (isTemporary) {
+      try {
+        await fs2.remove(absolutePath);
+      } catch {
+      }
+    }
+  }
+}
+
+// src/core/asset-resolver.ts
+var cachedAssetDir;
+function getAssetDir() {
+  if (cachedAssetDir) return cachedAssetDir;
+  const currentFile = fileURLToPath2(import.meta.url);
+  let dir = path3.dirname(currentFile);
+  while (dir !== path3.dirname(dir)) {
+    if (existsSync3(path3.join(dir, "examples"))) {
+      cachedAssetDir = dir;
+      return dir;
+    }
+    dir = path3.dirname(dir);
+  }
+  cachedAssetDir = path3.dirname(currentFile);
+  return cachedAssetDir;
+}
+function resolveAsset(assetPath, assetType, baseDir) {
+  if (isUrl2(assetPath)) {
+    return assetPath;
   }
+  if (!assetPath.includes("/") && !assetPath.includes("\\")) {
+    const assetDir = getAssetDir();
+    return path3.join(assetDir, "examples", assetPath);
+  }
+  if (path3.isAbsolute(assetPath)) {
+    return assetPath;
+  }
+  return path3.resolve(baseDir || process.cwd(), assetPath);
+}
+
+// src/core/local-packages.ts
+import path4 from "path";
+import fs3 from "fs-extra";
+async function resolveLocalPackage(packageName, localPath, configDir, logger) {
+  const absolutePath = path4.isAbsolute(localPath) ? localPath : path4.resolve(configDir, localPath);
+  if (!await fs3.pathExists(absolutePath)) {
+    throw new Error(
+      `Local package path not found: ${localPath} (resolved to ${absolutePath})`
+    );
+  }
+  const pkgJsonPath = path4.join(absolutePath, "package.json");
+  if (!await fs3.pathExists(pkgJsonPath)) {
+    throw new Error(
+      `No package.json found at ${absolutePath}. Is this a valid package directory?`
+    );
+  }
+  const distPath = path4.join(absolutePath, "dist");
+  const hasDistFolder = await fs3.pathExists(distPath);
+  if (!hasDistFolder) {
+    logger.warn(
+      `\u26A0\uFE0F  ${packageName}: No dist/ folder found. Using package root.`
+    );
+  }
+  return {
+    name: packageName,
+    absolutePath,
+    distPath: hasDistFolder ? distPath : absolutePath,
+    hasDistFolder
+  };
+}
+async function copyLocalPackage(localPkg, targetDir, logger) {
+  const packageDir = path4.join(targetDir, "node_modules", localPkg.name);
+  await fs3.ensureDir(path4.dirname(packageDir));
+  await fs3.copy(
+    path4.join(localPkg.absolutePath, "package.json"),
+    path4.join(packageDir, "package.json")
+  );
+  if (localPkg.hasDistFolder) {
+    await fs3.copy(localPkg.distPath, path4.join(packageDir, "dist"));
+  } else {
+    const entries = await fs3.readdir(localPkg.absolutePath);
+    for (const entry of entries) {
+      if (!["node_modules", ".turbo", ".git"].includes(entry)) {
+        await fs3.copy(
+          path4.join(localPkg.absolutePath, entry),
+          path4.join(packageDir, entry)
+        );
+      }
+    }
+  }
+  logger.info(`\u{1F4E6} Using local: ${localPkg.name} from ${localPkg.absolutePath}`);
+  return packageDir;
+}
+
+// src/core/input-detector.ts
+import fs4 from "fs-extra";
+
+// src/config/validators.ts
+import { schemas } from "@walkeros/core/dev";
+var { safeParseSetup } = schemas;
+function validateFlowSetup(data) {
+  const result = safeParseSetup(data);
+  if (!result.success) {
+    const errors = result.error.issues.map((issue) => {
+      const path11 = issue.path.length > 0 ? issue.path.map(String).join(".") : "root";
+      return `  - ${path11}: ${issue.message}`;
+    }).join("\n");
+    throw new Error(`Invalid configuration:
+${errors}`);
+  }
+  return result.data;
+}
+function getAvailableFlows(setup) {
+  return Object.keys(setup.flows);
+}
+
+// src/config/build-defaults.ts
+var WEB_BUILD_DEFAULTS = {
+  format: "iife",
+  platform: "browser",
+  target: "es2020",
+  minify: true,
+  sourcemap: false,
+  cache: true,
+  windowCollector: "collector",
+  windowElb: "elb"
+};
+var SERVER_BUILD_DEFAULTS = {
+  format: "esm",
+  platform: "node",
+  target: "node20",
+  minify: true,
+  sourcemap: false,
+  cache: true
+};
+var DEFAULT_OUTPUT_PATHS = {
+  web: "./dist/walker.js",
+  server: "./dist/bundle.mjs"
+};
+function getBuildDefaults(platform) {
+  return platform === "web" ? WEB_BUILD_DEFAULTS : SERVER_BUILD_DEFAULTS;
+}
+function getDefaultOutput(platform) {
+  return DEFAULT_OUTPUT_PATHS[platform];
+}
+
+// src/config/loader.ts
+import path5 from "path";
+import fs5 from "fs-extra";
+import { getFlowConfig, getPlatform } from "@walkeros/core";
+var DEFAULT_INCLUDE_FOLDER = "./shared";
+function loadBundleConfig(rawConfig, options) {
+  const setup = validateFlowSetup(rawConfig);
+  const availableFlows = getAvailableFlows(setup);
+  const flowName = resolveFlow(setup, options.flowName, availableFlows);
+  const flowConfig = getFlowConfig(setup, flowName);
+  const platform = getPlatform(flowConfig);
+  if (!platform) {
+    throw new Error(
+      `Invalid configuration: flow "${flowName}" must have a "web" or "server" key.`
+    );
+  }
+  const buildDefaults = getBuildDefaults(platform);
+  const packages = flowConfig.packages || {};
+  const output = options.buildOverrides?.output || getDefaultOutput(platform);
+  const configDir = isUrl2(options.configPath) ? process.cwd() : path5.dirname(options.configPath);
+  let includes = setup.include;
+  if (!includes) {
+    const defaultIncludePath = path5.resolve(configDir, DEFAULT_INCLUDE_FOLDER);
+    if (fs5.pathExistsSync(defaultIncludePath)) {
+      includes = [DEFAULT_INCLUDE_FOLDER];
+    }
+  }
+  const buildOptions = {
+    ...buildDefaults,
+    packages,
+    output,
+    include: includes,
+    configDir,
+    ...options.buildOverrides
+  };
+  const isMultiFlow = availableFlows.length > 1;
+  if (isMultiFlow && options.logger) {
+    options.logger.info(
+      `\u{1F4E6} Using flow: ${flowName} (${availableFlows.length} total)`
+    );
+  }
+  return {
+    flowConfig,
+    buildOptions,
+    flowName,
+    isMultiFlow,
+    availableFlows
+  };
+}
+function resolveFlow(setup, requestedFlow, available) {
+  if (available.length === 1) {
+    return available[0];
+  }
+  if (!requestedFlow) {
+    throw new Error(
+      `Multiple flows found. Please specify a flow using --flow flag.
+Available flows: ${available.join(", ")}`
+    );
+  }
+  if (!available.includes(requestedFlow)) {
+    throw new Error(
+      `Flow "${requestedFlow}" not found in configuration.
+Available flows: ${available.join(", ")}`
+    );
+  }
+  return requestedFlow;
+}
+
+// src/commands/bundle/bundler.ts
+import esbuild from "esbuild";
+import path8 from "path";
+import fs8 from "fs-extra";
+import { packageNameToVariable } from "@walkeros/core";
+
+// src/commands/bundle/package-manager.ts
+import pacote from "pacote";
+import path6 from "path";
+import fs6 from "fs-extra";
+
+// src/core/cache-utils.ts
+import { getHashServer } from "@walkeros/server-core";
+var HASH_LENGTH = 12;
+function isMutableVersion(version) {
+  return version === "latest" || version.includes("^") || version.includes("~") || version.includes("*") || version.includes("x");
+}
+function getTodayDate() {
+  return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+}
+async function getPackageCacheKey(packageName, version, date) {
+  const safeName = packageName.replace(/\//g, "-").replace(/@/g, "");
+  if (isMutableVersion(version)) {
+    const dateStr = date ?? getTodayDate();
+    const input2 = `${safeName}@${version}:${dateStr}`;
+    return getHashServer(input2, HASH_LENGTH);
+  }
+  const input = `${safeName}@${version}`;
+  return getHashServer(input, HASH_LENGTH);
+}
+function normalizeJson(content) {
+  const parsed = JSON.parse(content);
+  return JSON.stringify(parsed);
+}
+async function getFlowConfigCacheKey(content, date) {
+  const dateStr = date ?? getTodayDate();
+  const normalized = normalizeJson(content);
+  const input = `${normalized}:${dateStr}`;
+  return getHashServer(input, HASH_LENGTH);
+}
+
+// src/commands/bundle/package-manager.ts
+var PACKAGE_DOWNLOAD_TIMEOUT_MS = 6e4;
+async function withTimeout(promise, ms, errorMessage) {
+  const timeout = new Promise(
+    (_, reject) => setTimeout(() => reject(new Error(errorMessage)), ms)
+  );
+  return Promise.race([promise, timeout]);
+}
+function getPackageDirectory(baseDir, packageName, version) {
+  return path6.join(baseDir, "node_modules", packageName);
+}
+async function getCachedPackagePath(pkg, tmpDir) {
+  const cacheDir = getTmpPath(tmpDir, "cache", "packages");
+  const cacheKey = await getPackageCacheKey(pkg.name, pkg.version);
+  return path6.join(cacheDir, cacheKey);
+}
+async function isPackageCached(pkg, tmpDir) {
+  const cachedPath = await getCachedPackagePath(pkg, tmpDir);
+  return fs6.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 = path6.join(packageDir, "package.json");
+    if (await fs6.pathExists(packageJsonPath)) {
+      const packageJson = await fs6.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, configDir, tmpDir) {
+  const packagePaths = /* @__PURE__ */ new Map();
+  const downloadQueue = [...packages];
+  const processed = /* @__PURE__ */ new Set();
+  const userSpecifiedPackages = new Set(packages.map((p) => p.name));
+  const localPackageMap = /* @__PURE__ */ new Map();
+  for (const pkg of packages) {
+    if (pkg.path) {
+      localPackageMap.set(pkg.name, pkg.path);
+    }
+  }
+  validateNoDuplicatePackages(packages);
+  await fs6.ensureDir(targetDir);
+  while (downloadQueue.length > 0) {
+    const pkg = downloadQueue.shift();
+    const pkgKey = `${pkg.name}@${pkg.version}`;
+    if (processed.has(pkgKey)) {
+      continue;
+    }
+    processed.add(pkgKey);
+    if (!pkg.path && localPackageMap.has(pkg.name)) {
+      pkg.path = localPackageMap.get(pkg.name);
+    }
+    if (pkg.path) {
+      const localPkg = await resolveLocalPackage(
+        pkg.name,
+        pkg.path,
+        configDir || process.cwd(),
+        logger
+      );
+      const installedPath = await copyLocalPackage(localPkg, targetDir, logger);
+      packagePaths.set(pkg.name, installedPath);
+      const deps = await resolveDependencies(pkg, installedPath, logger);
+      for (const dep of deps) {
+        const depKey = `${dep.name}@${dep.version}`;
+        if (!processed.has(depKey)) {
+          downloadQueue.push(dep);
+        }
+      }
+      continue;
+    }
+    const packageSpec = `${pkg.name}@${pkg.version}`;
+    const packageDir = getPackageDirectory(targetDir, pkg.name, pkg.version);
+    const cachedPath = await getCachedPackagePath(pkg, tmpDir);
+    if (useCache && await isPackageCached(pkg, tmpDir)) {
+      if (userSpecifiedPackages.has(pkg.name)) {
+        logger.debug(`Downloading ${packageSpec} (cached)`);
+      }
+      try {
+        await fs6.ensureDir(path6.dirname(packageDir));
+        await fs6.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}`
+        );
+      }
+    }
+    try {
+      await fs6.ensureDir(path6.dirname(packageDir));
+      const cacheDir = process.env.NPM_CACHE_DIR || getTmpPath(tmpDir, "cache", "npm");
+      await withTimeout(
+        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
+        }),
+        PACKAGE_DOWNLOAD_TIMEOUT_MS,
+        `Package download timed out after ${PACKAGE_DOWNLOAD_TIMEOUT_MS / 1e3}s: ${packageSpec}`
+      );
+      if (userSpecifiedPackages.has(pkg.name)) {
+        const pkgStats = await fs6.stat(path6.join(packageDir, "package.json"));
+        const pkgJsonSize = pkgStats.size;
+        const sizeKB = (pkgJsonSize / 1024).toFixed(1);
+        logger.debug(`Downloading ${packageSpec} (${sizeKB} KB)`);
+      }
+      if (useCache) {
+        try {
+          await fs6.ensureDir(path6.dirname(cachedPath));
+          await fs6.copy(packageDir, cachedPath);
+        } catch (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/core/build-cache.ts
+import fs7 from "fs-extra";
+import path7 from "path";
+async function getBuildCachePath(configContent, tmpDir) {
+  const cacheDir = getTmpPath(tmpDir, "cache", "builds");
+  const cacheKey = await getFlowConfigCacheKey(configContent);
+  return path7.join(cacheDir, `${cacheKey}.js`);
+}
+async function isBuildCached(configContent, tmpDir) {
+  const cachePath = await getBuildCachePath(configContent, tmpDir);
+  return fs7.pathExists(cachePath);
+}
+async function cacheBuild(configContent, buildOutput, tmpDir) {
+  const cachePath = await getBuildCachePath(configContent, tmpDir);
+  await fs7.ensureDir(path7.dirname(cachePath));
+  await fs7.writeFile(cachePath, buildOutput, "utf-8");
+}
+async function getCachedBuild(configContent, tmpDir) {
+  const cachePath = await getBuildCachePath(configContent, tmpDir);
+  if (await fs7.pathExists(cachePath)) {
+    return await fs7.readFile(cachePath, "utf-8");
+  }
+  return null;
+}
+
+// src/commands/bundle/bundler.ts
+function isInlineCode(code) {
+  return code !== null && typeof code === "object" && !Array.isArray(code) && "push" in code;
+}
+function validateReference(type, name, ref) {
+  const hasPackage = !!ref.package;
+  const hasCode = isInlineCode(ref.code);
+  if (hasPackage && hasCode) {
+    throw new Error(
+      `${type} "${name}": Cannot specify both package and code. Use one or the other.`
+    );
+  }
+  if (!hasPackage && !hasCode) {
+    throw new Error(`${type} "${name}": Must specify either package or code.`);
+  }
+}
+function generateInlineCode(inline, config, env, chain, chainPropertyName, isDestination) {
+  const pushFn = inline.push.replace("$code:", "");
+  const initFn = inline.init ? inline.init.replace("$code:", "") : void 0;
+  const typeLine = inline.type ? `type: '${inline.type}',` : "";
+  const chainLine = chain && chainPropertyName ? `${chainPropertyName}: ${JSON.stringify(chain)},` : "";
+  if (isDestination) {
+    return `{
+      code: {
+        ${typeLine}
+        config: ${JSON.stringify(config || {})},
+        ${initFn ? `init: ${initFn},` : ""}
+        push: ${pushFn}
+      },
+      config: ${JSON.stringify(config || {})},
+      env: ${JSON.stringify(env || {})}${chain ? `,
+      ${chainLine.slice(0, -1)}` : ""}
+    }`;
+  }
+  return `{
+      code: async (context) => ({
+        ${typeLine}
+        config: context.config,
+        ${initFn ? `init: ${initFn},` : ""}
+        push: ${pushFn}
+      }),
+      config: ${JSON.stringify(config || {})},
+      env: ${JSON.stringify(env || {})}${chain ? `,
+      ${chainLine.slice(0, -1)}` : ""}
+    }`;
+}
+async function copyIncludes(includes, sourceDir, outputDir, logger) {
+  for (const include of includes) {
+    const sourcePath = path8.resolve(sourceDir, include);
+    const folderName = path8.basename(include);
+    const destPath = path8.join(outputDir, folderName);
+    if (await fs8.pathExists(sourcePath)) {
+      await fs8.copy(sourcePath, destPath);
+      logger.debug(`Copied ${include} to output`);
+    } else {
+      logger.debug(`Include folder not found: ${include}`);
+    }
+  }
+}
+function generateCacheKeyContent(flowConfig, buildOptions) {
+  const configForCache = {
+    flow: flowConfig,
+    build: {
+      ...buildOptions,
+      // Exclude non-deterministic fields from cache key
+      tempDir: void 0,
+      output: void 0
+    }
+  };
+  return JSON.stringify(configForCache);
+}
+function validateFlowConfig(flowConfig, logger) {
+  let hasDeprecatedCodeTrue = false;
+  const sources = flowConfig.sources || {};
+  for (const [sourceId, source] of Object.entries(sources)) {
+    if (source && typeof source === "object" && source.code === true) {
+      logger.warning(
+        `DEPRECATED: Source "${sourceId}" uses code: true which is no longer supported. Use $code: prefix in config values or create a source package instead.`
+      );
+      hasDeprecatedCodeTrue = true;
+    }
+  }
+  const destinations = flowConfig.destinations || {};
+  for (const [destId, dest] of Object.entries(destinations)) {
+    if (dest && typeof dest === "object" && dest.code === true) {
+      logger.warning(
+        `DEPRECATED: Destination "${destId}" uses code: true which is no longer supported. Use $code: prefix in config values or create a destination package instead.`
+      );
+      hasDeprecatedCodeTrue = true;
+    }
+  }
+  const transformers = flowConfig.transformers || {};
+  for (const [transformerId, transformer] of Object.entries(transformers)) {
+    if (transformer && typeof transformer === "object" && transformer.code === true) {
+      logger.warning(
+        `DEPRECATED: Transformer "${transformerId}" uses code: true which is no longer supported. Use $code: prefix in config values or create a transformer package instead.`
+      );
+      hasDeprecatedCodeTrue = true;
+    }
+  }
+  if (hasDeprecatedCodeTrue) {
+    logger.warning(
+      `See https://www.elbwalker.com/docs/walkeros/getting-started/flow for migration guide.`
+    );
+  }
+  return hasDeprecatedCodeTrue;
+}
+async function bundleCore(flowConfig, buildOptions, logger, showStats = false) {
+  const bundleStartTime = Date.now();
+  const hasDeprecatedFeatures = validateFlowConfig(flowConfig, logger);
+  if (hasDeprecatedFeatures) {
+    logger.warning("Skipping deprecated code: true entries from bundle.");
+  }
+  const TEMP_DIR = buildOptions.tempDir || getTmpPath();
+  if (buildOptions.cache !== false) {
+    const configContent = generateCacheKeyContent(flowConfig, buildOptions);
+    const cached = await isBuildCached(configContent, TEMP_DIR);
+    if (cached) {
+      const cachedBuild = await getCachedBuild(configContent, TEMP_DIR);
+      if (cachedBuild) {
+        logger.debug("Using cached build");
+        const outputPath = path8.resolve(buildOptions.output);
+        await fs8.ensureDir(path8.dirname(outputPath));
+        await fs8.writeFile(outputPath, cachedBuild);
+        const stats = await fs8.stat(outputPath);
+        const sizeKB = (stats.size / 1024).toFixed(1);
+        logger.log(`Output: ${outputPath} (${sizeKB} KB, cached)`);
+        if (showStats) {
+          const stats2 = await fs8.stat(outputPath);
+          const packageStats = Object.entries(buildOptions.packages).map(
+            ([name, pkg]) => ({
+              name: `${name}@${pkg.version || "latest"}`,
+              size: 0
+              // Size estimation not available for cached builds
+            })
+          );
+          return {
+            totalSize: stats2.size,
+            packages: packageStats,
+            buildTime: Date.now() - bundleStartTime,
+            treeshakingEffective: true
+          };
+        }
+        return;
+      }
+    }
+  }
+  try {
+    await fs8.ensureDir(TEMP_DIR);
+    const hasSourcesOrDests = Object.keys(
+      flowConfig.sources || {}
+    ).length > 0 || Object.keys(
+      flowConfig.destinations || {}
+    ).length > 0;
+    if (hasSourcesOrDests && !buildOptions.packages["@walkeros/collector"]) {
+      buildOptions.packages["@walkeros/collector"] = {};
+    }
+    logger.debug("Downloading packages");
+    const packagesArray = Object.entries(buildOptions.packages).map(
+      ([name, packageConfig]) => ({
+        name,
+        version: packageConfig.version || "latest",
+        path: packageConfig.path
+        // Pass local path if defined
+      })
+    );
+    const packagePaths = await downloadPackages(
+      packagesArray,
+      TEMP_DIR,
+      logger,
+      buildOptions.cache,
+      buildOptions.configDir,
+      // For resolving relative local paths
+      TEMP_DIR
+    );
+    for (const [pkgName, pkgPath] of packagePaths.entries()) {
+      if (pkgName.startsWith("@walkeros/")) {
+        const pkgJsonPath = path8.join(pkgPath, "package.json");
+        const pkgJson = await fs8.readJSON(pkgJsonPath);
+        if (!pkgJson.exports && pkgJson.module) {
+          pkgJson.exports = {
+            ".": {
+              import: pkgJson.module,
+              require: pkgJson.main
+            }
+          };
+          await fs8.writeJSON(pkgJsonPath, pkgJson, { spaces: 2 });
+        }
+      }
+    }
+    const packageJsonPath = path8.join(TEMP_DIR, "package.json");
+    await fs8.writeFile(
+      packageJsonPath,
+      JSON.stringify({ type: "module" }, null, 2)
+    );
+    logger.debug("Creating entry point");
+    const entryContent = await createEntryPoint(
+      flowConfig,
+      buildOptions,
+      packagePaths
+    );
+    const entryPath = path8.join(TEMP_DIR, "entry.js");
+    await fs8.writeFile(entryPath, entryContent);
+    logger.debug(
+      `Running esbuild (target: ${buildOptions.target || "es2018"}, format: ${buildOptions.format})`
+    );
+    const outputPath = path8.resolve(buildOptions.output);
+    await fs8.ensureDir(path8.dirname(outputPath));
+    const esbuildOptions = createEsbuildOptions(
+      buildOptions,
+      entryPath,
+      outputPath,
+      TEMP_DIR,
+      packagePaths,
+      logger
+    );
+    try {
+      await esbuild.build(esbuildOptions);
+    } catch (buildError) {
+      throw createBuildError(
+        buildError,
+        buildOptions.code || ""
+      );
+    } finally {
+      await esbuild.stop();
+    }
+    const outputStats = await fs8.stat(outputPath);
+    const sizeKB = (outputStats.size / 1024).toFixed(1);
+    const buildTime = ((Date.now() - bundleStartTime) / 1e3).toFixed(1);
+    logger.log(`Output: ${outputPath} (${sizeKB} KB, ${buildTime}s)`);
+    if (buildOptions.cache !== false) {
+      const configContent = generateCacheKeyContent(flowConfig, buildOptions);
+      const buildOutput = await fs8.readFile(outputPath, "utf-8");
+      await cacheBuild(configContent, buildOutput, TEMP_DIR);
+      logger.debug("Build cached for future use");
+    }
+    let stats;
+    if (showStats) {
+      stats = await collectBundleStats(
+        outputPath,
+        buildOptions.packages,
+        bundleStartTime,
+        entryContent
+      );
+    }
+    if (buildOptions.include && buildOptions.include.length > 0) {
+      const outputDir = path8.dirname(outputPath);
+      await copyIncludes(
+        buildOptions.include,
+        buildOptions.configDir || process.cwd(),
+        outputDir,
+        logger
+      );
+    }
+    return stats;
+  } catch (error) {
+    throw error;
+  }
+}
+async function collectBundleStats(outputPath, packages, startTime2, entryContent) {
+  const stats = await fs8.stat(outputPath);
+  const totalSize = stats.size;
+  const buildTime = Date.now() - startTime2;
+  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.format === "esm") {
+      baseOptions.banner = {
+        js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`
+      };
+    }
+  }
+  if (buildOptions.target) {
+    baseOptions.target = buildOptions.target;
+  } else if (buildOptions.platform === "node") {
+    baseOptions.target = "node18";
+  } else {
+    baseOptions.target = "es2018";
+  }
+  return baseOptions;
+}
+function detectDestinationPackages(flowConfig) {
+  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 && "code" in destConfig && destConfig.code === true) {
+        continue;
+      }
+      if (typeof destConfig === "object" && destConfig !== null && "package" in destConfig && typeof destConfig.package === "string") {
+        destinationPackages.add(destConfig.package);
+      }
+    }
+  }
+  return 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 && "code" in sourceConfig && sourceConfig.code === true) {
+        continue;
+      }
+      if (typeof sourceConfig === "object" && sourceConfig !== null && "package" in sourceConfig && typeof sourceConfig.package === "string") {
+        sourcePackages.add(sourceConfig.package);
+      }
+    }
+  }
+  return sourcePackages;
+}
+function detectTransformerPackages(flowConfig) {
+  const transformerPackages = /* @__PURE__ */ new Set();
+  const transformers = flowConfig.transformers;
+  if (transformers) {
+    for (const [transformerKey, transformerConfig] of Object.entries(
+      transformers
+    )) {
+      if (typeof transformerConfig === "object" && transformerConfig !== null && "code" in transformerConfig && transformerConfig.code === true) {
+        continue;
+      }
+      if (typeof transformerConfig === "object" && transformerConfig !== null && "package" in transformerConfig && typeof transformerConfig.package === "string") {
+        transformerPackages.add(transformerConfig.package);
+      }
+    }
+  }
+  return transformerPackages;
+}
+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 && "code" in destConfig && destConfig.code === true) {
+        continue;
+      }
+      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 && "code" in sourceConfig && sourceConfig.code === true) {
+        continue;
+      }
+      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);
+        }
+      }
+    }
+  }
+  const transformers = flowConfig.transformers;
+  if (transformers) {
+    for (const [transformerKey, transformerConfig] of Object.entries(
+      transformers
+    )) {
+      if (typeof transformerConfig === "object" && transformerConfig !== null && "code" in transformerConfig && transformerConfig.code === true) {
+        continue;
+      }
+      if (typeof transformerConfig === "object" && transformerConfig !== null && "package" in transformerConfig && typeof transformerConfig.package === "string" && "code" in transformerConfig && typeof transformerConfig.code === "string") {
+        const isAutoGenerated = transformerConfig.code.startsWith("_");
+        if (!isAutoGenerated) {
+          if (!explicitCodeImports.has(transformerConfig.package)) {
+            explicitCodeImports.set(transformerConfig.package, /* @__PURE__ */ new Set());
+          }
+          explicitCodeImports.get(transformerConfig.package).add(transformerConfig.code);
+        }
+      }
+    }
+  }
+  return explicitCodeImports;
+}
+function generateImportStatements(packages, destinationPackages, sourcePackages, transformerPackages, explicitCodeImports) {
+  const importStatements = [];
+  const examplesMappings = [];
+  const usedPackages = /* @__PURE__ */ new Set([
+    ...destinationPackages,
+    ...sourcePackages,
+    ...transformerPackages
+  ]);
+  for (const [packageName, packageConfig] of Object.entries(packages)) {
+    const isUsedByDestOrSource = usedPackages.has(packageName);
+    const hasExplicitCode = explicitCodeImports.has(packageName);
+    const namedImportsToGenerate = [];
+    if (isUsedByDestOrSource && !hasExplicitCode) {
+      const varName = packageNameToVariable(packageName);
+      importStatements.push(`import ${varName} from '${packageName}';`);
+    }
+    if (hasExplicitCode) {
+      const codes = Array.from(explicitCodeImports.get(packageName));
+      namedImportsToGenerate.push(...codes);
+    }
+    if (packageConfig.imports && packageConfig.imports.length > 0) {
+      const uniqueImports = [...new Set(packageConfig.imports)];
+      for (const imp of uniqueImports) {
+        if (imp.startsWith("default as ")) {
+          if (!isUsedByDestOrSource || hasExplicitCode) {
+            const defaultImportName = imp.replace("default as ", "");
+            importStatements.push(
+              `import ${defaultImportName} from '${packageName}';`
+            );
+          }
+        } else {
+          if (!namedImportsToGenerate.includes(imp)) {
+            namedImportsToGenerate.push(imp);
+          }
+        }
+      }
+      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`
+          );
+        }
+      }
+    }
+    if (packageName === "@walkeros/collector" && !namedImportsToGenerate.includes("startFlow")) {
+      namedImportsToGenerate.push("startFlow");
+    }
+    if (namedImportsToGenerate.length > 0) {
+      const importList = namedImportsToGenerate.join(", ");
+      importStatements.push(`import { ${importList} } from '${packageName}';`);
+    }
+  }
+  return { importStatements, examplesMappings };
+}
+async function createEntryPoint(flowConfig, buildOptions, packagePaths) {
+  const destinationPackages = detectDestinationPackages(flowConfig);
+  const sourcePackages = detectSourcePackages(flowConfig);
+  const transformerPackages = detectTransformerPackages(flowConfig);
+  const explicitCodeImports = detectExplicitCodeImports(flowConfig);
+  const { importStatements } = generateImportStatements(
+    buildOptions.packages,
+    destinationPackages,
+    sourcePackages,
+    transformerPackages,
+    explicitCodeImports
+  );
+  const importsCode = importStatements.join("\n");
+  const hasFlow = Object.values(flowConfig.sources || {}).some(
+    (s) => s.package || isInlineCode(s.code)
+  ) || Object.values(flowConfig.destinations || {}).some(
+    (d) => d.package || isInlineCode(d.code)
+  );
+  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) {
+    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}` : "")
+  );
+}
+function buildConfigObject(flowConfig, explicitCodeImports) {
+  const flowWithProps = flowConfig;
+  const sources = flowWithProps.sources || {};
+  const destinations = flowWithProps.destinations || {};
+  const transformers = flowWithProps.transformers || {};
+  Object.entries(sources).forEach(([name, source]) => {
+    if (source.code !== true) {
+      validateReference("Source", name, source);
+    }
+  });
+  Object.entries(destinations).forEach(([name, dest]) => {
+    if (dest.code !== true) {
+      validateReference("Destination", name, dest);
+    }
+  });
+  Object.entries(transformers).forEach(([name, transformer]) => {
+    if (transformer.code !== true) {
+      validateReference("Transformer", name, transformer);
+    }
+  });
+  const sourcesEntries = Object.entries(sources).filter(
+    ([, source]) => source.code !== true && (source.package || isInlineCode(source.code))
+  ).map(([key, source]) => {
+    if (isInlineCode(source.code)) {
+      return `    ${key}: ${generateInlineCode(source.code, source.config || {}, source.env, source.next, "next")}`;
+    }
+    let codeVar;
+    if (source.code && typeof source.code === "string" && explicitCodeImports.has(source.package)) {
+      codeVar = source.code;
+    } else {
+      codeVar = packageNameToVariable(source.package);
+    }
+    const configStr = source.config ? processConfigValue(source.config) : "{}";
+    const envStr = source.env ? `,
+      env: ${processConfigValue(source.env)}` : "";
+    const nextStr = source.next ? `,
+      next: ${JSON.stringify(source.next)}` : "";
+    return `    ${key}: {
+      code: ${codeVar},
+      config: ${configStr}${envStr}${nextStr}
+    }`;
+  });
+  const destinationsEntries = Object.entries(destinations).filter(
+    ([, dest]) => dest.code !== true && (dest.package || isInlineCode(dest.code))
+  ).map(([key, dest]) => {
+    if (isInlineCode(dest.code)) {
+      return `    ${key}: ${generateInlineCode(dest.code, dest.config || {}, dest.env, dest.before, "before", true)}`;
+    }
+    let codeVar;
+    if (dest.code && typeof dest.code === "string" && explicitCodeImports.has(dest.package)) {
+      codeVar = dest.code;
+    } else {
+      codeVar = packageNameToVariable(dest.package);
+    }
+    const configStr = dest.config ? processConfigValue(dest.config) : "{}";
+    const envStr = dest.env ? `,
+      env: ${processConfigValue(dest.env)}` : "";
+    const beforeStr = dest.before ? `,
+      before: ${JSON.stringify(dest.before)}` : "";
+    return `    ${key}: {
+      code: ${codeVar},
+      config: ${configStr}${envStr}${beforeStr}
+    }`;
+  });
+  const transformersEntries = Object.entries(transformers).filter(
+    ([, transformer]) => transformer.code !== true && (transformer.package || isInlineCode(transformer.code))
+  ).map(([key, transformer]) => {
+    if (isInlineCode(transformer.code)) {
+      return `    ${key}: ${generateInlineCode(transformer.code, transformer.config || {}, transformer.env, transformer.next, "next")}`;
+    }
+    let codeVar;
+    if (transformer.code && typeof transformer.code === "string" && explicitCodeImports.has(transformer.package)) {
+      codeVar = transformer.code;
+    } else {
+      codeVar = packageNameToVariable(transformer.package);
+    }
+    const configStr = transformer.config ? processConfigValue(transformer.config) : "{}";
+    const envStr = transformer.env ? `,
+      env: ${processConfigValue(transformer.env)}` : "";
+    const nextStr = transformer.next ? `,
+      next: ${JSON.stringify(transformer.next)}` : "";
+    return `    ${key}: {
+      code: ${codeVar},
+      config: ${configStr}${envStr}${nextStr}
+    }`;
+  });
+  const collectorStr = flowWithProps.collector ? `,
+  ...${processConfigValue(flowWithProps.collector)}` : "";
+  const transformersStr = transformersEntries.length > 0 ? `,
+  transformers: {
+${transformersEntries.join(",\n")}
+  }` : "";
+  return `{
+  sources: {
+${sourcesEntries.join(",\n")}
+  },
+  destinations: {
+${destinationsEntries.join(",\n")}
+  }${transformersStr}${collectorStr}
+}`;
+}
+function processConfigValue(value) {
+  return serializeWithCode(value, 0);
+}
+function serializeWithCode(value, indent) {
+  const spaces = "  ".repeat(indent);
+  const nextSpaces = "  ".repeat(indent + 1);
+  if (typeof value === "string") {
+    if (value.startsWith("$code:")) {
+      return value.slice(6);
+    }
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "[]";
+    const items = value.map(
+      (v) => nextSpaces + serializeWithCode(v, indent + 1)
+    );
+    return `[
+${items.join(",\n")}
+${spaces}]`;
+  }
+  if (value !== null && typeof value === "object") {
+    const entries = Object.entries(value);
+    if (entries.length === 0) return "{}";
+    const props = entries.map(
+      ([k, v]) => `${nextSpaces}${JSON.stringify(k)}: ${serializeWithCode(v, indent + 1)}`
+    );
+    return `{
+${props.join(",\n")}
+${spaces}}`;
+  }
+  return JSON.stringify(value);
+}
+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}
+  // Apply context overrides (e.g., logger config from CLI)
+  if (context.logger) {
+    config.logger = { ...config.logger, ...context.logger };
+  }
+
+  return await startFlow(config);
+}`;
+  }
+}
+
+// src/core/api-client.ts
+import createClient from "openapi-fetch";
+
+// src/commands/bundle/index.ts
+async function bundle(configOrPath, options = {}) {
+  let rawConfig;
+  let configPath = path9.resolve(process.cwd(), "walkeros.config.json");
+  if (typeof configOrPath === "string") {
+    configPath = resolveAsset(configOrPath, "config");
+    rawConfig = await loadJsonConfig(configPath);
+  } else {
+    rawConfig = configOrPath;
+  }
+  const { flowConfig, buildOptions } = loadBundleConfig(rawConfig, {
+    configPath,
+    flowName: options.flowName,
+    buildOverrides: options.buildOverrides
+  });
+  if (options.cache !== void 0) {
+    buildOptions.cache = options.cache;
+  }
+  const logger = createCommandLogger(options);
+  return await bundleCore(
+    flowConfig,
+    buildOptions,
+    logger,
+    options.stats ?? false
+  );
+}
+
+// src/commands/run/utils.ts
+async function prepareBundleForRun(configPath, options) {
+  const tempDir = getTmpPath(
+    void 0,
+    `run-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
+  );
+  await fs10.ensureDir(tempDir);
+  const tempPath = path10.join(tempDir, "bundle.mjs");
+  await bundle(configPath, {
+    cache: true,
+    verbose: options.verbose,
+    silent: options.silent,
+    buildOverrides: {
+      output: tempPath,
+      format: "esm",
+      platform: "node"
+    }
+  });
+  return tempPath;
+}
+function isPreBuiltConfig(configPath) {
+  return configPath.endsWith(".mjs") || configPath.endsWith(".js") || configPath.endsWith(".cjs");
+}
+
+// src/runtime/main.ts
+import { writeFileSync as writeFileSync4, readFileSync as readFileSync4 } from "fs";
+function adaptLogger(cliLogger) {
+  return {
+    error: (message) => {
+      cliLogger.error(message instanceof Error ? message.message : message);
+    },
+    info: (message) => {
+      cliLogger.info(message instanceof Error ? message.message : message);
+    },
+    debug: (message) => {
+      cliLogger.debug(message instanceof Error ? message.message : message);
+    },
+    throw: (message) => {
+      const msg = message instanceof Error ? message.message : message;
+      cliLogger.error(msg);
+      throw message instanceof Error ? message : new Error(msg);
+    },
+    scope: (_name) => adaptLogger(cliLogger)
+  };
+}
+function resolveAppUrl2() {
+  return process.env.APP_URL || process.env.WALKEROS_APP_URL || "https://app.walkeros.io";
+}
+async function main() {
+  const cliLogger = createLogger({ silent: false, verbose: true });
+  const logger = adaptLogger(cliLogger);
+  let env;
+  try {
+    env = validateEnv(process.env);
+  } catch (error) {
+    cliLogger.error(
+      `Configuration error: ${error instanceof Error ? error.message : error}`
+    );
+    process.exit(1);
+  }
+  cliLogger.log(`walkeros/flow v${VERSION} \u2014 ${env.mode} mode`);
+  cliLogger.log(`Instance: ${getInstanceId()}`);
+  initStatus({
+    mode: env.mode,
+    port: env.port,
+    configSource: env.remoteConfig ? "api" : "local",
+    apiEnabled: env.apiEnabled
+  });
+  if (env.mode === "serve") {
+    setRunning();
+    await runServeMode({ port: env.port, file: env.bundlePath }, logger);
+    return;
+  }
+  let configPath = null;
+  let configVersion;
+  if (env.remoteConfig) {
+    cliLogger.log("Fetching config from API...");
+    try {
+      const result = await fetchConfig({
+        appUrl: resolveAppUrl2(),
+        token: env.token,
+        projectId: env.projectId,
+        flowId: env.flowId
+      });
+      if (result.changed) {
+        const tmpConfigPath = `/tmp/walkeros-flow-${Date.now()}.json`;
+        writeFileSync4(
+          tmpConfigPath,
+          JSON.stringify(result.content, null, 2),
+          "utf-8"
+        );
+        configPath = tmpConfigPath;
+        configVersion = result.version;
+        cliLogger.log(`Config version: ${result.version}`);
+      }
+    } catch (error) {
+      cliLogger.error(
+        `API fetch failed: ${error instanceof Error ? error.message : error}`
+      );
+      const cached = readCache(env.cacheDir);
+      if (cached) {
+        cliLogger.log(`Using cached bundle (version: ${cached.version})`);
+        await runWithBundle(
+          cached.bundlePath,
+          env,
+          logger,
+          cliLogger,
+          cached.version
+        );
+        return;
+      }
+      cliLogger.error("No cached bundle available. Cannot start.");
+      process.exit(1);
+    }
+  } else {
+    const resolved = await resolveBundle(env.bundlePath);
+    if (resolved.source === "stdin") {
+      cliLogger.log("Bundle: received via stdin");
+    } else if (resolved.source === "url") {
+      cliLogger.log("Bundle: fetched from URL");
+    } else {
+      cliLogger.log(`Bundle: ${resolved.path}`);
+    }
+    if (isPreBuiltConfig(resolved.path)) {
+      await runWithBundle(resolved.path, env, logger, cliLogger, void 0);
+      return;
+    }
+    configPath = resolved.path;
+  }
+  if (!configPath) {
+    cliLogger.error("No config resolved");
+    process.exit(1);
+  }
+  cliLogger.log("Building flow...");
+  let bundlePath;
+  try {
+    bundlePath = await prepareBundleForRun(configPath, {
+      verbose: false,
+      silent: true
+    });
+  } catch (error) {
+    cliLogger.error(
+      `Bundle failed: ${error instanceof Error ? error.message : error}`
+    );
+    if (env.remoteConfig) {
+      const cached = readCache(env.cacheDir);
+      if (cached) {
+        cliLogger.log(`Using cached bundle (version: ${cached.version})`);
+        await runWithBundle(
+          cached.bundlePath,
+          env,
+          logger,
+          cliLogger,
+          cached.version
+        );
+        return;
+      }
+    }
+    process.exit(1);
+  }
+  cliLogger.log("Bundle ready");
+  try {
+    const configContent = readFileSync4(configPath, "utf-8");
+    writeCache(
+      env.cacheDir,
+      bundlePath,
+      configContent,
+      configVersion || "local"
+    );
+  } catch {
+    cliLogger.debug("Cache write failed (non-critical)");
+  }
+  await runWithBundle(bundlePath, env, logger, cliLogger, configVersion);
+}
+async function runWithBundle(bundlePath, env, logger, cliLogger, configVersion) {
+  let handle;
+  try {
+    handle = await loadFlow(bundlePath, { port: env.port }, logger);
+  } catch (error) {
+    cliLogger.error(
+      `Failed to load flow: ${error instanceof Error ? error.message : error}`
+    );
+    process.exit(1);
+  }
+  setRunning();
+  cliLogger.log("Flow running");
+  cliLogger.log(`Port: ${env.port}`);
+  let heartbeat = null;
+  let poller = null;
+  if (env.apiEnabled) {
+    heartbeat = createHeartbeat(
+      {
+        appUrl: resolveAppUrl2(),
+        token: env.token,
+        projectId: env.projectId,
+        flowId: env.flowId,
+        configVersion,
+        mode: env.mode,
+        intervalMs: env.heartbeatInterval * 1e3
+      },
+      logger
+    );
+    heartbeat.start();
+    cliLogger.log(`Heartbeat: active (every ${env.heartbeatInterval}s)`);
+  }
+  if (env.remoteConfig) {
+    poller = createPoller(
+      {
+        fetchOptions: {
+          appUrl: resolveAppUrl2(),
+          token: env.token,
+          projectId: env.projectId,
+          flowId: env.flowId
+        },
+        intervalMs: env.pollInterval * 1e3,
+        onUpdate: async (content, version) => {
+          const tmpConfigPath = `/tmp/walkeros-flow-${Date.now()}.json`;
+          writeFileSync4(
+            tmpConfigPath,
+            JSON.stringify(content, null, 2),
+            "utf-8"
+          );
+          const newBundle = await prepareBundleForRun(tmpConfigPath, {
+            verbose: false,
+            silent: true
+          });
+          handle = await swapFlow(
+            handle,
+            newBundle,
+            { port: env.port },
+            logger
+          );
+          writeCache(env.cacheDir, newBundle, JSON.stringify(content), version);
+          configVersion = version;
+          if (heartbeat) heartbeat.updateConfigVersion(version);
+          updateConfigVersion(version);
+          updateLastPoll();
+          cliLogger.log(`Hot-swapped to version ${version}`);
+        }
+      },
+      logger
+    );
+    poller.start();
+    cliLogger.log(`Polling: active (every ${env.pollInterval}s)`);
+  }
+  const shutdown = async (signal) => {
+    cliLogger.log(`Received ${signal}, shutting down...`);
+    if (poller) poller.stop();
+    if (heartbeat) heartbeat.stop();
+    try {
+      if (handle.collector.command) {
+        await handle.collector.command("shutdown");
+      }
+    } catch {
+    }
+    cliLogger.log("Shutdown complete");
+    process.exit(0);
+  };
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  await new Promise(() => {
+  });
 }
 main();