@walkeros/cli 1.2.0 → 1.3.0

package/dist/index.js

@@ -1,8 +1,611 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../../node_modules/is-docker/index.js
+import fs15 from "fs";
+function hasDockerEnv() {
+  try {
+    fs15.statSync("/.dockerenv");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasDockerCGroup() {
+  try {
+    return fs15.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+  } catch {
+    return false;
+  }
+}
+function isDocker() {
+  if (isDockerCached === void 0) {
+    isDockerCached = hasDockerEnv() || hasDockerCGroup();
+  }
+  return isDockerCached;
+}
+var isDockerCached;
+var init_is_docker = __esm({
+  "../../node_modules/is-docker/index.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/is-inside-container/index.js
+import fs16 from "fs";
+function isInsideContainer() {
+  if (cachedResult === void 0) {
+    cachedResult = hasContainerEnv() || isDocker();
+  }
+  return cachedResult;
+}
+var cachedResult, hasContainerEnv;
+var init_is_inside_container = __esm({
+  "../../node_modules/is-inside-container/index.js"() {
+    "use strict";
+    init_is_docker();
+    hasContainerEnv = () => {
+      try {
+        fs16.statSync("/run/.containerenv");
+        return true;
+      } catch {
+        return false;
+      }
+    };
+  }
+});
+
+// ../../node_modules/is-wsl/index.js
+import process2 from "process";
+import os from "os";
+import fs17 from "fs";
+var isWsl, is_wsl_default;
+var init_is_wsl = __esm({
+  "../../node_modules/is-wsl/index.js"() {
+    "use strict";
+    init_is_inside_container();
+    isWsl = () => {
+      if (process2.platform !== "linux") {
+        return false;
+      }
+      if (os.release().toLowerCase().includes("microsoft")) {
+        if (isInsideContainer()) {
+          return false;
+        }
+        return true;
+      }
+      try {
+        return fs17.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft") ? !isInsideContainer() : false;
+      } catch {
+        return false;
+      }
+    };
+    is_wsl_default = process2.env.__IS_WSL_TEST__ ? isWsl : isWsl();
+  }
+});
+
+// ../../node_modules/wsl-utils/index.js
+import process3 from "process";
+import fs18, { constants as fsConstants } from "fs/promises";
+var wslDrivesMountPoint, powerShellPathFromWsl, powerShellPath;
+var init_wsl_utils = __esm({
+  "../../node_modules/wsl-utils/index.js"() {
+    "use strict";
+    init_is_wsl();
+    init_is_wsl();
+    wslDrivesMountPoint = /* @__PURE__ */ (() => {
+      const defaultMountPoint = "/mnt/";
+      let mountPoint;
+      return async function() {
+        if (mountPoint) {
+          return mountPoint;
+        }
+        const configFilePath = "/etc/wsl.conf";
+        let isConfigFileExists = false;
+        try {
+          await fs18.access(configFilePath, fsConstants.F_OK);
+          isConfigFileExists = true;
+        } catch {
+        }
+        if (!isConfigFileExists) {
+          return defaultMountPoint;
+        }
+        const configContent = await fs18.readFile(configFilePath, { encoding: "utf8" });
+        const configMountPoint = /(?<!#.*)root\s*=\s*(?<mountPoint>.*)/g.exec(configContent);
+        if (!configMountPoint) {
+          return defaultMountPoint;
+        }
+        mountPoint = configMountPoint.groups.mountPoint.trim();
+        mountPoint = mountPoint.endsWith("/") ? mountPoint : `${mountPoint}/`;
+        return mountPoint;
+      };
+    })();
+    powerShellPathFromWsl = async () => {
+      const mountPoint = await wslDrivesMountPoint();
+      return `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe`;
+    };
+    powerShellPath = async () => {
+      if (is_wsl_default) {
+        return powerShellPathFromWsl();
+      }
+      return `${process3.env.SYSTEMROOT || process3.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
+    };
+  }
+});
+
+// ../../node_modules/define-lazy-prop/index.js
+function defineLazyProperty(object, propertyName, valueGetter) {
+  const define = (value) => Object.defineProperty(object, propertyName, { value, enumerable: true, writable: true });
+  Object.defineProperty(object, propertyName, {
+    configurable: true,
+    enumerable: true,
+    get() {
+      const result = valueGetter();
+      define(result);
+      return result;
+    },
+    set(value) {
+      define(value);
+    }
+  });
+  return object;
+}
+var init_define_lazy_prop = __esm({
+  "../../node_modules/define-lazy-prop/index.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/default-browser-id/index.js
+import { promisify } from "util";
+import process4 from "process";
+import { execFile } from "child_process";
+async function defaultBrowserId() {
+  if (process4.platform !== "darwin") {
+    throw new Error("macOS only");
+  }
+  const { stdout } = await execFileAsync("defaults", ["read", "com.apple.LaunchServices/com.apple.launchservices.secure", "LSHandlers"]);
+  const match = /LSHandlerRoleAll = "(?!-)(?<id>[^"]+?)";\s+?LSHandlerURLScheme = (?:http|https);/.exec(stdout);
+  const browserId = match?.groups.id ?? "com.apple.Safari";
+  if (browserId === "com.apple.safari") {
+    return "com.apple.Safari";
+  }
+  return browserId;
+}
+var execFileAsync;
+var init_default_browser_id = __esm({
+  "../../node_modules/default-browser-id/index.js"() {
+    "use strict";
+    execFileAsync = promisify(execFile);
+  }
+});
+
+// ../../node_modules/run-applescript/index.js
+import process5 from "process";
+import { promisify as promisify2 } from "util";
+import { execFile as execFile2, execFileSync } from "child_process";
+async function runAppleScript(script, { humanReadableOutput = true, signal } = {}) {
+  if (process5.platform !== "darwin") {
+    throw new Error("macOS only");
+  }
+  const outputArguments = humanReadableOutput ? [] : ["-ss"];
+  const execOptions = {};
+  if (signal) {
+    execOptions.signal = signal;
+  }
+  const { stdout } = await execFileAsync2("osascript", ["-e", script, outputArguments], execOptions);
+  return stdout.trim();
+}
+var execFileAsync2;
+var init_run_applescript = __esm({
+  "../../node_modules/run-applescript/index.js"() {
+    "use strict";
+    execFileAsync2 = promisify2(execFile2);
+  }
+});
+
+// ../../node_modules/bundle-name/index.js
+async function bundleName(bundleId) {
+  return runAppleScript(`tell application "Finder" to set app_path to application file id "${bundleId}" as string
+tell application "System Events" to get value of property list item "CFBundleName" of property list file (app_path & ":Contents:Info.plist")`);
+}
+var init_bundle_name = __esm({
+  "../../node_modules/bundle-name/index.js"() {
+    "use strict";
+    init_run_applescript();
+  }
+});
+
+// ../../node_modules/default-browser/windows.js
+import { promisify as promisify3 } from "util";
+import { execFile as execFile3 } from "child_process";
+async function defaultBrowser(_execFileAsync = execFileAsync3) {
+  const { stdout } = await _execFileAsync("reg", [
+    "QUERY",
+    " HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice",
+    "/v",
+    "ProgId"
+  ]);
+  const match = /ProgId\s*REG_SZ\s*(?<id>\S+)/.exec(stdout);
+  if (!match) {
+    throw new UnknownBrowserError(`Cannot find Windows browser in stdout: ${JSON.stringify(stdout)}`);
+  }
+  const { id } = match.groups;
+  const browser = windowsBrowserProgIds[id];
+  if (!browser) {
+    throw new UnknownBrowserError(`Unknown browser ID: ${id}`);
+  }
+  return browser;
+}
+var execFileAsync3, windowsBrowserProgIds, _windowsBrowserProgIdMap, UnknownBrowserError;
+var init_windows = __esm({
+  "../../node_modules/default-browser/windows.js"() {
+    "use strict";
+    execFileAsync3 = promisify3(execFile3);
+    windowsBrowserProgIds = {
+      MSEdgeHTM: { name: "Edge", id: "com.microsoft.edge" },
+      // The missing `L` is correct.
+      MSEdgeBHTML: { name: "Edge Beta", id: "com.microsoft.edge.beta" },
+      MSEdgeDHTML: { name: "Edge Dev", id: "com.microsoft.edge.dev" },
+      AppXq0fevzme2pys62n3e0fbqa7peapykr8v: { name: "Edge", id: "com.microsoft.edge.old" },
+      ChromeHTML: { name: "Chrome", id: "com.google.chrome" },
+      ChromeBHTML: { name: "Chrome Beta", id: "com.google.chrome.beta" },
+      ChromeDHTML: { name: "Chrome Dev", id: "com.google.chrome.dev" },
+      ChromiumHTM: { name: "Chromium", id: "org.chromium.Chromium" },
+      BraveHTML: { name: "Brave", id: "com.brave.Browser" },
+      BraveBHTML: { name: "Brave Beta", id: "com.brave.Browser.beta" },
+      BraveDHTML: { name: "Brave Dev", id: "com.brave.Browser.dev" },
+      BraveSSHTM: { name: "Brave Nightly", id: "com.brave.Browser.nightly" },
+      FirefoxURL: { name: "Firefox", id: "org.mozilla.firefox" },
+      OperaStable: { name: "Opera", id: "com.operasoftware.Opera" },
+      VivaldiHTM: { name: "Vivaldi", id: "com.vivaldi.Vivaldi" },
+      "IE.HTTP": { name: "Internet Explorer", id: "com.microsoft.ie" }
+    };
+    _windowsBrowserProgIdMap = new Map(Object.entries(windowsBrowserProgIds));
+    UnknownBrowserError = class extends Error {
+    };
+  }
+});
+
+// ../../node_modules/default-browser/index.js
+import { promisify as promisify4 } from "util";
+import process6 from "process";
+import { execFile as execFile4 } from "child_process";
+async function defaultBrowser2() {
+  if (process6.platform === "darwin") {
+    const id = await defaultBrowserId();
+    const name = await bundleName(id);
+    return { name, id };
+  }
+  if (process6.platform === "linux") {
+    const { stdout } = await execFileAsync4("xdg-mime", ["query", "default", "x-scheme-handler/http"]);
+    const id = stdout.trim();
+    const name = titleize(id.replace(/.desktop$/, "").replace("-", " "));
+    return { name, id };
+  }
+  if (process6.platform === "win32") {
+    return defaultBrowser();
+  }
+  throw new Error("Only macOS, Linux, and Windows are supported");
+}
+var execFileAsync4, titleize;
+var init_default_browser = __esm({
+  "../../node_modules/default-browser/index.js"() {
+    "use strict";
+    init_default_browser_id();
+    init_bundle_name();
+    init_windows();
+    execFileAsync4 = promisify4(execFile4);
+    titleize = (string) => string.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x) => x.toUpperCase());
+  }
+});
+
+// ../../node_modules/open/index.js
+var open_exports = {};
+__export(open_exports, {
+  apps: () => apps,
+  default: () => open_default,
+  openApp: () => openApp
+});
+import process7 from "process";
+import { Buffer as Buffer2 } from "buffer";
+import path15 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { promisify as promisify5 } from "util";
+import childProcess from "child_process";
+import fs19, { constants as fsConstants2 } from "fs/promises";
+async function getWindowsDefaultBrowserFromWsl() {
+  const powershellPath = await powerShellPath();
+  const rawCommand = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
+  const encodedCommand = Buffer2.from(rawCommand, "utf16le").toString("base64");
+  const { stdout } = await execFile5(
+    powershellPath,
+    [
+      "-NoProfile",
+      "-NonInteractive",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-EncodedCommand",
+      encodedCommand
+    ],
+    { encoding: "utf8" }
+  );
+  const progId = stdout.trim();
+  const browserMap = {
+    ChromeHTML: "com.google.chrome",
+    BraveHTML: "com.brave.Browser",
+    MSEdgeHTM: "com.microsoft.edge",
+    FirefoxURL: "org.mozilla.firefox"
+  };
+  return browserMap[progId] ? { id: browserMap[progId] } : {};
+}
+function detectArchBinary(binary) {
+  if (typeof binary === "string" || Array.isArray(binary)) {
+    return binary;
+  }
+  const { [arch]: archBinary } = binary;
+  if (!archBinary) {
+    throw new Error(`${arch} is not supported`);
+  }
+  return archBinary;
+}
+function detectPlatformBinary({ [platform]: platformBinary }, { wsl }) {
+  if (wsl && is_wsl_default) {
+    return detectArchBinary(wsl);
+  }
+  if (!platformBinary) {
+    throw new Error(`${platform} is not supported`);
+  }
+  return detectArchBinary(platformBinary);
+}
+var execFile5, __dirname, localXdgOpenPath, platform, arch, pTryEach, baseOpen, open, openApp, apps, open_default;
+var init_open = __esm({
+  "../../node_modules/open/index.js"() {
+    "use strict";
+    init_wsl_utils();
+    init_define_lazy_prop();
+    init_default_browser();
+    init_is_inside_container();
+    execFile5 = promisify5(childProcess.execFile);
+    __dirname = path15.dirname(fileURLToPath3(import.meta.url));
+    localXdgOpenPath = path15.join(__dirname, "xdg-open");
+    ({ platform, arch } = process7);
+    pTryEach = async (array, mapper) => {
+      let latestError;
+      for (const item of array) {
+        try {
+          return await mapper(item);
+        } catch (error) {
+          latestError = error;
+        }
+      }
+      throw latestError;
+    };
+    baseOpen = async (options) => {
+      options = {
+        wait: false,
+        background: false,
+        newInstance: false,
+        allowNonzeroExitCode: false,
+        ...options
+      };
+      if (Array.isArray(options.app)) {
+        return pTryEach(options.app, (singleApp) => baseOpen({
+          ...options,
+          app: singleApp
+        }));
+      }
+      let { name: app, arguments: appArguments = [] } = options.app ?? {};
+      appArguments = [...appArguments];
+      if (Array.isArray(app)) {
+        return pTryEach(app, (appName) => baseOpen({
+          ...options,
+          app: {
+            name: appName,
+            arguments: appArguments
+          }
+        }));
+      }
+      if (app === "browser" || app === "browserPrivate") {
+        const ids = {
+          "com.google.chrome": "chrome",
+          "google-chrome.desktop": "chrome",
+          "com.brave.Browser": "brave",
+          "org.mozilla.firefox": "firefox",
+          "firefox.desktop": "firefox",
+          "com.microsoft.msedge": "edge",
+          "com.microsoft.edge": "edge",
+          "com.microsoft.edgemac": "edge",
+          "microsoft-edge.desktop": "edge"
+        };
+        const flags = {
+          chrome: "--incognito",
+          brave: "--incognito",
+          firefox: "--private-window",
+          edge: "--inPrivate"
+        };
+        const browser = is_wsl_default ? await getWindowsDefaultBrowserFromWsl() : await defaultBrowser2();
+        if (browser.id in ids) {
+          const browserName = ids[browser.id];
+          if (app === "browserPrivate") {
+            appArguments.push(flags[browserName]);
+          }
+          return baseOpen({
+            ...options,
+            app: {
+              name: apps[browserName],
+              arguments: appArguments
+            }
+          });
+        }
+        throw new Error(`${browser.name} is not supported as a default browser`);
+      }
+      let command;
+      const cliArguments = [];
+      const childProcessOptions = {};
+      if (platform === "darwin") {
+        command = "open";
+        if (options.wait) {
+          cliArguments.push("--wait-apps");
+        }
+        if (options.background) {
+          cliArguments.push("--background");
+        }
+        if (options.newInstance) {
+          cliArguments.push("--new");
+        }
+        if (app) {
+          cliArguments.push("-a", app);
+        }
+      } else if (platform === "win32" || is_wsl_default && !isInsideContainer() && !app) {
+        command = await powerShellPath();
+        cliArguments.push(
+          "-NoProfile",
+          "-NonInteractive",
+          "-ExecutionPolicy",
+          "Bypass",
+          "-EncodedCommand"
+        );
+        if (!is_wsl_default) {
+          childProcessOptions.windowsVerbatimArguments = true;
+        }
+        const encodedArguments = ["Start"];
+        if (options.wait) {
+          encodedArguments.push("-Wait");
+        }
+        if (app) {
+          encodedArguments.push(`"\`"${app}\`""`);
+          if (options.target) {
+            appArguments.push(options.target);
+          }
+        } else if (options.target) {
+          encodedArguments.push(`"${options.target}"`);
+        }
+        if (appArguments.length > 0) {
+          appArguments = appArguments.map((argument) => `"\`"${argument}\`""`);
+          encodedArguments.push("-ArgumentList", appArguments.join(","));
+        }
+        options.target = Buffer2.from(encodedArguments.join(" "), "utf16le").toString("base64");
+      } else {
+        if (app) {
+          command = app;
+        } else {
+          const isBundled = !__dirname || __dirname === "/";
+          let exeLocalXdgOpen = false;
+          try {
+            await fs19.access(localXdgOpenPath, fsConstants2.X_OK);
+            exeLocalXdgOpen = true;
+          } catch {
+          }
+          const useSystemXdgOpen = process7.versions.electron ?? (platform === "android" || isBundled || !exeLocalXdgOpen);
+          command = useSystemXdgOpen ? "xdg-open" : localXdgOpenPath;
+        }
+        if (appArguments.length > 0) {
+          cliArguments.push(...appArguments);
+        }
+        if (!options.wait) {
+          childProcessOptions.stdio = "ignore";
+          childProcessOptions.detached = true;
+        }
+      }
+      if (platform === "darwin" && appArguments.length > 0) {
+        cliArguments.push("--args", ...appArguments);
+      }
+      if (options.target) {
+        cliArguments.push(options.target);
+      }
+      const subprocess = childProcess.spawn(command, cliArguments, childProcessOptions);
+      if (options.wait) {
+        return new Promise((resolve3, reject) => {
+          subprocess.once("error", reject);
+          subprocess.once("close", (exitCode) => {
+            if (!options.allowNonzeroExitCode && exitCode > 0) {
+              reject(new Error(`Exited with code ${exitCode}`));
+              return;
+            }
+            resolve3(subprocess);
+          });
+        });
+      }
+      subprocess.unref();
+      return subprocess;
+    };
+    open = (target, options) => {
+      if (typeof target !== "string") {
+        throw new TypeError("Expected a `target`");
+      }
+      return baseOpen({
+        ...options,
+        target
+      });
+    };
+    openApp = (name, options) => {
+      if (typeof name !== "string" && !Array.isArray(name)) {
+        throw new TypeError("Expected a valid `name`");
+      }
+      const { arguments: appArguments = [] } = options ?? {};
+      if (appArguments !== void 0 && appArguments !== null && !Array.isArray(appArguments)) {
+        throw new TypeError("Expected `appArguments` as Array type");
+      }
+      return baseOpen({
+        ...options,
+        app: {
+          name,
+          arguments: appArguments
+        }
+      });
+    };
+    apps = {};
+    defineLazyProperty(apps, "chrome", () => detectPlatformBinary({
+      darwin: "google chrome",
+      win32: "chrome",
+      linux: ["google-chrome", "google-chrome-stable", "chromium"]
+    }, {
+      wsl: {
+        ia32: "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe",
+        x64: ["/mnt/c/Program Files/Google/Chrome/Application/chrome.exe", "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe"]
+      }
+    }));
+    defineLazyProperty(apps, "brave", () => detectPlatformBinary({
+      darwin: "brave browser",
+      win32: "brave",
+      linux: ["brave-browser", "brave"]
+    }, {
+      wsl: {
+        ia32: "/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe",
+        x64: ["/mnt/c/Program Files/BraveSoftware/Brave-Browser/Application/brave.exe", "/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe"]
+      }
+    }));
+    defineLazyProperty(apps, "firefox", () => detectPlatformBinary({
+      darwin: "firefox",
+      win32: String.raw`C:\Program Files\Mozilla Firefox\firefox.exe`,
+      linux: "firefox"
+    }, {
+      wsl: "/mnt/c/Program Files/Mozilla Firefox/firefox.exe"
+    }));
+    defineLazyProperty(apps, "edge", () => detectPlatformBinary({
+      darwin: "microsoft edge",
+      win32: "msedge",
+      linux: ["microsoft-edge", "microsoft-edge-dev"]
+    }, {
+      wsl: "/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe"
+    }));
+    defineLazyProperty(apps, "browser", () => "browser");
+    defineLazyProperty(apps, "browserPrivate", () => "browserPrivate");
+    open_default = open;
+  }
+});
 
 // src/index.ts
 import { Command } from "commander";
-import chalk3 from "chalk";
 
 // src/version.ts
 import { readFileSync } from "fs";
@@ -27,29 +630,33 @@ function findPackageJson() {
 }
 var VERSION = JSON.parse(findPackageJson()).version;
 
-// src/commands/bundle/index.ts
-import path9 from "path";
-import fs8 from "fs-extra";
-import { getPlatform as getPlatform2 } from "@walkeros/core";
+// src/core/banner.ts
+import chalk2 from "chalk";
 
 // src/core/logger.ts
 import chalk from "chalk";
 var BRAND_COLOR = "#01b5e2";
 function createLogger(options = {}) {
-  const { verbose = false, silent = false, json = false } = options;
+  const {
+    verbose = false,
+    silent = false,
+    json = false,
+    stderr = false
+  } = options;
   const shouldLog = !silent && !json;
   const shouldDebug = verbose && !silent && !json;
+  const out = stderr ? console.error : console.log;
   return {
     log: (...args) => {
       if (shouldLog) {
         const message = args.map((arg) => String(arg)).join(" ");
-        console.log(message);
+        out(message);
       }
     },
     brand: (...args) => {
       if (shouldLog) {
         const message = args.map((arg) => String(arg)).join(" ");
-        console.log(chalk.hex(BRAND_COLOR)(message));
+        out(chalk.hex(BRAND_COLOR)(message));
       }
     },
     error: (...args) => {
@@ -61,43 +668,43 @@ function createLogger(options = {}) {
     debug: (...args) => {
       if (shouldDebug) {
         const message = args.map((arg) => String(arg)).join(" ");
-        console.log(`  ${message}`);
+        out(`  ${message}`);
       }
     },
     json: (data) => {
       if (!silent) {
-        console.log(JSON.stringify(data, null, 2));
+        out(JSON.stringify(data, null, 2));
       }
     },
     // Backward-compatible methods (all use default terminal color per design)
     info: (...args) => {
       if (shouldLog) {
         const message = args.map((arg) => String(arg)).join(" ");
-        console.log(message);
+        out(message);
       }
     },
     success: (...args) => {
       if (shouldLog) {
         const message = args.map((arg) => String(arg)).join(" ");
-        console.log(message);
+        out(message);
       }
     },
     warning: (...args) => {
       if (shouldLog) {
         const message = args.map((arg) => String(arg)).join(" ");
-        console.log(message);
+        out(message);
       }
     },
     warn: (...args) => {
       if (shouldLog) {
         const message = args.map((arg) => String(arg)).join(" ");
-        console.log(message);
+        out(message);
       }
     },
     gray: (...args) => {
       if (shouldLog) {
         const message = args.map((arg) => String(arg)).join(" ");
-        console.log(message);
+        out(message);
       }
     }
   };
@@ -106,10 +713,25 @@ function createCommandLogger(options) {
   return createLogger({
     verbose: options.verbose,
     silent: options.silent ?? false,
-    json: options.json
+    json: options.json,
+    stderr: options.stderr
   });
 }
 
+// src/core/banner.ts
+function printBanner(version) {
+  const b = chalk2.hex(BRAND_COLOR);
+  console.error(`${b("        \u2571\u2571")}`);
+  console.error(`${b(" \u2571\u2571    \u2571\u2571")}   ${b("walkerOS")}`);
+  console.error(`${b("\u2571\u2571 \u2571\u2571 \u2571\u2571")}    v${version}`);
+  console.error("");
+}
+
+// src/commands/bundle/index.ts
+import path10 from "path";
+import fs9 from "fs-extra";
+import { getPlatform as getPlatform2 } from "@walkeros/core";
+
 // src/core/collector-logger.ts
 function createCollectorLoggerConfig(cliLogger, verbose) {
   return {
@@ -152,6 +774,17 @@ function createTimer() {
 }
 
 // src/core/output.ts
+import fs from "fs-extra";
+import path from "path";
+async function writeResult(content, options) {
+  if (options.output) {
+    const outputPath = path.resolve(options.output);
+    await fs.ensureDir(path.dirname(outputPath));
+    await fs.writeFile(outputPath, content);
+  } else {
+    process.stdout.write(content);
+  }
+}
 function createJsonOutput(success, data, error, duration) {
   return {
     success,
@@ -171,25 +804,139 @@ function formatBytes(bytes) {
 }
 
 // src/core/tmp.ts
-import path from "path";
+import path2 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);
-}
-function getDefaultTmpRoot() {
-  return DEFAULT_TMP_ROOT;
+  const absoluteRoot = path2.isAbsolute(root) ? root : path2.resolve(root);
+  return path2.join(absoluteRoot, ...segments);
 }
 
 // src/core/asset-resolver.ts
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { existsSync } from "fs";
+import { existsSync as existsSync2 } from "fs";
+import path4 from "path";
+
+// src/config/utils.ts
+import fs2 from "fs-extra";
 import path3 from "path";
 
+// src/lib/config-file.ts
+import {
+  readFileSync as readFileSync2,
+  writeFileSync,
+  mkdirSync,
+  unlinkSync,
+  existsSync
+} from "fs";
+import { join as join2 } from "path";
+import { homedir } from "os";
+function getConfigDir() {
+  const xdgConfig = process.env.XDG_CONFIG_HOME;
+  const base = xdgConfig || join2(homedir(), ".config");
+  return join2(base, "walkeros");
+}
+function getConfigPath() {
+  return join2(getConfigDir(), "config.json");
+}
+function readConfig() {
+  const configPath = getConfigPath();
+  try {
+    const content = readFileSync2(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function writeConfig(config) {
+  const dir = getConfigDir();
+  mkdirSync(dir, { recursive: true });
+  const configPath = getConfigPath();
+  writeFileSync(configPath, JSON.stringify(config, null, 2), { mode: 384 });
+}
+function deleteConfig() {
+  const configPath = getConfigPath();
+  if (existsSync(configPath)) {
+    unlinkSync(configPath);
+    return true;
+  }
+  return false;
+}
+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;
+}
+function resolveAppUrl() {
+  const envUrl = process.env.WALKEROS_APP_URL;
+  if (envUrl) return envUrl;
+  const config = readConfig();
+  if (config?.appUrl) return config.appUrl;
+  return "https://app.walkeros.io";
+}
+
+// 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 }
+  });
+}
+function resolveBaseUrl() {
+  return resolveAppUrl();
+}
+function requireProjectId() {
+  const projectId = process.env.WALKEROS_PROJECT_ID;
+  if (!projectId) throw new Error("WALKEROS_PROJECT_ID not set.");
+  return projectId;
+}
+async function apiRequest(path16, options) {
+  const token = getToken();
+  if (!token) throw new Error("WALKEROS_TOKEN not set.");
+  const baseUrl = resolveBaseUrl();
+  const { responseFormat, timeout = 3e4, ...fetchOptions } = options || {};
+  const response = await fetch(`${baseUrl}${path16}`, {
+    ...fetchOptions,
+    signal: AbortSignal.timeout(timeout),
+    headers: {
+      ...fetchOptions?.headers,
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    }
+  });
+  if (responseFormat === "raw") {
+    if (!response.ok) {
+      const body = await response.json().catch(() => ({}));
+      throw new Error(
+        body?.error?.message || `HTTP ${response.status}`
+      );
+    }
+    return response;
+  }
+  if (!response.ok) {
+    const body = await response.json().catch(() => ({}));
+    throw new Error(
+      body?.error?.message || `HTTP ${response.status}`
+    );
+  }
+  if (response.status === 204) return { success: true };
+  return response.json();
+}
+
 // src/config/utils.ts
-import fs from "fs-extra";
-import path2 from "path";
 function isUrl(str) {
   try {
     const url = new URL(str);
@@ -203,7 +950,7 @@ async function downloadFromUrl(url) {
     throw new Error(`Invalid URL: ${url}`);
   }
   try {
-    const response = await fetch(url);
+    const response = await authenticatedFetch(url);
     if (!response.ok) {
       throw new Error(
         `Failed to download ${url}: ${response.status} ${response.statusText}`
@@ -211,9 +958,9 @@ async function downloadFromUrl(url) {
     }
     const content = await response.text();
     const downloadsDir = getTmpPath(void 0, "downloads");
-    await fs.ensureDir(downloadsDir);
-    const tempPath = path2.join(downloadsDir, "flow.json");
-    await fs.writeFile(tempPath, content, "utf-8");
+    await fs2.ensureDir(downloadsDir);
+    const tempPath = path3.join(downloadsDir, "flow.json");
+    await fs2.writeFile(tempPath, content, "utf-8");
     return tempPath;
   } catch (error) {
     if (error instanceof Error) {
@@ -229,13 +976,13 @@ async function loadJsonConfig(configPath) {
     absolutePath = await downloadFromUrl(configPath);
     isTemporary = true;
   } else {
-    absolutePath = path2.resolve(configPath);
-    if (!await fs.pathExists(absolutePath)) {
+    absolutePath = path3.resolve(configPath);
+    if (!await fs2.pathExists(absolutePath)) {
       throw new Error(`Configuration file not found: ${absolutePath}`);
     }
   }
   try {
-    const rawConfig = await fs.readJson(absolutePath);
+    const rawConfig = await fs2.readJson(absolutePath);
     return rawConfig;
   } catch (error) {
     throw new Error(
@@ -244,7 +991,7 @@ async function loadJsonConfig(configPath) {
   } finally {
     if (isTemporary) {
       try {
-        await fs.remove(absolutePath);
+        await fs2.remove(absolutePath);
       } catch {
       }
     }
@@ -266,11 +1013,11 @@ async function loadJsonFromSource(source, options) {
     try {
       const tempPath = await downloadFromUrl(trimmedSource);
       try {
-        const data = await fs.readJson(tempPath);
+        const data = await fs2.readJson(tempPath);
         return data;
       } finally {
         try {
-          await fs.remove(tempPath);
+          await fs2.remove(tempPath);
         } catch {
         }
       }
@@ -280,10 +1027,10 @@ async function loadJsonFromSource(source, options) {
       );
     }
   }
-  const resolvedPath = path2.resolve(trimmedSource);
-  if (await fs.pathExists(resolvedPath)) {
+  const resolvedPath = path3.resolve(trimmedSource);
+  if (await fs2.pathExists(resolvedPath)) {
     try {
-      const data = await fs.readJson(resolvedPath);
+      const data = await fs2.readJson(resolvedPath);
       return data;
     } catch (error) {
       throw new Error(
@@ -309,15 +1056,15 @@ 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 (existsSync(path3.join(dir, "examples"))) {
+  let dir = path4.dirname(currentFile);
+  while (dir !== path4.dirname(dir)) {
+    if (existsSync2(path4.join(dir, "examples"))) {
       cachedAssetDir = dir;
       return dir;
     }
-    dir = path3.dirname(dir);
+    dir = path4.dirname(dir);
   }
-  cachedAssetDir = path3.dirname(currentFile);
+  cachedAssetDir = path4.dirname(currentFile);
   return cachedAssetDir;
 }
 function resolveAsset(assetPath, assetType, baseDir) {
@@ -326,12 +1073,12 @@ function resolveAsset(assetPath, assetType, baseDir) {
   }
   if (!assetPath.includes("/") && !assetPath.includes("\\")) {
     const assetDir = getAssetDir();
-    return path3.join(assetDir, "examples", assetPath);
+    return path4.join(assetDir, "examples", assetPath);
   }
-  if (path3.isAbsolute(assetPath)) {
+  if (path4.isAbsolute(assetPath)) {
     return assetPath;
   }
-  return path3.resolve(baseDir || process.cwd(), assetPath);
+  return path4.resolve(baseDir || process.cwd(), assetPath);
 }
 
 // src/core/utils.ts
@@ -340,23 +1087,23 @@ function getErrorMessage(error) {
 }
 
 // src/core/local-packages.ts
-import path4 from "path";
-import fs2 from "fs-extra";
+import path5 from "path";
+import fs3 from "fs-extra";
 async function resolveLocalPackage(packageName, localPath, configDir, logger2) {
-  const absolutePath = path4.isAbsolute(localPath) ? localPath : path4.resolve(configDir, localPath);
-  if (!await fs2.pathExists(absolutePath)) {
+  const absolutePath = path5.isAbsolute(localPath) ? localPath : path5.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 fs2.pathExists(pkgJsonPath)) {
+  const pkgJsonPath = path5.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 fs2.pathExists(distPath);
+  const distPath = path5.join(absolutePath, "dist");
+  const hasDistFolder = await fs3.pathExists(distPath);
   if (!hasDistFolder) {
     logger2.warn(
       `\u26A0\uFE0F  ${packageName}: No dist/ folder found. Using package root.`
@@ -370,21 +1117,21 @@ async function resolveLocalPackage(packageName, localPath, configDir, logger2) {
   };
 }
 async function copyLocalPackage(localPkg, targetDir, logger2) {
-  const packageDir = path4.join(targetDir, "node_modules", localPkg.name);
-  await fs2.ensureDir(path4.dirname(packageDir));
-  await fs2.copy(
-    path4.join(localPkg.absolutePath, "package.json"),
-    path4.join(packageDir, "package.json")
+  const packageDir = path5.join(targetDir, "node_modules", localPkg.name);
+  await fs3.ensureDir(path5.dirname(packageDir));
+  await fs3.copy(
+    path5.join(localPkg.absolutePath, "package.json"),
+    path5.join(packageDir, "package.json")
   );
   if (localPkg.hasDistFolder) {
-    await fs2.copy(localPkg.distPath, path4.join(packageDir, "dist"));
+    await fs3.copy(localPkg.distPath, path5.join(packageDir, "dist"));
   } else {
-    const entries = await fs2.readdir(localPkg.absolutePath);
+    const entries = await fs3.readdir(localPkg.absolutePath);
     for (const entry of entries) {
       if (!["node_modules", ".turbo", ".git"].includes(entry)) {
-        await fs2.copy(
-          path4.join(localPkg.absolutePath, entry),
-          path4.join(packageDir, entry)
+        await fs3.copy(
+          path5.join(localPkg.absolutePath, entry),
+          path5.join(packageDir, entry)
         );
       }
     }
@@ -394,15 +1141,15 @@ async function copyLocalPackage(localPkg, targetDir, logger2) {
 }
 
 // src/core/input-detector.ts
-import fs3 from "fs-extra";
+import fs4 from "fs-extra";
 async function detectInput(inputPath, platformOverride) {
   const content = await loadContent(inputPath);
   try {
     JSON.parse(content);
     return { type: "config", content };
   } catch {
-    const platform = platformOverride ?? detectPlatformFromPath(inputPath);
-    return { type: "bundle", content, platform };
+    const platform2 = platformOverride ?? detectPlatformFromPath(inputPath);
+    return { type: "bundle", content, platform: platform2 };
   }
 }
 function detectPlatformFromPath(inputPath) {
@@ -411,13 +1158,29 @@ function detectPlatformFromPath(inputPath) {
 }
 async function loadContent(inputPath) {
   if (isUrl(inputPath)) {
-    const response = await fetch(inputPath);
+    const response = await authenticatedFetch(inputPath);
     if (!response.ok) {
       throw new Error(`Failed to fetch ${inputPath}: ${response.status}`);
     }
     return response.text();
   }
-  return fs3.readFile(inputPath, "utf8");
+  return fs4.readFile(inputPath, "utf8");
+}
+
+// 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/config/validators.ts
@@ -430,8 +1193,8 @@ function validateFlowSetup(data) {
   const result = safeParseSetup(data);
   if (!result.success) {
     const errors = result.error.issues.map((issue) => {
-      const path14 = issue.path.length > 0 ? issue.path.map(String).join(".") : "root";
-      return `  - ${path14}: ${issue.message}`;
+      const path16 = issue.path.length > 0 ? issue.path.map(String).join(".") : "root";
+      return `  - ${path16}: ${issue.message}`;
     }).join("\n");
     throw new Error(`Invalid configuration:
 ${errors}`);
@@ -465,16 +1228,16 @@ 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 getBuildDefaults(platform2) {
+  return platform2 === "web" ? WEB_BUILD_DEFAULTS : SERVER_BUILD_DEFAULTS;
 }
-function getDefaultOutput(platform) {
-  return DEFAULT_OUTPUT_PATHS[platform];
+function getDefaultOutput(platform2) {
+  return DEFAULT_OUTPUT_PATHS[platform2];
 }
 
 // src/config/loader.ts
-import path5 from "path";
-import fs4 from "fs-extra";
+import path6 from "path";
+import fs5 from "fs-extra";
 import { getFlowConfig, getPlatform } from "@walkeros/core";
 var DEFAULT_INCLUDE_FOLDER = "./shared";
 function loadBundleConfig(rawConfig, options) {
@@ -482,20 +1245,20 @@ function loadBundleConfig(rawConfig, options) {
   const availableFlows = getAvailableFlows(setup);
   const flowName = resolveFlow(setup, options.flowName, availableFlows);
   const flowConfig = getFlowConfig(setup, flowName);
-  const platform = getPlatform(flowConfig);
-  if (!platform) {
+  const platform2 = getPlatform(flowConfig);
+  if (!platform2) {
     throw new Error(
       `Invalid configuration: flow "${flowName}" must have a "web" or "server" key.`
     );
   }
-  const buildDefaults = getBuildDefaults(platform);
+  const buildDefaults = getBuildDefaults(platform2);
   const packages = flowConfig.packages || {};
-  const output = options.buildOverrides?.output || getDefaultOutput(platform);
-  const configDir = isUrl(options.configPath) ? process.cwd() : path5.dirname(options.configPath);
+  const output = options.buildOverrides?.output || getDefaultOutput(platform2);
+  const configDir = isUrl(options.configPath) ? process.cwd() : path6.dirname(options.configPath);
   let includes = setup.include;
   if (!includes) {
-    const defaultIncludePath = path5.resolve(configDir, DEFAULT_INCLUDE_FOLDER);
-    if (fs4.pathExistsSync(defaultIncludePath)) {
+    const defaultIncludePath = path6.resolve(configDir, DEFAULT_INCLUDE_FOLDER);
+    if (fs5.pathExistsSync(defaultIncludePath)) {
       includes = [DEFAULT_INCLUDE_FOLDER];
     }
   }
@@ -561,14 +1324,14 @@ async function loadFlowConfig(configPath, options) {
 
 // src/commands/bundle/bundler.ts
 import esbuild from "esbuild";
-import path8 from "path";
-import fs7 from "fs-extra";
+import path9 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 fs5 from "fs-extra";
+import path7 from "path";
+import fs6 from "fs-extra";
 
 // src/core/cache-utils.ts
 import { getHashServer } from "@walkeros/server-core";
@@ -609,16 +1372,16 @@ async function withTimeout(promise, ms, errorMessage) {
   return Promise.race([promise, timeout]);
 }
 function getPackageDirectory(baseDir, packageName, version) {
-  return path6.join(baseDir, "node_modules", packageName);
+  return path7.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);
+  return path7.join(cacheDir, cacheKey);
 }
 async function isPackageCached(pkg, tmpDir) {
   const cachedPath = await getCachedPackagePath(pkg, tmpDir);
-  return fs5.pathExists(cachedPath);
+  return fs6.pathExists(cachedPath);
 }
 function validateNoDuplicatePackages(packages) {
   const packageMap = /* @__PURE__ */ new Map();
@@ -652,9 +1415,9 @@ async function resolveDependencies(pkg, packageDir, logger2, visited = /* @__PUR
   }
   visited.add(pkgKey);
   try {
-    const packageJsonPath = path6.join(packageDir, "package.json");
-    if (await fs5.pathExists(packageJsonPath)) {
-      const packageJson = await fs5.readJson(packageJsonPath);
+    const packageJsonPath = path7.join(packageDir, "package.json");
+    if (await fs6.pathExists(packageJsonPath)) {
+      const packageJson = await fs6.readJson(packageJsonPath);
       const deps = {
         ...packageJson.dependencies,
         ...packageJson.peerDependencies
@@ -682,7 +1445,7 @@ async function downloadPackages(packages, targetDir, logger2, useCache = true, c
     }
   }
   validateNoDuplicatePackages(packages);
-  await fs5.ensureDir(targetDir);
+  await fs6.ensureDir(targetDir);
   while (downloadQueue.length > 0) {
     const pkg = downloadQueue.shift();
     const pkgKey = `${pkg.name}@${pkg.version}`;
@@ -719,8 +1482,8 @@ async function downloadPackages(packages, targetDir, logger2, useCache = true, c
         logger2.debug(`Downloading ${packageSpec} (cached)`);
       }
       try {
-        await fs5.ensureDir(path6.dirname(packageDir));
-        await fs5.copy(cachedPath, packageDir);
+        await fs6.ensureDir(path7.dirname(packageDir));
+        await fs6.copy(cachedPath, packageDir);
         packagePaths.set(pkg.name, packageDir);
         const deps = await resolveDependencies(pkg, packageDir, logger2);
         for (const dep of deps) {
@@ -737,7 +1500,7 @@ async function downloadPackages(packages, targetDir, logger2, useCache = true, c
       }
     }
     try {
-      await fs5.ensureDir(path6.dirname(packageDir));
+      await fs6.ensureDir(path7.dirname(packageDir));
       const cacheDir = process.env.NPM_CACHE_DIR || getTmpPath(void 0, "cache", "npm");
       await withTimeout(
         pacote.extract(packageSpec, packageDir, {
@@ -754,15 +1517,15 @@ async function downloadPackages(packages, targetDir, logger2, useCache = true, c
         `Package download timed out after ${PACKAGE_DOWNLOAD_TIMEOUT_MS / 1e3}s: ${packageSpec}`
       );
       if (userSpecifiedPackages.has(pkg.name)) {
-        const pkgStats = await fs5.stat(path6.join(packageDir, "package.json"));
+        const pkgStats = await fs6.stat(path7.join(packageDir, "package.json"));
         const pkgJsonSize = pkgStats.size;
         const sizeKB = (pkgJsonSize / 1024).toFixed(1);
         logger2.debug(`Downloading ${packageSpec} (${sizeKB} KB)`);
       }
       if (useCache) {
         try {
-          await fs5.ensureDir(path6.dirname(cachedPath));
-          await fs5.copy(packageDir, cachedPath);
+          await fs6.ensureDir(path7.dirname(cachedPath));
+          await fs6.copy(packageDir, cachedPath);
         } catch (cacheError) {
         }
       }
@@ -782,26 +1545,26 @@ async function downloadPackages(packages, targetDir, logger2, useCache = true, c
 }
 
 // src/core/build-cache.ts
-import fs6 from "fs-extra";
-import path7 from "path";
+import fs7 from "fs-extra";
+import path8 from "path";
 async function getBuildCachePath(configContent, tmpDir) {
   const cacheDir = getTmpPath(tmpDir, "cache", "builds");
   const cacheKey = await getFlowConfigCacheKey(configContent);
-  return path7.join(cacheDir, `${cacheKey}.js`);
+  return path8.join(cacheDir, `${cacheKey}.js`);
 }
 async function isBuildCached(configContent, tmpDir) {
   const cachePath = await getBuildCachePath(configContent, tmpDir);
-  return fs6.pathExists(cachePath);
+  return fs7.pathExists(cachePath);
 }
 async function cacheBuild(configContent, buildOutput, tmpDir) {
   const cachePath = await getBuildCachePath(configContent, tmpDir);
-  await fs6.ensureDir(path7.dirname(cachePath));
-  await fs6.writeFile(cachePath, buildOutput, "utf-8");
+  await fs7.ensureDir(path8.dirname(cachePath));
+  await fs7.writeFile(cachePath, buildOutput, "utf-8");
 }
 async function getCachedBuild(configContent, tmpDir) {
   const cachePath = await getBuildCachePath(configContent, tmpDir);
-  if (await fs6.pathExists(cachePath)) {
-    return await fs6.readFile(cachePath, "utf-8");
+  if (await fs7.pathExists(cachePath)) {
+    return await fs7.readFile(cachePath, "utf-8");
   }
   return null;
 }
@@ -854,11 +1617,11 @@ function generateInlineCode(inline, config, env, chain, chainPropertyName, isDes
 }
 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 fs7.pathExists(sourcePath)) {
-      await fs7.copy(sourcePath, destPath);
+    const sourcePath = path9.resolve(sourceDir, include);
+    const folderName = path9.basename(include);
+    const destPath = path9.join(outputDir, folderName);
+    if (await fs8.pathExists(sourcePath)) {
+      await fs8.copy(sourcePath, destPath);
       logger2.debug(`Copied ${include} to output`);
     } else {
       logger2.debug(`Include folder not found: ${include}`);
@@ -927,14 +1690,14 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
       const cachedBuild = await getCachedBuild(configContent);
       if (cachedBuild) {
         logger2.debug("Using cached build");
-        const outputPath = path8.resolve(buildOptions.output);
-        await fs7.ensureDir(path8.dirname(outputPath));
-        await fs7.writeFile(outputPath, cachedBuild);
-        const stats = await fs7.stat(outputPath);
+        const outputPath = path9.resolve(buildOptions.output);
+        await fs8.ensureDir(path9.dirname(outputPath));
+        await fs8.writeFile(outputPath, cachedBuild);
+        const stats = await fs8.stat(outputPath);
         const sizeKB = (stats.size / 1024).toFixed(1);
         logger2.log(`Output: ${outputPath} (${sizeKB} KB, cached)`);
         if (showStats) {
-          const stats2 = await fs7.stat(outputPath);
+          const stats2 = await fs8.stat(outputPath);
           const packageStats = Object.entries(buildOptions.packages).map(
             ([name, pkg]) => ({
               name: `${name}@${pkg.version || "latest"}`,
@@ -954,7 +1717,7 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
     }
   }
   try {
-    await fs7.ensureDir(TEMP_DIR);
+    await fs8.ensureDir(TEMP_DIR);
     const hasSourcesOrDests = Object.keys(
       flowConfig.sources || {}
     ).length > 0 || Object.keys(
@@ -982,8 +1745,8 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
     );
     for (const [pkgName, pkgPath] of packagePaths.entries()) {
       if (pkgName.startsWith("@walkeros/")) {
-        const pkgJsonPath = path8.join(pkgPath, "package.json");
-        const pkgJson = await fs7.readJSON(pkgJsonPath);
+        const pkgJsonPath = path9.join(pkgPath, "package.json");
+        const pkgJson = await fs8.readJSON(pkgJsonPath);
         if (!pkgJson.exports && pkgJson.module) {
           pkgJson.exports = {
             ".": {
@@ -991,12 +1754,12 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
               require: pkgJson.main
             }
           };
-          await fs7.writeJSON(pkgJsonPath, pkgJson, { spaces: 2 });
+          await fs8.writeJSON(pkgJsonPath, pkgJson, { spaces: 2 });
         }
       }
     }
-    const packageJsonPath = path8.join(TEMP_DIR, "package.json");
-    await fs7.writeFile(
+    const packageJsonPath = path9.join(TEMP_DIR, "package.json");
+    await fs8.writeFile(
       packageJsonPath,
       JSON.stringify({ type: "module" }, null, 2)
     );
@@ -1006,13 +1769,13 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
       buildOptions,
       packagePaths
     );
-    const entryPath = path8.join(TEMP_DIR, "entry.js");
-    await fs7.writeFile(entryPath, entryContent);
+    const entryPath = path9.join(TEMP_DIR, "entry.js");
+    await fs8.writeFile(entryPath, entryContent);
     logger2.debug(
       `Running esbuild (target: ${buildOptions.target || "es2018"}, format: ${buildOptions.format})`
     );
-    const outputPath = path8.resolve(buildOptions.output);
-    await fs7.ensureDir(path8.dirname(outputPath));
+    const outputPath = path9.resolve(buildOptions.output);
+    await fs8.ensureDir(path9.dirname(outputPath));
     const esbuildOptions = createEsbuildOptions(
       buildOptions,
       entryPath,
@@ -1031,13 +1794,13 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
     } finally {
       await esbuild.stop();
     }
-    const outputStats = await fs7.stat(outputPath);
+    const outputStats = await fs8.stat(outputPath);
     const sizeKB = (outputStats.size / 1024).toFixed(1);
     const buildTime = ((Date.now() - bundleStartTime) / 1e3).toFixed(1);
     logger2.log(`Output: ${outputPath} (${sizeKB} KB, ${buildTime}s)`);
     if (buildOptions.cache !== false) {
       const configContent = generateCacheKeyContent(flowConfig, buildOptions);
-      const buildOutput = await fs7.readFile(outputPath, "utf-8");
+      const buildOutput = await fs8.readFile(outputPath, "utf-8");
       await cacheBuild(configContent, buildOutput);
       logger2.debug("Build cached for future use");
     }
@@ -1051,7 +1814,7 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
       );
     }
     if (buildOptions.include && buildOptions.include.length > 0) {
-      const outputDir = path8.dirname(outputPath);
+      const outputDir = path9.dirname(outputPath);
       await copyIncludes(
         buildOptions.include,
         buildOptions.configDir || process.cwd(),
@@ -1065,7 +1828,7 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
   }
 }
 async function collectBundleStats(outputPath, packages, startTime, entryContent) {
-  const stats = await fs7.stat(outputPath);
+  const stats = await fs8.stat(outputPath);
   const totalSize = stats.size;
   const buildTime = Date.now() - startTime;
   const packageStats = Object.entries(packages).map(([name, pkg]) => {
@@ -1577,16 +2340,47 @@ Package Breakdown:`);
 }
 
 // src/commands/bundle/index.ts
+function resolveOutputPath(output, buildOptions) {
+  const resolved = path10.resolve(output);
+  const ext = path10.extname(resolved);
+  if (output.endsWith("/") || output.endsWith(path10.sep) || !ext) {
+    const filename = buildOptions.platform === "browser" ? "walker.js" : "bundle.mjs";
+    return path10.join(resolved, filename);
+  }
+  return resolved;
+}
 async function bundleCommand(options) {
   const timer = createTimer();
   timer.start();
-  const logger2 = createCommandLogger(options);
+  const writingToStdout = !options.output;
+  const logger2 = createCommandLogger({
+    ...options,
+    stderr: writingToStdout
+  });
   try {
     if (options.flow && options.all) {
       throw new Error("Cannot use both --flow and --all flags together");
     }
-    const configPath = resolveAsset(options.config, "config");
-    const rawConfig = await loadJsonConfig(configPath);
+    if (options.all && writingToStdout) {
+      throw new Error(
+        "Cannot use --all without --output (multiple bundles need file output)"
+      );
+    }
+    let rawConfig;
+    let configPath;
+    if (isStdinPiped() && !options.config) {
+      const stdinContent = await readStdin();
+      try {
+        rawConfig = JSON.parse(stdinContent);
+      } catch {
+        throw new Error("Invalid JSON received on stdin");
+      }
+      configPath = path10.resolve(process.cwd(), "stdin.config.json");
+    } else {
+      const file = options.config || "bundle.config.json";
+      configPath = resolveAsset(file, "config");
+      rawConfig = await loadJsonConfig(configPath);
+    }
     const configsToBundle = options.all ? loadAllFlows(rawConfig, { configPath, logger: logger2 }) : [
       loadBundleConfig(rawConfig, {
         configPath,
@@ -1605,11 +2399,16 @@ async function bundleCommand(options) {
         if (options.cache !== void 0) {
           buildOptions.cache = options.cache;
         }
-        const configBasename = path9.basename(configPath);
+        if (options.output) {
+          buildOptions.output = resolveOutputPath(options.output, buildOptions);
+        } else {
+          const ext = buildOptions.platform === "browser" ? ".js" : ".mjs";
+          buildOptions.output = getTmpPath(void 0, "stdout-bundle" + ext);
+        }
         if (isMultiFlow || options.all) {
-          logger2.log(`Bundling ${configBasename} (flow: ${flowName})...`);
+          logger2.log(`Bundling flow: ${flowName}...`);
         } else {
-          logger2.log(`Bundling ${configBasename}...`);
+          logger2.log("Bundling...");
         }
         const shouldCollectStats = options.stats || options.json;
         const stats = await bundleCore(
@@ -1618,29 +2417,25 @@ async function bundleCommand(options) {
           logger2,
           shouldCollectStats
         );
-        results.push({
-          flowName,
-          success: true,
-          stats
-        });
+        results.push({ flowName, success: true, stats });
         if (!options.json && !options.all && options.stats && stats) {
           displayStats(stats, logger2);
         }
-        if (options.dockerfile && !options.all) {
-          const platform = getPlatform2(flowConfig);
-          if (platform) {
-            const outputDir = path9.dirname(buildOptions.output);
+        if (writingToStdout && !options.json) {
+          const bundleContent = await fs9.readFile(buildOptions.output);
+          await writeResult(bundleContent, {});
+        }
+        if (options.dockerfile && options.output) {
+          const platform2 = getPlatform2(flowConfig);
+          if (platform2) {
+            const outputDir = path10.dirname(buildOptions.output);
             const customFile = typeof options.dockerfile === "string" ? options.dockerfile : void 0;
-            await generateDockerfile(outputDir, platform, logger2, customFile);
+            await generateDockerfile(outputDir, platform2, logger2, customFile);
           }
         }
       } catch (error) {
         const errorMessage = getErrorMessage(error);
-        results.push({
-          flowName,
-          success: false,
-          error: errorMessage
-        });
+        results.push({ flowName, success: false, error: errorMessage });
         if (!options.all) {
           throw error;
         }
@@ -1650,7 +2445,7 @@ async function bundleCommand(options) {
     const successCount = results.filter((r) => r.success).length;
     const failureCount = results.filter((r) => !r.success).length;
     if (options.json) {
-      const output = failureCount === 0 ? createSuccessOutput(
+      const jsonResult = failureCount === 0 ? createSuccessOutput(
         {
           flows: results,
           summary: {
@@ -1664,7 +2459,9 @@ async function bundleCommand(options) {
         `${failureCount} flow(s) failed to build`,
         duration
       );
-      logger2.json(output);
+      await writeResult(JSON.stringify(jsonResult, null, 2) + "\n", {
+        output: options.output
+      });
     } else {
       if (options.all) {
         logger2.log(
@@ -1684,8 +2481,10 @@ Build Summary: ${successCount}/${results.length} succeeded`
     const duration = timer.getElapsed() / 1e3;
     const errorMessage = getErrorMessage(error);
     if (options.json) {
-      const output = createErrorOutput(errorMessage, duration);
-      logger2.json(output);
+      const jsonError = createErrorOutput(errorMessage, duration);
+      await writeResult(JSON.stringify(jsonError, null, 2) + "\n", {
+        output: options.output
+      });
     } else {
       logger2.error(`Error: ${errorMessage}`);
     }
@@ -1694,7 +2493,7 @@ Build Summary: ${successCount}/${results.length} succeeded`
 }
 async function bundle(configOrPath, options = {}) {
   let rawConfig;
-  let configPath = path9.resolve(process.cwd(), "walkeros.config.json");
+  let configPath = path10.resolve(process.cwd(), "walkeros.config.json");
   if (typeof configOrPath === "string") {
     configPath = resolveAsset(configOrPath, "config");
     rawConfig = await loadJsonConfig(configPath);
@@ -1717,14 +2516,14 @@ async function bundle(configOrPath, options = {}) {
     options.stats ?? false
   );
 }
-async function generateDockerfile(outputDir, platform, logger2, customFile) {
-  const destPath = path9.join(outputDir, "Dockerfile");
-  if (customFile && await fs8.pathExists(customFile)) {
-    await fs8.copy(customFile, destPath);
+async function generateDockerfile(outputDir, platform2, logger2, customFile) {
+  const destPath = path10.join(outputDir, "Dockerfile");
+  if (customFile && await fs9.pathExists(customFile)) {
+    await fs9.copy(customFile, destPath);
     logger2.log(`Dockerfile: ${destPath} (copied from ${customFile})`);
     return;
   }
-  const isWeb = platform === "web";
+  const isWeb = platform2 === "web";
   const bundleFile = isWeb ? "walker.js" : "bundle.mjs";
   const mode = isWeb ? "serve" : "collect";
   const dockerfile = `# Generated by walkeros CLI
@@ -1737,13 +2536,13 @@ ENV BUNDLE=/app/flow/${bundleFile}
 
 EXPOSE 8080
 `;
-  await fs8.writeFile(destPath, dockerfile);
+  await fs9.writeFile(destPath, dockerfile);
   logger2.log(`Dockerfile: ${destPath}`);
 }
 
 // src/commands/simulate/simulator.ts
-import path10 from "path";
-import fs10 from "fs-extra";
+import path11 from "path";
+import fs11 from "fs-extra";
 import { getPlatform as getPlatform3 } from "@walkeros/core";
 
 // src/commands/simulate/tracker.ts
@@ -1780,9 +2579,9 @@ var CallTracker = class {
     }
     for (const fullPath of paths) {
       const [destKey, ...pathParts] = fullPath.split(":");
-      const path14 = pathParts.join(":");
-      if (!path14) continue;
-      const cleanPath = path14.replace(/^call:/, "");
+      const path16 = pathParts.join(":");
+      if (!path16) continue;
+      const cleanPath = path16.replace(/^call:/, "");
       const parts = cleanPath.split(".");
       let current = wrapped;
       let source = env;
@@ -1826,7 +2625,7 @@ var CallTracker = class {
 
 // src/commands/simulate/jsdom-executor.ts
 import { JSDOM, VirtualConsole } from "jsdom";
-import fs9 from "fs-extra";
+import fs10 from "fs-extra";
 function buildSandboxFromEnvs(envs, destinations, tracker) {
   const baseBrowserMocks = {
     Image: class MockImage {
@@ -1895,7 +2694,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 fs10.readFile(bundlePath, "utf8");
   try {
     window.eval(bundleCode);
   } catch (error) {
@@ -2089,7 +2888,7 @@ async function executeSimulation(event, inputPath, platformOverride, options = {
   const tempDir = getTmpPath();
   const collectorLoggerConfig = options.logger ? createCollectorLoggerConfig(options.logger, options.verbose) : void 0;
   try {
-    await fs10.ensureDir(tempDir);
+    await fs11.ensureDir(tempDir);
     const detected = await detectInput(inputPath, platformOverride);
     if (!isObject(event) || !("name" in event) || typeof event.name !== "string") {
       throw new Error(
@@ -2126,7 +2925,7 @@ async function executeSimulation(event, inputPath, platformOverride, options = {
     };
   } finally {
     if (tempDir) {
-      await fs10.remove(tempDir).catch(() => {
+      await fs11.remove(tempDir).catch(() => {
       });
     }
   }
@@ -2135,11 +2934,11 @@ async function executeConfigSimulation(_content, configPath, typedEvent, tempDir
   const { flowConfig, buildOptions } = await loadFlowConfig(configPath, {
     flowName
   });
-  const platform = getPlatform3(flowConfig);
+  const platform2 = getPlatform3(flowConfig);
   const tracker = new CallTracker();
-  const tempOutput = path10.join(
+  const tempOutput = path11.join(
     tempDir,
-    `simulation-bundle-${generateId()}.${platform === "web" ? "js" : "mjs"}`
+    `simulation-bundle-${generateId()}.${platform2 === "web" ? "js" : "mjs"}`
   );
   const destinations = flowConfig.destinations;
   const simulationBuildOptions = {
@@ -2147,7 +2946,7 @@ async function executeConfigSimulation(_content, configPath, typedEvent, tempDir
     code: buildOptions.code || "",
     output: tempOutput,
     tempDir,
-    ...platform === "web" ? {
+    ...platform2 === "web" ? {
       format: "iife",
       platform: "browser",
       windowCollector: "collector",
@@ -2165,7 +2964,7 @@ async function executeConfigSimulation(_content, configPath, typedEvent, tempDir
   );
   const envs = await loadDestinationEnvs(destinations || {});
   let result;
-  if (platform === "web") {
+  if (platform2 === "web") {
     result = await executeInJSDOM(
       tempOutput,
       destinations || {},
@@ -2194,15 +2993,15 @@ async function executeConfigSimulation(_content, configPath, typedEvent, tempDir
     logs: []
   };
 }
-async function executeBundleSimulation(bundleContent, platform, typedEvent, tempDir, startTime, loggerConfig2) {
-  const tempOutput = path10.join(
+async function executeBundleSimulation(bundleContent, platform2, typedEvent, tempDir, startTime, loggerConfig2) {
+  const tempOutput = path11.join(
     tempDir,
-    `bundle-${generateId()}.${platform === "server" ? "mjs" : "js"}`
+    `bundle-${generateId()}.${platform2 === "server" ? "mjs" : "js"}`
   );
-  await fs10.writeFile(tempOutput, bundleContent, "utf8");
+  await fs11.writeFile(tempOutput, bundleContent, "utf8");
   const tracker = new CallTracker();
   let result;
-  if (platform === "web") {
+  if (platform2 === "web") {
     result = await executeInJSDOM(
       tempOutput,
       {},
@@ -2234,13 +3033,25 @@ async function executeBundleSimulation(bundleContent, platform, typedEvent, temp
 
 // src/commands/simulate/index.ts
 async function simulateCommand(options) {
-  const logger2 = createCommandLogger(options);
+  const logger2 = createCommandLogger({ ...options, stderr: true });
   const startTime = Date.now();
   try {
+    let config;
+    if (isStdinPiped() && !options.config) {
+      const stdinContent = await readStdin();
+      const fs20 = await import("fs-extra");
+      const path16 = await import("path");
+      const tmpPath = path16.default.resolve(".tmp", "stdin-simulate.json");
+      await fs20.default.ensureDir(path16.default.dirname(tmpPath));
+      await fs20.default.writeFile(tmpPath, stdinContent, "utf-8");
+      config = tmpPath;
+    } else {
+      config = options.config || "bundle.config.json";
+    }
     const event = await loadJsonFromSource(options.event, {
       name: "event"
     });
-    const result = await simulateCore(options.config, event, {
+    const result = await simulateCore(config, event, {
       flow: options.flow,
       json: options.json,
       verbose: options.verbose,
@@ -2250,23 +3061,24 @@ async function simulateCommand(options) {
       ...result,
       duration: (Date.now() - startTime) / 1e3
     };
-    const output = formatSimulationResult(resultWithDuration, {
+    const formatted = formatSimulationResult(resultWithDuration, {
       json: options.json
     });
-    if (options.json) {
-      console.log(output);
-    } else {
-      logger2.log(output);
-    }
+    await writeResult(formatted + "\n", { output: options.output });
     process.exit(result.success ? 0 : 1);
   } catch (error) {
     const errorMessage = getErrorMessage(error);
     if (options.json) {
-      logger2.json({
-        success: false,
-        error: errorMessage,
-        duration: (Date.now() - startTime) / 1e3
-      });
+      const errorOutput = JSON.stringify(
+        {
+          success: false,
+          error: errorMessage,
+          duration: (Date.now() - startTime) / 1e3
+        },
+        null,
+        2
+      );
+      await writeResult(errorOutput + "\n", { output: options.output });
     } else {
       logger2.error(`Error: ${errorMessage}`);
     }
@@ -2281,28 +3093,33 @@ async function simulate(configOrPath, event, options = {}) {
   }
   return await simulateCore(configOrPath, event, {
     json: options.json ?? false,
-    verbose: options.verbose ?? false
+    verbose: options.verbose ?? false,
+    flow: options.flow,
+    platform: options.platform
   });
 }
 
 // src/commands/push/index.ts
-import path11 from "path";
+import path12 from "path";
 import { JSDOM as JSDOM2, VirtualConsole as VirtualConsole2 } from "jsdom";
-import fs11 from "fs-extra";
+import fs12 from "fs-extra";
 import {
   getPlatform as getPlatform4
 } from "@walkeros/core";
 import { schemas as schemas2 } from "@walkeros/core/dev";
-async function pushCommand(options) {
-  const logger2 = createCommandLogger(options);
+async function pushCore(inputPath, event, options = {}) {
+  const logger2 = createCommandLogger({
+    silent: options.silent,
+    verbose: options.verbose
+  });
   const startTime = Date.now();
   let tempDir;
   try {
-    logger2.debug("Loading event");
-    const event = await loadJsonFromSource(options.event, {
-      name: "event"
-    });
-    const eventResult = schemas2.PartialEventSchema.safeParse(event);
+    let loadedEvent = event;
+    if (typeof event === "string") {
+      loadedEvent = await loadJsonFromSource(event, { name: "event" });
+    }
+    const eventResult = schemas2.PartialEventSchema.safeParse(loadedEvent);
     if (!eventResult.success) {
       const errors = eventResult.error.issues.map((issue) => `${String(issue.path.join("."))}: ${issue.message}`).join(", ");
       throw new Error(`Invalid event: ${errors}`);
@@ -2321,11 +3138,18 @@ async function pushCommand(options) {
       );
     }
     logger2.debug("Detecting input type");
-    const detected = await detectInput(options.config, options.platform);
+    const detected = await detectInput(
+      inputPath,
+      options.platform
+    );
     let result;
     if (detected.type === "config") {
       result = await executeConfigPush(
-        options,
+        {
+          config: inputPath,
+          flow: options.flow,
+          verbose: options.verbose
+        },
         validatedEvent,
         logger2,
         (dir) => {
@@ -2348,91 +3172,140 @@ async function pushCommand(options) {
         { logger: collectorLoggerConfig }
       );
     }
+    return result;
+  } catch (error) {
+    return {
+      success: false,
+      duration: Date.now() - startTime,
+      error: getErrorMessage(error)
+    };
+  } finally {
+    if (tempDir) {
+      await fs12.remove(tempDir).catch(() => {
+      });
+    }
+  }
+}
+async function pushCommand(options) {
+  const logger2 = createCommandLogger({ ...options, stderr: true });
+  const startTime = Date.now();
+  try {
+    let config;
+    if (isStdinPiped() && !options.config) {
+      const stdinContent = await readStdin();
+      const tmpPath = path12.resolve(".tmp", "stdin-push.json");
+      await fs12.ensureDir(path12.dirname(tmpPath));
+      await fs12.writeFile(tmpPath, stdinContent, "utf-8");
+      config = tmpPath;
+    } else {
+      config = options.config || "bundle.config.json";
+    }
+    const event = await loadJsonFromSource(options.event, { name: "event" });
+    const result = await pushCore(config, event, {
+      flow: options.flow,
+      json: options.json,
+      verbose: options.verbose,
+      silent: options.silent,
+      platform: options.platform
+    });
     const duration = Date.now() - startTime;
+    let output;
     if (options.json) {
-      logger2.json({
-        success: result.success,
-        event: result.elbResult,
-        duration
-      });
+      output = JSON.stringify(
+        {
+          success: result.success,
+          event: result.elbResult,
+          duration
+        },
+        null,
+        2
+      );
     } else {
+      const lines = [];
       if (result.success) {
-        logger2.log("Event pushed successfully");
+        lines.push("Event pushed successfully");
         if (result.elbResult && typeof result.elbResult === "object") {
           const pushResult = result.elbResult;
-          if ("id" in pushResult && pushResult.id) {
-            logger2.log(`  Event ID: ${pushResult.id}`);
-          }
-          if ("entity" in pushResult && pushResult.entity) {
-            logger2.log(`  Entity: ${pushResult.entity}`);
-          }
-          if ("action" in pushResult && pushResult.action) {
-            logger2.log(`  Action: ${pushResult.action}`);
-          }
+          if ("id" in pushResult && pushResult.id)
+            lines.push(`  Event ID: ${pushResult.id}`);
+          if ("entity" in pushResult && pushResult.entity)
+            lines.push(`  Entity: ${pushResult.entity}`);
+          if ("action" in pushResult && pushResult.action)
+            lines.push(`  Action: ${pushResult.action}`);
         }
-        logger2.log(`  Duration: ${duration}ms`);
+        lines.push(`  Duration: ${duration}ms`);
       } else {
-        logger2.error(`Error: ${result.error}`);
-        process.exit(1);
+        lines.push(`Error: ${result.error}`);
       }
+      output = lines.join("\n");
     }
-    process.exit(0);
+    await writeResult(output + "\n", { output: options.output });
+    process.exit(result.success ? 0 : 1);
   } catch (error) {
     const duration = Date.now() - startTime;
     const errorMessage = getErrorMessage(error);
     if (options.json) {
-      logger2.json({
-        success: false,
-        error: errorMessage,
-        duration
-      });
+      const errorOutput = JSON.stringify(
+        { success: false, error: errorMessage, duration },
+        null,
+        2
+      );
+      await writeResult(errorOutput + "\n", { output: options.output });
     } else {
       logger2.error(`Error: ${errorMessage}`);
     }
     process.exit(1);
-  } finally {
-    if (tempDir) {
-      await fs11.remove(tempDir).catch(() => {
-      });
-    }
   }
 }
+async function push(configOrPath, event, options = {}) {
+  if (typeof configOrPath !== "string") {
+    throw new Error(
+      "push() currently only supports config file paths. Config object support will be added in a future version. Please provide a path to a configuration file."
+    );
+  }
+  return await pushCore(configOrPath, event, {
+    json: options.json ?? false,
+    verbose: options.verbose ?? false,
+    flow: options.flow,
+    platform: options.platform
+  });
+}
 async function executeConfigPush(options, validatedEvent, logger2, setTempDir) {
   logger2.debug("Loading flow configuration");
   const { flowConfig, buildOptions } = await loadFlowConfig(options.config, {
     flowName: options.flow,
     logger: logger2
   });
-  const platform = getPlatform4(flowConfig);
+  const platform2 = getPlatform4(flowConfig);
   logger2.debug("Bundling flow configuration");
   const configDir = buildOptions.configDir || process.cwd();
-  const tempDir = path11.join(
+  const tempDir = path12.join(
     configDir,
     ".tmp",
     `push-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
   );
   setTempDir(tempDir);
-  await fs11.ensureDir(tempDir);
-  const tempPath = path11.join(
+  await fs12.ensureDir(tempDir);
+  const tempPath = path12.join(
     tempDir,
-    `bundle.${platform === "web" ? "js" : "mjs"}`
+    `bundle.${platform2 === "web" ? "js" : "mjs"}`
   );
   const pushBuildOptions = {
     ...buildOptions,
     output: tempPath,
-    format: platform === "web" ? "iife" : "esm",
-    platform: platform === "web" ? "browser" : "node",
-    ...platform === "web" && {
+    format: platform2 === "web" ? "iife" : "esm",
+    platform: platform2 === "web" ? "browser" : "node",
+    ...platform2 === "web" && {
       windowCollector: "collector",
       windowElb: "elb"
     }
   };
   await bundleCore(flowConfig, pushBuildOptions, logger2, false);
   logger2.debug(`Bundle created: ${tempPath}`);
-  if (platform === "web") {
+  if (platform2 === "web") {
     logger2.debug("Executing in web environment (JSDOM)");
     return executeWebPush(tempPath, validatedEvent, logger2);
-  } else if (platform === "server") {
+  } else if (platform2 === "server") {
     logger2.debug("Executing in server environment (Node.js)");
     const collectorLoggerConfig = createCollectorLoggerConfig(
       logger2,
@@ -2442,24 +3315,24 @@ async function executeConfigPush(options, validatedEvent, logger2, setTempDir) {
       logger: collectorLoggerConfig
     });
   } else {
-    throw new Error(`Unsupported platform: ${platform}`);
+    throw new Error(`Unsupported platform: ${platform2}`);
   }
 }
-async function executeBundlePush(bundleContent, platform, validatedEvent, logger2, setTempDir, context = {}) {
-  const tempDir = path11.join(
+async function executeBundlePush(bundleContent, platform2, validatedEvent, logger2, setTempDir, context = {}) {
+  const tempDir = path12.join(
     process.cwd(),
     ".tmp",
     `push-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
   );
   setTempDir(tempDir);
-  await fs11.ensureDir(tempDir);
-  const tempPath = path11.join(
+  await fs12.ensureDir(tempDir);
+  const tempPath = path12.join(
     tempDir,
-    `bundle.${platform === "server" ? "mjs" : "js"}`
+    `bundle.${platform2 === "server" ? "mjs" : "js"}`
   );
-  await fs11.writeFile(tempPath, bundleContent, "utf8");
+  await fs12.writeFile(tempPath, bundleContent, "utf8");
   logger2.debug(`Bundle written to: ${tempPath}`);
-  if (platform === "web") {
+  if (platform2 === "web") {
     logger2.debug("Executing in web environment (JSDOM)");
     return executeWebPush(tempPath, validatedEvent, logger2);
   } else {
@@ -2479,7 +3352,7 @@ async function executeWebPush(bundlePath, event, logger2) {
     });
     const { window } = dom;
     logger2.debug("Loading bundle...");
-    const bundleCode = await fs11.readFile(bundlePath, "utf8");
+    const bundleCode = await fs12.readFile(bundlePath, "utf8");
     window.eval(bundleCode);
     logger2.debug("Waiting for collector...");
     await waitForWindowProperty2(
@@ -2571,10 +3444,10 @@ function waitForWindowProperty2(window, prop, timeout = 5e3) {
 }
 
 // src/commands/run/index.ts
-import path13 from "path";
+import path14 from "path";
 
 // src/commands/run/validators.ts
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 
 // src/schemas/primitives.ts
 import { z } from "@walkeros/core/dev";
@@ -2591,6 +3464,69 @@ var RunOptionsSchema = z2.object({
   flowName: z2.string().optional().describe("Specific flow name to run")
 });
 
+// src/schemas/validate.ts
+import { z as z3 } from "@walkeros/core/dev";
+var ValidationTypeSchema = z3.enum(["event", "flow", "mapping"]).describe("Type of validation to perform");
+var ValidateOptionsSchema = z3.object({
+  flow: z3.string().optional().describe("Flow name for multi-flow configs")
+});
+var ValidateInputShape = {
+  type: ValidationTypeSchema,
+  input: z3.string().min(1).describe("JSON string, file path, or URL to validate"),
+  flow: z3.string().optional().describe("Flow name for multi-flow configs")
+};
+var ValidateInputSchema = z3.object(ValidateInputShape);
+
+// src/schemas/bundle.ts
+import { z as z4 } from "@walkeros/core/dev";
+var BundleOptionsSchema = z4.object({
+  silent: z4.boolean().optional().describe("Suppress all output"),
+  verbose: z4.boolean().optional().describe("Enable verbose logging"),
+  stats: z4.boolean().optional().default(true).describe("Return bundle statistics"),
+  cache: z4.boolean().optional().default(true).describe("Enable package caching"),
+  flowName: z4.string().optional().describe("Flow name for multi-flow configs")
+});
+var BundleInputShape = {
+  configPath: FilePathSchema.describe(
+    "Path to flow configuration file (JSON or JavaScript)"
+  ),
+  flow: z4.string().optional().describe("Flow name for multi-flow configs"),
+  stats: z4.boolean().optional().default(true).describe("Return bundle statistics"),
+  output: z4.string().optional().describe("Output file path (defaults to config-defined)")
+};
+var BundleInputSchema = z4.object(BundleInputShape);
+
+// src/schemas/simulate.ts
+import { z as z5 } from "@walkeros/core/dev";
+var PlatformSchema = z5.enum(["web", "server"]).describe("Platform type for event processing");
+var SimulateOptionsSchema = z5.object({
+  silent: z5.boolean().optional().describe("Suppress all output"),
+  verbose: z5.boolean().optional().describe("Enable verbose logging"),
+  json: z5.boolean().optional().describe("Format output as JSON")
+});
+var SimulateInputShape = {
+  configPath: FilePathSchema.describe("Path to flow configuration file"),
+  event: z5.string().min(1).describe("Event as JSON string, file path, or URL"),
+  flow: z5.string().optional().describe("Flow name for multi-flow configs"),
+  platform: PlatformSchema.optional().describe("Override platform detection")
+};
+var SimulateInputSchema = z5.object(SimulateInputShape);
+
+// src/schemas/push.ts
+import { z as z6 } from "@walkeros/core/dev";
+var PushOptionsSchema = z6.object({
+  silent: z6.boolean().optional().describe("Suppress all output"),
+  verbose: z6.boolean().optional().describe("Enable verbose logging"),
+  json: z6.boolean().optional().describe("Format output as JSON")
+});
+var PushInputShape = {
+  configPath: FilePathSchema.describe("Path to flow configuration file"),
+  event: z6.string().min(1).describe("Event as JSON string, file path, or URL"),
+  flow: z6.string().optional().describe("Flow name for multi-flow configs"),
+  platform: PlatformSchema.optional().describe("Override platform detection")
+};
+var PushInputSchema = z6.object(PushInputShape);
+
 // src/commands/run/validators.ts
 function validateMode(mode) {
   const result = RunModeSchema.safeParse(mode);
@@ -2604,7 +3540,7 @@ function validateMode(mode) {
 }
 function validateFlowFile(filePath) {
   const absolutePath = resolveAsset(filePath, "bundle");
-  if (!existsSync2(absolutePath)) {
+  if (!existsSync3(absolutePath)) {
     throw new Error(
       `Flow file not found: ${filePath}
    Resolved path: ${absolutePath}
@@ -2625,17 +3561,17 @@ function validatePort(port) {
 }
 
 // src/commands/run/utils.ts
-import path12 from "path";
-import fs12 from "fs-extra";
+import path13 from "path";
+import fs13 from "fs-extra";
 async function prepareBundleForRun(configPath, options) {
-  const configDir = path12.dirname(path12.resolve(configPath));
-  const tempDir = path12.join(
+  const configDir = path13.dirname(path13.resolve(configPath));
+  const tempDir = path13.join(
     configDir,
     ".tmp",
     `run-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
   );
-  await fs12.ensureDir(tempDir);
-  const tempPath = path12.join(tempDir, "bundle.mjs");
+  await fs13.ensureDir(tempDir);
+  const tempPath = path13.join(tempDir, "bundle.mjs");
   await bundle(configPath, {
     cache: true,
     verbose: options.verbose,
@@ -2826,8 +3762,8 @@ async function runCommand(mode, options) {
     let flowPath = null;
     if (mode === "collect") {
       if (isPreBuilt) {
-        flowPath = path13.resolve(configPath);
-        logger2.debug(`Using pre-built flow: ${path13.basename(flowPath)}`);
+        flowPath = path14.resolve(configPath);
+        logger2.debug(`Using pre-built flow: ${path14.basename(flowPath)}`);
       } else {
         logger2.debug("Building flow bundle");
         flowPath = await prepareBundleForRun(configPath, {
@@ -2877,7 +3813,7 @@ async function run(mode, options) {
     const isPreBuilt = isPreBuiltConfig(flowFile);
     let flowPath;
     if (isPreBuilt) {
-      flowPath = path13.resolve(flowFile);
+      flowPath = path14.resolve(flowFile);
     } else {
       flowPath = await prepareBundleForRun(flowFile, {
         verbose: options.verbose,
@@ -2906,7 +3842,7 @@ async function run(mode, options) {
 }
 
 // src/commands/validate/index.ts
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 
 // src/commands/validate/validators/event.ts
 import { schemas as schemas3 } from "@walkeros/core/dev";
@@ -2951,10 +3887,10 @@ function validateEvent(input) {
   const zodResult = PartialEventSchema.safeParse(input);
   if (!zodResult.success) {
     for (const issue of zodResult.error.issues) {
-      const path14 = issue.path.join(".");
-      if (path14 === "name") continue;
+      const path16 = issue.path.join(".");
+      if (path16 === "name") continue;
       errors.push({
-        path: path14 || "root",
+        path: path16 || "root",
         message: issue.message,
         code: "SCHEMA_VALIDATION"
       });
@@ -2990,9 +3926,9 @@ function validateFlow(input, options = {}) {
   const zodResult = SetupSchema.safeParse(input);
   if (!zodResult.success) {
     for (const issue of zodResult.error.issues) {
-      const path14 = issue.path.join(".");
+      const path16 = issue.path.join(".");
       errors.push({
-        path: path14 || "root",
+        path: path16 || "root",
         message: issue.message,
         code: "SCHEMA_VALIDATION"
       });
@@ -3127,16 +4063,16 @@ function formatResult(result, options) {
   }
   lines.push("Validation Results:");
   for (const error of result.errors) {
-    lines.push(chalk2.red(`  \u2717 ${error.path}: ${error.message}`));
+    lines.push(chalk3.red(`  \u2717 ${error.path}: ${error.message}`));
   }
   for (const warning of result.warnings) {
-    lines.push(chalk2.yellow(`  \u26A0 ${warning.path}: ${warning.message}`));
+    lines.push(chalk3.yellow(`  \u26A0 ${warning.path}: ${warning.message}`));
     if (warning.suggestion) {
-      lines.push(chalk2.gray(`    \u2192 ${warning.suggestion}`));
+      lines.push(chalk3.gray(`    \u2192 ${warning.suggestion}`));
     }
   }
   if (result.valid) {
-    lines.push(chalk2.green(`  \u2713 All checks passed`));
+    lines.push(chalk3.green(`  \u2713 All checks passed`));
   }
   lines.push("");
   lines.push(
@@ -3145,24 +4081,30 @@ function formatResult(result, options) {
   return lines.join("\n");
 }
 async function validateCommand(options) {
-  const logger2 = createCommandLogger(options);
+  const logger2 = createCommandLogger({ ...options, stderr: true });
   try {
-    const input = await loadJsonFromSource(options.input, {
-      name: options.type,
-      required: true
-    });
+    let input;
+    if (isStdinPiped() && !options.input) {
+      const stdinContent = await readStdin();
+      try {
+        input = JSON.parse(stdinContent);
+      } catch {
+        throw new Error("Invalid JSON received on stdin");
+      }
+    } else {
+      input = await loadJsonFromSource(options.input, {
+        name: options.type,
+        required: true
+      });
+    }
     const result = await validate(options.type, input, {
       flow: options.flow
     });
-    const output = formatResult(result, {
+    const formatted = formatResult(result, {
       json: options.json,
       verbose: options.verbose
     });
-    if (options.json) {
-      console.log(output);
-    } else {
-      logger2.log(output);
-    }
+    await writeResult(formatted + "\n", { output: options.output });
     if (!result.valid) {
       process.exit(1);
     }
@@ -3173,13 +4115,20 @@ async function validateCommand(options) {
   } catch (error) {
     const errorMessage = getErrorMessage(error);
     if (options.json) {
-      logger2.json({
-        valid: false,
-        type: options.type,
-        errors: [{ path: "input", message: errorMessage, code: "INPUT_ERROR" }],
-        warnings: [],
-        details: {}
-      });
+      const errorOutput = JSON.stringify(
+        {
+          valid: false,
+          type: options.type,
+          errors: [
+            { path: "input", message: errorMessage, code: "INPUT_ERROR" }
+          ],
+          warnings: [],
+          details: {}
+        },
+        null,
+        2
+      );
+      await writeResult(errorOutput + "\n", { output: options.output });
     } else {
       logger2.error(`Error: ${errorMessage}`);
     }
@@ -3188,21 +4137,22 @@ async function validateCommand(options) {
 }
 
 // src/commands/cache.ts
-import fs13 from "fs-extra";
+import fs14 from "fs-extra";
 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").option("--tmp-dir <dir>", "Custom temp directory").option("--silent", "Suppress output").action(async (options) => {
     const logger2 = createLogger({ silent: options.silent });
     const tmpDir = options.tmpDir;
     if (options.packages) {
-      await fs13.remove(getTmpPath(tmpDir, "cache", "packages"));
+      await fs14.remove(getTmpPath(tmpDir, "cache", "packages"));
       logger2.log("Package cache cleared");
     } else if (options.builds) {
-      await fs13.remove(getTmpPath(tmpDir, "cache", "builds"));
+      await fs14.remove(getTmpPath(tmpDir, "cache", "builds"));
       logger2.log("Build cache cleared");
     } else {
-      await fs13.remove(getTmpPath(tmpDir, "cache"));
-      logger2.log("All caches cleared");
+      const cacheDir = getTmpPath(tmpDir, "cache");
+      await fs14.remove(cacheDir);
+      logger2.log(`Cache cleared: ${cacheDir}`);
     }
   });
   cache.command("info").description("Show cache statistics").option("--tmp-dir <dir>", "Custom temp directory").option("--silent", "Suppress output").action(async (options) => {
@@ -3217,35 +4167,383 @@ function registerCacheCommand(program2) {
     logger2.log(`Cached builds: ${buildCount}`);
   });
 }
-function registerCleanCommand(program2) {
-  program2.command("clean").description("Clear the entire temp directory (.tmp/)").option("--tmp-dir <dir>", "Custom temp directory").option("--silent", "Suppress output").action(async (options) => {
-    const logger2 = createLogger({ silent: options.silent });
-    const tmpDir = options.tmpDir || getDefaultTmpRoot();
-    await fs13.remove(tmpDir);
-    logger2.log(`Temp directory cleared: ${tmpDir}`);
-  });
-}
 async function countEntries(dir) {
-  if (!await fs13.pathExists(dir)) return 0;
-  const entries = await fs13.readdir(dir);
+  if (!await fs14.pathExists(dir)) return 0;
+  const entries = await fs14.readdir(dir);
   return entries.length;
 }
 
+// src/commands/login/index.ts
+import { createServer } from "http";
+import { randomBytes } from "crypto";
+var LOGIN_TIMEOUT_MS = 2 * 60 * 1e3;
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+async function loginCommand(options) {
+  const logger2 = createLogger({
+    verbose: options.verbose,
+    silent: options.silent,
+    json: options.json
+  });
+  try {
+    const result = await login({ url: options.url });
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else if (result.success) {
+      logger2.success(`Logged in as ${result.email}`);
+      logger2.log(`Token stored in ${result.configPath}`);
+    }
+    process.exit(result.success ? 0 : 1);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (options.json) {
+      console.log(JSON.stringify({ success: false, error: message }, null, 2));
+    } else {
+      logger2.error(message);
+    }
+    process.exit(1);
+  }
+}
+async function login(options = {}) {
+  const appUrl = options.url || resolveAppUrl();
+  const state = randomBytes(32).toString("hex");
+  const { default: open2 } = await Promise.resolve().then(() => (init_open(), open_exports));
+  return new Promise((resolve3, reject) => {
+    const server = createServer(async (req, res) => {
+      const url = new URL(req.url || "", `http://localhost`);
+      if (url.pathname !== "/callback") {
+        res.writeHead(404);
+        res.end("Not found");
+        return;
+      }
+      const code = url.searchParams.get("code");
+      const returnedState = url.searchParams.get("state");
+      if (returnedState !== state) {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(
+          "<html><body><h1>Authorization failed</h1><p>State mismatch. Please try again.</p></body></html>"
+        );
+        cleanup();
+        reject(new Error("Authorization failed: state mismatch"));
+        return;
+      }
+      if (!code) {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(
+          "<html><body><h1>Authorization failed</h1><p>No authorization code received.</p></body></html>"
+        );
+        cleanup();
+        reject(new Error("Authorization failed: no code received"));
+        return;
+      }
+      try {
+        const exchangeResponse = await fetch(
+          `${appUrl}/api/auth/cli/exchange`,
+          {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ code })
+          }
+        );
+        if (!exchangeResponse.ok) {
+          const error = await exchangeResponse.json();
+          res.writeHead(200, { "Content-Type": "text/html" });
+          const safeMessage = escapeHtml(
+            error.error?.message || "Unknown error"
+          );
+          res.end(
+            `<html><body><h1>Authorization failed</h1><p>${safeMessage}</p></body></html>`
+          );
+          cleanup();
+          reject(new Error(error.error?.message || "Token exchange failed"));
+          return;
+        }
+        const data = await exchangeResponse.json();
+        writeConfig({
+          token: data.token,
+          email: data.email,
+          appUrl
+        });
+        const configPath = getConfigPath();
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(
+          "<html><body><h1>Authorized!</h1><p>You can close this tab and return to the terminal.</p></body></html>"
+        );
+        cleanup();
+        resolve3({ success: true, email: data.email, configPath });
+      } catch {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(
+          "<html><body><h1>Authorization failed</h1><p>Could not exchange authorization code.</p></body></html>"
+        );
+        cleanup();
+        reject(new Error("Token exchange failed"));
+      }
+    });
+    const timeout = setTimeout(() => {
+      cleanup();
+      reject(new Error("Authorization timed out. Please try again."));
+    }, LOGIN_TIMEOUT_MS);
+    function cleanup() {
+      clearTimeout(timeout);
+      server.close();
+    }
+    server.listen(0, () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        cleanup();
+        reject(new Error("Failed to start callback server"));
+        return;
+      }
+      const port = address.port;
+      const authUrl = `${appUrl}/auth/cli?port=${port}&state=${state}`;
+      open2(authUrl).catch(() => {
+        console.error(
+          `Could not open browser. Visit this URL manually:
+
+  ${authUrl}
+`
+        );
+      });
+    });
+  });
+}
+
+// src/commands/logout/index.ts
+async function logoutCommand(options) {
+  const logger2 = createLogger({
+    verbose: options.verbose,
+    silent: options.silent,
+    json: options.json
+  });
+  const deleted = deleteConfig();
+  const configPath = getConfigPath();
+  if (options.json) {
+    console.log(JSON.stringify({ success: true, deleted }));
+  } else if (deleted) {
+    logger2.success(`Logged out. Token removed from ${configPath}`);
+  } else {
+    logger2.log("No stored credentials found.");
+  }
+  process.exit(0);
+}
+
+// src/commands/auth/index.ts
+async function whoami() {
+  return apiRequest("/api/auth/whoami");
+}
+async function whoamiCommand(options) {
+  const logger2 = createCommandLogger(options);
+  try {
+    const result = await whoami();
+    if (options.json) {
+      await writeResult(JSON.stringify(result, null, 2), options);
+    } else {
+      const data = result;
+      if (data.email) logger2.log(`${data.email}`);
+      if (data.userId) logger2.log(`User: ${data.userId}`);
+      if (data.projectId) logger2.log(`Project: ${data.projectId}`);
+    }
+  } catch (error) {
+    logger2.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+// src/commands/projects/index.ts
+async function listProjects() {
+  return apiRequest("/api/projects");
+}
+async function getProject(options = {}) {
+  const id = options.projectId ?? requireProjectId();
+  return apiRequest(`/api/projects/${id}`);
+}
+async function createProject(options) {
+  return apiRequest("/api/projects", {
+    method: "POST",
+    body: JSON.stringify({ name: options.name })
+  });
+}
+async function updateProject(options) {
+  const id = options.projectId ?? requireProjectId();
+  return apiRequest(`/api/projects/${id}`, {
+    method: "PATCH",
+    body: JSON.stringify({ name: options.name })
+  });
+}
+async function deleteProject(options = {}) {
+  const id = options.projectId ?? requireProjectId();
+  return apiRequest(`/api/projects/${id}`, { method: "DELETE" });
+}
+async function handleResult(fn, options) {
+  const logger2 = createCommandLogger(options);
+  try {
+    const result = await fn();
+    await writeResult(JSON.stringify(result, null, 2), options);
+  } catch (error) {
+    logger2.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+async function listProjectsCommand(options) {
+  await handleResult(() => listProjects(), options);
+}
+async function getProjectCommand(projectId, options) {
+  await handleResult(
+    () => getProject({ projectId: projectId ?? options.project }),
+    options
+  );
+}
+async function createProjectCommand(name, options) {
+  await handleResult(() => createProject({ name }), options);
+}
+async function updateProjectCommand(projectId, options) {
+  const name = options.name;
+  if (!name) {
+    throw new Error("Missing required option: --name <name>");
+  }
+  await handleResult(
+    () => updateProject({
+      projectId: projectId ?? options.project,
+      name
+    }),
+    options
+  );
+}
+async function deleteProjectCommand(projectId, options) {
+  await handleResult(
+    () => deleteProject({ projectId: projectId ?? options.project }),
+    options
+  );
+}
+
+// src/commands/flows/index.ts
+async function listFlows(options = {}) {
+  const id = options.projectId ?? requireProjectId();
+  const params = new URLSearchParams();
+  if (options.sort) params.set("sort", options.sort);
+  if (options.order) params.set("order", options.order);
+  if (options.includeDeleted) params.set("include_deleted", "true");
+  const qs = params.toString();
+  return apiRequest(`/api/projects/${id}/flows${qs ? `?${qs}` : ""}`);
+}
+async function getFlow(options) {
+  const id = options.projectId ?? requireProjectId();
+  return apiRequest(`/api/projects/${id}/flows/${options.flowId}`);
+}
+async function createFlow(options) {
+  const id = options.projectId ?? requireProjectId();
+  return apiRequest(`/api/projects/${id}/flows`, {
+    method: "POST",
+    body: JSON.stringify({ name: options.name, content: options.content })
+  });
+}
+async function updateFlow(options) {
+  const id = options.projectId ?? requireProjectId();
+  const body = {};
+  if (options.name !== void 0) body.name = options.name;
+  if (options.content !== void 0) body.content = options.content;
+  return apiRequest(`/api/projects/${id}/flows/${options.flowId}`, {
+    method: "PATCH",
+    body: JSON.stringify(body)
+  });
+}
+async function deleteFlow(options) {
+  const id = options.projectId ?? requireProjectId();
+  return apiRequest(`/api/projects/${id}/flows/${options.flowId}`, {
+    method: "DELETE"
+  });
+}
+async function duplicateFlow(options) {
+  const id = options.projectId ?? requireProjectId();
+  const body = options.name ? { name: options.name } : {};
+  return apiRequest(`/api/projects/${id}/flows/${options.flowId}/duplicate`, {
+    method: "POST",
+    body: JSON.stringify(body)
+  });
+}
+async function handleResult2(fn, options) {
+  const logger2 = createCommandLogger(options);
+  try {
+    const result = await fn();
+    await writeResult(JSON.stringify(result, null, 2), options);
+  } catch (error) {
+    logger2.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+async function listFlowsCommand(options) {
+  await handleResult2(
+    () => listFlows({
+      projectId: options.project,
+      sort: options.sort,
+      order: options.order,
+      includeDeleted: options.includeDeleted
+    }),
+    options
+  );
+}
+async function getFlowCommand(flowId, options) {
+  await handleResult2(
+    () => getFlow({ flowId, projectId: options.project }),
+    options
+  );
+}
+async function createFlowCommand(name, options) {
+  const content = options.content ? JSON.parse(options.content) : JSON.parse(await readFlowStdin());
+  await handleResult2(
+    () => createFlow({ name, content, projectId: options.project }),
+    options
+  );
+}
+async function updateFlowCommand(flowId, options) {
+  const content = options.content ? JSON.parse(options.content) : void 0;
+  await handleResult2(
+    () => updateFlow({
+      flowId,
+      name: options.name,
+      content,
+      projectId: options.project
+    }),
+    options
+  );
+}
+async function deleteFlowCommand(flowId, options) {
+  await handleResult2(
+    () => deleteFlow({ flowId, projectId: options.project }),
+    options
+  );
+}
+async function duplicateFlowCommand(flowId, options) {
+  await handleResult2(
+    () => duplicateFlow({ flowId, name: options.name, projectId: options.project }),
+    options
+  );
+}
+async function readFlowStdin() {
+  if (!isStdinPiped()) {
+    throw new Error("Content required: use --content or pipe via stdin");
+  }
+  return readStdin();
+}
+
 // src/index.ts
 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(`${chalk3.hex("#01b5e2")("walkerOS")} v${VERSION}`);
+  if (!options.silent && !options.json && process.stdout.isTTY) {
+    printBanner(VERSION);
   }
 });
-program.command("bundle [file]").description("Bundle NPM packages with custom code").option("--flow <name>", "flow name for multi-flow configs").option("--all", "build all flows for multi-flow configs").option("--stats", "show bundle statistics").option("--json", "output as JSON (implies --stats)").option("--no-cache", "disable package caching").option("-v, --verbose", "verbose output").option("-s, --silent", "suppress output").option(
+program.command("bundle [file]").description("Bundle NPM packages with custom code").option("-o, --output <path>", "write bundle to file or directory").option("--flow <name>", "flow name for multi-flow configs").option("--all", "build all flows for multi-flow configs").option("--stats", "show bundle statistics").option("--json", "output as JSON (implies --stats)").option("--no-cache", "disable package caching").option("-v, --verbose", "verbose output").option("-s, --silent", "suppress output").option(
   "--dockerfile [file]",
   "generate Dockerfile (or copy custom file) to dist/"
 ).action(async (file, options) => {
   await bundleCommand({
-    config: file || "bundle.config.json",
+    config: file,
+    output: options.output,
     flow: options.flow,
     all: options.all,
     stats: options.stats,
@@ -3256,12 +4554,13 @@ program.command("bundle [file]").description("Bundle NPM packages with custom co
     dockerfile: options.dockerfile
   });
 });
-program.command("simulate [file]").description("Simulate event processing and capture API calls").option(
+program.command("simulate [file]").description("Simulate event processing and capture API calls").option("-o, --output <path>", "write result to file").option(
   "-e, --event <source>",
   "event to simulate (JSON string, file path, or URL)"
 ).option("--flow <name>", "flow name for multi-flow configs").option("-p, --platform <platform>", "platform override (web or server)").option("--json", "output as JSON").option("-v, --verbose", "verbose output").option("-s, --silent", "suppress output").action(async (file, options) => {
   await simulateCommand({
-    config: file || "bundle.config.json",
+    config: file,
+    output: options.output,
     event: options.event,
     flow: options.flow,
     platform: options.platform,
@@ -3273,9 +4572,10 @@ program.command("simulate [file]").description("Simulate event processing and ca
 program.command("push [file]").description("Push an event through the flow with real API execution").requiredOption(
   "-e, --event <source>",
   "event to push (JSON string, file path, or URL)"
-).option("--flow <name>", "flow name for multi-flow configs").option("-p, --platform <platform>", "platform override (web or server)").option("--json", "output as JSON").option("-v, --verbose", "verbose output").option("-s, --silent", "suppress output").action(async (file, options) => {
+).option("-o, --output <path>", "write result to file").option("--flow <name>", "flow name for multi-flow configs").option("-p, --platform <platform>", "platform override (web or server)").option("--json", "output as JSON").option("-v, --verbose", "verbose output").option("-s, --silent", "suppress output").action(async (file, options) => {
   await pushCommand({
-    config: file || "bundle.config.json",
+    config: file,
+    output: options.output,
     event: options.event,
     flow: options.flow,
     platform: options.platform,
@@ -3284,10 +4584,11 @@ program.command("push [file]").description("Push an event through the flow with
     silent: options.silent
   });
 });
-program.command("validate <type> [input]").description("Validate event, flow, or mapping configuration").option("--flow <name>", "flow name for multi-flow configs").option("--json", "output as JSON").option("-v, --verbose", "verbose output").option("-s, --silent", "suppress output").option("--strict", "fail on warnings").action(async (type, input, options) => {
+program.command("validate <type> [input]").description("Validate event, flow, or mapping configuration").option("-o, --output <path>", "write result to file").option("--flow <name>", "flow name for multi-flow configs").option("--json", "output as JSON").option("-v, --verbose", "verbose output").option("-s, --silent", "suppress output").option("--strict", "fail on warnings").action(async (type, input, options) => {
   await validateCommand({
     type,
     input,
+    output: options.output,
     flow: options.flow,
     json: options.json,
     verbose: options.verbose,
@@ -3295,6 +4596,65 @@ program.command("validate <type> [input]").description("Validate event, flow, or
     strict: options.strict
   });
 });
+var authCmd = program.command("auth").description("Authentication and identity");
+authCmd.command("login").description("Log in to walkerOS via browser").option("--url <url>", "custom app URL").option("--json", "output as JSON").option("-v, --verbose", "verbose output").option("-s, --silent", "suppress output").action(async (options) => {
+  await loginCommand({
+    url: options.url,
+    json: options.json,
+    verbose: options.verbose,
+    silent: options.silent
+  });
+});
+authCmd.command("logout").description("Remove stored credentials").option("--json", "output as JSON").option("-v, --verbose", "verbose output").option("-s, --silent", "suppress output").action(async (options) => {
+  await logoutCommand({
+    json: options.json,
+    verbose: options.verbose,
+    silent: options.silent
+  });
+});
+authCmd.command("whoami").description("Show current user identity").option("-o, --output <path>", "output file path").option("--json", "output as JSON").option("-v, --verbose", "verbose output").option("-s, --silent", "suppress output").action(async (options) => {
+  await whoamiCommand({
+    output: options.output,
+    json: options.json,
+    verbose: options.verbose,
+    silent: options.silent
+  });
+});
+var projectsCmd = program.command("projects").description("Manage walkerOS projects");
+projectsCmd.command("list").description("List all projects").option("-o, --output <path>", "output file path").option("--json", "output as JSON").option("-v, --verbose", "verbose output").option("-s, --silent", "suppress output").action(async (options) => {
+  await listProjectsCommand(options);
+});
+projectsCmd.command("get [projectId]").description("Get project details").option("-o, --output <path>", "output file path").option("--json", "output as JSON").option("-v, --verbose", "verbose output").option("-s, --silent", "suppress output").action(async (projectId, options) => {
+  await getProjectCommand(projectId, options);
+});
+projectsCmd.command("create <name>").description("Create a new project").option("-o, --output <path>", "output file path").option("--json", "output as JSON").option("-v, --verbose", "verbose output").option("-s, --silent", "suppress output").action(async (name, options) => {
+  await createProjectCommand(name, options);
+});
+projectsCmd.command("update [projectId]").description("Update a project").requiredOption("--name <name>", "new project name").option("-o, --output <path>", "output file path").option("--json", "output as JSON").option("-v, --verbose", "verbose output").option("-s, --silent", "suppress output").action(async (projectId, options) => {
+  await updateProjectCommand(projectId, options);
+});
+projectsCmd.command("delete [projectId]").description("Delete a project").option("-o, --output <path>", "output file path").option("--json", "output as JSON").option("-v, --verbose", "verbose output").option("-s, --silent", "suppress output").action(async (projectId, options) => {
+  await deleteProjectCommand(projectId, options);
+});
+var flowsCmd = program.command("flows").description("Manage walkerOS flows");
+flowsCmd.command("list").description("List all flows in a project").option("--project <id>", "project ID (defaults to WALKEROS_PROJECT_ID)").option("--sort <field>", "sort by: name, updated_at, created_at").option("--order <dir>", "sort order: asc, desc").option("--include-deleted", "include soft-deleted flows").option("-o, --output <path>", "output file path").option("--json", "output as JSON").option("-v, --verbose", "verbose output").option("-s, --silent", "suppress output").action(async (options) => {
+  await listFlowsCommand(options);
+});
+flowsCmd.command("get <flowId>").description("Get a flow with its full content").option("--project <id>", "project ID (defaults to WALKEROS_PROJECT_ID)").option("-o, --output <path>", "output file path").option("--json", "output as JSON").option("-v, --verbose", "verbose output").option("-s, --silent", "suppress output").action(async (flowId, options) => {
+  await getFlowCommand(flowId, options);
+});
+flowsCmd.command("create <name>").description("Create a new flow").option("--project <id>", "project ID (defaults to WALKEROS_PROJECT_ID)").option("-c, --content <json>", "Flow.Setup JSON string or file path").option("-o, --output <path>", "output file path").option("--json", "output as JSON").option("-v, --verbose", "verbose output").option("-s, --silent", "suppress output").action(async (name, options) => {
+  await createFlowCommand(name, options);
+});
+flowsCmd.command("update <flowId>").description("Update a flow").option("--project <id>", "project ID (defaults to WALKEROS_PROJECT_ID)").option("--name <name>", "new flow name").option("-c, --content <json>", "new Flow.Setup JSON string or file path").option("-o, --output <path>", "output file path").option("--json", "output as JSON").option("-v, --verbose", "verbose output").option("-s, --silent", "suppress output").action(async (flowId, options) => {
+  await updateFlowCommand(flowId, options);
+});
+flowsCmd.command("delete <flowId>").description("Delete a flow").option("--project <id>", "project ID (defaults to WALKEROS_PROJECT_ID)").option("-o, --output <path>", "output file path").option("--json", "output as JSON").option("-v, --verbose", "verbose output").option("-s, --silent", "suppress output").action(async (flowId, options) => {
+  await deleteFlowCommand(flowId, options);
+});
+flowsCmd.command("duplicate <flowId>").description("Duplicate a flow").option("--project <id>", "project ID (defaults to WALKEROS_PROJECT_ID)").option("--name <name>", "name for the copy").option("-o, --output <path>", "output file path").option("--json", "output as JSON").option("-v, --verbose", "verbose output").option("-s, --silent", "suppress output").action(async (flowId, options) => {
+  await duplicateFlowCommand(flowId, options);
+});
 var runCmd = program.command("run").description("Run walkerOS flows in collect or serve mode");
 runCmd.command("collect [file]").description(
   "Run collector mode (event collection endpoint). Defaults to server-collect.mjs if no file specified."
@@ -3323,16 +4683,34 @@ runCmd.command("serve [file]").description(
   });
 });
 registerCacheCommand(program);
-registerCleanCommand(program);
 program.parse();
 export {
+  apiRequest,
+  authenticatedFetch,
   bundle,
   bundleCommand,
+  createFlow,
+  createProject,
+  deleteFlow,
+  deleteProject,
+  duplicateFlow,
+  getAuthHeaders,
+  getFlow,
+  getProject,
+  getToken,
+  listFlows,
+  listProjects,
+  push,
   pushCommand,
+  requireProjectId,
+  resolveBaseUrl,
   run,
   runCommand,
   simulate,
   simulateCommand,
-  validate
+  updateFlow,
+  updateProject,
+  validate,
+  whoami
 };
 //# sourceMappingURL=index.js.map