@maiaos/cli 0.1.0-canary.2

package/dist/terminal/client.js

@@ -0,0 +1,68 @@
+import { liveTerminalCloseParametersSchema, liveTerminalControllerAcquireParametersSchema, liveTerminalControllerReleaseParametersSchema, liveTerminalControllerRequestParametersSchema, liveTerminalControllerRequestShowParametersSchema, liveTerminalResizeParametersSchema, liveTerminalSignalParametersSchema, liveTerminalWriteParametersSchema, terminalCreateParametersSchema, terminalEventsListParametersSchema, terminalListParametersSchema, terminalReadParametersSchema, terminalShowParametersSchema, } from "@maiaos/sdk";
+import * as Effect from "effect/Effect";
+import { commandIdentifier, } from "../local-node/index.js";
+export const makeTerminalClient = (node) => {
+    const createTerminal = (input) => {
+        return Effect.flatMap(commandIdentifier(input.commandId), (commandId) => {
+            return node.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) => {
+        return Effect.flatMap(commandIdentifier(input.commandId), (commandId) => {
+            return node.runValidatedNodeOperation({ ...input, commandId }, schema, operation, {
+                commandId,
+            });
+        });
+    };
+    const requestTerminalController = (input) => runValidatedTerminalMutation(input, liveTerminalControllerRequestParametersSchema, (client, parameters, options) => client.requestTerminalController(parameters, options));
+    const showTerminalControllerRequest = (input) => {
+        return node.runValidatedNodeOperation(input, liveTerminalControllerRequestShowParametersSchema, (client, parameters, options) => client.showTerminalControllerRequest(parameters, options));
+    };
+    const acquireTerminalController = (input) => runValidatedTerminalMutation(input, liveTerminalControllerAcquireParametersSchema, (client, parameters, options) => client.acquireTerminalController(parameters, options));
+    const releaseTerminalController = (input) => runValidatedTerminalMutation(input, liveTerminalControllerReleaseParametersSchema, (client, parameters, options) => client.releaseTerminalController(parameters, options));
+    const writeTerminalInput = (input) => runValidatedTerminalMutation(input, liveTerminalWriteParametersSchema, (client, parameters, options) => client.writeTerminalInput(parameters, options));
+    const resizeTerminal = (input) => runValidatedTerminalMutation(input, liveTerminalResizeParametersSchema, (client, parameters, options) => client.resizeTerminal(parameters, options));
+    const signalTerminal = (input) => runValidatedTerminalMutation(input, liveTerminalSignalParametersSchema, (client, parameters, options) => client.signalTerminal(parameters, options));
+    const closeTerminal = (input) => runValidatedTerminalMutation(input, liveTerminalCloseParametersSchema, (client, parameters, options) => client.closeTerminal(parameters, options));
+    const listTerminals = (input) => {
+        return node.runValidatedNodeOperation(input, terminalListParametersSchema, (client, parameters, options) => client.listTerminals(parameters, options));
+    };
+    const showTerminal = (terminalId) => {
+        return node.runValidatedNodeOperation({ terminalId }, terminalShowParametersSchema, (client, parameters, options) => client.showTerminal(parameters, options));
+    };
+    const listTerminalEvents = (input) => {
+        return node.runValidatedNodeOperation(input, terminalEventsListParametersSchema, (client, parameters, options) => client.listTerminalEvents(parameters, options));
+    };
+    const readTerminal = (input) => {
+        return node.runValidatedNodeOperation(input, terminalReadParametersSchema, (client, parameters, options) => client.readTerminal(parameters, options));
+    };
+    return {
+        acquireTerminalController,
+        closeTerminal,
+        createTerminal,
+        listTerminalEvents,
+        listTerminals,
+        readTerminal,
+        releaseTerminalController,
+        requestTerminalController,
+        resizeTerminal,
+        showTerminal,
+        showTerminalControllerRequest,
+        signalTerminal,
+        writeTerminalInput,
+    };
+};
+//# sourceMappingURL=client.js.map

package/dist/terminal/commands.d.ts

@@ -0,0 +1,7 @@
+import { type CommandContext, type CommandEffect } from "../command-line/index.js";
+export declare const runTerminalCreate: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runTerminalList: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runTerminalShow: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runTerminalEventsList: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runTerminalRead: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+//# sourceMappingURL=commands.d.ts.map

package/dist/terminal/commands.js

@@ -0,0 +1,131 @@
+import * as Effect from "effect/Effect";
+import { CliArgumentError, parseOptions, readCursor, readPageSize, requirePositionals, } from "../command-line/index.js";
+import { readTerminalColumns, readTerminalRows } from "./arguments.js";
+import { projectTerminalEventsResult, projectTerminalListResult, projectTerminalReadResult, projectTerminalShowResult, terminalOutputAudience, writeTerminalResult, } from "./output/index.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 20;
+    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", "--workspace"]), new Set(["--interactive"]));
+    requirePositionals(parsed.positionals, 0);
+    const workspaceId = parsed.options.get("--workspace");
+    if (workspaceId === undefined) {
+        throw new CliArgumentError("Option '--workspace' is required.");
+    }
+    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,
+        };
+};
+export const runTerminalCreate = (tokens, context) => Effect.gen(function* () {
+    const { parsed, workspaceId } = parseTerminalCreate(tokens);
+    const input = makeTerminalCreateInput(parsed, workspaceId);
+    const result = yield* context.dependencies.createTerminal(input);
+    return writeTerminalResult(result, context, (value) => ({
+        command: "terminal.create",
+        result: summarizeTerminalCreation(value),
+    }));
+});
+const parseTerminalList = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--after", "--limit", "--workspace"]));
+    requirePositionals(parsed.positionals, 0);
+    const workspaceId = parsed.options.get("--workspace");
+    if (workspaceId === undefined) {
+        throw new CliArgumentError("Option '--workspace' is required.");
+    }
+    return {
+        afterCursor: readCursor(parsed.options.get("--after")),
+        limit: readPageSize(parsed.options.get("--limit")),
+        workspaceId,
+    };
+};
+export const runTerminalList = (tokens, context) => Effect.gen(function* () {
+    const page = parseTerminalList(tokens);
+    const { workspaceId } = page;
+    const result = yield* context.dependencies.listTerminals(page);
+    return writeTerminalResult(result, context, (value) => projectTerminalListResult(value, workspaceId, terminalOutputAudience(context.json)));
+});
+export const runTerminalShow = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set());
+    requirePositionals(parsed.positionals, 1);
+    const terminalId = parsed.positionals[0];
+    if (terminalId === undefined) {
+        throw new CliArgumentError("The terminal identifier is missing.");
+    }
+    const result = yield* context.dependencies.showTerminal(terminalId);
+    return writeTerminalResult(result, context, (value) => projectTerminalShowResult(value, terminalOutputAudience(context.json)));
+});
+export const runTerminalEventsList = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set(["--after", "--limit", "--terminal"]));
+    requirePositionals(parsed.positionals, 0);
+    const terminalId = parsed.options.get("--terminal");
+    if (terminalId === undefined) {
+        throw new CliArgumentError("Option '--terminal' is required.");
+    }
+    const result = yield* context.dependencies.listTerminalEvents({
+        afterTerminalCursor: readCursor(parsed.options.get("--after")),
+        limit: readTerminalEventPageSize(parsed.options.get("--limit")),
+        terminalId,
+    });
+    return writeTerminalResult(result, context, (value) => projectTerminalEventsResult(value, terminalOutputAudience(context.json)));
+});
+export const runTerminalRead = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set(["--after", "--limit"]));
+    requirePositionals(parsed.positionals, 1);
+    const terminalId = parsed.positionals[0];
+    if (terminalId === undefined) {
+        throw new CliArgumentError("The terminal identifier is missing.");
+    }
+    const result = yield* context.dependencies.readTerminal({
+        afterChunkCursor: readCursor(parsed.options.get("--after")),
+        limit: readTerminalChunkPageSize(parsed.options.get("--limit")),
+        terminalId,
+    });
+    return writeTerminalResult(result, context, projectTerminalReadResult);
+});
+//# sourceMappingURL=commands.js.map

package/dist/terminal/control-commands.d.ts

@@ -0,0 +1,10 @@
+import { type CommandContext, type CommandEffect } from "../command-line/index.js";
+export declare const runControllerRequestShow: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runControllerRequestCreate: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runControllerAcquire: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runControllerRelease: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runTerminalInputWrite: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runTerminalResize: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runTerminalSignal: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runTerminalClose: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+//# sourceMappingURL=control-commands.d.ts.map

package/dist/terminal/control-commands.js

@@ -0,0 +1,212 @@
+import { Buffer } from "node:buffer";
+import { liveTerminalWriteParametersSchema, MAX_TERMINAL_INPUT_CHUNK_BYTES, } from "@maiaos/sdk";
+import * as Effect from "effect/Effect";
+import { CliArgumentError, parseOptions, requirePositionals, } from "../command-line/index.js";
+import { readTerminalColumns, readTerminalControllerFence, readTerminalExpectedRevision, readTerminalGeneration, readTerminalInputSequence, readTerminalLeaseDuration, readTerminalRows, terminalControllerFenceOptionNames, } from "./arguments.js";
+import { writeTerminalResult } from "./output/index.js";
+const optionNames = (...additional) => new Set([...terminalControllerFenceOptionNames, ...additional]);
+const commandId = (options) => {
+    const value = options.get("--command-id");
+    return value === undefined ? {} : { commandId: value };
+};
+const requiredTerminalOption = (options) => {
+    const terminalId = options.get("--terminal");
+    if (terminalId === undefined)
+        throw new CliArgumentError("Option '--terminal' is required.");
+    return terminalId;
+};
+const requiredTerminalId = (positionals) => {
+    const terminalId = positionals[0];
+    if (terminalId === undefined) {
+        throw new CliArgumentError("The terminal identifier is missing.");
+    }
+    return terminalId;
+};
+export const runControllerRequestShow = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set(["--terminal", "--terminal-generation"]));
+    requirePositionals(parsed.positionals, 1);
+    const terminalId = requiredTerminalOption(parsed.options);
+    const controllerRequestId = parsed.positionals[0];
+    if (controllerRequestId === undefined) {
+        throw new CliArgumentError("The controller request identifier is missing.");
+    }
+    const result = yield* context.dependencies.showTerminalControllerRequest({
+        controllerRequestId,
+        terminalGeneration: readTerminalGeneration(parsed),
+        terminalId,
+    });
+    return writeTerminalResult(result, context, (value) => ({
+        command: "terminal.controller.request.show",
+        result: value,
+    }));
+});
+export const runControllerRequestCreate = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set([
+        "--command-id",
+        "--lease-ms",
+        "--terminal",
+        "--terminal-generation",
+    ]));
+    requirePositionals(parsed.positionals, 0);
+    const terminalId = requiredTerminalOption(parsed.options);
+    const result = yield* context.dependencies.requestTerminalController({
+        ...commandId(parsed.options),
+        requestedLeaseDurationMs: readTerminalLeaseDuration(parsed),
+        terminalGeneration: readTerminalGeneration(parsed),
+        terminalId,
+    });
+    return writeTerminalResult(result, context, (value) => ({
+        command: "terminal.controller.request",
+        result: value,
+    }));
+});
+const readControllerAcquireInput = (tokens) => {
+    const parsed = parseOptions(tokens, new Set([
+        "--command-id",
+        "--expected-revision",
+        "--request",
+        "--terminal-generation",
+    ]));
+    requirePositionals(parsed.positionals, 1);
+    const terminalId = requiredTerminalId(parsed.positionals);
+    const controllerRequestId = parsed.options.get("--request");
+    if (controllerRequestId === undefined) {
+        throw new CliArgumentError("The controller request identifier is missing.");
+    }
+    return {
+        ...commandId(parsed.options),
+        controllerRequestId,
+        expectedTerminalRevision: readTerminalExpectedRevision(parsed),
+        terminalGeneration: readTerminalGeneration(parsed),
+        terminalId,
+    };
+};
+const requireAdmittedTerminalWriteScope = (scope) => {
+    const admission = liveTerminalWriteParametersSchema.safeParse({
+        ...scope,
+        bytesBase64: "AA==",
+        commandId: scope.commandId ?? "command_terminal_input_validation",
+    });
+    if (!admission.success) {
+        throw new CliArgumentError("The terminal input metadata is invalid.");
+    }
+};
+export const runControllerAcquire = (tokens, context) => Effect.gen(function* () {
+    const result = yield* context.dependencies.acquireTerminalController(readControllerAcquireInput(tokens));
+    return writeTerminalResult(result, context, (value) => ({
+        command: "terminal.controller.acquire",
+        result: value,
+    }));
+});
+const parseTerminalWriteOptions = (tokens) => {
+    const parsed = parseOptions(tokens, optionNames("--input-id", "--input-sequence"), new Set(["--input-stdin"]));
+    requirePositionals(parsed.positionals, 1);
+    if (!parsed.flags.has("--input-stdin")) {
+        throw new CliArgumentError("Option '--input-stdin' is required.");
+    }
+    return parsed;
+};
+const readTerminalWriteScope = (tokens) => {
+    const parsed = parseTerminalWriteOptions(tokens);
+    const terminalId = requiredTerminalId(parsed.positionals);
+    const inputId = parsed.options.get("--input-id");
+    if (inputId === undefined) {
+        throw new CliArgumentError("Option '--input-id' is required.");
+    }
+    const scope = {
+        ...commandId(parsed.options),
+        ...readTerminalControllerFence(parsed, terminalId),
+        inputId,
+        inputSequence: readTerminalInputSequence(parsed),
+    };
+    requireAdmittedTerminalWriteScope(scope);
+    return scope;
+};
+export const runControllerRelease = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, optionNames());
+    requirePositionals(parsed.positionals, 1);
+    const terminalId = requiredTerminalId(parsed.positionals);
+    const result = yield* context.dependencies.releaseTerminalController({
+        ...commandId(parsed.options),
+        ...readTerminalControllerFence(parsed, terminalId),
+    });
+    return writeTerminalResult(result, context, (value) => ({
+        command: "terminal.controller.release",
+        result: value,
+    }));
+});
+const readTerminalInput = (context) => {
+    if (context.io.stdin === undefined) {
+        throw new CliArgumentError("Terminal input requires standard input.");
+    }
+    return context.io.stdin({
+        label: "terminal input",
+        maxBytes: MAX_TERMINAL_INPUT_CHUNK_BYTES,
+        maxChunks: 1024,
+    });
+};
+export const runTerminalInputWrite = (tokens, context) => Effect.gen(function* () {
+    const scope = readTerminalWriteScope(tokens);
+    const input = yield* readTerminalInput(context);
+    if (input.length === 0) {
+        throw new CliArgumentError("Terminal input must not be empty.");
+    }
+    const result = yield* context.dependencies.writeTerminalInput({
+        ...scope,
+        bytesBase64: Buffer.from(input, "utf8").toString("base64"),
+    });
+    return writeTerminalResult(result, context, (value) => ({
+        command: "terminal.input.write",
+        result: value,
+    }));
+});
+const readTerminalSignalInput = (tokens) => {
+    const parsed = parseOptions(tokens, optionNames("--signal"));
+    requirePositionals(parsed.positionals, 1);
+    const terminalId = requiredTerminalId(parsed.positionals);
+    const signal = parsed.options.get("--signal");
+    if (signal !== "hangup" && signal !== "interrupt" && signal !== "terminate") {
+        throw new CliArgumentError("Option '--signal' must be hangup, interrupt, or terminate.");
+    }
+    return {
+        ...commandId(parsed.options),
+        ...readTerminalControllerFence(parsed, terminalId),
+        signal,
+    };
+};
+export const runTerminalResize = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, optionNames("--columns", "--rows"));
+    requirePositionals(parsed.positionals, 1);
+    const terminalId = requiredTerminalId(parsed.positionals);
+    const result = yield* context.dependencies.resizeTerminal({
+        ...commandId(parsed.options),
+        ...readTerminalControllerFence(parsed, terminalId),
+        columns: readTerminalColumns(parsed.options.get("--columns")),
+        rows: readTerminalRows(parsed.options.get("--rows")),
+    });
+    return writeTerminalResult(result, context, (value) => ({
+        command: "terminal.resize",
+        result: value,
+    }));
+});
+export const runTerminalSignal = (tokens, context) => Effect.gen(function* () {
+    const result = yield* context.dependencies.signalTerminal(readTerminalSignalInput(tokens));
+    return writeTerminalResult(result, context, (value) => ({
+        command: "terminal.signal",
+        result: value,
+    }));
+});
+export const runTerminalClose = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, optionNames());
+    requirePositionals(parsed.positionals, 1);
+    const terminalId = requiredTerminalId(parsed.positionals);
+    const result = yield* context.dependencies.closeTerminal({
+        ...commandId(parsed.options),
+        ...readTerminalControllerFence(parsed, terminalId),
+    });
+    return writeTerminalResult(result, context, (value) => ({
+        command: "terminal.close",
+        result: value,
+    }));
+});
+//# sourceMappingURL=control-commands.js.map

package/dist/terminal/index.d.ts

@@ -0,0 +1,4 @@
+export { type CreateTerminalInput, makeTerminalClient } from "./client.js";
+export { runTerminalCreate, runTerminalEventsList, runTerminalList, runTerminalRead, runTerminalShow, } from "./commands.js";
+export { runControllerAcquire, runControllerRelease, runControllerRequestCreate, runControllerRequestShow, runTerminalClose, runTerminalInputWrite, runTerminalResize, runTerminalSignal, } from "./control-commands.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/terminal/index.js

@@ -0,0 +1,4 @@
+export { makeTerminalClient } from "./client.js";
+export { runTerminalCreate, runTerminalEventsList, runTerminalList, runTerminalRead, runTerminalShow, } from "./commands.js";
+export { runControllerAcquire, runControllerRelease, runControllerRequestCreate, runControllerRequestShow, runTerminalClose, runTerminalInputWrite, runTerminalResize, runTerminalSignal, } from "./control-commands.js";
+//# sourceMappingURL=index.js.map

package/dist/terminal/output/compact-list.d.ts

@@ -0,0 +1,147 @@
+import type { TerminalEventsListResult, TerminalListResult, TerminalReadResult, TerminalShowResult } from "@maiaos/sdk";
+type ProtocolTerminal = TerminalListResult["items"][number];
+type ProtocolUnavailable = Extract<ProtocolTerminal, {
+    readonly state: "unavailable";
+}>;
+type ProtocolLive = Exclude<ProtocolTerminal, ProtocolUnavailable>;
+type ProtocolCleanup = ProtocolLive["cleanup"];
+type ProtocolExit = NonNullable<Extract<ProtocolLive, {
+    readonly exit?: unknown;
+}>["exit"]>;
+type ProtocolEvent = TerminalEventsListResult["items"][number];
+type ProtocolLegacyEvent = Extract<ProtocolEvent, {
+    readonly eventType: unknown;
+}>;
+type ProtocolLiveEvent = Exclude<ProtocolEvent, ProtocolLegacyEvent>;
+type ProtocolChunk = TerminalReadResult["items"][number];
+export type CliOutputAudience = "human" | "json";
+type CliTerminalCleanup = {
+    readonly reason: Extract<ProtocolCleanup, {
+        readonly state: "unknown";
+    }>["reason"];
+    readonly state: "unknown";
+} | {
+    readonly state: Exclude<ProtocolCleanup["state"], "unknown">;
+};
+type CliUnavailableTerminal = {
+    readonly id: ProtocolUnavailable["id"];
+    readonly projectId: ProtocolUnavailable["projectId"];
+    readonly revision: ProtocolUnavailable["revision"];
+    readonly state: ProtocolUnavailable["state"];
+    readonly unavailability: ProtocolUnavailable["unavailability"];
+    readonly workspaceId: ProtocolUnavailable["workspaceId"];
+    readonly workspaceRevision: ProtocolUnavailable["workspaceRevision"];
+};
+type CliHumanLiveCapability = {
+    readonly capability: {
+        readonly tier: ProtocolLive["capability"]["tier"];
+    };
+};
+type CliLiveTerminalFields = {
+    readonly cleanup?: CliTerminalCleanup;
+    readonly exit?: ProtocolExit;
+    readonly generation: ProtocolLive["generation"];
+    readonly id: ProtocolLive["id"];
+    readonly projectId: ProtocolLive["projectId"];
+    readonly revision: ProtocolLive["revision"];
+    readonly state: ProtocolLive["state"];
+    readonly workspaceId: ProtocolLive["workspaceId"];
+    readonly workspaceRevision: ProtocolLive["workspaceRevision"];
+};
+export type CliLiveTerminal<TAudience extends CliOutputAudience = "json"> = TAudience extends "human" ? CliLiveTerminalFields & CliHumanLiveCapability : CliLiveTerminalFields;
+export type CliTerminalListItem<TAudience extends CliOutputAudience = "json"> = CliLiveTerminal<TAudience> | CliUnavailableTerminal;
+export type CliTerminalShowTerminal<TAudience extends CliOutputAudience = "json"> = (CliLiveTerminal<TAudience> & {
+    readonly viewport: ProtocolLive["viewport"];
+}) | CliUnavailableTerminal;
+export type CliTerminalListResult<TAudience extends CliOutputAudience = "json"> = {
+    readonly command: "terminal.list";
+    readonly count: number;
+    readonly items: readonly CliTerminalListItem<TAudience>[];
+    readonly nextCursor?: TerminalListResult["nextCursor"];
+    readonly workspaceId: ProtocolTerminal["workspaceId"];
+};
+export type CliTerminalShowResult<TAudience extends CliOutputAudience = "json"> = {
+    readonly command: "terminal.show";
+    readonly terminal: CliTerminalShowTerminal<TAudience>;
+};
+type CliLegacyEventFields = {
+    readonly cursor: string;
+    readonly type: ProtocolLegacyEvent["eventType"];
+    readonly unavailability: ProtocolUnavailable["unavailability"];
+};
+type CliLegacyTerminalEvent<TAudience extends CliOutputAudience = "json"> = TAudience extends "human" ? CliLegacyEventFields & {
+    readonly globalCursor: ProtocolLegacyEvent["globalCursor"];
+} : CliLegacyEventFields;
+export type CliTerminalEvent<TAudience extends CliOutputAudience = "json"> = CliLegacyTerminalEvent<TAudience> | {
+    readonly cleanup: CliTerminalCleanup;
+    readonly cursor: string;
+    readonly type: "cleanup";
+} | {
+    readonly cursor: string;
+    readonly exit: ProtocolExit;
+    readonly type: "exit";
+} | {
+    readonly cursor: string;
+    readonly headCursor: string;
+    readonly oldestAvailableCursor: string;
+    readonly reason: Extract<ProtocolLiveEvent, {
+        readonly type: "gap";
+    }>["reason"];
+    readonly recovery: Extract<ProtocolLiveEvent, {
+        readonly type: "gap";
+    }>["recovery"];
+    readonly requestedAfterCursor?: string;
+    readonly type: "gap";
+} | {
+    readonly cursor: string;
+    readonly leaseId: string;
+    readonly reason: Extract<ProtocolLiveEvent, {
+        readonly type: "controller-revoked";
+    }>["reason"];
+    readonly type: "controller-revoked";
+} | {
+    readonly cursor: string;
+    readonly previousCleanup: CliTerminalCleanup;
+    readonly previousGeneration: number;
+    readonly previousRevision: string;
+    readonly previousState: ProtocolLive["state"];
+    readonly terminal: CliTerminalListItem<TAudience>;
+    readonly transition: Extract<ProtocolLiveEvent, {
+        readonly type: "lifecycle-transition";
+    }>["transition"];
+    readonly type: "lifecycle-transition";
+} | {
+    readonly cursor: string;
+    readonly type: "output";
+};
+export type CliTerminalEventsResult<TAudience extends CliOutputAudience = "json"> = {
+    readonly command: "terminal.events";
+    readonly count: number;
+    readonly headCursor: TerminalEventsListResult["headTerminalCursor"];
+    readonly items: readonly CliTerminalEvent<TAudience>[];
+    readonly nextCursor?: TerminalEventsListResult["nextTerminalCursor"];
+    readonly terminalId: TerminalEventsListResult["terminalId"];
+};
+type CliTerminalChunk = {
+    readonly bytesBase64: ProtocolChunk["bytesBase64"];
+    readonly cursor: ProtocolChunk["cursor"];
+    readonly generation?: number;
+};
+export type CliTerminalReadResult = {
+    readonly command: "terminal.read";
+    readonly count: number;
+    readonly headChunkCursor: TerminalReadResult["headChunkCursor"];
+    readonly items: readonly CliTerminalChunk[];
+    readonly nextChunkCursor?: TerminalReadResult["nextChunkCursor"];
+    readonly terminalId: TerminalReadResult["terminalId"];
+};
+export declare const terminalOutputAudience: (json: boolean) => CliOutputAudience;
+export declare const projectTerminalListItem: <TAudience extends CliOutputAudience = "json">(terminal: ProtocolTerminal, audience?: TAudience) => CliTerminalListItem<TAudience>;
+export declare const projectTerminalListResult: <TAudience extends CliOutputAudience = "json">(value: TerminalListResult, workspaceId: ProtocolTerminal["workspaceId"], audience?: TAudience) => CliTerminalListResult<TAudience>;
+export declare const projectTerminalShowResult: <TAudience extends CliOutputAudience = "json">(value: TerminalShowResult, audience?: TAudience) => CliTerminalShowResult<TAudience>;
+export declare const projectTerminalEvent: <TAudience extends CliOutputAudience = "json">(event: ProtocolEvent, audience?: TAudience) => CliTerminalEvent<TAudience>;
+export declare const projectTerminalEventsResult: <TAudience extends CliOutputAudience = "json">(value: TerminalEventsListResult, audience?: TAudience) => CliTerminalEventsResult<TAudience>;
+export declare const projectTerminalChunk: (chunk: ProtocolChunk) => CliTerminalChunk;
+export declare const projectTerminalReadResult: (value: TerminalReadResult) => CliTerminalReadResult;
+export {};
+//# sourceMappingURL=compact-list.d.ts.map