@bctrl/cli 0.1.0

package/dist/commands/space/index.js

@@ -0,0 +1,86 @@
+import { Command } from 'commander';
+import { createJsonBodyCommand, createViewCommand } from '../shared/rest.js';
+import { readJsonFile } from '../shared/io.js';
+import { addOutputFlags, outputData } from '../shared/output.js';
+import { createSpaceListCommand } from './list.js';
+export function createSpaceCommand(factory) {
+    const command = new Command('space').description('Manage BCTRL spaces');
+    command.addCommand(createSpaceListCommand(factory));
+    command.addCommand(createViewCommand(factory, {
+        description: 'View a space',
+        path: '/spaces/{id}',
+    }));
+    command.addCommand(createJsonBodyCommand(factory, {
+        name: 'create',
+        description: 'Create a space',
+        method: 'post',
+        path: '/spaces',
+        configure: (cmd) => cmd
+            .option('--name <name>', 'Space name')
+            .option('--region <region>', 'Space region')
+            .option('--subaccount-id <id>', 'Subaccount id')
+            .option('--from-file <path>', 'Read JSON request body from file, or - for stdin'),
+        body: async (_args, options) => {
+            if (typeof options.fromFile === 'string')
+                return readJsonFile(options.fromFile);
+            return {
+                name: options.name,
+                region: options.region,
+                subaccountId: options.subaccountId,
+            };
+        },
+    }));
+    command.addCommand(createJsonBodyCommand(factory, {
+        name: 'edit',
+        description: 'Edit a space',
+        method: 'patch',
+        path: '/spaces/{id}',
+        argNames: ['id'],
+        configure: (cmd) => cmd
+            .option('--name <name>', 'Space name')
+            .option('--from-file <path>', 'Read JSON request body from file, or - for stdin'),
+        body: async (_args, options) => {
+            if (typeof options.fromFile === 'string')
+                return readJsonFile(options.fromFile);
+            return { name: options.name };
+        },
+    }));
+    command.addCommand(createSpaceEnvironmentCommand(factory));
+    command.addCommand(createSpaceAgentContextCommand(factory));
+    return command;
+}
+function createSpaceEnvironmentCommand(factory) {
+    const command = new Command('env').description('Manage a space environment');
+    command.addCommand(createViewCommand(factory, {
+        name: 'get',
+        description: 'Get a space environment',
+        path: '/spaces/{id}/environment',
+    }));
+    command.addCommand(createJsonBodyCommand(factory, {
+        name: 'set',
+        description: 'Update a space environment',
+        method: 'patch',
+        path: '/spaces/{id}/environment',
+        argNames: ['id'],
+    }));
+    return command;
+}
+function createSpaceAgentContextCommand(factory) {
+    return addOutputFlags(new Command('agent-context')
+        .description('Get machine-readable context for coding agents')
+        .argument('<id>')
+        .option('--runtime <id>', 'Runtime id')
+        .option('--topic <topic>', 'Context topic')
+        .option('--detail <level>', 'Detail level'))
+        .action(async (id, options) => {
+        const client = await factory.apiClient();
+        const result = await client.get(`/spaces/${encodeURIComponent(id)}/agent-context`, {
+            query: {
+                runtimeId: options.runtime,
+                topic: options.topic,
+                detail: options.detail,
+            },
+        });
+        await outputData(factory.io, result, options);
+    });
+}

package/dist/commands/space/list.d.ts

@@ -0,0 +1,13 @@
+import { Command } from 'commander';
+import type { BctrlApiClient } from '../../api/client.js';
+import type { Factory } from '../../factory.js';
+import type { IOStreams } from '../../io/streams.js';
+import { type OutputFlags } from '../shared/output.js';
+export type SpaceListOptions = {
+    io: IOStreams;
+    apiClient: () => Promise<BctrlApiClient>;
+    limit?: number;
+    output?: OutputFlags;
+};
+export declare function createSpaceListCommand(factory: Factory, run?: (options: SpaceListOptions) => Promise<void>): Command;
+export declare function spaceListRun(options: SpaceListOptions): Promise<void>;

package/dist/commands/space/list.js

@@ -0,0 +1,25 @@
+import { Command } from 'commander';
+import { addOutputFlags, outputData } from '../shared/output.js';
+export function createSpaceListCommand(factory, run = spaceListRun) {
+    return addOutputFlags(new Command('list')
+        .description('List spaces')
+        .option('--limit <number>', 'Maximum number of spaces to return', parsePositiveInteger))
+        .action(async (options) => {
+        await run({
+            io: factory.io,
+            apiClient: factory.apiClient,
+            limit: options.limit,
+            output: options,
+        });
+    });
+}
+export async function spaceListRun(options) {
+    const client = await options.apiClient();
+    const result = await client.get('/spaces', {
+        query: {
+            limit: options.limit,
+        },
+    });
+    await outputData(options.io, result, options.output);
+}
+import { parsePositiveInteger } from '../shared/options.js';

package/dist/commands/subaccount/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+import type { Factory } from '../../factory.js';
+export declare function createSubaccountCommand(factory: Factory): Command;

package/dist/commands/subaccount/index.js

@@ -0,0 +1,162 @@
+import { Command } from 'commander';
+import { readJsonFile } from '../shared/io.js';
+import { parsePositiveInteger } from '../shared/options.js';
+import { addOutputFlags } from '../shared/output.js';
+import { createDeleteCommand, createJsonBodyCommand, createListCommand, createViewCommand, requestAndPrint, } from '../shared/rest.js';
+export function createSubaccountCommand(factory) {
+    const command = new Command('subaccount').description('Manage subaccounts, keys, limits, and usage');
+    command.addCommand(createListCommand(factory, {
+        description: 'List subaccounts',
+        path: '/subaccounts',
+        configure: (cmd) => cmd,
+    }));
+    command.addCommand(createViewCommand(factory, {
+        description: 'View a subaccount',
+        path: '/subaccounts/{id}',
+    }));
+    command.addCommand(createJsonBodyCommand(factory, {
+        name: 'create',
+        description: 'Create a subaccount',
+        method: 'post',
+        path: '/subaccounts',
+        configure: (cmd) => cmd
+            .option('--name <name>', 'Subaccount name')
+            .option('--external-id <id>', 'External id')
+            .option('--metadata-file <path>', 'Metadata JSON file')
+            .option('--from-file <path>', 'Read full JSON request body from file, or - for stdin'),
+        body: async (_args, options) => {
+            if (typeof options.fromFile === 'string')
+                return readJsonFile(options.fromFile);
+            return {
+                name: options.name,
+                externalId: options.externalId,
+                metadata: typeof options.metadataFile === 'string'
+                    ? await readJsonFile(options.metadataFile, '--metadata-file')
+                    : undefined,
+            };
+        },
+    }));
+    command.addCommand(createJsonBodyCommand(factory, {
+        name: 'edit',
+        description: 'Edit a subaccount',
+        method: 'patch',
+        path: '/subaccounts/{id}',
+        argNames: ['id'],
+        configure: (cmd) => cmd
+            .option('--name <name>', 'Subaccount name')
+            .option('--external-id <id>', 'External id')
+            .option('--metadata-file <path>', 'Metadata JSON file')
+            .option('--from-file <path>', 'Read full JSON request body from file, or - for stdin'),
+        body: async (_args, options) => {
+            if (typeof options.fromFile === 'string')
+                return readJsonFile(options.fromFile);
+            return {
+                name: options.name,
+                externalId: options.externalId,
+                metadata: typeof options.metadataFile === 'string'
+                    ? await readJsonFile(options.metadataFile, '--metadata-file')
+                    : undefined,
+            };
+        },
+    }));
+    command.addCommand(addOutputFlags(new Command('archive')
+        .description('Archive a subaccount')
+        .argument('<id>')
+        .requiredOption('-y, --yes', 'Confirm archive'))
+        .action(async (id, options) => {
+        await requestAndPrint(factory, 'post', `/subaccounts/${encodeURIComponent(id)}/archive`, {
+            output: options,
+        });
+    }));
+    command.addCommand(createSubaccountUsageCommand(factory));
+    command.addCommand(createSubaccountLimitsCommand(factory));
+    command.addCommand(createSubaccountKeyCommand(factory));
+    return command;
+}
+function createSubaccountUsageCommand(factory) {
+    return addOutputFlags(new Command('usage')
+        .description('Show subaccount usage')
+        .argument('[id]')
+        .option('-L, --limit <number>', 'Maximum number of usage records to return', parsePositiveInteger)
+        .option('--cursor <cursor>', 'Pagination cursor'))
+        .action(async (id, options) => {
+        if (id) {
+            await requestAndPrint(factory, 'get', `/subaccounts/${encodeURIComponent(id)}/usage`, {
+                output: options,
+            });
+            return;
+        }
+        await requestAndPrint(factory, 'get', '/subaccounts/usage', {
+            query: { limit: options.limit, cursor: options.cursor },
+            output: options,
+        });
+    });
+}
+function createSubaccountLimitsCommand(factory) {
+    const command = new Command('limits').description('Manage subaccount limits');
+    command.addCommand(addOutputFlags(new Command('get')
+        .description('View subaccount limits')
+        .argument('<id>'))
+        .action(async (id, options) => {
+        await requestAndPrint(factory, 'get', `/subaccounts/${encodeURIComponent(id)}/limits`, {
+            output: options,
+        });
+    }));
+    command.addCommand(createJsonBodyCommand(factory, {
+        name: 'set',
+        description: 'Update subaccount limits',
+        method: 'patch',
+        path: '/subaccounts/{id}/limits',
+        argNames: ['id'],
+        configure: (cmd) => cmd
+            .option('--max-spaces <number>', 'Maximum spaces')
+            .option('--max-active-runs <number>', 'Maximum active runs')
+            .option('--monthly-spend-micro-usd <number>', 'Monthly spend limit in micro USD')
+            .option('--from-file <path>', 'Read full JSON request body from file, or - for stdin'),
+        body: async (_args, options) => {
+            if (typeof options.fromFile === 'string')
+                return readJsonFile(options.fromFile);
+            return {
+                spaces: options.maxSpaces ? { max: Number(options.maxSpaces) } : undefined,
+                runs: options.maxActiveRuns ? { maxActive: Number(options.maxActiveRuns) } : undefined,
+                spend: options.monthlySpendMicroUsd
+                    ? { monthlyLimitMicroUsd: Number(options.monthlySpendMicroUsd) }
+                    : undefined,
+            };
+        },
+    }));
+    return command;
+}
+function createSubaccountKeyCommand(factory) {
+    const command = new Command('key').description('Manage subaccount API keys');
+    command.addCommand(addOutputFlags(new Command('list')
+        .description('List subaccount API keys')
+        .argument('<id>'))
+        .action(async (id, options) => {
+        await requestAndPrint(factory, 'get', `/subaccounts/${encodeURIComponent(id)}/api-keys`, {
+            output: options,
+        });
+    }));
+    command.addCommand(createJsonBodyCommand(factory, {
+        name: 'create',
+        description: 'Create a subaccount API key',
+        method: 'post',
+        path: '/subaccounts/{id}/api-keys',
+        argNames: ['id'],
+        configure: (cmd) => cmd
+            .option('--name <name>', 'API key name')
+            .option('--from-file <path>', 'Read full JSON request body from file, or - for stdin'),
+        body: async (_args, options) => {
+            if (typeof options.fromFile === 'string')
+                return readJsonFile(options.fromFile);
+            return { name: options.name };
+        },
+    }));
+    command.addCommand(createDeleteCommand(factory, {
+        name: 'revoke',
+        description: 'Revoke a subaccount API key',
+        path: '/subaccounts/{id}/api-keys/{keyId}',
+        argNames: ['id', 'keyId'],
+    }));
+    return command;
+}

package/dist/commands/tool/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+import type { Factory } from '../../factory.js';
+export declare function createToolCommand(factory: Factory): Command;

package/dist/commands/tool/index.js

@@ -0,0 +1,40 @@
+import { Command } from 'commander';
+import { createDeleteCommand, createJsonBodyCommand, createListCommand, createViewCommand } from '../shared/rest.js';
+export function createToolCommand(factory) {
+    const command = new Command('tool').description('Manage BCTRL tools');
+    command.addCommand(createListCommand(factory, {
+        description: 'List tools',
+        path: '/tools',
+        configure: (cmd) => cmd.option('--space <id>', 'Filter by space id'),
+        query: (options) => ({ spaceId: typeof options.space === 'string' ? options.space : undefined }),
+    }));
+    command.addCommand(createViewCommand(factory, {
+        description: 'View a tool',
+        path: '/tools/{id}',
+    }));
+    command.addCommand(createJsonBodyCommand(factory, {
+        name: 'create',
+        description: 'Create a tool',
+        method: 'post',
+        path: '/tools',
+    }));
+    command.addCommand(createJsonBodyCommand(factory, {
+        name: 'edit',
+        description: 'Edit a tool',
+        method: 'patch',
+        path: '/tools/{id}',
+        argNames: ['id'],
+    }));
+    command.addCommand(createJsonBodyCommand(factory, {
+        name: 'test',
+        description: 'Test a tool',
+        method: 'post',
+        path: '/tools/{id}/test',
+        argNames: ['id'],
+    }));
+    command.addCommand(createDeleteCommand(factory, {
+        description: 'Delete a tool',
+        path: '/tools/{id}',
+    }));
+    return command;
+}

package/dist/commands/tool-call/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+import type { Factory } from '../../factory.js';
+export declare function createToolCallCommand(factory: Factory): Command;

package/dist/commands/tool-call/index.js

@@ -0,0 +1,25 @@
+import { Command } from 'commander';
+import { createListCommand, createViewCommand } from '../shared/rest.js';
+export function createToolCallCommand(factory) {
+    const command = new Command('tool-call').description('Inspect BCTRL tool calls');
+    command.addCommand(createListCommand(factory, {
+        description: 'List tool calls',
+        path: '/tool-calls',
+        configure: (cmd) => cmd
+            .option('--tool <id>', 'Filter by tool id')
+            .option('--run <id>', 'Filter by run id')
+            .option('--invocation <id>', 'Filter by invocation id')
+            .option('--status <status>', 'Filter by status'),
+        query: (options) => ({
+            toolId: typeof options.tool === 'string' ? options.tool : undefined,
+            runId: typeof options.run === 'string' ? options.run : undefined,
+            invocationId: typeof options.invocation === 'string' ? options.invocation : undefined,
+            status: typeof options.status === 'string' ? options.status : undefined,
+        }),
+    }));
+    command.addCommand(createViewCommand(factory, {
+        description: 'View a tool call',
+        path: '/tool-calls/{id}',
+    }));
+    return command;
+}

package/dist/commands/toolset/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+import type { Factory } from '../../factory.js';
+export declare function createToolsetCommand(factory: Factory): Command;

package/dist/commands/toolset/index.js

@@ -0,0 +1,33 @@
+import { Command } from 'commander';
+import { createDeleteCommand, createJsonBodyCommand, createListCommand, createViewCommand } from '../shared/rest.js';
+export function createToolsetCommand(factory) {
+    const command = new Command('toolset').description('Manage BCTRL toolsets');
+    command.addCommand(createListCommand(factory, {
+        description: 'List toolsets',
+        path: '/toolsets',
+        configure: (cmd) => cmd.option('--space <id>', 'Filter by space id'),
+        query: (options) => ({ spaceId: typeof options.space === 'string' ? options.space : undefined }),
+    }));
+    command.addCommand(createViewCommand(factory, {
+        description: 'View a toolset',
+        path: '/toolsets/{id}',
+    }));
+    command.addCommand(createJsonBodyCommand(factory, {
+        name: 'create',
+        description: 'Create a toolset',
+        method: 'post',
+        path: '/toolsets',
+    }));
+    command.addCommand(createJsonBodyCommand(factory, {
+        name: 'edit',
+        description: 'Edit a toolset',
+        method: 'patch',
+        path: '/toolsets/{id}',
+        argNames: ['id'],
+    }));
+    command.addCommand(createDeleteCommand(factory, {
+        description: 'Delete a toolset',
+        path: '/toolsets/{id}',
+    }));
+    return command;
+}

package/dist/commands/vault/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+import type { Factory } from '../../factory.js';
+export declare function createVaultCommand(factory: Factory): Command;

package/dist/commands/vault/index.js

@@ -0,0 +1,96 @@
+import { Command } from 'commander';
+import { CliError } from '../../runtime/errors.js';
+import { readJsonFile, readText } from '../shared/io.js';
+import { parsePositiveInteger } from '../shared/options.js';
+import { addOutputFlags } from '../shared/output.js';
+import { createDeleteCommand, createJsonBodyCommand, createListCommand, createViewCommand, requestAndPrint, } from '../shared/rest.js';
+export function createVaultCommand(factory) {
+    const command = new Command('vault').description('Manage vault secrets and TOTP codes');
+    command.addCommand(createListCommand(factory, {
+        description: 'List vault secret metadata',
+        path: '/vault/secrets',
+        configure: (cmd) => cmd
+            .option('--prefix <prefix>', 'Filter by secret id prefix')
+            .option('--origin <origin>', 'Filter by origin')
+            .option('--has-totp', 'Only show secrets with TOTP')
+            .option('-L, --limit <number>', 'Maximum number of results to return', parsePositiveInteger),
+        query: (options) => ({
+            prefix: typeof options.prefix === 'string' ? options.prefix : undefined,
+            origin: typeof options.origin === 'string' ? options.origin : undefined,
+            hasTotp: options.hasTotp === true ? true : undefined,
+            limit: typeof options.limit === 'number' ? options.limit : undefined,
+        }),
+    }));
+    command.addCommand(createViewCommand(factory, {
+        description: 'View vault secret metadata',
+        path: '/vault/secrets/{id}',
+    }));
+    command.addCommand(createVaultReadCommand(factory));
+    command.addCommand(createVaultSetCommand(factory));
+    command.addCommand(createDeleteCommand(factory, {
+        description: 'Delete a vault secret',
+        path: '/vault/secrets/{id}',
+    }));
+    command.addCommand(createVaultTotpCommand(factory));
+    return command;
+}
+function createVaultReadCommand(factory) {
+    return addOutputFlags(new Command('read')
+        .description('Read a vault secret value')
+        .argument('<id>')
+        .option('--reveal', 'Allow printing a secret to an interactive terminal'))
+        .action(async (id, options) => {
+        if (factory.io.isStdoutTTY() && options.reveal !== true) {
+            throw new CliError('Refusing to print a secret to a terminal without --reveal');
+        }
+        await requestAndPrint(factory, 'get', `/vault/secrets/${encodeURIComponent(id)}/value`, {
+            output: options,
+        });
+    });
+}
+function createVaultSetCommand(factory) {
+    return createJsonBodyCommand(factory, {
+        name: 'set',
+        description: 'Create or replace a vault secret',
+        method: 'put',
+        path: '/vault/secrets',
+        argNames: ['id'],
+        configure: (cmd) => cmd
+            .option('--username <value>', 'Credential username')
+            .option('--password <value>', 'Credential password')
+            .option('--password-from-file <path>', 'Read password from file, or - for stdin')
+            .option('--totp <secret>', 'TOTP seed')
+            .option('--label <label>', 'Display label')
+            .option('--origin <origin...>', 'Allowed origin')
+            .option('--origin-pattern <pattern...>', 'Allowed origin pattern')
+            .option('--from-file <path>', 'Read full JSON request body from file, or - for stdin'),
+        body: async (args, options) => {
+            if (typeof options.fromFile === 'string')
+                return readJsonFile(options.fromFile);
+            const password = typeof options.passwordFromFile === 'string'
+                ? (await readText(options.passwordFromFile)).trimEnd()
+                : options.password;
+            return {
+                id: args.id,
+                value: {
+                    username: options.username,
+                    password,
+                    totp: options.totp,
+                },
+                metadata: {
+                    label: options.label,
+                    origins: options.origin,
+                    originPatterns: options.originPattern,
+                },
+            };
+        },
+    });
+}
+function createVaultTotpCommand(factory) {
+    return addOutputFlags(new Command('totp')
+        .description('Generate the current TOTP code for a vault secret')
+        .argument('<id>'))
+        .action(async (id, options) => {
+        await requestAndPrint(factory, 'post', '/vault/totp', { body: { id }, output: options });
+    });
+}

package/dist/commands/version/version.d.ts

@@ -0,0 +1,9 @@
+import { Command } from 'commander';
+import type { Factory } from '../../factory.js';
+import type { IOStreams } from '../../io/streams.js';
+export type VersionOptions = {
+    io: IOStreams;
+    version: string;
+};
+export declare function createVersionCommand(factory: Factory, run?: (options: VersionOptions) => void): Command;
+export declare function versionRun(options: VersionOptions): void;

package/dist/commands/version/version.js

@@ -0,0 +1,14 @@
+import { Command } from 'commander';
+export function createVersionCommand(factory, run = versionRun) {
+    return new Command('version')
+        .description('Show bctrl version')
+        .action(() => {
+        run({
+            io: factory.io,
+            version: factory.version,
+        });
+    });
+}
+export function versionRun(options) {
+    options.io.writeOut(`bctrl version ${options.version}\n`);
+}

package/dist/config/auth-store.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+export declare const StoredWhoamiSchema: z.ZodObject<{
+    authenticated: z.ZodLiteral<true>;
+    keyKind: z.ZodEnum<{
+        user: "user";
+        subaccount: "subaccount";
+    }>;
+    organizationId: z.ZodString;
+    subaccountId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    userId: z.ZodString;
+    apiKeyId: z.ZodString;
+    plan: z.ZodString;
+}, z.core.$strict>;
+export type StoredWhoami = z.infer<typeof StoredWhoamiSchema>;
+export declare const StoredAuthSchema: z.ZodObject<{
+    apiBaseUrl: z.ZodString;
+    token: z.ZodString;
+    whoami: z.ZodObject<{
+        authenticated: z.ZodLiteral<true>;
+        keyKind: z.ZodEnum<{
+            user: "user";
+            subaccount: "subaccount";
+        }>;
+        organizationId: z.ZodString;
+        subaccountId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userId: z.ZodString;
+        apiKeyId: z.ZodString;
+        plan: z.ZodString;
+    }, z.core.$strict>;
+    createdAt: z.ZodString;
+    validatedAt: z.ZodString;
+}, z.core.$strict>;
+export type StoredAuth = z.infer<typeof StoredAuthSchema>;
+export declare function getAuthFilePath(env?: NodeJS.ProcessEnv): string;
+export declare function readStoredAuth(env?: NodeJS.ProcessEnv): Promise<StoredAuth | null>;
+export declare function writeStoredAuth(auth: StoredAuth, env?: NodeJS.ProcessEnv): Promise<string>;
+export declare function deleteStoredAuth(env?: NodeJS.ProcessEnv): Promise<boolean>;

package/dist/config/auth-store.js

@@ -0,0 +1,71 @@
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+import { z } from 'zod';
+const DEFAULT_AUTH_FILE_NAME = 'auth.json';
+export const StoredWhoamiSchema = z
+    .object({
+    authenticated: z.literal(true),
+    keyKind: z.enum(['user', 'subaccount']),
+    organizationId: z.string().min(1),
+    subaccountId: z.string().min(1).nullable().optional(),
+    userId: z.string().min(1),
+    apiKeyId: z.string().min(1),
+    plan: z.string().min(1),
+})
+    .strict();
+export const StoredAuthSchema = z
+    .object({
+    apiBaseUrl: z.string().url(),
+    token: z.string().min(1),
+    whoami: StoredWhoamiSchema,
+    createdAt: z.string().datetime(),
+    validatedAt: z.string().datetime(),
+})
+    .strict();
+export function getAuthFilePath(env = process.env) {
+    if (env.BCTRL_AUTH_FILE?.trim()) {
+        return env.BCTRL_AUTH_FILE.trim();
+    }
+    const configDir = env.BCTRL_CONFIG_DIR?.trim() ??
+        (env.XDG_CONFIG_HOME?.trim()
+            ? join(env.XDG_CONFIG_HOME.trim(), 'bctrl')
+            : join(homedir(), '.config', 'bctrl'));
+    return join(configDir, DEFAULT_AUTH_FILE_NAME);
+}
+export async function readStoredAuth(env = process.env) {
+    const path = getAuthFilePath(env);
+    try {
+        const text = await readFile(path, 'utf8');
+        return StoredAuthSchema.parse(JSON.parse(text));
+    }
+    catch (error) {
+        if (isFileNotFound(error))
+            return null;
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to read BCTRL auth file at ${path}: ${reason}`);
+    }
+}
+export async function writeStoredAuth(auth, env = process.env) {
+    const path = getAuthFilePath(env);
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await writeFile(path, `${JSON.stringify(auth, null, 2)}\n`, { mode: 0o600 });
+    return path;
+}
+export async function deleteStoredAuth(env = process.env) {
+    try {
+        await rm(getAuthFilePath(env));
+        return true;
+    }
+    catch (error) {
+        if (isFileNotFound(error))
+            return false;
+        throw error;
+    }
+}
+function isFileNotFound(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'code' in error &&
+        error.code === 'ENOENT');
+}

package/dist/config/config.d.ts

@@ -0,0 +1,12 @@
+import { type StoredAuth } from './auth-store.js';
+export type TokenSource = 'BCTRL_API_KEY' | 'stored' | 'none';
+export type ActiveToken = {
+    token: string;
+    source: Exclude<TokenSource, 'none'>;
+};
+export type BctrlConfig = {
+    apiBaseUrl: string;
+    activeToken: ActiveToken | null;
+    storedAuth: StoredAuth | null;
+};
+export declare function loadConfig(env?: NodeJS.ProcessEnv): Promise<BctrlConfig>;