@walkeros/cli 1.2.0 → 1.4.0-next-1771252576264

package/dist/index.js

@@ -2,7 +2,6 @@
 
 // src/index.ts
 import { Command } from "commander";
-import chalk3 from "chalk";
 
 // src/version.ts
 import { readFileSync } from "fs";
@@ -27,29 +26,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 +64,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 +109,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 +170,18 @@ 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);
+    process.stdout.write("\n");
+  }
+}
 function createJsonOutput(success, data, error, duration) {
   return {
     success,
@@ -171,25 +201,107 @@ 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;
+}
+
 // src/config/utils.ts
-import fs from "fs-extra";
-import path2 from "path";
 function isUrl(str) {
   try {
     const url = new URL(str);
@@ -203,7 +315,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 +323,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 +341,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 +356,7 @@ async function loadJsonConfig(configPath) {
   } finally {
     if (isTemporary) {
       try {
-        await fs.remove(absolutePath);
+        await fs2.remove(absolutePath);
       } catch {
       }
     }
@@ -266,11 +378,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 +392,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 +421,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 +438,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 +452,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 +482,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,7 +506,7 @@ 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 {
@@ -411,13 +523,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 +558,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 path15 = issue.path.length > 0 ? issue.path.map(String).join(".") : "root";
+      return `  - ${path15}: ${issue.message}`;
     }).join("\n");
     throw new Error(`Invalid configuration:
 ${errors}`);
@@ -473,8 +601,8 @@ function getDefaultOutput(platform) {
 }
 
 // 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) {
@@ -491,11 +619,11 @@ function loadBundleConfig(rawConfig, options) {
   const buildDefaults = getBuildDefaults(platform);
   const packages = flowConfig.packages || {};
   const output = options.buildOverrides?.output || getDefaultOutput(platform);
-  const configDir = isUrl(options.configPath) ? process.cwd() : path5.dirname(options.configPath);
+  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 +689,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 +737,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 +780,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 +810,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 +847,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 +865,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 +882,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 +910,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 +982,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 +1055,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 +1082,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 +1110,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 +1119,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 +1134,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 +1159,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 +1179,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 +1193,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]) => {
@@ -1576,17 +1704,62 @@ Package Breakdown:`);
   logger2.info("\u2500".repeat(50));
 }
 
+// src/core/api-client.ts
+import createClient from "openapi-fetch";
+function createApiClient() {
+  const token = getToken();
+  if (!token) throw new Error("WALKEROS_TOKEN not set.");
+  return createClient({
+    baseUrl: resolveBaseUrl(),
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    }
+  });
+}
+
 // 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 +1778,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 +1796,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) {
+        if (writingToStdout && !options.json) {
+          const bundleContent = await fs9.readFile(buildOptions.output);
+          await writeResult(bundleContent, {});
+        }
+        if (options.dockerfile && options.output) {
           const platform = getPlatform2(flowConfig);
           if (platform) {
-            const outputDir = path9.dirname(buildOptions.output);
+            const outputDir = path10.dirname(buildOptions.output);
             const customFile = typeof options.dockerfile === "string" ? options.dockerfile : void 0;
             await generateDockerfile(outputDir, platform, 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 +1824,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 +1838,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 +1860,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 +1872,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);
@@ -1718,9 +1896,9 @@ async function bundle(configOrPath, options = {}) {
   );
 }
 async function generateDockerfile(outputDir, platform, logger2, customFile) {
-  const destPath = path9.join(outputDir, "Dockerfile");
-  if (customFile && await fs8.pathExists(customFile)) {
-    await fs8.copy(customFile, destPath);
+  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;
   }
@@ -1737,13 +1915,29 @@ ENV BUNDLE=/app/flow/${bundleFile}
 
 EXPOSE 8080
 `;
-  await fs8.writeFile(destPath, dockerfile);
+  await fs9.writeFile(destPath, dockerfile);
   logger2.log(`Dockerfile: ${destPath}`);
 }
+async function bundleRemote(options) {
+  const client = createApiClient();
+  const { data, error, response } = await client.POST("/api/bundle", {
+    body: { flow: options.content },
+    parseAs: "text"
+  });
+  if (error)
+    throw new Error(typeof error === "string" ? error : "Bundle failed");
+  const js = data;
+  const statsHeader = response.headers.get("X-Bundle-Stats");
+  return {
+    bundle: js,
+    size: js.length,
+    stats: statsHeader ? JSON.parse(statsHeader) : void 0
+  };
+}
 
 // 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 +1974,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 path15 = pathParts.join(":");
+      if (!path15) continue;
+      const cleanPath = path15.replace(/^call:/, "");
       const parts = cleanPath.split(".");
       let current = wrapped;
       let source = env;
@@ -1826,7 +2020,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 +2089,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 +2283,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 +2320,7 @@ async function executeSimulation(event, inputPath, platformOverride, options = {
     };
   } finally {
     if (tempDir) {
-      await fs10.remove(tempDir).catch(() => {
+      await fs11.remove(tempDir).catch(() => {
       });
     }
   }
@@ -2137,7 +2331,7 @@ async function executeConfigSimulation(_content, configPath, typedEvent, tempDir
   });
   const platform = getPlatform3(flowConfig);
   const tracker = new CallTracker();
-  const tempOutput = path10.join(
+  const tempOutput = path11.join(
     tempDir,
     `simulation-bundle-${generateId()}.${platform === "web" ? "js" : "mjs"}`
   );
@@ -2195,11 +2389,11 @@ async function executeConfigSimulation(_content, configPath, typedEvent, tempDir
   };
 }
 async function executeBundleSimulation(bundleContent, platform, typedEvent, tempDir, startTime, loggerConfig2) {
-  const tempOutput = path10.join(
+  const tempOutput = path11.join(
     tempDir,
     `bundle-${generateId()}.${platform === "server" ? "mjs" : "js"}`
   );
-  await fs10.writeFile(tempOutput, bundleContent, "utf8");
+  await fs11.writeFile(tempOutput, bundleContent, "utf8");
   const tracker = new CallTracker();
   let result;
   if (platform === "web") {
@@ -2234,13 +2428,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 fs15 = await import("fs-extra");
+      const path15 = await import("path");
+      const tmpPath = path15.default.resolve(".tmp", "stdin-simulate.json");
+      await fs15.default.ensureDir(path15.default.dirname(tmpPath));
+      await fs15.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 +2456,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 +2488,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 +2533,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,55 +2567,104 @@ 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, {
@@ -2406,14 +2674,14 @@ async function executeConfigPush(options, validatedEvent, logger2, setTempDir) {
   const platform = 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"}`
   );
@@ -2446,18 +2714,18 @@ async function executeConfigPush(options, validatedEvent, logger2, setTempDir) {
   }
 }
 async function executeBundlePush(bundleContent, platform, validatedEvent, logger2, setTempDir, context = {}) {
-  const tempDir = path11.join(
+  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"}`
   );
-  await fs11.writeFile(tempPath, bundleContent, "utf8");
+  await fs12.writeFile(tempPath, bundleContent, "utf8");
   logger2.debug(`Bundle written to: ${tempPath}`);
   if (platform === "web") {
     logger2.debug("Executing in web environment (JSDOM)");
@@ -2479,7 +2747,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 +2839,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 +2859,74 @@ 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.union([
+  z3.enum(["event", "flow", "mapping"]),
+  z3.string().regex(/^(destinations|sources|transformers)\.\w+$|^\w+$/)
+]).describe(
+  'Validation type: "event", "flow", "mapping", or dot-notation path (e.g., "destinations.snowplow") to validate a specific entry against its package schema'
+);
+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 +2940,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 +2961,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 +3162,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 +3213,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 +3242,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 +3287,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 path15 = issue.path.join(".");
+      if (path15 === "name") continue;
       errors.push({
-        path: path14 || "root",
+        path: path15 || "root",
         message: issue.message,
         code: "SCHEMA_VALIDATION"
       });
@@ -2990,9 +3326,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 path15 = issue.path.join(".");
       errors.push({
-        path: path14 || "root",
+        path: path15 || "root",
         message: issue.message,
         code: "SCHEMA_VALIDATION"
       });
@@ -3097,8 +3433,144 @@ function validateMapping(input) {
   };
 }
 
+// src/commands/validate/validators/entry.ts
+import Ajv from "ajv";
+import { fetchPackageSchema } from "@walkeros/core";
+var SECTIONS = ["destinations", "sources", "transformers"];
+function resolveEntry(path15, flowConfig) {
+  const flows = flowConfig.flows;
+  if (!flows || typeof flows !== "object") return "No flows found in config";
+  const flowName = Object.keys(flows)[0];
+  const flow = flows[flowName];
+  if (!flow) return `Flow "${flowName}" is empty`;
+  const parts = path15.split(".");
+  if (parts.length === 2) {
+    const [section, key] = parts;
+    if (!SECTIONS.includes(section)) {
+      return `Unknown section "${section}". Must be one of: ${SECTIONS.join(", ")}`;
+    }
+    const sectionData = flow[section];
+    if (!sectionData || !(key in sectionData)) {
+      return `Entry "${key}" not found in ${section}`;
+    }
+    return {
+      section,
+      key,
+      entry: sectionData[key]
+    };
+  }
+  if (parts.length === 1) {
+    const key = parts[0];
+    const matches = [];
+    for (const section of SECTIONS) {
+      const sectionData = flow[section];
+      if (sectionData && key in sectionData) {
+        matches.push({
+          section,
+          entry: sectionData[key]
+        });
+      }
+    }
+    if (matches.length === 0) {
+      return `Entry "${key}" not found in any section`;
+    }
+    if (matches.length > 1) {
+      const sections = matches.map((m) => m.section).join(", ");
+      return `Ambiguous key "${key}" found in multiple sections: ${sections}. Use dot-notation (e.g., destinations.${key})`;
+    }
+    return { section: matches[0].section, key, entry: matches[0].entry };
+  }
+  return `Invalid path "${path15}". Use "section.key" or just "key"`;
+}
+async function validateEntry(path15, flowConfig) {
+  const resolved = resolveEntry(path15, flowConfig);
+  if (typeof resolved === "string") {
+    return {
+      valid: false,
+      type: "entry",
+      errors: [{ path: path15, message: resolved, code: "ENTRY_VALIDATION" }],
+      warnings: [],
+      details: {}
+    };
+  }
+  const { section, key, entry } = resolved;
+  const packageName = entry.package;
+  if (!packageName) {
+    return {
+      valid: true,
+      type: "entry",
+      errors: [],
+      warnings: [],
+      details: {
+        section,
+        key,
+        skipped: true,
+        reason: "No package field \u2014 skipping remote schema validation"
+      }
+    };
+  }
+  let schemas5;
+  try {
+    const info = await fetchPackageSchema(packageName);
+    schemas5 = info.schemas;
+  } catch (error) {
+    return {
+      valid: false,
+      type: "entry",
+      errors: [
+        {
+          path: path15,
+          message: error instanceof Error ? error.message : "Unknown error",
+          code: "ENTRY_VALIDATION"
+        }
+      ],
+      warnings: [],
+      details: { section, key, package: packageName }
+    };
+  }
+  const settingsSchema = schemas5?.settings;
+  if (!settingsSchema) {
+    return {
+      valid: true,
+      type: "entry",
+      errors: [],
+      warnings: [],
+      details: { section, key, note: "Package has no settings schema" }
+    };
+  }
+  const config = entry.config;
+  const settings = config?.settings;
+  const ajv = new Ajv({ allErrors: true });
+  const validate2 = ajv.compile(settingsSchema);
+  const isValid = validate2(settings || {});
+  if (!isValid) {
+    const errors = (validate2.errors || []).map((e) => ({
+      path: e.instancePath || "/",
+      message: e.message || "Unknown error",
+      code: e.keyword
+    }));
+    return {
+      valid: false,
+      type: "entry",
+      errors,
+      warnings: [],
+      details: { section, key, package: packageName }
+    };
+  }
+  return {
+    valid: true,
+    type: "entry",
+    errors: [],
+    warnings: [],
+    details: { section, key, package: packageName }
+  };
+}
+
 // src/commands/validate/index.ts
 async function validate(type, input, options = {}) {
+  if (type.includes(".") || !["event", "flow", "mapping"].includes(type)) {
+    return validateEntry(type, input);
+  }
   switch (type) {
     case "event":
       return validateEvent(input);
@@ -3127,16 +3599,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 +3617,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 +3651,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 +3673,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 +3703,395 @@ 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 { hostname } from "os";
+var POLL_TIMEOUT_BUFFER_MS = 5e3;
+async function openInBrowser(url) {
+  const { default: open } = await import("open");
+  await open(url);
+}
+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 f = options.fetch ?? globalThis.fetch;
+  const codeResponse = await f(`${appUrl}/api/auth/device/code`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({})
+  });
+  if (!codeResponse.ok) {
+    return { success: false, error: "Failed to request device code" };
+  }
+  const { deviceCode, userCode, verificationUri, expiresIn, interval } = await codeResponse.json();
+  console.error(`
+! Your one-time code: ${userCode}`);
+  console.error(`  Authorize here: ${verificationUri}
+`);
+  const opener = options.openUrl ?? openInBrowser;
+  try {
+    await opener(verificationUri);
+    console.error("  Opening browser...");
+  } catch {
+    console.error("  Could not open browser. Visit the URL manually.");
+  }
+  console.error("  Waiting for authorization... (press Ctrl+C to cancel)\n");
+  const deadline = Date.now() + expiresIn * 1e3 + POLL_TIMEOUT_BUFFER_MS;
+  let pollInterval = (interval ?? 5) * 1e3;
+  const maxAttempts = options.maxPollAttempts ?? Infinity;
+  let attempts = 0;
+  while (Date.now() < deadline && attempts < maxAttempts) {
+    attempts++;
+    await new Promise((r) => setTimeout(r, pollInterval));
+    const tokenResponse = await f(`${appUrl}/api/auth/device/token`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ deviceCode, hostname: hostname() })
+    });
+    const data = await tokenResponse.json();
+    if (tokenResponse.ok && data.token) {
+      writeConfig({ token: data.token, email: data.email, appUrl });
+      const configPath = getConfigPath();
+      return { success: true, email: data.email, configPath };
+    }
+    if (data.error === "authorization_pending") continue;
+    if (data.error === "slow_down") {
+      pollInterval += 5e3;
+      continue;
+    }
+    return { success: false, error: data.error || "Authorization failed" };
+  }
+  return {
+    success: false,
+    error: "Authorization timed out. Please try again."
+  };
+}
+
+// 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() {
+  const client = createApiClient();
+  const { data, error } = await client.GET("/api/auth/whoami");
+  if (error) throw new Error(error.error?.message || "Not authenticated");
+  return data;
+}
+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() {
+  const client = createApiClient();
+  const { data, error } = await client.GET("/api/projects");
+  if (error) throw new Error(error.error?.message || "Failed to list projects");
+  return data;
+}
+async function getProject(options = {}) {
+  const id = options.projectId ?? requireProjectId();
+  const client = createApiClient();
+  const { data, error } = await client.GET("/api/projects/{projectId}", {
+    params: { path: { projectId: id } }
+  });
+  if (error) throw new Error(error.error?.message || "Failed to get project");
+  return data;
+}
+async function createProject(options) {
+  const client = createApiClient();
+  const { data, error } = await client.POST("/api/projects", {
+    body: { name: options.name }
+  });
+  if (error)
+    throw new Error(error.error?.message || "Failed to create project");
+  return data;
+}
+async function updateProject(options) {
+  const id = options.projectId ?? requireProjectId();
+  const client = createApiClient();
+  const { data, error } = await client.PATCH("/api/projects/{projectId}", {
+    params: { path: { projectId: id } },
+    body: { name: options.name }
+  });
+  if (error)
+    throw new Error(error.error?.message || "Failed to update project");
+  return data;
+}
+async function deleteProject(options = {}) {
+  const id = options.projectId ?? requireProjectId();
+  const client = createApiClient();
+  const { data, error } = await client.DELETE("/api/projects/{projectId}", {
+    params: { path: { projectId: id } }
+  });
+  if (error)
+    throw new Error(error.error?.message || "Failed to delete project");
+  return data ?? { success: true };
+}
+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 client = createApiClient();
+  const { data, error } = await client.GET("/api/projects/{projectId}/flows", {
+    params: {
+      path: { projectId: id },
+      query: {
+        sort: options.sort,
+        order: options.order,
+        include_deleted: options.includeDeleted ? "true" : void 0
+      }
+    }
+  });
+  if (error) throw new Error(error.error?.message || "Failed to list flows");
+  return data;
+}
+async function getFlow(options) {
+  const id = options.projectId ?? requireProjectId();
+  const client = createApiClient();
+  const { data, error } = await client.GET(
+    "/api/projects/{projectId}/flows/{flowId}",
+    {
+      params: { path: { projectId: id, flowId: options.flowId } }
+    }
+  );
+  if (error) throw new Error(error.error?.message || "Failed to get flow");
+  return data;
+}
+async function createFlow(options) {
+  const id = options.projectId ?? requireProjectId();
+  const client = createApiClient();
+  const { data, error } = await client.POST("/api/projects/{projectId}/flows", {
+    params: { path: { projectId: id } },
+    // Content is user-provided JSON; server validates the full schema
+    body: { name: options.name, content: options.content }
+  });
+  if (error) throw new Error(error.error?.message || "Failed to create flow");
+  return data;
+}
+async function updateFlow(options) {
+  const id = options.projectId ?? requireProjectId();
+  const client = createApiClient();
+  const body = {};
+  if (options.name !== void 0) body.name = options.name;
+  if (options.content !== void 0) body.content = options.content;
+  const { data, error } = await client.PATCH(
+    "/api/projects/{projectId}/flows/{flowId}",
+    {
+      params: { path: { projectId: id, flowId: options.flowId } },
+      // Dynamically constructed body; server validates the full schema
+      body
+    }
+  );
+  if (error) throw new Error(error.error?.message || "Failed to update flow");
+  return data;
+}
+async function deleteFlow(options) {
+  const id = options.projectId ?? requireProjectId();
+  const client = createApiClient();
+  const { data, error } = await client.DELETE(
+    "/api/projects/{projectId}/flows/{flowId}",
+    {
+      params: { path: { projectId: id, flowId: options.flowId } }
+    }
+  );
+  if (error) throw new Error(error.error?.message || "Failed to delete flow");
+  return data ?? { success: true };
+}
+async function duplicateFlow(options) {
+  const id = options.projectId ?? requireProjectId();
+  const client = createApiClient();
+  const { data, error } = await client.POST(
+    "/api/projects/{projectId}/flows/{flowId}/duplicate",
+    {
+      params: { path: { projectId: id, flowId: options.flowId } },
+      body: { name: options.name }
+    }
+  );
+  if (error)
+    throw new Error(error.error?.message || "Failed to duplicate flow");
+  return data;
+}
+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 +4102,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 +4120,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 +4132,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 +4144,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 +4231,34 @@ runCmd.command("serve [file]").description(
   });
 });
 registerCacheCommand(program);
-registerCleanCommand(program);
 program.parse();
 export {
   bundle,
   bundleCommand,
+  bundleRemote,
+  createApiClient,
+  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