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

package/dist/command-receipt/command.js

@@ -0,0 +1,63 @@
+import { DEFAULT_RECEIPT_LIST_PAGE_SIZE, } from "@maiaos/sdk";
+import { CliArgumentError, parseOptions, requirePositionals, } from "../command-line/arguments.js";
+import { writeNodeResult } from "../command-line/output.js";
+import { projectReceiptListResult } from "./compact-list.js";
+const RECEIPT_LIST_USAGE = "maia [--json] receipt list [--limit <1..32>] [--after <cursor>] [--actor <actor-id>] [--method <method>] [--since <recorded-at>] [--until <recorded-at>]";
+const RECEIPT_SHOW_USAGE = "maia receipt show <command-id>";
+const readReceiptListPageSize = (value) => {
+    if (value === undefined)
+        return DEFAULT_RECEIPT_LIST_PAGE_SIZE;
+    if (!/^(?:[1-9]|[12]\d|3[0-2])$/u.test(value)) {
+        throw new CliArgumentError("Option '--limit' must be an integer from 1 to 32.");
+    }
+    return Number(value);
+};
+const optionalListFilter = (options, flag, key) => {
+    const value = options.get(flag);
+    return value === undefined ? {} : { [key]: value };
+};
+const readReceiptListParameters = (tokens) => {
+    const parsed = parseOptions(tokens, new Set([
+        "--actor",
+        "--after",
+        "--limit",
+        "--method",
+        "--since",
+        "--until",
+    ]));
+    requirePositionals(parsed.positionals, 0, RECEIPT_LIST_USAGE);
+    return {
+        limit: readReceiptListPageSize(parsed.options.get("--limit")),
+        ...optionalListFilter(parsed.options, "--actor", "actor"),
+        ...optionalListFilter(parsed.options, "--after", "afterCursor"),
+        ...optionalListFilter(parsed.options, "--method", "method"),
+        ...optionalListFilter(parsed.options, "--since", "since"),
+        ...optionalListFilter(parsed.options, "--until", "until"),
+    };
+};
+const runReceiptList = async (tokens, context) => {
+    const result = await context.dependencies.listReceipts(readReceiptListParameters(tokens));
+    return writeNodeResult(result, context, projectReceiptListResult);
+};
+const runReceiptShow = async (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set());
+    requirePositionals(parsed.positionals, 1, RECEIPT_SHOW_USAGE);
+    const commandId = parsed.positionals[0];
+    if (commandId === undefined) {
+        throw new CliArgumentError("The command identifier is missing.");
+    }
+    const result = await context.dependencies.getReceipt(commandId);
+    return writeNodeResult(result, context, (value) => ({
+        command: "receipt.show",
+        result: value,
+    }));
+};
+export const runReceiptCommand = async (tokens, context) => {
+    const [subcommand, ...rest] = tokens;
+    if (subcommand === "list")
+        return runReceiptList(rest, context);
+    if (subcommand === "show")
+        return runReceiptShow(rest, context);
+    throw new CliArgumentError(`Usage: ${RECEIPT_LIST_USAGE} | ${RECEIPT_SHOW_USAGE}`);
+};
+//# sourceMappingURL=command.js.map

package/dist/command-receipt/compact-list.d.ts

@@ -0,0 +1,18 @@
+import type { ReceiptListResult } from "@maiaos/sdk";
+export type CliReceiptListItem = {
+    readonly commandId: ReceiptListResult["items"][number]["commandId"];
+    readonly createdAt: ReceiptListResult["items"][number]["createdAt"];
+    readonly method: ReceiptListResult["items"][number]["method"];
+    readonly receiptId: ReceiptListResult["items"][number]["receiptId"];
+    readonly state: ReceiptListResult["items"][number]["state"];
+    readonly target: ReceiptListResult["items"][number]["target"];
+};
+export type CliReceiptListResult = {
+    readonly command: "receipt.list";
+    readonly count: number;
+    readonly items: readonly CliReceiptListItem[];
+    readonly nextCursor?: ReceiptListResult["nextCursor"];
+};
+export declare const projectReceiptListItem: (item: ReceiptListResult["items"][number]) => CliReceiptListItem;
+export declare const projectReceiptListResult: (value: ReceiptListResult) => CliReceiptListResult;
+//# sourceMappingURL=compact-list.d.ts.map

package/dist/command-receipt/compact-list.js

@@ -0,0 +1,18 @@
+export const projectReceiptListItem = (item) => ({
+    commandId: item.commandId,
+    createdAt: item.createdAt,
+    method: item.method,
+    receiptId: item.receiptId,
+    state: item.state,
+    target: {
+        id: item.target.id,
+        type: item.target.type,
+    },
+});
+export const projectReceiptListResult = (value) => ({
+    command: "receipt.list",
+    count: value.items.length,
+    items: value.items.map(projectReceiptListItem),
+    ...(value.nextCursor === undefined ? {} : { nextCursor: value.nextCursor }),
+});
+//# sourceMappingURL=compact-list.js.map

package/dist/context/client.d.ts

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

package/dist/context/client.js

@@ -0,0 +1,19 @@
+import { INVOCATION_CONTEXT_ERROR_NODE_UNAVAILABLE, invocationContextShowParametersSchema, } from "@maiaos/sdk";
+import { runValidatedNodeOperation, } from "../local-node/client.js";
+const nodeContextUnavailable = () => Promise.resolve({
+    error: {
+        code: INVOCATION_CONTEXT_ERROR_NODE_UNAVAILABLE,
+        message: "The authenticated Maia node is unavailable.",
+        retryable: true,
+    },
+    ok: false,
+});
+export const showCurrentContext = () => {
+    return runValidatedNodeOperation({}, invocationContextShowParametersSchema, (client, parameters, options) => client.showCurrentContext(parameters, options)).then((result) => {
+        if (!result.ok && result.error.code === "node_unavailable") {
+            return nodeContextUnavailable();
+        }
+        return result;
+    });
+};
+//# sourceMappingURL=client.js.map

package/dist/context/commands.d.ts

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

package/dist/context/commands.js

@@ -0,0 +1,13 @@
+import { CliArgumentError, requireNoArguments, } from "../command-line/arguments.js";
+import { writeCurrentContextResult } from "../command-line/output.js";
+export const runContextCommand = (tokens, context) => {
+    const [subcommand, ...rest] = tokens;
+    if (subcommand !== "show") {
+        throw new CliArgumentError("Usage: maia context show");
+    }
+    requireNoArguments(rest, "Context show");
+    return context.dependencies
+        .showCurrentContext()
+        .then((result) => writeCurrentContextResult(result, context));
+};
+//# sourceMappingURL=commands.js.map

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import type { CliDependencies } from "./command-line/context.js";
+import { type CliIo } from "./command-line/output.js";
+export type { CliDependencies } from "./command-line/context.js";
+export type { CliErrorOutput, CliHelpResult, CliIo, CliStatusResult, CliSuccessOutput, CliSuccessResult, CliVersionResult, } from "./command-line/output.js";
+export declare const makeCli: (dependencies: CliDependencies) => (arguments_: readonly string[], version: string, io: CliIo) => Promise<number>;
+export declare const runCli: (arguments_: readonly string[], version: string, io: CliIo) => Promise<number>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,202 @@
+import { argumentsAreBounded, CliArgumentError, parseArguments, requireNoArguments, } from "./command-line/arguments.js";
+import { createHelpResult } from "./command-line/help.js";
+import { reportError, writeNodeResult, writeSuccess, } from "./command-line/output.js";
+import { runReceiptCommand } from "./command-receipt/command.js";
+import { runContextCommand } from "./context/commands.js";
+import { runIntegrationCommand } from "./integration-authorization/commands.js";
+import { runOrchestrationCommand } from "./orchestration/commands.js";
+import { runExecutionCommand, runProjectCommand, runWorkspaceCommand, } from "./project-workspace/commands.js";
+import { runRuntimeCommand } from "./runtime/command.js";
+import { runSessionCommand } from "./session/commands.js";
+import { runStatusCommand } from "./status/command.js";
+import { runTerminalCommand } from "./terminal/commands.js";
+import { runTurnCommand } from "./turn/commands.js";
+const HELP_ALIASES = new Set(["help", "--help", "-h"]);
+const VERSION_ALIASES = new Set(["version", "--version", "-v"]);
+const createArgumentError = (message) => ({
+    code: "invalid_argument",
+    message,
+    retryable: false,
+});
+const runHelpCommand = (rest, context) => {
+    writeSuccess(createHelpResult(context.version, rest), context.json, context.io);
+    return Promise.resolve(0);
+};
+const runVersionCommand = (rest, context) => {
+    requireNoArguments(rest, "Version");
+    writeSuccess({ command: "version", name: "maia", version: context.version }, context.json, context.io);
+    return Promise.resolve(0);
+};
+const runMonitorCommand = (rest, context) => {
+    requireNoArguments(rest, "Monitor");
+    return (context.dependencies.createMonitorBootstrap?.().then((result) => writeNodeResult(result, context, (value) => ({
+        command: "monitor",
+        result: value,
+    }))) ?? Promise.reject(new Error("No monitor.")));
+};
+const PRODUCT_COMMANDS = {
+    context: runContextCommand,
+    execution: runExecutionCommand,
+    integration: runIntegrationCommand,
+    project: runProjectCommand,
+    receipt: runReceiptCommand,
+    run: runOrchestrationCommand,
+    runtime: runRuntimeCommand,
+    session: runSessionCommand,
+    terminal: runTerminalCommand,
+    turn: runTurnCommand,
+    workspace: runWorkspaceCommand,
+};
+const runCommand = (tokens, context) => {
+    const [command, ...rest] = tokens;
+    if (command === undefined || HELP_ALIASES.has(command))
+        return runHelpCommand(rest, context);
+    if (VERSION_ALIASES.has(command))
+        return runVersionCommand(rest, context);
+    if (command === "status") {
+        requireNoArguments(rest, "Status");
+        return runStatusCommand(context);
+    }
+    if (command === "monitor")
+        return runMonitorCommand(rest, context);
+    const product = PRODUCT_COMMANDS[command];
+    if (product !== undefined)
+        return product(rest, context);
+    if (command.startsWith("-"))
+        throw new CliArgumentError("Command has an unknown option.");
+    return Promise.resolve(reportError({
+        code: "command_not_implemented",
+        message: "Command not implemented.",
+        retryable: false,
+    }, context));
+};
+const parseInvocation = (input) => {
+    if (!argumentsAreBounded(input.arguments_)) {
+        return {
+            exitCode: reportError(createArgumentError("Command arguments exceed the limit."), { io: input.io, json: input.arguments_.includes("--json") }),
+            ok: false,
+        };
+    }
+    const parsed = parseArguments(input.arguments_);
+    if (parsed.jsonFlagCount > 1) {
+        return {
+            exitCode: reportError(createArgumentError("Option '--json' may be used only once."), { io: input.io, json: true }),
+            ok: false,
+        };
+    }
+    return { ok: true, parsed };
+};
+const executeCli = async (input) => {
+    const invocation = parseInvocation(input);
+    if (!invocation.ok)
+        return invocation.exitCode;
+    const context = {
+        dependencies: input.dependencies,
+        io: input.io,
+        json: invocation.parsed.json,
+        version: input.version,
+    };
+    try {
+        return await runCommand(invocation.parsed.tokens, context);
+    }
+    catch (error) {
+        return error instanceof CliArgumentError
+            ? reportError(createArgumentError(error.message), context)
+            : reportError({
+                code: "internal_error",
+                message: "Maia CLI command failed.",
+                retryable: false,
+            }, context);
+    }
+};
+export const makeCli = (dependencies) => (arguments_, version, io) => executeCli({
+    arguments_,
+    dependencies,
+    io,
+    version,
+});
+const readStatus = async () => {
+    const { readLocalNodeStatus } = await import("./status/client.js");
+    return readLocalNodeStatus();
+};
+const loadIntegrationAuthorization = () => import("./integration-authorization/client.js");
+const loadProjectWorkspace = () => import("./project-workspace/client.js");
+const loadOrchestration = () => import("./orchestration/client.js");
+const loadSession = () => import("./session/client.js");
+const loadTerminal = () => import("./terminal/client.js");
+const loadTurn = () => import("./turn/client.js");
+const loadStatus = () => import("./status/client.js");
+const loadRuntime = () => import("./runtime/client.js");
+const loadContext = () => import("./context/client.js");
+const lazyDependencies = (load, names) => Object.fromEntries(names.map((name) => [
+    name,
+    (...arguments_) => load().then((module) => {
+        const operation = module[name];
+        return operation(...arguments_);
+    }),
+]));
+const defaultCliDependencies = {
+    ...lazyDependencies(loadIntegrationAuthorization, [
+        "applyIntegration",
+        "planIntegration",
+        "removeIntegration",
+        "statusIntegration",
+    ]),
+    ...lazyDependencies(loadProjectWorkspace, [
+        "attachWorkspaceRepository",
+        "configureWorkspaceExecution",
+        "getReceipt",
+        "listProjects",
+        "listReceipts",
+        "listWorkspaces",
+        "readExecutionCatalog",
+        "registerProject",
+        "showProject",
+        "showWorkspace",
+        "showWorkspaceExecution",
+    ]),
+    ...lazyDependencies(loadOrchestration, [
+        "acknowledgeRunDelivery",
+        "cancelRunQuestion",
+        "checkRunInbox",
+        "createRun",
+        "listRuns",
+        "listTasks",
+        "openRunQuestion",
+        "replyRunQuestion",
+        "settleRunDispatchTerminal",
+        "showDispatch",
+        "showRun",
+        "showTask",
+    ]),
+    ...lazyDependencies(loadSession, [
+        "createSession",
+        "listSessionEvents",
+        "listSessions",
+        "showSession",
+        "startSession",
+    ]),
+    ...lazyDependencies(loadTerminal, [
+        "acquireTerminalController",
+        "closeTerminal",
+        "createTerminal",
+        "listTerminalEvents",
+        "listTerminals",
+        "readTerminal",
+        "releaseTerminalController",
+        "requestTerminalController",
+        "resizeTerminal",
+        "showTerminal",
+        "showTerminalControllerRequest",
+        "signalTerminal",
+        "writeTerminalInput",
+    ]),
+    ...lazyDependencies(loadTurn, ["interruptTurn", "sendTurn", "showTurn"]),
+    ...lazyDependencies(loadRuntime, ["listInstalledHarnesses"]),
+    ...lazyDependencies(loadContext, ["showCurrentContext"]),
+    ...lazyDependencies(loadStatus, ["createMonitorBootstrap"]),
+    probeRuntime: (runtime = "codex") => loadRuntime().then((module) => module.probeRuntime(runtime)),
+    readStatus,
+};
+export const runCli = makeCli(defaultCliDependencies);
+//# sourceMappingURL=index.js.map

package/dist/integration-authorization/client.d.ts

@@ -0,0 +1,16 @@
+import type { IntegrationApplyCodexResult, IntegrationApplyPiRpcResult, IntegrationPlanCodexResult, IntegrationPlanPiRpcResult, IntegrationRemoveCodexResult, IntegrationRemovePiRpcResult, IntegrationStatusCodexResult, IntegrationStatusPiRpcResult } from "@maiaos/sdk";
+import { type CliNodeResult } from "../local-node/client.js";
+export type IntegrationTarget = "codex" | "pi-rpc";
+export declare const planIntegration: (integration: IntegrationTarget) => Promise<CliNodeResult<IntegrationPlanCodexResult | IntegrationPlanPiRpcResult>>;
+type ApplyIntegrationInput = {
+    readonly commandId?: string;
+    readonly planId: string;
+};
+export declare const applyIntegration: (integration: IntegrationTarget, input: ApplyIntegrationInput) => Promise<CliNodeResult<IntegrationApplyCodexResult | IntegrationApplyPiRpcResult>>;
+export declare const statusIntegration: (integration: IntegrationTarget) => Promise<CliNodeResult<IntegrationStatusCodexResult | IntegrationStatusPiRpcResult>>;
+type RemoveIntegrationInput = {
+    readonly commandId?: string;
+};
+export declare const removeIntegration: (integration: IntegrationTarget, input: RemoveIntegrationInput) => Promise<CliNodeResult<IntegrationRemoveCodexResult | IntegrationRemovePiRpcResult>>;
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/integration-authorization/client.js

@@ -0,0 +1,30 @@
+import { integrationApplyCodexParametersSchema, integrationApplyPiRpcParametersSchema, integrationPlanCodexParametersSchema, integrationPlanPiRpcParametersSchema, integrationRemoveCodexParametersSchema, integrationRemovePiRpcParametersSchema, integrationStatusCodexParametersSchema, integrationStatusPiRpcParametersSchema, } from "@maiaos/sdk";
+import { newCliIdentifier, runValidatedNodeOperation, } from "../local-node/client.js";
+const commandId = (requested) => requested ?? newCliIdentifier("command");
+export const planIntegration = (integration) => {
+    if (integration === "codex") {
+        return runValidatedNodeOperation({ integration }, integrationPlanCodexParametersSchema, (client, parameters, options) => client.planCodexIntegration(parameters, options));
+    }
+    return runValidatedNodeOperation({ integration }, integrationPlanPiRpcParametersSchema, (client, parameters, options) => client.planPiRpcIntegration(parameters, options));
+};
+export const applyIntegration = (integration, input) => {
+    const selectedCommandId = commandId(input.commandId);
+    if (integration === "codex") {
+        return runValidatedNodeOperation({ commandId: selectedCommandId, planId: input.planId }, integrationApplyCodexParametersSchema, (client, parameters, options) => client.applyCodexIntegration(parameters, options), { commandId: selectedCommandId });
+    }
+    return runValidatedNodeOperation({ commandId: selectedCommandId, planId: input.planId }, integrationApplyPiRpcParametersSchema, (client, parameters, options) => client.applyPiRpcIntegration(parameters, options), { commandId: selectedCommandId });
+};
+export const statusIntegration = (integration) => {
+    if (integration === "codex") {
+        return runValidatedNodeOperation({ integration }, integrationStatusCodexParametersSchema, (client, parameters, options) => client.statusCodexIntegration(parameters, options));
+    }
+    return runValidatedNodeOperation({ integration }, integrationStatusPiRpcParametersSchema, (client, parameters, options) => client.statusPiRpcIntegration(parameters, options));
+};
+export const removeIntegration = (integration, input) => {
+    const selectedCommandId = commandId(input.commandId);
+    if (integration === "codex") {
+        return runValidatedNodeOperation({ commandId: selectedCommandId, integration }, integrationRemoveCodexParametersSchema, (client, parameters, options) => client.removeCodexIntegration(parameters, options), { commandId: selectedCommandId });
+    }
+    return runValidatedNodeOperation({ commandId: selectedCommandId, integration }, integrationRemovePiRpcParametersSchema, (client, parameters, options) => client.removePiRpcIntegration(parameters, options), { commandId: selectedCommandId });
+};
+//# sourceMappingURL=client.js.map

package/dist/integration-authorization/commands.d.ts

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

package/dist/integration-authorization/commands.js

@@ -0,0 +1,92 @@
+import { CliArgumentError, parseOptions, requirePositionals, } from "../command-line/arguments.js";
+import { writeIntegrationApplyResult, writeIntegrationPlanResult, writeIntegrationRemoveResult, writeIntegrationStatusResult, } from "../command-line/output.js";
+const EXIT_OUTCOME_UNKNOWN = 76;
+const integrationUsage = (tail) => `maia integration ${tail}`;
+const PLAN_USAGE = integrationUsage("plan <codex|pi-rpc>");
+const APPLY_USAGE = integrationUsage("apply <plan-id> [--integration <codex|pi-rpc>] [--command-id <id>]");
+const STATUS_USAGE = integrationUsage("status <codex|pi-rpc>");
+const REMOVE_USAGE = integrationUsage("remove <codex|pi-rpc> [--command-id <id>]");
+const INTEGRATION_USAGE = [
+    PLAN_USAGE,
+    APPLY_USAGE,
+    STATUS_USAGE,
+    REMOVE_USAGE,
+].join(" | ");
+const requireIntegrationTarget = (value) => {
+    if (value === "codex" || value === "pi-rpc")
+        return value;
+    throw new CliArgumentError(`Usage: ${INTEGRATION_USAGE}`);
+};
+const applyIntegrationTarget = (options) => {
+    const requested = options.get("--integration");
+    return requested === undefined
+        ? "codex"
+        : requireIntegrationTarget(requested);
+};
+const runPlan = (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set());
+    requirePositionals(parsed.positionals, 1, PLAN_USAGE);
+    const integration = requireIntegrationTarget(parsed.positionals[0]);
+    const operation = context.dependencies.planIntegration;
+    if (operation === undefined)
+        throw new Error("Missing integration client.");
+    return operation(integration).then((result) => writeIntegrationPlanResult(result, context));
+};
+const runApply = (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set(["--command-id", "--integration"]));
+    requirePositionals(parsed.positionals, 1, APPLY_USAGE);
+    const planId = parsed.positionals[0];
+    if (planId === undefined)
+        throw new CliArgumentError("The integration plan identifier is missing.");
+    const integration = applyIntegrationTarget(parsed.options);
+    const operation = context.dependencies.applyIntegration;
+    if (operation === undefined)
+        throw new Error("Missing integration client.");
+    const requestedCommandId = parsed.options.get("--command-id");
+    return operation(integration, {
+        planId,
+        ...(requestedCommandId === undefined
+            ? {}
+            : { commandId: requestedCommandId }),
+    }).then((result) => writeIntegrationApplyResult(result, context));
+};
+const runStatus = (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set());
+    requirePositionals(parsed.positionals, 1, STATUS_USAGE);
+    const integration = requireIntegrationTarget(parsed.positionals[0]);
+    const operation = context.dependencies.statusIntegration;
+    if (operation === undefined)
+        throw new Error("Missing integration client.");
+    return operation(integration).then((result) => writeIntegrationStatusResult(result, context));
+};
+const runRemove = async (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set(["--command-id"]));
+    requirePositionals(parsed.positionals, 1, REMOVE_USAGE);
+    const integration = requireIntegrationTarget(parsed.positionals[0]);
+    const operation = context.dependencies.removeIntegration;
+    if (operation === undefined)
+        throw new Error("Missing integration client.");
+    const requestedCommandId = parsed.options.get("--command-id");
+    const result = await operation(integration, {
+        ...(requestedCommandId === undefined
+            ? {}
+            : { commandId: requestedCommandId }),
+    });
+    const exitCode = writeIntegrationRemoveResult(result, context);
+    return result.ok && result.value.outcome === "cleanup_unknown"
+        ? EXIT_OUTCOME_UNKNOWN
+        : exitCode;
+};
+export const runIntegrationCommand = (tokens, context) => {
+    const [subcommand, ...rest] = tokens;
+    if (subcommand === "plan")
+        return runPlan(rest, context);
+    if (subcommand === "apply")
+        return runApply(rest, context);
+    if (subcommand === "status")
+        return runStatus(rest, context);
+    if (subcommand === "remove")
+        return runRemove(rest, context);
+    throw new CliArgumentError(`Usage: ${INTEGRATION_USAGE}`);
+};
+//# sourceMappingURL=commands.js.map

package/dist/local-node/client.d.ts

@@ -0,0 +1,31 @@
+import type { LocalNodeClient, LocalNodeRequestOptions, ProtocolError } from "@maiaos/sdk";
+import { type LocalNodeConnection, type LocalNodeDiscoveryOptions } from "@maiaos/sdk/node";
+export type CliMutationRecovery = {
+    readonly commandId: string;
+};
+export type CliNodeResult<TValue> = {
+    readonly error: ProtocolError;
+    readonly ok: false;
+    readonly recovery?: CliMutationRecovery;
+} | {
+    readonly ok: true;
+    readonly value: TValue;
+};
+export declare const newCliIdentifier: (prefix: "command" | "request") => string;
+export declare const resolveCliDiscoveryOptions: () => LocalNodeDiscoveryOptions;
+export declare const connectCliLocalNode: (signal: AbortSignal) => Promise<LocalNodeConnection>;
+export declare const outcomeCanBeAmbiguous: (error: unknown) => boolean;
+export declare const invalidNodeInput: <TValue>() => Promise<CliNodeResult<TValue>>;
+export declare const runNodeOperation: <TValue>(operation: (signal: AbortSignal) => Promise<TValue>, recovery?: CliMutationRecovery) => Promise<CliNodeResult<TValue>>;
+export declare const runNodeClientOperation: <TValue>(operation: (client: LocalNodeClient, options: LocalNodeRequestOptions) => Promise<TValue>, recovery?: CliMutationRecovery) => Promise<CliNodeResult<TValue>>;
+type ParameterSchema<TParameters> = {
+    readonly safeParse: (input: unknown) => {
+        readonly data: TParameters;
+        readonly success: true;
+    } | {
+        readonly success: false;
+    };
+};
+export declare const runValidatedNodeOperation: <TParameters, TValue>(...[input, schema, operation, recovery]: readonly [input: unknown, schema: ParameterSchema<TParameters>, operation: (client: LocalNodeClient, parameters: TParameters, options: LocalNodeRequestOptions) => Promise<TValue>, recovery?: CliMutationRecovery]) => Promise<CliNodeResult<TValue>>;
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/local-node/client.js

@@ -0,0 +1,99 @@
+import { randomUUID } from "node:crypto";
+import { MaiaClientError, protocolErrorSchema } from "@maiaos/sdk";
+import { connectLocalNode, } from "@maiaos/sdk/node";
+import * as Effect from "effect/Effect";
+export const newCliIdentifier = (prefix) => `${prefix}_${randomUUID().replaceAll("-", "")}`;
+export const resolveCliDiscoveryOptions = () => {
+    if (process.env.MAIA_CLI_TEST_MODE !== "1")
+        return {};
+    const runtimeRootOverride = process.env.MAIA_CLI_TEST_RUNTIME_ROOT;
+    if (runtimeRootOverride === undefined) {
+        throw new Error("The CLI test runtime root is missing.");
+    }
+    return { runtimeRootOverride };
+};
+export const connectCliLocalNode = (signal) => connectLocalNode({ ...resolveCliDiscoveryOptions(), signal });
+const LOCAL_DEADLINE_ERROR = {
+    code: "deadline_exceeded",
+    message: "Local request expired before dispatch.",
+    retryable: true,
+};
+const LOCAL_OUTCOME_UNKNOWN_ERROR = {
+    code: "outcome_unknown",
+    message: "Local request outcome unknown.",
+    retryable: false,
+};
+const LOCAL_SATURATED_ERROR = {
+    code: "saturated",
+    message: "Local node saturated.",
+    retryable: true,
+};
+const localOperationError = (error) => {
+    if (error.code === "deadline_exceeded")
+        return LOCAL_DEADLINE_ERROR;
+    if (error.code === "outcome_unknown")
+        return LOCAL_OUTCOME_UNKNOWN_ERROR;
+    if (error.code === "saturated")
+        return LOCAL_SATURATED_ERROR;
+};
+const operationError = (error) => {
+    const remoteError = error instanceof Error && "remoteError" in error
+        ? error.remoteError
+        : undefined;
+    const parsed = protocolErrorSchema.safeParse(remoteError);
+    if (parsed.success)
+        return parsed.data;
+    if (error instanceof MaiaClientError) {
+        if (error.code === "invalid_request") {
+            return {
+                code: "invalid_argument",
+                message: "Command input is invalid.",
+                retryable: false,
+            };
+        }
+        const local = localOperationError(error);
+        if (local !== undefined)
+            return local;
+    }
+    return {
+        code: "node_unavailable",
+        message: "Local Maia node unavailable.",
+        retryable: true,
+    };
+};
+export const outcomeCanBeAmbiguous = (error) => !(error instanceof MaiaClientError) ||
+    (error.code !== "deadline_exceeded" &&
+        error.code !== "invalid_request" &&
+        error.code !== "saturated");
+export const invalidNodeInput = () => Promise.resolve({
+    error: {
+        code: "invalid_argument",
+        message: "The command input is invalid.",
+        retryable: false,
+    },
+    ok: false,
+});
+export const runNodeOperation = (operation, recovery) => Effect.runPromise(Effect.tryPromise({
+    catch: (cause) => ({ cause, error: operationError(cause) }),
+    try: operation,
+}).pipe(Effect.map((value) => ({ ok: true, value })), Effect.catch(({ cause, error }) => Effect.succeed({
+    error,
+    ok: false,
+    ...(recovery !== undefined && outcomeCanBeAmbiguous(cause)
+        ? { recovery }
+        : {}),
+}))));
+export const runNodeClientOperation = (operation, recovery) => runNodeOperation(async (signal) => {
+    const connection = await connectCliLocalNode(signal);
+    return operation(connection.client, {
+        messageId: newCliIdentifier("request"),
+        signal,
+    });
+}, recovery);
+export const runValidatedNodeOperation = (...[input, schema, operation, recovery]) => {
+    const parameters = schema.safeParse(input);
+    if (!parameters.success)
+        return invalidNodeInput();
+    return runNodeClientOperation((client, options) => operation(client, parameters.data, options), recovery);
+};
+//# sourceMappingURL=client.js.map