@wirecat/zoom-cli 0.56.0 → 0.57.0

package/dist/bundle/chunk-6P3YHT54.js

@@ -0,0 +1,385 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  parsePermissions
+} from "./chunk-7A6PZUDR.js";
+import {
+  checkConfigText,
+  issueMessage,
+  usableProfileName
+} from "./chunk-MAEFLDHG.js";
+import {
+  LEVELS
+} from "./chunk-TKCHUT2H.js";
+import {
+  CliError,
+  array,
+  boolean,
+  check,
+  integer,
+  literal,
+  maxLength,
+  minValue,
+  nullable,
+  number,
+  optional,
+  parse,
+  picklist,
+  pipe,
+  record,
+  regex,
+  safeParse,
+  saveConfigFile,
+  strictObject,
+  string,
+  union
+} from "./chunk-AE4BOXH7.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// dist/config.js
+import { existsSync, readFileSync, statSync } from "node:fs";
+
+// dist/config-issues.js
+var isNode = /* @__PURE__ */ __name((value) => typeof value === "object" && value !== null && !Array.isArray(value), "isNode");
+var SETTING_NAMES = {
+  client_id: "zoom.client_id",
+  source: "source",
+  files_folder: "files.folder",
+  files_timezone: "files.timezone",
+  context_sources: "context.sources",
+  record: "record",
+  keep_runs_for_days: "keep_runs_for_days",
+  keep_successful_runs_for_days: "keep_successful_runs_for_days",
+  runs_size_limit_mb: "runs_size_limit_mb",
+  record_input: "record_input"
+};
+var SHELL_SAFE = /^[A-Za-z0-9_.:@-]*$/;
+var fileIssue = /* @__PURE__ */ __name((file, what) => ({ kind: "invalid_value", file, what, at: [] }), "fileIssue");
+var pathOf = /* @__PURE__ */ __name((raw, { profile, key }) => {
+  if (key === void 0)
+    return [];
+  if (profile !== void 0) {
+    const entry = isNode(raw.profiles) ? raw.profiles[profile] : void 0;
+    const permission = key.startsWith("permissions.") && !(isNode(entry) && Object.hasOwn(entry, key));
+    return permission ? ["profiles", profile, "permissions", key.slice("permissions.".length)] : ["profiles", profile, key];
+  }
+  if (Object.hasOwn(raw, key))
+    return [key];
+  if (key.startsWith("profiles."))
+    return ["profiles", key.slice("profiles.".length)];
+  return [key.split(".")[0]];
+}, "pathOf");
+var inZmTerms = /* @__PURE__ */ __name((raw, issue) => {
+  const { fix: _, key: shared, ...rest } = issue;
+  const at = pathOf(raw, issue);
+  const [first] = at;
+  if (shared === void 0 || first === void 0)
+    return { ...rest, at };
+  const key = first === "profiles" ? shared : SETTING_NAMES[first] ?? first;
+  const named = key + shared.slice(first === "profiles" ? shared.length : first.length);
+  const fixable = [key, issue.profile ?? ""].every((word) => SHELL_SAFE.test(word));
+  return {
+    ...rest,
+    kind: issue.kind === "missing_setting" ? "invalid_value" : issue.kind,
+    key,
+    what: issue.what.replace(`setting ${shared}`, `setting ${named}`),
+    ...fixable ? { fix: `zm${issue.profile === void 0 ? "" : ` ${issue.profile}`} config unset ${key}` } : {},
+    at
+  };
+}, "inZmTerms");
+var configIssues = /* @__PURE__ */ __name((text, file, schema, permissionKeys) => {
+  const checked = checkConfigText(text, { file, tool: "zm", schema });
+  const broken = checked.issues.find((issue) => issue.kind === "invalid_json");
+  if (broken)
+    return { issues: [{ ...broken, at: [] }], raw: null };
+  const raw = JSON.parse(text);
+  if (!isNode(raw))
+    return { issues: [fileIssue(file, "the file has to be an object, in braces")], raw: null };
+  const found = /* @__PURE__ */ new Map();
+  const add = /* @__PURE__ */ __name((issue) => {
+    const id = issue.at.join("\0");
+    if (!found.has(id))
+      found.set(id, issue);
+  }, "add");
+  for (const issue of checked.issues)
+    add(inZmTerms(raw, issue));
+  if (permissionKeys) {
+    const rest = JSON.stringify(withoutIssues(raw, [...found.values()]));
+    for (const issue of checkConfigText(rest, { file, tool: "zm", schema, knownPermissions: permissionKeys }).issues)
+      if (issue.kind === "unknown_permission")
+        add(inZmTerms(raw, issue));
+  }
+  return { issues: [...found.values()], raw };
+}, "configIssues");
+var withoutIssues = /* @__PURE__ */ __name((raw, issues) => {
+  const copy = structuredClone(raw);
+  for (const { at } of issues)
+    removeAt(copy, at);
+  return copy;
+}, "withoutIssues");
+var removeAt = /* @__PURE__ */ __name((raw, at) => {
+  const parent = at.slice(0, -1).reduce((node, key) => isNode(node) ? node[key] : void 0, raw);
+  if (isNode(parent))
+    delete parent[at.at(-1)];
+}, "removeAt");
+var publicIssue = /* @__PURE__ */ __name(({ at: _, ...issue }) => issue, "publicIssue");
+
+// dist/profile.js
+var profilePattern = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+var profileAccountKey = /* @__PURE__ */ __name((profile) => `zm-profile:${profile}`, "profileAccountKey");
+var given = /* @__PURE__ */ __name((value) => value?.trim() ? value.trim() : void 0, "given");
+var usable = /* @__PURE__ */ __name((profile) => {
+  usableProfileName(profile);
+  if (!profilePattern.test(profile))
+    throw new CliError("validation_error", `"${profile}" cannot be a profile name \u2014 64 characters at most`);
+  return profile;
+}, "usable");
+var chooseProfile = /* @__PURE__ */ __name(({ word, env, profiles }) => {
+  const lock = given(env.ZM_PROFILE_LOCK);
+  const named = word !== void 0 ? word : given(env.ZM_PROFILE);
+  if (lock !== void 0)
+    usable(lock);
+  if (named !== void 0 && lock !== void 0 && named !== lock)
+    throw new CliError("permission_error", `this process is locked to profile ${lock} (ZM_PROFILE_LOCK) \u2014 profile ${named} is refused`);
+  const profile = named ?? lock;
+  if (profile === void 0) {
+    const here = profiles();
+    throw new CliError("validation_error", here.length === 0 ? "name a profile: there is none on this computer yet \u2014 create one with `zm personal session start` (any name in place of personal)" : `name a profile: \`zm <profile> \u2026\` \u2014 profiles here: ${here.join(", ")} (or set ZM_PROFILE)`, { profiles: [...here] });
+  }
+  return usable(profile);
+}, "chooseProfile");
+
+// dist/context-sources.js
+var fields = {
+  id: pipe(string(), regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)),
+  kind: picklist(["message", "mail", "document"]),
+  provider: pipe(string(), check((s) => !!s.trim() && Buffer.byteLength(s) <= 128)),
+  account: pipe(string(), check((s) => !!s.trim() && Buffer.byteLength(s) <= 1024))
+};
+var selected = pipe(array(strictObject(fields)), maxLength(8));
+var contextSourcesSchema = pipe(array(strictObject({ ...fields, profile: pipe(string(), regex(profilePattern)) })), maxLength(64), check((entries) => {
+  const ids = /* @__PURE__ */ new Set(), identities = /* @__PURE__ */ new Set(), counts = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const id = JSON.stringify([entry.profile, entry.id]), key = JSON.stringify([entry.profile, entry.kind, entry.provider, entry.account]);
+    const count = (counts.get(entry.profile) ?? 0) + 1;
+    if (ids.has(id) || identities.has(key) || count > 8)
+      return false;
+    ids.add(id);
+    identities.add(key);
+    counts.set(entry.profile, count);
+  }
+  return true;
+}));
+var replaceContextSources = /* @__PURE__ */ __name((value, profile, existing = []) => {
+  if (!profile)
+    throw new CliError("configuration_error", "name a profile: `zm <profile> config set context.sources \u2026`");
+  let input;
+  try {
+    input = JSON.parse(value);
+  } catch {
+    throw new CliError("validation_error", "context.sources must be a JSON array");
+  }
+  const parsed = safeParse(selected, input);
+  if (!parsed.success)
+    throw new CliError("validation_error", "context.sources needs at most eight unique source IDs with kind/provider/account; unknown fields are refused");
+  const combined = [...existing.filter((s) => s.profile !== profile), ...parsed.output.map((s) => ({ ...s, profile }))];
+  const all = safeParse(contextSourcesSchema, combined);
+  if (!all.success)
+    throw new CliError("validation_error", "context.sources contains duplicate IDs/identities or exceeds its profile limits");
+  return all.output;
+}, "replaceContextSources");
+
+// dist/config.js
+var ProfileEntry = strictObject({
+  permissions: optional(record(pipe(string(), regex(/^[a-z][a-z.-]*$/)), picklist(LEVELS)))
+});
+var ConfigFile = strictObject({
+  client_id: optional(nullable(pipe(string(), check((id) => id.trim() !== "" && !/\s/.test(id), "has to be a Zoom client ID, without spaces")))),
+  source: optional(picklist(["api", "files"])),
+  files_folder: optional(nullable(string())),
+  files_timezone: optional(nullable(pipe(string(), check((zone) => {
+    try {
+      new Intl.DateTimeFormat("en", { timeZone: zone });
+      return true;
+    } catch {
+      return false;
+    }
+  }, "has to be an IANA time zone, such as Europe/Madrid")))),
+  profiles: optional(record(pipe(string(), regex(profilePattern, "has to be a profile name of 64 characters at most")), ProfileEntry)),
+  context_sources: optional(contextSourcesSchema),
+  record: optional(boolean()),
+  keep_runs_for_days: optional(pipe(number(), integer(), minValue(1))),
+  keep_successful_runs_for_days: optional(pipe(number(), integer(), minValue(1))),
+  runs_size_limit_mb: optional(pipe(number(), integer(), minValue(1))),
+  record_input: optional(union([boolean(), literal("failed")]))
+});
+var DOCTOR = "zm doctor";
+var configOf = /* @__PURE__ */ __name((file) => ({
+  clientId: file.client_id ?? null,
+  source: file.source ?? "api",
+  filesFolder: file.files_folder ?? null,
+  filesTimezone: file.files_timezone ?? null,
+  profiles: Object.keys(file.profiles ?? {}).sort(),
+  permissions: Object.fromEntries(Object.entries(file.profiles ?? {}).flatMap(([name, entry]) => entry.permissions ? [[name, entry.permissions]] : [])),
+  ...file.context_sources === void 0 ? {} : { contextSources: file.context_sources },
+  ...file.record === void 0 ? {} : { record: file.record },
+  ...file.keep_runs_for_days === void 0 ? {} : { keepRunsForDays: file.keep_runs_for_days },
+  ...file.keep_successful_runs_for_days === void 0 ? {} : { keepSuccessfulRunsForDays: file.keep_successful_runs_for_days },
+  ...file.runs_size_limit_mb === void 0 ? {} : { runsSizeLimitMb: file.runs_size_limit_mb },
+  ...file.record_input === void 0 ? {} : { recordInput: file.record_input }
+}), "configOf");
+var inspectConfig = /* @__PURE__ */ __name((path, permissionKeys) => {
+  let text;
+  try {
+    text = readFileSync(path, "utf8");
+  } catch {
+    if (!existsSync(path))
+      return { found: false, issues: [], raw: {}, config: configOf({}) };
+    const what = statSync(path, { throwIfNoEntry: false })?.isDirectory() ? "the path is a folder, not a file" : "the file could not be read";
+    return { found: true, issues: [fileIssue(path, what)], raw: null, config: configOf({}) };
+  }
+  const { issues, raw } = configIssues(text, path, ConfigFile, permissionKeys);
+  return {
+    found: true,
+    issues,
+    raw,
+    config: configOf(raw ? parse(ConfigFile, withoutIssues(raw, issues)) : {})
+  };
+}, "inspectConfig");
+var readConfig = /* @__PURE__ */ __name((path, permissionKeys) => {
+  const { issues, config } = inspectConfig(path, permissionKeys);
+  if (issues.length > 0)
+    throw new CliError("configuration_error", issueMessage(issues.map(publicIssue), DOCTOR));
+  return config;
+}, "readConfig");
+var changeFile = /* @__PURE__ */ __name((path, permissionKeys, change) => {
+  const inspection = inspectConfig(path, permissionKeys);
+  if (!inspection.raw)
+    throw new CliError("configuration_error", issueMessage(inspection.issues.map(publicIssue), DOCTOR));
+  const raw = structuredClone(inspection.raw);
+  change(raw, inspection);
+  saveConfigFile(path, raw);
+  return inspectConfig(path, permissionKeys).config;
+}, "changeFile");
+var profileEntry = /* @__PURE__ */ __name((raw, profile) => {
+  if (!isNode(raw.profiles))
+    raw.profiles = {};
+  const profiles = raw.profiles;
+  if (!isNode(profiles[profile]))
+    profiles[profile] = {};
+  return profiles[profile];
+}, "profileEntry");
+var FILE_KEYS = Object.fromEntries(Object.entries(SETTING_NAMES).map(([file, name]) => [name, file]));
+var setConfig = /* @__PURE__ */ __name((path, key, value, profile, permissionKeys) => changeFile(path, permissionKeys, (raw, { config, issues }) => {
+  switch (key) {
+    case "permissions": {
+      const name = profile?.();
+      if (!name)
+        throw new CliError("validation_error", "name a profile: `zm <profile> config set permissions \u2026`");
+      profileEntry(raw, name).permissions = parsePermissions(value, permissionKeys ?? /* @__PURE__ */ new Set());
+      return;
+    }
+    case "context.sources": {
+      const broken = issues.find((issue) => issue.at[0] === "context_sources");
+      if (broken)
+        throw new CliError("configuration_error", issueMessage([publicIssue(broken)], DOCTOR));
+      raw.context_sources = replaceContextSources(value, profile?.() ?? null, config.contextSources);
+      return;
+    }
+    case "zoom.client_id":
+      if (!value.trim() || /\s/.test(value))
+        throw new CliError("validation_error", "client id must not contain whitespace");
+      raw.client_id = value;
+      return;
+    case "source":
+      if (value !== "api" && value !== "files")
+        throw new CliError("validation_error", "source must be api or files");
+      raw.source = value;
+      return;
+    case "files.folder":
+      if (!value.trim())
+        throw new CliError("validation_error", "folder must not be empty");
+      raw.files_folder = value;
+      return;
+    case "files.timezone":
+      try {
+        new Intl.DateTimeFormat("en", { timeZone: value });
+      } catch {
+        throw new CliError("validation_error", "expected an IANA time zone");
+      }
+      raw.files_timezone = value;
+      return;
+    case "record":
+      if (value !== "true" && value !== "false")
+        throw new CliError("validation_error", "record must be true or false");
+      raw.record = value === "true";
+      return;
+    case "keep_runs_for_days":
+      if (!/^[1-9]\d{0,4}$/.test(value))
+        throw new CliError("validation_error", "keep_runs_for_days must be a whole number of days, 1 or more");
+      raw.keep_runs_for_days = Number(value);
+      return;
+    case "record_input":
+      if (value !== "true" && value !== "false" && value !== "failed")
+        throw new CliError("validation_error", "record_input must be true, false or failed");
+      raw.record_input = value === "failed" ? value : value === "true";
+      return;
+    case "keep_successful_runs_for_days":
+      if (!/^[1-9]\d{0,4}$/.test(value))
+        throw new CliError("validation_error", "keep_successful_runs_for_days must be a whole number of days, 1 or more");
+      raw.keep_successful_runs_for_days = Number(value);
+      return;
+    case "runs_size_limit_mb":
+      if (!/^[1-9]\d{0,5}$/.test(value))
+        throw new CliError("validation_error", "runs_size_limit_mb must be a whole number of megabytes, 1 or more");
+      raw.runs_size_limit_mb = Number(value);
+      return;
+    default:
+      throw new CliError("validation_error", "unknown config key");
+  }
+}), "setConfig");
+var unsetConfig = /* @__PURE__ */ __name((path, key, profile, permissionKeys) => changeFile(path, permissionKeys, (raw, { issues }) => {
+  const reported = issues.find((issue) => issue.key === key && (issue.profile === void 0 || issue.profile === profile));
+  if (key === "context.sources" && !reported && profile !== void 0 && Array.isArray(raw.context_sources)) {
+    raw.context_sources = raw.context_sources.filter((source) => !isNode(source) || source.profile !== profile);
+    return;
+  }
+  const at = reported?.at ?? (FILE_KEYS[key] ? [FILE_KEYS[key]] : profileSettingAt(key, profile));
+  removeAt(raw, at);
+  const entry = isNode(raw.profiles) ? raw.profiles[at[1] ?? ""] : void 0;
+  if (at[2] === "permissions" && isNode(entry) && isNode(entry.permissions)) {
+    if (Object.keys(entry.permissions).length === 0)
+      delete entry.permissions;
+  }
+}), "unsetConfig");
+var profileSettingAt = /* @__PURE__ */ __name((key, profile) => {
+  if (key !== "permissions" && !key.startsWith("permissions."))
+    throw new CliError("validation_error", "unknown config key");
+  if (!profile)
+    throw new CliError("validation_error", `name a profile: \`zm <profile> config unset ${key}\``);
+  return key === "permissions" ? ["profiles", profile, "permissions"] : ["profiles", profile, "permissions", key.slice("permissions.".length)];
+}, "profileSettingAt");
+var addProfile = /* @__PURE__ */ __name((path, profile) => {
+  if (readConfig(path).profiles.includes(profile))
+    return;
+  changeFile(path, void 0, (raw) => {
+    profileEntry(raw, profile);
+  });
+}, "addProfile");
+var filesZone = /* @__PURE__ */ __name((config) => config.filesTimezone ?? Intl.DateTimeFormat().resolvedOptions().timeZone, "filesZone");
+
+export {
+  publicIssue,
+  profilePattern,
+  profileAccountKey,
+  chooseProfile,
+  contextSourcesSchema,
+  inspectConfig,
+  readConfig,
+  setConfig,
+  unsetConfig,
+  addProfile,
+  filesZone
+};