@wirecat/zoom-cli 0.56.0 → 0.58.0

package/dist/bundle/chunk-RUP467ZX.js

@@ -0,0 +1,948 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  ZM
+} from "./chunk-SV5L36WK.js";
+import {
+  commandsCommand,
+  formatSuggestions,
+  meetingResultItem,
+  runsCommand,
+  sharedCommandTemplate,
+  suggest
+} from "./chunk-U6QW67SU.js";
+import {
+  sharedStoreCommand
+} from "./chunk-SIA7HJE2.js";
+import {
+  answerEntity
+} from "./chunk-RXDIG23Z.js";
+import {
+  LOCAL_READ,
+  NO_EFFECTS,
+  REMOTE_READ,
+  annotate,
+  changesAuthorityNow,
+  customizeSharedCommand,
+  describeOptions,
+  describeProgram,
+  flatten,
+  hasSharedContract,
+  isLogin,
+  isStoreChange,
+  itemOf,
+  listOf,
+  metaNow,
+  metaOf,
+  overrideSharedContract,
+  profileFree,
+  renderAnswer,
+  snakeKeys
+} from "./chunk-MNUTWGSA.js";
+import {
+  readOnlyLockOf,
+  readOnlyRefusal
+} from "./chunk-XFCSPOLZ.js";
+import {
+  setupPermissionCeiling
+} from "./chunk-4AURKUDZ.js";
+import {
+  CEILING_KEY,
+  DEFAULT_PERMISSIONS,
+  LEVELS,
+  keyForCommand,
+  levelFor
+} from "./chunk-PF25S7L4.js";
+import {
+  MEETING_RESULT_ENTITIES
+} from "./chunk-PP3JGQQE.js";
+import {
+  CliError,
+  array,
+  boolean,
+  createRenderer,
+  exitCodeOfAnswer,
+  integer,
+  isoTimestamp,
+  literal,
+  minLength,
+  minValue,
+  nullable,
+  number,
+  optional,
+  picklist,
+  pipe,
+  projectFields,
+  record,
+  safeParse,
+  strictObject,
+  string,
+  union
+} from "./chunk-YIMI6O7R.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// dist/read-only.js
+var pathOf = /* @__PURE__ */ __name((command) => {
+  const words = [];
+  for (let at = command; at?.parent; at = at.parent)
+    words.unshift(at.name());
+  return words.join(" ");
+}, "pathOf");
+var usesEmbeddings = /* @__PURE__ */ __name((command, path) => {
+  const options = command.opts();
+  if (path === "meetings embeddings")
+    return true;
+  return path === "search meetings" && options.model !== void 0;
+}, "usesEmbeddings");
+var refusalOf = /* @__PURE__ */ __name((command) => {
+  const effects = metaOf(command).effects;
+  const path = pathOf(command);
+  if (isLogin(command))
+    return "log in or out";
+  if (effects?.remote === "write")
+    return "change Zoom";
+  if (usesEmbeddings(command, path))
+    return "build meeting vectors or send text to an embedding service";
+  if (changesAuthorityNow(command))
+    return "change what a later run may do";
+  if (!effects || isStoreChange(command))
+    return "change the local store or local files";
+  return void 0;
+}, "refusalOf");
+var refuseChangeWhenReadOnly = /* @__PURE__ */ __name((command, env) => {
+  const lock2 = readOnlyLockOf(ZM, env);
+  const refusal = lock2 && refusalOf(command);
+  if (lock2 && refusal)
+    throw readOnlyRefusal(lock2, refusal);
+}, "refuseChangeWhenReadOnly");
+
+// dist/answer-entities.js
+var text = string();
+var identifier = pipe(text, minLength(1));
+var nullableText = nullable(text);
+var count = pipe(number(), integer(), minValue(0));
+var flag = boolean();
+var optionalCount = optional(count);
+var scope = strictObject({ provider: text, account: text });
+var asset = strictObject({
+  id: nullableText,
+  type: text,
+  format: nullableText,
+  size: nullable(count),
+  status: text,
+  available: flag,
+  started_at: nullableText,
+  ended_at: nullableText
+});
+var occurrence = strictObject({ id: text, uuid: text, title: nullableText, started_at: nullableText });
+var recording = strictObject({ ...occurrence.entries, assets: array(asset) });
+var archivedFile = strictObject({
+  id: text,
+  path: text,
+  size: count,
+  sha256: text,
+  remote_size: nullable(count),
+  type: text,
+  format: nullableText,
+  started_at: nullableText,
+  ended_at: nullableText
+});
+var archive = strictObject({
+  uuid: text,
+  manifest_path: text,
+  downloaded: array(archivedFile),
+  skipped: array(archivedFile),
+  unavailable: array(asset)
+});
+var manifest = strictObject({ version: literal(1), meeting: occurrence, files: array(archivedFile) });
+var lock = strictObject({
+  name: text,
+  status: picklist(["active", "stale", "foreign", "unrecognized"]),
+  pid: nullable(count),
+  host: nullableText
+});
+var archiveReceipt = strictObject({
+  window: strictObject({ from: text, to: text }),
+  meeting: strictObject({ id: text, uuid: text, title: nullableText }),
+  archive,
+  availability: optional(literal("unknown")),
+  checkpoint_revision: optional(nullable(count))
+});
+var remote = strictObject({
+  id: text,
+  uuid: nullableText,
+  title: nullableText,
+  type: nullable(number()),
+  started_at: nullableText,
+  duration_minutes: nullable(number()),
+  timezone: nullableText,
+  agenda: nullableText,
+  join_url: nullableText
+});
+var remoteChange = strictObject({
+  action: picklist(["create", "update", "cancel"]),
+  applied: flag,
+  request: strictObject({
+    method: picklist(["POST", "PATCH", "DELETE"]),
+    path: text,
+    body: optional(record(text, union([text, number()])))
+  }),
+  meeting: optional(remote)
+});
+var schedule = strictObject({
+  version: literal(1),
+  id: text,
+  name: text,
+  scope,
+  destination: text,
+  from: text,
+  daily_at: text,
+  time_zone: text,
+  lookback_days: count,
+  max_bytes: count,
+  created_at: pipe(text, isoTimestamp())
+});
+var job = strictObject({
+  version: literal(1),
+  schedule,
+  capture: strictObject({ profile: text, client_id: text, config_dir: text, runtime: text, cli_path: text }),
+  state: picklist(["pending", "enabled", "disabled"])
+});
+var scheduleReceipt = strictObject({
+  applied: flag,
+  backend: text,
+  job,
+  units: optional(strictObject({ service_name: text, timer_name: text, service: text, timer: text })),
+  timer_state: picklist(["not_checked", "verified_enabled", "verified_disabled"])
+});
+var cue = strictObject({ start_ms: count, end_ms: count, speaker: nullableText, text });
+var archiveImport = strictObject({
+  uuid: text,
+  asset_ids: array(text),
+  status: picklist(["acknowledged", "unavailable"]),
+  meeting_id: optional(identifier),
+  created: optional(flag),
+  inserted_transcripts: optionalCount,
+  replayed_transcripts: optionalCount,
+  superseded_transcripts: optionalCount,
+  reason: optional(literal("missing_or_deleted"))
+});
+var searchHit = strictObject({
+  source: text,
+  id: nullableText,
+  title: nullableText,
+  time: nullableText,
+  text: nullableText,
+  url: nullableText,
+  people: array(text),
+  container_id: nullableText,
+  details: record(text, nullable(union([text, number(), flag])))
+});
+var ZOOM_ANSWER_ENTITIES = {
+  "recordings list": { name: "zoom_recording", schema: recording },
+  "recordings show": { name: "zoom_recording", schema: recording },
+  "recordings download": { name: "zoom_archive", schema: union([archive, archiveReceipt]) },
+  "recordings archive show": { name: "zoom_archive_manifest", schema: manifest },
+  "recordings archive check": {
+    name: "zoom_archive_check",
+    schema: strictObject({ manifest_path: text, id: text, path: text, valid: flag })
+  },
+  "recordings archive locks": { name: "zoom_archive_lock", schema: lock },
+  "recordings archive recover": {
+    name: "zoom_archive_recovery",
+    schema: strictObject({ locks: array(lock), removed: array(text) })
+  },
+  "recordings archive transcript": {
+    name: "zoom_archive_transcript",
+    schema: strictObject({ meeting: occurrence, asset: archivedFile, cues: array(cue) })
+  },
+  "recordings archive import": { name: "zoom_archive_import", schema: archiveImport },
+  "recordings schedule list": { name: "zoom_archive_job", schema: job },
+  "recordings schedule show": { name: "zoom_archive_job", schema: job },
+  "recordings schedule create": { name: "zoom_archive_schedule_change", schema: scheduleReceipt },
+  "recordings schedule disable": { name: "zoom_archive_schedule_change", schema: scheduleReceipt },
+  "recordings schedule run": { name: "zoom_archive_receipt", schema: archiveReceipt },
+  "remote-meetings list": { name: "zoom_remote_meeting", schema: remote },
+  "remote-meetings show": { name: "zoom_remote_meeting", schema: remote },
+  "remote-meetings invitation": {
+    name: "zoom_remote_invitation",
+    schema: strictObject({ id: text, invitation: text })
+  },
+  "remote-meetings create": { name: "zoom_remote_change", schema: remoteChange },
+  "remote-meetings update": { name: "zoom_remote_change", schema: remoteChange },
+  "remote-meetings cancel": { name: "zoom_remote_change", schema: remoteChange },
+  "zoom search": { name: "zoom_search_hit", schema: searchHit },
+  "meetings embeddings": { name: "meeting_embedding", schema: MEETING_RESULT_ENTITIES.meeting_embedding, shared: true },
+  "meetings sync": { name: "meeting_ingestion", schema: MEETING_RESULT_ENTITIES.meeting_ingestion, shared: true },
+  "meetings import": { name: "meeting_ingestion", schema: MEETING_RESULT_ENTITIES.meeting_ingestion, shared: true },
+  watch: { name: "meeting_ingestion", schema: MEETING_RESULT_ENTITIES.meeting_ingestion, shared: true },
+  "meetings export": { name: "meeting_export", schema: MEETING_RESULT_ENTITIES.meeting_export, shared: true },
+  "meetings update": { name: "meeting_association", schema: MEETING_RESULT_ENTITIES.meeting_association, shared: true },
+  "meetings link": { name: "meeting_association", schema: MEETING_RESULT_ENTITIES.meeting_association, shared: true },
+  "meetings transcribe": {
+    name: "meeting_transcription",
+    schema: MEETING_RESULT_ENTITIES.meeting_transcription,
+    shared: true
+  }
+};
+var declareZoomAnswers = /* @__PURE__ */ __name((program) => {
+  const walk = /* @__PURE__ */ __name((command, path) => {
+    const entity = ZOOM_ANSWER_ENTITIES[path.join(" ")];
+    if (entity?.shared)
+      annotate(command, { output: { entity: entity.name } });
+    else if (entity)
+      answerEntity(command, entity.name, entity.schema);
+    for (const child of command.commands)
+      walk(child, [...path, child.name()]);
+  }, "walk");
+  walk(program, []);
+}, "declareZoomAnswers");
+var publicValue = /* @__PURE__ */ __name((value, key = "") => {
+  if (typeof value === "number" && key === "meeting_id")
+    return String(value);
+  if (typeof value === "number" && key === "created_at")
+    return new Date(value).toISOString();
+  if (Array.isArray(value))
+    return value.map((item) => publicValue(item));
+  if (value && typeof value === "object")
+    return Object.fromEntries(Object.entries(value).map(([name, item]) => [name, publicValue(item, name)]));
+  return value;
+}, "publicValue");
+var schemas = new Map(Object.values(ZOOM_ANSWER_ENTITIES).map(({ name, schema }) => [name, schema]));
+var normalizeZoomAnswer = /* @__PURE__ */ __name((body, entity) => {
+  const schema = entity ? schemas.get(entity) : void 0;
+  if (!schema)
+    return body;
+  const checked = /* @__PURE__ */ __name((value) => {
+    if (entity && Object.hasOwn(MEETING_RESULT_ENTITIES, entity))
+      return meetingResultItem(entity, value);
+    const parsed = safeParse(schema, publicValue(value));
+    if (!parsed.success) {
+      const applied = value && typeof value === "object" && "applied" in value && value.applied === true;
+      throw new CliError(applied ? "outcome_unknown" : "invalid_response", `the command returned an invalid ${entity} answer`);
+    }
+    return parsed.output;
+  }, "checked");
+  return "item" in body ? { ...body, item: checked(body.item) } : { ...body, items: body.items.map(checked) };
+}, "normalizeZoomAnswer");
+
+// dist/answer-output.js
+var UTC_TIME = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?Z/;
+var record2 = /* @__PURE__ */ __name((value) => typeof value === "object" && value !== null && !Array.isArray(value), "record");
+var only = /* @__PURE__ */ __name((value, keys) => Object.keys(value).every((key) => keys.includes(key)), "only");
+var bodyOf = /* @__PURE__ */ __name((value) => {
+  const data = snakeKeys(value);
+  if (record2(data) && only(data, ["item", "items", "page", "next", "missing", "meta"])) {
+    if ("item" in data || Array.isArray(data.items) && record2(data.page))
+      return data;
+  }
+  if (record2(data) && Array.isArray(data.items) && only(data, ["items", "page", "limit", "has_more"]))
+    return listOf("list", {
+      items: data.items,
+      limit: Math.max(1, data.items.length),
+      has_more: data.has_more === true
+    });
+  return itemOf(data);
+}, "bodyOf");
+var renderBody = /* @__PURE__ */ __name((command, body, options) => {
+  const data = normalizeZoomAnswer(snakeKeys(body), metaOf(command).output?.entity);
+  const fields = options.fields;
+  const projected = fields ? projectFields(data, fields) : data;
+  const meta = metaNow({ ...projected.meta, run_id: options.meta.run_id, duration_ms: options.meta.duration_ms });
+  const chunks = [];
+  const streams = {
+    data: /* @__PURE__ */ __name((text3) => chunks.push(`${text3}
+`), "data"),
+    diagnostic: /* @__PURE__ */ __name((text3) => options.diagnostic(`${text3}
+`), "diagnostic")
+  };
+  const renderer = createRenderer({ format: options.format, color: false, quiet: options.quiet, streams });
+  for (const warning of options.warnings ?? [])
+    renderer.warn(warning);
+  const exitCode = process.exitCode;
+  try {
+    renderAnswer(command, { renderer, format: options.format, streams }, { ...projected, meta });
+  } finally {
+    process.exitCode = exitCode;
+  }
+  const text2 = chunks.join("");
+  const label = options.format === "pretty" && UTC_TIME.test(text2) ? "times in UTC\n" : "";
+  return { text: text2 + label, exitCode: exitCodeOfAnswer(meta, metaOf(command).partial === true) };
+}, "renderBody");
+var wholeList = /* @__PURE__ */ __name((command, items) => listOf(command, { items, limit: Math.max(1, items.length), has_more: false }), "wholeList");
+
+// dist/contract-overrides.js
+var SHELL_OVERRIDES = {
+  skill: [
+    {
+      command: ["skill"],
+      field: "effects",
+      before: null,
+      after: {
+        remote: "none",
+        local: "none"
+      },
+      reason: "Zoom installs its own meeting instructions through its source renderer and treats the packaged primary skill as effect-free."
+    },
+    {
+      command: ["skill", "show"],
+      field: "examples",
+      before: ["zm skill show"],
+      after: ["zm skill show --json"],
+      reason: "Zoom installs its own meeting instructions through its source renderer and treats the packaged primary skill as effect-free."
+    },
+    {
+      command: ["skill", "install"],
+      field: "examples",
+      before: ["zm skill install --for agents"],
+      after: ["zm skill install --for agents --json"],
+      reason: "Zoom installs its own meeting instructions through its source renderer and treats the packaged primary skill as effect-free."
+    }
+  ],
+  doctor: [
+    {
+      command: ["doctor"],
+      field: "description",
+      before: "the state this installation is in, without connecting unless --online",
+      after: "check local runtime and public config without a login or database",
+      reason: "Zoom local diagnostics inspect runtime and public config only; online account checks belong to session status."
+    },
+    {
+      command: ["doctor"],
+      field: "effects",
+      before: {
+        remote: "read",
+        local: "read"
+      },
+      after: {
+        remote: "none",
+        local: "read"
+      },
+      reason: "Zoom local diagnostics inspect runtime and public config only; online account checks belong to session status."
+    },
+    {
+      command: ["doctor"],
+      field: "runnable",
+      before: true,
+      after: null,
+      reason: "Zoom local diagnostics inspect runtime and public config only; online account checks belong to session status."
+    },
+    {
+      command: ["doctor"],
+      field: "options",
+      before: [
+        {
+          flags: "--online",
+          description: "also connect once and read the account; sends nothing",
+          takes_value: false,
+          mandatory: false
+        }
+      ],
+      after: [],
+      reason: "Zoom local diagnostics inspect runtime and public config only; online account checks belong to session status."
+    },
+    {
+      command: ["doctor"],
+      field: "children",
+      before: ["reports"],
+      after: [],
+      reason: "Zoom local diagnostics inspect runtime and public config only; online account checks belong to session status."
+    },
+    {
+      command: ["doctor"],
+      field: "examples",
+      before: null,
+      after: ["zm doctor --json"],
+      reason: "Zoom local diagnostics inspect runtime and public config only; online account checks belong to session status."
+    }
+  ],
+  mcp: [
+    {
+      command: ["mcp"],
+      field: "summary",
+      before: "serve this profile's commands to an AI agent, and set that up",
+      after: "serve zm's commands to an AI agent",
+      reason: "Zoom serves meeting and archive commands over stdio under its selected profile; HTTP-specific options are unsupported."
+    },
+    {
+      command: ["mcp"],
+      field: "description",
+      before: "serve this profile to an agent over MCP and set it up \u2014 `claude mcp add zm -- zm <profile> mcp serve`",
+      after: "serve zm's commands to an agent over MCP \u2014 `claude mcp add zm -- zm <profile> mcp serve`",
+      reason: "Zoom serves meeting and archive commands over stdio under its selected profile; HTTP-specific options are unsupported."
+    },
+    {
+      command: ["mcp"],
+      field: "children",
+      before: ["serve", "revoke", "server", "config", "add", "check"],
+      after: ["serve"],
+      reason: "Zoom serves meeting and archive commands over stdio under its selected profile; HTTP-specific options are unsupported."
+    },
+    {
+      command: ["mcp", "serve"],
+      field: "description",
+      before: "serve this profile to an agent over MCP, on stdin and stdout \u2014 `claude mcp add zm -- zm <profile> mcp serve`; `zm mcp serve --profiles a,b` or `--profiles all` serves those profiles from one server and each tool asks which",
+      after: "serve this profile to an agent over MCP, on stdin and stdout \u2014 `claude mcp add zm -- zm <profile> mcp serve`; `--profiles a,b` or `--profiles all` serves several from one server and each tool asks which",
+      reason: "Zoom serves meeting and archive commands over stdio under its selected profile; HTTP-specific options are unsupported."
+    },
+    {
+      command: ["mcp", "serve"],
+      field: "effects",
+      before: {
+        remote: "write",
+        local: "write"
+      },
+      after: {
+        remote: "read",
+        local: "write"
+      },
+      reason: "Zoom serves meeting and archive commands over stdio under its selected profile; HTTP-specific options are unsupported."
+    },
+    {
+      command: ["mcp", "serve"],
+      field: "examples",
+      before: [
+        "zm personal mcp serve",
+        "zm mcp serve --profiles work,personal",
+        "zm personal mcp serve --http --public-url https://laptop.example.ts.net"
+      ],
+      after: ["zm personal mcp serve"],
+      reason: "Zoom serves meeting and archive commands over stdio under its selected profile; HTTP-specific options are unsupported."
+    },
+    {
+      command: ["mcp", "serve"],
+      field: "options",
+      before: [
+        {
+          flags: "--permission <key=level>",
+          description: "make a permission stricter for this server only, like messages.send=deny; it never loosens the profile; repeat for more keys",
+          takes_value: true,
+          mandatory: false
+        },
+        {
+          flags: "--profiles <names|all>",
+          description: "serve several profiles from one server instead of one: names, comma-separated, or all for every profile",
+          takes_value: true,
+          mandatory: false
+        },
+        {
+          flags: "--http",
+          description: "serve over HTTP on 127.0.0.1 for ChatGPT and Claude in the browser, behind your tunnel; the profile's permissions decide",
+          takes_value: false,
+          mandatory: false
+        },
+        {
+          flags: "--port <port>",
+          description: "the local port for --http (default 8765)",
+          takes_value: true,
+          mandatory: false
+        },
+        {
+          flags: "--public-url <url>",
+          description: "the tunnel's https address the browser apps use, e.g. https://<name>.ts.net or https://<name>.ts.net/tg",
+          takes_value: true,
+          mandatory: false
+        }
+      ],
+      after: [
+        {
+          flags: "--profiles <names|all>",
+          description: "serve several profiles from one server instead of one: names, comma-separated, or all for every profile",
+          takes_value: true,
+          mandatory: false
+        }
+      ],
+      reason: "Zoom serves meeting and archive commands over stdio under its selected profile; HTTP-specific options are unsupported."
+    }
+  ],
+  search: [
+    {
+      command: ["search"],
+      field: "summary",
+      before: "search the local archive",
+      after: null,
+      reason: "Zoom searches explicit local meeting and archive sources, with opt-in unified store reads rather than a live messenger backend."
+    },
+    {
+      command: ["search"],
+      field: "description",
+      before: "find things by text: one resource when you know it (messages, notes), or search all across messages and notes; for mail, the separate memo CLI: memo search mail",
+      after: "opt-in shared store search; meetings by default",
+      reason: "Zoom searches explicit local meeting and archive sources, with opt-in unified store reads rather than a live messenger backend."
+    },
+    {
+      command: ["search"],
+      field: "children",
+      before: ["all", "messages", "notes", "conversations", "runs"],
+      after: ["all"],
+      reason: "Zoom searches explicit local meeting and archive sources, with opt-in unified store reads rather than a live messenger backend."
+    },
+    {
+      command: ["search"],
+      field: "effects",
+      before: null,
+      after: {
+        remote: "none",
+        local: "none"
+      },
+      reason: "Zoom searches explicit local meeting and archive sources, with opt-in unified store reads rather than a live messenger backend."
+    },
+    {
+      command: ["search", "all"],
+      field: "summary",
+      before: "search stored messages, notes, calendar events and selected meeting transcripts",
+      after: null,
+      reason: "Zoom searches explicit local meeting and archive sources, with opt-in unified store reads rather than a live messenger backend."
+    },
+    {
+      command: ["search", "all"],
+      field: "description",
+      before: "search messenger messages and notes in the local store, calendar events when the store holds a calendar, and a meeting account's transcripts when --source names one \u2014 best match first; not mail (the separate memo CLI searches it: memo search mail), tasks, people, memories or projects. Use it when you do not know where something was written; search messages or notes reads one kind with all its fields",
+      after: "search meetings and, with --only, messages, mail and notes in the local store",
+      reason: "Zoom searches explicit local meeting and archive sources, with opt-in unified store reads rather than a live messenger backend."
+    },
+    {
+      command: ["search", "all"],
+      field: "effects",
+      before: {
+        remote: "read",
+        local: "read"
+      },
+      after: {
+        remote: "none",
+        local: "read"
+      },
+      reason: "Zoom searches explicit local meeting and archive sources, with opt-in unified store reads rather than a live messenger backend."
+    },
+    {
+      command: ["search", "all"],
+      field: "examples",
+      before: ["zm personal search all draft"],
+      after: ['zm personal search all "example plan" --json'],
+      reason: "Zoom searches explicit local meeting and archive sources, with opt-in unified store reads rather than a live messenger backend."
+    },
+    {
+      command: ["search", "all"],
+      field: "arguments",
+      before: [
+        {
+          name: "query",
+          required: true,
+          variadic: true,
+          description: 'strict Lucene query: words, "phrases", AND/OR/NOT, field groups and date ranges'
+        }
+      ],
+      after: [
+        {
+          name: "query",
+          required: true,
+          variadic: false,
+          description: "words to find; a word also matches longer words it starts"
+        }
+      ],
+      reason: "Zoom searches explicit local meeting and archive sources, with opt-in unified store reads rather than a live messenger backend."
+    },
+    {
+      command: ["search", "all"],
+      field: "options",
+      before: [
+        {
+          flags: "--only <resources>",
+          description: "only these resources, separated by commas: messages, notes, events; meetings when --source names a meeting account",
+          takes_value: true,
+          mandatory: false
+        },
+        {
+          flags: "--source <accounts>",
+          description: "only these accounts, separated by commas: provider:account as a hit shows it, a provider, a kind or group:<name>; each resource reads the ones of its kind, and meetings only when it names one",
+          takes_value: true,
+          mandatory: false
+        },
+        {
+          flags: "--max-meetings <n>",
+          description: "how many of the meeting account's meetings to look through, newest first, or all for every one (default 100)",
+          takes_value: true,
+          mandatory: false
+        },
+        {
+          flags: "--limit <n>",
+          description: "how many",
+          takes_value: true,
+          mandatory: false
+        },
+        {
+          flags: "--page <n>",
+          description: "which page, starting at 1",
+          takes_value: true,
+          mandatory: false
+        },
+        {
+          flags: "--exact",
+          description: "bare words and quotes match their exact form only, as exact:word does",
+          takes_value: false,
+          mandatory: false
+        },
+        {
+          flags: "--timezone <zone>",
+          description: "the IANA timezone for calendar date boundaries",
+          takes_value: true,
+          mandatory: false
+        }
+      ],
+      after: [
+        {
+          flags: "--only <resources>",
+          description: "comma-separated meetings,messages,mail,notes (default meetings)",
+          takes_value: true,
+          mandatory: false
+        },
+        {
+          flags: "--limit <n>",
+          description: "how many results, 1 through 1000 (default 100)",
+          takes_value: true,
+          mandatory: false,
+          default: 100
+        },
+        {
+          flags: "--page <n>",
+          description: "which page, starting at 1",
+          takes_value: true,
+          mandatory: false
+        },
+        {
+          flags: "--max-meetings <n>",
+          description: "most meetings to look through, newest first, or all (default 100)",
+          takes_value: true,
+          mandatory: false
+        },
+        {
+          flags: "--exact",
+          description: "request exact matching; unsupported meeting queries are reported as skipped",
+          takes_value: false,
+          mandatory: false
+        }
+      ],
+      reason: "Zoom searches explicit local meeting and archive sources, with opt-in unified store reads rather than a live messenger backend."
+    }
+  ]
+};
+
+// dist/commands.js
+var addStandardCommandsDefinition = /* @__PURE__ */ __name((program, deps) => {
+  program.addCommand(commandsCommand(ZM).copyInheritedSettings(program));
+  program.addCommand(sharedStoreCommand().copyInheritedSettings(program));
+  annotate(program.command("complete").description("answer shell completion requests").argument("[words...]", "shell words ending in the partial word").action((words) => {
+    const suggestions = suggest({
+      commands: describeProgram(program),
+      globalOptions: describeOptions(program),
+      words
+    });
+    if (program.opts().json || program.opts().jsonl)
+      deps.output(wholeList("complete", suggestions));
+    else
+      deps.raw(`${formatSuggestions(suggestions)}
+`);
+  }), { effects: NO_EFFECTS, examples: ["zm complete -- meetings s"] });
+  annotate(program.command("doctor").description("check local runtime and public config without a login or database").action(() => deps.output(itemOf(deps.doctor()))), { effects: LOCAL_READ, examples: ["zm doctor --json"] });
+  const session = annotate(program.command("session"), { effects: NO_EFFECTS }).description("the saved Zoom login, separate from local data profiles");
+  annotate(session.command("status").description("show cached login state; remote verification is explicit").option("--check", "verify the session with Zoom").action(async (options) => deps.output(itemOf(await deps.sessionStatus(options.check === true)))), {
+    effects: REMOTE_READ,
+    examples: ["zm personal session status --json", "zm personal session status --check --dry-run --json"]
+  });
+}, "addStandardCommandsDefinition");
+var annotateMeetingCommands = /* @__PURE__ */ __name((program) => {
+  for (const item of flatten(describeProgram(program))) {
+    let command = program;
+    for (const part of item.path) {
+      const found = command.commands.find((child) => child.name() === part);
+      if (found)
+        command = found;
+    }
+    if (command.commands.length)
+      continue;
+    const path = item.path.join(" ");
+    if (!metaOf(command).effects)
+      throw new CliError("configuration_error", `command effects are missing: ${path}`);
+    const examples = item.examples?.map((example) => PROFILE_FREE.has(item.path[0] ?? "") ? example : example.replace(`zm ${path}`, `zm personal ${path}`)) ?? [exampleFor(path)];
+    if (JSON.stringify(examples) === JSON.stringify(item.examples))
+      continue;
+    const change = /* @__PURE__ */ __name((one) => {
+      annotate(one, { examples });
+    }, "change");
+    if (hasSharedContract(command))
+      overrideSharedContract(command, "Zoom account examples explicitly name the personal profile required for meeting reads.", change);
+    else
+      change(command);
+  }
+}, "annotateMeetingCommands");
+var PROFILE_FREE = /* @__PURE__ */ new Set([
+  "commands",
+  "complete",
+  "config",
+  "doctor",
+  "guide",
+  "help",
+  "skill",
+  "upgrade",
+  "models",
+  "runs"
+]);
+var markProfileFree = /* @__PURE__ */ __name((program) => {
+  for (const command of program.commands)
+    if (PROFILE_FREE.has(command.name()))
+      profileFree(command);
+}, "markProfileFree");
+var zoomRunsCommand = /* @__PURE__ */ __name(() => {
+  const runs = runsCommand(ZM);
+  overrideSharedContract(runs, "Zoom declares effects on every command group, the shared run log's included.", (group) => {
+    annotate(group, { effects: NO_EFFECTS });
+  });
+  return runs;
+}, "zoomRunsCommand");
+var exampleFor = /* @__PURE__ */ __name((path) => {
+  const profile = PROFILE_FREE.has(path.split(" ")[0] ?? "") ? "" : "personal ";
+  if (path === "mcp serve")
+    return "zm personal mcp serve";
+  if (path === "session start")
+    return "zm personal session start";
+  const argumentsByPath = {
+    "commands info": "meetings list",
+    "config set": "files.timezone Europe/Madrid",
+    "meetings sync": "--dry-run",
+    "meetings show": "1",
+    "meetings transcript": "1",
+    "meetings summary": "1",
+    "meetings export": "1 --format markdown",
+    "meetings people": '"Alice Example"',
+    "meetings projects evidence": 'RES "identity_id:12"',
+    "meetings import": "./downloaded-transcripts"
+  };
+  return `zm ${profile}${path}${argumentsByPath[path] ? ` ${argumentsByPath[path]}` : ""} --json`;
+}, "exampleFor");
+var addStandardCommands = /* @__PURE__ */ __name((...args) => {
+  customizeSharedCommand(sharedCommandTemplate(ZM, "doctor"), "Zoom local diagnostics inspect runtime and public config only; online account checks belong to session status.", () => {
+    addStandardCommandsDefinition(...args);
+    const command = args[0].commands.find((command2) => command2.name() === "doctor");
+    if (!command)
+      throw new Error("doctor builder did not install its command");
+    return command;
+  }, SHELL_OVERRIDES.doctor);
+}, "addStandardCommands");
+
+// dist/permissions.js
+var DEFAULT_PERMISSIONS2 = {
+  ...DEFAULT_PERMISSIONS,
+  "remote-meetings": "ask"
+};
+var discoveryLevels = /* @__PURE__ */ __name((own, env) => {
+  const ceiling = setupPermissionCeiling(env);
+  return {
+    ...DEFAULT_PERMISSIONS2,
+    ...own,
+    ...ceiling ? { [CEILING_KEY]: ceiling } : {},
+    ...readOnlyLockOf(ZM, env) ? { [CEILING_KEY]: "readonly" } : {}
+  };
+}, "discoveryLevels");
+var HOUSEKEEPING = /* @__PURE__ */ new Set([...PROFILE_FREE, "session", "mcp"]);
+var pathOf2 = /* @__PURE__ */ __name((command) => {
+  const words = [];
+  for (let at = command; at?.parent; at = at.parent)
+    words.unshift(at.name());
+  return words;
+}, "pathOf");
+var permissionKeyForPath = /* @__PURE__ */ __name((path) => path.length === 0 || HOUSEKEEPING.has(path[0]) && keyForCommand(path) === null ? null : path.join("."), "permissionKeyForPath");
+var permissionKeyOf = /* @__PURE__ */ __name((command) => permissionKeyForPath(pathOf2(command)), "permissionKeyOf");
+var permissionKeys = /* @__PURE__ */ __name((program) => {
+  const keys = /* @__PURE__ */ new Set(["mcp.authority"]);
+  const walk = /* @__PURE__ */ __name((command) => {
+    const key = permissionKeyOf(command);
+    if (key) {
+      const parts = key.split(".");
+      for (let size = 1; size <= parts.length; size++)
+        keys.add(parts.slice(0, size).join("."));
+    }
+    for (const child of command.commands)
+      walk(child);
+  }, "walk");
+  walk(program);
+  return keys;
+}, "permissionKeys");
+var parsePermissions = /* @__PURE__ */ __name((value, known) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    throw new CliError("validation_error", 'permissions must be a JSON object: {"remote-meetings": "allow"}');
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+    throw new CliError("validation_error", 'permissions must be a JSON object: {"remote-meetings": "allow"}');
+  for (const [key, level] of Object.entries(parsed)) {
+    if (!known.has(key))
+      throw new CliError("validation_error", `no command is called ${key}; a key is a command path, dotted`, {
+        keys: [...known].sort()
+      });
+    if (!LEVELS.includes(level))
+      throw new CliError("validation_error", `${key}: a level is one of ${LEVELS.join(", ")}`);
+  }
+  return parsed;
+}, "parsePermissions");
+var refuse = /* @__PURE__ */ __name((key, level, profile, what) => new CliError("permission_error", `${what}: ${key} is ${level} for profile ${profile} \u2014 \`zm ${profile} config set permissions \u2026\` changes it`, { key, level }), "refuse");
+var checkPermission = /* @__PURE__ */ __name((command, context) => {
+  const key = permissionKeyOf(command);
+  if (!key)
+    return;
+  const named = context.profile();
+  const profile = named ?? "<profile>";
+  const own = named === void 0 ? {} : context.config().permissions[named] ?? {};
+  const levels = context.ceiling ? { ...own, [CEILING_KEY]: context.ceiling } : own;
+  const { level, key: by } = levelFor(levels, key, DEFAULT_PERMISSIONS2);
+  const at = by ?? key;
+  if (level === "deny")
+    throw refuse(at, level, profile, "refused");
+  const changes = refusalOf(command);
+  if (level === "readonly" && changes && by === CEILING_KEY)
+    throw new CliError("permission_error", `refused to ${changes}: the WireCat setup answer keeps every tool read-only \u2014 \`tg setup\`, \`max setup\` or \`wa setup\` at a terminal changes it`, { key, level });
+  if (level === "readonly" && changes)
+    throw refuse(at, level, profile, `refused to ${changes}`);
+  const options = command.opts();
+  const confirms = metaOf(command).effects?.remote === "write" && command.options.some(({ long }) => long === "--yes");
+  if (!confirms || options.dryRun || options.yes)
+    return;
+  if (level === "allow") {
+    command.setOptionValue("yes", true);
+    return;
+  }
+  if (!context.confirm)
+    throw new CliError("confirmation_required", `${at} asks first for profile ${profile}: add --yes to apply, or --dry-run to preview`, { key: at });
+  return context.confirm(`zm: ${pathOf2(command).join(" ")} changes Zoom for profile ${profile}. Apply?`).then((yes) => {
+    if (!yes)
+      throw new CliError("cancelled", "not applied");
+    command.setOptionValue("yes", true);
+  });
+}, "checkPermission");
+var guardCommand = /* @__PURE__ */ __name((command, env, context, confirm) => {
+  refuseChangeWhenReadOnly(command, env);
+  const ceiling = setupPermissionCeiling(env);
+  return checkPermission(command, { ...context, ...confirm ? { confirm } : {}, ...ceiling ? { ceiling } : {} });
+}, "guardCommand");
+
+export {
+  ZOOM_ANSWER_ENTITIES,
+  declareZoomAnswers,
+  bodyOf,
+  renderBody,
+  wholeList,
+  SHELL_OVERRIDES,
+  annotateMeetingCommands,
+  markProfileFree,
+  zoomRunsCommand,
+  addStandardCommands,
+  DEFAULT_PERMISSIONS2 as DEFAULT_PERMISSIONS,
+  discoveryLevels,
+  permissionKeyForPath,
+  permissionKeys,
+  parsePermissions,
+  guardCommand
+};