attio-cli 0.2.0 → 0.3.0

package/dist/attio.js

@@ -3,6 +3,9 @@
 // bin/attio.ts
 import { program } from "commander";
 import chalk7 from "chalk";
+import { readFileSync as readFileSync3 } from "fs";
+import { dirname, join as join2 } from "path";
+import { fileURLToPath } from "url";
 
 // src/errors.ts
 import chalk from "chalk";
@@ -57,7 +60,7 @@ var AttioRateLimitError = class extends Error {
 import chalk2 from "chalk";
 
 // src/config.ts
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, chmodSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
 import * as dotenv from "dotenv";
@@ -73,8 +76,16 @@ function loadConfig() {
   }
 }
 function saveConfig(config2) {
-  mkdirSync(CONFIG_DIR, { recursive: true });
-  writeFileSync(CONFIG_FILE, JSON.stringify(config2, null, 2));
+  mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  try {
+    chmodSync(CONFIG_DIR, 448);
+  } catch {
+  }
+  writeFileSync(CONFIG_FILE, JSON.stringify(config2, null, 2), { mode: 384 });
+  try {
+    chmodSync(CONFIG_FILE, 384);
+  } catch {
+  }
 }
 function resolveApiKey(flagValue) {
   return flagValue || process.env.ATTIO_API_KEY || loadConfig().apiKey || "";
@@ -96,6 +107,20 @@ var BASE_URL = "https://api.attio.com/v2";
 var MAX_RETRIES = 3;
 var INITIAL_BACKOFF_MS = 1e3;
 var DEFAULT_TIMEOUT_MS = 3e4;
+function getRetryDelayMs(response, attempt) {
+  const retryAfter = response.headers.get("retry-after");
+  if (retryAfter) {
+    const asSeconds = Number(retryAfter);
+    if (!Number.isNaN(asSeconds)) {
+      return Math.max(0, Math.ceil(asSeconds * 1e3));
+    }
+    const asDate = Date.parse(retryAfter);
+    if (!Number.isNaN(asDate)) {
+      return Math.max(0, asDate - Date.now());
+    }
+  }
+  return INITIAL_BACKOFF_MS * Math.pow(2, attempt);
+}
 var AttioClient = class {
   apiKey;
   debug;
@@ -141,7 +166,10 @@ var AttioClient = class {
       }
       if (response.status === 429) {
         if (attempt < MAX_RETRIES) {
-          const backoff = INITIAL_BACKOFF_MS * Math.pow(2, attempt);
+          const backoff = Math.max(100, getRetryDelayMs(response, attempt));
+          if (this.debug) {
+            console.error(chalk2.dim(`  retrying in ${backoff}ms`));
+          }
           await new Promise((resolve) => setTimeout(resolve, backoff));
           continue;
         }
@@ -193,6 +221,43 @@ var AttioClient = class {
 import chalk3 from "chalk";
 import Table from "cli-table3";
 import { createInterface } from "readline";
+var ID_KEY_PRIORITY = [
+  "record_id",
+  "entry_id",
+  "task_id",
+  "note_id",
+  "comment_id",
+  "thread_id",
+  "workspace_member_id",
+  "list_id",
+  "object_id",
+  "webhook_id",
+  "workspace_id"
+];
+function toIdString(value) {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "bigint") {
+    const id = String(value);
+    return id.length > 0 ? id : "";
+  }
+  return "";
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function extractOutputId(raw) {
+  const direct = toIdString(raw);
+  if (direct) return direct;
+  if (!isRecord(raw)) return "";
+  for (const key of ID_KEY_PRIORITY) {
+    const id = toIdString(raw[key]);
+    if (id) return id;
+  }
+  for (const value of Object.values(raw)) {
+    const fallback = toIdString(value);
+    if (fallback) return fallback;
+  }
+  return "";
+}
 function detectFormat(opts) {
   if (opts.quiet) return "quiet";
   if (opts.json) return "json";
@@ -205,8 +270,8 @@ function outputList(items, opts) {
   const idField = opts.idField || "id";
   if (format === "quiet") {
     for (const item of items) {
-      const raw = typeof item === "string" ? item : item[idField] || "";
-      const id = typeof raw === "object" && raw !== null ? Object.values(raw)[0] : raw;
+      const raw = typeof item === "string" ? item : item[idField] ?? "";
+      const id = extractOutputId(raw);
       if (id) console.log(id);
     }
     return;
@@ -245,8 +310,8 @@ function outputList(items, opts) {
 }
 function outputSingle(item, opts) {
   if (opts.format === "quiet") {
-    const raw = item[opts.idField || "id"] || "";
-    const id = typeof raw === "object" && raw !== null ? Object.values(raw)[0] : raw;
+    const raw = item[opts.idField || "id"] ?? "";
+    const id = extractOutputId(raw);
     console.log(id || "");
     return;
   }
@@ -443,6 +508,20 @@ function flattenRecord(record) {
   }
   return flat;
 }
+function stripWrappingQuotes(raw) {
+  if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
+    return raw.slice(1, -1);
+  }
+  return raw;
+}
+function parseScalar(raw) {
+  const normalized = stripWrappingQuotes(raw.trim());
+  if (normalized === "true") return true;
+  if (normalized === "false") return false;
+  if (normalized === "null") return null;
+  if (/^-?\d+(\.\d+)?$/.test(normalized)) return Number(normalized);
+  return normalized;
+}
 function parseSets(sets) {
   const values = {};
   for (const set of sets) {
@@ -450,23 +529,31 @@ function parseSets(sets) {
     if (eqIdx === -1) throw new Error(`Invalid --set format: "${set}". Expected: key=value`);
     const key = set.slice(0, eqIdx).trim();
     const raw = set.slice(eqIdx + 1).trim();
-    if (raw === "true") {
-      values[key] = true;
-      continue;
-    }
-    if (raw === "false") {
-      values[key] = false;
-      continue;
-    }
-    if (/^-?\d+(\.\d+)?$/.test(raw)) {
-      values[key] = Number(raw);
-      continue;
+    if (raw.startsWith("{") && raw.endsWith("}")) {
+      try {
+        values[key] = JSON.parse(raw);
+        continue;
+      } catch {
+      }
     }
     if (raw.startsWith("[") && raw.endsWith("]")) {
-      values[key] = raw.slice(1, -1).split(",").map((s) => s.trim());
+      try {
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed)) {
+          values[key] = parsed;
+          continue;
+        }
+      } catch {
+      }
+      const inner = raw.slice(1, -1).trim();
+      if (inner === "") {
+        values[key] = [];
+        continue;
+      }
+      values[key] = inner.split(",").map((s) => parseScalar(s));
       continue;
     }
-    values[key] = raw;
+    values[key] = parseScalar(raw);
   }
   return values;
 }
@@ -481,8 +568,8 @@ async function readStdin() {
 async function resolveValues(options) {
   if (options.values) {
     if (options.values.startsWith("@")) {
-      const { readFileSync: readFileSync2 } = await import("fs");
-      return JSON.parse(readFileSync2(options.values.slice(1), "utf-8"));
+      const { readFileSync: readFileSync4 } = await import("fs");
+      return JSON.parse(readFileSync4(options.values.slice(1), "utf-8"));
     }
     return JSON.parse(options.values);
   }
@@ -507,7 +594,7 @@ async function paginate(fetchPage, options) {
     return fetchPage(options.limit, options.offset);
   }
   const allResults = [];
-  let offset = 0;
+  let offset = options.offset;
   const pageSize = 500;
   while (true) {
     const page = await fetchPage(pageSize, offset);
@@ -523,6 +610,29 @@ async function paginate(fetchPage, options) {
 }
 
 // src/commands/records.ts
+function parseLimit(value, fallback) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+  return Math.floor(parsed);
+}
+function parseOffset(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0) return 0;
+  return Math.floor(parsed);
+}
+function flattenEntry(entry) {
+  const flat = {
+    id: entry.id?.entry_id || "",
+    list_id: entry.id?.list_id || "",
+    parent_record_id: entry.parent_record_id || entry.record_id || "",
+    created_at: entry.created_at?.slice(0, 10) || ""
+  };
+  const values = entry.entry_values || entry.values || {};
+  for (const [key, attrValues] of Object.entries(values)) {
+    flat[key] = flattenValue(attrValues);
+  }
+  return flat;
+}
 async function listRecords(object, cmdOpts) {
   const client = new AttioClient(cmdOpts.apiKey, cmdOpts.debug);
   const format = detectFormat(cmdOpts);
@@ -537,8 +647,8 @@ async function listRecords(object, cmdOpts) {
   if (cmdOpts.sort && cmdOpts.sort.length > 0) {
     sorts = cmdOpts.sort.map(parseSort);
   }
-  const limit = Number(cmdOpts.limit) || 25;
-  const offset = Number(cmdOpts.offset) || 0;
+  const limit = parseLimit(cmdOpts.limit, 25);
+  const offset = parseOffset(cmdOpts.offset);
   const all = cmdOpts.all ?? false;
   const fetchPage = async (pageLimit, pageOffset) => {
     const body = {};
@@ -554,8 +664,8 @@ async function listRecords(object, cmdOpts) {
   };
   const records = await paginate(fetchPage, { limit, offset, all });
   if (format === "quiet") {
-    for (const r of records) {
-      console.log(r.id?.record_id ?? "");
+    for (const record of records) {
+      console.log(record.id?.record_id ?? "");
     }
     return;
   }
@@ -636,12 +746,12 @@ async function deleteRecord(object, recordId, cmdOpts) {
   );
   console.error("Deleted.");
 }
-async function upsertRecord(object, cmdOpts) {
+async function assertRecord(object, cmdOpts) {
   const client = new AttioClient(cmdOpts.apiKey, cmdOpts.debug);
   const format = detectFormat(cmdOpts);
   const matchAttr = cmdOpts.match;
   if (!matchAttr) {
-    throw new Error("--match <attribute-slug> is required for upsert");
+    throw new Error("--match <attribute-slug> is required for assert");
   }
   const values = requireValues(await resolveValues(cmdOpts));
   const res = await client.put(
@@ -659,23 +769,32 @@ async function upsertRecord(object, cmdOpts) {
   }
   outputSingle(flattenRecord(record), { format });
 }
-async function searchRecords(object, query, cmdOpts) {
+async function searchRecords(query, cmdOpts, objectScope) {
   const client = new AttioClient(cmdOpts.apiKey, cmdOpts.debug);
   const format = detectFormat(cmdOpts);
-  const limit = Number(cmdOpts.limit) || 25;
+  const limit = parseLimit(cmdOpts.limit, 25);
+  const optionObjects = cmdOpts.object ?? [];
+  let objects = objectScope && objectScope.length > 0 ? objectScope : optionObjects;
+  if (objects.length === 0) {
+    const objectsRes = await client.get("/objects");
+    objects = objectsRes.data.map((obj) => obj.api_slug).filter((slug) => typeof slug === "string" && slug.length > 0);
+  }
+  if (objects.length === 0) {
+    throw new Error("No objects available for search.");
+  }
   const res = await client.post(
     "/objects/records/search",
     {
       query,
-      objects: [object],
+      objects,
       request_as: { type: "workspace" },
       limit
     }
   );
   const records = res.data;
   if (format === "quiet") {
-    for (const r of records) {
-      console.log(r.id?.record_id ?? "");
+    for (const record of records) {
+      console.log(record.id?.record_id ?? "");
     }
     return;
   }
@@ -686,6 +805,87 @@ async function searchRecords(object, query, cmdOpts) {
   const flat = records.map(flattenRecord);
   outputList(flat, { format });
 }
+async function listRecordValues(object, recordId, cmdOpts) {
+  const client = new AttioClient(cmdOpts.apiKey, cmdOpts.debug);
+  const format = detectFormat(cmdOpts);
+  const requestedAttributes = cmdOpts.attribute ? [cmdOpts.attribute] : cmdOpts.attributes ?? [];
+  let attributes = requestedAttributes;
+  if (attributes.length === 0) {
+    const attrRes = await client.get(
+      `/objects/${encodeURIComponent(object)}/attributes`
+    );
+    attributes = attrRes.data.map((attr) => attr.api_slug).filter((slug) => typeof slug === "string" && slug.length > 0);
+  }
+  const showHistoric = cmdOpts.historic !== false;
+  const limit = parseLimit(cmdOpts.limit, 25);
+  const offset = parseOffset(cmdOpts.offset);
+  const all = cmdOpts.all ?? false;
+  const allValues = [];
+  for (const attribute of attributes) {
+    const fetchPage = async (pageLimit, pageOffset) => {
+      const params = new URLSearchParams();
+      params.set("show_historic", showHistoric ? "true" : "false");
+      params.set("limit", String(pageLimit));
+      params.set("offset", String(pageOffset));
+      const res = await client.get(
+        `/objects/${encodeURIComponent(object)}/records/${encodeURIComponent(recordId)}/attributes/${encodeURIComponent(attribute)}/values?${params.toString()}`
+      );
+      return res.data;
+    };
+    const attributeValues = await paginate(fetchPage, { limit, offset, all });
+    for (const value of attributeValues) {
+      allValues.push({ attribute, ...value });
+    }
+  }
+  if (format === "json") {
+    outputList(allValues, { format });
+    return;
+  }
+  const flat = allValues.map((value) => ({
+    attribute: value.attribute,
+    value: flattenValue([value]),
+    active_from: value.active_from || "",
+    active_until: value.active_until || "",
+    created_by_type: value.created_by_actor?.type || "",
+    created_by_id: value.created_by_actor?.id || ""
+  }));
+  outputList(flat, {
+    format,
+    columns: ["attribute", "value", "active_from", "active_until", "created_by_type", "created_by_id"],
+    idField: "attribute"
+  });
+}
+async function listRecordEntries(object, recordId, cmdOpts) {
+  const client = new AttioClient(cmdOpts.apiKey, cmdOpts.debug);
+  const format = detectFormat(cmdOpts);
+  const limit = parseLimit(cmdOpts.limit, 25);
+  const offset = parseOffset(cmdOpts.offset);
+  const all = cmdOpts.all ?? false;
+  const entries = await paginate(
+    async (pageLimit, pageOffset) => {
+      const params = new URLSearchParams();
+      params.set("limit", String(pageLimit));
+      params.set("offset", String(pageOffset));
+      const res = await client.get(
+        `/objects/${encodeURIComponent(object)}/records/${encodeURIComponent(recordId)}/entries?${params.toString()}`
+      );
+      return res.data;
+    },
+    { limit, offset, all }
+  );
+  if (format === "quiet") {
+    for (const entry of entries) {
+      console.log(entry.id?.entry_id ?? "");
+    }
+    return;
+  }
+  if (format === "json") {
+    outputList(entries, { format, idField: "id" });
+    return;
+  }
+  const flat = entries.map(flattenEntry);
+  outputList(flat, { format, idField: "id" });
+}
 function register4(program2) {
   const records = program2.command("records").description("Manage records in any Attio object");
   records.command("list").description("List or query records for an object").argument("<object>", "Object slug or ID (e.g. companies, people)").option(
@@ -699,12 +899,10 @@ function register4(program2) {
     (val, prev) => [...prev, val],
     []
   ).option("--limit <n>", "Maximum records to return", "25").option("--offset <n>", "Number of records to skip", "0").option("--all", "Auto-paginate to fetch all records").action(async (object, _opts, cmd) => {
-    const opts = cmd.optsWithGlobals();
-    await listRecords(object, opts);
+    await listRecords(object, cmd.optsWithGlobals());
   });
   records.command("get").description("Get a single record by ID").argument("<object>", "Object slug or ID").argument("<record-id>", "Record ID").action(async (object, recordId, _opts, cmd) => {
-    const opts = cmd.optsWithGlobals();
-    await getRecord(object, recordId, opts);
+    await getRecord(object, recordId, cmd.optsWithGlobals());
   });
   records.command("create").description("Create a new record").argument("<object>", "Object slug or ID").option("--values <json>", "JSON string or @file of attribute values").option(
     "--set <key=value>",
@@ -712,8 +910,7 @@ function register4(program2) {
     (val, prev) => [...prev, val],
     []
   ).action(async (object, _opts, cmd) => {
-    const opts = cmd.optsWithGlobals();
-    await createRecord(object, opts);
+    await createRecord(object, cmd.optsWithGlobals());
   });
   records.command("update").description("Update an existing record").argument("<object>", "Object slug or ID").argument("<record-id>", "Record ID").option("--values <json>", "JSON string or @file of attribute values").option(
     "--set <key=value>",
@@ -721,76 +918,175 @@ function register4(program2) {
     (val, prev) => [...prev, val],
     []
   ).action(async (object, recordId, _opts, cmd) => {
-    const opts = cmd.optsWithGlobals();
-    await updateRecord(object, recordId, opts);
+    await updateRecord(object, recordId, cmd.optsWithGlobals());
   });
   records.command("delete").description("Delete a record").argument("<object>", "Object slug or ID").argument("<record-id>", "Record ID").option("-y, --yes", "Skip confirmation prompt").action(async (object, recordId, _opts, cmd) => {
-    const opts = cmd.optsWithGlobals();
-    await deleteRecord(object, recordId, opts);
+    await deleteRecord(object, recordId, cmd.optsWithGlobals());
   });
-  records.command("upsert").description("Create or update a record by matching attribute").argument("<object>", "Object slug or ID").requiredOption("--match <attribute-slug>", "Attribute slug to match on (required)").option("--values <json>", "JSON string or @file of attribute values").option(
+  records.command("assert").description("Create or update a record by matching attribute").argument("<object>", "Object slug or ID").requiredOption("--match <attribute-slug>", "Attribute slug to match on (required)").option("--values <json>", "JSON string or @file of attribute values").option(
     "--set <key=value>",
     "Set an attribute value (repeatable)",
     (val, prev) => [...prev, val],
     []
   ).action(async (object, _opts, cmd) => {
-    const opts = cmd.optsWithGlobals();
-    await upsertRecord(object, opts);
+    await assertRecord(object, cmd.optsWithGlobals());
+  });
+  records.command("upsert").description("Alias for records assert").argument("<object>", "Object slug or ID").requiredOption("--match <attribute-slug>", "Attribute slug to match on (required)").option("--values <json>", "JSON string or @file of attribute values").option(
+    "--set <key=value>",
+    "Set an attribute value (repeatable)",
+    (val, prev) => [...prev, val],
+    []
+  ).action(async (object, _opts, cmd) => {
+    await assertRecord(object, cmd.optsWithGlobals());
+  });
+  records.command("search").description("Search records across one or more objects").argument("<query>", "Search query string").option(
+    "--object <object>",
+    "Object slug or ID to scope search (repeatable). Defaults to all objects",
+    (val, prev) => [...prev, val],
+    []
+  ).option("--limit <n>", "Maximum results to return", "25").action(async (query, _opts, cmd) => {
+    await searchRecords(query, cmd.optsWithGlobals());
+  });
+  records.command("values").description("List current and historic attribute values for a record").argument("<object>", "Object slug or ID").argument("<record-id>", "Record ID").option("--attribute <attribute>", "Only include a single attribute slug").option("--limit <n>", "Max values per page", "25").option("--offset <n>", "Starting offset", "0").option("--all", "Fetch all pages").option("--no-historic", "Exclude historic values and show active values only").action(async (object, recordId, _opts, cmd) => {
+    await listRecordValues(object, recordId, cmd.optsWithGlobals());
   });
-  records.command("search").description("Full-text search for records within an object").argument("<object>", "Object slug or ID (e.g. companies, people)").argument("<query>", "Search query string").option("--limit <n>", "Maximum results to return", "25").action(async (object, query, _opts, cmd) => {
-    const opts = cmd.optsWithGlobals();
-    await searchRecords(object, query, opts);
+  records.command("entries").description("List list entries where this record is the parent").argument("<object>", "Object slug or ID").argument("<record-id>", "Record ID").option("--limit <n>", "Max entries per page", "25").option("--offset <n>", "Starting offset", "0").option("--all", "Fetch all pages").action(async (object, recordId, _opts, cmd) => {
+    await listRecordEntries(object, recordId, cmd.optsWithGlobals());
   });
 }
 
 // src/commands/people.ts
 function register5(program2) {
   const cmd = program2.command("people").description("Manage people records (shortcut for: records <cmd> people)");
-  cmd.command("list").description("List people").option("--filter <expr>", 'Filter: = != ~ !~ ^ > >= < <= ? (e.g. "name~Acme"). Repeatable', (v, p) => [...p, v], []).option("--filter-json <json>", "Raw JSON filter").option("--sort <expr>", "Sort expression (repeatable)", (v, p) => [...p, v], []).option("--limit <n>", "Max results per page", "25").option("--offset <n>", "Starting offset", "0").option("--all", "Fetch all pages").action(async (options, command) => {
+  cmd.command("list").description("List people").option("--filter <expr>", 'Filter: = != ~ !~ ^ > >= < <= ? (e.g. "name~Acme"). Repeatable', (v, p) => [...p, v], []).option("--filter-json <json>", "Raw JSON filter").option("--sort <expr>", "Sort expression (repeatable)", (v, p) => [...p, v], []).option("--limit <n>", "Max results per page", "25").option("--offset <n>", "Starting offset", "0").option("--all", "Fetch all pages").action(async (_options, command) => {
     await listRecords("people", command.optsWithGlobals());
   });
-  cmd.command("get <record-id>").description("Get a person by record ID").action(async (recordId, options, command) => {
+  cmd.command("get <record-id>").description("Get a person by record ID").action(async (recordId, _options, command) => {
     await getRecord("people", recordId, command.optsWithGlobals());
   });
-  cmd.command("create").description("Create a person").option("--values <json>", "Values as JSON string or @file").option("--set <key=value>", "Set a field value (repeatable)", (v, p) => [...p, v], []).action(async (options, command) => {
+  cmd.command("create").description("Create a person").option("--values <json>", "Values as JSON string or @file").option("--set <key=value>", "Set a field value (repeatable)", (v, p) => [...p, v], []).action(async (_options, command) => {
     await createRecord("people", command.optsWithGlobals());
   });
-  cmd.command("update <record-id>").description("Update a person").option("--values <json>", "Values as JSON string or @file").option("--set <key=value>", "Set a field value (repeatable)", (v, p) => [...p, v], []).action(async (recordId, options, command) => {
+  cmd.command("update <record-id>").description("Update a person").option("--values <json>", "Values as JSON string or @file").option("--set <key=value>", "Set a field value (repeatable)", (v, p) => [...p, v], []).action(async (recordId, _options, command) => {
     await updateRecord("people", recordId, command.optsWithGlobals());
   });
-  cmd.command("delete <record-id>").description("Delete a person").option("-y, --yes", "Skip confirmation").action(async (recordId, options, command) => {
+  cmd.command("delete <record-id>").description("Delete a person").option("-y, --yes", "Skip confirmation").action(async (recordId, _options, command) => {
     await deleteRecord("people", recordId, command.optsWithGlobals());
   });
-  cmd.command("search <query>").description("Search people by name or email").option("--limit <n>", "Maximum results", "25").action(async (query, options, command) => {
-    await searchRecords("people", query, command.optsWithGlobals());
+  cmd.command("assert").description("Create or update a person by matching attribute").requiredOption("--match <attribute-slug>", "Attribute slug to match on (required)").option("--values <json>", "Values as JSON string or @file").option("--set <key=value>", "Set a field value (repeatable)", (v, p) => [...p, v], []).action(async (_options, command) => {
+    await assertRecord("people", command.optsWithGlobals());
+  });
+  cmd.command("search <query>").description("Search people by name or email").option("--limit <n>", "Maximum results", "25").action(async (query, _options, command) => {
+    await searchRecords(query, command.optsWithGlobals(), ["people"]);
   });
 }
 
 // src/commands/companies.ts
 function register6(program2) {
   const cmd = program2.command("companies").description("Manage company records (shortcut for: records <cmd> companies)");
-  cmd.command("list").description("List companies").option("--filter <expr>", 'Filter: = != ~ !~ ^ > >= < <= ? (e.g. "name~Acme"). Repeatable', (v, p) => [...p, v], []).option("--filter-json <json>", "Raw JSON filter").option("--sort <expr>", "Sort expression (repeatable)", (v, p) => [...p, v], []).option("--limit <n>", "Max results per page", "25").option("--offset <n>", "Starting offset", "0").option("--all", "Fetch all pages").action(async (options, command) => {
+  cmd.command("list").description("List companies").option("--filter <expr>", 'Filter: = != ~ !~ ^ > >= < <= ? (e.g. "name~Acme"). Repeatable', (v, p) => [...p, v], []).option("--filter-json <json>", "Raw JSON filter").option("--sort <expr>", "Sort expression (repeatable)", (v, p) => [...p, v], []).option("--limit <n>", "Max results per page", "25").option("--offset <n>", "Starting offset", "0").option("--all", "Fetch all pages").action(async (_options, command) => {
     await listRecords("companies", command.optsWithGlobals());
   });
-  cmd.command("get <record-id>").description("Get a company by record ID").action(async (recordId, options, command) => {
+  cmd.command("get <record-id>").description("Get a company by record ID").action(async (recordId, _options, command) => {
     await getRecord("companies", recordId, command.optsWithGlobals());
   });
-  cmd.command("create").description("Create a company").option("--values <json>", "Values as JSON string or @file").option("--set <key=value>", "Set a field value (repeatable)", (v, p) => [...p, v], []).action(async (options, command) => {
+  cmd.command("create").description("Create a company").option("--values <json>", "Values as JSON string or @file").option("--set <key=value>", "Set a field value (repeatable)", (v, p) => [...p, v], []).action(async (_options, command) => {
     await createRecord("companies", command.optsWithGlobals());
   });
-  cmd.command("update <record-id>").description("Update a company").option("--values <json>", "Values as JSON string or @file").option("--set <key=value>", "Set a field value (repeatable)", (v, p) => [...p, v], []).action(async (recordId, options, command) => {
+  cmd.command("update <record-id>").description("Update a company").option("--values <json>", "Values as JSON string or @file").option("--set <key=value>", "Set a field value (repeatable)", (v, p) => [...p, v], []).action(async (recordId, _options, command) => {
     await updateRecord("companies", recordId, command.optsWithGlobals());
   });
-  cmd.command("delete <record-id>").description("Delete a company").option("-y, --yes", "Skip confirmation").action(async (recordId, options, command) => {
+  cmd.command("delete <record-id>").description("Delete a company").option("-y, --yes", "Skip confirmation").action(async (recordId, _options, command) => {
     await deleteRecord("companies", recordId, command.optsWithGlobals());
   });
-  cmd.command("search <query>").description("Search companies by name or domain").option("--limit <n>", "Maximum results", "25").action(async (query, options, command) => {
-    await searchRecords("companies", query, command.optsWithGlobals());
+  cmd.command("assert").description("Create or update a company by matching attribute").requiredOption("--match <attribute-slug>", "Attribute slug to match on (required)").option("--values <json>", "Values as JSON string or @file").option("--set <key=value>", "Set a field value (repeatable)", (v, p) => [...p, v], []).action(async (_options, command) => {
+    await assertRecord("companies", command.optsWithGlobals());
+  });
+  cmd.command("search <query>").description("Search companies by name or domain").option("--limit <n>", "Maximum results", "25").action(async (query, _options, command) => {
+    await searchRecords(query, command.optsWithGlobals(), ["companies"]);
   });
 }
 
-// src/commands/lists.ts
+// src/commands/deals.ts
 function register7(program2) {
+  const cmd = program2.command("deals").description("Manage deal records (shortcut for: records <cmd> deals)");
+  cmd.command("list").description("List deals").option("--filter <expr>", "Filter: = != ~ !~ ^ > >= < <= ? (repeatable)", (v, p) => [...p, v], []).option("--filter-json <json>", "Raw JSON filter").option("--sort <expr>", "Sort expression (repeatable)", (v, p) => [...p, v], []).option("--limit <n>", "Max results per page", "25").option("--offset <n>", "Starting offset", "0").option("--all", "Fetch all pages").action(async (_options, command) => {
+    await listRecords("deals", command.optsWithGlobals());
+  });
+  cmd.command("get <record-id>").description("Get a deal by record ID").action(async (recordId, _options, command) => {
+    await getRecord("deals", recordId, command.optsWithGlobals());
+  });
+  cmd.command("create").description("Create a deal").option("--values <json>", "Values as JSON string or @file").option("--set <key=value>", "Set a field value (repeatable)", (v, p) => [...p, v], []).action(async (_options, command) => {
+    await createRecord("deals", command.optsWithGlobals());
+  });
+  cmd.command("update <record-id>").description("Update a deal").option("--values <json>", "Values as JSON string or @file").option("--set <key=value>", "Set a field value (repeatable)", (v, p) => [...p, v], []).action(async (recordId, _options, command) => {
+    await updateRecord("deals", recordId, command.optsWithGlobals());
+  });
+  cmd.command("delete <record-id>").description("Delete a deal").option("-y, --yes", "Skip confirmation").action(async (recordId, _options, command) => {
+    await deleteRecord("deals", recordId, command.optsWithGlobals());
+  });
+  cmd.command("assert").description("Create or update a deal by matching attribute").requiredOption("--match <attribute-slug>", "Attribute slug to match on (required)").option("--values <json>", "Values as JSON string or @file").option("--set <key=value>", "Set a field value (repeatable)", (v, p) => [...p, v], []).action(async (_options, command) => {
+    await assertRecord("deals", command.optsWithGlobals());
+  });
+  cmd.command("search <query>").description("Search deals").option("--limit <n>", "Maximum results", "25").action(async (query, _options, command) => {
+    await searchRecords(query, command.optsWithGlobals(), ["deals"]);
+  });
+}
+
+// src/commands/users.ts
+function register8(program2) {
+  const cmd = program2.command("users").description("Manage user records (shortcut for: records <cmd> users)");
+  cmd.command("list").description("List users").option("--filter <expr>", "Filter: = != ~ !~ ^ > >= < <= ? (repeatable)", (v, p) => [...p, v], []).option("--filter-json <json>", "Raw JSON filter").option("--sort <expr>", "Sort expression (repeatable)", (v, p) => [...p, v], []).option("--limit <n>", "Max results per page", "25").option("--offset <n>", "Starting offset", "0").option("--all", "Fetch all pages").action(async (_options, command) => {
+    await listRecords("users", command.optsWithGlobals());
+  });
+  cmd.command("get <record-id>").description("Get a user by record ID").action(async (recordId, _options, command) => {
+    await getRecord("users", recordId, command.optsWithGlobals());
+  });
+  cmd.command("create").description("Create a user").option("--values <json>", "Values as JSON string or @file").option("--set <key=value>", "Set a field value (repeatable)", (v, p) => [...p, v], []).action(async (_options, command) => {
+    await createRecord("users", command.optsWithGlobals());
+  });
+  cmd.command("update <record-id>").description("Update a user").option("--values <json>", "Values as JSON string or @file").option("--set <key=value>", "Set a field value (repeatable)", (v, p) => [...p, v], []).action(async (recordId, _options, command) => {
+    await updateRecord("users", recordId, command.optsWithGlobals());
+  });
+  cmd.command("delete <record-id>").description("Delete a user").option("-y, --yes", "Skip confirmation").action(async (recordId, _options, command) => {
+    await deleteRecord("users", recordId, command.optsWithGlobals());
+  });
+  cmd.command("assert").description("Create or update a user by matching attribute").requiredOption("--match <attribute-slug>", "Attribute slug to match on (required)").option("--values <json>", "Values as JSON string or @file").option("--set <key=value>", "Set a field value (repeatable)", (v, p) => [...p, v], []).action(async (_options, command) => {
+    await assertRecord("users", command.optsWithGlobals());
+  });
+  cmd.command("search <query>").description("Search users").option("--limit <n>", "Maximum results", "25").action(async (query, _options, command) => {
+    await searchRecords(query, command.optsWithGlobals(), ["users"]);
+  });
+}
+
+// src/commands/workspaces.ts
+function register9(program2) {
+  const cmd = program2.command("workspaces").description("Manage workspace records (shortcut for: records <cmd> workspaces)");
+  cmd.command("list").description("List workspaces").option("--filter <expr>", "Filter: = != ~ !~ ^ > >= < <= ? (repeatable)", (v, p) => [...p, v], []).option("--filter-json <json>", "Raw JSON filter").option("--sort <expr>", "Sort expression (repeatable)", (v, p) => [...p, v], []).option("--limit <n>", "Max results per page", "25").option("--offset <n>", "Starting offset", "0").option("--all", "Fetch all pages").action(async (_options, command) => {
+    await listRecords("workspaces", command.optsWithGlobals());
+  });
+  cmd.command("get <record-id>").description("Get a workspace by record ID").action(async (recordId, _options, command) => {
+    await getRecord("workspaces", recordId, command.optsWithGlobals());
+  });
+  cmd.command("create").description("Create a workspace").option("--values <json>", "Values as JSON string or @file").option("--set <key=value>", "Set a field value (repeatable)", (v, p) => [...p, v], []).action(async (_options, command) => {
+    await createRecord("workspaces", command.optsWithGlobals());
+  });
+  cmd.command("update <record-id>").description("Update a workspace").option("--values <json>", "Values as JSON string or @file").option("--set <key=value>", "Set a field value (repeatable)", (v, p) => [...p, v], []).action(async (recordId, _options, command) => {
+    await updateRecord("workspaces", recordId, command.optsWithGlobals());
+  });
+  cmd.command("delete <record-id>").description("Delete a workspace").option("-y, --yes", "Skip confirmation").action(async (recordId, _options, command) => {
+    await deleteRecord("workspaces", recordId, command.optsWithGlobals());
+  });
+  cmd.command("assert").description("Create or update a workspace by matching attribute").requiredOption("--match <attribute-slug>", "Attribute slug to match on (required)").option("--values <json>", "Values as JSON string or @file").option("--set <key=value>", "Set a field value (repeatable)", (v, p) => [...p, v], []).action(async (_options, command) => {
+    await assertRecord("workspaces", command.optsWithGlobals());
+  });
+  cmd.command("search <query>").description("Search workspaces").option("--limit <n>", "Maximum results", "25").action(async (query, _options, command) => {
+    await searchRecords(query, command.optsWithGlobals(), ["workspaces"]);
+  });
+}
+
+// src/commands/lists.ts
+function register10(program2) {
   const cmd = program2.command("lists").description("Manage lists");
   cmd.command("list").description("List all lists").action(async (_options, command) => {
     const opts = command.optsWithGlobals();
@@ -844,7 +1140,7 @@ function register7(program2) {
 }
 
 // src/commands/entries.ts
-function flattenEntry(entry) {
+function flattenEntry2(entry) {
   const flat = {
     id: entry.id?.entry_id || "",
     record_id: entry.record_id || entry.parent_record_id || "",
@@ -855,7 +1151,7 @@ function flattenEntry(entry) {
   }
   return flat;
 }
-function register8(program2) {
+function register11(program2) {
   const cmd = program2.command("entries").description("Manage list entries");
   cmd.command("list <list>").description("List entries in a list").option("--filter <expr>", 'Filter: = != ~ !~ ^ > >= < <= ? (e.g. "name~Acme"). Repeatable', (v, p) => [...p, v], []).option("--filter-json <json>", "Raw JSON filter").option("--sort <expr>", "Sort expression (repeatable)", (v, p) => [...p, v], []).option("--limit <n>", "Max results per page", "25").option("--offset <n>", "Starting offset", "0").option("--all", "Fetch all pages").action(async (list, _options, command) => {
     const opts = command.optsWithGlobals();
@@ -885,7 +1181,7 @@ function register8(program2) {
       outputList(entries, { format, idField: "id" });
       return;
     }
-    const flat = entries.map(flattenEntry);
+    const flat = entries.map(flattenEntry2);
     outputList(flat, { format, idField: "id" });
   });
   cmd.command("get <list> <entry-id>").description("Get an entry by ID").action(async (list, entryId, _options, command) => {
@@ -898,7 +1194,7 @@ function register8(program2) {
       outputSingle(entry, { format, idField: "id" });
       return;
     }
-    const flat = flattenEntry(entry);
+    const flat = flattenEntry2(entry);
     outputSingle(flat, { format, idField: "id" });
   });
   cmd.command("create <list>").description("Create a new entry in a list").requiredOption("--record <record-id>", "Parent record ID (required)").requiredOption("--object <parent-object>", "Parent object slug (required)").option("--values <json>", "Entry values as JSON string or @file").option("--set <key=value>", "Set a field value (repeatable)", (v, p) => [...p, v], []).action(async (list, _options, command) => {
@@ -919,7 +1215,28 @@ function register8(program2) {
       outputSingle(entry, { format, idField: "id" });
       return;
     }
-    const flat = flattenEntry(entry);
+    const flat = flattenEntry2(entry);
+    outputSingle(flat, { format, idField: "id" });
+  });
+  cmd.command("assert <list>").description("Create or update a list entry by parent record").requiredOption("--record <record-id>", "Parent record ID (required)").requiredOption("--object <parent-object>", "Parent object slug (required)").option("--values <json>", "Entry values as JSON string or @file").option("--set <key=value>", "Set a field value (repeatable)", (v, p) => [...p, v], []).action(async (list, _options, command) => {
+    const opts = command.optsWithGlobals();
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    const format = detectFormat(opts);
+    const resolvedValues = requireValues(await resolveValues({ values: opts.values, set: opts.set }));
+    const body = {
+      data: {
+        parent_record_id: opts.record,
+        parent_object: opts.object,
+        entry_values: resolvedValues
+      }
+    };
+    const res = await client.put(`/lists/${list}/entries`, body);
+    const entry = res.data;
+    if (format === "json") {
+      outputSingle(entry, { format, idField: "id" });
+      return;
+    }
+    const flat = flattenEntry2(entry);
     outputSingle(flat, { format, idField: "id" });
   });
   cmd.command("update <list> <entry-id>").description("Update an entry").option("--values <json>", "Entry values as JSON string or @file").option("--set <key=value>", "Set a field value (repeatable)", (v, p) => [...p, v], []).action(async (list, entryId, _options, command) => {
@@ -938,7 +1255,7 @@ function register8(program2) {
       outputSingle(entry, { format, idField: "id" });
       return;
     }
-    const flat = flattenEntry(entry);
+    const flat = flattenEntry2(entry);
     outputSingle(flat, { format, idField: "id" });
   });
   cmd.command("delete <list> <entry-id>").description("Delete an entry").option("-y, --yes", "Skip confirmation").action(async (list, entryId, _options, command) => {
@@ -957,7 +1274,7 @@ function register8(program2) {
 }
 
 // src/commands/tasks.ts
-function register9(program2) {
+function register12(program2) {
   const tasks = program2.command("tasks").description("Manage tasks");
   tasks.command("list").description("List tasks").option("--assignee <member-id>", "Filter by assignee workspace member ID").option("--is-completed", "Filter to only completed tasks").option("--linked-object <obj>", "Filter by linked object slug").option("--linked-record-id <id>", "Filter by linked record ID").option("--limit <n>", "Maximum tasks to return", "25").option("--offset <n>", "Number of tasks to skip", "0").option("--sort <expr>", "Sort expression").action(async (_options, command) => {
     const opts = command.optsWithGlobals();
@@ -1068,7 +1385,7 @@ function truncate(str, max) {
 }
 
 // src/commands/notes.ts
-function register10(program2) {
+function register13(program2) {
   const notes = program2.command("notes").description("Manage notes");
   notes.command("list").description("List notes").option("--object <obj>", "Filter by parent object slug").option("--record <id>", "Filter by parent record ID").option("--limit <n>", "Maximum notes to return", "25").option("--offset <n>", "Number of notes to skip", "0").action(async (_options, command) => {
     const opts = command.optsWithGlobals();
@@ -1141,7 +1458,7 @@ function register10(program2) {
 }
 
 // src/commands/comments.ts
-function register11(program2) {
+function register14(program2) {
   const comments = program2.command("comments").description("Manage comments on records");
   comments.command("list").description("List comment threads on a record").requiredOption("--object <obj>", "Object slug (required)").requiredOption("--record <id>", "Record ID (required)").option("--limit <n>", "Maximum threads to return", "25").option("--offset <n>", "Number of threads to skip", "0").action(async (_options, command) => {
     const opts = command.optsWithGlobals();
@@ -1235,8 +1552,413 @@ function truncate2(str, max) {
   return str.slice(0, max - 3) + "...";
 }
 
+// src/commands/threads.ts
+function flattenThread(thread) {
+  return {
+    id: thread.id?.thread_id || thread.thread_id || "",
+    object: thread.record?.object || "",
+    record_id: thread.record?.record_id || "",
+    list: thread.entry?.list || "",
+    entry_id: thread.entry?.entry_id || "",
+    comments: Array.isArray(thread.comments) ? thread.comments.length : 0,
+    created_at: thread.created_at || ""
+  };
+}
+function register15(program2) {
+  const cmd = program2.command("threads").description("Manage comment threads");
+  cmd.command("list").description("List comment threads").option("--object <object>", "Filter by object slug/ID (requires --record)").option("--record <record-id>", "Filter by parent record ID (requires --object)").option("--list <list>", "Filter by list slug/ID (requires --entry)").option("--entry <entry-id>", "Filter by entry ID (requires --list)").option("--limit <n>", "Maximum threads to return", "25").option("--offset <n>", "Number of threads to skip", "0").action(async (_options, command) => {
+    const opts = command.optsWithGlobals();
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    const format = detectFormat(opts);
+    if (opts.object && !opts.record || !opts.object && opts.record) {
+      throw new Error("--object and --record must be provided together.");
+    }
+    if (opts.list && !opts.entry || !opts.list && opts.entry) {
+      throw new Error("--list and --entry must be provided together.");
+    }
+    const params = new URLSearchParams();
+    params.set("limit", String(Number(opts.limit) || 25));
+    params.set("offset", String(Number(opts.offset) || 0));
+    if (opts.object) params.set("object", opts.object);
+    if (opts.record) params.set("record_id", opts.record);
+    if (opts.list) params.set("list", opts.list);
+    if (opts.entry) params.set("entry_id", opts.entry);
+    const res = await client.get(`/threads?${params.toString()}`);
+    const threads = res.data;
+    if (format === "quiet") {
+      for (const thread of threads) {
+        console.log(thread.id?.thread_id || thread.thread_id || "");
+      }
+      return;
+    }
+    if (format === "json") {
+      outputList(threads, { format, idField: "id" });
+      return;
+    }
+    outputList(threads.map(flattenThread), {
+      format,
+      columns: ["id", "object", "record_id", "list", "entry_id", "comments", "created_at"],
+      idField: "id"
+    });
+  });
+  cmd.command("get <id>").description("Get a thread by ID").action(async (id, _options, command) => {
+    const opts = command.optsWithGlobals();
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    const format = detectFormat(opts);
+    const res = await client.get(`/threads/${encodeURIComponent(id)}`);
+    const thread = res.data;
+    if (format === "json") {
+      outputSingle(thread, { format, idField: "id" });
+      return;
+    }
+    outputSingle(flattenThread(thread), { format, idField: "id" });
+  });
+}
+
+// src/commands/meetings.ts
+function flattenMeeting(meeting) {
+  return {
+    id: meeting.id?.meeting_id || "",
+    title: meeting.title || "",
+    start: meeting.start || "",
+    end: meeting.end || "",
+    is_all_day: meeting.is_all_day ?? false,
+    participants: Array.isArray(meeting.participants) ? meeting.participants.length : 0
+  };
+}
+async function listMeetings(opts) {
+  const client = new AttioClient(opts.apiKey, opts.debug);
+  const limit = Number(opts.limit) || 50;
+  const all = !!opts.all;
+  const baseParams = new URLSearchParams();
+  baseParams.set("limit", String(limit));
+  if (opts.linkedObject) baseParams.set("linked_object", opts.linkedObject);
+  if (opts.linkedRecordId) baseParams.set("linked_record_id", opts.linkedRecordId);
+  if (opts.participants) baseParams.set("participants", opts.participants);
+  if (opts.sort) baseParams.set("sort", opts.sort);
+  if (opts.endsFrom) baseParams.set("ends_from", opts.endsFrom);
+  if (opts.startsBefore) baseParams.set("starts_before", opts.startsBefore);
+  if (opts.timezone) baseParams.set("timezone", opts.timezone);
+  const allMeetings = [];
+  let cursor = opts.cursor;
+  while (true) {
+    const params = new URLSearchParams(baseParams);
+    if (cursor) params.set("cursor", cursor);
+    const res = await client.get(
+      `/meetings?${params.toString()}`
+    );
+    allMeetings.push(...res.data);
+    if (!all) break;
+    cursor = res.pagination?.next_cursor ?? void 0;
+    if (!cursor) break;
+  }
+  return allMeetings;
+}
+function register16(program2) {
+  const cmd = program2.command("meetings").description("Manage meetings (Beta API)");
+  cmd.command("list").description("List meetings (Beta API)").option("--limit <n>", "Maximum meetings per page", "50").option("--cursor <cursor>", "Pagination cursor").option("--all", "Auto-paginate through all pages").option("--linked-object <object>", "Filter by linked object slug or ID").option("--linked-record-id <id>", "Filter by linked record ID").option("--participants <emails>", "Comma-separated participant email addresses").option("--sort <order>", "Sort order (e.g. start_asc, start_desc)").option("--ends-from <iso-timestamp>", "Only include meetings ending after this time").option("--starts-before <iso-timestamp>", "Only include meetings starting before this time").option("--timezone <tz>", "Timezone used with date filters (defaults to UTC)").action(async (_options, command) => {
+    const opts = command.optsWithGlobals();
+    const format = detectFormat(opts);
+    if (opts.linkedRecordId && !opts.linkedObject) {
+      throw new Error("--linked-record-id requires --linked-object.");
+    }
+    const meetings = await listMeetings(opts);
+    if (format === "quiet") {
+      for (const meeting of meetings) {
+        console.log(meeting.id?.meeting_id || "");
+      }
+      return;
+    }
+    if (format === "json") {
+      outputList(meetings, { format, idField: "id" });
+      return;
+    }
+    outputList(meetings.map(flattenMeeting), {
+      format,
+      columns: ["id", "title", "start", "end", "is_all_day", "participants"],
+      idField: "id"
+    });
+  });
+  cmd.command("get <id>").description("Get a meeting by ID (Beta API)").action(async (id, _options, command) => {
+    const opts = command.optsWithGlobals();
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    const format = detectFormat(opts);
+    const res = await client.get(`/meetings/${encodeURIComponent(id)}`);
+    const meeting = res.data;
+    if (format === "json") {
+      outputSingle(meeting, { format, idField: "id" });
+      return;
+    }
+    outputSingle(flattenMeeting(meeting), { format, idField: "id" });
+  });
+}
+
+// src/commands/recordings.ts
+function flattenRecording(recording) {
+  return {
+    id: recording.id?.call_recording_id || "",
+    meeting_id: recording.id?.meeting_id || "",
+    status: recording.status || "",
+    created_at: recording.created_at || "",
+    web_url: recording.web_url || ""
+  };
+}
+async function listRecordingsForMeeting(meetingId, opts) {
+  const client = new AttioClient(opts.apiKey, opts.debug);
+  const all = !!opts.all;
+  const limit = Number(opts.limit) || 50;
+  const allRecordings = [];
+  let cursor = opts.cursor;
+  while (true) {
+    const params = new URLSearchParams();
+    params.set("limit", String(limit));
+    if (cursor) params.set("cursor", cursor);
+    const res = await client.get(
+      `/meetings/${encodeURIComponent(meetingId)}/call_recordings?${params.toString()}`
+    );
+    allRecordings.push(...res.data);
+    if (!all) break;
+    cursor = res.pagination?.next_cursor ?? void 0;
+    if (!cursor) break;
+  }
+  return allRecordings;
+}
+async function fetchTranscript(client, meetingId, recordingId, opts) {
+  const transcriptSegments = [];
+  let cursor = opts.cursor;
+  while (true) {
+    const params = new URLSearchParams();
+    if (cursor) params.set("cursor", cursor);
+    const query = params.toString();
+    const path = `/meetings/${encodeURIComponent(meetingId)}/call_recordings/${encodeURIComponent(recordingId)}/transcript${query ? `?${query}` : ""}`;
+    const res = await client.get(path);
+    const segmentData = res.data;
+    if (Array.isArray(segmentData.transcript)) {
+      transcriptSegments.push(...segmentData.transcript);
+    }
+    if (!opts.allTranscript) {
+      return { ...segmentData, transcript: transcriptSegments };
+    }
+    cursor = res.pagination?.next_cursor ?? void 0;
+    if (!cursor) {
+      return { ...segmentData, transcript: transcriptSegments };
+    }
+  }
+}
+function register17(program2) {
+  const cmd = program2.command("recordings").description("Manage call recordings (Beta API)");
+  cmd.command("list").description("List call recordings for a meeting (Beta API)").requiredOption("--meeting <meeting-id>", "Meeting ID (required)").option("--limit <n>", "Maximum recordings per page", "50").option("--cursor <cursor>", "Pagination cursor").option("--all", "Auto-paginate through all pages").action(async (_options, command) => {
+    const opts = command.optsWithGlobals();
+    const format = detectFormat(opts);
+    const recordings = await listRecordingsForMeeting(opts.meeting, opts);
+    if (format === "quiet") {
+      for (const recording of recordings) {
+        console.log(recording.id?.call_recording_id || "");
+      }
+      return;
+    }
+    if (format === "json") {
+      outputList(recordings, { format, idField: "id" });
+      return;
+    }
+    outputList(recordings.map(flattenRecording), {
+      format,
+      columns: ["id", "meeting_id", "status", "created_at", "web_url"],
+      idField: "id"
+    });
+  });
+  cmd.command("get <id>").description("Get a call recording by ID (Beta API)").requiredOption("--meeting <meeting-id>", "Meeting ID (required)").option("--transcript", "Include transcript data in the response").option("--cursor <cursor>", "Transcript pagination cursor").option("--all-transcript", "Fetch all transcript pages when using --transcript").action(async (id, _options, command) => {
+    const opts = command.optsWithGlobals();
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    const format = detectFormat(opts);
+    const res = await client.get(
+      `/meetings/${encodeURIComponent(opts.meeting)}/call_recordings/${encodeURIComponent(id)}`
+    );
+    const recording = res.data;
+    if (opts.transcript) {
+      const transcript = await fetchTranscript(client, opts.meeting, id, opts);
+      recording.transcript = transcript;
+    }
+    if (format === "json") {
+      outputSingle(recording, { format, idField: "id" });
+      return;
+    }
+    outputSingle(flattenRecording(recording), { format, idField: "id" });
+  });
+}
+
+// src/commands/webhooks.ts
+import { readFileSync as readFileSync2 } from "fs";
+var WEBHOOK_EVENT_TYPES = [
+  "call-recording.created",
+  "comment.created",
+  "comment.resolved",
+  "comment.unresolved",
+  "comment.deleted",
+  "list.created",
+  "list.updated",
+  "list.deleted",
+  "list-attribute.created",
+  "list-attribute.updated",
+  "list-entry.created",
+  "list-entry.updated",
+  "list-entry.deleted",
+  "object-attribute.created",
+  "object-attribute.updated",
+  "note.created",
+  "note-content.updated",
+  "note.updated",
+  "note.deleted",
+  "record.created",
+  "record.merged",
+  "record.updated",
+  "record.deleted",
+  "task.created",
+  "task.updated",
+  "task.deleted",
+  "workspace-member.created"
+];
+function parseJsonInput(raw) {
+  if (raw.startsWith("@")) {
+    return JSON.parse(readFileSync2(raw.slice(1), "utf-8"));
+  }
+  return JSON.parse(raw);
+}
+function flattenWebhook(item) {
+  return {
+    id: item.id?.webhook_id || "",
+    target_url: item.target_url || "",
+    status: item.status || "",
+    subscriptions: Array.isArray(item.subscriptions) ? item.subscriptions.length : 0,
+    created_at: item.created_at || ""
+  };
+}
+function collectEvents(rawEvents) {
+  if (rawEvents.length === 0) return [];
+  const invalid = rawEvents.filter((event) => !WEBHOOK_EVENT_TYPES.includes(event));
+  if (invalid.length > 0) {
+    throw new Error(`Unsupported webhook event type(s): ${invalid.join(", ")}`);
+  }
+  return rawEvents;
+}
+function parseSubscriptions(opts) {
+  if (opts.subscriptions) {
+    const parsed = parseJsonInput(opts.subscriptions);
+    if (!Array.isArray(parsed)) {
+      throw new Error("--subscriptions must be a JSON array or @file containing a JSON array.");
+    }
+    return parsed;
+  }
+  const events = collectEvents(opts.event ?? []);
+  if (events.length === 0) {
+    throw new Error("Provide at least one --event or --subscriptions for webhook subscriptions.");
+  }
+  const filter = opts.filterJson ? parseJsonInput(opts.filterJson) : null;
+  return events.map((eventType) => ({ event_type: eventType, filter }));
+}
+function register18(program2) {
+  const cmd = program2.command("webhooks").description("Manage webhooks");
+  cmd.command("events").description("List all supported webhook event types").action(async (_options, command) => {
+    const opts = command.optsWithGlobals();
+    const format = detectFormat(opts);
+    const events = WEBHOOK_EVENT_TYPES.map((eventType) => ({ event_type: eventType }));
+    outputList(events, { format, columns: ["event_type"], idField: "event_type" });
+  });
+  cmd.command("list").description("List webhooks").option("--limit <n>", "Maximum webhooks to return", "25").option("--offset <n>", "Number of webhooks to skip", "0").action(async (_options, command) => {
+    const opts = command.optsWithGlobals();
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    const format = detectFormat(opts);
+    const params = new URLSearchParams();
+    params.set("limit", String(Number(opts.limit) || 25));
+    params.set("offset", String(Number(opts.offset) || 0));
+    const res = await client.get(`/webhooks?${params.toString()}`);
+    const webhooks = res.data;
+    if (format === "quiet") {
+      for (const webhook of webhooks) {
+        console.log(webhook.id?.webhook_id || "");
+      }
+      return;
+    }
+    if (format === "json") {
+      outputList(webhooks, { format, idField: "id" });
+      return;
+    }
+    outputList(webhooks.map(flattenWebhook), {
+      format,
+      columns: ["id", "target_url", "status", "subscriptions", "created_at"],
+      idField: "id"
+    });
+  });
+  cmd.command("get <id>").description("Get a webhook by ID").action(async (id, _options, command) => {
+    const opts = command.optsWithGlobals();
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    const format = detectFormat(opts);
+    const res = await client.get(`/webhooks/${encodeURIComponent(id)}`);
+    const webhook = res.data;
+    if (format === "json") {
+      outputSingle(webhook, { format, idField: "id" });
+      return;
+    }
+    outputSingle(flattenWebhook(webhook), { format, idField: "id" });
+  });
+  cmd.command("create").description("Create a webhook").requiredOption("--target-url <url>", "Webhook destination URL (https only)").option(
+    "--event <event-type>",
+    'Webhook event type (repeatable). Use "webhooks events" to list all',
+    (val, prev) => [...prev, val],
+    []
+  ).option("--filter-json <json>", "JSON filter for all --event subscriptions").option("--subscriptions <json>", "Full subscriptions JSON array or @file (overrides --event)").action(async (_options, command) => {
+    const opts = command.optsWithGlobals();
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    const format = detectFormat(opts);
+    const subscriptions = parseSubscriptions(opts);
+    const res = await client.post("/webhooks", {
+      data: {
+        target_url: opts.targetUrl,
+        subscriptions
+      }
+    });
+    outputSingle(res.data, { format, idField: "id" });
+  });
+  cmd.command("update <id>").description("Update a webhook").option("--target-url <url>", "Webhook destination URL (https only)").option(
+    "--event <event-type>",
+    'Webhook event type (repeatable). Use "webhooks events" to list all',
+    (val, prev) => [...prev, val],
+    []
+  ).option("--filter-json <json>", "JSON filter for all --event subscriptions").option("--subscriptions <json>", "Full subscriptions JSON array or @file (overrides --event)").action(async (id, _options, command) => {
+    const opts = command.optsWithGlobals();
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    const format = detectFormat(opts);
+    const data = {};
+    if (opts.targetUrl) {
+      data.target_url = opts.targetUrl;
+    }
+    const hasSubscriptionFlags = !!opts.subscriptions || !!opts.filterJson || (opts.event ?? []).length > 0;
+    if (hasSubscriptionFlags) {
+      data.subscriptions = parseSubscriptions(opts);
+    }
+    if (Object.keys(data).length === 0) {
+      throw new Error("Nothing to update. Provide --target-url and/or subscription options.");
+    }
+    const res = await client.patch(`/webhooks/${encodeURIComponent(id)}`, { data });
+    outputSingle(res.data, { format, idField: "id" });
+  });
+  cmd.command("delete <id>").description("Delete a webhook").option("-y, --yes", "Skip confirmation").action(async (id, _options, command) => {
+    const opts = command.optsWithGlobals();
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    if (!opts.yes) {
+      const ok = await confirm(`Delete webhook ${id}?`);
+      if (!ok) {
+        console.error("Aborted.");
+        return;
+      }
+    }
+    await client.delete(`/webhooks/${encodeURIComponent(id)}`);
+    console.error("Deleted.");
+  });
+}
+
 // src/commands/members.ts
-function register12(program2) {
+function register19(program2) {
   const members = program2.command("members").description("Manage workspace members");
   members.command("list").description("List all workspace members").action(async function() {
     const opts = this.optsWithGlobals();
@@ -1271,7 +1993,7 @@ function register12(program2) {
 
 // src/commands/config.ts
 import chalk4 from "chalk";
-function register13(program2) {
+function register20(program2) {
   const cmd = program2.command("config").description("Manage CLI configuration");
   cmd.command("set <key> <value>").description("Set a config value (e.g., attio config set api-key <key>)").action((key, value) => {
     if (key === "api-key") {
@@ -1395,13 +2117,14 @@ Multiple \`--filter\` flags are ANDed. Use \`--filter-json '{...}'\` for raw Att
 import { execFile } from "child_process";
 import { platform } from "os";
 import chalk5 from "chalk";
-function register14(program2) {
+function register21(program2) {
   program2.command("open <object> [record-id]").description("Open an object or record in the Attio web app").action(async (object, recordId, options, command) => {
     const opts = command.optsWithGlobals();
+    const objectSlug = encodeURIComponent(object);
     let url;
     if (recordId) {
       const client = new AttioClient(opts.apiKey, opts.debug);
-      const res = await client.get(`/objects/${object}/records/${recordId}`);
+      const res = await client.get(`/objects/${objectSlug}/records/${encodeURIComponent(recordId)}`);
       const record = res.data;
       url = record.web_url;
       if (!url) {
@@ -1412,9 +2135,9 @@ function register14(program2) {
       const client = new AttioClient(opts.apiKey, opts.debug);
       const self = await client.get("/self");
       const slug = self.workspace_slug || "";
-      url = `https://app.attio.com/${slug}/${object}`;
+      url = `https://app.attio.com/${encodeURIComponent(slug)}/${objectSlug}`;
     }
-    const cmd = platform() === "darwin" ? "open" : platform() === "win32" ? "start" : "xdg-open";
+    const cmd = platform() === "darwin" ? "open" : platform() === "win32" ? "explorer" : "xdg-open";
     execFile(cmd, [url], (err) => {
       if (err) {
         console.log(url);
@@ -1426,7 +2149,7 @@ function register14(program2) {
 // src/commands/init.ts
 import { createInterface as createInterface2 } from "readline";
 import chalk6 from "chalk";
-function register15(program2) {
+function register22(program2) {
   program2.command("init").description("Interactive setup wizard \u2014 connect to your Attio workspace").action(async function() {
     const opts = this.optsWithGlobals();
     let apiKey = opts.apiKey;
@@ -1515,6 +2238,18 @@ function register15(program2) {
 }
 
 // bin/attio.ts
+function loadCliVersion() {
+  try {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const packagePath = join2(here, "..", "package.json");
+    const packageJson = JSON.parse(readFileSync3(packagePath, "utf-8"));
+    if (typeof packageJson.version === "string" && packageJson.version.length > 0) {
+      return packageJson.version;
+    }
+  } catch {
+  }
+  return "0.2.0";
+}
 function handleError(err) {
   const jsonMode = program.opts().json || !process.stdout.isTTY;
   if (err instanceof AttioApiError) {
@@ -1559,7 +2294,7 @@ function handleError(err) {
   }
   process.exit(1);
 }
-program.name("attio").version("0.1.0").description("CLI for the Attio CRM API. Built for scripts, agents, and humans who prefer terminals.").option("--api-key <key>", "Override API key").option("--json", "Force JSON output").option("--table", "Force table output").option("--csv", "Force CSV output").option("-q, --quiet", "Only output IDs").option("--no-color", "Disable colors").option("--debug", "Print request/response details to stderr");
+program.name("attio").version(loadCliVersion()).description("CLI for the Attio CRM API. Built for scripts, agents, and humans who prefer terminals.").option("--api-key <key>", "Override API key").option("--json", "Force JSON output").option("--table", "Force table output").option("--csv", "Force CSV output").option("-q, --quiet", "Only output IDs").option("--no-color", "Disable colors").option("--debug", "Print request/response details to stderr");
 if (process.argv.includes("--no-color")) {
   process.env.NO_COLOR = "1";
 }
@@ -1578,6 +2313,13 @@ register12(program);
 register13(program);
 register14(program);
 register15(program);
+register16(program);
+register17(program);
+register18(program);
+register19(program);
+register20(program);
+register21(program);
+register22(program);
 program.action(() => {
   if (!isConfigured()) {
     console.error("");