@bctrl/cli 0.1.0

package/README.md

@@ -0,0 +1,44 @@
+# BCTRL CLI
+
+TypeScript command-line interface for BCTRL.
+
+This package is intentionally scaffolded around a GitHub CLI-style command architecture:
+
+- tiny bin entrypoint
+- testable runtime `main()`
+- lazy factory dependencies
+- IO streams instead of direct `console.log`
+- one module per leaf command
+- `Options + createCommand + run` per command
+
+## Development
+
+```bash
+pnpm -C cli run dev -- --help
+pnpm -C cli run dev -- version
+pnpm -C cli run dev -- auth status
+pnpm -C cli run dev -- space list
+```
+
+## Command Boundary
+
+This package is for public BCTRL API usage:
+
+- auth
+- spaces
+- runtimes
+- runs
+- invocations
+- files
+- subaccounts
+- `bctrl version` for current version and future non-blocking update hints
+
+Do not add maintainer-only release commands here. CLI publishing belongs in pnpm scripts and CI/CD. Infrastructure rollout commands belong in `@bctrl/machine-cli`.
+
+Do not add a public `bctrl update` command initially. The public update surface is `bctrl version`, which can later show a safe upgrade command such as `npm install -g @bctrl/cli@latest`.
+
+## Build
+
+```bash
+pnpm -C cli run build
+```

package/dist/api/auth.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+export declare const AuthWhoamiSchema: 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 AuthWhoami = z.infer<typeof AuthWhoamiSchema>;
+export declare function validateAuthToken(apiBaseUrl: string, token: string): Promise<AuthWhoami>;

package/dist/api/auth.js

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { CliError } from '../runtime/errors.js';
+import { apiErrorFromResponse } from './errors.js';
+export const AuthWhoamiSchema = 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 async function validateAuthToken(apiBaseUrl, token) {
+    const response = await fetch(new URL(`${apiBaseUrl.replace(/\/+$/, '')}/auth/whoami`), {
+        method: 'GET',
+        headers: {
+            accept: 'application/json',
+            authorization: `Bearer ${token}`,
+            'user-agent': 'BCTRL CLI',
+        },
+    });
+    if (!response.ok) {
+        throw await apiErrorFromResponse(response, 'BCTRL auth validation');
+    }
+    const body = AuthWhoamiSchema.safeParse(await response.json());
+    if (!body.success) {
+        throw new CliError(`BCTRL auth validation returned an unexpected response: ${body.error.message}`);
+    }
+    return body.data;
+}

package/dist/api/client.d.ts

@@ -0,0 +1,22 @@
+import type { BctrlConfig } from '../config/config.js';
+export type BctrlApiClient = {
+    get: <T>(path: string, options?: RequestOptions) => Promise<T>;
+    post: <T>(path: string, options?: JsonRequestOptions) => Promise<T>;
+    patch: <T>(path: string, options?: JsonRequestOptions) => Promise<T>;
+    put: <T>(path: string, options?: JsonRequestOptions) => Promise<T>;
+    delete: <T>(path: string, options?: RequestOptions) => Promise<T>;
+    download: (path: string, options?: RequestOptions) => Promise<Uint8Array>;
+    streamText: (path: string, options?: RequestOptions) => Promise<AsyncIterable<string>>;
+    uploadFile: <T>(path: string, options: RequestOptions & {
+        file: Blob;
+        fileName: string;
+        fields?: Record<string, string>;
+    }) => Promise<T>;
+};
+export type RequestOptions = {
+    query?: Record<string, string | number | boolean | undefined>;
+};
+export type JsonRequestOptions = RequestOptions & {
+    body?: unknown;
+};
+export declare function createBctrlApiClient(config: BctrlConfig): BctrlApiClient;

package/dist/api/client.js

@@ -0,0 +1,130 @@
+import { AuthError, CliError } from '../runtime/errors.js';
+import { apiErrorFromResponse } from './errors.js';
+export function createBctrlApiClient(config) {
+    return {
+        get: (path, options) => requestJson(config, 'GET', path, options),
+        post: (path, options) => requestJson(config, 'POST', path, options),
+        patch: (path, options) => requestJson(config, 'PATCH', path, options),
+        put: (path, options) => requestJson(config, 'PUT', path, options),
+        delete: (path, options) => requestJson(config, 'DELETE', path, options),
+        download: (path, options) => requestBinary(config, 'GET', path, options),
+        streamText: (path, options) => requestTextStream(config, path, options),
+        uploadFile: (path, options) => uploadFile(config, path, options),
+    };
+}
+async function requestJson(config, method, path, options) {
+    if (!config.activeToken) {
+        throw new AuthError();
+    }
+    const headers = {
+        accept: 'application/json',
+        authorization: `Bearer ${config.activeToken.token}`,
+        'user-agent': 'BCTRL CLI',
+    };
+    let body;
+    if (options && 'body' in options && options.body !== undefined) {
+        headers['content-type'] = 'application/json';
+        body = JSON.stringify(options.body);
+    }
+    const response = await fetch(buildUrl(config.apiBaseUrl, path, options?.query), {
+        method,
+        headers,
+        body,
+    });
+    if (!response.ok) {
+        throw await apiErrorFromResponse(response);
+    }
+    if (response.status === 204) {
+        return { ok: true };
+    }
+    const text = await response.text();
+    return (text ? JSON.parse(text) : { ok: true });
+}
+async function requestBinary(config, method, path, options) {
+    if (!config.activeToken) {
+        throw new AuthError();
+    }
+    const response = await fetch(buildUrl(config.apiBaseUrl, path, options?.query), {
+        method,
+        headers: {
+            authorization: `Bearer ${config.activeToken.token}`,
+            'user-agent': 'BCTRL CLI',
+        },
+    });
+    if (!response.ok) {
+        throw await apiErrorFromResponse(response);
+    }
+    return new Uint8Array(await response.arrayBuffer());
+}
+async function requestTextStream(config, path, options) {
+    if (!config.activeToken) {
+        throw new AuthError();
+    }
+    const response = await fetch(buildUrl(config.apiBaseUrl, path, options?.query), {
+        method: 'GET',
+        headers: {
+            accept: 'text/event-stream',
+            authorization: `Bearer ${config.activeToken.token}`,
+            'user-agent': 'BCTRL CLI',
+        },
+    });
+    if (!response.ok) {
+        throw await apiErrorFromResponse(response);
+    }
+    if (!response.body) {
+        throw new CliError('BCTRL API response did not include a stream body');
+    }
+    const decoder = new TextDecoder();
+    const reader = response.body.getReader();
+    return {
+        async *[Symbol.asyncIterator]() {
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    if (value)
+                        yield decoder.decode(value, { stream: true });
+                }
+                const rest = decoder.decode();
+                if (rest)
+                    yield rest;
+            }
+            finally {
+                reader.releaseLock();
+            }
+        },
+    };
+}
+async function uploadFile(config, path, options) {
+    if (!config.activeToken) {
+        throw new AuthError();
+    }
+    const form = new FormData();
+    form.set('file', options.file, options.fileName);
+    for (const [key, value] of Object.entries(options.fields ?? {})) {
+        form.set(key, value);
+    }
+    const response = await fetch(buildUrl(config.apiBaseUrl, path, options.query), {
+        method: 'POST',
+        headers: {
+            accept: 'application/json',
+            authorization: `Bearer ${config.activeToken.token}`,
+            'user-agent': 'BCTRL CLI',
+        },
+        body: form,
+    });
+    if (!response.ok) {
+        throw await apiErrorFromResponse(response);
+    }
+    return (await response.json());
+}
+function buildUrl(baseUrl, path, query) {
+    const url = new URL(`${baseUrl}${path.startsWith('/') ? path : `/${path}`}`);
+    for (const [key, value] of Object.entries(query ?? {})) {
+        if (value !== undefined && value !== '') {
+            url.searchParams.set(key, String(value));
+        }
+    }
+    return url.toString();
+}

package/dist/api/errors.d.ts

@@ -0,0 +1,2 @@
+import { CliError } from '../runtime/errors.js';
+export declare function apiErrorFromResponse(response: Response, context?: string): Promise<CliError>;

package/dist/api/errors.js

@@ -0,0 +1,95 @@
+import { CliError } from '../runtime/errors.js';
+export async function apiErrorFromResponse(response, context = 'BCTRL API request') {
+    const bodyText = await response.text();
+    const parsed = parseErrorBody(bodyText);
+    const message = parsed.message ?? parsed.error;
+    const humanMessage = typeof message === 'string' && message.trim()
+        ? message.trim()
+        : bodyText || `${response.status} ${response.statusText}`;
+    const apiError = {
+        status: response.status,
+        code: typeof parsed.code === 'string' ? parsed.code : undefined,
+        requestId: typeof parsed.requestId === 'string' ? parsed.requestId : undefined,
+        details: isRecord(parsed.details) ? parsed.details : undefined,
+    };
+    return new CliError(formatApiErrorMessage(context, response.status, humanMessage, apiError), {
+        apiError,
+    });
+}
+function parseErrorBody(bodyText) {
+    if (!bodyText)
+        return {};
+    try {
+        const parsed = JSON.parse(bodyText);
+        return isRecord(parsed) ? parsed : { error: bodyText };
+    }
+    catch {
+        return { error: bodyText };
+    }
+}
+function formatApiErrorMessage(context, status, message, apiError) {
+    const lines = [`${context} failed: ${status} ${message}`];
+    if (apiError.code) {
+        lines.push(`Code: ${apiError.code}`);
+    }
+    if (apiError.requestId) {
+        lines.push(`Request ID: ${apiError.requestId}`);
+    }
+    const suggestion = suggestionForApiError(apiError);
+    if (suggestion) {
+        lines.push('', 'Try:', `  ${suggestion}`);
+    }
+    return lines.join('\n');
+}
+function suggestionForApiError(error) {
+    switch (error.code) {
+        case 'auth.required':
+        case 'auth.invalid':
+            return 'bctrl auth login';
+        case 'permission.denied':
+        case 'auth.forbidden':
+            return 'bctrl auth status';
+        case 'space.not_found':
+            return 'bctrl space list';
+        case 'runtime.not_found':
+            return error.details && typeof error.details.spaceId === 'string'
+                ? `bctrl runtime list --space ${error.details.spaceId}`
+                : 'bctrl runtime list';
+        case 'run.not_found':
+            return error.details && typeof error.details.runtimeId === 'string'
+                ? `bctrl runtime runs ${error.details.runtimeId}`
+                : 'bctrl run list';
+        case 'file.not_found':
+            return error.details && typeof error.details.spaceId === 'string'
+                ? `bctrl file list --space ${error.details.spaceId}`
+                : 'bctrl file list';
+        case 'tool.not_found':
+            return commandWithOptionalSpace('bctrl tool list', error.details);
+        case 'toolset.not_found':
+            return commandWithOptionalSpace('bctrl toolset list', error.details);
+        case 'tool_call.not_found':
+            return 'bctrl tool-call list';
+        case 'vault_secret.not_found':
+            return 'bctrl vault list';
+        case 'browser_extension.not_found':
+            return 'bctrl browser extension list';
+        case 'ai_provider.not_found':
+            return 'bctrl ai provider list';
+        case 'proxy.not_found':
+            return 'bctrl ai proxy list';
+        case 'subaccount.not_found':
+            return 'bctrl subaccount list';
+        case 'subaccount_api_key.not_found':
+            return error.details && typeof error.details.subaccountId === 'string'
+                ? `bctrl subaccount key list ${error.details.subaccountId}`
+                : 'bctrl subaccount list';
+        default:
+            return null;
+    }
+}
+function commandWithOptionalSpace(command, details) {
+    return details && typeof details.spaceId === 'string' ? `${command} --space ${details.spaceId}` : command;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/bin/bctrl.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/bctrl.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { main } from '../runtime/main.js';
+const argv = process.argv.slice(2);
+if (argv[0] === '--')
+    argv.shift();
+process.exitCode = await main(argv);

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

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

package/dist/commands/ai/index.js

@@ -0,0 +1,130 @@
+import { Command } from 'commander';
+import { readJsonFile } from '../shared/io.js';
+import { addOutputFlags } from '../shared/output.js';
+import { createDeleteCommand, createJsonBodyCommand, createListCommand, createViewCommand, requestAndPrint, } from '../shared/rest.js';
+export function createAiCommand(factory) {
+    const command = new Command('ai').description('Manage AI providers and proxies');
+    command.addCommand(createAiProviderCommand(factory));
+    command.addCommand(createAiProxyCommand(factory));
+    return command;
+}
+function createAiProviderCommand(factory) {
+    const command = new Command('provider').description('Manage AI providers');
+    command.addCommand(createListCommand(factory, {
+        description: 'List AI providers',
+        path: '/ai-providers',
+        configure: (cmd) => cmd
+            .option('--provider <provider>', 'Filter by provider')
+            .option('--name <name>', 'Filter by name')
+            .option('--status <status>', 'Filter by status'),
+        query: (options) => ({
+            provider: typeof options.provider === 'string' ? options.provider : undefined,
+            name: typeof options.name === 'string' ? options.name : undefined,
+            status: typeof options.status === 'string' ? options.status : undefined,
+        }),
+    }));
+    command.addCommand(createViewCommand(factory, {
+        description: 'View an AI provider',
+        path: '/ai-providers/{id}',
+    }));
+    command.addCommand(createJsonBodyCommand(factory, {
+        name: 'create',
+        description: 'Create an AI provider',
+        method: 'post',
+        path: '/ai-providers',
+        configure: (cmd) => cmd
+            .option('--name <name>', 'Provider name')
+            .option('--provider <provider>', 'Provider key')
+            .option('--api-key <key>', 'Provider API key')
+            .option('--status <status>', 'Provider status')
+            .option('--default-model <model>', 'Default model')
+            .option('--subaccount <id>', 'Subaccount scope')
+            .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,
+                provider: options.provider,
+                apiKey: options.apiKey,
+                status: options.status,
+                scope: typeof options.subaccount === 'string' ? { subaccountId: options.subaccount } : undefined,
+                config: typeof options.defaultModel === 'string' ? { defaultModel: options.defaultModel } : undefined,
+            };
+        },
+    }));
+    command.addCommand(createJsonBodyCommand(factory, {
+        name: 'edit',
+        description: 'Edit an AI provider',
+        method: 'patch',
+        path: '/ai-providers/{id}',
+        argNames: ['id'],
+        configure: (cmd) => cmd
+            .option('--name <name>', 'Provider name')
+            .option('--api-key <key>', 'Provider API key')
+            .option('--status <status>', 'Provider status')
+            .option('--default-model <model>', 'Default model')
+            .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,
+                apiKey: options.apiKey,
+                status: options.status,
+                config: typeof options.defaultModel === 'string' ? { defaultModel: options.defaultModel } : undefined,
+            };
+        },
+    }));
+    command.addCommand(addOutputFlags(new Command('test')
+        .description('Test an AI provider')
+        .argument('<id>'))
+        .action(async (id, options) => {
+        await requestAndPrint(factory, 'post', `/ai-providers/${encodeURIComponent(id)}/test`, {
+            output: options,
+        });
+    }));
+    command.addCommand(createDeleteCommand(factory, {
+        description: 'Delete an AI provider',
+        path: '/ai-providers/{id}',
+    }));
+    return command;
+}
+function createAiProxyCommand(factory) {
+    const command = new Command('proxy').description('Manage AI/browser proxies');
+    command.addCommand(createListCommand(factory, {
+        description: 'List proxies',
+        path: '/proxies',
+        configure: (cmd) => cmd,
+    }));
+    command.addCommand(createViewCommand(factory, {
+        description: 'View a proxy',
+        path: '/proxies/{id}',
+    }));
+    command.addCommand(createJsonBodyCommand(factory, {
+        name: 'create',
+        description: 'Create a proxy',
+        method: 'post',
+        path: '/proxies',
+    }));
+    command.addCommand(createJsonBodyCommand(factory, {
+        name: 'edit',
+        description: 'Edit a proxy',
+        method: 'patch',
+        path: '/proxies/{id}',
+        argNames: ['id'],
+    }));
+    command.addCommand(addOutputFlags(new Command('test')
+        .description('Test a proxy')
+        .argument('<id>'))
+        .action(async (id, options) => {
+        await requestAndPrint(factory, 'post', `/proxies/${encodeURIComponent(id)}/test`, {
+            output: options,
+        });
+    }));
+    command.addCommand(createDeleteCommand(factory, {
+        description: 'Delete a proxy',
+        path: '/proxies/{id}',
+    }));
+    return command;
+}

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

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

package/dist/commands/auth/index.js

@@ -0,0 +1,13 @@
+import { Command } from 'commander';
+import { createAuthLoginCommand } from './login.js';
+import { createAuthLogoutCommand } from './logout.js';
+import { createAuthStatusCommand } from './status.js';
+import { createAuthTokenCommand } from './token.js';
+export function createAuthCommand(factory) {
+    const command = new Command('auth').description('Manage BCTRL authentication');
+    command.addCommand(createAuthLoginCommand(factory));
+    command.addCommand(createAuthLogoutCommand(factory));
+    command.addCommand(createAuthStatusCommand(factory));
+    command.addCommand(createAuthTokenCommand(factory));
+    return command;
+}

package/dist/commands/auth/login.d.ts

@@ -0,0 +1,11 @@
+import { Command } from 'commander';
+import type { BctrlConfig } from '../../config/config.js';
+import type { Factory } from '../../factory.js';
+import type { IOStreams } from '../../io/streams.js';
+export type AuthLoginOptions = {
+    io: IOStreams;
+    config: () => Promise<BctrlConfig>;
+    withToken?: boolean;
+};
+export declare function createAuthLoginCommand(factory: Factory, run?: (options: AuthLoginOptions) => Promise<void>): Command;
+export declare function authLoginRun(options: AuthLoginOptions): Promise<void>;

package/dist/commands/auth/login.js

@@ -0,0 +1,52 @@
+import { Command } from 'commander';
+import { writeStoredAuth } from '../../config/auth-store.js';
+import { CliError } from '../../runtime/errors.js';
+import { validateAuthToken } from '../../api/auth.js';
+import { readHiddenInput } from '../shared/hidden-input.js';
+export function createAuthLoginCommand(factory, run = authLoginRun) {
+    return new Command('login')
+        .description('Authenticate with a BCTRL API key')
+        .option('--with-token', 'Read API key from standard input')
+        .action(async (options) => {
+        await run({
+            io: factory.io,
+            config: factory.config,
+            withToken: options.withToken,
+        });
+    });
+}
+export async function authLoginRun(options) {
+    const config = await options.config();
+    const token = options.withToken
+        ? (await readStreamText(options.io.in)).trim()
+        : await readHiddenInput(options.io, 'Paste BCTRL API key: ');
+    if (!token) {
+        throw new CliError('No API key provided');
+    }
+    const whoami = await validateAuthToken(config.apiBaseUrl, token);
+    const now = new Date().toISOString();
+    const path = await writeStoredAuth({
+        apiBaseUrl: config.apiBaseUrl,
+        token,
+        whoami,
+        createdAt: now,
+        validatedAt: now,
+    });
+    options.io.writeErr(`Logged in to ${config.apiBaseUrl}\n`);
+    options.io.writeErr(`Credentials saved to ${path}\n`);
+    options.io.writeErr(`Key kind: ${whoami.keyKind}\n`);
+    options.io.writeErr(`Organization: ${whoami.organizationId}\n`);
+    if (whoami.subaccountId) {
+        options.io.writeErr(`Subaccount: ${whoami.subaccountId}\n`);
+    }
+    if (config.activeToken?.source === 'BCTRL_API_KEY') {
+        options.io.writeErr('BCTRL_API_KEY is set and will take precedence over stored credentials.\n');
+    }
+}
+async function readStreamText(stream) {
+    const chunks = [];
+    for await (const chunk of stream) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}

package/dist/commands/auth/logout.d.ts

@@ -0,0 +1,10 @@
+import { Command } from 'commander';
+import type { BctrlConfig } from '../../config/config.js';
+import type { Factory } from '../../factory.js';
+import type { IOStreams } from '../../io/streams.js';
+export type AuthLogoutOptions = {
+    io: IOStreams;
+    config: () => Promise<BctrlConfig>;
+};
+export declare function createAuthLogoutCommand(factory: Factory, run?: (options: AuthLogoutOptions) => Promise<void>): Command;
+export declare function authLogoutRun(options: AuthLogoutOptions): Promise<void>;

package/dist/commands/auth/logout.js

@@ -0,0 +1,23 @@
+import { Command } from 'commander';
+import { deleteStoredAuth } from '../../config/auth-store.js';
+export function createAuthLogoutCommand(factory, run = authLogoutRun) {
+    return new Command('logout').description('Remove stored BCTRL credentials').action(async () => {
+        await run({
+            io: factory.io,
+            config: factory.config,
+        });
+    });
+}
+export async function authLogoutRun(options) {
+    const config = await options.config();
+    const removed = await deleteStoredAuth();
+    if (removed) {
+        options.io.writeErr('Removed stored BCTRL credentials.\n');
+    }
+    else {
+        options.io.writeErr('No stored BCTRL credentials found.\n');
+    }
+    if (config.activeToken?.source === 'BCTRL_API_KEY') {
+        options.io.writeErr('BCTRL_API_KEY is still set and will continue to authenticate this shell.\n');
+    }
+}

package/dist/commands/auth/status.d.ts

@@ -0,0 +1,12 @@
+import { Command } from 'commander';
+import type { BctrlConfig } from '../../config/config.js';
+import type { Factory } from '../../factory.js';
+import type { IOStreams } from '../../io/streams.js';
+import { type OutputFlags } from '../shared/output.js';
+export type AuthStatusOptions = {
+    io: IOStreams;
+    config: () => Promise<BctrlConfig>;
+    output?: OutputFlags;
+};
+export declare function createAuthStatusCommand(factory: Factory, run?: (options: AuthStatusOptions) => Promise<void>): Command;
+export declare function authStatusRun(options: AuthStatusOptions): Promise<void>;

package/dist/commands/auth/status.js

@@ -0,0 +1,31 @@
+import { Command } from 'commander';
+import { validateAuthToken } from '../../api/auth.js';
+import { addOutputFlags, outputData } from '../shared/output.js';
+export function createAuthStatusCommand(factory, run = authStatusRun) {
+    return addOutputFlags(new Command('status')
+        .description('Show BCTRL authentication status'))
+        .action(async (options) => {
+        await run({
+            io: factory.io,
+            config: factory.config,
+            output: options,
+        });
+    });
+}
+export async function authStatusRun(options) {
+    const config = await options.config();
+    if (!config.activeToken) {
+        await outputData(options.io, {
+            apiBaseUrl: config.apiBaseUrl,
+            authenticated: false,
+            tokenSource: null,
+        }, options.output);
+        return;
+    }
+    const whoami = await validateAuthToken(config.apiBaseUrl, config.activeToken.token);
+    await outputData(options.io, {
+        apiBaseUrl: config.apiBaseUrl,
+        tokenSource: config.activeToken.source,
+        ...whoami,
+    }, options.output);
+}