@bctrl/cli 0.1.2 → 0.1.4

package/dist/commands/runtime/index.js

@@ -1,12 +1,10 @@
-import { Command } from 'commander';
-import { CliError } from '../../runtime/errors.js';
-import { addCliHelp } from '../shared/help.js';
-import { readBlob, readJsonFile, writeBinary } from '../shared/io.js';
+import { Command, Option } from 'commander';
+import { readBlob, readJsonFile } from '../shared/io.js';
 import { parsePositiveInteger } from '../shared/options.js';
 import { addOutputFlags, outputData } from '../shared/output.js';
-import { addPaginationFlags, createJsonBodyCommand, createListCommand, createViewCommand, pathTemplate, requestAndPrint, } from '../shared/rest.js';
+import { addPaginationFlags, createDeleteCommand, createJsonBodyCommand, createListCommand, createViewCommand, requestAndPrint, } from '../shared/rest.js';
 export function createRuntimeCommand(factory) {
-    const command = new Command('runtime').description('Create, start, stop, and manage BCTRL runtimes');
+    const command = new Command('runtime').description('Manage runtimes');
     command.addCommand(createListCommand(factory, {
         description: 'List runtimes',
         path: '/runtimes',
@@ -21,188 +19,339 @@ export function createRuntimeCommand(factory) {
         }),
     }));
     command.addCommand(createViewCommand(factory, {
-        description: 'View a runtime',
-        path: '/runtimes/{id}',
+        name: 'get',
+        description: 'Get a runtime',
+        path: '/runtimes/{runtimeId}',
+        argName: 'runtimeId',
     }));
-    command.addCommand(addCliHelp(createJsonBodyCommand(factory, {
+    command.addCommand(createRuntimeCreateCommand(factory));
+    command.addCommand(createRuntimePatchCommand(factory));
+    command.addCommand(createDeleteCommand(factory, {
+        description: 'Delete a runtime and its browser state',
+        path: '/runtimes/{runtimeId}',
+        argNames: ['runtimeId'],
+        configure: (cmd) => cmd.option('--force', 'Stop the runtime first if it is still active'),
+        query: (_args, options) => ({ force: options.force === true ? true : undefined }),
+    }));
+    command.addCommand(createRuntimeStartCommand(factory));
+    command.addCommand(addOutputFlags(new Command('stop').description('Stop a runtime').argument('<runtimeId>')).action(async (runtimeId, options) => {
+        await requestAndPrint(factory, 'post', `/runtimes/${encodeURIComponent(runtimeId)}/stop`, {
+            output: options,
+        });
+    }));
+    command.addCommand(createRuntimeFileCommand(factory));
+    command.addCommand(createRuntimeInvocationCommand(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>')).action(async (runtimeId, options) => {
+        await requestAndPrint(factory, 'get', `/runtimes/${encodeURIComponent(runtimeId)}/targets`, {
+            output: 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')).action(async (runtimeId, options) => {
+        await requestAndPrint(factory, 'post', `/runtimes/${encodeURIComponent(runtimeId)}/targets`, {
+            body: {
+                ...(options.uri ? { uri: options.uri } : {}),
+                ...(options.activate ? { activate: true } : {}),
+            },
+            output: options,
+        });
+    }));
+    command.addCommand(addOutputFlags(new Command('get').description('Get a target').argument('<runtimeId>').argument('<targetId>')).action(async (runtimeId, targetId, options) => {
+        await requestAndPrint(factory, 'get', `/runtimes/${encodeURIComponent(runtimeId)}/targets/${encodeURIComponent(targetId)}`, { output: options });
+    }));
+    command.addCommand(addOutputFlags(new Command('activate')
+        .description('Focus a target')
+        .argument('<runtimeId>')
+        .argument('<targetId>')).action(async (runtimeId, targetId, options) => {
+        await requestAndPrint(factory, 'post', `/runtimes/${encodeURIComponent(runtimeId)}/targets/${encodeURIComponent(targetId)}/activate`, { output: options });
+    }));
+    command.addCommand(addOutputFlags(new Command('delete')
+        .description('Close a target')
+        .argument('<runtimeId>')
+        .argument('<targetId>')).action(async (runtimeId, targetId, options) => {
+        await requestAndPrint(factory, 'delete', `/runtimes/${encodeURIComponent(runtimeId)}/targets/${encodeURIComponent(targetId)}`, { output: options });
+    }));
+    return command;
+}
+function createRuntimeCreateCommand(factory) {
+    return createJsonBodyCommand(factory, {
         name: 'create',
         description: 'Create a runtime',
         method: 'post',
         path: '/runtimes',
         configure: (cmd) => cmd
-            .option('--space <id>', 'Space id')
+            .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('--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.space !== 'string' || options.space.length === 0) {
-                throw new CliError('runtime create requires --space unless --input is used');
-            }
+            const config = typeof options.configFile === 'string'
+                ? await readJsonFile(options.configFile, '--config-file')
+                : undefined;
             return {
                 type: 'browser',
                 spaceId: options.space,
                 name: options.name,
-                config: typeof options.configFile === 'string' ? await readJsonFile(options.configFile, '--config-file') : undefined,
+                config: buildRuntimeCreateConfig(config, options),
                 metadata: typeof options.metadataFile === 'string'
                     ? await readJsonFile(options.metadataFile, '--metadata-file')
                     : undefined,
             };
         },
-    }), 'runtime.create'));
-    command.addCommand(addCliHelp(addOutputFlags(new Command('start')
+    });
+}
+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 createJsonBodyCommand(factory, {
+        name: 'patch',
+        description: 'Update a runtime',
+        method: 'patch',
+        path: '/runtimes/{runtimeId}',
+        argNames: ['runtimeId'],
+        configure: (cmd) => cmd
+            .option('--name <name>', 'Runtime name')
+            .option('--idle-timeout-minutes <minutes>', 'Idle timeout in minutes', parsePositiveInteger)
+            .option('--config-file <path>', 'Runtime config 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,
+                idleTimeoutMinutes: options.idleTimeoutMinutes,
+                config: typeof options.configFile === 'string'
+                    ? await readJsonFile(options.configFile, '--config-file')
+                    : undefined,
+            };
+        },
+    });
+}
+function createRuntimeStartCommand(factory) {
+    return addOutputFlags(new Command('start')
         .description('Start a runtime')
-        .argument('<id>'))
-        .action(async (id, options) => {
-        await requestAndPrint(factory, 'post', `/runtimes/${encodeURIComponent(id)}/start`, {
-            output: options,
-        });
-    }), 'runtime.start'));
-    command.addCommand(addOutputFlags(new Command('stop')
-        .description('Stop a runtime')
-        .argument('<id>'))
-        .action(async (id, options) => {
-        await requestAndPrint(factory, 'post', `/runtimes/${encodeURIComponent(id)}/stop`, {
-            output: options,
-        });
-    }));
-    command.addCommand(createRuntimeConnectionCommand(factory));
-    command.addCommand(createRuntimeFileCommand(factory));
-    command.addCommand(addOutputFlags(new Command('runs')
-        .description('List runs for a runtime')
-        .argument('<id>')
-        .option('-L, --limit <number>', 'Maximum number of results to return', parsePositiveInteger)
-        .option('--cursor <cursor>', 'Pagination cursor'))
-        .action(async (id, options) => {
-        await requestAndPrint(factory, 'get', `/runtimes/${encodeURIComponent(id)}/runs`, {
-            query: { limit: options.limit, cursor: options.cursor },
+        .argument('<runtimeId>')
+        .option('--idempotency-key <key>', 'Idempotency key for retry-safe start')).action(async (runtimeId, options) => {
+        await requestAndPrint(factory, 'post', `/runtimes/${encodeURIComponent(runtimeId)}/start`, {
+            idempotencyKey: options.idempotencyKey,
             output: 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>')).action(async (runtimeId, invocationId, options) => {
+        await requestAndPrint(factory, 'post', `/runtimes/${encodeURIComponent(runtimeId)}/invocations/${encodeURIComponent(invocationId)}/cancel`, { output: options });
     }));
     return command;
 }
-function createRuntimeConnectionCommand(factory) {
-    const command = new Command('connection').description('Manage runtime connections');
-    command.addCommand(addOutputFlags(new Command('list')
-        .description('List runtime connections')
-        .argument('<runtime>')
-        .option('--status <status>', 'Filter by connection status')
-        .option('-L, --limit <number>', 'Maximum number of results to return', parsePositiveInteger))
-        .action(async (runtime, options) => {
-        await requestAndPrint(factory, 'get', `/runtimes/${encodeURIComponent(runtime)}/connections`, {
-            query: { status: options.status, limit: options.limit },
+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-ms <ms>', 'Invocation timeout in milliseconds', parsePositiveInteger)
+        .option('--idempotency-key <key>', 'Idempotency key for retry-safe create')
+        .option('--input <path>', 'Read full JSON request body from file, or - for stdin')).action(async (runtimeId, options) => {
+        const body = typeof options.input === 'string'
+            ? await readJsonFile(options.input)
+            : {
+                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,
+                timeoutMs: options.timeoutMs,
+            };
+        await requestAndPrint(factory, 'post', `/runtimes/${encodeURIComponent(runtimeId)}/invocations`, {
+            body,
+            idempotencyKey: options.idempotencyKey,
             output: options,
         });
-    }));
-    command.addCommand(addCliHelp(createJsonBodyCommand(factory, {
-        name: 'create',
-        description: 'Create a runtime connection',
+    });
+}
+function createRuntimeInvocationWaitCommand(factory) {
+    return createJsonBodyCommand(factory, {
+        name: 'wait',
+        description: 'Wait for an invocation',
         method: 'post',
-        path: '/runtimes/{runtime}/connections',
-        argNames: ['runtime'],
+        path: '/runtimes/{runtimeId}/invocations/{invocationId}/wait',
+        argNames: ['runtimeId', 'invocationId'],
         configure: (cmd) => cmd
-            .option('--protocol <protocol>', 'Connection protocol', 'cdp')
+            .option('--timeout-ms <ms>', 'Wait timeout in milliseconds', parsePositiveInteger)
             .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 {
-                protocol: options.protocol,
-            };
+            return { timeoutMs: options.timeoutMs };
         },
-    }), 'runtime.connection.create'));
-    command.addCommand(addOutputFlags(new Command('delete')
-        .description('Revoke a runtime connection')
-        .argument('<runtime>')
-        .argument('<connection>'))
-        .action(async (runtime, connection, options) => {
-        await requestAndPrint(factory, 'delete', pathTemplate('/runtimes/{runtime}/connections/{connection}', { runtime, connection }), { output: options });
-    }));
-    return command;
+    });
 }
 function createRuntimeFileCommand(factory) {
     const command = new Command('file').description('Move files into and out of runtimes');
-    command.addCommand(addOutputFlags(new Command('push')
-        .description('Upload and stage a local file into a runtime')
-        .argument('<runtime>')
-        .argument('<local-path>')
-        .option('--storage-path <path>', 'Advanced: durable BCTRL storage path')
+    command.addCommand(addOutputFlags(addPaginationFlags(new Command('list').description('List runtime files').argument('<runtimeId>'))
+        .option('--type <type>', 'Filter by file type')).action(async (runtimeId, options) => {
+        await requestAndPrint(factory, 'get', `/runtimes/${encodeURIComponent(runtimeId)}/files`, {
+            query: { type: options.type, limit: options.limit, cursor: options.cursor },
+            output: options,
+        });
+    }));
+    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-file <path>', 'Metadata JSON file'))
-        .action(async (runtime, localPath, options) => {
+        .option('--metadata-file <path>', 'Metadata JSON file')).action(async (runtimeId, localPath, options) => {
         const client = await factory.apiClient();
         const file = await readBlob(localPath);
         const metadata = typeof options.metadataFile === 'string'
             ? JSON.stringify(await readJsonFile(options.metadataFile, '--metadata-file'))
             : undefined;
-        const result = await client.uploadFile(`/runtimes/${encodeURIComponent(runtime)}/files/upload`, {
+        const result = await client.uploadFile(`/runtimes/${encodeURIComponent(runtimeId)}/files/upload`, {
             file: file.blob,
             fileName: options.name ?? file.fileName,
             fields: {
-                ...(options.storagePath ? { storagePath: options.storagePath } : {}),
+                ...(options.destinationPath ? { destinationPath: options.destinationPath } : {}),
+                ...(options.runtimePath ? { runtimePath: options.runtimePath } : {}),
                 ...(options.name ? { name: options.name } : {}),
                 ...(metadata ? { metadata } : {}),
             },
         });
         await outputData(factory.io, result, options);
-    }));
-    command.addCommand(addOutputFlags(new Command('pull')
-        .description('Collect a runtime file and download it locally')
-        .argument('<runtime>')
-        .argument('<runtime-path>')
-        .requiredOption('--to <path>', 'Output path, or - for stdout')
-        .option('--name <name>', 'Durable file name')
-        .option('--storage-path <path>', 'Advanced: durable BCTRL storage path'))
-        .action(async (runtime, runtimePath, options) => {
-        const client = await factory.apiClient();
-        const collected = await client.post(`/runtimes/${encodeURIComponent(runtime)}/files/collect`, {
-            body: {
-                path: runtimePath,
-                name: options.name,
-                storagePath: options.storagePath,
-            },
-        });
-        if (!collected.id) {
-            throw new CliError('Expected runtime file collect response to include id');
-        }
-        const data = await client.download(`/files/${encodeURIComponent(collected.id)}/content`);
-        await writeBinary(options.to, data);
-    }));
-    command.addCommand(createJsonBodyCommand(factory, {
+    });
+}
+function createRuntimeFileStageCommand(factory) {
+    return createJsonBodyCommand(factory, {
         name: 'stage',
         description: 'Stage a durable file into a runtime',
         method: 'post',
-        path: '/runtimes/{runtime}/files/stage',
-        argNames: ['runtime'],
+        path: '/runtimes/{runtimeId}/files/stage',
+        argNames: ['runtimeId'],
         configure: (cmd) => cmd
             .option('--file <id>', 'Durable file id')
-            .option('--storage-path <path>', 'Advanced: durable BCTRL storage path')
-            .option('--name <name>', 'Runtime-local name')
+            .option('--runtime-path <path>', 'Runtime workspace destination')
+            .option('--name <name>', 'Runtime-local display 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 { fileId: options.file, storagePath: options.storagePath, name: options.name };
+            return { fileId: options.file, runtimePath: options.runtimePath, name: options.name };
         },
-    }));
-    command.addCommand(createJsonBodyCommand(factory, {
+    });
+}
+function createRuntimeFileCollectCommand(factory) {
+    return createJsonBodyCommand(factory, {
         name: 'collect',
         description: 'Collect a runtime-local file into durable storage',
         method: 'post',
-        path: '/runtimes/{runtime}/files/collect',
-        argNames: ['runtime'],
+        path: '/runtimes/{runtimeId}/files/collect',
+        argNames: ['runtimeId'],
         configure: (cmd) => cmd
-            .requiredOption('--path <path>', 'Runtime-local path')
+            .requiredOption('--runtime-path <path>', 'Runtime workspace source')
             .option('--name <name>', 'Durable file name')
-            .option('--storage-path <path>', 'Advanced: durable BCTRL storage path')
+            .option('--destination-path <path>', 'Durable BCTRL storage destination')
             .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 { path: options.path, name: options.name, storagePath: options.storagePath };
+            return {
+                runtimePath: options.runtimePath,
+                name: options.name,
+                destinationPath: options.destinationPath,
+            };
         },
-    }));
-    return command;
+    });
 }

package/dist/commands/shared/help.js

@@ -10,7 +10,7 @@ function toCommandHelpSpec(help) {
     const raw = help;
     return {
         purpose: raw.summary,
-        flags: raw.flags?.map((flag) => ({ ...flag })),
+        flags: raw.cli?.flags?.map((flag) => ({ ...flag })),
         input: raw.input?.fields.map((field) => ({ ...field })),
         output: raw.output?.fields.map((field) => ({ ...field })),
         examples: raw.examples?.map(formatHelpItem).filter((value) => Boolean(value)),

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

@@ -14,6 +14,7 @@ export declare function addJsonBodyFlag(command: Command): Command;
 export declare function requestAndPrint(deps: ApiDeps, method: ClientMethod, path: string, options?: {
     query?: Record<string, string | number | boolean | undefined>;
     body?: unknown;
+    idempotencyKey?: string;
     output?: OutputFlags;
 }): Promise<void>;
 export declare function bodyFromInputOption(path: string | undefined): Promise<unknown>;

package/dist/commands/shared/rest.js

@@ -16,16 +16,24 @@ export function addJsonBodyFlag(command) {
 }
 export async function requestAndPrint(deps, method, path, options) {
     const client = await deps.apiClient();
+    const requestOptions = options
+        ? {
+            ...(options.query !== undefined ? { query: options.query } : {}),
+            ...(options.body !== undefined ? { body: options.body } : {}),
+            ...(options.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : {}),
+        }
+        : undefined;
+    const clientOptions = requestOptions && Object.keys(requestOptions).length > 0 ? requestOptions : undefined;
     const result = method === 'get'
-        ? await client.get(path, options)
+        ? await client.get(path, clientOptions)
         : method === 'post'
-            ? await client.post(path, options)
+            ? await client.post(path, clientOptions)
             : method === 'patch'
-                ? await client.patch(path, options)
+                ? await client.patch(path, clientOptions)
                 : method === 'put'
-                    ? await client.put(path, options)
-                    : await client.delete(path, options);
-    await outputData(deps.io, result, options?.output);
+                    ? await client.put(path, clientOptions)
+                    : await client.delete(path, clientOptions);
+    await outputData(deps.io, result, options?.output ? outputFlags(options.output) : undefined);
 }
 export async function bodyFromInputOption(path) {
     return path ? readJsonFile(path) : {};

package/dist/commands/space/index.js

@@ -1,14 +1,15 @@
 import { Command } from 'commander';
-import { createJsonBodyCommand, createViewCommand } from '../shared/rest.js';
+import { createDeleteCommand, createJsonBodyCommand, createViewCommand } from '../shared/rest.js';
 import { readJsonFile } from '../shared/io.js';
-import { addOutputFlags, outputData } from '../shared/output.js';
 import { createSpaceListCommand } from './list.js';
 export function createSpaceCommand(factory) {
     const command = new Command('space').description('Manage BCTRL spaces');
     command.addCommand(createSpaceListCommand(factory));
     command.addCommand(createViewCommand(factory, {
+        name: 'get',
         description: 'View a space',
-        path: '/spaces/{id}',
+        path: '/spaces/{spaceId}',
+        argName: 'spaceId',
     }));
     command.addCommand(createJsonBodyCommand(factory, {
         name: 'create',
@@ -17,7 +18,6 @@ export function createSpaceCommand(factory) {
         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) => {
@@ -25,17 +25,16 @@ export function createSpaceCommand(factory) {
                 return readJsonFile(options.input);
             return {
                 name: options.name,
-                region: options.region,
                 subaccountId: options.subaccountId,
             };
         },
     }));
     command.addCommand(createJsonBodyCommand(factory, {
-        name: 'edit',
+        name: 'patch',
         description: 'Edit a space',
         method: 'patch',
-        path: '/spaces/{id}',
-        argNames: ['id'],
+        path: '/spaces/{spaceId}',
+        argNames: ['spaceId'],
         configure: (cmd) => cmd
             .option('--name <name>', 'Space name')
             .option('--input <path>', 'Read JSON request body from file, or - for stdin'),
@@ -45,8 +44,12 @@ export function createSpaceCommand(factory) {
             return { name: options.name };
         },
     }));
+    command.addCommand(createDeleteCommand(factory, {
+        description: 'Delete a space',
+        path: '/spaces/{spaceId}',
+        argNames: ['spaceId'],
+    }));
     command.addCommand(createSpaceEnvironmentCommand(factory));
-    command.addCommand(createSpaceAgentContextCommand(factory));
     return command;
 }
 function createSpaceEnvironmentCommand(factory) {
@@ -54,33 +57,15 @@ function createSpaceEnvironmentCommand(factory) {
     command.addCommand(createViewCommand(factory, {
         name: 'get',
         description: 'Get a space environment',
-        path: '/spaces/{id}/environment',
+        path: '/spaces/{spaceId}/environment',
+        argName: 'spaceId',
     }));
     command.addCommand(createJsonBodyCommand(factory, {
-        name: 'set',
+        name: 'patch',
         description: 'Update a space environment',
         method: 'patch',
-        path: '/spaces/{id}/environment',
-        argNames: ['id'],
+        path: '/spaces/{spaceId}/environment',
+        argNames: ['spaceId'],
     }));
     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;