ente-cli 0.4.81 → 0.4.83

package/dist/cli.mjs

@@ -3800,7 +3800,7 @@ async function runCli(cli2, argv, context) {
 }
 
 // ente/version.ts
-var VERSION = "0.4.81";
+var VERSION = "0.4.83";
 
 // ente/branding.ts
 var NPM_REGISTRY = "https://registry.npmjs.org";
@@ -10861,6 +10861,7 @@ async function makeCaller(opts) {
     convexUrl: opts.convexUrl,
     query: (ref, ...args) => withRetry(() => client.query(ref, ...args)),
     mutation: (ref, ...args) => withRetry(() => client.mutation(ref, ...args)),
+    mutationUnqueued: (ref, ...args) => withRetry(() => client.mutation(ref, args[0] ?? {}, { skipQueue: true })),
     action: (ref, ...args) => withRetry(() => client.action(ref, ...args))
   };
 }
@@ -11739,6 +11740,48 @@ var PinsList = class extends ProfileCommand {
 };
 var PINS_COMMANDS = [PinsList];
 
+// ente/pinTargets.ts
+async function pinToTargets(caller, entityId, targets, opts) {
+  const result = { succeeded: [], failures: [] };
+  if (targets.length === 0) return result;
+  let ids = [];
+  try {
+    ids = await resolveEntitiesC(caller, targets);
+  } catch (exc) {
+    for (const target of targets) result.failures.push({ target, error: `could not resolve target: ${errorMessage(exc)}` });
+    return result;
+  }
+  for (let i = 0; i < ids.length; i++) {
+    const target = targets[i];
+    try {
+      await caller.mutation(pinsCreate, {
+        sourceEntityId: entityId,
+        targetEntityId: ids[i],
+        ...opts.shareParents ? {
+          grantMissingParentAccess: true,
+          ...opts.parentSpaceGrantFingerprint ? { parentSpaceGrantFingerprint: opts.parentSpaceGrantFingerprint } : {}
+        } : {}
+      });
+      result.succeeded.push(target);
+    } catch (exc) {
+      result.failures.push({ target, error: errorMessage(exc) });
+    }
+  }
+  return result;
+}
+function failOnPinFailures(err, label, entityId, result) {
+  if (result.failures.length === 0) return;
+  err("");
+  err(
+    `\u26A0  ${label} (${entityId}) created, but ${result.failures.length} of ${result.failures.length + result.succeeded.length} pin(s) failed:`
+  );
+  for (const { target, error } of result.failures) {
+    err(`    - '${target}': ${error}`);
+    err(`      retry: ente entity pin ${entityId} "${target}"`);
+  }
+  throw new ExitWithCode(2);
+}
+
 // ente/commands/entity.ts
 var entitiesDuplicate = makeFunctionReference("entities:duplicate");
 var entitiesCreate = makeFunctionReference("entities:create");
@@ -11875,59 +11918,23 @@ var EntityCreate = class extends ProfileCommand {
     if (this.description) {
       await caller.mutation(entitiesSetDescriptionFromMarkdown, { entityId, markdown: this.description });
     }
-    const pinFailures = [];
-    const pinSucceeded = [];
-    if (this.pin && this.pin.length) {
-      let pinIds = [];
-      try {
-        pinIds = await resolveEntitiesC(caller, this.pin);
-      } catch (exc) {
-        for (const target of this.pin) pinFailures.push([target, `could not resolve target: ${errorMessage(exc)}`]);
-      }
-      for (let i = 0; i < pinIds.length; i++) {
-        const targetLabel = this.pin[i];
-        try {
-          await caller.mutation(pinsCreate, {
-            sourceEntityId: entityId,
-            targetEntityId: pinIds[i],
-            ...this.shareParents ? {
-              grantMissingParentAccess: true,
-              ...this.parentSpaceGrantFingerprint ? { parentSpaceGrantFingerprint: this.parentSpaceGrantFingerprint } : {}
-            } : {}
-          });
-          pinSucceeded.push(targetLabel);
-        } catch (exc) {
-          pinFailures.push([targetLabel, errorMessage(exc)]);
-        }
-      }
-    }
+    const pins = await pinToTargets(caller, entityId, this.pin ?? [], {
+      shareParents: this.shareParents,
+      ...this.parentSpaceGrantFingerprint ? { parentSpaceGrantFingerprint: this.parentSpaceGrantFingerprint } : {}
+    });
     const spaces = await spacesFooterFromMemberships(caller);
     const jsonOut = { data: { entityId } };
-    if (pinFailures.length) {
+    if (pins.failures.length) {
       jsonOut.error = { message: "Entity created, but some parent relationships failed.", code: "PARTIAL_SUCCESS" };
-      jsonOut.data = {
-        entityId,
-        pinFailures: pinFailures.map(([target, error]) => ({ target, error })),
-        pinSucceeded
-      };
+      jsonOut.data = { entityId, pinFailures: pins.failures, pinSucceeded: pins.succeeded };
     }
     this.emitText(jsonWithSpaces(jsonOut, spaces), () => {
       let body = `Created ${this.type} '${this.name}' (${entityId})`;
-      if (pinSucceeded.length) body += `
-Pinned to: ${pinSucceeded.join(", ")}`;
+      if (pins.succeeded.length) body += `
+Pinned to: ${pins.succeeded.join(", ")}`;
       return withFooter(body, spaces);
     });
-    if (pinFailures.length) {
-      this.err("");
-      this.err(
-        `\u26A0  Entity '${this.name}' (${entityId}) created, but ${pinFailures.length} of ${pinFailures.length + pinSucceeded.length} pin(s) failed:`
-      );
-      for (const [target, msg] of pinFailures) {
-        this.err(`    - '${target}': ${msg}`);
-        this.err(`      retry: ente entity pin ${entityId} "${target}"`);
-      }
-      throw new ExitWithCode(2);
-    }
+    failOnPinFailures((line) => this.err(line), `Entity '${this.name}'`, entityId, pins);
   }
 };
 var EntityShowCorrection = class extends ProfileCommand {
@@ -13720,24 +13727,11 @@ var TASK_COMMANDS = [
 ];
 
 // ente/commands/list.ts
+import { readFileSync as readFileSync10 } from "node:fs";
+
+// ente/databaseList.ts
 var COLUMN_TYPES = ["text", "number", "boolean", "single-select", "multi-select"];
 var SELECT_TYPES = /* @__PURE__ */ new Set(["single-select", "multi-select"]);
-var DATABASE_LIST_TABS = ["database", "activities"];
-var entitiesCreate2 = makeFunctionReference("entities:create");
-var updateDatabaseView = makeFunctionReference("entities:updateDatabaseView");
-var setDescriptionFromMarkdown = makeFunctionReference("entities:setDescriptionFromMarkdown");
-var setEnabledTabs = makeFunctionReference("entities:setEnabledTabs");
-var setCustomIcon = makeFunctionReference("entities:setCustomIcon");
-var removeDatabaseColumn = makeFunctionReference("entities:removeDatabaseColumn");
-var findById = makeFunctionReference(
-  "entities:findById"
-);
-var listSpacesForEntity = makeFunctionReference(
-  "entities:listSpacesForEntity"
-);
-var activitiesCreate3 = makeFunctionReference("activities:create");
-var setAttributeValue = makeFunctionReference("activities:setAttributeValue");
-var listRows = makeFunctionReference("activities:listEntityDatabaseRowsPaginated");
 function parseColumn(spec) {
   const parts = spec.split(":");
   const keyPart = (parts[0] ?? "").trim();
@@ -13750,6 +13744,10 @@ function parseColumn(spec) {
   if (!/^[a-z0-9_-]+$/.test(key))
     throw new Error(`Invalid column key '${key}': use lowercase letters, numbers, '_' or '-'.`);
   if (eq !== -1 && !label) throw new Error(`Invalid --column '${spec}': empty label after '='.`);
+  if (typeRaw === "date")
+    throw new Error(
+      `Invalid --column '${spec}': ente database lists have no date column type yet. Store an ISO date (YYYY-MM-DD) in a text column.`
+    );
   if (!COLUMN_TYPES.includes(typeRaw))
     throw new Error(`Invalid --column '${spec}': type must be one of ${COLUMN_TYPES.join(", ")}.`);
   const type = typeRaw;
@@ -13762,22 +13760,324 @@ function parseColumn(spec) {
   }
   return col;
 }
-function coerceValue(type, raw) {
-  switch (type) {
+var TRUE_WORDS = /* @__PURE__ */ new Set(["true", "yes", "1", "on"]);
+var FALSE_WORDS = /* @__PURE__ */ new Set(["false", "no", "0", "off"]);
+function assertOption(column, value) {
+  const options = column.options ?? [];
+  if (options.length > 0 && !options.some((o) => o.value === value))
+    throw new Error(
+      `'${value}' is not an option of column '${column.key}'. Options: ${options.map((o) => o.value).join(", ")}.`
+    );
+}
+function coerceValue(column, raw) {
+  const where = `column '${column.key}' (${column.type})`;
+  if (raw === null || raw === "") return null;
+  switch (column.type) {
     case "number": {
-      const n = Number(raw);
-      if (Number.isNaN(n)) throw new Error(`Value '${raw}' is not a number.`);
-      return n;
-    }
-    case "boolean":
-      return ["true", "yes", "1", "on"].includes(raw.trim().toLowerCase());
-    case "multi-select":
-      return raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
-    default:
+      if (typeof raw === "number" && Number.isFinite(raw)) return raw;
+      if (typeof raw === "string") {
+        const n = Number(raw.trim());
+        if (raw.trim() !== "" && Number.isFinite(n)) return n;
+      }
+      throw new Error(`Value ${JSON.stringify(raw)} is not a number for ${where}.`);
+    }
+    case "boolean": {
+      if (typeof raw === "boolean") return raw;
+      const word = typeof raw === "string" ? raw.trim().toLowerCase() : "";
+      if (TRUE_WORDS.has(word)) return true;
+      if (FALSE_WORDS.has(word)) return false;
+      throw new Error(`Value ${JSON.stringify(raw)} is not a boolean for ${where}; use true/false.`);
+    }
+    case "multi-select": {
+      const values = Array.isArray(raw) ? raw.map((v2) => {
+        if (typeof v2 !== "string") throw new Error(`Value ${JSON.stringify(raw)} must list strings for ${where}.`);
+        return v2.trim();
+      }) : typeof raw === "string" ? raw.split(",").map((s) => s.trim()) : null;
+      if (!values) throw new Error(`Value ${JSON.stringify(raw)} is not a list for ${where}.`);
+      const kept = values.filter((s) => s.length > 0);
+      for (const v2 of kept) assertOption(column, v2);
+      return kept;
+    }
+    case "single-select":
+    case "text": {
+      if (typeof raw !== "string") throw new Error(`Value ${JSON.stringify(raw)} is not text for ${where}.`);
+      if (column.type === "single-select") assertOption(column, raw);
       return raw;
+    }
+  }
+}
+function columnFor(columns, key, listName) {
+  const col = columns.find((c) => c.key === key);
+  if (!col)
+    throw new Error(
+      `'${key}' is not a column of list '${listName}'. Columns: ${columns.map((c) => c.key).join(", ") || "(none)"}. Add it with: ente list column add "${listName}" ${key}:text`
+    );
+  return col;
+}
+function coerceAttributes(columns, raw, listName) {
+  const out = {};
+  for (const [key, value] of Object.entries(raw)) out[key] = coerceValue(columnFor(columns, key, listName), value);
+  return out;
+}
+function sameValue(a, b) {
+  const empty = (v2) => v2 === void 0 || v2 === null || Array.isArray(v2) && v2.length === 0;
+  if (empty(a) || empty(b)) return empty(a) && empty(b);
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+    return a.every((v2, i) => v2 === b[i]);
+  }
+  return a === b;
+}
+function parseWhere(columns, specs, listName) {
+  return specs.map((spec) => {
+    const eq = spec.indexOf("=");
+    if (eq <= 0) throw new Error(`Invalid --where '${spec}'. Use key=value (empty value matches empty cells).`);
+    const key = spec.slice(0, eq);
+    const column = columnFor(columns, key, listName);
+    return { key, value: coerceValue(column, spec.slice(eq + 1)) };
+  });
+}
+function matchesWhere(attributes, clauses) {
+  const attrs = attributes ?? {};
+  return clauses.every(({ key, value }) => {
+    const cell = attrs[key];
+    if (Array.isArray(value) && value.length > 0) {
+      return Array.isArray(cell) && value.every((v2) => cell.includes(v2));
+    }
+    return sameValue(cell, value);
+  });
+}
+function planUpsert(existing, inputs, keyColumn) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const row of existing) {
+    const raw = row.attributes?.[keyColumn];
+    if (typeof raw !== "string" || raw === "") continue;
+    const other = byKey.get(raw);
+    if (other)
+      throw new Error(
+        `The list already holds two rows with ${keyColumn}=${JSON.stringify(raw)} (${other.rowId}, ${row.rowId}). Delete one with \`ente activity delete <rowId>\` before syncing.`
+      );
+    byKey.set(raw, row);
+  }
+  const keyless = /* @__PURE__ */ new Map();
+  for (const row of existing) {
+    const raw = row.attributes?.[keyColumn];
+    if ((typeof raw !== "string" || raw === "") && row.title) keyless.set(row.title, row.rowId);
+  }
+  const seen = /* @__PURE__ */ new Map();
+  const steps = inputs.map((input) => {
+    const key = input.attributes[keyColumn];
+    if (typeof key !== "string" || key.trim() === "")
+      throw new Error(`Line ${input.line}: missing a text value for key column '${keyColumn}'.`);
+    const firstLine = seen.get(key);
+    if (firstLine !== void 0)
+      throw new Error(`Line ${input.line}: ${keyColumn}=${JSON.stringify(key)} repeats line ${firstLine}.`);
+    seen.set(key, input.line);
+    const row = byKey.get(key);
+    if (!row) return { action: "create", input, key };
+    const stored = row.attributes ?? {};
+    const changes = {};
+    for (const [k, v2] of Object.entries(input.attributes)) {
+      if (!sameValue(stored[k], v2)) changes[k] = v2;
+    }
+    const title = input.title !== void 0 && input.title !== (row.title ?? "") ? input.title : void 0;
+    if (Object.keys(changes).length === 0 && title === void 0)
+      return { action: "unchanged", input, key, rowId: row.rowId };
+    return { action: "update", input, key, rowId: row.rowId, changes, ...title !== void 0 ? { title } : {} };
+  });
+  const orphans = steps.filter((step) => step.action === "create" && step.input.title !== void 0 && keyless.has(step.input.title)).map((step) => `line ${step.input.line} '${step.input.title}' \u2194 row ${keyless.get(step.input.title)}`);
+  if (orphans.length > 0)
+    throw new Error(
+      `Rows without a ${keyColumn} value carry the title of rows about to be created (an interrupted earlier run?): ${orphans.join(
+        "; "
+      )}. Set their key with \`ente list update <list> <rowId> --attr ${keyColumn}=\u2026\` or trash them with \`ente activity delete <rowId>\`, then rerun.`
+    );
+  return steps;
+}
+function parseImportLines(text) {
+  const rows = [];
+  const lines = text.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const source = lines[i].trim();
+    if (!source) continue;
+    const line = i + 1;
+    let parsed;
+    try {
+      parsed = JSON.parse(source);
+    } catch (err) {
+      throw new Error(`Line ${line}: not valid JSON (${err instanceof Error ? err.message : String(err)}).`);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      throw new Error(`Line ${line}: expected a JSON object.`);
+    const obj = parsed;
+    const unknownKeys = Object.keys(obj).filter((k) => !["title", "attrs", "content"].includes(k));
+    if (unknownKeys.length > 0)
+      throw new Error(`Line ${line}: unknown field(s) ${unknownKeys.join(", ")}; allowed: title, attrs, content.`);
+    if (obj.title !== void 0 && typeof obj.title !== "string") throw new Error(`Line ${line}: "title" must be a string.`);
+    if (obj.content !== void 0 && typeof obj.content !== "string") throw new Error(`Line ${line}: "content" must be a string.`);
+    const attrs = obj.attrs ?? {};
+    if (!attrs || typeof attrs !== "object" || Array.isArray(attrs)) throw new Error(`Line ${line}: "attrs" must be an object.`);
+    rows.push({
+      line,
+      attrs,
+      ...obj.title !== void 0 ? { title: obj.title } : {},
+      ...obj.content !== void 0 ? { content: obj.content } : {}
+    });
+  }
+  return rows;
+}
+async function runPool(items, limit, work) {
+  let next = 0;
+  const failures = [];
+  const worker = async () => {
+    while (failures.length === 0 && next < items.length) {
+      const item = items[next++];
+      try {
+        await work(item);
+      } catch (error) {
+        failures.push(error);
+      }
+    }
+  };
+  await Promise.all(Array.from({ length: Math.max(1, Math.min(limit, items.length)) }, worker));
+  if (failures.length === 1) throw failures[0];
+  if (failures.length > 1)
+    throw new Error(
+      `${failures.length} writes failed:
+${failures.map((e) => `  - ${e instanceof Error ? e.message : String(e)}`).join("\n")}`
+    );
+}
+
+// ente/commands/list.ts
+var DATABASE_LIST_TABS = ["database", "activities"];
+var ROW_PAGE_SIZE = 100;
+var entitiesCreate2 = makeFunctionReference("entities:create");
+var updateDatabaseView = makeFunctionReference("entities:updateDatabaseView");
+var setDescriptionFromMarkdown = makeFunctionReference("entities:setDescriptionFromMarkdown");
+var setEnabledTabs = makeFunctionReference("entities:setEnabledTabs");
+var setCustomIcon = makeFunctionReference("entities:setCustomIcon");
+var removeDatabaseColumn = makeFunctionReference("entities:removeDatabaseColumn");
+var findById = makeFunctionReference(
+  "entities:findById"
+);
+var listSpacesForEntity = makeFunctionReference(
+  "entities:listSpacesForEntity"
+);
+var activitiesCreate3 = makeFunctionReference("activities:create");
+var activitiesGetByIdRich3 = makeFunctionReference(
+  "activities:getByIdRich"
+);
+var activitiesUpdateTitle3 = makeFunctionReference("activities:updateTitle");
+var setAttributeValue = makeFunctionReference("activities:setAttributeValue");
+var listRows = makeFunctionReference("activities:listEntityDatabaseRowsPaginated");
+async function loadList(caller, listNameOrId) {
+  const entityId = await resolveEntityC(caller, listNameOrId);
+  const entity = await caller.query(findById, { id: entityId });
+  if (!entity) throw new Error(`List '${listNameOrId}' not found or not accessible.`);
+  const stored = entity.databaseView;
+  return {
+    entityId,
+    entity,
+    view: {
+      version: 1,
+      columns: stored?.columns ?? [],
+      filters: stored?.filters ?? [],
+      sorts: stored?.sorts ?? []
+    }
+  };
+}
+async function fetchAllRows(caller, entityId) {
+  const rows = [];
+  let cursor = null;
+  for (; ; ) {
+    const res = await caller.query(listRows, {
+      entityId,
+      ignoreViewFilters: true,
+      paginationOpts: { numItems: ROW_PAGE_SIZE, cursor }
+    });
+    rows.push(...res.page);
+    if (res.isDone) return rows;
+    cursor = res.continueCursor;
+  }
+}
+async function resolveOwnerSpace(caller, entityId, space) {
+  if (space) return resolveSpaceByNameC(caller, space);
+  const spaces = await caller.query(listSpacesForEntity, { entityId });
+  if (spaces.length === 0) throw new Error("The list is in no accessible space; pass --space explicitly.");
+  if (spaces.length > 1)
+    throw new Error(
+      `The list spans multiple spaces (${spaces.map((s) => s.name).join(", ")}); pass --space to choose one.`
+    );
+  return spaces[0]._id;
+}
+function rowJson(row) {
+  return {
+    rowId: row._id,
+    title: row.title ?? null,
+    type: row.type,
+    completed: row.completed ?? false,
+    createdAt: row._creationTime,
+    attributes: row.attributes ?? {},
+    entities: (row.entityDetails ?? []).filter((e) => e !== null).map((e) => ({ entityId: e._id, name: e.name }))
+  };
+}
+function rowLine(row) {
+  const attrStr = Object.entries(row.attributes ?? {}).filter(([, v2]) => v2 !== null && v2 !== void 0 && !(Array.isArray(v2) && v2.length === 0)).map(([k, v2]) => `${k}=${Array.isArray(v2) ? v2.join(",") : String(v2)}`).join("  ");
+  return `- ${row.title || "(untitled)"} (${row._id})${attrStr ? `   [${attrStr}]` : ""}`;
+}
+async function applyStep(ctx, step) {
+  const { caller } = ctx;
+  if (step.action === "unchanged") return step.rowId;
+  if (step.action === "update") {
+    if (step.title !== void 0)
+      await caller.mutationUnqueued(activitiesUpdateTitle3, { activityId: step.rowId, title: step.title });
+    for (const [key, value] of Object.entries(step.changes))
+      await caller.mutationUnqueued(setAttributeValue, { activityId: step.rowId, key, value });
+    return step.rowId;
+  }
+  const { input } = step;
+  const rowId = await caller.mutationUnqueued(activitiesCreate3, {
+    entityId: ctx.entityId,
+    ownerSpaceId: ctx.ownerSpaceId,
+    type: ctx.type,
+    ...input.title !== void 0 ? { title: input.title } : {},
+    ...ctx.deadline !== void 0 ? { deadline: ctx.deadline } : {},
+    ...input.content !== void 0 ? { contentMarkdown: input.content } : {}
+  });
+  const ordered = Object.entries(input.attributes).sort(
+    ([a], [b]) => a === ctx.keyColumn ? -1 : b === ctx.keyColumn ? 1 : 0
+  );
+  try {
+    for (const [key, value] of ordered) {
+      if (value === null || Array.isArray(value) && value.length === 0) continue;
+      await caller.mutationUnqueued(setAttributeValue, { activityId: rowId, key, value });
+    }
+  } catch (exc) {
+    throw new Error(`Line ${input.line}: row ${rowId} was created, but setting its cells failed: ${errorMessage(exc)}`);
   }
+  return rowId;
+}
+function stepResult(step, rowId) {
+  const base = { line: step.input.line, key: step.key };
+  const contentIgnored = step.action !== "create" && step.input.content !== void 0 ? { contentIgnored: true } : {};
+  if (step.action === "create") return { ...base, action: "created", rowId };
+  if (step.action === "unchanged") return { ...base, action: "unchanged", rowId: step.rowId, ...contentIgnored };
+  return {
+    ...base,
+    action: "updated",
+    rowId: step.rowId,
+    changed: [...step.title !== void 0 ? ["title"] : [], ...Object.keys(step.changes)],
+    ...contentIgnored
+  };
+}
+function countActions(results) {
+  return {
+    created: results.filter((r) => r.action === "created").length,
+    updated: results.filter((r) => r.action === "updated").length,
+    unchanged: results.filter((r) => r.action === "unchanged").length
+  };
 }
-var ListCreate = class extends ClientCommand {
+var ListCreate = class extends ProfileCommand {
   static paths = [["list", "create"]];
   static usage = Command.Usage({
     category: "List",
@@ -13790,6 +14090,10 @@ var ListCreate = class extends ClientCommand {
       [
         "A recipe collection with labelled columns and an icon",
         'ente list create Rezepte --space "ivo&sarah" --icon book-open --column "protein_g=Protein (g):number" --column "vegan:boolean"'
+      ],
+      [
+        "A sync target pinned under a project",
+        'ente list create Firmen --space "ivo&thomas" --pin Recherche --column "repo:text" --column "stage:single-select:Kandidat,in Review,verfolgt,verworfen"'
       ]
     ]
   });
@@ -13803,13 +14107,20 @@ var ListCreate = class extends ClientCommand {
   icon = options_exports.String("--icon", {
     description: "Entity icon as named in the web icon picker (e.g. book-open, leaf, star)"
   });
+  pin = options_exports.Array("--pin", { description: "Pin the list under parent entities (resolved by name)" });
+  shareParents = options_exports.Boolean("--share-parents", false, {
+    description: "Share pinned parents and ancestors into the list's space when required"
+  });
+  parentSpaceGrantFingerprint = options_exports.String("--parent-space-grant-fingerprint", {
+    description: "Exact grantFingerprint returned by the confirmation-required error"
+  });
   async run() {
     if (this.type !== "topic" && this.type !== "project") {
       throw new Error(`--type must be 'topic' or 'project' (got '${this.type}').`);
     }
     const columns = (this.column ?? []).map(parseColumn);
-    const spaceId = await resolveSpaceByName(this.client(), this.space);
     const caller = await resolveCaller();
+    const spaceId = await resolveSpaceByNameC(caller, this.space);
     const entityId = await caller.mutation(entitiesCreate2, {
       spaceId,
       name: this.name,
@@ -13828,17 +14139,27 @@ var ListCreate = class extends ClientCommand {
     if (this.icon) {
       await caller.mutation(setCustomIcon, { id: entityId, icon: this.icon });
     }
+    const pins = await pinToTargets(caller, entityId, this.pin ?? [], {
+      shareParents: this.shareParents,
+      ...this.parentSpaceGrantFingerprint ? { parentSpaceGrantFingerprint: this.parentSpaceGrantFingerprint } : {}
+    });
+    const data = { entityId, name: this.name, type: this.type, columns, enabledTabs: DATABASE_LIST_TABS };
     this.emitText(
-      { data: { entityId, name: this.name, type: this.type, columns, enabledTabs: DATABASE_LIST_TABS } },
-      () => `Created list '${this.name}' (${entityId}) with ${columns.length} column${columns.length === 1 ? "" : "s"}; opens on its database view.`
+      pins.failures.length ? {
+        data: { ...data, pinFailures: pins.failures, pinSucceeded: pins.succeeded },
+        error: { message: "List created, but some parent relationships failed.", code: "PARTIAL_SUCCESS" }
+      } : { data: { ...data, ...pins.succeeded.length ? { pinSucceeded: pins.succeeded } : {} } },
+      () => `Created list '${this.name}' (${entityId}) with ${columns.length} column${columns.length === 1 ? "" : "s"}; opens on its database view.${pins.succeeded.length ? `
+Pinned to: ${pins.succeeded.join(", ")}` : ""}`
     );
+    failOnPinFailures((line) => this.err(line), `List '${this.name}'`, entityId, pins);
   }
 };
-var ListAdd = class extends ClientCommand {
+var ListAdd = class extends ProfileCommand {
   static paths = [["list", "add"]];
   static usage = Command.Usage({
     category: "List",
-    description: "Add a row (activity) to a database list",
+    description: "Add a row (activity) to a database list; with --key, update the row holding that key instead",
     examples: [
       [
         "Add a categorised idea",
@@ -13847,6 +14168,10 @@ var ListAdd = class extends ClientCommand {
       [
         "Add a recipe row whose body is the recipe",
         'ente list add Rezepte --title "Tofu-Wraps" --attr vegan=true --content-file tofu-wraps.md'
+      ],
+      [
+        "Upsert by a stable key column",
+        'ente list add Firmen --key repo --title "Acme" --attr repo=firmen.csv#42 --attr stage=Kandidat'
       ]
     ]
   });
@@ -13854,81 +14179,183 @@ var ListAdd = class extends ClientCommand {
   title = options_exports.String("--title", { description: "Row title" });
   type = options_exports.String("--type", "note", { description: "Row activity type: note (default) or task" });
   attr = options_exports.Array("--attr", { description: "Column values as key=value (coerced to the column type)" });
+  key = options_exports.String("--key", {
+    description: "Upsert: update the row whose <key> cell equals this row's --attr <key>=\u2026 instead of adding one"
+  });
   deadline = options_exports.String("--deadline", { description: "Deadline (only meaningful for --type task)" });
   space = options_exports.String("--space", { description: "Owner space (name or ID); default: the list's space" });
-  content = options_exports.String("--content", { description: "Row body as markdown" });
+  content = options_exports.String("--content", { description: "Row body as markdown (only used when the row is created)" });
   contentFile = options_exports.String("--content-file", { description: "Read the row body from a markdown file" });
   async run() {
     if (this.type !== "note" && this.type !== "task") {
       throw new Error(`--type must be 'note' or 'task' (got '${this.type}').`);
     }
-    const client = this.client();
-    const entityId = await resolveEntity(client, this.list);
     const caller = await resolveCaller();
-    const entity = await caller.query(findById, { id: entityId });
-    if (!entity) throw new Error(`List '${this.list}' not found or not accessible.`);
-    const columns = entity.databaseView?.columns ?? [];
-    const columnByKey = new Map(columns.map((c) => [c.key, c]));
-    const rawAttrs = parseAttrs(this.attr);
-    const coerced = [];
-    for (const [key, raw] of Object.entries(rawAttrs)) {
-      const col = columnByKey.get(key);
-      if (!col)
-        throw new Error(
-          `'${key}' is not a column of list '${entity.name}'. Columns: ${columns.map((c) => c.key).join(", ") || "(none)"}. Add it with: ente list column add "${entity.name}" ${key}:text`
-        );
-      coerced.push({ key, value: coerceValue(col.type, raw) });
-    }
-    const ownerSpaceId = await this.resolveOwnerSpace(entityId);
+    const { entityId, entity, view } = await loadList(caller, this.list);
+    const attributes = coerceAttributes(view.columns, parseAttrs(this.attr), entity.name);
+    const content = readContentOption(this.content, this.contentFile);
+    const input = {
+      line: 1,
+      attributes,
+      ...this.title !== void 0 ? { title: this.title } : {},
+      ...content !== void 0 ? { content } : {}
+    };
+    if (this.key !== void 0) columnOrThrow(view.columns, this.key, entity.name);
+    const existing = this.key !== void 0 ? (await fetchAllRows(caller, entityId)).map(toExisting) : [];
+    const keyColumn = this.key ?? "";
+    const step = this.key !== void 0 ? planUpsert(existing, [input], keyColumn)[0] : { action: "create", input, key: "" };
     const deadline = this.type === "task" && this.deadline ? parseDeadline(this.deadline) : void 0;
-    const contentMarkdown = readContentOption(this.content, this.contentFile);
-    const activityId = await caller.mutation(activitiesCreate3, {
-      entityId,
-      ownerSpaceId,
-      type: this.type,
-      title: this.title,
-      ...deadline !== void 0 ? { deadline } : {},
-      ...contentMarkdown !== void 0 ? { contentMarkdown } : {}
-    });
-    for (const { key, value } of coerced) {
-      await caller.mutation(setAttributeValue, { activityId, key, value });
-    }
+    const ownerSpaceId = step.action === "create" ? await resolveOwnerSpace(caller, entityId, this.space) : "";
+    const rowId = await applyStep(
+      { caller, entityId, ownerSpaceId, keyColumn, type: this.type, ...deadline !== void 0 ? { deadline } : {} },
+      step
+    );
+    const result = stepResult(step, rowId);
     this.emitText(
-      { data: { activityId, entityId, title: this.title ?? null, attributes: Object.fromEntries(coerced.map((c) => [c.key, c.value])) } },
-      () => `Added row '${this.title ?? "(untitled)"}' (${activityId}) to '${entity.name}'.`
+      { data: { ...result, activityId: rowId, entityId, title: this.title ?? null, attributes } },
+      () => result.action === "created" ? `Added row '${this.title ?? "(untitled)"}' (${rowId}) to '${entity.name}'.` : result.action === "updated" ? `Updated row ${rowId} in '${entity.name}': ${(result.changed ?? []).join(", ")}.${result.contentIgnored ? " (body left unchanged)" : ""}` : `Row ${rowId} in '${entity.name}' is unchanged.`
     );
   }
-  /** Owner space for the row: explicit --space, else the list's sole space. */
-  async resolveOwnerSpace(entityId) {
-    if (this.space) return resolveSpaceByName(this.client(), this.space);
+};
+function columnOrThrow(columns, key, listName) {
+  const col = columns.find((c) => c.key === key);
+  if (!col) throw new Error(`--key '${key}' is not a column of list '${listName}'.`);
+  if (col.type !== "text") throw new Error(`--key '${key}' must be a text column (it is ${col.type}).`);
+  return col;
+}
+function toExisting(row) {
+  return { rowId: row._id, title: row.title ?? null, attributes: row.attributes ?? {} };
+}
+var ListUpdate = class extends ProfileCommand {
+  static paths = [["list", "update"]];
+  static usage = Command.Usage({
+    category: "List",
+    description: "Change cells (and optionally the title) of one row of a database list",
+    examples: [
+      ["Move a row to another stage", "ente list update Firmen <rowId> --attr stage=verfolgt"],
+      ["Clear a cell", "ente list update Firmen <rowId> --attr notiz="]
+    ]
+  });
+  list = options_exports.String();
+  rowId = options_exports.String();
+  attr = options_exports.Array("--attr", { description: "Column values as key=value (coerced; empty value clears the cell)" });
+  title = options_exports.String("--title", { description: "New row title" });
+  async run() {
+    if (!this.attr?.length && this.title === void 0) throw new Error("Nothing to update. Pass --attr and/or --title.");
     const caller = await resolveCaller();
-    const spaces = await caller.query(listSpacesForEntity, { entityId });
-    if (spaces.length === 0)
-      throw new Error("The list is in no accessible space; pass --space explicitly.");
-    if (spaces.length > 1)
-      throw new Error(
-        `The list spans multiple spaces (${spaces.map((s) => s.name).join(", ")}); pass --space to choose one.`
-      );
-    return spaces[0]._id;
+    const { entityId, entity, view } = await loadList(caller, this.list);
+    const attributes = coerceAttributes(view.columns, parseAttrs(this.attr), entity.name);
+    const row = await caller.query(activitiesGetByIdRich3, { activityId: this.rowId });
+    if (!row) throw new Error(`Row ${this.rowId} not found or not accessible.`);
+    if (!(row.entityDetails ?? []).some((e) => e?._id === entityId))
+      throw new Error(`Activity ${this.rowId} is not a row of list '${entity.name}'.`);
+    if (this.title !== void 0) await caller.mutation(activitiesUpdateTitle3, { activityId: this.rowId, title: this.title });
+    for (const [key, value] of Object.entries(attributes))
+      await caller.mutation(setAttributeValue, { activityId: this.rowId, key, value });
+    this.emitText(
+      { data: { rowId: this.rowId, entityId, ...this.title !== void 0 ? { title: this.title } : {}, attributes } },
+      () => `Updated row ${this.rowId} in '${entity.name}': ${[
+        ...this.title !== void 0 ? ["title"] : [],
+        ...Object.keys(attributes)
+      ].join(", ")}.`
+    );
   }
 };
-async function loadListView(entityId, listNameOrId) {
-  const caller = await resolveCaller();
-  const entity = await caller.query(findById, { id: entityId });
-  if (!entity) throw new Error(`List '${listNameOrId}' not found or not accessible.`);
-  const stored = entity.databaseView;
-  return {
-    entityId,
-    entity,
-    view: {
-      version: 1,
-      columns: stored?.columns ?? [],
-      filters: stored?.filters ?? [],
-      sorts: stored?.sorts ?? []
+var ListImport = class extends ProfileCommand {
+  static paths = [["list", "import"]];
+  static usage = Command.Usage({
+    category: "List",
+    description: "Upsert rows from a JSONL file by a key column (created / updated / unchanged per row)",
+    details: `
+      One JSON object per line: {"title": "\u2026", "attrs": {"<key>": "\u2026", \u2026}, "content": "\u2026markdown\u2026"}.
+      Values are coerced to each column's type like --attr. The whole file is checked before the
+      first write: an unknown column, a bad value, a missing key or a key repeated in the file (or
+      held by two existing rows) fails the run. "content" is only written when a row is created.
+      Rows of the list that are not in the file are left alone.
+    `,
+    examples: [
+      ["Preview a sync", "ente list import Firmen --file firmen.jsonl --key repo --dry-run --json"],
+      ["Run it", "ente list import Firmen --file firmen.jsonl --key repo"]
+    ]
+  });
+  list = options_exports.String();
+  file = options_exports.String("--file", { required: true, description: "JSONL file, one row per line" });
+  key = options_exports.String("--key", { required: true, description: "Text column holding each row's stable key" });
+  dryRun = options_exports.Boolean("--dry-run", false, { description: "Plan only; write nothing" });
+  space = options_exports.String("--space", { description: "Owner space for new rows (name or ID); default: the list's space" });
+  concurrency = options_exports.String("--concurrency", "4", { description: "Rows written in parallel (1-16, default 4)" });
+  async run() {
+    const concurrency = Number(this.concurrency);
+    if (!Number.isInteger(concurrency) || concurrency < 1 || concurrency > 16)
+      throw new Error(`--concurrency must be an integer from 1 to 16 (got '${this.concurrency}').`);
+    const lines = parseImportLines(readFileSync10(this.file, "utf8"));
+    const caller = await resolveCaller();
+    const { entityId, entity, view } = await loadList(caller, this.list);
+    columnOrThrow(view.columns, this.key, entity.name);
+    const inputs = lines.map((l) => {
+      try {
+        return {
+          line: l.line,
+          attributes: coerceAttributes(view.columns, l.attrs, entity.name),
+          ...l.title !== void 0 ? { title: l.title } : {},
+          ...l.content !== void 0 ? { content: l.content } : {}
+        };
+      } catch (exc) {
+        throw new Error(`Line ${l.line}: ${errorMessage(exc)}`);
+      }
+    });
+    const existing = (await fetchAllRows(caller, entityId)).map(toExisting);
+    const steps = planUpsert(existing, inputs, this.key);
+    const needsSpace = steps.some((s) => s.action === "create");
+    const ownerSpaceId = needsSpace ? await resolveOwnerSpace(caller, entityId, this.space) : "";
+    const results = new Array(steps.length);
+    let failure = null;
+    if (this.dryRun) {
+      steps.forEach((step, i) => results[i] = stepResult(step, step.action === "create" ? null : step.rowId));
+    } else {
+      const ctx = { caller, entityId, ownerSpaceId, keyColumn: this.key, type: "note" };
+      let done = 0;
+      const writes = steps.map((step, index) => ({ step, index })).filter(({ step }) => step.action !== "unchanged");
+      steps.forEach((step, i) => {
+        if (step.action === "unchanged") results[i] = stepResult(step, step.rowId);
+      });
+      try {
+        await runPool(writes, concurrency, async ({ step, index }) => {
+          results[index] = stepResult(step, await applyStep(ctx, step));
+          done += 1;
+          if (done % 100 === 0) this.err(`\u2026 ${done}/${writes.length} rows written`);
+        });
+      } catch (exc) {
+        failure = errorMessage(exc);
+      }
     }
-  };
-}
-var ListColumnAdd = class extends ClientCommand {
+    const written = results.filter((r) => r !== void 0);
+    const counts = countActions(written);
+    const notWritten = steps.length - written.length;
+    const payload = {
+      entityId,
+      key: this.key,
+      dryRun: this.dryRun,
+      ...counts,
+      ...failure ? { notWritten } : {},
+      rows: written
+    };
+    this.emitText(
+      failure ? { data: payload, error: { message: failure, code: "IMPORT_FAILED" } } : { data: payload },
+      () => {
+        const head = `${this.dryRun ? "Dry run \u2014 would be " : ""}${counts.created} created, ${counts.updated} updated, ${counts.unchanged} unchanged in '${entity.name}'.`;
+        const changed = written.filter((r) => r.action !== "unchanged").map((r) => `  ${r.action.padEnd(8)} ${r.key} ${r.rowId ?? ""}${r.changed ? ` (${r.changed.join(", ")})` : ""}`);
+        return [head, ...changed].join("\n");
+      }
+    );
+    if (failure) {
+      this.err(`Error: ${failure}`);
+      this.err(`${notWritten} row(s) were not written. The import is an upsert \u2014 rerun it to continue.`);
+      throw new ExitWithCode(1);
+    }
+  }
+};
+var ListColumnAdd = class extends ProfileCommand {
   static paths = [["list", "column", "add"]];
   static usage = Command.Usage({
     category: "List",
@@ -13938,7 +14365,8 @@ var ListColumnAdd = class extends ClientCommand {
   list = options_exports.String();
   columns = options_exports.Rest({ required: 1 });
   async run() {
-    const { entityId, entity, view } = await loadListView(await resolveEntity(this.client(), this.list), this.list);
+    const caller = await resolveCaller();
+    const { entityId, entity, view } = await loadList(caller, this.list);
     const added = this.columns.map(parseColumn);
     const taken = new Set(view.columns.map((c) => c.key));
     for (const col of added) {
@@ -13946,7 +14374,6 @@ var ListColumnAdd = class extends ClientCommand {
       taken.add(col.key);
     }
     const columns = [...view.columns, ...added];
-    const caller = await resolveCaller();
     await caller.mutation(updateDatabaseView, { id: entityId, databaseView: { ...view, columns } });
     this.emitText(
       { data: { entityId, added, columns } },
@@ -13954,7 +14381,7 @@ var ListColumnAdd = class extends ClientCommand {
     );
   }
 };
-var ListColumnRemove = class extends ClientCommand {
+var ListColumnRemove = class extends ProfileCommand {
   static paths = [["list", "column", "remove"]];
   static usage = Command.Usage({
     category: "List",
@@ -13964,7 +14391,8 @@ var ListColumnRemove = class extends ClientCommand {
   list = options_exports.String();
   keys = options_exports.Rest({ required: 1 });
   async run() {
-    const { entityId, entity, view } = await loadListView(await resolveEntity(this.client(), this.list), this.list);
+    const caller = await resolveCaller();
+    const { entityId, entity, view } = await loadList(caller, this.list);
     const present = new Set(view.columns.map((c) => c.key));
     const missing = this.keys.filter((key) => !present.has(key));
     if (missing.length > 0) {
@@ -13972,7 +14400,6 @@ var ListColumnRemove = class extends ClientCommand {
         `Not a column of '${entity.name}': ${missing.join(", ")}. Columns: ${[...present].join(", ") || "(none)"}.`
       );
     }
-    const caller = await resolveCaller();
     let current = view;
     for (const key of this.keys) {
       await caller.mutation(removeDatabaseColumn, { id: entityId, key, databaseView: current });
@@ -13984,33 +14411,59 @@ var ListColumnRemove = class extends ClientCommand {
     );
   }
 };
-var ListShow = class extends ClientCommand {
+var ListShow = class extends ProfileCommand {
   static paths = [["list", "show"]];
   static usage = Command.Usage({
     category: "List",
-    description: "Show the rows of a database list"
+    description: "Show the rows of a database list (all rows, newest first; --view applies the table's saved filters)",
+    examples: [
+      ["Every row, for a script", "ente list show Firmen --all --json"],
+      ["Only followed rows", "ente list show Firmen --all --where stage=verfolgt"],
+      ["Page by page", "ente list show Firmen --limit 100 --cursor <nextCursor> --json"]
+    ]
   });
   list = options_exports.String();
-  limit = options_exports.String("--limit", { description: "Max rows (default 100)" });
+  limit = options_exports.String("--limit", { description: "Rows per page (default 100); ignored with --all" });
+  cursor = options_exports.String("--cursor", { description: "Continue from the nextCursor of a previous page" });
+  all = options_exports.Boolean("--all", false, { description: "Read every page" });
+  where = options_exports.Array("--where", {
+    description: "Keep rows whose cell equals key=value (repeatable, all must match; multi-select: contains)"
+  });
+  view = options_exports.Boolean("--view", false, { description: "Apply the table's saved filters and sorts" });
   async run() {
-    const entityId = await resolveEntity(this.client(), this.list);
+    if (this.all && this.cursor) throw new Error("Use --all or --cursor, not both.");
+    const numItems = this.limit === void 0 ? ROW_PAGE_SIZE : Number(this.limit);
+    if (!Number.isInteger(numItems) || numItems < 1 || numItems > 200)
+      throw new Error(`--limit must be an integer from 1 to 200 (got '${this.limit}').`);
     const caller = await resolveCaller();
-    const numItems = this.limit ? Number(this.limit) : 100;
-    const res = await caller.query(listRows, {
-      entityId,
-      paginationOpts: { numItems, cursor: null }
-    });
-    this.emitText({ data: { rows: res.page, isDone: res.isDone } }, () => {
-      if (res.page.length === 0) return "(no rows)";
-      return res.page.map((row) => {
-        const attrs = row.attributes ?? {};
-        const attrStr = Object.entries(attrs).filter(([, v2]) => v2 !== null && v2 !== void 0 && !(Array.isArray(v2) && v2.length === 0)).map(([k, v2]) => `${k}=${Array.isArray(v2) ? v2.join(",") : String(v2)}`).join("  ");
-        return `- ${row.title || "(untitled)"}${attrStr ? `   [${attrStr}]` : ""}`;
-      }).join("\n");
-    });
+    const { entityId, entity, view } = await loadList(caller, this.list);
+    const clauses = parseWhere(view.columns, this.where ?? [], entity.name);
+    const rows = [];
+    let cursor = this.cursor ?? null;
+    let nextCursor = null;
+    for (; ; ) {
+      const res = await caller.query(listRows, {
+        entityId,
+        ...this.view ? {} : { ignoreViewFilters: true },
+        paginationOpts: { numItems, cursor }
+      });
+      rows.push(...res.page);
+      nextCursor = res.isDone ? null : res.continueCursor;
+      if (!this.all || nextCursor === null) break;
+      cursor = nextCursor;
+    }
+    const kept = rows.filter((row) => matchesWhere(row.attributes, clauses));
+    this.emitText(
+      { data: { entityId, rows: kept.map(rowJson), count: kept.length, nextCursor, isDone: nextCursor === null } },
+      () => {
+        const body = kept.length === 0 ? "(no rows)" : kept.map(rowLine).join("\n");
+        return nextCursor ? `${body}
+\u2026 more rows: --cursor ${nextCursor} (or --all)` : body;
+      }
+    );
   }
 };
-var LIST_COMMANDS = [ListCreate, ListAdd, ListColumnAdd, ListColumnRemove, ListShow];
+var LIST_COMMANDS = [ListCreate, ListAdd, ListUpdate, ListImport, ListColumnAdd, ListColumnRemove, ListShow];
 
 // ente/diagnosticContract.ts
 var DIAGNOSTICS_LIMITS = { rows: 100, bytes: 1048576, windowMs: 6048e5, cursorChars: 8192, grantHours: 24 };
@@ -14720,7 +15173,7 @@ var QUERY_COMMANDS = [QueryCmd];
 
 // ente/commands/recordingPipeline.ts
 import { spawnSync } from "node:child_process";
-import { mkdtempSync, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "node:fs";
+import { mkdtempSync, readFileSync as readFileSync11, writeFileSync as writeFileSync6 } from "node:fs";
 import { tmpdir } from "node:os";
 import path5 from "node:path";
 var getVoicePipelineSettings = makeFunctionReference("users:getVoicePipelineSettings");
@@ -14736,7 +15189,7 @@ async function resolveValue(cmd, label, current) {
   if (cmd.edit) return editInEditor(current, label);
   if (cmd.file) {
     if (cmd.file === "-") return await readStdin();
-    return readFileSync10(cmd.file, "utf8");
+    return readFileSync11(cmd.file, "utf8");
   }
   if (cmd.value !== void 0) return cmd.value;
   throw new Error(`No ${label} given. Pass a value, --file <path> (or --file -), or --edit.`);
@@ -14750,7 +15203,7 @@ function editInEditor(initial, label) {
   if (res.status !== 0) {
     throw new Error(`Editor '${editor}' exited with a non-zero status; ${label} unchanged.`);
   }
-  return readFileSync10(file, "utf8");
+  return readFileSync11(file, "utf8");
 }
 function readStdin() {
   return new Promise((resolve2, reject) => {
@@ -15313,7 +15766,7 @@ function parseAgentIconInput(raw) {
 }
 
 // ente/commands/agent.ts
-import { readFileSync as readFileSync11 } from "node:fs";
+import { readFileSync as readFileSync12 } from "node:fs";
 import { randomUUID } from "node:crypto";
 
 // ente/agentCaller.ts
@@ -15630,7 +16083,7 @@ var AgentSend = class extends ClientCommand {
         threadId: this.threadId,
         claimId,
         text: this.message,
-        ...this.htmlFile ? { html: readFileSync11(this.htmlFile, "utf8") } : {},
+        ...this.htmlFile ? { html: readFileSync12(this.htmlFile, "utf8") } : {},
         ...this.request === "none" ? {} : { requestKind: this.request },
         ...this.requestPrompt ? { requestPrompt: this.requestPrompt } : {},
         idempotencyKey: this.idempotencyKey ?? randomUUID()
@@ -15669,7 +16122,7 @@ var AgentNew = class extends ClientCommand {
       const response = await client.createAgentThread({
         title: this.title,
         text: this.message,
-        ...this.htmlFile ? { html: readFileSync11(this.htmlFile, "utf8") } : {},
+        ...this.htmlFile ? { html: readFileSync12(this.htmlFile, "utf8") } : {},
         ...this.request === "none" ? {} : { requestKind: this.request },
         ...this.requestPrompt ? { requestPrompt: this.requestPrompt } : {},
         idempotencyKey: this.idempotencyKey ?? randomUUID()
@@ -15716,7 +16169,7 @@ var AgentConfigSetPrompt = class extends ClientCommand {
     if (!!this.prompt === !!this.file) {
       throw new Error("Provide exactly one of --text or --file.");
     }
-    const prompt = this.file ? readFileSync11(this.file, "utf8") : this.prompt;
+    const prompt = this.file ? readFileSync12(this.file, "utf8") : this.prompt;
     const client = await boundAgentClient(this.client(), await this.client().getAuthContext());
     const { data } = await client.updateAgentPrompt(prompt);
     this.emitText({ data }, () => `Updated Ente prompt configuration for ${data.name}.`);
@@ -15730,7 +16183,7 @@ var AgentSchedulesConfigure = class extends ClientCommand {
   });
   file = options_exports.String("--file", { required: true, description: "JSON file containing an array of schedules" });
   async run() {
-    const parsed = JSON.parse(readFileSync11(this.file, "utf8"));
+    const parsed = JSON.parse(readFileSync12(this.file, "utf8"));
     if (!Array.isArray(parsed)) {
       throw new Error("The schedules file must contain a JSON array.");
     }
@@ -15755,7 +16208,7 @@ var AGENT_COMMANDS = [
 ];
 
 // ente/commands/agenda.ts
-import { readFileSync as readFileSync12 } from "node:fs";
+import { readFileSync as readFileSync13 } from "node:fs";
 var AgendaPointCreate = class extends ClientCommand {
   static paths = [["agenda", "create-point"]];
   static usage = Command.Usage({
@@ -15785,7 +16238,7 @@ var AgendaPointCreate = class extends ClientCommand {
   async run() {
     if (this.content !== void 0 && this.contentFile !== void 0)
       throw new Error("Use either --content or --content-file, not both.");
-    const contentMarkdown = this.content !== void 0 ? this.content : this.contentFile !== void 0 ? readFileSync12(this.contentFile, "utf8") : void 0;
+    const contentMarkdown = this.content !== void 0 ? this.content : this.contentFile !== void 0 ? readFileSync13(this.contentFile, "utf8") : void 0;
     const result = await this.client().createAgendaPoint({
       meetingActivityId: this.activity,
       title: this.title,
@@ -16549,7 +17002,7 @@ var CANVAS_COMMANDS = [
 ];
 
 // ente/commands/notification.ts
-import { readFileSync as readFileSync13 } from "node:fs";
+import { readFileSync as readFileSync14 } from "node:fs";
 
 // ente/notificationEmailContract.ts
 var NOTIFICATION_EMAIL_CLI_SURFACE = {
@@ -16583,7 +17036,7 @@ var CLI_LIMITS = NOTIFICATION_EMAIL_CLI_SURFACE.limits;
 function readBody(inline, file, label) {
   if (inline !== void 0 && file !== void 0)
     throw new Error(`notification send: use either --${label} or --${label}-file, not both.`);
-  const value = file !== void 0 ? readFileSync13(file, "utf8") : inline;
+  const value = file !== void 0 ? readFileSync14(file, "utf8") : inline;
   if (value !== void 0 && !value.trim())
     throw new Error(`notification send: ${label} body must not be empty.`);
   return value;
@@ -16885,7 +17338,7 @@ function parseUserMailboxRequest(input) {
 
 // ente/commands/agentMail.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { readFileSync as readFileSync14 } from "node:fs";
+import { readFileSync as readFileSync15 } from "node:fs";
 
 // ente/agentMailContract.ts
 var AGENT_MAIL_CLI_SURFACE = {
@@ -17085,7 +17538,7 @@ function readBody2(inline, file, label) {
   if (inline !== void 0 && file !== void 0) {
     throw new Error(`agent mail: use either --${label} or --${label}-file, not both.`);
   }
-  const value = file === void 0 ? inline : readFileSync14(file, "utf8");
+  const value = file === void 0 ? inline : readFileSync15(file, "utf8");
   if (value !== void 0 && !value.trim()) {
     throw new Error(`agent mail: ${label} body must not be empty.`);
   }
@@ -17378,7 +17831,7 @@ var UserMailboxCommand = class extends ClientCommand {
   requestFile = options_exports.String("--request-file", { description: "Read the complete operation JSON from a file" });
   async run() {
     if (this.request === void 0 === (this.requestFile === void 0)) throw new Error("Use exactly one of --request or --request-file");
-    const parsed = parseUserMailboxRequest(JSON.parse(this.request ?? readFileSync14(this.requestFile, "utf8")));
+    const parsed = parseUserMailboxRequest(JSON.parse(this.request ?? readFileSync15(this.requestFile, "utf8")));
     if ("error" in parsed) throw new Error(parsed.error);
     const result = await this.client().userMailbox(parsed.value);
     this.emitText(result, () => JSON.stringify(result.data, null, 2));