@walkeros/cli 1.3.0 → 1.4.0-next-1771257332985

package/dist/index.js

@@ -1,608 +1,4 @@
 #!/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";
@@ -783,6 +179,7 @@ async function writeResult(content, options) {
     await fs.writeFile(outputPath, content);
   } else {
     process.stdout.write(content);
+    process.stdout.write("\n");
   }
 }
 function createJsonOutput(success, data, error, duration) {
@@ -903,38 +300,6 @@ function requireProjectId() {
   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
 function isUrl(str) {
@@ -1148,8 +513,8 @@ async function detectInput(inputPath, platformOverride) {
     JSON.parse(content);
     return { type: "config", content };
   } catch {
-    const platform2 = platformOverride ?? detectPlatformFromPath(inputPath);
-    return { type: "bundle", content, platform: platform2 };
+    const platform = platformOverride ?? detectPlatformFromPath(inputPath);
+    return { type: "bundle", content, platform };
   }
 }
 function detectPlatformFromPath(inputPath) {
@@ -1193,8 +558,8 @@ function validateFlowSetup(data) {
   const result = safeParseSetup(data);
   if (!result.success) {
     const errors = result.error.issues.map((issue) => {
-      const path16 = issue.path.length > 0 ? issue.path.map(String).join(".") : "root";
-      return `  - ${path16}: ${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}`);
@@ -1228,11 +593,11 @@ var DEFAULT_OUTPUT_PATHS = {
   web: "./dist/walker.js",
   server: "./dist/bundle.mjs"
 };
-function getBuildDefaults(platform2) {
-  return platform2 === "web" ? WEB_BUILD_DEFAULTS : SERVER_BUILD_DEFAULTS;
+function getBuildDefaults(platform) {
+  return platform === "web" ? WEB_BUILD_DEFAULTS : SERVER_BUILD_DEFAULTS;
 }
-function getDefaultOutput(platform2) {
-  return DEFAULT_OUTPUT_PATHS[platform2];
+function getDefaultOutput(platform) {
+  return DEFAULT_OUTPUT_PATHS[platform];
 }
 
 // src/config/loader.ts
@@ -1245,15 +610,15 @@ function loadBundleConfig(rawConfig, options) {
   const availableFlows = getAvailableFlows(setup);
   const flowName = resolveFlow(setup, options.flowName, availableFlows);
   const flowConfig = getFlowConfig(setup, flowName);
-  const platform2 = getPlatform(flowConfig);
-  if (!platform2) {
+  const platform = getPlatform(flowConfig);
+  if (!platform) {
     throw new Error(
       `Invalid configuration: flow "${flowName}" must have a "web" or "server" key.`
     );
   }
-  const buildDefaults = getBuildDefaults(platform2);
+  const buildDefaults = getBuildDefaults(platform);
   const packages = flowConfig.packages || {};
-  const output = options.buildOverrides?.output || getDefaultOutput(platform2);
+  const output = options.buildOverrides?.output || getDefaultOutput(platform);
   const configDir = isUrl(options.configPath) ? process.cwd() : path6.dirname(options.configPath);
   let includes = setup.include;
   if (!includes) {
@@ -2339,6 +1704,20 @@ 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);
@@ -2426,11 +1805,11 @@ async function bundleCommand(options) {
           await writeResult(bundleContent, {});
         }
         if (options.dockerfile && options.output) {
-          const platform2 = getPlatform2(flowConfig);
-          if (platform2) {
+          const platform = getPlatform2(flowConfig);
+          if (platform) {
             const outputDir = path10.dirname(buildOptions.output);
             const customFile = typeof options.dockerfile === "string" ? options.dockerfile : void 0;
-            await generateDockerfile(outputDir, platform2, logger2, customFile);
+            await generateDockerfile(outputDir, platform, logger2, customFile);
           }
         }
       } catch (error) {
@@ -2516,14 +1895,14 @@ async function bundle(configOrPath, options = {}) {
     options.stats ?? false
   );
 }
-async function generateDockerfile(outputDir, platform2, logger2, customFile) {
+async function generateDockerfile(outputDir, platform, 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 = platform2 === "web";
+  const isWeb = platform === "web";
   const bundleFile = isWeb ? "walker.js" : "bundle.mjs";
   const mode = isWeb ? "serve" : "collect";
   const dockerfile = `# Generated by walkeros CLI
@@ -2539,6 +1918,22 @@ EXPOSE 8080
   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 path11 from "path";
@@ -2579,9 +1974,9 @@ var CallTracker = class {
     }
     for (const fullPath of paths) {
       const [destKey, ...pathParts] = fullPath.split(":");
-      const path16 = pathParts.join(":");
-      if (!path16) continue;
-      const cleanPath = path16.replace(/^call:/, "");
+      const path15 = pathParts.join(":");
+      if (!path15) continue;
+      const cleanPath = path15.replace(/^call:/, "");
       const parts = cleanPath.split(".");
       let current = wrapped;
       let source = env;
@@ -2934,11 +2329,11 @@ async function executeConfigSimulation(_content, configPath, typedEvent, tempDir
   const { flowConfig, buildOptions } = await loadFlowConfig(configPath, {
     flowName
   });
-  const platform2 = getPlatform3(flowConfig);
+  const platform = getPlatform3(flowConfig);
   const tracker = new CallTracker();
   const tempOutput = path11.join(
     tempDir,
-    `simulation-bundle-${generateId()}.${platform2 === "web" ? "js" : "mjs"}`
+    `simulation-bundle-${generateId()}.${platform === "web" ? "js" : "mjs"}`
   );
   const destinations = flowConfig.destinations;
   const simulationBuildOptions = {
@@ -2946,7 +2341,7 @@ async function executeConfigSimulation(_content, configPath, typedEvent, tempDir
     code: buildOptions.code || "",
     output: tempOutput,
     tempDir,
-    ...platform2 === "web" ? {
+    ...platform === "web" ? {
       format: "iife",
       platform: "browser",
       windowCollector: "collector",
@@ -2964,7 +2359,7 @@ async function executeConfigSimulation(_content, configPath, typedEvent, tempDir
   );
   const envs = await loadDestinationEnvs(destinations || {});
   let result;
-  if (platform2 === "web") {
+  if (platform === "web") {
     result = await executeInJSDOM(
       tempOutput,
       destinations || {},
@@ -2993,15 +2388,15 @@ async function executeConfigSimulation(_content, configPath, typedEvent, tempDir
     logs: []
   };
 }
-async function executeBundleSimulation(bundleContent, platform2, typedEvent, tempDir, startTime, loggerConfig2) {
+async function executeBundleSimulation(bundleContent, platform, typedEvent, tempDir, startTime, loggerConfig2) {
   const tempOutput = path11.join(
     tempDir,
-    `bundle-${generateId()}.${platform2 === "server" ? "mjs" : "js"}`
+    `bundle-${generateId()}.${platform === "server" ? "mjs" : "js"}`
   );
   await fs11.writeFile(tempOutput, bundleContent, "utf8");
   const tracker = new CallTracker();
   let result;
-  if (platform2 === "web") {
+  if (platform === "web") {
     result = await executeInJSDOM(
       tempOutput,
       {},
@@ -3039,11 +2434,11 @@ async function simulateCommand(options) {
     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");
+      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";
@@ -3276,7 +2671,7 @@ async function executeConfigPush(options, validatedEvent, logger2, setTempDir) {
     flowName: options.flow,
     logger: logger2
   });
-  const platform2 = getPlatform4(flowConfig);
+  const platform = getPlatform4(flowConfig);
   logger2.debug("Bundling flow configuration");
   const configDir = buildOptions.configDir || process.cwd();
   const tempDir = path12.join(
@@ -3288,24 +2683,24 @@ async function executeConfigPush(options, validatedEvent, logger2, setTempDir) {
   await fs12.ensureDir(tempDir);
   const tempPath = path12.join(
     tempDir,
-    `bundle.${platform2 === "web" ? "js" : "mjs"}`
+    `bundle.${platform === "web" ? "js" : "mjs"}`
   );
   const pushBuildOptions = {
     ...buildOptions,
     output: tempPath,
-    format: platform2 === "web" ? "iife" : "esm",
-    platform: platform2 === "web" ? "browser" : "node",
-    ...platform2 === "web" && {
+    format: platform === "web" ? "iife" : "esm",
+    platform: platform === "web" ? "browser" : "node",
+    ...platform === "web" && {
       windowCollector: "collector",
       windowElb: "elb"
     }
   };
   await bundleCore(flowConfig, pushBuildOptions, logger2, false);
   logger2.debug(`Bundle created: ${tempPath}`);
-  if (platform2 === "web") {
+  if (platform === "web") {
     logger2.debug("Executing in web environment (JSDOM)");
     return executeWebPush(tempPath, validatedEvent, logger2);
-  } else if (platform2 === "server") {
+  } else if (platform === "server") {
     logger2.debug("Executing in server environment (Node.js)");
     const collectorLoggerConfig = createCollectorLoggerConfig(
       logger2,
@@ -3315,10 +2710,10 @@ async function executeConfigPush(options, validatedEvent, logger2, setTempDir) {
       logger: collectorLoggerConfig
     });
   } else {
-    throw new Error(`Unsupported platform: ${platform2}`);
+    throw new Error(`Unsupported platform: ${platform}`);
   }
 }
-async function executeBundlePush(bundleContent, platform2, validatedEvent, logger2, setTempDir, context = {}) {
+async function executeBundlePush(bundleContent, platform, validatedEvent, logger2, setTempDir, context = {}) {
   const tempDir = path12.join(
     process.cwd(),
     ".tmp",
@@ -3328,11 +2723,11 @@ async function executeBundlePush(bundleContent, platform2, validatedEvent, logge
   await fs12.ensureDir(tempDir);
   const tempPath = path12.join(
     tempDir,
-    `bundle.${platform2 === "server" ? "mjs" : "js"}`
+    `bundle.${platform === "server" ? "mjs" : "js"}`
   );
   await fs12.writeFile(tempPath, bundleContent, "utf8");
   logger2.debug(`Bundle written to: ${tempPath}`);
-  if (platform2 === "web") {
+  if (platform === "web") {
     logger2.debug("Executing in web environment (JSDOM)");
     return executeWebPush(tempPath, validatedEvent, logger2);
   } else {
@@ -3466,7 +2861,12 @@ var RunOptionsSchema = z2.object({
 
 // 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 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")
 });
@@ -3887,10 +3287,10 @@ function validateEvent(input) {
   const zodResult = PartialEventSchema.safeParse(input);
   if (!zodResult.success) {
     for (const issue of zodResult.error.issues) {
-      const path16 = issue.path.join(".");
-      if (path16 === "name") continue;
+      const path15 = issue.path.join(".");
+      if (path15 === "name") continue;
       errors.push({
-        path: path16 || "root",
+        path: path15 || "root",
         message: issue.message,
         code: "SCHEMA_VALIDATION"
       });
@@ -3926,9 +3326,9 @@ function validateFlow(input, options = {}) {
   const zodResult = SetupSchema.safeParse(input);
   if (!zodResult.success) {
     for (const issue of zodResult.error.issues) {
-      const path16 = issue.path.join(".");
+      const path15 = issue.path.join(".");
       errors.push({
-        path: path16 || "root",
+        path: path15 || "root",
         message: issue.message,
         code: "SCHEMA_VALIDATION"
       });
@@ -4033,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);
@@ -4174,11 +3710,11 @@ async function countEntries(dir) {
 }
 
 // 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;");
+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({
@@ -4207,107 +3743,57 @@ async function loginCommand(options) {
 }
 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}
-`
-        );
-      });
-    });
+  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
@@ -4331,7 +3817,10 @@ async function logoutCommand(options) {
 
 // src/commands/auth/index.ts
 async function whoami() {
-  return apiRequest("/api/auth/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);
@@ -4353,28 +3842,49 @@ async function whoamiCommand(options) {
 
 // src/commands/projects/index.ts
 async function listProjects() {
-  return apiRequest("/api/projects");
+  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();
-  return apiRequest(`/api/projects/${id}`);
+  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) {
-  return apiRequest("/api/projects", {
-    method: "POST",
-    body: JSON.stringify({ name: options.name })
+  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();
-  return apiRequest(`/api/projects/${id}`, {
-    method: "PATCH",
-    body: JSON.stringify({ name: options.name })
+  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();
-  return apiRequest(`/api/projects/${id}`, { method: "DELETE" });
+  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);
@@ -4421,47 +3931,85 @@ async function deleteProjectCommand(projectId, 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}` : ""}`);
+  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();
-  return apiRequest(`/api/projects/${id}/flows/${options.flowId}`);
+  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();
-  return apiRequest(`/api/projects/${id}/flows`, {
-    method: "POST",
-    body: JSON.stringify({ name: options.name, content: options.content })
+  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;
-  return apiRequest(`/api/projects/${id}/flows/${options.flowId}`, {
-    method: "PATCH",
-    body: JSON.stringify(body)
-  });
+  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();
-  return apiRequest(`/api/projects/${id}/flows/${options.flowId}`, {
-    method: "DELETE"
-  });
+  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 body = options.name ? { name: options.name } : {};
-  return apiRequest(`/api/projects/${id}/flows/${options.flowId}/duplicate`, {
-    method: "POST",
-    body: JSON.stringify(body)
-  });
+  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);
@@ -4685,10 +4233,10 @@ runCmd.command("serve [file]").description(
 registerCacheCommand(program);
 program.parse();
 export {
-  apiRequest,
-  authenticatedFetch,
   bundle,
   bundleCommand,
+  bundleRemote,
+  createApiClient,
   createFlow,
   createProject,
   deleteFlow,