deepspace 0.2.4 → 0.2.6

package/dist/cli.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 
 // src/cli/cli.ts
-import { defineCommand as defineCommand10, runMain } from "citty";
-import { execSync as execSync4 } from "child_process";
-import { readFileSync as readFileSync7, existsSync as existsSync10 } from "fs";
-import { dirname as dirname2, join as join11 } from "path";
+import { defineCommand as defineCommand13, runMain } from "citty";
+import { execSync as execSync5 } from "child_process";
+import { readFileSync as readFileSync9, existsSync as existsSync11 } from "fs";
+import { dirname as dirname2, join as join12 } from "path";
 import { fileURLToPath } from "url";
 
 // src/cli/commands/login.ts
@@ -204,7 +204,7 @@ function openBrowser(url) {
   });
 }
 function sleep(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 async function doEmailLogin(email, password) {
   const res = await fetch(`${AUTH_URL}/api/auth/sign-in/email`, {
@@ -1118,13 +1118,715 @@ var add_default = defineCommand9({
   }
 });
 
+// src/cli/commands/domain.ts
+import { defineCommand as defineCommand10 } from "citty";
+import { execSync as execSync4 } from "child_process";
+
+// src/cli/lib/app-context.ts
+import { existsSync as existsSync10, readFileSync as readFileSync7 } from "fs";
+import { join as join11, resolve as resolve5 } from "path";
+import { parse as parseToml4 } from "smol-toml";
+function detectAppName(cwd = process.cwd()) {
+  const wranglerPath = join11(resolve5(cwd), "wrangler.toml");
+  if (!existsSync10(wranglerPath)) return null;
+  try {
+    const cfg = parseToml4(readFileSync7(wranglerPath, "utf-8"));
+    return typeof cfg.name === "string" && cfg.name.length > 0 ? cfg.name : null;
+  } catch {
+    return null;
+  }
+}
+function requireAppName(explicit, cwd) {
+  if (explicit) return explicit;
+  const detected = detectAppName(cwd);
+  if (detected) return detected;
+  throw new Error(
+    "No app specified. Pass --app <name>, or run from an app directory with a wrangler.toml."
+  );
+}
+
+// src/cli/commands/domain.ts
+var API_URL = process.env.DEEPSPACE_API_URL ?? ENVS.prod.api;
+async function api(token, path, init) {
+  const res = await fetch(`${API_URL}${path}`, {
+    ...init,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+      ...init?.headers ?? {}
+    }
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    let msg = text;
+    try {
+      msg = JSON.parse(text).error ?? text;
+    } catch {
+    }
+    throw new Error(`API ${path} (${res.status}): ${msg}`);
+  }
+  return JSON.parse(text);
+}
+function fmtCents(cents) {
+  if (cents === null || cents === void 0) return "\u2014";
+  return `$${(cents / 100).toFixed(2)}`;
+}
+function fmtDate(iso) {
+  if (!iso) return "\u2014";
+  return iso.slice(0, 10);
+}
+async function confirm2(message) {
+  if (!process.stdin.isTTY) {
+    throw new Error(`${message} \u2014 pass --yes to confirm non-interactively`);
+  }
+  process.stdout.write(`${message} [y/N] `);
+  return new Promise((resolve6) => {
+    process.stdin.setEncoding("utf-8");
+    process.stdin.once("data", (data) => {
+      const answer = data.toString().trim().toLowerCase();
+      resolve6(answer === "y" || answer === "yes");
+    });
+  });
+}
+var search = defineCommand10({
+  meta: { name: "search", description: "Search for available domains" },
+  args: {
+    query: { type: "positional", description: "Domain or keyword", required: true },
+    limit: { type: "string", description: "Max results (default 10)", default: "10" },
+    json: { type: "boolean", description: "Emit JSON instead of a table" }
+  },
+  async run({ args }) {
+    const token = await ensureToken();
+    const limit = parseInt(args.limit ?? "10", 10) || 10;
+    const result = await api(
+      token,
+      `/api/domains/search?q=${encodeURIComponent(args.query)}&limit=${limit}`
+    );
+    if (args.json) {
+      process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+      return;
+    }
+    if (result.domains.length === 0) {
+      console.log("No matches.");
+      return;
+    }
+    for (const d of result.domains) {
+      const tag = d.registrable ? "\u2713" : "\u2717";
+      const price = d.registrable ? `${fmtCents(d.chargedCents)}/yr` : d.reason ?? "\u2014";
+      const slowFlag = d.registrar && d.registrar !== "cloudflare" ? "  (15-60 min provisioning)" : "";
+      console.log(`${tag} ${d.name.padEnd(40)} ${price}${slowFlag}`);
+    }
+  }
+});
+var buy = defineCommand10({
+  meta: { name: "buy", description: "Buy a domain and attach it to an app" },
+  args: {
+    domain: { type: "positional", description: "Domain to buy", required: true },
+    app: { type: "string", description: "App to attach (defaults to ./wrangler.toml)" },
+    yes: { type: "boolean", description: "Skip the confirmation prompt", default: false },
+    "no-open": { type: "boolean", description: "Do not open browser; print Stripe URL", default: false },
+    "no-wait": { type: "boolean", description: "Exit after creating session; do not poll until active", default: false },
+    json: { type: "boolean", description: "Emit JSON to stdout", default: false }
+  },
+  async run({ args }) {
+    const token = await ensureToken();
+    const appName = requireAppName(args.app);
+    const priceCheck = await api(token, "/api/domains/check", {
+      method: "POST",
+      body: JSON.stringify({ domains: [args.domain] })
+    });
+    const result = priceCheck.domains[0];
+    if (!result || !result.registrable) {
+      console.error(`Not available: ${result?.reason ?? "unknown"}`);
+      process.exit(1);
+    }
+    const price = fmtCents(result.chargedCents);
+    const expectedTime = result.registrar === "cloudflare" ? "~60-90 seconds" : "15-60 minutes (registry NS propagation)";
+    if (!args.yes) {
+      const ok = await confirm2(
+        `Buy ${args.domain} for ${price}/yr (auto-renews; non-refundable), attach to ${appName}? Provisioning takes ${expectedTime}.`
+      );
+      if (!ok) {
+        console.log("Cancelled.");
+        return;
+      }
+    }
+    const checkout = await api(
+      token,
+      "/api/domains/checkout",
+      {
+        method: "POST",
+        body: JSON.stringify({ domain: args.domain, appName })
+      }
+    );
+    if (args.json) {
+      process.stdout.write(JSON.stringify({ ...checkout, expectedTime, registrar: result.registrar }, null, 2) + "\n");
+    } else {
+      console.log(`Stripe Checkout: ${checkout.url}`);
+    }
+    if (!args["no-open"] && process.stdin.isTTY) {
+      openBrowser2(checkout.url);
+    }
+    if (args["no-wait"]) return;
+    const timeoutMs = result.registrar === "cloudflare" ? 5 * 60 * 1e3 : 60 * 60 * 1e3;
+    if (!args.json) {
+      console.log(`Waiting for payment & provisioning (up to ${expectedTime}). Press Ctrl-C anytime \u2014`);
+      console.log(`provisioning continues server-side; check later with \`deepspace domain status ${args.domain}\`.`);
+    }
+    const deadline = Date.now() + timeoutMs;
+    let lastStatus = "";
+    while (Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, 5e3));
+      try {
+        const detail = await api(
+          token,
+          `/api/domains/${checkout.purchaseId}`
+        );
+        if (detail.domain.status !== lastStatus) {
+          lastStatus = detail.domain.status;
+          if (!args.json) console.log(`  \u2192 ${lastStatus}`);
+        }
+        if (detail.domain.status === "active") {
+          if (args.json) {
+            process.stdout.write(JSON.stringify({ ...checkout, status: "active", domain: args.domain }, null, 2) + "\n");
+          } else {
+            console.log(`\u2713 ${args.domain} is live and pointing at ${appName}`);
+          }
+          return;
+        }
+        if (detail.domain.status.startsWith("failed:")) {
+          console.error(`Provisioning failed: ${detail.domain.statusError ?? detail.domain.status}`);
+          process.exit(1);
+        }
+      } catch (err) {
+        if (!args.json) console.error(`(poll error: ${err instanceof Error ? err.message : String(err)})`);
+      }
+    }
+    console.error(`Polling timed out. Provisioning may still be in progress; check with:`);
+    console.error(`  deepspace domain status ${args.domain}`);
+    process.exit(1);
+  }
+});
+var list2 = defineCommand10({
+  meta: { name: "list", description: "List your domains" },
+  args: {
+    json: { type: "boolean", description: "Emit JSON" }
+  },
+  async run({ args }) {
+    const token = await ensureToken();
+    const result = await api(token, "/api/domains");
+    if (args.json) {
+      process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+      return;
+    }
+    if (result.domains.length === 0) {
+      console.log("No domains. Try `deepspace domain search <name>`.");
+      return;
+    }
+    console.log(`DOMAIN                              APP                  STATUS               EXPIRES      AUTO-RENEW`);
+    for (const d of result.domains) {
+      console.log(
+        `${d.domain.padEnd(35)} ${d.appName.padEnd(20)} ${d.status.padEnd(20)} ${fmtDate(d.expiresAt).padEnd(12)} ${d.autoRenew ? "on" : "off"}`
+      );
+    }
+  }
+});
+var status = defineCommand10({
+  meta: { name: "status", description: "Show details for one domain" },
+  args: {
+    domain: { type: "positional", description: "Domain", required: true },
+    json: { type: "boolean" }
+  },
+  async run({ args }) {
+    const token = await ensureToken();
+    const all = await api(token, "/api/domains");
+    const found = all.domains.find((d) => d.domain === args.domain);
+    if (!found) {
+      console.error(`No domain ${args.domain} in your account`);
+      process.exit(1);
+    }
+    if (args.json) {
+      process.stdout.write(JSON.stringify(found, null, 2) + "\n");
+      return;
+    }
+    console.log(`Domain:        ${found.domain}`);
+    console.log(`Status:        ${found.status}${found.statusError ? ` (${found.statusError})` : ""}`);
+    console.log(`Attached app:  ${found.appName}`);
+    console.log(`Registrar:     ${found.registrar}`);
+    console.log(`Registered:    ${fmtDate(found.registeredAt)}`);
+    console.log(`Expires:       ${fmtDate(found.expiresAt)}`);
+    console.log(`Auto-renew:    ${found.autoRenew ? "on" : "off"}`);
+    console.log(`Charged:       ${fmtCents(found.chargedCents)}/yr`);
+  }
+});
+var attach = defineCommand10({
+  meta: { name: "attach", description: "Re-point a domain at a different app" },
+  args: {
+    domain: { type: "positional", description: "Domain to re-point", required: true },
+    app: { type: "string", description: "Target app (defaults to ./wrangler.toml)" },
+    json: { type: "boolean" }
+  },
+  async run({ args }) {
+    const token = await ensureToken();
+    const targetApp = requireAppName(args.app);
+    const all = await api(token, "/api/domains");
+    const found = all.domains.find((d) => d.domain === args.domain);
+    if (!found) {
+      console.error(`No domain ${args.domain} in your account`);
+      process.exit(1);
+    }
+    const result = await api(
+      token,
+      `/api/domains/${found.id}/reattach`,
+      {
+        method: "POST",
+        body: JSON.stringify({ appName: targetApp })
+      }
+    );
+    if (args.json) {
+      process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+      return;
+    }
+    console.log(`\u2713 ${args.domain} now points at ${targetApp}`);
+  }
+});
+var detach = defineCommand10({
+  meta: {
+    name: "detach",
+    description: "Stop routing the domain (keeps the registration; auto-renew unchanged)"
+  },
+  args: {
+    domain: { type: "positional", description: "Domain to detach", required: true },
+    yes: { type: "boolean", description: "Skip the confirmation prompt" }
+  },
+  async run({ args }) {
+    const token = await ensureToken();
+    const all = await api(token, "/api/domains");
+    const found = all.domains.find((d) => d.domain === args.domain);
+    if (!found) {
+      console.error(`No domain ${args.domain} in your account`);
+      process.exit(1);
+    }
+    if (!args.yes) {
+      const ok = await confirm2(
+        `Detach ${args.domain}? Routing will stop; the domain stays registered (auto-renew is unchanged).`
+      );
+      if (!ok) {
+        console.log("Cancelled.");
+        return;
+      }
+    }
+    await api(token, `/api/domains/${found.id}`, { method: "DELETE" });
+    console.log(`\u2713 ${args.domain} detached. Use \`deepspace domain attach\` to re-route, or \`renew --auto off\` to stop auto-renewal.`);
+  }
+});
+var renew = defineCommand10({
+  meta: { name: "renew", description: "Toggle auto-renewal at the registrar" },
+  args: {
+    domain: { type: "positional", description: "Domain", required: true },
+    auto: { type: "string", description: '"on" or "off"', required: true }
+  },
+  async run({ args }) {
+    if (args.auto !== "on" && args.auto !== "off") {
+      console.error('--auto must be "on" or "off"');
+      process.exit(1);
+    }
+    const token = await ensureToken();
+    const all = await api(token, "/api/domains");
+    const found = all.domains.find((d) => d.domain === args.domain);
+    if (!found) {
+      console.error(`No domain ${args.domain} in your account`);
+      process.exit(1);
+    }
+    const enabled = args.auto === "on";
+    await api(token, `/api/domains/${found.id}/auto-renew`, {
+      method: "POST",
+      body: JSON.stringify({ autoRenew: enabled })
+    });
+    console.log(`\u2713 ${args.domain} auto-renew ${enabled ? "enabled" : "disabled"}`);
+  }
+});
+function openBrowser2(url) {
+  try {
+    if (process.platform === "darwin") execSync4(`open ${JSON.stringify(url)}`);
+    else if (process.platform === "win32") execSync4(`start "" ${JSON.stringify(url)}`);
+    else execSync4(`xdg-open ${JSON.stringify(url)} 2>/dev/null || true`);
+  } catch {
+  }
+}
+var domain_default = defineCommand10({
+  meta: { name: "domain", description: "Buy and manage custom domains" },
+  subCommands: { search, buy, list: list2, status, attach, detach, renew }
+});
+
+// src/cli/commands/integrations.ts
+import { defineCommand as defineCommand11 } from "citty";
+
+// src/cli/commands/_invoke-impl.ts
+import { readFileSync as readFileSync8 } from "fs";
+var API_URL2 = process.env.DEEPSPACE_API_URL ?? ENVS.prod.api;
+var DEFAULT_TIMEOUT_MS = 12e4;
+function parseTarget(target) {
+  if (!target || typeof target !== "string") {
+    throw new Error("Missing target. Expected '<integration>/<endpoint>' (e.g. 'openai/chat-completion').");
+  }
+  const parts = target.split("/");
+  if (parts.length !== 2 || !parts[0] || !parts[1]) {
+    throw new Error(`Bad target '${target}'. Expected '<integration>/<endpoint>' (e.g. 'openai/chat-completion').`);
+  }
+  return { integration: parts[0], endpoint: parts[1] };
+}
+function resolveBody(opts) {
+  if (opts.body != null && opts.bodyFile != null) {
+    throw new Error("Pass either --body or --body-file, not both.");
+  }
+  let raw;
+  if (opts.body != null) {
+    raw = opts.body;
+  } else if (opts.bodyFile != null) {
+    raw = opts.bodyFile === "-" ? readFileSync8(0, "utf-8") : readFileSync8(opts.bodyFile, "utf-8");
+  } else {
+    return "{}";
+  }
+  try {
+    JSON.parse(raw);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "invalid JSON";
+    throw new Error(`Body is not valid JSON: ${msg}`);
+  }
+  return raw;
+}
+function flushAndExit(code) {
+  return new Promise(() => {
+    process.stdout.write("", () => process.exit(code));
+  });
+}
+async function fetchCatalog() {
+  const res = await fetch(`${API_URL2}/api/integrations`);
+  if (!res.ok) {
+    throw new Error(`Failed to fetch integration catalog (${res.status})`);
+  }
+  return await res.json();
+}
+function findEndpoint(catalog, integration, endpoint) {
+  const endpoints = catalog.integrations[integration];
+  if (!endpoints) return null;
+  return endpoints.find((e) => e.endpoint === endpoint) ?? null;
+}
+function formatCurrency(value, currency) {
+  if (currency === "USD") return `$${value}`;
+  return `${value} ${currency}`;
+}
+async function runList(args) {
+  const catalog = await fetchCatalog();
+  if (args.json) {
+    process.stdout.write(JSON.stringify(catalog) + "\n");
+    await flushAndExit(0);
+  }
+  const names = Object.keys(catalog.integrations).sort();
+  if (names.length === 0) {
+    console.log("No integrations available.");
+    return;
+  }
+  for (const name of names) {
+    console.log(name);
+    const endpoints = [...catalog.integrations[name]].sort((a, b) => a.endpoint.localeCompare(b.endpoint));
+    const widest = Math.max(...endpoints.map((e) => e.endpoint.length));
+    for (const ep of endpoints) {
+      const pad = ep.endpoint.padEnd(widest);
+      const cost = formatCurrency(ep.billing.baseCost, ep.billing.currency);
+      console.log(`  ${pad}  ${ep.billing.model.padEnd(12)} ${cost}`);
+    }
+    console.log();
+  }
+  console.log("Run 'deepspace integrations info <integration>/<endpoint>' for the request schema.");
+}
+async function runInfo(args) {
+  const { integration, endpoint } = parseTarget(args.target);
+  const catalog = await fetchCatalog();
+  const info2 = findEndpoint(catalog, integration, endpoint);
+  if (!info2) {
+    const available = catalog.integrations[integration];
+    if (!available) {
+      const names = Object.keys(catalog.integrations).sort().join(", ");
+      throw new Error(`Unknown integration '${integration}'. Available: ${names}`);
+    }
+    const endpoints = available.map((e) => e.endpoint).join(", ");
+    throw new Error(`Unknown endpoint '${endpoint}' for '${integration}'. Available: ${endpoints}`);
+  }
+  if (args.json) {
+    process.stdout.write(JSON.stringify(info2) + "\n");
+    await flushAndExit(0);
+  }
+  console.log(`${integration}/${endpoint}`);
+  console.log(`  billing: ${info2.billing.model}, ${formatCurrency(info2.billing.baseCost, info2.billing.currency)} per call`);
+  console.log();
+  console.log("Input schema:");
+  console.log(info2.inputSchema ? JSON.stringify(info2.inputSchema, null, 2) : "  (no schema registered)");
+  console.log();
+  console.log("Example body:");
+  console.log(info2.example ? JSON.stringify(info2.example, null, 2) : "  (no example available)");
+}
+async function runInvoke(args) {
+  const { integration, endpoint } = parseTarget(args.target);
+  const body = resolveBody({ body: args.body, bodyFile: args.bodyFile });
+  const timeoutMs = args.timeout ?? DEFAULT_TIMEOUT_MS;
+  let jwt;
+  try {
+    jwt = await ensureToken();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(msg);
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  const startedAt = Date.now();
+  let res;
+  try {
+    res = await fetch(`${API_URL2}/api/integrations/${integration}/${endpoint}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${jwt}`
+      },
+      body,
+      signal: controller.signal
+    });
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
+      throw new Error(`Request timed out after ${timeoutMs}ms`);
+    }
+    throw new Error(err instanceof Error ? err.message : "Request failed");
+  } finally {
+    clearTimeout(timer);
+  }
+  const elapsed = Date.now() - startedAt;
+  let payload;
+  try {
+    payload = await res.json();
+  } catch {
+    throw new Error(`Request failed (${res.status}) with non-JSON response`);
+  }
+  if (args.json) {
+    process.stdout.write(JSON.stringify(payload) + "\n");
+    await flushAndExit(payload?.success === false || !res.ok ? 1 : 0);
+  }
+  const ok = payload?.success !== false && res.ok;
+  if (ok) {
+    const data = "data" in payload ? payload.data : payload;
+    console.log(JSON.stringify(data, null, 2));
+    console.error(`
+\u2713 ${integration}/${endpoint} (${elapsed}ms)`);
+    return;
+  }
+  const errMsg = payload.error ?? `Request failed (${res.status})`;
+  console.error(`\u2717 ${integration}/${endpoint} (${res.status}, ${elapsed}ms): ${errMsg}`);
+  if (Array.isArray(payload.issues)) {
+    for (const issue of payload.issues) {
+      const path = issue.path?.length ? issue.path.join(".") : "(root)";
+      console.error(`  - ${path}: ${issue.message}`);
+    }
+  }
+  if (res.status === 401) {
+    console.error("\nHint: run 'deepspace login' to authenticate.");
+  }
+  process.exit(1);
+}
+
+// src/cli/commands/integrations.ts
+var list3 = defineCommand11({
+  meta: {
+    name: "list",
+    description: "List all available integrations"
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: "Print raw JSON (machine-readable)",
+      default: false
+    }
+  },
+  async run({ args }) {
+    try {
+      await runList({ json: args.json });
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  }
+});
+var info = defineCommand11({
+  meta: {
+    name: "info",
+    description: "Print schema + example body for an integration endpoint"
+  },
+  args: {
+    target: {
+      type: "positional",
+      description: "<integration>/<endpoint> (e.g. 'openai/chat-completion')",
+      required: true
+    },
+    json: {
+      type: "boolean",
+      description: "Print raw JSON (machine-readable)",
+      default: false
+    }
+  },
+  async run({ args }) {
+    try {
+      await runInfo({ target: args.target, json: args.json });
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  }
+});
+var invoke = defineCommand11({
+  meta: {
+    name: "invoke",
+    description: "Invoke a platform integration as the logged-in user"
+  },
+  args: {
+    target: {
+      type: "positional",
+      description: "<integration>/<endpoint> (e.g. 'openai/chat-completion')",
+      required: true
+    },
+    body: {
+      type: "string",
+      alias: "d",
+      description: "Inline JSON body",
+      required: false
+    },
+    "body-file": {
+      type: "string",
+      alias: "f",
+      description: "Read JSON body from file (use - for stdin)",
+      required: false
+    },
+    json: {
+      type: "boolean",
+      description: "Print only the response JSON (machine-readable)",
+      default: false
+    },
+    timeout: {
+      type: "string",
+      description: "Request timeout in milliseconds (default: 120000)",
+      required: false
+    }
+  },
+  async run({ args }) {
+    try {
+      const timeout = args.timeout != null ? Number(args.timeout) : void 0;
+      if (timeout != null && (!Number.isFinite(timeout) || timeout <= 0)) {
+        throw new Error(`Invalid --timeout '${args.timeout}'. Must be a positive number of milliseconds.`);
+      }
+      await runInvoke({
+        target: args.target,
+        body: args.body,
+        bodyFile: args["body-file"],
+        json: args.json,
+        timeout
+      });
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  }
+});
+var integrations_default = defineCommand11({
+  meta: {
+    name: "integrations",
+    description: "List, inspect, and invoke platform integrations"
+  },
+  subCommands: {
+    list: list3,
+    info,
+    invoke
+  }
+});
+
+// src/cli/commands/invoke.ts
+import { defineCommand as defineCommand12 } from "citty";
+var invoke_default = defineCommand12({
+  meta: {
+    name: "invoke",
+    description: "Invoke a platform integration as the logged-in user"
+  },
+  args: {
+    target: {
+      type: "positional",
+      description: "<integration>/<endpoint> (e.g. 'openai/chat-completion')",
+      required: false
+    },
+    body: {
+      type: "string",
+      alias: "d",
+      description: "Inline JSON body",
+      required: false
+    },
+    "body-file": {
+      type: "string",
+      alias: "f",
+      description: "Read JSON body from file (use - for stdin)",
+      required: false
+    },
+    json: {
+      type: "boolean",
+      description: "Print only the response JSON (machine-readable)",
+      default: false
+    },
+    info: {
+      type: "boolean",
+      description: "Print schema + example body for the endpoint, then exit",
+      default: false
+    },
+    list: {
+      type: "boolean",
+      description: "Print all available integrations, then exit",
+      default: false
+    },
+    timeout: {
+      type: "string",
+      description: "Request timeout in milliseconds (default: 120000)",
+      required: false
+    }
+  },
+  async run({ args }) {
+    try {
+      if (args.list) {
+        await runList({ json: args.json });
+        return;
+      }
+      if (args.info) {
+        await runInfo({ target: args.target, json: args.json });
+        return;
+      }
+      const timeout = args.timeout != null ? Number(args.timeout) : void 0;
+      if (timeout != null && (!Number.isFinite(timeout) || timeout <= 0)) {
+        throw new Error(`Invalid --timeout '${args.timeout}'. Must be a positive number of milliseconds.`);
+      }
+      await runInvoke({
+        target: args.target,
+        body: args.body,
+        bodyFile: args["body-file"],
+        json: args.json,
+        timeout
+      });
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  }
+});
+
 // src/cli/cli.ts
 var __dirname = dirname2(fileURLToPath(import.meta.url));
-var pkg = JSON.parse(readFileSync7(join11(__dirname, "..", "package.json"), "utf-8"));
-if (process.platform === "linux" && !process.env.SSL_CERT_FILE && existsSync10("/etc/ssl/certs/ca-certificates.crt")) {
+var pkg = JSON.parse(readFileSync9(join12(__dirname, "..", "package.json"), "utf-8"));
+if (process.platform === "linux" && !process.env.SSL_CERT_FILE && existsSync11("/etc/ssl/certs/ca-certificates.crt")) {
   process.env.SSL_CERT_FILE = "/etc/ssl/certs/ca-certificates.crt";
 }
-var create2 = defineCommand10({
+var create2 = defineCommand13({
   meta: {
     name: "create",
     description: "Create a new DeepSpace app"
@@ -1140,10 +1842,10 @@ var create2 = defineCommand10({
     const name = args.name ? ` ${args.name}` : "";
     console.log(`Running: npm create deepspace${name}
 `);
-    execSync4(`npm create deepspace@latest${name}`, { stdio: "inherit" });
+    execSync5(`npm create deepspace@latest${name}`, { stdio: "inherit" });
   }
 });
-var main = defineCommand10({
+var main = defineCommand13({
   meta: {
     name: "deepspace",
     version: pkg.version,
@@ -1158,12 +1860,16 @@ var main = defineCommand10({
     test: test_default,
     "test-accounts": test_accounts_default,
     add: add_default,
+    integrations: integrations_default,
+    invoke: invoke_default,
     deploy: deploy_default,
-    undeploy: undeploy_default
-  },
-  run() {
-    console.log("deepspace CLI \u2014 run `npx deepspace --help` for usage");
+    undeploy: undeploy_default,
+    domain: domain_default
   }
+  // No `run()` here — citty cascades parent run() AFTER subcommand finishes,
+  // which corrupts agent-friendly output (`--json`) and prints noise on every
+  // command. Citty's default behavior when no subcommand matches is to print
+  // help, which is what we want for `deepspace` with no args.
 });
 runMain(main);
 //# sourceMappingURL=cli.js.map