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

package/dist/orchestration/compact-aggregate.js

@@ -0,0 +1,110 @@
+export const projectDispatchShowDispatch = (dispatch) => ({
+    attemptId: dispatch.attemptId,
+    ...(dispatch.state === "failed" ? { failure: dispatch.failure } : {}),
+    id: dispatch.id,
+    revision: dispatch.revision,
+    runId: dispatch.runId,
+    state: dispatch.state,
+    taskId: dispatch.taskId,
+    terminalId: dispatch.terminalId,
+});
+const projectMailbox = (mailbox) => ({
+    id: mailbox.id,
+    owner: { id: mailbox.owner.id, kind: mailbox.owner.kind },
+    revision: mailbox.revision,
+});
+const projectQuestion = (question) => ({
+    ...(question.state === "answered" ? { answer: question.answer } : {}),
+    body: question.body,
+    id: question.id,
+    revision: question.revision,
+    state: question.state,
+    subject: question.subject,
+    taskId: question.taskId,
+});
+export const projectOrchestrationAggregate = (aggregate) => ({
+    attempt: {
+        id: aggregate.attempt.id,
+        revision: aggregate.attempt.revision,
+        state: aggregate.attempt.state,
+        taskId: aggregate.attempt.taskId,
+    },
+    dispatch: projectDispatchShowDispatch(aggregate.dispatch),
+    mailboxes: [...aggregate.mailboxes]
+        .map(projectMailbox)
+        .sort((left, right) => left.owner.kind.localeCompare(right.owner.kind)),
+    ...(aggregate.question === undefined
+        ? {}
+        : { question: projectQuestion(aggregate.question) }),
+    run: {
+        dispatchTaskId: aggregate.run.dispatchTaskId,
+        id: aggregate.run.id,
+        revision: aggregate.run.revision,
+        rootTaskId: aggregate.run.rootTaskId,
+        state: aggregate.run.state,
+        terminalId: aggregate.run.terminalId,
+        workspaceId: aggregate.run.workspaceId,
+    },
+    taskCount: aggregate.tasks.length,
+});
+export const projectOrchestrationDelivery = (delivery) => ({
+    deliveryId: delivery.id,
+    mailboxId: delivery.mailboxId,
+    ...("questionId" in delivery.message
+        ? { questionId: delivery.message.questionId }
+        : {}),
+    sequence: delivery.sequence,
+    subject: delivery.message.subject,
+    type: delivery.message.type,
+});
+export const projectOrchestrationReceipt = (receipt) => ({
+    aggregateRevision: receipt.aggregateRevision,
+    commandId: receipt.commandId,
+    receiptId: receipt.receiptId,
+    state: receipt.state,
+    target: receipt.target,
+});
+export const projectRunShowResult = (value) => ({
+    aggregate: projectOrchestrationAggregate(value.aggregate),
+    command: "run.show",
+});
+export const projectRunCreateResult = (value) => ({
+    aggregate: projectOrchestrationAggregate(value.aggregate),
+    command: "run.create",
+    delivery: value.delivery,
+    initialDelivery: projectOrchestrationDelivery(value.initialDelivery),
+    receipt: projectOrchestrationReceipt(value.receipt),
+});
+export const projectQuestionOpenResult = (value) => ({
+    aggregate: projectOrchestrationAggregate(value.aggregate),
+    command: "run.question.open",
+    delivery: projectOrchestrationDelivery(value.delivery),
+    receipt: projectOrchestrationReceipt(value.receipt),
+});
+export const projectQuestionReplyResult = (value) => ({
+    aggregate: projectOrchestrationAggregate(value.aggregate),
+    command: "run.question.reply",
+    delivery: projectOrchestrationDelivery(value.delivery),
+    receipt: projectOrchestrationReceipt(value.receipt),
+});
+export const projectQuestionCancelResult = (value) => ({
+    aggregate: projectOrchestrationAggregate(value.aggregate),
+    command: "run.question.cancel",
+    receipt: projectOrchestrationReceipt(value.receipt),
+});
+export const projectDispatchSettleResult = (value) => ({
+    aggregate: projectOrchestrationAggregate(value.aggregate),
+    command: "run.dispatch.settle-terminal",
+    delivery: projectOrchestrationDelivery(value.delivery),
+    receipt: projectOrchestrationReceipt(value.receipt),
+});
+export const projectInboxAckResult = (value) => ({
+    command: "run.inbox.ack",
+    delivery: projectOrchestrationDelivery(value.delivery),
+    mailboxId: value.mailbox.id,
+    mailboxRevision: value.mailbox.revision,
+    owner: { id: value.mailbox.owner.id, kind: value.mailbox.owner.kind },
+    receipt: projectOrchestrationReceipt(value.receipt),
+    runId: value.mailbox.runId,
+});
+//# sourceMappingURL=compact-aggregate.js.map

package/dist/orchestration/compact-run-list.d.ts

@@ -0,0 +1,19 @@
+import type { OrchestrationRun, OrchestrationRunListResult } from "@maiaos/sdk";
+export type CliRunListItem = {
+    readonly dispatchTaskId: OrchestrationRun["dispatchTaskId"];
+    readonly id: OrchestrationRun["id"];
+    readonly revision: OrchestrationRun["revision"];
+    readonly rootTaskId: OrchestrationRun["rootTaskId"];
+    readonly state: OrchestrationRun["state"];
+    readonly terminalId: OrchestrationRun["terminalId"];
+};
+export type CliRunListResult = {
+    readonly command: "run.list";
+    readonly count: number;
+    readonly items: readonly CliRunListItem[];
+    readonly nextCursor?: OrchestrationRunListResult["nextCursor"];
+    readonly workspaceId: OrchestrationRun["workspaceId"];
+};
+export declare const projectRunListItem: (run: OrchestrationRun) => CliRunListItem;
+export declare const projectRunListResult: (value: OrchestrationRunListResult, workspaceId: OrchestrationRun["workspaceId"]) => CliRunListResult;
+//# sourceMappingURL=compact-run-list.d.ts.map

package/dist/orchestration/compact-run-list.js

@@ -0,0 +1,16 @@
+export const projectRunListItem = (run) => ({
+    dispatchTaskId: run.dispatchTaskId,
+    id: run.id,
+    revision: run.revision,
+    rootTaskId: run.rootTaskId,
+    state: run.state,
+    terminalId: run.terminalId,
+});
+export const projectRunListResult = (value, workspaceId) => ({
+    command: "run.list",
+    count: value.items.length,
+    items: value.items.map(projectRunListItem),
+    ...(value.nextCursor === undefined ? {} : { nextCursor: value.nextCursor }),
+    workspaceId: value.items[0]?.workspaceId ?? workspaceId,
+});
+//# sourceMappingURL=compact-run-list.js.map

package/dist/project-workspace/client.d.ts

@@ -0,0 +1,43 @@
+import type { ExecutionCatalogGetResult, ProjectListResult, ProjectRegisterResult, ProjectShowResult, ReceiptGetResult, ReceiptListParameters, ReceiptListResult, WorkspaceExecutionConfigureParameters, WorkspaceExecutionConfigureResult, WorkspaceExecutionShowResult, WorkspaceListResult, WorkspaceRepositoryAttachResult, WorkspaceShowResult } from "@maiaos/sdk";
+import { type CliNodeResult } from "../local-node/client.js";
+export type { CliMutationRecovery, CliNodeResult, } from "../local-node/client.js";
+export type RegisterProjectInput = {
+    readonly commandId?: string;
+    readonly name?: string;
+    readonly path: string;
+};
+export type AttachRepositoryInput = RegisterProjectInput & {
+    readonly expectedRevision: string;
+    readonly workspaceId: string;
+};
+export type ConfigureWorkspaceExecutionInput = (Omit<Extract<WorkspaceExecutionConfigureParameters, {
+    operation: "clear";
+}>, "commandId"> & {
+    readonly commandId?: string;
+}) | (Omit<Extract<WorkspaceExecutionConfigureParameters, {
+    operation: "set";
+}>, "commandId"> & {
+    readonly commandId?: string;
+});
+export declare const registerProject: (input: RegisterProjectInput) => Promise<CliNodeResult<ProjectRegisterResult>>;
+export declare const projectWorkspaceClientInternals: {
+    readonly outcomeCanBeAmbiguous: (error: unknown) => boolean;
+};
+export declare const listProjects: (input: {
+    readonly afterCursor: string;
+    readonly limit: number;
+}) => Promise<CliNodeResult<ProjectListResult>>;
+export declare const showProject: (projectId: string) => Promise<CliNodeResult<ProjectShowResult>>;
+export declare const listWorkspaces: (input: {
+    readonly afterCursor: string;
+    readonly limit: number;
+    readonly projectId: string;
+}) => Promise<CliNodeResult<WorkspaceListResult>>;
+export declare const showWorkspace: (workspaceId: string) => Promise<CliNodeResult<WorkspaceShowResult>>;
+export declare const readExecutionCatalog: () => Promise<CliNodeResult<ExecutionCatalogGetResult>>;
+export declare const showWorkspaceExecution: (workspaceId: string) => Promise<CliNodeResult<WorkspaceExecutionShowResult>>;
+export declare const configureWorkspaceExecution: (input: ConfigureWorkspaceExecutionInput) => Promise<CliNodeResult<WorkspaceExecutionConfigureResult>>;
+export declare const attachWorkspaceRepository: (input: AttachRepositoryInput) => Promise<CliNodeResult<WorkspaceRepositoryAttachResult>>;
+export declare const getReceipt: (commandId: string) => Promise<CliNodeResult<ReceiptGetResult>>;
+export declare const listReceipts: (input: ReceiptListParameters) => Promise<CliNodeResult<ReceiptListResult>>;
+//# sourceMappingURL=client.d.ts.map

package/dist/project-workspace/client.js

@@ -0,0 +1,54 @@
+import { basename, resolve } from "node:path";
+import { projectListParametersSchema, projectRegisterParametersSchema, projectShowParametersSchema, receiptGetParametersSchema, receiptListParametersSchema, workspaceExecutionConfigureParametersSchema, workspaceExecutionShowParametersSchema, workspaceListParametersSchema, workspaceRepositoryAttachParametersSchema, workspaceShowParametersSchema, } from "@maiaos/sdk";
+import { newCliIdentifier, outcomeCanBeAmbiguous, runNodeClientOperation, runValidatedNodeOperation, } from "../local-node/client.js";
+export const registerProject = (input) => {
+    const rootPath = resolve(input.path);
+    const commandId = input.commandId ?? newCliIdentifier("command");
+    return runValidatedNodeOperation({
+        commandId,
+        expectedRevision: "0",
+        name: input.name ?? basename(rootPath),
+        rootPath,
+    }, projectRegisterParametersSchema, (client, parameters, options) => client.registerProject(parameters, options), { commandId });
+};
+export const projectWorkspaceClientInternals = {
+    outcomeCanBeAmbiguous,
+};
+export const listProjects = (input) => {
+    return runValidatedNodeOperation(input, projectListParametersSchema, (client, parameters, options) => client.listProjects(parameters, options));
+};
+export const showProject = (projectId) => {
+    return runValidatedNodeOperation({ projectId }, projectShowParametersSchema, (client, parameters, options) => client.showProject(parameters, options));
+};
+export const listWorkspaces = (input) => {
+    return runValidatedNodeOperation(input, workspaceListParametersSchema, (client, parameters, options) => client.listWorkspaces(parameters, options));
+};
+export const showWorkspace = (workspaceId) => {
+    return runValidatedNodeOperation({ workspaceId }, workspaceShowParametersSchema, (client, parameters, options) => client.showWorkspace(parameters, options));
+};
+export const readExecutionCatalog = () => runNodeClientOperation((client, options) => client.readExecutionCatalog({}, options));
+export const showWorkspaceExecution = (workspaceId) => {
+    return runValidatedNodeOperation({ workspaceId }, workspaceExecutionShowParametersSchema, (client, parameters, options) => client.showWorkspaceExecution(parameters, options));
+};
+export const configureWorkspaceExecution = (input) => {
+    const commandId = input.commandId ?? newCliIdentifier("command");
+    return runValidatedNodeOperation({ ...input, commandId }, workspaceExecutionConfigureParametersSchema, (client, parameters, options) => client.configureWorkspaceExecution(parameters, options), { commandId });
+};
+export const attachWorkspaceRepository = (input) => {
+    const rootPath = resolve(input.path);
+    const commandId = input.commandId ?? newCliIdentifier("command");
+    return runValidatedNodeOperation({
+        commandId,
+        expectedRevision: input.expectedRevision,
+        name: input.name ?? basename(rootPath),
+        rootPath,
+        workspaceId: input.workspaceId,
+    }, workspaceRepositoryAttachParametersSchema, (client, parameters, options) => client.attachWorkspaceRepository(parameters, options), { commandId });
+};
+export const getReceipt = (commandId) => {
+    return runValidatedNodeOperation({ commandId }, receiptGetParametersSchema, (client, parameters, options) => client.getReceipt(parameters, options));
+};
+export const listReceipts = (input) => {
+    return runValidatedNodeOperation(input, receiptListParametersSchema, (client, parameters, options) => client.listReceipts(parameters, options));
+};
+//# sourceMappingURL=client.js.map

package/dist/project-workspace/commands.d.ts

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

package/dist/project-workspace/commands.js

@@ -0,0 +1,239 @@
+import { CliArgumentError, parseOptions, readCursor, readExpectedRevision, readPageSize, requirePositionals, } from "../command-line/arguments.js";
+import { writeNodeResult } from "../command-line/output.js";
+const WORKSPACE_REPOSITORY_ADD_USAGE = "maia [--json] workspace repo add <workspace-id> <repository> --expected-revision <revision> [--name <name>] [--command-id <id>]";
+const summarizeProjectRegistration = (result) => ({
+    checkoutId: result.checkout.id,
+    delivery: result.delivery,
+    projectId: result.project.id,
+    receipt: result.receipt,
+    repositoryId: result.repository.id,
+    workspaceId: result.workspace.id,
+});
+const summarizeRepositoryAttachment = (result) => ({
+    checkoutId: result.checkout.id,
+    delivery: result.delivery,
+    receipt: result.receipt,
+    repositoryId: result.repository.id,
+    workspaceId: result.workspace.id,
+    workspaceRevision: result.workspace.revision,
+});
+const runProjectAdd = async (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set(["--command-id", "--name"]));
+    requirePositionals(parsed.positionals, 1, "maia project add <repository>");
+    const path = parsed.positionals[0];
+    if (path === undefined) {
+        throw new CliArgumentError("The repository path is missing.");
+    }
+    const commandId = parsed.options.get("--command-id");
+    const name = parsed.options.get("--name");
+    const result = await context.dependencies.registerProject({
+        path,
+        ...(commandId === undefined ? {} : { commandId }),
+        ...(name === undefined ? {} : { name }),
+    });
+    return writeNodeResult(result, context, (value) => ({
+        command: "project.add",
+        result: summarizeProjectRegistration(value),
+    }));
+};
+const runProjectList = async (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set(["--after", "--limit"]));
+    requirePositionals(parsed.positionals, 0, "maia project list");
+    const result = await context.dependencies.listProjects({
+        afterCursor: readCursor(parsed.options.get("--after")),
+        limit: readPageSize(parsed.options.get("--limit")),
+    });
+    return writeNodeResult(result, context, (value) => ({
+        command: "project.list",
+        result: value,
+    }));
+};
+const runProjectShow = async (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set());
+    requirePositionals(parsed.positionals, 1, "maia project show <project-id>");
+    const projectId = parsed.positionals[0];
+    if (projectId === undefined) {
+        throw new CliArgumentError("The project identifier is missing.");
+    }
+    const result = await context.dependencies.showProject(projectId);
+    return writeNodeResult(result, context, (value) => ({
+        command: "project.show",
+        result: value,
+    }));
+};
+export const runProjectCommand = (tokens, context) => {
+    const [subcommand, ...rest] = tokens;
+    if (subcommand === "add")
+        return runProjectAdd(rest, context);
+    if (subcommand === "list")
+        return runProjectList(rest, context);
+    if (subcommand === "show")
+        return runProjectShow(rest, context);
+    throw new CliArgumentError("Usage: maia project <add|list|show>");
+};
+const runExecutionCatalog = async (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set());
+    requirePositionals(parsed.positionals, 0, "maia execution catalog");
+    const operation = context.dependencies.readExecutionCatalog;
+    if (operation === undefined)
+        throw new Error("Missing execution client.");
+    const result = await operation();
+    return writeNodeResult(result, context, (value) => ({
+        command: "execution.catalog",
+        result: value,
+    }));
+};
+export const runExecutionCommand = (tokens, context) => {
+    const [subcommand, ...rest] = tokens;
+    if (subcommand === "catalog")
+        return runExecutionCatalog(rest, context);
+    throw new CliArgumentError("Usage: maia execution catalog");
+};
+const runWorkspaceList = async (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set(["--after", "--limit", "--project"]));
+    requirePositionals(parsed.positionals, 0, "maia workspace list --project <project-id>");
+    const projectId = parsed.options.get("--project");
+    if (projectId === undefined) {
+        throw new CliArgumentError("Option '--project' is required.");
+    }
+    const result = await context.dependencies.listWorkspaces({
+        afterCursor: readCursor(parsed.options.get("--after")),
+        limit: readPageSize(parsed.options.get("--limit")),
+        projectId,
+    });
+    return writeNodeResult(result, context, (value) => ({
+        command: "workspace.list",
+        result: value,
+    }));
+};
+const runWorkspaceShow = async (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set());
+    requirePositionals(parsed.positionals, 1, "maia workspace show <workspace-id>");
+    const workspaceId = parsed.positionals[0];
+    if (workspaceId === undefined) {
+        throw new CliArgumentError("The workspace identifier is missing.");
+    }
+    const result = await context.dependencies.showWorkspace(workspaceId);
+    return writeNodeResult(result, context, (value) => ({
+        command: "workspace.show",
+        result: value,
+    }));
+};
+const parseWorkspaceRepositoryAdd = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--command-id", "--expected-revision", "--name"]));
+    requirePositionals(parsed.positionals, 2, WORKSPACE_REPOSITORY_ADD_USAGE);
+    const [workspaceId, path] = parsed.positionals;
+    const expectedRevision = readExpectedRevision(parsed.options.get("--expected-revision"));
+    if (workspaceId === undefined || path === undefined) {
+        throw new CliArgumentError("Workspace and repository are required.");
+    }
+    const commandId = parsed.options.get("--command-id");
+    const name = parsed.options.get("--name");
+    return {
+        expectedRevision,
+        path,
+        workspaceId,
+        ...(commandId === undefined ? {} : { commandId }),
+        ...(name === undefined ? {} : { name }),
+    };
+};
+const runWorkspaceRepositoryAdd = async (tokens, context) => {
+    const input = parseWorkspaceRepositoryAdd(tokens);
+    const result = await context.dependencies.attachWorkspaceRepository(input);
+    return writeNodeResult(result, context, (value) => ({
+        command: "workspace.repo.add",
+        result: summarizeRepositoryAttachment(value),
+    }));
+};
+const summarizeExecutionConfiguration = (result) => ({
+    ...(result.binding === undefined ? {} : { binding: result.binding }),
+    delivery: result.delivery,
+    receipt: result.receipt,
+    resolution: result.resolution,
+    workspaceId: result.workspace.id,
+    workspaceRevision: result.workspace.revision,
+});
+const readExecutionSelection = (profileId, policyId) => {
+    if ((profileId === undefined) === (policyId === undefined)) {
+        throw new CliArgumentError("Exactly one of '--profile' or '--policy' is required.");
+    }
+    return profileId === undefined
+        ? { id: policyId ?? "", kind: "policy" }
+        : { id: profileId, kind: "profile" };
+};
+const readExecutionMutation = (parsed, usage) => {
+    requirePositionals(parsed.positionals, 1, usage);
+    const workspaceId = parsed.positionals[0];
+    if (workspaceId === undefined) {
+        throw new CliArgumentError("The workspace identifier is missing.");
+    }
+    const commandId = parsed.options.get("--command-id");
+    return {
+        expectedRevision: readExpectedRevision(parsed.options.get("--expected-revision")),
+        workspaceId,
+        ...(commandId === undefined ? {} : { commandId }),
+    };
+};
+const readExecutionInput = (operation, tokens) => {
+    const parsed = parseOptions(tokens, new Set([
+        "--command-id",
+        "--expected-revision",
+        ...(operation === "set" ? ["--policy", "--profile"] : []),
+    ]));
+    const common = readExecutionMutation(parsed, operation === "set"
+        ? "maia workspace execution set <workspace-id> (--profile <profile-id> | --policy <policy-id>) --expected-revision <revision> [--command-id <id>]"
+        : "maia workspace execution clear <workspace-id> --expected-revision <revision> [--command-id <id>]");
+    return operation === "clear"
+        ? { ...common, operation }
+        : {
+            ...common,
+            operation,
+            selection: readExecutionSelection(parsed.options.get("--profile"), parsed.options.get("--policy")),
+        };
+};
+const runWorkspaceExecutionShow = async (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set());
+    requirePositionals(parsed.positionals, 1, "maia workspace execution show <workspace-id>");
+    const workspaceId = parsed.positionals[0];
+    if (workspaceId === undefined) {
+        throw new CliArgumentError("The workspace identifier is missing.");
+    }
+    const operation = context.dependencies.showWorkspaceExecution;
+    if (operation === undefined)
+        throw new Error("Missing execution client.");
+    const result = await operation(workspaceId);
+    return writeNodeResult(result, context, (value) => ({
+        command: "workspace.execution.show",
+        result: value,
+    }));
+};
+const runWorkspaceExecutionCommand = (tokens, context) => {
+    const [subcommand, ...rest] = tokens;
+    if (subcommand === "show")
+        return runWorkspaceExecutionShow(rest, context);
+    if (subcommand === "set" || subcommand === "clear") {
+        const operation = context.dependencies.configureWorkspaceExecution;
+        if (operation === undefined)
+            throw new Error("Missing execution client.");
+        return operation(readExecutionInput(subcommand, rest)).then((result) => writeNodeResult(result, context, (value) => ({
+            command: "workspace.execution.configure",
+            result: summarizeExecutionConfiguration(value),
+        })));
+    }
+    throw new CliArgumentError("Usage: maia workspace execution <show|set|clear>");
+};
+export const runWorkspaceCommand = (tokens, context) => {
+    const [subcommand, ...rest] = tokens;
+    if (subcommand === "list")
+        return runWorkspaceList(rest, context);
+    if (subcommand === "execution") {
+        return runWorkspaceExecutionCommand(rest, context);
+    }
+    if (subcommand === "show")
+        return runWorkspaceShow(rest, context);
+    if (subcommand === "repo" && rest[0] === "add") {
+        return runWorkspaceRepositoryAdd(rest.slice(1), context);
+    }
+    throw new CliArgumentError("Usage: maia workspace <list|show|repo add>");
+};
+//# sourceMappingURL=commands.js.map

package/dist/runtime/client.d.ts

@@ -0,0 +1,6 @@
+import type { InstalledHarnessListResult, RuntimeProbeResult } from "@maiaos/sdk";
+import { type CliNodeResult } from "../local-node/client.js";
+export declare const listInstalledHarnesses: () => Promise<CliNodeResult<InstalledHarnessListResult>>;
+export declare const probeRuntime: (runtime: "codex" | "pi-rpc") => Promise<CliNodeResult<RuntimeProbeResult>>;
+export declare const probeCodexRuntime: () => Promise<CliNodeResult<RuntimeProbeResult>>;
+//# sourceMappingURL=client.d.ts.map

package/dist/runtime/client.js

@@ -0,0 +1,10 @@
+import { installedHarnessListParametersSchema, runtimeProbeParametersSchema, } from "@maiaos/sdk";
+import { runValidatedNodeOperation, } from "../local-node/client.js";
+export const listInstalledHarnesses = () => {
+    return runValidatedNodeOperation({}, installedHarnessListParametersSchema, (client, parameters, options) => client.listInstalledHarnesses(parameters, options));
+};
+export const probeRuntime = (runtime) => {
+    return runValidatedNodeOperation({ runtime }, runtimeProbeParametersSchema, (client, parameters, options) => client.probeRuntime(parameters, options));
+};
+export const probeCodexRuntime = () => probeRuntime("codex");
+//# sourceMappingURL=client.js.map

package/dist/runtime/command.d.ts

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

package/dist/runtime/command.js

@@ -0,0 +1,20 @@
+import { CliArgumentError, requireNoArguments, } from "../command-line/arguments.js";
+import { writeRuntimeListResult, writeRuntimeProbeResult, } from "../command-line/output.js";
+export const runRuntimeCommand = (tokens, context) => {
+    const [subcommand, ...rest] = tokens;
+    if (subcommand === "list") {
+        requireNoArguments(rest, "Runtime list");
+        return context.dependencies
+            .listInstalledHarnesses()
+            .then((result) => writeRuntimeListResult(result, context));
+    }
+    const [runtime, ...probeRest] = rest;
+    if (subcommand !== "probe" || (runtime !== "codex" && runtime !== "pi-rpc")) {
+        throw new CliArgumentError("Usage: maia runtime list | maia runtime probe <codex|pi-rpc>");
+    }
+    requireNoArguments(probeRest, "Runtime probe");
+    return context.dependencies
+        .probeRuntime(runtime)
+        .then((result) => writeRuntimeProbeResult(result, context));
+};
+//# sourceMappingURL=command.js.map

package/dist/session/client.d.ts

@@ -0,0 +1,32 @@
+import type { SessionCreateResult, SessionEventsListResult, SessionListResult, SessionShowResult, SessionStartResult } from "@maiaos/sdk";
+import { type CliNodeResult } from "../local-node/client.js";
+export type CreateSessionInput = {
+    readonly commandId?: string;
+    readonly profile: "pi-rpc";
+    readonly runtime: "pi";
+    readonly workspaceId: string;
+} | {
+    readonly commandId?: string;
+    readonly profile?: "codex";
+    readonly runtime: "codex";
+    readonly workspaceId: string;
+};
+export declare const createSession: (input: CreateSessionInput) => Promise<CliNodeResult<SessionCreateResult>>;
+export declare const listSessions: (input: {
+    readonly afterCursor: string;
+    readonly limit: number;
+    readonly projectId: string;
+}) => Promise<CliNodeResult<SessionListResult>>;
+export declare const showSession: (sessionId: string) => Promise<CliNodeResult<SessionShowResult>>;
+export declare const listSessionEvents: (input: {
+    readonly afterSessionCursor: string;
+    readonly limit: number;
+    readonly sessionId: string;
+}) => Promise<CliNodeResult<SessionEventsListResult>>;
+export type StartSessionInput = {
+    readonly commandId?: string;
+    readonly expectedRevision: string;
+    readonly sessionId: string;
+};
+export declare const startSession: (input: StartSessionInput) => Promise<CliNodeResult<SessionStartResult>>;
+//# sourceMappingURL=client.d.ts.map

package/dist/session/client.js

@@ -0,0 +1,30 @@
+import { sessionCreateParametersSchema, sessionEventsListParametersSchema, sessionListParametersSchema, sessionShowParametersSchema, sessionStartParametersSchema, } from "@maiaos/sdk";
+import { newCliIdentifier, runValidatedNodeOperation, } from "../local-node/client.js";
+export const createSession = (input) => {
+    const commandId = input.commandId ?? newCliIdentifier("command");
+    return runValidatedNodeOperation({
+        commandId,
+        expectedRevision: "0",
+        ...(input.profile === undefined ? {} : { profile: input.profile }),
+        runtime: input.runtime,
+        workspaceId: input.workspaceId,
+    }, sessionCreateParametersSchema, (client, parameters, options) => client.createSession(parameters, options), { commandId });
+};
+export const listSessions = (input) => {
+    return runValidatedNodeOperation(input, sessionListParametersSchema, (client, parameters, options) => client.listSessions(parameters, options));
+};
+export const showSession = (sessionId) => {
+    return runValidatedNodeOperation({ sessionId }, sessionShowParametersSchema, (client, parameters, options) => client.showSession(parameters, options));
+};
+export const listSessionEvents = (input) => {
+    return runValidatedNodeOperation(input, sessionEventsListParametersSchema, (client, parameters, options) => client.listSessionEvents(parameters, options));
+};
+export const startSession = (input) => {
+    const commandId = input.commandId ?? newCliIdentifier("command");
+    return runValidatedNodeOperation({
+        commandId,
+        expectedRevision: input.expectedRevision,
+        sessionId: input.sessionId,
+    }, sessionStartParametersSchema, (client, parameters, options) => client.startSession(parameters, options), { commandId });
+};
+//# sourceMappingURL=client.js.map

package/dist/session/commands.d.ts

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