@bli-cockpit/cli 0.2.119 → 0.2.121

package/dist/commands/correct.js

@@ -37,11 +37,22 @@ export async function runCorrect(command, io) {
         writeFailure(command, io, "no_correction_text", 'Say what is wrong: `cockpit correct --claim <id> --text "..."`, or pipe it in on stdin.');
         return 1;
     }
+    const selection = await readBriefClaim(command, io, dashboardUrl, session.device_token, log);
+    if (!selection)
+        return 1;
+    const filed = await fileCorrection(command, io, dashboardUrl, session.device_token, log, selection, text);
+    if (!filed)
+        return 1;
+    printFiledCorrection(command, io, filed);
+    logFiledCorrection(command, io, filed, selection.claim, text, startedAt);
+    return 0;
+}
+async function readBriefClaim(command, io, dashboardUrl, deviceToken, log) {
     // Step one: which page, whose, and does that line exist.
     const read = await towerJsonRequest({
         dashboardUrl,
         path: `/api/jarvis/brief${briefQuery(command)}`,
-        deviceToken: session.device_token,
+        deviceToken,
         fetch: io.fetch,
         method: "GET",
         label: "correct:brief",
@@ -50,62 +61,69 @@ export async function runCorrect(command, io) {
     });
     if (!read.ok) {
         writeFailure(command, io, read.reason, read.detail);
-        return 1;
+        return null;
     }
     const brief = read.body;
     const personId = brief.page?.personId;
     if (!brief.ok || !personId) {
         writeFailure(command, io, brief.error ?? "no_page", brief.reply ?? "There is no page to correct.");
-        return 1;
+        return null;
     }
     const claim = (brief.claims ?? []).find((candidate) => candidate.claimId === command.claimId);
     if (!claim) {
         writeFailure(command, io, "unknown_claim", `That page has no line called “${command.claimId}”. Run \`cockpit brief --claims\` to see the ids.`);
-        return 1;
+        return null;
     }
+    return { brief, personId, claim };
+}
+async function fileCorrection(command, io, dashboardUrl, deviceToken, log, selection, text) {
     // Step two: the same door the panel's form posts to.
     const written = await towerJsonRequest({
         dashboardUrl,
         path: "/api/jarvis/corrections",
-        deviceToken: session.device_token,
+        deviceToken,
         fetch: io.fetch,
         label: "correct",
         timeoutMs: REQUEST_DEADLINE_MS,
         log,
         body: {
-            personId,
-            pageId: brief.page?.pageId ?? null,
+            personId: selection.personId,
+            pageId: selection.brief.page?.pageId ?? null,
             claimId: command.claimId,
             // The line as it reads now, so the ledger records what was disputed and
             // the live check has the sentence to work from.
-            quotedText: claim.text ?? null,
+            quotedText: selection.claim.text ?? null,
             correctionText: text,
-            contextLinks: claim.links ?? [],
+            contextLinks: selection.claim.links ?? [],
             clauseOnPage: true,
-            clauseIsObserved: Boolean(claim.observed),
+            clauseIsObserved: Boolean(selection.claim.observed),
             ...(command.supersedes ? { supersedes: command.supersedes } : {}),
         },
     });
     if (!written.ok) {
         writeFailure(command, io, written.reason, written.detail);
-        return 1;
+        return null;
     }
     const filed = written.body;
     if (!filed.correctionId) {
         writeFailure(command, io, "not_filed", filed.error ?? "Tower did not record that correction.");
-        return 1;
+        return null;
     }
+    return filed;
+}
+function printFiledCorrection(command, io, filed) {
     if (command.json) {
         writeLine(io.stdout, JSON.stringify({ ok: true, ...filed }));
+        return;
     }
-    else {
-        const styled = colorEnabled(io);
-        writeLine(io.stdout, filed.reply ?? "Filed.");
-        if (filed.finding)
-            writeLine(io.stdout, dim(`The record says: ${filed.finding}`, styled));
-        if (filed.link)
-            writeLine(io.stdout, dim(filed.link, styled));
-    }
+    const styled = colorEnabled(io);
+    writeLine(io.stdout, filed.reply ?? "Filed.");
+    if (filed.finding)
+        writeLine(io.stdout, dim(`The record says: ${filed.finding}`, styled));
+    if (filed.link)
+        writeLine(io.stdout, dim(filed.link, styled));
+}
+function logFiledCorrection(command, io, filed, claim, text, startedAt) {
     writeLine(io.stderr, `[correct cli] filed ${JSON.stringify({
         tier: filed.tier ?? null,
         outcome: filed.outcome ?? null,
@@ -117,7 +135,6 @@ export async function runCorrect(command, io) {
         text_length: text.length,
         elapsed_ms: Date.now() - startedAt,
     })}`);
-    return 0;
 }
 function briefQuery(command) {
     const params = new URLSearchParams({ claims: "1" });

package/dist/commands/docs.js

@@ -225,8 +225,19 @@ async function updateDoc(command, door) {
         && !command.clearParent) {
         return failAgentDoor(door, TAG, "invalid_body", "docs update needs at least one of --title, --visibility, --parent/--clear-parent, or a body on --body-stdin/--file.");
     }
-    const answer = await askAgentDoor(door, {
-        path: `/api/docs/documents/${encodeURIComponent(resolved.id)}`,
+    const answer = await updateDocument(command, door, resolved.id, bodyMarkdown);
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const document = answer.body.document ?? {};
+    writeLine(door.io.stderr, `${TAG} updated ${JSON.stringify({ document_id: document["id"] ?? resolved.id })}`);
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, document });
+    writeLine(door.io.stdout, `Updated ${String(document["title"] ?? "")} (${String(document["id"] ?? resolved.id)}).`);
+    return 0;
+}
+async function updateDocument(command, door, documentId, bodyMarkdown) {
+    return askAgentDoor(door, {
+        path: `/api/docs/documents/${encodeURIComponent(documentId)}`,
         method: "PATCH",
         label: "docs update",
         timeoutMs: WRITE_DEADLINE_MS,
@@ -242,12 +253,4 @@ async function updateDoc(command, door) {
             ...(command.allowEmpty ? { allow_empty: true } : {}),
         },
     });
-    if (!answer.ok)
-        return failAgentDoor(door, TAG, answer.reason, answer.detail);
-    const document = answer.body.document ?? {};
-    writeLine(door.io.stderr, `${TAG} updated ${JSON.stringify({ document_id: document["id"] ?? resolved.id })}`);
-    if (door.json)
-        return emitAgentDoor(door, { ok: true, document });
-    writeLine(door.io.stdout, `Updated ${String(document["title"] ?? "")} (${String(document["id"] ?? resolved.id)}).`);
-    return 0;
 }

package/dist/commands/editor.js

@@ -105,14 +105,32 @@ export async function editInEditor(options) {
     const platform = options.platform ?? process.platform;
     const log = options.log ?? ((line) => console.error(line));
     const chosen = resolveEditorCommand(options.env, platform);
-    if (!chosen) {
-        return {
-            ok: false,
-            reason: "no_editor_configured",
-            detail: "No editor is configured. Set EDITOR (or VISUAL) — for example `export EDITOR=nano` — " +
-                "or pipe the edited page in on stdin instead.",
-        };
+    if (!chosen)
+        return noEditorConfigured();
+    const unavailable = invalidWindowsEditorReason(chosen, platform);
+    if (unavailable)
+        return unavailable;
+    const scratch = await writeEditorScratchFile(options);
+    if (!scratch.ok)
+        return scratch;
+    try {
+        return await runEditorSession(options, chosen, scratch.file, log);
     }
+    finally {
+        // Whatever happened. The page is not a secret, but it is somebody's writing
+        // and it does not belong in /tmp after the command returns.
+        await removeEditorScratchDirectory(scratch.directory);
+    }
+}
+function noEditorConfigured() {
+    return {
+        ok: false,
+        reason: "no_editor_configured",
+        detail: "No editor is configured. Set EDITOR (or VISUAL) — for example `export EDITOR=nano` — " +
+            "or pipe the edited page in on stdin instead.",
+    };
+}
+function invalidWindowsEditorReason(chosen, platform) {
     // A `.cmd` or `.bat` is a batch script; Node cannot execute one without
     // handing the whole line to cmd.exe, and that is the one thing this module
     // will not do with a person's own path in it.
@@ -125,12 +143,14 @@ export async function editInEditor(options) {
                 "notepad, or the full path to Code.exe.",
         };
     }
-    let directory;
-    let file;
+    return null;
+}
+async function writeEditorScratchFile(options) {
     try {
-        directory = await mkdtemp(join(tmpdir(), "cockpit-brief-"));
-        file = join(directory, `brief-${randomBytes(4).toString("hex")}${options.suffix ?? ".md"}`);
+        const directory = await mkdtemp(join(tmpdir(), "cockpit-brief-"));
+        const file = join(directory, `brief-${randomBytes(4).toString("hex")}${options.suffix ?? ".md"}`);
         await writeFile(file, options.contents, "utf8");
+        return { ok: true, directory, file };
     }
     catch (error) {
         return {
@@ -139,13 +159,11 @@ export async function editInEditor(options) {
             detail: `The page could not be written to a scratch file (${messageOf(error)}).`,
         };
     }
+}
+async function runEditorSession(options, chosen, file, log) {
     try {
         const spawn = options.spawn ?? spawnSync;
-        log(`[brief edit] editor opening ${JSON.stringify({
-            program: basenameOf(chosen.program),
-            extra_args: chosen.args.length,
-            bytes: Buffer.byteLength(options.contents, "utf8"),
-        })}`);
+        reportEditorOpening(log, chosen, options.contents);
         // `stdio: "inherit"` hands the terminal over: a full-screen editor needs the
         // real tty. `shell: false` is the default and is stated to make the rule
         // above impossible to lose in a refactor.
@@ -170,12 +188,8 @@ export async function editInEditor(options) {
                     "Nothing has been sent to Tower.",
             };
         }
-        const text = stripLeadingBom(await readFile(file, "utf8"));
-        log(`[brief edit] editor closed ${JSON.stringify({
-            program: basenameOf(chosen.program),
-            status: result.status ?? null,
-            bytes: Buffer.byteLength(text, "utf8"),
-        })}`);
+        const text = await readEditedText(file);
+        reportEditorClosed(log, chosen, result.status, text);
         return { ok: true, text, program: basenameOf(chosen.program) };
     }
     catch (error) {
@@ -185,14 +199,29 @@ export async function editInEditor(options) {
             detail: `The edited page could not be read back (${messageOf(error)}).`,
         };
     }
-    finally {
-        // Whatever happened. The page is not a secret, but it is somebody's writing
-        // and it does not belong in /tmp after the command returns.
-        await rm(directory, { recursive: true, force: true }).catch(() => {
-            // Deliberately silent: the temp directory is the OS's to reap, and a
-            // failure to remove it must not turn a saved edit into a failed command.
-        });
-    }
+}
+function reportEditorOpening(log, chosen, contents) {
+    log(`[brief edit] editor opening ${JSON.stringify({
+        program: basenameOf(chosen.program),
+        extra_args: chosen.args.length,
+        bytes: Buffer.byteLength(contents, "utf8"),
+    })}`);
+}
+async function readEditedText(file) {
+    return stripLeadingBom(await readFile(file, "utf8"));
+}
+function reportEditorClosed(log, chosen, status, text) {
+    log(`[brief edit] editor closed ${JSON.stringify({
+        program: basenameOf(chosen.program),
+        status,
+        bytes: Buffer.byteLength(text, "utf8"),
+    })}`);
+}
+async function removeEditorScratchDirectory(directory) {
+    await rm(directory, { recursive: true, force: true }).catch(() => {
+        // Deliberately silent: the temp directory is the OS's to reap, and a
+        // failure to remove it must not turn a saved edit into a failed command.
+    });
 }
 /** The program's own name, never the directories around it. */
 function basenameOf(program) {

package/dist/commands/install-receipts.js

@@ -48,6 +48,17 @@ export function sanitizeInstallErrorCode(value) {
 export async function reportInstallEventsBestEffort(options) {
     if (options.events.length === 0)
         return null;
+    if (shouldWithholdDevBuildReceipts(options))
+        return null;
+    const paths = getCollectorRuntimePaths(options.homeDir);
+    if (!(await queueInstallEvents(options, paths)))
+        return null;
+    const session = await readLocalCollectorSessionFile(paths).catch(() => null);
+    if (!hasValidInstallEventSession(session))
+        return null;
+    return deliverPendingInstallEvents(options, paths, session.device_token);
+}
+function shouldWithholdDevBuildReceipts(options) {
     // BLI-3554. Withheld BEFORE the outbox, not before the POST: an entry queued
     // by a checkout survives in `~/.cockpit` and the next real scheduled tick
     // would deliver it under the workspace version, which is exactly how 47
@@ -65,32 +76,18 @@ export async function reportInstallEventsBestEffort(options) {
             cli_version: LOCAL_COLLECTOR_VERSION,
             fix: "set COCKPIT_DEV=0 to post receipts from a checkout deliberately",
         }));
-        return null;
+        return true;
     }
-    const paths = getCollectorRuntimePaths(options.homeDir);
+    return suppression.suppressed;
+}
+async function queueInstallEvents(options, paths) {
     try {
         await enqueueInstallEventEntry(paths, {
             dashboardUrl: options.dashboardUrl,
             cliVersion: LOCAL_COLLECTOR_VERSION,
             command: options.command,
             osPlatform: os.platform(),
-            events: options.events.map((event) => ({
-                step: event.step.trim().slice(0, 120),
-                status: event.status,
-                ...(event.error_code
-                    ? { error_code: sanitizeInstallErrorCode(event.error_code) }
-                    : {}),
-                // Already redacted and capped at the point it was produced; bounded
-                // again here because this mapping is what the server contract sees.
-                ...(event.error_detail
-                    ? {
-                        error_detail: event.error_detail
-                            .trim()
-                            .slice(0, SYNC_ERROR_DETAIL_MAX_CHARS),
-                    }
-                    : {}),
-                ...(event.at ? { at: event.at } : {}),
-            })),
+            events: options.events.map(normalizeInstallEvent),
         });
     }
     catch (error) {
@@ -107,90 +104,44 @@ export async function reportInstallEventsBestEffort(options) {
         if (options.json) {
             writeLine(options.io.stderr, "Install event outbox unavailable: local_write_failed");
         }
-        return null;
+        return false;
     }
-    const session = await readLocalCollectorSessionFile(paths).catch(() => null);
+    return true;
+}
+function normalizeInstallEvent(event) {
+    // Already redacted and capped at the point it was produced; bounded
+    // again here because this mapping is what the server contract sees.
+    const detail = event.error_detail?.trim().slice(0, SYNC_ERROR_DETAIL_MAX_CHARS);
+    const code = event.error_code ? sanitizeInstallErrorCode(event.error_code) : undefined;
+    return {
+        step: event.step.trim().slice(0, 120),
+        status: event.status,
+        ...(code ? { error_code: code } : {}),
+        ...(detail ? { error_detail: detail } : {}),
+        ...(event.at ? { at: event.at } : {}),
+    };
+}
+function hasValidInstallEventSession(session) {
     if (!session ||
         session.session_state !== "valid" ||
         typeof session.device_token !== "string" ||
         !session.device_token) {
-        return null;
+        return false;
     }
+    return true;
+}
+async function deliverPendingInstallEvents(options, paths, deviceToken) {
     const pending = (await readPendingInstallEventEntries(paths)).slice(0, 20);
     const failures = [];
     let delivered = 0;
     let observedMinCliVersion = null;
     for (let offset = 0; offset < pending.length; offset += 5) {
-        await Promise.all(pending.slice(offset, offset + 5).map(async (entry) => {
-            const controller = new AbortController();
-            const timeout = setTimeout(() => controller.abort(), 5_000);
-            try {
-                const response = await options.io.fetch(`${entry.dashboard_url}/api/ambient/install-events`, {
-                    method: "POST",
-                    headers: {
-                        "Content-Type": "application/json",
-                        Authorization: `Bearer ${session.device_token}`,
-                    },
-                    body: JSON.stringify({
-                        cli_version: entry.cli_version,
-                        command: entry.command,
-                        os_platform: entry.os_platform,
-                        events: entry.events,
-                    }),
-                    signal: controller.signal,
-                });
-                if (!response.ok) {
-                    throw new Error(`http_${response.status}`);
-                }
-                const receipt = (await response.json().catch((error) => {
-                    // This reply carries the server-published `min_cli_version` floor
-                    // (BLI-2678). A body that will not parse means the floor is not
-                    // observed on this tick and the forced-update path silently does
-                    // nothing — while the 2xx above says the receipt landed fine.
-                    console.error("[install-receipts] receipt body unreadable; no min_cli_version observed", JSON.stringify({
-                        reason: "receipt_body_unreadable",
-                        http_status: response.status,
-                        ...describeError(error),
-                    }));
-                    return null;
-                }));
-                if (typeof receipt?.min_cli_version === "string" &&
-                    receipt.min_cli_version.trim()) {
-                    observedMinCliVersion = receipt.min_cli_version.trim();
-                }
-                await removeInstallEventEntry(paths, entry.outbox_id);
+        await Promise.all(pending.slice(offset, offset + 5).map((entry) => deliverInstallEventEntry(options.io, paths, entry, deviceToken, failures).then((floor) => {
+            if (floor != null)
+                observedMinCliVersion = floor;
+            if (floor !== undefined)
                 delivered += 1;
-            }
-            catch (error) {
-                const failureReason = classifyInstallTelemetryError(error);
-                failures.push(failureReason);
-                // The classified reason is the coarse bucket the outbox row keeps;
-                // beside it, what actually happened. `network_error` covers DNS,
-                // TLS, timeout and abort, and only one of those is worth waking up
-                // for (BLI-3238).
-                console.error("[install-receipts] install event delivery failed, entry kept for retry", JSON.stringify({
-                    reason: failureReason,
-                    outbox_id: entry.outbox_id,
-                    ...describeError(error),
-                }));
-                await recordInstallEventAttemptFailure(paths, entry, {
-                    attemptedAt: new Date().toISOString(),
-                    failureReason,
-                }).catch((writeError) => {
-                    // Double failure: delivery failed AND the retry bookkeeping did.
-                    // The entry stays queued, so nothing is lost, but the attempt
-                    // count stops advancing and the outbox looks stuck for no reason.
-                    console.error("[install-receipts] could not record the delivery failure against the entry", JSON.stringify({
-                        reason: "attempt_bookkeeping_failed",
-                        outbox_id: entry.outbox_id,
-                        ...describeError(writeError),
-                    }));
-                });
-            }
-            finally {
-                clearTimeout(timeout);
-            }
-        }));
+        })));
     }
     if (delivered > 0) {
         // The success branch says so too (BLI-3554 / the logging contract): a log
@@ -209,6 +160,70 @@ export async function reportInstallEventsBestEffort(options) {
     }
     return observedMinCliVersion;
 }
+async function deliverInstallEventEntry(io, paths, entry, deviceToken, failures) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5_000);
+    try {
+        const response = await postInstallEventEntry(io, entry, deviceToken, controller.signal);
+        const floor = await readObservedMinCliVersion(response);
+        await removeInstallEventEntry(paths, entry.outbox_id);
+        return floor;
+    }
+    catch (error) {
+        await keepFailedInstallEventEntry(paths, entry, error, failures);
+        return undefined;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function postInstallEventEntry(io, entry, deviceToken, signal) {
+    const response = await io.fetch(`${entry.dashboard_url}/api/ambient/install-events`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${deviceToken}` },
+        body: JSON.stringify({
+            cli_version: entry.cli_version,
+            command: entry.command,
+            os_platform: entry.os_platform,
+            events: entry.events,
+        }),
+        signal,
+    });
+    if (!response.ok)
+        throw new Error(`http_${response.status}`);
+    return response;
+}
+async function readObservedMinCliVersion(response) {
+    const receipt = (await response.json().catch((error) => {
+        // This reply carries the server-published `min_cli_version` floor
+        // (BLI-2678). A body that will not parse means the floor is not
+        // observed on this tick and the forced-update path silently does
+        // nothing — while the 2xx above says the receipt landed fine.
+        console.error("[install-receipts] receipt body unreadable; no min_cli_version observed", JSON.stringify({ reason: "receipt_body_unreadable", http_status: response.status, ...describeError(error) }));
+        return null;
+    }));
+    return typeof receipt?.min_cli_version === "string" && receipt.min_cli_version.trim()
+        ? receipt.min_cli_version.trim()
+        : null;
+}
+async function keepFailedInstallEventEntry(paths, entry, error, failures) {
+    const failureReason = classifyInstallTelemetryError(error);
+    failures.push(failureReason);
+    // The classified reason is the coarse bucket the outbox row keeps;
+    // beside it, what actually happened. `network_error` covers DNS,
+    // TLS, timeout and abort, and only one of those is worth waking up
+    // for (BLI-3238).
+    console.error("[install-receipts] install event delivery failed, entry kept for retry", JSON.stringify({ reason: failureReason, outbox_id: entry.outbox_id, ...describeError(error) }));
+    await recordInstallEventAttemptFailure(paths, entry, {
+        attemptedAt: new Date().toISOString(),
+        failureReason,
+    }).catch((writeError) => {
+        // Double failure: delivery failed AND the retry bookkeeping did.
+        // The entry stays queued, so nothing is lost, but the attempt
+        // count stops advancing and the outbox looks stuck for no reason.
+        console.error("[install-receipts] could not record the delivery failure against the entry", JSON.stringify({ reason: "attempt_bookkeeping_failed", outbox_id: entry.outbox_id, ...describeError(writeError) }));
+    });
+}
 function classifyInstallTelemetryError(error) {
     if (error instanceof Error && error.name === "AbortError") {
         return "timeout";

package/dist/commands/local-args-tower-admin.js

@@ -89,6 +89,8 @@ export function parseOpsArgs(args) {
             // BLI-3912: one line per model — latency, tokens/s, today's spend, last
             // probe verdict. A SECOND door like --memory, asked for only when named.
             "--models",
+            "--turns",
+            "--tool-router",
             "--person",
             "--dry-run",
             "--json",
@@ -130,6 +132,8 @@ export function parseOpsArgs(args) {
             skips: values.booleans.has("--skips"),
             memory: values.booleans.has("--memory") || memoryDays !== undefined,
             models: values.booleans.has("--models"),
+            turns: values.booleans.has("--turns"),
+            toolRouter: values.booleans.has("--tool-router"),
             ...(memoryDays === undefined ? {} : { memoryDays: Number(memoryDays) }),
             ...base,
         };

package/dist/commands/local-args-tower-cal.js

@@ -77,12 +77,25 @@ export function parseCalArgs(args) {
             "--attendee",
         ],
     });
+    const { action, rest } = readCalAction(values);
+    const { subject, query } = readCalSubjectOrQuery(action, rest);
+    const { title, startsAt, endsAt } = readCalCreateDetails(action, values);
+    validateCalSharing(action, values);
+    // Read in the order the flags have always been checked, so a caller who got
+    // two of them wrong is told about --limit first, as before.
+    const limit = optionalPositiveInteger(values.flags.get("--limit"), "--limit");
+    const offset = readCalOffset(values);
+    return buildCalCommand(values, action, subject, query, title, startsAt, endsAt, offset, limit);
+}
+function readCalAction(values) {
     const first = values.positionals[0];
     const action = (first === undefined ? "today" : first);
     if (!CAL_ACTIONS.has(action)) {
         throw new Error(`Unknown cal command: ${first}. Try today, week, next, find, calendars, add-ical, create, share, detach, or sync.`);
     }
-    const rest = values.positionals.slice(first === undefined ? 0 : 1);
+    return { action, rest: values.positionals.slice(first === undefined ? 0 : 1) };
+}
+function readCalSubjectOrQuery(action, rest) {
     let subject;
     let query;
     if (CAL_ACTIONS_NEEDING_A_SUBJECT.has(action)) {
@@ -100,6 +113,9 @@ export function parseCalArgs(args) {
     else if (rest.length > 0) {
         throw new Error(`cal ${action} does not take "${rest[0]}".`);
     }
+    return { subject, query };
+}
+function readCalCreateDetails(action, values) {
     const title = optionalNonEmpty(values.flags.get("--title"));
     const startsAt = optionalNonEmpty(values.flags.get("--at"));
     const endsAt = optionalNonEmpty(values.flags.get("--until"));
@@ -114,15 +130,24 @@ export function parseCalArgs(args) {
         if (!endsAt)
             throw new Error("cal create needs --until <when it ends>.");
     }
-    if (action === "share" && !values.booleans.has("--org-visible") && !values.booleans.has("--private")) {
+    return { title, startsAt, endsAt };
+}
+function validateCalSharing(action, values) {
+    if (action === "share" &&
+        !values.booleans.has("--org-visible") &&
+        !values.booleans.has("--private")) {
         throw new Error("cal share needs --org-visible (every member may read it) or --private (only you). Sharing is a decision, not a default.");
     }
-    const limit = optionalPositiveInteger(values.flags.get("--limit"), "--limit");
+}
+function readCalOffset(values) {
     const offsetRaw = optionalNonEmpty(values.flags.get("--offset"));
     const offset = offsetRaw === undefined ? undefined : Number.parseInt(offsetRaw, 10);
     if (offset !== undefined && !Number.isFinite(offset)) {
         throw new Error("--offset takes a whole number of days (today/next) or weeks (week).");
     }
+    return offset;
+}
+function buildCalCommand(values, action, subject, query, title, startsAt, endsAt, offset, limit) {
     return {
         kind: "cal",
         action,