@adkit.so/cli 1.0.0 → 1.0.2

package/dist/cli.js

@@ -1,16 +1,1407 @@
 #!/usr/bin/env node
-import { resolveConfig, readConfig } from './config.js';
-import { AdkitClient } from './client.js';
-import { formatOutput } from './output.js';
-import { login, logout } from './commands/auth.js';
-import { listProjects, useProject, currentProject } from './commands/projects.js';
-import { listAccounts, connectAccount, disconnectAccount, listPages, listPixels, listCampaigns, createCampaign, updateCampaign, deleteCampaign, listAdSets, createAdSet, updateAdSet, deleteAdSet, listAds, createAd, updateAd, deleteAd, createCreative, updateCreative, deleteCreative, uploadMedia, listMedia, deleteMedia, searchInterests } from './commands/meta.js';
-import { status } from './commands/status.js';
-import { listDrafts, getDraft, publishDraft, deleteDraft } from './commands/drafts.js';
-import { parseArgs, unwrapList } from './cli-utils.js';
-import { CliError } from './errors.js';
-const DEFAULT_BASE_URL = 'https://app.adkit.so/api/v1';
-const USAGE = `
+
+// src/config.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+var CONFIG_DIR = join(homedir(), ".config", "adkit");
+var CONFIG_PATH = join(CONFIG_DIR, "config.json");
+function parseConfigFile(raw) {
+  const parsed = JSON.parse(raw);
+  if (!parsed || typeof parsed !== "object") return {};
+  return parsed;
+}
+function readConfig() {
+  if (!existsSync(CONFIG_PATH)) return null;
+  try {
+    return parseConfigFile(readFileSync(CONFIG_PATH, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeConfig(updates) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  let existing = {};
+  if (existsSync(CONFIG_PATH)) {
+    try {
+      existing = parseConfigFile(readFileSync(CONFIG_PATH, "utf-8"));
+    } catch {
+    }
+  }
+  const merged = { ...existing, ...updates };
+  writeFileSync(CONFIG_PATH, JSON.stringify(merged, null, 2), { mode: 384 });
+}
+function resolveConfig(flags = {}) {
+  const envKey = process.env.ADKIT_API_KEY;
+  if (envKey) return { apiKey: envKey };
+  const config = readConfig();
+  if (!config) return { apiKey: null };
+  if (flags.project) {
+    const projectKey = config.projects?.[flags.project]?.apiKey ?? null;
+    return { apiKey: projectKey, selectedProject: config.selectedProject };
+  }
+  if (config.selectedProject && config.projects?.[config.selectedProject]) {
+    return {
+      apiKey: config.projects[config.selectedProject]?.apiKey ?? null,
+      selectedProject: config.selectedProject
+    };
+  }
+  return {
+    apiKey: config.apiKey ?? null,
+    selectedProject: config.selectedProject
+  };
+}
+function getDefaultAccount(platform2) {
+  const config = readConfig();
+  if (!config?.selectedProject || !config.projects) return null;
+  const project = config.projects[config.selectedProject];
+  if (!project) return null;
+  return (platform2 === "meta" ? project.defaultMetaAccount : project.defaultGoogleAccount) ?? null;
+}
+
+// src/errors.ts
+var CliError = class extends Error {
+  code;
+  suggestion;
+  constructor(code, message, suggestion) {
+    super(message);
+    this.code = code;
+    this.suggestion = suggestion;
+  }
+};
+
+// src/client.ts
+function isErrorResponse(value) {
+  return value != null && typeof value === "object";
+}
+var AdkitClient = class {
+  apiKey;
+  baseUrl;
+  constructor({ apiKey, baseUrl }) {
+    const isLocalhost = baseUrl.startsWith("http://localhost") || baseUrl.startsWith("http://127.0.0.1");
+    if (baseUrl.startsWith("http://") && !isLocalhost) throw new Error("HTTPS is required \u2014 insecure HTTP base URLs are not allowed");
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl;
+  }
+  async request(method, path2, body) {
+    const url = `${this.baseUrl}${path2}`;
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json"
+    };
+    const init = { method, headers };
+    if (body !== void 0) init.body = JSON.stringify(body);
+    let response;
+    try {
+      response = await fetch(url, init);
+    } catch (err) {
+      if (err instanceof DOMException && err.name === "AbortError") throw new CliError("NETWORK_ERROR", "Request timed out", "Retry the command");
+      throw new CliError("NETWORK_ERROR", "Network connection error \u2014 check your internet connection and try again. If using a custom base URL, verify `ADKIT_BASE_URL` is correct.", "Check internet connection");
+    }
+    if (response.status === 204) return void 0;
+    if (!response.ok) {
+      let serverMessage = "";
+      let dataMessage = "";
+      let retryable;
+      try {
+        const json = await response.json();
+        if (isErrorResponse(json)) {
+          serverMessage = json.statusMessage ?? json.message ?? "";
+          dataMessage = json.data?.message ?? "";
+          retryable = json.data?.retryable;
+        }
+      } catch {
+      }
+      if (response.status === 401) throw new CliError("INVALID_API_KEY", `Invalid or expired API key${serverMessage ? ` \u2014 ${serverMessage}` : ""}`, "Run: adkit setup");
+      if (response.status === 429) {
+        const retryAfter = response.headers.get("Retry-After") ?? "60";
+        throw new CliError("RATE_LIMITED", serverMessage || "Rate limit exceeded", `Wait ${retryAfter} seconds before retrying`);
+      }
+      if (response.status === 404) {
+        const fallback = `Not found: ${method} ${path2} \u2014 the resource may have been deleted or the ID is wrong`;
+        throw new CliError("NOT_FOUND", serverMessage || fallback, "Check the resource ID");
+      }
+      if (response.status >= 500) {
+        const errorMsg = dataMessage || serverMessage || `Server error (HTTP ${String(response.status)})`;
+        let suggestion;
+        if (retryable === true) suggestion = "Retry in a few seconds";
+        throw new CliError("SERVER_ERROR", errorMsg, suggestion);
+      }
+      throw new CliError("SERVER_ERROR", serverMessage || `Request failed (HTTP ${String(response.status)})`);
+    }
+    return response.json();
+  }
+  async get(path2) {
+    return this.request("GET", path2);
+  }
+  async post(path2, body) {
+    return this.request("POST", path2, body);
+  }
+  async patch(path2, body) {
+    return this.request("PATCH", path2, body);
+  }
+  async delete(path2) {
+    return this.request("DELETE", path2);
+  }
+};
+
+// src/output.ts
+function filterFields(data, fields) {
+  return data.map((row) => {
+    const filtered = {};
+    for (const f of fields) {
+      if (f in row) filtered[f] = row[f];
+    }
+    return filtered;
+  });
+}
+function toStr(value) {
+  if (value == null) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return `${value}`;
+  return JSON.stringify(value);
+}
+function formatTable(data) {
+  if (data.length === 0) return "";
+  const keys = Object.keys(data[0]);
+  const widths = {};
+  for (const key of keys) {
+    widths[key] = key.length;
+    for (const row of data) {
+      const val = toStr(row[key]);
+      if (val.length > widths[key]) widths[key] = val.length;
+    }
+  }
+  const header = keys.map((k) => k.toUpperCase().padEnd(widths[k])).join("  ");
+  const separator = keys.map((k) => "-".repeat(widths[k])).join("  ");
+  const rows = data.map((row) => keys.map((k) => toStr(row[k]).padEnd(widths[k])).join("  "));
+  return [header, separator, ...rows].join("\n");
+}
+function formatOutput(data, options) {
+  let rows = data;
+  if (options.fields) {
+    rows = filterFields(rows, options.fields);
+  }
+  const json = options.json ?? !(process.stdout.isTTY ?? false);
+  if (json) {
+    return JSON.stringify(rows);
+  }
+  return formatTable(rows);
+}
+
+// ../../node_modules/open/index.js
+import process7 from "node:process";
+import { Buffer } from "node:buffer";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify as promisify5 } from "node:util";
+import childProcess from "node:child_process";
+import fs5, { constants as fsConstants2 } from "node:fs/promises";
+
+// ../../node_modules/wsl-utils/index.js
+import process3 from "node:process";
+import fs4, { constants as fsConstants } from "node:fs/promises";
+
+// ../../node_modules/is-wsl/index.js
+import process2 from "node:process";
+import os from "node:os";
+import fs3 from "node:fs";
+
+// ../../node_modules/is-inside-container/index.js
+import fs2 from "node:fs";
+
+// ../../node_modules/is-docker/index.js
+import fs from "node:fs";
+var isDockerCached;
+function hasDockerEnv() {
+  try {
+    fs.statSync("/.dockerenv");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasDockerCGroup() {
+  try {
+    return fs.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+  } catch {
+    return false;
+  }
+}
+function isDocker() {
+  if (isDockerCached === void 0) {
+    isDockerCached = hasDockerEnv() || hasDockerCGroup();
+  }
+  return isDockerCached;
+}
+
+// ../../node_modules/is-inside-container/index.js
+var cachedResult;
+var hasContainerEnv = () => {
+  try {
+    fs2.statSync("/run/.containerenv");
+    return true;
+  } catch {
+    return false;
+  }
+};
+function isInsideContainer() {
+  if (cachedResult === void 0) {
+    cachedResult = hasContainerEnv() || isDocker();
+  }
+  return cachedResult;
+}
+
+// ../../node_modules/is-wsl/index.js
+var isWsl = () => {
+  if (process2.platform !== "linux") {
+    return false;
+  }
+  if (os.release().toLowerCase().includes("microsoft")) {
+    if (isInsideContainer()) {
+      return false;
+    }
+    return true;
+  }
+  try {
+    return fs3.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft") ? !isInsideContainer() : false;
+  } catch {
+    return false;
+  }
+};
+var is_wsl_default = process2.env.__IS_WSL_TEST__ ? isWsl : isWsl();
+
+// ../../node_modules/wsl-utils/index.js
+var wslDrivesMountPoint = /* @__PURE__ */ (() => {
+  const defaultMountPoint = "/mnt/";
+  let mountPoint;
+  return async function() {
+    if (mountPoint) {
+      return mountPoint;
+    }
+    const configFilePath = "/etc/wsl.conf";
+    let isConfigFileExists = false;
+    try {
+      await fs4.access(configFilePath, fsConstants.F_OK);
+      isConfigFileExists = true;
+    } catch {
+    }
+    if (!isConfigFileExists) {
+      return defaultMountPoint;
+    }
+    const configContent = await fs4.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;
+  };
+})();
+var powerShellPathFromWsl = async () => {
+  const mountPoint = await wslDrivesMountPoint();
+  return `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe`;
+};
+var 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;
+}
+
+// ../../node_modules/default-browser/index.js
+import { promisify as promisify4 } from "node:util";
+import process6 from "node:process";
+import { execFile as execFile4 } from "node:child_process";
+
+// ../../node_modules/default-browser-id/index.js
+import { promisify } from "node:util";
+import process4 from "node:process";
+import { execFile } from "node:child_process";
+var execFileAsync = promisify(execFile);
+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);
+  return match?.groups.id ?? "com.apple.Safari";
+}
+
+// ../../node_modules/run-applescript/index.js
+import process5 from "node:process";
+import { promisify as promisify2 } from "node:util";
+import { execFile as execFile2, execFileSync } from "node:child_process";
+var execFileAsync2 = promisify2(execFile2);
+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();
+}
+
+// ../../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")`);
+}
+
+// ../../node_modules/default-browser/windows.js
+import { promisify as promisify3 } from "node:util";
+import { execFile as execFile3 } from "node:child_process";
+var execFileAsync3 = promisify3(execFile3);
+var windowsBrowserProgIds = {
+  AppXq0fevzme2pys62n3e0fbqa7peapykr8v: { name: "Edge", id: "com.microsoft.edge.old" },
+  MSEdgeDHTML: { name: "Edge", id: "com.microsoft.edge" },
+  // On macOS, it's "com.microsoft.edgemac"
+  MSEdgeHTM: { name: "Edge", id: "com.microsoft.edge" },
+  // Newer Edge/Win10 releases
+  "IE.HTTP": { name: "Internet Explorer", id: "com.microsoft.ie" },
+  FirefoxURL: { name: "Firefox", id: "org.mozilla.firefox" },
+  ChromeHTML: { name: "Chrome", id: "com.google.chrome" },
+  BraveHTML: { name: "Brave", id: "com.brave.Browser" },
+  BraveBHTML: { name: "Brave Beta", id: "com.brave.Browser.beta" },
+  BraveSSHTM: { name: "Brave Nightly", id: "com.brave.Browser.nightly" }
+};
+var UnknownBrowserError = class extends Error {
+};
+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;
+}
+
+// ../../node_modules/default-browser/index.js
+var execFileAsync4 = promisify4(execFile4);
+var titleize = (string) => string.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x) => x.toUpperCase());
+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");
+}
+
+// ../../node_modules/open/index.js
+var execFile5 = promisify5(childProcess.execFile);
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var localXdgOpenPath = path.join(__dirname, "xdg-open");
+var { platform, arch } = process7;
+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 = Buffer.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] } : {};
+}
+var pTryEach = async (array, mapper) => {
+  let latestError;
+  for (const item of array) {
+    try {
+      return await mapper(item);
+    } catch (error) {
+      latestError = error;
+    }
+  }
+  throw latestError;
+};
+var 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 = Buffer.from(encodedArguments.join(" "), "utf16le").toString("base64");
+  } else {
+    if (app) {
+      command = app;
+    } else {
+      const isBundled = !__dirname || __dirname === "/";
+      let exeLocalXdgOpen = false;
+      try {
+        await fs5.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((resolve, reject) => {
+      subprocess.once("error", reject);
+      subprocess.once("close", (exitCode) => {
+        if (!options.allowNonzeroExitCode && exitCode > 0) {
+          reject(new Error(`Exited with code ${exitCode}`));
+          return;
+        }
+        resolve(subprocess);
+      });
+    });
+  }
+  subprocess.unref();
+  return subprocess;
+};
+var open = (target, options) => {
+  if (typeof target !== "string") {
+    throw new TypeError("Expected a `target`");
+  }
+  return baseOpen({
+    ...options,
+    target
+  });
+};
+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 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");
+var open_default = open;
+
+// src/commands/auth.ts
+import { unlinkSync, existsSync as existsSync2 } from "node:fs";
+import { hostname } from "node:os";
+var MAX_POLL_ATTEMPTS = 450;
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function createSpinner() {
+  let frame = 0;
+  let timer = null;
+  let currentText = "";
+  return {
+    start(text) {
+      currentText = text;
+      frame = 0;
+      timer = setInterval(() => {
+        process.stderr.write(`\r${SPINNER_FRAMES[frame++ % SPINNER_FRAMES.length]} ${currentText}`);
+      }, 80);
+    },
+    update(text) {
+      currentText = text;
+    },
+    stop(finalText) {
+      if (timer) clearInterval(timer);
+      process.stderr.write("\r\x1B[K");
+      if (finalText) console.log(finalText);
+    }
+  };
+}
+function printNextSteps(scope) {
+  const lines = ["Getting started:"];
+  if (scope?.includes("manage")) {
+    lines.push("  adkit meta accounts list       List your connected ad accounts");
+    lines.push("  adkit meta campaigns list      List campaigns");
+    lines.push("  adkit meta campaigns create    Create a campaign");
+    lines.push("  adkit drafts list              View pending drafts");
+  } else lines.push("  adkit setup manage             Connect Meta Ads");
+  lines.push("  adkit --help                   See all commands");
+  lines.push("");
+  console.log(lines.join("\n"));
+}
+async function detectDefaultAccounts(baseUrl, apiKey) {
+  try {
+    const client = new AdkitClient({ apiKey, baseUrl });
+    const data = await client.get("/manage/status");
+    const config = readConfig();
+    if (!config?.selectedProject || !config.projects) return;
+    const project = config.projects[config.selectedProject];
+    if (!project) return;
+    let changed = false;
+    const metaAccounts = data.platforms?.meta?.accounts;
+    if (metaAccounts?.length === 1) {
+      project.defaultMetaAccount = metaAccounts[0].id;
+      changed = true;
+      console.log(`Default Meta account: ${metaAccounts[0].name} (${metaAccounts[0].id})`);
+    }
+    const googleAccounts = data.platforms?.google?.accounts;
+    if (googleAccounts?.length === 1) {
+      project.defaultGoogleAccount = googleAccounts[0].id;
+      changed = true;
+      console.log(`Default Google account: ${googleAccounts[0].name} (${googleAccounts[0].id})`);
+    }
+    if (changed) writeConfig({ projects: config.projects });
+  } catch {
+  }
+}
+async function login({ baseUrl, scope }) {
+  const spinner = createSpinner();
+  spinner.start("Connecting to AdKit...");
+  let createResponse;
+  try {
+    createResponse = await fetch(`${baseUrl}/auth/cli-session`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ src: "cli", hostname: hostname(), scope: scope && scope.length > 0 ? scope : void 0 })
+    });
+  } catch {
+    spinner.stop();
+    throw new Error("Network connection failed \u2014 check your internet connection");
+  }
+  if (!createResponse.ok) {
+    spinner.stop();
+    let msg = "Failed to create session";
+    try {
+      const errData = await createResponse.json();
+      if (errData.message) msg = errData.message;
+    } catch {
+    }
+    throw new Error(msg);
+  }
+  const createData = await createResponse.json();
+  const sessionId = createData.session.sessionId;
+  const rawUrl = createData.session.url;
+  const origin = new URL(baseUrl).origin;
+  const sessionUrl = rawUrl.startsWith("http") ? rawUrl : `${origin}${rawUrl}`;
+  await open_default(sessionUrl);
+  spinner.stop(`\u2713 Browser opened \u2014 complete setup at ${sessionUrl}`);
+  spinner.start("Waiting for setup to complete...");
+  let projects;
+  let legacyApiKey;
+  for (let attempt = 0; attempt < MAX_POLL_ATTEMPTS; attempt++) {
+    let pollResponse;
+    try {
+      pollResponse = await fetch(`${baseUrl}/auth/cli-session/${sessionId}`, {
+        method: "GET"
+      });
+    } catch {
+      spinner.stop();
+      throw new Error("Network connection failed during polling");
+    }
+    if (!pollResponse.ok) {
+      spinner.stop();
+      if (pollResponse.status === 404) throw new Error("Session not found or expired");
+      throw new Error(`Poll failed with status ${pollResponse.status}`);
+    }
+    let pollData;
+    try {
+      pollData = await pollResponse.json();
+    } catch {
+      continue;
+    }
+    const status2 = pollData.session?.status;
+    if (status2 === "complete") {
+      projects = pollData.session.projects;
+      legacyApiKey = pollData.session.apiKey;
+      break;
+    }
+    if (status2 === "expired") {
+      spinner.stop();
+      throw new Error("Session expired \u2014 timed out waiting for authentication");
+    }
+    await new Promise((r) => setTimeout(r, 2e3));
+  }
+  spinner.stop();
+  if (!projects && !legacyApiKey) throw new Error("Login timed out \u2014 max poll attempts exceeded");
+  if (projects && projects.length > 0) {
+    const projectsMap = {};
+    for (const p of projects) projectsMap[p.id] = { name: p.name, apiKey: p.apiKey };
+    writeConfig({
+      projects: projectsMap,
+      selectedProject: projects[0].id,
+      apiKey: projects[0].apiKey
+    });
+    console.log("\n\u2705 AdKit is configured!\n");
+    const names = projects.map((p) => `  \u2022 ${p.name}`).join("\n");
+    console.log(`Projects:
+${names}
+`);
+    if (scope?.includes("manage")) await detectDefaultAccounts(baseUrl, projects[0].apiKey);
+    printNextSteps(scope);
+  } else {
+    writeConfig({ apiKey: legacyApiKey });
+    console.log("\n\u2705 AdKit is configured!\n");
+    printNextSteps(scope);
+  }
+}
+function logout() {
+  if (existsSync2(CONFIG_PATH)) unlinkSync(CONFIG_PATH);
+  console.log("Logged out \u2014 API key removed.");
+}
+
+// src/commands/projects.ts
+function listProjects(config) {
+  if (!config.projects) return [];
+  return Object.entries(config.projects).map(([id, value]) => {
+    const entry = { id, name: value.name, apiKey: value.apiKey };
+    if (config.selectedProject === id) {
+      entry.current = true;
+    }
+    return entry;
+  });
+}
+function useProject(projectId) {
+  const config = readConfig() ?? {};
+  if (!config.projects?.[projectId]) {
+    throw new Error(`Project not found: ${projectId}`);
+  }
+  writeConfig({ selectedProject: projectId });
+}
+function currentProject(config) {
+  if (!config.selectedProject) return null;
+  const entry = config.projects?.[config.selectedProject];
+  if (!entry) return null;
+  return { id: config.selectedProject, name: entry.name, apiKey: entry.apiKey };
+}
+
+// src/cli-utils.ts
+function parseArgs(argv, options) {
+  const args = [];
+  const flags = {};
+  const multiSet = new Set(options?.multi);
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg.startsWith("--")) {
+      args.push(arg);
+      continue;
+    }
+    const eqIdx = arg.indexOf("=");
+    let key;
+    let value;
+    if (eqIdx !== -1) {
+      key = arg.slice(2, eqIdx);
+      value = arg.slice(eqIdx + 1);
+    } else {
+      key = arg.slice(2);
+      const next = argv[i + 1];
+      if (next && !next.startsWith("--")) {
+        value = next;
+        i++;
+      } else value = true;
+    }
+    if (multiSet.has(key) && typeof value === "string") {
+      const existing = flags[key];
+      if (Array.isArray(existing)) existing.push(value);
+      else flags[key] = [value];
+    } else flags[key] = value;
+  }
+  return { args, flags };
+}
+var GLOBAL_FLAGS = ["account", "json", "fields", "publish", "data", "platform-overrides", "force", "project"];
+function validateFlags(flags, allowed, command) {
+  const allAllowed = /* @__PURE__ */ new Set([...GLOBAL_FLAGS, ...allowed]);
+  const unknown = Object.keys(flags).filter((k) => !allAllowed.has(k));
+  if (unknown.length) throw new CliError("UNKNOWN_FLAG", `Unknown flag${unknown.length > 1 ? "s" : ""}: ${unknown.map((f) => `--${f}`).join(", ")}`, `Run: adkit ${command} --help`);
+}
+function unwrapList(data) {
+  if (Array.isArray(data)) return data;
+  if (data && typeof data === "object") {
+    const values = Object.values(data);
+    const arr = values.find((v) => Array.isArray(v));
+    if (arr) return arr;
+  }
+  return [];
+}
+
+// ../shared/dist/manage/meta/media-utils.js
+var IMAGE_HASH_RE = /^[0-9a-f]{32}$/i;
+var VIDEO_ID_RE = /^\d+$/;
+
+// src/commands/meta.ts
+function parseJsonObject(raw, label) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new CliError("INVALID_VALUE", `Invalid JSON in \`--${label}\``, `Check JSON syntax in --${label}`);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new CliError("INVALID_VALUE", `Expected a JSON object in \`--${label}\``, `Check JSON syntax in --${label}`);
+  return parsed;
+}
+function dateStamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function generateCampaignName() {
+  return `campaign ${dateStamp()}`;
+}
+function generateAdSetName() {
+  return `adset ${dateStamp()}`;
+}
+function generateAdName() {
+  return `ad ${dateStamp()}`;
+}
+function generateCreativeName() {
+  return `creative ${dateStamp()}`;
+}
+function requireArg(args, index, label, hint) {
+  const val = args[index];
+  if (!val) throw new CliError("MISSING_ARGUMENT", `Missing required argument: \`<${label}>\``, hint);
+  return val;
+}
+function requireFlag(flags, key, hint) {
+  const val = flags[key];
+  if (typeof val !== "string") throw new CliError("MISSING_FLAG", `Missing required flag: \`--${key}\``, hint);
+  return val;
+}
+function parseDataFlag(flags, hint) {
+  const raw = requireFlag(flags, "data", hint);
+  try {
+    return JSON.parse(raw);
+  } catch {
+    const truncated = raw.length > 80 ? raw.slice(0, 80) + "..." : raw;
+    throw new CliError("INVALID_VALUE", `Invalid JSON in \`--data\` flag: ${truncated}`, "Check JSON syntax in --data");
+  }
+}
+function mergeAccountId(body, flags) {
+  if (typeof body !== "object" || body === null || Array.isArray(body)) return body;
+  const obj = body;
+  if (!obj.accountId) {
+    if (typeof flags.account === "string") obj.accountId = flags.account;
+    else {
+      const defaultAccount = getDefaultAccount("meta");
+      if (defaultAccount) obj.accountId = defaultAccount;
+    }
+  }
+  return obj;
+}
+function flagStr(flags, key) {
+  const val = flags[key];
+  if (typeof val === "string") return val;
+  if (Array.isArray(val)) return val[0];
+  return void 0;
+}
+function flagArr(flags, key) {
+  const val = flags[key];
+  if (Array.isArray(val)) return val;
+  if (typeof val === "string") return [val];
+  return [];
+}
+function queryString(params) {
+  const entries = Object.entries(params).filter((e) => e[1] !== void 0);
+  if (entries.length === 0) return "";
+  return "?" + entries.map(([k, v]) => `${k}=${encodeURIComponent(v)}`).join("&");
+}
+function isMediaUploadResult(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const obj = value;
+  return obj.type === "image" && typeof obj.imageHash === "string" || obj.type === "video" && typeof obj.videoId === "string";
+}
+async function listAccounts(client, _args, _flags) {
+  return client.get("/manage/meta/accounts");
+}
+async function connectAccount(client, args, _flags) {
+  const id = requireArg(args, 0, "account-id", "Run: adkit manage meta accounts connect <account-id>");
+  return client.post("/manage/meta/accounts/connect", { id });
+}
+async function disconnectAccount(client, args, _flags) {
+  const id = requireArg(args, 0, "account-id", "Run: adkit manage meta accounts disconnect <account-id>");
+  return client.delete(`/manage/meta/accounts/${id}`);
+}
+async function listPages(client, args, _flags) {
+  const id = requireArg(args, 0, "account-id", "Run: adkit manage meta accounts <account-id> pages");
+  return client.get(`/manage/meta/accounts/${id}/pages`);
+}
+async function listPixels(client, args, _flags) {
+  const id = requireArg(args, 0, "account-id", "Run: adkit manage meta accounts <account-id> pixels");
+  return client.get(`/manage/meta/accounts/${id}/pixels`);
+}
+function buildCampaignPayload(flags) {
+  const payload = {};
+  if (typeof flags.name === "string") payload.name = flags.name;
+  if (typeof flags.objective === "string") payload.objective = flags.objective;
+  if (typeof flags.status === "string") payload.status = flags.status;
+  if (typeof flags["bid-strategy"] === "string") payload.bidStrategy = flags["bid-strategy"];
+  if (flags.abo === true) payload.advantageCampaignBudget = false;
+  else payload.advantageCampaignBudget = true;
+  if (typeof flags["budget-daily"] === "string") payload.budget = { daily: parseFloat(flags["budget-daily"]) };
+  if (typeof flags["budget-total"] === "string") payload.budget = { ...payload.budget, lifetime: parseFloat(flags["budget-total"]) };
+  if (typeof flags["platform-overrides"] === "string") payload.platformOverrides = parseJsonObject(flags["platform-overrides"], "platform-overrides");
+  return payload;
+}
+async function listCampaigns(client, _args, flags) {
+  validateFlags(flags, [], "manage meta campaigns list");
+  const accountId = typeof flags.account === "string" ? flags.account : void 0;
+  const qs = queryString({ accountId });
+  return client.get(`/manage/meta/campaigns${qs}`);
+}
+var CAMPAIGN_FLAGS = ["name", "objective", "status", "budget-daily", "budget-total", "abo", "bid-strategy"];
+var ADSET_FLAGS = ["campaign", "name", "status", "optimization", "budget-daily", "budget-total", "countries", "genders", "targeting", "pixel", "event-type", "interest"];
+var AD_FLAGS = ["creative", "adset", "name", "status", "media", "primary-text", "headline", "description", "cta", "url", "page"];
+var CREATIVE_FLAGS = ["page-id", "headline", "primary-text", "link-description", "link-url", "cta", "name", "image-hash", "image-url", "video-id", "force"];
+var MEDIA_FLAGS = ["file", "url", "account"];
+async function createCampaign(client, _args, flags) {
+  if (typeof flags.data === "string") {
+    const body2 = parseDataFlag(flags, "Check JSON syntax in --data");
+    mergeAccountId(body2, flags);
+    const publish2 = flags.publish === true ? "?publish=true" : "";
+    return client.post(`/manage/meta/campaigns${publish2}`, body2);
+  }
+  validateFlags(flags, CAMPAIGN_FLAGS, "manage meta campaigns create");
+  const payload = buildCampaignPayload(flags);
+  if (!payload.name) payload.name = generateCampaignName();
+  const body = { campaigns: [payload] };
+  mergeAccountId(body, flags);
+  const publish = flags.publish === true ? "?publish=true" : "";
+  return client.post(`/manage/meta/campaigns${publish}`, body);
+}
+async function updateCampaign(client, args, flags) {
+  const id = requireArg(args, 0, "campaign-id", `Run: adkit manage meta campaigns update <campaign-id> --status paused`);
+  if (typeof flags.data === "string") {
+    const body = parseDataFlag(flags, "Check JSON syntax in --data");
+    mergeAccountId(body, flags);
+    return client.patch(`/manage/meta/campaigns/${id}`, body);
+  }
+  validateFlags(flags, CAMPAIGN_FLAGS, "manage meta campaigns update");
+  const payload = buildCampaignPayload(flags);
+  mergeAccountId(payload, flags);
+  return client.patch(`/manage/meta/campaigns/${id}`, payload);
+}
+async function deleteCampaign(client, args, _flags) {
+  const id = requireArg(args, 0, "campaign-id", "Run: adkit manage meta campaigns delete <campaign-id>");
+  return client.delete(`/manage/meta/campaigns/${id}`);
+}
+function buildAdSetPayload(flags) {
+  const payload = {};
+  if (typeof flags.campaign === "string") payload.campaignId = flags.campaign;
+  if (typeof flags.name === "string") payload.name = flags.name;
+  if (typeof flags.status === "string") payload.status = flags.status;
+  if (typeof flags.optimization === "string") payload.optimization = flags.optimization;
+  if (typeof flags["budget-daily"] === "string") payload.budget = { daily: parseFloat(flags["budget-daily"]) };
+  if (typeof flags["budget-total"] === "string") payload.budget = { ...payload.budget, lifetime: parseFloat(flags["budget-total"]) };
+  const targeting = {};
+  if (typeof flags.countries === "string") targeting.countries = flags.countries.split(",");
+  if (Array.isArray(flags.interest)) targeting.interests = flags.interest;
+  else if (typeof flags.interest === "string") targeting.interests = [flags.interest];
+  if (typeof flags.targeting === "string") Object.assign(targeting, parseJsonObject(flags.targeting, "targeting"));
+  if (Object.keys(targeting).length) payload.targeting = targeting;
+  if (typeof flags.pixel === "string") payload.pixelId = flags.pixel;
+  if (typeof flags["event-type"] === "string") payload.eventType = flags["event-type"];
+  if (typeof flags["platform-overrides"] === "string") payload.platformOverrides = parseJsonObject(flags["platform-overrides"], "platform-overrides");
+  return payload;
+}
+async function listAdSets(client, _args, flags) {
+  validateFlags(flags, ["campaign"], "manage meta adsets list");
+  const accountId = typeof flags.account === "string" ? flags.account : void 0;
+  const campaignId = typeof flags.campaign === "string" ? flags.campaign : void 0;
+  const qs = queryString({ accountId, campaignId });
+  return client.get(`/manage/meta/adsets${qs}`);
+}
+async function createAdSet(client, _args, flags) {
+  if (typeof flags.data === "string") {
+    const body2 = parseDataFlag(flags, "Check JSON syntax in --data");
+    mergeAccountId(body2, flags);
+    const publish2 = flags.publish === true ? "?publish=true" : "";
+    return client.post(`/manage/meta/adsets${publish2}`, body2);
+  }
+  validateFlags(flags, ADSET_FLAGS, "manage meta adsets create");
+  const payload = buildAdSetPayload(flags);
+  if (!payload.campaignId) throw new CliError("MISSING_FLAG", "Missing required flag: `--campaign`", 'Run: adkit manage meta adsets create --campaign cmp_abc --name "US 25-44" --budget-daily 20 --optimization link_clicks');
+  if (!payload.name) payload.name = generateAdSetName();
+  const body = { adsets: [payload] };
+  mergeAccountId(body, flags);
+  const publish = flags.publish === true ? "?publish=true" : "";
+  return client.post(`/manage/meta/adsets${publish}`, body);
+}
+async function updateAdSet(client, args, flags) {
+  const id = requireArg(args, 0, "adset-id", `Run: adkit manage meta adsets update <adset-id> --budget-daily 50`);
+  if (typeof flags.data === "string") {
+    const body = parseDataFlag(flags, "Check JSON syntax in --data");
+    mergeAccountId(body, flags);
+    return client.patch(`/manage/meta/adsets/${id}`, body);
+  }
+  validateFlags(flags, ADSET_FLAGS, "manage meta adsets update");
+  const payload = buildAdSetPayload(flags);
+  mergeAccountId(payload, flags);
+  return client.patch(`/manage/meta/adsets/${id}`, payload);
+}
+async function deleteAdSet(client, args, _flags) {
+  const id = requireArg(args, 0, "adset-id", "Run: adkit manage meta adsets delete <adset-id>");
+  return client.delete(`/manage/meta/adsets/${id}`);
+}
+async function listAds(client, _args, flags) {
+  validateFlags(flags, ["adset"], "manage meta ads list");
+  const accountId = typeof flags.account === "string" ? flags.account : void 0;
+  const adsetId = typeof flags.adset === "string" ? flags.adset : void 0;
+  const qs = queryString({ accountId, adsetId });
+  return client.get(`/manage/meta/ads${qs}`);
+}
+async function createAd(client, _args, flags) {
+  if (typeof flags.data === "string") {
+    const body2 = parseDataFlag(flags, "Check JSON syntax in --data");
+    mergeAccountId(body2, flags);
+    const publish2 = flags.publish === true ? "?publish=true" : "";
+    return client.post(`/manage/meta/ads${publish2}`, body2);
+  }
+  validateFlags(flags, AD_FLAGS, "manage meta ads create");
+  const creativeId = typeof flags.creative === "string" ? flags.creative : void 0;
+  const mediaFlags = ["media", "primary-text", "headline", "description", "cta"];
+  const hasMediaFlags = mediaFlags.some((f) => flags[f] !== void 0);
+  if (creativeId && hasMediaFlags) throw new CliError("INVALID_VALUE", "`--creative` cannot be combined with --media, --primary-text, --headline, --description, or --cta", "Use --creative to reference an existing creative, OR use --media/--primary-text/etc. to create a new one");
+  if (creativeId) {
+    const adsetId2 = requireFlag(flags, "adset", "Run: adkit manage meta ads create --creative cr_abc --adset as_xyz --publish");
+    const ad2 = {
+      adsetId: adsetId2,
+      name: typeof flags.name === "string" ? flags.name : generateAdName(),
+      creativeId
+    };
+    if (typeof flags.status === "string") ad2.status = flags.status;
+    const body2 = { ads: [ad2] };
+    mergeAccountId(body2, flags);
+    const publish2 = flags.publish === true ? "?publish=true" : "";
+    return client.post(`/manage/meta/ads${publish2}`, body2);
+  }
+  const mediaInputs = flagArr(flags, "media");
+  const primaryTexts = flagArr(flags, "primary-text");
+  const headlines = flagArr(flags, "headline");
+  const descriptions = flagArr(flags, "description");
+  if (mediaInputs.length === 0) throw new CliError("MISSING_FLAG", "Missing required flag: `--media` (or use `--creative` to reference an existing creative)", 'Run: adkit manage meta ads create --media ./hero.mp4 --primary-text "Hello" --adset as_xyz --publish');
+  const adsetId = typeof flags.adset === "string" ? flags.adset : void 0;
+  if (!adsetId) throw new CliError("MISSING_FLAG", "Missing required flag: `--adset`", "Run: adkit manage meta ads create --media ./hero.mp4 --adset as_789 --publish");
+  function isMediaId(input) {
+    return IMAGE_HASH_RE.test(input) || VIDEO_ID_RE.test(input);
+  }
+  const mediaIds = [];
+  for (const input of mediaInputs) {
+    if (isMediaId(input)) {
+      mediaIds.push(input);
+    } else {
+      let uploadBody;
+      if (input.startsWith("http://") || input.startsWith("https://")) uploadBody = { imageUrl: input };
+      else {
+        const fs6 = await import("node:fs");
+        const path2 = await import("node:path");
+        const VIDEO_EXTENSIONS = /* @__PURE__ */ new Set([".mp4", ".mov", ".avi", ".webm", ".mkv"]);
+        const resolved = path2.resolve(input);
+        const ext = path2.extname(resolved).toLowerCase();
+        const filename = path2.basename(resolved);
+        const base64 = fs6.readFileSync(resolved).toString("base64");
+        if (VIDEO_EXTENSIONS.has(ext)) uploadBody = { videoBase64: base64, filename };
+        else uploadBody = { imageBase64: base64, filename };
+      }
+      const result = await client.post("/manage/meta/media", uploadBody);
+      if (!isMediaUploadResult(result)) throw new CliError("SERVER_ERROR", "Media upload did not return an image hash or video ID");
+      const id = result.type === "image" ? result.imageHash : result.videoId;
+      mediaIds.push(id);
+    }
+  }
+  const ad = { adsetId, mediaIds };
+  if (primaryTexts.length) ad.primaryTexts = primaryTexts;
+  if (headlines.length) ad.headlines = headlines;
+  if (descriptions.length) ad.descriptions = descriptions;
+  if (typeof flags.cta === "string") ad.cta = flags.cta;
+  if (typeof flags.name === "string") ad.name = flags.name;
+  if (typeof flags.url === "string") ad.url = flags.url;
+  if (typeof flags.page === "string") ad.pageId = flags.page;
+  const body = { ads: [ad] };
+  mergeAccountId(body, flags);
+  const publish = flags.publish === true ? "?publish=true" : "";
+  return client.post(`/manage/meta/ads${publish}`, body);
+}
+async function updateAd(client, args, flags) {
+  const id = requireArg(args, 0, "ad-id", `Run: adkit manage meta ads update <ad-id> --data '{"status":"paused"}'`);
+  const body = parseDataFlag(flags, "Check JSON syntax in --data");
+  mergeAccountId(body, flags);
+  return client.patch(`/manage/meta/ads/${id}`, body);
+}
+async function deleteAd(client, args, _flags) {
+  const id = requireArg(args, 0, "ad-id", "Run: adkit manage meta ads delete <ad-id>");
+  return client.delete(`/manage/meta/ads/${id}`);
+}
+function buildCreativePayload(flags) {
+  const payload = {};
+  const pageId = flagStr(flags, "page-id");
+  const linkUrl = flagStr(flags, "link-url");
+  const cta = flagStr(flags, "cta");
+  const name = flagStr(flags, "name");
+  const imageHash = flagStr(flags, "image-hash");
+  const imageUrl = flagStr(flags, "image-url");
+  const videoId = flagStr(flags, "video-id");
+  if (pageId) payload.pageId = pageId;
+  if (linkUrl) payload.linkUrl = linkUrl;
+  if (cta) payload.cta = cta;
+  if (name) payload.name = name;
+  if (imageHash) payload.imageHash = imageHash;
+  if (imageUrl) payload.imageUrl = imageUrl;
+  if (videoId) payload.videoId = videoId;
+  const headlines = flagArr(flags, "headline");
+  if (headlines.length) payload.headlines = headlines;
+  const primaryTexts = flagArr(flags, "primary-text");
+  if (primaryTexts.length) payload.primaryTexts = primaryTexts;
+  const linkDescriptions = flagArr(flags, "link-description");
+  if (linkDescriptions.length) payload.linkDescriptions = linkDescriptions;
+  if (typeof flags["platform-overrides"] === "string") payload.platformOverrides = parseJsonObject(flags["platform-overrides"], "platform-overrides");
+  return payload;
+}
+async function createCreative(client, _args, flags) {
+  if (typeof flags.data === "string") {
+    const body = parseDataFlag(flags, "Check JSON syntax in --data");
+    mergeAccountId(body, flags);
+    const publish2 = flags.publish === true ? "?publish=true" : "";
+    return client.post(`/manage/meta/creatives${publish2}`, body);
+  }
+  validateFlags(flags, CREATIVE_FLAGS, "manage meta creatives create");
+  const payload = buildCreativePayload(flags);
+  if (!payload.pageId) throw new CliError("MISSING_FLAG", "Missing required flag: `--page-id`", 'Run: adkit manage meta creatives create --page-id pg_123 --headline "Get Started" --primary-text "Try it free" --link-url https://example.com');
+  if (!payload.headlines?.length) throw new CliError("MISSING_FLAG", "Missing required flag: `--headline`", 'Run: adkit manage meta creatives create --page-id pg_123 --headline "Get Started" --primary-text "Try it free" --link-url https://example.com');
+  if (!payload.primaryTexts?.length) throw new CliError("MISSING_FLAG", "Missing required flag: `--primary-text`", 'Run: adkit manage meta creatives create --page-id pg_123 --headline "Get Started" --primary-text "Try it free" --link-url https://example.com');
+  if (!payload.linkUrl) throw new CliError("MISSING_FLAG", "Missing required flag: `--link-url`", 'Run: adkit manage meta creatives create --page-id pg_123 --headline "Get Started" --primary-text "Try it free" --link-url https://example.com');
+  const isMultiAsset = (payload.headlines?.length ?? 0) > 1 || (payload.primaryTexts?.length ?? 0) > 1 || (payload.linkDescriptions?.length ?? 0) > 1;
+  if (isMultiAsset && flags.force !== true) throw new CliError("INVALID_VALUE", "Standalone creatives with multiple assets use Dynamic Creative format, which Meta doesn't support for sales/app_promotion. Use `ads create` instead (auto-detects the right format). Add --force to proceed anyway.");
+  if (!payload.name) payload.name = generateCreativeName();
+  mergeAccountId(payload, flags);
+  const publish = flags.publish === true ? "?publish=true" : "";
+  return client.post(`/manage/meta/creatives${publish}`, payload);
+}
+async function updateCreative(client, args, flags) {
+  const id = requireArg(args, 0, "creative-id", `Run: adkit manage meta creatives update <creative-id> --primary-text "Start free trial"`);
+  if (typeof flags.data === "string") {
+    const body = parseDataFlag(flags, "Check JSON syntax in --data");
+    mergeAccountId(body, flags);
+    return client.patch(`/manage/meta/creatives/${id}`, body);
+  }
+  validateFlags(flags, CREATIVE_FLAGS, "manage meta creatives update");
+  const payload = buildCreativePayload(flags);
+  mergeAccountId(payload, flags);
+  return client.patch(`/manage/meta/creatives/${id}`, payload);
+}
+async function deleteCreative(client, args, _flags) {
+  const id = requireArg(args, 0, "creative-id", "Run: adkit manage meta creatives delete <creative-id>");
+  return client.delete(`/manage/meta/creatives/${id}`);
+}
+async function searchInterests(client, args, flags) {
+  if (!args.length) throw new CliError("MISSING_ARGUMENT", "Missing query", "Run: adkit manage meta interests search <query> [query2] [query3]");
+  const accountId = typeof flags.account === "string" ? flags.account : void 0;
+  const allResults = [];
+  for (const query of args) {
+    const qs = queryString({ accountId, q: query });
+    const res = await client.get(`/manage/meta/interests/search${qs}`);
+    const obj = res && typeof res === "object" && "results" in res ? res : null;
+    const arr = obj && Array.isArray(obj.results) ? obj.results : [];
+    for (const item of arr) allResults.push(item);
+  }
+  return { results: allResults };
+}
+async function uploadMedia(client, _args, flags) {
+  validateFlags(flags, MEDIA_FLAGS, "manage meta media upload");
+  const filePath = typeof flags.file === "string" ? flags.file : void 0;
+  const url = typeof flags.url === "string" ? flags.url : void 0;
+  if (!filePath && !url) throw new CliError("MISSING_FLAG", "Missing required flag: `--file` or `--url`", "Run: adkit manage meta media upload --file ./video.mp4");
+  if (filePath) {
+    const fs6 = await import("node:fs");
+    const path2 = await import("node:path");
+    const resolved = path2.resolve(filePath);
+    const ext = path2.extname(resolved).toLowerCase();
+    const isVideo = [".mp4", ".mov", ".avi", ".webm", ".mkv"].includes(ext);
+    const base64 = fs6.readFileSync(resolved).toString("base64");
+    const filename = path2.basename(resolved);
+    if (isVideo) return client.post("/manage/meta/media", { videoBase64: base64, filename });
+    else return client.post("/manage/meta/media", { imageBase64: base64, filename });
+  }
+  if (!url) throw new CliError("MISSING_FLAG", "Missing required flag: `--file` or `--url`");
+  const VIDEO_EXTENSIONS = /* @__PURE__ */ new Set([".mp4", ".mov", ".avi", ".mkv", ".webm"]);
+  const urlExt = new URL(url).pathname.match(/\.[^.]+$/)?.[0]?.toLowerCase() ?? "";
+  if (VIDEO_EXTENSIONS.has(urlExt)) return client.post("/manage/meta/media", { videoUrl: url });
+  return client.post("/manage/meta/media", { imageUrl: url });
+}
+async function listMedia(client, _args, flags) {
+  const accountId = typeof flags.account === "string" ? flags.account : void 0;
+  const qs = queryString({ accountId });
+  return client.get(`/manage/meta/media${qs}`);
+}
+async function deleteMedia(client, args, flags) {
+  const id = requireArg(args, 0, "media-id", "Run: adkit manage meta media delete <media-id>");
+  const accountId = typeof flags.account === "string" ? flags.account : void 0;
+  const qs = queryString({ accountId });
+  return client.delete(`/manage/meta/media/${id}${qs}`);
+}
+
+// src/commands/status.ts
+async function status(client, json) {
+  const data = await client.get("/manage/status");
+  if (json) {
+    console.log(JSON.stringify(data));
+    return;
+  }
+  const { project, platforms } = data;
+  const lines = [];
+  lines.push(`Project: ${project.name || "unnamed"} (${project.id})`);
+  lines.push("");
+  if (platforms.meta.connected) {
+    lines.push("Meta: connected");
+    for (const a of platforms.meta.accounts) {
+      lines.push(`  ${a.id} \u2014 ${a.name} (${a.currency}, ${a.status})`);
+      if (a.defaults.pageId) lines.push(`    Page: ${a.defaults.pageId}`);
+      if (a.defaults.pixelId) lines.push(`    Pixel: ${a.defaults.pixelId}`);
+    }
+  } else {
+    lines.push("Meta: not connected");
+  }
+  if (platforms.google.connected) {
+    lines.push("Google: connected");
+    for (const a of platforms.google.accounts) {
+      lines.push(`  ${a.id} \u2014 ${a.name} (${a.currency})`);
+    }
+  } else {
+    lines.push("Google: not connected");
+  }
+  console.log(lines.join("\n"));
+}
+
+// src/commands/drafts.ts
+function requireArg2(args, index, label, hint) {
+  const val = args[index];
+  if (!val) {
+    throw new CliError("MISSING_ARGUMENT", `Missing required argument: \`<${label}>\``, hint);
+  }
+  return val;
+}
+function queryString2(params) {
+  const entries = Object.entries(params).filter((e) => e[1] !== void 0);
+  if (entries.length === 0) return "";
+  return "?" + entries.map(([k, v]) => `${k}=${encodeURIComponent(v)}`).join("&");
+}
+var DRAFT_LIST_FLAGS = ["platform", "limit", "offset"];
+async function listDrafts(client, _args, flags) {
+  validateFlags(flags, DRAFT_LIST_FLAGS, "manage drafts list");
+  const platform2 = typeof flags.platform === "string" ? flags.platform : void 0;
+  const limit = typeof flags.limit === "string" ? flags.limit : void 0;
+  const offset = typeof flags.offset === "string" ? flags.offset : void 0;
+  const qs = queryString2({ platform: platform2, limit, offset });
+  return client.get(`/manage/drafts${qs}`);
+}
+async function getDraft(client, args, _flags) {
+  const id = requireArg2(args, 0, "draft-id", "Run: adkit drafts get <draft-id>");
+  return client.get(`/manage/drafts/${id}`);
+}
+async function publishDraft(client, args, _flags) {
+  const id = requireArg2(args, 0, "draft-id", "Run: adkit drafts publish <draft-id>");
+  return client.post(`/manage/drafts/${id}/publish`);
+}
+async function deleteDraft(client, args, _flags) {
+  const id = requireArg2(args, 0, "draft-id", "Run: adkit drafts delete <draft-id>");
+  return client.delete(`/manage/drafts/${id}`);
+}
+
+// src/cli.ts
+var DEFAULT_BASE_URL = "https://app.adkit.so/api/v1";
+var USAGE = `
 Usage: adkit <command> [options]
 
 Commands:
@@ -31,23 +1422,16 @@ Global flags:
 
 Run \`adkit <command> --help\` for details.
 `.trim();
-// ---------------------------------------------------------------------------
-// Shared flag descriptions (DRY building blocks for help text)
-// ---------------------------------------------------------------------------
-const FLAG = {
-    account: '  --account <id>      Ad account ID (auto-resolved if only one)',
-    publish: '  --publish           Publish immediately (default: draft)',
-    overrides: '  --platform-overrides <json>  Raw Meta API fields merged onto payload',
-    data: '  --data <json>       Full JSON body — bypasses named flags',
-    status: '  --status <s>        active, paused, archived',
-    budgetDaily: '  --budget-daily <n>  Daily budget in account currency',
-    cta: '  --cta <type>        sign_up, learn_more, shop_now, download, get_offer, contact_us, subscribe, get_quote, book_now, apply_now',
+var FLAG = {
+  account: "  --account <id>      Ad account ID (auto-resolved if only one)",
+  publish: "  --publish           Publish immediately (default: draft)",
+  overrides: "  --platform-overrides <json>  Raw Meta API fields merged onto payload",
+  data: "  --data <json>       Full JSON body \u2014 bypasses named flags",
+  status: "  --status <s>        active, paused, archived",
+  budgetDaily: "  --budget-daily <n>  Daily budget in account currency",
+  cta: "  --cta <type>        sign_up, learn_more, shop_now, download, get_offer, contact_us, subscribe, get_quote, book_now, apply_now"
 };
-// ---------------------------------------------------------------------------
-// Entity-specific help text
-// ---------------------------------------------------------------------------
-// --- Campaigns ---
-const CAMPAIGN_HELP = `adkit manage meta campaigns — Meta ad campaigns
+var CAMPAIGN_HELP = `adkit manage meta campaigns \u2014 Meta ad campaigns
 
   list                List campaigns
   create              Create a campaign
@@ -66,7 +1450,7 @@ Examples:
   adkit manage meta campaigns delete cmp_abc
 
 Run --help full for all fields and advanced options.`;
-const CAMPAIGN_HELP_FULL = `adkit manage meta campaigns — Meta ad campaigns
+var CAMPAIGN_HELP_FULL = `adkit manage meta campaigns \u2014 Meta ad campaigns
 
   list                List campaigns
   create              Create a campaign
@@ -101,8 +1485,7 @@ Examples:
     "budget":{"lifetime":500},"specialAdCategories":["housing"],
     "startDate":"2026-04-01T00:00:00+0000","endDate":"2026-04-30T23:59:59+0000"
   }' --publish`;
-// --- Ad Sets ---
-const ADSET_HELP = `adkit manage meta adsets — Meta ad sets
+var ADSET_HELP = `adkit manage meta adsets \u2014 Meta ad sets
 
   list                List ad sets
   create              Create an ad set
@@ -121,8 +1504,8 @@ ${FLAG.budgetDaily}
   --interest <id>     Interest ID (repeatable). Find IDs: adkit manage meta interests search <query>
 
 Rules:
-  - objective=sales → event-type: purchase, add_to_cart, complete_registration, subscribe, start_trial, content_view
-  - objective=leads → event-type: lead, contact, complete_registration, subscribe, other
+  - objective=sales \u2192 event-type: purchase, add_to_cart, complete_registration, subscribe, start_trial, content_view
+  - objective=leads \u2192 event-type: lead, contact, complete_registration, subscribe, other
 
 Examples:
   adkit manage meta adsets create --campaign cmp_abc --name "US Broad" \\
@@ -134,7 +1517,7 @@ Examples:
   adkit manage meta adsets delete as_xyz
 
 Run --help full for all fields and advanced options.`;
-const ADSET_HELP_FULL = `adkit manage meta adsets — Meta ad sets
+var ADSET_HELP_FULL = `adkit manage meta adsets \u2014 Meta ad sets
 
   list                List ad sets
   create              Create an ad set
@@ -153,8 +1536,8 @@ ${FLAG.budgetDaily}
   --interest <id>     Interest ID (repeatable). Find IDs: adkit manage meta interests search <query>
 
 Rules:
-  - objective=sales → event-type: purchase, add_to_cart, complete_registration, subscribe, start_trial, content_view
-  - objective=leads → event-type: lead, contact, complete_registration, subscribe, other
+  - objective=sales \u2192 event-type: purchase, add_to_cart, complete_registration, subscribe, start_trial, content_view
+  - objective=leads \u2192 event-type: lead, contact, complete_registration, subscribe, other
 
 Advanced flags:
   --targeting <json>  Complex targeting JSON, merged with simple flags (JSON keys take precedence)
@@ -199,15 +1582,14 @@ Examples:
   }' --publish
   adkit manage meta adsets update as_xyz --budget-daily 50
   adkit manage meta adsets delete as_xyz`;
-// --- Ads ---
-const ADS_HELP = `adkit manage meta ads — Meta ads
+var ADS_HELP = `adkit manage meta ads \u2014 Meta ads
 
   list                List ads
   create              Create an ad
   update <id>         Update an ad
   delete <id>         Delete an ad
 
-Flags (create — new creative from media):
+Flags (create \u2014 new creative from media):
   --adset <id>        Ad set ID (required)
   --media <path|url>  Media file or URL (repeatable). Handles upload + processing automatically
   --primary-text <t>  Ad body text (repeatable)
@@ -218,7 +1600,7 @@ ${FLAG.cta}
   --url <url>         Landing page URL
   --page <id>         Facebook Page ID (auto-resolved from account defaults)
 
-Flags (create — existing creative):
+Flags (create \u2014 existing creative):
   --adset <id>        Ad set ID (required)
   --creative <id>     Existing creative ID
   --name <name>       Ad name
@@ -236,14 +1618,14 @@ Examples:
   adkit manage meta ads delete ad_123
 
 Run --help full for all fields and advanced options.`;
-const ADS_HELP_FULL = `adkit manage meta ads — Meta ads
+var ADS_HELP_FULL = `adkit manage meta ads \u2014 Meta ads
 
   list                List ads
   create              Create an ad
   update <id>         Update an ad
   delete <id>         Delete an ad
 
-Flags (create — new creative from media):
+Flags (create \u2014 new creative from media):
   --adset <id>        Ad set ID (required)
   --media <path|url>  Media file or URL (repeatable). Handles upload + processing automatically
   --primary-text <t>  Ad body text (repeatable)
@@ -254,7 +1636,7 @@ ${FLAG.cta}
   --url <url>         Landing page URL
   --page <id>         Facebook Page ID (auto-resolved from account defaults)
 
-Flags (create — existing creative):
+Flags (create \u2014 existing creative):
   --adset <id>        Ad set ID (required)
   --creative <id>     Existing creative ID
   --name <name>       Ad name
@@ -266,7 +1648,7 @@ Flags (list):
   adsetId             (required) Parent ad set ID
   name                (required) Ad name
   status              active, paused, archived, deleted
-  creative            { creativeId: "cr_..." } — reference existing creative
+  creative            { creativeId: "cr_..." } \u2014 reference existing creative
   platformOverrides   Raw Meta API fields merged onto the payload
 
 Examples:
@@ -278,8 +1660,7 @@ Examples:
   adkit manage meta ads list --adset as_xyz
   adkit manage meta ads update ad_123 --data '{"status":"paused"}'
   adkit manage meta ads delete ad_123`;
-// --- Creatives ---
-const CREATIVE_HELP = `adkit manage meta creatives — Meta ad creatives
+var CREATIVE_HELP = `adkit manage meta creatives \u2014 Meta ad creatives
 
 Prefer using "ads create --media" which handles creative creation automatically.
 
@@ -306,7 +1687,7 @@ Examples:
   adkit manage meta creatives delete cr_abc
 
 Run --help full for all fields and advanced options.`;
-const CREATIVE_HELP_FULL = `adkit manage meta creatives — Meta ad creatives
+var CREATIVE_HELP_FULL = `adkit manage meta creatives \u2014 Meta ad creatives
 
 Prefer using "ads create --media" which handles creative creation automatically.
 
@@ -346,11 +1727,8 @@ Examples:
   }' --publish
   adkit manage meta creatives update cr_abc --primary-text "Start free trial"
   adkit manage meta creatives delete cr_abc`;
-// ---------------------------------------------------------------------------
-// Composed HELP and HELP_FULL
-// ---------------------------------------------------------------------------
-const HELP = {
-    'meta accounts': `adkit manage meta accounts — Meta ad accounts
+var HELP = {
+  "meta accounts": `adkit manage meta accounts \u2014 Meta ad accounts
 
   list                List connected ad accounts
   connect <id>        Connect an ad account
@@ -363,11 +1741,11 @@ Examples:
   adkit manage meta accounts connect act_123456789
   adkit manage meta accounts act_123456789 pages
   adkit manage meta accounts disconnect act_123456789`.trim(),
-    'meta campaigns': CAMPAIGN_HELP,
-    'meta adsets': ADSET_HELP,
-    'meta ads': ADS_HELP,
-    'meta creatives': CREATIVE_HELP,
-    'meta media': `adkit manage meta media — Upload media to Meta
+  "meta campaigns": CAMPAIGN_HELP,
+  "meta adsets": ADSET_HELP,
+  "meta ads": ADS_HELP,
+  "meta creatives": CREATIVE_HELP,
+  "meta media": `adkit manage meta media \u2014 Upload media to Meta
 
   upload              Upload an image or video
 
@@ -378,7 +1756,7 @@ Flags:
 Examples:
   adkit manage meta media upload --file ./hero-video.mp4
   adkit manage meta media upload --url https://example.com/hero.png`.trim(),
-    'meta interests': `adkit manage meta interests — Search targeting interests
+  "meta interests": `adkit manage meta interests \u2014 Search targeting interests
 
   search <query>      Search for interests (multiple queries supported)
 
@@ -387,14 +1765,14 @@ Output: Returns id and name for each interest. Use the id with --interest flag.
 Examples:
   adkit manage meta interests search "yoga"
   adkit manage meta interests search "saas" "marketing" "digital ads"`.trim(),
-    manage: `adkit manage — Ad platform management
+  manage: `adkit manage \u2014 Ad platform management
 
 Platforms:
   meta                Meta (Facebook/Instagram) ads
   drafts              Manage drafts across platforms
 
 Run adkit manage <platform> --help for details.`.trim(),
-    meta: `adkit manage meta — Meta Ads management
+  meta: `adkit manage meta \u2014 Meta Ads management
 
 Entity groups:
   accounts            List connected ad accounts
@@ -411,7 +1789,7 @@ ${FLAG.data}
 
 Mutations are draft-first by default. Use --publish to publish immediately.
 Run adkit manage meta <group> --help for details.`.trim(),
-    drafts: `adkit manage drafts — Manage drafts
+  drafts: `adkit manage drafts \u2014 Manage drafts
 
   list                List all drafts
   get <id>            Get a draft by ID
@@ -427,7 +1805,7 @@ Examples:
   adkit manage drafts list --platform meta --limit 10
   adkit manage drafts publish dft_abc123
   adkit manage drafts delete dft_abc123`.trim(),
-    status: `adkit status — Show project context and connected accounts
+  status: `adkit status \u2014 Show project context and connected accounts
 
 Displays project name, connected platforms, and ad accounts with defaults.
 AI agents should call this first to understand the context.
@@ -435,7 +1813,7 @@ AI agents should call this first to understand the context.
 Examples:
   adkit status
   adkit status --json`.trim(),
-    projects: `adkit projects — Manage projects
+  projects: `adkit projects \u2014 Manage projects
 
   list                List all configured projects
   use <id>            Switch active project
@@ -443,399 +1821,372 @@ Examples:
 
 Examples:
   adkit projects list
-  adkit projects use proj_abc123`.trim(),
+  adkit projects use proj_abc123`.trim()
 };
-const HELP_FULL = {
-    'meta campaigns': CAMPAIGN_HELP_FULL,
-    'meta adsets': ADSET_HELP_FULL,
-    'meta ads': ADS_HELP_FULL,
-    'meta creatives': CREATIVE_HELP_FULL,
+var HELP_FULL = {
+  "meta campaigns": CAMPAIGN_HELP_FULL,
+  "meta adsets": ADSET_HELP_FULL,
+  "meta ads": ADS_HELP_FULL,
+  "meta creatives": CREATIVE_HELP_FULL
 };
 function getBaseUrl() {
-    return process.env.ADKIT_BASE_URL || DEFAULT_BASE_URL;
+  return process.env.ADKIT_BASE_URL || DEFAULT_BASE_URL;
 }
 function wantsJson(flags) {
-    return flags.json === true || !(process.stdout.isTTY ?? false);
+  return flags.json === true || !(process.stdout.isTTY ?? false);
 }
 function requireClient(flags) {
-    const projectFlag = typeof flags.project === 'string' ? flags.project : undefined;
-    const { apiKey } = resolveConfig({ project: projectFlag });
-    if (!apiKey)
-        throw new CliError('NOT_AUTHENTICATED', 'No API key found', 'Run: adkit setup');
-    return new AdkitClient({ apiKey, baseUrl: getBaseUrl() });
-}
-function printList(data, flags, emptyHint = 'No results.') {
-    const rows = unwrapList(data);
-    const fields = typeof flags.fields === 'string' ? flags.fields.split(',') : undefined;
-    const output = formatOutput(rows, { fields, json: wantsJson(flags) });
-    if (output)
-        console.log(output);
-    else
-        console.log(emptyHint);
+  const projectFlag = typeof flags.project === "string" ? flags.project : void 0;
+  const { apiKey } = resolveConfig({ project: projectFlag });
+  if (!apiKey) throw new CliError("NOT_AUTHENTICATED", "No API key found", "Run: adkit setup");
+  return new AdkitClient({ apiKey, baseUrl: getBaseUrl() });
+}
+function printList(data, flags, emptyHint = "No results.") {
+  const rows = unwrapList(data);
+  const fields = typeof flags.fields === "string" ? flags.fields.split(",") : void 0;
+  const output = formatOutput(rows, { fields, json: wantsJson(flags) });
+  if (output) console.log(output);
+  else console.log(emptyHint);
 }
 function hasArrayValues(v) {
-    return v !== null && typeof v === 'object' && !Array.isArray(v) && Object.values(v).some(Array.isArray);
+  return v !== null && typeof v === "object" && !Array.isArray(v) && Object.values(v).some(Array.isArray);
 }
 function printResult(data, flags, emptyHint) {
-    if (data === undefined) {
-        console.log('Done.');
-        return;
-    }
-    if (wantsJson(flags))
-        console.log(JSON.stringify(data));
-    else if (Array.isArray(data) || hasArrayValues(data))
-        printList(data, flags, emptyHint);
-    else
-        console.log(JSON.stringify(data, null, 2));
+  if (data === void 0) {
+    console.log("Done.");
+    return;
+  }
+  if (wantsJson(flags)) console.log(JSON.stringify(data));
+  else if (Array.isArray(data) || hasArrayValues(data)) printList(data, flags, emptyHint);
+  else console.log(JSON.stringify(data, null, 2));
 }
 function showHelp(key, full = false) {
-    const text = full ? HELP_FULL[key] || HELP[key] : HELP[key];
-    if (text) {
-        console.log(text);
-        return true;
-    }
-    return false;
+  const text = full ? HELP_FULL[key] || HELP[key] : HELP[key];
+  if (text) {
+    console.log(text);
+    return true;
+  }
+  return false;
 }
 async function main() {
-    const { args, flags } = parseArgs(process.argv.slice(2), {
-        multi: ['media', 'primary-text', 'headline', 'description', 'link-description', 'interest'],
-    });
-    if (args.length === 0) {
-        console.log(USAGE);
-        process.exit(0);
+  const { args, flags } = parseArgs(process.argv.slice(2), {
+    multi: ["media", "primary-text", "headline", "description", "link-description", "interest"]
+  });
+  if (args.length === 0) {
+    console.log(USAGE);
+    process.exit(0);
+  }
+  if (flags.help && args.length === 0) {
+    console.log(USAGE);
+    process.exit(0);
+  }
+  try {
+    if (args[0] === "status") {
+      const client = requireClient(flags);
+      await status(client, wantsJson(flags));
+      return;
     }
-    // Top-level --help with no command
-    if (flags.help && args.length === 0) {
+    if (args[0] === "manage") {
+      const manageTarget = args[1];
+      if (flags.help && !manageTarget) {
+        showHelp("manage", flags.help === "full");
+        process.exit(0);
+      }
+      if (!manageTarget) {
+        showHelp("manage", flags.help === "full");
+        process.exit(0);
+      }
+      if (manageTarget === "drafts") {
+        const action2 = args[2];
+        const restArgs2 = args.slice(3);
+        if (flags.help) {
+          showHelp("drafts", flags.help === "full");
+          process.exit(0);
+        }
+        const client2 = requireClient(flags);
+        let data2;
+        let emptyHint2;
+        switch (action2) {
+          case "list":
+          case void 0:
+            data2 = await listDrafts(client2, restArgs2, flags);
+            emptyHint2 = "No drafts found. Drafts are created automatically when you create or update ads without `--publish`.";
+            break;
+          case "get":
+            data2 = await getDraft(client2, restArgs2, flags);
+            break;
+          case "publish":
+            data2 = await publishDraft(client2, restArgs2, flags);
+            break;
+          case "delete":
+            data2 = await deleteDraft(client2, restArgs2, flags);
+            break;
+          default:
+            throw new CliError("UNKNOWN_COMMAND", `Unknown action: manage drafts ${action2}`, "Available: list, get, publish, delete");
+        }
+        printResult(data2, flags, emptyHint2);
+        return;
+      }
+      const platform2 = manageTarget;
+      if (platform2 !== "meta") throw new CliError("UNKNOWN_COMMAND", `Unknown platform: ${platform2}`, "Available: meta");
+      const entity = args[2];
+      const action = args[3];
+      const restArgs = args.slice(4);
+      if (flags.help) {
+        const helpKey = entity ? `meta ${entity}` : "meta";
+        if (showHelp(helpKey, flags.help === "full")) process.exit(0);
         console.log(USAGE);
         process.exit(0);
-    }
-    try {
-        // --- status ---
-        if (args[0] === 'status') {
-            const client = requireClient(flags);
-            await status(client, wantsJson(flags));
-            return;
+      }
+      if (!entity) {
+        showHelp("meta", flags.help === "full");
+        process.exit(0);
+      }
+      const client = requireClient(flags);
+      let data;
+      let emptyHint;
+      switch (entity) {
+        case "accounts": {
+          if (action && action !== "list" && action !== "connect" && action !== "disconnect") {
+            const accountId = action;
+            const sub = args[4];
+            if (sub === "pages") {
+              data = await listPages(client, [accountId], flags);
+              emptyHint = "No Facebook Pages found for this account.";
+            } else if (sub === "pixels") {
+              data = await listPixels(client, [accountId], flags);
+              emptyHint = "No Meta Pixels found for this account.";
+            } else throw new CliError("UNKNOWN_COMMAND", `Unknown subcommand: meta accounts ${accountId} ${sub ?? ""}`, "Expected: pages or pixels");
+            break;
+          }
+          switch (action) {
+            case "list":
+            case void 0:
+              data = await listAccounts(client, restArgs, flags);
+              emptyHint = "No Meta ad accounts connected. Run `adkit setup manage` or connect via https://app.adkit.so/settings/integrations";
+              break;
+            case "connect":
+              data = await connectAccount(client, restArgs, flags);
+              break;
+            case "disconnect":
+              data = await disconnectAccount(client, restArgs, flags);
+              break;
+            default:
+              throw new CliError("UNKNOWN_COMMAND", `Unknown action: meta accounts ${action}`, "Run: adkit manage meta accounts --help");
+          }
+          break;
         }
-        // --- manage commands (platform management) ---
-        if (args[0] === 'manage') {
-            const manageTarget = args[1];
-            if (flags.help && !manageTarget) {
-                showHelp('manage', flags.help === 'full');
-                process.exit(0);
-            }
-            if (!manageTarget) {
-                showHelp('manage', flags.help === 'full');
-                process.exit(0);
-            }
-            // --- manage drafts ---
-            if (manageTarget === 'drafts') {
-                const action = args[2];
-                const restArgs = args.slice(3);
-                if (flags.help) {
-                    showHelp('drafts', flags.help === 'full');
-                    process.exit(0);
-                }
-                const client = requireClient(flags);
-                let data;
-                let emptyHint;
-                switch (action) {
-                    case 'list':
-                    case undefined:
-                        data = await listDrafts(client, restArgs, flags);
-                        emptyHint = 'No drafts found. Drafts are created automatically when you create or update ads without `--publish`.';
-                        break;
-                    case 'get':
-                        data = await getDraft(client, restArgs, flags);
-                        break;
-                    case 'publish':
-                        data = await publishDraft(client, restArgs, flags);
-                        break;
-                    case 'delete':
-                        data = await deleteDraft(client, restArgs, flags);
-                        break;
-                    default:
-                        throw new CliError('UNKNOWN_COMMAND', `Unknown action: manage drafts ${action}`, 'Available: list, get, publish, delete');
-                }
-                printResult(data, flags, emptyHint);
-                return;
-            }
-            // --- manage <platform> (meta, google, etc.) ---
-            const platform = manageTarget;
-            if (platform !== 'meta')
-                throw new CliError('UNKNOWN_COMMAND', `Unknown platform: ${platform}`, 'Available: meta');
-            const entity = args[2];
-            const action = args[3];
-            const restArgs = args.slice(4);
-            // Help routing
-            if (flags.help) {
-                const helpKey = entity ? `meta ${entity}` : 'meta';
-                if (showHelp(helpKey, flags.help === 'full'))
-                    process.exit(0);
-                console.log(USAGE);
-                process.exit(0);
-            }
-            if (!entity) {
-                showHelp('meta', flags.help === 'full');
-                process.exit(0);
-            }
-            const client = requireClient(flags);
-            let data;
-            let emptyHint;
-            switch (entity) {
-                case 'accounts': {
-                    // Special case: meta accounts <id> pages/pixels
-                    if (action && action !== 'list' && action !== 'connect' && action !== 'disconnect') {
-                        const accountId = action;
-                        const sub = args[4];
-                        if (sub === 'pages') {
-                            data = await listPages(client, [accountId], flags);
-                            emptyHint = 'No Facebook Pages found for this account.';
-                        }
-                        else if (sub === 'pixels') {
-                            data = await listPixels(client, [accountId], flags);
-                            emptyHint = 'No Meta Pixels found for this account.';
-                        }
-                        else
-                            throw new CliError('UNKNOWN_COMMAND', `Unknown subcommand: meta accounts ${accountId} ${sub ?? ''}`, 'Expected: pages or pixels');
-                        break;
-                    }
-                    switch (action) {
-                        case 'list':
-                        case undefined:
-                            data = await listAccounts(client, restArgs, flags);
-                            emptyHint = 'No Meta ad accounts connected. Run `adkit setup manage` or connect via https://app.adkit.so/settings/integrations';
-                            break;
-                        case 'connect':
-                            data = await connectAccount(client, restArgs, flags);
-                            break;
-                        case 'disconnect':
-                            data = await disconnectAccount(client, restArgs, flags);
-                            break;
-                        default:
-                            throw new CliError('UNKNOWN_COMMAND', `Unknown action: meta accounts ${action}`, 'Run: adkit manage meta accounts --help');
-                    }
-                    break;
-                }
-                case 'campaigns': {
-                    if (!action) {
-                        showHelp('meta campaigns', flags.help === 'full');
-                        process.exit(0);
-                    }
-                    switch (action) {
-                        case 'list':
-                            data = await listCampaigns(client, restArgs, flags);
-                            emptyHint = 'No campaigns found. Create one with `adkit manage meta campaigns create --name "My Campaign" --objective sales --publish`.';
-                            break;
-                        case 'create':
-                            data = await createCampaign(client, restArgs, flags);
-                            break;
-                        case 'update':
-                            data = await updateCampaign(client, restArgs, flags);
-                            break;
-                        case 'delete':
-                            data = await deleteCampaign(client, restArgs, flags);
-                            break;
-                        default:
-                            throw new CliError('UNKNOWN_COMMAND', `Unknown action: meta campaigns ${action}`, 'Run: adkit manage meta campaigns --help');
-                    }
-                    break;
-                }
-                case 'adsets': {
-                    if (!action) {
-                        showHelp('meta adsets', flags.help === 'full');
-                        process.exit(0);
-                    }
-                    switch (action) {
-                        case 'list':
-                            data = await listAdSets(client, restArgs, flags);
-                            emptyHint = 'No ad sets found. Create one with `adkit manage meta adsets create --campaign cmp_123 --name "My AdSet" --publish`.';
-                            break;
-                        case 'create':
-                            data = await createAdSet(client, restArgs, flags);
-                            break;
-                        case 'update':
-                            data = await updateAdSet(client, restArgs, flags);
-                            break;
-                        case 'delete':
-                            data = await deleteAdSet(client, restArgs, flags);
-                            break;
-                        default:
-                            throw new CliError('UNKNOWN_COMMAND', `Unknown action: meta adsets ${action}`, 'Run: adkit manage meta adsets --help');
-                    }
-                    break;
-                }
-                case 'ads': {
-                    if (!action) {
-                        showHelp('meta ads', flags.help === 'full');
-                        process.exit(0);
-                    }
-                    switch (action) {
-                        case 'list':
-                            data = await listAds(client, restArgs, flags);
-                            emptyHint = 'No ads found. Create one with `adkit manage meta ads create --data \'{"adsetId":"as_123","creativeId":"cr_123","name":"My Ad"}\'`.';
-                            break;
-                        case 'create':
-                            data = await createAd(client, restArgs, flags);
-                            break;
-                        case 'update':
-                            data = await updateAd(client, restArgs, flags);
-                            break;
-                        case 'delete':
-                            data = await deleteAd(client, restArgs, flags);
-                            break;
-                        default:
-                            throw new CliError('UNKNOWN_COMMAND', `Unknown action: meta ads ${action}`, 'Run: adkit manage meta ads --help');
-                    }
-                    break;
-                }
-                case 'creatives': {
-                    switch (action) {
-                        case 'create':
-                            data = await createCreative(client, restArgs, flags);
-                            break;
-                        case 'update':
-                            data = await updateCreative(client, restArgs, flags);
-                            break;
-                        case 'delete':
-                            data = await deleteCreative(client, restArgs, flags);
-                            break;
-                        default:
-                            throw new CliError('UNKNOWN_COMMAND', `Unknown action: meta creatives ${action ?? 'list'}`, 'Available: create, update, delete');
-                    }
-                    break;
-                }
-                case 'media': {
-                    switch (action) {
-                        case 'upload':
-                            data = await uploadMedia(client, restArgs, flags);
-                            break;
-                        case 'list':
-                            data = await listMedia(client, restArgs, flags);
-                            emptyHint = 'No media found for this account.';
-                            break;
-                        case 'delete':
-                            data = await deleteMedia(client, restArgs, flags);
-                            break;
-                        default:
-                            throw new CliError('UNKNOWN_COMMAND', `Unknown action: meta media ${action ?? ''}`, 'Available: upload, list, delete');
-                    }
-                    break;
-                }
-                case 'interests': {
-                    switch (action) {
-                        case 'search':
-                            data = await searchInterests(client, restArgs, flags);
-                            emptyHint = 'No interests found for that query.';
-                            break;
-                        default:
-                            throw new CliError('UNKNOWN_COMMAND', `Unknown action: meta interests ${action ?? ''}`, 'Available: search');
-                    }
-                    break;
-                }
-                default:
-                    throw new CliError('UNKNOWN_COMMAND', `Unknown entity: meta ${entity}`, 'Available: accounts, campaigns, adsets, ads, creatives, media, interests');
-            }
-            printResult(data, flags, emptyHint);
-            return;
+        case "campaigns": {
+          if (!action) {
+            showHelp("meta campaigns", flags.help === "full");
+            process.exit(0);
+          }
+          switch (action) {
+            case "list":
+              data = await listCampaigns(client, restArgs, flags);
+              emptyHint = 'No campaigns found. Create one with `adkit manage meta campaigns create --name "My Campaign" --objective sales --publish`.';
+              break;
+            case "create":
+              data = await createCampaign(client, restArgs, flags);
+              break;
+            case "update":
+              data = await updateCampaign(client, restArgs, flags);
+              break;
+            case "delete":
+              data = await deleteCampaign(client, restArgs, flags);
+              break;
+            default:
+              throw new CliError("UNKNOWN_COMMAND", `Unknown action: meta campaigns ${action}`, "Run: adkit manage meta campaigns --help");
+          }
+          break;
         }
-        // --- projects commands ---
-        if (args[0] === 'projects') {
-            const action = args[1];
-            if (flags.help) {
-                showHelp('projects', flags.help === 'full');
-                process.exit(0);
-            }
-            switch (action) {
-                case 'list':
-                case undefined: {
-                    const config = readConfig() ?? {};
-                    const projects = listProjects(config);
-                    if (projects.length === 0)
-                        console.log('No projects configured. Run `adkit setup` to set up your first project.');
-                    else {
-                        for (const p of projects) {
-                            const marker = p.current ? '* ' : '  ';
-                            console.log(`${marker}${p.name} (${p.id})`);
-                        }
-                    }
-                    break;
-                }
-                case 'current': {
-                    const config = readConfig() ?? {};
-                    const project = currentProject(config);
-                    if (!project)
-                        console.log('No project selected. Run `adkit projects use <id>`.');
-                    else
-                        console.log(`Active project: ${project.name} (${project.id})`);
-                    break;
-                }
-                case 'use': {
-                    const projectId = args[2];
-                    if (!projectId)
-                        throw new CliError('MISSING_ARGUMENT', 'Missing required argument: `<project-id>`', 'Run: adkit projects use <project-id>');
-                    useProject(projectId);
-                    console.log(`Switched to project: ${projectId}`);
-                    break;
-                }
-                default:
-                    throw new CliError('UNKNOWN_COMMAND', `Unknown action: projects ${action}`, 'Available: list, use, current');
-            }
-            return;
+        case "adsets": {
+          if (!action) {
+            showHelp("meta adsets", flags.help === "full");
+            process.exit(0);
+          }
+          switch (action) {
+            case "list":
+              data = await listAdSets(client, restArgs, flags);
+              emptyHint = 'No ad sets found. Create one with `adkit manage meta adsets create --campaign cmp_123 --name "My AdSet" --publish`.';
+              break;
+            case "create":
+              data = await createAdSet(client, restArgs, flags);
+              break;
+            case "update":
+              data = await updateAdSet(client, restArgs, flags);
+              break;
+            case "delete":
+              data = await deleteAdSet(client, restArgs, flags);
+              break;
+            default:
+              throw new CliError("UNKNOWN_COMMAND", `Unknown action: meta adsets ${action}`, "Run: adkit manage meta adsets --help");
+          }
+          break;
         }
-        // --- logout ---
-        if (args[0] === 'logout') {
-            logout();
-            return;
+        case "ads": {
+          if (!action) {
+            showHelp("meta ads", flags.help === "full");
+            process.exit(0);
+          }
+          switch (action) {
+            case "list":
+              data = await listAds(client, restArgs, flags);
+              emptyHint = 'No ads found. Create one with `adkit manage meta ads create --data \'{"adsetId":"as_123","creativeId":"cr_123","name":"My Ad"}\'`.';
+              break;
+            case "create":
+              data = await createAd(client, restArgs, flags);
+              break;
+            case "update":
+              data = await updateAd(client, restArgs, flags);
+              break;
+            case "delete":
+              data = await deleteAd(client, restArgs, flags);
+              break;
+            default:
+              throw new CliError("UNKNOWN_COMMAND", `Unknown action: meta ads ${action}`, "Run: adkit manage meta ads --help");
+          }
+          break;
         }
-        // --- setup (auth + onboarding) ---
-        if (args[0] === 'setup') {
-            const scope = args.slice(1); // e.g. ['manage'], ['manage', 'studio'], or []
-            await login({ baseUrl: getBaseUrl(), scope });
-            return;
+        case "creatives": {
+          switch (action) {
+            case "create":
+              data = await createCreative(client, restArgs, flags);
+              break;
+            case "update":
+              data = await updateCreative(client, restArgs, flags);
+              break;
+            case "delete":
+              data = await deleteCreative(client, restArgs, flags);
+              break;
+            default:
+              throw new CliError("UNKNOWN_COMMAND", `Unknown action: meta creatives ${action ?? "list"}`, "Available: create, update, delete");
+          }
+          break;
         }
-        // --- fallback ---
-        throw new CliError('UNKNOWN_COMMAND', `Unknown command: ${args.join(' ')}`, 'Run: adkit --help');
-    }
-    catch (err) {
-        const jsonErrors = wantsJson(flags);
-        if (err instanceof CliError) {
-            if (!jsonErrors) {
-                console.error(`Error: ${err.message}`);
-                if (err.suggestion)
-                    console.error(`Suggestion: ${err.suggestion}`);
-            }
-            else {
-                console.error(JSON.stringify({
-                    error: true,
-                    code: err.code,
-                    message: err.message,
-                    ...(err.suggestion && { suggestion: err.suggestion }),
-                }));
-            }
+        case "media": {
+          switch (action) {
+            case "upload":
+              data = await uploadMedia(client, restArgs, flags);
+              break;
+            case "list":
+              data = await listMedia(client, restArgs, flags);
+              emptyHint = "No media found for this account.";
+              break;
+            case "delete":
+              data = await deleteMedia(client, restArgs, flags);
+              break;
+            default:
+              throw new CliError("UNKNOWN_COMMAND", `Unknown action: meta media ${action ?? ""}`, "Available: upload, list, delete");
+          }
+          break;
+        }
+        case "interests": {
+          switch (action) {
+            case "search":
+              data = await searchInterests(client, restArgs, flags);
+              emptyHint = "No interests found for that query.";
+              break;
+            default:
+              throw new CliError("UNKNOWN_COMMAND", `Unknown action: meta interests ${action ?? ""}`, "Available: search");
+          }
+          break;
         }
-        else {
-            const message = err instanceof Error ? err.message : String(err);
-            if (!jsonErrors)
-                console.error(`Error: ${message}`);
-            else {
-                console.error(JSON.stringify({
-                    error: true,
-                    code: 'UNKNOWN',
-                    message,
-                }));
+        default:
+          throw new CliError("UNKNOWN_COMMAND", `Unknown entity: meta ${entity}`, "Available: accounts, campaigns, adsets, ads, creatives, media, interests");
+      }
+      printResult(data, flags, emptyHint);
+      return;
+    }
+    if (args[0] === "projects") {
+      const action = args[1];
+      if (flags.help) {
+        showHelp("projects", flags.help === "full");
+        process.exit(0);
+      }
+      switch (action) {
+        case "list":
+        case void 0: {
+          const config = readConfig() ?? {};
+          const projects = listProjects(config);
+          if (projects.length === 0) console.log("No projects configured. Run `adkit setup` to set up your first project.");
+          else {
+            for (const p of projects) {
+              const marker = p.current ? "* " : "  ";
+              console.log(`${marker}${p.name} (${p.id})`);
             }
+          }
+          break;
+        }
+        case "current": {
+          const config = readConfig() ?? {};
+          const project = currentProject(config);
+          if (!project) console.log("No project selected. Run `adkit projects use <id>`.");
+          else console.log(`Active project: ${project.name} (${project.id})`);
+          break;
+        }
+        case "use": {
+          const projectId = args[2];
+          if (!projectId) throw new CliError("MISSING_ARGUMENT", "Missing required argument: `<project-id>`", "Run: adkit projects use <project-id>");
+          useProject(projectId);
+          console.log(`Switched to project: ${projectId}`);
+          break;
         }
-        const EXIT_CODES = {
-            MISSING_ARGUMENT: 2,
-            MISSING_FLAG: 2,
-            INVALID_VALUE: 2,
-            UNKNOWN_COMMAND: 2,
-            UNKNOWN_FLAG: 2,
-            NOT_FOUND: 3,
-            INVALID_API_KEY: 4,
-            NOT_AUTHENTICATED: 4,
-        };
-        process.exit(err instanceof CliError ? (EXIT_CODES[err.code] ?? 1) : 1);
+        default:
+          throw new CliError("UNKNOWN_COMMAND", `Unknown action: projects ${action}`, "Available: list, use, current");
+      }
+      return;
+    }
+    if (args[0] === "logout") {
+      logout();
+      return;
+    }
+    if (args[0] === "setup") {
+      const scope = args.slice(1);
+      await login({ baseUrl: getBaseUrl(), scope });
+      return;
+    }
+    throw new CliError("UNKNOWN_COMMAND", `Unknown command: ${args.join(" ")}`, "Run: adkit --help");
+  } catch (err) {
+    const jsonErrors = wantsJson(flags);
+    if (err instanceof CliError) {
+      if (!jsonErrors) {
+        console.error(`Error: ${err.message}`);
+        if (err.suggestion) console.error(`Suggestion: ${err.suggestion}`);
+      } else {
+        console.error(
+          JSON.stringify({
+            error: true,
+            code: err.code,
+            message: err.message,
+            ...err.suggestion && { suggestion: err.suggestion }
+          })
+        );
+      }
+    } else {
+      const message = err instanceof Error ? err.message : String(err);
+      if (!jsonErrors) console.error(`Error: ${message}`);
+      else {
+        console.error(
+          JSON.stringify({
+            error: true,
+            code: "UNKNOWN",
+            message
+          })
+        );
+      }
     }
+    const EXIT_CODES = {
+      MISSING_ARGUMENT: 2,
+      MISSING_FLAG: 2,
+      INVALID_VALUE: 2,
+      UNKNOWN_COMMAND: 2,
+      UNKNOWN_FLAG: 2,
+      NOT_FOUND: 3,
+      INVALID_API_KEY: 4,
+      NOT_AUTHENTICATED: 4
+    };
+    process.exit(err instanceof CliError ? EXIT_CODES[err.code] ?? 1 : 1);
+  }
 }
 void main();