@bctrl/cli 0.1.0

package/dist/config/config.js

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { readStoredAuth } from './auth-store.js';
+const DEFAULT_API_BASE_URL = 'https://api.bctrl.ai/v2';
+const EnvSchema = z.object({
+    BCTRL_API_KEY: z.string().optional(),
+    BCTRL_API_URL: z.string().url().optional(),
+});
+export async function loadConfig(env = process.env) {
+    const parsed = EnvSchema.parse(env);
+    const apiBaseUrl = normalizeApiBaseUrl(parsed.BCTRL_API_URL ?? DEFAULT_API_BASE_URL);
+    const apiKey = parsed.BCTRL_API_KEY?.trim();
+    if (apiKey) {
+        return {
+            apiBaseUrl,
+            activeToken: { token: apiKey, source: 'BCTRL_API_KEY' },
+            storedAuth: null,
+        };
+    }
+    const storedAuth = await readStoredAuth(env);
+    const activeToken = resolveStoredToken(apiBaseUrl, storedAuth);
+    return {
+        apiBaseUrl,
+        activeToken,
+        storedAuth,
+    };
+}
+function resolveStoredToken(apiBaseUrl, storedAuth) {
+    if (storedAuth && normalizeApiBaseUrl(storedAuth.apiBaseUrl) === apiBaseUrl) {
+        return { token: storedAuth.token, source: 'stored' };
+    }
+    return null;
+}
+function normalizeApiBaseUrl(url) {
+    return url.replace(/\/+$/, '');
+}

package/dist/factory.d.ts

@@ -0,0 +1,15 @@
+import { type BctrlApiClient } from './api/client.js';
+import { type BctrlConfig } from './config/config.js';
+import type { IOStreams } from './io/streams.js';
+export type Factory = {
+    version: string;
+    io: IOStreams;
+    config: () => Promise<BctrlConfig>;
+    apiClient: () => Promise<BctrlApiClient>;
+};
+type CreateFactoryOptions = {
+    io: IOStreams;
+    version?: string;
+};
+export declare function createFactory(options: CreateFactoryOptions): Factory;
+export {};

package/dist/factory.js

@@ -0,0 +1,15 @@
+import { createBctrlApiClient } from './api/client.js';
+import { loadConfig } from './config/config.js';
+export function createFactory(options) {
+    let configPromise;
+    const config = () => {
+        configPromise ??= loadConfig();
+        return configPromise;
+    };
+    return {
+        version: options.version ?? '0.1.0',
+        io: options.io,
+        config,
+        apiClient: async () => createBctrlApiClient(await config()),
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { createRootCommand } from './root.js';
+export { createFactory, type Factory } from './factory.js';
+export { main } from './runtime/main.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export { createRootCommand } from './root.js';
+export { createFactory } from './factory.js';
+export { main } from './runtime/main.js';

package/dist/io/streams.d.ts

@@ -0,0 +1,22 @@
+import type { Readable, Writable } from 'node:stream';
+export type IOStreams = {
+    in: Readable;
+    out: Writable;
+    err: Writable;
+    isStdinTTY: () => boolean;
+    isStdoutTTY: () => boolean;
+    isStderrTTY: () => boolean;
+    canPrompt: () => boolean;
+    colorEnabled: () => boolean;
+    writeOut: (text: string) => void;
+    writeErr: (text: string) => void;
+};
+type IOStreamsOptions = {
+    in: Readable;
+    out: Writable;
+    err: Writable;
+    env?: NodeJS.ProcessEnv;
+};
+export declare function createIOStreams(options: IOStreamsOptions): IOStreams;
+export declare function createSystemIOStreams(): IOStreams;
+export {};

package/dist/io/streams.js

@@ -0,0 +1,42 @@
+import { isatty } from 'node:tty';
+function streamIsTTY(stream, fallbackFd) {
+    if (typeof stream.isTTY === 'boolean') {
+        return Boolean(stream.isTTY);
+    }
+    return fallbackFd === undefined ? false : isatty(fallbackFd);
+}
+export function createIOStreams(options) {
+    const env = options.env ?? process.env;
+    const io = {
+        in: options.in,
+        out: options.out,
+        err: options.err,
+        isStdinTTY: () => streamIsTTY(options.in, 0),
+        isStdoutTTY: () => streamIsTTY(options.out, 1),
+        isStderrTTY: () => streamIsTTY(options.err, 2),
+        canPrompt: () => io.isStdinTTY() && io.isStdoutTTY() && env.BCTRL_PROMPT_DISABLED !== '1',
+        colorEnabled: () => {
+            if (env.NO_COLOR !== undefined)
+                return false;
+            if (env.CLICOLOR_FORCE && env.CLICOLOR_FORCE !== '0')
+                return true;
+            if (env.CLICOLOR === '0')
+                return false;
+            return io.isStdoutTTY();
+        },
+        writeOut: (text) => {
+            options.out.write(text);
+        },
+        writeErr: (text) => {
+            options.err.write(text);
+        },
+    };
+    return io;
+}
+export function createSystemIOStreams() {
+    return createIOStreams({
+        in: process.stdin,
+        out: process.stdout,
+        err: process.stderr,
+    });
+}

package/dist/root.d.ts

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

package/dist/root.js

@@ -0,0 +1,40 @@
+import { Command } from 'commander';
+import { createAiCommand } from './commands/ai/index.js';
+import { createAuthCommand } from './commands/auth/index.js';
+import { createBrowserCommand } from './commands/browser/index.js';
+import { createFileCommand } from './commands/file/index.js';
+import { createInvocationCommand } from './commands/invocation/index.js';
+import { createRunCommand } from './commands/run/index.js';
+import { createRuntimeCommand } from './commands/runtime/index.js';
+import { createSpaceCommand } from './commands/space/index.js';
+import { createSubaccountCommand } from './commands/subaccount/index.js';
+import { createToolCommand } from './commands/tool/index.js';
+import { createToolCallCommand } from './commands/tool-call/index.js';
+import { createToolsetCommand } from './commands/toolset/index.js';
+import { createVaultCommand } from './commands/vault/index.js';
+import { createVersionCommand } from './commands/version/version.js';
+export function createRootCommand(factory) {
+    const command = new Command();
+    command
+        .name('bctrl')
+        .description('BCTRL command-line interface')
+        .usage('<command> [flags]')
+        .showHelpAfterError()
+        .showSuggestionAfterError()
+        .option('--no-color', 'Disable color output');
+    command.addCommand(createVersionCommand(factory));
+    command.addCommand(createAuthCommand(factory));
+    command.addCommand(createAiCommand(factory));
+    command.addCommand(createBrowserCommand(factory));
+    command.addCommand(createFileCommand(factory));
+    command.addCommand(createInvocationCommand(factory));
+    command.addCommand(createRunCommand(factory));
+    command.addCommand(createRuntimeCommand(factory));
+    command.addCommand(createSpaceCommand(factory));
+    command.addCommand(createSubaccountCommand(factory));
+    command.addCommand(createToolCommand(factory));
+    command.addCommand(createToolsetCommand(factory));
+    command.addCommand(createToolCallCommand(factory));
+    command.addCommand(createVaultCommand(factory));
+    return command;
+}

package/dist/runtime/errors.d.ts

@@ -0,0 +1,19 @@
+export type ApiErrorInfo = {
+    status: number;
+    code?: string;
+    requestId?: string;
+    details?: Record<string, unknown>;
+};
+export declare class CliError extends Error {
+    readonly exitCode: number;
+    readonly apiError?: ApiErrorInfo;
+    constructor(message: string, options?: {
+        exitCode?: number;
+        cause?: unknown;
+        apiError?: ApiErrorInfo;
+    });
+}
+export declare class AuthError extends CliError {
+    constructor(message?: string);
+}
+export declare function errorMessage(error: unknown): string;

package/dist/runtime/errors.js

@@ -0,0 +1,23 @@
+export class CliError extends Error {
+    exitCode;
+    apiError;
+    constructor(message, options) {
+        super(message, { cause: options?.cause });
+        this.name = 'CliError';
+        this.exitCode = options?.exitCode ?? 1;
+        this.apiError = options?.apiError;
+    }
+}
+export class AuthError extends CliError {
+    constructor(message = 'BCTRL_API_KEY is required') {
+        super(`${message}\n\nRun:\n  bctrl auth login\n\nOr set:\n  export BCTRL_API_KEY=...`, {
+            exitCode: 4,
+        });
+        this.name = 'AuthError';
+    }
+}
+export function errorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+}

package/dist/runtime/exit-codes.d.ts

@@ -0,0 +1,7 @@
+export declare const ExitCode: {
+    readonly Ok: 0;
+    readonly Error: 1;
+    readonly Cancel: 2;
+    readonly Auth: 4;
+};
+export type ExitCode = (typeof ExitCode)[keyof typeof ExitCode];

package/dist/runtime/exit-codes.js

@@ -0,0 +1,6 @@
+export const ExitCode = {
+    Ok: 0,
+    Error: 1,
+    Cancel: 2,
+    Auth: 4,
+};

package/dist/runtime/main.d.ts

@@ -0,0 +1 @@
+export declare function main(argv: string[]): Promise<number>;

package/dist/runtime/main.js

@@ -0,0 +1,27 @@
+import { InvalidArgumentError } from 'commander';
+import { createFactory } from '../factory.js';
+import { createSystemIOStreams } from '../io/streams.js';
+import { createRootCommand } from '../root.js';
+import { CliError, errorMessage } from './errors.js';
+import { ExitCode } from './exit-codes.js';
+export async function main(argv) {
+    const io = createSystemIOStreams();
+    const factory = createFactory({ io });
+    const root = createRootCommand(factory);
+    try {
+        await root.parseAsync(argv, { from: 'user' });
+        return ExitCode.Ok;
+    }
+    catch (error) {
+        if (error instanceof InvalidArgumentError) {
+            io.writeErr(`${error.message}\n`);
+            return ExitCode.Error;
+        }
+        if (error instanceof CliError) {
+            io.writeErr(`${error.message}\n`);
+            return error.exitCode;
+        }
+        io.writeErr(`${errorMessage(error)}\n`);
+        return ExitCode.Error;
+    }
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@bctrl/cli",
+  "version": "0.1.0",
+  "description": "BCTRL command-line interface",
+  "type": "module",
+  "bin": {
+    "bctrl": "./dist/bin/bctrl.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "pnpm run clean && tsc -p tsconfig.json",
+    "dev": "tsx src/bin/bctrl.ts",
+    "prepack": "pnpm run build",
+    "test": "tsx --test \"tests/**/*.test.ts\"",
+    "typecheck": "tsc --noEmit",
+    "typecheck:tests": "tsc --noEmit -p tests/tsconfig.json"
+  },
+  "keywords": [
+    "bctrl",
+    "cli",
+    "browser-automation",
+    "agents"
+  ],
+  "author": "",
+  "license": "ISC",
+  "packageManager": "pnpm@10.12.4",
+  "dependencies": {
+    "commander": "^14.0.3",
+    "handlebars": "^4.7.9",
+    "jq-web": "^0.6.2",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "^25.7.0",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.3"
+  }
+}