@bctrl/cli 0.1.3 → 0.1.5

package/dist/commands/shared/{rest.js → operation.js}

@@ -1,11 +1,10 @@
+import { CLI_OPENAPI_ROUTES } from '../../generated/openapi-routes.js';
 import { Command } from 'commander';
-import { CliError } from '../../runtime/errors.js';
 import { readJsonFile } from './io.js';
 import { parsePositiveInteger } from './options.js';
 import { addOutputFlags, outputData } from './output.js';
-export function pathTemplate(template, params) {
-    return template.replace(/\{(\w+)\}/g, (_, key) => encodeURIComponent(params[key] ?? ''));
-}
+import { CliError } from '../../runtime/errors.js';
+import { addCliOperationHelp } from './help.js';
 export function addPaginationFlags(command) {
     return command
         .option('-L, --limit <number>', 'Maximum number of results to return', parsePositiveInteger)
@@ -14,72 +13,125 @@ export function addPaginationFlags(command) {
 export function addJsonBodyFlag(command) {
     return command.option('--input <path>', 'Read JSON request body from file, or - for stdin');
 }
-export async function requestAndPrint(deps, method, path, options) {
+export function outputFlags(options) {
+    return {
+        ...(typeof options.json === 'string' || typeof options.json === 'boolean'
+            ? { json: options.json }
+            : {}),
+        ...(typeof options.jq === 'string' ? { jq: options.jq } : {}),
+        ...(typeof options.template === 'string' ? { template: options.template } : {}),
+    };
+}
+export function operationPath(operationId, pathParams) {
+    const route = CLI_OPENAPI_ROUTES[operationId];
+    return route.path.replace(/\{([^}]+)\}/g, (_match, key) => {
+        const value = pathParams?.[key];
+        if (value === undefined) {
+            throw new Error(`Missing path parameter "${key}" for ${operationId}`);
+        }
+        return encodeURIComponent(String(value));
+    });
+}
+export async function requestOperationAndPrint(deps, operationId, input) {
+    const result = await requestOperation(deps, operationId, input);
+    await outputData(deps.io, result, input.output);
+}
+export async function requestOperation(deps, operationId, input) {
+    const route = CLI_OPENAPI_ROUTES[operationId];
     const client = await deps.apiClient();
-    const result = method === 'get'
+    const path = operationPath(operationId, input.pathParams);
+    const requestOptions = {
+        ...('query' in input && input.query !== undefined ? { query: input.query } : {}),
+        ...('body' in input && input.body !== undefined ? { body: input.body } : {}),
+        ...(input.idempotencyKey ? { idempotencyKey: input.idempotencyKey } : {}),
+    };
+    const options = Object.keys(requestOptions).length > 0 ? requestOptions : undefined;
+    const result = route.method === 'get'
         ? await client.get(path, options)
-        : method === 'post'
+        : route.method === 'post'
             ? await client.post(path, options)
-            : method === 'patch'
+            : route.method === 'patch'
                 ? await client.patch(path, options)
-                : method === 'put'
+                : route.method === 'put'
                     ? await client.put(path, options)
                     : await client.delete(path, options);
-    await outputData(deps.io, result, options?.output);
+    return result;
 }
-export async function bodyFromInputOption(path) {
-    return path ? readJsonFile(path) : {};
+export async function uploadOperationFile(deps, operationId, input) {
+    const client = await deps.apiClient();
+    return client.uploadFile(operationPath(operationId, input.pathParams), {
+        file: input.file,
+        fileName: input.fileName,
+        ...('query' in input && input.query !== undefined ? { query: input.query } : {}),
+        ...(input.fields ? { fields: input.fields } : {}),
+    });
 }
-export function createListCommand(factory, config) {
+export async function downloadOperation(deps, operationId, input) {
+    const client = await deps.apiClient();
+    return client.download(operationPath(operationId, input.pathParams));
+}
+export async function streamOperationText(deps, operationId, input) {
+    const client = await deps.apiClient();
+    return client.streamText(operationPath(operationId, input.pathParams), {
+        ...('query' in input && input.query !== undefined ? { query: input.query } : {}),
+    });
+}
+export function createOperationListCommand(factory, config) {
     let command = new Command(config.name ?? 'list').description(config.description);
+    command = addCliOperationHelp(command, config.operationId);
     command = config.configure ? config.configure(command) : addPaginationFlags(command);
     command = addOutputFlags(command);
     return command.action(async (options) => {
-        await requestAndPrint(factory, 'get', config.path, {
+        await requestOperationAndPrint(factory, config.operationId, {
             query: config.query ? config.query(options) : defaultListQuery(options),
             output: outputFlags(options),
         });
     });
 }
-export function createViewCommand(factory, config) {
+export function createOperationViewCommand(factory, config) {
     const argName = config.argName ?? 'id';
     let command = new Command(config.name ?? 'view')
         .description(config.description)
         .argument(`<${argName}>`);
+    command = addCliOperationHelp(command, config.operationId);
     command = config.configure ? config.configure(command) : command;
     command = addOutputFlags(command);
     return command.action(async (id, options) => {
-        await requestAndPrint(factory, 'get', pathTemplate(config.path, { [argName]: id, id }), {
+        await requestOperationAndPrint(factory, config.operationId, {
+            pathParams: { [argName]: id, id },
             query: config.query ? config.query(id, options) : undefined,
             output: outputFlags(options),
         });
     });
 }
-export function createDeleteCommand(factory, config) {
+export function createOperationDeleteCommand(factory, config) {
     const argNames = config.argNames ?? ['id'];
     let command = new Command(config.name ?? 'delete').description(config.description);
+    command = addCliOperationHelp(command, config.operationId);
     for (const arg of argNames)
         command = command.argument(`<${arg}>`);
     command = command.option('-y, --yes', 'Confirm deletion');
     command = config.configure ? config.configure(command) : command;
     command = addOutputFlags(command);
-    return command.action(async (...args) => {
-        const options = getActionOptions(args);
+    return command.action(async (...actionArgs) => {
+        const options = getActionOptions(actionArgs);
         if (options.yes !== true) {
             throw new CliError('Refusing to delete without --yes');
         }
         const params = {};
         for (let i = 0; i < argNames.length; i += 1)
-            params[argNames[i]] = String(args[i]);
-        await requestAndPrint(factory, 'delete', pathTemplate(config.path, params), {
+            params[argNames[i]] = String(actionArgs[i]);
+        await requestOperationAndPrint(factory, config.operationId, {
+            pathParams: params,
             query: config.query ? config.query(params, options) : undefined,
             output: outputFlags(options),
         });
     });
 }
-export function createJsonBodyCommand(factory, config) {
+export function createOperationJsonBodyCommand(factory, config) {
     const argNames = config.argNames ?? [];
     let command = new Command(config.name).description(config.description);
+    command = addCliOperationHelp(command, config.operationId);
     for (const arg of argNames)
         command = command.argument(`<${arg}>`);
     command = config.configure ? config.configure(command) : addJsonBodyFlag(command);
@@ -89,8 +141,11 @@ export function createJsonBodyCommand(factory, config) {
         const args = {};
         for (let i = 0; i < argNames.length; i += 1)
             args[argNames[i]] = String(actionArgs[i]);
-        const body = config.body ? await config.body(args, options) : await bodyFromInputOption(String(options.input ?? ''));
-        await requestAndPrint(factory, config.method, pathTemplate(config.path, args), {
+        const body = config.body
+            ? await config.body(args, options)
+            : await bodyFromInputOption(String(options.input ?? ''));
+        await requestOperationAndPrint(factory, config.operationId, {
+            pathParams: args,
             body,
             query: config.query ? config.query(args, options) : undefined,
             output: outputFlags(options),
@@ -103,14 +158,8 @@ function defaultListQuery(options) {
         cursor: typeof options.cursor === 'string' ? options.cursor : undefined,
     };
 }
-export function outputFlags(options) {
-    return {
-        ...(typeof options.json === 'string' || typeof options.json === 'boolean'
-            ? { json: options.json }
-            : {}),
-        ...(typeof options.jq === 'string' ? { jq: options.jq } : {}),
-        ...(typeof options.template === 'string' ? { template: options.template } : {}),
-    };
+async function bodyFromInputOption(path) {
+    return path ? readJsonFile(path) : {};
 }
 function getActionOptions(args) {
     const candidate = args.at(-2);

package/dist/commands/space/index.js

@@ -1,86 +1,80 @@
 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 { outputFlags, requestOperationAndPrint } from '../shared/operation.js';
+import { addOutputFlags } from '../shared/output.js';
+import { CliError } from '../../runtime/errors.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(addOutputFlags(new Command('get').description('View a space').argument('<spaceId>')).action(async (spaceId, options) => {
+        await requestOperationAndPrint(factory, 'spaces.get', {
+            pathParams: { spaceId },
+            output: outputFlags(options),
+        });
     }));
-    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('--input <path>', 'Read JSON request body from file, or - for stdin'),
-        body: async (_args, options) => {
-            if (typeof options.input === 'string')
-                return readJsonFile(options.input);
-            return {
-                name: options.name,
-                region: options.region,
-                subaccountId: options.subaccountId,
-            };
-        },
+    command.addCommand(addOutputFlags(new Command('create')
+        .description('Create a space')
+        .option('--name <name>', 'Space name')
+        .option('--subaccount-id <id>', 'Subaccount id')
+        .option('--input <path>', 'Read JSON request body from file, or - for stdin')).action(async (options) => {
+        await requestOperationAndPrint(factory, 'spaces.create', {
+            body: typeof options.input === 'string'
+                ? (await readJsonFile(options.input))
+                : {
+                    name: options.name,
+                    subaccountId: options.subaccountId,
+                },
+            output: outputFlags(options),
+        });
     }));
-    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('--input <path>', 'Read JSON request body from file, or - for stdin'),
-        body: async (_args, options) => {
-            if (typeof options.input === 'string')
-                return readJsonFile(options.input);
-            return { name: options.name };
-        },
+    command.addCommand(addOutputFlags(new Command('patch')
+        .description('Edit a space')
+        .argument('<spaceId>')
+        .option('--name <name>', 'Space name')
+        .option('--input <path>', 'Read JSON request body from file, or - for stdin')).action(async (spaceId, options) => {
+        await requestOperationAndPrint(factory, 'spaces.update', {
+            pathParams: { spaceId },
+            body: typeof options.input === 'string'
+                ? (await readJsonFile(options.input))
+                : { name: options.name },
+            output: outputFlags(options),
+        });
+    }));
+    command.addCommand(addOutputFlags(new Command('delete')
+        .description('Delete a space')
+        .argument('<spaceId>')
+        .option('-y, --yes', 'Confirm deletion')).action(async (spaceId, options) => {
+        if (options.yes !== true) {
+            throw new CliError('Refusing to delete without --yes');
+        }
+        await requestOperationAndPrint(factory, 'spaces.delete', {
+            pathParams: { spaceId },
+            output: outputFlags(options),
+        });
     }));
     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(addOutputFlags(new Command('get').description('Get a space environment').argument('<spaceId>')).action(async (spaceId, options) => {
+        await requestOperationAndPrint(factory, 'spaces.environment.get', {
+            pathParams: { spaceId },
+            output: outputFlags(options),
+        });
     }));
-    command.addCommand(createJsonBodyCommand(factory, {
-        name: 'set',
-        description: 'Update a space environment',
-        method: 'patch',
-        path: '/spaces/{id}/environment',
-        argNames: ['id'],
+    command.addCommand(addOutputFlags(new Command('patch')
+        .description('Update a space environment')
+        .argument('<spaceId>')
+        .option('--input <path>', 'Read JSON request body from file, or - for stdin')).action(async (spaceId, options) => {
+        await requestOperationAndPrint(factory, 'spaces.environment.update', {
+            pathParams: { spaceId },
+            body: typeof options.input === 'string'
+                ? (await readJsonFile(options.input))
+                : {},
+            output: outputFlags(options),
+        });
     }));
     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

@@ -1,13 +1,3 @@
 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>;
+export declare function createSpaceListCommand(factory: Factory): Command;

package/dist/commands/space/list.js

@@ -1,25 +1,17 @@
 import { Command } from 'commander';
-import { addOutputFlags, outputData } from '../shared/output.js';
-export function createSpaceListCommand(factory, run = spaceListRun) {
-    return addOutputFlags(new Command('list')
+import { addPaginationFlags, outputFlags, requestOperationAndPrint } from '../shared/operation.js';
+import { addOutputFlags } from '../shared/output.js';
+export function createSpaceListCommand(factory) {
+    return addOutputFlags(addPaginationFlags(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,
+        .option('--subaccount <id>', 'Filter by subaccount id'))).action(async (options) => {
+        await requestOperationAndPrint(factory, 'spaces.list', {
+            query: {
+                subaccountId: options.subaccount,
+                limit: options.limit,
+                cursor: options.cursor,
+            },
+            output: outputFlags(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.js

@@ -2,54 +2,65 @@ 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';
+import { addPaginationFlags, createOperationJsonBodyCommand, createOperationListCommand, createOperationViewCommand, outputFlags, requestOperationAndPrint, } from '../shared/operation.js';
 export function createSubaccountCommand(factory) {
-    const command = new Command('subaccount').description('Manage subaccounts, keys, limits, and usage');
-    command.addCommand(createListCommand(factory, {
+    const command = new Command('subaccount').description('Manage subaccounts');
+    command.addCommand(createOperationListCommand(factory, {
+        operationId: 'subaccounts.list',
         description: 'List subaccounts',
-        path: '/subaccounts',
-        configure: (cmd) => cmd,
+        query: (options) => ({
+            limit: typeof options.limit === 'number' ? options.limit : undefined,
+            cursor: typeof options.cursor === 'string' ? options.cursor : undefined,
+            include: options.includeUsage === true ? 'usage' : undefined,
+            status: typeof options.status === 'string' ? options.status : undefined,
+            externalId: typeof options.externalId === 'string' ? options.externalId : undefined,
+            query: typeof options.query === 'string' ? options.query : undefined,
+        }),
+        configure: (cmd) => addPaginationFlags(cmd)
+            .option('--include-usage', 'Inline current usage')
+            .option('--status <status>', 'Filter by status')
+            .option('--external-id <id>', 'Filter by external id')
+            .option('--query <text>', 'Search by id, name, or external id'),
     }));
-    command.addCommand(createViewCommand(factory, {
-        description: 'View a subaccount',
-        path: '/subaccounts/{id}',
+    command.addCommand(createOperationViewCommand(factory, {
+        operationId: 'subaccounts.get',
+        name: 'get',
+        description: 'Get a subaccount',
+        argName: 'subaccountId',
+        configure: (cmd) => cmd.option('--include <value>', 'Include related data, for example usage'),
+        query: (_id, options) => ({
+            include: typeof options.include === 'string' ? options.include : undefined,
+        }),
     }));
-    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('--input <path>', 'Read full JSON request body from file, or - for stdin'),
-        body: async (_args, options) => {
-            if (typeof options.input === 'string')
-                return readJsonFile(options.input);
-            return {
-                name: options.name,
-                externalId: options.externalId,
-                metadata: typeof options.metadataFile === 'string'
-                    ? await readJsonFile(options.metadataFile, '--metadata-file')
-                    : undefined,
-            };
-        },
+    command.addCommand(createSubaccountWriteCommand(factory, 'create', 'subaccounts.create'));
+    command.addCommand(createSubaccountWriteCommand(factory, 'patch', 'subaccounts.update', ['subaccountId']));
+    command.addCommand(addOutputFlags(new Command('archive')
+        .description('Archive a subaccount')
+        .argument('<subaccountId>')
+        .requiredOption('-y, --yes', 'Confirm archive')).action(async (subaccountId, options) => {
+        await requestOperationAndPrint(factory, 'subaccounts.archive', {
+            pathParams: { subaccountId },
+            output: outputFlags(options),
+        });
     }));
-    command.addCommand(createJsonBodyCommand(factory, {
-        name: 'edit',
-        description: 'Edit a subaccount',
-        method: 'patch',
-        path: '/subaccounts/{id}',
-        argNames: ['id'],
+    command.addCommand(createSubaccountUsageCommand(factory));
+    return command;
+}
+function createSubaccountWriteCommand(factory, name, operationId, argNames = []) {
+    return createOperationJsonBodyCommand(factory, {
+        operationId,
+        name,
+        description: name === 'create' ? 'Create a subaccount' : 'Update a subaccount',
+        argNames,
         configure: (cmd) => cmd
             .option('--name <name>', 'Subaccount name')
             .option('--external-id <id>', 'External id')
             .option('--metadata-file <path>', 'Metadata JSON file')
             .option('--input <path>', 'Read full JSON request body from file, or - for stdin'),
         body: async (_args, options) => {
-            if (typeof options.input === 'string')
-                return readJsonFile(options.input);
+            if (typeof options.input === 'string') {
+                return (await readJsonFile(options.input));
+            }
             return {
                 name: options.name,
                 externalId: options.externalId,
@@ -58,105 +69,25 @@ export function createSubaccountCommand(factory) {
                     : 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) => {
+        .option('--cursor <cursor>', 'Pagination cursor')).action(async (id, options) => {
         if (id) {
-            await requestAndPrint(factory, 'get', `/subaccounts/${encodeURIComponent(id)}/usage`, {
-                output: options,
+            await requestOperationAndPrint(factory, 'subaccounts.get', {
+                pathParams: { subaccountId: id },
+                query: { include: 'usage' },
+                output: outputFlags(options),
             });
             return;
         }
-        await requestAndPrint(factory, 'get', '/subaccounts/usage', {
+        await requestOperationAndPrint(factory, 'subaccounts.usage.list', {
             query: { limit: options.limit, cursor: options.cursor },
-            output: options,
+            output: outputFlags(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('--input <path>', 'Read full JSON request body from file, or - for stdin'),
-        body: async (_args, options) => {
-            if (typeof options.input === 'string')
-                return readJsonFile(options.input);
-            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('--input <path>', 'Read full JSON request body from file, or - for stdin'),
-        body: async (_args, options) => {
-            if (typeof options.input === 'string')
-                return readJsonFile(options.input);
-            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;
-}