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

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

@@ -0,0 +1,148 @@
+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";
+export type CliTerminalCleanup = {
+    readonly reason: Extract<ProtocolCleanup, {
+        readonly state: "unknown";
+    }>["reason"];
+    readonly state: "unknown";
+} | {
+    readonly state: Exclude<ProtocolCleanup["state"], "unknown">;
+};
+export 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"];
+};
+export 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"];
+};
+export 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 projectTerminalShowTerminal: <TAudience extends CliOutputAudience = "json">(terminal: ProtocolTerminal, audience?: TAudience) => CliTerminalShowTerminal<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

package/dist/terminal/compact-list.js

@@ -0,0 +1,152 @@
+const projectCleanup = (cleanup) => cleanup.state === "unknown"
+    ? { reason: cleanup.reason, state: cleanup.state }
+    : { state: cleanup.state };
+const projectOptionalCleanup = (cleanup) => cleanup.state === "pending" ? {} : { cleanup: projectCleanup(cleanup) };
+const projectExit = (exit) => ({
+    ...(exit.code === undefined ? {} : { code: exit.code }),
+    observedAt: exit.observedAt,
+    ...(exit.signal === undefined ? {} : { signal: exit.signal }),
+});
+const projectOptionalExit = (terminal) => "exit" in terminal && terminal.exit !== undefined
+    ? { exit: projectExit(terminal.exit) }
+    : {};
+const projectUnavailableTerminal = (terminal) => ({
+    id: terminal.id,
+    projectId: terminal.projectId,
+    revision: terminal.revision,
+    state: terminal.state,
+    unavailability: terminal.unavailability,
+    workspaceId: terminal.workspaceId,
+    workspaceRevision: terminal.workspaceRevision,
+});
+const projectLiveTerminal = (terminal, includeViewport, audience) => ({
+    ...(audience === "human"
+        ? { capability: { tier: terminal.capability.tier } }
+        : {}),
+    ...projectOptionalCleanup(terminal.cleanup),
+    ...projectOptionalExit(terminal),
+    generation: terminal.generation,
+    id: terminal.id,
+    projectId: terminal.projectId,
+    revision: terminal.revision,
+    state: terminal.state,
+    ...(includeViewport
+        ? {
+            viewport: {
+                columns: terminal.viewport.columns,
+                rows: terminal.viewport.rows,
+            },
+        }
+        : {}),
+    workspaceId: terminal.workspaceId,
+    workspaceRevision: terminal.workspaceRevision,
+});
+export const terminalOutputAudience = (json) => json ? "json" : "human";
+export const projectTerminalListItem = (terminal, audience = "json") => (terminal.state === "unavailable"
+    ? projectUnavailableTerminal(terminal)
+    : projectLiveTerminal(terminal, false, audience));
+export const projectTerminalShowTerminal = (terminal, audience = "json") => (terminal.state === "unavailable"
+    ? projectUnavailableTerminal(terminal)
+    : projectLiveTerminal(terminal, true, audience));
+export const projectTerminalListResult = (value, workspaceId, audience = "json") => ({
+    command: "terminal.list",
+    count: value.items.length,
+    items: value.items.map((item) => projectTerminalListItem(item, audience)),
+    ...(value.nextCursor === undefined ? {} : { nextCursor: value.nextCursor }),
+    workspaceId: value.items[0]?.workspaceId ?? workspaceId,
+});
+export const projectTerminalShowResult = (value, audience = "json") => ({
+    command: "terminal.show",
+    terminal: projectTerminalShowTerminal(value.terminal, audience),
+});
+const projectLegacyEvent = (event, audience) => ({
+    cursor: event.terminalCursor,
+    ...(audience === "human" ? { globalCursor: event.globalCursor } : {}),
+    type: event.eventType,
+    unavailability: {
+        code: event.payload.code,
+        platform: event.payload.platform,
+    },
+});
+const projectCleanupEvent = (event) => ({
+    cleanup: projectCleanup(event.cleanup),
+    cursor: event.cursor,
+    type: "cleanup",
+});
+const projectControllerRevokedEvent = (event) => ({
+    cursor: event.cursor,
+    leaseId: event.leaseId,
+    reason: event.reason,
+    type: "controller-revoked",
+});
+const projectExitEvent = (event) => ({
+    cursor: event.cursor,
+    exit: projectExit(event.exit),
+    type: "exit",
+});
+const projectGapEvent = (event) => ({
+    cursor: event.cursor,
+    headCursor: event.headCursor,
+    oldestAvailableCursor: event.oldestAvailableCursor,
+    reason: event.reason,
+    recovery: event.recovery,
+    ...(event.requestedAfterCursor === undefined
+        ? {}
+        : { requestedAfterCursor: event.requestedAfterCursor }),
+    type: "gap",
+});
+const projectLifecycleEvent = (event, audience) => ({
+    cursor: event.cursor,
+    previousCleanup: projectCleanup(event.previousCleanup),
+    previousGeneration: event.previousGeneration,
+    previousRevision: event.previousRevision,
+    previousState: event.previousState,
+    terminal: projectTerminalListItem(event.terminal, audience),
+    transition: event.transition,
+    type: "lifecycle-transition",
+});
+const projectLiveEvent = (event, audience) => {
+    switch (event.type) {
+        case "cleanup":
+            return projectCleanupEvent(event);
+        case "controller-revoked":
+            return projectControllerRevokedEvent(event);
+        case "exit":
+            return projectExitEvent(event);
+        case "gap":
+            return projectGapEvent(event);
+        case "lifecycle-transition":
+            return projectLifecycleEvent(event, audience);
+        case "output":
+            return { cursor: event.cursor, type: "output" };
+    }
+};
+export const projectTerminalEvent = (event, audience = "json") => "eventType" in event
+    ? projectLegacyEvent(event, audience)
+    : projectLiveEvent(event, audience);
+export const projectTerminalEventsResult = (value, audience = "json") => ({
+    command: "terminal.events",
+    count: value.items.length,
+    headCursor: value.headTerminalCursor,
+    items: value.items.map((event) => projectTerminalEvent(event, audience)),
+    ...(value.nextTerminalCursor === undefined
+        ? {}
+        : { nextCursor: value.nextTerminalCursor }),
+    terminalId: value.terminalId,
+});
+export const projectTerminalChunk = (chunk) => ({
+    bytesBase64: chunk.bytesBase64,
+    cursor: chunk.cursor,
+    ...("generation" in chunk ? { generation: chunk.generation } : {}),
+});
+export const projectTerminalReadResult = (value) => ({
+    command: "terminal.read",
+    count: value.items.length,
+    headChunkCursor: value.headChunkCursor,
+    items: value.items.map(projectTerminalChunk),
+    ...(value.nextChunkCursor === undefined
+        ? {}
+        : { nextChunkCursor: value.nextChunkCursor }),
+    terminalId: value.terminalId,
+});
+//# sourceMappingURL=compact-list.js.map

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

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

package/dist/terminal/control-commands.js

@@ -0,0 +1,211 @@
+import { Buffer } from "node:buffer";
+import { liveTerminalWriteParametersSchema, MAX_TERMINAL_INPUT_CHUNK_BYTES, } from "@maiaos/sdk";
+import { CliArgumentError, parseOptions, requirePositionals, } from "../command-line/arguments.js";
+import { writeNodeResult } from "../command-line/output.js";
+import { readTerminalColumns, readTerminalControllerFence, readTerminalExpectedRevision, readTerminalGeneration, readTerminalInputSequence, readTerminalLeaseDuration, readTerminalRows, terminalControllerFenceOptionNames, } from "./arguments.js";
+const optionNames = (...additional) => new Set([...terminalControllerFenceOptionNames, ...additional]);
+const commandId = (options) => {
+    const value = options.get("--command-id");
+    return value === undefined ? {} : { commandId: value };
+};
+const requiredTerminalId = (positionals) => {
+    const terminalId = positionals[0];
+    if (terminalId === undefined) {
+        throw new CliArgumentError("The terminal identifier is missing.");
+    }
+    return terminalId;
+};
+const runControllerRequestShow = async (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set(["--terminal-generation"]));
+    requirePositionals(parsed.positionals, 2, "maia terminal controller request show");
+    const terminalId = requiredTerminalId(parsed.positionals);
+    const controllerRequestId = parsed.positionals[1];
+    if (controllerRequestId === undefined) {
+        throw new CliArgumentError("The controller request identifier is missing.");
+    }
+    const result = await context.dependencies.showTerminalControllerRequest({
+        controllerRequestId,
+        terminalGeneration: readTerminalGeneration(parsed),
+        terminalId,
+    });
+    return writeNodeResult(result, context, (value) => ({
+        command: "terminal.controller.request.show",
+        result: value,
+    }));
+};
+const runControllerRequest = async (tokens, context) => {
+    if (tokens[0] === "show")
+        return runControllerRequestShow(tokens.slice(1), context);
+    const parsed = parseOptions(tokens, new Set(["--command-id", "--lease-ms", "--terminal-generation"]));
+    requirePositionals(parsed.positionals, 1, "maia terminal controller request");
+    const terminalId = requiredTerminalId(parsed.positionals);
+    const result = await context.dependencies.requestTerminalController({
+        ...commandId(parsed.options),
+        requestedLeaseDurationMs: readTerminalLeaseDuration(parsed),
+        terminalGeneration: readTerminalGeneration(parsed),
+        terminalId,
+    });
+    return writeNodeResult(result, context, (value) => ({
+        command: "terminal.controller.request",
+        result: value,
+    }));
+};
+const readControllerAcquireInput = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--command-id", "--expected-revision", "--terminal-generation"]));
+    requirePositionals(parsed.positionals, 2, "maia terminal controller acquire");
+    const terminalId = requiredTerminalId(parsed.positionals);
+    const controllerRequestId = parsed.positionals[1];
+    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.");
+    }
+};
+const runControllerAcquire = async (tokens, context) => {
+    const result = await context.dependencies.acquireTerminalController(readControllerAcquireInput(tokens));
+    return writeNodeResult(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, "maia terminal input write");
+    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;
+};
+const runControllerRelease = async (tokens, context) => {
+    const parsed = parseOptions(tokens, optionNames());
+    requirePositionals(parsed.positionals, 1, "maia terminal controller release");
+    const terminalId = requiredTerminalId(parsed.positionals);
+    const result = await context.dependencies.releaseTerminalController({
+        ...commandId(parsed.options),
+        ...readTerminalControllerFence(parsed, terminalId),
+    });
+    return writeNodeResult(result, context, (value) => ({
+        command: "terminal.controller.release",
+        result: value,
+    }));
+};
+export const runTerminalControllerCommand = (tokens, context) => {
+    const [subcommand, ...rest] = tokens;
+    if (subcommand === "acquire")
+        return runControllerAcquire(rest, context);
+    if (subcommand === "release")
+        return runControllerRelease(rest, context);
+    if (subcommand === "request")
+        return runControllerRequest(rest, context);
+    throw new CliArgumentError("Usage: maia terminal controller <request|acquire|release>");
+};
+const readTerminalInput = async (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 runTerminalInputCommand = async (tokens, context) => {
+    const [subcommand, ...rest] = tokens;
+    if (subcommand !== "write") {
+        throw new CliArgumentError("Usage: maia terminal input write");
+    }
+    const scope = readTerminalWriteScope(rest);
+    const input = await readTerminalInput(context);
+    if (input.length === 0) {
+        throw new CliArgumentError("Terminal input must not be empty.");
+    }
+    const result = await context.dependencies.writeTerminalInput({
+        ...scope,
+        bytesBase64: Buffer.from(input, "utf8").toString("base64"),
+    });
+    return writeNodeResult(result, context, (value) => ({
+        command: "terminal.input.write",
+        result: value,
+    }));
+};
+const readTerminalSignalInput = (tokens) => {
+    const parsed = parseOptions(tokens, optionNames("--signal"));
+    requirePositionals(parsed.positionals, 1, "maia terminal signal");
+    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 = async (tokens, context) => {
+    const parsed = parseOptions(tokens, optionNames("--columns", "--rows"));
+    requirePositionals(parsed.positionals, 1, "maia terminal resize");
+    const terminalId = requiredTerminalId(parsed.positionals);
+    const result = await context.dependencies.resizeTerminal({
+        ...commandId(parsed.options),
+        ...readTerminalControllerFence(parsed, terminalId),
+        columns: readTerminalColumns(parsed.options.get("--columns")),
+        rows: readTerminalRows(parsed.options.get("--rows")),
+    });
+    return writeNodeResult(result, context, (value) => ({
+        command: "terminal.resize",
+        result: value,
+    }));
+};
+export const runTerminalSignal = async (tokens, context) => {
+    const result = await context.dependencies.signalTerminal(readTerminalSignalInput(tokens));
+    return writeNodeResult(result, context, (value) => ({
+        command: "terminal.signal",
+        result: value,
+    }));
+};
+export const runTerminalClose = async (tokens, context) => {
+    const parsed = parseOptions(tokens, optionNames());
+    requirePositionals(parsed.positionals, 1, "maia terminal close");
+    const terminalId = requiredTerminalId(parsed.positionals);
+    const result = await context.dependencies.closeTerminal({
+        ...commandId(parsed.options),
+        ...readTerminalControllerFence(parsed, terminalId),
+    });
+    return writeNodeResult(result, context, (value) => ({
+        command: "terminal.close",
+        result: value,
+    }));
+};
+//# sourceMappingURL=control-commands.js.map

package/dist/turn/client.d.ts

@@ -0,0 +1,17 @@
+import type { TurnInterruptResult, TurnSendResult, TurnShowResult } from "@maiaos/sdk";
+import { type CliNodeResult } from "../local-node/client.js";
+export type InterruptTurnInput = {
+    readonly commandId?: string;
+    readonly expectedRevision: string;
+    readonly turnId: string;
+};
+export type SendTurnInput = {
+    readonly commandId?: string;
+    readonly expectedRevision: string;
+    readonly prompt: string;
+    readonly sessionId: string;
+};
+export declare const interruptTurn: (input: InterruptTurnInput) => Promise<CliNodeResult<TurnInterruptResult>>;
+export declare const sendTurn: (input: SendTurnInput) => Promise<CliNodeResult<TurnSendResult>>;
+export declare const showTurn: (turnId: string) => Promise<CliNodeResult<TurnShowResult>>;
+//# sourceMappingURL=client.d.ts.map

package/dist/turn/client.js

@@ -0,0 +1,23 @@
+import { turnInterruptParametersSchema, turnSendParametersSchema, turnShowParametersSchema, } from "@maiaos/sdk";
+import { newCliIdentifier, runValidatedNodeOperation, } from "../local-node/client.js";
+export const interruptTurn = (input) => {
+    const commandId = input.commandId ?? newCliIdentifier("command");
+    return runValidatedNodeOperation({
+        commandId,
+        expectedRevision: input.expectedRevision,
+        turnId: input.turnId,
+    }, turnInterruptParametersSchema, (client, parameters, options) => client.interruptTurn(parameters, options), { commandId });
+};
+export const sendTurn = (input) => {
+    const commandId = input.commandId ?? newCliIdentifier("command");
+    return runValidatedNodeOperation({
+        commandId,
+        expectedRevision: input.expectedRevision,
+        input: { text: input.prompt, type: "text" },
+        sessionId: input.sessionId,
+    }, turnSendParametersSchema, (client, parameters, options) => client.sendTurn(parameters, options), { commandId });
+};
+export const showTurn = (turnId) => {
+    return runValidatedNodeOperation({ turnId }, turnShowParametersSchema, (client, parameters, options) => client.showTurn(parameters, options));
+};
+//# sourceMappingURL=client.js.map

package/dist/turn/commands.d.ts

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