@bctrl/cli 0.1.3 → 0.1.5

package/dist/commands/file/index.js

@@ -2,16 +2,18 @@ import { Command } from 'commander';
 import { readBlob, readJsonFile, writeBinary } from '../shared/io.js';
 import { parsePositiveInteger } from '../shared/options.js';
 import { addOutputFlags, outputData } from '../shared/output.js';
-import { createDeleteCommand, createJsonBodyCommand, createListCommand, createViewCommand, } from '../shared/rest.js';
+import { createOperationDeleteCommand, createOperationJsonBodyCommand, createOperationListCommand, createOperationViewCommand, downloadOperation, uploadOperationFile, } from '../shared/operation.js';
 export function createFileCommand(factory) {
     const command = new Command('file').description('Upload, download, and manage BCTRL files');
-    command.addCommand(createListCommand(factory, {
+    command.addCommand(createOperationListCommand(factory, {
+        operationId: 'files.list',
         description: 'List files',
-        path: '/files',
         configure: (cmd) => cmd
             .option('--space <id>', 'Filter by space id')
             .option('--source <source>', 'Filter by file source')
             .option('--prefix <path>', 'Filter by path prefix')
+            .option('--folders', 'Directory view: direct files plus subfolder rollups')
+            .option('--created-after <iso>', 'Only files created after this timestamp')
             .option('--query <text>', 'Search query')
             .option('-L, --limit <number>', 'Maximum number of results to return', parsePositiveInteger)
             .option('--cursor <cursor>', 'Pagination cursor'),
@@ -19,26 +21,28 @@ export function createFileCommand(factory) {
             spaceId: typeof options.space === 'string' ? options.space : undefined,
             source: typeof options.source === 'string' ? options.source : undefined,
             prefix: typeof options.prefix === 'string' ? options.prefix : undefined,
-            query: typeof options.query === 'string' ? options.query : undefined,
+            include: options.folders === true ? 'folders' : undefined,
+            createdAfter: typeof options.createdAfter === 'string' ? options.createdAfter : undefined,
+            // The public query param is `q` (was sent as `query`, which the API ignores).
+            q: typeof options.query === 'string' ? options.query : undefined,
             limit: typeof options.limit === 'number' ? options.limit : undefined,
             cursor: typeof options.cursor === 'string' ? options.cursor : undefined,
         }),
     }));
-    command.addCommand(createViewCommand(factory, {
+    command.addCommand(createOperationViewCommand(factory, {
+        operationId: 'files.get',
+        name: 'get',
         description: 'View file metadata',
-        path: '/files/{fileId}',
         argName: 'fileId',
     }));
     command.addCommand(addOutputFlags(new Command('upload')
         .description('Upload a file')
         .argument('<path>')
-        .requiredOption('--space <id>', 'Space id')
+        .option('--space <id>', 'Space id; omitted uses caller default space')
         .option('--path <storagePath>', 'Storage path')
-        .option('--name <name>', 'Display name'))
-        .action(async (path, options) => {
-        const client = await factory.apiClient();
+        .option('--name <name>', 'Display name')).action(async (path, options) => {
         const file = await readBlob(path);
-        const result = await client.uploadFile('/files', {
+        const result = await uploadOperationFile(factory, 'files.upload', {
             file: file.blob,
             fileName: options.name ?? file.fileName,
             query: { spaceId: options.space },
@@ -54,23 +58,24 @@ export function createFileCommand(factory) {
         .argument('<id>')
         .requiredOption('--to <path>', 'Output path, or - for stdout')
         .action(async (id, options) => {
-        const client = await factory.apiClient();
-        const data = await client.download(`/files/${encodeURIComponent(id)}/content`);
+        const data = await downloadOperation(factory, 'files.content', {
+            pathParams: { fileId: id },
+        });
         await writeBinary(options.to, data);
     }));
-    command.addCommand(createJsonBodyCommand(factory, {
-        name: 'edit',
+    command.addCommand(createOperationJsonBodyCommand(factory, {
+        operationId: 'files.update',
+        name: 'patch',
         description: 'Edit file metadata',
-        method: 'patch',
-        path: '/files/{fileId}',
         argNames: ['fileId'],
         configure: (cmd) => cmd
             .option('--name <name>', 'Display name')
             .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,
                 metadata: typeof options.metadataFile === 'string'
@@ -79,9 +84,9 @@ export function createFileCommand(factory) {
             };
         },
     }));
-    command.addCommand(createDeleteCommand(factory, {
+    command.addCommand(createOperationDeleteCommand(factory, {
+        operationId: 'files.delete',
         description: 'Delete a file',
-        path: '/files/{fileId}',
         argNames: ['fileId'],
     }));
     return command;

package/dist/commands/{invocation → help}/index.d.ts

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

package/dist/commands/help/index.js

@@ -0,0 +1,17 @@
+import { Command } from 'commander';
+import { addOutputFlags } from '../shared/output.js';
+import { outputFlags, requestOperationAndPrint } from '../shared/operation.js';
+export function createHelpCommand(factory) {
+    return addOutputFlags(new Command('help')
+        .description('Get BCTRL API help')
+        .option('--topic <topic>', 'Help topic')
+        .option('--audience <audience>', 'Help audience')).action(async (options) => {
+        await requestOperationAndPrint(factory, 'help', {
+            query: {
+                topic: options.topic,
+                audience: options.audience,
+            },
+            output: outputFlags(options),
+        });
+    });
+}

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

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

package/dist/commands/proxy/index.js

@@ -0,0 +1,72 @@
+import { Command } from 'commander';
+import { addOutputFlags } from '../shared/output.js';
+import { addPaginationFlags, createOperationDeleteCommand, createOperationJsonBodyCommand, createOperationListCommand, createOperationViewCommand, outputFlags, requestOperationAndPrint, } from '../shared/operation.js';
+export function createProxyCommand(factory) {
+    const command = new Command('proxy').description('Manage proxies');
+    command.addCommand(createOperationListCommand(factory, {
+        operationId: 'proxies.list',
+        description: 'List proxies',
+    }));
+    command.addCommand(createOperationViewCommand(factory, {
+        operationId: 'proxies.get',
+        name: 'get',
+        description: 'Get a proxy',
+        argName: 'proxyId',
+    }));
+    command.addCommand(createOperationJsonBodyCommand(factory, {
+        operationId: 'proxies.create',
+        name: 'create',
+        description: 'Create a proxy',
+    }));
+    command.addCommand(createOperationJsonBodyCommand(factory, {
+        operationId: 'proxies.update',
+        name: 'patch',
+        description: 'Update a proxy',
+        argNames: ['proxyId'],
+    }));
+    command.addCommand(addOutputFlags(new Command('test').description('Test a proxy').argument('<proxyId>')).action(async (proxyId, options) => {
+        await requestOperationAndPrint(factory, 'proxies.test', {
+            pathParams: { proxyId },
+            output: outputFlags(options),
+        });
+    }));
+    command.addCommand(createOperationDeleteCommand(factory, {
+        operationId: 'proxies.delete',
+        description: 'Delete a proxy',
+        argNames: ['proxyId'],
+    }));
+    command.addCommand(createProxyPoolCommand(factory));
+    return command;
+}
+function createProxyPoolCommand(factory) {
+    const command = new Command('pool').description('Inspect managed proxy pools');
+    command.addCommand(createOperationListCommand(factory, {
+        operationId: 'proxies.pools.list',
+        description: 'List proxy pools',
+        configure: (cmd) => addPaginationFlags(cmd)
+            .option('--country <country>', 'Filter by ISO country code')
+            .option('--category <category>', 'Filter by category')
+            .option('--available <boolean>', 'Filter by availability'),
+        query: (options) => ({
+            country: typeof options.country === 'string' ? options.country : undefined,
+            category: typeof options.category === 'string' ? options.category : undefined,
+            available: typeof options.available === 'string' ? parseBooleanFlag(options.available) : undefined,
+            limit: typeof options.limit === 'number' ? options.limit : undefined,
+            cursor: typeof options.cursor === 'string' ? options.cursor : undefined,
+        }),
+    }));
+    command.addCommand(createOperationViewCommand(factory, {
+        operationId: 'proxies.pools.get',
+        name: 'get',
+        description: 'Get a proxy pool',
+        argName: 'poolId',
+    }));
+    return command;
+}
+function parseBooleanFlag(value) {
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    return undefined;
+}

package/dist/commands/run/index.js

@@ -3,57 +3,242 @@ import { CliError } from '../../runtime/errors.js';
 import { readJsonFile, writeBinary } from '../shared/io.js';
 import { parsePositiveInteger } from '../shared/options.js';
 import { addOutputFlags } from '../shared/output.js';
-import { addPaginationFlags, createJsonBodyCommand, createListCommand, createViewCommand, requestAndPrint, } from '../shared/rest.js';
+import { addPaginationFlags, createOperationJsonBodyCommand, createOperationListCommand, createOperationViewCommand, downloadOperation, outputFlags, requestOperation, requestOperationAndPrint, streamOperationText, } from '../shared/operation.js';
 export function createRunCommand(factory) {
-    const command = new Command('run').description('Inspect and stream BCTRL run history');
-    command.addCommand(createListCommand(factory, {
+    const command = new Command('run').description('Inspect and stream runs');
+    command.addCommand(createOperationListCommand(factory, {
+        operationId: 'runs.list',
         description: 'List runs',
-        path: '/runs',
         configure: (cmd) => addPaginationFlags(cmd)
             .option('--space <id>', 'Filter by space id')
             .option('--runtime <id>', 'Filter by runtime id')
-            .option('--status <status>', 'Filter by run status'),
+            .option('--status <status>', 'Filter by run status')
+            .option('--subaccount <id>', 'Filter by subaccount id'),
         query: (options) => ({
             spaceId: typeof options.space === 'string' ? options.space : undefined,
             runtimeId: typeof options.runtime === 'string' ? options.runtime : undefined,
             status: typeof options.status === 'string' ? options.status : undefined,
+            subaccountId: typeof options.subaccount === 'string' ? options.subaccount : undefined,
             limit: typeof options.limit === 'number' ? options.limit : undefined,
             cursor: typeof options.cursor === 'string' ? options.cursor : undefined,
         }),
     }));
-    command.addCommand(createViewCommand(factory, {
-        description: 'View a run',
-        path: '/runs/{id}',
+    command.addCommand(createOperationViewCommand(factory, {
+        operationId: 'runs.get',
+        name: 'get',
+        description: 'Get a run',
+        argName: 'runId',
     }));
+    command.addCommand(createRunActivityCommand(factory));
     command.addCommand(createRunEventsCommand(factory));
-    command.addCommand(createRunCommandsCommand(factory));
     command.addCommand(createRunFilesCommand(factory));
-    command.addCommand(createRunExportCommand(factory));
-    command.addCommand(createRunWatchCommand(factory));
-    command.addCommand(createRunWaitCommand(factory));
-    command.addCommand(createRunViewerCommand(factory, 'live', 'Mint a live viewer URL'));
-    command.addCommand(createRunViewerCommand(factory, 'recording', 'Mint a recording viewer URL'));
+    command.addCommand(createRunInvocationsCommand(factory));
+    command.addCommand(createRunInvocationCommand(factory));
+    command.addCommand(createRunViewerCommand(factory, 'live', 'Create a live viewer URL'));
+    command.addCommand(createRunViewerCommand(factory, 'recording', 'Create a recording viewer URL'));
     return command;
 }
-function createRunWatchCommand(factory) {
-    return new Command('watch')
-        .description('Stream run events')
-        .argument('<id>')
-        .option('--type <type...>', 'Filter by event type')
-        .option('--category <category...>', 'Filter by event category')
-        .option('--connection <id>', 'Filter by connection id')
-        .option('-L, --limit <number>', 'Maximum number of events per poll', parsePositiveInteger)
-        .option('--cursor <cursor>', 'Start cursor')
-        .action(async (id, options) => {
-        const client = await factory.apiClient();
-        const stream = await client.streamText(`/runs/${encodeURIComponent(id)}/events/stream`, {
+function createRunActivityCommand(factory) {
+    const command = new Command('activity').description('Inspect run activities');
+    command.addCommand(createRunActivityListCommand(factory));
+    command.addCommand(createSseCommand(factory, {
+        name: 'stream',
+        description: 'Stream run activities',
+        operationId: 'runs.activity.stream',
+        configure: (cmd) => addPaginationFlags(cmd)
+            .option('--view <view>', 'Activity view')
+            .option('--type <type>', 'Filter by activity type')
+            .option('--category <category>', 'Filter by activity category')
+            .option('--severity <severity>', 'Filter by severity')
+            .option('--invocation <id>', 'Filter by invocation id')
+            .option('--file <id>', 'Filter by file id'),
+        query: (options) => ({
+            view: typeof options.view === 'string' ? options.view : undefined,
+            type: typeof options.type === 'string' ? options.type : undefined,
+            category: typeof options.category === 'string' ? options.category : undefined,
+            severity: typeof options.severity === 'string' ? options.severity : undefined,
+            invocationId: typeof options.invocation === 'string' ? options.invocation : undefined,
+            fileId: typeof options.file === 'string' ? options.file : undefined,
+            limit: typeof options.limit === 'number' ? options.limit : undefined,
+            cursor: typeof options.cursor === 'string' ? options.cursor : undefined,
+        }),
+    }));
+    return command;
+}
+function createRunActivityListCommand(factory) {
+    return addOutputFlags(addPaginationFlags(new Command('list').description('List run activities').argument('<runId>'))
+        .option('--view <view>', 'Activity view')
+        .option('--type <type>', 'Filter by activity type')
+        .option('--category <category>', 'Filter by activity category')
+        .option('--severity <severity>', 'Filter by severity')
+        .option('--invocation <id>', 'Filter by invocation id')
+        .option('--file <id>', 'Filter by file id')).action(async (runId, options) => {
+        await requestOperationAndPrint(factory, 'runs.activity.list', {
+            pathParams: { runId },
+            query: {
+                view: options.view,
+                type: options.type,
+                category: options.category,
+                severity: options.severity,
+                invocationId: options.invocation,
+                fileId: options.file,
+                limit: options.limit,
+                cursor: options.cursor,
+            },
+            output: outputFlags(options),
+        });
+    });
+}
+function createRunEventsCommand(factory) {
+    const command = new Command('events').description('Inspect run events');
+    command.addCommand(createRunEventsListCommand(factory));
+    command.addCommand(createSseCommand(factory, {
+        name: 'stream',
+        description: 'Stream run events',
+        operationId: 'runs.events.stream',
+        configure: (cmd) => addPaginationFlags(cmd)
+            .option('--type <type>', 'Filter by event type')
+            .option('--status <status>', 'Filter by event status')
+            .option('--page-id <id>', 'Filter by page id')
+            .option('--context-id <id>', 'Filter by browser context id'),
+        query: (options) => ({
+            type: typeof options.type === 'string' ? options.type : undefined,
+            status: typeof options.status === 'string' ? options.status : undefined,
+            pageId: typeof options.pageId === 'string' ? options.pageId : undefined,
+            contextId: typeof options.contextId === 'string' ? options.contextId : undefined,
+            limit: typeof options.limit === 'number' ? options.limit : undefined,
+            cursor: typeof options.cursor === 'string' ? options.cursor : undefined,
+        }),
+    }));
+    return command;
+}
+function createRunEventsListCommand(factory) {
+    return addOutputFlags(addPaginationFlags(new Command('list').description('List run events').argument('<runId>'))
+        .option('--type <type>', 'Filter by event type')
+        .option('--status <status>', 'Filter by event status')
+        .option('--page-id <id>', 'Filter by page id')
+        .option('--context-id <id>', 'Filter by browser context id')).action(async (runId, options) => {
+        await requestOperationAndPrint(factory, 'runs.events.list', {
+            pathParams: { runId },
+            query: {
+                type: options.type,
+                status: options.status,
+                pageId: options.pageId,
+                contextId: options.contextId,
+                limit: options.limit,
+                cursor: options.cursor,
+            },
+            output: outputFlags(options),
+        });
+    });
+}
+function createRunFilesCommand(factory) {
+    const command = new Command('files').description('Inspect run files');
+    command.addCommand(createRunFilesListCommand(factory));
+    command.addCommand(createRunFilesExportCommand(factory));
+    return command;
+}
+function createRunFilesListCommand(factory) {
+    return addOutputFlags(addPaginationFlags(new Command('list').description('List run files').argument('<runId>')).option('--type <type>', 'Filter by file type')).action(async (runId, options) => {
+        await requestOperationAndPrint(factory, 'runs.files.list', {
+            pathParams: { runId },
+            query: {
+                type: options.type,
+                limit: options.limit,
+                cursor: options.cursor,
+            },
+            output: outputFlags(options),
+        });
+    });
+}
+function createRunFilesExportCommand(factory) {
+    return addOutputFlags(new Command('export')
+        .description('Export run files as an archive')
+        .argument('<runId>')
+        .requiredOption('--to <path>', 'Output archive path, or - for stdout')
+        .option('--name <name>', 'Export file name', 'run-files.zip')
+        .option('--type <type...>', 'Filter exported file types')
+        .option('--input <path>', 'Read JSON request body from file, or - for stdin')).action(async (runId, options) => {
+        const body = typeof options.input === 'string'
+            ? await readJsonFile(options.input)
+            : {
+                format: 'zip',
+                name: options.name,
+                filter: options.type ? { type: options.type } : undefined,
+            };
+        const result = (await requestOperation(factory, 'runs.files.export', {
+            pathParams: { runId },
+            body: body,
+        }));
+        const fileId = result.fileId ?? result.id;
+        if (!fileId) {
+            throw new CliError('Expected run export response to include fileId');
+        }
+        const data = await downloadOperation(factory, 'files.content', {
+            pathParams: { fileId },
+        });
+        await writeBinary(options.to, data);
+    });
+}
+function createRunInvocationsCommand(factory) {
+    const command = addOutputFlags(addPaginationFlags(new Command('invocations').description('List run invocations').argument('<runId>'))
+        .option('--status <status>', 'Filter by invocation status')
+        .option('--action <action>', 'Filter by invocation action'));
+    command.action(async (runId, options) => {
+        await requestOperationAndPrint(factory, 'runs.invocations.list', {
+            pathParams: { runId },
             query: {
-                type: options.type?.join(','),
-                category: options.category?.join(','),
-                connectionId: options.connection,
+                status: options.status,
+                action: options.action,
                 limit: options.limit,
                 cursor: options.cursor,
             },
+            output: outputFlags(options),
+        });
+    });
+    return command;
+}
+function createRunInvocationCommand(factory) {
+    const command = new Command('invocation').description('Inspect run invocations');
+    command.addCommand(addOutputFlags(new Command('get')
+        .description('Get a run invocation')
+        .argument('<runId>')
+        .argument('<invocationId>')).action(async (runId, invocationId, options) => {
+        await requestOperationAndPrint(factory, 'runs.invocations.get', {
+            pathParams: { runId, invocationId },
+            output: outputFlags(options),
+        });
+    }));
+    return command;
+}
+function createRunViewerCommand(factory, name, description) {
+    return createOperationJsonBodyCommand(factory, {
+        operationId: name === 'live' ? 'runs.live' : 'runs.recording',
+        name,
+        description,
+        argNames: ['runId'],
+        configure: (cmd) => cmd
+            .option('--expires-in-seconds <seconds>', 'Viewer expiration in seconds', parsePositiveInteger)
+            .option('--control <none|input>', 'Live viewer control mode')
+            .option('--input <path>', 'Read JSON request body from file, or - for stdin'),
+        body: async (_args, options) => {
+            if (typeof options.input === 'string') {
+                return (await readJsonFile(options.input));
+            }
+            return {
+                expiresInSeconds: typeof options.expiresInSeconds === 'number' ? options.expiresInSeconds : undefined,
+                control: name === 'live' ? options.control : undefined,
+            };
+        },
+    });
+}
+function createSseCommand(factory, config) {
+    let command = new Command(config.name).description(config.description).argument('<runId>');
+    command = config.configure(command);
+    return command.action(async (runId, options) => {
+        const stream = await streamOperationText(factory, config.operationId, {
+            pathParams: { runId },
+            query: config.query(options),
         });
         await renderSseStream(factory, stream);
     });
@@ -110,138 +295,20 @@ function formatRunEvent(value) {
     if (!value || typeof value !== 'object')
         return JSON.stringify(value);
     const event = value;
-    const time = typeof event.time === 'string' ? event.time : '';
+    const time = typeof event.time === 'string'
+        ? event.time
+        : typeof event.createdAt === 'string'
+            ? event.createdAt
+            : '';
     const label = [event.category, event.type].filter((part) => typeof part === 'string').join('/');
     const status = typeof event.status === 'string' ? ` ${event.status}` : '';
-    const name = typeof event.name === 'string' ? ` ${event.name}` : '';
-    const suffix = event.data && Object.keys(event.data).length > 0 ? ` ${JSON.stringify(event.data)}` : '';
+    const name = typeof event.title === 'string'
+        ? ` ${event.title}`
+        : typeof event.name === 'string'
+            ? ` ${event.name}`
+            : '';
+    const suffix = event.data && Object.keys(event.data).length > 0
+        ? ` ${JSON.stringify(event.data)}`
+        : '';
     return [time, label || 'event'].filter(Boolean).join(' ') + status + name + suffix;
 }
-function createRunEventsCommand(factory) {
-    return addOutputFlags(new Command('events')
-        .description('List run events')
-        .argument('<id>')
-        .option('--type <type...>', 'Filter by event type')
-        .option('--category <category...>', 'Filter by event category')
-        .option('--connection <id>', 'Filter by connection 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', `/runs/${encodeURIComponent(id)}/events`, {
-            query: {
-                type: options.type?.join(','),
-                category: options.category?.join(','),
-                connectionId: options.connection,
-                limit: options.limit,
-                cursor: options.cursor,
-            },
-            output: options,
-        });
-    });
-}
-function createRunCommandsCommand(factory) {
-    return addOutputFlags(new Command('commands')
-        .description('List run commands')
-        .argument('<id>')
-        .option('--type <type>', 'Filter by command type')
-        .option('--connection <id>', 'Filter by connection 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', `/runs/${encodeURIComponent(id)}/commands`, {
-            query: {
-                type: options.type,
-                connectionId: options.connection,
-                limit: options.limit,
-                cursor: options.cursor,
-            },
-            output: options,
-        });
-    });
-}
-function createRunFilesCommand(factory) {
-    return addOutputFlags(new Command('files')
-        .description('List run files')
-        .argument('<id>')
-        .option('--type <type>', 'Filter by file type')
-        .option('-L, --limit <number>', 'Maximum number of results to return', parsePositiveInteger)
-        .option('--cursor <cursor>', 'Pagination cursor'))
-        .action(async (id, options) => {
-        await requestAndPrint(factory, 'get', `/runs/${encodeURIComponent(id)}/files`, {
-            query: { type: options.type, limit: options.limit, cursor: options.cursor },
-            output: options,
-        });
-    });
-}
-function createRunExportCommand(factory) {
-    return addOutputFlags(new Command('export')
-        .description('Export run files as an archive')
-        .argument('<id>')
-        .requiredOption('--to <path>', 'Output archive path, or - for stdout')
-        .option('--name <name>', 'Export file name', 'run-files.zip')
-        .option('--type <type...>', 'Filter exported file types'))
-        .action(async (id, options) => {
-        const client = await factory.apiClient();
-        const result = await client.post(`/runs/${encodeURIComponent(id)}/files/export`, {
-            body: {
-                format: 'zip',
-                name: options.name,
-                filter: options.type ? { type: options.type } : undefined,
-            },
-        });
-        const fileId = result.fileId ?? result.id;
-        if (!fileId) {
-            throw new CliError('Expected run export response to include fileId');
-        }
-        const data = await client.download(`/files/${encodeURIComponent(fileId)}/content`);
-        await writeBinary(options.to, data);
-    });
-}
-function createRunWaitCommand(factory) {
-    return createJsonBodyCommand(factory, {
-        name: 'wait',
-        description: 'Wait for a run event',
-        method: 'post',
-        path: '/runs/{id}/events/wait',
-        argNames: ['id'],
-        configure: (cmd) => cmd
-            .option('--type <type...>', 'Event type')
-            .option('--category <category...>', 'Event category')
-            .option('--connection <id>', 'Connection id')
-            .option('--cursor <cursor>', 'Cursor')
-            .option('--timeout-ms <ms>', 'Timeout in milliseconds')
-            .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 {
-                type: options.type,
-                category: options.category,
-                connectionId: options.connection,
-                cursor: options.cursor,
-                timeoutMs: options.timeoutMs ? Number(options.timeoutMs) : undefined,
-            };
-        },
-    });
-}
-function createRunViewerCommand(factory, name, description) {
-    return createJsonBodyCommand(factory, {
-        name,
-        description,
-        method: 'post',
-        path: `/runs/{id}/${name}`,
-        argNames: ['id'],
-        configure: (cmd) => cmd
-            .option('--expires-in-seconds <seconds>', 'Viewer expiration in seconds')
-            .option('--control <none|input>', 'Live viewer control mode')
-            .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 {
-                expiresInSeconds: options.expiresInSeconds ? Number(options.expiresInSeconds) : undefined,
-                control: name === 'live' ? options.control : undefined,
-            };
-        },
-    });
-}