@maiaos/cli 0.1.0-canary.2

package/dist/connection/client.js

@@ -0,0 +1,28 @@
+import { connectionCapacitySetParametersSchema, connectionCreateParametersSchema, connectionDetectParametersSchema, connectionGatewayCreateParametersSchema, connectionListParametersSchema, connectionLoginStartParametersSchema, connectionModelsListParametersSchema, connectionShowParametersSchema, connectionStateSetParametersSchema, connectionSystemConfirmParametersSchema, connectionSystemPreviewParametersSchema, connectionUsageShowParametersSchema, } from "@maiaos/sdk";
+const readClient = (node) => ({
+    listConnectionModels: (input) => node.runValidatedNodeOperation(input, connectionModelsListParametersSchema, (client, parameters, options) => client.listConnectionModels(parameters, options)),
+    listConnections: (input) => node.runValidatedNodeOperation(input, connectionListParametersSchema, (client, parameters, options) => client.listConnections(parameters, options)),
+    showConnection: (input) => node.runValidatedNodeOperation(input, connectionShowParametersSchema, (client, parameters, options) => client.showConnection(parameters, options)),
+    showConnectionUsage: (input) => node.runValidatedNodeOperation(input, connectionUsageShowParametersSchema, (client, parameters, options) => client.showConnectionUsage(parameters, options)),
+});
+const mutationClient = (node) => ({
+    createConnection: (input) => node.runValidatedNodeOperation(input, connectionCreateParametersSchema, (client, parameters, options) => client.createConnection(parameters, options), { commandId: input.commandId }),
+    setConnectionCapacity: (input) => node.runValidatedNodeOperation(input, connectionCapacitySetParametersSchema, (client, parameters, options) => client.setConnectionCapacity(parameters, options), { commandId: input.commandId }),
+    setConnectionState: (input) => node.runValidatedNodeOperation(input, connectionStateSetParametersSchema, (client, parameters, options) => client.setConnectionState(parameters, options), { commandId: input.commandId }),
+});
+const signInClient = (node) => ({
+    createGatewayConnection: (input) => node.runValidatedNodeOperation(input, connectionGatewayCreateParametersSchema, (client, parameters, options) => client.createGatewayConnection(parameters, options), { commandId: input.commandId }),
+    startConnectionLogin: (input) => node.runValidatedNodeOperation(input, connectionLoginStartParametersSchema, (client, parameters, options) => client.startConnectionLogin(parameters, options), { commandId: input.commandId }),
+});
+const systemClient = (node) => ({
+    confirmSystemConnections: (input) => node.runValidatedNodeOperation(input, connectionSystemConfirmParametersSchema, (client, parameters, options) => client.confirmSystemConnections(parameters, options), { commandId: input.commandId }),
+    detectConnections: (input) => node.runValidatedNodeOperation(input, connectionDetectParametersSchema, (client, parameters, options) => client.detectConnections(parameters, options)),
+    previewSystemConnections: (input) => node.runValidatedNodeOperation(input, connectionSystemPreviewParametersSchema, (client, parameters, options) => client.previewSystemConnections(parameters, options)),
+});
+export const makeConnectionClient = (node) => ({
+    ...readClient(node),
+    ...mutationClient(node),
+    ...signInClient(node),
+    ...systemClient(node),
+});
+//# sourceMappingURL=client.js.map

package/dist/connection/commands.d.ts

@@ -0,0 +1,15 @@
+import { type Connection } from "@maiaos/sdk";
+import { Effect } from "effect";
+import { type CommandContext, type CommandEffect } from "../command-line/index.js";
+import type { VendorLoginOptions } from "./login.js";
+export declare const runConnectionCreate: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runConnectionList: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runConnectionShow: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runConnectionModelsList: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runConnectionUsageShow: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runConnectionLoginStart: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runConnectionCapacitySet: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runConnectionEnable: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export declare const runConnectionDisable: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+export type VendorLogin = (connection: Connection, options: VendorLoginOptions) => Effect.Effect<number, unknown>;
+//# sourceMappingURL=commands.d.ts.map

package/dist/connection/commands.js

@@ -0,0 +1,118 @@
+import { connectionCapacitySetParametersSchema, connectionCreateParametersSchema, connectionListParametersSchema, connectionModelsListParametersSchema, connectionShowParametersSchema, connectionStateSetParametersSchema, connectionUsageShowParametersSchema, protocolErrorSchema, } from "@maiaos/sdk";
+import { Cause, Effect } from "effect";
+import { CliArgumentError, reportError, writeSuccess, } from "../command-line/index.js";
+import { fillCommandIdentifier, } from "../local-node/index.js";
+import { readConnectionCapacity, readConnectionCreate, readConnectionList, readConnectionModels, readConnectionState, readConnectionTarget, readConnectionUsage, } from "./input.js";
+import { formatConnectionResult, redactConnectionResult, } from "./output/index.js";
+import { ConnectionNodeError } from "./resolve.js";
+import { signInThroughNode } from "./signin.js";
+const invalidInput = (error) => error instanceof CliArgumentError
+    ? error
+    : new CliArgumentError("Invalid connection input. Use 'maia help connection' for usage.");
+const recoveryFor = (parameters) => typeof parameters === "object" &&
+    parameters !== null &&
+    "commandId" in parameters &&
+    typeof parameters.commandId === "string"
+    ? { recovery: { commandId: parameters.commandId } }
+    : {};
+const boundaryFailure = (parameters) => ({
+    error: {
+        code: "recovery" in recoveryFor(parameters)
+            ? "outcome_unknown"
+            : "node_unavailable",
+        message: "Connection response unavailable. Reconcile the original command before retrying a mutation.",
+        retryable: false,
+    },
+    ok: false,
+    ...recoveryFor(parameters),
+});
+const request = (spec) => Effect.gen(function* () {
+    const parsed = yield* Effect.try({ catch: invalidInput, try: spec.input });
+    const filled = yield* fillCommandIdentifier(parsed);
+    const parameters = yield* Effect.try({
+        catch: invalidInput,
+        try: () => spec.parameters.parse(filled),
+    });
+    const operation = spec.operation;
+    if (operation === undefined)
+        return yield* Effect.fail(new Error("Missing connection client."));
+    const response = yield* operation(parameters).pipe(Effect.catchCause((cause) => Cause.hasInterruptsOnly(cause)
+        ? Effect.interrupt
+        : Effect.succeed(boundaryFailure(parameters))));
+    return { parameters, response };
+});
+const writeResponse = (response, parameters, context) => {
+    if (!response.ok) {
+        const error = protocolErrorSchema.parse(response.error);
+        return reportError(error, {
+            ...context,
+            ...(error.code === "outcome_unknown" ? recoveryFor(parameters) : {}),
+        });
+    }
+    writeSuccess({
+        command: response.value.method,
+        result: redactConnectionResult(response.value),
+    }, context, formatConnectionResult);
+    return 0;
+};
+const invoke = (spec, context) => request(spec).pipe(Effect.map(({ parameters, response }) => writeResponse(response, parameters, context)));
+const usage = (tokens, context) => invoke({
+    input: () => {
+        const parsed = readConnectionUsage(tokens);
+        return {
+            connectionId: parsed.connection,
+            ...(parsed.refresh ? { refresh: true } : {}),
+        };
+    },
+    operation: context.dependencies.showConnectionUsage,
+    parameters: connectionUsageShowParametersSchema,
+}, context);
+const reportFailure = (error, context) => {
+    if (error instanceof ConnectionNodeError)
+        return reportError(error.error, context);
+    return reportError({
+        code: error instanceof CliArgumentError
+            ? "invalid_argument"
+            : "internal_error",
+        message: error instanceof CliArgumentError
+            ? error.message
+            : "Connection command failed.",
+        retryable: false,
+    }, context);
+};
+const leaf = (program) => (tokens, context) => Effect.suspend(() => program(tokens, context)).pipe(Effect.catch((error) => Effect.sync(() => reportFailure(error, context))));
+export const runConnectionCreate = leaf((tokens, context) => invoke({
+    input: () => readConnectionCreate(tokens),
+    operation: context.dependencies.createConnection,
+    parameters: connectionCreateParametersSchema,
+}, context));
+export const runConnectionList = leaf((tokens, context) => invoke({
+    input: () => readConnectionList(tokens),
+    operation: context.dependencies.listConnections,
+    parameters: connectionListParametersSchema,
+}, context));
+export const runConnectionShow = leaf((tokens, context) => invoke({
+    input: () => readConnectionTarget(tokens),
+    operation: context.dependencies.showConnection,
+    parameters: connectionShowParametersSchema,
+}, context));
+export const runConnectionModelsList = leaf((tokens, context) => invoke({
+    input: () => readConnectionModels(tokens),
+    operation: context.dependencies.listConnectionModels,
+    parameters: connectionModelsListParametersSchema,
+}, context));
+export const runConnectionUsageShow = leaf(usage);
+export const runConnectionLoginStart = leaf(signInThroughNode);
+export const runConnectionCapacitySet = leaf((tokens, context) => invoke({
+    input: () => readConnectionCapacity(tokens),
+    operation: context.dependencies.setConnectionCapacity,
+    parameters: connectionCapacitySetParametersSchema,
+}, context));
+const stateLeaf = (state) => leaf((tokens, context) => invoke({
+    input: () => readConnectionState(tokens, state),
+    operation: context.dependencies.setConnectionState,
+    parameters: connectionStateSetParametersSchema,
+}, context));
+export const runConnectionEnable = stateLeaf("enabled");
+export const runConnectionDisable = stateLeaf("disabled");
+//# sourceMappingURL=commands.js.map

package/dist/connection/index.d.ts

@@ -0,0 +1,7 @@
+export { type ConnectionCliDependencies, makeConnectionClient, } from "./client.js";
+export { runConnectionCapacitySet, runConnectionCreate, runConnectionDisable, runConnectionEnable, runConnectionList, runConnectionLoginStart, runConnectionModelsList, runConnectionShow, runConnectionUsageShow, type VendorLogin, } from "./commands.js";
+export { runVendorLogin } from "./login.js";
+export { describeConnection, formatConnectionResult, redactConnection, redactConnectionResult, } from "./output/index.js";
+export { callNode, ConnectionNodeError, findConnectionByName, } from "./resolve.js";
+export { runConnectionDetect, runSetup } from "./system.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/connection/index.js

@@ -0,0 +1,7 @@
+export { makeConnectionClient, } from "./client.js";
+export { runConnectionCapacitySet, runConnectionCreate, runConnectionDisable, runConnectionEnable, runConnectionList, runConnectionLoginStart, runConnectionModelsList, runConnectionShow, runConnectionUsageShow, } from "./commands.js";
+export { runVendorLogin } from "./login.js";
+export { describeConnection, formatConnectionResult, redactConnection, redactConnectionResult, } from "./output/index.js";
+export { callNode, ConnectionNodeError, findConnectionByName, } from "./resolve.js";
+export { runConnectionDetect, runSetup } from "./system.js";
+//# sourceMappingURL=index.js.map

package/dist/connection/input.d.ts

@@ -0,0 +1,50 @@
+export declare const readConnectionCreate: (tokens: readonly string[]) => {
+    maxConcurrentSessions?: undefined;
+    commandId: string | undefined;
+    configRootKind: string;
+    executor: string;
+    name: string;
+} | {
+    maxConcurrentSessions: number;
+    commandId: string | undefined;
+    configRootKind: string;
+    executor: string;
+    name: string;
+};
+export declare const readConnectionList: (tokens: readonly string[]) => {
+    limit: number;
+    afterCursor?: string | undefined;
+};
+export declare const readConnectionTarget: (tokens: readonly string[]) => {
+    connectionId: string | undefined;
+};
+export declare const readConnectionCapacity: (tokens: readonly string[]) => {
+    maxConcurrentSessions?: undefined;
+    commandId: string | undefined;
+    connectionId: string | undefined;
+    expectedRevision: string;
+} | {
+    maxConcurrentSessions: number;
+    commandId: string | undefined;
+    connectionId: string | undefined;
+    expectedRevision: string;
+};
+export declare const readConnectionUsage: (tokens: readonly string[]) => {
+    connection: string;
+    refresh: boolean;
+};
+export declare const readConnectionSignin: (tokens: readonly string[]) => {
+    commandId: string | undefined;
+    connection: string;
+    flow: "browser" | "device-code";
+};
+export declare const readConnectionState: (tokens: readonly string[], state: "disabled" | "enabled") => {
+    commandId: string | undefined;
+    connectionId: string | undefined;
+    expectedRevision: string;
+    state: "disabled" | "enabled";
+};
+export declare const readConnectionModels: (tokens: readonly string[]) => {
+    connectionId: string;
+};
+//# sourceMappingURL=input.d.ts.map

package/dist/connection/input.js

@@ -0,0 +1,90 @@
+import { CliArgumentError, parseOptions, readExpectedRevision, readPageSize, requirePositionals, } from "../command-line/index.js";
+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) };
+};
+const requireOption = (options, name) => {
+    const value = options.get(name);
+    if (value === undefined)
+        throw new CliArgumentError(`Option '${name}' is required.`);
+    return value;
+};
+export const readConnectionCreate = (tokens) => {
+    const parsed = parseOptions(tokens, new Set([
+        "--command-id",
+        "--executor",
+        "--max-sessions",
+        "--name",
+        "--root",
+    ]));
+    requirePositionals(parsed.positionals, 0);
+    return {
+        commandId: parsed.options.get("--command-id"),
+        configRootKind: requireOption(parsed.options, "--root"),
+        executor: requireOption(parsed.options, "--executor"),
+        name: requireOption(parsed.options, "--name"),
+        ...readSessionLimit(parsed.options.get("--max-sessions")),
+    };
+};
+export const readConnectionList = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--after", "--limit"]));
+    requirePositionals(parsed.positionals, 0);
+    const afterCursor = parsed.options.get("--after");
+    return {
+        limit: readPageSize(parsed.options.get("--limit")),
+        ...(afterCursor === undefined ? {} : { afterCursor }),
+    };
+};
+export const readConnectionTarget = (tokens) => {
+    const parsed = parseOptions(tokens, new Set());
+    requirePositionals(parsed.positionals, 1);
+    return { connectionId: parsed.positionals[0] };
+};
+export const readConnectionCapacity = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--command-id", "--expected-revision", "--max-sessions"]));
+    requirePositionals(parsed.positionals, 1);
+    return {
+        commandId: parsed.options.get("--command-id"),
+        connectionId: parsed.positionals[0],
+        expectedRevision: readExpectedRevision(parsed.options.get("--expected-revision")),
+        ...readSessionLimit(requireOption(parsed.options, "--max-sessions")),
+    };
+};
+export const readConnectionUsage = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(), new Set(["--refresh"]));
+    requirePositionals(parsed.positionals, 1);
+    return {
+        connection: parsed.positionals[0] ?? "",
+        refresh: parsed.flags.has("--refresh"),
+    };
+};
+export const readConnectionSignin = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--command-id"]), new Set(["--device-code"]));
+    requirePositionals(parsed.positionals, 1);
+    return {
+        commandId: parsed.options.get("--command-id"),
+        connection: parsed.positionals[0] ?? "",
+        flow: parsed.flags.has("--device-code")
+            ? "device-code"
+            : "browser",
+    };
+};
+export const readConnectionState = (tokens, state) => {
+    const parsed = parseOptions(tokens, new Set(["--command-id", "--expected-revision"]));
+    requirePositionals(parsed.positionals, 1);
+    return {
+        commandId: parsed.options.get("--command-id"),
+        connectionId: parsed.positionals[0],
+        expectedRevision: readExpectedRevision(parsed.options.get("--expected-revision")),
+        state,
+    };
+};
+export const readConnectionModels = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--connection"]));
+    requirePositionals(parsed.positionals, 0);
+    return { connectionId: requireOption(parsed.options, "--connection") };
+};
+//# sourceMappingURL=input.js.map

package/dist/connection/login.d.ts

@@ -0,0 +1,13 @@
+import type { Connection } from "@maiaos/sdk";
+import * as Effect from "effect/Effect";
+export declare const vendorEnvironmentChanges: (connection: Connection) => Readonly<Record<string, string | undefined>>;
+export type VendorLoginOptions = {
+    readonly deviceCode: boolean;
+};
+export declare const vendorLoginArguments: (connection: Connection, options: VendorLoginOptions) => readonly string[];
+export declare const hasLocalBrowser: (environment: Readonly<NodeJS.ProcessEnv>, platform: NodeJS.Platform) => boolean;
+export declare const localBrowserAvailable: Effect.Effect<boolean>;
+export declare const effectiveLoginOptions: (options: VendorLoginOptions, localBrowser: boolean) => VendorLoginOptions;
+export declare const headlessLoginHint: (executor: Connection["executor"]) => string;
+export declare const runVendorLogin: (connection: Connection, options: VendorLoginOptions) => Effect.Effect<number, unknown>;
+//# sourceMappingURL=login.d.ts.map

package/dist/connection/login.js

@@ -0,0 +1,69 @@
+import process from "node:process";
+import * as NodeChildProcessSpawner from "@effect/platform-node-shared/NodeChildProcessSpawner";
+import * as NodeFileSystem from "@effect/platform-node-shared/NodeFileSystem";
+import * as NodePath from "@effect/platform-node-shared/NodePath";
+import * as Config from "effect/Config";
+import * as ConfigProvider from "effect/ConfigProvider";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as ChildProcess from "effect/process/ChildProcess";
+const vendorFor = (executor) => executor === "codex-cli"
+    ? { command: "codex", loginArguments: ["login"], variable: "CODEX_HOME" }
+    : {
+        command: "claude",
+        loginArguments: ["auth", "login"],
+        variable: "CLAUDE_CONFIG_DIR",
+    };
+export const vendorEnvironmentChanges = (connection) => ({
+    [vendorFor(connection.executor).variable]: connection.configRoot.kind === "maia-managed"
+        ? connection.configRoot.path
+        : undefined,
+});
+export const vendorLoginArguments = (connection, options) => {
+    const vendor = vendorFor(connection.executor);
+    return connection.executor === "codex-cli" && options.deviceCode
+        ? [...vendor.loginArguments, "--device-auth"]
+        : vendor.loginArguments;
+};
+export const hasLocalBrowser = (environment, platform) => {
+    if (environment.SSH_CONNECTION !== undefined ||
+        environment.SSH_CLIENT !== undefined ||
+        environment.SSH_TTY !== undefined)
+        return false;
+    if (platform === "darwin" || platform === "win32")
+        return true;
+    return (environment.DISPLAY !== undefined ||
+        environment.WAYLAND_DISPLAY !== undefined);
+};
+const BROWSER_VARIABLES = [
+    "DISPLAY",
+    "SSH_CLIENT",
+    "SSH_CONNECTION",
+    "SSH_TTY",
+    "WAYLAND_DISPLAY",
+];
+export const localBrowserAvailable = Effect.forEach(BROWSER_VARIABLES, (name) => Config.option(Config.String(name)).pipe(Effect.map((value) => [name, Option.getOrUndefined(value)]))).pipe(Effect.map((entries) => hasLocalBrowser(Object.fromEntries(entries.filter(([, value]) => value !== undefined)), process.platform)), Effect.orElseSucceed(() => hasLocalBrowser({}, process.platform)), Effect.provideService(ConfigProvider.ConfigProvider, ConfigProvider.fromEnv({ preserveEmptyStrings: true })));
+export const effectiveLoginOptions = (options, localBrowser) => ({
+    deviceCode: options.deviceCode || !localBrowser,
+});
+export const headlessLoginHint = (executor) => executor === "codex-cli"
+    ? "No browser on this machine: open the link below on any device and enter the code."
+    : "No browser on this machine: open the link Claude prints on any device, sign in, then paste the code here.";
+const spawner = NodeChildProcessSpawner.layer.pipe(Layer.provide(Layer.merge(NodeFileSystem.layer, NodePath.layer)));
+export const runVendorLogin = (connection, options) => Effect.gen(function* () {
+    const localBrowser = yield* localBrowserAvailable;
+    if (!localBrowser)
+        process.stderr.write(`${headlessLoginHint(connection.executor)}\n`);
+    const handle = yield* ChildProcess.make(vendorFor(connection.executor).command, vendorLoginArguments(connection, effectiveLoginOptions(options, localBrowser)), {
+        detached: false,
+        env: vendorEnvironmentChanges(connection),
+        extendEnv: true,
+        stderr: "inherit",
+        stdin: "inherit",
+        stdout: "inherit",
+        windowsHide: false,
+    });
+    return yield* handle.exitCode.pipe(Effect.map(Number), Effect.orElseSucceed(() => 1));
+}).pipe(Effect.scoped, Effect.provide(spawner));
+//# sourceMappingURL=login.js.map

package/dist/connection/output/format.d.ts

@@ -0,0 +1,32 @@
+import type { Connection, ConnectionCapacitySetResult, ConnectionCreateResult, ConnectionGatewayCreateResult, ConnectionListResult, ConnectionLoginStartResult, ConnectionModelsListResult, ConnectionShowResult, ConnectionStateSetResult, ConnectionUsage, ConnectionUsageShowResult } from "@maiaos/sdk";
+export type ConnectionResult = ConnectionCapacitySetResult | ConnectionCreateResult | ConnectionGatewayCreateResult | ConnectionListResult | ConnectionLoginStartResult | ConnectionModelsListResult | ConnectionShowResult | ConnectionStateSetResult | ConnectionUsageShowResult;
+export type RedactedConnection = Omit<Connection, "configRoot"> & {
+    readonly configRoot: {
+        readonly kind: Connection["configRoot"]["kind"];
+    };
+};
+type RedactedSingle<TResult extends {
+    readonly connection: Connection;
+}> = Omit<TResult, "connection"> & {
+    readonly connection: RedactedConnection;
+};
+type RedactedConnectionResult = ConnectionModelsListResult | (Omit<ConnectionListResult, "items"> & {
+    readonly items: readonly RedactedConnection[];
+}) | RedactedSingle<ConnectionCapacitySetResult> | RedactedSingle<ConnectionCreateResult> | RedactedSingle<ConnectionGatewayCreateResult> | RedactedSingle<ConnectionLoginStartResult> | RedactedSingle<ConnectionShowResult> | RedactedSingle<ConnectionStateSetResult> | RedactedSingle<ConnectionUsageShowResult> | {
+    readonly connection: RedactedConnection;
+    readonly method: "connection.login";
+};
+export type CliConnectionResult = {
+    readonly command: RedactedConnectionResult["method"];
+    readonly result: RedactedConnectionResult;
+};
+export declare const redactConnection: (connection: Connection) => RedactedConnection;
+export declare const redactConnectionResult: (result: ConnectionResult) => RedactedConnectionResult;
+export declare const isConnectionResult: (result: {
+    readonly command: string;
+}) => result is CliConnectionResult;
+export declare const describeUsage: (usage: ConnectionUsage) => string;
+export declare const describeConnection: (connection: RedactedConnection) => string;
+export declare const formatConnectionResult: ({ result, }: CliConnectionResult) => string;
+export {};
+//# sourceMappingURL=format.d.ts.map

package/dist/connection/output/format.js

@@ -0,0 +1,94 @@
+import { formatRows, withNextPage } from "../../command-line/index.js";
+export const redactConnection = (connection) => ({
+    ...connection,
+    configRoot: { kind: connection.configRoot.kind },
+});
+export const redactConnectionResult = (result) => {
+    if (result.method === "connection.models.list")
+        return result;
+    return result.method === "connection.list"
+        ? { ...result, items: result.items.map(redactConnection) }
+        : { ...result, connection: redactConnection(result.connection) };
+};
+export const isConnectionResult = (result) => result.command.startsWith("connection.");
+const windowLabel = (window) => {
+    if (window.kind === "session")
+        return "5h";
+    if (window.kind !== "weekly")
+        return window.id.replaceAll("_", "-");
+    const model = window.id.replace(/^seven_day_?/u, "").replaceAll("_", " ");
+    return model === "" || window.id === "primary" || window.id === "secondary"
+        ? "week"
+        : `week ${model}`;
+};
+const resetText = (resetsAt) => resetsAt === undefined ? "" : ` resets ${resetsAt.slice(0, 16)}Z`;
+export const describeUsage = (usage) => {
+    if (usage.unavailable !== undefined)
+        return `usage unavailable: ${usage.unavailable.message ?? usage.unavailable.reason}`;
+    const windows = usage.windows.map((window) => `${windowLabel(window)} ${String(Math.round(window.usedPercent))}%${resetText(window.resetsAt)}`);
+    const credits = usage.resetCredits?.availableCount ?? 0;
+    const parts = [
+        ...(usage.account?.plan === undefined ? [] : [usage.account.plan]),
+        ...windows,
+        ...(credits > 0
+            ? [`${String(credits)} reset credit${credits === 1 ? "" : "s"}`]
+            : []),
+    ];
+    return parts.length === 0 ? "no usage windows" : parts.join(", ");
+};
+export const describeConnection = (connection) => {
+    const limited = connection.limitedUntil === null
+        ? ""
+        : ` limited-until=${connection.limitedUntil}`;
+    const usage = connection.usage === undefined
+        ? ""
+        : `\n  ${describeUsage(connection.usage)}`;
+    const gateway = connection.gateway === undefined
+        ? ""
+        : ` gateway=${connection.gateway.baseUrl}`;
+    return `${connection.connectionId} ${connection.name} ${connection.executor} ${connection.state} sessions<=${String(connection.maxConcurrentSessions)} revision=${connection.revision} root=${connection.configRoot.kind}${gateway}${limited}${usage}`;
+};
+const describeLogin = (login) => login.authUrl === undefined
+    ? `Open ${login.verificationUrl ?? ""} and enter ${login.userCode ?? ""} before ${login.expiresAt}.`
+    : `Open ${login.authUrl} before ${login.expiresAt}.`;
+const describeModels = (result) => {
+    const lines = result.models.map((model) => model.displayName === undefined
+        ? model.id
+        : `${model.id}  ${model.displayName}`);
+    const notes = [
+        ...(result.truncated ? ["the gateway listed more models"] : []),
+        ...(result.omitted > 0
+            ? [`${String(result.omitted)} entries without a usable id`]
+            : []),
+    ];
+    return `${[
+        ...(lines.length === 0 ? ["No models."] : lines),
+        ...(notes.length === 0 ? [] : [`(${notes.join("; ")})`]),
+    ].join("\n")}\n`;
+};
+const prefixFor = (method) => {
+    return method === "connection.login" ? "Signed in: " : "";
+};
+const formatConnectionList = (result) => withNextPage(formatRows(result.items, (connection) => `${connection.connectionId}\t${connection.name}\t${connection.executor}\t${connection.state}\t${String(connection.maxConcurrentSessions)}\t${connection.limitedUntil ?? "-"}`, {
+    empty: "No connections.",
+    headers: [
+        "CONNECTION",
+        "NAME",
+        "EXECUTOR",
+        "STATE",
+        "SESSIONS",
+        "LIMITED UNTIL",
+    ],
+}), result.nextCursor);
+export const formatConnectionResult = ({ result, }) => {
+    if (result.method === "connection.models.list")
+        return describeModels(result);
+    if (result.method === "connection.list")
+        return formatConnectionList(result);
+    const prefix = prefixFor(result.method);
+    const login = result.method === "connection.login.start"
+        ? `\n${describeLogin(result.login)}`
+        : "";
+    return `${prefix}${describeConnection(result.connection)}${login}\n`;
+};
+//# sourceMappingURL=format.js.map

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

@@ -0,0 +1,2 @@
+export { type CliConnectionResult, type ConnectionResult, describeConnection, formatConnectionResult, isConnectionResult, redactConnection, redactConnectionResult, type RedactedConnection, } from "./format.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/connection/output/index.js

@@ -0,0 +1,2 @@
+export { describeConnection, formatConnectionResult, isConnectionResult, redactConnection, redactConnectionResult, } from "./format.js";
+//# sourceMappingURL=index.js.map

package/dist/connection/resolve.d.ts

@@ -0,0 +1,60 @@
+import type { ProtocolError } from "@maiaos/sdk";
+import { Effect } from "effect";
+import type { CliServices, CommandContext } from "../command-line/index.js";
+import type { CliNodeEffect } from "../local-node/index.js";
+declare const ConnectionNodeError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ConnectionNodeError";
+} & Readonly<A>;
+export declare class ConnectionNodeError extends ConnectionNodeError_base<{
+    readonly error: ProtocolError;
+    readonly message: string;
+}> {
+    constructor(error: ProtocolError);
+}
+export declare const callNode: <TOperation, TValue>(operation: TOperation | undefined, run: (operation: TOperation) => CliNodeEffect<TValue>) => Effect.Effect<TValue, ConnectionNodeError | Error, CliServices>;
+export declare const findConnectionByName: (context: CommandContext, name: string) => Effect.Effect<{
+    readonly configRoot: {
+        readonly kind: "maia-managed";
+        readonly path: string;
+    } | {
+        readonly kind: "system-default";
+    };
+    readonly connectionId: string;
+    readonly createdAt: string;
+    readonly executor: "claude-code" | "codex-cli" | "gateway";
+    readonly gateway?: {
+        readonly baseUrl: string;
+    } | undefined;
+    readonly limitedUntil: string | null;
+    readonly maxConcurrentSessions: number;
+    readonly name: string;
+    readonly revision: string;
+    readonly schemaVersion: "maia.connection/v1";
+    readonly state: "disabled" | "enabled";
+    readonly updatedAt: string;
+    readonly usage?: {
+        readonly account?: {
+            readonly email?: string | undefined;
+            readonly plan?: string | undefined;
+        } | undefined;
+        readonly checkedAt: string;
+        readonly resetCredits?: {
+            readonly availableCount: number;
+            readonly nextCreditId?: string | undefined;
+            readonly nextExpiresAt?: string | undefined;
+        } | undefined;
+        readonly unavailable?: {
+            readonly message?: string | undefined;
+            readonly reason: "probe_failed" | "signed_out" | "unsupported";
+        } | undefined;
+        readonly windows: readonly {
+            readonly id: string;
+            readonly kind: "other" | "session" | "weekly";
+            readonly resetsAt?: string | undefined;
+            readonly usedPercent: number;
+            readonly windowMinutes?: number | undefined;
+        }[];
+    } | undefined;
+} | undefined, ConnectionNodeError | Error, import("effect/Crypto").Crypto>;
+export {};
+//# sourceMappingURL=resolve.d.ts.map

package/dist/connection/resolve.js

@@ -0,0 +1,30 @@
+import { Data, Effect } from "effect";
+const PAGE_SIZE = 100;
+const MAXIMUM_PAGES = 10;
+export class ConnectionNodeError extends Data.TaggedError("ConnectionNodeError") {
+    constructor(error) {
+        super({ error, message: error.message });
+    }
+}
+export const callNode = (operation, run) => operation === undefined
+    ? Effect.fail(new Error("Missing connection client."))
+    : run(operation).pipe(Effect.flatMap((result) => result.ok
+        ? Effect.succeed(result.value)
+        : Effect.fail(new ConnectionNodeError(result.error))));
+const searchPage = (context, { afterCursor, name, page }) => callNode(context.dependencies.listConnections, (list) => list({
+    limit: PAGE_SIZE,
+    ...(afterCursor === undefined ? {} : { afterCursor }),
+})).pipe(Effect.flatMap((result) => {
+    const found = result.items.find((item) => item.name === name);
+    if (found !== undefined || result.nextCursor === undefined)
+        return Effect.succeed(found);
+    return page + 1 >= MAXIMUM_PAGES
+        ? Effect.succeed(found)
+        : searchPage(context, {
+            afterCursor: result.nextCursor,
+            name,
+            page: page + 1,
+        });
+}));
+export const findConnectionByName = (context, name) => searchPage(context, { name, page: 0 });
+//# sourceMappingURL=resolve.js.map

package/dist/connection/signin.d.ts

@@ -0,0 +1,4 @@
+import { Effect } from "effect";
+import { CliArgumentError, type CommandContext } from "../command-line/index.js";
+export declare const signInThroughNode: (tokens: readonly string[], context: CommandContext) => Effect.Effect<number, CliArgumentError | Error, import("effect/Crypto").Crypto>;
+//# sourceMappingURL=signin.d.ts.map