danube-cli 0.2.0

package/dist/danube.mjs

@@ -0,0 +1,1792 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/lib/output.ts
+import chalk from "chalk";
+function setHumanMode(enabled) {
+  humanMode = enabled;
+}
+function setQuietMode(enabled) {
+  quietMode = enabled;
+}
+function output(data) {
+  if (quietMode)
+    return;
+  console.log(JSON.stringify(data, null, 2));
+}
+function outputTable(items, columns, title) {
+  if (!humanMode) {
+    output(items);
+    return;
+  }
+  if (title) {
+    console.log(`
+${chalk.bold(title)}`);
+  }
+  if (items.length === 0) {
+    console.log(chalk.dim("  No results found."));
+    return;
+  }
+  const rows = items;
+  const widths = columns.map((col) => {
+    const headerLen = col.header.length;
+    const maxDataLen = rows.reduce((max, item) => {
+      const val = String(item[col.key] ?? "");
+      return Math.max(max, val.length);
+    }, 0);
+    return Math.min(Math.max(headerLen, maxDataLen), 60);
+  });
+  const header = columns.map((col, i) => chalk.cyan.bold(col.header.padEnd(widths[i]))).join("  ");
+  console.log(`  ${header}`);
+  console.log(`  ${widths.map((w) => "─".repeat(w)).join("  ")}`);
+  for (const item of rows) {
+    const row = columns.map((col, i) => {
+      let val = String(item[col.key] ?? "");
+      if (val.length > widths[i]) {
+        val = val.slice(0, widths[i] - 1) + "…";
+      }
+      val = val.padEnd(widths[i]);
+      if (col.style === "dim")
+        return chalk.dim(val);
+      if (col.style === "bold")
+        return chalk.bold(val);
+      return val;
+    }).join("  ");
+    console.log(`  ${row}`);
+  }
+  console.log();
+}
+function outputDetail(data, title) {
+  if (!humanMode) {
+    output(data);
+    return;
+  }
+  if (title) {
+    console.log(`
+${chalk.bold(title)}`);
+  }
+  const record = data;
+  for (const [key, value] of Object.entries(record)) {
+    if (value === undefined || value === null)
+      continue;
+    if (typeof value === "object") {
+      console.log(`  ${chalk.cyan(key + ":")}`);
+      console.log(`    ${JSON.stringify(value, null, 2).split(`
+`).join(`
+    `)}`);
+    } else {
+      console.log(`  ${chalk.cyan(key + ":")} ${value}`);
+    }
+  }
+  console.log();
+}
+function outputError(error, message, extra) {
+  if (humanMode) {
+    console.error(`${chalk.red("✗")} ${message}`);
+    if (extra) {
+      for (const [key, value] of Object.entries(extra)) {
+        if (value !== undefined && value !== null) {
+          console.error(`  ${chalk.dim(key + ":")} ${value}`);
+        }
+      }
+    }
+  } else {
+    const err = { error, message };
+    if (extra)
+      Object.assign(err, extra);
+    console.error(JSON.stringify(err));
+  }
+}
+function outputSuccess(message, data) {
+  if (humanMode) {
+    console.log(`${chalk.green("✓")} ${message}`);
+    if (data) {
+      for (const [key, value] of Object.entries(data)) {
+        console.log(`  ${chalk.cyan(key + ":")} ${value}`);
+      }
+    }
+  } else {
+    const result = { success: true, message };
+    if (data)
+      Object.assign(result, data);
+    output(result);
+  }
+}
+var humanMode = false, quietMode = false;
+var init_output = () => {};
+
+// package.json
+var package_default;
+var init_package = __esm(() => {
+  package_default = {
+    name: "danube-cli",
+    version: "0.2.0",
+    description: "Danube CLI — agent-first tool infrastructure for AI agents",
+    type: "module",
+    license: "MIT",
+    repository: {
+      type: "git",
+      url: "https://github.com/danubeai/danube-cli"
+    },
+    keywords: ["danube", "cli", "ai", "tools", "mcp", "agent"],
+    bin: {
+      danube: "./dist/danube.mjs"
+    },
+    files: [
+      "dist",
+      "README.md"
+    ],
+    scripts: {
+      dev: "bun run bin/danube.ts",
+      build: "bash scripts/build.sh",
+      prepublishOnly: "npm run build",
+      test: "bun test"
+    },
+    dependencies: {
+      chalk: "^5.4.1",
+      commander: "^13.1.0"
+    },
+    devDependencies: {
+      "@types/bun": "latest",
+      typescript: "^5.8.0"
+    }
+  };
+});
+
+// src/lib/version.ts
+var VERSION;
+var init_version = __esm(() => {
+  init_package();
+  VERSION = package_default.version;
+});
+
+// src/index.ts
+import { Command } from "commander";
+var ctx;
+var init_src = __esm(() => {
+  init_output();
+  init_version();
+  ctx = {
+    human: false,
+    apiKey: undefined,
+    profile: "default",
+    verbose: false,
+    quiet: false,
+    noColor: false
+  };
+});
+
+// src/lib/errors.ts
+function handleErrors(fn) {
+  return async (...args) => {
+    try {
+      await fn(...args);
+    } catch (e) {
+      if (e instanceof ConfigurationRequiredError) {
+        outputError("auth_required", e.message, {
+          fix: e.serviceName ? `danube connect ${e.serviceName.toLowerCase().replace(/ /g, "-")}` : undefined,
+          service_id: e.serviceId,
+          configuration_url: e.configurationUrl
+        });
+        process.exit(EXIT_AUTH);
+      } else if (e instanceof AuthenticationError) {
+        outputError("not_authenticated", e.message, { fix: "danube login" });
+        process.exit(EXIT_AUTH);
+      } else if (e instanceof AuthorizationError) {
+        outputError("forbidden", e.message);
+        process.exit(EXIT_AUTH);
+      } else if (e instanceof RateLimitError) {
+        outputError("rate_limited", e.message, { retry_after: e.retryAfter });
+        process.exit(EXIT_RATE_LIMIT);
+      } else if (e instanceof NotFoundError) {
+        outputError("not_found", e.message, { resource: e.resource, identifier: e.identifier });
+        process.exit(EXIT_ERROR);
+      } else if (e instanceof ValidationError) {
+        outputError("validation_error", e.message);
+        process.exit(EXIT_ERROR);
+      } else if (e instanceof TimeoutError) {
+        outputError("timeout", e.message);
+        process.exit(EXIT_ERROR);
+      } else if (e instanceof ConnectionError) {
+        outputError("connection_error", e.message);
+        process.exit(EXIT_ERROR);
+      } else if (e instanceof DanubeError) {
+        outputError("error", e.message);
+        process.exit(EXIT_ERROR);
+      } else {
+        throw e;
+      }
+    }
+  };
+}
+var EXIT_ERROR = 1, EXIT_AUTH = 2, EXIT_RATE_LIMIT = 3, DanubeError, AuthenticationError, AuthorizationError, NotFoundError, ValidationError, RateLimitError, ConfigurationRequiredError, ConnectionError, TimeoutError;
+var init_errors = __esm(() => {
+  init_output();
+  DanubeError = class DanubeError extends Error {
+    statusCode;
+    constructor(message, statusCode) {
+      super(message);
+      this.statusCode = statusCode;
+      this.name = "DanubeError";
+    }
+  };
+  AuthenticationError = class AuthenticationError extends DanubeError {
+    constructor(message = "Not authenticated. Run 'danube login' to authenticate.") {
+      super(message, 401);
+      this.name = "AuthenticationError";
+    }
+  };
+  AuthorizationError = class AuthorizationError extends DanubeError {
+    constructor(message = "Forbidden.") {
+      super(message, 403);
+      this.name = "AuthorizationError";
+    }
+  };
+  NotFoundError = class NotFoundError extends DanubeError {
+    resource;
+    identifier;
+    constructor(message, resource, identifier) {
+      super(message, 404);
+      this.resource = resource;
+      this.identifier = identifier;
+      this.name = "NotFoundError";
+    }
+  };
+  ValidationError = class ValidationError extends DanubeError {
+    constructor(message) {
+      super(message, 422);
+      this.name = "ValidationError";
+    }
+  };
+  RateLimitError = class RateLimitError extends DanubeError {
+    retryAfter;
+    constructor(message = "Rate limited.", retryAfter) {
+      super(message, 429);
+      this.retryAfter = retryAfter;
+      this.name = "RateLimitError";
+    }
+  };
+  ConfigurationRequiredError = class ConfigurationRequiredError extends DanubeError {
+    serviceName;
+    serviceId;
+    configurationUrl;
+    constructor(message, serviceName, serviceId, configurationUrl) {
+      super(message, 412);
+      this.serviceName = serviceName;
+      this.serviceId = serviceId;
+      this.configurationUrl = configurationUrl;
+      this.name = "ConfigurationRequiredError";
+    }
+  };
+  ConnectionError = class ConnectionError extends DanubeError {
+    constructor(message = "Failed to connect to the Danube API.") {
+      super(message);
+      this.name = "ConnectionError";
+    }
+  };
+  TimeoutError = class TimeoutError extends DanubeError {
+    constructor(message = "Request timed out.") {
+      super(message);
+      this.name = "TimeoutError";
+    }
+  };
+});
+
+// src/lib/config.ts
+import { chmodSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+function ensureConfigDir() {
+  const { mkdirSync } = __require("node:fs");
+  try {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  } catch {}
+}
+function readConfig() {
+  try {
+    const text = __require("node:fs").readFileSync(CONFIG_FILE, "utf-8");
+    return JSON.parse(text);
+  } catch {
+    return {};
+  }
+}
+function writeConfig(config) {
+  ensureConfigDir();
+  const { writeFileSync } = __require("node:fs");
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + `
+`, "utf-8");
+  chmodSync(CONFIG_FILE, 384);
+}
+function getProfile(profile = "default") {
+  const config = readConfig();
+  return config.profiles?.[profile] ?? {};
+}
+function saveApiKey(apiKey, profile = "default") {
+  const config = readConfig();
+  if (!config.profiles)
+    config.profiles = {};
+  if (!config.profiles[profile])
+    config.profiles[profile] = {};
+  config.profiles[profile].api_key = apiKey;
+  writeConfig(config);
+}
+function removeApiKey(profile = "default") {
+  const config = readConfig();
+  if (config.profiles?.[profile]) {
+    delete config.profiles[profile].api_key;
+    writeConfig(config);
+  }
+}
+function getApiKey(flagApiKey, profile = "default") {
+  if (flagApiKey)
+    return flagApiKey;
+  const envKey = process.env.DANUBE_API_KEY;
+  if (envKey)
+    return envKey;
+  return getProfile(profile).api_key;
+}
+function getBaseUrl(profile = "default") {
+  const envUrl = process.env.DANUBE_API_URL;
+  if (envUrl)
+    return envUrl;
+  return getProfile(profile).base_url ?? DEFAULT_BASE_URL;
+}
+function configSet(key, value, profile = "default") {
+  const config = readConfig();
+  if (!config.profiles)
+    config.profiles = {};
+  if (!config.profiles[profile])
+    config.profiles[profile] = {};
+  config.profiles[profile][key] = value;
+  writeConfig(config);
+}
+function configGet(key, profile = "default") {
+  return getProfile(profile)[key];
+}
+function listProfiles() {
+  const config = readConfig();
+  return Object.keys(config.profiles ?? {});
+}
+var CONFIG_DIR, CONFIG_FILE, DEFAULT_BASE_URL = "https://api.danubeai.com";
+var init_config = __esm(() => {
+  CONFIG_DIR = join(homedir(), ".danube");
+  CONFIG_FILE = join(CONFIG_DIR, "config.json");
+});
+
+// src/lib/api.ts
+class ApiClient {
+  baseUrl;
+  apiKey;
+  constructor(baseUrl, apiKey) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+  }
+  async request(method, path, opts) {
+    const url = new URL(path, this.baseUrl);
+    if (opts?.params) {
+      for (const [k, v] of Object.entries(opts.params)) {
+        if (v !== undefined)
+          url.searchParams.set(k, v);
+      }
+    }
+    const headers = {
+      "User-Agent": `danube-cli/${VERSION}`,
+      "Content-Type": "application/json"
+    };
+    if (!opts?.noAuth && this.apiKey) {
+      headers["danube-api-key"] = this.apiKey;
+    }
+    let response;
+    try {
+      response = await fetch(url.toString(), {
+        method,
+        headers,
+        body: opts?.body ? JSON.stringify(opts.body) : undefined,
+        signal: AbortSignal.timeout(60000)
+      });
+    } catch (e) {
+      if (e instanceof DOMException && e.name === "AbortError") {
+        throw new TimeoutError(`Request timed out: ${method} ${path}`);
+      }
+      throw new ConnectionError(`Failed to connect to ${this.baseUrl}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    if (response.ok) {
+      const text = await response.text();
+      if (!text)
+        return;
+      return JSON.parse(text);
+    }
+    let errorBody = {};
+    try {
+      errorBody = await response.json();
+    } catch {}
+    const detail = errorBody.detail ?? errorBody.message ?? response.statusText;
+    switch (response.status) {
+      case 401:
+        throw new AuthenticationError(detail);
+      case 403:
+        throw new AuthorizationError(detail);
+      case 404:
+        throw new NotFoundError(detail);
+      case 412:
+        throw new ConfigurationRequiredError(detail, errorBody.service_name, errorBody.service_id, errorBody.configuration_url);
+      case 422:
+        throw new ValidationError(detail);
+      case 429: {
+        const retryAfter = response.headers.get("retry-after");
+        throw new RateLimitError(detail, retryAfter ? parseInt(retryAfter) : undefined);
+      }
+      default:
+        throw new DanubeError(`${response.status}: ${detail}`, response.status);
+    }
+  }
+  async get(path, params) {
+    return this.request("GET", path, { params });
+  }
+  async post(path, body) {
+    return this.request("POST", path, { body });
+  }
+  async delete(path) {
+    return this.request("DELETE", path);
+  }
+  async put(path, body) {
+    return this.request("PUT", path, { body });
+  }
+  async patch(path, body) {
+    return this.request("PATCH", path, { body });
+  }
+  async publicPost(path, body) {
+    return this.request("POST", path, { body, noAuth: true });
+  }
+  async publicGet(path, params) {
+    return this.request("GET", path, { params, noAuth: true });
+  }
+}
+function getClient(flagApiKey, profile = "default") {
+  const apiKey = getApiKey(flagApiKey, profile);
+  if (!apiKey) {
+    outputError("not_authenticated", "No API key found. Run 'danube login' to authenticate.", {
+      fix: "danube login"
+    });
+    process.exit(2);
+  }
+  return new ApiClient(getBaseUrl(profile), apiKey);
+}
+function getPublicClient(profile = "default") {
+  return new ApiClient(getBaseUrl(profile));
+}
+var init_api = __esm(() => {
+  init_errors();
+  init_config();
+  init_output();
+  init_version();
+});
+
+// src/commands/auth.ts
+var exports_auth = {};
+__export(exports_auth, {
+  register: () => register
+});
+import chalk2 from "chalk";
+function register(program) {
+  program.command("login").description("Log in to Danube via device code (opens browser)").action(handleErrors(async () => {
+    const baseUrl = getBaseUrl(ctx.profile);
+    const client = new ApiClient(baseUrl);
+    const data = await client.publicPost("/v1/auth/device/code", {
+      client_name: "danube-cli"
+    });
+    if (humanMode) {
+      console.log();
+      console.log(chalk2.bold("  Enter this code:"));
+      console.log();
+      console.log(`    ${chalk2.bold.white.bgCyan(` ${data.user_code} `)}`);
+      console.log();
+      console.log(chalk2.dim(`  ${data.verification_url}`));
+      console.log();
+    } else {
+      output({
+        user_code: data.user_code,
+        verification_url: data.verification_url,
+        expires_in: data.expires_in
+      });
+    }
+    try {
+      const url = `${data.verification_url}?code=${data.user_code}`;
+      if (process.platform === "darwin") {
+        Bun.spawn(["open", url]);
+      } else if (process.platform === "linux") {
+        Bun.spawn(["xdg-open", url]);
+      } else {
+        Bun.spawn(["start", url]);
+      }
+      if (humanMode) {
+        console.log(chalk2.dim("  Browser opened. Waiting for authorization..."));
+      }
+    } catch {
+      if (humanMode) {
+        console.log(chalk2.dim(`  Open ${data.verification_url} in your browser`));
+      }
+    }
+    const start = Date.now();
+    const expiresMs = data.expires_in * 1000;
+    const intervalMs = data.interval * 1000;
+    while (Date.now() - start < expiresMs) {
+      await Bun.sleep(intervalMs);
+      try {
+        const tokenData = await client.publicPost("/v1/auth/device/token", { device_code: data.device_code });
+        saveApiKey(tokenData.api_key, ctx.profile);
+        if (humanMode) {
+          console.log(`
+${chalk2.green("✓")} Authenticated successfully!`);
+          console.log(`  API key saved to profile ${chalk2.cyan(ctx.profile)}`);
+          console.log();
+          console.log(chalk2.bold("  Next steps:"));
+          console.log(`  ${chalk2.dim("$")} danube search "send email"     ${chalk2.dim("# Find tools")}`);
+          console.log(`  ${chalk2.dim("$")} danube execute <tool> -d '{}'  ${chalk2.dim("# Run a tool")}`);
+          console.log(`  ${chalk2.dim("$")} danube services list           ${chalk2.dim("# Browse services")}`);
+          console.log();
+        } else {
+          output({
+            success: true,
+            key_prefix: tokenData.key_prefix ?? tokenData.api_key.slice(0, 8)
+          });
+        }
+        return;
+      } catch (e) {
+        const err = e;
+        if (err.statusCode === 428) {
+          if (humanMode) {
+            process.stdout.write(chalk2.dim("."));
+          }
+          continue;
+        }
+        if (err.statusCode === 410) {
+          outputError("expired", "Device code expired. Please try again.", { fix: "danube login" });
+          process.exit(1);
+        }
+        throw e;
+      }
+    }
+    outputError("timeout", "Login timed out. Please try again.", { fix: "danube login" });
+    process.exit(1);
+  }));
+  program.command("logout").description("Remove stored credentials").action(handleErrors(async () => {
+    removeApiKey(ctx.profile);
+    outputSuccess(`Logged out from profile '${ctx.profile}'`);
+  }));
+  program.command("whoami").description("Show current identity").action(handleErrors(async () => {
+    const client = getClient(ctx.apiKey, ctx.profile);
+    const identity = await client.get("/v1/identity/api");
+    if (humanMode) {
+      console.log();
+      const aboutMe = identity.about_me;
+      if (aboutMe?.name)
+        console.log(`  ${chalk2.cyan("Name:")} ${aboutMe.name}`);
+      if (aboutMe?.role)
+        console.log(`  ${chalk2.cyan("Role:")} ${aboutMe.role}`);
+      console.log(`  ${chalk2.cyan("Profile:")} ${ctx.profile}`);
+      if (Object.keys(identity).length === 0) {
+        console.log(chalk2.dim("  No identity attributes set yet."));
+      }
+      console.log();
+    } else {
+      output({
+        identity,
+        profile: ctx.profile
+      });
+    }
+  }));
+}
+var init_auth = __esm(() => {
+  init_src();
+  init_api();
+  init_config();
+  init_errors();
+  init_output();
+  init_api();
+});
+
+// src/commands/search.ts
+var exports_search = {};
+__export(exports_search, {
+  register: () => register2
+});
+function register2(program) {
+  program.command("search <query>").description("Find tools via semantic search. Use this first.").option("--service <id>", "Filter by service slug or ID").option("--limit <n>", "Maximum results", "10").addHelpText("after", `
+Examples:
+  $ danube search "send email"
+  $ danube search "weather" --limit 5`).action(handleErrors(async (query, opts) => {
+    const client = getClient(ctx.apiKey, ctx.profile);
+    const tools = await client.get("/v1/tools/search", {
+      query,
+      service_id: opts.service,
+      limit: opts.limit
+    });
+    outputTable(tools, [
+      { header: "ID", key: "id", style: "dim" },
+      { header: "Name", key: "name", style: "bold" },
+      { header: "Description", key: "description" },
+      { header: "Service", key: "service_name" }
+    ], `Tools matching '${query}'`);
+  }));
+}
+var init_search = __esm(() => {
+  init_src();
+  init_api();
+  init_errors();
+  init_output();
+});
+
+// src/lib/data-input.ts
+async function parseData(data) {
+  if (!data)
+    return {};
+  data = data.trim();
+  if (data === "-") {
+    const raw = await Bun.stdin.text();
+    if (!raw.trim())
+      return {};
+    try {
+      return JSON.parse(raw);
+    } catch (e) {
+      outputError("invalid_input", `Invalid JSON from stdin: ${e instanceof Error ? e.message : String(e)}`);
+      process.exit(1);
+    }
+  }
+  if (data.startsWith("@")) {
+    const filepath = data.slice(1);
+    const file = Bun.file(filepath);
+    if (!await file.exists()) {
+      outputError("file_not_found", `File not found: ${filepath}`);
+      process.exit(1);
+    }
+    try {
+      return JSON.parse(await file.text());
+    } catch (e) {
+      outputError("invalid_input", `Invalid JSON in ${filepath}: ${e instanceof Error ? e.message : String(e)}`);
+      process.exit(1);
+    }
+  }
+  try {
+    return JSON.parse(data);
+  } catch (e) {
+    outputError("invalid_input", `Invalid JSON: ${e instanceof Error ? e.message : String(e)}`);
+    process.exit(1);
+  }
+}
+var init_data_input = __esm(() => {
+  init_output();
+});
+
+// src/lib/resolve.ts
+function isUUID(value) {
+  return UUID_RE.test(value);
+}
+async function resolveTool(client, tool) {
+  if (isUUID(tool)) {
+    return client.publicGet(`/v1/tools/public/${tool}`);
+  }
+  const results = await client.get("/v1/tools/search", { query: tool, limit: "1" });
+  if (!results.length) {
+    outputError("not_found", `No tool found matching '${tool}'`);
+    process.exit(1);
+  }
+  return client.publicGet(`/v1/tools/public/${results[0].id}`);
+}
+var UUID_RE;
+var init_resolve = __esm(() => {
+  init_output();
+  UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+});
+
+// src/commands/execute.ts
+var exports_execute = {};
+__export(exports_execute, {
+  register: () => register3
+});
+function register3(program) {
+  program.command("execute <tool>").description("Run a tool. Handles validation and auth checks automatically.").option("-d, --data <json>", "JSON args: '{...}', @file, or - for stdin").option("--dry-run", "Validate without executing", false).option("--get-schema", "Print the tool's parameter schema", false).addHelpText("after", `
+Examples:
+  $ danube execute gmail-send-email -d '{"to":"a@b.com","subject":"Hi"}'
+  $ danube execute <tool-id> -d @params.json
+  $ danube execute <tool-name> --get-schema
+  $ danube execute <tool-name> --dry-run`).action(handleErrors(async (tool, opts) => {
+    const client = getClient(ctx.apiKey, ctx.profile);
+    if (opts.getSchema) {
+      const toolInfo = await resolveTool(client, tool);
+      output({
+        id: toolInfo.id,
+        name: toolInfo.name,
+        description: toolInfo.description,
+        parameters: toolInfo.parameters
+      });
+      return;
+    }
+    const params = await parseData(opts.data);
+    if (opts.dryRun) {
+      const toolInfo = await resolveTool(client, tool);
+      output({
+        dry_run: true,
+        tool_id: toolInfo.id,
+        tool_name: toolInfo.name,
+        parameters: params,
+        cost_cents: toolInfo.price_per_call_cents
+      });
+      return;
+    }
+    let toolId = tool;
+    if (!isUUID(tool)) {
+      const toolInfo = await resolveTool(client, tool);
+      toolId = toolInfo.id;
+    }
+    const result = await client.post(`/v1/tools/call/${toolId}`, {
+      parameters: params
+    });
+    output({
+      success: result.success,
+      result: result.result,
+      error: result.error,
+      tool_id: result.tool_id,
+      tool_name: result.tool_name,
+      duration_ms: result.duration_ms
+    });
+  }));
+}
+var init_execute = __esm(() => {
+  init_src();
+  init_api();
+  init_data_input();
+  init_errors();
+  init_output();
+  init_resolve();
+});
+
+// src/commands/connect.ts
+var exports_connect = {};
+__export(exports_connect, {
+  register: () => register4
+});
+import chalk3 from "chalk";
+import { createInterface } from "node:readline";
+async function promptSecret(prompt) {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) => {
+    process.stderr.write(prompt);
+    rl.question("", (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+function register4(program) {
+  program.command("connect <service>").description("Authenticate to a service (interactive). See also: credentials store").addHelpText("after", `
+Examples:
+  $ danube connect gmail
+  $ danube connect openai`).action(handleErrors(async (service) => {
+    const client = getClient(ctx.apiKey, ctx.profile);
+    const allServices = await client.publicGet("/v1/services/public");
+    const query = service.toLowerCase();
+    let target = allServices.find((s) => s.name.toLowerCase() === query || s.id === service);
+    if (!target) {
+      const matches = allServices.filter((s) => s.name.toLowerCase().includes(query) || (s.description ?? "").toLowerCase().includes(query));
+      if (matches.length) {
+        target = matches[0];
+      }
+    }
+    if (!target) {
+      outputError("not_found", `No service found matching '${service}'`);
+      process.exit(1);
+    }
+    if (humanMode) {
+      console.log(`
+Connecting to ${chalk3.bold(target.name)}...`);
+      console.log(`  Service ID: ${chalk3.dim(target.id)}`);
+      console.log();
+    }
+    let apiKeyValue;
+    if (humanMode) {
+      apiKeyValue = await promptSecret("  Enter API key: ");
+    } else {
+      apiKeyValue = (await Bun.stdin.text()).trim();
+      if (!apiKeyValue) {
+        outputError("invalid_input", "No credential provided on stdin");
+        process.exit(1);
+      }
+    }
+    const result = await client.post("/v1/credentials/store", {
+      service_id: target.id,
+      credential_type: "api_key",
+      credential_value: apiKeyValue
+    });
+    outputSuccess(`Connected to ${target.name}`, {
+      service_id: target.id,
+      credential_type: "api_key"
+    });
+  }));
+}
+var init_connect = __esm(() => {
+  init_src();
+  init_api();
+  init_errors();
+  init_output();
+});
+
+// src/commands/completion.ts
+var exports_completion = {};
+__export(exports_completion, {
+  register: () => register5
+});
+function register5(program) {
+  program.command("completion <shell>").description("Generate shell completion script (bash, zsh, fish)").addHelpText("after", `
+Examples:
+  $ danube completion bash >> ~/.bashrc
+  $ danube completion zsh >> ~/.zshrc
+  $ danube completion fish > ~/.config/fish/completions/danube.fish`).action(handleErrors(async (shell) => {
+    switch (shell) {
+      case "bash":
+        console.log(BASH_COMPLETION);
+        break;
+      case "zsh":
+        console.log(ZSH_COMPLETION);
+        break;
+      case "fish":
+        console.log(FISH_COMPLETION);
+        break;
+      default:
+        outputError("invalid_input", `Unsupported shell: ${shell}. Use bash, zsh, or fish.`);
+        process.exit(1);
+    }
+  }));
+}
+var BASH_COMPLETION = `#!/usr/bin/env bash
+_danube_completions() {
+  local cur prev commands
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  commands="search execute connect login logout whoami tools services workflows skills wallet credentials keys sites agent config completion"
+
+  case "\${prev}" in
+    danube)
+      COMPREPLY=($(compgen -W "\${commands}" -- "\${cur}"))
+      return 0
+      ;;
+    tools)
+      COMPREPLY=($(compgen -W "info list batch search rate ratings report recommend" -- "\${cur}"))
+      return 0
+      ;;
+    services)
+      COMPREPLY=($(compgen -W "list info tools" -- "\${cur}"))
+      return 0
+      ;;
+    workflows)
+      COMPREPLY=($(compgen -W "list info run status create update delete" -- "\${cur}"))
+      return 0
+      ;;
+    skills)
+      COMPREPLY=($(compgen -W "search get create update delete" -- "\${cur}"))
+      return 0
+      ;;
+    wallet)
+      COMPREPLY=($(compgen -W "balance transactions limits set-limits" -- "\${cur}"))
+      return 0
+      ;;
+    credentials)
+      COMPREPLY=($(compgen -W "store" -- "\${cur}"))
+      return 0
+      ;;
+    keys)
+      COMPREPLY=($(compgen -W "list create rotate revoke" -- "\${cur}"))
+      return 0
+      ;;
+    sites)
+      COMPREPLY=($(compgen -W "search get" -- "\${cur}"))
+      return 0
+      ;;
+    agent)
+      COMPREPLY=($(compgen -W "register info fund" -- "\${cur}"))
+      return 0
+      ;;
+    config)
+      COMPREPLY=($(compgen -W "set get profiles" -- "\${cur}"))
+      return 0
+      ;;
+  esac
+}
+complete -F _danube_completions danube
+`, ZSH_COMPLETION = `#compdef danube
+
+_danube() {
+  local -a commands subcommands
+  commands=(
+    'search:Find tools via semantic search'
+    'execute:Run a tool'
+    'connect:Authenticate to a service'
+    'login:Log in to Danube'
+    'logout:Remove stored credentials'
+    'whoami:Show current identity'
+    'tools:Inspect tools, ratings, and batch executions'
+    'services:Browse and inspect available services'
+    'workflows:List, run, and manage workflows'
+    'skills:Search, view, and manage skills'
+    'wallet:View wallet balance, transactions, and limits'
+    'credentials:Store service credentials'
+    'keys:Manage API keys'
+    'sites:Search the agent web directory'
+    'agent:Register and manage autonomous agents'
+    'config:Manage CLI configuration'
+    'completion:Generate shell completion script'
+  )
+
+  _arguments -C \\
+    '--human[Human-readable output]' \\
+    '--json[Machine-readable JSON output]' \\
+    '--api-key[Override API key]:key' \\
+    '--profile[Use named profile]:profile' \\
+    '-v[Verbose output]' \\
+    '-q[Suppress non-essential output]' \\
+    '--no-color[Disable colored output]' \\
+    '--version[Show version]' \\
+    '1:command:->command' \\
+    '*::arg:->args'
+
+  case $state in
+    command)
+      _describe 'command' commands
+      ;;
+  esac
+}
+
+_danube
+`, FISH_COMPLETION = `# Fish completions for danube
+complete -c danube -f
+
+# Top-level commands
+complete -c danube -n '__fish_use_subcommand' -a search -d 'Find tools via semantic search'
+complete -c danube -n '__fish_use_subcommand' -a execute -d 'Run a tool'
+complete -c danube -n '__fish_use_subcommand' -a connect -d 'Authenticate to a service'
+complete -c danube -n '__fish_use_subcommand' -a login -d 'Log in to Danube'
+complete -c danube -n '__fish_use_subcommand' -a logout -d 'Remove stored credentials'
+complete -c danube -n '__fish_use_subcommand' -a whoami -d 'Show current identity'
+complete -c danube -n '__fish_use_subcommand' -a tools -d 'Inspect tools'
+complete -c danube -n '__fish_use_subcommand' -a services -d 'Browse services'
+complete -c danube -n '__fish_use_subcommand' -a workflows -d 'Manage workflows'
+complete -c danube -n '__fish_use_subcommand' -a skills -d 'Search and manage skills'
+complete -c danube -n '__fish_use_subcommand' -a wallet -d 'View wallet'
+complete -c danube -n '__fish_use_subcommand' -a credentials -d 'Store credentials'
+complete -c danube -n '__fish_use_subcommand' -a keys -d 'Manage API keys'
+complete -c danube -n '__fish_use_subcommand' -a sites -d 'Agent web directory'
+complete -c danube -n '__fish_use_subcommand' -a agent -d 'Register and manage agents'
+complete -c danube -n '__fish_use_subcommand' -a config -d 'CLI configuration'
+complete -c danube -n '__fish_use_subcommand' -a completion -d 'Shell completions'
+
+# Subcommands
+complete -c danube -n '__fish_seen_subcommand_from tools' -a 'info list batch search rate ratings report recommend'
+complete -c danube -n '__fish_seen_subcommand_from services' -a 'list info tools'
+complete -c danube -n '__fish_seen_subcommand_from workflows' -a 'list info run status create update delete'
+complete -c danube -n '__fish_seen_subcommand_from skills' -a 'search get create update delete'
+complete -c danube -n '__fish_seen_subcommand_from wallet' -a 'balance transactions limits set-limits'
+complete -c danube -n '__fish_seen_subcommand_from credentials' -a 'store'
+complete -c danube -n '__fish_seen_subcommand_from keys' -a 'list create rotate revoke'
+complete -c danube -n '__fish_seen_subcommand_from sites' -a 'search get'
+complete -c danube -n '__fish_seen_subcommand_from agent' -a 'register info fund'
+complete -c danube -n '__fish_seen_subcommand_from config' -a 'set get profiles'
+
+# Global options
+complete -c danube -l human -d 'Human-readable output'
+complete -c danube -l json -d 'Machine-readable JSON output'
+complete -c danube -l api-key -x -d 'Override API key'
+complete -c danube -l profile -x -d 'Use named profile'
+complete -c danube -s v -l verbose -d 'Verbose output'
+complete -c danube -s q -l quiet -d 'Suppress non-essential output'
+complete -c danube -l no-color -d 'Disable colored output'
+complete -c danube -l version -d 'Show version'
+`;
+var init_completion = __esm(() => {
+  init_errors();
+  init_output();
+});
+
+// src/commands/tools.ts
+var exports_tools = {};
+__export(exports_tools, {
+  register: () => register6
+});
+function register6(program) {
+  const tools = program.command("tools").description("Inspect tools and run batch executions.");
+  tools.command("info <tool>").description("Print tool summary and parameter schema").action(handleErrors(async (tool) => {
+    const client = getClient(ctx.apiKey, ctx.profile);
+    const toolInfo = await resolveTool(client, tool);
+    outputDetail(toolInfo, toolInfo.name);
+  }));
+  tools.command("list [service]").description("List tools, optionally filtered by service").option("--limit <n>", "Maximum results", "50").action(handleErrors(async (service, opts) => {
+    const client = getClient(ctx.apiKey, ctx.profile);
+    let toolList;
+    if (service) {
+      toolList = await client.get("/v1/tools/search", {
+        service_id: service,
+        limit: opts.limit
+      });
+    } else {
+      toolList = await client.get("/v1/tools/search", { limit: opts.limit });
+    }
+    outputTable(toolList, [
+      { header: "ID", key: "id", style: "dim" },
+      { header: "Name", key: "name", style: "bold" },
+      { header: "Description", key: "description" }
+    ]);
+  }));
+  tools.command("batch <file>").description("Batch execute up to 10 tools from a JSON file").action(handleErrors(async (file) => {
+    const f = Bun.file(file);
+    if (!await f.exists()) {
+      outputError("file_not_found", `File not found: ${file}`);
+      process.exit(1);
+    }
+    let calls;
+    try {
+      const parsed = JSON.parse(await f.text());
+      if (!Array.isArray(parsed)) {
+        outputError("invalid_input", "Batch file must contain a JSON array");
+        process.exit(1);
+      }
+      calls = parsed;
+    } catch (e) {
+      outputError("invalid_input", `Invalid JSON in ${file}: ${e instanceof Error ? e.message : String(e)}`);
+      process.exit(1);
+    }
+    const client = getClient(ctx.apiKey, ctx.profile);
+    const results = await client.post("/v1/tools/call/batch", calls);
+    output(results);
+  }));
+  tools.command("search <query>").description("Search for tools by name or description").option("--service <id>", "Filter by service ID").option("--limit <n>", "Maximum results", "10").action(handleErrors(async (query, opts) => {
+    const client = getClient(ctx.apiKey, ctx.profile);
+    const result = await client.get("/v1/tools/search", {
+      query,
+      service_id: opts.service,
+      limit: opts.limit
+    });
+    outputTable(result, [
+      { header: "ID", key: "id", style: "dim" },
+      { header: "Name", key: "name", style: "bold" },
+      { header: "Description", key: "description" },
+      { header: "Service", key: "service_name" }
+    ], `Tools matching '${query}'`);
+  }));
+  tools.command("rate <tool> <rating>").description("Rate a tool (1-5 stars)").option("--comment <text>", "Optional comment").action(handleErrors(async (tool, rating, opts) => {
+    const client = getClient(ctx.apiKey, ctx.profile);
+    const toolInfo = await resolveTool(client, tool);
+    const ratingNum = parseInt(rating, 10);
+    if (isNaN(ratingNum) || ratingNum < 1 || ratingNum > 5) {
+      outputError("invalid_input", "Rating must be between 1 and 5");
+      process.exit(1);
+    }
+    const result = await client.post("/v1/ratings", {
+      tool_id: toolInfo.id,
+      rating: ratingNum,
+      comment: opts.comment
+    });
+    outputSuccess(`Rated ${toolInfo.name}: ${"★".repeat(ratingNum)}${"☆".repeat(5 - ratingNum)}`);
+  }));
+  tools.command("ratings <tool>").description("View ratings for a tool").action(handleErrors(async (tool) => {
+    const client = getClient(ctx.apiKey, ctx.profile);
+    const toolInfo = await resolveTool(client, tool);
+    const ratings = await client.publicGet(`/v1/ratings/tool/${toolInfo.id}`);
+    outputDetail(ratings, `Ratings for ${toolInfo.name}`);
+  }));
+  tools.command("report <tool>").description("Report a broken or degraded tool").option("--reason <reason>", "Reason: broken, degraded, incorrect_output, timeout, other", "broken").option("--description <text>", "Additional details").action(handleErrors(async (tool, opts) => {
+    const client = getClient(ctx.apiKey, ctx.profile);
+    const toolInfo = await resolveTool(client, tool);
+    const validReasons = ["broken", "degraded", "incorrect_output", "timeout", "other"];
+    if (!validReasons.includes(opts.reason)) {
+      outputError("invalid_input", `Invalid reason. Must be one of: ${validReasons.join(", ")}`);
+      process.exit(1);
+    }
+    await client.post(`/v1/tools/${toolInfo.id}/report`, {
+      reason: opts.reason,
+      description: opts.description
+    });
+    outputSuccess(`Reported ${toolInfo.name} as ${opts.reason}`);
+  }));
+  tools.command("recommend <tool>").description("Get tool recommendations based on co-usage").option("--limit <n>", "Maximum recommendations", "5").action(handleErrors(async (tool, opts) => {
+    const client = getClient(ctx.apiKey, ctx.profile);
+    const toolInfo = await resolveTool(client, tool);
+    const result = await client.get("/v1/tools/recommended", {
+      tool_id: toolInfo.id,
+      limit: opts.limit
+    });
+    outputTable(result, [
+      { header: "ID", key: "id", style: "dim" },
+      { header: "Name", key: "name", style: "bold" },
+      { header: "Description", key: "description" }
+    ], `Recommended tools based on ${toolInfo.name}`);
+  }));
+}
+var init_tools = __esm(() => {
+  init_src();
+  init_api();
+  init_errors();
+  init_output();
+  init_resolve();
+});
+
+// src/commands/services.ts
+var exports_services = {};
+__export(exports_services, {
+  register: () => register7
+});
+function register7(program) {
+  const services = program.command("services").description("Browse and inspect available services.");
+  services.command("list [query]").description("List or search available services").option("--limit <n>", "Maximum results", "10").action(handleErrors(async (query, opts) => {
+    const client = getPublicClient(ctx.profile);
+    let result = await client.publicGet("/v1/services/public", {
+      limit: opts.limit
+    });
+    if (query) {
+      const q = query.toLowerCase();
+      result = result.filter((s) => s.name.toLowerCase().includes(q) || (s.description ?? "").toLowerCase().includes(q));
+    }
+    outputTable(result, [
+      { header: "ID", key: "id", style: "dim" },
+      { header: "Name", key: "name", style: "bold" },
+      { header: "Type", key: "service_type" },
+      { header: "Description", key: "description" },
+      { header: "Tools", key: "tool_count" }
+    ], "Services");
+  }));
+  services.command("info <serviceId>").description("Get service details").action(handleErrors(async (serviceId) => {
+    const client = getPublicClient(ctx.profile);
+    const service = await client.publicGet(`/v1/services/public/${serviceId}`);
+    outputDetail(service, service.name);
+  }));
+  services.command("tools <serviceId>").description("List tools for a specific service").action(handleErrors(async (serviceId) => {
+    const client = getPublicClient(ctx.profile);
+    const result = await client.publicGet(`/v1/services/public/${serviceId}/tools`);
+    outputTable(result, [
+      { header: "ID", key: "id", style: "dim" },
+      { header: "Name", key: "name", style: "bold" },
+      { header: "Description", key: "description" }
+    ], "Service Tools");
+  }));
+}
+var init_services = __esm(() => {
+  init_src();
+  init_api();
+  init_errors();
+  init_output();
+});
+
+// src/commands/workflows.ts
+var exports_workflows = {};
+__export(exports_workflows, {
+  register: () => register8
+});
+function register8(program) {
+  const workflows = program.command("workflows").description("List, run, and manage workflows.");
+  workflows.command("list [query]").description("List public workflows").option("--limit <n>", "Maximum results", "10").action(handleErrors(async (query, opts) => {
+    const client = getPublicClient(ctx.profile);
+    const result = await client.publicGet("/v1/workflows/public", {
+      search: query ?? "",
+      limit: opts.limit
+    });
+    outputTable(result, [
+      { header: "ID", key: "id", style: "dim" },
+      { header: "Name", key: "name", style: "bold" },
+      { header: "Description", key: "description" },
+      { header: "Steps", key: "step_count" }
+    ], "Workflows");
+  }));
+  workflows.command("info <workflowId>").description("Get workflow details").action(handleErrors(async (workflowId) => {
+    const client = getClient(ctx.apiKey, ctx.profile);
+    const workflow = await client.get(`/v1/workflows/${workflowId}`);
+    outputDetail(workflow, workflow.name);
+  }));
+  workflows.command("run <workflowId>").description("Execute a workflow with inputs").option("-d, --data <json>", "Inputs as JSON, @file, or - for stdin").action(handleErrors(async (workflowId, opts) => {
+    const client = getClient(ctx.apiKey, ctx.profile);
+    const inputs = await parseData(opts.data);
+    const execution = await client.post(`/v1/workflows/${workflowId}/execute`, { inputs });
+    outputDetail(execution, `Workflow Execution ${execution.id}`);
+  }));
+  workflows.command("status <executionId>").description("Check workflow execution status").action(handleErrors(async (executionId) => {
+    const client = getClient(ctx.apiKey, ctx.profile);
+    const execution = await client.get(`/v1/workflows/executions/${executionId}`);
+    outputDetail(execution, `Execution ${execution.id}`);
+  }));
+  workflows.command("create <file>").description("Create a workflow from a JSON spec file").action(handleErrors(async (file) => {
+    const f = Bun.file(file);
+    if (!await f.exists()) {
+      outputError("file_not_found", `File not found: ${file}`);
+      process.exit(1);
+    }
+    let spec;
+    try {
+      spec = JSON.parse(await f.text());
+    } catch (e) {
+      outputError("invalid_input", `Invalid JSON: ${e instanceof Error ? e.message : String(e)}`);
+      process.exit(1);
+    }
+    const client = getClient(ctx.apiKey, ctx.profile);
+    const workflow = await client.post("/v1/workflows", {
+      name: spec.name,
+      steps: spec.steps ?? [],
+      description: spec.description ?? "",
+      visibility: spec.visibility ?? "private",
+      tags: spec.tags
+    });
+    outputDetail(workflow, `Created: ${workflow.name}`);
+  }));
+  workflows.command("update <workflowId> <file>").description("Update a workflow from a JSON spec file").action(handleErrors(async (workflowId, file) => {
+    const f = Bun.file(file);
+    if (!await f.exists()) {
+      outputError("file_not_found", `File not found: ${file}`);
+      process.exit(1);
+    }
+    let spec;
+    try {
+      spec = JSON.parse(await f.text());
+    } catch (e) {
+      outputError("invalid_input", `Invalid JSON: ${e instanceof Error ? e.message : String(e)}`);
+      process.exit(1);
+    }
+    const client = getClient(ctx.apiKey, ctx.profile);
+    const workflow = await client.patch(`/v1/workflows/${workflowId}`, spec);
+    outputDetail(workflow, `Updated: ${workflow.name}`);
+  }));
+  workflows.command("delete <workflowId>").description("Delete a workflow you own").action(handleErrors(async (workflowId) => {
+    const client = getClient(ctx.apiKey, ctx.profile);
+    await client.delete(`/v1/workflows/${workflowId}`);
+    outputSuccess(`Deleted workflow ${workflowId}`);
+  }));
+}
+var init_workflows = __esm(() => {
+  init_src();
+  init_api();
+  init_data_input();
+  init_errors();
+  init_output();
+});
+
+// src/commands/skills.ts
+var exports_skills = {};
+__export(exports_skills, {
+  register: () => register9
+});
+import chalk4 from "chalk";
+function register9(program) {
+  const skills = program.command("skills").description("Search, view, and manage skills.");
+  skills.command("search <query>").description("Find skills by query").option("--limit <n>", "Maximum results", "10").action(handleErrors(async (query, opts) => {
+    const client = getPublicClient(ctx.profile);
+    const result = await client.publicGet("/v1/skills/search", {
+      query,
+      limit: opts.limit
+    });
+    outputTable(result, [
+      { header: "ID", key: "id", style: "dim" },
+      { header: "Name", key: "name", style: "bold" },
+      { header: "Description", key: "description" }
+    ], `Skills matching '${query}'`);
+  }));
+  skills.command("get <identifier>").description("Get skill content (prints SKILL.md)").action(handleErrors(async (identifier) => {
+    const client = getPublicClient(ctx.profile);
+    const skill = await client.publicGet(`/v1/skills/${identifier}`);
+    if (humanMode) {
+      console.log(`
+${chalk4.bold(skill.name)}`);
+      if (skill.description) {
+        console.log(chalk4.dim(skill.description));
+      }
+      console.log();
+      if (skill.skill_md) {
+        console.log(skill.skill_md);
+      }
+    } else {
+      output({
+        id: skill.id,
+        name: skill.name,
+        description: skill.description,
+        skill_md: skill.skill_md
+      });
+    }
+  }));
+  skills.command("create <file>").description("Create a skill from a JSON spec file").option("--visibility <vis>", "Visibility: private or public", "private").action(handleErrors(async (file, opts) => {
+    const f = Bun.file(file);
+    if (!await f.exists()) {
+      outputError("file_not_found", `File not found: ${file}`);
+      process.exit(1);
+    }
+    let spec;
+    try {
+      spec = JSON.parse(await f.text());
+    } catch (e) {
+      outputError("invalid_input", `Invalid JSON: ${e instanceof Error ? e.message : String(e)}`);
+      process.exit(1);
+    }
+    const client = getClient(ctx.apiKey, ctx.profile);
+    const skill = await client.post("/v1/skills", {
+      name: spec.name,
+      skill_md_content: spec.skill_md_content ?? spec.skill_md ?? "",
+      description: spec.description,
+      scripts: spec.scripts,
+      reference_files: spec.reference_files,
+      assets: spec.assets,
+      visibility: opts.visibility,
+      service_id: spec.service_id
+    });
+    outputDetail(skill, `Created: ${skill.name}`);
+  }));
+  skills.command("update <skillId> <file>").description("Update a skill from a JSON spec file").action(handleErrors(async (skillId, file) => {
+    const f = Bun.file(file);
+    if (!await f.exists()) {
+      outputError("file_not_found", `File not found: ${file}`);
+      process.exit(1);
+    }
+    let spec;
+    try {
+      spec = JSON.parse(await f.text());
+    } catch (e) {
+      outputError("invalid_input", `Invalid JSON: ${e instanceof Error ? e.message : String(e)}`);
+      process.exit(1);
+    }
+    const client = getClient(ctx.apiKey, ctx.profile);
+    const skill = await client.patch(`/v1/skills/${skillId}`, spec);
+    outputDetail(skill, `Updated: ${skill.name}`);
+  }));
+  skills.command("delete <skillId>").description("Delete a skill you own").action(handleErrors(async (skillId) => {
+    const client = getClient(ctx.apiKey, ctx.profile);
+    await client.delete(`/v1/skills/${skillId}`);
+    outputSuccess(`Deleted skill ${skillId}`);
+  }));
+}
+var init_skills = __esm(() => {
+  init_src();
+  init_api();
+  init_errors();
+  init_output();
+});
+
+// src/commands/wallet.ts
+var exports_wallet = {};
+__export(exports_wallet, {
+  register: () => register10
+});
+import chalk5 from "chalk";
+function register10(program) {
+  const wallet = program.command("wallet").description("View wallet balance, transactions, and spending limits.");
+  wallet.command("balance").description("Show USDC wallet balance").action(handleErrors(async () => {
+    const client = getClient(ctx.apiKey, ctx.profile);
+    const bal = await client.get("/v1/wallet/balance");
+    if (humanMode) {
+      console.log(`
+  ${chalk5.bold("Balance:")} $${bal.balance_dollars.toFixed(2)} USDC`);
+      console.log(chalk5.dim(`  Lifetime spent: $${(bal.lifetime_spent_cents / 100).toFixed(2)}`));
+      console.log(chalk5.dim(`  Lifetime deposited: $${(bal.lifetime_deposited_cents / 100).toFixed(2)}`));
+      console.log();
+    } else {
+      output({
+        balance_cents: bal.balance_cents,
+        balance_dollars: bal.balance_dollars,
+        lifetime_spent_cents: bal.lifetime_spent_cents,
+        lifetime_deposited_cents: bal.lifetime_deposited_cents
+      });
+    }
+  }));
+  wallet.command("transactions").description("View transaction history").option("--limit <n>", "Number of transactions", "20").option("--offset <n>", "Offset for pagination", "0").action(handleErrors(async (opts) => {
+    const client = getClient(ctx.apiKey, ctx.profile);
+    const result = await client.get("/v1/wallet/transactions", {
+      limit: opts.limit,
+      offset: opts.offset
+    });
+    outputTable(result.transactions ?? result, [
+      { header: "ID", key: "id", style: "dim" },
+      { header: "Type", key: "type" },
+      { header: "Amount", key: "amount_cents" },
+      { header: "Balance After", key: "balance_after_cents" },
+      { header: "Date", key: "created_at" }
+    ], "Transactions");
+  }));
+  wallet.command("limits").description("View spending limits").action(handleErrors(async () => {
+    const client = getClient(ctx.apiKey, ctx.profile);
+    const limits = await client.get("/v1/x402/settings");
+    outputDetail(limits, "Spending Limits");
+  }));
+  wallet.command("set-limits").description("Update spending limits (amounts in USDC atomic units, 1 USDC = 1,000,000)").option("--max-per-call <atomic>", "Max per call in atomic units (0-5,000,000)").option("--daily-limit <atomic>", "Daily limit in atomic units (0 to remove limit)").action(handleErrors(async (opts) => {
+    if (!opts.maxPerCall && !opts.dailyLimit) {
+      outputError("invalid_input", "Provide at least one of --max-per-call or --daily-limit");
+      process.exit(1);
+    }
+    const body = {};
+    if (opts.maxPerCall)
+      body.max_per_call_atomic = parseInt(opts.maxPerCall, 10);
+    if (opts.dailyLimit)
+      body.daily_limit_atomic = parseInt(opts.dailyLimit, 10);
+    const client = getClient(ctx.apiKey, ctx.profile);
+    const limits = await client.put("/v1/x402/settings", body);
+    outputDetail(limits, "Updated Spending Limits");
+  }));
+}
+var init_wallet = __esm(() => {
+  init_src();
+  init_api();
+  init_errors();
+  init_output();
+});
+
+// src/commands/credentials.ts
+var exports_credentials = {};
+__export(exports_credentials, {
+  register: () => register11
+});
+import { createInterface as createInterface2 } from "node:readline";
+function register11(program) {
+  const credentials = program.command("credentials").description("Store service credentials.");
+  credentials.command("store <serviceId>").description("Store a credential for a service").option("--type <type>", "Credential type: api_key, bearer, oauth", "api_key").action(handleErrors(async (serviceId, opts) => {
+    let credentialValue;
+    if (humanMode) {
+      const rl = createInterface2({ input: process.stdin, output: process.stderr });
+      credentialValue = await new Promise((resolve) => {
+        process.stderr.write("  Enter credential value: ");
+        rl.question("", (answer) => {
+          rl.close();
+          resolve(answer.trim());
+        });
+      });
+    } else {
+      credentialValue = (await Bun.stdin.text()).trim();
+      if (!credentialValue) {
+        outputError("invalid_input", "No credential provided on stdin");
+        process.exit(1);
+      }
+    }
+    const client = getClient(ctx.apiKey, ctx.profile);
+    const result = await client.post("/v1/credentials/store", {
+      service_id: serviceId,
+      credential_type: opts.type,
+      credential_value: credentialValue
+    });
+    outputSuccess(`Credential stored for ${result.service_name ?? serviceId}`, {
+      service_id: result.service_id,
+      credential_type: result.credential_type
+    });
+  }));
+}
+var init_credentials = __esm(() => {
+  init_src();
+  init_api();
+  init_errors();
+  init_output();
+});
+
+// src/commands/keys.ts
+var exports_keys = {};
+__export(exports_keys, {
+  register: () => register12
+});
+function register12(program) {
+  const keys = program.command("keys").description("Manage API keys.");
+  keys.command("list").description("List all API keys").action(handleErrors(async () => {
+    const client = getClient(ctx.apiKey, ctx.profile);
+    const result = await client.get("/v1/api-keys");
+    outputTable(result, [
+      { header: "ID", key: "id", style: "dim" },
+      { header: "Name", key: "name", style: "bold" },
+      { header: "Prefix", key: "key_prefix" },
+      { header: "Created", key: "created_at" },
+      { header: "Last Used", key: "last_used" }
+    ], "API Keys");
+  }));
+  keys.command("create <name>").description("Create a new API key").action(handleErrors(async (name) => {
+    const client = getClient(ctx.apiKey, ctx.profile);
+    const key = await client.post("/v1/api-keys", { name });
+    outputDetail({
+      id: key.id,
+      name: key.name,
+      key: key.key,
+      key_prefix: key.key_prefix
+    }, `Created API Key: ${key.name}`);
+  }));
+  keys.command("rotate <keyId>").description("Rotate an API key (generates new key material)").action(handleErrors(async (keyId) => {
+    const client = getClient(ctx.apiKey, ctx.profile);
+    const key = await client.post(`/v1/api-keys/${keyId}/rotate`);
+    outputDetail({
+      id: key.id,
+      name: key.name,
+      key: key.key,
+      key_prefix: key.key_prefix
+    }, "Rotated API Key");
+  }));
+  keys.command("revoke <keyId>").description("Revoke an API key").action(handleErrors(async (keyId) => {
+    const client = getClient(ctx.apiKey, ctx.profile);
+    await client.delete(`/v1/api-keys/${keyId}`);
+    outputSuccess(`Revoked API key ${keyId}`);
+  }));
+}
+var init_keys = __esm(() => {
+  init_src();
+  init_api();
+  init_errors();
+  init_output();
+});
+
+// src/commands/sites.ts
+var exports_sites = {};
+__export(exports_sites, {
+  register: () => register13
+});
+function register13(program) {
+  const sites = program.command("sites").description("Search and inspect the agent web directory.");
+  sites.command("search <query>").description("Search the agent web directory").option("--category <cat>", "Filter by category").option("--limit <n>", "Maximum results", "10").action(handleErrors(async (query, opts) => {
+    const client = getPublicClient(ctx.profile);
+    const result = await client.publicGet("/v1/agent-sites/search", {
+      query,
+      category: opts.category,
+      limit: opts.limit
+    });
+    outputTable(result, [
+      { header: "ID", key: "id", style: "dim" },
+      { header: "Domain", key: "domain", style: "bold" },
+      { header: "Title", key: "page_title" },
+      { header: "Category", key: "category" }
+    ], `Sites matching '${query}'`);
+  }));
+  sites.command("get <identifier>").description("Get site details by ID or domain").action(handleErrors(async (identifier) => {
+    const client = getPublicClient(ctx.profile);
+    let site;
+    if (identifier.includes(".") && identifier.length < 100) {
+      try {
+        site = await client.publicGet(`/v1/agent-sites/domain/${encodeURIComponent(identifier)}`);
+        outputDetail(site, site.domain);
+        return;
+      } catch {}
+    }
+    site = await client.publicGet(`/v1/agent-sites/${identifier}`);
+    outputDetail(site, site.domain);
+  }));
+}
+var init_sites = __esm(() => {
+  init_src();
+  init_api();
+  init_errors();
+  init_output();
+});
+
+// src/commands/agent.ts
+var exports_agent = {};
+__export(exports_agent, {
+  register: () => register14
+});
+import chalk6 from "chalk";
+function register14(program) {
+  const agent = program.command("agent").description("Register and manage autonomous agents.");
+  agent.command("register <name> <email>").description("Register a new autonomous agent (no auth required)").action(handleErrors(async (name, email) => {
+    const client = new ApiClient(getBaseUrl(ctx.profile));
+    const result = await client.publicPost("/v1/agents", {
+      name,
+      operator_email: email
+    });
+    if (humanMode) {
+      console.log(`
+${chalk6.green("✓")} Agent registered!`);
+      console.log(`  ${chalk6.cyan("Agent ID:")} ${result.agent_id}`);
+      console.log(`  ${chalk6.cyan("API Key:")} ${chalk6.bold(result.api_key)}`);
+      console.log(chalk6.dim("  Save this API key — it won't be shown again."));
+      if (result.deposit_address) {
+        console.log(`  ${chalk6.cyan("Deposit Address:")} ${result.deposit_address}`);
+      }
+      console.log();
+    } else {
+      outputDetail(result, "Agent Registration");
+    }
+  }));
+  agent.command("info").description("Show current agent info and wallet balance").action(handleErrors(async () => {
+    const client = getClient(ctx.apiKey, ctx.profile);
+    const info = await client.get("/v1/agents/me");
+    outputDetail(info, info.name);
+  }));
+  agent.command("fund").description("Fund agent wallet via card or crypto").option("--method <method>", "Funding method: card_checkout or crypto", "card_checkout").option("--amount <cents>", "Amount in cents (required for card_checkout, min 100)").action(handleErrors(async (opts) => {
+    const client = getClient(ctx.apiKey, ctx.profile);
+    if (opts.method === "card_checkout" && !opts.amount) {
+      outputError("invalid_input", "Amount is required for card_checkout (e.g. --amount 500 for $5.00)");
+      process.exit(1);
+    }
+    const result = await client.post("/v1/agents/wallets/fund", {
+      method: opts.method,
+      amount_cents: opts.amount ? parseInt(opts.amount, 10) : undefined
+    });
+    if (humanMode && result.checkout_url) {
+      console.log(`
+${chalk6.green("✓")} Checkout created`);
+      console.log(`  ${chalk6.cyan("Open:")} ${result.checkout_url}`);
+      try {
+        if (process.platform === "darwin") {
+          Bun.spawn(["open", result.checkout_url]);
+        } else if (process.platform === "linux") {
+          Bun.spawn(["xdg-open", result.checkout_url]);
+        }
+      } catch {}
+      console.log();
+    } else if (humanMode && result.deposit_address) {
+      console.log(`
+${chalk6.green("✓")} Send USDC to:`);
+      console.log(`  ${chalk6.cyan("Address:")} ${result.deposit_address}`);
+      if (result.network)
+        console.log(`  ${chalk6.cyan("Network:")} ${result.network}`);
+      console.log();
+    } else {
+      outputDetail(result, "Fund Wallet");
+    }
+  }));
+}
+var init_agent = __esm(() => {
+  init_src();
+  init_api();
+  init_config();
+  init_errors();
+  init_output();
+});
+
+// src/commands/config.ts
+var exports_config = {};
+__export(exports_config, {
+  register: () => register15
+});
+import chalk7 from "chalk";
+function register15(program) {
+  const config = program.command("config").description("Manage CLI configuration.");
+  config.command("set <key> <value>").description("Set a config value").action(handleErrors(async (key, value) => {
+    configSet(key, value, ctx.profile);
+    if (humanMode) {
+      console.log(`${chalk7.green("✓")} Set ${key} = ${value} (profile: ${ctx.profile})`);
+    } else {
+      output({ key, value, profile: ctx.profile });
+    }
+  }));
+  config.command("get <key>").description("Get a config value").action(handleErrors(async (key) => {
+    const value = configGet(key, ctx.profile);
+    if (humanMode) {
+      if (value !== undefined) {
+        console.log(`  ${chalk7.cyan(key + ":")} ${value}`);
+      } else {
+        console.log(`  ${chalk7.cyan(key + ":")} ${chalk7.dim("(not set)")}`);
+      }
+    } else {
+      output({ key, value: value ?? null });
+    }
+  }));
+  config.command("profiles").description("List available profiles").action(handleErrors(async () => {
+    const names = listProfiles();
+    if (humanMode) {
+      if (!names.length) {
+        console.log(chalk7.dim("  No profiles configured. Run 'danube login' to create one."));
+      } else {
+        for (const name of names) {
+          const marker = name === ctx.profile ? ` ${chalk7.green("●")}` : "";
+          console.log(`  ${name}${marker}`);
+        }
+      }
+    } else {
+      output({ profiles: names, active: ctx.profile });
+    }
+  }));
+}
+var init_config2 = __esm(() => {
+  init_src();
+  init_config();
+  init_errors();
+  init_output();
+});
+
+// src/index.ts
+init_output();
+init_version();
+import { Command as Command2 } from "commander";
+var ctx2 = {
+  human: false,
+  apiKey: undefined,
+  profile: "default",
+  verbose: false,
+  quiet: false,
+  noColor: false
+};
+function main() {
+  const program = new Command2;
+  program.name("danube").description(`Danube CLI — agent-first tool infrastructure.
+
+` + `search → find tools. execute → run them. connect → authenticate.
+
+` + "Bias toward action: run 'danube search <task>', then 'danube execute <slug>'.").version(VERSION, "--version", "Show version").option("--human", "Human-readable output (tables, colors)").option("--json", "Machine-readable JSON output").option("--api-key <key>", "Override API key (env: DANUBE_API_KEY)").option("--profile <name>", "Use named profile", "default").option("-v, --verbose", "Verbose output", false).option("-q, --quiet", "Suppress non-essential output", false).option("--no-color", "Disable colored output", false).hook("preAction", (thisCommand) => {
+    const opts = thisCommand.opts();
+    if (opts.json) {
+      ctx2.human = false;
+    } else if (opts.human) {
+      ctx2.human = true;
+    } else {
+      ctx2.human = process.stdout.isTTY === true;
+    }
+    ctx2.apiKey = opts.apiKey;
+    ctx2.profile = opts.profile;
+    ctx2.verbose = opts.verbose;
+    ctx2.quiet = opts.quiet;
+    ctx2.noColor = opts.noColor ?? opts.color === false;
+    setHumanMode(ctx2.human);
+    setQuietMode(ctx2.quiet);
+  });
+  registerCommands(program);
+  program.parse(process.argv);
+}
+function registerCommands(program) {
+  (init_auth(), __toCommonJS(exports_auth)).register(program);
+  (init_search(), __toCommonJS(exports_search)).register(program);
+  (init_execute(), __toCommonJS(exports_execute)).register(program);
+  (init_connect(), __toCommonJS(exports_connect)).register(program);
+  (init_completion(), __toCommonJS(exports_completion)).register(program);
+  (init_tools(), __toCommonJS(exports_tools)).register(program);
+  (init_services(), __toCommonJS(exports_services)).register(program);
+  (init_workflows(), __toCommonJS(exports_workflows)).register(program);
+  (init_skills(), __toCommonJS(exports_skills)).register(program);
+  (init_wallet(), __toCommonJS(exports_wallet)).register(program);
+  (init_credentials(), __toCommonJS(exports_credentials)).register(program);
+  (init_keys(), __toCommonJS(exports_keys)).register(program);
+  (init_sites(), __toCommonJS(exports_sites)).register(program);
+  (init_agent(), __toCommonJS(exports_agent)).register(program);
+  (init_config2(), __toCommonJS(exports_config)).register(program);
+}
+
+// bin/danube.ts
+main();