@bli-cockpit/cli 0.2.38 → 0.2.40

package/dist/commands/local-args.js

@@ -49,6 +49,22 @@ export function parseLocalArgs(argv) {
             return parseAnalyzeArgs(argv.slice(1));
         case "jarvis":
             return parseJarvisArgs(argv.slice(1));
+        case "model":
+            return parseModelArgs(argv.slice(1));
+        case "scout":
+            return parseScoutArgs(argv.slice(1));
+        case "settings":
+            return parseSettingsArgs(argv.slice(1));
+        case "team":
+            return parseTeamArgs(argv.slice(1));
+        case "workbook":
+            return parseWorkbookArgs(argv.slice(1));
+        case "brief":
+            return parseBriefArgs(argv.slice(1));
+        case "correct":
+            return parseCorrectArgs(argv.slice(1));
+        case "notes":
+            return parseNotesArgs(argv.slice(1));
         case "backfill":
             return parseBackfillArgs(argv.slice(1));
         case "status":
@@ -283,15 +299,216 @@ function parseLoginArgs(args) {
 }
 function parseLogoutArgs(args) {
     const values = parseNamedArgs(args, {
-        allowedFlags: ["--home", "--json"],
-        valueFlags: ["--home"],
+        allowedFlags: ["--home", "--json", "--revoke", "--dashboard-url", "--yes"],
+        valueFlags: ["--home", "--dashboard-url"],
     });
     assertNoPositionals(values.positionals, "logout");
     return {
         kind: "logout",
         homeDir: optionalNonEmpty(values.flags.get("--home")),
         json: values.booleans.has("--json"),
+        revoke: values.booleans.has("--revoke"),
+        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
+        yes: values.booleans.has("--yes"),
+    };
+}
+const SETTINGS_SECTIONS = ["personal", "switches", "models", "env"];
+/**
+ * `cockpit settings [section] [verb] [args]` (BLI-3461).
+ *
+ * The flag set is the UNION across sections and the combinations are checked
+ * afterwards, per section — the same shape `parseDoctorArgs` uses. A flag that
+ * belongs to another section is refused by name rather than silently ignored,
+ * because a dropped `--project` on an env write is a change a person believes
+ * they made.
+ */
+function parseSettingsArgs(args) {
+    const values = parseNamedArgs(args, {
+        allowedFlags: [
+            "--home",
+            "--dashboard-url",
+            "--json",
+            "--chat-model",
+            "--brief-model",
+            "--chat",
+            "--memory",
+            "--project",
+            "--file",
+            "--id",
+            "--content-stdin",
+            "--yes",
+        ],
+        valueFlags: [
+            "--home",
+            "--dashboard-url",
+            "--chat-model",
+            "--brief-model",
+            "--chat",
+            "--memory",
+            "--project",
+            "--file",
+            "--id",
+        ],
+    });
+    const [rawSection, ...rest] = values.positionals;
+    const common = {
+        homeDir: optionalNonEmpty(values.flags.get("--home")),
+        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
+        yes: values.booleans.has("--yes"),
+        json: values.booleans.has("--json"),
     };
+    if (!rawSection) {
+        if (rest.length > 0)
+            throw new Error("settings does not accept that argument.");
+        return { kind: "settings", section: "overview", action: "show", ...common };
+    }
+    if (!SETTINGS_SECTIONS.includes(rawSection)) {
+        throw new Error(`settings section must be one of ${SETTINGS_SECTIONS.join(", ")} — or nothing, for all of them.`);
+    }
+    const section = rawSection;
+    if (section === "personal") {
+        if (rest.length > 0)
+            throw new Error("settings personal does not accept positional arguments.");
+        const chatModel = optionalNonEmpty(values.flags.get("--chat-model"));
+        const briefModel = optionalNonEmpty(values.flags.get("--brief-model"));
+        return {
+            kind: "settings",
+            section,
+            action: chatModel || briefModel ? "set" : "show",
+            chatModel,
+            briefModel,
+            ...common,
+        };
+    }
+    if (section === "switches") {
+        if (rest.length === 0) {
+            return { kind: "settings", section, action: "show", ...common };
+        }
+        if (rest[0] !== "set") {
+            throw new Error("settings switches takes no verb, or `set <key> <value>`.");
+        }
+        const [, key, value, ...extra] = rest;
+        if (!key || !value || extra.length > 0) {
+            throw new Error("settings switches set needs exactly a key and a value.");
+        }
+        return { kind: "settings", section, action: "set", switchKey: key, switchValue: value, ...common };
+    }
+    if (section === "models") {
+        if (rest.length === 0) {
+            return { kind: "settings", section, action: "show", ...common };
+        }
+        if (rest[0] !== "set" || rest.length > 1) {
+            throw new Error("settings models takes no verb, or `set --chat <key>` / `set --memory <id>`.");
+        }
+        const orgChatModel = optionalNonEmpty(values.flags.get("--chat"));
+        const orgMemoryModel = optionalNonEmpty(values.flags.get("--memory"));
+        if (!orgChatModel && !orgMemoryModel) {
+            throw new Error("settings models set needs --chat <key>, --memory <id>, or both.");
+        }
+        return { kind: "settings", section, action: "set", orgChatModel, orgMemoryModel, ...common };
+    }
+    // env
+    const verb = rest[0] ?? "list";
+    if (rest.length > 1)
+        throw new Error("settings env takes one verb: list, set, or delete.");
+    if (verb === "list") {
+        return { kind: "settings", section, action: "list", ...common };
+    }
+    if (verb === "set") {
+        const envProject = optionalNonEmpty(values.flags.get("--project"));
+        const envFile = optionalNonEmpty(values.flags.get("--file"));
+        if (!envProject || !envFile) {
+            throw new Error("settings env set needs --project <project> and --file <file name>.");
+        }
+        if (!values.booleans.has("--content-stdin")) {
+            // Deliberate: there is no `--content <value>` flag and never will be. A
+            // secret on a command line lands in shell history and in every process
+            // listing on the machine.
+            throw new Error("settings env set reads the file contents from stdin: add --content-stdin and pipe the file in.");
+        }
+        return {
+            kind: "settings",
+            section,
+            action: "set",
+            envProject,
+            envFile,
+            contentStdin: true,
+            ...common,
+        };
+    }
+    if (verb === "delete") {
+        const envId = optionalNonEmpty(values.flags.get("--id"));
+        if (!envId)
+            throw new Error("settings env delete needs --id <uuid>.");
+        return { kind: "settings", section, action: "delete", envId, ...common };
+    }
+    throw new Error("settings env takes one verb: list, set, or delete.");
+}
+/** `cockpit team [members|invite <email>|role <userId>]` (BLI-3461). */
+function parseTeamArgs(args) {
+    const values = parseNamedArgs(args, {
+        allowedFlags: ["--home", "--dashboard-url", "--json", "--role", "--team-id", "--yes"],
+        valueFlags: ["--home", "--dashboard-url", "--role", "--team-id"],
+    });
+    const common = {
+        homeDir: optionalNonEmpty(values.flags.get("--home")),
+        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
+        teamId: optionalNonEmpty(values.flags.get("--team-id")),
+        yes: values.booleans.has("--yes"),
+        json: values.booleans.has("--json"),
+    };
+    const [verb, subject, ...extra] = values.positionals;
+    if (extra.length > 0)
+        throw new Error("team does not accept that many arguments.");
+    if (!verb || verb === "members") {
+        if (subject)
+            throw new Error("team members does not accept positional arguments.");
+        return { kind: "team", action: "members", ...common };
+    }
+    if (verb === "invite") {
+        if (!subject)
+            throw new Error("team invite needs an email address.");
+        const email = optionalEmail(subject);
+        const role = optionalNonEmpty(values.flags.get("--role"));
+        if (!role)
+            throw new Error("team invite needs --role <role>.");
+        return { kind: "team", action: "invite", email, role, ...common };
+    }
+    if (verb === "role") {
+        if (!subject)
+            throw new Error("team role needs the user id whose role is changing.");
+        const role = optionalNonEmpty(values.flags.get("--role"));
+        if (!role)
+            throw new Error("team role needs --role <role>.");
+        return { kind: "team", action: "role", targetUserId: subject, role, ...common };
+    }
+    throw new Error("team takes one verb: members, invite, or role.");
+}
+/** `cockpit model [show|set <key>]` — the alias surface for the personal chat model. */
+function parseModelArgs(args) {
+    const values = parseNamedArgs(args, {
+        allowedFlags: ["--home", "--dashboard-url", "--json"],
+        valueFlags: ["--home", "--dashboard-url"],
+    });
+    const [verb, key, ...extra] = values.positionals;
+    if (extra.length > 0)
+        throw new Error("model does not accept that many arguments.");
+    const common = {
+        homeDir: optionalNonEmpty(values.flags.get("--home")),
+        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
+        json: values.booleans.has("--json"),
+    };
+    if (!verb || verb === "show") {
+        if (key)
+            throw new Error("model show does not accept positional arguments.");
+        return { kind: "model", action: "show", ...common };
+    }
+    if (verb === "set") {
+        if (!key)
+            throw new Error("model set needs a model key, e.g. openai:gpt-5.6-terra.");
+        return { kind: "model", action: "set", modelKey: key, ...common };
+    }
+    throw new Error("model takes one verb: show or set <key>.");
 }
 function parseStartArgs(args) {
     const values = parseNamedArgs(args, {
@@ -621,9 +838,24 @@ function parseJarvisArgs(args) {
             "--image",
             "--file",
             "--no-stream",
+            // BLI-3458: reading back what was already said, rather than saying
+            // something new. Neither takes a turn or reaches the model.
+            "--threads",
+            "--history",
+            "--limit",
             "--json",
         ],
-        valueFlags: ["--home", "--dashboard-url", "--prompt", "--as", "--thread", "--model", "--image", "--file"],
+        valueFlags: [
+            "--home",
+            "--dashboard-url",
+            "--prompt",
+            "--as",
+            "--thread",
+            "--model",
+            "--image",
+            "--file",
+            "--limit",
+        ],
     });
     const flaggedPrompt = optionalNonEmpty(values.flags.get("--prompt"));
     const positionalPrompt = optionalNonEmpty(values.positionals.join(" "));
@@ -641,6 +873,21 @@ function parseJarvisArgs(args) {
     if (image && file) {
         throw new Error("jarvis accepts either --image or --file, not both — they are the same flag.");
     }
+    // BLI-3458. Reading history and asking a question are different acts, and a
+    // command that quietly did one while you asked for the other would be worse
+    // than a refusal — `--threads` with a question would silently drop the
+    // question.
+    const threads = values.booleans.has("--threads");
+    const history = values.booleans.has("--history");
+    if (threads && history) {
+        throw new Error("jarvis --threads lists every thread; --history replays one. Pass one, not both.");
+    }
+    if ((threads || history) && (flaggedPrompt || positionalPrompt)) {
+        throw new Error("jarvis --threads and --history read back what was already said; they do not take a question.");
+    }
+    if ((threads || history) && image) {
+        throw new Error("jarvis --threads and --history do not take an attachment.");
+    }
     return {
         kind: "jarvis",
         homeDir: optionalNonEmpty(values.flags.get("--home")),
@@ -648,6 +895,9 @@ function parseJarvisArgs(args) {
         prompt: flaggedPrompt ?? positionalPrompt,
         subject: optionalNonEmpty(values.flags.get("--as")),
         thread,
+        threads,
+        history,
+        limit: optionalPositiveInteger(values.flags.get("--limit"), "--limit"),
         // BLI-3381: no client-side allowlist — the dashboard forwards this key
         // to the inference server's own allowlist and relays its refusal.
         model: optionalNonEmpty(values.flags.get("--model")),
@@ -659,6 +909,318 @@ function parseJarvisArgs(args) {
         json: values.booleans.has("--json"),
     };
 }
+/** The shortest prefix `cockpit scout start` will resolve. Below this, ids collide. */
+export const SCOUT_MIN_PREFIX_LENGTH = 6;
+/**
+ * `cockpit scout [--days <n>]` reads the board; `cockpit scout start|dismiss|undo
+ * <id>` moves one card. Positional shape modelled on `autostart`: an optional
+ * action word first, then what it acts on.
+ */
+function parseScoutArgs(args) {
+    const values = parseNamedArgs(args, {
+        allowedFlags: ["--home", "--dashboard-url", "--days", "--json"],
+        valueFlags: ["--home", "--dashboard-url", "--days"],
+    });
+    if (values.positionals.length > 2) {
+        throw new Error("scout accepts at most an action (start|dismiss|undo) and one experiment id.");
+    }
+    const [rawAction, rawRef] = values.positionals;
+    const base = {
+        homeDir: optionalNonEmpty(values.flags.get("--home")),
+        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
+        days: optionalPositiveInteger(values.flags.get("--days"), "--days"),
+        json: values.booleans.has("--json"),
+    };
+    if (!rawAction)
+        return { kind: "scout", action: "board", ...base };
+    if (rawAction !== "start" && rawAction !== "dismiss" && rawAction !== "undo") {
+        throw new Error("scout action must be start, dismiss, or undo.");
+    }
+    const experimentRef = optionalNonEmpty(rawRef);
+    if (!experimentRef) {
+        throw new Error(`scout ${rawAction} needs an experiment id from the board.`);
+    }
+    if (experimentRef.length < SCOUT_MIN_PREFIX_LENGTH) {
+        throw new Error(`scout ${rawAction} needs a full experiment id or a prefix of at least ${SCOUT_MIN_PREFIX_LENGTH} characters.`);
+    }
+    return { kind: "scout", action: rawAction, experimentRef, ...base };
+}
+/** The narrowest width worth wrapping to; below it every line is one word. */
+export const WORKBOOK_MIN_WIDTH = 20;
+/**
+ * `cockpit workbook` with nothing lists the library, one positional lists a
+ * project's shelf, two read a document.
+ */
+function parseWorkbookArgs(args) {
+    const values = parseNamedArgs(args, {
+        allowedFlags: [
+            "--home",
+            "--dashboard-url",
+            "--section",
+            "--width",
+            "--markdown",
+            "--json",
+        ],
+        valueFlags: ["--home", "--dashboard-url", "--section", "--width"],
+    });
+    if (values.positionals.length > 2) {
+        throw new Error("workbook accepts at most a project and a document.");
+    }
+    const project = optionalNonEmpty(values.positionals[0]);
+    const doc = optionalNonEmpty(values.positionals[1]);
+    const section = optionalNonEmpty(values.flags.get("--section"));
+    const markdown = values.booleans.has("--markdown");
+    if (!doc && (section || markdown)) {
+        throw new Error("workbook --section and --markdown need a project and a document, e.g. `cockpit workbook tower workbook`.");
+    }
+    const width = optionalPositiveInteger(values.flags.get("--width"), "--width");
+    if (width !== undefined && width < WORKBOOK_MIN_WIDTH) {
+        throw new Error(`workbook --width must be at least ${WORKBOOK_MIN_WIDTH}.`);
+    }
+    return {
+        kind: "workbook",
+        project,
+        doc,
+        section,
+        markdown,
+        width,
+        homeDir: optionalNonEmpty(values.flags.get("--home")),
+        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
+        json: values.booleans.has("--json"),
+    };
+}
+/**
+ * `cockpit brief` (BLI-3458) — the TODAY page, in the terminal.
+ *
+ * `--for` is the terminal's `?p=`, and it follows the same rule the website
+ * does: the dashboard resolves it against the roster and the database (or the
+ * route's own mirror of the database's rule) decides whether the page opens.
+ * Nothing is decided here.
+ */
+function parseBriefArgs(args) {
+    const values = parseNamedArgs(args, {
+        allowedFlags: [
+            "--home",
+            "--dashboard-url",
+            "--for",
+            "--as",
+            "--version",
+            "--tldr",
+            "--full",
+            "--versions",
+            "--claims",
+            "--json",
+        ],
+        valueFlags: ["--home", "--dashboard-url", "--for", "--as", "--version"],
+    });
+    assertNoPositionals(values.positionals, "brief");
+    const tldr = values.booleans.has("--tldr");
+    const full = values.booleans.has("--full");
+    if (tldr && full) {
+        throw new Error("brief accepts either --tldr or --full, not both.");
+    }
+    // `--as` is accepted as an alias so the two conversational commands read the
+    // same way; `cockpit jarvis --as <person>` has meant this since BLI-3380.
+    const forPerson = optionalNonEmpty(values.flags.get("--for"));
+    const asPerson = optionalNonEmpty(values.flags.get("--as"));
+    if (forPerson && asPerson && forPerson !== asPerson) {
+        throw new Error("brief --for and --as must name the same person.");
+    }
+    return {
+        kind: "brief",
+        homeDir: optionalNonEmpty(values.flags.get("--home")),
+        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
+        subject: forPerson ?? asPerson,
+        version: optionalNonEmpty(values.flags.get("--version")),
+        tldr,
+        versions: values.booleans.has("--versions"),
+        claims: values.booleans.has("--claims"),
+        json: values.booleans.has("--json"),
+    };
+}
+/**
+ * `cockpit correct` (BLI-3458) — say that one line on the page is wrong.
+ *
+ * `--claim` is required and comes from `cockpit brief --claims`, which prints
+ * the id beside every line it names. A correction with no claim would be a note
+ * about the page in general, and the panel has a sentinel for that; the
+ * terminal does not offer it, because a person who has just read
+ * `[claimId] the sentence` has the id in front of them.
+ *
+ * `--text` may be omitted when something is piped in — `git log | cockpit
+ * correct --claim x` — and the command reads stdin instead. Absent both, the
+ * command refuses rather than filing an empty correction.
+ */
+function parseCorrectArgs(args) {
+    const values = parseNamedArgs(args, {
+        allowedFlags: [
+            "--home",
+            "--dashboard-url",
+            "--claim",
+            "--text",
+            "--for",
+            "--as",
+            "--version",
+            "--supersedes",
+            "--json",
+        ],
+        valueFlags: [
+            "--home",
+            "--dashboard-url",
+            "--claim",
+            "--text",
+            "--for",
+            "--as",
+            "--version",
+            "--supersedes",
+        ],
+    });
+    const claimId = optionalNonEmpty(values.flags.get("--claim"));
+    if (!claimId) {
+        throw new Error("correct needs --claim <claimId>. Run `cockpit brief --claims` to see the id beside every line.");
+    }
+    const flaggedText = optionalNonEmpty(values.flags.get("--text"));
+    const positionalText = optionalNonEmpty(values.positionals.join(" "));
+    if (flaggedText && positionalText) {
+        throw new Error("correct accepts either --text or positional text, not both.");
+    }
+    const text = flaggedText ?? positionalText;
+    if (text && text.length > 4000) {
+        throw new Error("A correction is limited to 4000 characters.");
+    }
+    const forPerson = optionalNonEmpty(values.flags.get("--for"));
+    const asPerson = optionalNonEmpty(values.flags.get("--as"));
+    if (forPerson && asPerson && forPerson !== asPerson) {
+        throw new Error("correct --for and --as must name the same person.");
+    }
+    return {
+        kind: "correct",
+        homeDir: optionalNonEmpty(values.flags.get("--home")),
+        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
+        claimId,
+        text,
+        subject: forPerson ?? asPerson,
+        version: optionalNonEmpty(values.flags.get("--version")),
+        supersedes: optionalNonEmpty(values.flags.get("--supersedes")),
+        json: values.booleans.has("--json"),
+    };
+}
+const NOTES_ACTIONS = new Set([
+    "list",
+    "show",
+    "shelf",
+    "shelves",
+    "upload",
+    "paste",
+    "share",
+    "unshare",
+    "move",
+]);
+/** Actions whose first positional is the note it acts on. */
+const NOTES_ACTIONS_NEEDING_A_NOTE = new Set([
+    "show",
+    "share",
+    "unshare",
+    "move",
+]);
+function parseNotesArgs(args) {
+    const values = parseNamedArgs(args, {
+        allowedFlags: [
+            "--home",
+            "--dashboard-url",
+            "--file",
+            "--name",
+            "--exclude",
+            "--to",
+            "--clear-shelf",
+            "--series",
+            "--kind",
+            "--since",
+            "--until",
+            "--limit",
+            "--yes",
+            "--json",
+        ],
+        valueFlags: [
+            "--home",
+            "--dashboard-url",
+            "--file",
+            "--name",
+            "--exclude",
+            "--to",
+            "--series",
+            "--kind",
+            "--since",
+            "--until",
+            "--limit",
+        ],
+    });
+    // Bare `cockpit notes` is the list, which is the thing a person typing it
+    // almost always wants — same reasoning as bare `cockpit` running convergence.
+    const first = values.positionals[0];
+    const action = (first === undefined ? "list" : first);
+    if (!NOTES_ACTIONS.has(action)) {
+        throw new Error(`Unknown notes command: ${first}. Try list, show, shelf, shelves, upload, paste, share, unshare, or move.`);
+    }
+    const rest = values.positionals.slice(first === undefined ? 0 : 1);
+    const json = values.booleans.has("--json");
+    // `--json` implies `--yes`: a machine-readable run has nobody to prompt, and
+    // failing it for want of a confirmation flag it cannot see is a worse
+    // surprise than an explicit share it already asked for by name.
+    const yes = values.booleans.has("--yes") || json;
+    let noteId;
+    if (NOTES_ACTIONS_NEEDING_A_NOTE.has(action)) {
+        noteId = optionalNonEmpty(rest[0]);
+        if (!noteId)
+            throw new Error(`notes ${action} needs a note id.`);
+        if (rest.length > 1) {
+            throw new Error(`notes ${action} takes one note id, not ${rest.length}.`);
+        }
+    }
+    let paths;
+    if (action === "upload") {
+        // Explicit paths only. No globbing happens here — a shell that expands
+        // `*.md` hands us the names it found, and a shell that does not would have
+        // this command silently uploading a file literally called `*.md`.
+        paths = rest.filter((value) => value.trim() !== "");
+        if (paths.length === 0)
+            throw new Error("notes upload needs at least one file path.");
+    }
+    else if (action !== "paste" && !NOTES_ACTIONS_NEEDING_A_NOTE.has(action) && rest.length > 0) {
+        throw new Error(`notes ${action} does not take "${rest[0]}".`);
+    }
+    const to = optionalNonEmpty(values.flags.get("--to"));
+    const clearShelf = values.booleans.has("--clear-shelf");
+    if (action === "move") {
+        if (to && clearShelf) {
+            throw new Error("notes move accepts either --to or --clear-shelf, not both.");
+        }
+        if (!to && !clearShelf) {
+            throw new Error('notes move needs --to "<shelf>" or --clear-shelf.');
+        }
+    }
+    const limit = optionalPositiveInteger(values.flags.get("--limit"), "--limit");
+    return {
+        kind: "notes",
+        action,
+        homeDir: optionalNonEmpty(values.flags.get("--home")),
+        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
+        ...(noteId ? { noteId } : {}),
+        ...(paths ? { paths } : {}),
+        filePath: optionalNonEmpty(values.flags.get("--file")),
+        name: optionalNonEmpty(values.flags.get("--name")),
+        exclude: optionalNonEmpty(values.flags.get("--exclude")),
+        ...(to ? { to } : {}),
+        ...(clearShelf ? { clearShelf } : {}),
+        series: optionalNonEmpty(values.flags.get("--series")),
+        meetingKind: optionalNonEmpty(values.flags.get("--kind")),
+        since: optionalNonEmpty(values.flags.get("--since")),
+        until: optionalNonEmpty(values.flags.get("--until")),
+        ...(limit === undefined ? {} : { limit }),
+        yes,
+        json,
+    };
+}
 function parseNamedArgs(args, options) {
     const allowed = new Set(options.allowedFlags);
     const valueFlags = new Set(options.valueFlags);