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

package/dist/session/commands.js

@@ -0,0 +1,160 @@
+import { CliArgumentError, parseOptions, readCursor, readExpectedRevision, readPageSize, requirePositionals, } from "../command-line/arguments.js";
+import { writeNodeResult } from "../command-line/output.js";
+const SESSION_CREATE_USAGE = "maia session create <workspace-id> --runtime <codex|pi> [--profile <codex|pi-rpc>]";
+const SESSION_CREATE_SELECTION_ERROR = "Use '--runtime codex [--profile codex]' or '--runtime pi --profile pi-rpc'.";
+const SESSION_CREATE_OPTIONS = new Set([
+    "--command-id",
+    "--profile",
+    "--runtime",
+]);
+const summarizeSessionCreation = (result) => ({
+    delivery: result.delivery,
+    receipt: result.receipt,
+    sessionId: result.session.id,
+    state: result.session.state,
+    workspaceId: result.session.workspaceId,
+    workspaceRevision: result.session.workspaceRevision,
+});
+const summarizeSessionStart = (result) => ({
+    delivery: result.delivery,
+    receipt: result.receipt,
+    revision: result.session.revision,
+    sessionId: result.session.id,
+    state: result.session.state,
+});
+const readSessionEventPageSize = (value) => {
+    if (value === undefined)
+        return 2;
+    if (!/^(?:[1-9]|[12]\d|3[0-2])$/u.test(value)) {
+        throw new CliArgumentError("Option '--limit' must be an integer from 1 to 32 for session events.");
+    }
+    return Number(value);
+};
+const readSessionCreateOptions = (tokens) => {
+    const parsed = parseOptions(tokens, SESSION_CREATE_OPTIONS);
+    requirePositionals(parsed.positionals, 1, SESSION_CREATE_USAGE);
+    const workspaceId = parsed.positionals[0];
+    const runtime = parsed.options.get("--runtime");
+    const profile = parsed.options.get("--profile");
+    if (workspaceId === undefined ||
+        (runtime !== "codex" && runtime !== "pi") ||
+        (runtime === "codex" && profile !== undefined && profile !== "codex") ||
+        (runtime === "pi" && profile !== "pi-rpc")) {
+        throw new CliArgumentError(SESSION_CREATE_SELECTION_ERROR);
+    }
+    const command = parsed.options.has("--command-id")
+        ? { commandId: parsed.options.get("--command-id") }
+        : {};
+    return runtime === "pi"
+        ? { ...command, profile: "pi-rpc", runtime, workspaceId }
+        : {
+            ...command,
+            ...(profile === "codex" ? { profile } : {}),
+            runtime,
+            workspaceId,
+        };
+};
+const createSessionInput = (options) => options.runtime === "pi"
+    ? {
+        ...(options.commandId === undefined
+            ? {}
+            : { commandId: options.commandId }),
+        profile: "pi-rpc",
+        runtime: options.runtime,
+        workspaceId: options.workspaceId,
+    }
+    : {
+        ...(options.commandId === undefined
+            ? {}
+            : { commandId: options.commandId }),
+        ...(options.profile === "codex" ? { profile: options.profile } : {}),
+        runtime: options.runtime,
+        workspaceId: options.workspaceId,
+    };
+const runSessionCreate = async (tokens, context) => {
+    const result = await context.dependencies.createSession(createSessionInput(readSessionCreateOptions(tokens)));
+    return writeNodeResult(result, context, (value) => ({
+        command: "session.create",
+        result: summarizeSessionCreation(value),
+    }));
+};
+const runSessionList = async (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set(["--after", "--limit", "--project"]));
+    requirePositionals(parsed.positionals, 0, "maia session list --project <id>");
+    const projectId = parsed.options.get("--project");
+    if (projectId === undefined) {
+        throw new CliArgumentError("Option '--project' is required.");
+    }
+    const result = await context.dependencies.listSessions({
+        afterCursor: readCursor(parsed.options.get("--after")),
+        limit: readPageSize(parsed.options.get("--limit")),
+        projectId,
+    });
+    return writeNodeResult(result, context, (value) => ({
+        command: "session.list",
+        result: value,
+    }));
+};
+const runSessionShow = async (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set());
+    requirePositionals(parsed.positionals, 1, "maia session show <session-id>");
+    const sessionId = parsed.positionals[0];
+    if (sessionId === undefined) {
+        throw new CliArgumentError("The session identifier is missing.");
+    }
+    const result = await context.dependencies.showSession(sessionId);
+    return writeNodeResult(result, context, (value) => ({
+        command: "session.show",
+        result: value,
+    }));
+};
+const runSessionStart = async (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set(["--command-id", "--expected-revision"]));
+    requirePositionals(parsed.positionals, 1, "maia session start <session-id> --expected-revision <revision>");
+    const sessionId = parsed.positionals[0];
+    if (sessionId === undefined) {
+        throw new CliArgumentError("The session identifier is missing.");
+    }
+    const commandId = parsed.options.get("--command-id");
+    const result = await context.dependencies.startSession({
+        expectedRevision: readExpectedRevision(parsed.options.get("--expected-revision")),
+        sessionId,
+        ...(commandId === undefined ? {} : { commandId }),
+    });
+    return writeNodeResult(result, context, (value) => ({
+        command: "session.start",
+        result: summarizeSessionStart(value),
+    }));
+};
+const runSessionEvents = async (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set(["--after", "--limit"]));
+    requirePositionals(parsed.positionals, 1, "maia session events <session-id>");
+    const sessionId = parsed.positionals[0];
+    if (sessionId === undefined) {
+        throw new CliArgumentError("The session identifier is missing.");
+    }
+    const result = await context.dependencies.listSessionEvents({
+        afterSessionCursor: readCursor(parsed.options.get("--after")),
+        limit: readSessionEventPageSize(parsed.options.get("--limit")),
+        sessionId,
+    });
+    return writeNodeResult(result, context, (value) => ({
+        command: "session.events",
+        result: value,
+    }));
+};
+export const runSessionCommand = (tokens, context) => {
+    const [subcommand, ...rest] = tokens;
+    if (subcommand === "create")
+        return runSessionCreate(rest, context);
+    if (subcommand === "events")
+        return runSessionEvents(rest, context);
+    if (subcommand === "list")
+        return runSessionList(rest, context);
+    if (subcommand === "show")
+        return runSessionShow(rest, context);
+    if (subcommand === "start")
+        return runSessionStart(rest, context);
+    throw new CliArgumentError("Usage: maia session <create|events|list|show|start>");
+};
+//# sourceMappingURL=commands.js.map

package/dist/status/client.d.ts

@@ -0,0 +1,5 @@
+import type { LocalNodeStatusResult, MonitorBootstrapCreateResult } from "@maiaos/sdk";
+import { type CliNodeResult } from "../local-node/client.js";
+export declare const readLocalNodeStatus: () => Promise<LocalNodeStatusResult>;
+export declare const createMonitorBootstrap: () => Promise<CliNodeResult<MonitorBootstrapCreateResult>>;
+//# sourceMappingURL=client.d.ts.map

package/dist/status/client.js

@@ -0,0 +1,15 @@
+import * as Effect from "effect/Effect";
+import { connectCliLocalNode, runNodeClientOperation, } from "../local-node/client.js";
+class CliStatusError extends Error {
+    _tag = "CliStatusError";
+}
+const statusEffect = Effect.fn("Cli.status")(function* () {
+    const connection = yield* Effect.tryPromise({
+        catch: () => new CliStatusError("Local Maia node unavailable."),
+        try: (signal) => connectCliLocalNode(signal),
+    });
+    return connection.status;
+});
+export const readLocalNodeStatus = () => Effect.runPromise(statusEffect());
+export const createMonitorBootstrap = () => runNodeClientOperation((client, options) => client.createMonitorBootstrap(options));
+//# sourceMappingURL=client.js.map

package/dist/status/command.d.ts

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

package/dist/status/command.js

@@ -0,0 +1,17 @@
+import { reportError, writeStatusResult } from "../command-line/output.js";
+const createUnavailableError = () => ({
+    code: "node_unavailable",
+    message: "The local Maia node is unavailable.",
+    retryable: true,
+});
+export const runStatusCommand = async (context) => {
+    try {
+        const node = await context.dependencies.readStatus();
+        writeStatusResult(node, context);
+        return 0;
+    }
+    catch {
+        return reportError(createUnavailableError(), context);
+    }
+};
+//# sourceMappingURL=command.js.map

package/dist/status/compact.d.ts

@@ -0,0 +1,31 @@
+import type { LocalNodeStatusResult } from "@maiaos/sdk";
+export declare const sumObservationWarningTrees: (observations: LocalNodeStatusResult["processResources"]["observations"]) => number;
+export type CliCompactStatusResult = {
+    readonly command: "status";
+    readonly instanceId: LocalNodeStatusResult["instanceId"];
+    readonly lifecycle: LocalNodeStatusResult["lifecycle"];
+    readonly pid: LocalNodeStatusResult["pid"];
+    readonly processResources: {
+        readonly admission: {
+            readonly capacity: LocalNodeStatusResult["processResources"]["admission"]["capacity"];
+            readonly state: LocalNodeStatusResult["processResources"]["admission"]["state"];
+            readonly usedTrees: LocalNodeStatusResult["processResources"]["admission"]["usedTrees"];
+        };
+        readonly capability: {
+            readonly hardLimitEnforcement: LocalNodeStatusResult["processResources"]["capability"]["hardLimitEnforcement"];
+            readonly mode: LocalNodeStatusResult["processResources"]["capability"]["mode"];
+            readonly releaseQualified: LocalNodeStatusResult["processResources"]["capability"]["releaseQualified"];
+        };
+        readonly nextStep: LocalNodeStatusResult["processResources"]["nextStep"];
+        readonly pressure: LocalNodeStatusResult["processResources"]["pressure"];
+        readonly warningTrees: number;
+    };
+    readonly profile: LocalNodeStatusResult["profile"];
+    readonly storage: {
+        readonly integrity: LocalNodeStatusResult["storage"]["integrity"];
+        readonly journalMode: LocalNodeStatusResult["storage"]["journalMode"];
+        readonly schemaVersion: LocalNodeStatusResult["storage"]["schemaVersion"];
+    };
+};
+export declare const projectStatusResult: (node: LocalNodeStatusResult) => CliCompactStatusResult;
+//# sourceMappingURL=compact.d.ts.map

package/dist/status/compact.js

@@ -0,0 +1,46 @@
+const observedMetricKeys = [
+    "cpuTimeMilliseconds",
+    "fileDescriptorCount",
+    "ioReadBytes",
+    "ioWriteBytes",
+    "observedPeakRssBytes",
+    "processCount",
+    "rssBytes",
+];
+const warningTreesFromMetric = (metric) => "warningTrees" in metric && typeof metric.warningTrees === "number"
+    ? metric.warningTrees
+    : undefined;
+export const sumObservationWarningTrees = (observations) => observedMetricKeys.reduce((total, key) => {
+    const warningTrees = warningTreesFromMetric(observations[key]);
+    return warningTrees === undefined ? total : total + warningTrees;
+}, 0);
+const projectStatusAdmission = (admission) => ({
+    capacity: admission.capacity,
+    state: admission.state,
+    usedTrees: admission.usedTrees,
+});
+const projectStatusCapability = (capability) => ({
+    hardLimitEnforcement: capability.hardLimitEnforcement,
+    mode: capability.mode,
+    releaseQualified: capability.releaseQualified,
+});
+export const projectStatusResult = (node) => ({
+    command: "status",
+    instanceId: node.instanceId,
+    lifecycle: node.lifecycle,
+    pid: node.pid,
+    processResources: {
+        admission: projectStatusAdmission(node.processResources.admission),
+        capability: projectStatusCapability(node.processResources.capability),
+        nextStep: node.processResources.nextStep,
+        pressure: node.processResources.pressure,
+        warningTrees: sumObservationWarningTrees(node.processResources.observations),
+    },
+    profile: node.profile,
+    storage: {
+        integrity: node.storage.integrity,
+        journalMode: node.storage.journalMode,
+        schemaVersion: node.storage.schemaVersion,
+    },
+});
+//# sourceMappingURL=compact.js.map

package/dist/terminal/arguments.d.ts

@@ -0,0 +1,12 @@
+import type { LiveTerminalCloseParameters } from "@maiaos/sdk";
+import { type ParsedOptions } from "../command-line/arguments.js";
+export declare const readTerminalColumns: (value: string | undefined, fallback?: number) => number;
+export declare const readTerminalRows: (value: string | undefined, fallback?: number) => number;
+export declare const readTerminalGeneration: (parsed: ParsedOptions) => number;
+export declare const readTerminalLeaseDuration: (parsed: ParsedOptions) => number;
+export declare const readTerminalInputSequence: (parsed: ParsedOptions) => number;
+export declare const readTerminalExpectedRevision: (parsed: ParsedOptions) => string;
+export type TerminalControllerFenceInput = Omit<LiveTerminalCloseParameters, "commandId">;
+export declare const readTerminalControllerFence: (parsed: ParsedOptions, terminalId: string) => TerminalControllerFenceInput;
+export declare const terminalControllerFenceOptionNames: readonly ["--command-id", "--controller-epoch", "--controller-expires-at", "--controller-id", "--controller-revision", "--expected-revision", "--terminal-generation"];
+//# sourceMappingURL=arguments.d.ts.map

package/dist/terminal/arguments.js

@@ -0,0 +1,79 @@
+import { MAX_TERMINAL_COLUMNS, MAX_TERMINAL_CONTROLLER_LEASE_MS, MAX_TERMINAL_GENERATION, MAX_TERMINAL_INPUT_SEQUENCE, MAX_TERMINAL_ROWS, MIN_TERMINAL_COLUMNS, MIN_TERMINAL_CONTROLLER_LEASE_MS, MIN_TERMINAL_ROWS, } from "@maiaos/sdk";
+import { CliArgumentError, } from "../command-line/arguments.js";
+const MAX_SIGNED_SQLITE_INTEGER = 9223372036854775807n;
+const requiredOption = (parsed, name) => {
+    const value = parsed.options.get(name);
+    if (value === undefined) {
+        throw new CliArgumentError(`Option '${name}' is required.`);
+    }
+    return value;
+};
+const readBoundedInteger = (value, bounds) => {
+    const { maximum, minimum, name } = bounds;
+    if (!/^[1-9]\d*$/u.test(value)) {
+        throw new CliArgumentError(`Option '${name}' must be an integer from ${String(minimum)} to ${String(maximum)}.`);
+    }
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed) || parsed < minimum || parsed > maximum) {
+        throw new CliArgumentError(`Option '${name}' must be an integer from ${String(minimum)} to ${String(maximum)}.`);
+    }
+    return parsed;
+};
+const readRevision = (value, name) => {
+    if (!/^(?:0|[1-9]\d*)$/u.test(value) ||
+        BigInt(value) > MAX_SIGNED_SQLITE_INTEGER) {
+        throw new CliArgumentError(`Option '${name}' must be a non-negative signed 64-bit integer.`);
+    }
+    return value;
+};
+export const readTerminalColumns = (value, fallback) => readBoundedInteger(value ?? String(fallback), {
+    maximum: MAX_TERMINAL_COLUMNS,
+    minimum: MIN_TERMINAL_COLUMNS,
+    name: "--columns",
+});
+export const readTerminalRows = (value, fallback) => readBoundedInteger(value ?? String(fallback), {
+    maximum: MAX_TERMINAL_ROWS,
+    minimum: MIN_TERMINAL_ROWS,
+    name: "--rows",
+});
+export const readTerminalGeneration = (parsed) => readBoundedInteger(requiredOption(parsed, "--terminal-generation"), {
+    maximum: MAX_TERMINAL_GENERATION,
+    minimum: 1,
+    name: "--terminal-generation",
+});
+export const readTerminalLeaseDuration = (parsed) => readBoundedInteger(requiredOption(parsed, "--lease-ms"), {
+    maximum: MAX_TERMINAL_CONTROLLER_LEASE_MS,
+    minimum: MIN_TERMINAL_CONTROLLER_LEASE_MS,
+    name: "--lease-ms",
+});
+export const readTerminalInputSequence = (parsed) => readBoundedInteger(requiredOption(parsed, "--input-sequence"), {
+    maximum: MAX_TERMINAL_INPUT_SEQUENCE,
+    minimum: 1,
+    name: "--input-sequence",
+});
+export const readTerminalExpectedRevision = (parsed) => readRevision(requiredOption(parsed, "--expected-revision"), "--expected-revision");
+export const readTerminalControllerFence = (parsed, terminalId) => {
+    const terminalGeneration = readTerminalGeneration(parsed);
+    return {
+        controller: {
+            epoch: readRevision(requiredOption(parsed, "--controller-epoch"), "--controller-epoch"),
+            expiresAt: requiredOption(parsed, "--controller-expires-at"),
+            id: requiredOption(parsed, "--controller-id"),
+            revision: readRevision(requiredOption(parsed, "--controller-revision"), "--controller-revision"),
+            terminalGeneration,
+            terminalId,
+        },
+        expectedTerminalRevision: readTerminalExpectedRevision(parsed),
+        terminalId,
+    };
+};
+export const terminalControllerFenceOptionNames = [
+    "--command-id",
+    "--controller-epoch",
+    "--controller-expires-at",
+    "--controller-id",
+    "--controller-revision",
+    "--expected-revision",
+    "--terminal-generation",
+];
+//# sourceMappingURL=arguments.js.map

package/dist/terminal/client.d.ts

@@ -0,0 +1,45 @@
+import type { LiveTerminalCloseParameters, LiveTerminalCloseResult, LiveTerminalControllerAcquireParameters, LiveTerminalControllerAcquireResult, LiveTerminalControllerReleaseParameters, LiveTerminalControllerReleaseResult, LiveTerminalControllerRequestParameters, LiveTerminalControllerRequestResult, LiveTerminalControllerRequestShowParameters, LiveTerminalControllerRequestShowResult, LiveTerminalResizeParameters, LiveTerminalResizeResult, LiveTerminalSignalParameters, LiveTerminalSignalResult, LiveTerminalWriteParameters, LiveTerminalWriteResult, TerminalCreateResult, TerminalEventsListResult, TerminalListResult, TerminalReadResult, TerminalShowResult } from "@maiaos/sdk";
+import { type CliNodeResult } from "../local-node/client.js";
+export type CreateTerminalInput = {
+    readonly columns: number;
+    readonly commandId?: string;
+    readonly interactive: true;
+    readonly rows: number;
+    readonly workspaceId: string;
+} | {
+    readonly commandId?: string;
+    readonly interactive?: false;
+    readonly workspaceId: string;
+};
+export declare const createTerminal: (input: CreateTerminalInput) => Promise<CliNodeResult<TerminalCreateResult>>;
+type OptionalCommandId<TParameters extends {
+    readonly commandId: string;
+}> = Omit<TParameters, "commandId"> & {
+    readonly commandId?: string;
+};
+export declare const requestTerminalController: (input: OptionalCommandId<LiveTerminalControllerRequestParameters>) => Promise<CliNodeResult<LiveTerminalControllerRequestResult>>;
+export declare const showTerminalControllerRequest: (input: LiveTerminalControllerRequestShowParameters) => Promise<CliNodeResult<LiveTerminalControllerRequestShowResult>>;
+export declare const acquireTerminalController: (input: OptionalCommandId<LiveTerminalControllerAcquireParameters>) => Promise<CliNodeResult<LiveTerminalControllerAcquireResult>>;
+export declare const releaseTerminalController: (input: OptionalCommandId<LiveTerminalControllerReleaseParameters>) => Promise<CliNodeResult<LiveTerminalControllerReleaseResult>>;
+export declare const writeTerminalInput: (input: OptionalCommandId<LiveTerminalWriteParameters>) => Promise<CliNodeResult<LiveTerminalWriteResult>>;
+export declare const resizeTerminal: (input: OptionalCommandId<LiveTerminalResizeParameters>) => Promise<CliNodeResult<LiveTerminalResizeResult>>;
+export declare const signalTerminal: (input: OptionalCommandId<LiveTerminalSignalParameters>) => Promise<CliNodeResult<LiveTerminalSignalResult>>;
+export declare const closeTerminal: (input: OptionalCommandId<LiveTerminalCloseParameters>) => Promise<CliNodeResult<LiveTerminalCloseResult>>;
+export declare const listTerminals: (input: {
+    readonly afterCursor: string;
+    readonly limit: number;
+    readonly workspaceId: string;
+}) => Promise<CliNodeResult<TerminalListResult>>;
+export declare const showTerminal: (terminalId: string) => Promise<CliNodeResult<TerminalShowResult>>;
+export declare const listTerminalEvents: (input: {
+    readonly afterTerminalCursor: string;
+    readonly limit: number;
+    readonly terminalId: string;
+}) => Promise<CliNodeResult<TerminalEventsListResult>>;
+export declare const readTerminal: (input: {
+    readonly afterChunkCursor: string;
+    readonly limit: number;
+    readonly terminalId: string;
+}) => Promise<CliNodeResult<TerminalReadResult>>;
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/terminal/client.js

@@ -0,0 +1,48 @@
+import { liveTerminalCloseParametersSchema, liveTerminalControllerAcquireParametersSchema, liveTerminalControllerReleaseParametersSchema, liveTerminalControllerRequestParametersSchema, liveTerminalControllerRequestShowParametersSchema, liveTerminalResizeParametersSchema, liveTerminalSignalParametersSchema, liveTerminalWriteParametersSchema, terminalCreateParametersSchema, terminalEventsListParametersSchema, terminalListParametersSchema, terminalReadParametersSchema, terminalShowParametersSchema, } from "@maiaos/sdk";
+import { newCliIdentifier, runValidatedNodeOperation, } from "../local-node/client.js";
+export const createTerminal = (input) => {
+    const commandId = input.commandId ?? newCliIdentifier("command");
+    return runValidatedNodeOperation(input.interactive === true
+        ? {
+            columns: input.columns,
+            commandId,
+            expectedRevision: "0",
+            mode: "interactive",
+            rows: input.rows,
+            workspaceId: input.workspaceId,
+        }
+        : {
+            commandId,
+            expectedRevision: "0",
+            workspaceId: input.workspaceId,
+        }, terminalCreateParametersSchema, (client, parameters, options) => client.createTerminal(parameters, options), { commandId });
+};
+const runValidatedTerminalMutation = (input, schema, operation) => {
+    const commandId = input.commandId ?? newCliIdentifier("command");
+    return runValidatedNodeOperation({ ...input, commandId }, schema, operation, {
+        commandId,
+    });
+};
+export const requestTerminalController = (input) => runValidatedTerminalMutation(input, liveTerminalControllerRequestParametersSchema, (client, parameters, options) => client.requestTerminalController(parameters, options));
+export const showTerminalControllerRequest = (input) => {
+    return runValidatedNodeOperation(input, liveTerminalControllerRequestShowParametersSchema, (client, parameters, options) => client.showTerminalControllerRequest(parameters, options));
+};
+export const acquireTerminalController = (input) => runValidatedTerminalMutation(input, liveTerminalControllerAcquireParametersSchema, (client, parameters, options) => client.acquireTerminalController(parameters, options));
+export const releaseTerminalController = (input) => runValidatedTerminalMutation(input, liveTerminalControllerReleaseParametersSchema, (client, parameters, options) => client.releaseTerminalController(parameters, options));
+export const writeTerminalInput = (input) => runValidatedTerminalMutation(input, liveTerminalWriteParametersSchema, (client, parameters, options) => client.writeTerminalInput(parameters, options));
+export const resizeTerminal = (input) => runValidatedTerminalMutation(input, liveTerminalResizeParametersSchema, (client, parameters, options) => client.resizeTerminal(parameters, options));
+export const signalTerminal = (input) => runValidatedTerminalMutation(input, liveTerminalSignalParametersSchema, (client, parameters, options) => client.signalTerminal(parameters, options));
+export const closeTerminal = (input) => runValidatedTerminalMutation(input, liveTerminalCloseParametersSchema, (client, parameters, options) => client.closeTerminal(parameters, options));
+export const listTerminals = (input) => {
+    return runValidatedNodeOperation(input, terminalListParametersSchema, (client, parameters, options) => client.listTerminals(parameters, options));
+};
+export const showTerminal = (terminalId) => {
+    return runValidatedNodeOperation({ terminalId }, terminalShowParametersSchema, (client, parameters, options) => client.showTerminal(parameters, options));
+};
+export const listTerminalEvents = (input) => {
+    return runValidatedNodeOperation(input, terminalEventsListParametersSchema, (client, parameters, options) => client.listTerminalEvents(parameters, options));
+};
+export const readTerminal = (input) => {
+    return runValidatedNodeOperation(input, terminalReadParametersSchema, (client, parameters, options) => client.readTerminal(parameters, options));
+};
+//# sourceMappingURL=client.js.map

package/dist/terminal/commands.d.ts

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

package/dist/terminal/commands.js

@@ -0,0 +1,151 @@
+import { CliArgumentError, parseOptions, readCursor, readPageSize, requirePositionals, } from "../command-line/arguments.js";
+import { writeNodeResult } from "../command-line/output.js";
+import { readTerminalColumns, readTerminalRows } from "./arguments.js";
+import { projectTerminalEventsResult, projectTerminalListResult, projectTerminalReadResult, projectTerminalShowResult, terminalOutputAudience, } from "./compact-list.js";
+import { runTerminalClose, runTerminalControllerCommand, runTerminalInputCommand, runTerminalResize, runTerminalSignal, } from "./control-commands.js";
+const summarizeTerminalCreation = (result) => {
+    if (!("accepted" in result) || result.accepted)
+        return result;
+    const unavailableResult = result;
+    return {
+        accepted: unavailableResult.accepted,
+        delivery: unavailableResult.delivery,
+        receipt: unavailableResult.receipt,
+        state: unavailableResult.terminal.state,
+        terminalId: unavailableResult.terminal.id,
+        unavailability: unavailableResult.terminal.unavailability,
+        workspaceId: unavailableResult.terminal.workspaceId,
+        workspaceRevision: unavailableResult.terminal.workspaceRevision,
+    };
+};
+const readTerminalEventPageSize = (value) => {
+    if (value === undefined)
+        return 2;
+    if (!/^(?:[1-9]|[12]\d|3[0-2])$/u.test(value)) {
+        throw new CliArgumentError("Option '--limit' must be an integer from 1 to 32 for terminal events.");
+    }
+    return Number(value);
+};
+const readTerminalChunkPageSize = (value) => {
+    if (value === undefined)
+        return 2;
+    if (!/^[1-8]$/u.test(value)) {
+        throw new CliArgumentError("Option '--limit' must be an integer from 1 to 8 for terminal chunks.");
+    }
+    return Number(value);
+};
+const parseTerminalCreate = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--columns", "--command-id", "--rows"]), new Set(["--interactive"]));
+    requirePositionals(parsed.positionals, 1, "maia terminal create <workspace-id> [--interactive --columns <columns> --rows <rows>]");
+    const workspaceId = parsed.positionals[0];
+    if (workspaceId === undefined) {
+        throw new CliArgumentError("The workspace identifier is missing.");
+    }
+    return { parsed, workspaceId };
+};
+const makeTerminalCreateInput = (parsed, workspaceId) => {
+    const interactive = parsed.flags.has("--interactive");
+    if (!interactive &&
+        (parsed.options.has("--columns") || parsed.options.has("--rows"))) {
+        throw new CliArgumentError("Options '--columns' and '--rows' require '--interactive'.");
+    }
+    const commandId = parsed.options.get("--command-id");
+    return interactive
+        ? {
+            columns: readTerminalColumns(parsed.options.get("--columns"), 80),
+            ...(commandId === undefined ? {} : { commandId }),
+            interactive: true,
+            rows: readTerminalRows(parsed.options.get("--rows"), 24),
+            workspaceId,
+        }
+        : {
+            ...(commandId === undefined ? {} : { commandId }),
+            workspaceId,
+        };
+};
+const runTerminalCreate = async (tokens, context) => {
+    const { parsed, workspaceId } = parseTerminalCreate(tokens);
+    const input = makeTerminalCreateInput(parsed, workspaceId);
+    const result = await context.dependencies.createTerminal(input);
+    return writeNodeResult(result, context, (value) => ({
+        command: "terminal.create",
+        result: summarizeTerminalCreation(value),
+    }));
+};
+const runTerminalList = async (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set(["--after", "--limit", "--workspace"]));
+    requirePositionals(parsed.positionals, 0, "maia terminal list --workspace <id>");
+    const workspaceId = parsed.options.get("--workspace");
+    if (workspaceId === undefined) {
+        throw new CliArgumentError("Option '--workspace' is required.");
+    }
+    const result = await context.dependencies.listTerminals({
+        afterCursor: readCursor(parsed.options.get("--after")),
+        limit: readPageSize(parsed.options.get("--limit")),
+        workspaceId,
+    });
+    return writeNodeResult(result, context, (value) => projectTerminalListResult(value, workspaceId, terminalOutputAudience(context.json)));
+};
+const runTerminalShow = async (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set());
+    requirePositionals(parsed.positionals, 1, "maia terminal show <terminal-id>");
+    const terminalId = parsed.positionals[0];
+    if (terminalId === undefined) {
+        throw new CliArgumentError("The terminal identifier is missing.");
+    }
+    const result = await context.dependencies.showTerminal(terminalId);
+    return writeNodeResult(result, context, (value) => projectTerminalShowResult(value, terminalOutputAudience(context.json)));
+};
+const runTerminalEvents = async (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set(["--after", "--limit"]));
+    requirePositionals(parsed.positionals, 1, "maia terminal events <terminal-id>");
+    const terminalId = parsed.positionals[0];
+    if (terminalId === undefined) {
+        throw new CliArgumentError("The terminal identifier is missing.");
+    }
+    const result = await context.dependencies.listTerminalEvents({
+        afterTerminalCursor: readCursor(parsed.options.get("--after")),
+        limit: readTerminalEventPageSize(parsed.options.get("--limit")),
+        terminalId,
+    });
+    return writeNodeResult(result, context, (value) => projectTerminalEventsResult(value, terminalOutputAudience(context.json)));
+};
+const runTerminalRead = async (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set(["--after", "--limit"]));
+    requirePositionals(parsed.positionals, 1, "maia terminal read <terminal-id>");
+    const terminalId = parsed.positionals[0];
+    if (terminalId === undefined) {
+        throw new CliArgumentError("The terminal identifier is missing.");
+    }
+    const result = await context.dependencies.readTerminal({
+        afterChunkCursor: readCursor(parsed.options.get("--after")),
+        limit: readTerminalChunkPageSize(parsed.options.get("--limit")),
+        terminalId,
+    });
+    return writeNodeResult(result, context, projectTerminalReadResult);
+};
+export const runTerminalCommand = (tokens, context) => {
+    const [subcommand, ...rest] = tokens;
+    if (subcommand === "close")
+        return runTerminalClose(rest, context);
+    if (subcommand === "controller")
+        return runTerminalControllerCommand(rest, context);
+    if (subcommand === "create")
+        return runTerminalCreate(rest, context);
+    if (subcommand === "events")
+        return runTerminalEvents(rest, context);
+    if (subcommand === "input")
+        return runTerminalInputCommand(rest, context);
+    if (subcommand === "list")
+        return runTerminalList(rest, context);
+    if (subcommand === "read")
+        return runTerminalRead(rest, context);
+    if (subcommand === "resize")
+        return runTerminalResize(rest, context);
+    if (subcommand === "show")
+        return runTerminalShow(rest, context);
+    if (subcommand === "signal")
+        return runTerminalSignal(rest, context);
+    throw new CliArgumentError("Usage: maia terminal <create|list|show|events|read|controller|input|resize|signal|close>");
+};
+//# sourceMappingURL=commands.js.map