@wirecat/mail-cli 0.0.0-stage → 0.1.0

package/dist/bundle/chunk-3E3WA2L6.js

@@ -0,0 +1,1932 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  OFFLINE,
+  capability,
+  chatIdIn,
+  refuseLacking,
+  servicesFor,
+  throughWrapper
+} from "./chunk-T6464KYA.js";
+import {
+  foldName,
+  isId,
+  pickPerson
+} from "./chunk-WXAXYJJ7.js";
+import {
+  LOG_ATTRIBUTES,
+  MESSENGER_CHANGE_REFUSAL,
+  asFirstWord,
+  baseContext,
+  codeOf,
+  currentOperation,
+  currentRun,
+  environmentOf,
+  fromLogAttributes,
+  issueMessage,
+  logAttributes,
+  permissionIssues,
+  publicIssue,
+  readOnlyRefusal,
+  recalledAccount,
+  rememberAccount,
+  rootOf2 as rootOf
+} from "./chunk-GQQJOH7A.js";
+import {
+  AUTHORITY_KEY,
+  CEILING_KEY,
+  DEFAULT_PERMISSIONS,
+  WRITE_KEYS,
+  keyForCommand,
+  keyForWrite,
+  levelFor,
+  readKeysForCommand,
+  skipFlagFor
+} from "./chunk-QLEUNU6G.js";
+import {
+  isCliFailure,
+  providerErrorKey
+} from "./chunk-7SXGLT6T.js";
+import {
+  servingProfiles
+} from "./chunk-TE5U5OAM.js";
+import {
+  openStore
+} from "./chunk-NK7EB63L.js";
+import {
+  logRecordOf,
+  realSleep,
+  resolvePaths,
+  writeSecurely
+} from "./chunk-J3QXTBD2.js";
+import {
+  CliError
+} from "./chunk-5BVIWP3S.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/sends/guard.js
+import { randomUUID } from "node:crypto";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/sends/flood.js
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+var MOST_DEADLINES = 50;
+var LIMITED_HOLD_MS = 60 * 60 * 1e3;
+var FROZEN_HOLD_MS = 24 * 60 * 60 * 1e3;
+var NO_END = "9999-12-31T23:59:59.999Z";
+var holdEnd = /* @__PURE__ */ __name((block, show = (iso) => iso) => block.until === null ? "until lifted" : `until ${show(block.until)}`, "holdEnd");
+var floodPathFor = /* @__PURE__ */ __name((app, profile, env = process.env) => join(resolvePaths({ appName: app.appName, prefix: app.envPrefix, env }).state, "flood", `${profile}.json`), "floodPathFor");
+var FloodMemory = class {
+  static {
+    __name(this, "FloodMemory");
+  }
+  path;
+  now;
+  constructor(path, now = Date.now) {
+    this.path = path;
+    this.now = now;
+  }
+  /** What is still in force; anything expired is left out. */
+  read() {
+    const now = this.now();
+    let raw;
+    try {
+      raw = JSON.parse(readFileSync(this.path, "utf8"));
+    } catch {
+      return { deadlines: [] };
+    }
+    const alive = /* @__PURE__ */ __name((until) => typeof until === "string" && Date.parse(until) > now, "alive");
+    const deadlines = Array.isArray(raw.deadlines) ? raw.deadlines.filter((one) => typeof one?.operation === "string" && alive(one.until)) : [];
+    const block = raw.sendBlock && (raw.sendBlock.until === NO_END ? { ...raw.sendBlock, until: null } : raw.sendBlock);
+    const held = block && (block.until === null || alive(block.until));
+    return { deadlines, ...held ? { sendBlock: block } : {} };
+  }
+  /** The deadline this call is still under: one for its chat, or one for the call in every chat. */
+  owed(operation, chatId) {
+    return this.read().deadlines.filter((one) => one.operation === operation && (one.chatId === void 0 || one.chatId === chatId)).sort((a, b) => b.until.localeCompare(a.until))[0];
+  }
+  remember(deadline) {
+    const { waitMs, ...rest } = deadline;
+    const kept = { ...rest, until: new Date(this.now() + waitMs).toISOString() };
+    const state = this.read();
+    const others = state.deadlines.filter((one) => one.operation !== kept.operation || one.chatId !== kept.chatId);
+    const deadlines = [...others, kept].sort((a, b) => b.until.localeCompare(a.until)).slice(0, MOST_DEADLINES);
+    this.#write({ ...state, deadlines });
+    return kept;
+  }
+  sendBlock() {
+    return this.read().sendBlock;
+  }
+  /** A ban the messenger gave no end for holds until lifted; a spam limit or a freeze without one, for a while. */
+  block(block) {
+    const now = this.now();
+    const holdMs = { limited: LIMITED_HOLD_MS, frozen: FROZEN_HOLD_MS, banned: void 0 }[block.state];
+    const kept = {
+      ...block,
+      since: new Date(now).toISOString(),
+      until: block.until ?? (holdMs === void 0 ? null : new Date(now + holdMs).toISOString())
+    };
+    this.#write({ ...this.read(), sendBlock: kept });
+    return kept;
+  }
+  /** Lifts only a block of this state: an account found not frozen may still be limited for spam. */
+  unblock(state) {
+    const { sendBlock, ...rest } = this.read();
+    if (sendBlock?.state === state)
+      this.#write(rest);
+  }
+  /** Forgets every wait and lifts the hold, and answers with what was still in force. */
+  clear() {
+    const cleared = this.read();
+    this.#write({ deadlines: [] });
+    return cleared;
+  }
+  #write({ sendBlock, ...rest }) {
+    const state = sendBlock ? { ...rest, sendBlock: { ...sendBlock, until: sendBlock.until ?? NO_END } } : rest;
+    mkdirSync(dirname(this.path), { recursive: true, mode: 448 });
+    const temporary = `${this.path}.${process.pid}.tmp`;
+    writeFileSync(temporary, `${JSON.stringify(state)}
+`, { mode: 384 });
+    renameSync(temporary, this.path);
+  }
+};
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/sends/journal.js
+import { appendFileSync, mkdirSync as mkdirSync3, readFileSync as readFileSync2 } from "node:fs";
+import { dirname as dirname3, join as join2 } from "node:path";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/sends/file-lock.js
+import { closeSync, mkdirSync as mkdirSync2, openSync, statSync, unlinkSync } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+var LOCK_WAIT_MS = 5e3;
+var LOCK_STALE_MS = 3e4;
+var RETRY_MS = 20;
+var pause = new Int32Array(new SharedArrayBuffer(4));
+var withFileLock = /* @__PURE__ */ __name((path, what2, body, waitMs = LOCK_WAIT_MS) => {
+  const lock = lockFor(path);
+  const deadline = Date.now() + waitMs;
+  while (!taken(lock)) {
+    if (Date.now() >= deadline)
+      throw lockTimeout(what2, waitMs, lock);
+    Atomics.wait(pause, 0, 0, RETRY_MS);
+  }
+  return holding(lock, body);
+}, "withFileLock");
+var withFileLockAsync = /* @__PURE__ */ __name(async (path, what2, body, waitMs = LOCK_WAIT_MS, sleep = realSleep) => {
+  const lock = lockFor(path);
+  const deadline = Date.now() + waitMs;
+  while (!taken(lock)) {
+    if (Date.now() >= deadline)
+      throw lockTimeout(what2, waitMs, lock);
+    await sleep(RETRY_MS);
+  }
+  return holding(lock, body);
+}, "withFileLockAsync");
+var lockFor = /* @__PURE__ */ __name((path) => {
+  mkdirSync2(dirname2(path), { recursive: true, mode: 448 });
+  return `${path}.lock`;
+}, "lockFor");
+var taken = /* @__PURE__ */ __name((lock) => {
+  for (; ; ) {
+    try {
+      closeSync(openSync(lock, "wx", 384));
+      return true;
+    } catch (error) {
+      if (error.code !== "EEXIST")
+        throw error;
+      if (Date.now() - lockTime(lock) <= LOCK_STALE_MS)
+        return false;
+      try {
+        unlinkSync(lock);
+      } catch {
+      }
+    }
+  }
+}, "taken");
+var holding = /* @__PURE__ */ __name((lock, body) => {
+  try {
+    return body();
+  } finally {
+    try {
+      unlinkSync(lock);
+    } catch {
+    }
+  }
+}, "holding");
+var lockTimeout = /* @__PURE__ */ __name((what2, waitMs, lock) => new CliError("timeout", `${what2} stayed locked for ${waitMs / 1e3}s (${lock})`), "lockTimeout");
+var lockTime = /* @__PURE__ */ __name((lock) => {
+  try {
+    return statSync(lock).mtimeMs;
+  } catch {
+    return Date.now();
+  }
+}, "lockTime");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/sends/journal.js
+var sendsPathFor = /* @__PURE__ */ __name((app, profile, env = process.env) => join2(resolvePaths({ appName: app.appName, prefix: app.envPrefix, env }).state, "sends", `${profile}.jsonl`), "sendsPathFor");
+var SendJournal = class {
+  static {
+    __name(this, "SendJournal");
+  }
+  path;
+  resource;
+  constructor(path, resource = { service: "unknown", version: "unknown" }) {
+    this.path = path;
+    this.resource = resource;
+  }
+  /**
+   * Runs `body` with the journal to itself, across processes: two sends at the limit must not both
+   * read "one left". A lock file opened with `wx`, because `flock` is not there on Windows.
+   */
+  locked(body) {
+    return withFileLock(this.path, "the send journal", body);
+  }
+  /** `locked` without blocking the thread while another process holds the journal: what `serve` uses. */
+  lockedAsync(body) {
+    return withFileLockAsync(this.path, "the send journal", body);
+  }
+  append(entry) {
+    const { at, ...attributes } = entry;
+    const { runId, command, traceId } = currentRun();
+    const record = logRecordOf({
+      severity: entry.outcome === "sent" || entry.outcome === "reserved" ? "info" : "warn",
+      event: logAttributes({ event: "send.recorded", ...attributes }),
+      time: at,
+      runId,
+      ...traceId === void 0 ? {} : { traceId },
+      command,
+      resource: this.resource,
+      allow: LOG_ATTRIBUTES
+    });
+    mkdirSync3(dirname3(this.path), { recursive: true, mode: 448 });
+    appendFileSync(this.path, `${JSON.stringify(record)}
+`, { mode: 384 });
+  }
+  /**
+   * Oldest first, each reservation folded into its outcome; one with no outcome yet is in flight,
+   * or its process died. A line that does not parse is skipped: a torn last write must not block sending.
+   */
+  entries(filter) {
+    const lines = this.#lines();
+    const settled2 = new Set(lines.filter((entry) => entry.outcome !== "reserved").map((entry) => entry.reservation));
+    const entries = lines.filter((entry) => entry.outcome !== "reserved" || !settled2.has(entry.reservation)).map(({ reservation, ...entry }) => entry.outcome === "reserved" ? { ...entry, reservation } : entry).map(withSendId);
+    return filter === void 0 ? entries : entries.filter((entry) => (filter.outcome === void 0 || entry.outcome === filter.outcome) && (filter.chatId === void 0 || entry.chatId === filter.chatId) && (filter.operationId === void 0 || entry.operationId === filter.operationId) && (filter.errorCode === void 0 || entry.errorCode === filter.errorCode) && (filter.key === void 0 || entry.key === filter.key));
+  }
+  #lines() {
+    let text;
+    try {
+      text = readFileSync2(this.path, "utf8");
+    } catch {
+      return [];
+    }
+    return text.split("\n").filter((line) => line.trim() !== "").flatMap((line) => {
+      try {
+        return [entryOf(JSON.parse(line))];
+      } catch {
+        return [];
+      }
+    });
+  }
+};
+var entryOf = /* @__PURE__ */ __name((line) => {
+  if (!("attributes" in line))
+    return line;
+  const { event: _, ...attributes } = line.attributes;
+  return { at: line.time, ...fromLogAttributes(attributes) };
+}, "entryOf");
+var withSendId = /* @__PURE__ */ __name((entry) => {
+  const { cid, ...rest } = entry;
+  return cid === void 0 || rest.sendId !== void 0 ? rest : { ...rest, sendId: String(cid) };
+}, "withSendId");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/sends/recipients.js
+import { existsSync, readFileSync as readFileSync3, rmSync } from "node:fs";
+import { join as join3 } from "node:path";
+var recipientsPathFor = /* @__PURE__ */ __name((app, profile, env = process.env) => join3(resolvePaths({ appName: app.appName, prefix: app.envPrefix, env }).state, "profiles", `${profile}.recipients.json`), "recipientsPathFor");
+var RecipientList = class {
+  static {
+    __name(this, "RecipientList");
+  }
+  path;
+  command;
+  lockWaitMs;
+  /** `command` names the program in the hint that turns the list off. */
+  constructor(path, command, lockWaitMs) {
+    this.path = path;
+    this.command = command;
+    this.lockWaitMs = lockWaitMs;
+  }
+  /** `undefined` when the list is off. A file that cannot be read refuses rather than opening up. */
+  read() {
+    if (!existsSync(this.path))
+      return void 0;
+    try {
+      const parsed = JSON.parse(readFileSync3(this.path, "utf8"));
+      if (!Array.isArray(parsed.chats))
+        throw new Error("no `chats` array");
+      return parsed.chats;
+    } catch (error) {
+      throw new CliError("configuration_error", `the recipient list ${this.path} cannot be read (${error instanceof Error ? error.message : String(error)}) \u2014 fix the file or turn the list off with \`${this.command} recipients clear\``);
+    }
+  }
+  list(filter = {}) {
+    const chats = this.read();
+    return {
+      state: chats === void 0 ? "off" : chats.length === 0 ? "empty" : "on",
+      items: (chats ?? []).filter((chat) => (filter.id === void 0 || chat.id === filter.id) && (filter.title === void 0 || chat.title?.toLocaleLowerCase() === filter.title.toLocaleLowerCase()))
+    };
+  }
+  /** Whether it was new. Adding one again fills in a partner an older entry was stored without. */
+  add(recipient) {
+    return this.#locked(() => this.#added(recipient));
+  }
+  /** `add` waiting for the lock on timers: `recipients add` connects, so it runs inside `serve` when one holds the account. */
+  addAsync(recipient) {
+    return withFileLockAsync(this.path, "the recipient list", () => this.#added(recipient), this.lockWaitMs);
+  }
+  #added(recipient) {
+    const chats = this.read() ?? [];
+    const known = chats.find((chat) => chat.id === recipient.id);
+    if (known) {
+      if (recipient.partnerId && !known.partnerId) {
+        this.#write(chats.map((chat) => chat === known ? { ...known, partnerId: recipient.partnerId } : chat));
+      }
+      return false;
+    }
+    this.#write([...chats, recipient]);
+    return true;
+  }
+  /** The id or the title as it was stored; `undefined` when neither matched. */
+  remove(reference) {
+    return this.#locked(() => {
+      const chats = this.read() ?? [];
+      const wanted = reference.trim();
+      const gone = chats.find((chat) => chat.id === wanted) ?? chats.find((chat) => chat.title?.toLocaleLowerCase() === wanted.toLocaleLowerCase());
+      if (gone)
+        this.#write(chats.filter((chat) => chat !== gone));
+      return gone;
+    });
+  }
+  /**
+   * The chat the messenger now names `to`: its entry, and a partner of that id, follow it. Only an entry already there
+   * changes, and no list is created, so the list never opens up. Whether anything changed.
+   */
+  async rekey(from, to) {
+    if (from === to)
+      return false;
+    return withFileLockAsync(this.path, "the recipient list", () => {
+      const chats = this.read();
+      if (!chats?.some((chat) => chat.id === from || chat.partnerId === from))
+        return false;
+      const held = chats.some((chat) => chat.id === to);
+      this.#write(chats.filter((chat) => !(held && chat.id === from)).map((chat) => ({
+        ...chat,
+        ...chat.id === from ? { id: to } : {},
+        ...chat.partnerId === from ? { partnerId: to } : {}
+      })));
+      return true;
+    }, this.lockWaitMs);
+  }
+  /** Whether there was a list to turn off. */
+  off() {
+    return this.#locked(() => {
+      if (!existsSync(this.path))
+        return false;
+      rmSync(this.path);
+      return true;
+    });
+  }
+  /**
+   * Every change reads and writes under one lock: a `serve` re-keying while the owner removes a chat must not write
+   * the removed chat back. A lock held too long refuses the change and leaves the list as it was. Blocks the thread
+   * while it waits: for callers that cannot be async, and `recipients remove` and `clear`, which never
+   * connect and so never run inside `serve`.
+   */
+  #locked(body) {
+    return withFileLock(this.path, "the recipient list", body, this.lockWaitMs);
+  }
+  #write(chats) {
+    writeSecurely(this.path, `${JSON.stringify({ chats }, null, 2)}
+`, 384);
+  }
+};
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/sends/guard.js
+var HOUR_MS = 60 * 60 * 1e3;
+var READS_UNDER_HOLD = /* @__PURE__ */ new Set([
+  "attachments.extract",
+  "conversations.embeddings",
+  "conversations.links",
+  "messages.server-search",
+  "messages.sync-first",
+  "stats.contacts.top.sync-first",
+  "stats.messages.counters.sync",
+  "stats.messages.show.sync-first",
+  "stats.messages.top.sync-first",
+  "store.gaps.repair"
+]);
+var countsTowardLimit = /* @__PURE__ */ __name(({ kind = "message", action, notify }) => kind === "message" || kind === "forward" || kind === "edit" || kind === "delete" || kind === "pin" && notify === true || action === "create" || action === "members.add" || action === "requests.accept" || action === "join" || action === "contact-import", "countsTowardLimit");
+var weightOf = /* @__PURE__ */ __name(({ kind = "message", action, count, people }) => kind === "delete" || kind === "message" && action === void 0 ? Math.max(1, count ?? 1) : action === "create" || action === "members.add" || action === "requests.accept" || action === "contact-import" ? Math.max(1, people ?? count ?? 1) : 1, "weightOf");
+var timeOf = /* @__PURE__ */ __name((entry) => Date.parse(entry.scheduledFor ?? entry.at), "timeOf");
+var ceilingRefusal = /* @__PURE__ */ __name((key, command) => new CliError("permission_error", `${key} is not allowed: setup's answer keeps every WireCat tool read-only; the owner changes it at a terminal with \`${command} setup\``, { permission: key }), "ceilingRefusal");
+var levelRefusal = /* @__PURE__ */ __name((refused, fix = `${refused.command} ${refused.profile} config set permissions.${refused.key} allow`) => refused.named === CEILING_KEY ? ceilingRefusal(refused.key, refused.command) : new CliError("permission_error", `profile ${refused.profile} does not let ${refused.key} write (permissions.${refused.named} is ${refused.level}, from the ${refused.permissionSources[refused.named ?? ""] ?? "default"}); to allow it: ${fix}`, { permission: refused.key }), "levelRefusal");
+var sendGuard = /* @__PURE__ */ __name(({ profile, recipients, command = recipients.command, readOnlyLock, permissions, permissionSources = {}, permissionDefaults, permissionFix, ask = refuseToAsk, sendsPerHour, journal, flood, warn, now = /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "now") }) => {
+  const currentPermissions = /* @__PURE__ */ __name(() => typeof permissions === "function" ? permissions() : permissions, "currentPermissions");
+  let reservation;
+  const answered = /* @__PURE__ */ new WeakSet();
+  const refuseReadOnly = /* @__PURE__ */ __name(() => {
+    if (readOnlyLock)
+      throw readOnlyRefusal(readOnlyLock, MESSENGER_CHANGE_REFUSAL);
+  }, "refuseReadOnly");
+  const refuseHeld = /* @__PURE__ */ __name(({ key }) => {
+    if (key !== void 0 && READS_UNDER_HOLD.has(key))
+      return;
+    const block = flood?.sendBlock();
+    if (!block)
+      return;
+    throw new CliError("permission_error", `profile ${profile} holds its writes ${holdEnd(block)}: ${block.hint} \u2014 reads still work; do not retry: the owner checks the account with \`${command} ${profile} doctor --online\`, and lifts the hold with \`${command} ${profile} flood clear\` once it is over`, { sendBlock: block, standing: { state: block.state, hint: block.hint } });
+  }, "refuseHeld");
+  const permitted = /* @__PURE__ */ __name((request) => {
+    const { chatId, kind = "message", action, personIds } = request;
+    refuseReadOnly();
+    const levels = currentPermissions();
+    if (levels !== void 0) {
+      const key = request.key ?? keyForWrite(kind, action);
+      const { level, key: named } = levelFor(levels, key, permissionDefaults);
+      if (level === "deny" || level === "readonly")
+        throw levelRefusal({ profile, command, key, level, named, permissionSources }, permissionFix?.(request, key));
+      if (level === "ask" && !answered.has(request)) {
+        throw new CliError("confirmation_required", `${key} asks before it acts, and it was not asked`);
+      }
+    }
+    const allowed = recipients.read();
+    if (chatId !== null && allowed && !allowed.some((chat) => chat.id === chatId)) {
+      throw new CliError("confirmation_required", `chat ${chatId} is not on the recipient list of profile ${profile} \u2014 the owner adds it with \`${command} ${profile} recipients add ${chatId}\``, { chat_id: chatId });
+    }
+    const strangers = allowed ? (personIds ?? []).filter((id) => !allowed.some((chat) => chat.partnerId === id)) : [];
+    if (strangers.length > 0) {
+      throw new CliError("confirmation_required", `${strangers.join(", ")} ${strangers.length === 1 ? "is" : "are"} not on the recipient list of profile ${profile} \u2014 the owner adds the one-to-one chat with each person (\`${command} ${profile} recipients add <chat>\`); a chat added to the list earlier is added again to be recognised`, { person_ids: strangers });
+    }
+  }, "permitted");
+  const withinLimit = /* @__PURE__ */ __name((request, entries) => {
+    const { chatId, sendId } = request;
+    const asked = { ...request, people: request.personIds?.length ?? request.count };
+    const count = weightOf(asked);
+    if (count > sendsPerHour) {
+      throw new CliError("rate_limited", `${count} at once is more than the hourly limit of profile ${profile} (sendsPerHour ${sendsPerHour}) \u2014 do fewer at a time`);
+    }
+    const at = request.scheduledFor ? Date.parse(request.scheduledFor) : now().getTime();
+    const counted = entries.filter(countsTowardLimit).filter((entry) => entry.outcome === "sent" || entry.outcome === "outcome_unknown" || entry.outcome === "reserved").filter((entry) => Math.abs(timeOf(entry) - at) < HOUR_MS);
+    const unsure = /* @__PURE__ */ __name((entry) => entry.outcome === "outcome_unknown", "unsure");
+    const same = /* @__PURE__ */ __name((a, b) => a.sendId !== void 0 && a.sendId === b.sendId && a.chatId === b.chatId, "same");
+    const last = [...counted].reverse().find((entry) => same(entry, { chatId, sendId }));
+    if (sendId !== void 0 && last && unsure(last)) {
+      if (last.sendAs !== request.sendAs) {
+        throw new CliError("validation_error", "this send id was tried under another identity; repeat it with the same --send-as, or it may post twice", { operation_id: sendId, retryable: false });
+      }
+      return false;
+    }
+    const recent = counted.filter((entry, index) => !(unsure(entry) && counted.slice(index + 1).some((later) => same(later, entry)))).map((entry) => ({ time: timeOf(entry), weight: weightOf(entry) })).sort((a, b) => a.time - b.time);
+    const used = recent.reduce((sum, { weight }) => sum + weight, 0);
+    if (used + count > sendsPerHour) {
+      let freed = 0;
+      const opening = recent.find(({ weight }) => {
+        freed += weight;
+        return used - freed + count <= sendsPerHour;
+      });
+      const nextMs = (opening?.time ?? 0) + HOUR_MS;
+      const next = new Date(nextMs).toISOString();
+      throw new CliError("rate_limited", `profile ${profile} has sent ${used} messages in the hour around ${new Date(at).toISOString()}, and its limit is ${sendsPerHour} (sendsPerHour) \u2014 the next send is possible at ${next}`, { retry_after_ms: nextMs - now().getTime(), retry_at: next });
+    }
+    return true;
+  }, "withinLimit");
+  const counting = /* @__PURE__ */ __name((request) => {
+    permitted(request);
+    refuseHeld(request);
+    const asked = { ...request, people: request.personIds?.length ?? request.count };
+    const creatingTopic = request.kind === "chat" && request.action === "topic-create";
+    if (!countsTowardLimit(asked) && !creatingTopic)
+      return void 0;
+    const checked = /* @__PURE__ */ __name((entries) => {
+      if (!creatingTopic)
+        return withinLimit(request, entries);
+      if (request.sendId === void 0)
+        throw new CliError("validation_error", "a topic creation needs an attempt id");
+      if (entries.some((entry) => entry.action === "topic-create" && entry.sendId === request.sendId && ["sent", "outcome_unknown", "reserved"].includes(entry.outcome))) {
+        throw new CliError("validation_error", "this topic creation was already attempted; check topics list and do not repeat an unknown creation", { operation_id: request.sendId, retryable: false });
+      }
+      return true;
+    }, "checked");
+    const reserving = /* @__PURE__ */ __name(() => {
+      if (!checked(journal.entries()))
+        return;
+      const id = randomUUID();
+      const { chatId, kind, action, sendId, operationId, scheduledFor, notify } = request;
+      journal.append({
+        at: now().toISOString(),
+        profile,
+        chatId,
+        outcome: "reserved",
+        reservation: id,
+        ...kind ? { kind } : {},
+        ...action ? { action } : {},
+        ...asked.people === void 0 ? {} : kind === "delete" || kind === "message" || kind === void 0 ? { count: asked.people } : { people: asked.people },
+        ...sendId === void 0 ? {} : { sendId },
+        ...operationId === void 0 ? {} : { operationId },
+        ...scheduledFor ? { scheduledFor } : {},
+        ...notify === void 0 ? {} : { notify }
+      });
+      reservation = id;
+    }, "reserving");
+    return { checked, reserving };
+  }, "counting");
+  return {
+    ask: /* @__PURE__ */ __name(async (request) => {
+      refuseReadOnly();
+      const levels = currentPermissions();
+      if (levels === void 0)
+        return;
+      const key = request.key ?? keyForWrite(request.kind ?? "message", request.action);
+      if (levelFor(levels, key, permissionDefaults).level !== "ask")
+        return;
+      refuseHeld(request);
+      await ask(key, request);
+      answered.add(request);
+    }, "ask"),
+    check: /* @__PURE__ */ __name((request, { reserve = true } = {}) => {
+      const counted = counting(request);
+      if (!counted)
+        return;
+      if (reserve)
+        journal.locked(counted.reserving);
+      else
+        counted.checked(journal.entries());
+    }, "check"),
+    reserve: /* @__PURE__ */ __name(async (request) => {
+      const counted = counting(request);
+      if (counted)
+        await journal.lockedAsync(counted.reserving);
+    }, "reserve"),
+    // After a send, a failure to write here must not become the command's answer: the message is
+    // already with a person, and an error would invite the caller to send it again.
+    record: /* @__PURE__ */ __name((entry) => {
+      const { personIds: _, ...kept } = entry;
+      const settles = entry.outcome === "refused" ? void 0 : reservation;
+      reservation = void 0;
+      try {
+        journal.append({ at: now().toISOString(), profile, ...kept, ...settles ? { reservation: settles } : {} });
+      } catch (error) {
+        warn(`this send is not in the send journal: ${journalFailure(error)}`, {
+          event: "warning",
+          code: "send_not_journaled",
+          operation: "sends.journal"
+        });
+      }
+    }, "record")
+  };
+}, "sendGuard");
+var refuseToAsk = /* @__PURE__ */ __name(async (key) => {
+  throw new CliError("confirmation_required", `${key} asks before it acts (its permission level is ask), and nobody is here to answer \u2014 add ${skipFlagFor(key)} to go ahead`);
+}, "refuseToAsk");
+var guardFor = /* @__PURE__ */ __name((app, settings, warn, env = process.env, ask) => sendGuard({
+  profile: settings.profile,
+  command: app.command,
+  ...settings.readOnlyLock ? { readOnlyLock: settings.readOnlyLock } : {},
+  permissions: /* @__PURE__ */ __name(() => settings.permissions, "permissions"),
+  permissionSources: settings.permissionSources,
+  ...settings.permissionDefaults ? { permissionDefaults: settings.permissionDefaults } : {},
+  ...ask ? { ask } : {},
+  sendsPerHour: settings.sendsPerHour,
+  journal: new SendJournal(sendsPathFor(app, settings.profile, env), { service: app.command, version: app.version }),
+  recipients: new RecipientList(recipientsPathFor(app, settings.profile, env), app.command),
+  flood: new FloodMemory(floodPathFor(app, settings.profile, env)),
+  warn
+}), "guardFor");
+var journalFailure = /* @__PURE__ */ __name((error) => error?.code ?? (error instanceof Error ? error.name : "error"), "journalFailure");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/cli/messenger/ask.js
+import { openSync as openSync2 } from "node:fs";
+import { createInterface } from "node:readline";
+import { ReadStream } from "node:tty";
+var fromTerminal = /* @__PURE__ */ __name(async (question) => {
+  if (!process.stdin.isTTY || !process.stderr.isTTY)
+    return null;
+  let input;
+  try {
+    input = new ReadStream(openSync2("/dev/tty", "r"));
+  } catch {
+    return null;
+  }
+  const reader = createInterface({ input, output: process.stderr, terminal: true });
+  try {
+    return await new Promise((resolve, reject) => {
+      const cancel = /* @__PURE__ */ __name(() => reject(new CliError("cancelled", "cancelled \u2014 nothing was done")), "cancel");
+      reader.once("SIGINT", cancel);
+      reader.once("close", cancel);
+      reader.question(question, resolve);
+    });
+  } finally {
+    reader.close();
+    input.destroy();
+  }
+}, "fromTerminal");
+var what = /* @__PURE__ */ __name((key, { chatId, count, personIds, forEveryone }) => [
+  key,
+  forEveryone ? "for everyone" : void 0,
+  count !== void 0 ? `${count} ${count === 1 ? "item" : "items"}` : void 0,
+  personIds?.length ? `${personIds.length} ${personIds.length === 1 ? "person" : "people"}` : void 0,
+  chatId !== null ? `in chat ${chatId}` : void 0
+].filter(Boolean).join(", "), "what");
+var answerOf = /* @__PURE__ */ __name(async (command, question) => {
+  const given = command.optsWithGlobals();
+  if (given.json === true || given.jsonl === true)
+    return null;
+  return (environmentOf(command).answer ?? fromTerminal)(question);
+}, "answerOf");
+var terminalAsker = /* @__PURE__ */ __name((command) => async (key, request) => {
+  if (environmentOf(command).agent)
+    return;
+  const flag = skipFlagFor(key);
+  const given = command.optsWithGlobals();
+  if (flag === "--yes" ? given.yes === true : given.allowDangerous === true)
+    return;
+  const machine = given.json === true || given.jsonl === true;
+  const answer = machine ? null : await (environmentOf(command).answer ?? fromTerminal)(`${what(key, request)} \u2014 go ahead? [y/N] `);
+  if (answer === null) {
+    throw new CliError("confirmation_required", `${key} asks before it acts (its permission level is ask), and nobody is at a terminal to answer \u2014 add ${flag} to go ahead`, { permission: key });
+  }
+  if (!/^\s*y(es)?\s*$/i.test(answer))
+    throw new CliError("cancelled", `${key}: not done \u2014 the answer was no`);
+}, "terminalAsker");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/sends/pace.js
+import { readFileSync as readFileSync4, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join4 } from "node:path";
+var DEFAULT_PACE = { perMinute: 60, burst: 20 };
+var pacePathFor = /* @__PURE__ */ __name((app, profile, env = process.env) => join4(resolvePaths({ appName: app.appName, prefix: app.envPrefix, env }).state, "pace", `${profile}.json`), "pacePathFor");
+var Pacer = class {
+  static {
+    __name(this, "Pacer");
+  }
+  path;
+  rate;
+  now;
+  constructor(path, rate, now = Date.now) {
+    this.path = path;
+    this.rate = rate;
+    this.now = now;
+  }
+  get interval() {
+    return this.rate.perMinute > 0 ? 6e4 / this.rate.perMinute : 0;
+  }
+  /** When this call may go; reserved at once, so the next caller in any process lines up behind it. */
+  async reserve() {
+    const now = this.now();
+    if (this.interval === 0)
+      return now;
+    return withFileLockAsync(this.path, "the request pace", () => {
+      const tat = Math.max(this.read(), now);
+      this.write(tat + this.interval);
+      return Math.max(now, tat - this.rate.burst * this.interval);
+    });
+  }
+  /** The messenger asked every caller to wait: nothing goes before `now + waitMs`, in any process. */
+  async holdFor(waitMs) {
+    if (this.interval === 0)
+      return;
+    await withFileLockAsync(this.path, "the request pace", () => {
+      const hold = this.now() + waitMs + this.rate.burst * this.interval;
+      this.write(Math.max(this.read(), hold));
+    });
+  }
+  /** The owner's `flood clear`: every process may go again at once. */
+  async reset() {
+    await withFileLockAsync(this.path, "the request pace", () => this.write(0));
+  }
+  read() {
+    try {
+      const tat = Number(JSON.parse(readFileSync4(this.path, "utf8")).tat);
+      return Number.isFinite(tat) ? tat : 0;
+    } catch {
+      return 0;
+    }
+  }
+  write(tat) {
+    const temporary = `${this.path}.${process.pid}.tmp`;
+    writeFileSync2(temporary, JSON.stringify({ tat }), { mode: 384 });
+    renameSync2(temporary, this.path);
+  }
+};
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/cli/permission-keys.js
+var HOUSEKEEPING = /* @__PURE__ */ new Set([
+  "help",
+  "guide",
+  "config",
+  "session",
+  "doctor",
+  "commands",
+  "complete",
+  "upgrade",
+  "skill",
+  "mcp",
+  "runs"
+]);
+var commandPathKey = /* @__PURE__ */ __name((path) => path[0] === void 0 || HOUSEKEEPING.has(path[0]) ? null : path.join("."), "commandPathKey");
+var commandPermissions = /* @__PURE__ */ __name(({ keyOf = commandPathKey, extra = [], defaults = {} } = {}) => ({
+  keyOf,
+  extra: [AUTHORITY_KEY, ...extra],
+  defaults: { ...DEFAULT_PERMISSIONS, ...defaults }
+}), "commandPermissions");
+var pathOf = /* @__PURE__ */ __name((command) => {
+  const words = [];
+  for (let at = command; at?.parent; at = at.parent)
+    words.unshift(at.name());
+  return words;
+}, "pathOf");
+var rootOf2 = /* @__PURE__ */ __name((command) => {
+  let at = command;
+  while (at.parent)
+    at = at.parent;
+  return at;
+}, "rootOf");
+var everyCommand = /* @__PURE__ */ __name((command) => [command, ...command.commands.flatMap(everyCommand)], "everyCommand");
+var knownPermissionKeys = /* @__PURE__ */ __name((command, keyOf = (one) => keyForCommand(pathOf(one)), extra = []) => {
+  const known = /* @__PURE__ */ new Set();
+  const add = /* @__PURE__ */ __name((key) => {
+    for (let parts = key.split("."); parts.length > 0; parts = parts.slice(0, -1))
+      known.add(parts.join("."));
+  }, "add");
+  if (typeof keyOf !== "function") {
+    for (const one of everyCommand(rootOf2(command))) {
+      const key = keyOf.keyOf(pathOf(one));
+      if (key)
+        add(key);
+    }
+    for (const key of [...keyOf.extra, ...extra])
+      add(key);
+    return known;
+  }
+  for (const one of everyCommand(rootOf2(command))) {
+    const own = keyOf(one);
+    const key = own === void 0 ? keyForCommand(pathOf(one)) : own;
+    if (key)
+      add(key);
+  }
+  for (const key of [...WRITE_KEYS, ...extra])
+    add(key);
+  return known;
+}, "knownPermissionKeys");
+var knownBeside = /* @__PURE__ */ __name((key, known) => {
+  const parent = key.split(".").slice(0, -1).join(".");
+  const depth = parent === "" ? 1 : parent.split(".").length + 1;
+  return [...known].filter((one) => one.split(".").length === depth && (parent === "" || one.startsWith(`${parent}.`))).sort();
+}, "knownBeside");
+var unknownPermissionKeys = /* @__PURE__ */ __name((levels, known) => Object.keys(levels).filter((key) => key !== CEILING_KEY && !known.has(key)), "unknownPermissionKeys");
+var unknownPermissionIssues = /* @__PURE__ */ __name((command, settings, tool, keyOf) => {
+  const saved = settings.savedPermissions ?? Object.keys(settings.permissions).filter((key) => key !== CEILING_KEY && settings.permissionSources[key] !== "flag").map((key) => ({ key, at: ["profiles", settings.profile, "permissions", key] }));
+  return permissionIssues(saved, knownPermissionKeys(command, keyOf), { file: settings.configPath, tool }).map(publicIssue);
+}, "unknownPermissionIssues");
+var refuseUnknownPermissionKeys = /* @__PURE__ */ __name((command, settings, tool, keyOf) => {
+  const issues = unknownPermissionIssues(command, settings, tool, keyOf);
+  if (issues.length > 0)
+    throw new CliError("configuration_error", issueMessage(issues), { permission: issues[0]?.key });
+  const flagged = Object.keys(settings.permissions).filter((key2) => settings.permissionSources[key2] === "flag");
+  const [key] = unknownPermissionKeys(Object.fromEntries(flagged.map((one) => [one, true])), knownPermissionKeys(command, keyOf));
+  if (key !== void 0)
+    throw new CliError("validation_error", `--permission ${key} names no command`, { permission: key });
+}, "refuseUnknownPermissionKeys");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/cli/messenger/flooded.js
+var LONG_LIVED = /* @__PURE__ */ new Set(["self", "newSendId", "close", "formatMarkdown", "formatHtml", "storedChats"]);
+var LISTENING = /* @__PURE__ */ new Set(["watch", "feed", "listen", "listenHistory"]);
+var BLOCKING = /* @__PURE__ */ new Set(["frozen", "limited", "banned"]);
+var ANNOUNCE_WAIT_MS = 5e3;
+var LONGEST_PACE_WAIT_MS = 5 * 6e4;
+var chatOf = /* @__PURE__ */ __name((args) => typeof args[0] === "string" && /^-?\d+$/.test(args[0]) ? args[0] : void 0, "chatOf");
+var flooded = /* @__PURE__ */ __name((messenger, memory, { name, warn, pacer }) => {
+  const kept = /* @__PURE__ */ __name(async (operation, what2) => {
+    try {
+      await what2();
+    } catch (error) {
+      warn(`could not remember ${name}'s wait (${error instanceof Error ? error.message : String(error)})`, {
+        event: "warning",
+        code: "wait_not_remembered",
+        operation
+      });
+    }
+  }, "kept");
+  const noted = /* @__PURE__ */ __name(async (operation, chatId, error) => {
+    if (!isCliFailure(error))
+      return;
+    const details = error.details ?? {};
+    const standing = details.standing;
+    if (standing && BLOCKING.has(standing.state)) {
+      await kept(operation, () => {
+        const block = memory.block({
+          state: standing.state,
+          hint: standing.hint ?? error.message,
+          ...standing.until ? { until: standing.until } : {}
+        });
+        warn(`writes from this profile are held ${holdEnd(block)}: ${block.hint}`, {
+          event: "warning",
+          code: `account_${block.state}`,
+          operation
+        });
+      });
+      return;
+    }
+    const waitMs = Number(details.retry_after_ms);
+    if (error.code !== "rate_limited" || details.remembered === true || !Number.isFinite(waitMs) || waitMs <= 0)
+      return;
+    const providerError = providerErrorKey(details.provider_error);
+    await kept(operation, () => {
+      const deadline = memory.remember({
+        operation,
+        ...chatId ? { chatId } : {},
+        ...providerError ? { providerError } : {},
+        waitMs
+      });
+      warn(`${name} asked to wait before ${operation} again \u2014 until ${deadline.until}`, {
+        event: "warning",
+        code: "flood_wait",
+        operation,
+        counts: { seconds: Math.ceil(waitMs / 1e3) }
+      });
+    });
+    if (pacer)
+      await kept(operation, () => pacer.holdFor(waitMs));
+  }, "noted");
+  const turn = /* @__PURE__ */ __name(async (operation) => {
+    if (!pacer)
+      return;
+    let at = Date.now();
+    await kept(operation, async () => {
+      at = await pacer.reserve();
+    });
+    const waitMs = at - Date.now();
+    if (waitMs <= 0)
+      return;
+    if (waitMs > LONGEST_PACE_WAIT_MS) {
+      throw new CliError("rate_limited", `${name} asked this profile to wait, ${Math.ceil(waitMs / 1e3)} s are left \u2014 nothing was sent to ${name}`, { retry_after_ms: waitMs, retry_at: new Date(at).toISOString(), remembered: true });
+    }
+    if (waitMs >= ANNOUNCE_WAIT_MS) {
+      const seconds = Math.ceil(waitMs / 1e3);
+      warn(`waiting ${seconds} s to keep this profile's pace with ${name}`, {
+        event: "warning",
+        code: "pace_wait",
+        operation,
+        counts: { seconds }
+      });
+    }
+    await new Promise((resolve) => setTimeout(resolve, waitMs));
+  }, "turn");
+  return throughWrapper(messenger, {}, (operation, call) => {
+    if (LONG_LIVED.has(operation))
+      return call;
+    if (LISTENING.has(operation))
+      return (async (...args) => {
+        try {
+          return await call(...args);
+        } catch (error) {
+          await noted(operation, void 0, error);
+          throw error;
+        }
+      });
+    return (async (...args) => {
+      const chatId = chatOf(args);
+      const owed = memory.owed(operation, chatId);
+      if (owed) {
+        const waitMs = Math.max(0, Date.parse(owed.until) - Date.now());
+        throw new CliError("rate_limited", `${name} asked to wait before ${operation} again, ${Math.ceil(waitMs / 1e3)} s are left \u2014 nothing was sent to ${name}`, {
+          retry_after_ms: waitMs,
+          retry_at: owed.until,
+          remembered: true,
+          ...owed.providerError ? { provider_error: owed.providerError } : {}
+        });
+      }
+      await turn(operation);
+      try {
+        return await call(...args);
+      } catch (error) {
+        await noted(operation, chatId, error);
+        throw error;
+      }
+    });
+  });
+}, "flooded");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/cli/messenger/observed.js
+var observed = /* @__PURE__ */ __name((messenger, events) => {
+  const timed = /* @__PURE__ */ __name(async (operation, named, work, after) => {
+    const write = currentOperation();
+    const marked = /* @__PURE__ */ __name((part = {}) => write === void 0 ? part : { ...part, ids: { ...part.ids, operation: write } }, "marked");
+    events({ event: "request", operation, level: "operation", ...marked(named) });
+    const started = performance.now();
+    const durationMs = /* @__PURE__ */ __name(() => Math.round(performance.now() - started), "durationMs");
+    try {
+      const answer = await work();
+      events({
+        event: "response",
+        operation,
+        level: "operation",
+        durationMs: durationMs(),
+        outcome: "ok",
+        ...marked(after?.(answer))
+      });
+      return answer;
+    } catch (error) {
+      const providerError = isCliFailure(error) ? providerErrorKey(error.details?.provider_error) : void 0;
+      events({
+        event: "response",
+        operation,
+        level: "operation",
+        durationMs: durationMs(),
+        outcome: "error",
+        errorCode: isCliFailure(error) ? error.code : "generic_failure",
+        ...providerError ? { providerError } : {},
+        ...marked()
+      });
+      throw error;
+    }
+  }, "timed");
+  const counted = /* @__PURE__ */ __name(async (operation, onItem, work, count) => {
+    const counts = {};
+    await timed(operation, {}, () => work((item) => {
+      count(item, counts);
+      onItem(item);
+    }), () => ({ counts }));
+  }, "counted");
+  const mint = messenger.newSendId;
+  const { chats, history, contact, around, watch, feed, listen, listenHistory } = messenger;
+  return throughWrapper(messenger, {
+    self: /* @__PURE__ */ __name(() => messenger.self(), "self"),
+    ...mint ? { newSendId: /* @__PURE__ */ __name(() => mint.call(messenger), "newSendId") } : {},
+    me: /* @__PURE__ */ __name(() => timed("account.me", {}, () => messenger.me()), "me"),
+    ...chats ? {
+      chats: /* @__PURE__ */ __name((window) => timed("chats.list", {}, () => chats.call(messenger, window), (page) => ({ counts: { chats: page.items.length } })), "chats")
+    } : {},
+    ...history ? {
+      history: /* @__PURE__ */ __name((reference, options) => timed("messages.list", {}, () => history.call(messenger, reference, options), (page) => ({
+        ...page.items[0] ? { ids: { chat: page.items[0].chatId } } : {},
+        counts: { messages: page.items.length }
+      })), "history")
+    } : {},
+    resolve: /* @__PURE__ */ __name((reference) => timed("chats.resolve", {}, () => messenger.resolve(reference), (chat) => ({ ids: { chat: chat.id } })), "resolve"),
+    chat: /* @__PURE__ */ __name((reference) => timed("chats.show", {}, () => messenger.chat(reference), (card) => ({ ids: { chat: card.id }, ...card.members ? { counts: { members: card.members.length } } : {} })), "chat"),
+    ...contact ? {
+      contact: /* @__PURE__ */ __name((reference) => timed("contacts.show", {}, () => contact.call(messenger, reference), (card) => ({ ids: { person: card.id }, counts: { chats: card.chats.length } })), "contact")
+    } : {},
+    ...around ? {
+      around: /* @__PURE__ */ __name((reference, messageId, window) => timed("messages.around", { ids: { message_id: messageId } }, () => around.call(messenger, reference, messageId, window), (items) => ({
+        ...items[0] ? { ids: { chat: items[0].chatId, message_id: messageId } } : {},
+        counts: { messages: items.length }
+      })), "around")
+    } : {},
+    send: /* @__PURE__ */ __name((chatId, text, options) => timed("messages.send", {
+      ids: {
+        chat: chatId,
+        send: options.sendId,
+        ...options.replyTo ? { reply: options.replyTo } : {},
+        ...options.threadId ? { thread: options.threadId } : {}
+      }
+    }, () => messenger.send(chatId, text, options), (sent) => ({ ids: { chat: sent.message.chatId || chatId, message_id: sent.message.id } })), "send"),
+    ...watch ? {
+      watch: /* @__PURE__ */ __name((onEvent, signal, onReady) => counted("messages.watch", onEvent, (counting) => watch.call(messenger, counting, signal, onReady), byEvent), "watch")
+    } : {},
+    ...feed ? { feed: /* @__PURE__ */ __name((onBatch, signal) => timed("history.feed", {}, () => feed.call(messenger, onBatch, signal)), "feed") } : {},
+    ...listen ? {
+      listen: /* @__PURE__ */ __name((onEvent, signal) => counted("messages.listen", onEvent, (counting) => listen.call(messenger, counting, signal), byEvent), "listen")
+    } : {},
+    ...listenHistory ? {
+      listenHistory: /* @__PURE__ */ __name((onBatch, signal) => counted("history.listen", onBatch, (counting) => listenHistory.call(messenger, counting, signal), byPart), "listenHistory")
+    } : {},
+    logout: /* @__PURE__ */ __name(() => timed("session.logout", {}, () => messenger.logout()), "logout"),
+    close: /* @__PURE__ */ __name(() => messenger.close(), "close")
+  }, (name, call) => (...args) => timed(`adapter.${name}`, {}, () => call(...args)));
+}, "observed");
+var byEvent = /* @__PURE__ */ __name((event, counts) => {
+  counts[event.event] = (counts[event.event] ?? 0) + 1;
+}, "byEvent");
+var byPart = /* @__PURE__ */ __name((batch, counts) => {
+  counts.batches = (counts.batches ?? 0) + 1;
+  for (const [part, items] of Object.entries(batch))
+    if (Array.isArray(items) && items.length > 0)
+      counts[part] = (counts[part] ?? 0) + items.length;
+}, "byPart");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/cli/messenger/stored.js
+var REKEY_PACING = { lockMs: 50, pauseMs: 25 };
+var stored = /* @__PURE__ */ __name((messenger, { account, store, warn, events, pending, announcing, deletedWithoutChat, profile, rekeyed, rekeyPacing = REKEY_PACING, closing, namesFromStore, recipientIds, countsUnread = false }) => {
+  let warned = false;
+  let recorded = profile === void 0;
+  const notWritten = /* @__PURE__ */ __name((operation, error) => {
+    const warning = { event: "warning", code: "store_not_written", operation };
+    events(warning);
+    if (!warned)
+      warn(`not saved to the local store: ${error instanceof Error ? error.message : String(error)}`, warning);
+    warned = true;
+  }, "notWritten");
+  const attempt = /* @__PURE__ */ __name(async (operation, write) => {
+    try {
+      const opened = await store();
+      if (opened)
+        await write(opened);
+      if (opened && !recorded && profile) {
+        recorded = true;
+        await Promise.resolve().then(() => opened.accounts.saveProfile(profile.app, profile.name, account)).catch(() => {
+        });
+      }
+    } catch (error) {
+      notWritten(operation, error);
+    }
+  }, "attempt");
+  const save = /* @__PURE__ */ __name((operation, writing) => {
+    const saving = attempt(operation, writing);
+    pending?.add(saving);
+    return saving.finally(() => pending?.delete(saving));
+  }, "save");
+  const { chats, history, around, people } = messenger;
+  const followed = /* @__PURE__ */ __name(async (opened, scoped, held) => {
+    let answered;
+    try {
+      answered = await messenger.resolve(held.id);
+    } catch (error) {
+      if (codeOf(error) === "not_found")
+        return void 0;
+      throw error;
+    }
+    if (answered.id === held.id)
+      return void 0;
+    await attempt("history.rekey", async (store2) => {
+      await store2.chats.rekeyChat(scoped, held.id, answered.id);
+      await rekeyed?.(held.id, answered.id);
+    });
+    return (await storedChat(opened, scoped, namesFromStore ?? {}, answered.id)).held ?? answered;
+  }, "followed");
+  const titles = /* @__PURE__ */ new Map();
+  const storedPeople = /* @__PURE__ */ __name(async () => {
+    try {
+      return await (await store())?.people.people(account.provider, { account: account.account });
+    } catch {
+      return void 0;
+    }
+  }, "storedPeople");
+  let rekeysQueued = 0;
+  let rekeyRound = 0;
+  const rekeysOnly = /* @__PURE__ */ new Set();
+  const giveUpRekeys = /* @__PURE__ */ __name(() => {
+    rekeyRound += 1;
+    const count = rekeysQueued;
+    rekeysQueued = 0;
+    for (const saving of rekeysOnly)
+      pending?.delete(saving);
+    if (count === 0)
+      return;
+    const warning = {
+      event: "warning",
+      code: "rekeys_not_applied",
+      operation: "history.rekey",
+      counts: { rekeys: count }
+    };
+    events(warning);
+    warn(`${count} chat re-key${count === 1 ? "" : "s"} not applied yet; the next serve applies them`, warning);
+  }, "giveUpRekeys");
+  closing?.addEventListener("abort", giveUpRekeys, { once: true });
+  const saveRekeys = /* @__PURE__ */ __name(async (pairs, round) => {
+    let rest = pairs;
+    while (rest.length > 0 && round === rekeyRound) {
+      let pass;
+      try {
+        pass = await (await store())?.chats.rekeyChats(account, rest, rekeyPacing.lockMs);
+      } catch {
+        if (round === rekeyRound)
+          giveUpRekeys();
+        return;
+      }
+      if (round !== rekeyRound)
+        return;
+      const taken2 = pass?.taken ?? rest.length;
+      rekeysQueued -= taken2;
+      for (const { from, to } of pass?.applied ?? [])
+        await Promise.resolve().then(() => rekeyed?.(from, to)).catch((error) => notWritten("history.rekey", error));
+      for (const { error } of pass?.refused ?? [])
+        notWritten("history.rekey", error);
+      rest = rest.slice(taken2);
+      if (rest.length > 0)
+        await new Promise((resolve) => setTimeout(resolve, rekeyPacing.pauseMs));
+    }
+  }, "saveRekeys");
+  const saveBatches = /* @__PURE__ */ __name((operation, onBatch) => {
+    let previous = Promise.resolve();
+    return (batch) => {
+      if (namesFromStore) {
+        for (const { from, to } of batch.rekeys ?? []) {
+          const title = titles.get(from);
+          titles.delete(from);
+          if (title && !titles.has(to))
+            titles.set(to, title);
+        }
+        for (const chat of batch.chats ?? [])
+          if (chat.title)
+            titles.set(chat.id, chat.title);
+      }
+      const rekeys = batch.rekeys ?? [];
+      const round = rekeyRound;
+      rekeysQueued += rekeys.length;
+      const saving = previous.then(async () => {
+        await saveRekeys(rekeys, round);
+        await attempt(operation, (opened) => fill(opened, account, batch));
+      });
+      previous = saving;
+      pending?.add(saving);
+      if (onlyRekeys(batch))
+        rekeysOnly.add(saving);
+      void saving.finally(() => {
+        pending?.delete(saving);
+        rekeysOnly.delete(saving);
+      });
+      onBatch(batch);
+    };
+  }, "saveBatches");
+  return throughWrapper(messenger, {
+    ...messenger.forumState ? {
+      forumState: /* @__PURE__ */ __name(async (chatId) => {
+        const state = await capability(messenger, "forumState", "read forum settings")(chatId);
+        await save("forum.read", (opened) => opened.chats.saveChats(account, [state.chat]));
+        return state;
+      }, "forumState")
+    } : {},
+    ...messenger.upgradeForum ? {
+      upgradeForum: /* @__PURE__ */ __name(async (chatId) => {
+        const state = await capability(messenger, "upgradeForum", "upgrade a group")(chatId);
+        await save("forum.upgrade", (opened) => opened.chats.saveChats(account, [state.chat]));
+        return state;
+      }, "upgradeForum")
+    } : {},
+    ...messenger.enableForum ? {
+      enableForum: /* @__PURE__ */ __name(async (chatId) => {
+        const state = await capability(messenger, "enableForum", "enable forum topics")(chatId);
+        await save("forum.enable", (opened) => opened.chats.saveChats(account, [state.chat]));
+        return state;
+      }, "enableForum")
+    } : {},
+    self: /* @__PURE__ */ __name(() => messenger.self(), "self"),
+    resolve: /* @__PURE__ */ __name(async (reference) => {
+      if (isId(reference) && !namesFromStore)
+        return messenger.resolve(reference);
+      let accountId;
+      try {
+        accountId = account.account;
+      } catch {
+        return messenger.resolve(reference);
+      }
+      const scoped = { provider: account.provider, account: accountId };
+      const opened = await store().catch(() => void 0);
+      if (!opened)
+        return messenger.resolve(reference);
+      const { id, held } = namesFromStore ? await storedChat(opened, scoped, namesFromStore, reference) : {};
+      if (!isId(reference)) {
+        const people2 = await opened.people.people(scoped.provider, { account: scoped.account });
+        const wanted = foldName(reference.trim());
+        if (people2.all().some((person) => person.alias && foldName(person.alias).includes(wanted))) {
+          const person = pickPerson(reference, people2);
+          const chats2 = (await opened.chats.chatsWith(scoped, person.id)).filter((chat) => chat.kind === "dialog");
+          if (chats2.length !== 1 || !chats2[0])
+            throw new CliError("validation_error", "the alias has no unique stored direct chat; use a chat id");
+          let remote;
+          if (namesFromStore)
+            remote = held;
+          else
+            try {
+              remote = await messenger.resolve(reference);
+            } catch (error) {
+              if (!(error instanceof CliError) || error.code !== "not_found")
+                throw error;
+            }
+          if (remote && remote.id !== chats2[0].id)
+            throw new CliError("validation_error", "the local alias also names another messenger chat; use a chat id", {
+              candidates: [{ id: chats2[0].id }, { id: remote.id }]
+            });
+          return remote ?? (namesFromStore ? chats2[0] : messenger.resolve(chats2[0].id));
+        }
+      }
+      if (held && held.id === reference.trim())
+        return await followed(opened, scoped, held) ?? held;
+      return held ?? messenger.resolve(id ?? reference);
+    }, "resolve"),
+    chat: /* @__PURE__ */ __name((reference) => messenger.chat(reference), "chat"),
+    ...people && namesFromStore ? {
+      people: /* @__PURE__ */ __name(async (references) => {
+        const known = await storedPeople();
+        const found = references.map((reference) => known ? personIn(known, reference) : void 0);
+        const asked = references.filter((_, at) => found[at] === void 0);
+        const answered = asked.length === 0 ? [] : await people.call(messenger, asked);
+        const ids = [];
+        for (const id of found) {
+          const one = id ?? answered.shift();
+          if (one === void 0)
+            throw new CliError("not_found", "the messenger found fewer people than it was asked");
+          ids.push(one);
+        }
+        return ids;
+      }, "people")
+    } : {},
+    logout: /* @__PURE__ */ __name(() => messenger.logout(), "logout"),
+    close: /* @__PURE__ */ __name(() => messenger.close(), "close"),
+    me: /* @__PURE__ */ __name(async () => {
+      const me = await messenger.me();
+      await save("account.me", (opened) => opened.accounts.saveAccount(account, { name: me.name }));
+      return me;
+    }, "me"),
+    ...chats ? {
+      chats: /* @__PURE__ */ __name(async (window) => {
+        const page = await chats.call(messenger, window);
+        const complete = window.offset === 0 && !page.hasMore && page.items.length > 0;
+        await save("chats.list", async (opened) => {
+          await opened.chats.saveChats(account, page.items);
+          const ids = page.items.map((chat) => chat.id);
+          if (complete)
+            await opened.chats.markChatsLeft(account, ids);
+          else
+            await opened.chats.rejoinChats(account, ids);
+        });
+        return page;
+      }, "chats")
+    } : {},
+    ...history ? {
+      history: /* @__PURE__ */ __name(async (reference, options) => {
+        const seenAt = Date.now();
+        const page = await history.call(messenger, reference, options);
+        const chatId = page.items[0]?.chatId;
+        if (chatId !== void 0) {
+          await save("messages.list", (opened) => opened.messages.saveMessages(account, chatId, page.items, { via: "history", seenAt }));
+        }
+        return page;
+      }, "history")
+    } : {},
+    ...around ? {
+      around: /* @__PURE__ */ __name(async (reference, messageId, window) => {
+        const seenAt = Date.now();
+        const items = await around.call(messenger, reference, messageId, window);
+        const chatId = items[0]?.chatId;
+        if (chatId !== void 0) {
+          const plain = items.map(({ anchor, ...message }) => message);
+          await save("messages.around", (opened) => opened.messages.saveMessages(account, chatId, plain, { via: "context", seenAt }));
+        }
+        return items;
+      }, "around")
+    } : {},
+    ...messenger.watch ? {
+      watch: /* @__PURE__ */ __name(async (onEvent, signal, onReady) => {
+        if (namesFromStore)
+          await rememberTitles(store, account, titles);
+        return messenger.watch?.((event) => {
+          const seenAt = Date.now();
+          void save("messages.watch", (opened) => keep(opened, account, event, seenAt, deletedWithoutChat, countsUnread));
+          onEvent(namesFromStore ? titled(event, titles) : event);
+        }, signal, onReady) ?? Promise.resolve();
+      }, "watch")
+    } : {},
+    ...messenger.listen ? {
+      listen: /* @__PURE__ */ __name((onEvent, signal) => messenger.listen?.((event) => {
+        void save("messages.listen", (opened) => keep(opened, account, event, Date.now(), deletedWithoutChat, countsUnread));
+        onEvent(event);
+      }, signal) ?? Promise.resolve(), "listen")
+    } : {},
+    ...messenger.feed ? {
+      feed: /* @__PURE__ */ __name((onBatch, signal) => {
+        if (messenger.storedChats) {
+          const announced = announceStoredChats(messenger, store, account, events, warn, recipientIds);
+          announcing?.add(announced);
+          void announced.finally(() => announcing?.delete(announced));
+        }
+        return messenger.feed?.(saveBatches("history.feed", onBatch), signal) ?? Promise.resolve();
+      }, "feed")
+    } : {},
+    ...messenger.listenHistory ? {
+      listenHistory: /* @__PURE__ */ __name((onBatch, signal) => messenger.listenHistory?.(saveBatches("history.listen", onBatch), signal) ?? Promise.resolve(), "listenHistory")
+    } : {},
+    ...messenger.edit ? {
+      edit: /* @__PURE__ */ __name(async (chatId, messageId, text, options) => {
+        const seenAt = Date.now();
+        const edited = await capability(messenger, "edit", "edit")(chatId, messageId, text, options);
+        await save("messages.edit", async (opened) => {
+          const held = await opened.messages.message(account, messageId, { chatId }) !== void 0;
+          await saveSent(opened, account, chatId, edited, { via: "update", seenAt }, held ? chatId : void 0);
+        });
+        return edited;
+      }, "edit")
+    } : {},
+    ...messenger.createPoll ? {
+      // A messenger that never echoes a device's own message back would otherwise never hold the poll.
+      createPoll: /* @__PURE__ */ __name(async (chatId, poll, options) => {
+        const sent = await capability(messenger, "createPoll", "create a poll")(chatId, poll, options);
+        await save("polls.create", (opened) => saveSent(opened, account, chatId, sent.message, { via: "send" }));
+        return sent;
+      }, "createPoll")
+    } : {},
+    ...messenger.vote ? {
+      vote: /* @__PURE__ */ __name(async (chatId, messageId, answerIds) => {
+        const poll = await capability(messenger, "vote", "vote in a poll")(chatId, messageId, answerIds);
+        const votedAt = (/* @__PURE__ */ new Date()).toISOString();
+        await save("polls.vote", (opened) => opened.messages.saveVote(account, chatId, messageId, {
+          person: { id: account.account, name: null, username: null },
+          answers: answerIds,
+          votedAt
+        }));
+        return poll;
+      }, "vote")
+    } : {},
+    ...messenger.star ? {
+      // The messenger may not echo the owner's own star back, and `messages list starred:true` reads the store.
+      star: /* @__PURE__ */ __name(async (chatId, messageId, starred) => {
+        await capability(messenger, "star", "star a message")(chatId, messageId, starred);
+        await save("messages.star", (opened) => opened.messages.saveStar(account, chatId, messageId, starred));
+      }, "star")
+    } : {},
+    ...messenger.forward ? {
+      forward: /* @__PURE__ */ __name(async (fromChatId, messageId, toChatId, options) => {
+        const copy = await capability(messenger, "forward", "forward")(fromChatId, messageId, toChatId, options);
+        await save("messages.forward", (opened) => saveSent(opened, account, toChatId, copy, { via: "send" }));
+        return copy;
+      }, "forward")
+    } : {},
+    // Without this, a message deleted here would still be found by `search messages` and read `--offline`.
+    ...messenger.delete ? {
+      delete: /* @__PURE__ */ __name(async (chatId, messageIds, options) => {
+        await capability(messenger, "delete", "delete")(chatId, messageIds, options);
+        await save("messages.delete", (opened) => opened.messages.markDeleted(account, messageIds, { chatId }));
+      }, "delete")
+    } : {},
+    send: /* @__PURE__ */ __name(async (chatId, text, options) => {
+      const sent = await messenger.send(chatId, text, options);
+      if (options.at === void 0) {
+        await save("messages.send", async (opened) => {
+          for (const message of sent.messages ?? [sent.message])
+            await saveSent(opened, account, chatId, message, { via: "send" });
+        });
+      }
+      return sent;
+    }, "send")
+  });
+}, "stored");
+var saveSent = /* @__PURE__ */ __name((opened, account, typed, message, options, into = message.chatId || typed) => opened.messages.saveMessages(account, into, [message], { ...options, typedChatId: typed }), "saveSent");
+var storedChat = /* @__PURE__ */ __name(async (store, account, traits, reference) => {
+  const bound = store.forAccount(account);
+  const id = await chatIdIn(traits, reference, bound).catch((error) => {
+    if (codeOf(error) === "not_found")
+      return void 0;
+    throw error;
+  });
+  if (id === void 0)
+    return {};
+  const held = (await bound.chats.chats({})).items.find((chat) => chat.id === id);
+  return held ? { id, held } : { id };
+}, "storedChat");
+var personIn = /* @__PURE__ */ __name((people, reference) => {
+  try {
+    return pickPerson(reference, people).id;
+  } catch (error) {
+    if (codeOf(error) === "not_found")
+      return void 0;
+    throw error;
+  }
+}, "personIn");
+var announceStoredChats = /* @__PURE__ */ __name(async (messenger, store, account, events, warn, recipientIds) => {
+  let listed = [];
+  try {
+    listed = recipientIds?.() ?? [];
+  } catch (error) {
+    warn(`the messenger was not told the recipient list: ${error instanceof Error ? error.message : String(error)}`, {
+      event: "warning",
+      code: "recipients_not_read",
+      operation: "history.stored_chats"
+    });
+  }
+  try {
+    const opened = await store();
+    const held = opened ? (await opened.forAccount(account).chats.chats({})).items.map((chat) => chat.id) : [];
+    const recipients = [...new Set(listed)].filter((id) => !held.includes(id));
+    if (recipients.length > 0)
+      await messenger.storedChats?.(held, recipients);
+    else if (opened)
+      await messenger.storedChats?.(held);
+  } catch (error) {
+    const warning = { event: "warning", code: "stored_chats_failed", operation: "history.stored_chats" };
+    events(warning);
+    warn(`the messenger was not told the stored chats: ${error instanceof Error ? error.message : String(error)}`, warning);
+  }
+}, "announceStoredChats");
+var rememberTitles = /* @__PURE__ */ __name(async (store, account, titles) => {
+  try {
+    const opened = await store();
+    for (const chat of (await opened?.forAccount(account).chats.chats({}))?.items ?? [])
+      if (chat.title && !titles.has(chat.id))
+        titles.set(chat.id, chat.title);
+  } catch {
+  }
+}, "rememberTitles");
+var titled = /* @__PURE__ */ __name((event, titles) => {
+  if (event.event === "message" || event.event === "edit") {
+    const title2 = event.message.chatTitle ?? titles.get(event.message.chatId);
+    return title2 ? { ...event, message: { ...event.message, chatTitle: title2 } } : event;
+  }
+  if (event.event === "chat_event" && event.change.event === "title" && event.change.title)
+    titles.set(event.chatId, event.change.title);
+  if (event.chatTitle !== null || event.chatId === null)
+    return event;
+  const title = titles.get(event.chatId);
+  return title ? { ...event, chatTitle: title } : event;
+}, "titled");
+var onlyRekeys = /* @__PURE__ */ __name((batch) => Object.entries(batch).every(([part, items]) => part === "rekeys" === (items?.length ?? 0) > 0), "onlyRekeys");
+var fill = /* @__PURE__ */ __name(async (store, account, batch) => {
+  if (batch.chats?.length)
+    await store.chats.saveChats(account, batch.chats);
+  if (batch.people?.length)
+    await store.people.savePeople(account, batch.people);
+  const byChat = /* @__PURE__ */ new Map();
+  const of = /* @__PURE__ */ __name((chatId) => {
+    const held = byChat.get(chatId) ?? { messages: [], votes: [], reactions: [], stars: [] };
+    byChat.set(chatId, held);
+    return held;
+  }, "of");
+  for (const message of batch.messages ?? [])
+    of(message.chatId).messages.push(message);
+  for (const { chatId, messageId, vote } of batch.votes ?? [])
+    of(chatId).votes.push({ messageId, vote });
+  for (const { chatId, messageId, reaction } of batch.reactions ?? [])
+    of(chatId).reactions.push({ messageId, reaction });
+  for (const { chatId, messageId, starred } of batch.stars ?? [])
+    of(chatId).stars.push({ messageId, starred });
+  for (const [chatId, { messages, votes, reactions, stars }] of byChat)
+    await store.messages.saveMessages(account, chatId, messages, { via: "history", votes, reactions, stars });
+  const deletions = /* @__PURE__ */ new Map();
+  for (const { chatId, messageId } of batch.deletions ?? [])
+    deletions.set(chatId, [...deletions.get(chatId) ?? [], messageId]);
+  for (const [chatId, ids] of deletions)
+    await store.messages.markDeleted(account, ids, { chatId });
+  const changes = /* @__PURE__ */ new Map();
+  for (const { chatId, change } of batch.events ?? [])
+    changes.set(chatId, [...changes.get(chatId) ?? [], change]);
+  for (const [chatId, events] of changes)
+    await store.roster.saveChatEvents(account, chatId, events);
+}, "fill");
+var keep = /* @__PURE__ */ __name(async (store, account, event, seenAt, among, countsUnread) => {
+  switch (event.event) {
+    case "message":
+    case "edit": {
+      const { chatTitle, ...message } = event.message;
+      await store.messages.saveMessages(account, message.chatId, [message], {
+        via: "update",
+        seenAt,
+        ...countsUnread && event.event === "message" ? { countUnread: true } : {}
+      });
+      return;
+    }
+    case "delete":
+      await store.messages.markDeleted(account, [event.messageId], event.chatId === null ? among ? { among } : {} : { chatId: event.chatId });
+      return;
+    case "vote":
+      await store.messages.saveVote(account, event.chatId, event.messageId, event.vote);
+      return;
+    case "person_reaction":
+      await store.messages.saveReaction(account, event.chatId, event.messageId, event.reaction);
+      return;
+    case "star":
+      await store.messages.saveStar(account, event.chatId, event.messageId, event.starred);
+      return;
+    case "delivery":
+      await store.messages.saveDelivery(account, event.chatId, event.messageId, event.delivery);
+      return;
+    case "chat_event":
+      await store.roster.saveChatEvents(account, event.chatId, [event.change]);
+      return;
+    case "reaction":
+      await store.messages.saveReactions(account, event.chatId, event.messageId, event.reactions, event.counterObservation ? { observation: event.counterObservation } : {});
+  }
+}, "keep");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/cli/messenger/context.js
+var lazyStore = /* @__PURE__ */ __name((env, command, version) => {
+  let opened;
+  return {
+    open: /* @__PURE__ */ __name(() => {
+      opened ??= openStore({ env, command, ...version ? { version } : {} });
+      return opened;
+    }, "open"),
+    close: /* @__PURE__ */ __name(async () => {
+      if (opened)
+        await (await opened.catch(() => void 0))?.close();
+    }, "close")
+  };
+}, "lazyStore");
+var storedMessages = /* @__PURE__ */ __name((provider, store, account) => {
+  const key = /* @__PURE__ */ __name(() => {
+    const self = account();
+    return self ? { provider, account: self } : void 0;
+  }, "key");
+  return {
+    message: /* @__PURE__ */ __name(async (chatId, messageId) => {
+      const at = key();
+      return at && (await store()).messages.message(at, messageId, { chatId });
+    }, "message"),
+    threadMessages: /* @__PURE__ */ __name(async (chatId, threadId, window) => {
+      const owner = key();
+      return owner ? (await store()).messages.messages(owner, chatId, { ...window, threadId }) : { items: [], hasMore: false };
+    }, "threadMessages"),
+    newestIncoming: /* @__PURE__ */ __name(async (chatId, before) => {
+      const at = key();
+      if (!at)
+        return void 0;
+      const page = await (await store()).messages.messages(at, chatId, {
+        limit: 1,
+        outgoing: false,
+        ...before === void 0 ? {} : { before }
+      });
+      return page.items.at(-1);
+    }, "newestIncoming"),
+    anchor: /* @__PURE__ */ __name(async (chatId, at) => {
+      const owner = key();
+      if (!owner)
+        return void 0;
+      const window = at === void 0 ? { at: (/* @__PURE__ */ new Date(0)).toISOString(), before: 0, after: 1 } : { at, before: 1, after: 0 };
+      return (await (await store()).messages.messagesWindow(owner, chatId, window))[0];
+    }, "anchor"),
+    wroteTo: /* @__PURE__ */ __name(async (personId) => {
+      const owner = key();
+      if (!owner)
+        return false;
+      const opened = await store();
+      const dialogs = /* @__PURE__ */ new Set([
+        personId,
+        ...(await opened.chats.chatsWith(owner, personId)).filter((chat) => chat.kind === "dialog").map((chat) => chat.id)
+      ]);
+      for (const chatId of dialogs)
+        if ((await opened.messages.messages(owner, chatId, { limit: 1, outgoing: true })).items.length > 0)
+          return true;
+      return false;
+    }, "wroteTo"),
+    pollVotes: /* @__PURE__ */ __name(async (chatId, messageId) => {
+      const owner = key();
+      return owner ? (await store()).messages.pollVotes(owner, chatId, messageId) : [];
+    }, "pollVotes"),
+    reactors: /* @__PURE__ */ __name(async (chatId, messageId) => {
+      const owner = key();
+      return owner ? (await store()).messages.reactors(owner, chatId, messageId) : [];
+    }, "reactors")
+  };
+}, "storedMessages");
+var connectFor = /* @__PURE__ */ __name((command, messenger, base, options = {}) => {
+  const { relayed } = environmentOf(command);
+  if (!relayed)
+    return messenger.connect(command, base, options);
+  if (base.settings.profile !== relayed.profile) {
+    return Promise.reject(new CliError("permission_error", `this serve holds profile ${relayed.profile}; it does not run commands for profile ${base.settings.profile}`, { sent: false }));
+  }
+  return Promise.resolve(relayed.connection());
+}, "connectFor");
+var SAVES_WAIT_MS = 5e3;
+var REKEY_LOCK_WAIT_MS = 250;
+var settled = /* @__PURE__ */ __name(async (pending, ms) => {
+  if (pending.size === 0)
+    return true;
+  let timer;
+  const late = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(false), ms);
+  });
+  try {
+    return await Promise.race([Promise.all([...pending]).then(() => true), late]);
+  } finally {
+    clearTimeout(timer);
+  }
+}, "settled");
+var listened = /* @__PURE__ */ __name(({ run, operation, what: what2 }, events, warn, waitMs) => {
+  const abort = new AbortController();
+  let closing = false;
+  const ended = Promise.resolve().then(() => run(abort.signal)).catch((error) => {
+    if (closing)
+      return;
+    const warning = { event: "warning", code: "listen_failed", operation };
+    events(warning);
+    warn(`${what2} arriving during this command are not saved: ${error instanceof Error ? error.message : String(error)}`, warning);
+  });
+  return {
+    operation,
+    what: what2,
+    closing: /* @__PURE__ */ __name(() => {
+      closing = true;
+    }, "closing"),
+    stop: /* @__PURE__ */ __name(() => {
+      abort.abort();
+      return settled(/* @__PURE__ */ new Set([ended]), waitMs);
+    }, "stop")
+  };
+}, "listened");
+var passivesOf = /* @__PURE__ */ __name((adapter) => [
+  ...adapter.listen ? [
+    {
+      run: /* @__PURE__ */ __name((signal) => adapter.listen?.(() => {
+      }, signal), "run"),
+      operation: "messages.listen",
+      what: "messages"
+    }
+  ] : [],
+  ...adapter.listenHistory ? [
+    {
+      run: /* @__PURE__ */ __name((signal) => adapter.listenHistory?.(() => {
+      }, signal), "run"),
+      operation: "history.listen",
+      what: "history batches"
+    }
+  ] : []
+], "passivesOf");
+var rekeyRecipients = /* @__PURE__ */ __name(async (app, profile, env, warn, from, to) => {
+  try {
+    await new RecipientList(recipientsPathFor(app, profile, env), app.command, REKEY_LOCK_WAIT_MS).rekey(from, to);
+  } catch (error) {
+    warn(`the recipient list still names ${from}: ${error instanceof Error ? error.message : String(error)}`, {
+      event: "warning",
+      code: "recipients_not_rekeyed",
+      operation: "recipients.rekey"
+    });
+  }
+}, "rekeyRecipients");
+var waitsOf = /* @__PURE__ */ __name((command) => {
+  const { closeWaitMs, rekeyPacing } = environmentOf(command);
+  return { ...closeWaitMs === void 0 ? {} : { closeWaitMs }, ...rekeyPacing ? { rekeyPacing } : {} };
+}, "waitsOf");
+var connected = /* @__PURE__ */ __name((connection, { app, provider, name, deletedWithoutChat, pace, history, savedChatId, unreadCounts }, { settings, env, renderer }, events, store = lazyStore(env, app.command, app.version), { listen: watching = false, closeWaitMs = SAVES_WAIT_MS, rekeyPacing } = {}) => {
+  const self = connection.self();
+  if (self !== null)
+    rememberAccount(app, settings.profile, self, env);
+  const memory = new FloodMemory(floodPathFor(app, settings.profile, env));
+  const rate = {
+    ...DEFAULT_PACE,
+    ...pace,
+    ...settings.requestsPerMinute === void 0 ? {} : { perMinute: settings.requestsPerMinute }
+  };
+  const pacer = new Pacer(pacePathFor(app, settings.profile, env), rate);
+  const adapter = observed(flooded(connection, memory, { name: name ?? app.command, warn: renderer.warn, pacer }), events);
+  const pending = /* @__PURE__ */ new Set();
+  const announcing = /* @__PURE__ */ new Set();
+  const closing = new AbortController();
+  const saving = self === null ? adapter : stored(adapter, {
+    account: { provider, account: self },
+    profile: { app: app.command, name: settings.profile },
+    store: store.open,
+    warn: renderer.warn,
+    events,
+    pending,
+    announcing,
+    closing: closing.signal,
+    ...deletedWithoutChat ? { deletedWithoutChat } : {},
+    ...rekeyPacing ? { rekeyPacing } : {},
+    rekeyed: /* @__PURE__ */ __name((from, to) => rekeyRecipients(app, settings.profile, env, renderer.warn, from, to), "rekeyed"),
+    recipientIds: /* @__PURE__ */ __name(() => (new RecipientList(recipientsPathFor(app, settings.profile, env), app.command).read() ?? []).flatMap((recipient) => [recipient.id, ...recipient.partnerId ? [recipient.partnerId] : []]), "recipientIds"),
+    ...history === "store" ? { namesFromStore: savedChatId ? { savedChatId } : {} } : {},
+    ...unreadCounts === "store" ? { countsUnread: true } : {}
+  });
+  const passives = history === "store" && self !== null && !watching ? passivesOf(saving).map((passive) => listened(passive, events, renderer.warn, closeWaitMs)) : [];
+  return {
+    adapter: saving,
+    close: /* @__PURE__ */ __name(async () => {
+      for (const passive of passives)
+        passive.closing();
+      try {
+        await connection.close();
+      } finally {
+        try {
+          const ended = await Promise.all(passives.map((passive) => passive.stop()));
+          const warn = renderer.warn;
+          const warned = /* @__PURE__ */ __name((warning, text) => {
+            events(warning);
+            warn(text, warning);
+          }, "warned");
+          passives.forEach(({ operation, what: what2 }, at) => {
+            if (ended[at])
+              return;
+            warned({ event: "warning", code: "store_not_written", operation }, `not saved to the local store: the messenger was still handing on ${what2} at exit`);
+          });
+          await settled(/* @__PURE__ */ new Set([...pending, ...announcing]), closeWaitMs);
+          closing.abort();
+          if (pending.size > 0)
+            warned({ event: "warning", code: "store_not_written", operation: "close" }, "not saved to the local store: the last messages were still being written at exit");
+          if (announcing.size > 0)
+            warned({ event: "warning", code: "stored_chats_failed", operation: "close" }, "the messenger's stored-chats hook did not finish and was abandoned at exit; nothing is lost");
+        } finally {
+          await store.close();
+        }
+      }
+    }, "close")
+  };
+}, "connected");
+var connectedFor = /* @__PURE__ */ __name(async (command, messenger, base, options) => {
+  const store = lazyStore(base.env, messenger.app.command, messenger.app.version);
+  let connection;
+  try {
+    connection = await connectFor(command, messenger, base, {
+      ...options,
+      stored: storedMessages(messenger.provider, store.open, () => connection?.self())
+    });
+  } catch (error) {
+    await store.close();
+    throw error;
+  }
+  return {
+    connection,
+    ...connected(connection, messenger, base, options.events, store, {
+      ...waitsOf(command),
+      ...options.listen ? { listen: true } : {}
+    })
+  };
+}, "connectedFor");
+var markedProfile = /* @__PURE__ */ __name((messenger, profile, env) => messenger.profileState?.(profile, env) === "signed-out" ? `${profile} (not signed in)` : profile, "markedProfile");
+var unrecorded = /* @__PURE__ */ __name((command, messenger, profile, { offline, profilesHere }, env) => {
+  if (!profilesHere.includes(profile)) {
+    return new CliError("not_found", `no profile named "${profile}" \u2014 profiles here: ${profilesHere.length > 0 ? profilesHere.map((one) => markedProfile(messenger, one, env)).join(", ") : "none"}`, { profiles: profilesHere });
+  }
+  const words = `${messenger.app.command} ${asFirstWord(profile)}`;
+  const setup = rootOf(command).commands.some((one) => one.name() === "setup") ? `\`${words}setup\`` : void 0;
+  if (messenger.history === "store")
+    return new CliError("not_found", `nothing recorded for profile "${profile}" yet \u2014 ${setup ? `link it with ${setup}, then ` : ""}run \`${words}serve\` or \`${words}watch\` once to fill the local store`);
+  const ways = [
+    ...setup ? [`log in with ${setup}`] : [],
+    ...offline ? ["run the command once without --offline"] : []
+  ];
+  return new CliError("not_found", `nothing recorded for profile "${profile}" yet \u2014 ${ways.length > 0 ? ways.join(", or ") : "log in to it first"}`);
+}, "unrecorded");
+var warnUnserved = /* @__PURE__ */ __name(async (messenger, profile, { env, renderer }, store) => {
+  if (servingProfiles(messenger.app, env).includes(profile))
+    return;
+  const account = recalledAccount(messenger.app, messenger.provider, profile, env);
+  if (!account)
+    return;
+  const newest = (await store.chats.chatStats(account)).map((one) => one.newestAt).reduce((latest, at) => at !== null && (latest === null || at > latest) ? at : latest, null);
+  renderer.warn(`no \`${messenger.app.command} ${profile} serve\` keeps profile "${profile}" up to date \u2014 ` + (newest === null ? "the local store holds no messages yet" : `the newest stored message is from ${newest}`));
+}, "warnUnserved");
+var pathOf2 = /* @__PURE__ */ __name((command) => {
+  const words = [];
+  for (let at = command; at?.parent; at = at.parent)
+    words.unshift(at.name());
+  return words;
+}, "pathOf");
+var refuseDenied = /* @__PURE__ */ __name((command, settings) => {
+  for (const key of readKeysForCommand(pathOf2(command))) {
+    const { level, key: named } = levelFor(settings.permissions, key);
+    if (level !== "deny")
+      continue;
+    throw new CliError("permission_error", `profile ${settings.profile} denies ${key} (permissions.${named} is deny, from the ${settings.permissionSources[named ?? ""] ?? "default"})`, { permission: key });
+  }
+}, "refuseDenied");
+var refuseLocalWrite = /* @__PURE__ */ __name((context, command, permission) => {
+  const { settings } = context;
+  const { level, key } = levelFor(settings.permissions, permission);
+  if (level === "allow" || level === "ask" && context.agent)
+    return;
+  if (key === CEILING_KEY)
+    throw ceilingRefusal(permission, command);
+  throw new CliError(level === "ask" ? "confirmation_required" : "permission_error", `profile ${settings.profile} does not let ${permission} write (permissions.${key} is ${level}, from the ${settings.permissionSources[key ?? ""] ?? "default"}); to allow it: ${command} ${settings.profile} config set permissions.${permission} allow`, { permission });
+}, "refuseLocalWrite");
+var messengerContext = /* @__PURE__ */ __name((command, messenger, resolving = {}) => {
+  const { app, provider } = messenger;
+  const base = baseContext(command, (flags, options) => messenger.resolveSettings(flags, { ...options, ...resolving }));
+  const { profile } = base.settings;
+  refuseDenied(command, base.settings);
+  refuseLacking(messenger, pathOf2(command));
+  refuseUnknownPermissionKeys(command, base.settings, app.command, messenger.permissionKey);
+  const warn = /* @__PURE__ */ __name((text, warning) => base.renderer.warn(text, warning), "warn");
+  const accountFor = /* @__PURE__ */ __name(() => {
+    const account = messenger.accountOf?.(command) ?? recalledAccount(app, provider, profile, base.env);
+    if (!account)
+      throw unrecorded(command, messenger, profile, base.settings, base.env);
+    return account;
+  }, "accountFor");
+  const guard = messenger.guard?.(command, base.settings, warn) ?? guardFor(app, base.settings, warn, base.env, terminalAsker(command));
+  const { embedders } = environmentOf(command);
+  return {
+    ...base,
+    agent: environmentOf(command).agent !== void 0,
+    profile,
+    stdin: environmentOf(command).stdin ?? process.stdin,
+    ...environmentOf(command).recognizer ? { recognizer: environmentOf(command).recognizer } : {},
+    guard,
+    withMessenger: /* @__PURE__ */ __name((work, options = {}) => base.run(async (events) => {
+      if (base.settings.offline)
+        throw new CliError("validation_error", OFFLINE);
+      const { connection, adapter, close } = await connectedFor(command, messenger, base, { ...options, events });
+      base.track(connection);
+      try {
+        return await work(adapter);
+      } finally {
+        await close();
+      }
+    }, { unbounded: options.listen === true }), "withMessenger"),
+    withStore: /* @__PURE__ */ __name((work, { name } = {}) => base.run(async () => {
+      const account = accountFor();
+      const store = await openStore({ env: base.env, command: app.command, version: app.version });
+      try {
+        return await work(store, account);
+      } finally {
+        await store.close();
+      }
+    }, name === void 0 ? {} : { name }), "withStore"),
+    withServices: /* @__PURE__ */ __name((work, { name } = {}) => base.run(async (events) => {
+      let held;
+      let store;
+      let warned;
+      let released;
+      const releaseConnection = /* @__PURE__ */ __name(() => released ??= held?.close() ?? Promise.resolve(), "releaseConnection");
+      const openOnce = /* @__PURE__ */ __name(() => store ??= openStore({ env: base.env, command: app.command, version: app.version }), "openOnce");
+      const deps = {
+        messenger,
+        profile,
+        env: base.env,
+        offline: base.settings.offline,
+        reads: messenger.history ?? "server",
+        // Turning recording off by name (--no-record, or record: false) keeps no search history either.
+        history: base.settings.record,
+        searchCatchUp: base.settings.searchCatchUp,
+        pictures: base.settings.pictureSearch,
+        reranker: base.settings.searchReranker,
+        guard,
+        ...embedders ? { embedders } : {},
+        connection: /* @__PURE__ */ __name(async () => {
+          if (base.settings.offline)
+            throw new CliError("validation_error", OFFLINE);
+          if (released)
+            throw new CliError("validation_error", "the read connection has already been released");
+          if (!held) {
+            let connection;
+            connection = await connectFor(command, messenger, base, {
+              events,
+              stored: storedMessages(messenger.provider, openOnce, () => connection?.self())
+            });
+            if (released) {
+              await connection.close();
+              throw new CliError("validation_error", "the read connection has already been released");
+            }
+            base.track(connection);
+            held = connected(connection, messenger, base, events, void 0, waitsOf(command));
+          }
+          return held.adapter;
+        }, "connection"),
+        account: /* @__PURE__ */ __name(async () => accountFor(), "account"),
+        // The connect's stored lookup opens the store too; only a service reading its answer there warns.
+        store: /* @__PURE__ */ __name(() => {
+          warned ??= openOnce().then(async (opened) => {
+            if (messenger.history === "store")
+              await warnUnserved(messenger, profile, base, opened);
+            return opened;
+          });
+          return warned;
+        }, "store")
+      };
+      try {
+        return await work(servicesFor(deps), async (read) => {
+          try {
+            return await read(await deps.connection());
+          } finally {
+            await releaseConnection();
+          }
+        });
+      } finally {
+        try {
+          await releaseConnection();
+        } finally {
+          if (store)
+            await (await store.catch(() => void 0))?.close();
+        }
+      }
+    }, name === void 0 ? {} : { name }), "withServices")
+  };
+}, "messengerContext");
+
+export {
+  holdEnd,
+  floodPathFor,
+  FloodMemory,
+  sendsPathFor,
+  SendJournal,
+  recipientsPathFor,
+  RecipientList,
+  ceilingRefusal,
+  levelRefusal,
+  sendGuard,
+  guardFor,
+  commandPermissions,
+  knownPermissionKeys,
+  knownBeside,
+  unknownPermissionIssues,
+  refuseUnknownPermissionKeys,
+  answerOf,
+  terminalAsker,
+  DEFAULT_PACE,
+  pacePathFor,
+  Pacer,
+  connectedFor,
+  refuseLocalWrite,
+  messengerContext
+};