@bli-cockpit/cli 0.2.57 → 0.2.58

package/dist/commands/issue-contracts.js

@@ -0,0 +1,99 @@
+/**
+ * What `cockpit issue` hands between its own halves (BLI-3716): the row
+ * shapes the `/api/work/**` doors answer with, the two deadlines, and the
+ * three "which one did you mean" resolvers both the read half (`issue.ts`)
+ * and the write half (`issue-write.ts`) need.
+ *
+ * Split out so neither half carries the other's weight — the same table-of-
+ * contents discipline `commands/session-sync*.ts` and `commands/backfill*.ts`
+ * follow, applied before the file got large rather than after.
+ */
+import { askAgentDoor } from "./agent-door.js";
+import { isInteractiveStdin, readPipedText } from "./cli-io.js";
+import { readNoteFile } from "./notes-file.js";
+export const TAG = "[issue cli]";
+export const READ_DEADLINE_MS = 30_000;
+export const WRITE_DEADLINE_MS = 60_000;
+export const BODY_MAX_CHARS = 200_000;
+/** A project id from a project NAME or a uuid — exact after case-folding. */
+export async function resolveProjectId(door, ref) {
+    const answer = await askAgentDoor(door, {
+        path: "/api/work/projects?include_archived=true",
+        method: "GET",
+        label: "issue project resolve",
+        timeoutMs: READ_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return { status: "list_failed", reason: answer.reason, detail: answer.detail };
+    const projects = answer.body.projects ?? [];
+    const wanted = ref.toLowerCase();
+    const match = projects.find((project) => project.id === ref || project.name.toLowerCase() === wanted);
+    return match ? { status: "ok", id: match.id } : { status: "not_found" };
+}
+/** A parent issue's uuid from any issue reference, via the door's own resolver. */
+export async function resolveIssueUuid(door, ref) {
+    const answer = await askAgentDoor(door, {
+        path: `/api/work/issues/${encodeURIComponent(ref)}`,
+        method: "GET",
+        label: "issue parent resolve",
+        timeoutMs: READ_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return { status: "failed", reason: answer.reason, detail: answer.detail };
+    const issue = answer.body.issue;
+    if (!issue?.id) {
+        return {
+            status: "failed",
+            reason: "issue_not_found_or_unreadable",
+            detail: `That issue does not exist, or you cannot read it: ${ref}`,
+        };
+    }
+    return { status: "ok", id: issue.id };
+}
+/** Body on stdin, never argv — `--file` is the safest way on Windows. */
+export async function readBody(command, io) {
+    if (command.filePath) {
+        const read = await readNoteFile(command.filePath);
+        if (!read.ok) {
+            return { ok: false, reason: read.refusal, detail: `Could not read ${command.filePath}: ${read.detail}` };
+        }
+        return { ok: true, text: read.bytes.toString("utf8") };
+    }
+    if (isInteractiveStdin(io))
+        return { ok: true, text: "" };
+    try {
+        const text = await readPipedText(io.stdin, {
+            maxChars: BODY_MAX_CHARS,
+            overflowMessage: `An issue description is limited to ${BODY_MAX_CHARS} characters.`,
+        });
+        return { ok: true, text };
+    }
+    catch (error) {
+        return { ok: false, reason: "description_too_long", detail: error instanceof Error ? error.message : String(error) };
+    }
+}
+/** The project/parent halves both `create` and `update` need, resolved once. */
+export async function resolveRefs(command, door) {
+    let projectId;
+    let parentId;
+    if (command.project) {
+        const resolved = await resolveProjectId(door, command.project);
+        if (resolved.status === "list_failed")
+            return { ok: false, reason: resolved.reason, detail: resolved.detail };
+        if (resolved.status === "not_found") {
+            return {
+                ok: false,
+                reason: "project_not_found_or_unreadable",
+                detail: `No project here is called "${command.project}" — run \`cockpit project list\` for the names.`,
+            };
+        }
+        projectId = resolved.id;
+    }
+    if (command.parentRef) {
+        const resolved = await resolveIssueUuid(door, command.parentRef);
+        if (resolved.status === "failed")
+            return { ok: false, reason: resolved.reason, detail: resolved.detail };
+        parentId = resolved.id;
+    }
+    return { ok: true, ...(projectId ? { projectId } : {}), ...(parentId ? { parentId } : {}) };
+}

package/dist/commands/issue-write.js

@@ -0,0 +1,129 @@
+/**
+ * The verbs that CHANGE something: `cockpit issue create|update|move|comment`
+ * (BLI-3716). The reads and the router live in `issue.ts`, the shared shapes
+ * and resolvers in `issue-contracts.ts`.
+ *
+ * Every write prints a receipt line on stderr naming what it did and to
+ * which row, success included — `--json` owns stdout, so a receipt that went
+ * there would corrupt the one machine-readable object a caller parses.
+ */
+import { askAgentDoor, emitAgentDoor, failAgentDoor, } from "./agent-door.js";
+import { writeLine } from "./cli-io.js";
+import { TAG, WRITE_DEADLINE_MS, readBody, resolveRefs, } from "./issue-contracts.js";
+export async function createIssue(command, door) {
+    if (!command.title)
+        return failAgentDoor(door, TAG, "invalid_body", "issue create needs --title.");
+    const refs = await resolveRefs(command, door);
+    if (!refs.ok)
+        return failAgentDoor(door, TAG, refs.reason, refs.detail);
+    const body = await readBody(command, door.io);
+    if (!body.ok)
+        return failAgentDoor(door, TAG, body.reason, body.detail);
+    const answer = await askAgentDoor(door, {
+        path: "/api/work/issues",
+        method: "POST",
+        label: "issue create",
+        timeoutMs: WRITE_DEADLINE_MS,
+        body: {
+            title: command.title,
+            ...(body.text ? { description: body.text } : {}),
+            ...(refs.projectId ? { project_id: refs.projectId } : {}),
+            ...(refs.parentId ? { parent_id: refs.parentId } : {}),
+            ...(command.priority === undefined ? {} : { priority: command.priority }),
+            ...(command.assignee ? { assignee_id: command.assignee } : {}),
+        },
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const issue = answer.body.issue;
+    writeLine(door.io.stderr, `${TAG} created ${JSON.stringify({ issue_id: issue?.id ?? null, identifier: issue?.identifier ?? null, description_bytes: Buffer.byteLength(body.text, "utf8") })}`);
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, issue });
+    writeLine(door.io.stdout, `Created ${issue?.identifier ?? ""} — ${issue?.title ?? ""} (${issue?.id ?? ""}).`);
+    return 0;
+}
+export async function updateIssue(command, door) {
+    const ref = command.issueRef ?? "";
+    const refs = await resolveRefs(command, door);
+    if (!refs.ok)
+        return failAgentDoor(door, TAG, refs.reason, refs.detail);
+    let description;
+    if (command.bodyStdin || command.filePath) {
+        const body = await readBody(command, door.io);
+        if (!body.ok)
+            return failAgentDoor(door, TAG, body.reason, body.detail);
+        description = body.text;
+    }
+    if (description === undefined
+        && command.title === undefined
+        && command.priority === undefined
+        && command.assignee === undefined
+        && refs.projectId === undefined
+        && refs.parentId === undefined) {
+        return failAgentDoor(door, TAG, "invalid_body", "issue update needs at least one of --title, --priority, --assignee, --project, --parent, or a description on --body-stdin/--file.");
+    }
+    const answer = await askAgentDoor(door, {
+        path: `/api/work/issues/${encodeURIComponent(ref)}`,
+        method: "PATCH",
+        label: "issue update",
+        timeoutMs: WRITE_DEADLINE_MS,
+        body: {
+            ...(command.title !== undefined ? { title: command.title } : {}),
+            ...(description !== undefined ? { description } : {}),
+            ...(command.priority === undefined ? {} : { priority: command.priority }),
+            ...(command.assignee ? { assignee_id: command.assignee } : {}),
+            ...(refs.projectId ? { project_id: refs.projectId } : {}),
+            ...(refs.parentId ? { parent_id: refs.parentId } : {}),
+        },
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const issue = answer.body.issue;
+    writeLine(door.io.stderr, `${TAG} updated ${JSON.stringify({ issue_id: issue?.id ?? null, identifier: issue?.identifier ?? null })}`);
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, issue });
+    writeLine(door.io.stdout, `Updated ${issue?.identifier ?? ref} — ${issue?.title ?? ""}.`);
+    return 0;
+}
+export async function moveIssue(command, door) {
+    const ref = command.issueRef ?? "";
+    const answer = await askAgentDoor(door, {
+        path: `/api/work/issues/${encodeURIComponent(ref)}/state`,
+        method: "POST",
+        label: "issue move",
+        timeoutMs: WRITE_DEADLINE_MS,
+        body: { state: command.moveState },
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const issue = answer.body.issue;
+    writeLine(door.io.stderr, `${TAG} moved ${JSON.stringify({ issue_id: issue?.id ?? null, identifier: issue?.identifier ?? null, to_state: command.moveState })}`);
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, issue });
+    writeLine(door.io.stdout, `${issue?.identifier ?? ref} is now ${issue?.state ?? command.moveState}.`);
+    return 0;
+}
+export async function commentIssue(command, door) {
+    const ref = command.issueRef ?? "";
+    const body = await readBody(command, door.io);
+    if (!body.ok)
+        return failAgentDoor(door, TAG, body.reason, body.detail);
+    if (body.text.trim() === "") {
+        return failAgentDoor(door, TAG, "invalid_body", 'A comment is never taken on the command line — pipe it in: `echo "..." | cockpit issue comment BLI-3654`.');
+    }
+    const answer = await askAgentDoor(door, {
+        path: `/api/work/issues/${encodeURIComponent(ref)}/comments`,
+        method: "POST",
+        label: "issue comment",
+        timeoutMs: WRITE_DEADLINE_MS,
+        body: { body_markdown: body.text },
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const comment = answer.body.comment;
+    writeLine(door.io.stderr, `${TAG} commented ${JSON.stringify({ comment_id: comment?.id ?? null, byte_size: Buffer.byteLength(body.text, "utf8") })}`);
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, comment });
+    writeLine(door.io.stdout, `Commented on ${ref} (${comment?.id ?? ""}).`);
+    return 0;
+}

package/dist/commands/issue.js

@@ -0,0 +1,189 @@
+/**
+ * `cockpit issue` — Tower's issue tracker, typed (BLI-3716).
+ *
+ * Seven verbs over `/api/work/**`, the same doors the browser uses. Every
+ * one of those routes already accepted the collector device token
+ * (`resolveCaller({ allowDeviceToken: true })`, BLI-3703), so this command
+ * is a terminal in front of an existing door, not a new one.
+ *
+ * Three references a person actually types, resolved here or by the door:
+ *  - an ISSUE is `BLI-3654` or a uuid. The SERVER resolves it
+ *    (`lib/work/issue-ref.ts`), so `show`/`move`/`comment`/`history` cost one
+ *    request, not two.
+ *  - a PROJECT is its name or a uuid, resolved by `issue-contracts.ts`
+ *    against the same `GET /api/work/projects` list `cockpit project list`
+ *    prints — exact after case-folding, never fuzzy.
+ *  - a PARENT is another issue reference, resolved with one `GET` so the
+ *    create/patch body carries the uuid its schema demands.
+ *
+ * This file is the router plus the READ verbs (`list`, `show`, `history`);
+ * `issue-write.ts` holds `create`, `update`, `move` and `comment`, and
+ * `issue-contracts.ts` the shapes and resolvers both halves share.
+ *
+ * Bodies never travel on argv: a description or a comment comes from stdin
+ * or `--file`. A refusal keeps the door's own `reason` label verbatim
+ * (`agent-door.ts`) — `issue_not_found_or_unreadable`, `invalid_state`,
+ * `needs_rls_client`, `comment_too_long`, and so on.
+ */
+import { askAgentDoor, emitAgentDoor, failAgentDoor, openAgentDoor, } from "./agent-door.js";
+import { writeLine } from "./cli-io.js";
+import { READ_DEADLINE_MS, TAG, resolveProjectId, } from "./issue-contracts.js";
+import { commentIssue, createIssue, moveIssue, updateIssue } from "./issue-write.js";
+export async function runIssue(command, io) {
+    const door = await openAgentDoor("issue", command, io);
+    switch (command.action) {
+        case "list":
+            return listIssues(command, door);
+        case "show":
+            return showIssue(command, door);
+        case "create":
+            return createIssue(command, door);
+        case "update":
+            return updateIssue(command, door);
+        case "move":
+            return moveIssue(command, door);
+        case "comment":
+            return commentIssue(command, door);
+        case "history":
+            return issueHistory(command, door);
+    }
+}
+function issueLine(issue) {
+    return `${issue.identifier.padEnd(9)}  ${issue.state.padEnd(11)}  ${issue.title}`;
+}
+async function listIssues(command, door) {
+    const query = new URLSearchParams();
+    if (command.stateFilter)
+        query.set("state", command.stateFilter);
+    if (command.assignee)
+        query.set("assignee_id", command.assignee);
+    if (command.limit !== undefined)
+        query.set("limit", String(command.limit));
+    if (command.project) {
+        const resolved = await resolveProjectId(door, command.project);
+        if (resolved.status === "list_failed")
+            return failAgentDoor(door, TAG, resolved.reason, resolved.detail);
+        if (resolved.status === "not_found") {
+            return failAgentDoor(door, TAG, "project_not_found_or_unreadable", `No project here is called "${command.project}" — run \`cockpit project list\` for the names.`);
+        }
+        query.set("project_id", resolved.id);
+    }
+    const suffix = query.toString();
+    const answer = await askAgentDoor(door, {
+        path: `/api/work/issues${suffix ? `?${suffix}` : ""}`,
+        method: "GET",
+        label: "issue list",
+        timeoutMs: READ_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const issues = answer.body.issues ?? [];
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, issues });
+    if (issues.length === 0) {
+        writeLine(door.io.stdout, "No issues match that.");
+        return 0;
+    }
+    for (const issue of issues)
+        writeLine(door.io.stdout, issueLine(issue));
+    writeLine(door.io.stdout, "");
+    writeLine(door.io.stdout, `${issues.length} issue(s).`);
+    return 0;
+}
+async function showIssue(command, door) {
+    const ref = command.issueRef ?? "";
+    const answer = await askAgentDoor(door, {
+        path: `/api/work/issues/${encodeURIComponent(ref)}`,
+        method: "GET",
+        label: "issue show",
+        timeoutMs: READ_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const issue = answer.body.issue;
+    if (!issue) {
+        return failAgentDoor(door, TAG, "issue_not_found_or_unreadable", `That issue does not exist, or you cannot read it: ${ref}`);
+    }
+    // A comment read that fails does NOT fail the whole `show` — the issue is
+    // already in hand, and a named gap beats losing what was read.
+    const commentsAnswer = await askAgentDoor(door, {
+        path: `/api/work/issues/${encodeURIComponent(issue.id)}/comments`,
+        method: "GET",
+        label: "issue show comments",
+        timeoutMs: READ_DEADLINE_MS,
+    });
+    const comments = commentsAnswer.ok
+        ? (commentsAnswer.body.comments ?? [])
+        : [];
+    if (!commentsAnswer.ok) {
+        writeLine(door.io.stderr, `${TAG} comments unread ${JSON.stringify({ reason: commentsAnswer.reason, issue_id: issue.id })}`);
+    }
+    if (door.json) {
+        return emitAgentDoor(door, {
+            ok: true,
+            issue,
+            comments,
+            ...(commentsAnswer.ok ? {} : { comments_unread_reason: commentsAnswer.reason }),
+        });
+    }
+    writeLine(door.io.stdout, `${issue.identifier}  ${issue.title}`);
+    writeLine(door.io.stdout, `${issue.state}  ·  priority ${issue.priority ?? 0}  ·  assignee ${issue.assignee_id ?? "(nobody)"}  ·  updated ${issue.updated_at}`);
+    writeLine(door.io.stdout, `id ${issue.id}${issue.parent_id ? `  ·  parent ${issue.parent_id}` : ""}`);
+    writeLine(door.io.stdout, "");
+    writeLine(door.io.stdout, issue.description ?? "(no description)");
+    if (comments.length > 0) {
+        writeLine(door.io.stdout, "");
+        writeLine(door.io.stdout, `--- ${comments.length} comment(s) ---`);
+        for (const comment of comments) {
+            writeLine(door.io.stdout, "");
+            writeLine(door.io.stdout, `[${comment.created_at}] ${comment.author_name ?? comment.author_id ?? "unknown"}`);
+            writeLine(door.io.stdout, comment.body_markdown);
+        }
+    }
+    else if (commentsAnswer.ok) {
+        writeLine(door.io.stdout, "");
+        writeLine(door.io.stdout, "No comments.");
+    }
+    return 0;
+}
+/**
+ * What a history row actually says. A row imported from Linear's issue
+ * TIMESTAMPS (created/started/completed/canceled) carries no state names at
+ * all: the reader refuses to name a workflow state it cannot prove
+ * (`linear-reader.ts` `buildSyntheticTransitions` — "naming a stale workflow
+ * state would be a small invented fact"), and only the state CATEGORY it did
+ * know is dropped on the way into `work_issue_history`. Printing
+ * "(none) -> (none)" is honest and useless; this says which it is, so nobody
+ * reads a real gap as a broken command.
+ */
+function historyChange(row) {
+    if (row.from_value === null && row.to_value === null) {
+        return `(no state names recorded — imported from ${row.source})`;
+    }
+    return `${row.from_value ?? "(none)"} -> ${row.to_value ?? "(none)"}`;
+}
+async function issueHistory(command, door) {
+    const ref = command.issueRef ?? "";
+    const query = command.limit === undefined ? "" : `?limit=${command.limit}`;
+    const answer = await askAgentDoor(door, {
+        path: `/api/work/issues/${encodeURIComponent(ref)}/history${query}`,
+        method: "GET",
+        label: "issue history",
+        timeoutMs: READ_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const history = answer.body.history ?? [];
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, history });
+    if (history.length === 0) {
+        writeLine(door.io.stdout, `No recorded changes for ${ref}.`);
+        return 0;
+    }
+    for (const row of history) {
+        writeLine(door.io.stdout, `${row.occurred_at}  ${row.change_type.padEnd(9)}  ${historyChange(row)}  ${row.actor_name ?? ""}`.trimEnd());
+    }
+    writeLine(door.io.stdout, "");
+    writeLine(door.io.stdout, `${history.length} change(s).`);
+    return 0;
+}

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

@@ -0,0 +1,178 @@
+/**
+ * `cockpit issue` and `cockpit project` argument parsing (BLI-3716) — the
+ * Work surface's half of `local-args-tower.ts`, a sibling of
+ * `local-args-tower-docs-msg.ts` for the same reason that file is a sibling
+ * of the pages family: issues are their own noun with their own vocabulary
+ * (a state, an assignee, a project) and folding them into another family's
+ * parser would stretch that family's doc comment past the truth.
+ *
+ * Two commands, because a person types `cockpit project list`, not
+ * `cockpit issue projects` — the nouns are what a person says.
+ *
+ * Bodies never travel on argv: `create --title` names the issue, but the
+ * DESCRIPTION and every comment come from stdin or `--file`, the same
+ * discipline `cockpit docs` and `cockpit notes paste` keep (BLI-3706, and
+ * the sourcing-secrets verdict before it — argv is world-readable on a
+ * shared machine and lands in shell history).
+ */
+import { optionalNonEmpty, optionalPositiveInteger, optionalUrl, parseNamedArgs, } from "./local-arg-values.js";
+const ISSUE_ACTIONS = new Set([
+    "list",
+    "show",
+    "create",
+    "update",
+    "move",
+    "comment",
+    "history",
+]);
+/** Every verb except `list` and `create` names ONE issue first. */
+const ISSUE_ACTIONS_NEEDING_AN_ISSUE = new Set([
+    "show",
+    "update",
+    "move",
+    "comment",
+    "history",
+]);
+/**
+ * The closed state vocabulary, copied verbatim from
+ * `apps/dashboard/src/lib/work/api-doors.ts` `WORK_ISSUE_STATES` (which is
+ * itself the migration's CHECK constraint). Duplicated rather than imported
+ * because no dependency edge exists from the collector to the dashboard;
+ * `issue.ts`'s tests pin the list so a drift shows up here rather than as a
+ * 400 on a fleet machine.
+ */
+export const ISSUE_STATES = ["backlog", "todo", "in_progress", "in_review", "done", "canceled"];
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export function parseIssueArgs(args) {
+    const values = parseNamedArgs(args, {
+        allowedFlags: [
+            "--home",
+            "--dashboard-url",
+            "--state",
+            "--assignee",
+            "--project",
+            "--limit",
+            "--title",
+            "--priority",
+            "--parent",
+            "--file",
+            "--body-stdin",
+            "--json",
+        ],
+        valueFlags: [
+            "--home",
+            "--dashboard-url",
+            "--state",
+            "--assignee",
+            "--project",
+            "--limit",
+            "--title",
+            "--priority",
+            "--parent",
+            "--file",
+        ],
+    });
+    const first = values.positionals[0];
+    const action = (first === undefined ? "list" : first);
+    if (!ISSUE_ACTIONS.has(action)) {
+        throw new Error(`Unknown issue command: ${first}. Try list, show, create, update, move, comment, or history.`);
+    }
+    const rest = values.positionals.slice(first === undefined ? 0 : 1);
+    let issueRef;
+    let moveState;
+    if (ISSUE_ACTIONS_NEEDING_AN_ISSUE.has(action)) {
+        issueRef = optionalNonEmpty(rest[0]);
+        if (!issueRef)
+            throw new Error(`issue ${action} needs an issue id or identifier, e.g. BLI-3654.`);
+        if (action === "move") {
+            moveState = optionalNonEmpty(rest[1]);
+            if (!moveState) {
+                throw new Error(`issue move needs a state: ${ISSUE_STATES.join(", ")}.`);
+            }
+            if (rest.length > 2)
+                throw new Error(`issue move takes an issue and one state, not ${rest.length} words.`);
+        }
+        else if (rest.length > 1) {
+            throw new Error(`issue ${action} takes one issue reference, not ${rest.length}.`);
+        }
+    }
+    else if (rest.length > 0) {
+        throw new Error(`issue ${action} does not take "${rest[0]}".`);
+    }
+    if (moveState && !ISSUE_STATES.includes(moveState)) {
+        throw new Error(`issue move state must be one of: ${ISSUE_STATES.join(", ")}.`);
+    }
+    const stateFilter = optionalNonEmpty(values.flags.get("--state"));
+    if (stateFilter !== undefined && !ISSUE_STATES.includes(stateFilter)) {
+        throw new Error(`--state must be one of: ${ISSUE_STATES.join(", ")}.`);
+    }
+    if (stateFilter !== undefined && action !== "list") {
+        throw new Error("--state filters `cockpit issue list`; to move an issue use `cockpit issue move <id> <state>`.");
+    }
+    const title = optionalNonEmpty(values.flags.get("--title"));
+    if (action === "create" && !title)
+        throw new Error("issue create needs --title.");
+    // Not `optionalPositiveInteger`: 0 is a legitimate priority ("none", the
+    // column default), and that helper refuses it as non-positive.
+    const priorityRaw = optionalNonEmpty(values.flags.get("--priority"));
+    let priority;
+    if (priorityRaw !== undefined) {
+        priority = Number(priorityRaw);
+        if (!Number.isInteger(priority) || priority < 0 || priority > 4) {
+            throw new Error("--priority must be 0-4 (0 none, 1 urgent, 2 high, 3 medium, 4 low).");
+        }
+    }
+    // An assignee is `me`, `unassigned`, or a person's uuid. A name or an
+    // email is refused HERE rather than travelling to Postgres as a malformed
+    // uuid, which would come back as a 500 that names nothing useful.
+    const assignee = optionalNonEmpty(values.flags.get("--assignee"));
+    if (assignee !== undefined && assignee !== "me" && assignee !== "unassigned" && !UUID_PATTERN.test(assignee)) {
+        throw new Error('--assignee must be "me", "unassigned", or a person\'s uuid (see `cockpit team`).');
+    }
+    if (assignee === "unassigned" && action !== "list") {
+        throw new Error('--assignee unassigned filters `cockpit issue list`; to clear an assignee pass --assignee "" is not supported yet.');
+    }
+    const limit = optionalPositiveInteger(values.flags.get("--limit"), "--limit");
+    if (limit !== undefined && action !== "list" && action !== "history") {
+        throw new Error("--limit belongs to `cockpit issue list` or `cockpit issue history`.");
+    }
+    return {
+        kind: "issue",
+        action,
+        homeDir: optionalNonEmpty(values.flags.get("--home")),
+        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
+        ...(issueRef ? { issueRef } : {}),
+        ...(moveState ? { moveState } : {}),
+        ...(stateFilter ? { stateFilter } : {}),
+        ...(assignee ? { assignee } : {}),
+        project: optionalNonEmpty(values.flags.get("--project")),
+        ...(limit === undefined ? {} : { limit }),
+        title,
+        ...(priority === undefined ? {} : { priority }),
+        parentRef: optionalNonEmpty(values.flags.get("--parent")),
+        filePath: optionalNonEmpty(values.flags.get("--file")),
+        bodyStdin: values.booleans.has("--body-stdin"),
+        json: values.booleans.has("--json"),
+    };
+}
+export function parseProjectArgs(args) {
+    const values = parseNamedArgs(args, {
+        allowedFlags: ["--home", "--dashboard-url", "--archived", "--json"],
+        valueFlags: ["--home", "--dashboard-url"],
+    });
+    const first = values.positionals[0];
+    const action = (first === undefined ? "list" : first);
+    if (action !== "list")
+        throw new Error(`Unknown project command: ${first}. The only verb is list.`);
+    const rest = values.positionals.slice(first === undefined ? 0 : 1);
+    if (rest.length > 0)
+        throw new Error(`project list does not take "${rest[0]}".`);
+    return {
+        kind: "project",
+        action,
+        homeDir: optionalNonEmpty(values.flags.get("--home")),
+        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
+        includeArchived: values.booleans.has("--archived"),
+        json: values.booleans.has("--json"),
+    };
+}

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

@@ -18,10 +18,13 @@
  *                                model
  *   local-args-tower-docs-msg.ts docs, msg          — the document library and
  *                                                      channels/messages (BLI-3706)
+ *   local-args-tower-work.ts    issue, project     — the issue tracker
+ *                                                      (BLI-3716)
  *
  * Every name this module has ever exported is still importable from here.
  */
 export { parseJarvisArgs, parseCorrectArgs } from "./local-args-tower-chat.js";
 export { parseBriefArgs, WORKBOOK_MIN_WIDTH, parseWorkbookArgs, parseNotesArgs, } from "./local-args-tower-pages.js";
 export { SCOUT_MIN_PREFIX_LENGTH, parseScoutArgs, parseOpsArgs, SLACK_WORKSPACE_KEYS, parseSlackArgs, parseSettingsArgs, parseTeamArgs, parseModelArgs, } from "./local-args-tower-admin.js";
-export { parseDocsArgs, parseMsgArgs, } from "./local-args-tower-docs-msg.js";
+export { parseDocsArgs, parseMsgArgs, } from "./local-args-tower-docs-msg.js";
+export { ISSUE_STATES, parseIssueArgs, parseProjectArgs, } from "./local-args-tower-work.js";

package/dist/commands/local-args.js

@@ -1,11 +1,11 @@
 import { parseAgentRulesArgs, parseAnalyzeArgs, parseAutostartArgs, parseBackfillArgs, parseCleanArgs, parseDoctorArgs, parseInstallArgs, parseLoginArgs, parseMemoryArgs, parseLogoutArgs, parseOnboardArgs, parseReleaseArgs, parseServeArgs, parseSessionsArgs, parseStartArgs, parseStatusArgs, parseSyncArgs, parseUpdateArgs, } from "./local-args-collector.js";
-import { parseBriefArgs, parseCorrectArgs, parseDocsArgs, parseJarvisArgs, parseModelArgs, parseMsgArgs, parseNotesArgs, parseOpsArgs, parseScoutArgs, parseSettingsArgs, parseSlackArgs, parseTeamArgs, parseWorkbookArgs, } from "./local-args-tower.js";
+import { parseBriefArgs, parseCorrectArgs, parseDocsArgs, parseIssueArgs, parseJarvisArgs, parseModelArgs, parseMsgArgs, parseNotesArgs, parseOpsArgs, parseProjectArgs, parseScoutArgs, parseSettingsArgs, parseSlackArgs, parseTeamArgs, parseWorkbookArgs, } from "./local-args-tower.js";
 // `normalizeUrl` has always been part of this module's surface — `local.ts` and
 // `local-auth.ts` import it from here — so it stays exported from this address
 // even though it now lives next door. The same goes for the four names the
 // Tower parsers publish.
 export { normalizeUrl } from "./local-arg-values.js";
-export { SCOUT_MIN_PREFIX_LENGTH, SLACK_WORKSPACE_KEYS, WORKBOOK_MIN_WIDTH, } from "./local-args-tower.js";
+export { SCOUT_MIN_PREFIX_LENGTH, SLACK_WORKSPACE_KEYS, WORKBOOK_MIN_WIDTH, ISSUE_STATES, } from "./local-args-tower.js";
 // The six human "set my machine up" doors. They are one thing wearing six
 // hats, so they all run the convergence command — but they keep accepting the
 // flags they always accepted, because DMs, runbooks and AGENTS.md rules across
@@ -88,6 +88,10 @@ export function parseLocalArgs(argv) {
             return parseDocsArgs(argv.slice(1));
         case "msg":
             return parseMsgArgs(argv.slice(1));
+        case "issue":
+            return parseIssueArgs(argv.slice(1));
+        case "project":
+            return parseProjectArgs(argv.slice(1));
         case "release":
             return parseReleaseArgs(argv.slice(1));
         default: