@asturiu/v0-sdk 0.0.0-stage → 1.0.0

package/src/cli/files.ts

@@ -0,0 +1,371 @@
+/**
+ * The repository's files next to what the Engine holds: the Definition set, the branding and the portal options
+ * (ADR-029, ADR-038, ADR-039). `definitions`, `branding`, `pull` and `apply`.
+ */
+import { brandingImageProblems, inlineImageBytes } from "../branding.js";
+import { type DefinitionSet, type DefinitionStatus, applyBranding, applyDefinitions, applyPortal, definitionSetHash, definitionStatus, entryTypesOf, readBranding, readPortal } from "../definition-set.js";
+import { PORTAL_PAGES, PORTAL_SWITCHES } from "../portal-options.js";
+import { sanitizeThemeSpec } from "../theme.js";
+import { type CallResult, type Ctx, EXIT, Fail, call, emit, hostOf, needTenantApi, readFailure, sources } from "./context.js";
+import { type Json, imagePaths } from "./sources.js";
+import { type Tone, bytes, plain, plural, truncate } from "./terminal.js";
+
+// ================================================================== differences
+
+/** Where two JSON values differ, as dotted paths with both sides. */
+export function differences(a: unknown, b: unknown, at = ""): { path: string; a: unknown; b: unknown }[] {
+  const isObj = (v: unknown): v is Json => !!v && typeof v === "object" && !Array.isArray(v);
+  if (isObj(a) && isObj(b)) return [...new Set([...Object.keys(a), ...Object.keys(b)])].flatMap((k) => differences(a[k], b[k], at ? `${at}.${k}` : k));
+  return JSON.stringify(a) === JSON.stringify(b) ? [] : [{ path: at || "(all)", a, b }];
+}
+
+/** A value as a difference shows it: an inline image by its size, long text cut. */
+function shown(v: unknown): string {
+  if (v === undefined) return "(not set)";
+  const size = inlineImageBytes(v);
+  if (size !== null) return `inline image, ${bytes(size)}`;
+  return truncate(JSON.stringify(v), 60);
+}
+
+/** The theme keys the Engine would not keep. */
+export function themeDrops(theme: unknown): string[] {
+  if (!theme || typeof theme !== "object") return [];
+  return differences(theme, sanitizeThemeSpec(theme))
+    .filter((d) => d.b === undefined)
+    .map((d) => d.path);
+}
+
+/** Reads one of the repository's files; its error instead of a throw. */
+export function readSource(read: () => Json): { value: Json | null; error: string | null } {
+  try {
+    return { value: read(), error: null };
+  } catch (err) {
+    return { value: null, error: (err as Error).message };
+  }
+}
+
+export type TabState = { error: string; why: string; status: number } | { source: string; theme?: boolean; redirected?: string[]; stored: Json; differences: { path: string; repository: string; stored: string }[]; source_error?: string };
+export const tabRead = (s: TabState): s is Exclude<TabState, { error: string }> => !("error" in s);
+
+/**
+ * What the repository sends next to what the Engine holds, per tab. A switch or page the repository leaves out is its
+ * default (on, in the portal), so it is compared as such; a page an administrator redirected is not the repository's.
+ */
+export async function presentation(ctx: Ctx): Promise<{ branding: TabState; portal: TabState }> {
+  const [b, p] = await Promise.all([call(ctx, (fetch, cfg) => readBranding({ ...cfg, fetch })), call(ctx, (fetch, cfg) => readPortal({ ...cfg, fetch }))]);
+  const src = sources(ctx);
+  const diff = (x: unknown, y: unknown) => differences(x, y).map((d) => ({ path: d.path, repository: shown(d.a), stored: shown(d.b) }));
+
+  let branding: TabState;
+  if (!b.ok) branding = { error: readFailure(b, "branding"), why: b.why, status: b.status };
+  else {
+    const w = readSource(() => src.branding());
+    branding = { source: b.value.source, theme: b.value.branding.theme !== undefined, stored: b.value.branding as Json, differences: w.value ? diff(w.value, b.value.branding) : [], ...(w.error ? { source_error: w.error } : {}) };
+  }
+  let portal: TabState;
+  if (!p.ok) portal = { error: readFailure(p, "portal"), why: p.why, status: p.status };
+  else {
+    const w = readSource(() => src.portal());
+    let differ: { path: string; repository: string; stored: string }[] = [];
+    if (w.value) {
+      const redirected = p.value.redirected as string[];
+      const wanted: Json = Object.fromEntries(PORTAL_SWITCHES.map((k) => [k, w.value?.[k] ?? true]));
+      wanted.pages = Object.fromEntries(PORTAL_PAGES.filter((pg) => !redirected.includes(pg) && (p.value.portal.pages as Json | undefined)?.[pg] !== undefined).map((pg) => [pg, w.value?.pages?.[pg] ?? { mode: "portal" }]));
+      differ = diff(wanted, p.value.portal);
+    }
+    portal = { source: p.value.source, redirected: p.value.redirected, stored: p.value.portal as Json, differences: differ, ...(w.error ? { source_error: w.error } : {}) };
+  }
+  return { branding, portal };
+}
+
+/** A tab's state without the stored values (inline images make it long). */
+export function withoutStored(s: TabState): Json {
+  const { stored: _s, ...rest } = s as Json;
+  return rest;
+}
+
+const editedIn = (source: string) => (source === "repository" ? "edited in the repository" : "edited in the Admin UI");
+
+/** Both tabs next to the repository's files: who edits each, and every difference as a table. */
+function renderTabs(ctx: Ctx, pres: { branding: TabState; portal: TabState }) {
+  const { t } = ctx;
+  const src = sources(ctx);
+  for (const tab of ["branding", "portal"] as const) {
+    const s = pres[tab];
+    const label = t.paint.bold(tab === "branding" ? "Branding" : "Portal");
+    if (!tabRead(s)) {
+      t.item(s.why === "no-key" ? "muted" : "fail", label, s.error);
+      t.out();
+      continue;
+    }
+    const tone: Tone = s.source_error ? "fail" : s.differences.length ? "warn" : s.source === "repository" ? "ok" : "warn";
+    t.item(tone, `${label}  ${editedIn(s.source)}`, s.source_error ? "" : s.differences.length ? plural(s.differences.length, "difference") : `equal to ${src.files[tab]}`);
+    if (s.source_error) t.out(`      ${t.paint.red(plain(s.source_error))}`);
+    if (s.source !== "repository") t.out(`      ${t.paint.gray("apply answers 409 until a tenant administrator hands the tab to the repository")}`);
+    if (tab === "branding" && !s.theme) t.out(`      ${t.paint.gray("no theme stored: the portal runs on its default look")}`);
+    if (tab === "portal" && s.redirected?.length) t.out(`      ${t.paint.gray(`${s.redirected.join(", ")} ${s.redirected.length === 1 ? "stays" : "stay"} in the application, where an administrator moved ${s.redirected.length === 1 ? "it" : "them"}`)}`);
+    if (s.differences.length) {
+      t.table(
+        s.differences,
+        [
+          { label: "Key", value: (d) => d.path, paint: (x) => t.paint.bold(x) },
+          { label: "Repository", value: (d) => d.repository, flex: true, min: 14 },
+          { label: "Stored", value: (d) => d.stored, flex: true, min: 14, paint: (x) => t.paint.cyan(x) },
+        ],
+        { indent: 6 },
+      );
+    }
+    t.out();
+  }
+}
+
+// ================================================================== the Definition set
+
+/**
+ * The repository's Definition set, its size and its hash: the hash the SDK sends and the Engine stores, so equal
+ * hashes mean the live set is the repository's.
+ */
+export async function repositorySet(ctx: Ctx) {
+  const read = readSource(() => sources(ctx).definitions());
+  if (!read.value) return { set: null, error: read.error, hash: null as string | null, wallets: 0, entries: 0, fields: 0 };
+  const set = read.value as DefinitionSet;
+  const entries = Object.values(entryTypesOf({ wallets: set.wallets ?? {}, shared_entries: set.shared_entries }));
+  const fields = Object.keys(set.shared_fields ?? {}).length + entries.reduce((n, e) => n + Object.keys(e.fields ?? {}).length, 0);
+  let hash: string | null = null;
+  try {
+    hash = await definitionSetHash(set);
+  } catch {
+    hash = null;
+  }
+  return { set, error: null, hash, wallets: Object.keys(set.wallets ?? {}).length, entries: entries.length, fields };
+}
+
+/** Where the repository's set stands: live, waiting for approval, or not sent; null when either side is unknown. */
+export function setState(live: DefinitionStatus | null, hash: string | null): "live" | "waiting" | "differs" | null {
+  if (!live || !hash || !live.hash) return null;
+  if (live.hash === hash) return "live";
+  if (live.waiting.some((w) => w.hash === hash)) return "waiting";
+  return "differs";
+}
+
+export async function readDefinitionStatus(ctx: Ctx): Promise<CallResult<DefinitionStatus>> {
+  return call(ctx, (fetch, cfg) => definitionStatus({ ...cfg, fetch }));
+}
+
+export async function cmdDefinitions(ctx: Ctx, args: string[]) {
+  const sub = args[0] ?? "status";
+  if (sub === "apply") return applyParts(ctx, ["definitions"]);
+  if (sub !== "status") throw new Fail(`“definitions ${plain(sub)}” is not a command.`, { hint: `${ctx.cmd} definitions, or ${ctx.cmd} definitions apply`, code: EXIT.misunderstood });
+  const { t } = ctx;
+  const src = sources(ctx);
+  const [st, repo] = await t.busy("Reading the live Definition set", () => Promise.all([readDefinitionStatus(ctx), repositorySet(ctx)]));
+  const live = st.ok ? st.value : null;
+  const state = setState(live, repo.hash);
+  if (ctx.flags.check && state !== "live") ctx.exit = EXIT.failed;
+  if (ctx.json) return emit(ctx, { live: st.ok ? live : { error: readFailure(st, "definitions") }, repository: { file: src.files.definitions, hash: repo.hash, wallet_types: repo.wallets, entry_types: repo.entries, fields: repo.fields, ...(repo.error ? { error: repo.error } : {}) }, state });
+
+  t.banner("Definitions", [`live at ${hostOf(ctx.baseUrl)}`, `next to ${src.label}`]);
+  const short = (h: string | null | undefined) => (h ? `${h.slice(0, 12)}${t.sym.ellipsis}` : "—");
+  const rows: [string, string | string[]][] = [];
+  if (live) rows.push(["Live", [`${t.mark(live.source === "repository" ? "ok" : "warn")} revision ${t.paint.bold(String(live.revision))} ${t.sym.dot} ${editedIn(live.source)}  ${t.paint.gray(live.auto_apply === "safe" ? "safe changes apply on their own" : "every change waits for approval")}`, `  ${t.paint.gray(`hash ${short(live.hash)}`)}`]]);
+  else if (!st.ok) rows.push(["Live", `${t.mark(st.why === "no-key" ? "muted" : "fail")} ${readFailure(st, "definitions")}`]);
+  if (repo.set) rows.push(["Repository", [`${t.mark("info")} ${plural(repo.wallets, "Wallet type")} ${t.sym.dot} ${plural(repo.entries, "Entry type")} ${t.sym.dot} ${plural(repo.fields, "Field")}`, `  ${t.paint.gray(`hash ${short(repo.hash)} ${t.sym.dot} ${src.files.definitions}`)}`]]);
+  else rows.push(["Repository", `${t.mark("fail")} ${plain(repo.error)}`]);
+  for (const w of live?.waiting ?? []) rows.push(["Waiting", [`${t.mark("warn")} plan ${t.paint.bold(plain(w.plan_id))} ${t.sym.dot} since ${w.created_at.slice(0, 10)}${w.hash === repo.hash ? ` ${t.sym.dot} the repository's set` : ""}`, `  ${t.paint.gray(`hash ${short(w.hash)}`)}`]]);
+  t.pairs(rows, { width: 14 });
+  t.out();
+  const steps: [string, string][] = [];
+  if (state === "live") t.item("ok", t.paint.bold("The live set is the repository's."));
+  else if (state === "waiting") t.item("warn", t.paint.bold("The repository's set waits for a tenant administrator's approval."), "the Admin UI, your Tenant › Definitions");
+  else if (state === "differs") {
+    t.item("warn", t.paint.bold("The live set is not the repository's."), live?.source === "repository" ? "it goes out at the next start" : "");
+    steps.push([`${ctx.cmd} definitions apply`, "send it now"]);
+  }
+  if (live && live.source !== "repository") t.out(`  ${t.paint.gray(`${t.sym.arrow} apply answers 409 until a tenant administrator sets the Definitions to be edited in the repository`)}`);
+  t.next(steps);
+  t.out();
+}
+
+// ================================================================== branding and portal
+
+export async function cmdBranding(ctx: Ctx, args: string[]) {
+  const sub = args[0] ?? "status";
+  if (sub === "apply") return applyParts(ctx, ["branding", "portal"]);
+  if (sub !== "status") throw new Fail(`“branding ${plain(sub)}” is not a command.`, { hint: `${ctx.cmd} branding, or ${ctx.cmd} branding apply`, code: EXIT.misunderstood });
+  const { t } = ctx;
+  const src = sources(ctx);
+  const pres = await t.busy("Reading the Branding and Portal tabs", () => presentation(ctx));
+  const total = [pres.branding, pres.portal].reduce((n, s) => n + (tabRead(s) ? s.differences.length : 0), 0);
+  const unread = !tabRead(pres.branding) || !tabRead(pres.portal);
+  if (ctx.flags.check && (total || unread)) ctx.exit = EXIT.failed;
+  if (ctx.json) return emit(ctx, { branding: withoutStored(pres.branding), portal: withoutStored(pres.portal), differences: total });
+
+  t.banner("Branding and portal", [`stored at ${hostOf(ctx.baseUrl)}`, `next to ${src.label}`]);
+  renderTabs(ctx, pres);
+  if (!total && !unread) t.item("ok", "The stored tabs are what the repository sends.");
+  t.next(
+    total
+      ? [
+          [`${ctx.cmd} branding apply`, `make the stored tabs what ${src.label} says`],
+          [`${ctx.cmd} pull`, `or take the stored state into ${src.label}`],
+        ]
+      : [],
+  );
+  t.out();
+}
+
+export async function cmdPull(ctx: Ctx) {
+  const { t, flags } = ctx;
+  needTenantApi(ctx, "nothing to pull.");
+  const src = sources(ctx);
+  const pres = await t.busy("Reading the Branding and Portal tabs", () => presentation(ctx));
+  const branding = pres.branding;
+  const portal = pres.portal;
+  if (!tabRead(branding)) throw new Fail(`The branding could not be read: ${branding.error.replace(/^not read: /, "")}.`);
+  if (!tabRead(portal)) throw new Fail(`The portal could not be read: ${portal.error.replace(/^not read: /, "")}.`);
+  const total = branding.differences.length + portal.differences.length;
+  const strip = withoutStored;
+
+  if (!ctx.json) {
+    t.banner("Pull", [`stored at ${hostOf(ctx.baseUrl)}`, `into ${src.label}`]);
+    renderTabs(ctx, pres);
+  }
+  if (!total || !src.write) {
+    if (ctx.json) return emit(ctx, { branding: strip(branding), portal: strip(portal), written: [] });
+    if (!src.write && total) t.callout("info", "Copy these into the repository's files by hand", [`This repository's configuration has no way to write ${src.label}.`]);
+    else t.item("ok", "Nothing to take in.");
+    t.out();
+    return;
+  }
+
+  let write = flags.write === true || flags.yes === true;
+  if (!write && !flags["dry-run"] && !ctx.json) write = (await t.confirm(`Write the stored state into ${src.label}? It replaces what is there.`, false)) === true;
+  if (!write) {
+    if (ctx.json) return emit(ctx, { branding: strip(branding), portal: strip(portal), written: [] });
+    t.next([[`${ctx.cmd} pull --write`, `write the stored state into ${src.label}`]]);
+    t.out();
+    return;
+  }
+  const written = src.write({ branding: branding.stored, portal: portal.stored });
+  if (ctx.json) return emit(ctx, { branding: strip(branding), portal: strip(portal), written });
+  for (const f of written) t.item("ok", `Wrote ${f}`);
+  t.out(`  ${t.paint.gray(`${t.sym.arrow} Review the diff${src.afterWrite ? `, then run ${src.afterWrite}` : ""}.`)}`);
+  t.out();
+}
+
+// ================================================================== apply
+
+export async function cmdApply(ctx: Ctx, args: string[]) {
+  const named = args.map((a) => a.toLowerCase());
+  const known = ["definitions", "branding", "portal"];
+  const unknown = named.filter((a) => !known.includes(a));
+  if (unknown.length) throw new Fail(`“apply ${plain(unknown[0])}”: apply sends definitions, branding and portal.`, { hint: `${ctx.cmd} apply, or ${ctx.cmd} apply definitions`, code: EXIT.misunderstood });
+  return applyParts(ctx, (named.length ? named : known) as ("definitions" | "branding" | "portal")[]);
+}
+
+/** Sends the parts named, as the server start does, and shows each outcome. Exits 1 when one is refused or not sent. */
+export async function applyParts(ctx: Ctx, parts: ("definitions" | "branding" | "portal")[]) {
+  const { t } = ctx;
+  needTenantApi(ctx, "nothing sent.");
+  const src = sources(ctx);
+  const want = new Set(parts);
+  const notes: { level: string; message: string; detail?: unknown }[] = [];
+  const log = {
+    info: (m: string, d?: Record<string, unknown>) => notes.push({ level: "info", message: m, detail: d }),
+    warn: (m: string, d?: Record<string, unknown>) => notes.push({ level: "warn", message: m, detail: d }),
+    error: (m: string, d?: Record<string, unknown>) => notes.push({ level: "error", message: m, detail: d }),
+  };
+  const set = want.has("definitions") ? readSource(() => src.definitions()) : null;
+  const branding = want.has("branding") ? readSource(() => src.branding()) : null;
+  const portal = want.has("portal") ? readSource(() => src.portal()) : null;
+  const drops = branding?.value ? themeDrops(branding.value.theme) : [];
+
+  const [d, b, p] = await t.busy(`Sending to ${hostOf(ctx.baseUrl)}`, () =>
+    Promise.all([
+      set?.value ? call(ctx, (fetch, cfg) => applyDefinitions({ ...cfg, set: set.value as DefinitionSet, fetch, log })) : null,
+      branding?.value ? call(ctx, (fetch, cfg) => applyBranding({ ...cfg, branding: branding.value as Json, fetch, log })) : null,
+      portal?.value ? call(ctx, (fetch, cfg) => applyPortal({ ...cfg, portal: portal.value as Json, fetch, log })) : null,
+    ]),
+  );
+  const outcome = (r: CallResult<unknown> | null, read: { error: string | null } | null): Json => {
+    if (!r) return { status: "error", message: read?.error ?? "not read" };
+    if (!r.ok) return { status: "error", message: r.message, http: r.status };
+    const v = r.value as Json;
+    if (v.status === "error") return { ...v, message: r.network || v.message, http: r.status };
+    return v;
+  };
+  const results: Record<string, Json> = {};
+  if (set) results.definitions = outcome(d, set);
+  if (branding) results.branding = outcome(b, branding);
+  if (portal) results.portal = outcome(p, portal);
+  const bad = Object.values(results).some((r) => r.status === "error" || r.status === "refused");
+  ctx.exit = bad ? EXIT.failed : EXIT.done;
+  if (ctx.json) return emit(ctx, { ...results, ...(drops.length ? { theme_dropped: drops } : {}) });
+
+  const order = ["definitions", "branding", "portal"].filter((x) => want.has(x as "definitions"));
+  const what = order.length === 3 ? "Apply" : `Apply ${order.length === 1 ? order[0] : `${order.slice(0, -1).join(", ")} and ${order[order.length - 1]}`}`;
+  t.banner(what, [`from ${src.label}`, `to ${hostOf(ctx.baseUrl)}`]);
+  const tone: Record<string, Tone> = { applied: "ok", unchanged: "ok", waiting: "warn", refused: "fail", error: "fail" };
+  const why = (r: Json, scope: string) => {
+    if (r.http === 409) return `${plain(r.message)} ${t.sym.dot} still edited in the Admin UI: a tenant administrator hands it to the repository`;
+    if (r.http === 404) return `${plain(r.message)} ${t.sym.dot} the key lacks the scope “${scope}”`;
+    return plain(r.message);
+  };
+
+  const rd = results.definitions;
+  if (rd) {
+    const changes = (s: Json | undefined) => (s ? ` ${t.sym.dot} ${plural(s.changes, "change")}` : "");
+    const text: Record<string, string> = {
+      applied: `applied ${t.sym.dot} revision ${rd.revision}${changes(rd.summary)}`,
+      unchanged: `unchanged ${t.sym.dot} revision ${rd.revision}`,
+      waiting: rd.reverted_in ? `waits: an administrator reverted it in revision ${rd.reverted_in}` : `waits for a tenant administrator's approval${rd.summary ? ` ${t.sym.dot} ${plural(rd.summary.unsafe, "change")} ${rd.summary.unsafe === 1 ? "touches" : "touch"} existing data` : ""}`,
+      refused: "refused",
+      error: `not sent ${t.sym.dot} ${why(rd, "definitions")}`,
+    };
+    t.item(tone[rd.status] ?? "info", `${t.paint.bold("Definitions".padEnd(12))} ${text[rd.status] ?? plain(rd.status)}`);
+    if (rd.status === "waiting" && rd.approve_url) t.out(`      ${t.paint.gray("approve at")} ${t.link(plain(rd.approve_url), rd.approve_url)}`);
+    if (rd.status === "waiting" && rd.reverted_in) t.out(`      ${t.paint.gray("revert the same change in the repository, or have the waiting plan approved")}`);
+    if ((rd.status === "applied" || rd.status === "waiting") && rd.changes?.length) {
+      const shownChanges: Json[] = rd.changes.slice(0, 20);
+      t.table(
+        shownChanges,
+        [
+          { label: "Address", value: (c) => c.address, paint: (x) => t.paint.bold(x) },
+          { label: "Change", value: (c) => String(c.change).replace(/_/g, " "), flex: true, min: 12 },
+          ...(shownChanges.some((c) => c.in_use?.length) ? [{ label: "In use", value: (c: Json) => (c.in_use?.length ? String(c.in_use.reduce((n: number, u: { count: number }) => n + u.count, 0)) : ""), align: "right" as const, paint: (x: string) => t.paint.gray(x) }] : []),
+          { label: "Safe", value: (c) => (c.safe ? t.sym.ok : t.sym.warn), paint: (x) => (x === t.sym.ok ? t.paint.green(x) : t.paint.yellow(x)) },
+        ],
+        { indent: 6 },
+      );
+      if (rd.changes.length > shownChanges.length) t.out(`      ${t.paint.gray(`and ${rd.changes.length - shownChanges.length} more (--json lists them all)`)}`);
+    }
+    for (const reason of rd.reasons ?? []) t.out(`      ${t.paint.red(t.sym.bullet)} ${reason.address ? `${t.paint.bold(plain(reason.address))}  ` : ""}${plain(reason.reason)}`);
+    for (const w of rd.warnings ?? []) t.out(`      ${t.paint.yellow(t.sym.bullet)} ${w.address ? `${t.paint.bold(plain(w.address))}  ` : ""}${plain(w.reason)}`);
+  }
+
+  for (const [tab, label] of [
+    ["branding", "Branding"],
+    ["portal", "Portal"],
+  ] as const) {
+    const r = results[tab];
+    if (!r) continue;
+    t.item(tone[r.status] ?? "info", `${t.paint.bold(label.padEnd(12))} ${r.status === "error" ? `not sent ${t.sym.dot} ${why(r, tab)}` : plain(r.status)}`);
+    for (const pr of r.problems ?? []) t.out(`      ${t.paint.red(t.sym.bullet)} ${t.paint.bold((pr.path ?? []).join("."))}  ${plain(pr.message)}`);
+    if (r.kept?.length) t.out(`      ${t.paint.gray(`${r.kept.join(", ")} ${r.kept.length === 1 ? "stays" : "stay"} where an administrator moved ${r.kept.length === 1 ? "it" : "them"}: leave ${r.kept.length === 1 ? "it" : "them"} out of ${src.files.portal}`)}`);
+    if (tab === "branding" && drops.length) t.out(`      ${t.paint.yellow(t.sym.warn)} ${t.paint.gray(`the Engine drops ${drops.map((x) => `theme.${x}`).join(", ")}: not in the theme reference`)}`);
+  }
+  if (bad) {
+    t.out();
+    t.item("fail", t.paint.bold("Not everything was applied."), "nothing above was retried");
+  }
+  t.out();
+}
+
+/** The branding's images the portal refuses, and how many it sends inline: for `doctor`. */
+export function brandingFileCheck(value: Json): { problems: { path: string[]; message: string }[]; drops: string[]; images: number } {
+  return {
+    problems: brandingImageProblems(value),
+    drops: themeDrops(value.theme),
+    images: imagePaths().filter((p) => p.reduce<any>((o, k) => o?.[k], value) !== undefined).length,
+  };
+}

package/src/cli/index.ts

@@ -0,0 +1,7 @@
+/** The command line as a module, for tests and for the local page: `run(argv, options)` answers the exit code. */
+export { COMMAND, COMMANDS, DEFAULT_PREFIX, parseArgs, run, type RunOptions } from "./cli.js";
+export { EXIT, secretIn } from "./context.js";
+export { bundle, type Finding } from "./feedback.js";
+export { promptOf } from "./changesets.js";
+export { createUiHandler, uiAction, type UiAction, type UiRequest, type UiResponse } from "./ui.js";
+export { plain } from "./terminal.js";