@maiaos/cli 0.1.0-canary.44938d4.manual.1

package/dist/command-line/output.js

@@ -0,0 +1,643 @@
+import { projectDispatchSettleResult, projectDispatchShowDispatch, projectInboxAckResult, projectQuestionCancelResult, projectQuestionOpenResult, projectQuestionReplyResult, projectRunCreateResult, projectRunShowResult, } from "../orchestration/compact-aggregate.js";
+import { projectRunListResult } from "../orchestration/compact-run-list.js";
+import { projectStatusResult } from "../status/compact.js";
+import { HELP_USAGE } from "./help.js";
+const EXIT_DATA_NOT_FOUND = 66;
+const EXIT_USAGE = 64;
+const EXIT_UNAVAILABLE = 69;
+const EXIT_SOFTWARE = 70;
+const EXIT_DEADLINE = 74;
+const EXIT_TEMPORARY = 75;
+const EXIT_OUTCOME_UNKNOWN = 76;
+const EXIT_PERMISSION = 77;
+const projectRuntimeListItem = (item) => item.detected
+    ? { harnessId: item.harnessId, status: item.status }
+    : {
+        harnessId: item.harnessId,
+        reason: item.reason,
+        status: item.status,
+    };
+const isHelpFamilyResult = (result) => "family" in result;
+const formatHumanHelpIndex = (result) => {
+    const commandLines = result.commands
+        .map((command) => `  ${command.name.padEnd(12)}${command.summary}`)
+        .join("\n");
+    return `Maia CLI ${result.version}\n\nUsage:\n  ${HELP_USAGE.join("\n  ")}\n\nCallable commands:\n${commandLines}\n\nCommands use the SDK and the same durable node state.\n`;
+};
+const formatHumanHelp = (result) => {
+    if (!isHelpFamilyResult(result))
+        return formatHumanHelpIndex(result);
+    if (result.usage.length === 0) {
+        return `Maia CLI ${result.version}\n\nNo usage rows for that command family.\n`;
+    }
+    return `Maia CLI ${result.version}\n\nUsage:\n  ${result.usage.map((row) => row.usage).join("\n  ")}\n`;
+};
+const processResourceNextStep = (nextStep) => {
+    switch (nextStep) {
+        case "close_idle_terminal":
+            return "close an idle Maia terminal, then retry";
+        case "inspect_cleanup_unknown":
+            return "inspect cleanup-unknown terminals and processes before restart";
+        case "inspect_observed_pressure":
+            return "inspect per-tree pressure warnings; termination stays disabled";
+        case "none":
+            return "none";
+        case "verify_native_host":
+            return "verify the native process host";
+    }
+};
+const formatObservedMetric = (label, metric) => `${label} ${metric.state}${metric.maximumValue === undefined ? "" : ` max ${String(metric.maximumValue)}`}; budget ${metric.budget}; ${String(metric.warningTrees)} warning`;
+const formatHumanStatus = (result) => {
+    const { node } = result;
+    const resources = node.processResources;
+    const observed = resources.observations;
+    return `Maia node ${node.lifecycle}\n  profile: ${node.profile}\n  pid: ${String(node.pid)}\n  instance: ${node.instanceId}\n  storage: ${node.storage.integrity} (${node.storage.journalMode})\n  process resources: ${resources.pressure} (${resources.capability.mode}; hard limits ${resources.capability.hardLimitEnforcement}; release qualified ${String(resources.capability.releaseQualified)})\n  admission: ${resources.admission.state}; ${String(resources.admission.usedTrees)}/${String(resources.admission.capacity)} used; ${String(resources.admission.availableTrees)} available; ${String(resources.admission.queuedSpawns)} queued\n  ownership: ${String(resources.activeTrees)} active; ${String(resources.fencedTrees)} fenced; ${String(resources.cleanupUnknownTrees)} cleanup unknown; ${String(resources.supervision.watcherFibers)} watcher fibers\n  latest target observations: ${[
+        formatObservedMetric("cpu-ms", observed.cpuTimeMilliseconds),
+        formatObservedMetric("rss-bytes", observed.rssBytes),
+        formatObservedMetric("peak-rss-bytes", observed.observedPeakRssBytes),
+        formatObservedMetric("processes", observed.processCount),
+        formatObservedMetric("fds", observed.fileDescriptorCount),
+        formatObservedMetric("io-read-bytes", observed.ioReadBytes),
+        formatObservedMetric("io-write-bytes", observed.ioWriteBytes),
+    ].join("; ")}\n  observed-pressure termination: ${resources.capability.observedPressureTermination}; samples are advisory, not hard enforcement or automatic kill\n  inspect: --json compact; SDK lossless\n  next step: ${processResourceNextStep(resources.nextStep)}\n`;
+};
+const formatIntegration = (result) => {
+    switch (result.command) {
+        case "integration.plan": {
+            const target = result.result.plan.target;
+            const digest = target.adapter === "codex"
+                ? target.executableSha256
+                : target.packageClosure.closureSha256;
+            return `${result.result.integration}\tplanned\t${result.result.plan.planId}\t${result.result.plan.expiresAt}\t${digest}\n`;
+        }
+        case "integration.apply":
+            return `${result.result.integration}\t${result.result.authorization.state}\t${result.result.authorization.revision}\n`;
+        case "integration.remove":
+            return `${result.result.integration}\t${result.result.outcome}\t${result.result.authorization.revision}\n`;
+        case "integration.status": {
+            const item = result.result.items[0];
+            return item.authorizationAvailable
+                ? `${result.result.integration}\t${item.authorization.state}\t${item.authorization.revision}\t${item.nextAction}\n`
+                : `${result.result.integration}\tunavailable\t${item.reason}\t${item.nextAction}\n`;
+        }
+    }
+};
+const formatRuntimeList = (items) => formatRows(items, (item) => {
+    const reason = item.reason;
+    return reason === undefined
+        ? `${item.harnessId}\t${item.status}`
+        : `${item.harnessId}\t${item.status}\t${reason}`;
+}, true);
+const formatRuntimeProbe = (result) => {
+    const runtime = result.adapter === "pi-rpc" ? "pi-rpc" : "codex";
+    if (result.status === "ready") {
+        return `${runtime}\tready\t${result.executableVersion}\t${String(result.handshakeMilliseconds)}ms\n`;
+    }
+    const version = result.status === "incompatible" && result.executableVersion !== undefined
+        ? `\t${result.executableVersion}`
+        : "";
+    return `${runtime}\t${result.status}\t${result.reason}${version}\n`;
+};
+const isTerminalControl = (character) => {
+    const point = character.codePointAt(0);
+    return (point !== undefined &&
+        (point <= 31 ||
+            (point >= 127 && point <= 159) ||
+            point === 8232 ||
+            point === 8233));
+};
+const formatTerminalCell = (value) => Array.from(value, (character) => isTerminalControl(character) ? "�" : character).join("");
+const formatRows = (items, format, newlineWhenEmpty = false) => `${items.map(format).join("\n")}${items.length > 0 || newlineWhenEmpty ? "\n" : ""}`;
+const tab = (values) => values.join("\t");
+const formatProjectList = (result) => formatRows(result.items, (project) => `${project.id}\t${formatTerminalCell(project.name)}\t${project.revision}`);
+const formatWorkspaceList = (result) => formatRows(result.items, (workspace) => `${workspace.id}\t${formatTerminalCell(workspace.name)}\t${workspace.kind}\t${workspace.revision}`);
+const formatSessionList = (result) => formatRows(result.items, (session) => `${session.id}\t${session.runtime}\t${session.state}\t${session.workspaceId}`);
+const formatSessionSuccess = (result) => {
+    switch (result.command) {
+        case "session.create":
+            return `${result.result.sessionId}\n`;
+        case "session.events":
+            return formatRows(result.result.items, (event) => `${event.sessionCursor}\t${event.eventType}\t${event.globalCursor}`);
+        case "session.list":
+            return formatSessionList(result.result);
+        case "session.show":
+            return `${result.result.session.id}\t${result.result.session.runtime}\t${result.result.session.state}\t${result.result.session.workspaceId}\n`;
+        case "session.start":
+            return `${result.result.sessionId}\t${result.result.state}\t${result.result.revision}\n`;
+    }
+};
+const formatWorkspaceSuccess = (result) => {
+    switch (result.command) {
+        case "workspace.execution.configure":
+            return `${result.result.workspaceId}\t${result.result.workspaceRevision}\t${result.result.resolution.status}\t${result.result.resolution.reason}\n`;
+        case "workspace.execution.show":
+            return `${result.result.workspace.id}\t${result.result.workspace.revision}\t${result.result.resolution.status}\t${result.result.resolution.reason}\n`;
+        case "workspace.list":
+            return formatWorkspaceList(result.result);
+        case "workspace.repo.add":
+            return `${result.result.repositoryId}\n`;
+        case "workspace.show":
+            return `${result.result.workspace.id}\t${formatTerminalCell(result.result.workspace.name)}\t${result.result.workspace.revision}\n`;
+    }
+};
+const formatTurnSuccess = (result) => {
+    switch (result.command) {
+        case "turn.interrupt":
+        case "turn.send":
+            return `${result.result.turnId}\t${result.result.state}\t${result.result.revision}\n`;
+        case "turn.show": {
+            const turn = result.result.turn;
+            return `${turn.id}\t${turn.state}\t${turn.revision}\t${turn.sessionId}\n`;
+        }
+    }
+};
+const isHumanLiveTerminal = (terminal) => terminal.state !== "unavailable" && "capability" in terminal;
+const formatTerminalProjection = (terminal) => {
+    if (terminal.state === "unavailable") {
+        return `${formatTerminalCell(terminal.id)}\t${formatTerminalCell(terminal.state)}\t${formatTerminalCell(terminal.unavailability.code)}\t${formatTerminalCell(terminal.workspaceId)}`;
+    }
+    if (!isHumanLiveTerminal(terminal)) {
+        throw new Error("Human live terminal TSV requires capability.tier.");
+    }
+    return `${formatTerminalCell(terminal.id)}\t${formatTerminalCell(terminal.state)}\t${formatTerminalCell(terminal.capability.tier)}\t${formatTerminalCell(terminal.workspaceId)}`;
+};
+export const formatTerminalList = (result) => formatRows(result.items, formatTerminalProjection);
+export const formatTerminalShow = (result) => `${formatTerminalProjection(result.terminal)}\n`;
+const isHumanLegacyEvent = (event) => "unavailability" in event && "globalCursor" in event;
+const formatTerminalEvent = (event) => {
+    if ("unavailability" in event) {
+        if (!isHumanLegacyEvent(event)) {
+            throw new Error("Human legacy terminal event TSV requires globalCursor.");
+        }
+        return `${formatTerminalCell(event.cursor)}\t${formatTerminalCell(event.type)}\t${formatTerminalCell(event.globalCursor)}`;
+    }
+    return `${formatTerminalCell(event.cursor)}\t${formatTerminalCell(event.type)}`;
+};
+export const formatTerminalEvents = (result) => formatRows(result.items, formatTerminalEvent);
+export const formatTerminalRead = (result) => formatRows(result.items, (chunk) => `${formatTerminalCell(chunk.cursor)}\t${chunk.bytesBase64}`);
+const formatTerminalSuccess = (result) => {
+    switch (result.command) {
+        case "terminal.create":
+            return "accepted" in result.result && !result.result.accepted
+                ? `${result.result.terminalId}\t${result.result.state}\t${result.result.unavailability.code}\n`
+                : `${JSON.stringify(result.result)}\n`;
+        case "terminal.close":
+        case "terminal.controller.acquire":
+        case "terminal.controller.release":
+        case "terminal.controller.request":
+        case "terminal.controller.request.show":
+        case "terminal.input.write":
+        case "terminal.resize":
+        case "terminal.signal":
+            return `${JSON.stringify(result.result)}\n`;
+        case "terminal.events":
+            return formatTerminalEvents(result);
+        case "terminal.list":
+            return formatTerminalList(result);
+        case "terminal.read":
+            return formatTerminalRead(result);
+        case "terminal.show":
+            return formatTerminalShow(result);
+    }
+};
+const formatProjectSuccess = (result) => {
+    switch (result.command) {
+        case "project.add":
+            return `${result.result.projectId}\n`;
+        case "project.list":
+            return formatProjectList(result.result);
+        case "project.show":
+            return `${result.result.project.id}\t${formatTerminalCell(result.result.project.name)}\t${result.result.project.revision}\n`;
+    }
+};
+const isProjectResult = (result) => result.command.startsWith("project.");
+const isOrchestrationResult = (result) => result.command.startsWith("run.");
+const isSessionResult = (result) => result.command.startsWith("session.");
+const isTerminalResult = (result) => result.command.startsWith("terminal.");
+const isTurnResult = (result) => result.command.startsWith("turn.");
+const isWorkspaceResult = (result) => result.command.startsWith("workspace.");
+export const formatInboxAck = (result) => `${tab([
+    result.command,
+    result.receipt.commandId,
+    result.runId,
+    result.owner.kind,
+    result.owner.id,
+    result.mailboxRevision,
+    result.receipt.state,
+])}\n${tab([
+    result.delivery.deliveryId,
+    result.delivery.sequence,
+    result.delivery.type,
+    formatTerminalCell(result.delivery.subject),
+])}\n`;
+const formatInboxCheck = (result) => {
+    const header = tab([
+        result.command,
+        result.runId,
+        result.owner.kind,
+        result.owner.id,
+        String(result.count),
+        result.mailboxRevision,
+    ]);
+    if (result.items.length === 0)
+        return `${header}\n`;
+    return `${header}\n${result.items
+        .map((item) => tab([
+        item.deliveryId,
+        item.sequence,
+        item.type,
+        formatTerminalCell(item.subject),
+    ]))
+        .join("\n")}\n`;
+};
+export const formatReceiptList = (result) => {
+    const header = tab([
+        result.command,
+        String(result.count),
+        result.nextCursor ?? "-",
+    ]);
+    if (result.items.length === 0)
+        return `${header}\n`;
+    return `${header}\n${result.items
+        .map((item) => tab([
+        item.commandId,
+        item.method,
+        item.state,
+        item.target.type,
+        item.target.id,
+    ]))
+        .join("\n")}\n`;
+};
+export const formatRunList = (result) => {
+    const header = tab([
+        result.command,
+        result.workspaceId,
+        String(result.count),
+        result.nextCursor ?? "-",
+    ]);
+    if (result.items.length === 0)
+        return `${header}\n`;
+    return `${header}\n${result.items
+        .map((item) => tab([
+        item.id,
+        item.state,
+        item.revision,
+        item.terminalId,
+        item.rootTaskId,
+        item.dispatchTaskId,
+    ]))
+        .join("\n")}\n`;
+};
+const formatTaskList = (result) => {
+    const header = tab([
+        result.command,
+        result.runId,
+        String(result.count),
+        result.nextCursor ?? "-",
+    ]);
+    if (result.items.length === 0)
+        return `${header}\n`;
+    return `${header}\n${result.items
+        .map((item) => tab([item.id, item.clientKey, item.state, item.revision]))
+        .join("\n")}\n`;
+};
+const formatTaskShow = (result) => [
+    tab([
+        result.command,
+        result.task.runId,
+        result.task.id,
+        result.task.clientKey,
+        result.task.state,
+        result.task.revision,
+    ]),
+    formatTerminalCell(result.task.objective),
+    "",
+].join("\n");
+const formatDispatchShow = (result) => {
+    const header = tab([
+        result.command,
+        result.dispatch.runId,
+        result.dispatch.id,
+        result.dispatch.taskId,
+        result.dispatch.state,
+        result.dispatch.revision,
+    ]);
+    if (result.dispatch.state !== "failed" ||
+        result.dispatch.failure === undefined) {
+        return `${header}\n`;
+    }
+    return `${header}\n${result.dispatch.failure.code}\t${result.dispatch.failure.platform}\n`;
+};
+const formatFailedDispatchLine = (dispatch) => dispatch.state === "failed" && dispatch.failure !== undefined
+    ? `${dispatch.failure.code}\t${dispatch.failure.platform}\n`
+    : "";
+const formatMailboxLines = (mailboxes) => `${mailboxes.map((mailbox) => `${mailbox.owner.kind}\t${mailbox.id}\t${mailbox.revision}`).join("\n")}\n`;
+const formatQuestionLines = (question) => {
+    if (question === undefined)
+        return "";
+    const lines = [
+        `${question.id}\t${question.state}\t${question.revision}`,
+        formatTerminalCell(question.subject),
+        formatTerminalCell(question.body),
+    ];
+    if (question.state === "answered" && question.answer !== undefined) {
+        lines.push(formatTerminalCell(question.answer));
+    }
+    return `${lines.join("\n")}\n`;
+};
+const formatDeliveryLine = (delivery) => delivery === undefined
+    ? ""
+    : `${delivery.deliveryId}\t${delivery.sequence}\t${delivery.type}\t${formatTerminalCell(delivery.subject)}\n`;
+const formatCompactAggregateBody = (aggregate, delivery) => `${formatFailedDispatchLine(aggregate.dispatch)}${formatMailboxLines(aggregate.mailboxes)}${formatQuestionLines(aggregate.question)}${formatDeliveryLine(delivery)}`;
+export const formatRunShow = (result) => `${tab([
+    result.command,
+    result.aggregate.run.id,
+    result.aggregate.run.state,
+    result.aggregate.run.revision,
+    result.aggregate.dispatch.id,
+    result.aggregate.dispatch.state,
+    result.aggregate.dispatch.revision,
+])}\n${formatCompactAggregateBody(result.aggregate)}`;
+export const formatRunCreate = (result) => `${tab([
+    result.command,
+    result.delivery,
+    result.receipt.commandId,
+    result.aggregate.run.id,
+    result.aggregate.run.revision,
+    result.aggregate.dispatch.id,
+    result.aggregate.dispatch.revision,
+])}\n${formatCompactAggregateBody(result.aggregate, result.initialDelivery)}`;
+const formatQuestionMutation = (result) => `${tab([
+    result.command,
+    result.receipt.commandId,
+    result.aggregate.run.id,
+    result.aggregate.question?.id ?? "",
+    result.aggregate.question?.revision ?? "",
+    result.aggregate.run.revision,
+    result.aggregate.dispatch.revision,
+])}\n${formatCompactAggregateBody(result.aggregate, result.delivery)}`;
+export const formatQuestionOpen = (result) => formatQuestionMutation(result);
+export const formatQuestionReply = (result) => formatQuestionMutation(result);
+export const formatQuestionCancel = (result) => `${tab([
+    result.command,
+    result.receipt.commandId,
+    result.aggregate.run.id,
+    result.aggregate.run.revision,
+    result.aggregate.dispatch.revision,
+])}\n${formatCompactAggregateBody(result.aggregate)}`;
+export const formatDispatchSettle = (result) => `${tab([
+    result.command,
+    result.receipt.commandId,
+    result.aggregate.run.id,
+    result.aggregate.dispatch.state,
+    result.aggregate.run.revision,
+    result.aggregate.dispatch.revision,
+])}\n${formatCompactAggregateBody(result.aggregate, result.delivery)}`;
+const formatCompactOrchestration = (result) => {
+    if (result.command === "run.inbox.ack")
+        return formatInboxAck(result);
+    if (result.command === "run.inbox.check")
+        return formatInboxCheck(result);
+    if (result.command === "run.task.list")
+        return formatTaskList(result);
+    if (result.command === "run.task.show")
+        return formatTaskShow(result);
+    if (result.command === "run.dispatch.show")
+        return formatDispatchShow(result);
+    if (result.command === "run.show")
+        return formatRunShow(result);
+    if (result.command === "run.create")
+        return formatRunCreate(result);
+    if (result.command === "run.question.open")
+        return formatQuestionOpen(result);
+    if (result.command === "run.question.reply") {
+        return formatQuestionReply(result);
+    }
+    if (result.command === "run.question.cancel") {
+        return formatQuestionCancel(result);
+    }
+    if (result.command === "run.dispatch.settle-terminal") {
+        return formatDispatchSettle(result);
+    }
+    return formatRunList(result);
+};
+const formatNodeSuccess = (result) => {
+    if (result.command === "monitor")
+        return `${result.result.url}\n`;
+    if (result.command === "execution.catalog") {
+        const [provider] = result.result.providers;
+        return `${provider.id}\t${provider.kind}\t${provider.binding}\t${provider.reason}\n`;
+    }
+    if (isProjectResult(result))
+        return formatProjectSuccess(result);
+    if (isOrchestrationResult(result))
+        return formatCompactOrchestration(result);
+    if (isSessionResult(result))
+        return formatSessionSuccess(result);
+    if (isTerminalResult(result))
+        return formatTerminalSuccess(result);
+    if (isTurnResult(result))
+        return formatTurnSuccess(result);
+    if (isWorkspaceResult(result))
+        return formatWorkspaceSuccess(result);
+    switch (result.command) {
+        case "integration.apply":
+        case "integration.plan":
+        case "integration.remove":
+        case "integration.status":
+            return formatIntegration(result);
+        case "context.show":
+            return `${result.principal.kind}\t${result.principal.id}\t${result.actorId}\n`;
+        case "receipt.list":
+            return formatReceiptList(result);
+        case "receipt.show":
+            return `${result.result.receipt.receiptId}\t${result.result.receipt.state}\t${result.result.receipt.target.type}:${result.result.receipt.target.id}\n`;
+        case "runtime.list":
+            return formatRuntimeList(result.items);
+        case "runtime.probe":
+            return formatRuntimeProbe(result.result);
+    }
+};
+const isHumanStatusResult = (result) => result.command === "status" && "node" in result;
+const formatHumanSuccess = (result) => {
+    if (result.command === "help")
+        return formatHumanHelp(result);
+    if (result.command === "status") {
+        if (!isHumanStatusResult(result)) {
+            throw new Error("Compact status is JSON-only.");
+        }
+        return formatHumanStatus(result);
+    }
+    if (result.command === "version")
+        return `${result.version}\n`;
+    return formatNodeSuccess(result);
+};
+export const writeStatusResult = (node, context) => {
+    if (context.json) {
+        writeSuccess(projectStatusResult(node), true, context.io);
+        return;
+    }
+    writeSuccess({ command: "status", node }, false, context.io);
+};
+export const writeSuccess = (result, json, io) => {
+    if (json) {
+        const output = { ok: true, result };
+        io.stdout(`${JSON.stringify(output)}\n`);
+        return;
+    }
+    io.stdout(formatHumanSuccess(result));
+};
+const writeError = (error, recovery, context) => {
+    if (context.json) {
+        const output = {
+            error,
+            ok: false,
+            ...(recovery === undefined ? {} : { recovery }),
+        };
+        context.io.stderr(`${JSON.stringify(output)}\n`);
+        return;
+    }
+    const usage = error.code === "invalid_argument" ||
+        error.code === "command_not_implemented"
+        ? "Run 'maia --help' for usage.\n"
+        : "";
+    const recoveryHint = recovery === undefined
+        ? ""
+        : `Outcome unknown. Recover with:\n  maia receipt show ${recovery.commandId}\n`;
+    context.io.stderr(`maia: ${error.message}\n${recoveryHint}${usage}`);
+};
+export const reportError = (error, context) => {
+    writeError(error, context.recovery, context);
+    if (error.code === "invalid_argument" ||
+        error.code === "command_not_implemented") {
+        return EXIT_USAGE;
+    }
+    if (error.code === "resource_not_found")
+        return EXIT_DATA_NOT_FOUND;
+    if (error.code === "authentication_failed")
+        return EXIT_PERMISSION;
+    if (error.code === "node_unavailable" ||
+        error.code === "node_context_unavailable") {
+        return EXIT_UNAVAILABLE;
+    }
+    if (error.code === "context_override_forbidden")
+        return EXIT_PERMISSION;
+    if (error.code === "deadline_exceeded")
+        return EXIT_DEADLINE;
+    if (error.code === "outcome_unknown")
+        return EXIT_OUTCOME_UNKNOWN;
+    if (error.code === "saturated")
+        return EXIT_TEMPORARY;
+    if (error.retryable)
+        return EXIT_TEMPORARY;
+    return EXIT_SOFTWARE;
+};
+export const writeNodeResult = (result, context, map) => {
+    if (!result.ok) {
+        return reportError(result.error, {
+            ...context,
+            ...(result.recovery === undefined ? {} : { recovery: result.recovery }),
+        });
+    }
+    writeSuccess(map(result.value), context.json, context.io);
+    return 0;
+};
+const projectInboxCheckItem = (delivery) => ({
+    body: delivery.message.body,
+    deliveryId: delivery.id,
+    mailboxId: delivery.mailboxId,
+    sequence: delivery.sequence,
+    subject: delivery.message.subject,
+    type: delivery.message.type,
+});
+const projectedResultWriter = (project) => (result, context) => writeNodeResult(result, context, project);
+export const writeInboxAckResult = projectedResultWriter(projectInboxAckResult);
+export const writeInboxCheckResult = (result, context) => writeNodeResult(result, context, (value) => ({
+    command: "run.inbox.check",
+    count: value.items.length,
+    items: value.items.map(projectInboxCheckItem),
+    mailboxId: value.mailbox.id,
+    mailboxRevision: value.mailbox.revision,
+    owner: {
+        id: value.mailbox.owner.id,
+        kind: value.mailbox.owner.kind,
+    },
+    runId: value.mailbox.runId,
+}));
+const projectTaskListItem = (task) => ({
+    clientKey: task.clientKey,
+    dependencyTaskIds: task.dependencyTaskIds,
+    id: task.id,
+    revision: task.revision,
+    state: task.state,
+});
+export const writeRunListResult = (result, context, workspaceId) => writeNodeResult(result, context, (value) => projectRunListResult(value, workspaceId));
+export const writeTaskListResult = (result, context) => writeNodeResult(result, context, (value) => ({
+    command: "run.task.list",
+    count: value.items.length,
+    items: value.items.map(projectTaskListItem),
+    ...(value.nextCursor === undefined ? {} : { nextCursor: value.nextCursor }),
+    runId: value.runId,
+}));
+const projectTaskShowTask = (task) => ({
+    clientKey: task.clientKey,
+    dependencyTaskIds: task.dependencyTaskIds,
+    id: task.id,
+    objective: task.objective,
+    revision: task.revision,
+    runId: task.runId,
+    state: task.state,
+});
+export const writeTaskShowResult = (result, context) => writeNodeResult(result, context, (value) => ({
+    command: "run.task.show",
+    task: projectTaskShowTask(value.task),
+}));
+export const writeDispatchShowResult = (result, context) => writeNodeResult(result, context, (value) => ({
+    command: "run.dispatch.show",
+    dispatch: projectDispatchShowDispatch(value.dispatch),
+}));
+export const writeRunShowResult = projectedResultWriter(projectRunShowResult);
+export const writeRunCreateResult = projectedResultWriter(projectRunCreateResult);
+export const writeQuestionOpenResult = projectedResultWriter(projectQuestionOpenResult);
+export const writeQuestionReplyResult = projectedResultWriter(projectQuestionReplyResult);
+export const writeQuestionCancelResult = projectedResultWriter(projectQuestionCancelResult);
+export const writeDispatchSettleResult = projectedResultWriter(projectDispatchSettleResult);
+export const writeCurrentContextResult = (result, context) => writeNodeResult(result, context, (value) => ({
+    actorId: value.actorId,
+    allowedActions: value.allowedActions,
+    command: "context.show",
+    contextRevision: value.contextRevision,
+    principal: value.principal,
+}));
+export const writeIntegrationApplyResult = (result, context) => writeNodeResult(result, context, (value) => ({
+    command: "integration.apply",
+    result: value,
+}));
+export const writeIntegrationPlanResult = (result, context) => writeNodeResult(result, context, (value) => ({
+    command: "integration.plan",
+    result: value,
+}));
+export const writeIntegrationRemoveResult = (result, context) => writeNodeResult(result, context, (value) => ({
+    command: "integration.remove",
+    result: value,
+}));
+export const writeIntegrationStatusResult = (result, context) => writeNodeResult(result, context, (value) => ({
+    command: "integration.status",
+    result: value,
+}));
+export const writeRuntimeListResult = (result, context) => writeNodeResult(result, context, (value) => ({
+    command: "runtime.list",
+    items: value.items.map(projectRuntimeListItem),
+}));
+export const writeRuntimeProbeResult = (result, context) => {
+    const exitCode = writeNodeResult(result, context, (value) => ({
+        command: "runtime.probe",
+        result: value,
+    }));
+    if (!result.ok || result.value.status === "ready")
+        return exitCode;
+    return result.value.status === "unavailable"
+        ? EXIT_UNAVAILABLE
+        : EXIT_SOFTWARE;
+};
+//# sourceMappingURL=output.js.map

package/dist/command-line/stdin.d.ts

@@ -0,0 +1,7 @@
+export type BoundedStdinRequest = {
+    readonly label: string;
+    readonly maxBytes: number;
+    readonly maxChunks: number;
+};
+export declare const readBoundedStdin: (input: AsyncIterable<string | Uint8Array>, request: BoundedStdinRequest) => Promise<string>;
+//# sourceMappingURL=stdin.d.ts.map

package/dist/command-line/stdin.js

@@ -0,0 +1,34 @@
+import { Buffer } from "node:buffer";
+import { CliArgumentError } from "./arguments.js";
+const collectNextChunk = async (step) => {
+    const next = await step.iterator.next();
+    if (next.done === true)
+        return;
+    const buffer = Buffer.from(next.value);
+    const nextBytes = step.collected.bytes + buffer.byteLength;
+    if (nextBytes > step.request.maxBytes ||
+        step.collected.chunks.length >= step.request.maxChunks) {
+        throw new CliArgumentError(`Standard input exceeds the bounded ${step.request.label} limit.`);
+    }
+    step.collected.bytes = nextBytes;
+    step.collected.chunks.push(buffer);
+    await collectNextChunk(step);
+};
+export const readBoundedStdin = async (input, request) => {
+    const iterator = input[Symbol.asyncIterator]();
+    const collected = { bytes: 0, chunks: [] };
+    try {
+        await collectNextChunk({ collected, iterator, request });
+    }
+    catch (error) {
+        await Promise.resolve(iterator.return?.()).catch(() => false);
+        throw error;
+    }
+    try {
+        return new TextDecoder("utf-8", { fatal: true }).decode(Buffer.concat(collected.chunks, collected.bytes));
+    }
+    catch {
+        throw new CliArgumentError("Standard input must contain valid UTF-8.");
+    }
+};
+//# sourceMappingURL=stdin.js.map

package/dist/command-receipt/command.d.ts

@@ -0,0 +1,3 @@
+import type { CommandContext } from "../command-line/context.js";
+export declare const runReceiptCommand: (tokens: readonly string[], context: CommandContext) => Promise<number>;
+//# sourceMappingURL=command.d.ts.map