@wirecat/zoom-cli 0.55.0 → 0.57.0

package/dist/bundle/chunk-QLIB3PEC.js

@@ -0,0 +1,1146 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  AUDIT_MIN_SCORE,
+  throughWrapper
+} from "./chunk-ICSKEDPI.js";
+import {
+  Command,
+  InvalidArgumentError,
+  Option,
+  annotate,
+  environmentOf,
+  itemOf,
+  listOf,
+  nextStep,
+  renderAnswer,
+  sharedCommand,
+  snakeKeys
+} from "./chunk-MAEFLDHG.js";
+import {
+  readOnlyLockOf
+} from "./chunk-OCGPZHXW.js";
+import {
+  formatReference
+} from "./chunk-GARCOIB6.js";
+import {
+  EVENT_QUERY,
+  MEETING_PROJECT_EVIDENCE_QUERY,
+  MEETING_QUERY,
+  MEETING_QUERY_GUIDE,
+  MeetingError,
+  SAVE_HELP,
+  eventItem,
+  exportMeeting,
+  importFiles,
+  listed,
+  meetingDetailsAnswer,
+  meetingHitsList,
+  meetingPeople,
+  meetingSummaryAnswer,
+  meetingTranscriptAnswer,
+  meetingsList,
+  meetingsQuery,
+  pull,
+  readMeetingProjectEvidence,
+  validateMeetingHitSearch,
+  validateMeetingPassage
+} from "./chunk-LXB6ONWC.js";
+import {
+  OPERATORS_BY_TYPE,
+  QUERY_LIMITS,
+  dateRange,
+  defineQuery,
+  fieldsHelp,
+  fieldsNamed,
+  parseLucene,
+  queryError,
+  queryFieldsOf,
+  timezoneOf,
+  validateQuery,
+  zonedMoment
+} from "./chunk-LSVI3A5X.js";
+import {
+  CliError,
+  array,
+  boolean,
+  check,
+  description,
+  maxLength,
+  optional,
+  pipe,
+  record,
+  safeParse,
+  strictObject,
+  string
+} from "./chunk-AE4BOXH7.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/cli/messenger/lacks.js
+var COMMAND_NEEDS = {
+  "account update": ["updateProfile", "change the profile"],
+  "account sessions list": ["sessions", "list the account's sessions"],
+  "account sessions end": ["endOtherSessions", "end other sessions"],
+  "chats events": ["chatEvents", "read who joined or left"],
+  "chats inspect": ["inspect", "read a link"],
+  "chats folders list": ["folders", "list its folders"],
+  "chats folders show": ["folders", "list its folders"],
+  "chats folders create": ["createFolder", "create a folder"],
+  "chats folders update": ["updateFolder", "change a folder"],
+  "chats folders delete": ["deleteFolder", "delete a folder"],
+  "contacts add": ["addContact", "add a contact"],
+  "contacts remove": ["removeContact", "remove a contact"],
+  "contacts rename": ["renameContact", "rename a contact"],
+  "contacts import": ["importContacts", "import contacts"],
+  "messages comments": ["comments", "read comments on a channel post"],
+  "messages pin": ["pin", "pin a message"],
+  "messages unpin": ["unpin", "unpin a message"]
+};
+var STORE_ANSWERS = /* @__PURE__ */ new Set(["chats events"]);
+var lackedNeed = /* @__PURE__ */ __name((messenger, path) => {
+  const need = COMMAND_NEEDS[path];
+  if (!need)
+    return void 0;
+  if (path === "messages comments" && (messenger?.readsComments ?? messenger?.channelComments) === false)
+    return need;
+  if (!messenger?.lacks?.includes(need[0]) && !messenger?.never?.includes(need[0]))
+    return void 0;
+  return messenger.history === "store" && STORE_ANSWERS.has(path) ? void 0 : need;
+}, "lackedNeed");
+var refuseLacking = /* @__PURE__ */ __name((messenger, path) => {
+  const need = lackedNeed(messenger, path.join(" "));
+  if (need)
+    throw new CliError("validation_error", `this messenger cannot ${need[1]}`);
+}, "refuseLacking");
+var hideNever = /* @__PURE__ */ __name((messenger, group) => {
+  const walk = /* @__PURE__ */ __name((command, path) => {
+    for (const child of command.commands) {
+      const at = [...path, child.name()];
+      const need = COMMAND_NEEDS[at.join(" ")];
+      if (need && messenger.never?.includes(need[0]))
+        child._hidden = true;
+      walk(child, at);
+    }
+  }, "walk");
+  walk(group, [group.name()]);
+  return group;
+}, "hideNever");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/meetings/cli/search.js
+var ZONED = /(?:Z|[+-]\d{2}:?\d{2})$/i;
+var moment = /* @__PURE__ */ __name((flag, end, readIn) => (value) => {
+  const zone = timezoneOf();
+  let time;
+  try {
+    time = zonedMoment(value, zone, { start: 0, end: value.length }, { end });
+  } catch {
+    throw new CliError("validation_error", `${flag} takes an ISO date, or a time with or without an offset`);
+  }
+  if (!ZONED.test(value.trim()))
+    readIn(zone);
+  return time;
+}, "moment");
+var integer = /* @__PURE__ */ __name((value) => {
+  if (!/^[1-9]\d*$/.test(value) || !Number.isSafeInteger(Number(value)))
+    throw new CliError("validation_error", "expected a positive safe integer");
+  return Number(value);
+}, "integer");
+var createMeetingSearchCommandDefinition = /* @__PURE__ */ __name((program) => {
+  let search = program.commands.find((command2) => command2.name() === "search");
+  if (!search) {
+    search = new Command("search").description("search the stored resources");
+    program.addCommand(search);
+  }
+  const readIn = /* @__PURE__ */ __name((zone) => command.setOptionValue("timesReadIn", zone), "readIn");
+  const command = search.command("meetings").description("find words in stored meetings, indexing new ones first").argument("<query>", 'words, OR, (groups), -word, "a phrase", "a b"~N (within N lines), exact:word, from:"Name" (who said the line); date>=30d, project:, tag:, topic: choose meetings; a word also matches its other forms and spellings speech recognition garbled').option("--meeting-id <id>", "only this stored meeting", integer).option("--identity-id <id>", "meetings with this participant identity; does not say who spoke a hit", integer).option("--person-id <id>", "meetings with a participant linked to this person", integer).option("--event-id <id>", "only meetings linked to this stored event", integer).option("--series-id <id>", "only meetings in this stored series", integer).option("--project <project>", "meetings confirmed in this project, by name, key or alias").option("--tag <name>", "meetings with this tag, by name or alias").option("--topic-name <name>", "meetings with this topic, by name or alias").option("--since-time <time>", "meetings starting at or after this ISO 8601 date or time", moment("--since-time", false, readIn)).option("--until-time <time>", "meetings starting at or before this ISO 8601 date or time; a date alone covers that whole local day", moment("--until-time", true, readIn)).option("--limit <n>", "how many hits, 1 through 1000 (default 100)", integer).option("--cursor <cursor>", "continue from the previous page's page.next_cursor, with the same query and filters").option("--max-read-bytes <bytes>", "most stored bytes to read, 1 through 67108864 (default 4194304)", integer);
+  annotate(command, {
+    origin: "handwritten",
+    effects: { remote: "none", local: "read" },
+    output: { entity: "meeting_hit" }
+  });
+  return command;
+}, "createMeetingSearchCommandDefinition");
+var meetingHitSearchRequest = /* @__PURE__ */ __name((query, options, signal) => {
+  const request = {
+    meetingId: options.meetingId,
+    participantIdentityId: options.identityId,
+    personId: options.personId,
+    eventId: options.eventId,
+    meetingSeriesId: options.seriesId,
+    project: options.project,
+    tag: options.tag,
+    topic: options.topicName ?? options.topic,
+    since: options.sinceTime,
+    until: options.untilTime,
+    limit: options.limit,
+    after: options.cursor,
+    maxReadBytes: options.maxReadBytes,
+    signal
+  };
+  validateMeetingHitSearch(query, request);
+  signal?.throwIfAborted();
+  return request;
+}, "meetingHitSearchRequest");
+var meetingSearchArguments = /* @__PURE__ */ __name((query, options) => Object.fromEntries(Object.entries({
+  query,
+  meeting_id: options.meetingId?.toString(),
+  identity_id: options.identityId?.toString(),
+  person_id: options.personId?.toString(),
+  event_id: options.eventId?.toString(),
+  series_id: options.seriesId?.toString(),
+  project: options.project,
+  tag: options.tag,
+  topic_name: options.topicName ?? options.topic,
+  since_time: options.sinceTime === void 0 ? void 0 : new Date(options.sinceTime).toISOString(),
+  until_time: options.untilTime === void 0 ? void 0 : new Date(options.untilTime).toISOString(),
+  max_read_bytes: options.maxReadBytes ?? 4194304
+}).filter(([, value]) => value !== void 0)), "meetingSearchArguments");
+var meetingSearchMeta = /* @__PURE__ */ __name((options) => {
+  const window2 = {
+    ...options.sinceTime === void 0 ? {} : { since: new Date(options.sinceTime).toISOString() },
+    ...options.untilTime === void 0 ? {} : { until: new Date(options.untilTime).toISOString() }
+  };
+  return {
+    ...options.timesReadIn === void 0 ? {} : { timezone: options.timesReadIn },
+    ...Object.keys(window2).length === 0 ? {} : { window: window2 }
+  };
+}, "meetingSearchMeta");
+var addMeetingSearchCommandDefinition = /* @__PURE__ */ __name((program, deps) => createMeetingSearchCommand(program).action(async (query, options) => {
+  const request = meetingHitSearchRequest(query, options, deps.signal());
+  deps.output(meetingHitsList(await deps.search(query, request, options), request.limit ?? 100, "search meetings", meetingSearchArguments(query, options), meetingSearchMeta(options)));
+}), "addMeetingSearchCommandDefinition");
+var createMeetingSearchCommand = sharedCommand(createMeetingSearchCommandDefinition);
+var addMeetingSearchCommand = sharedCommand(addMeetingSearchCommandDefinition);
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/meetings/cli/query-options.js
+var queryWordsAfterOptions = /* @__PURE__ */ __name((command) => {
+  command.allowUnknownOption();
+  const parse = command.parseOptions.bind(command);
+  command.parseOptions = (args) => {
+    const parsed = parse(args);
+    const end = parsed.unknown.indexOf("--");
+    const help = command._getHelpOption();
+    const typo = parsed.unknown.slice(0, end < 0 ? void 0 : end).find((word) => word.startsWith("--") && !help?.is(word));
+    if (typo !== void 0) {
+      command.allowUnknownOption(false);
+      command.unknownOption(typo);
+    }
+    if (end >= 0)
+      parsed.unknown.splice(end, 1);
+    return parsed;
+  };
+  return command;
+}, "queryWordsAfterOptions");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/meetings/cli/passage.js
+var count = /* @__PURE__ */ __name((value) => {
+  if (!/^(0|[1-9]\d*)$/.test(value) || !Number.isSafeInteger(Number(value)))
+    throw new CliError("validation_error", "expected a nonnegative safe integer");
+  return Number(value);
+}, "count");
+var meetingPassageRequest = /* @__PURE__ */ __name((reference, options, signal) => {
+  const input = {
+    before: options.beforeN,
+    after: options.afterN,
+    bytes: options.bytes,
+    max_read_bytes: options.maxReadBytes,
+    expected_fingerprint: options.expectedFingerprint,
+    format: options.format ?? "text",
+    signal
+  };
+  validateMeetingPassage(reference, input);
+  signal?.throwIfAborted();
+  return input;
+}, "meetingPassageRequest");
+var createMeetingPassageCommandDefinition = /* @__PURE__ */ __name((program) => {
+  const meetings = program.commands.find((command) => command.name() === "meetings");
+  if (!meetings)
+    throw new CliError("configuration_error", "meeting command group is unavailable");
+  return annotate(meetings.command("passage").description("read a cited cue with bounded context before and after it").argument("<reference>", "retained transcript cue reference from a search hit").option("--before-n <n>", "preceding cues (default 3)", count).option("--after-n <n>", "following cues (default 3); at most 999 surrounding cues in total", count).option("--bytes <bytes>", "cue JSON byte budget (default 65536); the anchor must fit", count).option("--max-read-bytes <bytes>", "stored text byte budget (default 4194304); boundary probes read metadata only", count).option("--expected-fingerprint <hash>", "reject a changed anchor using its previously read cue fingerprint").addOption(new Option("--format <format>", "compact text, Markdown or structured JSON").choices(["text", "markdown", "json"]).default("text")), {
+    origin: "handwritten",
+    effects: { remote: "none", local: "read" },
+    output: { entity: "meeting_passage" },
+    examples: [`${program.name()} meetings passage meeting:1/1/1/0 --json`]
+  });
+}, "createMeetingPassageCommandDefinition");
+var addMeetingPassageCommandDefinition = /* @__PURE__ */ __name((program, deps) => createMeetingPassageCommand(program).action(async (reference, options, command) => {
+  const globals = command.optsWithGlobals();
+  const format = globals.json || globals.jsonl ? "json" : options.format ?? "text";
+  const input = meetingPassageRequest(reference, { ...options, format }, deps.signal());
+  const result = await deps.read(reference, input);
+  input.signal?.throwIfAborted();
+  deps.output(result, format);
+}), "addMeetingPassageCommandDefinition");
+var createMeetingPassageCommand = sharedCommand(createMeetingPassageCommandDefinition);
+var addMeetingPassageCommand = sharedCommand(addMeetingPassageCommandDefinition);
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/meetings/cli/project-evidence.js
+var integer2 = /* @__PURE__ */ __name((value) => {
+  if (!/^[1-9]\d*$/.test(value) || !Number.isSafeInteger(Number(value)))
+    throw new CliError("validation_error", "expected a positive safe integer");
+  return Number(value);
+}, "integer");
+var addMeetingProjectEvidenceCommandDefinition = /* @__PURE__ */ __name((program, deps) => {
+  const group = program.commands.find((command) => command.name() === "meetings");
+  if (!group)
+    throw new CliError("configuration_error", "meeting command group is unavailable");
+  const projects = group.commands.find((command) => command.name() === "projects") ?? group.command("projects").description("project-name evidence in stored meetings");
+  return annotate(queryWordsAfterOptions(projects.command("evidence").description("find cited project-name and alias evidence in the local meeting index; does not refresh it or confirm membership")).argument("<project>", "existing project name, key or explicit alias").argument("[query...]", "exact ID fields and a UTC started_at range, joined by AND").addHelpText("after", `
+${fieldsHelp(MEETING_PROJECT_EVIDENCE_QUERY)}`).option("--limit <n>", "hits in one name page, 1 through 1000 (default 100)", integer2).option("--cursor <cursor>", "continue with the same project and frozen selection from next").option("--max-read-bytes <bytes>", "word-read byte budget, at most 67108864 (default 4194304)", integer2).action(async (project, words, options) => {
+    deps.output(await readMeetingProjectEvidence(deps.read, project, { ...options, query: words.join(" "), signal: deps.signal() }, deps.now?.()));
+  }), {
+    origin: "handwritten",
+    effects: { remote: "none", local: "read" },
+    query: MEETING_PROJECT_EVIDENCE_QUERY,
+    output: { entity: "meeting_project_evidence" }
+  });
+}, "addMeetingProjectEvidenceCommandDefinition");
+var addMeetingProjectEvidenceCommand = sharedCommand(addMeetingProjectEvidenceCommandDefinition);
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/meetings/cli/index.js
+var integer3 = /* @__PURE__ */ __name((text) => {
+  if (!/^[1-9]\d*$/.test(text) || !Number.isSafeInteger(Number(text)))
+    throw new InvalidArgumentError("expected a positive integer");
+  return Number(text);
+}, "integer");
+var lookbackDays = /* @__PURE__ */ __name((text) => {
+  if (!/^(0|[1-9]\d*)$/.test(text) || Number(text) > 31)
+    throw new InvalidArgumentError("expected an integer from 0 through 31 days");
+  return Number(text);
+}, "lookbackDays");
+var date = /* @__PURE__ */ __name((text) => {
+  try {
+    return zonedMoment(text, timezoneOf(), { start: 0, end: text.length });
+  } catch {
+    throw new InvalidArgumentError("expected an ISO date, or a time with or without an offset");
+  }
+}, "date");
+var LOCAL_READ = { remote: "none", local: "read" };
+var LOCAL_WRITE = { remote: "none", local: "write" };
+var FETCH = { remote: "read", local: "write" };
+var addMeetingCommandsDefinition = /* @__PURE__ */ __name((program, deps) => {
+  const group = annotate(program.command("meetings").description("stored meetings and their records"), {
+    effects: { remote: "none", local: "none" }
+  });
+  const output = /* @__PURE__ */ __name((command) => command.option("--json", "one JSON value").option("--jsonl", "one JSON object per item").hook("preAction", (cmd) => {
+    const opts = cmd.optsWithGlobals();
+    if (opts.json && opts.jsonl)
+      throw new MeetingError("validation_error", "choose --json or --jsonl");
+  }), "output");
+  const print = /* @__PURE__ */ __name((value, command) => {
+    const opts = command.optsWithGlobals();
+    deps.write(value, opts.json ? "json" : opts.jsonl ? "jsonl" : "text");
+  }, "print");
+  const list = queryWordsAfterOptions(group.command("list").description("stored meetings, newest first")).argument("[query...]", "field:value terms that narrow the list \u2014 the fields are below").addHelpText("after", `
+${fieldsHelp(MEETING_QUERY, MEETING_QUERY_GUIDE)}`);
+  annotate(list, { effects: LOCAL_READ, query: defineQuery(MEETING_QUERY), output: { entity: "meeting" } });
+  output(list).option("--limit <n>", "meetings per page", integer3, 100).option("--page <n>", "page number", integer3, 1).action(async (words, opts, command) => {
+    const query = meetingsQuery(words.join(" "));
+    print(await meetingsList(deps.store, { accountId: deps.accountId, limit: opts.limit, ...query ? { query } : {} }, opts.page), command);
+  });
+  output(annotate(group.command("show"), { effects: LOCAL_READ, output: { entity: "meeting_details" } }).description("show a stored meeting").argument("<meeting>", "stored meeting id", integer3).addHelpText("after", SAVE_HELP)).action(async (id, _opts, command) => {
+    print(await meetingDetailsAnswer(deps.store, id, deps.accountId), command);
+  });
+  output(annotate(group.command("transcript"), { effects: LOCAL_READ, output: { entity: "meeting_transcript" } }).description("show current meeting transcripts").argument("<meeting>", "stored meeting id", integer3).option("--history", "include superseded transcript versions").addHelpText("after", SAVE_HELP)).action(async (id, opts, command) => {
+    print(await meetingTranscriptAnswer(deps.store, id, deps.accountId, { history: opts.history }), command);
+  });
+  output(annotate(group.command("summary"), { effects: LOCAL_READ, output: { entity: "meeting_summary" } }).description("show stored meeting summaries").argument("<meeting>", "stored meeting id", integer3)).action(async (id, _opts, command) => {
+    print(await meetingSummaryAnswer(deps.store, id, deps.accountId), command);
+  });
+  output(annotate(group.command("export"), { effects: LOCAL_WRITE, output: { entity: "meeting_export" } }).description("export a meeting as Markdown or one transcript as WebVTT").argument("<meeting>", "stored meeting id", integer3).addOption(new Option("--format <format>", "export format").choices(["markdown", "vtt"]).default("markdown")).option("--transcript-id <id>", "export a specific transcript version", integer3).option("--output <file>", "write content to a file through the host's writer")).action(async (id, opts, command) => {
+    if (opts.output !== void 0 && !opts.output.trim())
+      throw new MeetingError("validation_error", "output path must not be empty");
+    if (opts.output !== void 0 && !deps.writeFile)
+      throw new MeetingError("configuration_error", "the host has no export file writer");
+    const result = await exportMeeting(deps.store, id, {
+      accountId: deps.accountId,
+      format: opts.format,
+      transcriptId: opts.transcriptId
+    });
+    if (opts.output !== void 0) {
+      await deps.writeFile?.(opts.output, result.content);
+      print({ meetingId: result.meetingId, format: result.format, output: opts.output }, command);
+    } else
+      print(result, command);
+  });
+  output(annotate(group.command("people"), { effects: LOCAL_READ, output: { entity: "meeting_participants" } }).description("find meeting participants by name or email").argument("<query>", "a name or an email address")).option("--limit <n>", "most matching observations per page, 1\u20131000 (default 50)", integer3).option("--scan-limit <n>", "most participant observations to inspect, 1\u201310000 (default 1000)", integer3).option("--max-read-bytes <bytes>", "most stored name and email bytes to read (default 1048576)", integer3).option("--cursor <cursor>", "continue with the same name query and selected account").action(async (query, opts, command) => {
+    print(await meetingPeople(deps.store, query, deps.accountId, {
+      limit: opts.limit,
+      scanLimit: opts.scanLimit,
+      maxReadBytes: opts.maxReadBytes,
+      cursor: opts.cursor
+    }), command);
+  });
+  output(annotate(group.command("sync"), {
+    effects: FETCH,
+    offline: false,
+    output: { entity: "meeting_ingestion" }
+  }).description("bring the stored meetings up to date from the connected account")).option("--since-time <time>", "fetch meetings starting at or after this ISO 8601 date or time", date).option("--lookback-days <days>", "revisit recent occurrences for late transcripts (0\u201331)", lookbackDays, 0).action(async (opts, command) => {
+    if (!deps.source)
+      throw new MeetingError("configuration_error", "meeting source is unavailable");
+    print(await pull(deps.source, deps.store, {
+      accountId: deps.accountId,
+      since: opts.sinceTime === void 0 ? void 0 : new Date(opts.sinceTime).toISOString(),
+      now: deps.now?.(),
+      lookbackMs: opts.lookbackDays * 864e5
+    }), command);
+  });
+  const importCommand = annotate(group.command("import"), {
+    effects: LOCAL_WRITE,
+    output: { entity: "meeting_ingestion" }
+  }).description("import downloaded meeting transcripts").argument("<folder>", "folder of transcripts downloaded from the provider");
+  if (deps.importHelp)
+    importCommand.addHelpText("after", `
+${deps.importHelp}`);
+  output(importCommand).action(async (folder, _opts, command) => {
+    if (!deps.readFiles)
+      throw new MeetingError("configuration_error", "file reader is unavailable");
+    const files = await deps.readFiles(folder);
+    if (files.some((file) => file.meeting.accountId !== deps.accountId))
+      throw new MeetingError("validation_error", "file account differs from selected account");
+    print(await importFiles(files, deps.store, deps.now?.()), command);
+  });
+  const eventList = queryWordsAfterOptions(annotate(program.command("events").description("the owner's stored events"), {
+    effects: { remote: "none", local: "none" }
+  }).command("list")).description("list stored events").argument("[query...]", "event id, origin or time fields that narrow the list").addHelpText("after", `
+${fieldsHelp(EVENT_QUERY, MEETING_QUERY_GUIDE)}`);
+  annotate(eventList, { effects: LOCAL_READ, output: { entity: "event" }, query: EVENT_QUERY });
+  output(eventList).action(async (words, _opts, command) => {
+    const query = words.length ? parseLucene(words.join(" "), { defaultField: "none", command: "events list" }) : void 0;
+    if (query)
+      validateQuery(query, EVENT_QUERY, { command: "events list" });
+    if (query && !deps.store.queryEvents)
+      throw new MeetingError("validation_error", "this store cannot filter events");
+    const events = query ? await deps.store.queryEvents?.(query) : await deps.store.events();
+    print(listed((events ?? []).map(eventItem)), command);
+  });
+}, "addMeetingCommandsDefinition");
+var addMeetingCommands = sharedCommand(addMeetingCommandsDefinition);
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/cli/list-query.js
+var LIST_QUERY_GUIDE = "https://github.com/WireCatLabs/cli-core/blob/main/docs/search/query-language.md";
+var withQuery = /* @__PURE__ */ __name((command, registry) => {
+  const query = defineQuery(registry);
+  annotate(command, { query, output: { entity: registry.entity } });
+  const shown = askable(query);
+  queryWordsAfterOptions(command).argument("[query...]", shown.length > 0 ? "field:value terms that narrow the list \u2014 the fields are below" : "field:value terms; this list filters by none yet");
+  if (shown.length > 0)
+    command.addHelpText("after", `
+${fieldsHelp({ ...query, fields: shown }, LIST_QUERY_GUIDE)}`);
+  return command;
+}, "withQuery");
+var unfilteredQuery = /* @__PURE__ */ __name((entity, schema) => ({
+  entity,
+  backend: "native",
+  fields: queryFieldsOf(schema, {})
+}), "unfilteredQuery");
+var commandPath = /* @__PURE__ */ __name((command) => {
+  const words = [];
+  for (let at = command; at?.parent; at = at.parent)
+    words.unshift(at.name());
+  return words.join(" ");
+}, "commandPath");
+var listQuery = /* @__PURE__ */ __name((text, registry, command) => {
+  const context = { command, guide: LIST_QUERY_GUIDE };
+  const typed = text.trim() === "" ? void 0 : parseLucene(text, { defaultField: "none", ...context });
+  if (typed)
+    validateQuery(typed, registry, context);
+  const named = typed ? fieldsNamed(typed) : /* @__PURE__ */ new Set();
+  const defaults = (registry.defaults ?? []).filter((term) => !named.has(term.replace(/^-/, "").split(/[:<>=]/)[0] ?? "")).map((term) => parseLucene(term, { defaultField: "none", ...context }).root);
+  const roots = [...typed ? [typed.root] : [], ...defaults];
+  if (roots.length === 0)
+    return void 0;
+  if (roots.length === 1 && typed)
+    return typed;
+  return {
+    version: 1,
+    language: "lucene-v1",
+    root: {
+      kind: "boolean",
+      clauses: roots.map((node) => ({ occur: "must", node })),
+      span: { start: 0, end: text.length }
+    }
+  };
+}, "listQuery");
+var typedQuery = /* @__PURE__ */ __name((words) => typeof words === "string" ? words : (words ?? []).join(" "), "typedQuery");
+var EVERY = Number.MAX_SAFE_INTEGER - 1;
+var pageOf = /* @__PURE__ */ __name(({ limit, page, all }) => all ? { limit: EVERY, offset: 0 } : { limit, offset: (page - 1) * limit }, "pageOf");
+var pagedList = /* @__PURE__ */ __name((command, { limit, page, all }, { items, has_more, ...rest }) => listOf(command, {
+  ...rest,
+  items,
+  limit: all ? Math.max(1, items.length) : limit,
+  has_more: all ? false : has_more,
+  page
+}), "pagedList");
+var askable = /* @__PURE__ */ __name((registry) => registry.backend === "native" ? registry.fields.filter((field) => field.native) : registry.fields, "askable");
+var queryArgument = /* @__PURE__ */ __name((registry) => {
+  const fields = askable(registry);
+  return optional(pipe(string(), maxLength(QUERY_LIMITS.bytes), description(fields.length === 0 ? "field:value terms; this list filters by none yet, so any term is refused" : `${registry.backend === "native" ? "field:value terms joined by AND that narrow the list" : "field:value terms that narrow the list (Lucene: AND OR NOT, [a TO b], > <)"}; fields: ${fields.map((field) => field.name).join(", ")}; e.g. ${fields[0]?.example ?? ""}`)));
+}, "queryArgument");
+var nativeTerms = /* @__PURE__ */ __name((ast, command) => {
+  const terms = /* @__PURE__ */ new Map();
+  if (!ast)
+    return terms;
+  const context = { command, guide: LIST_QUERY_GUIDE };
+  const add = /* @__PURE__ */ __name((node) => {
+    if (node.kind === "boolean") {
+      for (const clause of node.clauses) {
+        if (clause.occur !== "must")
+          queryError("query.unsupported-placement", clause.node.span, "this list takes only field:value terms joined by AND", context);
+        add(clause.node);
+      }
+      return;
+    }
+    if (terms.has(node.field))
+      queryError("query.unsupported-placement", node.span, `${node.field} only once here`, context);
+    terms.set(node.field, node);
+  }, "add");
+  add(ast.root);
+  return terms;
+}, "nativeTerms");
+var queryTerms = /* @__PURE__ */ __name((words, registry, command) => {
+  const terms = /* @__PURE__ */ new Map();
+  for (const [field, node] of nativeTerms(listQuery(typedQuery(words), registry, command), command)) {
+    if (node.operator !== "term" && node.operator !== "phrase")
+      queryError("query.unsupported-placement", node.span, `${field} takes one whole value here`, {
+        command,
+        guide: LIST_QUERY_GUIDE
+      });
+    const enumerated = registry.fields.find(({ name }) => name === field)?.type === "enum";
+    terms.set(field, enumerated ? node.value.toLowerCase() : node.value);
+  }
+  return terms;
+}, "queryTerms");
+var timeBounds = /* @__PURE__ */ __name((term, zone = timezoneOf()) => {
+  if (!term)
+    return {};
+  const upper = term.operator === "range" ? term.upper ?? "*" : term.value;
+  const range = dateRange(term.value, upper, term.operator === "range" ? term.lower_inclusive !== false : true, term.operator === "range" ? term.upper_inclusive !== false : true, zone, term.span);
+  const until = range.upper === void 0 ? void 0 : range.upper - (range.upper_inclusive ? 0 : 1);
+  return {
+    ...range.lower === void 0 ? {} : { since: range.lower },
+    ...until === void 0 ? {} : { until },
+    meta: {
+      timezone: zone,
+      window: {
+        ...range.lower === void 0 ? {} : { since: new Date(range.lower).toISOString() },
+        ...until === void 0 ? {} : { until: new Date(until).toISOString() }
+      }
+    }
+  };
+}, "timeBounds");
+var searchText = /* @__PURE__ */ __name((term) => term === void 0 ? void 0 : term.value.replace(/^\*+|\*+$/g, ""), "searchText");
+var nativeField = /* @__PURE__ */ __name((field) => ({ ...field, native: true }), "nativeField");
+var termField = /* @__PURE__ */ __name((name, type, example, more = {}) => nativeField({
+  name,
+  type,
+  operators: OPERATORS_BY_TYPE[type].filter((operator) => operator === "term" || operator === "phrase"),
+  example,
+  ...more
+}), "termField");
+var queryHelp = /* @__PURE__ */ __name((registry) => `
+${fieldsHelp(registry, LIST_QUERY_GUIDE)}`, "queryHelp");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/cli/paging.js
+var positiveCount = /* @__PURE__ */ __name((flag) => (value) => {
+  if (!/^\d+$/.test(value.trim()) || Number(value) < 1)
+    throw new CliError("validation_error", `${flag} takes a whole number from 1 upwards, not "${value}"`);
+  return Number(value);
+}, "positiveCount");
+var withPaging = /* @__PURE__ */ __name((command) => command.option("--limit <n>", "how many to show", positiveCount("--limit")).option("--page <n>", "which page, starting at 1", positiveCount("--page")).option("--all", "every row, no paging"), "withPaging");
+var window = /* @__PURE__ */ __name(({ limit, page, all }) => all ? { offset: 0 } : { limit, offset: (page - 1) * limit }, "window");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/cli/messenger/chat-answers.js
+var defined = /* @__PURE__ */ __name((record2) => Object.fromEntries(Object.entries(record2).filter(([, value]) => value !== void 0)), "defined");
+var chatRef = /* @__PURE__ */ __name((account, chat) => formatReference({ type: "chat", provider: account.provider, account: account.account, chat }), "chatRef");
+var settingsOf = /* @__PURE__ */ __name((settings) => defined({
+  all_can_pin: settings.allCanPin,
+  only_admins_add: settings.onlyAdminsAdd,
+  only_admins_call: settings.onlyAdminsCall,
+  only_owner_edits_info: settings.onlyOwnerEditsInfo,
+  members_see_link: settings.membersSeeLink,
+  join_approval: settings.joinApproval,
+  only_admins_send: settings.onlyAdminsSend,
+  only_admins_edit_info: settings.onlyAdminsEditInfo,
+  disappearing_seconds: settings.disappearingSeconds
+}), "settingsOf");
+var chatAnswer = /* @__PURE__ */ __name((account, chat) => defined({
+  ref: chatRef(account, chat.id),
+  id: chat.id,
+  title: chat.title,
+  kind: chat.kind,
+  unread_count: chat.unreadCount,
+  unread_mentions: chat.unreadMentions,
+  last_message_at: chat.lastMessageAt,
+  participants_count: chat.participantsCount,
+  muted: chat.muted,
+  muted_until: chat.mutedUntil ?? void 0,
+  archived: chat.archived,
+  marked_unread: chat.markedUnread,
+  membership_state: chat.membershipState,
+  parent_chat_id: chat.parentChatId ?? void 0,
+  scope: chat.scope,
+  provider_metadata: chat.providerMetadata,
+  description: chat.description,
+  invite_link: chat.link,
+  settings: chat.settings ? settingsOf(chat.settings) : void 0,
+  members: chat.members?.map(memberAnswer)
+}), "chatAnswer");
+var memberAnswer = /* @__PURE__ */ __name((member) => {
+  const group = member;
+  return defined({
+    id: member.id,
+    name: member.name,
+    username: member.username,
+    role: group.role,
+    last_seen_at: group.lastSeenAt,
+    registered_at: group.registeredAt,
+    joined_at: group.joinedAt,
+    invited_by: group.invitedBy,
+    is_bot: group.isBot,
+    deleted: group.deleted,
+    flagged: group.flagged,
+    has_photo: group.hasPhoto,
+    score: group.score,
+    reasons: group.reasons,
+    check: group.check ? snakeKeys(group.check) : void 0
+  });
+}, "memberAnswer");
+var contactRef = /* @__PURE__ */ __name((provider, id) => formatReference({ type: "contact", provider, id }), "contactRef");
+var contactAnswer = /* @__PURE__ */ __name((account, contact) => {
+  const card = contact;
+  return defined({
+    ref: contactRef(account.provider, contact.id),
+    id: contact.id,
+    name: contact.name,
+    username: contact.username,
+    alias: contact.alias,
+    display_name: contact.displayName,
+    description: contact.description,
+    last_messaged_at: contact.lastMessagedAt,
+    chats: card.chats?.map((chat) => ({
+      ref: chatRef(account, chat.id),
+      id: chat.id,
+      title: chat.title,
+      kind: chat.kind,
+      last_message_at: chat.lastMessageAt
+    })),
+    notes: card.notes?.map(({ id, text, revision, createdAt, updatedAt }) => ({
+      id,
+      text,
+      revision,
+      created_at: createdAt,
+      updated_at: updatedAt
+    }))
+  });
+}, "contactAnswer");
+var chatEventAnswer = /* @__PURE__ */ __name((chatId, event) => defined({
+  chat_id: chatId,
+  time: event.timestamp,
+  type: event.event,
+  message_id: event.messageId,
+  by: event.by,
+  people: event.people,
+  title: event.title
+}), "chatEventAnswer");
+var HISTORY_TYPES = { joined: "join", left: "leave", changed: "profile" };
+var memberEventAnswer = /* @__PURE__ */ __name((chatId, event) => defined({
+  chat_id: chatId,
+  time: event.at,
+  type: HISTORY_TYPES[event.event],
+  by: event.invitedBy === void 0 ? void 0 : { id: event.invitedBy, name: null },
+  people: [{ id: event.id, name: event.name, username: event.username }],
+  before: event.before ? { name: event.before.name, username: event.before.username } : void 0
+}), "memberEventAnswer");
+var inviteLinkAnswer = /* @__PURE__ */ __name((link) => defined({
+  link: link.link,
+  approval: link.approval,
+  expires_at: link.expiresAt,
+  max_uses: link.maxUses,
+  primary: link.primary,
+  revoked: link.revoked,
+  pending_count: link.pending,
+  joined_count: link.joined
+}), "inviteLinkAnswer");
+var joinRequestAnswer = /* @__PURE__ */ __name((request) => defined({
+  person_id: request.person.id,
+  name: request.person.name,
+  username: request.person.username,
+  requested_at: request.requestedAt,
+  about: request.about
+}), "joinRequestAnswer");
+var pollVoteAnswer = /* @__PURE__ */ __name((vote) => ({
+  person_id: vote.person.id,
+  name: vote.person.name,
+  username: vote.person.username,
+  answers: vote.answers,
+  voted_at: vote.votedAt
+}), "pollVoteAnswer");
+var topicAnswer = /* @__PURE__ */ __name((topic) => defined({
+  id: topic.id,
+  title: topic.title,
+  closed: topic.closed,
+  pinned: topic.pinned,
+  hidden: topic.hidden,
+  unread_count: topic.unreadCount,
+  last_message_at: topic.lastMessageAt,
+  created_at: topic.createdAt,
+  untrusted: ["title"]
+}), "topicAnswer");
+var folderAnswer = /* @__PURE__ */ __name((folder) => {
+  const shown = "chats" in folder ? folder : void 0;
+  const listed2 = shown ? void 0 : folder;
+  return defined({
+    id: folder.id,
+    title: folder.title,
+    chat_ids: listed2 ? listed2.chatIds : shown?.chats.map((chat) => chat.id) ?? [],
+    emoji: folder.emoji,
+    include: folder.include,
+    skip: folder.skip,
+    excluded_chat_ids: listed2?.excludedChatIds ?? shown?.excluded.map((chat) => chat.id),
+    pinned_chat_ids: listed2?.pinnedChatIds ?? shown?.pinned.map((chat) => chat.id),
+    chats: shown?.chats,
+    pinned_chats: shown?.pinned,
+    excluded_chats: shown?.excluded
+  });
+}, "folderAnswer");
+var lines = /* @__PURE__ */ __name((line) => (body) => (body.items ?? (body.item === void 0 ? [] : [body.item])).map((item) => `${line(item).trimEnd()}
+`).join(""), "lines");
+var pageOf2 = /* @__PURE__ */ __name(({ limit, page, all }, { items, hasMore }) => all ? { limit: Math.max(1, items.length), has_more: false, page: 1 } : { limit, has_more: hasMore, page }, "pageOf");
+var wholeList = /* @__PURE__ */ __name((command, items, extra = {}) => listOf(command, { items, limit: Math.max(1, items.length), has_more: false, ...extra }), "wholeList");
+var chatShown = /* @__PURE__ */ __name((account, card) => {
+  const listed2 = card.members?.length;
+  const short = listed2 !== void 0 && card.participantsCount !== null && listed2 < card.participantsCount;
+  return itemOf(chatAnswer(account, card), short ? {
+    missing: [
+      {
+        field: "members",
+        why: `${listed2} listed; the chat reports ${card.participantsCount} \u2014 the list may omit your account or be partial`,
+        step: "chats.members"
+      }
+    ],
+    next: [nextStep("chats.members", { args: { chat: card.id } })]
+  } : {});
+}, "chatShown");
+var scoreFloor = /* @__PURE__ */ __name((ast) => {
+  const term = nativeTerms(ast, "chats members check").get("score");
+  if (!term)
+    return AUDIT_MIN_SCORE;
+  const upper = term.operator === "range" ? term.upper ?? "*" : term.value;
+  if (term.operator !== "range" || upper !== "*")
+    queryError("query.unsupported-operator", term.span, "score takes a lower bound: score>=3", {
+      command: "chats members check",
+      guide: LIST_QUERY_GUIDE
+    });
+  const floor = Number(term.value);
+  return Math.ceil(term.lower_inclusive === false ? floor + 1 : floor);
+}, "scoreFloor");
+var auditAnswer = /* @__PURE__ */ __name((audit) => wholeList("chats members check", audit.items.map(memberAnswer), {
+  ...audit.more ? { meta: { truncated: true } } : {},
+  ...audit.completeness && audit.completeness.state !== "complete" ? {
+    missing: [
+      {
+        field: "reasons",
+        why: "never_wrote counts only stored messages, and the store does not hold the chat whole",
+        ...audit.fetch ? { step: "messages.sync" } : {}
+      }
+    ],
+    ...audit.fetch ? { next: [nextStep("messages.sync", { args: { chat: audit.chatId } })] } : {}
+  } : {}
+}), "auditAnswer");
+var renderItem = /* @__PURE__ */ __name((command, output, value, next = []) => renderAnswer(command, output, itemOf(snakeKeys(value), { next })), "renderItem");
+var withPage = /* @__PURE__ */ __name((command) => command.option("--limit <n>", "how many to show", positiveCount("--limit")).option("--page <n>", "which page, starting at 1", positiveCount("--page")), "withPage");
+var documentLinkAnswer = /* @__PURE__ */ __name(({ url, documentId, title, inStore, locator, sentAt, sender }) => ({
+  url,
+  document_id: documentId,
+  title,
+  in_store: inStore,
+  ref: locator,
+  sent_at: sentAt,
+  sender
+}), "documentLinkAnswer");
+var accountAnswer = /* @__PURE__ */ __name((provider, { id, name, username, phone }) => ({
+  provider,
+  id,
+  name,
+  username,
+  ...phone === void 0 ? {} : { phone }
+}), "accountAnswer");
+var sessionAnswer = /* @__PURE__ */ __name(({ current, client, device, location, lastActiveAt, createdAt }) => ({
+  current,
+  client,
+  device,
+  location,
+  last_active_at: lastActiveAt,
+  ...createdAt === void 0 ? {} : { created_at: createdAt }
+}), "sessionAnswer");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/background/relay.js
+import { createHash } from "node:crypto";
+import { chmodSync, lstatSync, mkdirSync, rmSync } from "node:fs";
+import { createConnection, createServer } from "node:net";
+import { tmpdir } from "node:os";
+import { dirname, isAbsolute, join } from "node:path";
+import { PassThrough, Writable } from "node:stream";
+var RELAY_PROTOCOL = 1;
+var requestSchema = strictObject({
+  argv: array(string()),
+  env: record(string(), string()),
+  cwd: pipe(string(), check((path) => isAbsolute(path))),
+  tty: boolean(),
+  stdinTty: boolean()
+});
+var MAX_CLIENT_LINE = 1024 * 1024;
+var MAX_SERVE_LINE = 64 * 1024 * 1024;
+var MAX_SOCKET_PATH = 100;
+var relayPath = /* @__PURE__ */ __name((lockPath) => {
+  const beside = lockPath.replace(/\.lock$/, ".sock");
+  if (beside.length <= MAX_SOCKET_PATH)
+    return beside;
+  const hash = createHash("sha256").update(beside).digest("hex").slice(0, 16);
+  const name = join(`wirecat-relay-${process.getuid?.() ?? "user"}`, `${hash}.sock`);
+  const temporary = join(tmpdir(), name);
+  if (temporary.length <= MAX_SOCKET_PATH || process.platform === "win32")
+    return temporary;
+  return join("/tmp", name);
+}, "relayPath");
+var privateDirectory = /* @__PURE__ */ __name((dir) => {
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  const stat = lstatSync(dir);
+  const mine = process.getuid === void 0 || stat.uid === process.getuid();
+  if (!stat.isDirectory() || !mine || (stat.mode & 63) !== 0) {
+    throw new CliError("permission_error", `${dir} is not a private directory, so serve does not listen there`);
+  }
+}, "privateDirectory");
+var lines2 = /* @__PURE__ */ __name((socket, max, onLine, onTooLong) => {
+  let buffered = "";
+  socket.setEncoding("utf8");
+  socket.on("data", (chunk) => {
+    buffered += chunk;
+    for (let end = buffered.indexOf("\n"); end >= 0; end = buffered.indexOf("\n")) {
+      const line = buffered.slice(0, end);
+      buffered = buffered.slice(end + 1);
+      if (line)
+        onLine(line);
+    }
+    if (buffered.length > max)
+      onTooLong();
+  });
+}, "lines");
+var frame = /* @__PURE__ */ __name((socket, value) => {
+  if (!socket.destroyed)
+    socket.write(`${JSON.stringify(value)}
+`);
+}, "frame");
+var listenRelay = /* @__PURE__ */ __name(async (path, run) => {
+  privateDirectory(dirname(path));
+  rmSync(path, { force: true });
+  const open = /* @__PURE__ */ new Set();
+  const running = /* @__PURE__ */ new Set();
+  const server = createServer((socket) => {
+    open.add(socket);
+    const stop = new AbortController();
+    const stdin = new PassThrough();
+    let started = false;
+    socket.on("error", () => {
+    });
+    socket.on("close", () => {
+      open.delete(socket);
+      stop.abort(new CliError("cancelled", "the client went away", { retryable: false }));
+      if (!stdin.writableEnded)
+        stdin.end();
+    });
+    lines2(socket, MAX_CLIENT_LINE, (line) => {
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch {
+        socket.destroy();
+        return;
+      }
+      if (!started) {
+        started = true;
+        if (message.v !== RELAY_PROTOCOL) {
+          frame(socket, { diagnostic: `serve speaks relay protocol ${RELAY_PROTOCOL}; restart it`, exit: 1 });
+          socket.end();
+          return;
+        }
+        const parsed = safeParse(requestSchema, message.run);
+        if (!parsed.success) {
+          socket.destroy();
+          return;
+        }
+        stdin.isTTY = parsed.output.stdinTty;
+        if (parsed.output.stdinTty)
+          stdin.end();
+        const job = serve(socket, parsed.output, stdin, stop.signal, run);
+        running.add(job);
+        void job.then(() => running.delete(job), () => running.delete(job));
+        return;
+      }
+      if (typeof message.stdin === "string" && !stdin.writableEnded)
+        stdin.write(Buffer.from(message.stdin, "base64"));
+      if (message.stdinEnd === true && !stdin.writableEnded)
+        stdin.end();
+    }, () => socket.destroy());
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(path, () => {
+      server.off("error", reject);
+      resolve();
+    });
+  });
+  chmodSync(path, 384);
+  return {
+    close: /* @__PURE__ */ __name(async () => {
+      for (const socket of open)
+        socket.destroy();
+      await new Promise((resolve) => server.close(() => resolve()));
+      await Promise.allSettled(running);
+      rmSync(path, { force: true });
+    }, "close")
+  };
+}, "listenRelay");
+var serve = /* @__PURE__ */ __name(async (socket, request, stdin, signal, run) => {
+  const streams = {
+    data: /* @__PURE__ */ __name((text) => frame(socket, { data: text }), "data"),
+    diagnostic: /* @__PURE__ */ __name((text) => frame(socket, { diagnostic: text }), "diagnostic"),
+    progress: /* @__PURE__ */ __name((text) => frame(socket, { progress: text }), "progress")
+  };
+  const stdout = new Writable({
+    write: /* @__PURE__ */ __name((chunk, _encoding, done) => {
+      frame(socket, { raw: Buffer.from(chunk).toString("base64") });
+      done();
+    }, "write")
+  });
+  let code = 1;
+  try {
+    code = await run(request, { streams, stdin, stdout, signal });
+  } finally {
+    frame(socket, { exit: code });
+    socket.end();
+  }
+}, "serve");
+var relayCommand = /* @__PURE__ */ __name((path, request, options) => new Promise((resolve, reject) => {
+  const { streams, stdin, stdout, signal, deadlineMs, writes, holder, listens = false } = options;
+  const socket = createConnection(path);
+  let connected = false;
+  let settled = false;
+  let timer;
+  const forward = /* @__PURE__ */ __name((chunk) => frame(socket, { stdin: Buffer.from(chunk).toString("base64") }), "forward");
+  const ended = /* @__PURE__ */ __name(() => frame(socket, { stdinEnd: true }), "ended");
+  const brokenPipe = /* @__PURE__ */ __name((error) => {
+    if (error.code === "EPIPE")
+      finish({ code: 0 });
+  }, "brokenPipe");
+  const finish = /* @__PURE__ */ __name((outcome) => {
+    if (settled)
+      return;
+    settled = true;
+    if (timer)
+      clearTimeout(timer);
+    stdout.off("error", brokenPipe);
+    signal.removeEventListener("abort", aborted);
+    stdin.off("data", forward).off("end", ended);
+    stdin.pause();
+    socket.destroy();
+    if ("code" in outcome)
+      resolve(outcome.code);
+    else
+      reject(outcome.error);
+  }, "finish");
+  const stopped = /* @__PURE__ */ __name(() => writes ? new CliError("outcome_unknown", `${holder} stopped before the command finished; it may have run \u2014 check before repeating it`, { retryable: false }) : new CliError("provider_unavailable", `${holder} stopped before the command finished`, { retryable: true }), "stopped");
+  const aborted = /* @__PURE__ */ __name(() => finish(listens ? { code: 0 } : { error: signal.reason }), "aborted");
+  if (signal.aborted)
+    return aborted();
+  signal.addEventListener("abort", aborted, { once: true });
+  stdout.on("error", brokenPipe);
+  if (deadlineMs !== void 0)
+    timer = setTimeout(() => finish({ error: stopped() }), deadlineMs);
+  socket.on("connect", () => {
+    connected = true;
+    frame(socket, { v: RELAY_PROTOCOL, run: request });
+    if (request.stdinTty)
+      ended();
+    else {
+      stdin.on("data", forward).once("end", ended);
+      stdin.resume();
+    }
+  });
+  socket.on("error", (error) => {
+    if (connected)
+      return finish({ error: stopped() });
+    finish({
+      error: new CliError("provider_unavailable", `${holder} holds the connection but does not answer its relay (${error.code ?? error.message}) \u2014 restart it`, { retryable: false, sent: false })
+    });
+  });
+  socket.on("close", () => finish({ error: stopped() }));
+  lines2(socket, MAX_SERVE_LINE, (line) => {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      return finish({ error: stopped() });
+    }
+    if (typeof message.data === "string")
+      streams.data(message.data);
+    if (typeof message.diagnostic === "string")
+      streams.diagnostic(message.diagnostic);
+    if (typeof message.progress === "string")
+      streams.progress?.(message.progress);
+    if (typeof message.raw === "string")
+      stdout.write(Buffer.from(message.raw, "base64"));
+    if (typeof message.exit === "number")
+      finish({ code: message.exit });
+  }, () => finish({ error: stopped() }));
+}), "relayCommand");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/cli/messenger/serve-relay.js
+var lentConnection = /* @__PURE__ */ __name((connection, watchers) => throughWrapper(connection, {
+  close: /* @__PURE__ */ __name(async () => {
+  }, "close"),
+  feed: void 0,
+  storedChats: void 0,
+  listen: void 0,
+  listenHistory: void 0,
+  ...connection.watch && watchers ? {
+    // A watcher that throws (its output limit, a closed reader) ends its own watch, never serve's.
+    watch: /* @__PURE__ */ __name(async (onEvent, signal, onReady) => {
+      let watcher;
+      try {
+        await new Promise((resolve, reject) => {
+          watcher = /* @__PURE__ */ __name((event) => {
+            try {
+              onEvent(event);
+            } catch (error) {
+              reject(error);
+            }
+          }, "watcher");
+          watchers.add(watcher);
+          signal.addEventListener("abort", () => resolve(), { once: true });
+          onReady?.();
+          if (signal.aborted)
+            resolve();
+        });
+      } finally {
+        if (watcher)
+          watchers.delete(watcher);
+      }
+    }, "watch")
+  } : { watch: void 0 }
+}), "lentConnection");
+var serveRelay = /* @__PURE__ */ __name((command, messenger) => {
+  let held;
+  let relay;
+  const watchers = /* @__PURE__ */ new Set();
+  const borrowed = /* @__PURE__ */ __name(() => {
+    const connection = held;
+    if (!connection)
+      throw new CliError("provider_unavailable", "serve is not connected yet", { retryable: true });
+    return lentConnection(connection, watchers);
+  }, "borrowed");
+  return {
+    messenger: {
+      ...messenger,
+      connect: /* @__PURE__ */ __name(async (...args) => {
+        held = await messenger.connect(...args);
+        return held;
+      }, "connect")
+    },
+    arrived: /* @__PURE__ */ __name((event) => {
+      for (const watcher of watchers)
+        watcher(event);
+    }, "arrived"),
+    /** Listens beside the lock; the address goes into it, which is how a client finds it. */
+    open: /* @__PURE__ */ __name(async (lockPath, profile) => {
+      const environment = environmentOf(command);
+      const runCommand = environment.runCommand;
+      if (!runCommand)
+        return void 0;
+      const readOnly = readOnlyLockOf(messenger.app, environment.env ?? process.env);
+      const path = relayPath(lockPath);
+      relay = await listenRelay(path, (request, io) => runCommand(request.argv, {
+        env: {
+          ...request.env,
+          ...readOnly ? { [`${messenger.app.envPrefix}_READ_ONLY`]: "1" } : {}
+        },
+        streams: io.streams,
+        stdin: io.stdin,
+        stdout: io.stdout,
+        tty: request.tty,
+        signal: io.signal,
+        answer: /* @__PURE__ */ __name(() => null, "answer"),
+        relayed: { profile, cwd: request.cwd, connection: borrowed }
+      }));
+      return { path, protocol: RELAY_PROTOCOL };
+    }, "open"),
+    close: /* @__PURE__ */ __name(async () => {
+      await relay?.close();
+    }, "close")
+  };
+}, "serveRelay");
+
+export {
+  COMMAND_NEEDS,
+  lackedNeed,
+  refuseLacking,
+  hideNever,
+  RELAY_PROTOCOL,
+  relayCommand,
+  lentConnection,
+  serveRelay,
+  meetingPassageRequest,
+  createMeetingPassageCommand,
+  addMeetingPassageCommand,
+  addMeetingProjectEvidenceCommand,
+  meetingHitSearchRequest,
+  meetingSearchArguments,
+  meetingSearchMeta,
+  createMeetingSearchCommand,
+  addMeetingCommands,
+  LIST_QUERY_GUIDE,
+  withQuery,
+  unfilteredQuery,
+  commandPath,
+  listQuery,
+  typedQuery,
+  pageOf,
+  pagedList,
+  queryArgument,
+  nativeTerms,
+  queryTerms,
+  timeBounds,
+  searchText,
+  nativeField,
+  termField,
+  queryHelp,
+  positiveCount,
+  withPaging,
+  window,
+  chatRef,
+  chatAnswer,
+  memberAnswer,
+  contactRef,
+  contactAnswer,
+  chatEventAnswer,
+  memberEventAnswer,
+  inviteLinkAnswer,
+  joinRequestAnswer,
+  pollVoteAnswer,
+  topicAnswer,
+  folderAnswer,
+  lines,
+  pageOf2,
+  wholeList,
+  chatShown,
+  scoreFloor,
+  auditAnswer,
+  renderItem,
+  withPage,
+  documentLinkAnswer,
+  accountAnswer,
+  sessionAnswer
+};