ambiguous 0.1.0

package/dist/index.js

@@ -0,0 +1,3484 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/lib/output.ts
+import chalk from "chalk";
+var _jsonMode = false;
+var _quietMode = false;
+function setJsonMode(on) {
+  _jsonMode = on;
+}
+function setQuietMode(on) {
+  _quietMode = on;
+}
+function isJsonMode() {
+  return _jsonMode || !process.stdout.isTTY;
+}
+function isQuietMode() {
+  return _quietMode;
+}
+function useColor() {
+  return !!process.stdout.isTTY && !process.env.NO_COLOR;
+}
+function dim(text) {
+  return useColor() ? chalk.dim(text) : text;
+}
+function bold(text) {
+  return useColor() ? chalk.bold(text) : text;
+}
+function green(text) {
+  return useColor() ? chalk.green(text) : text;
+}
+function red(text) {
+  return useColor() ? chalk.red(text) : text;
+}
+function yellow(text) {
+  return useColor() ? chalk.yellow(text) : text;
+}
+function printTable(data, columns) {
+  if (isJsonMode()) {
+    console.log(JSON.stringify(data));
+    return;
+  }
+  if (data.length === 0) {
+    if (!isQuietMode()) console.log(dim("No results."));
+    return;
+  }
+  const headers = columns.map((c) => c.header ?? c.key);
+  const formatters = columns.map((c) => c.format ?? String);
+  const rows = data.map(
+    (row) => columns.map((col, i) => {
+      const raw = row[col.key];
+      return raw == null ? "" : formatters[i](raw);
+    })
+  );
+  const widths = columns.map((col, i) => {
+    const headerLen = headers[i].length;
+    const maxDataLen = rows.reduce((max, row) => Math.max(max, row[i].length), 0);
+    return col.width ?? Math.max(headerLen, maxDataLen);
+  });
+  const pad = (s, w, align = "left") => align === "right" ? s.padStart(w) : s.padEnd(w);
+  const headerLine = columns.map((col, i) => pad(headers[i], widths[i], col.align)).join("  ");
+  console.log(bold(headerLine));
+  for (const row of rows) {
+    const line = columns.map((col, i) => pad(row[i], widths[i], col.align)).join("  ");
+    console.log(line);
+  }
+}
+function printOne(data, fields) {
+  if (isJsonMode()) {
+    console.log(JSON.stringify(data));
+    return;
+  }
+  const entries = fields ? fields.map((f) => [f.label ?? f.key, f.format ? f.format(data[f.key]) : String(data[f.key] ?? "")]) : Object.entries(data).map(([k, v]) => [k, String(v ?? "")]);
+  const maxLabelLen = entries.reduce((max, [label]) => Math.max(max, label.length), 0);
+  for (const [label, value] of entries) {
+    console.log(`${dim(label.padEnd(maxLabelLen))}  ${value}`);
+  }
+}
+function printJson(data) {
+  console.log(JSON.stringify(data, null, isJsonMode() ? void 0 : 2));
+}
+function success(msg) {
+  if (isQuietMode() && isJsonMode()) return;
+  if (isJsonMode()) {
+    console.log(JSON.stringify({ ok: true, message: msg }));
+    return;
+  }
+  console.log(green("\u2713") + " " + msg);
+}
+function warn(msg) {
+  if (isQuietMode()) return;
+  console.error(yellow("\u26A0") + " " + msg);
+}
+function info(msg) {
+  if (isQuietMode()) return;
+  console.error(dim(msg));
+}
+
+// src/lib/client.ts
+import { AmbiguousClient, AmbiguousApiError } from "@ambiguous/api-client";
+
+// src/lib/config.ts
+import Conf from "conf";
+var DEFAULT_API_URL = "https://api.ambi.cc";
+var config = new Conf({
+  projectName: "ambi",
+  defaults: {
+    apiUrl: DEFAULT_API_URL
+  }
+});
+function getConfigPath() {
+  return config.path;
+}
+function get(key) {
+  return config.get(key);
+}
+function set(key, value) {
+  config.set(key, value);
+}
+function getAll() {
+  return config.store;
+}
+function clear() {
+  config.clear();
+}
+function getAuthToken() {
+  return config.get("authToken");
+}
+function setAuth(token, userName, userEmail) {
+  config.set("authToken", token);
+  if (userName) config.set("userName", userName);
+  if (userEmail) config.set("userEmail", userEmail);
+}
+function clearAuth() {
+  config.delete("authToken");
+  config.delete("userName");
+  config.delete("userEmail");
+}
+function isAuthenticated() {
+  return !!config.get("authToken");
+}
+function getApiUrl() {
+  const url = config.get("apiUrl") || process.env.AMBI_API_URL || DEFAULT_API_URL;
+  return url.replace(/\/+$/, "");
+}
+
+// src/lib/client.ts
+var _client = null;
+function getClient(opts) {
+  const requireAuth = opts?.requireAuth ?? true;
+  const token = getAuthToken();
+  const apiUrl = getApiUrl();
+  if (requireAuth && !token) {
+    throw new Error(
+      "Not authenticated. Run `ambi auth login` or `ambi auth login --token <key>` first."
+    );
+  }
+  _client = new AmbiguousClient({
+    baseUrl: apiUrl,
+    ...token?.startsWith("ak_") ? { apiKey: token } : { token }
+  });
+  return _client;
+}
+async function rawRequest(method, path, data, query) {
+  const client = getClient();
+  return client.request(method, path, data, query);
+}
+
+// src/lib/errors.ts
+var EXIT_ERROR = 1;
+var EXIT_AUTH_ERROR = 2;
+var CliError = class extends Error {
+  constructor(message, exitCode = EXIT_ERROR) {
+    super(message);
+    this.exitCode = exitCode;
+    this.name = "CliError";
+  }
+};
+function exitCodeFor(err) {
+  if (err instanceof CliError) return err.exitCode;
+  if (err instanceof AmbiguousApiError) {
+    return err.statusCode === 401 || err.statusCode === 403 ? EXIT_AUTH_ERROR : EXIT_ERROR;
+  }
+  return EXIT_ERROR;
+}
+function messageFor(err) {
+  if (err instanceof AmbiguousApiError) {
+    const bodyMsg = typeof err.body?.error === "string" ? err.body.error : void 0;
+    const bodyMessage = typeof err.body?.message === "string" ? err.body.message : void 0;
+    return bodyMsg || bodyMessage || `HTTP ${err.statusCode}`;
+  }
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+function jsonPayload(err) {
+  const base = {
+    ok: false,
+    error: messageFor(err)
+  };
+  if (err instanceof AmbiguousApiError) {
+    base.statusCode = err.statusCode;
+    if (err.body && typeof err.body === "object") {
+      const { error: _e, message: _m, ...rest } = err.body;
+      if (Object.keys(rest).length > 0) base.details = rest;
+    }
+  }
+  return base;
+}
+function authHint(err) {
+  if (err instanceof AmbiguousApiError && err.statusCode === 401) {
+    return "Run `ambi auth login` to authenticate.";
+  }
+  if (err instanceof Error && err.message.includes("Not authenticated")) {
+    return "Run `ambi auth login` or `ambi auth login --token <key>` first.";
+  }
+  return null;
+}
+function handleError(err) {
+  const code = exitCodeFor(err);
+  if (isJsonMode()) {
+    console.log(JSON.stringify(jsonPayload(err)));
+  } else {
+    const msg = messageFor(err);
+    console.error(red("Error:") + " " + msg);
+    if (err instanceof AmbiguousApiError) {
+      console.error(dim(`  HTTP ${err.statusCode}`));
+    }
+    const hint = authHint(err);
+    if (hint) {
+      console.error(yellow("  Hint:") + " " + hint);
+    }
+  }
+  process.exit(code);
+}
+function withErrorHandler(fn) {
+  return async (...args) => {
+    try {
+      await fn(...args);
+    } catch (err) {
+      handleError(err);
+    }
+  };
+}
+
+// src/commands/auth.ts
+import * as http from "http";
+import * as crypto from "crypto";
+import open from "open";
+async function exchangeCode(apiUrl, code) {
+  const res = await fetch(`${apiUrl}/api/auth/cli/exchange`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ code })
+  });
+  const data = await res.json();
+  if (!res.ok) {
+    throw new CliError(
+      data.error || `Code exchange failed: HTTP ${res.status}`,
+      EXIT_AUTH_ERROR
+    );
+  }
+  return {
+    token: data.token,
+    user: data.display_name ?? void 0,
+    email: data.email ?? void 0
+  };
+}
+async function browserLogin(timeoutMs = 12e4) {
+  return new Promise((resolve6, reject) => {
+    const state = crypto.randomUUID();
+    let settled = false;
+    const server = http.createServer(async (req, res) => {
+      const url = new URL(req.url ?? "/", `http://localhost`);
+      if (url.pathname !== "/callback") {
+        res.writeHead(404);
+        res.end("Not found");
+        return;
+      }
+      const receivedState = url.searchParams.get("state");
+      const code = url.searchParams.get("code");
+      if (receivedState !== state) {
+        res.writeHead(400);
+        res.end("State mismatch \u2014 possible CSRF. Please try again.");
+        return;
+      }
+      if (!code) {
+        res.writeHead(400);
+        res.end("No auth code received. Please try again.");
+        return;
+      }
+      try {
+        const apiUrl = getApiUrl();
+        const result = await exchangeCode(apiUrl, code);
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(`
+          <!DOCTYPE html>
+          <html>
+          <body style="font-family: Inter, system-ui, sans-serif; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; background: #F1F3F9; color: #27272C;">
+            <div style="text-align: center;">
+              <h1 style="font-size: 24px; margin-bottom: 8px;">Authenticated!</h1>
+              <p style="color: #6B7280;">You can close this window and return to the terminal.</p>
+            </div>
+          </body>
+          </html>
+        `);
+        settled = true;
+        server.close();
+        resolve6(result);
+      } catch (err) {
+        res.writeHead(500);
+        res.end("Authentication failed. Please try again.");
+        if (!settled) {
+          settled = true;
+          server.close();
+          reject(err);
+        }
+      }
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      if (!addr || typeof addr === "string") {
+        reject(new Error("Failed to start local server"));
+        return;
+      }
+      const port = addr.port;
+      const apiUrl = getApiUrl();
+      const authUrl = `${apiUrl}/api/auth/cli?port=${port}&state=${state}`;
+      open(authUrl).catch(() => {
+        warn("Could not open browser automatically.");
+      });
+      if (!isJsonMode()) {
+        console.error(dim(`Opening browser to authenticate...`));
+        console.error(dim(`If the browser didn't open, visit:`));
+        console.error(`  ${authUrl}`);
+        console.error(dim(`Waiting for authentication...`));
+      }
+    });
+    const timer = setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        server.close();
+        reject(new CliError("Login timed out. Please try again.", EXIT_AUTH_ERROR));
+      }
+    }, timeoutMs);
+    server.on("close", () => clearTimeout(timer));
+    server.on("error", (err) => {
+      if (!settled) {
+        settled = true;
+        reject(new CliError(`Local server error: ${err.message}`));
+      }
+    });
+  });
+}
+function registerAuthCommands(parent) {
+  const auth = parent.command("auth").description("Manage authentication");
+  auth.command("login").description("Authenticate with Ambiguous Workspace").option("--token <token>", "Authenticate directly with an API key or JWT (for agents/CI)").action(
+    withErrorHandler(async (opts) => {
+      if (opts.token) {
+        setAuth(opts.token);
+        success("Authenticated with provided token.");
+        return;
+      }
+      const result = await browserLogin();
+      setAuth(result.token, result.user, result.email);
+      if (isJsonMode()) {
+        printJson({
+          ok: true,
+          user: result.user ?? null,
+          email: result.email ?? null
+        });
+      } else {
+        const who = result.user ?? result.email ?? "unknown";
+        success(`Logged in as ${who}`);
+      }
+    })
+  );
+  auth.command("logout").description("Clear stored credentials").action(
+    withErrorHandler(async () => {
+      clearAuth();
+      success("Logged out.");
+    })
+  );
+  auth.command("status").description("Show current authentication status").action(
+    withErrorHandler(async () => {
+      const authenticated = isAuthenticated();
+      const data = {
+        authenticated,
+        apiUrl: getApiUrl()
+      };
+      if (authenticated) {
+        const userName = get("userName");
+        const userEmail = get("userEmail");
+        if (userName) data.user = userName;
+        if (userEmail) data.email = userEmail;
+        const token = getAuthToken();
+        data.tokenPreview = token.length > 12 ? token.slice(0, 8) + "..." + token.slice(-4) : "***";
+      }
+      if (isJsonMode()) {
+        printJson(data);
+      } else {
+        printOne(data, [
+          { key: "authenticated", label: "Authenticated", format: (v) => v ? green("yes") : "no" },
+          { key: "user", label: "User" },
+          { key: "email", label: "Email" },
+          { key: "apiUrl", label: "API URL" },
+          { key: "tokenPreview", label: "Token" }
+        ].filter((f) => data[f.key] != null));
+      }
+    })
+  );
+  auth.command("token").description("Print the raw auth token (for piping to other tools)").action(
+    withErrorHandler(async () => {
+      const token = getAuthToken();
+      if (!token) {
+        throw new CliError("Not authenticated. Run `ambi auth login` first.", EXIT_AUTH_ERROR);
+      }
+      process.stdout.write(token + "\n");
+    })
+  );
+}
+
+// src/lib/input.ts
+import * as readline from "readline";
+function parseFields(fields) {
+  const result = {};
+  for (const field of fields) {
+    const eqIndex = field.indexOf("=");
+    if (eqIndex === -1) {
+      throw new Error(`Invalid field format: "${field}". Expected key=value.`);
+    }
+    const key = field.slice(0, eqIndex).trim();
+    const rawValue = field.slice(eqIndex + 1);
+    if (!key) {
+      throw new Error(`Empty key in field: "${field}".`);
+    }
+    const value = coerce(rawValue);
+    setNested(result, key, value);
+  }
+  return result;
+}
+function coerce(value) {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (value === "null") return null;
+  if (value === "") return "";
+  if (value.startsWith("[") && value.endsWith("]") || value.startsWith("{") && value.endsWith("}")) {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  if (/^-?(?:0|[1-9]\d*)(\.\d+)?$/.test(value)) {
+    const num = Number(value);
+    if (Number.isFinite(num)) return num;
+  }
+  return value;
+}
+var BANNED_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function setNested(obj, path, value) {
+  const keys = path.split(".");
+  let current = obj;
+  for (const k of keys) {
+    if (BANNED_KEYS.has(k)) {
+      throw new Error(`Invalid field key: "${k}" is not allowed.`);
+    }
+  }
+  for (let i = 0; i < keys.length - 1; i++) {
+    const k = keys[i];
+    if (current[k] == null || typeof current[k] !== "object") {
+      current[k] = {};
+    }
+    current = current[k];
+  }
+  current[keys[keys.length - 1]] = value;
+}
+var MAX_STDIN_BYTES = 10 * 1024 * 1024;
+async function readStdin() {
+  if (process.stdin.isTTY) {
+    return null;
+  }
+  const chunks = [];
+  let totalBytes = 0;
+  return new Promise((resolve6, reject) => {
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      totalBytes += Buffer.byteLength(chunk);
+      if (totalBytes > MAX_STDIN_BYTES) {
+        process.stdin.destroy();
+        reject(new Error(`Stdin too large (max ${MAX_STDIN_BYTES / 1024 / 1024} MB).`));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    process.stdin.on("end", () => {
+      const raw = chunks.join("").trim();
+      if (!raw) {
+        resolve6(null);
+        return;
+      }
+      try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+          resolve6(parsed);
+        } else {
+          reject(new Error("Stdin JSON must be an object (not an array or primitive)."));
+        }
+      } catch {
+        reject(new Error("Invalid JSON on stdin."));
+      }
+    });
+    process.stdin.on("error", reject);
+  });
+}
+async function collectInput(fieldFlags) {
+  const stdinData = await readStdin();
+  const fieldData = parseFields(fieldFlags);
+  return { ...stdinData ?? {}, ...fieldData };
+}
+async function confirm(message, defaultAnswer = false) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    return defaultAnswer;
+  }
+  const suffix = defaultAnswer ? "[Y/n]" : "[y/N]";
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stderr
+    // prompts go to stderr so stdout stays clean for piping
+  });
+  return new Promise((resolve6) => {
+    rl.question(`${message} ${suffix} `, (answer) => {
+      rl.close();
+      const trimmed = answer.trim().toLowerCase();
+      if (trimmed === "") resolve6(defaultAnswer);
+      else resolve6(trimmed === "y" || trimmed === "yes");
+    });
+  });
+}
+
+// src/commands/config.ts
+var ALLOWED_KEYS = [
+  "apiUrl",
+  "workspace",
+  "authToken",
+  "userName",
+  "userEmail"
+];
+function isValidKey(key) {
+  return ALLOWED_KEYS.includes(key);
+}
+function registerConfigCommands(parent) {
+  const cfg = parent.command("config").description("Manage CLI configuration");
+  cfg.command("get <key>").description("Get a config value").action(
+    withErrorHandler(async (key) => {
+      if (!isValidKey(key)) {
+        throw new CliError(
+          `Unknown config key: "${key}". Valid keys: ${ALLOWED_KEYS.join(", ")}`
+        );
+      }
+      const value = get(key);
+      if (isJsonMode()) {
+        printJson({ key, value: value ?? null });
+      } else {
+        if (value == null) {
+          console.log(dim("(not set)"));
+        } else {
+          if (key === "authToken" && typeof value === "string" && value.length > 12) {
+            console.log(value.slice(0, 8) + "..." + value.slice(-4));
+          } else {
+            console.log(String(value));
+          }
+        }
+      }
+    })
+  );
+  cfg.command("set <key> <value>").description("Set a config value").action(
+    withErrorHandler(async (key, value) => {
+      if (!isValidKey(key)) {
+        throw new CliError(
+          `Unknown config key: "${key}". Valid keys: ${ALLOWED_KEYS.join(", ")}`
+        );
+      }
+      set(key, value);
+      success(`Set ${key} = ${key === "authToken" ? "***" : value}`);
+    })
+  );
+  cfg.command("list").description("Show all config values").action(
+    withErrorHandler(async () => {
+      const all = getAll();
+      if (isJsonMode()) {
+        const safe = { ...all };
+        if (safe.authToken) {
+          safe.authToken = safe.authToken.length > 12 ? safe.authToken.slice(0, 8) + "..." + safe.authToken.slice(-4) : "***";
+        }
+        printJson(safe);
+      } else {
+        const entries = ALLOWED_KEYS.map((key) => ({
+          key,
+          label: key,
+          format: key === "authToken" ? (v) => {
+            if (!v) return dim("(not set)");
+            const s = String(v);
+            return s.length > 12 ? s.slice(0, 8) + "..." + s.slice(-4) : "***";
+          } : (v) => v == null ? dim("(not set)") : String(v)
+        }));
+        printOne(all, entries);
+      }
+    })
+  );
+  cfg.command("path").description("Print the config file path").action(
+    withErrorHandler(async () => {
+      const p = getConfigPath();
+      if (isJsonMode()) {
+        printJson({ path: p });
+      } else {
+        console.log(p);
+      }
+    })
+  );
+  cfg.command("reset").description("Reset config to defaults").option("-y, --yes", "Skip confirmation").action(
+    withErrorHandler(async (opts) => {
+      if (!opts.yes) {
+        const ok = await confirm("Reset all config to defaults? This will log you out.");
+        if (!ok) {
+          console.log("Cancelled.");
+          return;
+        }
+      }
+      clear();
+      success("Config reset to defaults.");
+    })
+  );
+}
+
+// src/commands/docs.ts
+import { existsSync } from "fs";
+import { writeFile } from "fs/promises";
+import { basename, resolve, extname } from "path";
+var docColumns = [
+  { key: "id", header: "ID", width: 12, format: (v) => String(v).slice(0, 12) },
+  { key: "title", header: "Title" },
+  { key: "type", header: "Type", width: 6 },
+  {
+    key: "updated_at",
+    header: "Updated",
+    format: (v) => {
+      if (!v) return "";
+      const d = new Date(String(v));
+      return d.toLocaleDateString();
+    }
+  }
+];
+function registerDocsCommands(program2) {
+  const docs = program2.command("docs").description("Manage documents (docs, sheets, slides)");
+  docs.command("list").description("List your documents").option("--type <type>", "Filter by type (doc, sheet, slide)").option("-f, --field <fields...>", "Field filters (key=value)").action(
+    withErrorHandler(async (opts) => {
+      const client = getClient();
+      const params = {};
+      if (opts.type) params.type = opts.type;
+      const res = await client.docs.list(params);
+      printTable(res.documents, docColumns);
+    })
+  );
+  docs.command("create").description("Create a new document").option("-f, --field <fields...>", "Set fields (title=..., type=doc|sheet|slide, content=...)").action(
+    withErrorHandler(async (opts) => {
+      const data = await collectInput(opts.field ?? []);
+      if (!data.type) data.type = "doc";
+      const client = getClient();
+      const doc = await client.docs.create(data);
+      if (isJsonMode()) {
+        printOne(doc);
+      } else {
+        success(`Created ${data.type} "${doc.title}" (${doc.id})`);
+      }
+    })
+  );
+  docs.command("get <id>").description("Get a document by ID").action(
+    withErrorHandler(async (id) => {
+      const client = getClient();
+      const doc = await client.docs.get(id);
+      printOne(doc);
+    })
+  );
+  docs.command("update <id>").description("Update a document").option("-f, --field <fields...>", "Set fields (title=..., content=...)").action(
+    withErrorHandler(async (id, opts) => {
+      const data = await collectInput(opts.field ?? []);
+      const client = getClient();
+      const doc = await client.docs.update(id, data);
+      if (isJsonMode()) {
+        printOne(doc);
+      } else {
+        success(`Updated "${doc.title}" (${doc.id})`);
+      }
+    })
+  );
+  docs.command("delete <id>").description("Delete a document").option("-y, --yes", "Skip confirmation").action(
+    withErrorHandler(async (id, opts) => {
+      if (!opts.yes && !isJsonMode()) {
+        const ok = await confirm(`Delete document ${id}?`);
+        if (!ok) {
+          console.error(dim("Cancelled."));
+          return;
+        }
+      }
+      const client = getClient();
+      await client.docs.delete(id);
+      success(`Deleted document ${id}`);
+    })
+  );
+  const perms = docs.command("permissions").description("Manage document permissions");
+  perms.command("list <docId>").description("List permissions for a document").action(
+    withErrorHandler(async (docId) => {
+      const client = getClient();
+      const res = await client.docs.listPermissions(docId);
+      printTable(
+        res.permissions.map((p) => ({
+          user_id: p.user_id,
+          name: p.user?.display_name ?? "",
+          email: p.user?.email ?? "",
+          role: p.role
+        })),
+        [
+          { key: "user_id", header: "User ID", width: 12, format: (v) => String(v).slice(0, 12) },
+          { key: "name", header: "Name" },
+          { key: "email", header: "Email" },
+          { key: "role", header: "Role", width: 10 }
+        ]
+      );
+    })
+  );
+  perms.command("set <docId>").description("Set permission on a document").option("-f, --field <fields...>", "Set fields (user_id=..., role=viewer|commenter|editor|owner)").action(
+    withErrorHandler(async (docId, opts) => {
+      const data = await collectInput(opts.field ?? []);
+      const client = getClient();
+      const perm = await client.docs.setPermission(docId, data);
+      if (isJsonMode()) {
+        printOne(perm);
+      } else {
+        success(`Set ${perm.role} permission for ${perm.user_id} on ${docId}`);
+      }
+    })
+  );
+  perms.command("remove <docId> <userId>").description("Remove a user's permission from a document").action(
+    withErrorHandler(async (docId, userId) => {
+      const client = getClient();
+      await client.docs.removePermission(docId, userId);
+      success(`Removed permission for ${userId} on ${docId}`);
+    })
+  );
+  const comments = docs.command("comments").description("Manage document comments");
+  comments.command("list <docId>").description("List comments on a document").action(
+    withErrorHandler(async (docId) => {
+      const client = getClient();
+      const res = await client.docs.listComments(docId);
+      printTable(
+        res.comments.map((c) => ({
+          id: c.id,
+          author: c.user?.display_name ?? c.user_id ?? "",
+          content: String(c.content ?? "").slice(0, 60),
+          resolved: c.resolved ? "yes" : "no"
+        })),
+        [
+          { key: "id", header: "ID", width: 12, format: (v) => String(v).slice(0, 12) },
+          { key: "author", header: "Author" },
+          { key: "content", header: "Content" },
+          { key: "resolved", header: "Resolved", width: 8 }
+        ]
+      );
+    })
+  );
+  comments.command("add <docId>").description("Add a comment to a document").option("-f, --field <fields...>", "Set fields (content=..., parent_id=...)").action(
+    withErrorHandler(async (docId, opts) => {
+      const data = await collectInput(opts.field ?? []);
+      const client = getClient();
+      const comment = await client.docs.addComment(docId, data);
+      if (isJsonMode()) {
+        printOne(comment);
+      } else {
+        success(`Added comment ${comment.id}`);
+      }
+    })
+  );
+  comments.command("resolve <docId> <commentId>").description("Resolve a comment").action(
+    withErrorHandler(async (docId, commentId) => {
+      const client = getClient();
+      await client.docs.resolveComment(docId, commentId, true);
+      success(`Resolved comment ${commentId}`);
+    })
+  );
+  comments.command("unresolve <docId> <commentId>").description("Unresolve a comment").action(
+    withErrorHandler(async (docId, commentId) => {
+      const client = getClient();
+      await client.docs.resolveComment(docId, commentId, false);
+      success(`Unreresolved comment ${commentId}`);
+    })
+  );
+  comments.command("delete <docId> <commentId>").description("Delete a comment").option("-y, --yes", "Skip confirmation").action(
+    withErrorHandler(async (docId, commentId, opts) => {
+      if (!opts.yes && !isJsonMode()) {
+        const ok = await confirm(`Delete comment ${commentId}?`);
+        if (!ok) {
+          console.error(dim("Cancelled."));
+          return;
+        }
+      }
+      const client = getClient();
+      await client.docs.deleteComment(docId, commentId);
+      success(`Deleted comment ${commentId}`);
+    })
+  );
+  docs.command("import <file>").description("Import a file as a new document (.md, .html, .txt, .docx)").option("-f, --field <fields...>", "Set fields (title=...)").action(
+    withErrorHandler(async (file, opts) => {
+      const filePath = resolve(file);
+      if (!existsSync(filePath)) {
+        throw new CliError(`File not found: ${filePath}`);
+      }
+      const fields = await collectInput(opts.field ?? []);
+      const title = fields.title ?? basename(file, extname(file));
+      const fileContent = await import("fs/promises").then((fs) => fs.readFile(filePath));
+      const fileName = basename(filePath);
+      const formData = new FormData();
+      formData.append("file", new globalThis.Blob([fileContent]), fileName);
+      formData.append("title", title);
+      const apiUrl = getApiUrl();
+      const token = getAuthToken();
+      if (!token) throw new CliError("Not authenticated. Run `ambi auth login` first.", 2);
+      const res = await fetch(`${apiUrl}/api/documents/import`, {
+        method: "POST",
+        headers: {
+          "Authorization": token.startsWith("ak_") ? `Bearer ${token}` : `Bearer ${token}`
+        },
+        body: formData
+      });
+      if (!res.ok) {
+        const body = await res.json().catch(() => ({}));
+        throw new CliError(
+          body.error || body.message || `Import failed: HTTP ${res.status}`
+        );
+      }
+      const doc = await res.json();
+      if (isJsonMode()) {
+        printOne(doc);
+      } else {
+        success(`Imported "${doc.title}" (${doc.id})`);
+      }
+    })
+  );
+  docs.command("export <id>").description("Export a document to a file").requiredOption("--format <format>", "Export format (docx, pdf, html, md, xlsx, csv, pptx)").option("-o, --output <path>", "Output file path (default: ./<title>.<format>)").action(
+    withErrorHandler(async (id, opts) => {
+      const format = opts.format;
+      const validFormats = ["docx", "pdf", "html", "md", "xlsx", "csv", "pptx"];
+      if (!validFormats.includes(format)) {
+        throw new CliError(`Invalid format "${format}". Valid: ${validFormats.join(", ")}`);
+      }
+      const apiUrl = getApiUrl();
+      const token = getAuthToken();
+      if (!token) throw new CliError("Not authenticated. Run `ambi auth login` first.", 2);
+      info(`Exporting document ${id} as ${format}...`);
+      const res = await fetch(`${apiUrl}/api/documents/${encodeURIComponent(id)}/export`, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ format })
+      });
+      if (!res.ok) {
+        const body = await res.json().catch(() => ({}));
+        throw new CliError(
+          body.error || body.message || `Export failed: HTTP ${res.status}`
+        );
+      }
+      const contentDisp = res.headers.get("content-disposition") ?? "";
+      const filenameMatch = contentDisp.match(/filename="?([^";\n]+)"?/);
+      const serverFilename = filenameMatch?.[1];
+      const outputPath = opts.output ? resolve(opts.output) : resolve(serverFilename ?? `document-${id}.${format}`);
+      const buffer = Buffer.from(await res.arrayBuffer());
+      await writeFile(outputPath, buffer);
+      if (isJsonMode()) {
+        printOne({ ok: true, path: outputPath, format, size: buffer.length });
+      } else {
+        success(`Exported to ${outputPath} (${formatBytes(buffer.length)})`);
+      }
+    })
+  );
+  const versions = docs.command("versions").description("Manage document version history");
+  versions.command("list <docId>").description("List version history for a document").action(
+    withErrorHandler(async (docId) => {
+      const client = getClient();
+      const res = await client.request("GET", `/api/documents/${docId}/versions`);
+      printTable(
+        (res.versions ?? []).map((v) => ({
+          id: v.id,
+          title: v.title ?? "",
+          user: v.user_name ?? v.user_id ?? "",
+          created_at: v.created_at
+        })),
+        [
+          { key: "id", header: "Version ID", width: 12, format: (v) => String(v).slice(0, 12) },
+          { key: "title", header: "Title" },
+          { key: "user", header: "User" },
+          {
+            key: "created_at",
+            header: "Created",
+            format: (v) => {
+              if (!v) return "";
+              const d = new Date(String(v));
+              return d.toLocaleString();
+            }
+          }
+        ]
+      );
+    })
+  );
+  versions.command("create <docId>").description("Create a manual version snapshot").action(
+    withErrorHandler(async (docId) => {
+      const client = getClient();
+      const version = await client.request("POST", `/api/documents/${docId}/versions`);
+      if (isJsonMode()) {
+        printOne(version);
+      } else {
+        success(`Created version ${version.id} for document ${docId}`);
+      }
+    })
+  );
+  versions.command("get <docId> <versionId>").description("Get a specific version (includes content)").action(
+    withErrorHandler(async (docId, versionId) => {
+      const client = getClient();
+      const version = await client.request(
+        "GET",
+        `/api/documents/${docId}/versions/${versionId}`
+      );
+      printOne(version);
+    })
+  );
+  versions.command("revert <docId> <versionId>").description("Revert a document to a specific version").option("-y, --yes", "Skip confirmation").action(
+    withErrorHandler(async (docId, versionId, opts) => {
+      if (!opts.yes && !isJsonMode()) {
+        const ok = await confirm(`Revert document ${docId} to version ${versionId}?`);
+        if (!ok) {
+          console.error(dim("Cancelled."));
+          return;
+        }
+      }
+      const client = getClient();
+      await client.request("POST", `/api/documents/${docId}/versions/${versionId}/revert`);
+      success(`Reverted document ${docId} to version ${versionId}`);
+    })
+  );
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+// src/commands/sheets.ts
+import { existsSync as existsSync2 } from "fs";
+import { readFile } from "fs/promises";
+import { basename as basename2, resolve as resolve2, extname as extname2 } from "path";
+var sheetListColumns = [
+  { key: "id", header: "ID", width: 12, format: (v) => String(v).slice(0, 12) },
+  { key: "title", header: "Title" },
+  {
+    key: "updated_at",
+    header: "Updated",
+    format: (v) => {
+      if (!v) return "";
+      return new Date(String(v)).toLocaleDateString();
+    }
+  }
+];
+function registerSheetsCommands(program2) {
+  const sheets = program2.command("sheets").description("Manage spreadsheets");
+  sheets.command("list").description("List your sheets").action(
+    withErrorHandler(async () => {
+      const client = getClient();
+      const res = await client.docs.list({ type: "sheet" });
+      printTable(res.documents, sheetListColumns);
+    })
+  );
+  sheets.command("create").description("Create a new spreadsheet").option("-f, --field <fields...>", "Set fields (title=...)").action(
+    withErrorHandler(async (opts) => {
+      const data = await collectInput(opts.field ?? []);
+      data.type = "sheet";
+      const client = getClient();
+      const doc = await client.docs.create(data);
+      if (isJsonMode()) {
+        printOne(doc);
+      } else {
+        success(`Created sheet "${doc.title}" (${doc.id})`);
+      }
+    })
+  );
+  sheets.command("get <id>").description("Get a sheet document by ID").action(
+    withErrorHandler(async (id) => {
+      const client = getClient();
+      const doc = await client.docs.get(id);
+      printOne(doc);
+    })
+  );
+  sheets.command("delete <id>").description("Delete a sheet").option("-y, --yes", "Skip confirmation").action(
+    withErrorHandler(async (id, opts) => {
+      if (!opts.yes && !isJsonMode()) {
+        const ok = await confirm(`Delete sheet ${id}?`);
+        if (!ok) {
+          console.error(dim("Cancelled."));
+          return;
+        }
+      }
+      const client = getClient();
+      await client.docs.delete(id);
+      success(`Deleted sheet ${id}`);
+    })
+  );
+  sheets.command("data <id>").description("Get structured sheet data (columns + rows as JSON)").option("--tab <name>", "Show only a specific tab").action(
+    withErrorHandler(async (id, opts) => {
+      const client = getClient();
+      const data = await client.sheets.getData(id);
+      if (isJsonMode()) {
+        if (opts.tab) {
+          const tab = data.sheets.find((s) => s.name === opts.tab);
+          if (!tab) throw new CliError(`Tab "${opts.tab}" not found`);
+          printOne(tab);
+        } else {
+          printOne(data);
+        }
+        return;
+      }
+      const tabs = opts.tab ? data.sheets.filter((s) => s.name === opts.tab) : data.sheets;
+      if (opts.tab && tabs.length === 0) {
+        throw new CliError(`Tab "${opts.tab}" not found`);
+      }
+      for (const tab of tabs) {
+        if (data.sheets.length > 1) {
+          info(`
+--- ${tab.name} ---`);
+        }
+        if (tab.columns.length === 0) {
+          info("(empty sheet)");
+          continue;
+        }
+        const columns = tab.columns.map((col) => ({
+          key: col.id,
+          header: col.name || col.id
+        }));
+        printTable(tab.rows, columns);
+      }
+    })
+  );
+  sheets.command("update-cells <id>").description("Update specific cells (pass JSON array via stdin or -f)").option("-f, --field <fields...>", "Cell updates as row:col=value (e.g., 0:A=Hello)").option("--tab <name>", "Target sheet tab name").action(
+    withErrorHandler(async (id, opts) => {
+      let cells;
+      const stdinData = await collectInput([]);
+      if (stdinData.cells && Array.isArray(stdinData.cells)) {
+        cells = stdinData.cells;
+      } else if (opts.field && opts.field.length > 0) {
+        cells = opts.field.map((f) => {
+          const match = f.match(/^(\d+):([A-Za-z]+)=(.*)$/);
+          if (!match) throw new CliError(`Invalid cell format "${f}". Use row:col=value (e.g., 0:A=Hello)`);
+          const [, rowStr, column, value] = match;
+          const cell = { row: parseInt(rowStr, 10), column, value };
+          if (opts.tab) cell.sheet = opts.tab;
+          return cell;
+        });
+      } else {
+        throw new CliError('Provide cell updates via stdin JSON ({"cells": [...]}) or -f 0:A=Hello');
+      }
+      const client = getClient();
+      const result = await client.sheets.updateCells(id, cells);
+      if (isJsonMode()) {
+        printOne(result);
+      } else {
+        success(`Updated ${cells.length} cell(s)`);
+      }
+    })
+  );
+  sheets.command("import <file>").description("Import a file as a new spreadsheet (.xlsx, .csv)").option("-f, --field <fields...>", "Set fields (title=...)").action(
+    withErrorHandler(async (file, opts) => {
+      const filePath = resolve2(file);
+      if (!existsSync2(filePath)) {
+        throw new CliError(`File not found: ${filePath}`);
+      }
+      const ext = extname2(filePath).toLowerCase();
+      if (![".xlsx", ".csv"].includes(ext)) {
+        throw new CliError(`Unsupported format "${ext}". Use .xlsx or .csv`);
+      }
+      const fields = await collectInput(opts.field ?? []);
+      const title = fields.title ?? basename2(file, ext);
+      const fileContent = await readFile(filePath);
+      const fileName = basename2(filePath);
+      const formData = new FormData();
+      formData.append("file", new globalThis.Blob([fileContent]), fileName);
+      formData.append("title", title);
+      const apiUrl = getApiUrl();
+      const token = getAuthToken();
+      if (!token) throw new CliError("Not authenticated. Run `ambi auth login` first.", 2);
+      const res = await fetch(`${apiUrl}/api/sheets/import`, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${token}`
+        },
+        body: formData
+      });
+      if (!res.ok) {
+        const body = await res.json().catch(() => ({}));
+        throw new CliError(
+          body.error || body.message || `Import failed: HTTP ${res.status}`
+        );
+      }
+      const doc = await res.json();
+      if (isJsonMode()) {
+        printOne(doc);
+      } else {
+        success(`Imported "${doc.title}" (${doc.id})`);
+      }
+    })
+  );
+  sheets.command("add-tab <id>").description("Add a new sheet tab").option("--name <name>", "Tab name").action(
+    withErrorHandler(async (id, opts) => {
+      const client = getClient();
+      const result = await client.sheets.addTab(id, opts.name);
+      if (isJsonMode()) {
+        printOne(result);
+      } else {
+        const tabNames = result.sheets.map((s) => s.name).join(", ");
+        success(`Added tab. Tabs: ${tabNames}`);
+      }
+    })
+  );
+  sheets.command("remove-tab <id> <tabName>").description("Remove a sheet tab").option("-y, --yes", "Skip confirmation").action(
+    withErrorHandler(async (id, tabName, opts) => {
+      if (!opts.yes && !isJsonMode()) {
+        const ok = await confirm(`Remove tab "${tabName}" from sheet ${id}?`);
+        if (!ok) {
+          console.error(dim("Cancelled."));
+          return;
+        }
+      }
+      const client = getClient();
+      const result = await client.sheets.removeTab(id, tabName);
+      if (isJsonMode()) {
+        printOne(result);
+      } else {
+        success(`Removed tab "${tabName}"`);
+      }
+    })
+  );
+  sheets.command("rename-tab <id> <tabName> <newName>").description("Rename a sheet tab").action(
+    withErrorHandler(async (id, tabName, newName) => {
+      const client = getClient();
+      const result = await client.sheets.renameTab(id, tabName, newName);
+      if (isJsonMode()) {
+        printOne(result);
+      } else {
+        success(`Renamed tab "${tabName}" to "${newName}"`);
+      }
+    })
+  );
+  sheets.command("add-columns <id>").description("Add a column to a sheet").option("-f, --field <fields...>", "Column fields (name=..., type=text|number|currency|date|boolean|formula)").option("--tab <name>", "Target sheet tab name").action(
+    withErrorHandler(async (id, opts) => {
+      const data = await collectInput(opts.field ?? []);
+      if (!data.name) throw new CliError("Column name is required. Use -f name=...");
+      const params = { name: data.name };
+      if (data.type) params.type = data.type;
+      if (data.id) params.id = data.id;
+      if (opts.tab) params.sheet = opts.tab;
+      const client = getClient();
+      const result = await client.sheets.addColumn(id, params);
+      if (isJsonMode()) {
+        printOne(result);
+      } else {
+        success(`Added column "${data.name}"`);
+      }
+    })
+  );
+  sheets.command("remove-column <id> <columnId>").description("Remove a column from a sheet").option("--tab <name>", "Target sheet tab name").option("-y, --yes", "Skip confirmation").action(
+    withErrorHandler(async (id, columnId, opts) => {
+      if (!opts.yes && !isJsonMode()) {
+        const ok = await confirm(`Remove column "${columnId}"?`);
+        if (!ok) {
+          console.error(dim("Cancelled."));
+          return;
+        }
+      }
+      const client = getClient();
+      const result = await client.sheets.removeColumn(id, columnId, opts.tab);
+      if (isJsonMode()) {
+        printOne(result);
+      } else {
+        success(`Removed column "${columnId}"`);
+      }
+    })
+  );
+  sheets.command("add-rows <id>").description("Add rows to a sheet (pass JSON array via stdin)").option("--tab <name>", "Target sheet tab name").action(
+    withErrorHandler(async (id, opts) => {
+      const stdinData = await collectInput([]);
+      let rows;
+      if (stdinData.rows && Array.isArray(stdinData.rows)) {
+        rows = stdinData.rows;
+      } else if (Array.isArray(stdinData)) {
+        rows = stdinData;
+      } else {
+        throw new CliError('Provide rows via stdin JSON: {"rows": [{...}, ...]} or [{...}, ...]');
+      }
+      const client = getClient();
+      const result = await client.sheets.addRows(id, rows, opts.tab);
+      if (isJsonMode()) {
+        printOne(result);
+      } else {
+        success(`Added ${rows.length} row(s)`);
+      }
+    })
+  );
+  sheets.command("delete-rows <id>").description("Delete rows by index (0-based)").option("-f, --field <fields...>", "Row indices (e.g., -f 0 -f 2 -f 5)").option("--tab <name>", "Target sheet tab name").option("-y, --yes", "Skip confirmation").action(
+    withErrorHandler(async (id, opts) => {
+      let indices;
+      const stdinData = await collectInput([]);
+      if (stdinData.indices && Array.isArray(stdinData.indices)) {
+        indices = stdinData.indices.map(Number);
+      } else if (opts.field && opts.field.length > 0) {
+        indices = opts.field.map((f) => {
+          const n = parseInt(f, 10);
+          if (isNaN(n)) throw new CliError(`Invalid row index "${f}"`);
+          return n;
+        });
+      } else {
+        throw new CliError('Provide row indices via -f 0 -f 2 or stdin JSON: {"indices": [0, 2]}');
+      }
+      if (!opts.yes && !isJsonMode()) {
+        const ok = await confirm(`Delete ${indices.length} row(s)?`);
+        if (!ok) {
+          console.error(dim("Cancelled."));
+          return;
+        }
+      }
+      const client = getClient();
+      const result = await client.sheets.deleteRows(id, indices, opts.tab);
+      if (isJsonMode()) {
+        printOne(result);
+      } else {
+        success(`Deleted ${indices.length} row(s)`);
+      }
+    })
+  );
+}
+
+// src/commands/slides.ts
+import { existsSync as existsSync3 } from "fs";
+import { readFile as readFile2 } from "fs/promises";
+import { basename as basename3, resolve as resolve3, extname as extname3 } from "path";
+var slideListColumns = [
+  { key: "id", header: "ID", width: 12, format: (v) => String(v).slice(0, 12) },
+  { key: "title", header: "Title" },
+  {
+    key: "updated_at",
+    header: "Updated",
+    format: (v) => {
+      if (!v) return "";
+      return new Date(String(v)).toLocaleDateString();
+    }
+  }
+];
+var layoutColumns = [
+  { key: "name", header: "Name" },
+  { key: "description", header: "Description" }
+];
+function registerSlidesCommands(program2) {
+  const slides = program2.command("slides").description("Manage presentations");
+  slides.command("list").description("List your slide decks").action(
+    withErrorHandler(async () => {
+      const client = getClient();
+      const res = await client.docs.list({ type: "slide" });
+      printTable(res.documents, slideListColumns);
+    })
+  );
+  slides.command("create").description("Create a new slide deck").option("-f, --field <fields...>", "Set fields (title=...)").action(
+    withErrorHandler(async (opts) => {
+      const data = await collectInput(opts.field ?? []);
+      data.type = "slide";
+      const client = getClient();
+      const doc = await client.docs.create(data);
+      if (isJsonMode()) {
+        printOne(doc);
+      } else {
+        success(`Created deck "${doc.title}" (${doc.id})`);
+      }
+    })
+  );
+  slides.command("get <id>").description("Get a slide document by ID").action(
+    withErrorHandler(async (id) => {
+      const client = getClient();
+      const doc = await client.docs.get(id);
+      printOne(doc);
+    })
+  );
+  slides.command("delete <id>").description("Delete a slide deck").option("-y, --yes", "Skip confirmation").action(
+    withErrorHandler(async (id, opts) => {
+      if (!opts.yes && !isJsonMode()) {
+        const ok = await confirm(`Delete slide deck ${id}?`);
+        if (!ok) {
+          console.error(dim("Cancelled."));
+          return;
+        }
+      }
+      const client = getClient();
+      await client.docs.delete(id);
+      success(`Deleted slide deck ${id}`);
+    })
+  );
+  slides.command("data <id>").description("Get structured slide data (slides array + settings)").action(
+    withErrorHandler(async (id) => {
+      const client = getClient();
+      const data = await client.slides.getData(id);
+      if (isJsonMode()) {
+        printOne(data);
+        return;
+      }
+      info(`Slide count: ${data.slide_count}`);
+      if (data.settings && Object.keys(data.settings).length > 0) {
+        info(`Settings: ${JSON.stringify(data.settings)}`);
+      }
+      for (let i = 0; i < data.slides.length; i++) {
+        const slide = data.slides[i];
+        info(`
+--- Slide ${i} ${slide.layout ? `(${slide.layout})` : ""} ---`);
+        console.log(slide.content);
+      }
+    })
+  );
+  slides.command("layouts").description("List available slide layouts").action(
+    withErrorHandler(async () => {
+      const client = getClient();
+      const res = await client.slides.listLayouts();
+      printTable(res.layouts, layoutColumns);
+    })
+  );
+  slides.command("add-slide <id>").description("Add a new slide to a deck").option("-f, --field <fields...>", "Set fields (content=..., layout=..., after_index=...)").action(
+    withErrorHandler(async (id, opts) => {
+      const data = await collectInput(opts.field ?? []);
+      const params = {};
+      if (data.content) params.content = data.content;
+      if (data.layout) params.layout = data.layout;
+      if (data.after_index !== void 0) params.after_index = parseInt(String(data.after_index), 10);
+      const client = getClient();
+      const result = await client.slides.addSlide(id, params);
+      if (isJsonMode()) {
+        printOne(result);
+      } else {
+        success(`Added slide (${result.slide_count} total)`);
+      }
+    })
+  );
+  slides.command("update-slide <id> <index>").description("Update a specific slide").option("-f, --field <fields...>", "Set fields (content=..., layout=...)").action(
+    withErrorHandler(async (id, indexStr, opts) => {
+      const index = parseInt(indexStr, 10);
+      if (isNaN(index)) throw new CliError(`Invalid slide index "${indexStr}"`);
+      const data = await collectInput(opts.field ?? []);
+      const params = {};
+      if (data.content) params.content = data.content;
+      if (data.layout) params.layout = data.layout;
+      const client = getClient();
+      const result = await client.slides.updateSlide(id, index, params);
+      if (isJsonMode()) {
+        printOne(result);
+      } else {
+        success(`Updated slide ${index}`);
+      }
+    })
+  );
+  slides.command("remove-slide <id> <index>").description("Remove a slide from a deck").option("-y, --yes", "Skip confirmation").action(
+    withErrorHandler(async (id, indexStr, opts) => {
+      const index = parseInt(indexStr, 10);
+      if (isNaN(index)) throw new CliError(`Invalid slide index "${indexStr}"`);
+      if (!opts.yes && !isJsonMode()) {
+        const ok = await confirm(`Remove slide ${index}?`);
+        if (!ok) {
+          console.error(dim("Cancelled."));
+          return;
+        }
+      }
+      const client = getClient();
+      const result = await client.slides.removeSlide(id, index);
+      if (isJsonMode()) {
+        printOne(result);
+      } else {
+        success(`Removed slide ${index} (${result.slide_count} remaining)`);
+      }
+    })
+  );
+  slides.command("reorder <id>").description("Reorder slides (--order 2,0,1,3)").requiredOption("--order <indices>", "Comma-separated slide indices in new order").action(
+    withErrorHandler(async (id, opts) => {
+      const order = opts.order.split(",").map((s) => {
+        const n = parseInt(s.trim(), 10);
+        if (isNaN(n)) throw new CliError(`Invalid index "${s}" in --order`);
+        return n;
+      });
+      const client = getClient();
+      const result = await client.slides.reorder(id, order);
+      if (isJsonMode()) {
+        printOne(result);
+      } else {
+        success(`Reordered slides: ${order.join(", ")}`);
+      }
+    })
+  );
+  slides.command("settings <id>").description("Get or update deck settings").option("-f, --field <fields...>", "Set fields (theme=..., aspect_ratio=16:9, paginate=true)").action(
+    withErrorHandler(async (id, opts) => {
+      const client = getClient();
+      if (!opts.field || opts.field.length === 0) {
+        const data2 = await client.slides.getData(id);
+        printOne(data2.settings);
+        return;
+      }
+      const data = await collectInput(opts.field);
+      const params = {};
+      if (data.theme) params.theme = data.theme;
+      if (data.aspect_ratio) params.aspect_ratio = data.aspect_ratio;
+      if (data.header) params.header = data.header;
+      if (data.footer) params.footer = data.footer;
+      if (data.paginate !== void 0) params.paginate = data.paginate === "true" || data.paginate === true;
+      const result = await client.slides.updateSettings(id, params);
+      if (isJsonMode()) {
+        printOne(result);
+      } else {
+        success("Updated deck settings");
+      }
+    })
+  );
+  slides.command("import <file>").description("Import a file as a new slide deck (.pptx)").option("-f, --field <fields...>", "Set fields (title=...)").action(
+    withErrorHandler(async (file, opts) => {
+      const filePath = resolve3(file);
+      if (!existsSync3(filePath)) {
+        throw new CliError(`File not found: ${filePath}`);
+      }
+      const ext = extname3(filePath).toLowerCase();
+      if (ext !== ".pptx") {
+        throw new CliError(`Unsupported format "${ext}". Use .pptx`);
+      }
+      const fields = await collectInput(opts.field ?? []);
+      const title = fields.title ?? basename3(file, ext);
+      const fileContent = await readFile2(filePath);
+      const fileName = basename3(filePath);
+      const formData = new FormData();
+      formData.append("file", new globalThis.Blob([fileContent]), fileName);
+      formData.append("title", title);
+      const apiUrl = getApiUrl();
+      const token = getAuthToken();
+      if (!token) throw new CliError("Not authenticated. Run `ambi auth login` first.", 2);
+      const res = await fetch(`${apiUrl}/api/slides/import`, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${token}`
+        },
+        body: formData
+      });
+      if (!res.ok) {
+        const body = await res.json().catch(() => ({}));
+        throw new CliError(
+          body.error || body.message || `Import failed: HTTP ${res.status}`
+        );
+      }
+      const doc = await res.json();
+      if (isJsonMode()) {
+        printOne(doc);
+      } else {
+        success(`Imported "${doc.title}" (${doc.id})`);
+      }
+    })
+  );
+}
+
+// src/commands/chat.ts
+var channelColumns = [
+  { key: "id", header: "ID", width: 12, format: (v) => String(v).slice(0, 12) },
+  { key: "name", header: "Name" },
+  { key: "type", header: "Type", width: 8 },
+  { key: "description", header: "Description", format: (v) => v ? String(v).slice(0, 40) : "" }
+];
+var messageColumns = [
+  { key: "id", header: "ID", width: 12, format: (v) => String(v).slice(0, 12) },
+  {
+    key: "user",
+    header: "From",
+    format: (v) => {
+      if (v && typeof v === "object" && "display_name" in v) {
+        return String(v.display_name);
+      }
+      return String(v ?? "");
+    }
+  },
+  { key: "content", header: "Content", format: (v) => String(v ?? "").slice(0, 60) },
+  {
+    key: "created_at",
+    header: "Time",
+    format: (v) => {
+      if (!v) return "";
+      const d = new Date(String(v));
+      return d.toLocaleString();
+    }
+  }
+];
+function registerChatCommands(program2) {
+  const chat = program2.command("chat").description("Chat \u2014 channels, messages, reactions, threads");
+  const channels = chat.command("channels").description("Manage channels");
+  channels.command("list").description("List your channels").action(
+    withErrorHandler(async () => {
+      const client = getClient();
+      const res = await client.chat.listChannels();
+      printTable(res.channels, channelColumns);
+    })
+  );
+  channels.command("create").description("Create a channel").option("-f, --field <fields...>", "Set fields (name=..., type=public|private|dm, description=..., member_ids=[...])").action(
+    withErrorHandler(async (opts) => {
+      const data = await collectInput(opts.field ?? []);
+      if (!data.type) data.type = "public";
+      const client = getClient();
+      const ch = await client.chat.createChannel(data);
+      if (isJsonMode()) {
+        printOne(ch);
+      } else {
+        success(`Channel created: ${ch.id}`);
+        printOne(ch);
+      }
+    })
+  );
+  channels.command("get <id>").description("Get channel details").action(
+    withErrorHandler(async (id) => {
+      const client = getClient();
+      const ch = await client.chat.getChannel(id);
+      printOne(ch);
+    })
+  );
+  channels.command("update <id>").description("Update a channel").option("-f, --field <fields...>", "Set fields (name=..., description=...)").action(
+    withErrorHandler(async (id, opts) => {
+      const data = await collectInput(opts.field ?? []);
+      const client = getClient();
+      const ch = await client.chat.updateChannel(id, data);
+      if (isJsonMode()) {
+        printOne(ch);
+      } else {
+        success(`Channel updated: ${id}`);
+      }
+    })
+  );
+  channels.command("delete <id>").description("Delete a channel").option("-y, --yes", "Skip confirmation").action(
+    withErrorHandler(async (id, opts) => {
+      if (!opts.yes && !isJsonMode()) {
+        const ok = await confirm(`Delete channel ${id}?`);
+        if (!ok) {
+          console.error(dim("Cancelled."));
+          return;
+        }
+      }
+      const client = getClient();
+      await client.chat.deleteChannel(id);
+      success(`Channel deleted: ${id}`);
+    })
+  );
+  const messages = chat.command("messages").description("Send and manage messages");
+  messages.command("list <channelId>").description("List messages in a channel").option("--limit <n>", "Number of messages to fetch", "50").option("--before <msgId>", "Fetch messages before this ID (pagination)").action(
+    withErrorHandler(async (channelId, opts) => {
+      const client = getClient();
+      const params = {};
+      if (opts.limit) params.limit = parseInt(opts.limit, 10);
+      if (opts.before) params.before = opts.before;
+      const res = await client.chat.listMessages(channelId, params);
+      printTable(res.messages, messageColumns);
+    })
+  );
+  messages.command("send <channelId>").description("Send a message").option("-f, --field <fields...>", "Set fields (content=..., thread_id=...)").action(
+    withErrorHandler(async (channelId, opts) => {
+      const data = await collectInput(opts.field ?? []);
+      if (!data.content) {
+        throw new CliError('Message content is required. Use -f content="your message"');
+      }
+      const client = getClient();
+      const msg = await client.chat.sendMessage(channelId, data);
+      if (isJsonMode()) {
+        printOne(msg);
+      } else {
+        success(`Message sent: ${msg.id}`);
+      }
+    })
+  );
+  messages.command("edit <channelId> <messageId>").description("Edit a message").option("-f, --field <fields...>", "Set fields (content=...)").action(
+    withErrorHandler(async (channelId, messageId, opts) => {
+      const data = await collectInput(opts.field ?? []);
+      if (!data.content) {
+        throw new CliError('Message content is required. Use -f content="new content"');
+      }
+      const client = getClient();
+      const msg = await client.chat.editMessage(channelId, messageId, String(data.content));
+      if (isJsonMode()) {
+        printOne(msg);
+      } else {
+        success(`Message updated: ${messageId}`);
+      }
+    })
+  );
+  messages.command("delete <channelId> <messageId>").description("Delete a message").action(
+    withErrorHandler(async (channelId, messageId) => {
+      const client = getClient();
+      await client.chat.deleteMessage(channelId, messageId);
+      success(`Message deleted: ${messageId}`);
+    })
+  );
+  messages.command("search").description("Search messages across channels").requiredOption("-f, --field <fields...>", "Search fields (q=..., channel_id=..., limit=...)").action(
+    withErrorHandler(async (opts) => {
+      const data = await collectInput(opts.field ?? []);
+      if (!data.q) {
+        throw new CliError('Search query is required. Use -f q="search term"');
+      }
+      const client = getClient();
+      const query = { q: String(data.q) };
+      if (data.channel_id) query.channel_id = String(data.channel_id);
+      if (data.limit) query.limit = String(data.limit);
+      const res = await client.request("GET", "/api/channels/messages/search", void 0, query);
+      const messages2 = res.messages ?? res;
+      printTable(messages2, messageColumns);
+    })
+  );
+  chat.command("react <channelId> <messageId> <emoji>").description("Add a reaction to a message").action(
+    withErrorHandler(async (channelId, messageId, emoji) => {
+      const client = getClient();
+      await client.chat.addReaction(channelId, messageId, emoji);
+      success(`Reaction ${emoji} added to ${messageId}`);
+    })
+  );
+  chat.command("unreact <channelId> <messageId> <emoji>").description("Remove a reaction from a message").action(
+    withErrorHandler(async (channelId, messageId, emoji) => {
+      const client = getClient();
+      await client.chat.removeReaction(channelId, messageId, emoji);
+      success(`Reaction ${emoji} removed from ${messageId}`);
+    })
+  );
+  chat.command("thread <channelId> <messageId>").description("Get thread replies for a message").action(
+    withErrorHandler(async (channelId, messageId) => {
+      const client = getClient();
+      const res = await client.chat.getThread(channelId, messageId);
+      printTable(res.messages, messageColumns);
+    })
+  );
+  chat.command("add-member <channelId>").description("Add member(s) to a channel").option("-f, --field <fields...>", "Set fields (user_ids=[...] or user_id=...)").action(
+    withErrorHandler(async (channelId, opts) => {
+      const data = await collectInput(opts.field ?? []);
+      let userIds;
+      if (data.user_ids && Array.isArray(data.user_ids)) {
+        userIds = data.user_ids;
+      } else if (data.user_id) {
+        userIds = [String(data.user_id)];
+      } else {
+        throw new CliError('Specify user(s): -f user_id=<id> or -f user_ids=["id1","id2"]');
+      }
+      const client = getClient();
+      const res = await client.chat.addMembers(channelId, userIds);
+      success(`Added ${userIds.length} member(s) to channel ${channelId}`);
+      if (isJsonMode()) printOne(res);
+    })
+  );
+  chat.command("remove-member <channelId> <userId>").description("Remove a member from a channel").action(
+    withErrorHandler(async (channelId, userId) => {
+      const client = getClient();
+      await client.chat.removeMember(channelId, userId);
+      success(`Removed ${userId} from channel ${channelId}`);
+    })
+  );
+}
+
+// src/commands/mail.ts
+var emailListColumns = [
+  { key: "id", header: "ID", width: 12, format: (v) => String(v).slice(0, 12) },
+  {
+    key: "from",
+    header: "From",
+    format: (v) => {
+      if (v && typeof v === "object" && "display_name" in v) {
+        return String(v.display_name);
+      }
+      return String(v ?? "");
+    }
+  },
+  { key: "subject", header: "Subject", format: (v) => String(v ?? "").slice(0, 50) },
+  {
+    key: "read",
+    header: "Read",
+    width: 5,
+    format: (v) => v ? "yes" : "no"
+  },
+  {
+    key: "starred",
+    header: "Star",
+    width: 5,
+    format: (v) => v ? "*" : ""
+  },
+  {
+    key: "sent_at",
+    header: "Date",
+    format: (v) => {
+      if (!v) return "";
+      const d = new Date(String(v));
+      return d.toLocaleDateString();
+    }
+  }
+];
+function buildListOpts(opts) {
+  const query = {};
+  if (opts.limit) query.limit = opts.limit;
+  if (opts.offset) query.offset = opts.offset;
+  return query;
+}
+function registerMailCommands(program2) {
+  const mail = program2.command("mail").description("Mail \u2014 inbox, send, read, star, signature");
+  mail.command("inbox").description("List inbox emails").option("--limit <n>", "Max results", "50").option("--offset <n>", "Offset for pagination", "0").option("--unread", "Show only unread emails").action(
+    withErrorHandler(async (opts) => {
+      const client = getClient();
+      const res = await client.mail.inbox({
+        limit: parseInt(opts.limit, 10),
+        offset: parseInt(opts.offset, 10),
+        ...opts.unread ? { unread: true } : {}
+      });
+      printTable(res.emails, emailListColumns);
+    })
+  );
+  mail.command("sent").description("List sent emails").option("--limit <n>", "Max results", "50").option("--offset <n>", "Offset for pagination", "0").action(
+    withErrorHandler(async (opts) => {
+      const client = getClient();
+      const res = await client.mail.sent({
+        limit: parseInt(opts.limit, 10),
+        offset: parseInt(opts.offset, 10)
+      });
+      printTable(res.emails, emailListColumns);
+    })
+  );
+  mail.command("starred").description("List starred emails").option("--limit <n>", "Max results", "50").option("--offset <n>", "Offset for pagination", "0").action(
+    withErrorHandler(async (opts) => {
+      const client = getClient();
+      const res = await client.request("GET", "/api/mail/starred", void 0, buildListOpts(opts));
+      printTable(res.emails, emailListColumns);
+    })
+  );
+  mail.command("drafts").description("List draft emails").option("--limit <n>", "Max results", "50").option("--offset <n>", "Offset for pagination", "0").action(
+    withErrorHandler(async (opts) => {
+      const client = getClient();
+      const res = await client.request("GET", "/api/mail/drafts", void 0, buildListOpts(opts));
+      printTable(res.emails, emailListColumns);
+    })
+  );
+  mail.command("snoozed").description("List snoozed emails").option("--limit <n>", "Max results", "50").option("--offset <n>", "Offset for pagination", "0").action(
+    withErrorHandler(async (opts) => {
+      const client = getClient();
+      const res = await client.request("GET", "/api/mail/snoozed", void 0, buildListOpts(opts));
+      printTable(res.emails, emailListColumns);
+    })
+  );
+  mail.command("get <id>").description("Get email details (marks as read)").action(
+    withErrorHandler(async (id) => {
+      const client = getClient();
+      const email = await client.mail.get(id);
+      printOne(email);
+    })
+  );
+  mail.command("send").description("Send an email").option("-f, --field <fields...>", "Set fields (to=a@b.com,c@d.com subject=... body=... cc=... bcc=... from_email=...)").action(
+    withErrorHandler(async (opts) => {
+      const data = await collectInput(opts.field ?? []);
+      for (const key of ["to", "cc", "bcc"]) {
+        if (typeof data[key] === "string") {
+          data[key] = data[key].split(",").map((s) => s.trim());
+        }
+      }
+      const client = getClient();
+      const email = await client.mail.send(data);
+      if (isJsonMode()) {
+        printOne(email);
+      } else {
+        success(`Email sent: ${email.id}`);
+        printOne(email);
+      }
+    })
+  );
+  mail.command("delete <id>").description("Delete an email").action(
+    withErrorHandler(async (id) => {
+      const client = getClient();
+      await client.mail.delete(id);
+      success(`Email deleted: ${id}`);
+    })
+  );
+  mail.command("star <id>").description("Star an email").action(
+    withErrorHandler(async (id) => {
+      const client = getClient();
+      await client.request("PATCH", `/api/mail/${id}`, { starred: true });
+      success(`Email starred: ${id}`);
+    })
+  );
+  mail.command("unstar <id>").description("Unstar an email").action(
+    withErrorHandler(async (id) => {
+      const client = getClient();
+      await client.request("PATCH", `/api/mail/${id}`, { starred: false });
+      success(`Email unstarred: ${id}`);
+    })
+  );
+  mail.command("read <id>").description("Mark an email as read").action(
+    withErrorHandler(async (id) => {
+      const client = getClient();
+      await client.mail.markRead(id, true);
+      success(`Email marked as read: ${id}`);
+    })
+  );
+  mail.command("unread <id>").description("Mark an email as unread").action(
+    withErrorHandler(async (id) => {
+      const client = getClient();
+      await client.mail.markRead(id, false);
+      success(`Email marked as unread: ${id}`);
+    })
+  );
+  mail.command("snooze <id> <until>").description("Snooze email until a datetime (ISO 8601)").action(
+    withErrorHandler(async (id, until) => {
+      const client = getClient();
+      await client.request("PATCH", `/api/mail/${id}`, { snoozed_until: until });
+      success(`Email snoozed until ${until}: ${id}`);
+    })
+  );
+  mail.command("unsnooze <id>").description("Unsnooze an email").action(
+    withErrorHandler(async (id) => {
+      const client = getClient();
+      await client.request("PATCH", `/api/mail/${id}`, { snoozed_until: null });
+      success(`Email unsnoozed: ${id}`);
+    })
+  );
+  const sendAs = mail.command("send-as").description("Manage send-as addresses");
+  sendAs.command("list").description("List available send-as addresses").action(
+    withErrorHandler(async () => {
+      const client = getClient();
+      const res = await client.request("GET", "/api/mail/send-as");
+      if (isJsonMode()) {
+        printOne(res);
+      } else {
+        const cols = [
+          { key: "email", header: "Email" },
+          { key: "source", header: "Source" },
+          { key: "is_default", header: "Default", width: 8, format: (v) => v ? "yes" : "" }
+        ];
+        printTable(res.addresses ?? [], cols);
+      }
+    })
+  );
+  sendAs.command("set <email>").description("Set default send-as address").action(
+    withErrorHandler(async (email) => {
+      const client = getClient();
+      const res = await client.request("PATCH", "/api/mail/send-as", { email });
+      if (isJsonMode()) {
+        printOne(res);
+      } else {
+        success(`Default send-as set to: ${res.default_send_as ?? email}`);
+      }
+    })
+  );
+  const signature = mail.command("signature").description("Manage email signature");
+  signature.command("get").description("Get current email signature").action(
+    withErrorHandler(async () => {
+      const client = getClient();
+      const res = await client.request("GET", "/api/mail/signature");
+      if (isJsonMode()) {
+        printOne(res);
+      } else {
+        console.log(dim("Source: ") + res.source);
+        console.log(dim("Signature:"));
+        console.log(res.effective || "(none)");
+      }
+    })
+  );
+  signature.command("set").description("Set personal email signature").option("-f, --field <fields...>", "Set fields (markdown=...)").action(
+    withErrorHandler(async (opts) => {
+      const data = await collectInput(opts.field ?? []);
+      const client = getClient();
+      const res = await client.request("PUT", "/api/mail/signature", { markdown: data.markdown ?? data.content ?? "" });
+      if (isJsonMode()) {
+        printOne(res);
+      } else {
+        success("Signature updated");
+        console.log(res.effective || "(none)");
+      }
+    })
+  );
+  signature.command("clear").description("Clear personal signature (use workspace default)").action(
+    withErrorHandler(async () => {
+      const client = getClient();
+      const res = await client.request("PUT", "/api/mail/signature", { markdown: null });
+      if (isJsonMode()) {
+        printOne(res);
+      } else {
+        success("Personal signature cleared. Using workspace default.");
+      }
+    })
+  );
+}
+
+// src/commands/tasks.ts
+var taskColumns = [
+  { key: "id", header: "ID", width: 12, format: (v) => String(v).slice(0, 12) },
+  { key: "title", header: "Title" },
+  { key: "status", header: "Status", width: 12 },
+  { key: "priority", header: "Priority", width: 8 },
+  {
+    key: "assignee",
+    header: "Assignee",
+    width: 16,
+    format: (v) => {
+      if (!v || typeof v !== "object") return "";
+      return v.display_name ?? "";
+    }
+  },
+  {
+    key: "due_date",
+    header: "Due",
+    width: 12,
+    format: (v) => v ? String(v) : ""
+  }
+];
+function registerTasksCommands(program2) {
+  const tasks = program2.command("tasks").description("Manage tasks");
+  tasks.command("list").description("List tasks").option("--assignee <userId>", "Filter by assignee").option("--status <status>", "Filter by status (todo, in_progress, done, cancelled)").option("--priority <priority>", "Filter by priority (urgent, high, medium, low)").option("--project <projectId>", "Filter by project").option("--creator <userId>", "Filter by creator").option("--limit <n>", "Max results", "50").option("--offset <n>", "Offset for pagination", "0").option("-f, --field <fields...>", "Field filters (key=value)").action(
+    withErrorHandler(async (opts) => {
+      const client = getClient();
+      const params = {};
+      if (opts.assignee) params.assignee_id = opts.assignee;
+      if (opts.status) params.status = opts.status;
+      if (opts.priority) params.priority = opts.priority;
+      if (opts.project) params.project_id = opts.project;
+      if (opts.creator) params.creator_id = opts.creator;
+      if (opts.limit) params.limit = parseInt(opts.limit, 10);
+      if (opts.offset && opts.offset !== "0") params.offset = parseInt(opts.offset, 10);
+      const res = await client.tasks.list(params);
+      printTable(res.tasks, taskColumns);
+    })
+  );
+  tasks.command("create").description("Create a task").option("-f, --field <fields...>", "Set fields (title=..., status=..., priority=..., assignee_id=..., due_date=..., description=..., project_id=..., parent_task_id=...)").action(
+    withErrorHandler(async (opts) => {
+      const data = await collectInput(opts.field ?? []);
+      const client = getClient();
+      const task = await client.tasks.create(data);
+      if (isJsonMode()) {
+        printOne(task);
+      } else {
+        success(`Task created: ${task.id} \u2014 ${task.title}`);
+      }
+    })
+  );
+  tasks.command("get <id>").description("Get a task by ID").action(
+    withErrorHandler(async (id) => {
+      const client = getClient();
+      const task = await client.tasks.get(id);
+      printOne(task);
+    })
+  );
+  tasks.command("update <id>").description("Update a task").option("-f, --field <fields...>", "Set fields (title=..., status=..., priority=..., assignee_id=..., due_date=..., description=...)").action(
+    withErrorHandler(async (id, opts) => {
+      const data = await collectInput(opts.field ?? []);
+      const client = getClient();
+      const task = await client.tasks.update(id, data);
+      if (isJsonMode()) {
+        printOne(task);
+      } else {
+        success(`Task updated: ${task.id}`);
+      }
+    })
+  );
+  tasks.command("delete <id>").description("Delete a task").action(
+    withErrorHandler(async (id) => {
+      const client = getClient();
+      await client.tasks.delete(id);
+      success(`Task deleted: ${id}`);
+    })
+  );
+  tasks.command("subtasks <id>").description("List subtasks of a task").action(
+    withErrorHandler(async (id) => {
+      const client = getClient();
+      const res = await client.tasks.listSubtasks(id);
+      printTable(res.tasks, taskColumns);
+    })
+  );
+}
+
+// src/commands/drive.ts
+import { createReadStream, statSync, existsSync as existsSync4 } from "fs";
+import { writeFile as writeFile2 } from "fs/promises";
+import { basename as basename4, resolve as resolve4 } from "path";
+import { lookup } from "mime-types";
+var fileColumns = [
+  { key: "id", header: "ID", width: 12, format: (v) => String(v).slice(0, 12) },
+  { key: "name", header: "Name" },
+  {
+    key: "is_folder",
+    header: "Type",
+    width: 8,
+    format: (v) => v ? "folder" : "file"
+  },
+  {
+    key: "size_bytes",
+    header: "Size",
+    width: 10,
+    align: "right",
+    format: (v) => {
+      if (v == null) return "\u2014";
+      const n = Number(v);
+      if (n < 1024) return `${n} B`;
+      if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+      if (n < 1024 * 1024 * 1024) return `${(n / (1024 * 1024)).toFixed(1)} MB`;
+      return `${(n / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+    }
+  },
+  {
+    key: "updated_at",
+    header: "Updated",
+    format: (v) => {
+      if (!v) return "";
+      return new Date(String(v)).toLocaleDateString();
+    }
+  }
+];
+function registerDriveCommands(program2) {
+  const drive = program2.command("drive").description("Manage files and folders");
+  drive.command("list [folderId]").description("List files in a folder (or root)").option("-q, --query <search>", "Search query").action(
+    withErrorHandler(async (folderId, opts) => {
+      const client = getClient();
+      const params = {};
+      if (folderId) params.parent_id = folderId;
+      if (opts.query) params.q = opts.query;
+      const res = await client.drive.list(params);
+      printTable(res.files, fileColumns);
+    })
+  );
+  drive.command("get <id>").description("Get file/folder metadata").action(
+    withErrorHandler(async (id) => {
+      const client = getClient();
+      const file = await client.drive.get(id);
+      printOne(file);
+    })
+  );
+  drive.command("upload <file>").description("Upload a file").option("--folder <id>", "Parent folder ID").option("--name <name>", "Override file name").action(
+    withErrorHandler(async (filePath, opts) => {
+      const absPath = resolve4(filePath);
+      if (!existsSync4(absPath)) {
+        throw new CliError(`File not found: ${absPath}`);
+      }
+      const stat = statSync(absPath);
+      const name = opts.name ?? basename4(absPath);
+      const mimeType = lookup(absPath) || "application/octet-stream";
+      const client = getClient();
+      const initRes = await client.drive.initiateUpload({
+        name,
+        mime_type: mimeType,
+        size_bytes: stat.size,
+        parent_id: opts.folder
+      });
+      const uploadRes = await fetch(initRes.upload_url, {
+        method: "PUT",
+        headers: { "Content-Type": mimeType, "Content-Length": String(stat.size) },
+        body: createReadStream(absPath),
+        // @ts-expect-error duplex is required for streaming body in Node.js but not in RequestInit types
+        duplex: "half"
+      });
+      if (!uploadRes.ok) {
+        throw new CliError(`Upload failed: HTTP ${uploadRes.status}`);
+      }
+      if (isJsonMode()) {
+        printOne(initRes.file);
+      } else {
+        success(`Uploaded: ${name} (${initRes.file.id})`);
+      }
+    })
+  );
+  drive.command("download <id> [dest]").description("Download a file").action(
+    withErrorHandler(async (id, dest) => {
+      const client = getClient();
+      const file = await client.drive.get(id);
+      const destPath = dest ? resolve4(dest) : resolve4(basename4(file.name));
+      const apiUrl = getApiUrl();
+      const token = getAuthToken();
+      const res = await fetch(`${apiUrl}/api/drive/${id}/content`, {
+        headers: {
+          Authorization: `Bearer ${token}`
+        }
+      });
+      if (!res.ok) {
+        throw new CliError(`Download failed: HTTP ${res.status}`);
+      }
+      const buffer = Buffer.from(await res.arrayBuffer());
+      await writeFile2(destPath, buffer);
+      if (isJsonMode()) {
+        printOne({ id, name: file.name, path: destPath, size_bytes: buffer.length });
+      } else {
+        success(`Downloaded: ${file.name} \u2192 ${destPath} (${buffer.length} bytes)`);
+      }
+    })
+  );
+  drive.command("mkdir <name>").description("Create a folder").option("--parent <id>", "Parent folder ID").action(
+    withErrorHandler(async (name, opts) => {
+      const client = getClient();
+      const folder = await client.drive.createFolder({
+        name,
+        parent_id: opts.parent
+      });
+      if (isJsonMode()) {
+        printOne(folder);
+      } else {
+        success(`Folder created: ${folder.id} \u2014 ${name}`);
+      }
+    })
+  );
+  drive.command("mv <id> <parentId>").description("Move a file/folder to a new parent").action(
+    withErrorHandler(async (id, parentId) => {
+      const client = getClient();
+      const file = await client.drive.update(id, { parent_id: parentId });
+      if (isJsonMode()) {
+        printOne(file);
+      } else {
+        success(`Moved: ${file.name} \u2192 folder ${parentId}`);
+      }
+    })
+  );
+  drive.command("rename <id> <name>").description("Rename a file/folder").action(
+    withErrorHandler(async (id, name) => {
+      const client = getClient();
+      const file = await client.drive.update(id, { name });
+      if (isJsonMode()) {
+        printOne(file);
+      } else {
+        success(`Renamed to: ${name}`);
+      }
+    })
+  );
+  drive.command("delete <id>").description("Delete a file or folder").option("-y, --yes", "Skip confirmation").action(
+    withErrorHandler(async (id, opts) => {
+      if (!opts.yes && !isJsonMode()) {
+        const ok = await confirm(`Delete ${id}?`);
+        if (!ok) {
+          console.error(dim("Cancelled."));
+          return;
+        }
+      }
+      const client = getClient();
+      await client.drive.delete(id);
+      success(`Deleted: ${id}`);
+    })
+  );
+  drive.command("storage").description("Show storage usage").action(
+    withErrorHandler(async () => {
+      const client = getClient();
+      const res = await client.request("GET", "/api/admin/usage");
+      if (isJsonMode()) {
+        printOne(res);
+      } else {
+        const used = res.storage_used_bytes ?? res.storageUsedBytes ?? 0;
+        const total = res.storage_limit_bytes ?? res.storageLimitBytes ?? 0;
+        const usedMB = (Number(used) / (1024 * 1024)).toFixed(1);
+        const totalGB = total ? (Number(total) / (1024 * 1024 * 1024)).toFixed(1) : "\u221E";
+        success(`Storage: ${usedMB} MB used of ${totalGB} GB`);
+      }
+    })
+  );
+}
+
+// src/commands/calendar.ts
+import { writeFile as writeFile3 } from "fs/promises";
+import { resolve as resolve5 } from "path";
+var calendarColumns = [
+  { key: "id", header: "ID", width: 12, format: (v) => String(v).slice(0, 12) },
+  { key: "name", header: "Name" },
+  { key: "timezone", header: "Timezone", width: 24 },
+  { key: "color", header: "Color", width: 8 },
+  {
+    key: "is_default",
+    header: "Default",
+    width: 8,
+    format: (v) => v ? "Yes" : ""
+  }
+];
+var eventColumns = [
+  { key: "id", header: "ID", width: 12, format: (v) => String(v).slice(0, 12) },
+  { key: "title", header: "Title" },
+  {
+    key: "start_at",
+    header: "Start",
+    width: 18,
+    format: (v) => {
+      if (!v) return "";
+      const d = new Date(String(v));
+      return d.toLocaleString(void 0, { month: "short", day: "numeric", hour: "2-digit", minute: "2-digit" });
+    }
+  },
+  {
+    key: "end_at",
+    header: "End",
+    width: 18,
+    format: (v) => {
+      if (!v) return "";
+      const d = new Date(String(v));
+      return d.toLocaleString(void 0, { month: "short", day: "numeric", hour: "2-digit", minute: "2-digit" });
+    }
+  },
+  { key: "status", header: "Status", width: 12 },
+  { key: "location", header: "Location", width: 20, format: (v) => String(v ?? "") }
+];
+var busyColumns = [
+  { key: "user_id", header: "User", width: 12, format: (v) => String(v).slice(0, 12) },
+  {
+    key: "start",
+    header: "Busy Start",
+    width: 20,
+    format: (v) => v ? new Date(String(v)).toLocaleString() : ""
+  },
+  {
+    key: "end",
+    header: "Busy End",
+    width: 20,
+    format: (v) => v ? new Date(String(v)).toLocaleString() : ""
+  },
+  { key: "title", header: "Title", format: (v) => String(v ?? "") }
+];
+function registerCalendarCommands(program2) {
+  const cal = program2.command("calendar").description("Manage calendars and events");
+  cal.command("list").description("List your calendars").action(
+    withErrorHandler(async () => {
+      const client = getClient();
+      const res = await client.calendar.listCalendars();
+      printTable(res.calendars, calendarColumns);
+    })
+  );
+  cal.command("create").description("Create a calendar").option("-f, --field <fields...>", "Set fields (name=..., color=..., timezone=...)").action(
+    withErrorHandler(async (opts) => {
+      const data = await collectInput(opts.field ?? []);
+      const client = getClient();
+      const calendar = await client.calendar.createCalendar(data);
+      if (isJsonMode()) {
+        printOne(calendar);
+      } else {
+        success(`Calendar created: ${calendar.id} \u2014 ${calendar.name}`);
+      }
+    })
+  );
+  cal.command("update <id>").description("Update a calendar").option("-f, --field <fields...>", "Set fields (name=..., color=..., timezone=...)").action(
+    withErrorHandler(async (id, opts) => {
+      const data = await collectInput(opts.field ?? []);
+      const client = getClient();
+      const calendar = await client.calendar.updateCalendar(id, data);
+      if (isJsonMode()) {
+        printOne(calendar);
+      } else {
+        success(`Calendar updated: ${calendar.id}`);
+      }
+    })
+  );
+  cal.command("delete <id>").description("Delete a calendar").option("-y, --yes", "Skip confirmation").action(
+    withErrorHandler(async (id, opts) => {
+      if (!opts.yes && !isJsonMode()) {
+        const ok = await confirm(`Delete calendar ${id}?`);
+        if (!ok) {
+          console.error(dim("Cancelled."));
+          return;
+        }
+      }
+      const client = getClient();
+      await client.calendar.deleteCalendar(id);
+      success(`Calendar deleted: ${id}`);
+    })
+  );
+  const events = cal.command("events").description("Manage calendar events");
+  events.command("list").description("List events").option("--start <datetime>", "Start of date range (ISO 8601)").option("--end <datetime>", "End of date range (ISO 8601)").option("--calendar <id>", "Filter by calendar ID").action(
+    withErrorHandler(async (opts) => {
+      const client = getClient();
+      const params = {};
+      if (opts.start) params.start = opts.start;
+      if (opts.end) params.end = opts.end;
+      if (opts.calendar) params.calendar_id = opts.calendar;
+      const res = await client.calendar.listEvents(params);
+      printTable(res.events, eventColumns);
+    })
+  );
+  events.command("create <calendarId>").description("Create an event").option("-f, --field <fields...>", "Set fields (title=..., start_at=..., end_at=..., description=..., location=..., all_day=..., recurrence_rule=..., attendees=[...])").action(
+    withErrorHandler(async (calendarId, opts) => {
+      const data = await collectInput(opts.field ?? []);
+      const client = getClient();
+      const event = await client.calendar.createEvent(calendarId, data);
+      if (isJsonMode()) {
+        printOne(event);
+      } else {
+        success(`Event created: ${event.id} \u2014 ${event.title}`);
+      }
+    })
+  );
+  events.command("get <id>").description("Get event details").action(
+    withErrorHandler(async (id) => {
+      const client = getClient();
+      const event = await client.calendar.getEvent(id);
+      printOne(event);
+    })
+  );
+  events.command("update <id>").description("Update an event").option("-f, --field <fields...>", "Set fields (title=..., start_at=..., end_at=..., description=..., location=..., attendees=[...])").action(
+    withErrorHandler(async (id, opts) => {
+      const data = await collectInput(opts.field ?? []);
+      const client = getClient();
+      const event = await client.calendar.updateEvent(id, data);
+      if (isJsonMode()) {
+        printOne(event);
+      } else {
+        success(`Event updated: ${event.id}`);
+      }
+    })
+  );
+  events.command("delete <id>").description("Delete an event").option("-y, --yes", "Skip confirmation").action(
+    withErrorHandler(async (id, opts) => {
+      if (!opts.yes && !isJsonMode()) {
+        const ok = await confirm(`Delete event ${id}?`);
+        if (!ok) {
+          console.error(dim("Cancelled."));
+          return;
+        }
+      }
+      const client = getClient();
+      await client.calendar.deleteEvent(id);
+      success(`Event deleted: ${id}`);
+    })
+  );
+  events.command("rsvp <id>").description("RSVP to an event").option("--accept", "Accept the invitation").option("--decline", "Decline the invitation").option("--tentative", "Mark as tentative").action(
+    withErrorHandler(async (id, opts) => {
+      let status;
+      if (opts.accept) status = "accepted";
+      else if (opts.decline) status = "declined";
+      else if (opts.tentative) status = "tentative";
+      else throw new CliError("Specify --accept, --decline, or --tentative");
+      const client = getClient();
+      const res = await client.calendar.rsvp(id, status);
+      if (isJsonMode()) {
+        printOne(res);
+      } else {
+        success(`RSVP: ${status} for event ${id}`);
+      }
+    })
+  );
+  cal.command("availability").description("Check free/busy availability").requiredOption("--users <userIds>", "Comma-separated user IDs").requiredOption("--start <datetime>", "Start of time range (ISO 8601)").requiredOption("--end <datetime>", "End of time range (ISO 8601)").action(
+    withErrorHandler(async (opts) => {
+      const client = getClient();
+      const userIds = opts.users.split(",").map((s) => s.trim());
+      const res = await client.calendar.checkAvailability({
+        user_ids: userIds,
+        start: opts.start,
+        end: opts.end
+      });
+      printTable(res.busy, busyColumns);
+    })
+  );
+  cal.command("export <id>").description("Export event as .ics").option("-o, --output <file>", "Output file path").action(
+    withErrorHandler(async (id, opts) => {
+      const apiUrl = getApiUrl();
+      const token = getAuthToken();
+      const res = await fetch(`${apiUrl}/api/calendars/events/${id}/export`, {
+        headers: { Authorization: `Bearer ${token}` }
+      });
+      if (!res.ok) {
+        throw new CliError(`Export failed: HTTP ${res.status}`);
+      }
+      const icsContent = await res.text();
+      const outPath = opts.output ? resolve5(opts.output) : resolve5(`event-${id}.ics`);
+      await writeFile3(outPath, icsContent, "utf-8");
+      if (isJsonMode()) {
+        printOne({ id, path: outPath, format: "ics" });
+      } else {
+        success(`Exported: ${outPath}`);
+      }
+    })
+  );
+}
+
+// src/commands/crm.ts
+var contactColumns = [
+  { key: "id", header: "ID", width: 12, format: (v) => String(v).slice(0, 12) },
+  { key: "name", header: "Name" },
+  { key: "type", header: "Type", width: 8 },
+  { key: "email", header: "Email" },
+  { key: "lifecycle_stage", header: "Stage", width: 12 }
+];
+var dealColumns = [
+  { key: "id", header: "ID", width: 12, format: (v) => String(v).slice(0, 12) },
+  { key: "title", header: "Title" },
+  { key: "amount", header: "Amount", width: 10, format: (v) => v != null ? `$${Number(v).toLocaleString()}` : "" },
+  { key: "status", header: "Status", width: 8 },
+  { key: "stage", header: "Stage", format: (v) => v && typeof v === "object" ? v.name ?? "" : String(v ?? "") }
+];
+var pipelineColumns = [
+  { key: "id", header: "ID", width: 12, format: (v) => String(v).slice(0, 12) },
+  { key: "name", header: "Name" },
+  { key: "is_default", header: "Default", width: 8, format: (v) => v ? "yes" : "no" }
+];
+var activityColumns = [
+  { key: "id", header: "ID", width: 12, format: (v) => String(v).slice(0, 12) },
+  { key: "type", header: "Type", width: 8 },
+  { key: "subject", header: "Subject" },
+  { key: "occurred_at", header: "Date", format: (v) => v ? new Date(String(v)).toLocaleDateString() : "" }
+];
+function registerCrmCommands(program2) {
+  const crm = program2.command("crm").description("CRM \u2014 contacts, deals, pipelines, activities");
+  const contacts = crm.command("contacts").description("Manage contacts");
+  contacts.command("list").description("List contacts").option("--type <type>", "Filter by type (person, company)").option("--stage <stage>", "Filter by lifecycle stage").option("--owner <userId>", "Filter by owner").option("-q, --query <q>", "Search query").option("--limit <n>", "Limit results").option("--offset <n>", "Offset results").action(
+    withErrorHandler(async (opts) => {
+      const client = getClient();
+      const params = {};
+      if (opts.type) params.type = opts.type;
+      if (opts.stage) params.lifecycle_stage = opts.stage;
+      if (opts.owner) params.owner_id = opts.owner;
+      if (opts.query) params.q = opts.query;
+      if (opts.limit) params.limit = Number(opts.limit);
+      if (opts.offset) params.offset = Number(opts.offset);
+      const res = await client.crm.listContacts(params);
+      printTable(res.contacts, contactColumns);
+    })
+  );
+  contacts.command("create").description("Create a contact").option("-f, --field <fields...>", "Set fields (name=..., type=person|company, email=..., phone=..., lifecycle_stage=...)").action(
+    withErrorHandler(async (opts) => {
+      const data = await collectInput(opts.field ?? []);
+      if (!data.type) data.type = "person";
+      const client = getClient();
+      const contact = await client.crm.createContact(data);
+      if (isJsonMode()) {
+        printOne(contact);
+      } else {
+        success(`Created ${data.type} "${contact.name}" (${contact.id})`);
+      }
+    })
+  );
+  contacts.command("get <id>").description("Get a contact by ID").action(
+    withErrorHandler(async (id) => {
+      const client = getClient();
+      const contact = await client.crm.getContact(id);
+      printOne(contact);
+    })
+  );
+  contacts.command("update <id>").description("Update a contact").option("-f, --field <fields...>", "Set fields (name=..., email=..., lifecycle_stage=...)").action(
+    withErrorHandler(async (id, opts) => {
+      const data = await collectInput(opts.field ?? []);
+      const client = getClient();
+      const contact = await client.crm.updateContact(id, data);
+      if (isJsonMode()) {
+        printOne(contact);
+      } else {
+        success(`Updated "${contact.name}" (${contact.id})`);
+      }
+    })
+  );
+  contacts.command("delete <id>").description("Delete a contact").option("-y, --yes", "Skip confirmation").action(
+    withErrorHandler(async (id, opts) => {
+      if (!opts.yes && !isJsonMode()) {
+        const ok = await confirm(`Delete contact ${id}?`);
+        if (!ok) {
+          console.error(dim("Cancelled."));
+          return;
+        }
+      }
+      const client = getClient();
+      await client.crm.deleteContact(id);
+      success(`Deleted contact ${id}`);
+    })
+  );
+  contacts.command("activities <contactId>").description("List activities for a contact").option("--type <type>", "Filter by activity type (note, call, email, meeting, task)").action(
+    withErrorHandler(async (contactId, opts) => {
+      const client = getClient();
+      const params = {};
+      if (opts.type) params.type = opts.type;
+      const res = await client.crm.listContactActivities(contactId, params);
+      printTable(res.activities, activityColumns);
+    })
+  );
+  const deals = crm.command("deals").description("Manage deals");
+  deals.command("list").description("List deals").option("--pipeline <id>", "Filter by pipeline").option("--stage <id>", "Filter by stage").option("--status <status>", "Filter by status (open, won, lost)").option("--limit <n>", "Limit results").option("--offset <n>", "Offset results").action(
+    withErrorHandler(async (opts) => {
+      const client = getClient();
+      const params = {};
+      if (opts.pipeline) params.pipeline_id = opts.pipeline;
+      if (opts.stage) params.stage_id = opts.stage;
+      if (opts.status) params.status = opts.status;
+      if (opts.limit) params.limit = Number(opts.limit);
+      if (opts.offset) params.offset = Number(opts.offset);
+      const res = await client.crm.listDeals(params);
+      printTable(res.deals, dealColumns);
+    })
+  );
+  deals.command("create").description("Create a deal").option("-f, --field <fields...>", "Set fields (title=..., amount=..., pipeline_id=..., stage_id=..., contact_id=...)").action(
+    withErrorHandler(async (opts) => {
+      const data = await collectInput(opts.field ?? []);
+      if (data.amount) data.amount = Number(data.amount);
+      const client = getClient();
+      const deal = await client.crm.createDeal(data);
+      if (isJsonMode()) {
+        printOne(deal);
+      } else {
+        success(`Created deal "${deal.title}" (${deal.id})`);
+      }
+    })
+  );
+  deals.command("get <id>").description("Get a deal by ID").action(
+    withErrorHandler(async (id) => {
+      const client = getClient();
+      const deal = await client.crm.getDeal(id);
+      printOne(deal);
+    })
+  );
+  deals.command("update <id>").description("Update a deal").option("-f, --field <fields...>", "Set fields (title=..., amount=..., stage_id=..., status=...)").action(
+    withErrorHandler(async (id, opts) => {
+      const data = await collectInput(opts.field ?? []);
+      if (data.amount) data.amount = Number(data.amount);
+      const client = getClient();
+      const deal = await client.crm.updateDeal(id, data);
+      if (isJsonMode()) {
+        printOne(deal);
+      } else {
+        success(`Updated deal "${deal.title}" (${deal.id})`);
+      }
+    })
+  );
+  deals.command("delete <id>").description("Delete a deal").option("-y, --yes", "Skip confirmation").action(
+    withErrorHandler(async (id, opts) => {
+      if (!opts.yes && !isJsonMode()) {
+        const ok = await confirm(`Delete deal ${id}?`);
+        if (!ok) {
+          console.error(dim("Cancelled."));
+          return;
+        }
+      }
+      const client = getClient();
+      await client.crm.deleteDeal(id);
+      success(`Deleted deal ${id}`);
+    })
+  );
+  const pipelines = crm.command("pipelines").description("Manage pipelines");
+  pipelines.command("list").description("List pipelines with stages").action(
+    withErrorHandler(async () => {
+      const client = getClient();
+      const res = await client.crm.listPipelines();
+      printTable(res.pipelines, pipelineColumns);
+    })
+  );
+  pipelines.command("create").description("Create a pipeline").option("-f, --field <fields...>", 'Set fields (name=..., stages=[{"name":"Lead","probability":10}])').action(
+    withErrorHandler(async (opts) => {
+      const data = await collectInput(opts.field ?? []);
+      if (typeof data.stages === "string") {
+        try {
+          data.stages = JSON.parse(data.stages);
+        } catch {
+        }
+      }
+      const client = getClient();
+      const pipeline = await client.crm.createPipeline(data);
+      if (isJsonMode()) {
+        printOne(pipeline);
+      } else {
+        success(`Created pipeline "${pipeline.name}" (${pipeline.id})`);
+      }
+    })
+  );
+  pipelines.command("update <id>").description("Update a pipeline").option("-f, --field <fields...>", "Set fields (name=..., stages=[...])").action(
+    withErrorHandler(async (id, opts) => {
+      const data = await collectInput(opts.field ?? []);
+      if (typeof data.stages === "string") {
+        try {
+          data.stages = JSON.parse(data.stages);
+        } catch {
+        }
+      }
+      const client = getClient();
+      const pipeline = await client.crm.updatePipeline(id, data);
+      if (isJsonMode()) {
+        printOne(pipeline);
+      } else {
+        success(`Updated pipeline "${pipeline.name}" (${pipeline.id})`);
+      }
+    })
+  );
+  pipelines.command("delete <id>").description("Delete a pipeline").option("-y, --yes", "Skip confirmation").action(
+    withErrorHandler(async (id, opts) => {
+      if (!opts.yes && !isJsonMode()) {
+        const ok = await confirm(`Delete pipeline ${id}?`);
+        if (!ok) {
+          console.error(dim("Cancelled."));
+          return;
+        }
+      }
+      const client = getClient();
+      await client.crm.deletePipeline(id);
+      success(`Deleted pipeline ${id}`);
+    })
+  );
+  const activities = crm.command("activities").description("Log and manage activities");
+  activities.command("log").description("Log an activity (note, call, email, meeting, task)").option("-f, --field <fields...>", "Set fields (type=call, subject=..., body=..., contact_id=..., deal_id=..., duration_minutes=30)").action(
+    withErrorHandler(async (opts) => {
+      const data = await collectInput(opts.field ?? []);
+      if (data.duration_minutes) data.duration_minutes = Number(data.duration_minutes);
+      const client = getClient();
+      const activity = await client.crm.logActivity(data);
+      if (isJsonMode()) {
+        printOne(activity);
+      } else {
+        success(`Logged ${activity.type} activity (${activity.id})`);
+      }
+    })
+  );
+  activities.command("delete <id>").description("Delete an activity").option("-y, --yes", "Skip confirmation").action(
+    withErrorHandler(async (id, opts) => {
+      if (!opts.yes && !isJsonMode()) {
+        const ok = await confirm(`Delete activity ${id}?`);
+        if (!ok) {
+          console.error(dim("Cancelled."));
+          return;
+        }
+      }
+      const client = getClient();
+      await client.crm.deleteActivity(id);
+      success(`Deleted activity ${id}`);
+    })
+  );
+}
+
+// src/commands/forms.ts
+var formColumns = [
+  { key: "id", header: "ID", width: 12, format: (v) => String(v).slice(0, 12) },
+  { key: "title", header: "Title" },
+  { key: "slug", header: "Slug", width: 20 },
+  { key: "is_published", header: "Published", width: 10, format: (v) => v ? "yes" : "no" }
+];
+var responseColumns = [
+  { key: "id", header: "ID", width: 12, format: (v) => String(v).slice(0, 12) },
+  { key: "respondent_email", header: "Email" },
+  { key: "submitted_at", header: "Submitted", format: (v) => v ? new Date(String(v)).toLocaleDateString() : "" }
+];
+function registerFormsCommands(program2) {
+  const forms = program2.command("forms").description("Manage forms and responses");
+  forms.command("list").description("List forms").option("-q, --query <q>", "Search query").option("--published", "Only published forms").action(
+    withErrorHandler(async (opts) => {
+      const client = getClient();
+      const params = {};
+      if (opts.query) params.q = opts.query;
+      if (opts.published) params.published = true;
+      const res = await client.forms.list(params);
+      printTable(res.forms, formColumns);
+    })
+  );
+  forms.command("create").description("Create a form").option("-f, --field <fields...>", "Set fields (title=..., slug=..., description=...)").action(
+    withErrorHandler(async (opts) => {
+      const data = await collectInput(opts.field ?? []);
+      if (typeof data.fields === "string") {
+        try {
+          data.fields = JSON.parse(data.fields);
+        } catch {
+        }
+      }
+      if (typeof data.settings === "string") {
+        try {
+          data.settings = JSON.parse(data.settings);
+        } catch {
+        }
+      }
+      const client = getClient();
+      const form = await client.forms.create(data);
+      if (isJsonMode()) {
+        printOne(form);
+      } else {
+        success(`Created form "${form.title}" (${form.id})`);
+      }
+    })
+  );
+  forms.command("get <id>").description("Get a form by ID").action(
+    withErrorHandler(async (id) => {
+      const client = getClient();
+      const form = await client.forms.get(id);
+      printOne(form);
+    })
+  );
+  forms.command("update <id>").description("Update a form").option("-f, --field <fields...>", "Set fields (title=..., is_published=true)").action(
+    withErrorHandler(async (id, opts) => {
+      const data = await collectInput(opts.field ?? []);
+      if (typeof data.fields === "string") {
+        try {
+          data.fields = JSON.parse(data.fields);
+        } catch {
+        }
+      }
+      if (typeof data.settings === "string") {
+        try {
+          data.settings = JSON.parse(data.settings);
+        } catch {
+        }
+      }
+      if (data.is_published === "true") data.is_published = true;
+      if (data.is_published === "false") data.is_published = false;
+      const client = getClient();
+      const form = await client.forms.update(id, data);
+      if (isJsonMode()) {
+        printOne(form);
+      } else {
+        success(`Updated form "${form.title}" (${form.id})`);
+      }
+    })
+  );
+  forms.command("delete <id>").description("Delete a form").option("-y, --yes", "Skip confirmation").action(
+    withErrorHandler(async (id, opts) => {
+      if (!opts.yes && !isJsonMode()) {
+        const ok = await confirm(`Delete form ${id}?`);
+        if (!ok) {
+          console.error(dim("Cancelled."));
+          return;
+        }
+      }
+      const client = getClient();
+      await client.forms.delete(id);
+      success(`Deleted form ${id}`);
+    })
+  );
+  forms.command("publish <id>").description("Publish a form").action(
+    withErrorHandler(async (id) => {
+      const client = getClient();
+      await client.forms.update(id, { is_published: true });
+      success(`Published form ${id}`);
+    })
+  );
+  forms.command("unpublish <id>").description("Unpublish a form").action(
+    withErrorHandler(async (id) => {
+      const client = getClient();
+      await client.forms.update(id, { is_published: false });
+      success(`Unpublished form ${id}`);
+    })
+  );
+  forms.command("submit <slug>").description("Submit a response to a form (by slug)").option("-f, --field <fields...>", "Set response data (fieldId=value)").action(
+    withErrorHandler(async (slug, opts) => {
+      const data = await collectInput(opts.field ?? []);
+      const client = getClient();
+      const response = await client.forms.submit(slug, data);
+      if (isJsonMode()) {
+        printOne(response);
+      } else {
+        success(`Submitted response (${response.id})`);
+      }
+    })
+  );
+  const responses = forms.command("responses").description("Manage form responses");
+  responses.command("list <formId>").description("List responses for a form").option("--limit <n>", "Limit results").option("--offset <n>", "Offset results").action(
+    withErrorHandler(async (formId, opts) => {
+      const client = getClient();
+      const params = {};
+      if (opts.limit) params.limit = Number(opts.limit);
+      if (opts.offset) params.offset = Number(opts.offset);
+      const res = await client.forms.listResponses(formId, params);
+      printTable(res.responses, responseColumns);
+    })
+  );
+  responses.command("get <formId> <responseId>").description("Get a specific response").action(
+    withErrorHandler(async (formId, responseId) => {
+      const client = getClient();
+      const response = await client.forms.getResponse(formId, responseId);
+      printOne(response);
+    })
+  );
+  responses.command("delete <formId> <responseId>").description("Delete a response").option("-y, --yes", "Skip confirmation").action(
+    withErrorHandler(async (formId, responseId, opts) => {
+      if (!opts.yes && !isJsonMode()) {
+        const ok = await confirm(`Delete response ${responseId}?`);
+        if (!ok) {
+          console.error(dim("Cancelled."));
+          return;
+        }
+      }
+      const client = getClient();
+      await client.forms.deleteResponse(formId, responseId);
+      success(`Deleted response ${responseId}`);
+    })
+  );
+}
+
+// src/commands/wiki.ts
+var spaceColumns = [
+  { key: "id", header: "ID", width: 12, format: (v) => String(v).slice(0, 12) },
+  { key: "name", header: "Name" },
+  { key: "slug", header: "Slug", width: 20 },
+  { key: "is_private", header: "Private", width: 8, format: (v) => v ? "yes" : "no" }
+];
+var pageColumns = [
+  { key: "id", header: "ID", width: 12, format: (v) => String(v).slice(0, 12) },
+  { key: "title", header: "Title" },
+  { key: "icon", header: "Icon", width: 4 },
+  { key: "slug", header: "Slug", width: 20 }
+];
+function registerWikiCommands(program2) {
+  const wiki = program2.command("wiki").description("Wiki \u2014 knowledge base with spaces, pages, databases");
+  const spaces = wiki.command("spaces").description("Manage wiki spaces");
+  spaces.command("list").description("List wiki spaces").action(
+    withErrorHandler(async () => {
+      const client = getClient();
+      const res = await client.wiki.listSpaces();
+      printTable(res.spaces, spaceColumns);
+    })
+  );
+  spaces.command("create").description("Create a wiki space").option("-f, --field <fields...>", "Set fields (name=..., slug=..., description=..., is_private=false)").action(
+    withErrorHandler(async (opts) => {
+      const data = await collectInput(opts.field ?? []);
+      if (data.is_private === "true") data.is_private = true;
+      if (data.is_private === "false") data.is_private = false;
+      const client = getClient();
+      const space = await client.wiki.createSpace(data);
+      if (isJsonMode()) {
+        printOne(space);
+      } else {
+        success(`Created space "${space.name}" (${space.id})`);
+      }
+    })
+  );
+  spaces.command("get <slug>").description("Get a space by slug").action(
+    withErrorHandler(async (slug) => {
+      const client = getClient();
+      const space = await client.wiki.getSpace(slug);
+      printOne(space);
+    })
+  );
+  spaces.command("update <id>").description("Update a wiki space").option("-f, --field <fields...>", "Set fields (name=..., description=...)").action(
+    withErrorHandler(async (id, opts) => {
+      const data = await collectInput(opts.field ?? []);
+      if (data.is_private === "true") data.is_private = true;
+      if (data.is_private === "false") data.is_private = false;
+      const client = getClient();
+      const space = await client.wiki.updateSpace(id, data);
+      if (isJsonMode()) {
+        printOne(space);
+      } else {
+        success(`Updated space "${space.name}" (${space.id})`);
+      }
+    })
+  );
+  spaces.command("delete <id>").description("Delete a wiki space").option("-y, --yes", "Skip confirmation").action(
+    withErrorHandler(async (id, opts) => {
+      if (!opts.yes && !isJsonMode()) {
+        const ok = await confirm(`Delete space ${id} and all its pages?`);
+        if (!ok) {
+          console.error(dim("Cancelled."));
+          return;
+        }
+      }
+      const client = getClient();
+      await client.wiki.deleteSpace(id);
+      success(`Deleted space ${id}`);
+    })
+  );
+  const pages = wiki.command("pages").description("Manage wiki pages");
+  pages.command("create <spaceId>").description("Create a page in a space").option("-f, --field <fields...>", "Set fields (title=..., slug=..., content=..., icon=..., parent_page_id=...)").action(
+    withErrorHandler(async (spaceId, opts) => {
+      const data = await collectInput(opts.field ?? []);
+      if (data.is_template === "true") data.is_template = true;
+      const client = getClient();
+      const page = await client.wiki.createPage(spaceId, data);
+      if (isJsonMode()) {
+        printOne(page);
+      } else {
+        success(`Created page "${page.title}" (${page.id})`);
+      }
+    })
+  );
+  pages.command("get <id>").description("Get a page by ID").action(
+    withErrorHandler(async (id) => {
+      const client = getClient();
+      const page = await client.wiki.getPage(id);
+      printOne(page);
+    })
+  );
+  pages.command("update <id>").description("Update a page").option("-f, --field <fields...>", "Set fields (title=..., content=..., icon=..., parent_page_id=...)").action(
+    withErrorHandler(async (id, opts) => {
+      const data = await collectInput(opts.field ?? []);
+      const client = getClient();
+      const page = await client.wiki.updatePage(id, data);
+      if (isJsonMode()) {
+        printOne(page);
+      } else {
+        success(`Updated page "${page.title}" (${page.id})`);
+      }
+    })
+  );
+  pages.command("delete <id>").description("Delete a page and its children").option("-y, --yes", "Skip confirmation").action(
+    withErrorHandler(async (id, opts) => {
+      if (!opts.yes && !isJsonMode()) {
+        const ok = await confirm(`Delete page ${id} and all children?`);
+        if (!ok) {
+          console.error(dim("Cancelled."));
+          return;
+        }
+      }
+      const client = getClient();
+      await client.wiki.deletePage(id);
+      success(`Deleted page ${id}`);
+    })
+  );
+  pages.command("children <pageId>").description("List child pages").action(
+    withErrorHandler(async (pageId) => {
+      const client = getClient();
+      const res = await client.wiki.listChildren(pageId);
+      printTable(res.pages, pageColumns);
+    })
+  );
+  pages.command("backlinks <pageId>").description("List pages that link to this page").action(
+    withErrorHandler(async (pageId) => {
+      const client = getClient();
+      const res = await client.wiki.listBacklinks(pageId);
+      printTable(
+        res.backlinks,
+        [
+          { key: "id", header: "ID", width: 12, format: (v) => String(v).slice(0, 12) },
+          { key: "title", header: "Title" }
+        ]
+      );
+    })
+  );
+  pages.command("duplicate <pageId>").description("Duplicate a page").action(
+    withErrorHandler(async (pageId) => {
+      const client = getClient();
+      const page = await client.wiki.duplicatePage(pageId);
+      if (isJsonMode()) {
+        printOne(page);
+      } else {
+        success(`Duplicated page \u2192 "${page.title}" (${page.id})`);
+      }
+    })
+  );
+  wiki.command("search").description("Search across all wiki content").requiredOption("-q, --query <q>", "Search query").option("--space <slug>", "Limit to a specific space").action(
+    withErrorHandler(async (opts) => {
+      const client = getClient();
+      const params = { q: opts.query };
+      if (opts.space) params.space = opts.space;
+      const res = await client.wiki.search(params);
+      printTable(res.results, pageColumns);
+    })
+  );
+  const db = wiki.command("db").description("Manage wiki databases");
+  db.command("get <id>").description("Get a database (schema + rows)").action(
+    withErrorHandler(async (id) => {
+      const client = getClient();
+      const database = await client.wiki.getDatabase(id);
+      printOne(database);
+    })
+  );
+  db.command("create <pageId>").description("Create a database on a page").option("-f, --field <fields...>", 'Set fields (name=..., schema={"properties":[...]})').action(
+    withErrorHandler(async (pageId, opts) => {
+      const data = await collectInput(opts.field ?? []);
+      if (typeof data.schema === "string") {
+        try {
+          data.schema = JSON.parse(data.schema);
+        } catch {
+        }
+      }
+      const client = getClient();
+      const database = await client.wiki.createDatabase(pageId, data);
+      if (isJsonMode()) {
+        printOne(database);
+      } else {
+        success(`Created database "${database.name}" (${database.id})`);
+      }
+    })
+  );
+  db.command("update <id>").description("Update a database schema or views").option("-f, --field <fields...>", "Set fields (schema=..., views=...)").action(
+    withErrorHandler(async (id, opts) => {
+      const data = await collectInput(opts.field ?? []);
+      if (typeof data.schema === "string") {
+        try {
+          data.schema = JSON.parse(data.schema);
+        } catch {
+        }
+      }
+      if (typeof data.views === "string") {
+        try {
+          data.views = JSON.parse(data.views);
+        } catch {
+        }
+      }
+      const client = getClient();
+      const database = await client.wiki.updateDatabase(id, data);
+      if (isJsonMode()) {
+        printOne(database);
+      } else {
+        success(`Updated database (${database.id})`);
+      }
+    })
+  );
+  db.command("query <databaseId>").description("Query database rows").option("--filter <json>", "Filter as JSON").option("--sort <json>", "Sort as JSON").option("--limit <n>", "Page size").option("--offset <n>", "Offset").action(
+    withErrorHandler(async (databaseId, opts) => {
+      const client = getClient();
+      const params = {};
+      if (opts.filter) {
+        try {
+          params.filter = JSON.parse(opts.filter);
+        } catch {
+          params.filter = opts.filter;
+        }
+      }
+      if (opts.sort) {
+        try {
+          params.sorts = JSON.parse(opts.sort);
+        } catch {
+          params.sorts = opts.sort;
+        }
+      }
+      if (opts.limit) params.page_size = Number(opts.limit);
+      if (opts.offset) params.offset = Number(opts.offset);
+      const res = await client.wiki.queryRows(databaseId, params);
+      if (isJsonMode()) {
+        printOne(res);
+      } else {
+        printTable(
+          res.rows.map((r) => ({ id: r.id, ...r.properties })),
+          [
+            { key: "id", header: "ID", width: 12, format: (v) => String(v).slice(0, 12) }
+          ]
+        );
+      }
+    })
+  );
+  db.command("add-row <databaseId>").description("Add a row to a database").option("-f, --field <fields...>", "Set properties (propName=value)").action(
+    withErrorHandler(async (databaseId, opts) => {
+      const data = await collectInput(opts.field ?? []);
+      const client = getClient();
+      const row = await client.wiki.createRow(databaseId, data);
+      if (isJsonMode()) {
+        printOne(row);
+      } else {
+        success(`Added row (${row.id})`);
+      }
+    })
+  );
+  db.command("update-row <databaseId> <rowId>").description("Update a row in a database").option("-f, --field <fields...>", "Set properties (propName=value)").action(
+    withErrorHandler(async (databaseId, rowId, opts) => {
+      const data = await collectInput(opts.field ?? []);
+      const client = getClient();
+      const row = await client.wiki.updateRow(databaseId, rowId, data);
+      if (isJsonMode()) {
+        printOne(row);
+      } else {
+        success(`Updated row ${rowId}`);
+      }
+    })
+  );
+  db.command("delete-row <databaseId> <rowId>").description("Delete a row from a database").option("-y, --yes", "Skip confirmation").action(
+    withErrorHandler(async (databaseId, rowId, opts) => {
+      if (!opts.yes && !isJsonMode()) {
+        const ok = await confirm(`Delete row ${rowId}?`);
+        if (!ok) {
+          console.error(dim("Cancelled."));
+          return;
+        }
+      }
+      const client = getClient();
+      await client.wiki.deleteRow(databaseId, rowId);
+      success(`Deleted row ${rowId}`);
+    })
+  );
+}
+
+// src/commands/admin.ts
+var userColumns = [
+  { key: "id", header: "ID", width: 12, format: (v) => String(v).slice(0, 12) },
+  { key: "display_name", header: "Name" },
+  { key: "email", header: "Email" },
+  { key: "type", header: "Type", width: 8 }
+];
+var roleColumns = [
+  { key: "id", header: "ID", width: 12, format: (v) => String(v).slice(0, 12) },
+  { key: "name", header: "Name" },
+  { key: "is_system", header: "System", width: 8, format: (v) => v ? "yes" : "no" }
+];
+var auditColumns = [
+  { key: "id", header: "ID", width: 10 },
+  { key: "action", header: "Action", width: 20 },
+  { key: "user_id", header: "User", width: 12, format: (v) => String(v ?? "").slice(0, 12) },
+  { key: "resource_type", header: "Resource", width: 12 },
+  { key: "created_at", header: "Date", format: (v) => v ? new Date(String(v)).toLocaleString() : "" }
+];
+var apiKeyColumns = [
+  { key: "id", header: "ID", width: 12, format: (v) => String(v).slice(0, 12) },
+  { key: "name", header: "Name" },
+  { key: "user_id", header: "User", width: 12, format: (v) => String(v ?? "").slice(0, 12) },
+  { key: "last_used_at", header: "Last Used", format: (v) => v ? new Date(String(v)).toLocaleDateString() : "never" }
+];
+function registerAdminCommands(program2) {
+  const admin = program2.command("admin").description("Workspace administration");
+  const users = admin.command("users").description("Manage users and agents");
+  users.command("list").description("List all users").option("--type <type>", "Filter by type (human, agent)").option("--role <role>", "Filter by role").option("-q, --query <q>", "Search query").option("--limit <n>", "Limit results").option("--offset <n>", "Offset results").action(
+    withErrorHandler(async (opts) => {
+      const client = getClient();
+      const params = {};
+      if (opts.type) params.type = opts.type;
+      if (opts.role) params.role = opts.role;
+      if (opts.query) params.q = opts.query;
+      if (opts.limit) params.limit = Number(opts.limit);
+      if (opts.offset) params.offset = Number(opts.offset);
+      const res = await client.admin.listUsers(params);
+      printTable(res.users, userColumns);
+    })
+  );
+  users.command("get <id>").description("Get user details").action(
+    withErrorHandler(async (id) => {
+      const client = getClient();
+      const user = await client.admin.getUser(id);
+      printOne(user);
+    })
+  );
+  users.command("update <id>").description("Update a user").option("-f, --field <fields...>", "Set fields (display_name=..., role=...)").action(
+    withErrorHandler(async (id, opts) => {
+      const data = await collectInput(opts.field ?? []);
+      const client = getClient();
+      const user = await client.admin.updateUser(id, data);
+      if (isJsonMode()) {
+        printOne(user);
+      } else {
+        success(`Updated user ${user.display_name} (${user.id})`);
+      }
+    })
+  );
+  users.command("delete <id>").description("Deactivate/delete a user").option("-y, --yes", "Skip confirmation").action(
+    withErrorHandler(async (id, opts) => {
+      if (!opts.yes && !isJsonMode()) {
+        const ok = await confirm(`Delete user ${id}? This cannot be undone.`);
+        if (!ok) {
+          console.error(dim("Cancelled."));
+          return;
+        }
+      }
+      const client = getClient();
+      await client.admin.deleteUser(id);
+      success(`Deleted user ${id}`);
+    })
+  );
+  const roles = admin.command("roles").description("Manage roles and permissions");
+  roles.command("list").description("List all roles").action(
+    withErrorHandler(async () => {
+      const client = getClient();
+      const res = await client.admin.listRoles();
+      printTable(res.roles, roleColumns);
+    })
+  );
+  roles.command("create").description("Create a custom role").option("-f, --field <fields...>", 'Set fields (name=..., permissions=["users.view","docs.manage"])').action(
+    withErrorHandler(async (opts) => {
+      const data = await collectInput(opts.field ?? []);
+      if (typeof data.permissions === "string") {
+        try {
+          data.permissions = JSON.parse(data.permissions);
+        } catch {
+        }
+      }
+      const client = getClient();
+      const role = await client.admin.createRole(data);
+      if (isJsonMode()) {
+        printOne(role);
+      } else {
+        success(`Created role "${role.name}" (${role.id})`);
+      }
+    })
+  );
+  roles.command("update <id>").description("Update a role").option("-f, --field <fields...>", "Set fields (name=..., permissions=[...])").action(
+    withErrorHandler(async (id, opts) => {
+      const data = await collectInput(opts.field ?? []);
+      if (typeof data.permissions === "string") {
+        try {
+          data.permissions = JSON.parse(data.permissions);
+        } catch {
+        }
+      }
+      const client = getClient();
+      const role = await client.admin.updateRole(id, data);
+      if (isJsonMode()) {
+        printOne(role);
+      } else {
+        success(`Updated role "${role.name}" (${role.id})`);
+      }
+    })
+  );
+  roles.command("delete <id>").description("Delete a custom role").option("-y, --yes", "Skip confirmation").action(
+    withErrorHandler(async (id, opts) => {
+      if (!opts.yes && !isJsonMode()) {
+        const ok = await confirm(`Delete role ${id}?`);
+        if (!ok) {
+          console.error(dim("Cancelled."));
+          return;
+        }
+      }
+      const client = getClient();
+      await client.admin.deleteRole(id);
+      success(`Deleted role ${id}`);
+    })
+  );
+  roles.command("assign <userId> <roleName>").description("Assign a role to a user").action(
+    withErrorHandler(async (userId, roleName) => {
+      const client = getClient();
+      await client.admin.assignRole(userId, roleName);
+      success(`Assigned role "${roleName}" to user ${userId}`);
+    })
+  );
+  roles.command("remove <userId> <roleName>").description("Remove a role from a user").action(
+    withErrorHandler(async (userId, roleName) => {
+      const client = getClient();
+      await client.admin.removeRole(userId, roleName);
+      success(`Removed role "${roleName}" from user ${userId}`);
+    })
+  );
+  const settings = admin.command("settings").description("Workspace settings");
+  settings.command("get").description("Get all workspace settings").action(
+    withErrorHandler(async () => {
+      const client = getClient();
+      const res = await client.admin.getSettings();
+      printOne(res);
+    })
+  );
+  settings.command("set").description("Update workspace settings").option("-f, --field <fields...>", "Set settings (key=value)").action(
+    withErrorHandler(async (opts) => {
+      const data = await collectInput(opts.field ?? []);
+      const client = getClient();
+      await client.admin.updateSettings(data);
+      success("Settings updated");
+    })
+  );
+  admin.command("audit-log").description("Query the audit log").option("--user <userId>", "Filter by user").option("--action <action>", "Filter by action (e.g. user.login)").option("--resource <type>", "Filter by resource type").option("--start <date>", "Start date (ISO 8601)").option("--end <date>", "End date (ISO 8601)").option("--limit <n>", "Limit results").option("--offset <n>", "Offset results").action(
+    withErrorHandler(async (opts) => {
+      const client = getClient();
+      const params = {};
+      if (opts.user) params.user_id = opts.user;
+      if (opts.action) params.action = opts.action;
+      if (opts.resource) params.resource_type = opts.resource;
+      if (opts.start) params.start = opts.start;
+      if (opts.end) params.end = opts.end;
+      if (opts.limit) params.limit = Number(opts.limit);
+      if (opts.offset) params.offset = Number(opts.offset);
+      const res = await client.admin.queryAuditLog(params);
+      printTable(res.entries, auditColumns);
+    })
+  );
+  const apiKeys = admin.command("api-keys").description("Manage API keys");
+  apiKeys.command("list").description("List all API keys").option("--user <userId>", "Filter by user").action(
+    withErrorHandler(async (opts) => {
+      const client = getClient();
+      const params = {};
+      if (opts.user) params.user_id = opts.user;
+      const res = await client.admin.listApiKeys(params);
+      printTable(res.api_keys, apiKeyColumns);
+    })
+  );
+  apiKeys.command("create").description("Create an API key").option("-f, --field <fields...>", 'Set fields (user_id=..., name=..., scopes=["*"], expires_at=...)').action(
+    withErrorHandler(async (opts) => {
+      const data = await collectInput(opts.field ?? []);
+      if (typeof data.scopes === "string") {
+        try {
+          data.scopes = JSON.parse(data.scopes);
+        } catch {
+        }
+      }
+      const client = getClient();
+      const key = await client.admin.createApiKey(data);
+      if (isJsonMode()) {
+        printOne(key);
+      } else {
+        success(`Created API key "${key.name}"
+  Key: ${key.key}
+  (Save this \u2014 it won't be shown again)`);
+      }
+    })
+  );
+  apiKeys.command("revoke <id>").description("Revoke an API key").option("-y, --yes", "Skip confirmation").action(
+    withErrorHandler(async (id, opts) => {
+      if (!opts.yes && !isJsonMode()) {
+        const ok = await confirm(`Revoke API key ${id}? This cannot be undone.`);
+        if (!ok) {
+          console.error(dim("Cancelled."));
+          return;
+        }
+      }
+      const client = getClient();
+      await client.admin.revokeApiKey(id);
+      success(`Revoked API key ${id}`);
+    })
+  );
+  admin.command("usage").description("Get workspace usage statistics").action(
+    withErrorHandler(async () => {
+      const client = getClient();
+      const usage = await client.admin.getUsage();
+      printOne(usage);
+    })
+  );
+}
+
+// src/commands/api.ts
+function registerApiCommands(program2) {
+  program2.command("api <method> <path>").description("Make a raw API request (escape hatch)").option("-d, --data <json>", "Request body as JSON").option("--query <params>", "Query params as key=value,key=value").action(
+    withErrorHandler(async (method, path, opts) => {
+      let data;
+      if (opts.data) {
+        try {
+          data = JSON.parse(opts.data);
+        } catch {
+          data = opts.data;
+        }
+      }
+      let query;
+      if (opts.query) {
+        query = {};
+        for (const pair of opts.query.split(",")) {
+          const eq = pair.indexOf("=");
+          if (eq > 0) {
+            query[pair.slice(0, eq)] = pair.slice(eq + 1);
+          }
+        }
+      }
+      const result = await rawRequest(method.toUpperCase(), path, data, query);
+      printOne(result);
+    })
+  );
+}
+
+// src/commands/search.ts
+var searchColumns = [
+  { key: "type", header: "Type", width: 10 },
+  { key: "id", header: "ID", width: 12, format: (v) => String(v).slice(0, 12) },
+  { key: "title", header: "Title" }
+];
+function registerSearchCommands(program2) {
+  program2.command("search <query>").description("Search across all modules").option("--module <module>", "Limit to a specific module").option("--limit <n>", "Limit results").action(
+    withErrorHandler(async (query, opts) => {
+      const client = getClient();
+      const params = { q: query };
+      if (opts.module) params.module = opts.module;
+      if (opts.limit) params.limit = Number(opts.limit);
+      const res = await client.request("POST", "/api/search", params);
+      const results = res.results ?? [];
+      printTable(
+        results.map((r) => ({
+          type: r.type ?? r.module ?? "",
+          id: r.id ?? "",
+          title: r.title ?? r.name ?? r.subject ?? ""
+        })),
+        searchColumns
+      );
+    })
+  );
+}
+
+// src/commands/notifications.ts
+var notifColumns = [
+  { key: "id", header: "ID", width: 12, format: (v) => String(v).slice(0, 12) },
+  { key: "event_type", header: "Event", width: 20 },
+  { key: "read", header: "Read", width: 6, format: (v) => v ? "yes" : "no" },
+  { key: "created_at", header: "Date", format: (v) => v ? new Date(String(v)).toLocaleDateString() : "" }
+];
+function registerNotificationsCommands(program2) {
+  const notifs = program2.command("notifications").alias("notifs").description("Manage notifications");
+  notifs.command("list").description("List notifications").action(
+    withErrorHandler(async () => {
+      const client = getClient();
+      const res = await client.request("GET", "/api/notifications");
+      printTable(res.notifications ?? [], notifColumns);
+    })
+  );
+  notifs.command("read <id>").description("Mark a notification as read").action(
+    withErrorHandler(async (id) => {
+      const client = getClient();
+      await client.request("PATCH", `/api/notifications/${id}`, { read: true });
+      success(`Marked notification ${id} as read`);
+    })
+  );
+  notifs.command("unread-counts").description("Get unread counts per module").action(
+    withErrorHandler(async () => {
+      const client = getClient();
+      const res = await client.request("GET", "/api/unread-counts");
+      printOne(res);
+    })
+  );
+}
+
+// src/commands/webhooks.ts
+var webhookColumns = [
+  { key: "id", header: "ID", width: 12, format: (v) => String(v).slice(0, 12) },
+  { key: "url", header: "URL" },
+  { key: "active", header: "Active", width: 8, format: (v) => v ? "yes" : "no" }
+];
+function registerWebhooksCommands(program2) {
+  const webhooks = program2.command("webhooks").description("Manage webhook registrations");
+  webhooks.command("list").description("List webhook registrations").action(
+    withErrorHandler(async () => {
+      const client = getClient();
+      const res = await client.webhooks.list();
+      printTable(res.registrations, webhookColumns);
+    })
+  );
+  webhooks.command("create").description("Create a webhook registration").option("-f, --field <fields...>", 'Set fields (url=..., events=["*"], secret=...)').action(
+    withErrorHandler(async (opts) => {
+      const data = await collectInput(opts.field ?? []);
+      if (typeof data.events === "string") {
+        try {
+          data.events = JSON.parse(data.events);
+        } catch {
+        }
+      }
+      const client = getClient();
+      const webhook = await client.webhooks.create(data);
+      if (isJsonMode()) {
+        printOne(webhook);
+      } else {
+        success(`Created webhook (${webhook.id}) \u2192 ${webhook.url}`);
+      }
+    })
+  );
+  webhooks.command("delete <id>").description("Delete a webhook registration").option("-y, --yes", "Skip confirmation").action(
+    withErrorHandler(async (id, opts) => {
+      if (!opts.yes && !isJsonMode()) {
+        const ok = await confirm(`Delete webhook ${id}?`);
+        if (!ok) {
+          console.error(dim("Cancelled."));
+          return;
+        }
+      }
+      const client = getClient();
+      await client.webhooks.delete(id);
+      success(`Deleted webhook ${id}`);
+    })
+  );
+}
+
+// src/commands/assistant.ts
+function registerAssistantCommands(program2) {
+  const assistant = program2.command("assistant").alias("ai").description("AI assistant");
+  assistant.command("chat <message>").description("Send a message to the AI assistant").option("--context <json>", "Context object as JSON (e.g. current page)").action(
+    withErrorHandler(async (message, opts) => {
+      const client = getClient();
+      const body = { message };
+      if (opts.context) {
+        try {
+          body.context = JSON.parse(opts.context);
+        } catch {
+          body.context = opts.context;
+        }
+      }
+      const res = await client.request("POST", "/api/assistant/chat", body);
+      if (isJsonMode()) {
+        printOne(res);
+      } else {
+        const text = res.response ?? res.message ?? res.content ?? JSON.stringify(res);
+        console.log(text);
+      }
+    })
+  );
+}
+
+// src/index.ts
+var program = new Command();
+program.name("ambi").description("CLI for Ambiguous Workspaces \u2014 built for humans and LLMs").version("0.1.0").option("--json", "Output as JSON (auto-enabled when stdout is piped)").option("-q, --quiet", "Suppress non-essential output");
+program.hook("preAction", (_thisCommand, actionCommand) => {
+  const root = actionCommand.optsWithGlobals();
+  if (root.json) setJsonMode(true);
+  if (root.quiet) setQuietMode(true);
+});
+registerAuthCommands(program);
+registerConfigCommands(program);
+registerDocsCommands(program);
+registerSheetsCommands(program);
+registerSlidesCommands(program);
+registerChatCommands(program);
+registerMailCommands(program);
+registerTasksCommands(program);
+registerDriveCommands(program);
+registerCalendarCommands(program);
+registerCrmCommands(program);
+registerFormsCommands(program);
+registerWikiCommands(program);
+registerAdminCommands(program);
+registerApiCommands(program);
+registerSearchCommands(program);
+registerNotificationsCommands(program);
+registerWebhooksCommands(program);
+registerAssistantCommands(program);
+try {
+  await program.parseAsync();
+} catch (err) {
+  handleError(err);
+}