assent-cli 0.0.0-stage → 0.6.1

package/dist/cli.js

@@ -0,0 +1,636 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseWhen = parseWhen;
+exports.parseAction = parseAction;
+exports.parseItem = parseItem;
+exports.parseRef = parseRef;
+exports.redactedTail = redactedTail;
+exports.itemState = itemState;
+exports.commandName = commandName;
+exports.runCli = runCli;
+const node_crypto_1 = require("node:crypto");
+const node_path_1 = require("node:path");
+const args_1 = require("./args");
+const client_1 = require("./client");
+const config_1 = require("./config");
+const exit_codes_1 = require("./exit-codes");
+const redact_1 = require("./redact");
+const usage_1 = require("./usage");
+const hook_1 = require("./hook");
+const claude_code_1 = require("./claude-code");
+const mcp_bridge_1 = require("./mcp-bridge");
+const STRING = { type: "string" };
+const MANY = { type: "string", multiple: true };
+const FLAG = { type: "boolean" };
+const KINDS = ["todo", "approve", "pay", "login", "code", "reply"];
+const STYLES = ["primary", "secondary", "danger"];
+const TASK_OPTIONS = { title: STRING, detail: STRING, url: STRING, due: STRING, remind: STRING, dedupe: STRING, run: STRING, why: STRING, project: STRING, track: STRING, question: STRING, "answer-type": STRING, effort: STRING, series: STRING, "idempotency-key": STRING, "allow-duplicate": FLAG };
+const ANSWER_TYPES = ["yes_no", "choice", "text", "number", "done"];
+const BARE_DATE = /^\d{4}-\d{2}-\d{2}$/;
+const LOCAL_DATE_TIME = /^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2}(?::\d{2})?)$/;
+const CLEAR_WORDS = new Set(["none", "clear"]);
+const ITEM_OUTCOMES = ["done", "skipped", "needs_you", "failed"];
+const ITEM_TYPES = ["note", "task", "run", "agent"];
+const RELATIONS = ["produced", "about", "blocks", "related"];
+const DEFAULT_TAIL_CHARS = 8000;
+const SUMMARY_LIMIT = 1000;
+const LOG_MARGIN_CHARS = 1024;
+function text(values, name) {
+    const value = values[name];
+    return typeof value === "string" ? value : undefined;
+}
+function required(values, name) {
+    const value = text(values, name);
+    if (!value)
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, `--${name} is required`);
+    return value;
+}
+function positional(args, index, label) {
+    const value = args.positionals[index];
+    if (!value)
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, `${label} is required`);
+    return value;
+}
+function many(values, name) {
+    const value = values[name];
+    return Array.isArray(value) ? value : [];
+}
+function wholeNumber(values, name, min, max) {
+    const raw = text(values, name);
+    if (raw === undefined)
+        return undefined;
+    const value = Number(raw);
+    if (!Number.isInteger(value) || value < min || value > max)
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, `--${name} must be a whole number from ${min} to ${max}`);
+    return value;
+}
+function parseWhen(raw, flag, warn) {
+    const value = raw.trim();
+    if (BARE_DATE.test(value) && !Number.isNaN(Date.parse(value))) {
+        warn(`--${flag} ${value} has no time, so it means 09:00 on that day in your Assent time zone. Pass a time like ${value}T17:00 to choose one.`);
+        return value;
+    }
+    const local = LOCAL_DATE_TIME.exec(value);
+    const ms = local ? new Date(`${local[1]}T${local[2]}`).getTime() : Date.parse(value);
+    if (Number.isNaN(ms) || !(local || /T/.test(value)))
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, `--${flag} must be a date and time like 2026-10-15T17:00, 2026-10-15 17:00 or 2026-10-15T17:00:00+01:00, or a date like 2026-10-15 for 09:00`);
+    return new Date(ms).toISOString();
+}
+function when(values, flag, deps) {
+    const raw = text(values, flag);
+    return raw === undefined ? undefined : parseWhen(raw, flag, deps.stderr);
+}
+function whenOrClear(values, flag, deps) {
+    const raw = text(values, flag);
+    if (raw !== undefined && CLEAR_WORDS.has(raw.trim().toLowerCase()))
+        return null;
+    return when(values, flag, deps);
+}
+function parseAction(raw) {
+    const [id, ...rest] = raw.split(":");
+    const last = rest[rest.length - 1];
+    const style = rest.length > 1 && STYLES.includes(last) ? last : undefined;
+    const label = (style ? rest.slice(0, -1) : rest).join(":");
+    if (!id || !label)
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, `--action must look like id:label or id:label:primary, got ${raw}`);
+    return style ? { id, label, style } : { id, label };
+}
+function parseItem(raw) {
+    const [id, ...rest] = raw.split(":");
+    const last = rest[rest.length - 1];
+    const flag = rest.length > 1 && (last === "selected" || last === "unselected") ? last : undefined;
+    const title = (flag ? rest.slice(0, -1) : rest).join(":");
+    if (!id || !title)
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, `--item must look like id:title or id:title:unselected, got ${raw}`);
+    return { id, title, selected: flag !== "unselected" };
+}
+function runUuid(values, env) {
+    return text(values, "run") ?? (0, config_1.assentEnv)(env, "RUN_UUID");
+}
+function parseRef(raw, flag) {
+    const [type, uuid] = (raw ?? "").split(":");
+    if (!ITEM_TYPES.includes(type) || !uuid)
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, `--${flag} must look like type:uuid with type one of ${ITEM_TYPES.join(", ")}`);
+    return { type, uuid };
+}
+function parseReason(raw) {
+    const at = raw.indexOf(":");
+    if (at < 1)
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, "--reason must look like id:text");
+    return [raw.slice(0, at), raw.slice(at + 1)];
+}
+const MAX_BADGES = 4;
+const MAX_LINKS = 4;
+function splitItemFlag(raw, flag, shape) {
+    const at = raw.indexOf(":");
+    if (at < 1 || at === raw.length - 1)
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, `--${flag} must look like ${shape}`);
+    return [raw.slice(0, at), raw.slice(at + 1)];
+}
+function groupByItem(entries, flag, base) {
+    const grouped = new Map();
+    for (const [id, value] of entries) {
+        if (!base.some((item) => item.id === id))
+            throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, `--${flag} ${id} does not match any item id`);
+        grouped.set(id, [...(grouped.get(id) ?? []), value]);
+    }
+    return grouped;
+}
+function appended(item, key, added, max) {
+    const all = [...(item[key] ?? []), ...added];
+    if (all.length > max)
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, `Item ${String(item.id)} can have at most ${max} ${key}`);
+    return all;
+}
+async function taskItems(values, deps) {
+    const fromJson = text(values, "item-json");
+    const base = fromJson === undefined ? many(values, "item").map(parseItem) : await (0, args_1.readItemsJson)(fromJson, (path) => deps.readFile(path), () => deps.readStdin());
+    const recommended = new Set(many(values, "recommend"));
+    const reasons = new Map(many(values, "reason").map(parseReason));
+    for (const id of recommended)
+        if (!base.some((item) => item.id === id))
+            throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, `--recommend ${id} does not match any item id`);
+    for (const id of reasons.keys())
+        if (!base.some((item) => item.id === id))
+            throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, `--reason ${id} does not match any item id`);
+    const badges = groupByItem(many(values, "badge").map((raw) => { const [id, rest] = splitItemFlag(raw, "badge", "itemId:label[:tone]"); return [id, (0, args_1.parseBadge)(rest)]; }), "badge", base);
+    const links = groupByItem(many(values, "link").map((raw) => { const [id, rest] = splitItemFlag(raw, "link", "itemId:label:url"); const [label, ...url] = rest.split(":"); return [id, (0, args_1.parseLink)(`${label}=${url.join(":")}`)]; }), "link", base);
+    return base.map((item) => ({
+        ...item,
+        ...(badges.has(String(item.id)) ? { badges: appended(item, "badges", badges.get(String(item.id)), MAX_BADGES) } : {}),
+        ...(links.has(String(item.id)) ? { links: appended(item, "links", links.get(String(item.id)), MAX_LINKS) } : {}),
+        ...(recommended.has(String(item.id)) ? { recommended: true } : {}),
+        ...(reasons.has(String(item.id)) ? { reason: (0, redact_1.redact)(reasons.get(String(item.id))) } : {}),
+    }));
+}
+const MAX_ATTACHMENTS = 4;
+async function uploadFile(api, deps, path, name) {
+    const bytes = deps.readBytes(path);
+    if (bytes === null)
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, `Cannot read ${path}`);
+    return api.attach(name ?? (0, node_path_1.basename)(path), bytes);
+}
+async function withAttachments(items, values, api, deps) {
+    const wanted = groupByItem(many(values, "attach").map((raw) => splitItemFlag(raw, "attach", "itemId:path")), "attach", items);
+    for (const [id, paths] of wanted) {
+        const item = items.find((candidate) => candidate.id === id);
+        if (paths.length + (item.attachments?.length ?? 0) > MAX_ATTACHMENTS)
+            throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, `Item ${id} can have at most ${MAX_ATTACHMENTS} attachments`);
+        for (const path of paths)
+            if (deps.readBytes(path) === null)
+                throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, `Cannot read ${path}`);
+    }
+    const uploaded = new Map();
+    for (const [id, paths] of wanted)
+        uploaded.set(id, await Promise.all(paths.map(async (path) => ({ uuid: (await uploadFile(api, deps, path)).uuid }))));
+    return items.map((item) => (uploaded.has(String(item.id)) ? { ...item, attachments: [...(item.attachments ?? []), ...uploaded.get(String(item.id))] } : item));
+}
+async function taskBody(values, kind, ctx) {
+    const { api, deps } = ctx;
+    const actions = many(values, "action").map(parseAction);
+    const items = await withAttachments(await taskItems(values, deps), values, api, deps);
+    const fields = many(values, "field").map(args_1.parseField);
+    const group = text(values, "group");
+    const parsedGroup = group === undefined ? undefined : (0, args_1.parseGroup)(group);
+    return {
+        kind,
+        title: (0, redact_1.redact)(required(values, "title")),
+        detail: redactOptional(text(values, "detail")),
+        why: redactOptional(text(values, "why")),
+        url: text(values, "url"),
+        actions: actions.length ? actions : undefined,
+        items: items.length ? items : undefined,
+        fields: fields.length ? fields : undefined,
+        group: parsedGroup === undefined ? undefined : { ...parsedGroup, title: (0, redact_1.redact)(parsedGroup.title) },
+        rules: (0, args_1.parseRules)(many(values, "conflict-on"), text(values, "total-of"), text(values, "decline-action")),
+        dueAt: when(values, "due", deps),
+        remindAt: when(values, "remind", deps),
+        dedupeKey: text(values, "dedupe"),
+        runUuid: runUuid(values, deps.env),
+        projectUuid: text(values, "project"),
+        projectTrack: text(values, "track"),
+        question: redactOptional(text(values, "question")),
+        answerType: answerType(values),
+        effortMinutes: effortMinutes(values),
+        seriesKey: text(values, "series"),
+        allowDuplicate: values["allow-duplicate"] === true ? true : undefined,
+        action: text(values, "rule-action"),
+        target: redactOptional(text(values, "target")),
+    };
+}
+function answerType(values) {
+    const value = text(values, "answer-type");
+    if (value !== undefined && !ANSWER_TYPES.includes(value))
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, `--answer-type must be one of ${ANSWER_TYPES.join(", ")}`);
+    return value;
+}
+function effortMinutes(values) {
+    const value = text(values, "effort");
+    if (value === undefined)
+        return undefined;
+    const minutes = Number(value);
+    if (!Number.isInteger(minutes) || minutes < 1 || minutes > 1440)
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, "--effort must be whole minutes from 1 to 1440");
+    return minutes;
+}
+function askKey(values) {
+    return text(values, "idempotency-key");
+}
+const resolveTask = async ({ api, args }) => {
+    const uuid = positional(args, 0, "The task uuid");
+    return { output: await api.resolve(uuid, { outcome: args.values.withdraw === true ? "withdrawn" : "resolved", note: redactOptional(text(args.values, "note")) }) };
+};
+function redactOptional(value) {
+    return value === undefined ? undefined : (0, redact_1.redact)(value);
+}
+function lockPath(ctx, resource) {
+    const keyId = (0, node_crypto_1.createHash)("sha256").update(ctx.agentKey).digest("hex").slice(0, 12);
+    return (0, node_path_1.join)(ctx.deps.home, ".ordia", "locks", `${keyId}-${encodeURIComponent(resource)}.json`);
+}
+function cachedToken(raw) {
+    if (raw === null)
+        return undefined;
+    try {
+        const parsed = JSON.parse(raw);
+        return typeof parsed?.token === "string" ? parsed.token : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const NUMBER_FRAGMENT = /^[\d()+-]+$/;
+const NEXT_WORD = /^\s{0,64}\S*/;
+const NUMBER_RUN = /^[\d()\- \t]*/;
+function dropCutWord(cut) {
+    const boundary = /\s/.exec(cut.slice(0, LOG_MARGIN_CHARS));
+    if (!boundary)
+        return cut.slice(LOG_MARGIN_CHARS);
+    const fragment = cut.slice(0, boundary.index);
+    const rest = cut.slice(boundary.index + 1);
+    if (fragment !== "" && "bearer".endsWith(fragment.toLowerCase()))
+        return rest.replace(NEXT_WORD, "");
+    if (NUMBER_FRAGMENT.test(fragment))
+        return rest.replace(NUMBER_RUN, "");
+    return rest;
+}
+function redactedTail(log, tailChars) {
+    const window = tailChars + LOG_MARGIN_CHARS;
+    if (log.length <= window)
+        return (0, redact_1.redact)(log).slice(-tailChars);
+    return (0, redact_1.redact)(dropCutWord(log.slice(-window))).slice(-tailChars);
+}
+const runStart = async ({ api, args }) => ({
+    output: await api.runStart({ summary: text(args.values, "summary"), maxMinutes: wholeNumber(args.values, "max-minutes", 1, 1440) }),
+});
+const runProgress = async ({ api, args }) => {
+    const uuid = positional(args, 0, "The run uuid");
+    const total = wholeNumber(args.values, "total", 1, 1000000);
+    const done = wholeNumber(args.values, "done", 0, 1000000);
+    if (total === undefined || done === undefined)
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, "Pass --done n and --total m");
+    const label = text(args.values, "label");
+    return { output: await api.runProgress(uuid, { done: Math.min(done, total), total, label: label === undefined ? undefined : (0, redact_1.redact)(label).slice(0, 120) }) };
+};
+const taskUpdate = async ({ api, args, deps }) => {
+    const uuid = positional(args, 0, "The task uuid");
+    const patch = { dueAt: whenOrClear(args.values, "due", deps), remindAt: whenOrClear(args.values, "remind", deps) };
+    if (patch.dueAt === undefined && patch.remindAt === undefined)
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, "Pass --due and/or --remind (a date and time, or none to clear)");
+    return { output: await api.taskUpdate(uuid, patch) };
+};
+const RESULT_KEYS = [["done", "done"], ["skipped", "skipped"], ["needs_you", "needs-you"], ["failed", "failed"]];
+const MAX_RESULT_COUNT = 1000;
+async function runResults(ctx) {
+    const source = text(ctx.args.values, "result-json");
+    const parsed = source === undefined ? {} : await (0, args_1.readJsonInput)(source, "result-json", (path) => ctx.deps.readFile(path), () => ctx.deps.readStdin());
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, "--result-json must be a JSON object like {\"done\":8,\"needs_you\":1}");
+    const given = parsed;
+    const results = {};
+    for (const [key, flag] of RESULT_KEYS) {
+        const typed = wholeNumber(ctx.args.values, flag, 0, MAX_RESULT_COUNT);
+        const value = typed ?? given[key];
+        if (value === undefined)
+            continue;
+        if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || value > MAX_RESULT_COUNT)
+            throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, `${key} must be a whole number from 0 to ${MAX_RESULT_COUNT}`);
+        results[key] = value;
+    }
+    return Object.keys(results).length ? results : undefined;
+}
+const runDefer = async ({ api, args, deps }) => {
+    const uuid = positional(args, 0, "The run uuid");
+    const retryAt = when(args.values, "retry-at", deps);
+    if (retryAt === undefined)
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, "Pass --retry-at with the date and time the job will try again");
+    return { output: await api.runDefer(uuid, { retryAt: new Date(retryAt).toISOString() }) };
+};
+const ISSUE_TEXT_LIMIT = 500;
+const runFinish = async (ctx) => {
+    const { api, args, deps } = ctx;
+    const uuid = positional(args, 0, "The run uuid");
+    const exitCode = wholeNumber(args.values, "exit-code", -2147483648, 2147483647);
+    const status = text(args.values, "status") ?? (exitCode === undefined ? undefined : exitCode === 0 ? "ok" : "fail");
+    if (status !== "ok" && status !== "fail" && status !== "deferred")
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, "Pass --exit-code n or --status ok|fail|deferred");
+    const reason = text(args.values, "issue-reason");
+    const impact = text(args.values, "impact");
+    const action = text(args.values, "action-needed");
+    if ((reason || impact || action) && (!reason || !impact || !action || !["needs_action", "recovery_exhausted", "deadline_at_risk"].includes(reason)))
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, "Pass --issue-reason needs_action|recovery_exhausted|deadline_at_risk with --impact and --action-needed");
+    if ((impact?.length ?? 0) > ISSUE_TEXT_LIMIT || (action?.length ?? 0) > ISSUE_TEXT_LIMIT)
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, `--impact and --action-needed take at most ${ISSUE_TEXT_LIMIT} characters each`);
+    const retryAt = when(args.values, "retry-at", deps);
+    if (retryAt !== undefined && status !== "deferred")
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, "A retry time requires --status deferred");
+    if (reason && status === "ok")
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, "A successful run cannot have an unresolved issue");
+    const logFile = text(args.values, "log-file");
+    const log = logFile === undefined ? null : deps.readFile(logFile);
+    const tailChars = wholeNumber(args.values, "log-tail-bytes", 1, 200000) ?? DEFAULT_TAIL_CHARS;
+    const summary = text(args.values, "summary");
+    return {
+        output: await api.runFinish(uuid, {
+            status,
+            ...(retryAt === undefined ? {} : { retryAt: new Date(retryAt).toISOString() }),
+            ...(reason && impact && action ? { issue: { reason, impact: (0, redact_1.redact)(impact), action: (0, redact_1.redact)(action) } } : {}),
+            exitCode,
+            taskUuid: text(args.values, "task"),
+            results: await runResults(ctx),
+            summary: summary === undefined ? undefined : (0, redact_1.redact)(summary).slice(0, SUMMARY_LIMIT),
+            logTail: log === null ? undefined : redactedTail(log, tailChars),
+        }),
+    };
+};
+async function pickUp(api, task) {
+    try {
+        return { output: await api.pickedUp(task.uuid) };
+    }
+    catch (err) {
+        if (err instanceof exit_codes_1.CliError && err.exitCode === exit_codes_1.EXIT.conflict)
+            return { output: { ...task, resumedBy: "helper" }, exitCode: exit_codes_1.EXIT.conflict };
+        throw err;
+    }
+}
+async function waitForAnswer(ctx, task) {
+    const timeoutMs = (wholeNumber(ctx.args.values, "timeout", 1, 604800) ?? 3600) * 1000;
+    const intervalMs = (wholeNumber(ctx.args.values, "interval", 1, 3600) ?? 15) * 1000;
+    const deadline = ctx.deps.now() + timeoutMs;
+    let current = task;
+    while (current.status === "open") {
+        if (current.answerExpiresAt !== null && Date.parse(current.answerExpiresAt) <= ctx.deps.now())
+            return { output: { ...current, status: "expired" }, exitCode: exit_codes_1.EXIT.conflict };
+        if (ctx.deps.now() >= deadline)
+            return { output: current, exitCode: exit_codes_1.EXIT.timeout };
+        await ctx.deps.sleep(intervalMs);
+        current = await ctx.api.task(current.uuid);
+    }
+    if (current.status !== "answered")
+        return { output: current, exitCode: current.status === "done" ? exit_codes_1.EXIT.ok : exit_codes_1.EXIT.conflict };
+    if (ctx.args.values["no-pickup"] === true)
+        return { output: current };
+    return pickUp(ctx.api, current);
+}
+async function replyDraft(values, kind, deps) {
+    const inline = text(values, "draft");
+    const file = text(values, "draft-file");
+    if (kind !== "reply") {
+        if (inline !== undefined || file !== undefined)
+            throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, "--draft and --draft-file are only for --kind reply");
+        return undefined;
+    }
+    if (inline !== undefined && file !== undefined)
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, "Pass --draft or --draft-file, not both");
+    const draft = inline ?? (file === undefined ? undefined : file === "-" ? await deps.readStdin() : deps.readFile(file));
+    if (file !== undefined && draft === null)
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, `Cannot read ${file}`);
+    if (!draft?.trim())
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, "--kind reply needs --draft, or --draft-file with a path or - for stdin");
+    return draft.replace(/\r?\n$/, "");
+}
+const ask = async (ctx) => {
+    const kind = text(ctx.args.values, "kind") ?? "approve";
+    if (!KINDS.includes(kind))
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, `--kind must be one of ${KINDS.join(", ")}`);
+    const draft = await replyDraft(ctx.args.values, kind, ctx.deps);
+    const task = await ctx.api.ask({ ...(await taskBody(ctx.args.values, kind, ctx)), draft }, askKey(ctx.args.values));
+    return ctx.args.values.wait === true ? waitForAnswer(ctx, task) : { output: task };
+};
+const note = async ({ api, args, deps }) => {
+    const title = required(args.values, "title");
+    const inline = text(args.values, "content");
+    const file = text(args.values, "content-file");
+    const content = inline ?? (file === undefined ? undefined : file === "-" ? await deps.readStdin() : deps.readFile(file));
+    if (content === undefined || content === null)
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, "Pass --content, or --content-file with a readable path or - for stdin");
+    const tags = many(args.values, "tag");
+    return { output: await api.note({ title: (0, redact_1.redact)(title), content: (0, redact_1.redact)(content), tags: tags.length ? tags : undefined, runUuid: runUuid(args.values, deps.env) }) };
+};
+const noteUpdate = async ({ api, args, deps }) => {
+    const uuid = positional(args, 0, "The note uuid");
+    const file = text(args.values, "content-file");
+    const content = text(args.values, "content") ?? (file === undefined ? undefined : file === "-" ? await deps.readStdin() : deps.readFile(file));
+    if (content === null)
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, `Cannot read ${file}`);
+    const tags = many(args.values, "tag");
+    const patch = { title: redactOptional(text(args.values, "title")), content: redactOptional(content), tags: tags.length ? tags : undefined };
+    if (Object.values(patch).every((v) => v === undefined))
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, "Pass --title, --content, --content-file or --tag");
+    return { output: await api.noteUpdate(uuid, patch) };
+};
+const link = async ({ api, args }) => {
+    const relation = text(args.values, "relation") ?? "related";
+    if (!RELATIONS.includes(relation))
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, `--relation must be one of ${RELATIONS.join(", ")}`);
+    return { output: await api.link({ from: parseRef(text(args.values, "from"), "from"), to: parseRef(text(args.values, "to"), "to"), relation }) };
+};
+const handoff = async ({ api, args, deps }) => {
+    const toAgentName = text(args.values, "to");
+    const toAgentUuid = text(args.values, "to-uuid");
+    if (!toAgentName && !toAgentUuid)
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, "Pass --to <agent name> or --to-uuid <agent uuid>");
+    return { output: await api.handoff({ toAgentName, toAgentUuid, title: required(args.values, "title"), detail: text(args.values, "detail"), runUuid: runUuid(args.values, deps.env) }) };
+};
+const lockAcquire = async (ctx) => {
+    const resource = positional(ctx.args, 0, "The resource, for example deploy:vps,");
+    const ttlMinutes = wholeNumber(ctx.args.values, "ttl", 1, 720) ?? 30;
+    const waitMs = (wholeNumber(ctx.args.values, "wait", 0, 86400) ?? 0) * 1000;
+    const intervalMs = (wholeNumber(ctx.args.values, "interval", 1, 3600) ?? 15) * 1000;
+    const deadline = ctx.deps.now() + waitMs;
+    for (;;) {
+        const result = await ctx.api.lockAcquire({ resource, ttlMinutes });
+        if (result.acquired) {
+            ctx.deps.writeFile(lockPath(ctx, resource), JSON.stringify({ resource, token: result.token, expiresAt: result.expiresAt }));
+            return { output: result };
+        }
+        if (ctx.deps.now() + intervalMs > deadline)
+            return { output: result, exitCode: exit_codes_1.EXIT.conflict };
+        await ctx.deps.sleep(intervalMs);
+    }
+};
+const lockRelease = async (ctx) => {
+    const resource = positional(ctx.args, 0, "The resource, for example deploy:vps,");
+    const path = lockPath(ctx, resource);
+    const token = text(ctx.args.values, "token") ?? cachedToken(ctx.deps.readFile(path));
+    if (!token)
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, `No saved token for ${resource}; pass --token`);
+    try {
+        const output = await ctx.api.lockRelease({ resource, token });
+        ctx.deps.removeFile(path);
+        return { output };
+    }
+    catch (err) {
+        if (err instanceof exit_codes_1.CliError && err.exitCode === exit_codes_1.EXIT.notFound)
+            ctx.deps.removeFile(path);
+        throw err;
+    }
+};
+function itemState(task, itemId) {
+    if (task.withdrawnItemIds?.includes(itemId))
+        return "withdrawn";
+    if (task.heldItemIds?.includes(itemId))
+        return "held";
+    const selected = task.answer?.selectedItemIds ?? [];
+    if (!selected.includes(itemId))
+        return "not_selected";
+    return task.itemOutcomes?.find((entry) => entry.itemId === itemId)?.outcome ?? "go";
+}
+const itemResult = async ({ api, args }) => {
+    const uuid = positional(args, 0, "The task uuid");
+    const itemId = positional(args, 1, "The item id");
+    const outcome = positional(args, 2, "The outcome");
+    if (!ITEM_OUTCOMES.includes(outcome))
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, `outcome must be one of ${ITEM_OUTCOMES.join(", ")}`);
+    const url = text(args.values, "url");
+    if (url !== undefined && !/^https?:\/\//.test(url))
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, "--url must start with http:// or https://");
+    return { output: await api.itemResult(uuid, itemId, { outcome, reason: redactOptional(text(args.values, "reason")), url }) };
+};
+const itemStatus = async ({ api, args }) => {
+    const uuid = positional(args, 0, "The task uuid");
+    const itemId = positional(args, 1, "The item id");
+    return { output: { itemId, state: itemState(await api.task(uuid), itemId) } };
+};
+async function planBody(ctx) {
+    const source = required(ctx.args.values, "file");
+    const parsed = await (0, args_1.readJsonInput)(source, "file", (path) => ctx.deps.readFile(path), () => ctx.deps.readStdin());
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, "--file must be a JSON object");
+    return parsed;
+}
+const planCreate = async (ctx) => ({
+    output: await ctx.api.planCreate(await planBody(ctx), text(ctx.args.values, "idempotency-key") ?? (0, node_crypto_1.randomUUID)()),
+});
+const planSessions = async (ctx) => {
+    const uuid = positional(ctx.args, 0, "The plan uuid");
+    return { output: await ctx.api.planSessions(uuid, await planBody(ctx)) };
+};
+const RULE_EXPIRIES = ["1d", "7d", "30d", "none"];
+const RULE_EXIT = { allow: exit_codes_1.EXIT.ok, deny: exit_codes_1.EXIT.ruleDeny };
+const ALLOW_FROM_PERSON = "Agents can only add deny rules. For an allow rule, ask with --rule-action and --target and the person can answer Always in Assent.";
+const rulesCheck = async ({ api, args }) => {
+    const output = await api.rulesCheck({ action: required(args.values, "action"), target: redactOptional(text(args.values, "target")), summary: redactOptional(text(args.values, "summary")) });
+    return { output, exitCode: RULE_EXIT[output.decision] ?? exit_codes_1.EXIT.ruleAsk };
+};
+const rulesAdd = async ({ api, args }) => {
+    if (args.values.allow === true || args.values.deny !== true)
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, ALLOW_FROM_PERSON);
+    const expiresIn = text(args.values, "expires") ?? "none";
+    if (!RULE_EXPIRIES.includes(expiresIn))
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, `--expires must be one of ${RULE_EXPIRIES.join(", ")}`);
+    return { output: await api.rulesAdd({ effect: "deny", action: required(args.values, "action"), target: text(args.values, "target"), reason: redactOptional(text(args.values, "reason")), expiresIn }) };
+};
+const taskAdd = async (ctx) => {
+    const parentTaskUuid = text(ctx.args.values, "parent");
+    const parentItemId = text(ctx.args.values, "parent-item");
+    if ((parentTaskUuid === undefined) !== (parentItemId === undefined))
+        throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, "--parent and --parent-item go together");
+    return { output: await ctx.api.ask({ ...(await taskBody(ctx.args.values, "todo", ctx)), parentTaskUuid, parentItemId }, askKey(ctx.args.values)) };
+};
+const COMMANDS = {
+    whoami: { options: {}, handler: async ({ api }) => ({ output: await api.me() }) },
+    "run start": { options: { summary: STRING, "max-minutes": STRING }, handler: runStart },
+    "run progress": { options: { done: STRING, total: STRING, label: STRING }, handler: runProgress },
+    "run finish": { options: { "issue-reason": STRING, impact: STRING, "action-needed": STRING, status: STRING, "retry-at": STRING, "exit-code": STRING, summary: STRING, "log-file": STRING, "log-tail-bytes": STRING, task: STRING, "result-json": STRING, done: STRING, skipped: STRING, "needs-you": STRING, failed: STRING }, handler: runFinish },
+    "run defer": { options: { "retry-at": STRING }, handler: runDefer },
+    ask: { options: { ...TASK_OPTIONS, kind: STRING, draft: STRING, "draft-file": STRING, action: MANY, item: MANY, attach: MANY, "item-json": STRING, recommend: MANY, reason: MANY, badge: MANY, link: MANY, field: MANY, group: STRING, "conflict-on": MANY, "total-of": STRING, "decline-action": STRING, "rule-action": STRING, target: STRING, wait: FLAG, "no-pickup": FLAG, timeout: STRING, interval: STRING }, handler: ask },
+    attach: { options: { name: STRING }, handler: async ({ api, args, deps }) => ({ output: await uploadFile(api, deps, positional(args, 0, "The file path"), text(args.values, "name")) }) },
+    answers: { options: {}, handler: async ({ api }) => ({ output: await api.answers() }) },
+    "picked-up": { options: {}, handler: async ({ api, args }) => ({ output: await api.pickedUp(positional(args, 0, "The task uuid")) }) },
+    "task add": { options: { ...TASK_OPTIONS, parent: STRING, "parent-item": STRING }, handler: taskAdd },
+    "task resolve": { options: { withdraw: FLAG, note: STRING }, handler: resolveTask },
+    "task update": { options: { due: STRING, remind: STRING }, handler: taskUpdate },
+    "task item-result": { options: { reason: STRING, url: STRING }, handler: itemResult },
+    "task item-status": { options: {}, handler: itemStatus },
+    "task get": { options: {}, handler: async ({ api, args }) => ({ output: await api.task(positional(args, 0, "The task uuid")) }) },
+    note: { options: { title: STRING, content: STRING, "content-file": STRING, tag: MANY, run: STRING }, handler: note },
+    "note update": { options: { title: STRING, content: STRING, "content-file": STRING, tag: MANY }, handler: noteUpdate },
+    link: { options: { from: STRING, to: STRING, relation: STRING }, handler: link },
+    "memory get": { options: {}, handler: async ({ api }) => ({ output: await api.memory() }) },
+    "lock acquire": { options: { ttl: STRING, wait: STRING, interval: STRING }, handler: lockAcquire },
+    "lock release": { options: { token: STRING }, handler: lockRelease },
+    handoff: { options: { to: STRING, "to-uuid": STRING, title: STRING, detail: STRING, run: STRING }, handler: handoff },
+    handoffs: { options: {}, handler: async ({ api }) => ({ output: await api.handoffs() }) },
+    "plan create": { options: { file: STRING, "idempotency-key": STRING }, handler: planCreate },
+    "project get": { options: {}, handler: async ({ api, args }) => ({ output: await api.projectGet(positional(args, 0, "The project uuid")) }) },
+    "project overview": { options: {}, handler: async ({ api, args }) => ({ output: await api.projectOverview(positional(args, 0, "The project uuid")) }) },
+    "plan get": { options: {}, handler: async ({ api, args }) => ({ output: await api.planGet(positional(args, 0, "The plan uuid")) }) },
+    "plan sessions": { options: { file: STRING }, handler: planSessions },
+    "rules check": { options: { action: STRING, target: STRING, summary: STRING }, handler: rulesCheck },
+    "rules list": { options: {}, handler: async ({ api }) => ({ output: await api.rulesList() }) },
+    "rules add": { options: { deny: FLAG, allow: FLAG, action: STRING, target: STRING, reason: STRING, expires: STRING }, handler: rulesAdd },
+    "rules remove": { options: {}, handler: async ({ api, args }) => ({ output: await api.rulesRemove(positional(args, 0, "The rule uuid")) }) },
+    "handoffs done": { options: {}, handler: async ({ api, args }) => ({ output: await api.completeTask(positional(args, 0, "The task uuid")) }) },
+};
+function resolveCommand(argv, name) {
+    const two = `${argv[0]} ${argv[1] ?? ""}`;
+    if (Object.hasOwn(COMMANDS, two))
+        return { def: COMMANDS[two], rest: argv.slice(2) };
+    if (Object.hasOwn(COMMANDS, argv[0]))
+        return { def: COMMANDS[argv[0]], rest: argv.slice(1) };
+    throw new exit_codes_1.CliError(exit_codes_1.EXIT.usage, `Unknown command: ${argv.slice(0, 2).join(" ")}. Run ${name} help`);
+}
+function print(deps, output, field) {
+    if (field === undefined) {
+        deps.stdout(JSON.stringify(output));
+        return;
+    }
+    const value = output[field];
+    deps.stdout(typeof value === "string" ? value : JSON.stringify(value ?? null));
+}
+function commandName(startedAs) {
+    return startedAs !== undefined && (0, node_path_1.basename)(startedAs) === usage_1.LEGACY_COMMAND ? usage_1.LEGACY_COMMAND : usage_1.COMMAND;
+}
+async function runCli(argv, deps) {
+    if (argv.length === 0 || argv[0] === "help" || argv[0] === "--help" || argv[0] === "-h") {
+        deps.stdout((0, usage_1.usage)(deps.name ?? usage_1.COMMAND));
+        return exit_codes_1.EXIT.ok;
+    }
+    if (argv[0] === "hook" && argv[1] === "claude-code")
+        return (0, claude_code_1.runClaudeCodeSetup)(argv.slice(2), deps);
+    if (argv[0] === "hook")
+        return (0, hook_1.runHook)(argv.slice(1), deps);
+    if (argv[0] === "mcp")
+        return (0, mcp_bridge_1.runMcpBridge)(deps);
+    if (argv[0] === "--version") {
+        deps.stdout(usage_1.VERSION);
+        return exit_codes_1.EXIT.ok;
+    }
+    try {
+        const { def, rest } = resolveCommand(argv, deps.name ?? usage_1.COMMAND);
+        const args = (0, args_1.parseCommandArgs)(rest, def.options);
+        const config = (0, config_1.loadCliConfig)({ env: deps.env, home: deps.home, readFile: deps.readFile, exists: (path) => deps.readFile(path) !== null });
+        const api = client_1.AgentApi.fromConfig(config, deps.fetchImpl);
+        const { output, exitCode = exit_codes_1.EXIT.ok } = await def.handler({ api, deps, args, agentKey: config.agentKey });
+        print(deps, output, text(args.values, "get"));
+        return exitCode;
+    }
+    catch (err) {
+        if (err instanceof exit_codes_1.CliError) {
+            deps.stderr(JSON.stringify({ error: err.message, exitCode: err.exitCode, status: err.status ?? null }));
+            return err.exitCode;
+        }
+        deps.stderr(JSON.stringify({ error: err.message, exitCode: exit_codes_1.EXIT.failure, status: null }));
+        return exit_codes_1.EXIT.failure;
+    }
+}