@maiaos/cli 0.1.0-canary.2

package/dist/login/vendor-account.js

@@ -0,0 +1,75 @@
+import { Effect } from "effect";
+import { CliArgumentError, writeSuccess, } from "../command-line/index.js";
+import { callNode, ConnectionNodeError, findConnectionByName, formatConnectionResult, redactConnection, redactConnectionResult, runVendorLogin, } from "../connection/index.js";
+import { newCliIdentifier } from "../local-node/index.js";
+import { safeLoginError } from "./failure.js";
+import { nextFreeName } from "./vendor-input.js";
+const allAccounts = (context) => callNode(context.dependencies.listConnections, (list) => list({ limit: 100 }));
+const accountName = (context, input) => input.name === undefined
+    ? allAccounts(context).pipe(Effect.map((result) => nextFreeName(input.vendor, new Set(result.items.map((item) => item.name)))))
+    : Effect.succeed(input.name);
+const createAccount = (context, input, name) => callNode(context.dependencies.createConnection, (create) => Effect.flatMap(newCliIdentifier("command"), (commandId) => create({
+    commandId,
+    configRootKind: "maia-managed",
+    executor: input.executor,
+    name,
+    ...(input.maxConcurrentSessions === undefined
+        ? {}
+        : { maxConcurrentSessions: input.maxConcurrentSessions }),
+}))).pipe(Effect.map((result) => result.connection));
+const requireSignable = (connection, input) => {
+    if (connection.executor !== input.executor)
+        return Effect.fail(new CliArgumentError(`'${connection.name}' is a ${connection.executor} account.`));
+    if (connection.state !== "enabled")
+        return Effect.fail(new CliArgumentError(`Enable '${connection.name}' first: maia connection enable ${connection.name}.`));
+    return connection.configRoot.kind === "maia-managed"
+        ? Effect.succeed(connection)
+        : Effect.fail(new CliArgumentError(`'${connection.name}' uses your normal ${input.vendor} login; it is already signed in through the ${input.vendor} CLI.`));
+};
+const signableAccount = (context, input) => Effect.gen(function* () {
+    const name = yield* accountName(context, input);
+    const existing = yield* findConnectionByName(context, name);
+    return yield* requireSignable(existing ?? (yield* createAccount(context, input, name)), input);
+});
+const vendorSignIn = (context, connection, input) => Effect.suspend(() => (context.dependencies.runVendorLogin ?? runVendorLogin)(connection, {
+    deviceCode: input.deviceCode,
+})).pipe(Effect.catchDefect(Effect.fail), Effect.mapError(() => safeLoginError("The vendor sign-in could not start.")), Effect.flatMap((status) => status === 0
+    ? Effect.void
+    : Effect.fail(new ConnectionNodeError({
+        code: "login_failed",
+        message: `The ${connection.executor} sign-in exited with status ${String(status)}.`,
+        retryable: true,
+    }))));
+const freshUsage = (context, connection) => connection.executor === "codex-cli"
+    ? callNode(context.dependencies.showConnectionUsage, (show) => show({ connectionId: connection.connectionId, refresh: true })).pipe(Effect.map((result) => result.connection), Effect.orElseSucceed(() => connection))
+    : Effect.succeed(connection);
+export const signInHere = (context, input) => Effect.gen(function* () {
+    const connection = yield* signableAccount(context, input);
+    yield* vendorSignIn(context, connection, input);
+    return yield* freshUsage(context, connection);
+});
+export const writeSignedIn = (context, connection) => {
+    writeSuccess({
+        command: "connection.login",
+        result: {
+            connection: redactConnection(connection),
+            method: "connection.login",
+        },
+    }, context, formatConnectionResult);
+    return 0;
+};
+const startDeviceCodeLogin = (context, connection) => callNode(context.dependencies.startConnectionLogin, (start) => Effect.flatMap(newCliIdentifier("command"), (commandId) => start({
+    commandId,
+    connectionId: connection.connectionId,
+    expectedRevision: connection.revision,
+    flow: "device-code",
+})));
+export const signInThroughNode = (context, input) => Effect.gen(function* () {
+    if (input.executor !== "codex-cli")
+        return yield* Effect.fail(new CliArgumentError("Claude Code signs in from a terminal: run 'maia login claude' in one."));
+    const connection = yield* signableAccount(context, input);
+    const started = yield* startDeviceCodeLogin(context, connection);
+    writeSuccess({ command: started.method, result: redactConnectionResult(started) }, context, formatConnectionResult);
+    return 0;
+});
+//# sourceMappingURL=vendor-account.js.map

package/dist/login/vendor-input.d.ts

@@ -0,0 +1,14 @@
+export type Vendor = "claude" | "codex";
+type VendorExecutor = "claude-code" | "codex-cli";
+export declare const vendorExecutor: (vendor: string) => undefined | VendorExecutor;
+export type VendorLoginInput = {
+    readonly deviceCode: boolean;
+    readonly executor: VendorExecutor;
+    readonly maxConcurrentSessions?: number;
+    readonly name?: string;
+    readonly vendor: Vendor;
+};
+export declare const readVendorLogin: (tokens: readonly string[]) => VendorLoginInput;
+export declare const nextFreeName: (vendor: Vendor, taken: ReadonlySet<string>) => string;
+export {};
+//# sourceMappingURL=vendor-input.d.ts.map

package/dist/login/vendor-input.js

@@ -0,0 +1,36 @@
+import { CliArgumentError, parseOptions, requirePositionals, } from "../command-line/index.js";
+const EXECUTORS = new Map([
+    ["claude", "claude-code"],
+    ["codex", "codex-cli"],
+]);
+export const vendorExecutor = (vendor) => EXECUTORS.get(vendor);
+const readSessionLimit = (value) => {
+    if (value === undefined)
+        return {};
+    if (!/^(?:[1-9]|1[0-6])$/u.test(value))
+        throw new CliArgumentError("Option '--max-sessions' must be an integer from 1 to 16.");
+    return { maxConcurrentSessions: Number(value) };
+};
+export const readVendorLogin = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--max-sessions", "--name"]), new Set(["--device-code"]));
+    requirePositionals(parsed.positionals, 1);
+    const vendor = parsed.positionals[0] ?? "";
+    const executor = vendorExecutor(vendor);
+    if (executor === undefined || (vendor !== "claude" && vendor !== "codex"))
+        throw new CliArgumentError("The vendor must be claude or codex.");
+    const name = parsed.options.get("--name");
+    return {
+        deviceCode: parsed.flags.has("--device-code"),
+        executor,
+        vendor,
+        ...(name === undefined ? {} : { name }),
+        ...readSessionLimit(parsed.options.get("--max-sessions")),
+    };
+};
+export const nextFreeName = (vendor, taken) => {
+    const candidate = (index) => taken.has(`${vendor}-${String(index)}`)
+        ? candidate(index + 1)
+        : `${vendor}-${String(index)}`;
+    return candidate(1);
+};
+//# sourceMappingURL=vendor-input.js.map

package/dist/mcp/calls.d.ts

@@ -0,0 +1,7 @@
+import type { CoordinatorToolOperation } from "@maiaos/sdk";
+import { type LocalNodeRequestMethod } from "@maiaos/sdk";
+import { type CliNodeEffect, type CliNodeOperations } from "../local-node/index.js";
+export type CoordinatorCall = (node: CliNodeOperations, input: unknown) => CliNodeEffect<unknown>;
+export declare const COORDINATOR_CALLS: ReadonlyMap<CoordinatorToolOperation, CoordinatorCall>;
+export declare const WORKER_CALLS: ReadonlyMap<LocalNodeRequestMethod, CoordinatorCall>;
+//# sourceMappingURL=calls.d.ts.map

package/dist/mcp/calls.js

@@ -0,0 +1,202 @@
+import { approvalListParametersSchema, approvalShowParametersSchema, connectionDetectParametersSchema, connectionListParametersSchema, connectionModelsListParametersSchema, connectionShowParametersSchema, connectionUsageShowParametersSchema, containerIndexListParametersSchema, COORDINATOR_TOOL_OPERATIONS, discoverySessionsListParametersSchema, invocationContextShowParametersSchema, LOCAL_NODE_CALL_METHODS, localNodeRequestPayloadSchema, portLeaseAcquireParametersSchema, portLeaseListParametersSchema, portLeaseReleaseParametersSchema, portLeaseRenewParametersSchema, projectGuardShowParametersSchema, projectListParametersSchema, projectShowParametersSchema, receiptGetParametersSchema, runLedgerCreateParametersSchema, runLedgerListParametersSchema, runLedgerTaskDispatchParametersSchema, runLedgerTaskListParametersSchema, runLedgerTaskSettleParametersSchema, runLedgerTaskShowParametersSchema, sessionArchiveParametersSchema, sessionCreateParametersSchema, sessionDiffParametersSchema, sessionEventsListParametersSchema, sessionHistoryReadParametersSchema, sessionListParametersSchema, sessionObserveParametersSchema, sessionResumeParametersSchema, sessionShowParametersSchema, sessionStartParametersSchema, sessionStopParametersSchema, turnInterruptParametersSchema, turnSendParametersSchema, turnShowParametersSchema, turnWaitParametersSchema, workerToolDefinitions, workspaceListParametersSchema, workspaceShowParametersSchema, } from "@maiaos/sdk";
+import { Predicate } from "effect";
+import { invalidNodeInput, } from "../local-node/index.js";
+const recoveryOf = (input) => Predicate.hasProperty(input, "commandId") &&
+    Predicate.isString(input.commandId)
+    ? { commandId: input.commandId }
+    : undefined;
+const validated = (schema, run) => (node, input) => node.runValidatedNodeOperation(input, schema, run, recoveryOf(input));
+const status = (node, input) => input === undefined ||
+    (Predicate.isObject(input) && Object.keys(input).length === 0)
+    ? node.runNodeClientOperation((client, options) => client.status(options))
+    : invalidNodeInput();
+const callBound = new Set(LOCAL_NODE_CALL_METHODS);
+const isCallPayload = (payload) => callBound.has(payload.method);
+const isCallBound = (operation) => callBound.has(operation);
+const typedCall = (method) => (node, input) => {
+    const payload = localNodeRequestPayloadSchema.safeParse({
+        method,
+        parameters: input,
+    });
+    if (!payload.success)
+        return invalidNodeInput(payload.error);
+    const { data } = payload;
+    return isCallPayload(data)
+        ? node.runNodeClientOperation((client, options) => client.call(data.method, data.parameters, options), recoveryOf(input))
+        : invalidNodeInput();
+};
+export const COORDINATOR_CALLS = new Map([
+    ...COORDINATOR_TOOL_OPERATIONS.filter(isCallBound).map((operation) => [operation, typedCall(operation)]),
+    [
+        "approval.list",
+        validated(approvalListParametersSchema, (client, parameters, options) => client.listApprovals(parameters, options)),
+    ],
+    [
+        "approval.show",
+        validated(approvalShowParametersSchema, (client, parameters, options) => client.showApproval(parameters, options)),
+    ],
+    [
+        "connection.detect",
+        validated(connectionDetectParametersSchema, (client, parameters, options) => client.detectConnections(parameters, options)),
+    ],
+    [
+        "connection.list",
+        validated(connectionListParametersSchema, (client, parameters, options) => client.listConnections(parameters, options)),
+    ],
+    [
+        "connection.models.list",
+        validated(connectionModelsListParametersSchema, (client, parameters, options) => client.listConnectionModels(parameters, options)),
+    ],
+    [
+        "connection.show",
+        validated(connectionShowParametersSchema, (client, parameters, options) => client.showConnection(parameters, options)),
+    ],
+    [
+        "connection.usage.show",
+        validated(connectionUsageShowParametersSchema, (client, parameters, options) => client.showConnectionUsage(parameters, options)),
+    ],
+    [
+        "container.index.list",
+        validated(containerIndexListParametersSchema, (client, parameters, options) => client.listContainerIndex(parameters, options)),
+    ],
+    [
+        "discovery.sessions.list",
+        validated(discoverySessionsListParametersSchema, (client, parameters, options) => client.listDiscoveredSessions(parameters, options)),
+    ],
+    ["node.status", status],
+    [
+        "port.lease.acquire",
+        validated(portLeaseAcquireParametersSchema, (client, parameters, options) => client.acquirePortLease(parameters, options)),
+    ],
+    [
+        "port.lease.list",
+        validated(portLeaseListParametersSchema, (client, parameters, options) => client.listPortLeases(parameters, options)),
+    ],
+    [
+        "port.lease.release",
+        validated(portLeaseReleaseParametersSchema, (client, parameters, options) => client.releasePortLease(parameters, options)),
+    ],
+    [
+        "port.lease.renew",
+        validated(portLeaseRenewParametersSchema, (client, parameters, options) => client.renewPortLease(parameters, options)),
+    ],
+    [
+        "project.guard.show",
+        validated(projectGuardShowParametersSchema, (client, parameters, options) => client.showProjectGuard(parameters, options)),
+    ],
+    [
+        "project.list",
+        validated(projectListParametersSchema, (client, parameters, options) => client.listProjects(parameters, options)),
+    ],
+    [
+        "project.show",
+        validated(projectShowParametersSchema, (client, parameters, options) => client.showProject(parameters, options)),
+    ],
+    [
+        "receipt.get",
+        validated(receiptGetParametersSchema, (client, parameters, options) => client.getReceipt(parameters, options)),
+    ],
+    [
+        "run.ledger.create",
+        validated(runLedgerCreateParametersSchema, (client, parameters, options) => client.createRunLedger(parameters, options)),
+    ],
+    [
+        "run.ledger.list",
+        validated(runLedgerListParametersSchema, (client, parameters, options) => client.listRunLedgers(parameters, options)),
+    ],
+    [
+        "run.ledger.task.dispatch",
+        validated(runLedgerTaskDispatchParametersSchema, (client, parameters, options) => client.dispatchRunLedgerTask(parameters, options)),
+    ],
+    [
+        "run.ledger.task.list",
+        validated(runLedgerTaskListParametersSchema, (client, parameters, options) => client.listRunLedgerTasks(parameters, options)),
+    ],
+    [
+        "run.ledger.task.settle",
+        validated(runLedgerTaskSettleParametersSchema, (client, parameters, options) => client.settleRunLedgerTask(parameters, options)),
+    ],
+    [
+        "run.ledger.task.show",
+        validated(runLedgerTaskShowParametersSchema, (client, parameters, options) => client.showRunLedgerTask(parameters, options)),
+    ],
+    [
+        "session.archive",
+        validated(sessionArchiveParametersSchema, (client, parameters, options) => client.archiveSession(parameters, options)),
+    ],
+    [
+        "session.create",
+        validated(sessionCreateParametersSchema, (client, parameters, options) => client.createSession(parameters, options)),
+    ],
+    [
+        "session.diff",
+        validated(sessionDiffParametersSchema, (client, parameters, options) => client.diffSession(parameters, options)),
+    ],
+    [
+        "session.events.list",
+        validated(sessionEventsListParametersSchema, (client, parameters, options) => client.listSessionEvents(parameters, options)),
+    ],
+    [
+        "session.history.read",
+        validated(sessionHistoryReadParametersSchema, (client, parameters, options) => client.readSessionHistory(parameters, options)),
+    ],
+    [
+        "session.list",
+        validated(sessionListParametersSchema, (client, parameters, options) => client.listSessions(parameters, options)),
+    ],
+    [
+        "session.observe",
+        validated(sessionObserveParametersSchema, (client, parameters, options) => client.observeSessions(parameters, options)),
+    ],
+    [
+        "session.resume",
+        validated(sessionResumeParametersSchema, (client, parameters, options) => client.resumeSession(parameters, options)),
+    ],
+    [
+        "session.show",
+        validated(sessionShowParametersSchema, (client, parameters, options) => client.showSession(parameters, options)),
+    ],
+    [
+        "session.start",
+        validated(sessionStartParametersSchema, (client, parameters, options) => client.startSession(parameters, options)),
+    ],
+    [
+        "session.stop",
+        validated(sessionStopParametersSchema, (client, parameters, options) => client.stopSession(parameters, options)),
+    ],
+    [
+        "turn.interrupt",
+        validated(turnInterruptParametersSchema, (client, parameters, options) => client.interruptTurn(parameters, options)),
+    ],
+    [
+        "turn.send",
+        validated(turnSendParametersSchema, (client, parameters, options) => client.sendTurn(parameters, options)),
+    ],
+    [
+        "turn.show",
+        validated(turnShowParametersSchema, (client, parameters, options) => client.showTurn(parameters, options)),
+    ],
+    [
+        "turn.wait",
+        validated(turnWaitParametersSchema, (client, parameters, options) => client.waitTurns(parameters, options)),
+    ],
+    [
+        "workspace.list",
+        validated(workspaceListParametersSchema, (client, parameters, options) => client.listWorkspaces(parameters, options)),
+    ],
+    [
+        "workspace.show",
+        validated(workspaceShowParametersSchema, (client, parameters, options) => client.showWorkspace(parameters, options)),
+    ],
+]);
+export const WORKER_CALLS = (() => {
+    const available = new Map(COORDINATOR_CALLS);
+    available.set("context.show", validated(invocationContextShowParametersSchema, (client, parameters, options) => client.showCurrentContext(parameters, options)));
+    return new Map(workerToolDefinitions().map(({ operation }) => {
+        const call = available.get(operation);
+        if (call === undefined)
+            throw new Error(`No worker SDK call for ${operation}.`);
+        return [operation, call];
+    }));
+})();
+//# sourceMappingURL=calls.js.map

package/dist/mcp/commands.d.ts

@@ -0,0 +1,9 @@
+import * as Effect from "effect/Effect";
+import { type CliServices, type CommandContext, type CommandEffect } from "../command-line/index.js";
+import type { CliNodeOperations } from "../local-node/index.js";
+export type McpCliDependencies = {
+    readonly serveMcp: (version: string, worker?: boolean) => Effect.Effect<number, unknown, CliServices>;
+};
+export declare const makeMcpClient: (node: CliNodeOperations) => McpCliDependencies;
+export declare const runMcpCommand: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+//# sourceMappingURL=commands.d.ts.map

package/dist/mcp/commands.js

@@ -0,0 +1,21 @@
+import * as Config from "effect/Config";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { requireNoArguments, } from "../command-line/index.js";
+export const makeMcpClient = (node) => ({
+    serveMcp: (version, worker = false) => Effect.promise(() => import("./server.js")).pipe(Effect.flatMap((module) => Effect.gen(function* () {
+        const credential = yield* Config.option(Config.String("MAIA_SESSION_CREDENTIAL"));
+        const origin = yield* Config.option(Config.String("MAIA_NODE_ORIGIN"));
+        const session = worker || Option.isSome(credential) || Option.isSome(origin);
+        return yield* module.serveCoordinatorMcp(session ? node.asSession() : node.asCoordinator(), version, { worker: session });
+    }))),
+});
+export const runMcpCommand = (tokens, context) => {
+    const worker = tokens[0] === "--worker";
+    requireNoArguments(worker ? tokens.slice(1) : tokens, "MCP");
+    const { serveMcp } = context.dependencies;
+    if (serveMcp === undefined)
+        return Effect.die(new Error("The MCP server is unavailable."));
+    return Effect.orDie(serveMcp(context.version, worker));
+};
+//# sourceMappingURL=commands.js.map

package/dist/mcp/index.d.ts

@@ -0,0 +1,2 @@
+export { makeMcpClient, type McpCliDependencies, runMcpCommand, } from "./commands.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/mcp/index.js

@@ -0,0 +1,2 @@
+export { makeMcpClient, runMcpCommand, } from "./commands.js";
+//# sourceMappingURL=index.js.map

package/dist/mcp/server.d.ts

@@ -0,0 +1,11 @@
+import { Cause, Crypto, Effect, Layer } from "effect";
+import { McpSchema } from "effect/ai";
+import type { Stdio } from "effect/Stdio";
+import type { CliNodeOperations, CliNodeResult } from "../local-node/index.js";
+export declare const toolResult: (result: CliNodeResult<unknown>) => McpSchema.CallToolResult;
+export declare const coordinatorMcpLayer: (node: CliNodeOperations, version: string, worker?: boolean) => Layer.Layer<never, Cause.IllegalArgumentError, Crypto.Crypto | Stdio>;
+export declare const serveCoordinatorMcp: (node: CliNodeOperations, version: string, options?: {
+    readonly stdio?: Layer.Layer<Stdio>;
+    readonly worker?: boolean;
+}) => Effect.Effect<number, never, Crypto.Crypto>;
+//# sourceMappingURL=server.d.ts.map

package/dist/mcp/server.js

@@ -0,0 +1,57 @@
+import * as NodeStdio from "@effect/platform-node-shared/NodeStdio";
+import { coordinatorToolDefinitions, workerToolDefinitions, } from "@maiaos/sdk";
+import { Cause, Context, Crypto, Effect, Exit, Fiber, Layer, Logger, } from "effect";
+import { McpProtocol, McpSchema, McpServer } from "effect/ai";
+import { COORDINATOR_CALLS, WORKER_CALLS, } from "./calls.js";
+export const toolResult = (result) => result.ok
+    ? new McpSchema.CallToolResult({
+        content: [{ text: JSON.stringify(result.value), type: "text" }],
+    })
+    : new McpSchema.CallToolResult({
+        content: [
+            {
+                text: JSON.stringify({
+                    error: result.error,
+                    ...(result.recovery === undefined
+                        ? {}
+                        : { recovery: result.recovery }),
+                }),
+                type: "text",
+            },
+        ],
+        isError: true,
+    });
+const toolFor = (definition) => new McpSchema.Tool({
+    annotations: {
+        destructiveHint: definition.destructive,
+        idempotentHint: true,
+        openWorldHint: false,
+        readOnlyHint: definition.readOnly,
+    },
+    description: definition.description,
+    inputSchema: definition.inputSchema,
+    name: definition.name,
+});
+const callFor = (definition) => {
+    const call = WORKER_CALLS.get(definition.operation) ??
+        [...COORDINATOR_CALLS].find(([operation]) => operation === definition.operation)?.[1];
+    return call === undefined
+        ? Effect.die(new Error(`No SDK call for ${definition.operation}.`))
+        : Effect.succeed(call);
+};
+const registerTools = (node, worker) => Effect.gen(function* () {
+    const server = yield* McpServer.McpServer;
+    const crypto = yield* Crypto.Crypto;
+    yield* Effect.forEach(worker ? workerToolDefinitions() : coordinatorToolDefinitions(), (definition) => Effect.flatMap(callFor(definition), (call) => server.addTool({
+        annotations: Context.empty(),
+        handle: (payload) => call(node, payload).pipe(Effect.provideService(Crypto.Crypto, crypto), Effect.map(toolResult)),
+        tool: toolFor(definition),
+    })), { discard: true });
+});
+export const coordinatorMcpLayer = (node, version, worker = false) => Layer.effectDiscard(registerTools(node, worker)).pipe(Layer.provide(McpServer.layerStdio({
+    name: "maia",
+    protocols: [McpProtocol.v2025_06_18],
+    version,
+})));
+export const serveCoordinatorMcp = (node, version, options = {}) => Layer.launch(coordinatorMcpLayer(node, version, options.worker)).pipe(Effect.provide(options.stdio ?? NodeStdio.layer), Effect.provideService(Logger.LogToStderr, true), Effect.forkChild, Effect.flatMap(Fiber.await), Effect.map((exit) => Exit.isSuccess(exit) || Cause.hasInterruptsOnly(exit.cause) ? 0 : 1));
+//# sourceMappingURL=server.js.map

package/dist/orchestration/client.d.ts

@@ -0,0 +1,78 @@
+import type { OrchestrationDispatchSettleTerminalResult, OrchestrationDispatchShowResult, OrchestrationInboxAckResult, OrchestrationInboxCheckParameters, OrchestrationInboxCheckResult, OrchestrationQuestionCancelResult, OrchestrationQuestionOpenResult, OrchestrationQuestionReplyResult, OrchestrationRunCreateResult, OrchestrationRunListResult, OrchestrationRunShowResult, OrchestrationTaskGraph, OrchestrationTaskListResult, OrchestrationTaskShowResult } from "@maiaos/sdk";
+import { type CliNodeEffect, type CliNodeOperations } from "../local-node/index.js";
+type MutationInput = {
+    readonly commandId?: string;
+};
+type CreateRunInput = {
+    readonly commandId?: string;
+    readonly graph: OrchestrationTaskGraph;
+    readonly terminalId: string;
+    readonly workspaceId: string;
+};
+export declare const makeOrchestrationClient: (node: CliNodeOperations) => {
+    acknowledgeRunDelivery: (input: MutationInput & {
+        readonly coordinatorEpoch: 1;
+        readonly deliveryId: string;
+        readonly expectedMailboxRevision: string;
+        readonly owner: OrchestrationInboxCheckParameters["owner"];
+        readonly runId: string;
+    }) => CliNodeEffect<OrchestrationInboxAckResult>;
+    cancelRunQuestion: (input: (MutationInput & {
+        readonly coordinatorEpoch: 1;
+        readonly dispatchId: string;
+        readonly expectedDispatchRevision: string;
+        readonly expectedRunRevision: string;
+        readonly runId: string;
+    }) & {
+        readonly expectedQuestionRevision: string;
+        readonly questionId: string;
+    }) => CliNodeEffect<OrchestrationQuestionCancelResult>;
+    checkRunInbox: (input: OrchestrationInboxCheckParameters) => CliNodeEffect<OrchestrationInboxCheckResult>;
+    createRun: (input: CreateRunInput) => CliNodeEffect<OrchestrationRunCreateResult>;
+    listRuns: (input: {
+        readonly afterCursor: string;
+        readonly limit: number;
+        readonly workspaceId: string;
+    }) => CliNodeEffect<OrchestrationRunListResult>;
+    listTasks: (input: {
+        readonly afterCursor: string;
+        readonly limit: number;
+        readonly runId: string;
+    }) => CliNodeEffect<OrchestrationTaskListResult>;
+    openRunQuestion: (input: (MutationInput & {
+        readonly coordinatorEpoch: 1;
+        readonly dispatchId: string;
+        readonly expectedDispatchRevision: string;
+        readonly expectedRunRevision: string;
+        readonly runId: string;
+    }) & {
+        readonly body: string;
+        readonly subject: string;
+    }) => CliNodeEffect<OrchestrationQuestionOpenResult>;
+    replyRunQuestion: (input: (MutationInput & {
+        readonly coordinatorEpoch: 1;
+        readonly dispatchId: string;
+        readonly expectedDispatchRevision: string;
+        readonly expectedRunRevision: string;
+        readonly runId: string;
+    }) & {
+        readonly answer: string;
+        readonly expectedQuestionRevision: string;
+        readonly questionId: string;
+    }) => CliNodeEffect<OrchestrationQuestionReplyResult>;
+    settleRunDispatchTerminal: (input: MutationInput & {
+        readonly coordinatorEpoch: 1;
+        readonly dispatchId: string;
+        readonly expectedDispatchRevision: string;
+        readonly expectedRunRevision: string;
+        readonly runId: string;
+    }) => CliNodeEffect<OrchestrationDispatchSettleTerminalResult>;
+    showDispatch: (runId: string) => CliNodeEffect<OrchestrationDispatchShowResult>;
+    showRun: (runId: string) => CliNodeEffect<OrchestrationRunShowResult>;
+    showTask: (input: {
+        readonly runId: string;
+        readonly taskId: string;
+    }) => CliNodeEffect<OrchestrationTaskShowResult>;
+};
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/orchestration/client.js

@@ -0,0 +1,89 @@
+import { inspectOrchestrationRunCreateAdmission, orchestrationDispatchSettleTerminalParametersSchema, orchestrationDispatchShowParametersSchema, orchestrationInboxAckParametersSchema, orchestrationInboxCheckParametersSchema, orchestrationQuestionCancelParametersSchema, orchestrationQuestionOpenParametersSchema, orchestrationQuestionReplyParametersSchema, orchestrationRunCreateParametersSchema, orchestrationRunListParametersSchema, orchestrationRunShowParametersSchema, orchestrationTaskListParametersSchema, orchestrationTaskShowParametersSchema, } from "@maiaos/sdk";
+import * as Effect from "effect/Effect";
+import { commandIdentifier, invalidNodeInput, } from "../local-node/index.js";
+const admittedRunCreateParameters = (input, commandId) => {
+    const parameters = orchestrationRunCreateParametersSchema.safeParse({
+        commandId,
+        expectedRevision: "0",
+        graph: input.graph,
+        terminalId: input.terminalId,
+        workspaceId: input.workspaceId,
+    });
+    if (!parameters.success)
+        return;
+    try {
+        inspectOrchestrationRunCreateAdmission(parameters.data);
+    }
+    catch {
+        return;
+    }
+    return parameters.data;
+};
+export const makeOrchestrationClient = (node) => {
+    const createRun = (input) => {
+        return Effect.flatMap(commandIdentifier(input.commandId), (commandId) => {
+            const parameters = admittedRunCreateParameters(input, commandId);
+            if (parameters === undefined)
+                return invalidNodeInput();
+            return node.runNodeClientOperation((client, options) => client.createOrchestrationRun(parameters, options), { commandId });
+        });
+    };
+    const listRuns = (input) => {
+        return node.runValidatedNodeOperation(input, orchestrationRunListParametersSchema, (client, parameters, options) => client.listOrchestrationRuns(parameters, options));
+    };
+    const showRun = (runId) => {
+        return node.runValidatedNodeOperation({ runId }, orchestrationRunShowParametersSchema, (client, parameters, options) => client.showOrchestrationRun(parameters, options));
+    };
+    const listTasks = (input) => {
+        return node.runValidatedNodeOperation(input, orchestrationTaskListParametersSchema, (client, parameters, options) => client.listOrchestrationTasks(parameters, options));
+    };
+    const showDispatch = (runId) => {
+        return node.runValidatedNodeOperation({ runId }, orchestrationDispatchShowParametersSchema, (client, parameters, options) => client.showOrchestrationDispatch(parameters, options));
+    };
+    const showTask = (input) => {
+        return node.runValidatedNodeOperation(input, orchestrationTaskShowParametersSchema, (client, parameters, options) => client.showOrchestrationTask(parameters, options));
+    };
+    const checkRunInbox = (input) => {
+        return node.runValidatedNodeOperation(input, orchestrationInboxCheckParametersSchema, (client, parameters, options) => client.checkOrchestrationInbox(parameters, options));
+    };
+    const acknowledgeRunDelivery = (input) => {
+        return Effect.flatMap(commandIdentifier(input.commandId), (commandId) => {
+            return node.runValidatedNodeOperation({ ...input, commandId }, orchestrationInboxAckParametersSchema, (client, parameters, options) => client.acknowledgeOrchestrationDelivery(parameters, options), { commandId });
+        });
+    };
+    const openRunQuestion = (input) => {
+        return Effect.flatMap(commandIdentifier(input.commandId), (commandId) => {
+            return node.runValidatedNodeOperation({ ...input, commandId }, orchestrationQuestionOpenParametersSchema, (client, parameters, options) => client.openOrchestrationQuestion(parameters, options), { commandId });
+        });
+    };
+    const replyRunQuestion = (input) => {
+        return Effect.flatMap(commandIdentifier(input.commandId), (commandId) => {
+            return node.runValidatedNodeOperation({ ...input, commandId }, orchestrationQuestionReplyParametersSchema, (client, parameters, options) => client.replyOrchestrationQuestion(parameters, options), { commandId });
+        });
+    };
+    const cancelRunQuestion = (input) => {
+        return Effect.flatMap(commandIdentifier(input.commandId), (commandId) => {
+            return node.runValidatedNodeOperation({ ...input, commandId }, orchestrationQuestionCancelParametersSchema, (client, parameters, options) => client.cancelOrchestrationQuestion(parameters, options), { commandId });
+        });
+    };
+    const settleRunDispatchTerminal = (input) => {
+        return Effect.flatMap(commandIdentifier(input.commandId), (commandId) => {
+            return node.runValidatedNodeOperation({ ...input, commandId }, orchestrationDispatchSettleTerminalParametersSchema, (client, parameters, options) => client.settleOrchestrationDispatchTerminal(parameters, options), { commandId });
+        });
+    };
+    return {
+        acknowledgeRunDelivery,
+        cancelRunQuestion,
+        checkRunInbox,
+        createRun,
+        listRuns,
+        listTasks,
+        openRunQuestion,
+        replyRunQuestion,
+        settleRunDispatchTerminal,
+        showDispatch,
+        showRun,
+        showTask,
+    };
+};
+//# sourceMappingURL=client.js.map

package/dist/orchestration/commands.d.ts

@@ -0,0 +1,14 @@
+import { type CommandContext, type CommandEffect } from "../command-line/index.js";
+export declare const runCreate: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runShow: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runList: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runTaskList: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runTaskShow: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runInboxCheck: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runInboxAck: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runQuestionOpen: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runQuestionReply: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runQuestionCancel: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runDispatchShow: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runDispatchSettleTerminal: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+//# sourceMappingURL=commands.d.ts.map