@wirecat/zoom-cli 0.1.1 → 0.2.1

package/dist/program.js

@@ -1,12 +1,22 @@
-import { MeetingError } from "@wirecat/cli-meetings";
+import { CliError, createDeadline, createRenderer, exitCodeFor, fieldsOf, GENERIC_FAILURE, projectFields, realSleep, } from "@wirecat/cli-core";
+import { importFiles, listed, MeetingError, pull } from "@wirecat/cli-meetings";
 import { addMeetingCommands } from "@wirecat/cli-meetings/cli";
 import { Command, CommanderError } from "commander";
+import { addZoomSkillCommands } from "./agent-skill.js";
 import { ZoomApiSource } from "./api.js";
+import { addArchiveCommands, } from "./archive-commands.js";
+import { readArchiveTranscripts, searchArchiveTranscripts } from "./archive-transcripts.js";
+import { addStandardCommands, annotateMeetingCommands } from "./commands.js";
 import { profileAccountKey, readConfig, setConfig } from "./config.js";
-import { ZoomError } from "./errors.js";
+import { checkCancelled, ZoomError } from "./errors.js";
+import { bytes, duration, resetCliOptions, startExecution } from "./execution.js";
 import { FilesSource, importFile, readDownloadedFiles, validateDownloadedFiles } from "./files.js";
 import { login } from "./login.js";
+import { getZoomProfile, inspectArchive, inspectArchiveLocks, recoverArchiveLocks, verifyArchive, ZoomRecordings, } from "./recordings.js";
+import { ZoomRemoteMeetings } from "./remote-meetings.js";
+import { emitReceipt } from "./streaming.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");
 };
@@ -25,17 +35,64 @@ const unavailableStore = {
     cursor: unavailable,
     setCursor: unavailable,
 };
-const render = (data, format) => {
-    if (format === "jsonl" && typeof data === "object" && data !== null && "items" in data && Array.isArray(data.items))
-        return data.items.map((row) => `${JSON.stringify(row)}\n`).join("");
-    return `${JSON.stringify(data, null, format === "text" ? 2 : undefined)}\n`;
+const render = (value, format, deps, fields) => {
+    if (fields)
+        value = projectFields(value, fields);
+    const chunks = [];
+    const renderer = createRenderer({
+        format: format === "text" ? (deps.outputIsTTY ? "pretty" : "json") : format,
+        color: false,
+        streams: { data: (text) => chunks.push(`${text}\n`), diagnostic: deps.diagnostic },
+    });
+    if (format === "jsonl" &&
+        typeof value === "object" &&
+        value !== null &&
+        "items" in value &&
+        Array.isArray(value.items))
+        renderer.stream(value.items);
+    else
+        renderer.result(value);
+    return chunks.join("");
 };
 export const createProgram = (deps) => {
     let config;
     const getConfig = () => (config ??= readConfig(deps.configPath));
     let connection;
     let parsing = false;
-    let meetingOutput = [];
+    let execution;
+    let fields;
+    let activeTokens;
+    const currentExecution = () => execution;
+    const signal = () => currentExecution()?.deadline.signal ?? deps.signal;
+    const fetchWithSignal = (fetcher) => (input, init) => {
+        checkCancelled(signal());
+        if (program.opts().offline)
+            throw new ZoomError("configuration_error", "the command requires network access; remove --offline");
+        const operation = signal();
+        return fetcher(input, {
+            ...init,
+            signal: operation && init?.signal ? AbortSignal.any([operation, init.signal]) : (operation ?? init?.signal),
+        });
+    };
+    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");
+        execution.output.data(text);
+    };
+    const guardedStore = (store) => new Proxy(store, {
+        get(target, key, receiver) {
+            const method = Reflect.get(target, key, receiver);
+            return typeof method === "function"
+                ? async (...args) => {
+                    checkCancelled(signal());
+                    const result = await method.apply(target, args);
+                    checkCancelled(signal());
+                    return result;
+                }
+                : method;
+        },
+    });
     let selectedStore = deps.store;
     let selectedAccountId = deps.accountId;
     const requireAccount = () => {
@@ -50,15 +107,47 @@ export const createProgram = (deps) => {
         .option("--json", "one JSON value")
         .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 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")
         .exitOverride()
         .configureOutput({ writeOut: deps.data, writeErr: deps.diagnostic, outputError: () => { } });
+    const api = () => {
+        if (program.opts().offline)
+            throw new ZoomError("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");
+    };
     program.hook("preAction", async (_root, action) => {
-        const config = getConfig();
         const opts = action.optsWithGlobals();
         if (opts.json && opts.jsonl)
             throw new ZoomError("validation_error", "choose --json or --jsonl");
-        if (action.name() === "login" || action.parent?.name() === "config")
+        fields = opts.fields === undefined ? undefined : fieldsOf(opts.fields);
+        execution = startExecution(action, { signal: deps.signal, sleep: deps.sleep });
+        checkCancelled(signal());
+        let family = action;
+        while (family.parent && family.parent !== program)
+            family = family.parent;
+        if ([
+            "login",
+            "commands",
+            "complete",
+            "doctor",
+            "config",
+            "session",
+            "recordings",
+            "remote-meetings",
+            "serve",
+            "skill",
+            "watch",
+        ].includes(family.name()))
             return;
+        const config = getConfig();
+        if (opts.offline && action.name() === "pull" && config.source === "api" && !deps.source)
+            throw new ZoomError("configuration_error", "API pull requires network access; remove --offline");
         if (!selectedStore) {
             if (!deps.connectStore)
                 return unavailable();
@@ -81,7 +170,32 @@ export const createProgram = (deps) => {
         }
         requireAccount();
     });
-    const output = (value) => deps.data(render(value, program.opts().json ? "json" : program.opts().jsonl ? "jsonl" : "text"));
+    const output = (value) => buffer(render(value, program.opts().json ? "json" : program.opts().jsonl ? "jsonl" : "text", deps, fields));
+    const outputItems = async (values) => {
+        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":[');
+        for await (const value of values) {
+            checkCancelled(signal());
+            const projected = fields ? projectFields(listed([value]), fields).items[0] : value;
+            if (format === "json") {
+                if (count)
+                    buffer(",");
+                buffer(render(projected, "json", deps).trimEnd());
+            }
+            else
+                buffer(render(projected, format, deps));
+            count++;
+        }
+        metadata.limit = count;
+        if (format === "json")
+            buffer(`],${JSON.stringify(metadata).slice(1)}\n`);
+        else if (format === "text")
+            buffer(render(count ? metadata : listed([]), "text", deps));
+    };
     const cfg = program.command("config").description("local Zoom configuration");
     cfg
         .command("show")
@@ -105,13 +219,25 @@ export const createProgram = (deps) => {
         const config = getConfig();
         if (!config.clientId)
             throw new ZoomError("configuration_error", "run zm config set zoom.clientId <Public Client ID> first");
-        if (program.opts().input === false)
+        const globals = program.opts();
+        if (globals.offline)
+            throw new ZoomError("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({
-            tokens: deps.tokens,
+            tokens: tokens(),
+            signal: signal(),
             openBrowser: (url) => deps.openBrowser(url, opts.browser),
             readPaste: deps.readPaste,
-            showUrl: (url) => deps.diagnostic(`Open this URL to approve Zoom login:\n${url}\n`),
+            showUrl: (url) => {
+                if (!program.opts().quiet)
+                    deps.diagnostic(`Open this URL to approve Zoom login:\n${url}\n`);
+            },
         }));
     });
     let activeSource;
@@ -121,7 +247,7 @@ export const createProgram = (deps) => {
         activeSource ??= (async () => {
             const config = getConfig();
             if (config.source === "api")
-                return new ZoomApiSource(deps.tokens, deps.fetch);
+                return new ZoomApiSource(tokens(), fetchWithSignal(deps.fetch));
             if (!config.filesFolder)
                 throw new ZoomError("configuration_error", "set files.folder before pulling from files");
             return new FilesSource(await (deps.readFiles ?? readDownloadedFiles)(config.filesFolder), config.filesTimezone);
@@ -157,9 +283,9 @@ export const createProgram = (deps) => {
             return (await getSource()).files(id);
         },
     };
-    addMeetingCommands(program, {
+    const meetingCommands = {
         get store() {
-            return selectedStore ?? unavailableStore;
+            return guardedStore(selectedStore ?? unavailableStore);
         },
         rootIngestion: true,
         get accountId() {
@@ -172,24 +298,305 @@ export const createProgram = (deps) => {
         },
         now: deps.now,
         write: (value, format) => {
-            meetingOutput.push(render(value, format));
+            buffer(render(value, format, deps, fields));
+        },
+        writeFile: deps.writeFile
+            ? async (path, content) => {
+                checkCancelled(signal());
+                await deps.writeFile?.(path, content, { signal: signal() });
+                checkCancelled(signal());
+            }
+            : undefined,
+    };
+    addMeetingCommands(program, meetingCommands);
+    addStandardCommands(program, {
+        output,
+        discovery: (value) => buffer(render(value, program.opts().json ? "json" : program.opts().jsonl ? "jsonl" : "text", deps)),
+        fields: () => fields,
+        raw: buffer,
+        doctor: () => {
+            const config = getConfig();
+            return {
+                version: VERSION,
+                runtime: { node: process.versions.node },
+                config: { readable: true, path: deps.configPath, source: config.source },
+                dataProfile: config.accountProfile,
+                authentication: { configured: config.clientId !== null, state: "not_checked" },
+                database: "not_checked",
+            };
+        },
+        sessionStatus: async (check) => {
+            const config = getConfig();
+            if (!config.clientId)
+                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");
+                api();
+                return {
+                    configured: true,
+                    state: "verified",
+                    dataProfile: config.accountProfile,
+                    verified: true,
+                    profile: await (deps.checkSession
+                        ? deps.checkSession({ signal: signal() })
+                        : getZoomProfile(tokens(), fetchWithSignal(deps.fetch), { signal: signal() })),
+                };
+            }
+            const saved = deps.tokens.load();
+            return {
+                configured: true,
+                state: saved ? (saved.expiresAt > (deps.now?.() ?? Date.now()) ? "saved" : "expired") : "missing",
+                dataProfile: config.accountProfile,
+                verified: false,
+                ...(saved ? { expiresAt: saved.expiresAt, scopes: saved.scopes } : {}),
+            };
+        },
+    });
+    let watchConfig;
+    let watchSince;
+    const watchSleep = deps.sleep;
+    const receipt = async (value) => {
+        const text = render(value, program.opts().jsonl ? "jsonl" : "text", deps, fields);
+        const operation = signal();
+        const grace = operation.aborted ? createDeadline({ timeoutMs: 1000 }) : undefined;
+        try {
+            await emitReceipt(text, program.opts().maxOutputBytes, async (serialized) => {
+                if (deps.streamData)
+                    await deps.streamData(serialized, grace?.signal ?? operation);
+                else
+                    deps.data(serialized);
+            });
+        }
+        finally {
+            grace?.dispose();
+        }
+    };
+    addWatchCommand(program, {
+        signal: () => signal(),
+        receipt,
+        outputIsTTY: deps.outputIsTTY,
+        sleep: watchSleep ? (ms, abort) => watchSleep(ms, abort, "retry") : undefined,
+        prepare: (folder, flags) => {
+            const config = { ...getConfig() };
+            const source = flags.source ?? (folder !== undefined ? "files" : config.source);
+            const plan = {
+                source,
+                since: flags.since,
+                lookbackDays: flags.lookbackDays ?? 0,
+                intervalMs: flags.interval,
+                folder: folder ?? config.filesFolder ?? undefined,
+            };
+            if (source === "files") {
+                if (flags.since !== undefined || flags.lookbackDays !== undefined)
+                    throw new ZoomError("validation_error", "since 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");
+            }
+            else {
+                if (folder !== undefined)
+                    throw new ZoomError("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");
+                if (!deps.source) {
+                    if (!config.clientId)
+                        throw new ZoomError("configuration_error", "run zm config set zoom.clientId <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");
+                }
+            }
+            if (!deps.store && !config.accountProfile)
+                throw new ZoomError("configuration_error", "select a local profile with zm config set account.profile <label>");
+            watchConfig = config;
+            watchSince = plan.since;
+            return plan;
         },
+        ingest: async (plan, operation) => {
+            checkCancelled(operation);
+            const config = watchConfig;
+            if (!config)
+                throw new ZoomError("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 (error instanceof CliError || error instanceof MeetingError)
+                            throw error;
+                        throw new ZoomError("configuration_error", "could not open the shared meeting store");
+                    }
+                }
+                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");
+                const store = guardedStore(cycle?.store ?? deps.store ?? unavailableStore);
+                if (plan.source === "files") {
+                    const files = validateDownloadedFiles(await (deps.readFiles ?? readDownloadedFiles)(plan.folder ?? ""), config.filesTimezone);
+                    checkCancelled(operation);
+                    result = await importFiles(files.map((file) => importFile(file, accountId, config.filesTimezone)), store, deps.now?.());
+                }
+                else {
+                    const original = deps.source ??
+                        new ZoomApiSource(tokens(), fetchWithSignal(deps.fetch), {
+                            now: deps.now,
+                            sleep: (ms, abort) => (deps.sleep ?? realSleep)(ms, AbortSignal.any([operation, abort]), "retry"),
+                        });
+                    let sourceFailure;
+                    const source = new Proxy(original, {
+                        get(target, key, receiver) {
+                            const method = Reflect.get(target, key, receiver);
+                            return typeof method === "function"
+                                ? async (...args) => {
+                                    if (sourceFailure)
+                                        throw sourceFailure;
+                                    checkCancelled(operation);
+                                    try {
+                                        const value = await method.apply(target, args);
+                                        checkCancelled(operation);
+                                        return value;
+                                    }
+                                    catch (error) {
+                                        if (error instanceof CliError && error.code === "outcome_unknown") {
+                                            sourceFailure = error;
+                                            throw error;
+                                        }
+                                        checkCancelled(operation);
+                                        throw error;
+                                    }
+                                }
+                                : method;
+                        },
+                    });
+                    let cursorAdvanced = false;
+                    const trackingStore = new Proxy(store, {
+                        get(target, key, receiver) {
+                            if (key === "setCursor")
+                                return async (...args) => {
+                                    await target.setCursor(...args);
+                                    cursorAdvanced = true;
+                                };
+                            return Reflect.get(target, key, receiver);
+                        },
+                    });
+                    result = await pull(source, trackingStore, {
+                        accountId,
+                        since: watchSince,
+                        lookbackMs: plan.lookbackDays * 86400000,
+                        now: deps.now?.(),
+                    });
+                    if (sourceFailure)
+                        throw sourceFailure;
+                    checkCancelled(operation);
+                    if (cursorAdvanced)
+                        watchSince = undefined;
+                }
+            }
+            catch (error) {
+                failure = error;
+            }
+            finally {
+                if (cycle) {
+                    try {
+                        await cycle.close();
+                    }
+                    catch {
+                        failure ??= new ZoomError("configuration_error", "could not close the shared meeting store");
+                    }
+                }
+            }
+            if (failure)
+                throw failure;
+            if (!result)
+                return unavailable();
+            return result;
+        },
+    });
+    const retrySleep = deps.sleep;
+    const remoteOptions = {
+        now: deps.now,
+        sleep: retrySleep ? (ms, abort) => retrySleep(ms, abort, "retry") : undefined,
+    };
+    addArchiveCommands(program, {
+        output,
+        outputItems,
+        transcripts: deps.archiveTranscripts ?? { read: readArchiveTranscripts, search: searchArchiveTranscripts },
+        receipt,
+        outputIsTTY: deps.outputIsTTY,
+        api,
+        signal,
+        now: deps.now ?? Date.now,
+        recordings: () => deps.recordings ?? new ZoomRecordings(tokens(), fetchWithSignal(deps.fetch), remoteOptions),
+        remoteMeetings: () => deps.remoteMeetings ?? new ZoomRemoteMeetings(tokens(), fetchWithSignal(deps.fetch), remoteOptions),
+        archive: deps.archive ?? {
+            inspect: inspectArchive,
+            verify: verifyArchive,
+            locks: inspectArchiveLocks,
+            recover: recoverArchiveLocks,
+        },
+    });
+    addZoomSkillCommands(program, () => {
+        const renderer = createRenderer({
+            format: program.opts().json ? "json" : program.opts().jsonl ? "jsonl" : deps.outputIsTTY ? "pretty" : "json",
+            color: false,
+            quiet: Boolean(program.opts().quiet),
+            streams: { data: buffer, diagnostic: deps.diagnostic },
+        });
+        return {
+            renderer: { ...renderer, result: output, stream: (items) => output({ items: [...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")
+        .action(async () => {
+        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");
+        await deps.serveMcp({ signal: signal(), maxResultBytes: program.opts().maxOutputBytes });
+    });
+    annotateMeetingCommands(program);
     const parseAsync = program.parseAsync.bind(program);
     program.parseAsync = async (...args) => {
         if (parsing)
             throw new ZoomError("validation_error", "concurrent command parsing is unavailable");
+        resetCliOptions(program);
         parsing = true;
         config = undefined;
         activeSource = undefined;
-        meetingOutput = [];
+        execution = undefined;
+        activeTokens = undefined;
+        watchConfig = undefined;
+        watchSince = undefined;
+        fields = undefined;
         let result = program;
         let failed = false;
         let failure;
+        const running = parseAsync(...args);
+        void running.catch(() => { });
         try {
-            result = await parseAsync(...args);
+            const active = currentExecution();
+            result = active ? await active.deadline.race(() => running) : await running;
         }
         catch (error) {
+            await running.catch(() => { });
             failed = true;
             failure = error;
         }
@@ -210,14 +617,23 @@ export const createProgram = (deps) => {
                 }
             }
         }
+        if (!failed) {
+            try {
+                checkCancelled(signal());
+            }
+            catch (error) {
+                failed = true;
+                failure = error;
+            }
+        }
+        currentExecution()?.deadline.dispose();
         parsing = false;
         if (failed) {
-            meetingOutput = [];
+            currentExecution()?.output.discard();
             throw failure;
         }
-        for (const text of meetingOutput)
-            deps.data(text);
-        meetingOutput = [];
+        currentExecution()?.output.flush(deps.data);
+        execution = undefined;
         return result;
     };
     return program;
@@ -233,28 +649,11 @@ export const run = async (args, deps) => {
             "code" in error &&
             ["commander.helpDisplayed", "commander.help", "commander.version"].includes(String(error.code)))
             return 0;
-        const code = error instanceof ZoomError || error instanceof MeetingError
-            ? error.code
-            : error instanceof CommanderError
-                ? "validation_error"
-                : "generic_failure";
-        const message = error instanceof ZoomError || error instanceof MeetingError
-            ? error.message
-            : "command failed; use --help for usage";
+        const typed = error instanceof CliError || error instanceof MeetingError;
+        const code = typed ? error.code : error instanceof CommanderError ? "validation_error" : "generic_failure";
+        const message = typed ? error.message : "command failed; use --help for usage";
         deps.diagnostic(`${JSON.stringify({ error: { code, message } })}\n`);
-        return code === "configuration_error"
-            ? 3
-            : code === "authentication_error"
-                ? 4
-                : code === "provider_error"
-                    ? 11
-                    : code === "invalid_response"
-                        ? 13
-                        : code === "not_found"
-                            ? 6
-                            : code === "generic_failure"
-                                ? 1
-                                : 2;
+        return code === "generic_failure" ? GENERIC_FAILURE : exitCodeFor(code);
     }
 };
 //# sourceMappingURL=program.js.map