@wirecat/zoom-cli 0.13.0 → 0.15.0

package/dist/program.js

@@ -1,33 +1,33 @@
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
-import { createDeadline, createRenderer, errorObjectOf, errorRecordOf, exitCodeOfAnswer, exitCodeOfError, fieldsOf, isCliError, projectFields, realSleep, renderError, } from "@wirecat/cli-base";
+import { CliError, createDeadline, createOutputBuffer, createRenderer, errorObjectOf, errorRecordOf, exitCodeOfError, isCliError, projectFields, realSleep, renderError, } from "@wirecat/cli-base";
 import { metaOf } from "@wirecat/cli-base/commands";
-import { jsonlRecords, listOf } from "@wirecat/cli-core/cli";
-import { importFiles, listed, MeetingError, pull, } from "@wirecat/cli-core/meetings";
+import { checkJson, itemOf, snakeKeys } from "@wirecat/cli-core/cli";
+import { importFiles, pull, } from "@wirecat/cli-core/meetings";
 import { addMeetingCommands, addMeetingPassageCommand } from "@wirecat/cli-core/meetings/cli";
 import { Command, CommanderError } from "commander";
 import { addZoomSkillCommands } from "./agent-skill.js";
-import { createAnswerRenderer } from "./answer-output.js";
+import { bodyOf, renderBody, wholeList } from "./answer-output.js";
 import { hostFailureContext } from "./answer-policy.js";
-import { meetingAnswer } from "./answers.js";
 import { ZoomApiSource } from "./api.js";
 import { addArchiveCommands, } from "./archive-commands.js";
 import { applyArchiveImport, preflightArchiveImport } from "./archive-import.js";
 import { readArchiveTranscripts, searchArchiveTranscripts } from "./archive-transcripts.js";
 import { addStandardCommands, annotateMeetingCommands } from "./commands.js";
 import { profileAccountKey, readConfig, setConfig } from "./config.js";
-import { checkCancelled, ZoomError } from "./errors.js";
+import { checkCancelled } from "./errors.js";
 import { bytes, duration, resetCliOptions, startExecution } from "./execution.js";
 import { FilesSource, importFile, readDownloadedFiles, validateDownloadedFiles } from "./files.js";
 import { addIngestionSearchCommands } from "./ingestion-search-commands.js";
-import { snakeKeys } from "./keys.js";
+import { liftJsonFields } from "./json-fields.js";
 import { addLocalTranscriptionCommands } from "./local-transcription-commands.js";
 import { login } from "./login.js";
 import { addMeetingContextCommands } from "./meeting-context-commands.js";
 import { addMeetingIntegrationCommands } from "./meeting-integration-commands.js";
-import { addProjectEvidenceCommand } from "./meeting-project-evidence-commands.js";
+import { addZoomMcpCommand } from "./meeting-mcp-command.js";
+import { addMeetingReadBindings } from "./meeting-read-command-bindings.js";
 import { addMeetingSearchCommands } from "./meeting-search-commands.js";
-import { addMeetingEmbeddingCommand, validateMeetingModel, } from "./meeting-semantic-commands.js";
+import { addMeetingEmbeddingCommand } from "./meeting-semantic-commands.js";
 import { createRecordingScheduleService } from "./recording-schedule.js";
 import { addRecordingScheduleCommands } from "./recording-schedule-commands.js";
 import { fileRecordingScheduleStore } from "./recording-schedule-store.js";
@@ -40,7 +40,7 @@ import { runUnifiedSearch } from "./unified-search.js";
 import { VERSION } from "./version.js";
 import { addWatchCommand } from "./watch-commands.js";
 const unavailable = async () => {
-    throw new ZoomError("configuration_error", "the shared SQLite meeting store is not available yet");
+    throw new CliError("configuration_error", "the shared SQLite meeting store is not available yet");
 };
 const unavailableStore = {
     saveMeeting: unavailable,
@@ -62,7 +62,7 @@ const answerExitCodes = new WeakMap();
 export const createProgram = (deps) => {
     let config;
     const getConfig = () => (config ??= readConfig(deps.configPath));
-    let connection;
+    let connecting;
     let parsing = false;
     let execution;
     let fields;
@@ -72,7 +72,7 @@ export const createProgram = (deps) => {
     const fetchWithSignal = (fetcher) => (input, init) => {
         checkCancelled(signal());
         if (program.opts().offline)
-            throw new ZoomError("configuration_error", "the command requires network access; remove --offline");
+            throw new CliError("configuration_error", "the command requires network access; remove --offline");
         const operation = signal();
         return fetcher(input, {
             ...init,
@@ -82,7 +82,7 @@ export const createProgram = (deps) => {
     const tokens = () => (activeTokens ??= deps.tokens.withSignal(signal(), fetchWithSignal(deps.tokens.options.fetch)));
     const buffer = (text) => {
         if (!execution)
-            throw new ZoomError("configuration_error", "command execution is not initialized");
+            throw new CliError("configuration_error", "command execution is not initialized");
         execution.output.data(text);
     };
     const guardedStore = (store) => new Proxy(store, {
@@ -102,133 +102,99 @@ export const createProgram = (deps) => {
     let selectedAccountId = deps.accountId;
     const requireAccount = () => {
         if (!Number.isSafeInteger(selectedAccountId) || !selectedAccountId || selectedAccountId < 1)
-            throw new ZoomError("configuration_error", "the selected meeting account is unavailable");
+            throw new CliError("configuration_error", "the selected meeting account is unavailable");
         return selectedAccountId;
     };
+    const openStore = async (intent) => {
+        if (!deps.connectStore)
+            return unavailable();
+        const profile = getConfig().accountProfile;
+        if (!profile)
+            throw new CliError("configuration_error", "select a local profile with zm config set account.profile <label>");
+        try {
+            return await deps.connectStore({ profile, externalId: profileAccountKey(profile), intent });
+        }
+        catch (error) {
+            if (isCliError(error))
+                throw error;
+            throw new CliError("configuration_error", "could not open the shared meeting store");
+        }
+    };
+    const connected = (intent = "read") => (connecting ??= openStore(intent));
     const program = new Command()
         .name("zm")
         .version(VERSION)
         .description("Zoom meeting transcripts and summaries")
-        .option("--json", "one JSON value")
+        .option("--json", "one JSON value; --json=id,title keeps only those fields")
         .option("--jsonl", "one JSON object per item")
         .option("--no-input", "disable interactive login")
         .option("--interactive", "permit browser approval in an interactive terminal")
         .option("--quiet", "suppress non-error diagnostics")
-        .option("--fields <paths>", "project result fields, such as id,title")
         .option("--timeout <duration>", "command deadline: reads 30s, login 5m, downloads/transcription 1h; watch/MCP have no default", duration)
         .option("--max-output-bytes <bytes>", "bound rendered result bytes (default 4194304; zero is unlimited)", bytes)
         .option("--offline", "refuse network requests")
         .option("--debug", "on a failure, its whole record — cause and stack — in place of the short line")
         .exitOverride()
         .configureOutput({ writeOut: deps.data, writeErr: deps.diagnostic, outputError: () => { } });
-    const render = createAnswerRenderer(program, (meta) => {
-        const action = execution?.action;
-        answerExitCodes.set(program, Math.max(answerExitCodes.get(program) ?? 0, exitCodeOfAnswer(meta, action ? metaOf(action).partial : false)));
-    });
+    const formatOf = () => program.opts().jsonl ? "jsonl" : program.opts().json || !deps.outputIsTTY ? "json" : "pretty";
+    const rendered = (body, format = formatOf()) => {
+        if (!execution)
+            throw new CliError("configuration_error", "command execution is not initialized");
+        const answer = renderBody(execution.action, body, {
+            format,
+            meta: execution.meta(),
+            fields,
+            quiet: Boolean(program.opts().quiet),
+            diagnostic: deps.diagnostic,
+        });
+        answerExitCodes.set(program, Math.max(answerExitCodes.get(program) ?? 0, answer.exitCode));
+        return answer.text;
+    };
     const api = () => {
         if (program.opts().offline)
-            throw new ZoomError("configuration_error", "the command requires network access; remove --offline");
+            throw new CliError("configuration_error", "the command requires network access; remove --offline");
         if (!getConfig().clientId)
-            throw new ZoomError("configuration_error", "run zm config set zoom.clientId <Public Client ID> first");
+            throw new CliError("configuration_error", "run zm config set zoom.client_id <Public Client ID> first");
     };
     program.hook("preAction", async (_root, action) => {
         const opts = action.optsWithGlobals();
         if (opts.json && opts.jsonl)
-            throw new ZoomError("validation_error", "choose --json or --jsonl");
-        fields = opts.fields === undefined ? undefined : fieldsOf(opts.fields);
+            throw new CliError("validation_error", "choose --json or --jsonl");
+        checkJson(action, { json: opts.json === true, ...(fields ? { fields: fields.join(",") } : {}) }, false);
         execution = startExecution(action, { signal: deps.signal, sleep: deps.sleep, now: deps.now });
         checkCancelled(signal());
-        let family = action;
-        while (family.parent && family.parent !== program)
-            family = family.parent;
-        if ([
-            "commands",
-            "complete",
-            "doctor",
-            "config",
-            "session",
-            "recordings",
-            "remote-meetings",
-            "serve",
-            "skill",
-            "watch",
-            "search",
-        ].includes(family.name()) ||
-            (family.name() === "meetings" &&
-                ["passage", "evidence", "context", "task-proposal", "embeddings", "update", "link", "transcribe"].includes(action.name())))
+        if (!storeCommands.has(action))
             return;
         const config = getConfig();
-        const ingestion = family.name() === "meetings" && ["sync", "import"].includes(action.name());
+        const ingestion = action.parent?.name() === "meetings" && ["sync", "import"].includes(action.name());
         if (opts.offline && ingestion && action.name() !== "import" && config.source === "api" && !deps.source)
-            throw new ZoomError("configuration_error", "API sync requires network access; remove --offline");
+            throw new CliError("configuration_error", "API sync requires network access; remove --offline");
         if (!selectedStore) {
-            if (!deps.connectStore)
-                return unavailable();
-            if (!config.accountProfile)
-                throw new ZoomError("configuration_error", "select a local profile with zm config set account.profile <label>");
-            try {
-                connection = await deps.connectStore({
-                    profile: config.accountProfile,
-                    externalId: profileAccountKey(config.accountProfile),
-                    intent: ingestion ? "ingestion" : "read",
-                });
-            }
-            catch (error) {
-                if (error instanceof ZoomError || error instanceof MeetingError)
-                    throw error;
-                throw new ZoomError("configuration_error", "could not open the shared meeting store");
-            }
+            const connection = await connected(ingestion ? "ingestion" : "read");
             selectedStore = connection.store;
             selectedAccountId = connection.accountId;
         }
         requireAccount();
     });
-    const output = (value) => buffer(render(value, program.opts().json ? "json" : program.opts().jsonl ? "jsonl" : "text", deps, fields, true, false, execution?.meta));
+    const output = (body) => buffer(rendered(body));
     const outputItems = async (values) => {
-        const meta = execution?.meta;
-        if (!meta)
-            throw new ZoomError("configuration_error", "execution metadata is unavailable");
-        const format = program.opts().jsonl ? "jsonl" : program.opts().json || !deps.outputIsTTY ? "json" : "text";
-        const metadata = listed([]);
-        delete metadata.items;
-        let count = 0;
-        if (format === "json")
-            buffer('{"items":[');
+        const items = [];
+        // Fails on the row that crosses --max-output-bytes, so a long iterator stops reading there.
+        const measured = createOutputBuffer({ maxOutputBytes: program.opts().maxOutputBytes });
         for await (const value of values) {
             checkCancelled(signal());
             const item = snakeKeys(value);
-            const projected = fields ? projectFields(listed([item]), fields).items[0] : item;
-            if (format === "json") {
-                if (count)
-                    buffer(",");
-                buffer(render(projected, "json", deps).trimEnd());
-            }
-            else if (format === "jsonl") {
-                const packet = meetingAnswer(projected, meta());
-                buffer(`${JSON.stringify(jsonlRecords(packet)[0])}\n`);
-            }
-            else
-                buffer(render(projected, format, deps, undefined, true, false, execution?.meta));
-            count++;
-        }
-        metadata.limit = count;
-        if (format === "json")
-            buffer(`],"page":${JSON.stringify({ mode: "page", limit: Math.max(1, count), has_more: false })},"meta":${JSON.stringify(execution?.meta())}}\n`);
-        else if (format === "jsonl") {
-            const packet = meetingAnswer(listOf("meetings import", { items: [], limit: Math.max(1, count), has_more: false }), meta());
-            buffer(`${jsonlRecords(packet)
-                .map((record) => JSON.stringify(record))
-                .join("\n")}\n`);
+            measured.data(JSON.stringify(fields ? projectFields(item, fields) : item));
+            items.push(item);
         }
-        else if (format === "text")
-            buffer(render(count ? metadata : listed([]), "text", deps));
+        output(wholeList("list", items));
     };
     const cfg = program.command("config").description("local Zoom configuration");
     cfg
         .command("show")
         .description("show local configuration")
         .action(() => {
-        output(getConfig());
+        output(itemOf(getConfig()));
     });
     cfg
         .command("set")
@@ -236,7 +202,7 @@ export const createProgram = (deps) => {
         .argument("<key>", "setting name, such as account.profile")
         .argument("<value>", "new value")
         .action((key, value) => {
-        output(setConfig(deps.configPath, key, value));
+        output(itemOf(setConfig(deps.configPath, key, value)));
     });
     let activeSource;
     const getSource = () => {
@@ -247,7 +213,7 @@ export const createProgram = (deps) => {
             if (config.source === "api")
                 return new ZoomApiSource(tokens(), fetchWithSignal(deps.fetch));
             if (!config.filesFolder)
-                throw new ZoomError("configuration_error", "set files.folder before pulling from files");
+                throw new CliError("configuration_error", "set files.folder before pulling from files");
             return new FilesSource(await (deps.readFiles ?? readDownloadedFiles)(config.filesFolder), config.filesTimezone);
         })();
         return activeSource;
@@ -294,10 +260,7 @@ export const createProgram = (deps) => {
             return validateDownloadedFiles(await (deps.readFiles ?? readDownloadedFiles)(folder), config.filesTimezone).map((file) => importFile(file, requireAccount(), config.filesTimezone));
         },
         now: deps.now,
-        write: (value, format) => {
-            const paged = typeof value === "object" && value !== null && "page" in value && typeof value.page === "object";
-            buffer(render(value, format, deps, fields, paged, true, execution?.meta));
-        },
+        write: (value) => output(bodyOf(value)),
         writeFile: deps.writeFile
             ? async (path, content) => {
                 checkCancelled(signal());
@@ -306,10 +269,18 @@ export const createProgram = (deps) => {
             }
             : undefined,
     };
+    const before = new Set(program.commands);
     addMeetingCommands(program, meetingCommands);
+    const leaves = (command) => command.commands.length ? command.commands.flatMap(leaves) : [command];
+    // The meeting reads cli-core mounts read the store opened before their action; zoom's own commands open it lazily.
+    const storeCommands = new Set(program.commands.filter((group) => !before.has(group)).flatMap(leaves));
     addStandardCommands(program, {
         output,
-        discovery: (value) => buffer(render(value, program.opts().json ? "json" : program.opts().jsonl ? "jsonl" : "text", deps, undefined, false, true)),
+        discovery: (value) => createRenderer({
+            format: formatOf(),
+            color: false,
+            streams: { data: (text) => buffer(`${text}\n`), diagnostic: deps.diagnostic },
+        }).result(value),
         fields: () => fields,
         raw: buffer,
         doctor: () => {
@@ -329,7 +300,7 @@ export const createProgram = (deps) => {
                 return { configured: false, state: "not_configured", dataProfile: config.accountProfile, verified: false };
             if (check) {
                 if (program.opts().offline)
-                    throw new ZoomError("configuration_error", "session verification requires network access; remove --offline");
+                    throw new CliError("configuration_error", "session verification requires network access; remove --offline");
                 api();
                 return {
                     configured: true,
@@ -353,7 +324,7 @@ export const createProgram = (deps) => {
     });
     const session = program.commands.find((command) => command.name() === "session");
     if (!session)
-        throw new ZoomError("configuration_error", "session command group is unavailable");
+        throw new CliError("configuration_error", "session command group is unavailable");
     session
         .command("start")
         .description("log in to Zoom through your browser")
@@ -361,18 +332,18 @@ export const createProgram = (deps) => {
         .action(async (opts) => {
         const config = getConfig();
         if (!config.clientId)
-            throw new ZoomError("configuration_error", "run zm config set zoom.clientId <Public Client ID> first");
+            throw new CliError("configuration_error", "run zm config set zoom.client_id <Public Client ID> first");
         const globals = program.opts();
         if (globals.offline)
-            throw new ZoomError("configuration_error", "login requires network access; remove --offline");
+            throw new CliError("configuration_error", "login requires network access; remove --offline");
         const headless = deps.interactive === false ||
             Boolean(deps.env?.CI) ||
             (deps.interactive !== undefined &&
                 (globals.json || globals.jsonl || deps.outputIsTTY === false) &&
                 !globals.interactive);
         if (globals.input === false || headless)
-            throw new ZoomError("configuration_error", "login requires browser approval; remove --no-input");
-        output(await login({
+            throw new CliError("configuration_error", "login requires browser approval; remove --no-input");
+        output(itemOf(await login({
             tokens: tokens(),
             signal: signal(),
             openBrowser: (url) => deps.openBrowser(url, opts.browser),
@@ -381,13 +352,13 @@ export const createProgram = (deps) => {
                 if (!program.opts().quiet)
                     deps.diagnostic(`Open this URL to approve Zoom login:\n${url}\n`);
             },
-        }));
+        })));
     });
     let watchConfig;
     let watchSince;
     const watchSleep = deps.sleep;
-    const receipt = async (value) => {
-        const text = render(value, program.opts().jsonl ? "jsonl" : program.opts().json ? "json" : "text", deps, fields, true, false, execution?.meta);
+    const receipt = async (body) => {
+        const text = rendered(body);
         const operation = signal();
         const grace = operation.aborted ? createDeadline({ timeoutMs: 1000 }) : undefined;
         try {
@@ -419,24 +390,24 @@ export const createProgram = (deps) => {
             };
             if (source === "files") {
                 if (flags.sinceTime !== undefined || flags.lookbackDays !== undefined)
-                    throw new ZoomError("validation_error", "--since-time and --lookback-days apply only to API watching");
+                    throw new CliError("validation_error", "--since-time and --lookback-days apply only to API watching");
                 if (!plan.folder?.trim())
-                    throw new ZoomError("configuration_error", "set files.folder or provide a folder for file watching");
+                    throw new CliError("configuration_error", "set files.folder or provide a folder for file watching");
             }
             else {
                 if (folder !== undefined)
-                    throw new ZoomError("validation_error", "API watching does not accept a folder");
+                    throw new CliError("validation_error", "API watching does not accept a folder");
                 if (program.opts().offline)
-                    throw new ZoomError("configuration_error", "API watching requires network access; remove --offline");
+                    throw new CliError("configuration_error", "API watching requires network access; remove --offline");
                 if (!deps.source) {
                     if (!config.clientId)
-                        throw new ZoomError("configuration_error", "run zm config set zoom.clientId <Public Client ID> first");
+                        throw new CliError("configuration_error", "run zm config set zoom.client_id <Public Client ID> first");
                     if (tokens().options.clientId !== config.clientId)
-                        throw new ZoomError("configuration_error", "the OAuth client changed before watch started; retry with matching configuration");
+                        throw new CliError("configuration_error", "the OAuth client changed before watch started; retry with matching configuration");
                 }
             }
             if (!deps.store && !config.accountProfile)
-                throw new ZoomError("configuration_error", "select a local profile with zm config set account.profile <label>");
+                throw new CliError("configuration_error", "select a local profile with zm config set account.profile <label>");
             watchConfig = config;
             watchSince = plan.since;
             return plan;
@@ -445,33 +416,17 @@ export const createProgram = (deps) => {
             checkCancelled(operation);
             const config = watchConfig;
             if (!config)
-                throw new ZoomError("configuration_error", "watch configuration is unavailable");
+                throw new CliError("configuration_error", "watch configuration is unavailable");
             let cycle;
             let failure;
             let result;
             try {
-                if (!deps.store) {
-                    if (!deps.connectStore)
-                        return unavailable();
-                    if (!config.accountProfile)
-                        throw new ZoomError("configuration_error", "select a local profile with zm config set account.profile <label>");
-                    try {
-                        cycle = await deps.connectStore({
-                            profile: config.accountProfile,
-                            externalId: profileAccountKey(config.accountProfile),
-                            intent: "ingestion",
-                        });
-                    }
-                    catch (error) {
-                        if (isCliError(error))
-                            throw error;
-                        throw new ZoomError("configuration_error", "could not open the shared meeting store");
-                    }
-                }
+                if (!deps.store)
+                    cycle = await openStore("ingestion");
                 checkCancelled(operation);
                 const accountId = cycle?.accountId ?? deps.accountId;
                 if (!Number.isSafeInteger(accountId) || !accountId || accountId < 1)
-                    throw new ZoomError("configuration_error", "the selected meeting account is unavailable");
+                    throw new CliError("configuration_error", "the selected meeting account is unavailable");
                 const store = guardedStore(cycle?.store ?? deps.store ?? unavailableStore);
                 if (plan.source === "files") {
                     const files = validateDownloadedFiles(await (deps.readFiles ?? readDownloadedFiles)(plan.folder ?? ""), config.filesTimezone);
@@ -543,7 +498,7 @@ export const createProgram = (deps) => {
                         await cycle.close();
                     }
                     catch {
-                        failure ??= new ZoomError("configuration_error", "could not close the shared meeting store");
+                        failure ??= new CliError("configuration_error", "could not close the shared meeting store");
                     }
                 }
             }
@@ -597,7 +552,7 @@ export const createProgram = (deps) => {
                         if (dirname(deps.configPath) !== job.capture.configDir ||
                             selected.accountProfile !== job.capture.profile ||
                             selected.clientId !== job.capture.clientId)
-                            throw new ZoomError("configuration_error", "archive schedule requires its saved profile and Zoom client id; select those settings before running");
+                            throw new CliError("configuration_error", "archive schedule requires its saved profile and Zoom client id; select those settings before running");
                         return new ZoomRecordings(new TokenManager({
                             clientId: job.capture.clientId,
                             keyring: deps.tokens.options.keyring,
@@ -615,9 +570,9 @@ export const createProgram = (deps) => {
         capture: () => {
             const selected = getConfig();
             if (!selected.accountProfile || !selected.clientId)
-                throw new ZoomError("configuration_error", "archive schedules require a configured local profile and Zoom client id");
+                throw new CliError("configuration_error", "archive schedules require a configured local profile and Zoom client id");
             if (!deps.recordingScheduleTarget)
-                throw new ZoomError("configuration_error", "archive scheduler requires an explicit runtime and CLI path");
+                throw new CliError("configuration_error", "archive scheduler requires an explicit runtime and CLI path");
             return {
                 profile: selected.accountProfile,
                 clientId: selected.clientId,
@@ -634,220 +589,99 @@ export const createProgram = (deps) => {
     });
     addZoomSkillCommands(program, () => {
         const renderer = createRenderer({
-            format: program.opts().json ? "json" : program.opts().jsonl ? "jsonl" : deps.outputIsTTY ? "pretty" : "json",
+            format: formatOf(),
             color: false,
             quiet: Boolean(program.opts().quiet),
             streams: { data: buffer, diagnostic: deps.diagnostic },
         });
         return {
-            renderer: { ...renderer, result: output, stream: (items) => output({ items: [...items] }) },
+            renderer: {
+                ...renderer,
+                result: (value) => output(bodyOf(value)),
+                stream: (items) => output(wholeList("skill", [...items])),
+            },
             streams: { data: (text) => buffer(`${text}\n`), diagnostic: deps.diagnostic },
             env: deps.env,
         };
     });
-    program
-        .command("serve")
-        .description("serve read-only meeting tools over MCP stdio")
-        .requiredOption("--mcp", "use the MCP JSON-RPC protocol")
-        .option("--unified-search", "include selected-profile meetings-only unified search")
-        .option("--meeting-context", "include account-fixed evidence, person context and task proposals")
-        .option("--semantic", "include read-only meeting vector search with an explicit query model")
-        .option("--model <model>", "query embedding model: an installed one, or one served at --base-url")
-        .option("--base-url <url>", "explicit remote embedding endpoint for semantic queries")
-        .option("--dims <n>", "vector size the remote service returns, in dimensions", bytes)
-        .action(async (options) => {
-        const opts = program.opts();
-        if (opts.json || opts.jsonl || opts.fields)
-            throw new ZoomError("validation_error", "MCP stdio controls its own output; omit --json, --jsonl and --fields");
-        if (!deps.serveMcp)
-            throw new ZoomError("configuration_error", "the MCP server adapter is not available");
-        if (options.semantic)
-            validateMeetingModel({ model: options.model ?? "", baseUrl: options.baseUrl, dims: options.dims });
-        else if (options.model !== undefined || options.baseUrl !== undefined || options.dims !== undefined)
-            throw new ZoomError("validation_error", "MCP model options require --semantic");
-        if (options.semantic && options.baseUrl !== undefined && opts.offline)
-            throw new ZoomError("configuration_error", "remote embeddings require network access; remove --offline");
-        await deps.serveMcp({
-            commandRegistry: program,
-            signal: signal(),
-            maxResultBytes: program.opts().maxOutputBytes,
-            ...(options.unifiedSearch ? { includeUnifiedSearch: true } : {}),
-            ...(options.meetingContext ? { includeMeetingContext: true } : {}),
-            ...(options.semantic
-                ? { semanticModel: { model: options.model ?? "", baseUrl: options.baseUrl, dims: options.dims } }
-                : {}),
-        });
-    });
+    const preparationOptions = {
+        credentials: () => {
+            api();
+            return tokens();
+        },
+        fetch: fetchWithSignal(deps.fetch),
+        remoteOptions,
+    };
+    addZoomMcpCommand(program, { fields: () => fields, signal, serve: deps.serveMcp, preparation: preparationOptions });
     addIngestionSearchCommands(program, {
         signal,
-        output: (value) => buffer(render(value, program.opts().jsonl ? "jsonl" : program.opts().json ? "json" : "text", deps, fields, true, false, execution?.meta)),
+        output,
         outputItems,
         receipt,
         preflight: preflightArchiveImport,
         apply: async function* (plan) {
             if (plan.occurrences === 0)
                 return;
-            let store = deps.transcriptStore;
-            let accountId = selectedAccountId;
-            if (!store) {
-                const config = getConfig();
-                if (!config.accountProfile || !deps.connectStore)
-                    throw new ZoomError("configuration_error", "select a local profile with an available transcript append store");
-                connection = await deps.connectStore({
-                    profile: config.accountProfile,
-                    externalId: profileAccountKey(config.accountProfile),
-                    intent: "ingestion",
-                    capability: "transcript-append",
-                });
-                accountId = connection.accountId;
-                if (!connection.appendTranscripts && !connection.appendTranscriptsWithReceipt)
-                    throw new ZoomError("configuration_error", "the installed meeting store does not support transcript append");
-                store = {
-                    appendTranscripts: connection.appendTranscripts,
-                    appendTranscriptsWithReceipt: connection.appendTranscriptsWithReceipt,
-                };
-            }
-            for await (const item of applyArchiveImport(plan, store, {
-                accountId: accountId ?? 0,
+            const connection = await connected("ingestion");
+            for await (const item of applyArchiveImport(plan, connection, {
+                accountId: connection.accountId,
                 now: deps.now?.(),
                 signal: signal(),
             }))
                 yield item;
         },
-        search: async (request) => {
-            if (deps.unifiedSearch)
-                return runUnifiedSearch(deps.unifiedSearch, request);
-            const config = getConfig();
-            if (!config.accountProfile || !deps.connectStore)
-                throw new ZoomError("configuration_error", "select a stored local profile for unified search");
-            connection = await deps.connectStore({
-                profile: config.accountProfile,
-                externalId: profileAccountKey(config.accountProfile),
-                intent: "read",
-            });
-            if (!connection.unifiedSearch)
-                throw new ZoomError("configuration_error", "unified search is unavailable in this store connector");
-            return runUnifiedSearch(connection.unifiedSearch, request);
-        },
+        search: async (request) => runUnifiedSearch((await connected()).unifiedSearch, request),
     });
-    const integrationConnection = async (capability) => {
-        const config = getConfig();
-        if (!config.accountProfile || !deps.connectStore)
-            throw new ZoomError("configuration_error", "select a stored local profile for meeting integration");
-        connection = await deps.connectStore({
-            profile: config.accountProfile,
-            externalId: profileAccountKey(config.accountProfile),
-            intent: "read",
-            capability,
-        });
-        return connection;
-    };
-    const integrationOutput = (value) => buffer(render(value, program.opts().jsonl ? "jsonl" : program.opts().json ? "json" : "text", deps, fields, true, false, execution?.meta));
-    addProjectEvidenceCommand(program, {
-        read: deps.meetingProjectEvidence,
-        connect: () => integrationConnection("meeting-project-evidence"),
-        signal,
-        now: deps.now,
-        output: integrationOutput,
+    addMeetingReadBindings(program, {
+        project: {
+            read: async (project, request) => (await connected()).meetingProjectEvidence(project, request),
+            signal,
+            now: deps.now,
+            output: (value) => output(bodyOf(value)),
+        },
+        preparation: {
+            ...preparationOptions,
+            connect: () => openStore("read"),
+        },
     });
     addMeetingIntegrationCommands(program, {
         signal,
-        output: integrationOutput,
+        output,
         receipt,
-        integration: async () => {
-            if (deps.meetingIntegration)
-                return deps.meetingIntegration;
-            const connected = await integrationConnection("meeting-integration");
-            if (!connected.meetingIntegration)
-                throw new ZoomError("configuration_error", "meeting integration is unavailable in this store connector");
-            return connected.meetingIntegration;
-        },
+        integration: async () => (await connected()).meetingIntegration,
     });
     addLocalTranscriptionCommands(program, {
         signal,
-        output: integrationOutput,
+        output,
         receipt,
-        capabilities: async () => {
-            if (deps.meetingTranscription)
-                return deps.meetingTranscription;
-            const config = getConfig();
-            if (!config.accountProfile || !deps.connectStore)
-                throw new ZoomError("configuration_error", "select a stored local profile for transcription");
-            connection = await deps.connectStore({
-                profile: config.accountProfile,
-                externalId: profileAccountKey(config.accountProfile),
-                intent: "read",
-                capability: "transcript-append",
-            });
-            if (!connection.meetingTranscription)
-                throw new ZoomError("configuration_error", "local transcription is unavailable in this store connector");
-            return connection.meetingTranscription;
-        },
+        capabilities: async () => (await connected()).meetingTranscription,
     });
-    const meetingContext = async () => {
-        if (deps.meetingContext)
-            return deps.meetingContext;
-        const config = getConfig();
-        if (!config.accountProfile || !deps.connectStore)
-            throw new ZoomError("configuration_error", "select a stored local profile for meeting context");
-        connection = await deps.connectStore({
-            profile: config.accountProfile,
-            externalId: profileAccountKey(config.accountProfile),
-            intent: "read",
-        });
-        if (!connection.meetingContext)
-            throw new ZoomError("configuration_error", "meeting context is unavailable in this store connector");
-        return connection.meetingContext;
-    };
+    const meetingContext = async () => (await connected()).meetingContext;
     addMeetingContextCommands(program, {
         signal,
-        output: (value) => buffer(render(value, program.opts().jsonl ? "jsonl" : program.opts().json ? "json" : "text", deps, fields, true, false, execution?.meta)),
+        output,
         context: meetingContext,
     });
     addMeetingPassageCommand(program, {
         signal,
         read: async (reference, options) => {
             if (fields && options.format !== "json")
-                throw new ZoomError("validation_error", "passage field selection requires --json or --format json");
-            const context = await meetingContext();
-            if (!context.passage)
-                throw new ZoomError("configuration_error", "meeting passage is unavailable in this store connector");
-            return context.passage(reference, options);
+                throw new CliError("validation_error", "passage field selection requires --json or --format json");
+            return (await meetingContext()).passage(reference, options);
         },
         output: (result, format) => {
             if (format === "json")
-                buffer(render(result.packet, program.opts().jsonl ? "jsonl" : "json", deps, fields, true, false, execution?.meta));
+                buffer(rendered(bodyOf(result.packet), program.opts().jsonl ? "jsonl" : "json"));
             else
                 buffer(result.content);
         },
     });
-    const meetingSemantic = async () => {
-        if (deps.meetingSemantic)
-            return deps.meetingSemantic;
-        const config = getConfig();
-        if (!config.accountProfile || !deps.connectStore)
-            throw new ZoomError("configuration_error", "select a stored local profile for meeting vectors");
-        connection = await deps.connectStore({
-            profile: config.accountProfile,
-            externalId: profileAccountKey(config.accountProfile),
-            intent: "read",
-        });
-        if (!connection.meetingSemantic)
-            throw new ZoomError("configuration_error", "meeting vector capabilities are unavailable in this store connector");
-        return connection.meetingSemantic;
-    };
+    const meetingSemantic = async () => (await connected()).meetingSemantic;
     addMeetingSearchCommands(program, {
         signal,
         offline: () => Boolean(program.opts().offline),
-        output: integrationOutput,
-        words: async () => {
-            if (deps.meetingSearch)
-                return deps.meetingSearch;
-            const connected = await integrationConnection("meeting-search");
-            if (!connected.meetingSearch)
-                throw new ZoomError("configuration_error", "meeting search is unavailable in this store connector");
-            return connected.meetingSearch;
-        },
+        output,
+        words: async () => (await connected()).meetingSearch,
         meaning: meetingSemantic,
         archive: (deps.archiveTranscripts ?? { search: searchArchiveTranscripts }).search,
     });
@@ -855,14 +689,14 @@ export const createProgram = (deps) => {
         signal,
         offline: () => Boolean(program.opts().offline),
         receipt,
-        output: integrationOutput,
+        output,
         capabilities: meetingSemantic,
     });
     annotateMeetingCommands(program);
     const parseAsync = program.parseAsync.bind(program);
     program.parseAsync = async (...args) => {
         if (parsing)
-            throw new ZoomError("validation_error", "concurrent command parsing is unavailable");
+            throw new CliError("validation_error", "concurrent command parsing is unavailable");
         resetCliOptions(program);
         parsing = true;
         answerExitCodes.set(program, 0);
@@ -872,11 +706,12 @@ export const createProgram = (deps) => {
         activeTokens = undefined;
         watchConfig = undefined;
         watchSince = undefined;
-        fields = undefined;
+        const lifted = liftJsonFields(program, args);
+        fields = lifted.fields;
         let result = program;
         let failed = false;
         let failure;
-        const running = parseAsync(...args);
+        const running = parseAsync(...lifted.args);
         void running.catch(() => { });
         try {
             const active = currentExecution();
@@ -888,18 +723,18 @@ export const createProgram = (deps) => {
             failure = error;
         }
         finally {
-            if (connection) {
-                const closing = connection;
-                connection = undefined;
+            if (connecting) {
+                const closing = connecting;
+                connecting = undefined;
                 selectedStore = deps.store;
                 selectedAccountId = deps.accountId;
                 try {
-                    await closing.close();
+                    await (await closing.catch(() => undefined))?.close();
                 }
                 catch {
                     if (!failed) {
                         failed = true;
-                        failure = new ZoomError("configuration_error", "could not close the shared meeting store");
+                        failure = new CliError("configuration_error", "could not close the shared meeting store");
                     }
                 }
             }
@@ -941,9 +776,9 @@ export const run = async (args, deps) => {
         const failure = isCliError(error)
             ? error
             : unknownOutcome
-                ? new ZoomError("outcome_unknown", "operation outcome is unknown; verify stored state before retrying")
+                ? new CliError("outcome_unknown", "operation outcome is unknown; verify stored state before retrying")
                 : error instanceof CommanderError
-                    ? new ZoomError("validation_error", "command failed; use --help for usage")
+                    ? new CliError("validation_error", "command failed; use --help for usage")
                     : error;
         const selected = commandSelection(program, args);
         return reportFailure(failure, args, deps, selected.path, hostFailureContext(program, metaOf(selected.action).effects));