@maiaos/cli 0.1.0-canary.2

package/dist/login/agent-provider.js

@@ -0,0 +1,109 @@
+import { Effect } from "effect";
+import { CliArgumentError, recoverStdin, } from "../command-line/index.js";
+import { safeLoginError } from "./failure.js";
+const defaultAccess = {
+    list: () => Effect.tryPromise({
+        catch: (error) => error,
+        try: () => import("@maiaos/agent").then((agent) => agent.listMaiaAgentProviders()),
+    }),
+    login: (input) => Effect.tryPromise({
+        catch: (error) => error,
+        try: () => import("@maiaos/agent").then((agent) => agent.loginMaiaAgentProvider(input)),
+    }),
+};
+const access = (context) => context.dependencies.agentProviders ?? defaultAccess;
+const isSafeError = (error) => error instanceof CliArgumentError ||
+    (error instanceof Error && error.name === "MaiaLoginError");
+const safely = (failure) => (error) => isSafeError(error) ? error : safeLoginError(failure);
+const safeEffect = (effect, failure) => Effect.mapError(effect, safely(failure));
+export const listAgentProviders = (context) => safeEffect(access(context).list(), "Maia could not read the Maia agent's model providers.");
+const authLabel = (type) => type === "oauth" ? "subscription" : "API key";
+const cancelled = () => new CliArgumentError("Sign-in cancelled.");
+const chosen = (question, answer) => {
+    const choices = question.choices ?? [];
+    if (choices.length === 0)
+        return Effect.succeed(answer);
+    const choice = choices[Number(answer) - 1] ?? choices.find((item) => item.id === answer);
+    return choice === undefined
+        ? Effect.fail(new CliArgumentError(`Choose a number from 1 to ${String(choices.length)}.`))
+        : Effect.succeed(choice.id);
+};
+const promptAnswer = (context, question) => context.io.prompt?.(`${question.message} `, {
+    secret: question.secret,
+    ...(question.signal === undefined ? {} : { signal: question.signal }),
+}) ?? Effect.undefined;
+const askTerminal = (context, question) => Effect.gen(function* () {
+    context.io.stderr((question.choices ?? [])
+        .map((choice, index) => `  ${String(index + 1)}) ${choice.label}\n`)
+        .join(""));
+    const answer = yield* promptAnswer(context, question);
+    if (answer === undefined)
+        return yield* cancelled();
+    return yield* chosen(question, answer);
+});
+const terminalInteraction = (context) => ({
+    ask: (question) => Effect.runPromise(askTerminal(context, question)),
+    show: (text) => {
+        context.io.stderr(`${text}\n`);
+    },
+});
+const keyInteraction = (context, input) => ({
+    ask: (question) => question.secret
+        ? Promise.resolve(input.key)
+        : Promise.reject(new CliArgumentError(`'${input.providerId}' needs more than an API key: run 'maia login ${input.providerId}' at a terminal.`)),
+    show: (text) => {
+        context.io.stderr(`${text}\n`);
+    },
+});
+const findProvider = (providers, providerId) => {
+    const provider = providers.find((item) => item.id === providerId);
+    return provider === undefined
+        ? Effect.fail(new CliArgumentError(`Unknown login target '${providerId}'. Use claude, codex or a model provider; 'maia login' lists them.`))
+        : Effect.succeed(provider);
+};
+const askAuthType = (context, provider) => safeEffect(askTerminal(context, {
+    choices: provider.authTypes.map((type) => ({
+        id: type,
+        label: authLabel(type),
+    })),
+    message: `Sign ${provider.name} in with:`,
+    secret: false,
+}), "Sign-in cancelled.").pipe(Effect.map((answer) => (answer === "oauth" ? "oauth" : "api_key")));
+const stdinRefusal = (provider) => new CliArgumentError(`${provider.name} ${provider.stored === "oauth" ? "is signed in with a subscription" : "signs in with a subscription"}: run 'maia login ${provider.id}' at a terminal.`);
+const authTypeFor = (context, provider, keyFromStdin) => {
+    if (keyFromStdin)
+        return provider.authTypes.includes("api_key") && provider.stored !== "oauth"
+            ? Effect.succeed("api_key")
+            : Effect.fail(stdinRefusal(provider));
+    if (provider.stored !== undefined)
+        context.io.stderr(`This replaces the stored ${authLabel(provider.stored)} for ${provider.name}.\n`);
+    const [only, other] = provider.authTypes;
+    return only !== undefined && other === undefined
+        ? Effect.succeed(only)
+        : askAuthType(context, provider);
+};
+const readKey = (context) => {
+    const stdin = context.io.stdin;
+    return stdin === undefined
+        ? Effect.fail(new CliArgumentError("Standard input is unavailable."))
+        : recoverStdin(stdin({ label: "API key", maxBytes: 8 * 1024, maxChunks: 8 }), safely("Maia could not read the key from standard input."));
+};
+const interactionFor = (context, input) => input.keyFromStdin
+    ? readKey(context).pipe(Effect.map((key) => keyInteraction(context, { key, providerId: input.providerId })))
+    : Effect.succeed(terminalInteraction(context));
+const refuseWithoutTerminal = (provider) => Effect.fail(new CliArgumentError(`${provider.name} signs in at a terminal: run 'maia login ${provider.id}' in one, or pass an API key with --api-key-stdin.`));
+export const signInAgentProvider = (context, input) => Effect.gen(function* () {
+    const providers = yield* listAgentProviders(context);
+    const provider = yield* findProvider(providers, input.providerId);
+    if (!input.keyFromStdin && !input.atTerminal)
+        return yield* refuseWithoutTerminal(provider);
+    const authType = yield* authTypeFor(context, provider, input.keyFromStdin);
+    const interaction = yield* interactionFor(context, input);
+    yield* safeEffect(access(context).login({
+        authType,
+        interaction,
+        providerId: provider.id,
+    }), `The ${provider.name} sign-in did not complete.`);
+    return provider;
+});
+//# sourceMappingURL=agent-provider.js.map

package/dist/login/commands.d.ts

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

package/dist/login/commands.js

@@ -0,0 +1,93 @@
+import { Effect } from "effect";
+import { CliArgumentError, parseOptions, reportError, requirePositionals, unknownCommand, writeSuccess, } from "../command-line/index.js";
+import { callNode, ConnectionNodeError, redactConnection, } from "../connection/index.js";
+import { listAgentProviders, signInAgentProvider } from "./agent-provider.js";
+import { loginFailureMessage } from "./failure.js";
+import { gatewayLogin } from "./gateway.js";
+import { runLoginMenu } from "./menu.js";
+import { formatLoginList } from "./output/index.js";
+import { signInHere, signInThroughNode, writeSignedIn, } from "./vendor-account.js";
+import { readVendorLogin } from "./vendor-input.js";
+const atTerminal = (context) => context.io.interactive === true && !context.json;
+const parsed = (read) => Effect.try({
+    catch: (error) => error instanceof CliArgumentError
+        ? error
+        : new CliArgumentError("Invalid login input."),
+    try: read,
+});
+const listLogins = (context) => Effect.all([
+    callNode(context.dependencies.listConnections, (list) => list({ limit: 100 })),
+    listAgentProviders(context),
+]).pipe(Effect.map(([accounts, providers]) => {
+    writeSuccess({
+        accounts: accounts.items.map(redactConnection),
+        agentProviders: providers.filter((item) => item.stored !== undefined),
+        availableProviders: providers
+            .filter((item) => item.stored === undefined)
+            .map((item) => item.id),
+        command: "login.list",
+    }, context, formatLoginList);
+    return 0;
+}));
+const readAgentVendorLogin = (tokens, context) => {
+    const input = readVendorLogin(tokens);
+    if (!atTerminal(context) && input.name === undefined)
+        throw new CliArgumentError("Pass --name: without a terminal, running the command again must reach the same account.");
+    return input;
+};
+const vendorLogin = (tokens, context) => parsed(() => readAgentVendorLogin(tokens, context)).pipe(Effect.flatMap((input) => atTerminal(context)
+    ? signInHere(context, input).pipe(Effect.map((connection) => writeSignedIn(context, connection)))
+    : signInThroughNode(context, input)));
+const readProviderLogin = (tokens, context) => {
+    const options = parseOptions(tokens, new Set(), new Set(["--api-key-stdin"]));
+    requirePositionals(options.positionals, 1);
+    if (context.profile !== undefined)
+        throw new CliArgumentError("Model providers belong to the Maia agent, not a Node profile: run without --profile.");
+    return {
+        keyFromStdin: options.flags.has("--api-key-stdin"),
+        providerId: options.positionals[0] ?? "",
+    };
+};
+const providerLogin = (tokens, context) => parsed(() => readProviderLogin(tokens, context)).pipe(Effect.flatMap((input) => signInAgentProvider(context, {
+    ...input,
+    atTerminal: atTerminal(context),
+})), Effect.map((provider) => {
+    writeSuccess({ command: "login", providerId: provider.id }, context, ({ providerId }) => `${providerId} stored in Maia auth.json\n`);
+    return 0;
+}));
+const loginTarget = (tokens) => parseOptions(tokens, new Set(["--base-url", "--command-id", "--max-sessions", "--name"]), new Set(["--api-key-stdin", "--device-code"])).positionals[0];
+const remoteLoginRefusal = (target, context) => context.node === undefined ||
+    target === "claude" ||
+    target === "codex" ||
+    target === "gateway"
+    ? undefined
+    : new CliArgumentError("With --node, name the account to sign in there: maia --node <name> login <claude|codex|gateway>.");
+const login = (tokens, context) => {
+    const target = tokens.length === 0 ? undefined : loginTarget(tokens);
+    const refusal = remoteLoginRefusal(target, context);
+    if (refusal !== undefined)
+        return Effect.fail(refusal);
+    if (target === undefined && tokens.length > 0)
+        return Effect.fail(unknownCommand());
+    if (target === undefined)
+        return atTerminal(context) ? runLoginMenu(context) : listLogins(context);
+    if (target === "gateway")
+        return gatewayLogin(tokens, context);
+    return target === "claude" || target === "codex"
+        ? vendorLogin(tokens, context)
+        : providerLogin(tokens, 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: loginFailureMessage(error),
+        retryable: false,
+    }, context);
+};
+export const runLogin = (tokens, context) => login(tokens, context).pipe(Effect.catch((error) => Effect.sync(() => reportFailure(error, context))));
+export const runLoginGateway = (tokens, context) => runLogin(["gateway", ...tokens], context);
+//# sourceMappingURL=commands.js.map

package/dist/login/failure.d.ts

@@ -0,0 +1,3 @@
+export declare const safeLoginError: (message: string) => Error;
+export declare const loginFailureMessage: (error: unknown) => string;
+//# sourceMappingURL=failure.d.ts.map

package/dist/login/failure.js

@@ -0,0 +1,14 @@
+import { CliArgumentError } from "../command-line/index.js";
+import { ConnectionNodeError } from "../connection/index.js";
+const SAFE_ERROR_NAME = "MaiaLoginError";
+export const safeLoginError = (message) => Object.assign(new Error(message), { name: SAFE_ERROR_NAME });
+export const loginFailureMessage = (error) => {
+    if (error instanceof ConnectionNodeError)
+        return error.error.message;
+    if (error instanceof CliArgumentError)
+        return error.message;
+    return error instanceof Error && error.name === SAFE_ERROR_NAME
+        ? error.message
+        : "The sign-in did not complete.";
+};
+//# sourceMappingURL=failure.js.map

package/dist/login/gateway.d.ts

@@ -0,0 +1,12 @@
+import { Effect } from "effect";
+import { type CommandContext } from "../command-line/index.js";
+type GatewayLoginInput = {
+    readonly baseUrl: string;
+    readonly commandId?: string;
+    readonly maxConcurrentSessions?: number;
+    readonly name: string;
+};
+export declare const readGatewayLogin: (tokens: readonly string[]) => GatewayLoginInput;
+export declare const gatewayLogin: (tokens: readonly string[], context: CommandContext) => Effect.Effect<number, unknown, import("effect/Crypto").Crypto>;
+export {};
+//# sourceMappingURL=gateway.d.ts.map

package/dist/login/gateway.js

@@ -0,0 +1,71 @@
+import { connectionGatewayCreateParametersSchema, } from "@maiaos/sdk";
+import { Effect } from "effect";
+import { CliArgumentError, missingArgument, parseOptions, recoverStdin, requirePositionals, writeSuccess, } from "../command-line/index.js";
+import { callNode, ConnectionNodeError, formatConnectionResult, redactConnectionResult, } from "../connection/index.js";
+import { newCliIdentifier } from "../local-node/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) };
+};
+export const readGatewayLogin = (tokens) => {
+    const parsed = parseOptions(tokens, new Set(["--base-url", "--command-id", "--max-sessions", "--name"]), new Set(["--api-key-stdin"]));
+    requirePositionals(parsed.positionals, 1);
+    const commandId = parsed.options.get("--command-id");
+    const name = parsed.options.get("--name");
+    const baseUrl = parsed.options.get("--base-url");
+    if (parsed.positionals[0] !== "gateway" ||
+        name === undefined ||
+        baseUrl === undefined ||
+        !parsed.flags.has("--api-key-stdin"))
+        throw missingArgument();
+    if (/\/v1\/?$/u.test(baseUrl))
+        throw new CliArgumentError("Leave '/v1' out of '--base-url'; Maia adds it for each request.");
+    return {
+        baseUrl,
+        ...(commandId === undefined ? {} : { commandId }),
+        name,
+        ...readSessionLimit(parsed.options.get("--max-sessions")),
+    };
+};
+const INVALID_GATEWAY = "Invalid gateway: '--base-url' must be https, or http to a loopback host, without credentials, query, fragment, trailing slash or '/v1'; '--name' uses lower-case letters, digits and dashes; the key is one line of 8 to 4096 printable characters.";
+const readKey = (context) => {
+    const stdin = context.io.stdin;
+    return stdin === undefined
+        ? Effect.fail(new CliArgumentError("Standard input is unavailable."))
+        : recoverStdin(stdin({ label: "API key", maxBytes: 8 * 1024, maxChunks: 8 }), () => new CliArgumentError("Maia could not read the key from standard input."));
+};
+const gatewayParameters = (input, apiKey) => (input.commandId === undefined
+    ? newCliIdentifier("command")
+    : Effect.succeed(input.commandId)).pipe(Effect.flatMap((commandId) => {
+    const parameters = connectionGatewayCreateParametersSchema.safeParse({
+        ...input,
+        apiKey: apiKey.trim(),
+        commandId,
+    });
+    return parameters.success
+        ? Effect.succeed(parameters.data)
+        : Effect.fail(new CliArgumentError(INVALID_GATEWAY));
+}));
+const readInput = (tokens) => Effect.try({
+    catch: (error) => error instanceof CliArgumentError
+        ? error
+        : new CliArgumentError("Invalid login input."),
+    try: () => readGatewayLogin(tokens),
+});
+const withRetryHint = (error, commandId) => error instanceof ConnectionNodeError && error.error.code === "storage_failed"
+    ? new ConnectionNodeError({
+        ...error.error,
+        message: `${error.error.message} Retry: the same command with --command-id ${commandId}.`,
+    })
+    : error;
+const createGateway = (context, parameters) => callNode(context.dependencies.createGatewayConnection, (create) => create(parameters)).pipe(Effect.mapError((error) => withRetryHint(error, parameters.commandId)));
+export const gatewayLogin = (tokens, context) => readInput(tokens).pipe(Effect.flatMap((input) => readKey(context).pipe(Effect.flatMap((key) => gatewayParameters(input, key)))), Effect.flatMap((parameters) => createGateway(context, parameters)), Effect.map((result) => {
+    if (result.keyCustody === "kept" && !context.json)
+        context.io.stderr("The gateway already had a key; it keeps that key and ignored the one on stdin.\n");
+    writeSuccess({ command: result.method, result: redactConnectionResult(result) }, context, formatConnectionResult);
+    return 0;
+}));
+//# sourceMappingURL=gateway.js.map

package/dist/login/index.d.ts

@@ -0,0 +1,3 @@
+export { type AgentProviderAccess } from "./agent-provider.js";
+export { runLogin, runLoginGateway } from "./commands.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/login/index.js

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

package/dist/login/menu.d.ts

@@ -0,0 +1,4 @@
+import { Effect } from "effect";
+import { type CommandContext } from "../command-line/index.js";
+export declare const runLoginMenu: (context: CommandContext) => Effect.Effect<number, unknown, import("effect/Crypto").Crypto>;
+//# sourceMappingURL=menu.d.ts.map

package/dist/login/menu.js

@@ -0,0 +1,105 @@
+import { Effect } from "effect";
+import { CliArgumentError, } from "../command-line/index.js";
+import { callNode, describeConnection, redactConnection, } from "../connection/index.js";
+import { listAgentProviders, signInAgentProvider } from "./agent-provider.js";
+import { loginFailureMessage } from "./failure.js";
+import { describeAgentProvider, formatAccounts, formatSignedInProviders, } from "./output/index.js";
+import { signInHere } from "./vendor-account.js";
+import { nextFreeName, vendorExecutor, } from "./vendor-input.js";
+const MENU = [
+    "",
+    "  1) Add a Codex account",
+    "  2) Add a Claude Code account",
+    "  3) Sign a worker account in again",
+    "  4) Sign the Maia agent in to a model provider",
+    "  q) Quit",
+    "",
+].join("\n");
+const say = (context, text) => Effect.sync(() => {
+    context.io.stderr(`${text}\n`);
+});
+const ask = (context, question) => {
+    const prompt = context.io.prompt;
+    return prompt === undefined
+        ? Effect.fail(new CliArgumentError("Sign-in cancelled."))
+        : prompt(question).pipe(Effect.flatMap((answer) => answer === undefined
+            ? Effect.fail(new CliArgumentError("Sign-in cancelled."))
+            : Effect.succeed(answer)));
+};
+const listAccounts = (context) => callNode(context.dependencies.listConnections, (list) => list({ limit: 100 })).pipe(Effect.map((result) => ({
+    accounts: result.items,
+})), Effect.catch((error) => say(context, `Worker accounts are unavailable: ${loginFailureMessage(error)}`).pipe(Effect.as({}))));
+const showLogins = (context, logins) => Effect.sync(() => {
+    const accounts = logins.accounts === undefined
+        ? ""
+        : formatAccounts(logins.accounts.map(redactConnection));
+    context.io.stderr(`${accounts}${formatSignedInProviders(logins.providers)}`);
+});
+const askName = (context, vendor, accounts) => {
+    const proposal = nextFreeName(vendor, new Set(accounts.map((account) => account.name)));
+    return ask(context, `Name [${proposal}]: `).pipe(Effect.map((answer) => (answer === "" ? proposal : answer)));
+};
+const addAccount = (context, vendor, accounts) => askName(context, vendor, accounts).pipe(Effect.flatMap((name) => {
+    const executor = vendorExecutor(vendor);
+    return executor === undefined
+        ? Effect.void
+        : signInHere(context, {
+            deviceCode: false,
+            executor,
+            name,
+            vendor,
+        }).pipe(Effect.flatMap((connection) => say(context, `Signed in: ${describeConnection(redactConnection(connection))}`)));
+}));
+const signInAgain = (context, accounts) => ask(context, "Account name: ").pipe(Effect.flatMap((name) => {
+    const account = accounts.find((item) => item.name === name);
+    if (account === undefined)
+        return say(context, `No account is named '${name}'.`);
+    if (account.executor === "gateway")
+        return say(context, `'${name}' is a gateway; it signs in with its API key, not a vendor login.`);
+    const vendor = account.executor === "codex-cli" ? "codex" : "claude";
+    return signInHere(context, {
+        deviceCode: false,
+        executor: account.executor,
+        name: account.name,
+        vendor,
+    }).pipe(Effect.asVoid);
+}));
+const signInProvider = (context, providers) => say(context, providers
+    .map((provider, index) => `  ${String(index + 1)}) ${describeAgentProvider(provider)}`)
+    .join("\n")).pipe(Effect.andThen(ask(context, "Provider (number or id): ")), Effect.flatMap((answer) => {
+    const providerId = providers[Number(answer) - 1]?.id ?? answer;
+    return providerId === ""
+        ? Effect.void
+        : signInAgentProvider(context, {
+            atTerminal: true,
+            keyFromStdin: false,
+            providerId,
+        }).pipe(Effect.flatMap((provider) => say(context, `The Maia agent is signed in to ${provider.name}.`)));
+}));
+const choose = (context, choice, logins) => {
+    const accounts = logins.accounts ?? [];
+    if (choice === "1")
+        return addAccount(context, "codex", accounts);
+    if (choice === "2")
+        return addAccount(context, "claude", accounts);
+    if (choice === "3")
+        return signInAgain(context, accounts);
+    return choice === "4"
+        ? signInProvider(context, logins.providers)
+        : say(context, "Choose 1, 2, 3, 4 or q.");
+};
+const round = (context) => Effect.gen(function* () {
+    const logins = {
+        ...(yield* listAccounts(context)),
+        providers: yield* listAgentProviders(context),
+    };
+    yield* showLogins(context, logins);
+    yield* say(context, MENU);
+    const choice = yield* ask(context, "> ").pipe(Effect.orElseSucceed(() => "q"));
+    if (choice === "q" || choice === "")
+        return 0;
+    yield* choose(context, choice, logins).pipe(Effect.catch((error) => say(context, loginFailureMessage(error))));
+    return yield* round(context);
+});
+export const runLoginMenu = (context) => round(context);
+//# sourceMappingURL=menu.js.map

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

@@ -0,0 +1,16 @@
+import type { MaiaAgentProvider } from "@maiaos/agent";
+import { type RedactedConnection } from "../../connection/output/index.js";
+export type CliLoginListResult = {
+    readonly accounts: readonly RedactedConnection[];
+    readonly agentProviders: readonly MaiaAgentProvider[];
+    readonly availableProviders: readonly string[];
+    readonly command: "login.list";
+};
+export declare const isLoginListResult: (result: {
+    readonly command: string;
+}) => result is CliLoginListResult;
+export declare const describeAgentProvider: (provider: MaiaAgentProvider) => string;
+export declare const formatAccounts: (accounts: readonly RedactedConnection[]) => string;
+export declare const formatSignedInProviders: (providers: readonly MaiaAgentProvider[]) => string;
+export declare const formatLoginList: (result: CliLoginListResult) => string;
+//# sourceMappingURL=format.d.ts.map

package/dist/login/output/format.js

@@ -0,0 +1,31 @@
+import { describeConnection, } from "../../connection/output/index.js";
+export const isLoginListResult = (result) => result.command === "login.list";
+const authLabel = (type) => type === "oauth" ? "subscription" : "API key";
+export const describeAgentProvider = (provider) => [
+    `${provider.name} (${provider.id})`,
+    provider.authTypes.map(authLabel).join(" or "),
+    ...(provider.stored === undefined
+        ? []
+        : [`signed in with ${authLabel(provider.stored)}`]),
+].join("  ");
+export const formatAccounts = (accounts) => accounts.length === 0
+    ? "Worker accounts: none yet.\n"
+    : `Worker accounts (Maia Node)\n${accounts
+        .map((account) => `  ${describeConnection(account)}\n`)
+        .join("")}`;
+export const formatSignedInProviders = (providers) => {
+    const signedIn = providers.filter((item) => item.stored !== undefined);
+    return signedIn.length === 0
+        ? "Maia agent model providers: none signed in.\n"
+        : `Maia agent model providers (one credential each)\n${signedIn
+            .map((provider) => `  ${describeAgentProvider(provider)}\n`)
+            .join("")}`;
+};
+export const formatLoginList = (result) => [
+    formatAccounts(result.accounts),
+    formatSignedInProviders(result.agentProviders),
+    result.availableProviders.length === 0
+        ? ""
+        : `Other model providers: ${result.availableProviders.join(", ")}\n`,
+].join("");
+//# sourceMappingURL=format.js.map

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

@@ -0,0 +1,2 @@
+export { type CliLoginListResult, describeAgentProvider, formatAccounts, formatLoginList, formatSignedInProviders, isLoginListResult, } from "./format.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/login/output/index.js

@@ -0,0 +1,2 @@
+export { describeAgentProvider, formatAccounts, formatLoginList, formatSignedInProviders, isLoginListResult, } from "./format.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,95 @@
+import type { Connection } from "@maiaos/sdk";
+import { Effect } from "effect";
+import { type CommandContext } from "../command-line/index.js";
+import { ConnectionNodeError } from "../connection/index.js";
+import { type VendorLoginInput } from "./vendor-input.js";
+export declare const signInHere: (context: CommandContext, input: VendorLoginInput) => 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;
+} | {
+    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;
+}, ConnectionNodeError | Error, import("effect/Crypto").Crypto>;
+export declare const writeSignedIn: (context: CommandContext, connection: Connection) => number;
+export declare const signInThroughNode: (context: CommandContext, input: VendorLoginInput) => Effect.Effect<number, ConnectionNodeError | Error, import("effect/Crypto").Crypto>;
+//# sourceMappingURL=vendor-account.d.ts.map