@maiaos/cli 0.1.0-canary.2

package/dist/connection/signin.js

@@ -0,0 +1,32 @@
+import { Effect } from "effect";
+import { CliArgumentError, writeSuccess, } from "../command-line/index.js";
+import { commandIdentifier } from "../local-node/index.js";
+import { readConnectionSignin } from "./input.js";
+import { localBrowserAvailable } from "./login.js";
+import { formatConnectionResult, redactConnectionResult, } from "./output/index.js";
+import { callNode } from "./resolve.js";
+const parseSignin = (tokens) => Effect.try({
+    catch: (error) => error instanceof CliArgumentError
+        ? error
+        : new CliArgumentError("Invalid connection input."),
+    try: () => readConnectionSignin(tokens),
+});
+const startSignin = (context, input) => Effect.gen(function* () {
+    const connectionId = input.connection;
+    const shown = yield* callNode(context.dependencies.showConnection, (show) => show({ connectionId }));
+    const commandId = yield* commandIdentifier(input.commandId);
+    const localBrowser = yield* localBrowserAvailable;
+    return yield* callNode(context.dependencies.startConnectionLogin, (start) => start({
+        commandId,
+        connectionId,
+        expectedRevision: shown.connection.revision,
+        flow: input.flow === "device-code" || !localBrowser
+            ? "device-code"
+            : "browser",
+    }));
+});
+export const signInThroughNode = (tokens, context) => parseSignin(tokens).pipe(Effect.flatMap((input) => startSignin(context, input)), Effect.map((started) => {
+    writeSuccess({ command: started.method, result: redactConnectionResult(started) }, context, formatConnectionResult);
+    return 0;
+}));
+//# sourceMappingURL=signin.js.map

package/dist/connection/system.d.ts

@@ -0,0 +1,4 @@
+import { type CommandContext, type CommandEffect } from "../command-line/index.js";
+export declare const runConnectionDetect: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runSetup: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+//# sourceMappingURL=system.d.ts.map

package/dist/connection/system.js

@@ -0,0 +1,190 @@
+import { connectionSystemConfirmParametersSchema, } from "@maiaos/sdk";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import { askToConfirm, CliArgumentError, confirmParameters, EXIT_CANCELLED, parseOptions, promptOrRefuse, readPipedPreview, reportError, requestedTwoPhaseMode, requirePositionals, TWO_PHASE_FLAGS, } from "../command-line/index.js";
+import { commandIdentifier, } from "../local-node/index.js";
+class SetupNodeError extends Data.TaggedError("SetupNodeError") {
+}
+const required = (effect) => effect === undefined
+    ? Effect.fail(new CliArgumentError("Connections are unavailable."))
+    : Effect.flatMap(effect, (result) => result.ok
+        ? Effect.succeed(result.value)
+        : Effect.fail(new SetupNodeError({ error: result.error })));
+const write = (context, output, text) => {
+    context.io.stdout(context.json ? `${JSON.stringify({ ok: true, result: output })}\n` : text);
+};
+const nodeLocal = (value) => ({
+    ...value,
+    pathScope: "node-local",
+});
+const markDetected = (detected) => ({
+    ...detected,
+    executors: detected.executors.map((item) => item.binary.found ? { ...item, binary: nodeLocal(item.binary) } : item),
+});
+const markPreview = (preview) => ({
+    ...preview,
+    items: preview.items.map((item) => item.executable === undefined
+        ? item
+        : { ...item, executable: nodeLocal(item.executable) }),
+});
+const signIn = (item) => {
+    if (item.endpoint !== undefined)
+        return `custom endpoint ${item.endpoint.host} (${item.endpoint.credential === "helper" ? "credential helper" : "key variable"})`;
+    const kind = item.accountKind === undefined ? "" : ` (${item.accountKind})`;
+    if (item.auth === "vendor-login")
+        return `signed in${kind}`;
+    return item.auth === "none" ? "signed out" : "sign-in unknown";
+};
+const detectedText = (item) => {
+    if (!item.binary.found)
+        return `${item.executor}: not installed\n`;
+    const { onNodePath, path, version } = item.binary;
+    const account = item.connection === undefined
+        ? "no system-default account"
+        : `account ${item.connection.name} (${item.connection.state})`;
+    return [
+        `${item.executor} ${version ?? "(version unknown)"} ${path}${onNodePath ? "" : " (not on the Node's PATH)"}`,
+        `  ${signIn(item)}; ${account}; executable ${item.executableApproved ? "approved" : "not approved"}`,
+        ...(item.endpoint?.hint === undefined ? [] : [`  ${item.endpoint.hint}`]),
+        "",
+    ].join("\n");
+};
+export const runConnectionDetect = (tokens, context) => Effect.gen(function* () {
+    requirePositionals(tokens, 0);
+    const detected = yield* required(context.dependencies.detectConnections?.({}));
+    write(context, { command: "connection.detect", result: markDetected(detected) }, detected.executors.map(detectedText).join(""));
+    return 0;
+}).pipe(Effect.catch(reportSetupFailure(context)));
+const SKIPPED = new Map([
+    ["approval-unavailable", "this Node cannot approve vendor executables"],
+    ["auth-unknown", "Maia could not read its sign-in"],
+    [
+        "env-key-endpoint",
+        "its custom endpoint reads a key variable, which Maia Sessions do not pass",
+    ],
+    ["missing", "not installed"],
+    ["name-taken", "the default account names are taken"],
+    [
+        "not-on-node-path",
+        "not on the Node's PATH; start the Node from a shell that finds it",
+    ],
+    [
+        "settings-endpoint",
+        "its custom endpoint lives in ~/.claude/settings.json, which Maia's Claude Sessions do not load",
+    ],
+    ["signed-out", "signed out; sign in with the CLI itself first"],
+]);
+const skipText = (item) => `${SKIPPED.get(item.reason ?? "missing") ?? ""}${item.endpoint?.hint === undefined ? "" : `; ${item.endpoint.hint}`}`;
+const itemText = (item) => {
+    if (item.reason !== undefined)
+        return `  ${item.executor}: skipped, ${skipText(item)}\n`;
+    const { connection, endpoint, executable, executor } = item;
+    const account = connection?.action === "create"
+        ? `create account ${connection.name} (system default, ${String(connection.maxConcurrentSessions)} Sessions)`
+        : `use account ${connection?.name ?? ""} (${String(connection?.maxConcurrentSessions ?? "")} Sessions)`;
+    const approval = executable?.action === "approve"
+        ? `approve ${executable.path}`
+        : "executable already approved";
+    const through = endpoint === undefined ? "" : `, through ${endpoint.host}`;
+    return `  ${executor} ${executable?.version ?? ""}: ${account}; ${approval}${through}\n`;
+};
+const hasWork = (item) => item.connection?.action === "create" || item.executable?.action === "approve";
+const previewText = (preview) => `Maia uses the installed CLIs as they are, with your own login and config:\n${preview.items.map(itemText).join("")}${(preview.notes ?? []).map((note) => `  note: ${note}\n`).join("")}`;
+const withCapacityNotes = (plan, requested) => {
+    const notes = plan.items.flatMap(({ connection, reason }) => requested === undefined ||
+        reason !== undefined ||
+        connection?.action !== "existing" ||
+        connection.maxConcurrentSessions === requested
+        ? []
+        : [
+            `existing account ${connection.name} keeps Sessions<=${String(connection.maxConcurrentSessions)}, not ${String(requested)}; use 'maia connection capacity set ${connection.name} --max-sessions ${String(requested)} --expected-revision <revision>' to change it.`,
+        ]);
+    return notes.length === 0 ? plan : { ...plan, notes };
+};
+const confirmedText = (result) => result.items
+    .map((item) => `${item.executor}: account ${item.connection.name} (${item.connection.connectionId})${item.connectionReceipt === undefined ? "" : ", created"}${item.approvalReceipt === undefined ? "" : ", executable approved"}\n`)
+    .join("") || "Nothing changed.\n";
+const readSetup = (parsed) => {
+    requirePositionals(parsed.positionals, 0);
+    const sessions = parsed.options.get("--max-sessions");
+    if (sessions !== undefined && !/^(?:[1-9]|1[0-6])$/u.test(sessions))
+        throw new CliArgumentError("--max-sessions must be 1 to 16.");
+    return {
+        commandId: parsed.options.get("--command-id"),
+        ...(sessions === undefined
+            ? {}
+            : { maxConcurrentSessions: Number(sessions) }),
+    };
+};
+const confirm = (context, preview) => Effect.gen(function* () {
+    const parameters = yield* confirmParameters(connectionSystemConfirmParametersSchema, preview, ["items", "notes"]);
+    return yield* required(context.dependencies.confirmSystemConnections?.(parameters));
+});
+const preview = (context, input) => Effect.flatMap(commandIdentifier(input.commandId), (commandId) => required(context.dependencies.previewSystemConnections?.({
+    commandId,
+    ...(input.maxConcurrentSessions === undefined
+        ? {}
+        : { maxConcurrentSessions: input.maxConcurrentSessions }),
+})).pipe(Effect.map((plan) => withCapacityNotes(plan, input.maxConcurrentSessions))));
+const settled = (context, plan) => {
+    if (plan.items.some((item) => item.reason === undefined)) {
+        write(context, { command: "setup", result: { preview: markPreview(plan) } }, `${previewText(plan)}Already set up.\n`);
+        return 0;
+    }
+    if (!context.json)
+        context.io.stdout(previewText(plan));
+    const reasons = plan.items
+        .map((item) => `${item.executor} ${skipText(item)}`)
+        .join("; ");
+    return reportError({
+        code: "resource_not_found",
+        message: `No installed CLI is usable: ${reasons}.`,
+        retryable: false,
+    }, context);
+};
+const writeConfirmed = (context, result, plan) => {
+    write(context, {
+        command: "setup",
+        result: {
+            ...(plan === undefined ? {} : { preview: markPreview(plan) }),
+            result,
+        },
+    }, confirmedText(result));
+    return 0;
+};
+const writeDryRun = (context, plan) => {
+    write(context, { command: "connection.system.preview", result: markPreview(plan) }, `${previewText(plan)}Confirm with: maia --json setup --dry-run | maia setup --confirm-stdin\n`);
+    return 0;
+};
+export const runSetup = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set(["--command-id", "--max-sessions"]), new Set(["--yes", ...TWO_PHASE_FLAGS]));
+    const input = readSetup(parsed);
+    const requested = requestedTwoPhaseMode(parsed.flags, true);
+    if (requested === "confirm-stdin")
+        return writeConfirmed(context, yield* confirm(context, yield* readPipedPreview(context)));
+    const plan = yield* preview(context, input);
+    if (requested === "dry-run")
+        return writeDryRun(context, plan);
+    if (!plan.items.some(hasWork))
+        return settled(context, plan);
+    const mode = requested ?? promptOrRefuse(context, true);
+    if (!context.json)
+        context.io.stdout(previewText(plan));
+    if (mode === "prompt" && !(yield* askToConfirm(context, "Use them?"))) {
+        context.io.stderr("Cancelled; nothing changed.\n");
+        return EXIT_CANCELLED;
+    }
+    return writeConfirmed(context, yield* confirm(context, plan), plan);
+}).pipe(Effect.catch(reportSetupFailure(context)));
+const reportSetupFailure = (context) => (error) => Effect.sync(() => reportError(error instanceof SetupNodeError
+    ? error.error
+    : {
+        code: error instanceof CliArgumentError
+            ? "invalid_argument"
+            : "internal_error",
+        message: error instanceof CliArgumentError
+            ? error.message
+            : "The setup command failed.",
+        retryable: false,
+    }, context));
+//# sourceMappingURL=system.js.map

package/dist/connection/tree/index.d.ts

@@ -0,0 +1,2 @@
+export { CONNECTION_TREE } from "./tree.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/connection/tree/index.js

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

package/dist/connection/tree/tree.d.ts

@@ -0,0 +1,3 @@
+import type { TreeFragment } from "../../command-tree/index.js";
+export declare const CONNECTION_TREE: TreeFragment;
+//# sourceMappingURL=tree.d.ts.map

package/dist/connection/tree/tree.js

@@ -0,0 +1,209 @@
+const connection = () => import("../index.js");
+const login = () => import("../../login/index.js");
+const integration = () => import("../../integration/index.js");
+const provider = () => import("../../provider/index.js");
+const loginRunner = [login, "runLogin"];
+export const CONNECTION_TREE = {
+    groups: [
+        ["connection", "Worker account Connections."],
+        ["connection login", "Sign-ins the Node starts."],
+        ["connection usage", "A Connection's usage."],
+        ["connection models", "Models a Connection offers."],
+        ["connection capacity", "A Connection's Session limit."],
+        ["integration", "Approve vendor executables."],
+        ["integration plan", "Plan approving a vendor executable."],
+        ["integration status", "A vendor integration's status."],
+        ["integration apply", "Approve a vendor executable with a plan."],
+        ["integration remove", "Remove a vendor integration."],
+        ["provider", "Model providers."],
+        ["provider pool", "Model-provider pools."],
+    ],
+    leaves: [
+        [
+            "setup [--max-sessions <1..16>] [--command-id <id>] [--dry-run | --confirm-stdin | --yes]",
+            1,
+            ["connection.system.preview", "connection.system.confirm"],
+            "Use the installed vendor CLIs as system-default accounts.",
+            {
+                example: "maia setup --max-sessions 4",
+                kind: "two-phase",
+                run: [connection, "runSetup"],
+            },
+        ],
+        [
+            "login",
+            1,
+            "",
+            "List worker accounts and model providers.",
+            { kind: "composite", run: loginRunner },
+        ],
+        [
+            "login <claude|codex> [--name <name>] [--device-code] [--max-sessions <1..16>]",
+            1,
+            "",
+            "Add or re-sign a Claude Code or Codex account.",
+            {
+                example: "maia login codex --name codex-2 --device-code",
+                kind: "composite",
+                run: loginRunner,
+            },
+        ],
+        [
+            "login <model-provider> [--api-key-stdin]",
+            1,
+            "",
+            "Sign in a model provider for Maia's agent.",
+            { kind: "composite", run: loginRunner },
+        ],
+        [
+            "login gateway --name <name> --base-url <url> --api-key-stdin [--max-sessions <1..16>] [--command-id <id>]",
+            1,
+            "connection.gateway.create",
+            "Add an AI gateway Connection with its API key.",
+            { run: [login, "runLoginGateway"] },
+        ],
+        [
+            "connection create --name <name> --executor <codex-cli|claude-code> --root <maia-managed|system-default> [--max-sessions <1..16>] [--command-id <id>]",
+            1,
+            "connection.create",
+            "Create a worker account Connection.",
+            { run: [connection, "runConnectionCreate"] },
+        ],
+        [
+            "connection list [--limit <1..100>] [--after <cursor>]",
+            1,
+            "connection.list",
+            "List Connections.",
+            {
+                example: "maia --json connection list",
+                run: [connection, "runConnectionList"],
+            },
+        ],
+        [
+            "connection show <connection>",
+            1,
+            "connection.show",
+            "Show one Connection by name or ID.",
+            { run: [connection, "runConnectionShow"] },
+        ],
+        [
+            "connection detect",
+            1,
+            "connection.detect",
+            "Detect the installed vendor CLIs.",
+            {
+                example: "maia --json connection detect",
+                run: [connection, "runConnectionDetect"],
+            },
+        ],
+        [
+            "connection login start <connection> [--device-code] [--command-id <id>]",
+            1,
+            "connection.login.start",
+            "Start a Node-side sign-in for a Connection.",
+            { run: [connection, "runConnectionLoginStart"] },
+        ],
+        [
+            "connection usage show <connection> [--refresh]",
+            1,
+            "connection.usage.show",
+            "Show a Connection's usage.",
+            { run: [connection, "runConnectionUsageShow"] },
+        ],
+        [
+            "connection models list --connection <connection>",
+            1,
+            "connection.models.list",
+            "List the models a Connection offers.",
+            { run: [connection, "runConnectionModelsList"] },
+        ],
+        [
+            "connection capacity set <connection> --max-sessions <1..16> --expected-revision <revision> [--command-id <id>]",
+            1,
+            "connection.capacity.set",
+            "Set a Connection's Session limit.",
+            { run: [connection, "runConnectionCapacitySet"] },
+        ],
+        [
+            "connection enable <connection> --expected-revision <revision> [--command-id <id>]",
+            1,
+            "connection.state.set",
+            "Enable a Connection.",
+            { kind: "discriminant", run: [connection, "runConnectionEnable"] },
+        ],
+        [
+            "connection disable <connection> --expected-revision <revision> [--command-id <id>]",
+            1,
+            "connection.state.set",
+            "Disable a Connection.",
+            { kind: "discriminant", run: [connection, "runConnectionDisable"] },
+        ],
+        [
+            "integration plan codex",
+            1,
+            "integration.plan.codex",
+            "Plan approving the Codex executable.",
+            {
+                example: "maia integration plan codex",
+                run: [integration, "runPlanCodex"],
+            },
+        ],
+        [
+            "integration plan claude-code",
+            1,
+            "integration.plan.claude-code",
+            "Plan approving the Claude Code executable.",
+            { run: [integration, "runPlanClaudeCode"] },
+        ],
+        [
+            "integration status codex",
+            1,
+            "integration.status.codex",
+            "Show the Codex integration status.",
+            { run: [integration, "runStatusCodex"] },
+        ],
+        [
+            "integration status claude-code",
+            1,
+            "integration.status.claude-code",
+            "Show the Claude Code integration status.",
+            { run: [integration, "runStatusClaudeCode"] },
+        ],
+        [
+            "integration apply codex --plan <plan-id> [--command-id <id>]",
+            1,
+            "integration.apply.codex",
+            "Approve the Codex executable with a plan.",
+            { run: [integration, "runApplyCodex"] },
+        ],
+        [
+            "integration apply claude-code --plan <plan-id> [--command-id <id>]",
+            1,
+            "integration.apply.claude-code",
+            "Approve the Claude Code executable with a plan.",
+            { run: [integration, "runApplyClaudeCode"] },
+        ],
+        [
+            "integration remove codex [--command-id <id>]",
+            1,
+            "integration.remove.codex",
+            "Remove the Codex integration.",
+            { run: [integration, "runRemoveCodex"] },
+        ],
+        [
+            "integration remove claude-code [--command-id <id>]",
+            1,
+            "integration.remove.claude-code",
+            "Remove the Claude Code integration.",
+            { run: [integration, "runRemoveClaudeCode"] },
+        ],
+        [
+            "provider pool list",
+            1,
+            "provider.pool.list",
+            "List model-provider pools.",
+            { run: [provider, "runProviderPoolList"] },
+        ],
+    ],
+};
+//# sourceMappingURL=tree.js.map

package/dist/container/client.d.ts

@@ -0,0 +1,142 @@
+import { type ContainerCreateConfirmParameters, type ContainerCreatePreviewParameters, type ContainerIndexListParameters, type ContainerListParameters, type ContainerRenameConfirmParameters, type ContainerRenamePreviewParameters, type ContainerShowParameters } from "@maiaos/sdk";
+import type { CliNodeOperations } from "../local-node/index.js";
+export declare const makeContainerClient: (node: CliNodeOperations) => {
+    confirmContainerCreate: (input: ContainerCreateConfirmParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly actorId: string;
+        readonly commandId: string;
+        readonly container: {
+            readonly createdAt: string;
+            readonly id: string;
+            readonly name: string;
+            readonly revision: string;
+            readonly schemaVersion: "maia.container/v1";
+            readonly updatedAt: string;
+        };
+        readonly delivery: "duplicate" | "new";
+        readonly inputDigest: string;
+        readonly receipt: {
+            readonly actorId: string;
+            readonly aggregateRevision: string;
+            readonly commandId: string;
+            readonly createdAt: string;
+            readonly eventCursor: string;
+            readonly method: string;
+            readonly receiptId: string;
+            readonly schemaVersion: 1;
+            readonly state: "succeeded";
+            readonly target: {
+                readonly id: string;
+                readonly type: string;
+            };
+            readonly updatedAt: string;
+        };
+        readonly method: "container.create.confirm";
+    }>;
+    confirmContainerRename: (input: ContainerRenameConfirmParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly actorId: string;
+        readonly commandId: string;
+        readonly container: {
+            readonly createdAt: string;
+            readonly id: string;
+            readonly name: string;
+            readonly revision: string;
+            readonly schemaVersion: "maia.container/v1";
+            readonly updatedAt: string;
+        };
+        readonly delivery: "duplicate" | "new";
+        readonly inputDigest: string;
+        readonly receipt: {
+            readonly actorId: string;
+            readonly aggregateRevision: string;
+            readonly commandId: string;
+            readonly createdAt: string;
+            readonly eventCursor: string;
+            readonly method: string;
+            readonly receiptId: string;
+            readonly schemaVersion: 1;
+            readonly state: "succeeded";
+            readonly target: {
+                readonly id: string;
+                readonly type: string;
+            };
+            readonly updatedAt: string;
+        };
+        readonly expectedRevision: string;
+        readonly method: "container.rename.confirm";
+    }>;
+    listContainerIndex: (input: ContainerIndexListParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly items: readonly {
+            readonly container: {
+                readonly createdAt: string;
+                readonly id: string;
+                readonly name: string;
+                readonly revision: string;
+                readonly schemaVersion: "maia.container/v1";
+                readonly updatedAt: string;
+            };
+            readonly projectCount: number;
+            readonly projects: readonly {
+                readonly id: string;
+                readonly name: string;
+                readonly revision: string;
+                readonly path?: string | undefined;
+            }[];
+        }[];
+        readonly method: "container.index.list";
+        readonly nextCursor?: string | undefined;
+    }>;
+    listContainers: (input: ContainerListParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly items: readonly {
+            readonly createdAt: string;
+            readonly id: string;
+            readonly name: string;
+            readonly revision: string;
+            readonly schemaVersion: "maia.container/v1";
+            readonly updatedAt: string;
+        }[];
+        readonly method: "container.list";
+        readonly nextCursor?: string | undefined;
+    }>;
+    previewContainerCreate: (input: ContainerCreatePreviewParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly commandId: string;
+        readonly name: string;
+        readonly inputDigest: string;
+        readonly proof: string;
+        readonly actorId: string;
+        readonly expiresAt: string;
+        readonly issuedAt: string;
+        readonly containerId: string;
+        readonly method: "container.create.preview";
+    }>;
+    previewContainerRename: (input: ContainerRenamePreviewParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly commandId: string;
+        readonly name: string;
+        readonly containerId: string;
+        readonly expectedRevision: string;
+        readonly inputDigest: string;
+        readonly proof: string;
+        readonly actorId: string;
+        readonly expiresAt: string;
+        readonly issuedAt: string;
+        readonly method: "container.rename.preview";
+    }>;
+    showContainer: (input: ContainerShowParameters) => import("../local-node/client.js").CliNodeEffect<{
+        readonly container: {
+            readonly createdAt: string;
+            readonly id: string;
+            readonly name: string;
+            readonly revision: string;
+            readonly schemaVersion: "maia.container/v1";
+            readonly updatedAt: string;
+        };
+        readonly method: "container.show";
+        readonly nextCursor?: string | undefined;
+        readonly projects: readonly {
+            readonly id: string;
+            readonly name: string;
+            readonly revision: string;
+        }[];
+    }>;
+};
+export type ContainerCliDependencies = ReturnType<typeof makeContainerClient>;
+//# sourceMappingURL=client.d.ts.map

package/dist/container/client.js

@@ -0,0 +1,11 @@
+import { containerCreateConfirmParametersSchema, containerCreatePreviewParametersSchema, containerIndexListParametersSchema, containerListParametersSchema, containerRenameConfirmParametersSchema, containerRenamePreviewParametersSchema, containerShowParametersSchema, } from "@maiaos/sdk";
+export const makeContainerClient = (node) => ({
+    confirmContainerCreate: (input) => node.runValidatedNodeOperation(input, containerCreateConfirmParametersSchema, (client, parameters, options) => client.confirmContainerCreate(parameters, options), { commandId: input.commandId }),
+    confirmContainerRename: (input) => node.runValidatedNodeOperation(input, containerRenameConfirmParametersSchema, (client, parameters, options) => client.confirmContainerRename(parameters, options), { commandId: input.commandId }),
+    listContainerIndex: (input) => node.runValidatedNodeOperation(input, containerIndexListParametersSchema, (client, parameters, options) => client.listContainerIndex(parameters, options)),
+    listContainers: (input) => node.runValidatedNodeOperation(input, containerListParametersSchema, (client, parameters, options) => client.listContainers(parameters, options)),
+    previewContainerCreate: (input) => node.runValidatedNodeOperation(input, containerCreatePreviewParametersSchema, (client, parameters, options) => client.previewContainerCreate(parameters, options)),
+    previewContainerRename: (input) => node.runValidatedNodeOperation(input, containerRenamePreviewParametersSchema, (client, parameters, options) => client.previewContainerRename(parameters, options)),
+    showContainer: (input) => node.runValidatedNodeOperation(input, containerShowParametersSchema, (client, parameters, options) => client.showContainer(parameters, options)),
+});
+//# sourceMappingURL=client.js.map

package/dist/container/commands.d.ts

@@ -0,0 +1,7 @@
+import { type CommandContext, type CommandEffect } from "../command-line/index.js";
+export declare const runContainerList: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runContainerShow: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runContainerIndexList: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runContainerCreate: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runContainerRename: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+//# sourceMappingURL=commands.d.ts.map