agno-cli 0.1.0

package/dist/bin/agno.js

@@ -0,0 +1,3616 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/lib/errors.ts
+import {
+  APIError,
+  AuthenticationError,
+  BadRequestError,
+  InternalServerError,
+  NotFoundError,
+  RateLimitError,
+  RemoteServerUnavailableError,
+  UnprocessableEntityError
+} from "@worksofadam/agentos-sdk";
+import chalk from "chalk";
+function isConnectionError(err) {
+  if (!(err instanceof Error)) return false;
+  const code = err.code;
+  if (code === "ECONNREFUSED" || code === "ECONNRESET" || code === "ENOTFOUND") return true;
+  if (err.message.includes("fetch failed")) return true;
+  return false;
+}
+function isNetworkAPIError(err) {
+  return err instanceof APIError && err.status === 0 && err.message.includes("Network error");
+}
+function formatValidationError(message) {
+  try {
+    const parsed = JSON.parse(message);
+    if (parsed && Array.isArray(parsed.detail)) {
+      const lines = parsed.detail.map((d) => {
+        const field = d.loc?.slice(1).join(".") ?? "unknown";
+        return `  - ${field}: ${d.msg ?? "invalid"}`;
+      });
+      return `Validation error:
+${lines.join("\n")}`;
+    }
+  } catch {
+  }
+  return `Validation error: ${message}`;
+}
+function writeErr(msg) {
+  process.stderr.write(`${chalk.red("Error:")} ${msg}
+`);
+}
+function handleError(err, ctx) {
+  if (err instanceof AuthenticationError) {
+    writeErr("Authentication failed. Check your API key: agno-cli config show");
+    process.exitCode = 1;
+  } else if (err instanceof NotFoundError) {
+    const what = ctx?.resource ?? "Resource";
+    writeErr(`${what} not found.`);
+    process.exitCode = 1;
+  } else if (err instanceof BadRequestError) {
+    writeErr(`Invalid request: ${err.message}`);
+    process.exitCode = 1;
+  } else if (err instanceof UnprocessableEntityError) {
+    writeErr(formatValidationError(err.message));
+    process.exitCode = 1;
+  } else if (err instanceof RateLimitError) {
+    writeErr("Rate limited. Wait and retry.");
+    process.exitCode = 2;
+  } else if (err instanceof InternalServerError) {
+    writeErr(`Server error: ${err.message}
+Run \`agno-cli status\` for diagnostics.`);
+    process.exitCode = 2;
+  } else if (err instanceof RemoteServerUnavailableError) {
+    writeErr("Server unavailable. Is AgentOS running?");
+    process.exitCode = 2;
+  } else if (isConnectionError(err) || isNetworkAPIError(err)) {
+    const target = ctx?.url ? ` to ${ctx.url}` : "";
+    writeErr(`Cannot connect${target} -- is the server running?`);
+    process.exitCode = 2;
+  } else if (err instanceof APIError && err.status === 403) {
+    const isAdmin = err.message.toLowerCase().includes("admin");
+    if (isAdmin) {
+      writeErr("This operation requires admin scope. Check your API key permissions.");
+    } else {
+      writeErr("Access denied. Check your API key permissions.");
+    }
+    process.exitCode = 1;
+  } else if (err instanceof APIError) {
+    writeErr(`API error (${err.status}): ${err.message}`);
+    process.exitCode = err.status >= 500 ? 2 : 1;
+  } else if (err instanceof ConfigError) {
+    writeErr(err.message);
+    process.exitCode = 1;
+  } else {
+    writeErr(err instanceof Error ? err.message : String(err));
+    process.exitCode = 2;
+  }
+  process.exit();
+}
+var ConfigError;
+var init_errors = __esm({
+  "src/lib/errors.ts"() {
+    "use strict";
+    ConfigError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "ConfigError";
+      }
+    };
+  }
+});
+
+// src/lib/output.ts
+import chalk2 from "chalk";
+import Table from "cli-table3";
+function getOutputFormat(cmd) {
+  const globals = cmd.optsWithGlobals();
+  if (globals.json !== void 0) return "json";
+  if (globals.output === "json") return "json";
+  if (globals.output === "table") return "table";
+  return process.stdout.isTTY ? "table" : "json";
+}
+function getJsonFields(cmd) {
+  const globals = cmd.optsWithGlobals();
+  if (typeof globals.json === "string") return globals.json;
+  return void 0;
+}
+function selectFields(data, fields) {
+  const fieldList = fields.split(",").map((f) => f.trim());
+  if (Array.isArray(data)) {
+    return data.map((item) => pickFields(item, fieldList));
+  }
+  return pickFields(data, fieldList);
+}
+function pickFields(obj, fields) {
+  const result = {};
+  for (const field of fields) {
+    if (field in obj) {
+      result[field] = obj[field];
+    }
+  }
+  return result;
+}
+function outputList(cmd, data, opts) {
+  const format = getOutputFormat(cmd);
+  if (format === "json") {
+    const fields = getJsonFields(cmd);
+    if (fields) {
+      const filtered = selectFields(data, fields);
+      process.stdout.write(`${JSON.stringify(filtered, null, 2)}
+`);
+      return;
+    }
+    const envelope = { data };
+    if (opts.meta) envelope.meta = opts.meta;
+    process.stdout.write(`${JSON.stringify(envelope, null, 2)}
+`);
+    return;
+  }
+  if (data.length === 0) {
+    process.stderr.write("No items found.\n");
+    return;
+  }
+  const colWidths = calculateColWidths(opts.columns.length);
+  const table = new Table({
+    head: opts.columns.map((c) => chalk2.bold(c)),
+    style: { head: [], border: [] },
+    ...colWidths ? { colWidths } : {}
+  });
+  for (const row of data) {
+    table.push(opts.keys.map((key) => String(row[key] ?? "")));
+  }
+  process.stdout.write(`${table.toString()}
+`);
+}
+function outputDetail(cmd, data, opts) {
+  const format = getOutputFormat(cmd);
+  if (format === "json") {
+    const fields = getJsonFields(cmd);
+    if (fields) {
+      const filtered = selectFields(data, fields);
+      process.stdout.write(`${JSON.stringify(filtered, null, 2)}
+`);
+      return;
+    }
+    process.stdout.write(`${JSON.stringify(data, null, 2)}
+`);
+    return;
+  }
+  const maxLabelLen = Math.max(...opts.labels.map((l) => l.length));
+  const lines = [];
+  for (let i = 0; i < opts.labels.length; i++) {
+    const label = opts.labels[i];
+    const key = opts.keys[i];
+    if (label !== void 0 && key !== void 0) {
+      const padded = `${label}:`.padEnd(maxLabelLen + 2);
+      lines.push(`${chalk2.bold(padded)} ${String(data[key] ?? "")}`);
+    }
+  }
+  process.stdout.write(`${lines.join("\n")}
+`);
+}
+function printJson(data) {
+  process.stdout.write(`${JSON.stringify(data, null, 2)}
+`);
+}
+function writeError(msg) {
+  process.stderr.write(`${chalk2.red("Error:")} ${msg}
+`);
+}
+function writeSuccess(msg) {
+  process.stderr.write(`${chalk2.green("Success:")} ${msg}
+`);
+}
+function writeWarning(msg) {
+  process.stderr.write(`${chalk2.yellow("Warning:")} ${msg}
+`);
+}
+function maskKey(key) {
+  if (!key) return "(not set)";
+  return `${key.slice(0, 3)}...${key.slice(-4)}`;
+}
+function handleNoColorFlag(cmd) {
+  const globals = cmd.optsWithGlobals();
+  if (globals.color === false) {
+    process.env.NO_COLOR = "1";
+  }
+}
+function calculateColWidths(numCols) {
+  const termWidth = process.stdout.columns;
+  if (!termWidth) return void 0;
+  const available = termWidth - numCols * 3;
+  const colWidth = Math.max(10, Math.floor(available / numCols));
+  return Array.from({ length: numCols }, () => colWidth);
+}
+var init_output = __esm({
+  "src/lib/output.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import { parse, parseDocument } from "yaml";
+function getConfigPath() {
+  return _configFile;
+}
+function mapContext(raw) {
+  return {
+    baseUrl: String(raw.base_url ?? "http://localhost:7777"),
+    timeout: Number(raw.timeout ?? 60),
+    securityKey: raw.security_key == null ? void 0 : String(raw.security_key)
+  };
+}
+function unmapContext(ctx) {
+  return {
+    base_url: ctx.baseUrl,
+    timeout: ctx.timeout,
+    security_key: ctx.securityKey ?? null
+  };
+}
+function configExists() {
+  return existsSync(_configFile);
+}
+function loadConfig() {
+  if (!existsSync(_configFile)) {
+    return JSON.parse(JSON.stringify(DEFAULT_CONFIG));
+  }
+  try {
+    const raw = readFileSync(_configFile, "utf-8");
+    const data = parse(raw);
+    if (!data) {
+      return JSON.parse(JSON.stringify(DEFAULT_CONFIG));
+    }
+    const rawContexts = data.contexts ?? {};
+    const contexts = {};
+    for (const [name, rawCtx] of Object.entries(rawContexts)) {
+      contexts[name] = mapContext(rawCtx);
+    }
+    return {
+      current_context: String(data.current_context ?? "default"),
+      contexts
+    };
+  } catch (err) {
+    throw new ConfigError(
+      `Failed to parse config at ${_configFile}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+function saveConfig(config) {
+  const configDir = dirname(_configFile);
+  mkdirSync(configDir, { recursive: true, mode: 448 });
+  if (existsSync(_configFile)) {
+    const raw = readFileSync(_configFile, "utf-8");
+    const doc = parseDocument(raw);
+    doc.set("current_context", config.current_context);
+    for (const [name, ctx] of Object.entries(config.contexts)) {
+      const snake = unmapContext(ctx);
+      doc.setIn(["contexts", name, "base_url"], snake.base_url);
+      doc.setIn(["contexts", name, "timeout"], snake.timeout);
+      doc.setIn(["contexts", name, "security_key"], snake.security_key);
+    }
+    const existingContexts = doc.getIn(["contexts"]);
+    if (existingContexts && typeof existingContexts === "object" && "items" in existingContexts) {
+      const yamlMap = existingContexts;
+      const toDelete = [];
+      for (const item of yamlMap.items) {
+        if (item.key?.value && !(item.key.value in config.contexts)) {
+          toDelete.push(item.key.value);
+        }
+      }
+      for (const name of toDelete) {
+        doc.deleteIn(["contexts", name]);
+      }
+    }
+    writeFileSync(_configFile, doc.toString(), { mode: 384 });
+  } else {
+    const data = {
+      current_context: config.current_context,
+      contexts: Object.fromEntries(Object.entries(config.contexts).map(([name, ctx]) => [name, unmapContext(ctx)]))
+    };
+    const doc = parseDocument(JSON.stringify(data));
+    writeFileSync(_configFile, doc.toString(), { mode: 384 });
+  }
+}
+function resolveContext(overrides) {
+  const config = loadConfig();
+  const name = overrides.contextName ?? process.env.AGNO_CONTEXT ?? config.current_context;
+  const ctx = config.contexts[name];
+  if (!ctx) {
+    throw new ConfigError(`Context '${name}' not found. Run 'agno-cli config list' to see available contexts.`);
+  }
+  return {
+    baseUrl: overrides.urlOverride ?? process.env.AGNO_BASE_URL ?? ctx.baseUrl,
+    securityKey: overrides.keyOverride ?? process.env.AGNO_SECURITY_KEY ?? ctx.securityKey,
+    timeout: overrides.timeoutOverride ?? (process.env.AGNO_TIMEOUT ? Number.parseFloat(process.env.AGNO_TIMEOUT) : void 0) ?? ctx.timeout
+  };
+}
+var AGNO_CONFIG_DIR, AGNO_CONFIG_FILE, _configFile, DEFAULT_CONFIG;
+var init_config = __esm({
+  "src/lib/config.ts"() {
+    "use strict";
+    init_errors();
+    AGNO_CONFIG_DIR = join(homedir(), ".agno");
+    AGNO_CONFIG_FILE = join(AGNO_CONFIG_DIR, "config.yaml");
+    _configFile = AGNO_CONFIG_FILE;
+    DEFAULT_CONFIG = {
+      current_context: "default",
+      contexts: {
+        default: {
+          baseUrl: "http://localhost:7777",
+          timeout: 60,
+          securityKey: void 0
+        }
+      }
+    };
+  }
+});
+
+// src/commands/config.ts
+var config_exports = {};
+__export(config_exports, {
+  configCommand: () => configCommand
+});
+import { Command } from "commander";
+var configCommand;
+var init_config2 = __esm({
+  "src/commands/config.ts"() {
+    "use strict";
+    init_config();
+    init_output();
+    configCommand = new Command("config").description("Manage endpoint contexts and configuration");
+    configCommand.command("init").description("Initialize configuration with a default context").option("--url <url>", "Base URL for the default context", "http://localhost:7777").option("--key <key>", "Security key for the default context").option("--timeout <seconds>", "Timeout in seconds", Number.parseFloat, 60).option("-f, --force", "Overwrite existing config").action((_options, cmd) => {
+      const options = cmd.optsWithGlobals();
+      if (configExists() && !options.force) {
+        writeError(`Config already exists at ${getConfigPath()}. Use --force to overwrite.`);
+        process.exitCode = 1;
+        return;
+      }
+      const config = {
+        current_context: "default",
+        contexts: {
+          default: {
+            baseUrl: options.url ?? "http://localhost:7777",
+            timeout: options.timeout ?? 60,
+            securityKey: options.key
+          }
+        }
+      };
+      saveConfig(config);
+      writeSuccess(`Config initialized at ${getConfigPath()}`);
+    });
+    configCommand.command("add").argument("<name>", "Context name").description("Add a new context").option("--url <url>", "Base URL of the AgentOS instance (required)").option("--key <key>", "Security key").option("--timeout <seconds>", "Timeout in seconds", Number.parseFloat, 60).action((name, _options, cmd) => {
+      const options = cmd.optsWithGlobals();
+      if (!options.url) {
+        writeError("Missing required option --url <url>");
+        process.exitCode = 1;
+        return;
+      }
+      const config = loadConfig();
+      if (config.contexts[name]) {
+        writeError(`Context '${name}' already exists. Use 'config set' to modify it.`);
+        process.exitCode = 1;
+        return;
+      }
+      config.contexts[name] = {
+        baseUrl: options.url,
+        timeout: options.timeout ?? 60,
+        securityKey: options.key
+      };
+      saveConfig(config);
+      writeSuccess(`Context '${name}' added.`);
+    });
+    configCommand.command("use").argument("<name>", "Context to activate").description("Switch active context").action((name) => {
+      const config = loadConfig();
+      if (!config.contexts[name]) {
+        writeError(`Context '${name}' not found. Run 'agno-cli config list' to see available contexts.`);
+        process.exitCode = 1;
+        return;
+      }
+      config.current_context = name;
+      saveConfig(config);
+      writeSuccess(`Switched to context '${name}'.`);
+    });
+    configCommand.command("list").description("List all configured contexts").action((_options, cmd) => {
+      const config = loadConfig();
+      const format = getOutputFormat(cmd);
+      if (format === "json") {
+        const data2 = Object.entries(config.contexts).map(([name, ctx]) => ({
+          name,
+          url: ctx.baseUrl,
+          timeout: ctx.timeout,
+          active: name === config.current_context
+        }));
+        process.stdout.write(`${JSON.stringify({ data: data2 }, null, 2)}
+`);
+        return;
+      }
+      const data = Object.entries(config.contexts).map(([name, ctx]) => ({
+        name: name === config.current_context ? `* ${name}` : `  ${name}`,
+        url: ctx.baseUrl,
+        timeout: ctx.timeout
+      }));
+      outputList(cmd, data, {
+        columns: ["CONTEXT", "URL", "TIMEOUT"],
+        keys: ["name", "url", "timeout"]
+      });
+    });
+    configCommand.command("show").description("Show active context details").action((_options, cmd) => {
+      const config = loadConfig();
+      const name = config.current_context;
+      const ctx = config.contexts[name];
+      if (!ctx) {
+        writeError(`Active context '${name}' not found in config.`);
+        process.exitCode = 1;
+        return;
+      }
+      outputDetail(
+        cmd,
+        {
+          context: name,
+          base_url: ctx.baseUrl,
+          timeout: ctx.timeout,
+          security_key: maskKey(ctx.securityKey)
+        },
+        {
+          labels: ["Context", "Base URL", "Timeout", "Security Key"],
+          keys: ["context", "base_url", "timeout", "security_key"]
+        }
+      );
+    });
+    configCommand.command("set").argument("<key>", "Config key (base_url, timeout, security_key)").argument("<value>", "New value").description("Set a config value in active context").action((key, value) => {
+      const config = loadConfig();
+      const ctx = config.contexts[config.current_context];
+      if (!ctx) {
+        writeError(`Active context '${config.current_context}' not found.`);
+        process.exitCode = 1;
+        return;
+      }
+      switch (key) {
+        case "base_url":
+          ctx.baseUrl = value;
+          break;
+        case "timeout":
+          ctx.timeout = Number.parseFloat(value);
+          break;
+        case "security_key":
+          ctx.securityKey = value;
+          break;
+        default:
+          writeError(`Unknown config key '${key}'. Valid keys: base_url, timeout, security_key`);
+          process.exitCode = 1;
+          return;
+      }
+      saveConfig(config);
+      writeSuccess(
+        `Set ${key} to ${key === "security_key" ? maskKey(value) : value} in context '${config.current_context}'.`
+      );
+    });
+    configCommand.command("remove").argument("<name>", "Context to remove").description("Remove a context").action((name) => {
+      const config = loadConfig();
+      if (!config.contexts[name]) {
+        writeError(`Context '${name}' not found.`);
+        process.exitCode = 1;
+        return;
+      }
+      if (name === config.current_context) {
+        writeError(
+          `Cannot remove active context '${name}'. Switch to another context first with 'agno-cli config use <name>'.`
+        );
+        process.exitCode = 1;
+        return;
+      }
+      delete config.contexts[name];
+      saveConfig(config);
+      writeSuccess(`Context '${name}' removed.`);
+    });
+  }
+});
+
+// src/lib/client.ts
+import { AgentOSClient } from "@worksofadam/agentos-sdk";
+function getClient(cmd) {
+  if (_client) return _client;
+  const globals = cmd.optsWithGlobals();
+  const ctx = resolveContext({
+    contextName: globals.context,
+    urlOverride: globals.url,
+    keyOverride: globals.key,
+    timeoutOverride: globals.timeout
+  });
+  _client = new AgentOSClient({
+    baseUrl: ctx.baseUrl,
+    apiKey: ctx.securityKey,
+    timeout: ctx.timeout * 1e3
+    // seconds -> milliseconds
+  });
+  return _client;
+}
+function getBaseUrl(cmd) {
+  const globals = cmd.optsWithGlobals();
+  const ctx = resolveContext({
+    contextName: globals.context,
+    urlOverride: globals.url
+  });
+  return ctx.baseUrl;
+}
+var _client;
+var init_client = __esm({
+  "src/lib/client.ts"() {
+    "use strict";
+    init_config();
+    _client = null;
+  }
+});
+
+// src/commands/status.ts
+var status_exports = {};
+__export(status_exports, {
+  statusCommand: () => statusCommand
+});
+import { Command as Command2 } from "commander";
+var statusCommand;
+var init_status = __esm({
+  "src/commands/status.ts"() {
+    "use strict";
+    init_client();
+    init_errors();
+    init_output();
+    statusCommand = new Command2("status").description("Show AgentOS server status and resource counts").action(async (_options, cmd) => {
+      try {
+        const client = getClient(cmd);
+        const config = await client.getConfig();
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson(config);
+          return;
+        }
+        const display = {
+          os_id: config.os_id ?? "unknown"
+        };
+        const labels = ["OS ID"];
+        const keys = ["os_id"];
+        if (config.name) {
+          display.name = config.name;
+          labels.push("Name");
+          keys.push("name");
+        }
+        if (config.description) {
+          display.description = config.description;
+          labels.push("Description");
+          keys.push("description");
+        }
+        display.databases = Array.isArray(config.databases) ? config.databases.length : 0;
+        display.agents = Array.isArray(config.agents) ? config.agents.length : 0;
+        display.teams = Array.isArray(config.teams) ? config.teams.length : 0;
+        display.workflows = Array.isArray(config.workflows) ? config.workflows.length : 0;
+        labels.push("Databases", "Agents", "Teams", "Workflows");
+        keys.push("databases", "agents", "teams", "workflows");
+        outputDetail(cmd, display, { labels, keys });
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+  }
+});
+
+// src/lib/paused-runs.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, readdirSync, statSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+function writePausedRun(state) {
+  mkdirSync2(CACHE_DIR, { recursive: true, mode: 448 });
+  writeFileSync2(join2(CACHE_DIR, `${state.run_id}.json`), JSON.stringify(state, null, 2), { mode: 384 });
+}
+function readPausedRun(runId) {
+  cleanStalePausedRuns();
+  const filePath = join2(CACHE_DIR, `${runId}.json`);
+  if (!existsSync2(filePath)) return null;
+  return JSON.parse(readFileSync2(filePath, "utf-8"));
+}
+function deletePausedRun(runId) {
+  const filePath = join2(CACHE_DIR, `${runId}.json`);
+  if (!existsSync2(filePath)) return;
+  unlinkSync(filePath);
+}
+function cleanStalePausedRuns() {
+  if (!existsSync2(CACHE_DIR)) return;
+  const files = readdirSync(CACHE_DIR);
+  const now = Date.now();
+  for (const file of files) {
+    const filePath = join2(CACHE_DIR, file);
+    const stat = statSync(filePath);
+    if (now - stat.mtimeMs > MAX_AGE_MS) {
+      unlinkSync(filePath);
+    }
+  }
+}
+var CACHE_DIR, MAX_AGE_MS;
+var init_paused_runs = __esm({
+  "src/lib/paused-runs.ts"() {
+    "use strict";
+    init_config();
+    CACHE_DIR = join2(AGNO_CONFIG_DIR, "paused-runs");
+    MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+  }
+});
+
+// src/lib/stream.ts
+import chalk3 from "chalk";
+function formatContent(content) {
+  if (content == null) return "";
+  return typeof content === "string" ? content : JSON.stringify(content, null, 2);
+}
+function displayPausedToolInfo(tools, resourceId, runId) {
+  process.stderr.write(`
+${chalk3.yellow.bold("[Run Paused -- Tool requires confirmation]")}
+
+`);
+  for (const tool of tools) {
+    process.stderr.write(`  Tool:  ${chalk3.cyan(String(tool.tool_name ?? "unknown"))}
+`);
+    process.stderr.write(`  Args:  ${JSON.stringify(tool.tool_args ?? {})}
+`);
+    process.stderr.write(`  ID:    ${String(tool.tool_call_id ?? "unknown")}
+
+`);
+  }
+  process.stderr.write(
+    `To confirm: ${chalk3.green(`agno-cli agent continue ${resourceId} ${runId} --confirm --stream`)}
+`
+  );
+  process.stderr.write(
+    `To reject:  ${chalk3.red(`agno-cli agent continue ${resourceId} ${runId} --reject --stream`)}
+`
+  );
+}
+async function handleStreamRun(cmd, stream, resourceType, options) {
+  const format = getOutputFormat(cmd);
+  const contentEvent = CONTENT_EVENTS[resourceType];
+  const completedEvent = COMPLETED_EVENTS[resourceType];
+  const errorEvent = ERROR_EVENTS[resourceType];
+  const pausedEvent = PAUSED_EVENTS[resourceType];
+  const startedEvent = STARTED_EVENTS[resourceType];
+  const onSigint = () => {
+    stream.abort();
+  };
+  process.on("SIGINT", onSigint);
+  try {
+    if (format === "json") {
+      const events = [];
+      let jsonSessionId = null;
+      for await (const event of stream) {
+        events.push(event);
+        if (startedEvent && event.event === startedEvent) {
+          jsonSessionId = event.session_id ?? null;
+        }
+        if (pausedEvent && event.event === pausedEvent && options?.resourceId) {
+          const tools = event.tools;
+          const eventRunId = event.run_id;
+          if (tools && tools.length > 0) {
+            writePausedRun({
+              agent_id: options.resourceId,
+              run_id: eventRunId ?? "unknown",
+              session_id: jsonSessionId,
+              resource_type: resourceType,
+              paused_at: (/* @__PURE__ */ new Date()).toISOString(),
+              tools
+            });
+          }
+        }
+      }
+      process.stdout.write(`${JSON.stringify(events, null, 2)}
+`);
+    } else {
+      let metrics;
+      let sessionId = null;
+      let runId = null;
+      for await (const event of stream) {
+        if (event.event === errorEvent) {
+          const errorMsg = event.error ?? event.content ?? "Unknown stream error";
+          writeError(String(errorMsg));
+          process.exitCode = 2;
+        } else if (event.event === contentEvent) {
+          const content = event.content;
+          if (content != null) {
+            process.stdout.write(formatContent(content));
+          }
+        } else if (event.event === completedEvent) {
+          metrics = event.metrics;
+        } else if (event.event === startedEvent) {
+          sessionId = event.session_id ?? null;
+          runId = event.run_id ?? null;
+        } else if (pausedEvent && event.event === pausedEvent) {
+          const tools = event.tools;
+          const eventRunId = event.run_id ?? runId;
+          if (tools && tools.length > 0 && options?.resourceId) {
+            writePausedRun({
+              agent_id: options.resourceId,
+              run_id: eventRunId ?? "unknown",
+              session_id: sessionId,
+              resource_type: resourceType,
+              paused_at: (/* @__PURE__ */ new Date()).toISOString(),
+              tools
+            });
+            displayPausedToolInfo(tools, options.resourceId, eventRunId ?? "unknown");
+          }
+        }
+      }
+      process.stdout.write("\n");
+      if (metrics) {
+        printMetrics(metrics);
+      }
+    }
+  } finally {
+    process.removeListener("SIGINT", onSigint);
+  }
+}
+async function handleNonStreamRun(cmd, runFn, options) {
+  const format = getOutputFormat(cmd);
+  const ora = (await import("ora")).default;
+  const spinner = ora({ text: "Running...", stream: process.stderr }).start();
+  try {
+    const result = await runFn();
+    spinner.stop();
+    const resultObj = result;
+    const statusStr = typeof resultObj?.status === "string" ? resultObj.status.toLowerCase() : "";
+    const isPaused = resultObj?.is_paused === true || statusStr === "paused";
+    const tools = resultObj?.tools;
+    if (isPaused && tools && tools.length > 0 && options?.resourceId && options?.resourceType === "agent") {
+      const pausedRunId = resultObj?.run_id ?? "unknown";
+      const pausedSessionId = resultObj?.session_id ?? null;
+      writePausedRun({
+        agent_id: options.resourceId,
+        run_id: pausedRunId,
+        session_id: pausedSessionId,
+        resource_type: options.resourceType,
+        paused_at: (/* @__PURE__ */ new Date()).toISOString(),
+        tools
+      });
+      if (format !== "json") {
+        displayPausedToolInfo(tools, options.resourceId, pausedRunId);
+      }
+    }
+    if (format === "json") {
+      process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+    } else {
+      const content = result?.content;
+      if (content != null) {
+        process.stdout.write(`${formatContent(content)}
+`);
+      }
+      const metrics = result?.metrics;
+      if (metrics) {
+        printMetrics(metrics);
+      }
+    }
+  } catch (err) {
+    spinner.stop();
+    throw err;
+  }
+}
+function printMetrics(metrics) {
+  if (!metrics) return;
+  const parts = [];
+  const inputTokens = metrics.input_tokens;
+  const outputTokens = metrics.output_tokens;
+  const totalTokens = metrics.total_tokens;
+  const duration = metrics.duration;
+  if (inputTokens && outputTokens) {
+    parts.push(`tokens: ${inputTokens}/${outputTokens}`);
+  } else if (totalTokens) {
+    parts.push(`tokens: ${totalTokens}`);
+  }
+  if (duration) {
+    parts.push(`time: ${duration.toFixed(2)}s`);
+  }
+  if (parts.length > 0) {
+    process.stderr.write(`${chalk3.dim(`[${parts.join(", ")}]`)}
+`);
+  }
+}
+var CONTENT_EVENTS, COMPLETED_EVENTS, ERROR_EVENTS, PAUSED_EVENTS, STARTED_EVENTS;
+var init_stream = __esm({
+  "src/lib/stream.ts"() {
+    "use strict";
+    init_output();
+    init_paused_runs();
+    CONTENT_EVENTS = {
+      agent: "RunContent",
+      team: "TeamRunContent",
+      workflow: "StepOutput"
+    };
+    COMPLETED_EVENTS = {
+      agent: "RunCompleted",
+      team: "TeamRunCompleted",
+      workflow: "WorkflowCompleted"
+    };
+    ERROR_EVENTS = {
+      agent: "RunError",
+      team: "TeamRunError",
+      workflow: "WorkflowCancelled"
+    };
+    PAUSED_EVENTS = {
+      agent: "RunPaused"
+    };
+    STARTED_EVENTS = {
+      agent: "RunStarted",
+      team: "TeamRunStarted",
+      workflow: "WorkflowStarted"
+    };
+  }
+});
+
+// src/commands/agents.ts
+var agents_exports = {};
+__export(agents_exports, {
+  agentCommand: () => agentCommand
+});
+import { Command as Command3 } from "commander";
+function buildConfirmPayload(tools) {
+  const confirmed = tools.map((tool) => ({
+    ...tool,
+    confirmed: true
+  }));
+  return JSON.stringify(confirmed);
+}
+function buildRejectPayload(tools, note) {
+  const rejected = tools.map((tool) => ({
+    ...tool,
+    confirmed: false,
+    confirmation_note: note ?? "Rejected via CLI"
+  }));
+  return JSON.stringify(rejected);
+}
+var agentCommand;
+var init_agents = __esm({
+  "src/commands/agents.ts"() {
+    "use strict";
+    init_client();
+    init_errors();
+    init_output();
+    init_paused_runs();
+    init_stream();
+    agentCommand = new Command3("agent").description("Manage agents");
+    agentCommand.command("list").description("List all agents").option("--limit <n>", "Results per page", (v) => Number.parseInt(v, 10), 20).option("--page <n>", "Page number", (v) => Number.parseInt(v, 10), 1).action(async (_options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        const agents = await client.agents.list();
+        const limit = opts.limit;
+        const page = opts.page;
+        const start = (page - 1) * limit;
+        const paged = agents.slice(start, start + limit);
+        const meta = {
+          page,
+          limit,
+          total_pages: Math.ceil(agents.length / limit),
+          total_count: agents.length
+        };
+        outputList(
+          cmd,
+          paged.map((a) => ({
+            id: a.id ?? "",
+            name: a.name ?? "",
+            description: a.description ?? ""
+          })),
+          {
+            columns: ["ID", "NAME", "DESCRIPTION"],
+            keys: ["id", "name", "description"],
+            meta
+          }
+        );
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    agentCommand.command("get").argument("<agent_id>", "Agent ID").description("Get agent details").action(async (agentId, _options, cmd) => {
+      try {
+        const client = getClient(cmd);
+        const agent = await client.agents.get(agentId);
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          outputDetail(cmd, agent, { labels: [], keys: [] });
+          return;
+        }
+        const modelDisplay = agent.model?.model ?? agent.model?.name ?? "N/A";
+        outputDetail(
+          cmd,
+          {
+            id: agent.id ?? "",
+            name: agent.name ?? "",
+            description: agent.description ?? "",
+            model: modelDisplay
+          },
+          {
+            labels: ["ID", "Name", "Description", "Model"],
+            keys: ["id", "name", "description", "model"]
+          }
+        );
+      } catch (err) {
+        handleError(err, { resource: "Agent", url: getBaseUrl(cmd) });
+      }
+    });
+    agentCommand.command("run").argument("<agent_id>", "Agent ID").argument("<message>", "Message to send to the agent").description("Run an agent with a message").option("-s, --stream", "Stream the response via SSE").option("--session-id <id>", "Session ID for conversation context").option("--user-id <id>", "User ID for personalization").action(async (agentId, message, options, cmd) => {
+      try {
+        const client = getClient(cmd);
+        if (options.stream) {
+          const stream = await client.agents.runStream(agentId, {
+            message,
+            sessionId: options.sessionId,
+            userId: options.userId
+          });
+          await handleStreamRun(cmd, stream, "agent", { resourceId: agentId });
+        } else {
+          await handleNonStreamRun(
+            cmd,
+            () => client.agents.run(agentId, {
+              message,
+              sessionId: options.sessionId,
+              userId: options.userId
+            }),
+            { resourceType: "agent", resourceId: agentId }
+          );
+        }
+      } catch (err) {
+        handleError(err, { resource: "Agent", url: getBaseUrl(cmd) });
+      }
+    });
+    agentCommand.command("continue").argument("<agent_id>", "Agent ID").argument("<run_id>", "Run ID to continue").argument("[tool_results]", "Tool results JSON (optional when using --confirm or --reject)").description("Continue an agent run").option("-s, --stream", "Stream the response via SSE").option("--confirm", "Confirm the paused tool call (auto-reconstruct payload from cache)").option("--reject [note]", "Reject the paused tool call with optional note").option("--session-id <id>", "Session ID").option("--user-id <id>", "User ID").action(async (agentId, runId, toolResults, options, cmd) => {
+      try {
+        const client = getClient(cmd);
+        let tools;
+        let sessionId = options.sessionId;
+        if (options.confirm) {
+          const cached = readPausedRun(runId);
+          if (!cached) {
+            writeError(`No cached paused state for run ${runId}. Provide tool results JSON directly or re-run the agent with --stream to capture the paused state.`);
+            process.exitCode = 1;
+            return;
+          }
+          tools = buildConfirmPayload(cached.tools);
+          if (!sessionId && cached.session_id) {
+            sessionId = cached.session_id;
+          }
+        } else if (options.reject !== void 0) {
+          const cached = readPausedRun(runId);
+          if (!cached) {
+            writeError(`No cached paused state for run ${runId}. Provide tool results JSON directly or re-run the agent with --stream to capture the paused state.`);
+            process.exitCode = 1;
+            return;
+          }
+          const note = typeof options.reject === "string" ? options.reject : void 0;
+          tools = buildRejectPayload(cached.tools, note);
+          if (!sessionId && cached.session_id) {
+            sessionId = cached.session_id;
+          }
+        } else if (toolResults) {
+          tools = toolResults;
+        } else {
+          writeError("Provide tool results JSON, or use --confirm/--reject for a paused tool call.");
+          process.exitCode = 1;
+          return;
+        }
+        if (options.stream) {
+          const stream = await client.agents.continue(agentId, runId, {
+            tools,
+            sessionId,
+            userId: options.userId,
+            stream: true
+          });
+          await handleStreamRun(cmd, stream, "agent", { resourceId: agentId });
+        } else {
+          const result = await client.agents.continue(agentId, runId, {
+            tools,
+            sessionId,
+            userId: options.userId,
+            stream: false
+          });
+          const format = getOutputFormat(cmd);
+          if (format === "json") {
+            process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+          } else {
+            const content = result.content;
+            if (content) {
+              process.stdout.write(`${typeof content === "string" ? content : JSON.stringify(content, null, 2)}
+`);
+            }
+          }
+        }
+        if (options.confirm || options.reject !== void 0) {
+          deletePausedRun(runId);
+        }
+      } catch (err) {
+        handleError(err, { resource: "Agent", url: getBaseUrl(cmd) });
+      }
+    });
+    agentCommand.command("cancel").argument("<agent_id>", "Agent ID").argument("<run_id>", "Run ID to cancel").description("Cancel an in-progress agent run").action(async (agentId, runId, _options, cmd) => {
+      try {
+        const client = getClient(cmd);
+        await client.agents.cancel(agentId, runId);
+        writeSuccess(`Cancelled run ${runId} for agent ${agentId}`);
+      } catch (err) {
+        handleError(err, { resource: "Agent", url: getBaseUrl(cmd) });
+      }
+    });
+  }
+});
+
+// src/commands/teams.ts
+var teams_exports = {};
+__export(teams_exports, {
+  teamCommand: () => teamCommand
+});
+import { Command as Command4 } from "commander";
+var teamCommand;
+var init_teams = __esm({
+  "src/commands/teams.ts"() {
+    "use strict";
+    init_client();
+    init_errors();
+    init_output();
+    init_stream();
+    teamCommand = new Command4("team").description("Manage teams");
+    teamCommand.command("list").description("List all teams").option("--limit <n>", "Results per page", (v) => Number.parseInt(v, 10), 20).option("--page <n>", "Page number", (v) => Number.parseInt(v, 10), 1).action(async (_options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        const teams = await client.teams.list();
+        const limit = opts.limit;
+        const page = opts.page;
+        const start = (page - 1) * limit;
+        const paged = teams.slice(start, start + limit);
+        const meta = {
+          page,
+          limit,
+          total_pages: Math.ceil(teams.length / limit),
+          total_count: teams.length
+        };
+        outputList(
+          cmd,
+          paged.map((t) => ({
+            id: t.id ?? "",
+            name: t.name ?? "",
+            mode: t.mode ?? "",
+            description: t.description ?? ""
+          })),
+          {
+            columns: ["ID", "NAME", "MODE", "DESCRIPTION"],
+            keys: ["id", "name", "mode", "description"],
+            meta
+          }
+        );
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    teamCommand.command("get").argument("<team_id>", "Team ID").description("Get team details").action(async (teamId, _options, cmd) => {
+      try {
+        const client = getClient(cmd);
+        const team = await client.teams.get(teamId);
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          outputDetail(cmd, team, { labels: [], keys: [] });
+          return;
+        }
+        const modelDisplay = team.model?.model ?? team.model?.name ?? "N/A";
+        outputDetail(
+          cmd,
+          {
+            id: team.id ?? "",
+            name: team.name ?? "",
+            mode: team.mode ?? "",
+            description: team.description ?? "",
+            model: modelDisplay
+          },
+          {
+            labels: ["ID", "Name", "Mode", "Description", "Model"],
+            keys: ["id", "name", "mode", "description", "model"]
+          }
+        );
+      } catch (err) {
+        handleError(err, { resource: "Team", url: getBaseUrl(cmd) });
+      }
+    });
+    teamCommand.command("run").argument("<team_id>", "Team ID").argument("<message>", "Message to send to the team").description("Run a team with a message").option("-s, --stream", "Stream the response via SSE").option("--session-id <id>", "Session ID for conversation context").option("--user-id <id>", "User ID for personalization").action(async (teamId, message, options, cmd) => {
+      try {
+        const client = getClient(cmd);
+        if (options.stream) {
+          const stream = await client.teams.runStream(teamId, {
+            message,
+            sessionId: options.sessionId,
+            userId: options.userId
+          });
+          await handleStreamRun(cmd, stream, "team", { resourceId: teamId });
+        } else {
+          await handleNonStreamRun(
+            cmd,
+            () => client.teams.run(teamId, {
+              message,
+              sessionId: options.sessionId,
+              userId: options.userId
+            }),
+            { resourceType: "team", resourceId: teamId }
+          );
+        }
+      } catch (err) {
+        handleError(err, { resource: "Team", url: getBaseUrl(cmd) });
+      }
+    });
+    teamCommand.command("continue").argument("<team_id>", "Team ID").argument("<run_id>", "Run ID to continue").argument("<message>", "Message to continue with").description("Continue a team run").option("-s, --stream", "Stream the response via SSE").option("--session-id <id>", "Session ID").option("--user-id <id>", "User ID").action(async (teamId, runId, message, options, cmd) => {
+      try {
+        const client = getClient(cmd);
+        if (options.stream) {
+          const stream = await client.teams.continue(teamId, runId, {
+            tools: message,
+            sessionId: options.sessionId,
+            userId: options.userId,
+            stream: true
+          });
+          await handleStreamRun(cmd, stream, "team", { resourceId: teamId });
+        } else {
+          const result = await client.teams.continue(teamId, runId, {
+            tools: message,
+            sessionId: options.sessionId,
+            userId: options.userId,
+            stream: false
+          });
+          const format = getOutputFormat(cmd);
+          if (format === "json") {
+            process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+          } else {
+            const content = result.content;
+            if (content) {
+              process.stdout.write(`${typeof content === "string" ? content : JSON.stringify(content, null, 2)}
+`);
+            }
+          }
+        }
+      } catch (err) {
+        handleError(err, { resource: "Team", url: getBaseUrl(cmd) });
+      }
+    });
+    teamCommand.command("cancel").argument("<team_id>", "Team ID").argument("<run_id>", "Run ID to cancel").description("Cancel an in-progress team run").action(async (teamId, runId, _options, cmd) => {
+      try {
+        const client = getClient(cmd);
+        await client.teams.cancel(teamId, runId);
+        writeSuccess(`Cancelled run ${runId} for team ${teamId}`);
+      } catch (err) {
+        handleError(err, { resource: "Team", url: getBaseUrl(cmd) });
+      }
+    });
+  }
+});
+
+// src/commands/workflows.ts
+var workflows_exports = {};
+__export(workflows_exports, {
+  workflowCommand: () => workflowCommand
+});
+import { Command as Command5 } from "commander";
+var workflowCommand;
+var init_workflows = __esm({
+  "src/commands/workflows.ts"() {
+    "use strict";
+    init_client();
+    init_errors();
+    init_output();
+    init_stream();
+    workflowCommand = new Command5("workflow").description("Manage workflows");
+    workflowCommand.command("list").description("List all workflows").option("--limit <n>", "Results per page", (v) => Number.parseInt(v, 10), 20).option("--page <n>", "Page number", (v) => Number.parseInt(v, 10), 1).action(async (_options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        const workflows = await client.workflows.list();
+        const limit = opts.limit;
+        const page = opts.page;
+        const start = (page - 1) * limit;
+        const paged = workflows.slice(start, start + limit);
+        const meta = {
+          page,
+          limit,
+          total_pages: Math.ceil(workflows.length / limit),
+          total_count: workflows.length
+        };
+        outputList(
+          cmd,
+          paged.map((w) => ({
+            id: w.id ?? "",
+            name: w.name ?? "",
+            description: w.description ?? ""
+          })),
+          {
+            columns: ["ID", "NAME", "DESCRIPTION"],
+            keys: ["id", "name", "description"],
+            meta
+          }
+        );
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    workflowCommand.command("get").argument("<workflow_id>", "Workflow ID").description("Get workflow details").action(async (workflowId, _options, cmd) => {
+      try {
+        const client = getClient(cmd);
+        const workflow = await client.workflows.get(workflowId);
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          outputDetail(cmd, workflow, { labels: [], keys: [] });
+          return;
+        }
+        outputDetail(
+          cmd,
+          {
+            id: workflow.id ?? "",
+            name: workflow.name ?? "",
+            description: workflow.description ?? "",
+            steps: Array.isArray(workflow.steps) ? workflow.steps.length : 0,
+            workflow_agent: workflow.workflow_agent ? "Yes" : "No"
+          },
+          {
+            labels: ["ID", "Name", "Description", "Steps", "Workflow Agent"],
+            keys: ["id", "name", "description", "steps", "workflow_agent"]
+          }
+        );
+      } catch (err) {
+        handleError(err, { resource: "Workflow", url: getBaseUrl(cmd) });
+      }
+    });
+    workflowCommand.command("run").argument("<workflow_id>", "Workflow ID").argument("<message>", "Message to send to the workflow").description("Run a workflow with a message").option("-s, --stream", "Stream the response via SSE").option("--session-id <id>", "Session ID for conversation context").option("--user-id <id>", "User ID for personalization").action(async (workflowId, message, options, cmd) => {
+      try {
+        const client = getClient(cmd);
+        if (options.stream) {
+          const stream = await client.workflows.runStream(workflowId, {
+            message,
+            sessionId: options.sessionId,
+            userId: options.userId
+          });
+          await handleStreamRun(cmd, stream, "workflow", { resourceId: workflowId });
+        } else {
+          await handleNonStreamRun(
+            cmd,
+            () => client.workflows.run(workflowId, {
+              message,
+              sessionId: options.sessionId,
+              userId: options.userId
+            }),
+            { resourceType: "workflow", resourceId: workflowId }
+          );
+        }
+      } catch (err) {
+        handleError(err, { resource: "Workflow", url: getBaseUrl(cmd) });
+      }
+    });
+    workflowCommand.command("continue").argument("<workflow_id>", "Workflow ID").argument("<run_id>", "Run ID to continue").argument("<message>", "Message to continue with").description("Continue a workflow run").option("-s, --stream", "Stream the response via SSE").option("--session-id <id>", "Session ID").option("--user-id <id>", "User ID").action(async (workflowId, runId, message, options, cmd) => {
+      try {
+        const client = getClient(cmd);
+        if (options.stream) {
+          const stream = await client.workflows.continue(workflowId, runId, {
+            tools: message,
+            sessionId: options.sessionId,
+            userId: options.userId,
+            stream: true
+          });
+          await handleStreamRun(cmd, stream, "workflow", { resourceId: workflowId });
+        } else {
+          const result = await client.workflows.continue(workflowId, runId, {
+            tools: message,
+            sessionId: options.sessionId,
+            userId: options.userId,
+            stream: false
+          });
+          const format = getOutputFormat(cmd);
+          if (format === "json") {
+            process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+          } else {
+            const content = result.content;
+            if (content) {
+              process.stdout.write(`${typeof content === "string" ? content : JSON.stringify(content, null, 2)}
+`);
+            }
+          }
+        }
+      } catch (err) {
+        handleError(err, { resource: "Workflow", url: getBaseUrl(cmd) });
+      }
+    });
+    workflowCommand.command("cancel").argument("<workflow_id>", "Workflow ID").argument("<run_id>", "Run ID to cancel").description("Cancel an in-progress workflow run").action(async (workflowId, runId, _options, cmd) => {
+      try {
+        const client = getClient(cmd);
+        await client.workflows.cancel(workflowId, runId);
+        writeSuccess(`Cancelled run ${runId} for workflow ${workflowId}`);
+      } catch (err) {
+        handleError(err, { resource: "Workflow", url: getBaseUrl(cmd) });
+      }
+    });
+  }
+});
+
+// src/commands/models.ts
+var models_exports = {};
+__export(models_exports, {
+  modelCommand: () => modelCommand
+});
+import { Command as Command6 } from "commander";
+var modelCommand;
+var init_models = __esm({
+  "src/commands/models.ts"() {
+    "use strict";
+    init_client();
+    init_errors();
+    init_output();
+    modelCommand = new Command6("models").description("List available models");
+    modelCommand.command("list").description("List all available models").option("--limit <n>", "Results per page", (v) => Number.parseInt(v, 10), 20).option("--page <n>", "Page number", (v) => Number.parseInt(v, 10), 1).action(async (_options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        const models = await client.models.list();
+        const limit = opts.limit;
+        const page = opts.page;
+        const start = (page - 1) * limit;
+        const paged = models.slice(start, start + limit);
+        const meta = {
+          page,
+          limit,
+          total_pages: Math.ceil(models.length / limit),
+          total_count: models.length
+        };
+        outputList(
+          cmd,
+          paged.map((m) => ({
+            id: m.id ?? "",
+            provider: m.provider ?? ""
+          })),
+          {
+            columns: ["ID", "PROVIDER"],
+            keys: ["id", "provider"],
+            meta
+          }
+        );
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+  }
+});
+
+// src/commands/metrics.ts
+var metrics_exports = {};
+__export(metrics_exports, {
+  metricsCommand: () => metricsCommand
+});
+import { Command as Command7 } from "commander";
+var metricsCommand;
+var init_metrics = __esm({
+  "src/commands/metrics.ts"() {
+    "use strict";
+    init_client();
+    init_errors();
+    init_output();
+    metricsCommand = new Command7("metrics").description("View and refresh metrics");
+    metricsCommand.command("get").description("Get aggregated metrics").option("--start-date <date>", "Start date (YYYY-MM-DD)").option("--end-date <date>", "End date (YYYY-MM-DD)").option("--db-id <id>", "Database ID").action(async (_options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        const response = await client.metrics.get({
+          startingDate: opts.startDate,
+          endingDate: opts.endDate,
+          dbId: opts.dbId
+        });
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson(response);
+          return;
+        }
+        const metrics = response.metrics ?? [];
+        outputList(
+          cmd,
+          metrics.map((m) => ({
+            date: m.date ?? "",
+            agent_runs_count: m.agent_runs_count ?? 0,
+            team_runs_count: m.team_runs_count ?? 0,
+            workflow_runs_count: m.workflow_runs_count ?? 0,
+            users_count: m.users_count ?? 0
+          })),
+          {
+            columns: ["DATE", "AGENT_RUNS", "TEAM_RUNS", "WORKFLOW_RUNS", "USERS"],
+            keys: ["date", "agent_runs_count", "team_runs_count", "workflow_runs_count", "users_count"]
+          }
+        );
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    metricsCommand.command("refresh").description("Trigger metrics refresh").option("--db-id <id>", "Database ID").action(async (_options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        await client.metrics.refresh({ dbId: opts.dbId });
+        writeSuccess("Metrics refresh triggered.");
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+  }
+});
+
+// src/commands/sessions.ts
+var sessions_exports = {};
+__export(sessions_exports, {
+  sessionCommand: () => sessionCommand
+});
+import { Command as Command8 } from "commander";
+var sessionCommand;
+var init_sessions = __esm({
+  "src/commands/sessions.ts"() {
+    "use strict";
+    init_client();
+    init_errors();
+    init_output();
+    sessionCommand = new Command8("session").description("Manage sessions");
+    sessionCommand.command("list").description("List sessions").option("--type <type>", "Filter by type (agent, team, workflow)").option("--component-id <id>", "Filter by component ID").option("--user-id <id>", "Filter by user ID").option("--limit <n>", "Results per page", (v) => Number.parseInt(v, 10), 20).option("--page <n>", "Page number", (v) => Number.parseInt(v, 10), 1).option("--sort-by <field>", "Sort field").option("--sort-order <order>", "Sort order (asc, desc)").option("--db-id <id>", "Database ID").action(async (_options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        const result = await client.sessions.list({
+          type: opts.type,
+          componentId: opts.componentId,
+          userId: opts.userId,
+          page: opts.page,
+          limit: opts.limit,
+          sortBy: opts.sortBy,
+          sortOrder: opts.sortOrder,
+          dbId: opts.dbId
+        });
+        const data = result.data;
+        const meta = result.meta;
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson({ data, meta });
+          return;
+        }
+        outputList(
+          cmd,
+          data.map((s) => ({
+            session_id: s.session_id ?? "",
+            name: s.session_name ?? "",
+            type: s.type ?? "",
+            created_at: s.created_at ?? ""
+          })),
+          {
+            columns: ["SESSION_ID", "NAME", "TYPE", "CREATED_AT"],
+            keys: ["session_id", "name", "type", "created_at"],
+            meta
+          }
+        );
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    sessionCommand.command("get").argument("<session_id>", "Session ID").description("Get session details").option("--db-id <id>", "Database ID").action(async (sessionId, _options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        const session = await client.sessions.get(sessionId, { dbId: opts.dbId });
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          outputDetail(cmd, session, { labels: [], keys: [] });
+          return;
+        }
+        const s = session;
+        outputDetail(
+          cmd,
+          {
+            session_id: s.session_id ?? "",
+            name: s.session_name ?? "",
+            type: s.type ?? "",
+            state: s.session_state ? JSON.stringify(s.session_state) : "",
+            created_at: s.created_at ?? "",
+            updated_at: s.updated_at ?? ""
+          },
+          {
+            labels: ["Session ID", "Name", "Type", "State", "Created At", "Updated At"],
+            keys: ["session_id", "name", "type", "state", "created_at", "updated_at"]
+          }
+        );
+      } catch (err) {
+        handleError(err, { resource: "Session", url: getBaseUrl(cmd) });
+      }
+    });
+    sessionCommand.command("create").description("Create a new session").requiredOption("--type <type>", "Session type: agent, team, workflow (required)").requiredOption("--component-id <id>", "Component ID (required)").option("--name <name>", "Session name").option("--user-id <id>", "User ID").option("--db-id <id>", "Database ID").action(async (_options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        const session = await client.sessions.create({
+          type: opts.type,
+          componentId: opts.componentId,
+          name: opts.name,
+          userId: opts.userId,
+          dbId: opts.dbId
+        });
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson(session);
+          return;
+        }
+        const s = session;
+        outputDetail(
+          cmd,
+          {
+            session_id: s.session_id ?? "",
+            name: s.session_name ?? "",
+            type: s.type ?? "",
+            created_at: s.created_at ?? ""
+          },
+          {
+            labels: ["Session ID", "Name", "Type", "Created At"],
+            keys: ["session_id", "name", "type", "created_at"]
+          }
+        );
+        writeSuccess("Session created.");
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    sessionCommand.command("update").argument("<session_id>", "Session ID").description("Update a session").option("--name <name>", "New session name").option("--state <json>", "Session state as JSON string").option("--metadata <json>", "Metadata as JSON string").option("--summary <text>", "Session summary").option("--db-id <id>", "Database ID").action(async (sessionId, _options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        let parsedState;
+        if (opts.state) {
+          try {
+            parsedState = JSON.parse(opts.state);
+          } catch {
+            writeError("Invalid JSON for --state");
+            process.exitCode = 1;
+            return;
+          }
+        }
+        let parsedMetadata;
+        if (opts.metadata) {
+          try {
+            parsedMetadata = JSON.parse(opts.metadata);
+          } catch {
+            writeError("Invalid JSON for --metadata");
+            process.exitCode = 1;
+            return;
+          }
+        }
+        const client = getClient(cmd);
+        await client.sessions.update(sessionId, {
+          sessionName: opts.name,
+          sessionState: parsedState,
+          metadata: parsedMetadata,
+          summary: opts.summary,
+          dbId: opts.dbId
+        });
+        writeSuccess("Session updated.");
+      } catch (err) {
+        handleError(err, { resource: "Session", url: getBaseUrl(cmd) });
+      }
+    });
+    sessionCommand.command("delete").argument("<session_id>", "Session ID").description("Delete a session").option("--db-id <id>", "Database ID").action(async (sessionId, _options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        await client.sessions.delete(sessionId, { dbId: opts.dbId });
+        writeSuccess("Session deleted.");
+      } catch (err) {
+        handleError(err, { resource: "Session", url: getBaseUrl(cmd) });
+      }
+    });
+    sessionCommand.command("delete-all").description("Delete multiple sessions").requiredOption("--ids <ids>", "Comma-separated session IDs (required)").requiredOption("--types <types>", "Comma-separated session types, must match IDs (required)").option("--user-id <id>", "User ID").option("--db-id <id>", "Database ID").action(async (_options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const sessionIds = opts.ids.split(",").map((s) => s.trim());
+        const sessionTypes = opts.types.split(",").map((s) => s.trim());
+        const client = getClient(cmd);
+        await client.sessions.deleteAll({
+          sessionIds,
+          sessionTypes,
+          userId: opts.userId,
+          dbId: opts.dbId
+        });
+        writeSuccess("Sessions deleted.");
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    sessionCommand.command("runs").argument("<session_id>", "Session ID").description("List runs for a session").option("--db-id <id>", "Database ID").action(async (sessionId, _options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        const runs = await client.sessions.getRuns(sessionId, { dbId: opts.dbId });
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson({ data: runs });
+          return;
+        }
+        const data = runs.map((r) => ({
+          run_id: r.run_id ?? "",
+          status: r.status ?? "",
+          created_at: r.created_at ?? ""
+        }));
+        outputList(cmd, data, {
+          columns: ["RUN_ID", "STATUS", "CREATED_AT"],
+          keys: ["run_id", "status", "created_at"]
+        });
+      } catch (err) {
+        handleError(err, { resource: "Session", url: getBaseUrl(cmd) });
+      }
+    });
+  }
+});
+
+// src/commands/memories.ts
+var memories_exports = {};
+__export(memories_exports, {
+  memoryCommand: () => memoryCommand
+});
+import { Command as Command9 } from "commander";
+var memoryCommand;
+var init_memories = __esm({
+  "src/commands/memories.ts"() {
+    "use strict";
+    init_client();
+    init_errors();
+    init_output();
+    memoryCommand = new Command9("memory").description("Manage memories");
+    memoryCommand.command("list").description("List memories").option("--user-id <id>", "Filter by user ID").option("--team-id <id>", "Filter by team ID").option("--agent-id <id>", "Filter by agent ID").option("--search <content>", "Search within memory content").option("--topics <topics>", "Comma-separated topics to filter by").option("--limit <n>", "Results per page", (v) => Number.parseInt(v, 10), 20).option("--page <n>", "Page number", (v) => Number.parseInt(v, 10), 1).option("--sort-by <field>", "Sort field").option("--sort-order <order>", "Sort order (asc, desc)").option("--db-id <id>", "Database ID").action(async (_options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const parsedTopics = opts.topics ? opts.topics.split(",").map((t) => t.trim()) : void 0;
+        const client = getClient(cmd);
+        const result = await client.memories.list({
+          userId: opts.userId,
+          teamId: opts.teamId,
+          agentId: opts.agentId,
+          searchContent: opts.search,
+          topics: parsedTopics,
+          page: opts.page,
+          limit: opts.limit,
+          sortBy: opts.sortBy,
+          sortOrder: opts.sortOrder,
+          dbId: opts.dbId
+        });
+        const data = result.data;
+        const meta = result.meta;
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson({ data, meta });
+          return;
+        }
+        outputList(
+          cmd,
+          data.map((m) => ({
+            memory_id: m.memory_id ?? "",
+            memory: m.memory ?? "",
+            topics: Array.isArray(m.topics) ? m.topics.join(", ") : "",
+            user_id: m.user_id ?? ""
+          })),
+          {
+            columns: ["ID", "MEMORY", "TOPICS", "USER_ID"],
+            keys: ["memory_id", "memory", "topics", "user_id"],
+            meta
+          }
+        );
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    memoryCommand.command("get").argument("<memory_id>", "Memory ID").description("Get memory details").option("--db-id <id>", "Database ID").action(async (memoryId, _options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        const memory = await client.memories.get(memoryId, { dbId: opts.dbId });
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          outputDetail(cmd, memory, { labels: [], keys: [] });
+          return;
+        }
+        const m = memory;
+        outputDetail(
+          cmd,
+          {
+            memory_id: m.memory_id ?? "",
+            memory: m.memory ?? "",
+            topics: Array.isArray(m.topics) ? m.topics.join(", ") : "",
+            agent_id: m.agent_id ?? "",
+            team_id: m.team_id ?? "",
+            user_id: m.user_id ?? "",
+            updated_at: m.updated_at ?? ""
+          },
+          {
+            labels: ["Memory ID", "Memory", "Topics", "Agent ID", "Team ID", "User ID", "Updated At"],
+            keys: ["memory_id", "memory", "topics", "agent_id", "team_id", "user_id", "updated_at"]
+          }
+        );
+      } catch (err) {
+        handleError(err, { resource: "Memory", url: getBaseUrl(cmd) });
+      }
+    });
+    memoryCommand.command("create").description("Create a new memory").requiredOption("--memory <content>", "Memory content (required)").option("--topics <topics>", "Comma-separated topics").option("--user-id <id>", "User ID").option("--db-id <id>", "Database ID").action(async (_options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const parsedTopics = opts.topics ? opts.topics.split(",").map((t) => t.trim()) : void 0;
+        const client = getClient(cmd);
+        const memory = await client.memories.create({
+          memory: opts.memory,
+          topics: parsedTopics,
+          userId: opts.userId,
+          dbId: opts.dbId
+        });
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson(memory);
+          return;
+        }
+        const m = memory;
+        outputDetail(
+          cmd,
+          {
+            memory_id: m.memory_id ?? "",
+            memory: m.memory ?? "",
+            topics: Array.isArray(m.topics) ? m.topics.join(", ") : "",
+            user_id: m.user_id ?? ""
+          },
+          {
+            labels: ["Memory ID", "Memory", "Topics", "User ID"],
+            keys: ["memory_id", "memory", "topics", "user_id"]
+          }
+        );
+        writeSuccess("Memory created.");
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    memoryCommand.command("update").argument("<memory_id>", "Memory ID").description("Update a memory").option("--memory <content>", "New memory content").option("--topics <topics>", "Comma-separated topics").option("--db-id <id>", "Database ID").action(async (memoryId, _options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const parsedTopics = opts.topics ? opts.topics.split(",").map((t) => t.trim()) : void 0;
+        const client = getClient(cmd);
+        await client.memories.update(memoryId, {
+          memory: opts.memory,
+          topics: parsedTopics,
+          dbId: opts.dbId
+        });
+        writeSuccess("Memory updated.");
+      } catch (err) {
+        handleError(err, { resource: "Memory", url: getBaseUrl(cmd) });
+      }
+    });
+    memoryCommand.command("delete").argument("<memory_id>", "Memory ID").description("Delete a memory").option("--db-id <id>", "Database ID").action(async (memoryId, _options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        await client.memories.delete(memoryId, { dbId: opts.dbId });
+        writeSuccess("Memory deleted.");
+      } catch (err) {
+        handleError(err, { resource: "Memory", url: getBaseUrl(cmd) });
+      }
+    });
+    memoryCommand.command("delete-all").description("Delete multiple memories").requiredOption("--ids <ids>", "Comma-separated memory IDs (required)").option("--user-id <id>", "User ID").option("--db-id <id>", "Database ID").action(async (_options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const memoryIds = opts.ids.split(",").map((s) => s.trim());
+        const client = getClient(cmd);
+        await client.memories.deleteAll({
+          memoryIds,
+          userId: opts.userId,
+          dbId: opts.dbId
+        });
+        writeSuccess("Memories deleted.");
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    memoryCommand.command("topics").description("List memory topics").option("--user-id <id>", "Filter by user ID").option("--db-id <id>", "Database ID").action(async (_options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        const result = await client.memories.getTopics({
+          userId: opts.userId,
+          dbId: opts.dbId
+        });
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson(result);
+          return;
+        }
+        if (Array.isArray(result)) {
+          outputList(
+            cmd,
+            result.map((t) => ({ topic: String(t) })),
+            {
+              columns: ["TOPIC"],
+              keys: ["topic"]
+            }
+          );
+        } else {
+          printJson(result);
+        }
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    memoryCommand.command("stats").description("Get memory statistics").option("--user-id <id>", "Filter by user ID").option("--limit <n>", "Results per page", (v) => Number.parseInt(v, 10)).option("--page <n>", "Page number", (v) => Number.parseInt(v, 10)).option("--db-id <id>", "Database ID").action(async (_options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        const result = await client.memories.getStats({
+          userId: opts.userId,
+          limit: opts.limit,
+          page: opts.page,
+          dbId: opts.dbId
+        });
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson(result);
+          return;
+        }
+        if (Array.isArray(result)) {
+          outputList(
+            cmd,
+            result.map((s) => {
+              const stat = s;
+              return {
+                user_id: stat.user_id ?? "",
+                total_memories: stat.total_memories ?? "",
+                last_updated: stat.last_updated ?? ""
+              };
+            }),
+            {
+              columns: ["USER_ID", "TOTAL_MEMORIES", "LAST_UPDATED"],
+              keys: ["user_id", "total_memories", "last_updated"]
+            }
+          );
+        } else {
+          printJson(result);
+        }
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    memoryCommand.command("optimize").description("Optimize memories for a user").requiredOption("--user-id <id>", "User ID (required)").option("--model <model>", "Model to use for optimization").option("--apply", "Apply optimizations immediately").option("--db-id <id>", "Database ID").action(async (_options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        const result = await client.memories.optimize({
+          userId: opts.userId,
+          model: opts.model,
+          apply: opts.apply,
+          dbId: opts.dbId
+        });
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson(result);
+          return;
+        }
+        writeSuccess(`Memory optimization ${opts.apply ? "applied" : "previewed"}.`);
+        printJson(result);
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+  }
+});
+
+// src/commands/knowledge.ts
+var knowledge_exports = {};
+__export(knowledge_exports, {
+  knowledgeCommand: () => knowledgeCommand
+});
+import { existsSync as existsSync3 } from "fs";
+import { resolve } from "path";
+import { Command as Command10 } from "commander";
+var knowledgeCommand;
+var init_knowledge = __esm({
+  "src/commands/knowledge.ts"() {
+    "use strict";
+    init_client();
+    init_errors();
+    init_output();
+    knowledgeCommand = new Command10("knowledge").description("Manage knowledge base");
+    knowledgeCommand.command("upload").argument("[file_path]", "Local file path to upload").description("Upload content to knowledge base").option("--url <url>", "Upload from URL instead of file").option("--name <name>", "Content name").option("--description <desc>", "Content description").option("--db-id <id>", "Database ID").option("--knowledge-id <id>", "Knowledge base ID").action(async (filePath, _options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        if (!filePath && !opts.url) {
+          writeError("Provide a file path or --url");
+          process.exitCode = 1;
+          return;
+        }
+        if (filePath && opts.url) {
+          writeError("Provide either a file path or --url, not both");
+          process.exitCode = 1;
+          return;
+        }
+        const uploadOpts = {
+          name: opts.name,
+          description: opts.description,
+          dbId: opts.dbId,
+          knowledgeId: opts.knowledgeId
+        };
+        if (filePath) {
+          const resolved = resolve(filePath);
+          if (!existsSync3(resolved)) {
+            writeError(`File not found: ${resolved}`);
+            process.exitCode = 1;
+            return;
+          }
+          uploadOpts.file = resolved;
+        } else {
+          uploadOpts.url = opts.url;
+        }
+        const result = await client.knowledge.upload(uploadOpts);
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson(result);
+        } else {
+          outputDetail(
+            cmd,
+            {
+              id: result.id ?? "",
+              name: result.name ?? "",
+              status: result.status ?? "",
+              type: result.type ?? ""
+            },
+            {
+              labels: ["ID", "Name", "Status", "Type"],
+              keys: ["id", "name", "status", "type"]
+            }
+          );
+        }
+        process.stderr.write(`Check status: agno-cli knowledge status ${result.id}
+`);
+      } catch (err) {
+        handleError(err, { resource: "Knowledge base", url: getBaseUrl(cmd) });
+      }
+    });
+    knowledgeCommand.command("list").description("List knowledge content").option("--limit <n>", "Results per page", (v) => Number.parseInt(v, 10), 20).option("--page <n>", "Page number", (v) => Number.parseInt(v, 10), 1).option("--sort-by <field>", "Sort field").option("--sort-order <order>", "Sort order (asc, desc)").option("--db-id <id>", "Database ID").option("--knowledge-id <id>", "Knowledge base ID").action(async (_options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        const result = await client.knowledge.list({
+          limit: opts.limit,
+          page: opts.page,
+          sortBy: opts.sortBy,
+          sortOrder: opts.sortOrder,
+          dbId: opts.dbId,
+          knowledgeId: opts.knowledgeId
+        });
+        const r = result;
+        const data = r.data;
+        const meta = r.meta;
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson({ data, meta });
+          return;
+        }
+        outputList(
+          cmd,
+          data.map((k) => ({
+            id: k.id ?? "",
+            name: k.name ?? "",
+            status: k.status ?? "",
+            type: k.type ?? ""
+          })),
+          {
+            columns: ["ID", "NAME", "STATUS", "TYPE"],
+            keys: ["id", "name", "status", "type"],
+            meta
+          }
+        );
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    knowledgeCommand.command("get").argument("<content_id>", "Content ID").description("Get knowledge content details").option("--db-id <id>", "Database ID").option("--knowledge-id <id>", "Knowledge base ID").action(async (contentId, _options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        const result = await client.knowledge.get(contentId, { dbId: opts.dbId, knowledgeId: opts.knowledgeId });
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          outputDetail(cmd, result, { labels: [], keys: [] });
+          return;
+        }
+        const k = result;
+        const rawContent = String(k.content ?? "");
+        const truncatedContent = rawContent.length > 200 ? `${rawContent.substring(0, 197)}...` : rawContent;
+        outputDetail(
+          cmd,
+          {
+            id: k.id ?? "",
+            name: k.name ?? "",
+            status: k.status ?? "",
+            type: k.type ?? "",
+            content: truncatedContent
+          },
+          {
+            labels: ["ID", "Name", "Status", "Type", "Content"],
+            keys: ["id", "name", "status", "type", "content"]
+          }
+        );
+      } catch (err) {
+        handleError(err, { resource: "Knowledge base", url: getBaseUrl(cmd) });
+      }
+    });
+    knowledgeCommand.command("search").argument("<query>", "Search query").description("Search knowledge base").option("--search-type <type>", "Search type: vector, keyword, hybrid", "vector").option("--max-results <n>", "Maximum results", (v) => Number.parseInt(v, 10)).option("--limit <n>", "Results per page", (v) => Number.parseInt(v, 10), 20).option("--page <n>", "Page number", (v) => Number.parseInt(v, 10), 1).option("--db-id <id>", "Database ID").option("--knowledge-id <id>", "Knowledge base ID").action(async (query, _options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        const result = await client.knowledge.search(query, {
+          searchType: opts.searchType,
+          maxResults: opts.maxResults,
+          dbId: opts.dbId,
+          knowledgeId: opts.knowledgeId,
+          page: opts.page,
+          limit: opts.limit
+        });
+        const sr = result;
+        const data = sr.data;
+        const meta = sr.meta;
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson({ data, meta });
+          return;
+        }
+        outputList(
+          cmd,
+          data.map((item) => {
+            const rawContent = String(item.content ?? "");
+            return {
+              id: item.id ?? "",
+              content: rawContent.length > 80 ? `${rawContent.substring(0, 77)}...` : rawContent,
+              name: item.name ?? "",
+              score: item.reranking_score ?? ""
+            };
+          }),
+          {
+            columns: ["ID", "CONTENT", "NAME", "SCORE"],
+            keys: ["id", "content", "name", "score"],
+            meta
+          }
+        );
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    knowledgeCommand.command("status").argument("<content_id>", "Content ID").description("Get knowledge content processing status").option("--db-id <id>", "Database ID").option("--knowledge-id <id>", "Knowledge base ID").action(async (contentId, _options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        const result = await client.knowledge.getStatus(contentId, { dbId: opts.dbId, knowledgeId: opts.knowledgeId });
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson(result);
+          return;
+        }
+        const s = result;
+        outputDetail(
+          cmd,
+          {
+            content_id: s.content_id ?? "",
+            status: s.status ?? "",
+            progress: s.progress ?? "",
+            error: s.error ?? ""
+          },
+          {
+            labels: ["Content ID", "Status", "Progress", "Error"],
+            keys: ["content_id", "status", "progress", "error"]
+          }
+        );
+      } catch (err) {
+        handleError(err, { resource: "Knowledge base", url: getBaseUrl(cmd) });
+      }
+    });
+    knowledgeCommand.command("delete").argument("<content_id>", "Content ID").description("Delete knowledge content").option("--db-id <id>", "Database ID").option("--knowledge-id <id>", "Knowledge base ID").action(async (contentId, _options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        await client.knowledge.delete(contentId, { dbId: opts.dbId, knowledgeId: opts.knowledgeId });
+        writeSuccess("Knowledge content deleted.");
+      } catch (err) {
+        handleError(err, { resource: "Knowledge base", url: getBaseUrl(cmd) });
+      }
+    });
+    knowledgeCommand.command("delete-all").description("Delete all knowledge content").option("--db-id <id>", "Database ID").option("--knowledge-id <id>", "Knowledge base ID").action(async (_options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        await client.knowledge.deleteAll({ dbId: opts.dbId, knowledgeId: opts.knowledgeId });
+        writeSuccess("All knowledge content deleted.");
+      } catch (err) {
+        handleError(err, { resource: "Knowledge base", url: getBaseUrl(cmd) });
+      }
+    });
+    knowledgeCommand.command("config").description("Get knowledge base configuration").option("--db-id <id>", "Database ID").option("--knowledge-id <id>", "Knowledge base ID").action(async (_options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        const result = await client.knowledge.getConfig({ dbId: opts.dbId, knowledgeId: opts.knowledgeId });
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson(result);
+          return;
+        }
+        const c = result;
+        outputDetail(
+          cmd,
+          {
+            readers: c.readers ? JSON.stringify(c.readers) : "",
+            chunkers: c.chunkers ? JSON.stringify(c.chunkers) : "",
+            vector_dbs: c.vector_dbs ? JSON.stringify(c.vector_dbs) : ""
+          },
+          {
+            labels: ["Readers", "Chunkers", "Vector DBs"],
+            keys: ["readers", "chunkers", "vector_dbs"]
+          }
+        );
+      } catch (err) {
+        handleError(err, { resource: "Knowledge base", url: getBaseUrl(cmd) });
+      }
+    });
+  }
+});
+
+// src/commands/traces.ts
+var traces_exports = {};
+__export(traces_exports, {
+  traceCommand: () => traceCommand
+});
+import { Command as Command11 } from "commander";
+var traceCommand;
+var init_traces = __esm({
+  "src/commands/traces.ts"() {
+    "use strict";
+    init_client();
+    init_errors();
+    init_output();
+    traceCommand = new Command11("trace").description("Manage traces");
+    traceCommand.command("list").description("List traces").option("--run-id <id>", "Filter by run ID").option("--session-id <id>", "Filter by session ID").option("--user-id <id>", "Filter by user ID").option("--agent-id <id>", "Filter by agent ID").option("--status <status>", "Filter by status").option("--limit <n>", "Results per page", (v) => Number.parseInt(v, 10), 20).option("--page <n>", "Page number", (v) => Number.parseInt(v, 10), 1).option("--db-id <id>", "Database ID").action(async (_options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        const result = await client.traces.list({
+          runId: opts.runId,
+          sessionId: opts.sessionId,
+          userId: opts.userId,
+          agentId: opts.agentId,
+          status: opts.status,
+          page: opts.page,
+          limit: opts.limit,
+          dbId: opts.dbId
+        });
+        const data = result.data;
+        const meta = result.meta;
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson({ data, meta });
+          return;
+        }
+        outputList(
+          cmd,
+          data.map((t) => ({
+            trace_id: t.trace_id ?? "",
+            name: t.name ?? "",
+            status: t.status ?? "",
+            duration: t.duration ?? "",
+            start_time: t.start_time ?? ""
+          })),
+          {
+            columns: ["TRACE_ID", "NAME", "STATUS", "DURATION", "START_TIME"],
+            keys: ["trace_id", "name", "status", "duration", "start_time"],
+            meta
+          }
+        );
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    traceCommand.command("get").argument("<trace_id>", "Trace ID").description("Get trace details").option("--db-id <id>", "Database ID").action(async (traceId, _options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        const result = await client.traces.get(traceId, { dbId: opts.dbId });
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          outputDetail(cmd, result, { labels: [], keys: [] });
+          return;
+        }
+        const t = result;
+        outputDetail(
+          cmd,
+          {
+            trace_id: t.trace_id ?? "",
+            name: t.name ?? "",
+            status: t.status ?? "",
+            duration: t.duration ?? "",
+            start_time: t.start_time ?? "",
+            end_time: t.end_time ?? "",
+            error: t.error ?? ""
+          },
+          {
+            labels: ["Trace ID", "Name", "Status", "Duration", "Start Time", "End Time", "Error"],
+            keys: ["trace_id", "name", "status", "duration", "start_time", "end_time", "error"]
+          }
+        );
+      } catch (err) {
+        handleError(err, { resource: "Trace", url: getBaseUrl(cmd) });
+      }
+    });
+    traceCommand.command("stats").description("Get trace statistics").option("--user-id <id>", "Filter by user ID").option("--agent-id <id>", "Filter by agent ID").option("--team-id <id>", "Filter by team ID").option("--workflow-id <id>", "Filter by workflow ID").option("--start-time <time>", "Start time filter").option("--end-time <time>", "End time filter").option("--limit <n>", "Results per page", (v) => Number.parseInt(v, 10)).option("--page <n>", "Page number", (v) => Number.parseInt(v, 10)).option("--db-id <id>", "Database ID").action(async (_options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        const result = await client.traces.getStats({
+          userId: opts.userId,
+          agentId: opts.agentId,
+          teamId: opts.teamId,
+          workflowId: opts.workflowId,
+          startTime: opts.startTime,
+          endTime: opts.endTime,
+          page: opts.page,
+          limit: opts.limit,
+          dbId: opts.dbId
+        });
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson(result);
+          return;
+        }
+        const r = result;
+        if (Array.isArray(r.data)) {
+          const data = r.data;
+          outputList(
+            cmd,
+            data.map((s) => ({
+              session_id: s.session_id ?? "",
+              user_id: s.user_id ?? "",
+              agent_id: s.agent_id ?? "",
+              total_traces: s.total_traces ?? 0,
+              first_trace_at: s.first_trace_at ?? "",
+              last_trace_at: s.last_trace_at ?? ""
+            })),
+            {
+              columns: ["SESSION_ID", "USER_ID", "AGENT_ID", "TOTAL_TRACES", "FIRST_TRACE", "LAST_TRACE"],
+              keys: ["session_id", "user_id", "agent_id", "total_traces", "first_trace_at", "last_trace_at"]
+            }
+          );
+        } else {
+          printJson(result);
+        }
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    traceCommand.command("search").description("Search traces").option("--filter <json>", "Filter as JSON string").option("--group-by <field>", "Group results by: run, session").option("--limit <n>", "Results per page", (v) => Number.parseInt(v, 10), 20).option("--page <n>", "Page number", (v) => Number.parseInt(v, 10), 1).option("--db-id <id>", "Database ID").action(async (_options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        let parsedFilter;
+        if (opts.filter) {
+          try {
+            parsedFilter = JSON.parse(opts.filter);
+          } catch {
+            writeError("Invalid JSON for --filter");
+            process.exitCode = 1;
+            return;
+          }
+        }
+        const client = getClient(cmd);
+        const result = await client.traces.search({
+          filter: parsedFilter,
+          groupBy: opts.groupBy,
+          page: opts.page,
+          limit: opts.limit,
+          dbId: opts.dbId
+        });
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson(result);
+          return;
+        }
+        const r = result;
+        if (Array.isArray(r.data)) {
+          const data = r.data;
+          outputList(
+            cmd,
+            data.map((t) => ({
+              trace_id: t.trace_id ?? "",
+              name: t.name ?? "",
+              status: t.status ?? "",
+              duration: t.duration ?? ""
+            })),
+            {
+              columns: ["TRACE_ID", "NAME", "STATUS", "DURATION"],
+              keys: ["trace_id", "name", "status", "duration"]
+            }
+          );
+        } else {
+          printJson(result);
+        }
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+  }
+});
+
+// src/commands/evals.ts
+var evals_exports = {};
+__export(evals_exports, {
+  evalCommand: () => evalCommand
+});
+import { Command as Command12 } from "commander";
+var evalCommand;
+var init_evals = __esm({
+  "src/commands/evals.ts"() {
+    "use strict";
+    init_client();
+    init_errors();
+    init_output();
+    evalCommand = new Command12("eval").description("Manage eval runs");
+    evalCommand.command("list").description("List eval runs").option("--agent-id <id>", "Filter by agent ID").option("--team-id <id>", "Filter by team ID").option("--workflow-id <id>", "Filter by workflow ID").option("--model-id <id>", "Filter by model ID").option("--type <type>", "Filter by eval type").option("--limit <n>", "Results per page", (v) => Number.parseInt(v, 10), 20).option("--page <n>", "Page number", (v) => Number.parseInt(v, 10), 1).option("--sort-by <field>", "Sort field").option("--sort-order <order>", "Sort order (asc, desc)").option("--db-id <id>", "Database ID").action(async (_options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        const result = await client.evals.list({
+          agentId: opts.agentId,
+          teamId: opts.teamId,
+          workflowId: opts.workflowId,
+          modelId: opts.modelId,
+          type: opts.type,
+          page: opts.page,
+          limit: opts.limit,
+          sortBy: opts.sortBy,
+          sortOrder: opts.sortOrder,
+          dbId: opts.dbId
+        });
+        const data = result.data;
+        const meta = result.meta;
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson({ data, meta });
+          return;
+        }
+        outputList(
+          cmd,
+          data.map((e) => ({
+            id: e.id ?? "",
+            name: e.name ?? "",
+            eval_type: e.eval_type ?? "",
+            agent_id: e.agent_id ?? "",
+            created_at: e.created_at ?? ""
+          })),
+          {
+            columns: ["ID", "NAME", "EVAL_TYPE", "AGENT_ID", "CREATED_AT"],
+            keys: ["id", "name", "eval_type", "agent_id", "created_at"],
+            meta
+          }
+        );
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    evalCommand.command("get").argument("<eval_run_id>", "Eval run ID").description("Get eval run details").option("--db-id <id>", "Database ID").action(async (evalRunId, _options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        const result = await client.evals.get(evalRunId, { dbId: opts.dbId });
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          outputDetail(cmd, result, { labels: [], keys: [] });
+          return;
+        }
+        const e = result;
+        outputDetail(
+          cmd,
+          {
+            id: e.id ?? "",
+            name: e.name ?? "",
+            eval_type: e.eval_type ?? "",
+            agent_id: e.agent_id ?? "",
+            input: e.input ?? "",
+            output: e.output ?? "",
+            expected_output: e.expected_output ?? "",
+            score: e.score ?? "",
+            created_at: e.created_at ?? ""
+          },
+          {
+            labels: ["ID", "Name", "Eval Type", "Agent ID", "Input", "Output", "Expected Output", "Score", "Created At"],
+            keys: ["id", "name", "eval_type", "agent_id", "input", "output", "expected_output", "score", "created_at"]
+          }
+        );
+      } catch (err) {
+        handleError(err, { resource: "Eval", url: getBaseUrl(cmd) });
+      }
+    });
+    evalCommand.command("delete").description("Delete eval runs").requiredOption("--ids <ids>", "Comma-separated eval run IDs to delete (required)").option("--db-id <id>", "Database ID").action(async (_options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const parsedIds = opts.ids.split(",").map((id) => id.trim());
+        const client = getClient(cmd);
+        await client.evals.delete({ ids: parsedIds, dbId: opts.dbId });
+        writeSuccess("Eval runs deleted.");
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+  }
+});
+
+// src/commands/approvals.ts
+var approvals_exports = {};
+__export(approvals_exports, {
+  approvalCommand: () => approvalCommand
+});
+import { Command as Command13 } from "commander";
+var approvalCommand;
+var init_approvals = __esm({
+  "src/commands/approvals.ts"() {
+    "use strict";
+    init_client();
+    init_errors();
+    init_output();
+    approvalCommand = new Command13("approval").description("Manage approvals");
+    approvalCommand.command("list").description("List approvals").option("--status <status>", "Filter by status (e.g., pending, approved, rejected)").option("--agent-id <id>", "Filter by agent ID").option("--limit <n>", "Results per page", (v) => Number.parseInt(v, 10), 20).option("--page <n>", "Page number", (v) => Number.parseInt(v, 10), 1).action(async (_options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        const result = await client.approvals.list({
+          status: opts.status,
+          agentId: opts.agentId,
+          limit: opts.limit,
+          page: opts.page
+        });
+        const r = result;
+        const data = r.data ?? [];
+        const meta = r.meta;
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson({ data, meta });
+          return;
+        }
+        outputList(
+          cmd,
+          data.map((a) => ({
+            id: a.id ?? "",
+            status: a.status ?? "",
+            type: a.type ?? "",
+            created_at: a.created_at ?? ""
+          })),
+          {
+            columns: ["ID", "STATUS", "TYPE", "CREATED_AT"],
+            keys: ["id", "status", "type", "created_at"],
+            meta
+          }
+        );
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    approvalCommand.command("get").argument("<id>", "Approval ID").description("Get approval details").action(async (id, _options, cmd) => {
+      try {
+        const client = getClient(cmd);
+        const result = await client.approvals.get(id);
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          outputDetail(cmd, result, { labels: [], keys: [] });
+          return;
+        }
+        const a = result;
+        outputDetail(
+          cmd,
+          {
+            id: a.id ?? "",
+            status: a.status ?? "",
+            type: a.type ?? "",
+            agent_id: a.agent_id ?? "",
+            details: a.details ? JSON.stringify(a.details) : "",
+            created_at: a.created_at ?? ""
+          },
+          {
+            labels: ["ID", "Status", "Type", "Agent ID", "Details", "Created"],
+            keys: ["id", "status", "type", "agent_id", "details", "created_at"]
+          }
+        );
+      } catch (err) {
+        handleError(err, { resource: "Approval", url: getBaseUrl(cmd) });
+      }
+    });
+    approvalCommand.command("resolve").argument("<id>", "Approval ID").description("Resolve an approval").requiredOption("--status <status>", "Resolution status, e.g. approved, rejected (required)").option("--resolved-by <user>", "Who resolved the approval").option("--resolution-data <json>", "Additional resolution data as JSON").action(async (id, _options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        let resolutionData;
+        if (opts.resolutionData) {
+          try {
+            resolutionData = JSON.parse(opts.resolutionData);
+          } catch {
+            writeError("Invalid JSON for --resolution-data");
+            process.exitCode = 1;
+            return;
+          }
+        }
+        const result = await client.approvals.resolve(id, {
+          status: opts.status,
+          resolvedBy: opts.resolvedBy,
+          resolutionData
+        });
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson(result);
+          return;
+        }
+        const a = result;
+        outputDetail(
+          cmd,
+          {
+            id: a.id ?? "",
+            status: a.status ?? "",
+            resolved_by: a.resolved_by ?? "",
+            resolved_at: a.resolved_at ?? ""
+          },
+          {
+            labels: ["ID", "Status", "Resolved By", "Resolved At"],
+            keys: ["id", "status", "resolved_by", "resolved_at"]
+          }
+        );
+        writeSuccess("Approval resolved.");
+      } catch (err) {
+        handleError(err, { resource: "Approval", url: getBaseUrl(cmd) });
+      }
+    });
+  }
+});
+
+// src/commands/auth.ts
+var auth_exports = {};
+__export(auth_exports, {
+  authCommand: () => authCommand
+});
+import { Command as Command14 } from "commander";
+var authCommand, keyCommand, connectionCommand;
+var init_auth = __esm({
+  "src/commands/auth.ts"() {
+    "use strict";
+    init_client();
+    init_errors();
+    init_output();
+    authCommand = new Command14("auth").description("Authentication and connections");
+    authCommand.command("me").description("Show current auth info").action(async (_options, cmd) => {
+      try {
+        const client = getClient(cmd);
+        const result = await client.auth.me();
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson(result);
+          return;
+        }
+        const u = result;
+        outputDetail(
+          cmd,
+          {
+            id: u.id ?? "",
+            email: u.email ?? "",
+            role: u.role ?? "",
+            name: u.name ?? ""
+          },
+          {
+            labels: ["ID", "Email", "Role", "Name"],
+            keys: ["id", "email", "role", "name"]
+          }
+        );
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    keyCommand = new Command14("key").description("Manage API keys");
+    keyCommand.command("list").description("List API keys").action(async (_options, cmd) => {
+      try {
+        const client = getClient(cmd);
+        const result = await client.auth.keys.list();
+        const data = Array.isArray(result) ? result : [];
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson(data);
+          return;
+        }
+        outputList(
+          cmd,
+          data.map((k) => ({
+            id: k.id ?? "",
+            name: k.name ?? "",
+            created_at: k.created_at ?? "",
+            expires_at: k.expires_at ?? ""
+          })),
+          {
+            columns: ["ID", "NAME", "CREATED_AT", "EXPIRES_AT"],
+            keys: ["id", "name", "created_at", "expires_at"]
+          }
+        );
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    keyCommand.command("create").description("Create a new API key").requiredOption("--name <name>", "Key name (required)").option("--scopes <scopes>", "Comma-separated scopes").option("--expires-at <date>", "Expiration date (ISO 8601)").action(async (_options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        const result = await client.auth.keys.create({
+          name: opts.name,
+          scopes: opts.scopes ? opts.scopes.split(",") : void 0,
+          expiresAt: opts.expiresAt
+        });
+        const format = getOutputFormat(cmd);
+        const k = result;
+        if (format === "json") {
+          printJson(result);
+        } else {
+          outputDetail(
+            cmd,
+            {
+              id: k.id ?? "",
+              name: k.name ?? "",
+              key: k.key ?? "",
+              created_at: k.created_at ?? ""
+            },
+            {
+              labels: ["ID", "Name", "Key (save this!)", "Created"],
+              keys: ["id", "name", "key", "created_at"]
+            }
+          );
+          writeWarning("This key will not be shown again.");
+        }
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    keyCommand.command("get").argument("<key_id>", "Key ID").description("Get API key details").action(async (keyId, _options, cmd) => {
+      try {
+        const client = getClient(cmd);
+        const result = await client.auth.keys.get(keyId);
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson(result);
+          return;
+        }
+        const k = result;
+        outputDetail(
+          cmd,
+          {
+            id: k.id ?? "",
+            name: k.name ?? "",
+            created_at: k.created_at ?? "",
+            expires_at: k.expires_at ?? ""
+          },
+          {
+            labels: ["ID", "Name", "Created", "Expires"],
+            keys: ["id", "name", "created_at", "expires_at"]
+          }
+        );
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    keyCommand.command("revoke").argument("<key_id>", "Key ID").description("Revoke an API key").action(async (keyId, _options, cmd) => {
+      try {
+        const client = getClient(cmd);
+        await client.auth.keys.revoke(keyId);
+        writeSuccess(`API key ${keyId} revoked.`);
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    keyCommand.command("rotate").argument("<key_id>", "Key ID").description("Rotate an API key").action(async (keyId, _options, cmd) => {
+      try {
+        const client = getClient(cmd);
+        const result = await client.auth.keys.rotate(keyId);
+        const format = getOutputFormat(cmd);
+        const k = result;
+        if (format === "json") {
+          printJson(result);
+        } else {
+          outputDetail(
+            cmd,
+            {
+              id: k.id ?? "",
+              name: k.name ?? "",
+              key: k.key ?? "",
+              created_at: k.created_at ?? ""
+            },
+            {
+              labels: ["ID", "Name", "New Key (save this!)", "Created"],
+              keys: ["id", "name", "key", "created_at"]
+            }
+          );
+          writeWarning("This key will not be shown again.");
+        }
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    authCommand.addCommand(keyCommand);
+    connectionCommand = new Command14("connection").description("Manage connections");
+    connectionCommand.command("list").description("List connections").action(async (_options, cmd) => {
+      try {
+        const client = getClient(cmd);
+        const result = await client.auth.connections.list();
+        const data = Array.isArray(result) ? result : [];
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson(data);
+          return;
+        }
+        outputList(
+          cmd,
+          data.map((c) => ({
+            id: c.id ?? "",
+            name: c.name ?? "",
+            host: c.host ?? "",
+            port: c.port ?? "",
+            is_default: c.is_default ?? ""
+          })),
+          {
+            columns: ["ID", "NAME", "HOST", "PORT", "IS_DEFAULT"],
+            keys: ["id", "name", "host", "port", "is_default"]
+          }
+        );
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    connectionCommand.command("create").description("Create a new connection").requiredOption("--name <name>", "Connection name (required)").requiredOption("--host <host>", "Hostname or IP (required)").requiredOption("--port <port>", "Port number (required)").requiredOption("--user <user>", "Username (required)").requiredOption("--password <password>", "Password (required)").option("--is-default", "Set as default connection").action(async (_options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        const result = await client.auth.connections.create({
+          name: opts.name,
+          host: opts.host,
+          port: Number.parseInt(opts.port, 10),
+          user: opts.user,
+          password: opts.password,
+          isDefault: opts.isDefault ?? false
+        });
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson(result);
+          return;
+        }
+        const c = result;
+        outputDetail(
+          cmd,
+          {
+            id: c.id ?? "",
+            name: c.name ?? "",
+            host: c.host ?? "",
+            port: c.port ?? "",
+            is_default: c.is_default ?? ""
+          },
+          {
+            labels: ["ID", "Name", "Host", "Port", "Default"],
+            keys: ["id", "name", "host", "port", "is_default"]
+          }
+        );
+        writeSuccess("Connection created.");
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    connectionCommand.command("get").argument("<conn_id>", "Connection ID").description("Get connection details").action(async (connId, _options, cmd) => {
+      try {
+        const client = getClient(cmd);
+        const result = await client.auth.connections.get(connId);
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson(result);
+          return;
+        }
+        const c = result;
+        outputDetail(
+          cmd,
+          {
+            id: c.id ?? "",
+            name: c.name ?? "",
+            host: c.host ?? "",
+            port: c.port ?? "",
+            user: c.user ?? "",
+            is_default: c.is_default ?? ""
+          },
+          {
+            labels: ["ID", "Name", "Host", "Port", "User", "Default"],
+            keys: ["id", "name", "host", "port", "user", "is_default"]
+          }
+        );
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    connectionCommand.command("update").argument("<conn_id>", "Connection ID").description("Update a connection").option("--name <name>", "Connection name").option("--host <host>", "Hostname or IP").option("--port <port>", "Port number").option("--user <user>", "Username").option("--password <password>", "Password").option("--is-default", "Set as default connection").action(async (connId, _options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        const updateOpts = {};
+        if (opts.name) updateOpts.name = opts.name;
+        if (opts.host) updateOpts.host = opts.host;
+        if (opts.port) updateOpts.port = Number.parseInt(opts.port, 10);
+        if (opts.user) updateOpts.user = opts.user;
+        if (opts.password) updateOpts.password = opts.password;
+        if (opts.isDefault !== void 0) updateOpts.isDefault = opts.isDefault;
+        const result = await client.auth.connections.update(connId, updateOpts);
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson(result);
+          return;
+        }
+        const c = result;
+        outputDetail(
+          cmd,
+          {
+            id: c.id ?? "",
+            name: c.name ?? "",
+            host: c.host ?? "",
+            port: c.port ?? "",
+            is_default: c.is_default ?? ""
+          },
+          {
+            labels: ["ID", "Name", "Host", "Port", "Default"],
+            keys: ["id", "name", "host", "port", "is_default"]
+          }
+        );
+        writeSuccess("Connection updated.");
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    connectionCommand.command("delete").argument("<conn_id>", "Connection ID").description("Delete a connection").action(async (connId, _options, cmd) => {
+      try {
+        const client = getClient(cmd);
+        await client.auth.connections.delete(connId);
+        writeSuccess(`Connection ${connId} deleted.`);
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    connectionCommand.command("test").argument("<conn_id>", "Connection ID").description("Test a connection").action(async (connId, _options, cmd) => {
+      try {
+        const client = getClient(cmd);
+        const result = await client.auth.connections.test(connId);
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson(result);
+          return;
+        }
+        const t = result;
+        outputDetail(
+          cmd,
+          {
+            success: t.success ?? "",
+            message: t.message ?? ""
+          },
+          {
+            labels: ["Success", "Message"],
+            keys: ["success", "message"]
+          }
+        );
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    authCommand.addCommand(connectionCommand);
+  }
+});
+
+// src/commands/components.ts
+var components_exports = {};
+__export(components_exports, {
+  componentCommand: () => componentCommand
+});
+import { Command as Command15 } from "commander";
+var componentCommand, configSubCommand;
+var init_components = __esm({
+  "src/commands/components.ts"() {
+    "use strict";
+    init_client();
+    init_errors();
+    init_output();
+    componentCommand = new Command15("component").description("Manage components");
+    componentCommand.command("list").description("List components").option("--type <type>", "Filter by type (agent, team, workflow)").option("--limit <n>", "Results per page", (v) => Number.parseInt(v, 10), 20).option("--page <n>", "Page number", (v) => Number.parseInt(v, 10), 1).action(async (_options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        const result = await client.components.list({
+          componentType: opts.type,
+          page: opts.page,
+          limit: opts.limit
+        });
+        const r = result;
+        const data = r.data ?? [];
+        const meta = r.meta;
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson({ data, meta });
+          return;
+        }
+        outputList(
+          cmd,
+          data.map((c) => ({
+            id: c.id ?? "",
+            name: c.name ?? "",
+            type: c.component_type ?? "",
+            stage: c.stage ?? ""
+          })),
+          {
+            columns: ["ID", "NAME", "TYPE", "STAGE"],
+            keys: ["id", "name", "type", "stage"],
+            meta
+          }
+        );
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    componentCommand.command("get").argument("<component_id>", "Component ID").description("Get component details").action(async (componentId, _options, cmd) => {
+      try {
+        const client = getClient(cmd);
+        const result = await client.components.get(componentId);
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          outputDetail(cmd, result, { labels: [], keys: [] });
+          return;
+        }
+        const c = result;
+        outputDetail(
+          cmd,
+          {
+            id: c.id ?? "",
+            name: c.name ?? "",
+            component_type: c.component_type ?? "",
+            description: c.description ?? "",
+            stage: c.stage ?? "",
+            created_at: c.created_at ?? ""
+          },
+          {
+            labels: ["ID", "Name", "Type", "Description", "Stage", "Created"],
+            keys: ["id", "name", "component_type", "description", "stage", "created_at"]
+          }
+        );
+      } catch (err) {
+        handleError(err, { resource: "Component", url: getBaseUrl(cmd) });
+      }
+    });
+    componentCommand.command("create").description("Create a component").requiredOption("--name <name>", "Component name (required)").requiredOption("--type <type>", "Component type: agent, team, workflow (required)").option("--description <desc>", "Component description").option("--config <json>", "Configuration as JSON").option("--stage <stage>", "Stage (draft, published)").action(async (_options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        let config;
+        if (opts.config) {
+          try {
+            config = JSON.parse(opts.config);
+          } catch {
+            writeError("Invalid JSON for --config");
+            process.exitCode = 1;
+            return;
+          }
+        }
+        const result = await client.components.create({
+          name: opts.name,
+          componentType: opts.type,
+          description: opts.description,
+          config,
+          stage: opts.stage
+        });
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson(result);
+          return;
+        }
+        const c = result;
+        outputDetail(
+          cmd,
+          {
+            id: c.id ?? "",
+            name: c.name ?? "",
+            component_type: c.component_type ?? "",
+            stage: c.stage ?? ""
+          },
+          {
+            labels: ["ID", "Name", "Type", "Stage"],
+            keys: ["id", "name", "component_type", "stage"]
+          }
+        );
+        writeSuccess("Component created.");
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    componentCommand.command("update").argument("<component_id>", "Component ID").description("Update a component").option("--name <name>", "Component name").option("--type <type>", "Component type").option("--description <desc>", "Component description").option("--config <json>", "Configuration as JSON").option("--stage <stage>", "Stage (draft, published)").action(async (componentId, _options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        let config;
+        if (opts.config) {
+          try {
+            config = JSON.parse(opts.config);
+          } catch {
+            writeError("Invalid JSON for --config");
+            process.exitCode = 1;
+            return;
+          }
+        }
+        const updateOpts = {};
+        if (opts.name) updateOpts.name = opts.name;
+        if (opts.type) updateOpts.componentType = opts.type;
+        if (opts.description) updateOpts.description = opts.description;
+        if (config) updateOpts.config = config;
+        if (opts.stage) updateOpts.stage = opts.stage;
+        const result = await client.components.update(componentId, updateOpts);
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson(result);
+          return;
+        }
+        const c = result;
+        outputDetail(
+          cmd,
+          {
+            id: c.id ?? "",
+            name: c.name ?? "",
+            component_type: c.component_type ?? "",
+            stage: c.stage ?? ""
+          },
+          {
+            labels: ["ID", "Name", "Type", "Stage"],
+            keys: ["id", "name", "component_type", "stage"]
+          }
+        );
+        writeSuccess("Component updated.");
+      } catch (err) {
+        handleError(err, { resource: "Component", url: getBaseUrl(cmd) });
+      }
+    });
+    componentCommand.command("delete").argument("<component_id>", "Component ID").description("Delete a component").action(async (componentId, _options, cmd) => {
+      try {
+        const client = getClient(cmd);
+        await client.components.delete(componentId);
+        writeSuccess(`Component ${componentId} deleted.`);
+      } catch (err) {
+        handleError(err, { resource: "Component", url: getBaseUrl(cmd) });
+      }
+    });
+    configSubCommand = new Command15("config").description("Manage component configurations");
+    configSubCommand.command("list").argument("<component_id>", "Component ID").description("List component configurations").action(async (componentId, _options, cmd) => {
+      try {
+        const client = getClient(cmd);
+        const result = await client.components.listConfigs(componentId);
+        const data = Array.isArray(result) ? result : [];
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson(data);
+          return;
+        }
+        outputList(
+          cmd,
+          data.map((c) => ({
+            version: c.version ?? "",
+            status: c.status ?? "",
+            created_at: c.created_at ?? ""
+          })),
+          {
+            columns: ["VERSION", "STATUS", "CREATED_AT"],
+            keys: ["version", "status", "created_at"]
+          }
+        );
+      } catch (err) {
+        handleError(err, { resource: "Component", url: getBaseUrl(cmd) });
+      }
+    });
+    configSubCommand.command("create").argument("<component_id>", "Component ID").description("Create a component configuration").requiredOption("--config <json>", "Configuration as JSON (required)").action(async (componentId, _options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        let config;
+        try {
+          config = JSON.parse(opts.config);
+        } catch {
+          writeError("Invalid JSON for --config");
+          process.exitCode = 1;
+          return;
+        }
+        const result = await client.components.createConfig(componentId, { config });
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson(result);
+          return;
+        }
+        const c = result;
+        outputDetail(
+          cmd,
+          {
+            version: c.version ?? "",
+            status: c.status ?? "",
+            created_at: c.created_at ?? ""
+          },
+          {
+            labels: ["Version", "Status", "Created"],
+            keys: ["version", "status", "created_at"]
+          }
+        );
+        writeSuccess("Configuration created.");
+      } catch (err) {
+        handleError(err, { resource: "Component", url: getBaseUrl(cmd) });
+      }
+    });
+    configSubCommand.command("update").argument("<component_id>", "Component ID").argument("<version>", "Configuration version number").description("Update a draft component configuration").requiredOption("--config <json>", "Configuration as JSON (required)").action(async (componentId, version, _options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        let config;
+        try {
+          config = JSON.parse(opts.config);
+        } catch {
+          writeError("Invalid JSON for --config");
+          process.exitCode = 1;
+          return;
+        }
+        const result = await client.components.updateDraftConfig(componentId, Number.parseInt(version, 10), { config });
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson(result);
+          return;
+        }
+        const c = result;
+        outputDetail(
+          cmd,
+          {
+            version: c.version ?? "",
+            status: c.status ?? ""
+          },
+          {
+            labels: ["Version", "Status"],
+            keys: ["version", "status"]
+          }
+        );
+        writeSuccess("Configuration updated.");
+      } catch (err) {
+        handleError(err, { resource: "Component", url: getBaseUrl(cmd) });
+      }
+    });
+    configSubCommand.command("delete").argument("<component_id>", "Component ID").argument("<version>", "Configuration version number").description("Delete a component configuration version").action(async (componentId, version, _options, cmd) => {
+      try {
+        const client = getClient(cmd);
+        await client.components.deleteConfigVersion(componentId, Number.parseInt(version, 10));
+        writeSuccess(`Configuration version ${version} deleted.`);
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    componentCommand.addCommand(configSubCommand);
+  }
+});
+
+// src/commands/schedules.ts
+var schedules_exports = {};
+__export(schedules_exports, {
+  scheduleCommand: () => scheduleCommand
+});
+import { Command as Command16 } from "commander";
+var scheduleCommand;
+var init_schedules = __esm({
+  "src/commands/schedules.ts"() {
+    "use strict";
+    init_client();
+    init_errors();
+    init_output();
+    scheduleCommand = new Command16("schedule").description("Manage schedules");
+    scheduleCommand.command("list").description("List schedules").option("--enabled", "Filter to enabled schedules only").option("--limit <n>", "Results per page", (v) => Number.parseInt(v, 10), 20).option("--page <n>", "Page number", (v) => Number.parseInt(v, 10), 1).action(async (_options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        const result = await client.schedules.list({
+          enabled: opts.enabled,
+          limit: opts.limit,
+          page: opts.page
+        });
+        const r = result;
+        const data = r.data ?? [];
+        const meta = r.meta;
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson({ data, meta });
+          return;
+        }
+        outputList(
+          cmd,
+          data.map((s) => ({
+            id: s.id ?? "",
+            name: s.name ?? "",
+            cron: s.cron_expr ?? "",
+            enabled: s.enabled ?? "",
+            next_run: s.next_run ?? ""
+          })),
+          {
+            columns: ["ID", "NAME", "CRON", "ENABLED", "NEXT_RUN"],
+            keys: ["id", "name", "cron", "enabled", "next_run"],
+            meta
+          }
+        );
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    scheduleCommand.command("get").argument("<id>", "Schedule ID").description("Get schedule details").action(async (id, _options, cmd) => {
+      try {
+        const client = getClient(cmd);
+        const result = await client.schedules.get(id);
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          outputDetail(cmd, result, { labels: [], keys: [] });
+          return;
+        }
+        const s = result;
+        outputDetail(
+          cmd,
+          {
+            id: s.id ?? "",
+            name: s.name ?? "",
+            cron_expr: s.cron_expr ?? "",
+            endpoint: s.endpoint ?? "",
+            method: s.method ?? "",
+            enabled: s.enabled ?? "",
+            timezone: s.timezone ?? "",
+            next_run: s.next_run ?? "",
+            created_at: s.created_at ?? ""
+          },
+          {
+            labels: ["ID", "Name", "Cron", "Endpoint", "Method", "Enabled", "Timezone", "Next Run", "Created"],
+            keys: ["id", "name", "cron_expr", "endpoint", "method", "enabled", "timezone", "next_run", "created_at"]
+          }
+        );
+      } catch (err) {
+        handleError(err, { resource: "Schedule", url: getBaseUrl(cmd) });
+      }
+    });
+    scheduleCommand.command("create").description("Create a schedule").requiredOption("--name <name>", "Schedule name (required)").requiredOption("--cron <expr>", "Cron expression (required)").requiredOption("--endpoint <url>", "Endpoint URL (required)").requiredOption("--method <method>", "HTTP method: GET, POST, etc. (required)").option("--description <desc>", "Schedule description").option("--payload <json>", "Request payload as JSON").option("--timezone <tz>", "Timezone (default: UTC)").option("--timeout-seconds <n>", "Timeout in seconds", (v) => Number.parseInt(v, 10)).option("--max-retries <n>", "Maximum retries", (v) => Number.parseInt(v, 10)).option("--retry-delay-seconds <n>", "Retry delay in seconds", (v) => Number.parseInt(v, 10)).action(async (_options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        let payload;
+        if (opts.payload) {
+          try {
+            payload = JSON.parse(opts.payload);
+          } catch {
+            writeError("Invalid JSON for --payload");
+            process.exitCode = 1;
+            return;
+          }
+        }
+        const result = await client.schedules.create({
+          name: opts.name,
+          cronExpr: opts.cron,
+          endpoint: opts.endpoint,
+          method: opts.method,
+          description: opts.description,
+          payload,
+          timezone: opts.timezone,
+          timeoutSeconds: opts.timeoutSeconds,
+          maxRetries: opts.maxRetries,
+          retryDelaySeconds: opts.retryDelaySeconds
+        });
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson(result);
+          return;
+        }
+        const s = result;
+        outputDetail(
+          cmd,
+          {
+            id: s.id ?? "",
+            name: s.name ?? "",
+            cron_expr: s.cron_expr ?? "",
+            enabled: s.enabled ?? ""
+          },
+          {
+            labels: ["ID", "Name", "Cron", "Enabled"],
+            keys: ["id", "name", "cron_expr", "enabled"]
+          }
+        );
+        writeSuccess("Schedule created.");
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+    scheduleCommand.command("update").argument("<id>", "Schedule ID").description("Update a schedule").option("--name <name>", "Schedule name").option("--cron <expr>", "Cron expression").option("--endpoint <url>", "Endpoint URL").option("--method <method>", "HTTP method").option("--description <desc>", "Schedule description").option("--payload <json>", "Request payload as JSON").option("--timezone <tz>", "Timezone").option("--timeout-seconds <n>", "Timeout in seconds", (v) => Number.parseInt(v, 10)).option("--max-retries <n>", "Maximum retries", (v) => Number.parseInt(v, 10)).option("--retry-delay-seconds <n>", "Retry delay in seconds", (v) => Number.parseInt(v, 10)).action(async (id, _options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        let payload;
+        if (opts.payload) {
+          try {
+            payload = JSON.parse(opts.payload);
+          } catch {
+            writeError("Invalid JSON for --payload");
+            process.exitCode = 1;
+            return;
+          }
+        }
+        const updateOpts = {};
+        if (opts.name) updateOpts.name = opts.name;
+        if (opts.cron) updateOpts.cronExpr = opts.cron;
+        if (opts.endpoint) updateOpts.endpoint = opts.endpoint;
+        if (opts.method) updateOpts.method = opts.method;
+        if (opts.description) updateOpts.description = opts.description;
+        if (payload) updateOpts.payload = payload;
+        if (opts.timezone) updateOpts.timezone = opts.timezone;
+        if (opts.timeoutSeconds) updateOpts.timeoutSeconds = opts.timeoutSeconds;
+        if (opts.maxRetries) updateOpts.maxRetries = opts.maxRetries;
+        if (opts.retryDelaySeconds) updateOpts.retryDelaySeconds = opts.retryDelaySeconds;
+        const result = await client.schedules.update(id, updateOpts);
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson(result);
+          return;
+        }
+        const s = result;
+        outputDetail(
+          cmd,
+          {
+            id: s.id ?? "",
+            name: s.name ?? "",
+            cron_expr: s.cron_expr ?? "",
+            enabled: s.enabled ?? ""
+          },
+          {
+            labels: ["ID", "Name", "Cron", "Enabled"],
+            keys: ["id", "name", "cron_expr", "enabled"]
+          }
+        );
+        writeSuccess("Schedule updated.");
+      } catch (err) {
+        handleError(err, { resource: "Schedule", url: getBaseUrl(cmd) });
+      }
+    });
+    scheduleCommand.command("delete").argument("<id>", "Schedule ID").description("Delete a schedule").action(async (id, _options, cmd) => {
+      try {
+        const client = getClient(cmd);
+        await client.schedules.delete(id);
+        writeSuccess(`Schedule ${id} deleted.`);
+      } catch (err) {
+        handleError(err, { resource: "Schedule", url: getBaseUrl(cmd) });
+      }
+    });
+    scheduleCommand.command("pause").argument("<id>", "Schedule ID").description("Pause a schedule").action(async (id, _options, cmd) => {
+      try {
+        const client = getClient(cmd);
+        await client.schedules.disable(id);
+        writeSuccess("Schedule paused.");
+      } catch (err) {
+        handleError(err, { resource: "Schedule", url: getBaseUrl(cmd) });
+      }
+    });
+    scheduleCommand.command("resume").argument("<id>", "Schedule ID").description("Resume a schedule").action(async (id, _options, cmd) => {
+      try {
+        const client = getClient(cmd);
+        await client.schedules.enable(id);
+        writeSuccess("Schedule resumed.");
+      } catch (err) {
+        handleError(err, { resource: "Schedule", url: getBaseUrl(cmd) });
+      }
+    });
+    scheduleCommand.command("runs").argument("<id>", "Schedule ID").description("List schedule run history").action(async (id, _options, cmd) => {
+      try {
+        const client = getClient(cmd);
+        const result = await client.schedules.listRuns(id);
+        const r = result;
+        const data = r.data ?? (Array.isArray(result) ? result : []);
+        const meta = r.meta;
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson(meta ? { data, meta } : data);
+          return;
+        }
+        outputList(
+          cmd,
+          data.map((run) => ({
+            id: run.id ?? "",
+            status: run.status ?? "",
+            started_at: run.started_at ?? "",
+            completed_at: run.completed_at ?? ""
+          })),
+          {
+            columns: ["ID", "STATUS", "STARTED_AT", "COMPLETED_AT"],
+            keys: ["id", "status", "started_at", "completed_at"],
+            meta
+          }
+        );
+      } catch (err) {
+        handleError(err, { resource: "Schedule", url: getBaseUrl(cmd) });
+      }
+    });
+  }
+});
+
+// src/commands/database.ts
+var database_exports = {};
+__export(database_exports, {
+  databaseCommand: () => databaseCommand
+});
+import { Command as Command17 } from "commander";
+var databaseCommand;
+var init_database = __esm({
+  "src/commands/database.ts"() {
+    "use strict";
+    init_client();
+    init_errors();
+    init_output();
+    databaseCommand = new Command17("database").description("Manage databases");
+    databaseCommand.command("migrate").argument("<db_id>", "Database ID").description("Run database migrations").option("--target-version <version>", "Target migration version").action(async (dbId, _options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        await client.database.migrate(dbId, {
+          targetVersion: opts.targetVersion
+        });
+        writeSuccess("Database migration complete.");
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+  }
+});
+
+// src/commands/registry.ts
+var registry_exports = {};
+__export(registry_exports, {
+  registryCommand: () => registryCommand
+});
+import { Command as Command18 } from "commander";
+var registryCommand;
+var init_registry = __esm({
+  "src/commands/registry.ts"() {
+    "use strict";
+    init_client();
+    init_errors();
+    init_output();
+    registryCommand = new Command18("registry").description("Manage registry");
+    registryCommand.command("list").description("List registry items").option("--type <type>", "Filter by resource type").option("--name <name>", "Filter by name").option("--limit <n>", "Results per page", (v) => Number.parseInt(v, 10), 20).option("--page <n>", "Page number", (v) => Number.parseInt(v, 10), 1).action(async (_options, cmd) => {
+      try {
+        const opts = cmd.optsWithGlobals();
+        const client = getClient(cmd);
+        const result = await client.registry.list({
+          resourceType: opts.type,
+          name: opts.name,
+          limit: opts.limit,
+          page: opts.page
+        });
+        const r = result;
+        const data = r.data ?? (Array.isArray(result) ? result : []);
+        const meta = r.meta;
+        const format = getOutputFormat(cmd);
+        if (format === "json") {
+          printJson(meta ? { data, meta } : data);
+          return;
+        }
+        outputList(
+          cmd,
+          data.map((item) => ({
+            id: item.id ?? "",
+            name: item.name ?? "",
+            type: item.resource_type ?? item.type ?? "",
+            version: item.version ?? ""
+          })),
+          {
+            columns: ["ID", "NAME", "TYPE", "VERSION"],
+            keys: ["id", "name", "type", "version"],
+            meta
+          }
+        );
+      } catch (err) {
+        handleError(err, { url: getBaseUrl(cmd) });
+      }
+    });
+  }
+});
+
+// src/bin/agno.ts
+init_errors();
+init_output();
+import { Command as Command19, Option } from "commander";
+process.stdout.on("error", (err) => {
+  if (err.code === "EPIPE") process.exit(0);
+  throw err;
+});
+process.stderr.on("error", (err) => {
+  if (err.code === "EPIPE") process.exit(0);
+  throw err;
+});
+var VERSION = "0.1.0";
+var program = new Command19("agno-cli").version(VERSION, "-V, --version").description("CLI for interacting with AgentOS instances").option("-c, --context <name>", "Override active context").option("--url <url>", "Override base URL").option("--key <key>", "Override security key").option("--timeout <seconds>", "Override timeout", Number.parseFloat).option("--no-color", "Disable color output").option("--json [fields]", "Output JSON with optional field selection (e.g., --json id,name)").addOption(new Option("-o, --output <format>", "Output format").choices(["json", "table"]));
+program.hook("preAction", (thisCommand) => {
+  handleNoColorFlag(thisCommand);
+  const globals = thisCommand.optsWithGlobals();
+  if (globals.output === "table" && globals.json !== void 0) {
+    process.stderr.write("Error: --output table and --json cannot be used together.\n");
+    process.exit(1);
+  }
+});
+program.addHelpText(
+  "after",
+  `
+Examples:
+  $ agno-cli config init --url http://localhost:7777
+  $ agno-cli config show
+  $ agno-cli agent list --output json
+  $ agno-cli agent run my-agent "Hello" --stream
+`
+);
+var { configCommand: configCommand2 } = await Promise.resolve().then(() => (init_config2(), config_exports));
+program.addCommand(configCommand2);
+var { statusCommand: statusCommand2 } = await Promise.resolve().then(() => (init_status(), status_exports));
+program.addCommand(statusCommand2);
+var { agentCommand: agentCommand2 } = await Promise.resolve().then(() => (init_agents(), agents_exports));
+program.addCommand(agentCommand2);
+var { teamCommand: teamCommand2 } = await Promise.resolve().then(() => (init_teams(), teams_exports));
+program.addCommand(teamCommand2);
+var { workflowCommand: workflowCommand2 } = await Promise.resolve().then(() => (init_workflows(), workflows_exports));
+program.addCommand(workflowCommand2);
+var { modelCommand: modelCommand2 } = await Promise.resolve().then(() => (init_models(), models_exports));
+program.addCommand(modelCommand2);
+var { metricsCommand: metricsCommand2 } = await Promise.resolve().then(() => (init_metrics(), metrics_exports));
+program.addCommand(metricsCommand2);
+var { sessionCommand: sessionCommand2 } = await Promise.resolve().then(() => (init_sessions(), sessions_exports));
+program.addCommand(sessionCommand2);
+var { memoryCommand: memoryCommand2 } = await Promise.resolve().then(() => (init_memories(), memories_exports));
+program.addCommand(memoryCommand2);
+var { knowledgeCommand: knowledgeCommand2 } = await Promise.resolve().then(() => (init_knowledge(), knowledge_exports));
+program.addCommand(knowledgeCommand2);
+var { traceCommand: traceCommand2 } = await Promise.resolve().then(() => (init_traces(), traces_exports));
+program.addCommand(traceCommand2);
+var { evalCommand: evalCommand2 } = await Promise.resolve().then(() => (init_evals(), evals_exports));
+program.addCommand(evalCommand2);
+var { approvalCommand: approvalCommand2 } = await Promise.resolve().then(() => (init_approvals(), approvals_exports));
+program.addCommand(approvalCommand2);
+var { authCommand: authCommand2 } = await Promise.resolve().then(() => (init_auth(), auth_exports));
+program.addCommand(authCommand2);
+var { componentCommand: componentCommand2 } = await Promise.resolve().then(() => (init_components(), components_exports));
+program.addCommand(componentCommand2);
+var { scheduleCommand: scheduleCommand2 } = await Promise.resolve().then(() => (init_schedules(), schedules_exports));
+program.addCommand(scheduleCommand2);
+var { databaseCommand: databaseCommand2 } = await Promise.resolve().then(() => (init_database(), database_exports));
+program.addCommand(databaseCommand2);
+var { registryCommand: registryCommand2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
+program.addCommand(registryCommand2);
+program.action(() => {
+  program.outputHelp();
+});
+program.exitOverride();
+try {
+  await program.parseAsync(process.argv);
+} catch (err) {
+  if (err instanceof Error && "exitCode" in err) {
+    const cmdErr = err;
+    if (cmdErr.exitCode !== 0) {
+      handleError(err);
+    }
+  } else {
+    handleError(err);
+  }
+}