@arbidocs/cli 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2252 @@
+#!/usr/bin/env node
+'use strict';
+
+var commander = require('commander');
+var fs = require('fs');
+var path = require('path');
+var os = require('os');
+require('fake-indexeddb/auto');
+var sdk = require('@arbidocs/sdk');
+var prompts = require('@inquirer/prompts');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var path__default = /*#__PURE__*/_interopDefault(path);
+var os__default = /*#__PURE__*/_interopDefault(os);
+
+var CONFIG_DIR = path__default.default.join(os__default.default.homedir(), ".arbi");
+var CONFIG_FILE = path__default.default.join(CONFIG_DIR, "config.json");
+var CREDENTIALS_FILE = path__default.default.join(CONFIG_DIR, "credentials.json");
+function ensureConfigDir() {
+  if (!fs__default.default.existsSync(CONFIG_DIR)) {
+    fs__default.default.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  }
+}
+function writeSecureFile(filePath, data) {
+  ensureConfigDir();
+  fs__default.default.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", { mode: 384 });
+}
+function readJsonFile(filePath) {
+  try {
+    const content = fs__default.default.readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function getConfig() {
+  return readJsonFile(CONFIG_FILE);
+}
+function saveConfig(config) {
+  writeSecureFile(CONFIG_FILE, config);
+}
+function updateConfig(updates) {
+  const existing = getConfig() || {};
+  saveConfig({ ...existing, ...updates });
+}
+function requireConfig() {
+  const config = getConfig();
+  if (!config?.baseUrl) {
+    console.error("Not configured. Run: arbi config set-url <url>");
+    process.exit(1);
+  }
+  return config;
+}
+function getCredentials() {
+  return readJsonFile(CREDENTIALS_FILE);
+}
+function saveCredentials(creds) {
+  writeSecureFile(CREDENTIALS_FILE, creds);
+}
+function deleteCredentials() {
+  try {
+    fs__default.default.unlinkSync(CREDENTIALS_FILE);
+  } catch {
+  }
+}
+function requireCredentials() {
+  const creds = getCredentials();
+  if (!creds) {
+    console.error("Not logged in. Run: arbi login");
+    process.exit(1);
+  }
+  return creds;
+}
+var SESSION_FILE = path__default.default.join(CONFIG_DIR, "session.json");
+var DEFAULT_SESSION = {
+  lastMessageExtId: null
+};
+function getChatSession() {
+  return readJsonFile(SESSION_FILE) || { ...DEFAULT_SESSION };
+}
+function saveChatSession(session) {
+  writeSecureFile(SESSION_FILE, session);
+}
+function updateChatSession(updates) {
+  const existing = getChatSession();
+  saveChatSession({ ...existing, ...updates });
+}
+function clearChatSession() {
+  saveChatSession({ ...DEFAULT_SESSION });
+}
+
+// src/commands/config-cmd.ts
+function registerConfigCommand(program2) {
+  const config = program2.command("config").description("Manage CLI configuration");
+  config.command("set-url <url>").description("Set the ARBI server URL").action((url) => {
+    try {
+      const parsed = new URL(url);
+      const deploymentDomain = parsed.hostname;
+      updateConfig({ baseUrl: url.replace(/\/+$/, ""), deploymentDomain });
+      console.log(`Server URL: ${url}`);
+      console.log(`Domain:     ${deploymentDomain}`);
+    } catch {
+      console.error(`Invalid URL: ${url}`);
+      process.exit(1);
+    }
+  });
+}
+async function promptSelect(message, choices) {
+  return prompts.select({ message, choices });
+}
+async function promptCheckbox(message, choices) {
+  return prompts.checkbox({ message, choices });
+}
+async function promptSearch(message, choices) {
+  return prompts.search({
+    message,
+    source: async (term) => {
+      if (!term) return choices;
+      const lower = term.toLowerCase();
+      return choices.filter((c) => c.name.toLowerCase().includes(lower));
+    }
+  });
+}
+async function promptInput(message, required = true) {
+  return prompts.input({
+    message,
+    validate: required ? (v) => v.trim() ? true : "Required" : void 0
+  });
+}
+async function promptPassword(message) {
+  return prompts.password({
+    message,
+    mask: "*",
+    validate: (v) => v ? true : "Required"
+  });
+}
+async function promptConfirm(message, defaultValue = true) {
+  return prompts.confirm({ message, default: defaultValue });
+}
+
+// src/commands/login.ts
+function registerLoginCommand(program2) {
+  program2.command("login").description("Log in to ARBI").option("-e, --email <email>", "Email address (or ARBI_EMAIL env var)").option("-p, --password <password>", "Password (or ARBI_PASSWORD env var)").option("-w, --workspace <id>", "Workspace ID to select after login").action(async (opts) => {
+    const config = requireConfig();
+    const email = opts.email || process.env.ARBI_EMAIL || await promptInput("Email");
+    const pw = opts.password || process.env.ARBI_PASSWORD || await promptPassword("Password");
+    const arbi = sdk.createArbiClient({
+      baseUrl: config.baseUrl,
+      deploymentDomain: config.deploymentDomain,
+      credentials: "omit"
+    });
+    await arbi.crypto.initSodium();
+    try {
+      const result = await arbi.auth.login({ email, password: pw });
+      saveCredentials({
+        email,
+        signingPrivateKeyBase64: arbi.crypto.bytesToBase64(result.signingPrivateKey),
+        serverSessionKeyBase64: arbi.crypto.bytesToBase64(result.serverSessionKey)
+      });
+      const { data: workspaces } = await arbi.fetch.GET("/api/user/workspaces");
+      const wsList = workspaces || [];
+      console.log(`Logged in as ${email}`);
+      if (wsList.length === 0) {
+        console.log("No workspaces found.");
+        return;
+      }
+      if (opts.workspace) {
+        const ws2 = wsList.find((w) => w.external_id === opts.workspace);
+        if (!ws2) {
+          console.error(`Workspace ${opts.workspace} not found.`);
+          process.exit(1);
+        }
+        updateConfig({ selectedWorkspaceId: ws2.external_id });
+        console.log(`Workspace: ${ws2.name} (${ws2.external_id})`);
+        return;
+      }
+      if (wsList.length === 1) {
+        updateConfig({ selectedWorkspaceId: wsList[0].external_id });
+        console.log(`Workspace: ${wsList[0].name} (${wsList[0].external_id})`);
+        return;
+      }
+      const choices = wsList.map((ws2) => {
+        const totalDocs = ws2.shared_document_count + ws2.private_document_count;
+        return {
+          name: `${ws2.name} (${totalDocs} docs)`,
+          value: ws2.external_id,
+          description: ws2.external_id
+        };
+      });
+      const selected = await promptSelect("Select workspace", choices);
+      updateConfig({ selectedWorkspaceId: selected });
+      const ws = wsList.find((w) => w.external_id === selected);
+      console.log(`Workspace: ${ws.name} (${selected})`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`Login failed: ${msg}`);
+      process.exit(1);
+    }
+  });
+}
+var CENTRAL_API_URL = "https://central.arbi.work";
+async function getVerificationCode(email, apiKey) {
+  const params = new URLSearchParams({ email });
+  const res = await fetch(`${CENTRAL_API_URL}/license-management/verify-ci?${params.toString()}`, {
+    method: "GET",
+    headers: { "x-api-key": apiKey }
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`Failed to get verification code: ${res.status} ${body}`);
+  }
+  const data = await res.json();
+  const words = data?.verification_words ?? data?.verification_code ?? null;
+  if (!words) throw new Error("No verification code in response");
+  return Array.isArray(words) ? words.join(" ") : String(words);
+}
+function registerRegisterCommand(program2) {
+  program2.command("register").description("Register a new ARBI account").option("--non-interactive", "CI/automation mode (requires SUPPORT_API_KEY env var)").option("-e, --email <email>", "Email address (or ARBI_EMAIL env var)").option("-p, --password <password>", "Password (or ARBI_PASSWORD env var)").option("--first-name <name>", "First name").option("--last-name <name>", "Last name").action(
+    async (opts) => {
+      const config = requireConfig();
+      if (opts.nonInteractive) {
+        await nonInteractiveRegister(config, opts);
+      } else {
+        await interactiveRegister(config, opts);
+      }
+    }
+  );
+}
+async function interactiveRegister(config, opts) {
+  const email = opts.email || await promptInput("Email");
+  const arbi = sdk.createArbiClient({
+    baseUrl: config.baseUrl,
+    deploymentDomain: config.deploymentDomain,
+    credentials: "omit"
+  });
+  await arbi.crypto.initSodium();
+  const codeMethod = await promptSelect("Verification method", [
+    { name: "I have an invitation code", value: "code" },
+    { name: "Send me a verification email", value: "email" }
+  ]);
+  let verificationCode;
+  if (codeMethod === "code") {
+    verificationCode = await promptInput("Invitation code");
+  } else {
+    console.log("Sending verification email...");
+    const verifyResponse = await arbi.fetch.POST("/api/user/verify-email", {
+      body: { email }
+    });
+    if (verifyResponse.error) {
+      console.error(`Failed to send verification email: ${JSON.stringify(verifyResponse.error)}`);
+      process.exit(1);
+    }
+    console.log("Verification email sent. Check your inbox.");
+    verificationCode = await promptInput("Verification code");
+  }
+  const password2 = opts.password || await promptPassword("Password");
+  const confirmPw = await promptPassword("Confirm password");
+  if (password2 !== confirmPw) {
+    console.error("Passwords do not match.");
+    process.exit(1);
+  }
+  const firstName = opts.firstName || await promptInput("First name", false) || "User";
+  const lastName = opts.lastName || await promptInput("Last name", false) || "";
+  try {
+    await arbi.auth.register({
+      email,
+      password: password2,
+      verificationCode,
+      firstName,
+      lastName
+    });
+    console.log(`
+Registered successfully as ${email}`);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`Registration failed: ${msg}`);
+    process.exit(1);
+  }
+  const doLogin = await promptConfirm("Log in now?");
+  if (doLogin) {
+    try {
+      const loginResult = await arbi.auth.login({ email, password: password2 });
+      saveCredentials({
+        email,
+        signingPrivateKeyBase64: arbi.crypto.bytesToBase64(loginResult.signingPrivateKey),
+        serverSessionKeyBase64: arbi.crypto.bytesToBase64(loginResult.serverSessionKey)
+      });
+      const { data: workspaces } = await arbi.fetch.GET("/api/user/workspaces");
+      const wsList = workspaces || [];
+      console.log(`Logged in as ${email}`);
+      if (wsList.length === 1) {
+        updateConfig({ selectedWorkspaceId: wsList[0].external_id });
+        console.log(`Workspace: ${wsList[0].name} (${wsList[0].external_id})`);
+      } else if (wsList.length > 1) {
+        const choices = wsList.map((ws2) => {
+          const totalDocs = ws2.shared_document_count + ws2.private_document_count;
+          return {
+            name: `${ws2.name} (${totalDocs} docs)`,
+            value: ws2.external_id,
+            description: ws2.external_id
+          };
+        });
+        const selected = await promptSelect("Select workspace", choices);
+        updateConfig({ selectedWorkspaceId: selected });
+        const ws = wsList.find((w) => w.external_id === selected);
+        console.log(`Workspace: ${ws.name} (${selected})`);
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`Login failed: ${msg}`);
+      console.error("You can log in later with: arbi login");
+    }
+  }
+}
+async function nonInteractiveRegister(config, opts) {
+  const email = opts.email || process.env.ARBI_EMAIL;
+  const password2 = opts.password || process.env.ARBI_PASSWORD;
+  const supportApiKey = process.env.SUPPORT_API_KEY;
+  if (!email) {
+    console.error("Email required. Use --email <email> or set ARBI_EMAIL");
+    process.exit(1);
+  }
+  if (!password2) {
+    console.error("Password required. Use --password <password> or set ARBI_PASSWORD");
+    process.exit(1);
+  }
+  if (!supportApiKey) {
+    console.error("SUPPORT_API_KEY env var is required for --non-interactive registration");
+    process.exit(1);
+  }
+  const arbi = sdk.createArbiClient({
+    baseUrl: config.baseUrl,
+    deploymentDomain: config.deploymentDomain,
+    credentials: "omit"
+  });
+  await arbi.crypto.initSodium();
+  const verifyResponse = await arbi.fetch.POST("/api/user/verify-email", {
+    body: { email }
+  });
+  if (verifyResponse.error) {
+    console.error(`verify-email failed: ${JSON.stringify(verifyResponse.error)}`);
+    process.exit(1);
+  }
+  const verificationCode = await getVerificationCode(email, supportApiKey);
+  try {
+    await arbi.auth.register({
+      email,
+      password: password2,
+      verificationCode,
+      firstName: opts.firstName ?? "Test",
+      lastName: opts.lastName ?? "User"
+    });
+    console.log(`Registered: ${email}`);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`Registration failed: ${msg}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/logout.ts
+function registerLogoutCommand(program2) {
+  program2.command("logout").description("Log out of ARBI").action(() => {
+    deleteCredentials();
+    updateConfig({ selectedWorkspaceId: void 0 });
+    console.log("Logged out.");
+  });
+}
+
+// src/commands/status.ts
+function registerStatusCommand(program2) {
+  program2.command("status").description("Show current configuration and login status").action(() => {
+    const config = getConfig();
+    const creds = getCredentials();
+    if (!config?.baseUrl) {
+      console.log("Not configured. Run: arbi config set-url <url>");
+      return;
+    }
+    console.log(`Server:    ${config.baseUrl}`);
+    if (creds) {
+      console.log(`User:      ${creds.email}`);
+    } else {
+      console.log("User:      (not logged in)");
+    }
+    if (config.selectedWorkspaceId) {
+      console.log(`Workspace: ${config.selectedWorkspaceId}`);
+    } else {
+      console.log("Workspace: (none selected)");
+    }
+  });
+}
+async function createAuthenticatedClient() {
+  const config = requireConfig();
+  const creds = requireCredentials();
+  const arbi = sdk.createArbiClient({
+    baseUrl: config.baseUrl,
+    deploymentDomain: config.deploymentDomain,
+    credentials: "omit"
+  });
+  await arbi.crypto.initSodium();
+  const signingPrivateKey = sdk.base64ToBytes(creds.signingPrivateKeyBase64);
+  const loginResult = await arbi.auth.loginWithKey({
+    email: creds.email,
+    signingPrivateKey
+  });
+  saveCredentials({
+    ...creds,
+    serverSessionKeyBase64: arbi.crypto.bytesToBase64(loginResult.serverSessionKey)
+  });
+  return { arbi, loginResult };
+}
+async function selectWorkspace(arbi, workspaceId, wrappedKey, serverSessionKey) {
+  const creds = requireCredentials();
+  const signingPrivateKey = sdk.base64ToBytes(creds.signingPrivateKeyBase64);
+  const ed25519PublicKey = signingPrivateKey.slice(32, 64);
+  const encryptionKeyPair = sdk.deriveEncryptionKeypairFromSigning({
+    publicKey: ed25519PublicKey,
+    secretKey: signingPrivateKey
+  });
+  const workspaceKey = sdk.sealedBoxDecrypt(wrappedKey, encryptionKeyPair.secretKey);
+  const header = await sdk.createWorkspaceKeyHeader(workspaceKey, serverSessionKey);
+  arbi.session.setSelectedWorkspace(workspaceId);
+  arbi.session.setCachedWorkspaceHeader(workspaceId, header);
+}
+async function selectWorkspaceById(arbi, workspaceId, serverSessionKey) {
+  const { data: workspaces, error } = await arbi.fetch.GET("/api/user/workspaces");
+  if (error || !workspaces) {
+    throw new Error("Failed to fetch workspaces");
+  }
+  const ws = workspaces.find((w) => w.external_id === workspaceId);
+  if (!ws || !ws.wrapped_key) {
+    throw new Error(`Workspace ${workspaceId} not found or has no encryption key`);
+  }
+  await selectWorkspace(arbi, ws.external_id, ws.wrapped_key, serverSessionKey);
+  return { external_id: ws.external_id, name: ws.name, wrapped_key: ws.wrapped_key };
+}
+
+// src/helpers.ts
+function runAction(fn) {
+  return async () => {
+    try {
+      await fn();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`Error: ${msg}`);
+      process.exit(1);
+    }
+  };
+}
+function requireData(result, message) {
+  if (result.error || !result.data) {
+    console.error(message);
+    process.exit(1);
+  }
+  return result.data;
+}
+function requireOk(result, message) {
+  if (result.error) {
+    console.error(message);
+    process.exit(1);
+  }
+}
+async function resolveAuth() {
+  const config = requireConfig();
+  const { arbi, loginResult } = await createAuthenticatedClient();
+  return { arbi, loginResult, config };
+}
+async function resolveWorkspace(workspaceOpt) {
+  const config = requireConfig();
+  const workspaceId = workspaceOpt || config.selectedWorkspaceId;
+  if (!workspaceId) {
+    console.error("No workspace selected. Run: arbi workspace select <id>");
+    process.exit(1);
+  }
+  const { arbi, loginResult } = await createAuthenticatedClient();
+  await selectWorkspaceById(arbi, workspaceId, loginResult.serverSessionKey);
+  const accessToken = arbi.session.getState().accessToken;
+  const workspaceKeyHeader = arbi.session.getWorkspaceKeyHeader();
+  if (!accessToken || !workspaceKeyHeader) {
+    console.error("Authentication error \u2014 missing token or workspace key");
+    process.exit(1);
+  }
+  return { arbi, loginResult, config, workspaceId, accessToken, workspaceKeyHeader };
+}
+function printTable(columns, rows) {
+  console.log(columns.map((c) => c.header.padEnd(c.width)).join(""));
+  for (const row of rows) {
+    console.log(
+      columns.map((c) => {
+        const val = c.value(row);
+        return val.slice(0, c.width - 2).padEnd(c.width);
+      }).join("")
+    );
+  }
+}
+function parseJsonArg(input2, example) {
+  try {
+    return JSON.parse(input2);
+  } catch {
+    console.error(`Invalid JSON. Example: ${example}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/workspaces.ts
+function registerWorkspacesCommand(program2) {
+  program2.command("workspaces").description("List workspaces").action(
+    runAction(async () => {
+      const { arbi } = await resolveAuth();
+      const data = requireData(
+        await arbi.fetch.GET("/api/user/workspaces"),
+        "Failed to fetch workspaces"
+      );
+      if (data.length === 0) {
+        console.log("No workspaces found.");
+        return;
+      }
+      printTable(
+        [
+          { header: "ID", width: 24, value: (r) => r.external_id },
+          { header: "NAME", width: 30, value: (r) => r.name },
+          {
+            header: "DOCS",
+            width: 6,
+            value: (r) => String(r.shared_document_count + r.private_document_count)
+          },
+          {
+            header: "ROLE",
+            width: 10,
+            value: (r) => r.users?.[0]?.role ?? ""
+          }
+        ],
+        data
+      );
+    })
+  );
+  const workspace = program2.command("workspace").description("Workspace management");
+  workspace.command("select [id]").description("Select active workspace (interactive picker if no ID given)").action(
+    (id) => runAction(async () => {
+      const { arbi } = await resolveAuth();
+      const data = requireData(
+        await arbi.fetch.GET("/api/user/workspaces"),
+        "Failed to fetch workspaces"
+      );
+      if (data.length === 0) {
+        console.log("No workspaces found.");
+        return;
+      }
+      let selectedId;
+      if (id) {
+        const ws2 = data.find((w) => w.external_id === id);
+        if (!ws2) {
+          console.error(`Workspace ${id} not found.`);
+          console.error("Available workspaces:");
+          for (const w of data) console.error(`  ${w.external_id}  ${w.name}`);
+          process.exit(1);
+        }
+        selectedId = id;
+      } else {
+        const choices = data.map((ws2) => {
+          const totalDocs = ws2.shared_document_count + ws2.private_document_count;
+          return {
+            name: `${ws2.name} (${totalDocs} docs)`,
+            value: ws2.external_id,
+            description: ws2.external_id
+          };
+        });
+        selectedId = await promptSelect("Select workspace", choices);
+      }
+      updateConfig({ selectedWorkspaceId: selectedId });
+      const ws = data.find((w) => w.external_id === selectedId);
+      console.log(`Selected: ${ws.name} (${selectedId})`);
+    })()
+  );
+  workspace.command("create <name>").description("Create a new workspace").option("-d, --description <text>", "Workspace description").option("--public", "Make workspace public", false).action(
+    (name, opts) => runAction(async () => {
+      const { arbi } = await resolveAuth();
+      const data = requireData(
+        await arbi.fetch.POST("/api/workspace/create_protected", {
+          body: { name, description: opts.description ?? null, is_public: opts.public ?? false }
+        }),
+        "Failed to create workspace"
+      );
+      console.log(`Created: ${data.name} (${data.external_id})`);
+    })()
+  );
+  workspace.command("delete <id>").description("Delete a workspace").action(
+    (id) => runAction(async () => {
+      const { arbi } = await resolveAuth();
+      const data = requireData(
+        await arbi.fetch.DELETE("/api/workspace/{workspace_ext_id}", {
+          params: { path: { workspace_ext_id: id } }
+        }),
+        "Failed to delete workspace"
+      );
+      console.log(data?.detail ?? `Deleted workspace ${id}`);
+    })()
+  );
+  workspace.command("update <id> <json>").description("Update workspace properties (pass JSON)").action(
+    (id, json) => runAction(async () => {
+      const body = parseJsonArg(json, `arbi workspace update wrk-123 '{"name": "New Name"}'`);
+      const { arbi } = await resolveWorkspace(id);
+      const data = requireData(
+        await arbi.fetch.PATCH("/api/workspace/{workspace_ext_id}", {
+          params: { path: { workspace_ext_id: id } },
+          body
+        }),
+        "Failed to update workspace"
+      );
+      console.log(`Updated: ${data.name} (${data.external_id})`);
+    })()
+  );
+  workspace.command("users").description("List users in the active workspace").option("-w, --workspace <id>", "Workspace ID (defaults to selected workspace)").action(
+    (opts) => runAction(async () => {
+      const { arbi, workspaceId } = await resolveWorkspace(opts.workspace);
+      const data = requireData(
+        await arbi.fetch.GET("/api/workspace/{workspace_ext_id}/users", {
+          params: { path: { workspace_ext_id: workspaceId } }
+        }),
+        "Failed to fetch workspace users"
+      );
+      if (data.length === 0) {
+        console.log("No users found.");
+        return;
+      }
+      printTable(
+        [
+          {
+            header: "USER_ID",
+            width: 16,
+            value: (r) => r.user?.external_id ?? ""
+          },
+          {
+            header: "NAME",
+            width: 20,
+            value: (r) => {
+              const u = r.user;
+              return [u?.given_name, u?.family_name].filter(Boolean).join(" ") || "";
+            }
+          },
+          {
+            header: "EMAIL",
+            width: 30,
+            value: (r) => r.user?.email ?? ""
+          },
+          { header: "ROLE", width: 14, value: (r) => r.role },
+          { header: "DOCS", width: 6, value: (r) => String(r.document_count) },
+          { header: "CONVS", width: 6, value: (r) => String(r.conversation_count) }
+        ],
+        data
+      );
+    })()
+  );
+  workspace.command("add-user <emails...>").description("Add users to the active workspace").option("-w, --workspace <id>", "Workspace ID (defaults to selected workspace)").option("-r, --role <role>", "Role: owner, collaborator, guest", "collaborator").action(
+    (emails, opts) => runAction(async () => {
+      const { arbi, workspaceId } = await resolveWorkspace(opts.workspace);
+      const role = opts.role ?? "collaborator";
+      const data = requireData(
+        await arbi.fetch.POST("/api/workspace/{workspace_ext_id}/users", {
+          params: { path: { workspace_ext_id: workspaceId } },
+          body: { emails, role }
+        }),
+        "Failed to add users"
+      );
+      for (const u of data) console.log(`Added: ${u.user.email} as ${u.role}`);
+    })()
+  );
+  workspace.command("remove-user <user-ids...>").description("Remove users from the active workspace").option("-w, --workspace <id>", "Workspace ID (defaults to selected workspace)").action(
+    (userIds, opts) => runAction(async () => {
+      const { arbi, workspaceId } = await resolveWorkspace(opts.workspace);
+      requireOk(
+        await arbi.fetch.DELETE("/api/workspace/{workspace_ext_id}/users", {
+          params: { path: { workspace_ext_id: workspaceId } },
+          body: { users: userIds.map((id) => ({ user_ext_id: id })) }
+        }),
+        "Failed to remove users"
+      );
+      console.log(`Removed ${userIds.length} user(s).`);
+    })()
+  );
+  workspace.command("set-role <role> <user-ids...>").description("Update user roles (owner, collaborator, guest)").option("-w, --workspace <id>", "Workspace ID (defaults to selected workspace)").action(
+    (role, userIds, opts) => runAction(async () => {
+      const { arbi, workspaceId } = await resolveWorkspace(opts.workspace);
+      const data = requireData(
+        await arbi.fetch.PATCH("/api/workspace/{workspace_ext_id}/users", {
+          params: { path: { workspace_ext_id: workspaceId } },
+          body: { user_ext_ids: userIds, role }
+        }),
+        "Failed to update roles"
+      );
+      for (const u of data) console.log(`Updated: ${u.user.email} \u2192 ${u.role}`);
+    })()
+  );
+  workspace.command("copy <target-workspace-id> <doc-ids...>").description("Copy documents to another workspace").option("-w, --workspace <id>", "Source workspace ID (defaults to selected workspace)").action(
+    (targetId, docIds, opts) => runAction(async () => {
+      const { arbi, workspaceId } = await resolveWorkspace(opts.workspace);
+      const data = requireData(
+        await arbi.fetch.POST("/api/workspace/{workspace_ext_id}/copy", {
+          params: { path: { workspace_ext_id: workspaceId } },
+          body: { target_workspace_ext_id: targetId, items: docIds }
+        }),
+        "Failed to copy documents"
+      );
+      console.log(`${data.detail} (${data.documents_copied} document(s) copied)`);
+    })()
+  );
+}
+
+// src/commands/docs.ts
+function formatSize(bytes) {
+  if (!bytes) return "-";
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+async function fetchDocChoices(arbi, workspaceId) {
+  const data = requireData(
+    await arbi.fetch.GET("/api/workspace/{workspace_ext_id}/documents", {
+      params: { path: { workspace_ext_id: workspaceId } }
+    }),
+    "Failed to fetch documents"
+  );
+  if (data.length === 0) {
+    console.log("No documents found.");
+    process.exit(0);
+  }
+  return data.map((d) => ({
+    name: `${d.file_name ?? "Unnamed"} (${d.status})`,
+    value: d.external_id,
+    description: d.external_id
+  }));
+}
+function registerDocsCommand(program2) {
+  program2.command("docs").description("List documents in the active workspace").option("-w, --workspace <id>", "Workspace ID (defaults to selected workspace)").action(
+    (opts) => runAction(async () => {
+      const { arbi, workspaceId } = await resolveWorkspace(opts.workspace);
+      const data = requireData(
+        await arbi.fetch.GET("/api/workspace/{workspace_ext_id}/documents", {
+          params: { path: { workspace_ext_id: workspaceId } }
+        }),
+        "Failed to fetch documents"
+      );
+      if (data.length === 0) {
+        console.log("No documents found.");
+        return;
+      }
+      printTable(
+        [
+          { header: "ID", width: 24, value: (r) => r.external_id },
+          { header: "NAME", width: 36, value: (r) => r.file_name ?? "Unnamed" },
+          { header: "STATUS", width: 14, value: (r) => r.status ?? "" },
+          { header: "SIZE", width: 10, value: (r) => formatSize(r.file_size) }
+        ],
+        data
+      );
+    })()
+  );
+  const doc = program2.command("doc").description("Document management");
+  doc.command("get [ids...]").description("Get document details (interactive picker if no IDs given)").action(
+    (ids) => runAction(async () => {
+      const { arbi, workspaceId } = await resolveWorkspace();
+      let docIds = ids && ids.length > 0 ? ids : void 0;
+      if (!docIds) {
+        const choices = await fetchDocChoices(arbi, workspaceId);
+        const selected = await promptCheckbox("Select documents", choices);
+        if (selected.length === 0) return;
+        docIds = selected;
+      }
+      const data = requireData(
+        await arbi.fetch.GET("/api/document/", { params: { query: { external_ids: docIds } } }),
+        "Failed to fetch documents"
+      );
+      console.log(JSON.stringify(data, null, 2));
+    })()
+  );
+  doc.command("delete [ids...]").description("Delete documents (interactive picker if no IDs given)").action(
+    (ids) => runAction(async () => {
+      const { arbi, workspaceId } = await resolveWorkspace();
+      let docIds = ids && ids.length > 0 ? ids : void 0;
+      if (!docIds) {
+        const choices = await fetchDocChoices(arbi, workspaceId);
+        const selected = await promptCheckbox("Select documents to delete", choices);
+        if (selected.length === 0) return;
+        docIds = selected;
+      }
+      requireOk(
+        await arbi.fetch.DELETE("/api/document/", { body: { external_ids: docIds } }),
+        "Failed to delete documents"
+      );
+      console.log(`Deleted ${docIds.length} document(s).`);
+    })()
+  );
+  doc.command("update [json]").description("Update documents (interactive form if no JSON given)").action(
+    (json) => runAction(async () => {
+      if (json) {
+        const parsed = parseJsonArg(json, `arbi doc update '[{"external_id": "doc-123", "shared": true}]'`);
+        const body = Array.isArray(parsed) ? { documents: parsed } : parsed;
+        const { arbi } = await resolveWorkspace();
+        const data = requireData(
+          await arbi.fetch.PATCH("/api/document/", { body }),
+          "Failed to update documents"
+        );
+        console.log(`Updated ${data.length} document(s).`);
+      } else {
+        const { arbi, workspaceId } = await resolveWorkspace();
+        const choices = await fetchDocChoices(arbi, workspaceId);
+        const docId = await promptSearch("Select document to update", choices);
+        const field = await promptSelect("Field to update", [
+          { name: "Title", value: "title" },
+          { name: "Shared", value: "shared" },
+          { name: "Author", value: "author" },
+          { name: "Abstract", value: "abstract" },
+          { name: "Date", value: "date" }
+        ]);
+        let value;
+        if (field === "shared") {
+          value = await promptSelect("Shared?", [
+            { name: "Yes", value: true },
+            { name: "No", value: false }
+          ]);
+        } else if (field === "date") {
+          value = await promptInput("Date (YYYY-MM-DD)", false) || null;
+        } else {
+          value = await promptInput(`${field.charAt(0).toUpperCase() + field.slice(1)}`);
+        }
+        const data = requireData(
+          await arbi.fetch.PATCH("/api/document/", {
+            body: { documents: [{ external_id: docId, [field]: value }] }
+          }),
+          "Failed to update document"
+        );
+        console.log(`Updated ${data.length} document(s).`);
+      }
+    })()
+  );
+  doc.command("upload-url <urls...>").description("Upload documents from URLs").option("-w, --workspace <id>", "Workspace ID (defaults to selected workspace)").option("--shared", "Make documents shared", false).action(
+    (urls, opts) => runAction(async () => {
+      const { arbi, workspaceId } = await resolveWorkspace(opts.workspace);
+      const data = requireData(
+        await arbi.fetch.POST("/api/document/upload-url", {
+          params: {
+            query: { urls, workspace_ext_id: workspaceId, shared: opts.shared ?? false }
+          }
+        }),
+        "Failed to upload from URLs"
+      );
+      console.log(`Uploaded: ${data.doc_ext_ids.join(", ")}`);
+      if (data.duplicates && data.duplicates.length > 0) {
+        console.log(`Duplicates: ${data.duplicates.join(", ")}`);
+      }
+    })()
+  );
+  doc.command("parsed [doc-id] [stage]").description("Get parsed document content (stage: marker, subchunk, final)").action(
+    (docId, stage) => runAction(async () => {
+      const { arbi, config, accessToken, workspaceKeyHeader, workspaceId } = await resolveWorkspace();
+      if (!docId) {
+        const choices = await fetchDocChoices(arbi, workspaceId);
+        docId = await promptSearch("Select document", choices);
+      }
+      const validStages = ["marker", "subchunk", "final"];
+      if (!stage) {
+        stage = await promptSelect("Parsing stage", [
+          { name: "Final (processed)", value: "final" },
+          { name: "Subchunk", value: "subchunk" },
+          { name: "Marker (raw)", value: "marker" }
+        ]);
+      } else if (!validStages.includes(stage)) {
+        console.error(`Invalid stage: ${stage}. Must be one of: ${validStages.join(", ")}`);
+        process.exit(1);
+      }
+      const res = await fetch(`${config.baseUrl}/api/document/${docId}/parsed-${stage}`, {
+        headers: { Authorization: `Bearer ${accessToken}`, "workspace-key": workspaceKeyHeader }
+      });
+      if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        console.error(`Failed: ${res.status} ${body}`);
+        process.exit(1);
+      }
+      console.log(JSON.stringify(await res.json(), null, 2));
+    })()
+  );
+}
+var AUTH_TIMEOUT_MS = 1e4;
+function connectWebSocket(options) {
+  const { baseUrl, accessToken, onMessage, onClose } = options;
+  const url = sdk.buildWebSocketUrl(baseUrl);
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(url);
+    let authenticated = false;
+    const timeout = setTimeout(() => {
+      if (!authenticated) {
+        ws.close();
+        reject(new Error("WebSocket auth timed out"));
+      }
+    }, AUTH_TIMEOUT_MS);
+    ws.addEventListener("open", () => {
+      ws.send(sdk.createAuthMessage(accessToken));
+    });
+    ws.addEventListener("message", (event) => {
+      const data = typeof event.data === "string" ? event.data : String(event.data);
+      const msg = sdk.parseServerMessage(data);
+      if (!msg) return;
+      if (!authenticated) {
+        if (sdk.isMessageType(msg, "auth_result")) {
+          clearTimeout(timeout);
+          if (msg.success) {
+            authenticated = true;
+            resolve({ close: () => ws.close() });
+          } else {
+            ws.close();
+            reject(new Error(`WebSocket auth failed: ${msg.reason || "unknown"}`));
+          }
+        }
+        return;
+      }
+      onMessage(msg);
+    });
+    ws.addEventListener("close", (event) => {
+      clearTimeout(timeout);
+      if (!authenticated) {
+        reject(new Error(`WebSocket closed before auth (code ${event.code})`));
+        return;
+      }
+      onClose?.(event.code, event.reason);
+    });
+    ws.addEventListener("error", () => {
+    });
+  });
+}
+
+// src/commands/upload.ts
+function registerUploadCommand(program2) {
+  program2.command("upload <files...>").description("Upload documents to the active workspace").option("-w, --workspace <id>", "Workspace ID (defaults to selected workspace)").option("-W, --watch", "Watch document processing progress after upload").action(
+    (files, opts) => runAction(async () => {
+      for (const f of files) {
+        if (!fs__default.default.existsSync(f)) {
+          console.error(`File not found: ${f}`);
+          process.exit(1);
+        }
+      }
+      const { config, accessToken, workspaceKeyHeader, workspaceId } = await resolveWorkspace(
+        opts.workspace
+      );
+      const uploadedDocs = /* @__PURE__ */ new Map();
+      for (const filePath of files) {
+        const fileBuffer = fs__default.default.readFileSync(filePath);
+        const fileName = path__default.default.basename(filePath);
+        const formData = new FormData();
+        formData.append("files", new Blob([fileBuffer]), fileName);
+        const res = await fetch(
+          `${config.baseUrl}/api/document/upload?workspace_ext_id=${workspaceId}`,
+          {
+            method: "POST",
+            headers: {
+              Authorization: `Bearer ${accessToken}`,
+              "workspace-key": workspaceKeyHeader
+            },
+            body: formData
+          }
+        );
+        if (!res.ok) {
+          const body = await res.text().catch(() => "");
+          console.error(`Upload failed for ${fileName}: ${res.status} ${body}`);
+          process.exit(1);
+        }
+        const result = await res.json();
+        console.log(`Uploaded: ${fileName} (${result.doc_ext_ids.join(", ")})`);
+        if (result.duplicates && result.duplicates.length > 0) {
+          console.log(`  Duplicates: ${result.duplicates.join(", ")}`);
+        }
+        for (const id of result.doc_ext_ids) uploadedDocs.set(id, fileName);
+      }
+      if (opts.watch && uploadedDocs.size > 0) {
+        const pending = new Set(uploadedDocs.keys());
+        console.log(`
+Watching ${pending.size} document(s)...`);
+        const conn = await connectWebSocket({
+          baseUrl: config.baseUrl,
+          accessToken,
+          onMessage: (msg) => {
+            if (sdk.isMessageType(msg, "task_update")) {
+              if (!pending.has(msg.doc_ext_id)) return;
+              console.log(
+                `  ${uploadedDocs.get(msg.doc_ext_id) || msg.file_name}: ${msg.status} (${msg.progress}%)`
+              );
+              if (msg.status === "completed" || msg.status === "failed") {
+                pending.delete(msg.doc_ext_id);
+                if (pending.size === 0) {
+                  console.log("\nAll documents processed.");
+                  conn.close();
+                }
+              }
+            }
+          },
+          onClose: () => {
+            if (pending.size > 0)
+              console.log(`
+Connection closed. ${pending.size} document(s) still processing.`);
+          }
+        });
+      }
+    })()
+  );
+}
+function registerDownloadCommand(program2) {
+  program2.command("download [doc-id]").description("Download a document (interactive picker if no ID given)").option("-o, --output <path>", "Output file path").option("-w, --workspace <id>", "Workspace ID (defaults to selected workspace)").action(
+    (docId, opts) => runAction(async () => {
+      const { arbi, config, accessToken, workspaceKeyHeader, workspaceId } = await resolveWorkspace(opts.workspace);
+      if (!docId) {
+        const data = requireData(
+          await arbi.fetch.GET("/api/workspace/{workspace_ext_id}/documents", {
+            params: { path: { workspace_ext_id: workspaceId } }
+          }),
+          "Failed to fetch documents"
+        );
+        if (data.length === 0) {
+          console.log("No documents found.");
+          return;
+        }
+        const choices = data.map((d) => ({
+          name: `${d.file_name ?? "Unnamed"} (${d.status})`,
+          value: d.external_id,
+          description: d.external_id
+        }));
+        docId = await promptSearch("Select document to download", choices);
+      }
+      const res = await fetch(`${config.baseUrl}/api/document/${docId}/download`, {
+        headers: { Authorization: `Bearer ${accessToken}`, "workspace-key": workspaceKeyHeader }
+      });
+      if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        console.error(`Download failed: ${res.status} ${body}`);
+        process.exit(1);
+      }
+      let filename = `${docId}`;
+      const disposition = res.headers.get("content-disposition");
+      if (disposition) {
+        const match = disposition.match(/filename[*]?=(?:UTF-8''|"?)([^";]+)/i);
+        if (match) filename = decodeURIComponent(match[1].replace(/"/g, ""));
+      }
+      const outputPath = opts.output || path__default.default.join(process.cwd(), filename);
+      const buffer = Buffer.from(await res.arrayBuffer());
+      fs__default.default.writeFileSync(outputPath, buffer);
+      console.log(
+        `Downloaded: ${path__default.default.basename(outputPath)} (${(buffer.length / (1024 * 1024)).toFixed(1)} MB)`
+      );
+    })()
+  );
+}
+
+// src/commands/ask.ts
+function parseSSEEvents(chunk, buffer) {
+  const combined = buffer + chunk;
+  const events = [];
+  const parts = combined.split("\n\n");
+  const remaining = parts.pop() || "";
+  for (const part of parts) {
+    if (!part.trim()) continue;
+    let eventType = "";
+    let eventData = "";
+    for (const line of part.split("\n")) {
+      if (line.startsWith("event: ")) eventType = line.slice(7).trim();
+      else if (line.startsWith("data: ")) eventData = line.slice(6);
+    }
+    if (eventType && eventData) events.push({ event: eventType, data: eventData });
+  }
+  return { events, remaining };
+}
+function registerAskCommand(program2) {
+  program2.command("ask <question>").description("Ask the RAG assistant a question").option("-w, --workspace <id>", "Workspace ID (defaults to selected workspace)").option("-c, --config <id>", "Config ext_id to use (e.g. cfg-xxx)").option("-n, --new", "Start a new conversation (ignore previous context)").option("-v, --verbose", "Show agent steps and tool calls").action(
+    (question, opts) => runAction(async () => {
+      const { arbi, config, accessToken, workspaceKeyHeader, workspaceId } = await resolveWorkspace(opts.workspace);
+      const session = getChatSession();
+      if (opts.new) {
+        clearChatSession();
+        session.lastMessageExtId = null;
+      }
+      const docs = requireData(
+        await arbi.fetch.GET("/api/workspace/{workspace_ext_id}/documents", {
+          params: { path: { workspace_ext_id: workspaceId } }
+        }),
+        "Failed to fetch workspace documents"
+      );
+      const docIds = docs.map((d) => d.external_id);
+      const body = {
+        content: question,
+        workspace_ext_id: workspaceId,
+        tools: {
+          retrieval_chunk: {
+            name: "retrieval_chunk",
+            description: "retrieval chunk",
+            tool_args: { doc_ext_ids: docIds },
+            tool_responses: {}
+          },
+          retrieval_full_context: {
+            name: "retrieval_full_context",
+            description: "retrieval full_context",
+            tool_args: { doc_ext_ids: [] },
+            tool_responses: {}
+          }
+        }
+      };
+      if (session.lastMessageExtId) {
+        body.parent_message_ext_id = session.lastMessageExtId;
+      }
+      if (opts.config) {
+        body.config_ext_id = opts.config;
+      }
+      const res = await fetch(`${config.baseUrl}/api/assistant/query`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "workspace-key": workspaceKeyHeader,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body)
+      });
+      if (!res.ok) {
+        if (res.status === 503)
+          console.error(
+            "The selected LLM is not responding. Please retry or select another model."
+          );
+        else if (res.status === 401) console.error("Token has expired. Please run: arbi login");
+        else console.error(`Query failed: ${res.status} ${await res.text().catch(() => "")}`);
+        process.exit(1);
+      }
+      if (!res.body) {
+        console.error("No response body");
+        process.exit(1);
+      }
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder("utf-8");
+      let sseBuffer = "";
+      let assistantMessageExtId = null;
+      const processEvents = (events) => {
+        for (const { event, data } of events) {
+          try {
+            if (event === "stream_start") {
+              const parsed = JSON.parse(data);
+              if (parsed.assistant_message_ext_id) {
+                assistantMessageExtId = parsed.assistant_message_ext_id;
+              }
+            } else if (event === "agent_step") {
+              if (opts.verbose) {
+                const parsed = JSON.parse(data);
+                const focus = parsed.focus || parsed.status || "";
+                console.error(`
+[agent] ${focus}`);
+              }
+            } else if (event === "token") {
+              const parsed = JSON.parse(data);
+              if (parsed.content) process.stdout.write(parsed.content);
+            } else if (event === "error") {
+              const parsed = JSON.parse(data);
+              console.error(`
+Error: ${parsed.message || "Unknown streaming error"}`);
+            }
+          } catch {
+          }
+        }
+      };
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const { events, remaining } = parseSSEEvents(
+          decoder.decode(value, { stream: true }),
+          sseBuffer
+        );
+        sseBuffer = remaining;
+        processEvents(events);
+      }
+      if (sseBuffer.trim()) {
+        const { events } = parseSSEEvents(sseBuffer + "\n\n", "");
+        processEvents(events);
+      }
+      process.stdout.write("\n");
+      if (assistantMessageExtId) {
+        updateChatSession({ lastMessageExtId: assistantMessageExtId });
+      }
+    })()
+  );
+}
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toLocaleTimeString("en-GB", { hour12: false });
+}
+function registerWatchCommand(program2) {
+  program2.command("watch").description("Watch workspace activity in real time").option("-w, --workspace <id>", "Workspace ID (defaults to selected workspace)").action(
+    (opts) => runAction(async () => {
+      const { config, accessToken, workspaceId } = await resolveWorkspace(opts.workspace);
+      console.log(`Watching workspace ${workspaceId}... (Ctrl+C to stop)`);
+      await connectWebSocket({
+        baseUrl: config.baseUrl,
+        accessToken,
+        onMessage: (msg) => {
+          if (sdk.isMessageType(msg, "task_update")) {
+            console.log(
+              `[${timestamp()}] task_update: ${msg.file_name} - ${msg.status} (${msg.progress}%)`
+            );
+          } else if (sdk.isMessageType(msg, "batch_complete")) {
+            console.log(
+              `[${timestamp()}] batch_complete: ${msg.batch_type} - ${msg.doc_ext_ids.length} docs`
+            );
+          } else if (sdk.isMessageType(msg, "error")) {
+            console.log(`[${timestamp()}] error: ${msg.message}`);
+          } else {
+            console.log(`[${timestamp()}] ${msg.type}: ${JSON.stringify(msg)}`);
+          }
+        },
+        onClose: (code, reason) => {
+          console.log(`
+Connection closed (code ${code}${reason ? ": " + reason : ""})`);
+        }
+      });
+    })()
+  );
+}
+
+// src/commands/contacts.ts
+function registerContactsCommand(program2) {
+  const contacts = program2.command("contacts").description("Manage contacts");
+  contacts.command("list").description("List all contacts").action(
+    runAction(async () => {
+      const { arbi } = await resolveAuth();
+      const data = requireData(
+        await arbi.fetch.GET("/api/user/contacts"),
+        "Failed to fetch contacts"
+      );
+      if (data.length === 0) {
+        console.log("No contacts found.");
+        return;
+      }
+      printTable(
+        [
+          { header: "ID", width: 16, value: (r) => r.external_id },
+          {
+            header: "NAME",
+            width: 20,
+            value: (r) => {
+              const u = r.user;
+              return u ? [u.given_name, u.family_name].filter(Boolean).join(" ") : "";
+            }
+          },
+          { header: "EMAIL", width: 30, value: (r) => r.email },
+          { header: "STATUS", width: 18, value: (r) => r.status }
+        ],
+        data
+      );
+    })
+  );
+  contacts.command("add [emails...]").description("Add contacts by email (prompt if no emails given)").action(
+    (emails) => runAction(async () => {
+      const { arbi } = await resolveAuth();
+      if (!emails || emails.length === 0) {
+        const input2 = await promptInput("Email address(es), comma-separated");
+        emails = input2.split(",").map((e) => e.trim()).filter(Boolean);
+        if (emails.length === 0) return;
+      }
+      const data = requireData(
+        await arbi.fetch.POST("/api/user/contacts", { body: { emails } }),
+        "Failed to add contacts"
+      );
+      for (const c of data) {
+        console.log(`Added: ${c.email} (${c.external_id}) \u2014 ${c.status}`);
+      }
+    })()
+  );
+  contacts.command("remove [ids...]").description("Remove contacts (interactive picker if no IDs given)").action(
+    (ids) => runAction(async () => {
+      const { arbi } = await resolveAuth();
+      let contactIds = ids && ids.length > 0 ? ids : void 0;
+      if (!contactIds) {
+        const data = requireData(
+          await arbi.fetch.GET("/api/user/contacts"),
+          "Failed to fetch contacts"
+        );
+        if (data.length === 0) {
+          console.log("No contacts found.");
+          return;
+        }
+        contactIds = await promptCheckbox(
+          "Select contacts to remove",
+          data.map((c) => {
+            const u = c.user;
+            const name = u ? [u.given_name, u.family_name].filter(Boolean).join(" ") : "";
+            return {
+              name: name ? `${name} (${c.email})` : c.email,
+              value: c.external_id
+            };
+          })
+        );
+        if (contactIds.length === 0) return;
+      }
+      requireOk(
+        await arbi.fetch.DELETE("/api/user/contacts", { body: { contact_ids: contactIds } }),
+        "Failed to remove contacts"
+      );
+      console.log(`Removed ${contactIds.length} contact(s).`);
+    })()
+  );
+  contacts.action(async () => {
+    await contacts.commands.find((c) => c.name() === "list").parseAsync([], { from: "user" });
+  });
+}
+
+// src/commands/dm.ts
+function registerDmCommand(program2) {
+  const dm = program2.command("dm").description("Direct messages");
+  dm.command("list").description("List all DMs and notifications").action(
+    runAction(async () => {
+      const { arbi } = await resolveAuth();
+      const data = requireData(
+        await arbi.fetch.GET("/api/notifications/"),
+        "Failed to fetch messages"
+      );
+      if (data.length === 0) {
+        console.log("No messages found.");
+        return;
+      }
+      printTable(
+        [
+          { header: "ID", width: 16, value: (r) => r.external_id },
+          { header: "TYPE", width: 18, value: (r) => r.type },
+          {
+            header: "FROM",
+            width: 22,
+            value: (r) => {
+              const s = r.sender;
+              if (!s) return "";
+              const name = [s.given_name, s.family_name].filter(Boolean).join(" ");
+              return name || s.email || "";
+            }
+          },
+          { header: "READ", width: 6, value: (r) => r.read ? "yes" : "no" },
+          { header: "CONTENT", width: 40, value: (r) => r.content ?? "" }
+        ],
+        data
+      );
+    })
+  );
+  dm.command("send [recipient] [content]").description("Send a DM (interactive if no args; recipient can be email or user ext_id)").action(
+    (recipient, content) => runAction(async () => {
+      const { arbi } = await resolveAuth();
+      if (!recipient) {
+        const contacts = requireData(
+          await arbi.fetch.GET("/api/user/contacts"),
+          "Failed to fetch contacts"
+        );
+        if (contacts.length === 0) {
+          console.error("No contacts found. Add contacts first: arbi contacts add <email>");
+          process.exit(1);
+        }
+        recipient = await promptSelect(
+          "Send to",
+          contacts.map((c) => {
+            const u = c.user;
+            const name = u ? [u.given_name, u.family_name].filter(Boolean).join(" ") : "";
+            return {
+              name: name ? `${name} (${c.email})` : c.email,
+              value: u?.external_id ?? c.external_id,
+              description: c.email
+            };
+          })
+        );
+      }
+      if (!content) {
+        content = await promptInput("Message");
+      }
+      let recipientExtId = recipient;
+      if (recipient.includes("@")) {
+        const contacts = requireData(
+          await arbi.fetch.GET("/api/user/contacts"),
+          "Failed to fetch contacts"
+        );
+        const match = contacts.find((c) => c.email === recipient);
+        if (!match) {
+          console.error(`No contact found with email: ${recipient}`);
+          console.error("Add them first: arbi contacts add " + recipient);
+          process.exit(1);
+        }
+        recipientExtId = match.user?.external_id ?? match.external_id;
+      }
+      const data = requireData(
+        await arbi.fetch.POST("/api/notifications/", {
+          body: { messages: [{ recipient_ext_id: recipientExtId, content }] }
+        }),
+        "Failed to send message"
+      );
+      for (const n of data) {
+        console.log(`Sent: ${n.external_id} \u2192 ${n.recipient.email}`);
+      }
+    })()
+  );
+  dm.command("read [ids...]").description("Mark messages as read (interactive picker if no IDs given)").action(
+    (ids) => runAction(async () => {
+      const { arbi } = await resolveAuth();
+      let msgIds = ids && ids.length > 0 ? ids : void 0;
+      if (!msgIds) {
+        const data2 = requireData(
+          await arbi.fetch.GET("/api/notifications/"),
+          "Failed to fetch messages"
+        );
+        const unread = data2.filter((m) => !m.read);
+        if (unread.length === 0) {
+          console.log("No unread messages.");
+          return;
+        }
+        msgIds = await promptCheckbox(
+          "Select messages to mark as read",
+          unread.map((m) => {
+            const s = m.sender;
+            const from = s ? [s.given_name, s.family_name].filter(Boolean).join(" ") || s.email || "" : "";
+            return {
+              name: `${from}: ${(m.content ?? "").slice(0, 50)}`,
+              value: m.external_id
+            };
+          })
+        );
+        if (msgIds.length === 0) return;
+      }
+      const data = requireData(
+        await arbi.fetch.PATCH("/api/notifications/", {
+          body: { updates: msgIds.map((id) => ({ external_id: id, read: true })) }
+        }),
+        "Failed to update messages"
+      );
+      console.log(`Marked ${data.length} message(s) as read.`);
+    })()
+  );
+  dm.command("delete [ids...]").description("Delete messages (interactive picker if no IDs given)").action(
+    (ids) => runAction(async () => {
+      const { arbi } = await resolveAuth();
+      let msgIds = ids && ids.length > 0 ? ids : void 0;
+      if (!msgIds) {
+        const data = requireData(
+          await arbi.fetch.GET("/api/notifications/"),
+          "Failed to fetch messages"
+        );
+        if (data.length === 0) {
+          console.log("No messages found.");
+          return;
+        }
+        msgIds = await promptCheckbox(
+          "Select messages to delete",
+          data.map((m) => {
+            const s = m.sender;
+            const from = s ? [s.given_name, s.family_name].filter(Boolean).join(" ") || s.email || "" : "";
+            return {
+              name: `${from}: ${(m.content ?? "").slice(0, 50)}`,
+              value: m.external_id
+            };
+          })
+        );
+        if (msgIds.length === 0) return;
+      }
+      requireOk(
+        await arbi.fetch.DELETE("/api/notifications/", { body: { external_ids: msgIds } }),
+        "Failed to delete messages"
+      );
+      console.log(`Deleted ${msgIds.length} message(s).`);
+    })()
+  );
+  dm.action(async () => {
+    await dm.commands.find((c) => c.name() === "list").parseAsync([], { from: "user" });
+  });
+}
+
+// src/commands/tags.ts
+async function fetchTagChoices(arbi, workspaceId) {
+  const data = requireData(
+    await arbi.fetch.GET("/api/workspace/{workspace_ext_id}/tags", {
+      params: { path: { workspace_ext_id: workspaceId } }
+    }),
+    "Failed to fetch tags"
+  );
+  if (data.length === 0) {
+    console.log("No tags found.");
+    process.exit(0);
+  }
+  return {
+    data,
+    choices: data.map((t) => ({
+      name: `${t.name} (${t.tag_type?.type ?? "unknown"}, ${t.doctag_count} docs)`,
+      value: t.external_id,
+      description: t.external_id
+    }))
+  };
+}
+function registerTagsCommand(program2) {
+  const tags = program2.command("tags").description("Manage tags");
+  tags.command("list").description("List tags in the active workspace").option("-w, --workspace <id>", "Workspace ID (defaults to selected workspace)").action(
+    (opts) => runAction(async () => {
+      const { arbi, workspaceId } = await resolveWorkspace(opts.workspace);
+      const data = requireData(
+        await arbi.fetch.GET("/api/workspace/{workspace_ext_id}/tags", {
+          params: { path: { workspace_ext_id: workspaceId } }
+        }),
+        "Failed to fetch tags"
+      );
+      if (data.length === 0) {
+        console.log("No tags found.");
+        return;
+      }
+      printTable(
+        [
+          { header: "ID", width: 24, value: (r) => r.external_id },
+          { header: "NAME", width: 24, value: (r) => r.name },
+          {
+            header: "TYPE",
+            width: 12,
+            value: (r) => r.tag_type?.type ?? ""
+          },
+          { header: "DOCS", width: 6, value: (r) => String(r.doctag_count) },
+          { header: "SHARED", width: 8, value: (r) => r.shared ? "yes" : "no" }
+        ],
+        data
+      );
+    })()
+  );
+  tags.command("create [name]").description("Create a new tag (interactive form if no name given)").option("-w, --workspace <id>", "Workspace ID (defaults to selected workspace)").option(
+    "-t, --type <type>",
+    "Tag type (checkbox, text, number, select, folder, search, date, assistant)",
+    "checkbox"
+  ).option("-i, --instruction <text>", "Tag instruction").option("--shared", "Make tag shared", false).action(
+    (name, opts) => runAction(async () => {
+      const { arbi, workspaceId } = await resolveWorkspace(opts.workspace);
+      const interactive = !name;
+      if (!name) {
+        name = await promptInput("Tag name");
+      }
+      const tagType = opts.type || await promptSelect("Tag type", [
+        { name: "Checkbox", value: "checkbox" },
+        { name: "Text", value: "text" },
+        { name: "Number", value: "number" },
+        { name: "Select", value: "select" },
+        { name: "Date", value: "date" },
+        { name: "Folder", value: "folder" },
+        { name: "Search", value: "search" },
+        { name: "Assistant", value: "assistant" }
+      ]);
+      const instruction = interactive ? opts.instruction ?? (await promptInput("Instruction (optional)", false) || null) : opts.instruction ?? null;
+      const shared = interactive ? opts.shared || await promptConfirm("Shared?", false) : opts.shared ?? false;
+      const data = requireData(
+        await arbi.fetch.POST("/api/tag/", {
+          body: {
+            name,
+            workspace_ext_id: workspaceId,
+            tag_type: { type: tagType, options: [] },
+            instruction,
+            shared
+          }
+        }),
+        "Failed to create tag"
+      );
+      console.log(`Created: ${data.name} (${data.external_id})`);
+    })()
+  );
+  tags.command("delete [id]").description("Delete a tag (interactive picker if no ID given)").action(
+    (id) => runAction(async () => {
+      const { arbi, workspaceId } = await resolveWorkspace();
+      if (!id) {
+        const { choices } = await fetchTagChoices(arbi, workspaceId);
+        id = await promptSelect("Select tag to delete", choices);
+      }
+      const data = requireData(
+        await arbi.fetch.DELETE("/api/tag/{tag_ext_id}", {
+          params: { path: { tag_ext_id: id } }
+        }),
+        "Failed to delete tag"
+      );
+      console.log(data?.detail ?? `Deleted tag ${id}`);
+    })()
+  );
+  tags.command("update [id] [json]").description("Update a tag (interactive picker + form if no args)").action(
+    (id, json) => runAction(async () => {
+      const { arbi, workspaceId } = await resolveWorkspace();
+      if (!id) {
+        const { choices } = await fetchTagChoices(arbi, workspaceId);
+        id = await promptSelect("Select tag to update", choices);
+      }
+      let body;
+      if (json) {
+        body = parseJsonArg(json, `arbi tags update tag-123 '{"name": "New Name"}'`);
+      } else {
+        const field = await promptSelect("Field to update", [
+          { name: "Name", value: "name" },
+          { name: "Instruction", value: "instruction" },
+          { name: "Shared", value: "shared" }
+        ]);
+        if (field === "shared") {
+          body = { shared: await promptConfirm("Shared?") };
+        } else {
+          body = { [field]: await promptInput(field.charAt(0).toUpperCase() + field.slice(1)) };
+        }
+      }
+      const data = requireData(
+        await arbi.fetch.PATCH("/api/tag/{tag_ext_id}", {
+          params: { path: { tag_ext_id: id } },
+          body
+        }),
+        "Failed to update tag"
+      );
+      console.log(`Updated: ${data.name} (${data.external_id})`);
+    })()
+  );
+  tags.action(async (_opts, cmd) => {
+    await cmd.commands.find((c) => c.name() === "list").parseAsync([], { from: "user" });
+  });
+}
+
+// src/commands/doctags.ts
+async function pickTag(arbi, workspaceId, message = "Select tag") {
+  const data = requireData(
+    await arbi.fetch.GET("/api/workspace/{workspace_ext_id}/tags", {
+      params: { path: { workspace_ext_id: workspaceId } }
+    }),
+    "Failed to fetch tags"
+  );
+  if (data.length === 0) {
+    console.log("No tags found.");
+    process.exit(0);
+  }
+  return promptSelect(
+    message,
+    data.map((t) => ({
+      name: `${t.name} (${t.tag_type?.type ?? ""})`,
+      value: t.external_id,
+      description: t.external_id
+    }))
+  );
+}
+async function pickDocs(arbi, workspaceId, message = "Select documents") {
+  const data = requireData(
+    await arbi.fetch.GET("/api/workspace/{workspace_ext_id}/documents", {
+      params: { path: { workspace_ext_id: workspaceId } }
+    }),
+    "Failed to fetch documents"
+  );
+  if (data.length === 0) {
+    console.log("No documents found.");
+    process.exit(0);
+  }
+  return promptCheckbox(
+    message,
+    data.map((d) => ({
+      name: `${d.file_name ?? "Unnamed"} (${d.status})`,
+      value: d.external_id
+    }))
+  );
+}
+function registerDoctagsCommand(program2) {
+  const doctags = program2.command("doctags").description("Manage document tags (doctags)");
+  doctags.command("create [tag-id] [doc-ids...]").description("Assign a tag to documents (interactive pickers if no args)").option("-n, --note <text>", "Note for the doctag").action(
+    (tagId, docIds, opts) => runAction(async () => {
+      const { arbi, workspaceId } = await resolveWorkspace();
+      if (!tagId) tagId = await pickTag(arbi, workspaceId, "Select tag to assign");
+      if (!docIds || docIds.length === 0)
+        docIds = await pickDocs(arbi, workspaceId, "Select documents to tag");
+      if (docIds.length === 0) return;
+      const data = requireData(
+        await arbi.fetch.POST("/api/document/doctag", {
+          body: { tag_ext_id: tagId, doc_ext_ids: docIds, note: opts?.note ?? null }
+        }),
+        "Failed to create doctags"
+      );
+      console.log(`Created ${data.length} doctag(s) for tag ${tagId}.`);
+    })()
+  );
+  doctags.command("delete [tag-id] [doc-ids...]").description("Remove a tag from documents (interactive pickers if no args)").action(
+    (tagId, docIds) => runAction(async () => {
+      const { arbi, workspaceId } = await resolveWorkspace();
+      if (!tagId) tagId = await pickTag(arbi, workspaceId, "Select tag to remove");
+      if (!docIds || docIds.length === 0)
+        docIds = await pickDocs(arbi, workspaceId, "Select documents to untag");
+      if (docIds.length === 0) return;
+      requireOk(
+        await arbi.fetch.DELETE("/api/document/doctag", {
+          body: { tag_ext_id: tagId, doc_ext_ids: docIds }
+        }),
+        "Failed to delete doctags"
+      );
+      console.log(`Removed tag ${tagId} from ${docIds.length} document(s).`);
+    })()
+  );
+  doctags.command("generate").description("AI-generate doctags (interactive pickers if no flags)").option("--tags <ids>", "Comma-separated tag IDs").option("--docs <ids>", "Comma-separated document IDs").action(
+    (opts) => runAction(async () => {
+      const { arbi, workspaceId } = await resolveWorkspace();
+      let tagIds;
+      if (opts.tags) {
+        tagIds = opts.tags.split(",").map((s) => s.trim());
+      } else {
+        const data2 = requireData(
+          await arbi.fetch.GET("/api/workspace/{workspace_ext_id}/tags", {
+            params: { path: { workspace_ext_id: workspaceId } }
+          }),
+          "Failed to fetch tags"
+        );
+        if (data2.length === 0) {
+          console.log("No tags found.");
+          return;
+        }
+        tagIds = await promptCheckbox(
+          "Select tags to generate",
+          data2.map((t) => ({
+            name: `${t.name} (${t.tag_type?.type ?? ""})`,
+            value: t.external_id
+          }))
+        );
+        if (tagIds.length === 0) return;
+      }
+      let docIds;
+      if (opts.docs) {
+        docIds = opts.docs.split(",").map((s) => s.trim());
+      } else {
+        docIds = await pickDocs(arbi, workspaceId, "Select documents for AI tagging");
+        if (docIds.length === 0) return;
+      }
+      const data = requireData(
+        await arbi.fetch.POST("/api/document/doctag/generate", {
+          body: { tag_ext_ids: tagIds, doc_ext_ids: docIds }
+        }),
+        "Failed to generate doctags"
+      );
+      console.log(
+        `Generating doctags for ${data.doc_ext_ids.length} doc(s) with ${data.tag_ext_ids.length} tag(s).`
+      );
+    })()
+  );
+}
+
+// src/commands/conversations.ts
+async function pickConversation(arbi, workspaceId, message = "Select conversation") {
+  const data = requireData(
+    await arbi.fetch.GET("/api/workspace/{workspace_ext_id}/conversations", {
+      params: { path: { workspace_ext_id: workspaceId } }
+    }),
+    "Failed to fetch conversations"
+  );
+  if (data.length === 0) {
+    console.log("No conversations found.");
+    process.exit(0);
+  }
+  return promptSelect(
+    message,
+    data.map((c) => ({
+      name: `${c.title ?? "Untitled"} (${c.message_count} msgs)`,
+      value: c.external_id,
+      description: c.external_id
+    }))
+  );
+}
+function registerConversationsCommand(program2) {
+  const conv = program2.command("conversations").description("Manage conversations");
+  conv.command("list").description("List conversations in the active workspace").option("-w, --workspace <id>", "Workspace ID (defaults to selected workspace)").action(
+    (opts) => runAction(async () => {
+      const { arbi, workspaceId } = await resolveWorkspace(opts.workspace);
+      const data = requireData(
+        await arbi.fetch.GET("/api/workspace/{workspace_ext_id}/conversations", {
+          params: { path: { workspace_ext_id: workspaceId } }
+        }),
+        "Failed to fetch conversations"
+      );
+      if (data.length === 0) {
+        console.log("No conversations found.");
+        return;
+      }
+      printTable(
+        [
+          { header: "ID", width: 24, value: (r) => r.external_id },
+          { header: "TITLE", width: 36, value: (r) => r.title ?? "Untitled" },
+          { header: "MSGS", width: 6, value: (r) => String(r.message_count) },
+          { header: "SHARED", width: 8, value: (r) => r.is_shared ? "yes" : "no" }
+        ],
+        data
+      );
+    })()
+  );
+  conv.command("threads [conversation-id]").description("Show threads (interactive picker if no ID given)").action(
+    (conversationId) => runAction(async () => {
+      const { arbi, workspaceId } = await resolveWorkspace();
+      if (!conversationId) conversationId = await pickConversation(arbi, workspaceId);
+      const data = requireData(
+        await arbi.fetch.GET("/api/conversation/{conversation_ext_id}/threads", {
+          params: { path: { conversation_ext_id: conversationId } }
+        }),
+        "Failed to fetch threads"
+      );
+      console.log(JSON.stringify(data, null, 2));
+    })()
+  );
+  conv.command("delete [conversation-id]").description("Delete a conversation (interactive picker if no ID given)").action(
+    (conversationId) => runAction(async () => {
+      const { arbi, workspaceId } = await resolveWorkspace();
+      if (!conversationId)
+        conversationId = await pickConversation(
+          arbi,
+          workspaceId,
+          "Select conversation to delete"
+        );
+      const data = requireData(
+        await arbi.fetch.DELETE("/api/conversation/{conversation_ext_id}", {
+          params: { path: { conversation_ext_id: conversationId } }
+        }),
+        "Failed to delete conversation"
+      );
+      console.log(data?.detail ?? `Deleted conversation ${conversationId}`);
+    })()
+  );
+  conv.command("share [conversation-id]").description("Share a conversation (interactive picker if no ID given)").action(
+    (conversationId) => runAction(async () => {
+      const { arbi, workspaceId } = await resolveWorkspace();
+      if (!conversationId)
+        conversationId = await pickConversation(arbi, workspaceId, "Select conversation to share");
+      const data = requireData(
+        await arbi.fetch.POST("/api/conversation/{conversation_ext_id}/share", {
+          params: { path: { conversation_ext_id: conversationId } }
+        }),
+        "Failed to share conversation"
+      );
+      console.log(data?.detail ?? `Shared conversation ${conversationId}`);
+    })()
+  );
+  conv.command("title [conversation-id] [title]").description("Update conversation title (interactive if no args)").action(
+    (conversationId, title) => runAction(async () => {
+      const { arbi, workspaceId } = await resolveWorkspace();
+      if (!conversationId) conversationId = await pickConversation(arbi, workspaceId);
+      if (!title) title = await promptInput("New title");
+      const data = requireData(
+        await arbi.fetch.PATCH("/api/conversation/{conversation_ext_id}/title", {
+          params: { path: { conversation_ext_id: conversationId } },
+          body: { title }
+        }),
+        "Failed to update title"
+      );
+      console.log(data?.detail ?? `Updated title to: ${title}`);
+    })()
+  );
+  conv.command("add-user [conversation-id] [user-id]").description("Add a user to a conversation (interactive if no args)").action(
+    (conversationId, userId) => runAction(async () => {
+      const { arbi, workspaceId } = await resolveWorkspace();
+      if (!conversationId) conversationId = await pickConversation(arbi, workspaceId);
+      if (!userId) userId = await promptInput("User ext_id or email");
+      const data = requireData(
+        await arbi.fetch.POST("/api/conversation/{conversation_ext_id}/user", {
+          params: { path: { conversation_ext_id: conversationId } },
+          body: { user_ext_id: userId }
+        }),
+        "Failed to add user to conversation"
+      );
+      console.log(data?.detail ?? `Added user ${userId} to conversation`);
+    })()
+  );
+  conv.command("remove-user [conversation-id] [user-id]").description("Remove a user from a conversation (interactive if no args)").action(
+    (conversationId, userId) => runAction(async () => {
+      const { arbi, workspaceId } = await resolveWorkspace();
+      if (!conversationId) conversationId = await pickConversation(arbi, workspaceId);
+      if (!userId) userId = await promptInput("User ext_id");
+      const data = requireData(
+        await arbi.fetch.DELETE("/api/conversation/{conversation_ext_id}/user", {
+          params: { path: { conversation_ext_id: conversationId } },
+          body: { user_ext_id: userId }
+        }),
+        "Failed to remove user from conversation"
+      );
+      console.log(data?.detail ?? `Removed user ${userId} from conversation`);
+    })()
+  );
+  conv.command("message <message-id>").description("Get message details").action(
+    (messageId) => runAction(async () => {
+      const { arbi } = await resolveWorkspace();
+      const data = requireData(
+        await arbi.fetch.GET("/api/conversation/message/{message_ext_id}", {
+          params: { path: { message_ext_id: messageId } }
+        }),
+        "Failed to fetch message"
+      );
+      console.log(JSON.stringify(data, null, 2));
+    })()
+  );
+  conv.command("delete-message <message-id>").description("Delete a message and its descendants").action(
+    (messageId) => runAction(async () => {
+      const { arbi } = await resolveAuth();
+      const data = requireData(
+        await arbi.fetch.DELETE("/api/conversation/message/{message_ext_id}", {
+          params: { path: { message_ext_id: messageId } }
+        }),
+        "Failed to delete message"
+      );
+      console.log(data?.detail ?? `Deleted message ${messageId}`);
+    })()
+  );
+  conv.action(async (_opts, cmd) => {
+    await cmd.commands.find((c) => c.name() === "list").parseAsync([], { from: "user" });
+  });
+}
+
+// src/commands/settings.ts
+function registerSettingsCommand(program2) {
+  const settings = program2.command("settings").description("Manage user settings");
+  settings.command("get").description("Show current user settings").action(
+    runAction(async () => {
+      const { arbi } = await resolveAuth();
+      const data = requireData(
+        await arbi.fetch.GET("/api/user/settings"),
+        "Failed to fetch settings"
+      );
+      console.log(JSON.stringify(data, null, 2));
+    })
+  );
+  settings.command("set <json>").description("Update user settings (pass JSON object)").action(
+    (json) => runAction(async () => {
+      const body = parseJsonArg(json, `arbi settings set '{"hide_online_status": true}'`);
+      const { arbi } = await resolveAuth();
+      requireOk(
+        await arbi.fetch.PATCH("/api/user/settings", { body }),
+        "Failed to update settings"
+      );
+      console.log("Settings updated.");
+    })()
+  );
+  settings.action(async () => {
+    await settings.commands.find((c) => c.name() === "get").parseAsync([], { from: "user" });
+  });
+}
+
+// src/commands/agentconfig.ts
+var MODEL_SECTIONS = [
+  "Agents",
+  "QueryLLM",
+  "EvaluatorLLM",
+  "TitleLLM",
+  "SummariseLLM",
+  "DoctagLLM",
+  "ArtifactLLM"
+];
+async function pickConfig(arbi, message = "Select configuration") {
+  const data = requireData(
+    await arbi.fetch.GET("/api/configs/versions"),
+    "Failed to fetch config versions"
+  );
+  if (data.versions.length === 0) {
+    console.log("No saved configurations found.");
+    process.exit(0);
+  }
+  return promptSelect(
+    message,
+    data.versions.map((v) => ({
+      name: `${v.title || "(untitled)"} \u2014 ${new Date(v.created_at).toLocaleString()}`,
+      value: v.external_id,
+      description: v.external_id
+    }))
+  );
+}
+async function fetchModels(arbi) {
+  const data = requireData(await arbi.fetch.GET("/api/health/models"), "Failed to fetch models");
+  return data.models.map((m) => ({
+    name: `${m.model_name} (${m.provider ?? m.api_type})`,
+    value: m.model_name,
+    description: m.api_type
+  }));
+}
+async function buildConfigInteractively(arbi) {
+  const body = {};
+  const title = await promptInput("Config title (optional)", false);
+  if (title) body.title = title;
+  const section = await promptSelect("Section to configure", [
+    { name: "Agents \u2014 main agent model, persona, tools", value: "Agents" },
+    { name: "QueryLLM \u2014 answer review model", value: "QueryLLM" },
+    { name: "EvaluatorLLM \u2014 chunk evaluation", value: "EvaluatorLLM" },
+    { name: "TitleLLM \u2014 title generation", value: "TitleLLM" },
+    { name: "SummariseLLM \u2014 conversation summariser", value: "SummariseLLM" },
+    { name: "DoctagLLM \u2014 AI document tagging", value: "DoctagLLM" },
+    { name: "ArtifactLLM \u2014 skill/memory synthesis", value: "ArtifactLLM" },
+    { name: "Retriever \u2014 search parameters", value: "Retriever" },
+    { name: "Reranker \u2014 reranking model", value: "Reranker" },
+    { name: "ModelCitation \u2014 citation thresholds", value: "ModelCitation" },
+    { name: "Chunker \u2014 chunk size", value: "Chunker" },
+    { name: "Embedder \u2014 embedding model", value: "Embedder" },
+    { name: "KeywordEmbedder \u2014 BM25 parameters", value: "KeywordEmbedder" }
+  ]);
+  const sectionConfig = {};
+  if (MODEL_SECTIONS.includes(section)) {
+    const models = await fetchModels(arbi);
+    if (models.length > 0) {
+      const changeModel = await promptConfirm("Change model?", true);
+      if (changeModel) {
+        const modelKey = section === "Agents" ? "AGENT_MODEL_NAME" : "MODEL_NAME";
+        sectionConfig[modelKey] = await promptSelect("Model", models);
+        if (section === "Agents") {
+          sectionConfig.AGENT_API_TYPE = "remote";
+        } else {
+          sectionConfig.API_TYPE = "remote";
+        }
+      }
+    }
+  }
+  if (section === "Agents") {
+    const field = await promptSelect("What else to change?", [
+      { name: "Nothing else", value: "done" },
+      { name: "Temperature", value: "LLM_AGENT_TEMPERATURE" },
+      { name: "Max tokens", value: "AGENT_MAX_TOKENS" },
+      { name: "Max iterations", value: "AGENT_MAX_ITERATIONS" },
+      { name: "Persona", value: "PERSONA" },
+      { name: "Web search enabled", value: "WEB_SEARCH" },
+      { name: "Human in the loop", value: "HUMAN_IN_THE_LOOP" }
+    ]);
+    if (field !== "done") {
+      if (field === "WEB_SEARCH" || field === "HUMAN_IN_THE_LOOP") {
+        sectionConfig[field] = await promptConfirm(field + "?");
+      } else if (field === "LLM_AGENT_TEMPERATURE") {
+        sectionConfig[field] = parseFloat(await promptInput("Temperature (0.0 - 2.0)"));
+      } else if (field === "AGENT_MAX_TOKENS" || field === "AGENT_MAX_ITERATIONS") {
+        sectionConfig[field] = parseInt(await promptInput(field), 10);
+      } else {
+        sectionConfig[field] = await promptInput(field);
+      }
+    }
+  } else if (section === "Retriever") {
+    const field = await promptSelect("Field to change", [
+      { name: "Search mode", value: "SEARCH_MODE" },
+      { name: "Min similarity score", value: "MIN_RETRIEVAL_SIM_SCORE" },
+      { name: "Max chunks to retrieve", value: "MAX_TOTAL_CHUNKS_TO_RETRIEVE" },
+      { name: "Max distinct documents", value: "MAX_DISTINCT_DOCUMENTS" },
+      { name: "Hybrid dense weight", value: "HYBRID_DENSE_WEIGHT" },
+      { name: "Hybrid sparse weight", value: "HYBRID_SPARSE_WEIGHT" }
+    ]);
+    if (field === "SEARCH_MODE") {
+      sectionConfig[field] = await promptSelect("Search mode", [
+        { name: "Semantic (dense)", value: "semantic" },
+        { name: "Keyword (sparse/BM25)", value: "keyword" },
+        { name: "Hybrid (dense + sparse)", value: "hybrid" }
+      ]);
+    } else {
+      sectionConfig[field] = parseFloat(await promptInput(field));
+    }
+  } else if (section === "ModelCitation") {
+    const field = await promptSelect("Field to change", [
+      { name: "Similarity threshold", value: "SIM_THREASHOLD" },
+      { name: "Min char size", value: "MIN_CHAR_SIZE_TO_ANSWER" },
+      { name: "Max citations", value: "MAX_NUMB_CITATIONS" }
+    ]);
+    sectionConfig[field] = parseFloat(await promptInput(field));
+  } else if (section === "Chunker") {
+    sectionConfig.MAX_CHUNK_TOKENS = parseInt(await promptInput("Max chunk tokens"), 10);
+  } else if (section === "Reranker") {
+    const field = await promptSelect("Field to change", [
+      { name: "Max chunks after rerank", value: "MAX_NUMB_OF_CHUNKS" },
+      { name: "Model", value: "MODEL_NAME" }
+    ]);
+    if (field === "MODEL_NAME") {
+      const models = await fetchModels(arbi);
+      sectionConfig.MODEL_NAME = await promptSelect("Model", models);
+      sectionConfig.API_TYPE = "remote";
+    } else {
+      sectionConfig[field] = parseInt(await promptInput(field), 10);
+    }
+  } else if (section === "QueryLLM" || section === "EvaluatorLLM" || section === "TitleLLM" || section === "SummariseLLM" || section === "DoctagLLM" || section === "ArtifactLLM") {
+    const field = await promptSelect("What else to change?", [
+      { name: "Nothing else", value: "done" },
+      { name: "Temperature", value: "TEMPERATURE" },
+      { name: "Max tokens", value: "MAX_TOKENS" }
+    ]);
+    if (field !== "done") {
+      sectionConfig[field] = field === "TEMPERATURE" ? parseFloat(await promptInput("Temperature (0.0 - 2.0)")) : parseInt(await promptInput("Max tokens"), 10);
+    }
+  }
+  if (Object.keys(sectionConfig).length > 0) {
+    body[section] = sectionConfig;
+  }
+  return body;
+}
+function registerAgentconfigCommand(program2) {
+  const ac = program2.command("agentconfig").description("Manage agent configurations");
+  ac.command("list").description("List saved configuration versions").action(
+    runAction(async () => {
+      const { arbi } = await resolveAuth();
+      const data = requireData(
+        await arbi.fetch.GET("/api/configs/versions"),
+        "Failed to fetch config versions"
+      );
+      if (data.versions.length === 0) {
+        console.log("No saved configurations.");
+        return;
+      }
+      printTable(
+        [
+          { header: "ID", width: 24, value: (r) => r.external_id },
+          { header: "TITLE", width: 30, value: (r) => r.title ?? "(untitled)" },
+          {
+            header: "CREATED",
+            width: 22,
+            value: (r) => new Date(r.created_at).toLocaleString()
+          }
+        ],
+        data.versions
+      );
+    })
+  );
+  ac.command("get [config-id]").description('Show configuration details (picker if no ID; use "default" for system defaults)').action(
+    (configId) => runAction(async () => {
+      const { arbi } = await resolveAuth();
+      if (!configId) {
+        configId = await promptSelect("Which configuration?", [
+          { name: "System defaults", value: "default", description: "Built-in defaults" },
+          { name: "Pick from saved versions...", value: "__pick__" }
+        ]);
+        if (configId === "__pick__") {
+          configId = await pickConfig(arbi);
+        }
+      }
+      const data = requireData(
+        await arbi.fetch.GET("/api/configs/{config_ext_id}", {
+          params: { path: { config_ext_id: configId } }
+        }),
+        "Failed to fetch configuration"
+      );
+      console.log(JSON.stringify(data, null, 2));
+    })()
+  );
+  ac.command("save [json]").description("Save a new configuration (interactive if no JSON given)").option("-t, --title <title>", "Config title").option("--tag <tag-ext-id>", "Associate with an assistant tag").option("--message <msg-ext-id>", "Associate with a parent message").action(
+    (json, opts) => runAction(async () => {
+      const { arbi } = await resolveAuth();
+      let body;
+      if (json) {
+        body = parseJsonArg(
+          json,
+          `arbi agentconfig save '{"Agents": {"AGENT_MODEL_NAME": "GPT4o@OpenAI"}, "title": "GPT-4o config"}'`
+        );
+        if (opts?.title) body.title = opts.title;
+      } else {
+        body = await buildConfigInteractively(arbi);
+      }
+      if (opts?.tag) body.tag_ext_id = opts.tag;
+      if (opts?.message) body.parent_message_ext_id = opts.message;
+      const data = requireData(
+        await arbi.fetch.POST("/api/configs/", { body }),
+        "Failed to save configuration"
+      );
+      console.log(`Saved: ${data.title || "(untitled)"} (${data.external_id})`);
+    })()
+  );
+  ac.command("delete [config-id]").description("Delete a configuration (picker if no ID)").action(
+    (configId) => runAction(async () => {
+      const { arbi } = await resolveAuth();
+      if (!configId) configId = await pickConfig(arbi, "Select configuration to delete");
+      const data = requireData(
+        await arbi.fetch.DELETE("/api/configs/{config_ext_id}", {
+          params: { path: { config_ext_id: configId } }
+        }),
+        "Failed to delete configuration"
+      );
+      console.log(data.detail);
+    })()
+  );
+  ac.command("schema").description("Show JSON schema for all configuration models").action(
+    runAction(async () => {
+      const { arbi } = await resolveAuth();
+      const data = requireData(
+        await arbi.fetch.GET("/api/configs/schema"),
+        "Failed to fetch config schema"
+      );
+      console.log(JSON.stringify(data, null, 2));
+    })
+  );
+  ac.action(async () => {
+    await ac.commands.find((c) => c.name() === "list").parseAsync([], { from: "user" });
+  });
+}
+
+// src/commands/health.ts
+function registerHealthCommand(program2) {
+  program2.command("health").description("Show server health status").action(
+    runAction(async () => {
+      const { arbi } = await resolveAuth();
+      const data = requireData(
+        await arbi.fetch.GET("/api/health/"),
+        "Failed to fetch health status"
+      );
+      console.log(`Status: ${data.status}`);
+      if (data.backend_git_hash) console.log(`Backend: ${data.backend_git_hash}`);
+      if (data.frontend_docker_version) console.log(`Frontend: ${data.frontend_docker_version}`);
+      if (data.services.length > 0) {
+        console.log("\nServices:");
+        for (const s of data.services) {
+          console.log(`  ${s.name}: ${s.status}${s.detail ? ` \u2014 ${s.detail}` : ""}`);
+        }
+      }
+      if (data.models_health) {
+        console.log(`
+Models (${data.models_health.application}):`);
+        for (const m of data.models_health.models) {
+          console.log(`  ${m.model}: ${m.status}${m.detail ? ` \u2014 ${m.detail}` : ""}`);
+        }
+      }
+    })
+  );
+  program2.command("models").description("List available AI models").action(
+    runAction(async () => {
+      const { arbi } = await resolveAuth();
+      const data = requireData(
+        await arbi.fetch.GET("/api/health/models"),
+        "Failed to fetch models"
+      );
+      if (data.models.length === 0) {
+        console.log("No models available.");
+        return;
+      }
+      printTable(
+        [
+          { header: "NAME", width: 30, value: (r) => r.model_name },
+          { header: "PROVIDER", width: 20, value: (r) => r.provider ?? "" },
+          { header: "API_TYPE", width: 16, value: (r) => r.api_type }
+        ],
+        data.models
+      );
+    })
+  );
+}
+
+// src/index.ts
+console.debug = () => {
+};
+var _origInfo = console.info;
+console.info = (...args) => {
+  if (typeof args[0] === "string" && args[0].startsWith("[API]")) return;
+  _origInfo(...args);
+};
+var program = new commander.Command();
+program.name("arbi").description("ARBI CLI \u2014 interact with ARBI from the terminal").version("0.1.0");
+registerConfigCommand(program);
+registerLoginCommand(program);
+registerRegisterCommand(program);
+registerLogoutCommand(program);
+registerStatusCommand(program);
+registerWorkspacesCommand(program);
+registerDocsCommand(program);
+registerUploadCommand(program);
+registerDownloadCommand(program);
+registerAskCommand(program);
+registerWatchCommand(program);
+registerContactsCommand(program);
+registerDmCommand(program);
+registerTagsCommand(program);
+registerDoctagsCommand(program);
+registerConversationsCommand(program);
+registerSettingsCommand(program);
+registerAgentconfigCommand(program);
+registerHealthCommand(program);
+program.parse();
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map