@bctrl/cli 0.1.7 → 0.1.9

package/dist/commands/runtime/index.js

@@ -1,465 +1,44 @@
-import { Command, Option } from 'commander';
-import { parseJsonString, readBlob, readJsonFile } from '../shared/io.js';
-import { addPaginationFlags, buildOperationInput, createOperationJsonBodyCommand, outputFlags, requestOperationAndPrint, uploadOperationFile, } from '../shared/operation.js';
-import { parsePositiveInteger } from '../shared/options.js';
-import { addOutputFlags, outputData } from '../shared/output.js';
-import { CliError } from '../../runtime/errors.js';
-import { addCliOperationHelp } from '../shared/help.js';
+import { Command } from 'commander';
+import { createOperationDeleteCommand, createOperationJsonBodyCommand, createOperationListCommand, createOperationViewCommand, } from '../shared/operation.js';
 export function createRuntimeCommand(factory) {
-    const command = new Command('runtime').description('Manage runtimes');
-    command.addCommand(addOutputFlags(addPaginationFlags(new Command('list').description('List runtimes'))
-        .option('--space <id>', 'Filter by space id')
-        .addOption(new Option('--status <status>', 'Filter by runtime status').choices([
-        'active',
-        'failed',
-        'stopped',
-    ]))
-        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')).action(async (options) => {
-        await requestOperationAndPrint(factory, 'runtimes.list', await buildOperationInput('runtimes.list', options, {
-            query: {
-                spaceId: options.space,
-                status: options.status ? [options.status] : undefined,
-                limit: options.limit,
-                cursor: options.cursor,
-            },
-            output: outputFlags(options),
-        }));
+    const command = new Command('runtime').description('Manage runtime lifecycle');
+    command.addCommand(createOperationListCommand(factory, {
+        operationId: 'runtimes.list',
+        description: 'List runtimes',
     }));
-    command.addCommand(addOutputFlags(new Command('get')
-        .description('Get a runtime')
-        .argument('<runtimeId>')
-        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')).action(async (runtimeId, options) => {
-        await requestOperationAndPrint(factory, 'runtimes.get', await buildOperationInput('runtimes.get', options, {
-            pathParams: { runtimeId },
-            output: outputFlags(options),
-        }));
-    }));
-    command.addCommand(createRuntimeCreateCommand(factory));
-    command.addCommand(createRuntimePatchCommand(factory));
-    command.addCommand(addOutputFlags(new Command('delete')
-        .description('Delete a runtime and its browser state')
-        .argument('<runtimeId>')
-        .option('-y, --yes', 'Confirm deletion')
-        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')).action(async (runtimeId, options) => {
-        if (options.yes !== true) {
-            throw new CliError('Refusing to delete without --yes');
-        }
-        await requestOperationAndPrint(factory, 'runtimes.delete', await buildOperationInput('runtimes.delete', options, {
-            pathParams: { runtimeId },
-            output: outputFlags(options),
-        }));
-    }));
-    command.addCommand(createRuntimeStartCommand(factory));
-    command.addCommand(addOutputFlags(new Command('stop')
-        .description('Stop a runtime')
-        .argument('<runtimeId>')
-        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')).action(async (runtimeId, options) => {
-        await requestOperationAndPrint(factory, 'runtimes.stop', await buildOperationInput('runtimes.stop', options, {
-            pathParams: { runtimeId },
-            output: outputFlags(options),
-        }));
-    }));
-    command.addCommand(createRuntimeFileCommand(factory));
-    command.addCommand(createRuntimeInvocationCommand(factory));
-    command.addCommand(createRuntimeHumanActionCommand(factory));
-    command.addCommand(createRuntimeTargetCommand(factory));
-    return command;
-}
-function createRuntimeTargetCommand(factory) {
-    const command = new Command('target').description('Manage runtime targets (tabs)');
-    command.addCommand(addOutputFlags(new Command('list')
-        .description('List targets')
-        .argument('<runtimeId>')
-        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')).action(async (runtimeId, options) => {
-        await requestOperationAndPrint(factory, 'runtimes.targets.list', await buildOperationInput('runtimes.targets.list', options, {
-            pathParams: { runtimeId },
-            output: outputFlags(options),
-        }));
-    }));
-    command.addCommand(addOutputFlags(new Command('create')
-        .description('Open a new target')
-        .argument('<runtimeId>')
-        .option('--uri <uri>', 'Navigate the new target to this URI')
-        .option('--activate', 'Focus the new target')
-        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')
-        .option('--body <json>', 'Request body as JSON (inline, @file, or - for stdin)')).action(async (runtimeId, options) => {
-        await requestOperationAndPrint(factory, 'runtimes.targets.create', await buildOperationInput('runtimes.targets.create', options, {
-            pathParams: { runtimeId },
-            body: {
-                ...(options.uri ? { uri: options.uri } : {}),
-                ...(options.activate ? { activate: true } : {}),
-            },
-            output: outputFlags(options),
-        }));
-    }));
-    command.addCommand(addOutputFlags(new Command('get')
-        .description('Get a target')
-        .argument('<runtimeId>')
-        .argument('<targetId>')
-        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')).action(async (runtimeId, targetId, options) => {
-        await requestOperationAndPrint(factory, 'runtimes.targets.get', await buildOperationInput('runtimes.targets.get', options, {
-            pathParams: { runtimeId, targetId },
-            output: outputFlags(options),
-        }));
-    }));
-    command.addCommand(addOutputFlags(new Command('activate')
-        .description('Focus a target')
-        .argument('<runtimeId>')
-        .argument('<targetId>')
-        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')).action(async (runtimeId, targetId, options) => {
-        await requestOperationAndPrint(factory, 'runtimes.targets.activate', await buildOperationInput('runtimes.targets.activate', options, {
-            pathParams: { runtimeId, targetId },
-            output: outputFlags(options),
-        }));
-    }));
-    command.addCommand(addOutputFlags(new Command('delete')
-        .description('Close a target')
-        .argument('<runtimeId>')
-        .argument('<targetId>')
-        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')).action(async (runtimeId, targetId, options) => {
-        await requestOperationAndPrint(factory, 'runtimes.targets.delete', await buildOperationInput('runtimes.targets.delete', options, {
-            pathParams: { runtimeId, targetId },
-            output: outputFlags(options),
-        }));
-    }));
-    return command;
-}
-function createRuntimeCreateCommand(factory) {
-    return addOutputFlags(addCliOperationHelp(new Command('create')
-        .description('Create a runtime')
-        .option('--space <id>', 'Space id; omitted uses caller default space')
-        .option('--name <name>', 'Runtime name')
-        .option('--profile', 'Persist browser state across runtime starts')
-        .option('--proxy <id-or-url>', 'Saved proxy id or inline custom proxy URL')
-        .addOption(new Option('--device <device>', 'Fingerprint device filter').choices([
-        'desktop',
-        'mobile',
-    ]))
-        .addOption(new Option('--os <os>', 'Fingerprint OS filter').choices([
-        'windows',
-        'macos',
-        'android',
-        'ios',
-    ]))
-        .addOption(new Option('--browser <browser>', 'Fingerprint browser filter').choices([
-        'chrome',
-        'edge',
-        'safari',
-    ]))
-        .option('--browser-version <version>', 'Fingerprint browser version filter')
-        .option('--locale <locale>', 'Fingerprint locale/language filter; repeat to set an ordered language stack', collectLocale, [])
-        .option('--config-file <path>', 'Runtime config JSON file')
-        .option('--metadata-file <path>', 'Runtime metadata JSON file')
-        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')
-        .option('--body <json>', 'Full request body as JSON (inline, @file, or - for stdin)'), 'runtimes.create')).action(async (options) => {
-        // --body (raw JSON) is the complete body; otherwise build it from
-        // the curated flags. --params can still add query params. The control-plane
-        // validates the body against the runtimes.create schema either way.
-        const config = typeof options.configFile === 'string'
-            ? await readJsonFile(options.configFile, '--config-file')
-            : undefined;
-        await requestOperationAndPrint(factory, 'runtimes.create', await buildOperationInput('runtimes.create', options, {
-            body: {
-                type: 'browser',
-                spaceId: options.space,
-                name: options.name,
-                config: buildRuntimeCreateConfig(config, options),
-                metadata: typeof options.metadataFile === 'string'
-                    ? await readJsonFile(options.metadataFile, '--metadata-file')
-                    : undefined,
-            },
-            output: outputFlags(options),
-        }));
-    });
-}
-function collectLocale(value, previous) {
-    return [...previous, value];
-}
-function isRecord(value) {
-    return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
-function buildRuntimeCreateConfig(config, options) {
-    const fingerprint = {
-        ...(options.device ? { device: options.device } : {}),
-        ...(options.os ? { os: options.os } : {}),
-        ...(options.browser ? { browser: options.browser } : {}),
-        ...(options.browserVersion ? { browserVersion: options.browserVersion } : {}),
-        ...(options.locale && options.locale.length === 1 ? { locale: options.locale[0] } : {}),
-        ...(options.locale && options.locale.length > 1 ? { locale: options.locale } : {}),
-    };
-    const overrides = {
-        ...(options.profile === true ? { profile: true } : {}),
-        ...(options.proxy ? { proxy: options.proxy } : {}),
-        ...(Object.keys(fingerprint).length > 0 ? { fingerprint } : {}),
-    };
-    if (Object.keys(overrides).length === 0) {
-        return config;
-    }
-    if (config !== undefined && !isRecord(config)) {
-        throw new Error('--config-file must contain a JSON object when combined with runtime flags');
-    }
-    if (!isRecord(config)) {
-        return overrides;
-    }
-    return {
-        ...config,
-        ...overrides,
-        ...(isRecord(config.fingerprint) || 'fingerprint' in overrides
-            ? {
-                fingerprint: {
-                    ...(isRecord(config.fingerprint) ? config.fingerprint : {}),
-                    ...(isRecord(overrides.fingerprint) ? overrides.fingerprint : {}),
-                },
-            }
-            : {}),
-    };
-}
-function createRuntimePatchCommand(factory) {
-    return addOutputFlags(new Command('patch')
-        .description('Update a runtime')
-        .argument('<runtimeId>')
-        .option('--name <name>', 'Runtime name')
-        .option('--idle-timeout-seconds <seconds>', 'Idle timeout in seconds', parsePositiveInteger)
-        .option('--config-file <path>', 'Runtime config JSON file')
-        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')
-        .option('--body <json>', 'Request body as JSON (inline, @file, or - for stdin)')).action(async (runtimeId, options) => {
-        await requestOperationAndPrint(factory, 'runtimes.update', await buildOperationInput('runtimes.update', options, {
-            pathParams: { runtimeId },
-            body: {
-                name: options.name,
-                idleTimeoutSeconds: options.idleTimeoutSeconds,
-                config: typeof options.configFile === 'string'
-                    ? await readJsonFile(options.configFile, '--config-file')
-                    : undefined,
-            },
-            output: outputFlags(options),
-        }));
-    });
-}
-function createRuntimeStartCommand(factory) {
-    return addOutputFlags(new Command('start')
-        .description('Start a runtime')
-        .argument('<runtimeId>')
-        .option('--idempotency-key <key>', 'Idempotency key for retry-safe start')
-        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')).action(async (runtimeId, options) => {
-        await requestOperationAndPrint(factory, 'runtimes.start', await buildOperationInput('runtimes.start', options, {
-            pathParams: { runtimeId },
-            idempotencyKey: options.idempotencyKey,
-            output: outputFlags(options),
-        }));
-    });
-}
-function createRuntimeInvocationCommand(factory) {
-    const command = new Command('invocation').description('Create, wait for, and cancel invocations');
-    command.addCommand(createRuntimeInvocationCreateCommand(factory));
-    command.addCommand(createRuntimeInvocationWaitCommand(factory));
-    command.addCommand(addOutputFlags(new Command('cancel')
-        .description('Cancel an invocation')
-        .argument('<runtimeId>')
-        .argument('<invocationId>')
-        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')).action(async (runtimeId, invocationId, options) => {
-        await requestOperationAndPrint(factory, 'runtimes.invocations.cancel', await buildOperationInput('runtimes.invocations.cancel', options, {
-            pathParams: { runtimeId, invocationId },
-            output: outputFlags(options),
-        }));
-    }));
-    return command;
-}
-function createRuntimeInvocationCreateCommand(factory) {
-    return addOutputFlags(new Command('create')
-        .description('Create a runtime invocation')
-        .argument('<runtimeId>')
-        .option('--action <action>', 'Invocation action')
-        .option('--instruction <text>', 'Instruction for action/agent invocations')
-        .option('--target <target>', "Target to act on: 'active' (default), 'new', or a target id")
-        .option('--model <model>', 'Model id')
-        .option('--tool <id...>', 'Inline tool id')
-        .option('--toolset <id>', 'Toolset id')
-        .option('--timeout-seconds <seconds>', 'Invocation timeout in seconds', parsePositiveInteger)
-        .option('--idempotency-key <key>', 'Idempotency key for retry-safe create')
-        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')
-        .option('--body <json>', 'Request body as JSON (inline, @file, or - for stdin)')).action(async (runtimeId, options) => {
-        const body = {
-            action: options.action,
-            instruction: options.instruction,
-            target: options.target === undefined
-                ? undefined
-                : options.target === 'active' || options.target === 'new'
-                    ? options.target
-                    : { id: options.target },
-            model: options.model,
-            toolIds: options.tool,
-            toolsetId: options.toolset,
-            timeoutSeconds: options.timeoutSeconds,
-        };
-        await requestOperationAndPrint(factory, 'runtimes.invocations.create', await buildOperationInput('runtimes.invocations.create', options, {
-            pathParams: { runtimeId },
-            body: body,
-            idempotencyKey: options.idempotencyKey,
-            output: outputFlags(options),
-        }));
-    });
-}
-function createRuntimeInvocationWaitCommand(factory) {
-    return createOperationJsonBodyCommand(factory, {
-        operationId: 'runtimes.invocations.wait',
-        name: 'wait',
-        description: 'Wait for an invocation',
-        argNames: ['runtimeId', 'invocationId'],
-        configure: (cmd) => cmd
-            .option('--timeout-seconds <seconds>', 'Wait timeout in seconds', parsePositiveInteger),
-        body: async (_args, options) => {
-            return {
-                timeoutSeconds: options.timeoutSeconds,
-            };
-        },
-    });
-}
-function createRuntimeHumanActionCommand(factory) {
-    const command = new Command('human-action').description('Manage runtime human actions');
     command.addCommand(createOperationJsonBodyCommand(factory, {
-        operationId: 'runtimes.human-actions.create',
+        operationId: 'runtimes.create',
         name: 'create',
-        description: 'Request human action',
-        argNames: ['runtimeId'],
-        configure: (cmd) => cmd
-            .option('--message <message>', 'Instructions for the human')
-            .option('--timeout-seconds <seconds>', 'Human action timeout in seconds', parsePositiveInteger),
-        body: async (_args, options) => {
-            return {
-                message: options.message,
-                timeoutSeconds: options.timeoutSeconds,
-            };
-        },
+        description: 'Create a runtime',
     }));
-    command.addCommand(addOutputFlags(addCliOperationHelp(new Command('get')
-        .description('Get a human action')
-        .argument('<runtimeId>')
-        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)'), 'runtimes.human-actions.get')).action(async (runtimeId, options) => {
-        await requestOperationAndPrint(factory, 'runtimes.human-actions.get', await buildOperationInput('runtimes.human-actions.get', options, {
-            pathParams: { runtimeId },
-            output: outputFlags(options),
-        }));
+    command.addCommand(createOperationViewCommand(factory, {
+        operationId: 'runtimes.get',
+        name: 'get',
+        description: 'Get a runtime',
+        argName: 'runtimeId',
     }));
-    command.addCommand(addOutputFlags(addCliOperationHelp(new Command('complete')
-        .description('Complete a human action')
-        .argument('<runtimeId>')
-        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)'), 'runtimes.human-actions.complete')).action(async (runtimeId, options) => {
-        await requestOperationAndPrint(factory, 'runtimes.human-actions.complete', await buildOperationInput('runtimes.human-actions.complete', options, {
-            pathParams: { runtimeId },
-            output: outputFlags(options),
-        }));
+    command.addCommand(createOperationJsonBodyCommand(factory, {
+        operationId: 'runtimes.update',
+        name: 'patch',
+        description: 'Update a runtime',
+        argNames: ['runtimeId'],
     }));
-    command.addCommand(addOutputFlags(addCliOperationHelp(new Command('cancel')
-        .description('Cancel a human action')
-        .argument('<runtimeId>')
-        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)'), 'runtimes.human-actions.cancel')).action(async (runtimeId, options) => {
-        await requestOperationAndPrint(factory, 'runtimes.human-actions.cancel', await buildOperationInput('runtimes.human-actions.cancel', options, {
-            pathParams: { runtimeId },
-            output: outputFlags(options),
-        }));
+    command.addCommand(createOperationDeleteCommand(factory, {
+        operationId: 'runtimes.delete',
+        description: 'Delete a runtime',
+        argNames: ['runtimeId'],
     }));
-    command.addCommand(addOutputFlags(addCliOperationHelp(new Command('wait')
-        .description('Wait for a human action')
-        .argument('<runtimeId>')
-        .option('--timeout-seconds <seconds>', 'Long-poll timeout', parsePositiveInteger)
-        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')
-        .option('--body <json>', 'Request body as JSON (inline, @file, or - for stdin)'), 'runtimes.human-actions.wait')).action(async (runtimeId, options) => {
-        await requestOperationAndPrint(factory, 'runtimes.human-actions.wait', await buildOperationInput('runtimes.human-actions.wait', options, {
-            pathParams: { runtimeId },
-            body: {
-                timeoutSeconds: options.timeoutSeconds,
-            },
-            output: outputFlags(options),
-        }));
+    command.addCommand(createOperationJsonBodyCommand(factory, {
+        operationId: 'runtimes.start',
+        name: 'start',
+        description: 'Start a runtime',
+        argNames: ['runtimeId'],
     }));
-    return command;
-}
-function createRuntimeFileCommand(factory) {
-    const command = new Command('file').description('Move files into and out of runtimes');
-    command.addCommand(addOutputFlags(addPaginationFlags(new Command('list').description('List runtime files').argument('<runtimeId>'))
-        .option('--type <type>', 'Filter by file type')
-        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')).action(async (runtimeId, options) => {
-        await requestOperationAndPrint(factory, 'runtimes.files.list', await buildOperationInput('runtimes.files.list', options, {
-            pathParams: { runtimeId },
-            query: {
-                type: options.type,
-                limit: options.limit,
-                cursor: options.cursor,
-            },
-            output: outputFlags(options),
-        }));
+    command.addCommand(createOperationJsonBodyCommand(factory, {
+        operationId: 'runtimes.stop',
+        name: 'stop',
+        description: 'Stop a runtime',
+        argNames: ['runtimeId'],
     }));
-    command.addCommand(createRuntimeFileUploadCommand(factory));
-    command.addCommand(createRuntimeFileStageCommand(factory));
-    command.addCommand(createRuntimeFileCollectCommand(factory));
     return command;
 }
-function createRuntimeFileUploadCommand(factory) {
-    return addOutputFlags(new Command('upload')
-        .description('Upload a local file into a runtime workspace')
-        .argument('<runtimeId>')
-        .argument('<localPath>')
-        .option('--destination-path <path>', 'Durable BCTRL storage destination')
-        .option('--runtime-path <path>', 'Runtime workspace destination')
-        .option('--name <name>', 'Display name')
-        .option('--metadata <json>', 'Metadata as inline JSON (overrides --metadata-file)')
-        .option('--metadata-file <path>', 'Metadata JSON file')).action(async (runtimeId, localPath, options) => {
-        const file = await readBlob(localPath);
-        const metadata = options.metadata !== undefined
-            ? JSON.stringify(parseJsonString(options.metadata, '--metadata'))
-            : typeof options.metadataFile === 'string'
-                ? JSON.stringify(await readJsonFile(options.metadataFile, '--metadata-file'))
-                : undefined;
-        const result = await uploadOperationFile(factory, 'runtimes.files.upload', {
-            pathParams: { runtimeId },
-            file: file.blob,
-            fileName: options.name ?? file.fileName,
-            fields: {
-                ...(options.destinationPath ? { destinationPath: options.destinationPath } : {}),
-                ...(options.runtimePath ? { runtimePath: options.runtimePath } : {}),
-                ...(options.name ? { name: options.name } : {}),
-                ...(metadata ? { metadata } : {}),
-            },
-        });
-        await outputData(factory.io, result, options);
-    });
-}
-function createRuntimeFileStageCommand(factory) {
-    return createOperationJsonBodyCommand(factory, {
-        operationId: 'runtimes.files.stage',
-        name: 'stage',
-        description: 'Stage a durable file into a runtime',
-        argNames: ['runtimeId'],
-        configure: (cmd) => cmd
-            .option('--file <id>', 'Durable file id')
-            .option('--runtime-path <path>', 'Runtime workspace destination')
-            .option('--name <name>', 'Runtime-local display name'),
-        body: async (_args, options) => {
-            return {
-                fileId: options.file,
-                runtimePath: options.runtimePath,
-                name: options.name,
-            };
-        },
-    });
-}
-function createRuntimeFileCollectCommand(factory) {
-    return createOperationJsonBodyCommand(factory, {
-        operationId: 'runtimes.files.collect',
-        name: 'collect',
-        description: 'Collect a runtime-local file into durable storage',
-        argNames: ['runtimeId'],
-        configure: (cmd) => cmd
-            .requiredOption('--runtime-path <path>', 'Runtime workspace source')
-            .option('--name <name>', 'Durable file name')
-            .option('--destination-path <path>', 'Durable BCTRL storage destination'),
-        body: async (_args, options) => {
-            return {
-                runtimePath: options.runtimePath,
-                name: options.name,
-                destinationPath: options.destinationPath,
-            };
-        },
-    });
-}

package/dist/commands/shared/operation.d.ts

@@ -43,6 +43,7 @@ type OperationBodyInput<OperationId extends CliOperationId> = [
 export type OperationRequestInput<OperationId extends CliOperationId> = OperationPathInput<OperationId> & OperationQueryInput<OperationId> & OperationBodyInput<OperationId> & {
     idempotencyKey?: string;
     actingSubaccountId?: string;
+    runtimeId?: string;
     output?: OutputFlags;
 };
 export declare function optionString(options: Record<string, unknown>, name: string): string | undefined;
@@ -94,6 +95,7 @@ export declare function streamOperationText<OperationId extends CliOperationId>(
 export declare function createOperationListCommand<OperationId extends CliOperationId>(factory: ApiDeps, config: {
     operationId: OperationId;
     name?: string;
+    argNames?: string[];
     description: string;
     configure?: (command: Command) => Command;
     query?: (options: Record<string, unknown>) => CliOperationQuery<OperationId>;
@@ -126,5 +128,6 @@ export declare function createOperationJsonBodyCommand<OperationId extends CliOp
     body?: (args: Record<string, string>, options: Record<string, unknown>) => Promise<CliOperationJsonBody<OperationId>>;
     query?: (args: Record<string, string>, options: Record<string, unknown>) => CliOperationQuery<OperationId>;
     actingSubaccountId?: (args: Record<string, string>, options: Record<string, unknown>) => string | undefined;
+    runtimeId?: (args: Record<string, string>, options: Record<string, unknown>) => string | undefined;
 }): Command;
 export {};

package/dist/commands/shared/operation.js

@@ -122,6 +122,8 @@ export async function buildOperationInput(operationId, options, curated) {
         merged.idempotencyKey = c.idempotencyKey;
     if (c.actingSubaccountId)
         merged.actingSubaccountId = c.actingSubaccountId;
+    if (c.runtimeId)
+        merged.runtimeId = c.runtimeId;
     if (c.output)
         merged.output = c.output;
     return merged;
@@ -171,6 +173,7 @@ export async function requestOperation(deps, operationId, input) {
         ...('body' in input && input.body !== undefined ? { body: input.body } : {}),
         ...(input.idempotencyKey ? { idempotencyKey: input.idempotencyKey } : {}),
         ...(input.actingSubaccountId ? { actingSubaccountId: input.actingSubaccountId } : {}),
+        ...(input.runtimeId ? { runtimeId: input.runtimeId } : {}),
     };
     const options = Object.keys(requestOptions).length > 0 ? requestOptions : undefined;
     const result = route.method === 'get'
@@ -179,9 +182,7 @@ export async function requestOperation(deps, operationId, input) {
             ? await client.post(path, options)
             : route.method === 'patch'
                 ? await client.patch(path, options)
-                : route.method === 'put'
-                    ? await client.put(path, options)
-                    : await client.delete(path, options);
+                : await client.delete(path, options);
     return result;
 }
 export async function uploadOperationFile(deps, operationId, input) {
@@ -208,17 +209,26 @@ export async function streamOperationText(deps, operationId, input) {
     });
 }
 export function createOperationListCommand(factory, config) {
+    const argNames = config.argNames ?? [];
     let command = new Command(config.name ?? 'list').description(config.description);
     command = addCliOperationHelp(command, config.operationId);
+    for (const arg of argNames)
+        command = command.argument(`<${arg}>`);
     command = config.configure ? config.configure(command) : addPaginationFlags(command);
     command = addRequestOverrideFlags(command);
     command = addOutputFlags(command);
-    return command.action(async (options) => {
+    return command.action(async (...actionArgs) => {
+        const options = getActionOptions(actionArgs);
+        const args = {};
+        for (let i = 0; i < argNames.length; i += 1)
+            args[argNames[i]] = String(actionArgs[i]);
         const overrides = await resolveRequestOverrides(config.operationId, options);
         const curatedQuery = config.query ? config.query(options) : defaultListQuery(options);
         const actingSubaccountId = config.actingSubaccountId?.(options);
         await requestOperationAndPrint(factory, config.operationId, withActingSubaccount({
-            ...(overrides.pathParams ? { pathParams: overrides.pathParams } : {}),
+            ...(argNames.length > 0 || overrides.pathParams
+                ? { pathParams: overlayDefined(overrides.pathParams, args) }
+                : {}),
             query: overlayDefined(overrides.query, curatedQuery),
             output: outputFlags(options),
         }, actingSubaccountId));
@@ -293,12 +303,15 @@ export function createOperationJsonBodyCommand(factory, config) {
         const body = overrides.body !== undefined ? overrides.body : (curatedBody ?? {});
         const curatedQuery = config.query ? config.query(args, options) : undefined;
         const actingSubaccountId = config.actingSubaccountId?.(args, options);
-        await requestOperationAndPrint(factory, config.operationId, withActingSubaccount({
+        const runtimeId = config.runtimeId?.(args, options);
+        const requestInput = withActingSubaccount({
             pathParams: overlayDefined(overrides.pathParams, args),
             body,
             query: overlayDefined(overrides.query, curatedQuery),
             output: outputFlags(options),
-        }, actingSubaccountId));
+            ...(runtimeId ? { runtimeId } : {}),
+        }, actingSubaccountId);
+        await requestOperationAndPrint(factory, config.operationId, requestInput);
     });
 }
 function defaultListQuery(options) {

package/dist/commands/space/index.js

@@ -54,30 +54,5 @@ export function createSpaceCommand(factory) {
             output: outputFlags(options),
         }));
     }));
-    command.addCommand(createSpaceEnvironmentCommand(factory));
-    return command;
-}
-function createSpaceEnvironmentCommand(factory) {
-    const command = new Command('env').description('Manage a space environment');
-    command.addCommand(addOutputFlags(new Command('get')
-        .description('Get a space environment')
-        .argument('<spaceId>')
-        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')).action(async (spaceId, options) => {
-        await requestOperationAndPrint(factory, 'spaces.environment.get', await buildOperationInput('spaces.environment.get', options, {
-            pathParams: { spaceId },
-            output: outputFlags(options),
-        }));
-    }));
-    command.addCommand(addOutputFlags(new Command('patch')
-        .description('Update a space environment')
-        .argument('<spaceId>')
-        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')
-        .option('--body <json>', 'Request body as JSON (inline, @file, or - for stdin)')).action(async (spaceId, options) => {
-        await requestOperationAndPrint(factory, 'spaces.environment.update', await buildOperationInput('spaces.environment.update', options, {
-            pathParams: { spaceId },
-            body: {},
-            output: outputFlags(options),
-        }));
-    }));
     return command;
 }

package/dist/commands/subaccount/index.js

@@ -14,13 +14,13 @@ export function createSubaccountCommand(factory) {
             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,
+            q: typeof options.q === 'string' ? options.q : 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'),
+            .option('--q <text>', 'Search by id, name, or external id'),
     }));
     command.addCommand(createOperationViewCommand(factory, {
         operationId: 'subaccounts.get',