@maiaos/cli 0.1.0-canary.2

package/dist/integration/client.js

@@ -0,0 +1,24 @@
+import { integrationApplyClaudeCodeParametersSchema, integrationApplyCodexParametersSchema, integrationPlanClaudeCodeParametersSchema, integrationPlanCodexParametersSchema, integrationRemoveClaudeCodeParametersSchema, integrationRemoveCodexParametersSchema, integrationStatusClaudeCodeParametersSchema, integrationStatusCodexParametersSchema, } from "@maiaos/sdk";
+const readClient = (node) => ({
+    planCodexIntegration: (input) => node.runValidatedNodeOperation(input, integrationPlanCodexParametersSchema, (client, parameters, options) => client.planCodexIntegration(parameters, options)),
+    statusCodexIntegration: (input) => node.runValidatedNodeOperation(input, integrationStatusCodexParametersSchema, (client, parameters, options) => client.statusCodexIntegration(parameters, options)),
+});
+const mutationClient = (node) => ({
+    applyCodexIntegration: (input) => node.runValidatedNodeOperation(input, integrationApplyCodexParametersSchema, (client, parameters, options) => client.applyCodexIntegration(parameters, options), { commandId: input.commandId }),
+    removeCodexIntegration: (input) => node.runValidatedNodeOperation(input, integrationRemoveCodexParametersSchema, (client, parameters, options) => client.removeCodexIntegration(parameters, options), { commandId: input.commandId }),
+});
+const claudeCodeReadClient = (node) => ({
+    planClaudeCodeIntegration: (input) => node.runValidatedNodeOperation(input, integrationPlanClaudeCodeParametersSchema, (client, parameters, options) => client.planClaudeCodeIntegration(parameters, options)),
+    statusClaudeCodeIntegration: (input) => node.runValidatedNodeOperation(input, integrationStatusClaudeCodeParametersSchema, (client, parameters, options) => client.statusClaudeCodeIntegration(parameters, options)),
+});
+const claudeCodeMutationClient = (node) => ({
+    applyClaudeCodeIntegration: (input) => node.runValidatedNodeOperation(input, integrationApplyClaudeCodeParametersSchema, (client, parameters, options) => client.applyClaudeCodeIntegration(parameters, options), { commandId: input.commandId }),
+    removeClaudeCodeIntegration: (input) => node.runValidatedNodeOperation(input, integrationRemoveClaudeCodeParametersSchema, (client, parameters, options) => client.removeClaudeCodeIntegration(parameters, options), { commandId: input.commandId }),
+});
+export const makeIntegrationClient = (node) => ({
+    ...readClient(node),
+    ...mutationClient(node),
+    ...claudeCodeReadClient(node),
+    ...claudeCodeMutationClient(node),
+});
+//# sourceMappingURL=client.js.map

package/dist/integration/commands.d.ts

@@ -0,0 +1,10 @@
+import { type CommandContext, type CommandEffect } from "../command-line/index.js";
+export declare const runPlanCodex: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runStatusCodex: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runApplyCodex: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runRemoveCodex: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runPlanClaudeCode: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runStatusClaudeCode: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runApplyClaudeCode: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runRemoveClaudeCode: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+//# sourceMappingURL=commands.d.ts.map

package/dist/integration/commands.js

@@ -0,0 +1,104 @@
+import * as Effect from "effect/Effect";
+import { CliArgumentError, parseOptions, reportError, requirePositionals, writeNodeResult, } from "../command-line/index.js";
+import { commandIdentifier } from "../local-node/index.js";
+import { formatIntegrationApply, formatIntegrationPlan, formatIntegrationRemove, formatIntegrationStatus, } from "./output.js";
+const withInput = (operation, input) => operation === undefined ? undefined : () => operation(input);
+const codexOperations = (dependencies, commandId) => ({
+    apply: dependencies.applyCodexIntegration,
+    plan: withInput(dependencies.planCodexIntegration, { integration: "codex" }),
+    remove: withInput(dependencies.removeCodexIntegration, {
+        commandId,
+        integration: "codex",
+    }),
+    status: withInput(dependencies.statusCodexIntegration, {
+        integration: "codex",
+    }),
+});
+const claudeCodeOperations = (dependencies, commandId) => ({
+    apply: dependencies.applyClaudeCodeIntegration,
+    plan: withInput(dependencies.planClaudeCodeIntegration, {
+        integration: "claude-code",
+    }),
+    remove: withInput(dependencies.removeClaudeCodeIntegration, {
+        commandId,
+        integration: "claude-code",
+    }),
+    status: withInput(dependencies.statusClaudeCodeIntegration, {
+        integration: "claude-code",
+    }),
+});
+const vendorOperations = (dependencies, vendor, commandId) => vendor === "codex"
+    ? codexOperations(dependencies, commandId)
+    : claudeCodeOperations(dependencies, commandId);
+const missingClient = (context) => reportError({
+    code: "internal_error",
+    message: "The integration client is unavailable.",
+    retryable: false,
+}, context);
+const readCommandId = (tokens, options = []) => {
+    const parsed = parseOptions(tokens, new Set(["--command-id", ...options]));
+    requirePositionals(parsed.positionals, 0);
+    return {
+        commandId: parsed.options.get("--command-id"),
+        options: parsed.options,
+    };
+};
+const APPLY_PRESENTER = {
+    toResult: (result) => ({ command: "integration.apply", result }),
+    toText: formatIntegrationApply,
+};
+const PLAN_PRESENTER = {
+    toResult: (result) => ({ command: "integration.plan", result }),
+    toText: formatIntegrationPlan,
+};
+const REMOVE_PRESENTER = {
+    toResult: (result) => ({ command: "integration.remove", result }),
+    toText: formatIntegrationRemove,
+};
+const STATUS_PRESENTER = {
+    toResult: (result) => ({ command: "integration.status", result }),
+    toText: formatIntegrationStatus,
+};
+const runReads = (input, rest, context) => Effect.gen(function* () {
+    requirePositionals(parseOptions(rest, new Set()).positionals, 0);
+    const operations = vendorOperations(context.dependencies, input.vendor, "");
+    if (input.action === "plan")
+        return operations.plan === undefined
+            ? missingClient(context)
+            : writeNodeResult(yield* operations.plan(), context, PLAN_PRESENTER);
+    return operations.status === undefined
+        ? missingClient(context)
+        : writeNodeResult(yield* operations.status(), context, STATUS_PRESENTER);
+});
+const runApply = (vendor, rest, context) => Effect.gen(function* () {
+    const parsed = readCommandId(rest, ["--plan"]);
+    const planId = parsed.options.get("--plan");
+    if (planId === undefined)
+        throw new CliArgumentError("Option '--plan' is required.");
+    const commandId = yield* commandIdentifier(parsed.commandId);
+    const { apply } = vendorOperations(context.dependencies, vendor, commandId);
+    return apply === undefined
+        ? missingClient(context)
+        : writeNodeResult(yield* apply({ commandId, planId }), context, APPLY_PRESENTER);
+});
+const runMutations = (input, rest, context) => Effect.gen(function* () {
+    if (input.action === "apply")
+        return yield* runApply(input.vendor, rest, context);
+    const commandId = yield* commandIdentifier(readCommandId(rest).commandId);
+    const { remove } = vendorOperations(context.dependencies, input.vendor, commandId);
+    return remove === undefined
+        ? missingClient(context)
+        : writeNodeResult(yield* remove(), context, REMOVE_PRESENTER);
+});
+const integrationLeaf = (action, vendor) => (tokens, context) => action === "plan" || action === "status"
+    ? runReads({ action, vendor }, tokens, context)
+    : runMutations({ action, vendor }, tokens, context);
+export const runPlanCodex = integrationLeaf("plan", "codex");
+export const runStatusCodex = integrationLeaf("status", "codex");
+export const runApplyCodex = integrationLeaf("apply", "codex");
+export const runRemoveCodex = integrationLeaf("remove", "codex");
+export const runPlanClaudeCode = integrationLeaf("plan", "claude-code");
+export const runStatusClaudeCode = integrationLeaf("status", "claude-code");
+export const runApplyClaudeCode = integrationLeaf("apply", "claude-code");
+export const runRemoveClaudeCode = integrationLeaf("remove", "claude-code");
+//# sourceMappingURL=commands.js.map

package/dist/integration/index.d.ts

@@ -0,0 +1,3 @@
+export { type IntegrationCliDependencies, makeIntegrationClient, } from "./client.js";
+export { runApplyClaudeCode, runApplyCodex, runPlanClaudeCode, runPlanCodex, runRemoveClaudeCode, runRemoveCodex, runStatusClaudeCode, runStatusCodex, } from "./commands.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/integration/index.js

@@ -0,0 +1,3 @@
+export { makeIntegrationClient, } from "./client.js";
+export { runApplyClaudeCode, runApplyCodex, runPlanClaudeCode, runPlanCodex, runRemoveClaudeCode, runRemoveCodex, runStatusClaudeCode, runStatusCodex, } from "./commands.js";
+//# sourceMappingURL=index.js.map

package/dist/integration/output.d.ts

@@ -0,0 +1,22 @@
+import type { IntegrationApplyClaudeCodeResult, IntegrationApplyCodexResult, IntegrationApplyPiRpcResult, IntegrationPlanClaudeCodeResult, IntegrationPlanCodexResult, IntegrationPlanPiRpcResult, IntegrationRemoveClaudeCodeResult, IntegrationRemoveCodexResult, IntegrationRemovePiRpcResult, IntegrationStatusClaudeCodeResult, IntegrationStatusCodexResult, IntegrationStatusPiRpcResult } from "@maiaos/sdk";
+export type CliIntegrationPlan = {
+    readonly command: "integration.plan";
+    readonly result: IntegrationPlanClaudeCodeResult | IntegrationPlanCodexResult | IntegrationPlanPiRpcResult;
+};
+export type CliIntegrationApply = {
+    readonly command: "integration.apply";
+    readonly result: IntegrationApplyClaudeCodeResult | IntegrationApplyCodexResult | IntegrationApplyPiRpcResult;
+};
+export type CliIntegrationRemove = {
+    readonly command: "integration.remove";
+    readonly result: IntegrationRemoveClaudeCodeResult | IntegrationRemoveCodexResult | IntegrationRemovePiRpcResult;
+};
+export type CliIntegrationStatus = {
+    readonly command: "integration.status";
+    readonly result: IntegrationStatusClaudeCodeResult | IntegrationStatusCodexResult | IntegrationStatusPiRpcResult;
+};
+export declare const formatIntegrationPlan: ({ result, }: CliIntegrationPlan) => string;
+export declare const formatIntegrationApply: ({ result, }: CliIntegrationApply) => string;
+export declare const formatIntegrationRemove: ({ result, }: CliIntegrationRemove) => string;
+export declare const formatIntegrationStatus: ({ result, }: CliIntegrationStatus) => string;
+//# sourceMappingURL=output.d.ts.map

package/dist/integration/output.js

@@ -0,0 +1,20 @@
+export const formatIntegrationPlan = ({ result, }) => {
+    const { integration, plan } = result;
+    const { expiresAt, planId, target } = plan;
+    const identity = target.adapter === "pi-rpc"
+        ? target.packageClosure.closureSha256
+        : `${target.executablePath}\t${target.executableSha256}`;
+    return `${integration}\tplanned\t${planId}\t${expiresAt}\t${identity}\nnext: maia integration apply ${integration} --plan ${planId}\n`;
+};
+export const formatIntegrationApply = ({ result, }) => `${result.integration}\t${result.authorization.state}\t${result.authorization.revision}\n`;
+export const formatIntegrationRemove = ({ result, }) => `${result.integration}\t${result.outcome}\t${result.authorization.revision}\n`;
+export const formatIntegrationStatus = ({ result, }) => {
+    const [item] = result.items;
+    if (!item.authorizationAvailable)
+        return `${result.integration}\tunavailable\t${item.reason}\t${item.nextAction}\n`;
+    const recovery = item.nextAction === "inspect_cleanup_unknown"
+        ? `\nnext: end any ${result.integration} or maia-process-host process left from before a crash, then maia integration remove ${result.integration}, plan and apply`
+        : "";
+    return `${result.integration}\t${item.authorization.state}\t${item.authorization.revision}\t${item.nextAction}${recovery}\n`;
+};
+//# sourceMappingURL=output.js.map

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

@@ -0,0 +1,7 @@
+import type { LocalNodeCallMethod, LocalNodeCallParameters, LocalNodeCallResult } from "@maiaos/sdk";
+import type { CliNodeEffect, CliNodeOperations } from "./client.js";
+export type CliNodeCall = <TMethod extends LocalNodeCallMethod>(method: TMethod, parameters: LocalNodeCallParameters<TMethod>) => CliNodeEffect<LocalNodeCallResult<TMethod>>;
+export declare const makeCallClient: (node: CliNodeOperations) => {
+    readonly call: CliNodeCall;
+};
+//# sourceMappingURL=call.d.ts.map

package/dist/local-node/call.js

@@ -0,0 +1,13 @@
+const commandIdOf = (parameters) => {
+    const commandId = typeof parameters === "object" && parameters !== null
+        ? Reflect.get(parameters, "commandId")
+        : undefined;
+    return typeof commandId === "string" ? commandId : undefined;
+};
+export const makeCallClient = (node) => ({
+    call: (method, parameters) => {
+        const commandId = commandIdOf(parameters);
+        return node.runNodeClientOperation((client, options) => client.call(method, parameters, options), commandId === undefined ? undefined : { commandId });
+    },
+});
+//# sourceMappingURL=call.js.map

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

@@ -0,0 +1,67 @@
+import type { LocalNodeRequestOptions, LocalNodeStatusResult, ProtocolError } from "@maiaos/sdk";
+import type { DiscoveredNodeApiEffectConnection, LocalNodeEffectClient, NodeApiEffectDiscoveryOptions } from "@maiaos/sdk/node/effect";
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import * as Schedule from "effect/Schedule";
+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 type CliNodeConnection = Pick<DiscoveredNodeApiEffectConnection, "client" | "status">;
+export type CliNodeConnector = (options: NodeApiEffectDiscoveryOptions) => Effect.Effect<CliNodeConnection, unknown, Crypto.Crypto>;
+export declare const newCliIdentifier: (prefix: "command" | "request") => Effect.Effect<string, never, Crypto.Crypto>;
+export declare const commandIdentifier: (commandId: string | undefined) => Effect.Effect<string, never, Crypto.Crypto>;
+export declare const fillCommandIdentifier: (input: unknown) => Effect.Effect<unknown, never, Crypto.Crypto>;
+export declare const connectLocalNode: CliNodeConnector;
+export declare const outcomeCanBeAmbiguous: (error: unknown) => boolean;
+export declare const invalidNodeInput: <TValue>(schemaError?: unknown) => Effect.Effect<CliNodeResult<TValue>>;
+export type ParameterSchema<TParameters> = {
+    readonly safeParse: (input: unknown) => {
+        readonly data: TParameters;
+        readonly success: true;
+    } | {
+        readonly error?: unknown;
+        readonly success: false;
+    };
+};
+export type CliNodeEffect<TValue> = Effect.Effect<CliNodeResult<TValue>, never, Crypto.Crypto>;
+export type CliNodeOperations = {
+    readonly asCoordinator: () => CliNodeOperations;
+    readonly asSession: () => CliNodeOperations;
+    readonly readStatus: Effect.Effect<LocalNodeStatusResult, unknown, Crypto.Crypto>;
+    readonly runDiscoveryOperation: <TValue>(operation: (options: NodeApiEffectDiscoveryOptions) => Effect.Effect<TValue, unknown, Crypto.Crypto>, recovery?: CliMutationRecovery) => CliNodeEffect<TValue>;
+    readonly runNodeClientOperation: <TValue>(operation: (client: LocalNodeEffectClient, options: LocalNodeRequestOptions) => Effect.Effect<TValue, unknown>, recovery?: CliMutationRecovery) => CliNodeEffect<TValue>;
+    readonly runValidatedNodeOperation: <TParameters, TValue>(input: unknown, schema: ParameterSchema<TParameters>, operation: (client: LocalNodeEffectClient, parameters: TParameters, options: LocalNodeRequestOptions) => Effect.Effect<TValue, unknown>, recovery?: CliMutationRecovery) => CliNodeEffect<TValue>;
+};
+export type CliNodeOperationsOptions = {
+    readonly connector?: CliNodeConnector;
+    readonly discoveryOptions?: Effect.Effect<NodeApiEffectDiscoveryOptions, unknown> | NodeApiEffectDiscoveryOptions;
+    readonly remote?: boolean;
+    readonly requireSession?: boolean;
+};
+export type CliNodeBinding = {
+    readonly connector?: CliNodeConnector;
+    readonly profile?: string;
+    readonly remote?: boolean;
+};
+type LazyNodeDependencyInput<TModule, TClient> = {
+    readonly arguments_: readonly unknown[];
+    readonly binding: CliNodeBinding;
+    readonly loadClient: () => Promise<TModule>;
+    readonly makeClient: (module: TModule, node: CliNodeOperations) => TClient;
+    readonly name: keyof TClient;
+};
+export declare const isBriefSaturation: (error: unknown) => boolean;
+export declare const SATURATION_RETRY: Schedule.Schedule<import("effect/Duration").Duration, unknown, never, never>;
+export declare const makeCliNodeOperations: (options?: CliNodeOperationsOptions) => CliNodeOperations;
+export declare const discoveryOptionsFor: (profile: string | undefined) => Effect.Effect<NodeApiEffectDiscoveryOptions, unknown>;
+export declare const runLazyNodeDependency: <TModule, TClient>(input: LazyNodeDependencyInput<TModule, TClient>) => Effect.Effect<unknown, unknown, Crypto.Crypto>;
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/local-node/client.js

@@ -0,0 +1,241 @@
+import { protocolErrorSchema } from "@maiaos/sdk";
+import * as Cause from "effect/Cause";
+import * as Config from "effect/Config";
+import * as Crypto from "effect/Crypto";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Schedule from "effect/Schedule";
+export const newCliIdentifier = (prefix) => Effect.gen(function* () {
+    const crypto = yield* Crypto.Crypto;
+    const uuid = yield* Effect.orDie(crypto.randomUUIDv4);
+    return `${prefix}_${uuid.replaceAll("-", "")}`;
+});
+export const commandIdentifier = (commandId) => commandId === undefined
+    ? newCliIdentifier("command")
+    : Effect.succeed(commandId);
+export const fillCommandIdentifier = (input) => typeof input === "object" &&
+    input !== null &&
+    "commandId" in input &&
+    input.commandId === undefined
+    ? Effect.map(newCliIdentifier("command"), (commandId) => ({
+        ...input,
+        commandId,
+    }))
+    : Effect.succeed(input);
+const testRuntimeRootMissing = () => new Error("The CLI test runtime root is missing.");
+const cliDiscoveryOptions = Effect.gen(function* () {
+    const testMode = yield* Config.option(Config.String("MAIA_CLI_TEST_MODE"));
+    if (Option.getOrUndefined(testMode) !== "1")
+        return {};
+    const root = yield* Config.option(Config.String("MAIA_CLI_TEST_RUNTIME_ROOT"));
+    return Option.isSome(root)
+        ? { runtimeRootOverride: root.value }
+        : yield* Effect.fail(testRuntimeRootMissing());
+});
+export const connectLocalNode = (options) => Effect.promise(() => import("@maiaos/sdk/node/effect")).pipe(Effect.flatMap((sdk) => sdk.connectNodeApiEffect(options)));
+class CliLocalNodeError extends Data.TaggedError("CliLocalNodeError") {
+}
+const SESSION_CREDENTIAL_VARIABLE = "MAIA_SESSION_CREDENTIAL";
+const SESSION_NODE_ORIGIN_VARIABLE = "MAIA_NODE_ORIGIN";
+const SESSION_NODE_ORIGIN = /^http:\/\/127\.0\.0\.1:[1-9]\d{0,4}$/u;
+const sessionLaunchInvalid = () => new CliLocalNodeError({
+    error: {
+        code: "configuration_invalid",
+        message: `${SESSION_CREDENTIAL_VARIABLE} is set without a valid ${SESSION_NODE_ORIGIN_VARIABLE}.`,
+        retryable: false,
+    },
+});
+const sessionRemoteDenied = () => new CliLocalNodeError({
+    error: {
+        code: "role_denied",
+        message: "A Session credential cannot address another Node with --node.",
+        retryable: false,
+    },
+});
+const remoteDiscoveryDenied = () => new CliLocalNodeError({
+    error: {
+        code: "invalid_argument",
+        message: "Attached Session operations cannot run with --node.",
+        retryable: false,
+    },
+});
+const sessionAttachmentDenied = () => new CliLocalNodeError({
+    error: {
+        code: "role_denied",
+        message: "A Session credential cannot run attached operations.",
+        retryable: false,
+    },
+});
+const sessionLaunch = Effect.gen(function* () {
+    const credential = yield* Config.option(Config.String(SESSION_CREDENTIAL_VARIABLE));
+    const origin = yield* Config.option(Config.String(SESSION_NODE_ORIGIN_VARIABLE));
+    if (Option.isNone(credential) && Option.isNone(origin))
+        return Option.none();
+    if (Option.isNone(credential) ||
+        Option.isNone(origin) ||
+        !SESSION_NODE_ORIGIN.test(origin.value))
+        return yield* Effect.fail(sessionLaunchInvalid());
+    return Option.some({ credential: credential.value, origin: origin.value });
+});
+const connectSession = (options) => Effect.promise(() => import("@maiaos/sdk/node/effect")).pipe(Effect.flatMap((sdk) => sdk.connectSessionNodeApiEffect(options)));
+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 maiaClientErrorCode = (error) => {
+    if (!(error instanceof Error) ||
+        error.name !== "MaiaClientError" ||
+        !("code" in error) ||
+        typeof error.code !== "string")
+        return undefined;
+    return error.code;
+};
+const localOperationError = (code) => {
+    if (code === "deadline_exceeded")
+        return LOCAL_DEADLINE_ERROR;
+    if (code === "outcome_unknown")
+        return LOCAL_OUTCOME_UNKNOWN_ERROR;
+    if (code === "saturated")
+        return LOCAL_SATURATED_ERROR;
+};
+const operationError = (error) => {
+    if (error instanceof CliLocalNodeError)
+        return error.error;
+    const remoteError = error instanceof Error && "remoteError" in error
+        ? error.remoteError
+        : undefined;
+    const parsed = protocolErrorSchema.safeParse(remoteError);
+    if (parsed.success)
+        return parsed.data;
+    const clientErrorCode = maiaClientErrorCode(error);
+    if (clientErrorCode === "invalid_request") {
+        return {
+            code: "invalid_argument",
+            message: "Command input is invalid.",
+            retryable: false,
+        };
+    }
+    if (clientErrorCode !== undefined) {
+        const local = localOperationError(clientErrorCode);
+        if (local !== undefined)
+            return local;
+    }
+    return {
+        code: "node_unavailable",
+        message: "The local Maia node is unavailable: start it with 'maia-node --desktop', or 'pnpm dev:node' in a dev worktree, then retry.",
+        retryable: true,
+    };
+};
+export const outcomeCanBeAmbiguous = (error) => maiaClientErrorCode(error) === "outcome_unknown";
+const MAX_INPUT_ISSUE_LENGTH = 512;
+const inputIssue = (error) => {
+    const text = Predicate.hasProperty(error, "message") && Predicate.isString(error.message)
+        ? error.message.replaceAll(/\s*\n\s*/gu, " ").trim()
+        : "";
+    if (text === "")
+        return "";
+    return `: ${text.length > MAX_INPUT_ISSUE_LENGTH ? `${text.slice(0, MAX_INPUT_ISSUE_LENGTH)}…` : text}`;
+};
+export const invalidNodeInput = (schemaError) => Effect.succeed({
+    error: {
+        code: "invalid_argument",
+        message: `The command input is invalid${inputIssue(schemaError)}.`,
+        retryable: false,
+    },
+    ok: false,
+});
+const failedOperation = (error, recovery) => ({
+    error: operationError(error),
+    ok: false,
+    ...(recovery !== undefined && outcomeCanBeAmbiguous(error)
+        ? { recovery }
+        : {}),
+});
+const completeOperation = (program, recovery) => program.pipe(Effect.map((value) => ({ ok: true, value })), Effect.catchCause((cause) => Cause.hasInterruptsOnly(cause)
+    ? Effect.interrupt
+    : Effect.succeed(failedOperation(Cause.squash(cause), recovery))));
+const discoveryOptionsOf = (source) => {
+    if (source === undefined)
+        return cliDiscoveryOptions;
+    return Effect.isEffect(source) ? source : Effect.succeed(source);
+};
+export const isBriefSaturation = (error) => {
+    const remoteError = error instanceof Error && "remoteError" in error
+        ? error.remoteError
+        : undefined;
+    const parsed = protocolErrorSchema.safeParse(remoteError);
+    if (parsed.success)
+        return (parsed.data.code === "saturated" && parsed.data.saturation === "admission");
+    return maiaClientErrorCode(error) === "saturated";
+};
+export const SATURATION_RETRY = Schedule.exponential("100 millis").pipe(Schedule.jittered);
+const SATURATION_RETRIES = 4;
+const nodeClientOperation = (connect) => (operation, recovery) => completeOperation(Effect.gen(function* () {
+    const connection = yield* connect;
+    return yield* newCliIdentifier("request").pipe(Effect.flatMap((messageId) => operation(connection.client, { messageId })), Effect.retry({
+        schedule: SATURATION_RETRY,
+        times: SATURATION_RETRIES,
+        while: isBriefSaturation,
+    }));
+}), recovery);
+const validatedNodeOperation = (runNodeClientOperation) => (input, schema, operation, recovery) => {
+    const parameters = schema.safeParse(input);
+    if (!parameters.success)
+        return invalidNodeInput(parameters.error);
+    return runNodeClientOperation((client, requestOptions) => operation(client, parameters.data, requestOptions), recovery);
+};
+const asSessionOr = (operator, session, required = false) => Effect.flatMap(sessionLaunch, Option.match({
+    onNone: () => (required ? Effect.fail(sessionLaunchInvalid()) : operator),
+    onSome: session,
+}));
+const coordinatorOptions = (options) => ({
+    ...options,
+    discoveryOptions: Effect.map(discoveryOptionsOf(options.discoveryOptions), (discovered) => ({ ...discovered, principal: "coordinator" })),
+});
+const boundSession = (options) => options.remote === true
+    ? () => Effect.fail(sessionRemoteDenied())
+    : connectSession;
+export const makeCliNodeOperations = (options = {}) => {
+    const discoveryOptions = discoveryOptionsOf(options.discoveryOptions);
+    const connector = options.connector ?? connectLocalNode;
+    const connect = asSessionOr(Effect.flatMap(discoveryOptions, connector), boundSession(options), options.requireSession === true);
+    const runNodeClientOperation = nodeClientOperation(connect);
+    return {
+        asCoordinator: () => makeCliNodeOperations(coordinatorOptions(options)),
+        asSession: () => makeCliNodeOperations({ ...options, requireSession: true }),
+        readStatus: Effect.map(connect, (connection) => connection.status),
+        runDiscoveryOperation: (operation, recovery) => completeOperation(options.remote === true
+            ? Effect.fail(remoteDiscoveryDenied())
+            : asSessionOr(Effect.flatMap(discoveryOptions, operation), () => Effect.fail(sessionAttachmentDenied())), recovery),
+        runNodeClientOperation,
+        runValidatedNodeOperation: validatedNodeOperation(runNodeClientOperation),
+    };
+};
+export const discoveryOptionsFor = (profile) => Effect.map(cliDiscoveryOptions, (options) => ({
+    ...options,
+    ...(profile === undefined ? {} : { profile }),
+}));
+export const runLazyNodeDependency = (input) => Effect.promise(input.loadClient).pipe(Effect.flatMap((clientModule) => {
+    const { connector, profile, remote } = input.binding;
+    const client = input.makeClient(clientModule, makeCliNodeOperations({
+        ...(connector === undefined ? {} : { connector }),
+        discoveryOptions: discoveryOptionsFor(profile),
+        ...(remote === true ? { remote: true } : {}),
+    }));
+    const operation = client[input.name];
+    return operation(...input.arguments_);
+}));
+//# sourceMappingURL=client.js.map

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

@@ -0,0 +1,3 @@
+export { type CliNodeCall, makeCallClient } from "./call.js";
+export { type CliMutationRecovery, type CliNodeBinding, type CliNodeConnection, type CliNodeConnector, type CliNodeEffect, type CliNodeOperations, type CliNodeOperationsOptions, type CliNodeResult, commandIdentifier, connectLocalNode, discoveryOptionsFor, fillCommandIdentifier, invalidNodeInput, makeCliNodeOperations, newCliIdentifier, outcomeCanBeAmbiguous, type ParameterSchema, runLazyNodeDependency, } from "./client.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/local-node/index.js

@@ -0,0 +1,3 @@
+export { makeCallClient } from "./call.js";
+export { commandIdentifier, connectLocalNode, discoveryOptionsFor, fillCommandIdentifier, invalidNodeInput, makeCliNodeOperations, newCliIdentifier, outcomeCanBeAmbiguous, runLazyNodeDependency, } from "./client.js";
+//# sourceMappingURL=index.js.map

package/dist/login/agent-provider.d.ts

@@ -0,0 +1,20 @@
+import type { MaiaAgentProvider, MaiaLoginInteraction, MaiaProviderAuthType } from "@maiaos/agent";
+import { Effect } from "effect";
+import { type CommandContext } from "../command-line/index.js";
+export type AgentProviderAccess = {
+    readonly list: () => Effect.Effect<readonly MaiaAgentProvider[], unknown>;
+    readonly login: (input: {
+        readonly authType: MaiaProviderAuthType;
+        readonly interaction: MaiaLoginInteraction;
+        readonly providerId: string;
+    }) => Effect.Effect<void, unknown>;
+};
+export declare const listAgentProviders: (context: CommandContext) => Effect.Effect<readonly MaiaAgentProvider[], Error, never>;
+type AgentLoginInput = {
+    readonly atTerminal: boolean;
+    readonly keyFromStdin: boolean;
+    readonly providerId: string;
+};
+export declare const signInAgentProvider: (context: CommandContext, input: AgentLoginInput) => Effect.Effect<MaiaAgentProvider, Error, never>;
+export {};
+//# sourceMappingURL=agent-provider.d.ts.map