@bctrl/cli 0.1.4 → 0.1.5

package/dist/commands/ai/index.js

@@ -1,7 +1,7 @@
 import { Command } from 'commander';
 import { readJsonFile } from '../shared/io.js';
 import { addOutputFlags } from '../shared/output.js';
-import { createDeleteCommand, createJsonBodyCommand, createListCommand, createViewCommand, requestAndPrint, } from '../shared/rest.js';
+import { createOperationDeleteCommand, createOperationJsonBodyCommand, createOperationListCommand, createOperationViewCommand, outputFlags, requestOperationAndPrint, } from '../shared/operation.js';
 export function createAiCommand(factory) {
     const command = new Command('ai').description('Manage AI models and credentials');
     command.addCommand(createAiModelsCommand(factory));
@@ -10,9 +10,9 @@ export function createAiCommand(factory) {
 }
 function createAiModelsCommand(factory) {
     const command = new Command('models').description('Discover AI models');
-    command.addCommand(createListCommand(factory, {
+    command.addCommand(createOperationListCommand(factory, {
+        operationId: 'ai.models.list',
         description: 'List AI models',
-        path: '/ai/models',
         configure: (cmd) => cmd
             .option('--provider <provider>', 'Filter by provider')
             .option('--status <status>', 'Filter by support status')
@@ -21,7 +21,7 @@ function createAiModelsCommand(factory) {
         query: (options) => ({
             provider: typeof options.provider === 'string' ? options.provider : undefined,
             status: typeof options.status === 'string' ? options.status : undefined,
-            managed: typeof options.managed === 'string' ? options.managed : undefined,
+            managed: typeof options.managed === 'string' ? parseBooleanFlag(options.managed) : undefined,
             engine: typeof options.engine === 'string' ? options.engine : undefined,
         }),
     }));
@@ -29,9 +29,9 @@ function createAiModelsCommand(factory) {
 }
 function createAiCredentialsCommand(factory) {
     const command = new Command('credentials').description('Manage BYOK AI credentials');
-    command.addCommand(createListCommand(factory, {
+    command.addCommand(createOperationListCommand(factory, {
+        operationId: 'ai.credentials.list',
         description: 'List AI credentials',
-        path: '/ai/credentials',
         configure: (cmd) => cmd
             .option('--provider <provider>', 'Filter by provider')
             .option('--name <name>', 'Filter by name')
@@ -42,32 +42,32 @@ function createAiCredentialsCommand(factory) {
             status: typeof options.status === 'string' ? options.status : undefined,
         }),
     }));
-    command.addCommand(createViewCommand(factory, {
+    command.addCommand(createOperationViewCommand(factory, {
+        operationId: 'ai.credentials.get',
         name: 'get',
         description: 'Get an AI credential',
-        path: '/ai/credentials/{credentialId}',
         argName: 'credentialId',
     }));
-    command.addCommand(createAiCredentialWriteCommand(factory, 'create', 'post', '/ai/credentials'));
-    command.addCommand(createAiCredentialWriteCommand(factory, 'patch', 'patch', '/ai/credentials/{credentialId}', [
-        'credentialId',
-    ]));
+    command.addCommand(createAiCredentialWriteCommand(factory, 'create', 'ai.credentials.create'));
+    command.addCommand(createAiCredentialWriteCommand(factory, 'patch', 'ai.credentials.update', ['credentialId']));
     command.addCommand(addOutputFlags(new Command('test').description('Test an AI credential').argument('<credentialId>')).action(async (credentialId, options) => {
-        await requestAndPrint(factory, 'post', `/ai/credentials/${encodeURIComponent(credentialId)}/test`, { output: options });
+        await requestOperationAndPrint(factory, 'ai.credentials.test', {
+            pathParams: { credentialId },
+            output: outputFlags(options),
+        });
     }));
-    command.addCommand(createDeleteCommand(factory, {
+    command.addCommand(createOperationDeleteCommand(factory, {
+        operationId: 'ai.credentials.delete',
         description: 'Delete an AI credential',
-        path: '/ai/credentials/{credentialId}',
         argNames: ['credentialId'],
     }));
     return command;
 }
-function createAiCredentialWriteCommand(factory, name, method, path, argNames = []) {
-    return createJsonBodyCommand(factory, {
+function createAiCredentialWriteCommand(factory, name, operationId, argNames = []) {
+    return createOperationJsonBodyCommand(factory, {
+        operationId,
         name,
         description: name === 'create' ? 'Create an AI credential' : 'Update an AI credential',
-        method,
-        path,
         argNames,
         configure: (cmd) => cmd
             .option('--name <name>', 'Credential name')
@@ -79,8 +79,9 @@ function createAiCredentialWriteCommand(factory, name, method, path, argNames =
             .option('--subaccount-id <id>', 'Subaccount scope when using a parent/org key')
             .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,
                 provider: options.provider,
@@ -93,3 +94,10 @@ function createAiCredentialWriteCommand(factory, name, method, path, argNames =
         },
     });
 }
+function parseBooleanFlag(value) {
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    return undefined;
+}

package/dist/commands/api-key/index.js

@@ -1,11 +1,11 @@
 import { Command } from 'commander';
 import { readJsonFile } from '../shared/io.js';
-import { createDeleteCommand, createJsonBodyCommand, createListCommand, } from '../shared/rest.js';
+import { createOperationDeleteCommand, createOperationJsonBodyCommand, createOperationListCommand, } from '../shared/operation.js';
 export function createApiKeyCommand(factory) {
     const command = new Command('api-key').description('Manage API keys');
-    command.addCommand(createListCommand(factory, {
+    command.addCommand(createOperationListCommand(factory, {
+        operationId: 'api-keys.list',
         description: 'List API keys',
-        path: '/api-keys',
         configure: (cmd) => cmd
             .option('--subaccount-id <id>', 'Filter by subaccount id')
             .option('--kind <kind>', 'Filter by key kind: organization or subaccount')
@@ -18,19 +18,19 @@ export function createApiKeyCommand(factory) {
             cursor: typeof options.cursor === 'string' ? options.cursor : undefined,
         }),
     }));
-    command.addCommand(createJsonBodyCommand(factory, {
+    command.addCommand(createOperationJsonBodyCommand(factory, {
+        operationId: 'api-keys.create',
         name: 'create',
         description: 'Create an API key',
-        method: 'post',
-        path: '/api-keys',
         configure: (cmd) => cmd
             .option('--name <name>', 'API key name')
             .option('--subaccount-id <id>', 'Create a subaccount-scoped key')
             .option('--expires-at <iso>', 'Expiration timestamp')
             .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,
                 subaccountId: options.subaccountId,
@@ -38,9 +38,9 @@ export function createApiKeyCommand(factory) {
             };
         },
     }));
-    command.addCommand(createDeleteCommand(factory, {
+    command.addCommand(createOperationDeleteCommand(factory, {
+        operationId: 'api-keys.delete',
         description: 'Delete an API key',
-        path: '/api-keys/{keyId}',
         argNames: ['keyId'],
     }));
     return command;

package/dist/commands/browser-extension/index.js

@@ -1,12 +1,12 @@
 import { Command } from 'commander';
 import { readBlob, readJsonFile } from '../shared/io.js';
 import { addOutputFlags, outputData } from '../shared/output.js';
-import { createDeleteCommand, createJsonBodyCommand, createListCommand, createViewCommand, } from '../shared/rest.js';
+import { createOperationDeleteCommand, createOperationJsonBodyCommand, createOperationListCommand, createOperationViewCommand, uploadOperationFile, } from '../shared/operation.js';
 export function createBrowserExtensionCommand(factory) {
     const command = new Command('browser-extension').description('Manage browser extensions');
-    command.addCommand(createListCommand(factory, {
+    command.addCommand(createOperationListCommand(factory, {
+        operationId: 'browser-extensions.list',
         description: 'List browser extensions',
-        path: '/browser-extensions',
         configure: (cmd) => cmd
             .option('--subaccount-id <id>', 'Filter by subaccount id')
             .option('--q <text>', 'Search query')
@@ -19,10 +19,10 @@ export function createBrowserExtensionCommand(factory) {
             source: typeof options.source === 'string' ? options.source : undefined,
         }),
     }));
-    command.addCommand(createViewCommand(factory, {
+    command.addCommand(createOperationViewCommand(factory, {
+        operationId: 'browser-extensions.get',
         name: 'get',
         description: 'Get a browser extension',
-        path: '/browser-extensions/{extensionId}',
         argName: 'extensionId',
     }));
     command.addCommand(addOutputFlags(new Command('upload')
@@ -30,9 +30,8 @@ export function createBrowserExtensionCommand(factory) {
         .argument('<path>')
         .option('--name <name>', 'Display name')
         .option('--subaccount-id <id>', 'Create under a subaccount when using a parent/org key')).action(async (path, options) => {
-        const client = await factory.apiClient();
         const file = await readBlob(path);
-        const result = await client.uploadFile('/browser-extensions/upload', {
+        const result = await uploadOperationFile(factory, 'browser-extensions.upload', {
             file: file.blob,
             fileName: file.fileName,
             fields: {
@@ -42,19 +41,19 @@ export function createBrowserExtensionCommand(factory) {
         });
         await outputData(factory.io, result, options);
     }));
-    command.addCommand(createJsonBodyCommand(factory, {
+    command.addCommand(createOperationJsonBodyCommand(factory, {
+        operationId: 'browser-extensions.import',
         name: 'import',
         description: 'Import a browser extension from a URL',
-        method: 'post',
-        path: '/browser-extensions/import',
         configure: (cmd) => cmd
             .option('--url <url>', 'Extension URL')
             .option('--name <name>', 'Display name')
             .option('--subaccount-id <id>', 'Create under a subaccount when using a parent/org key')
             .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 {
                 url: options.url,
                 name: options.name,
@@ -62,24 +61,24 @@ export function createBrowserExtensionCommand(factory) {
             };
         },
     }));
-    command.addCommand(createJsonBodyCommand(factory, {
+    command.addCommand(createOperationJsonBodyCommand(factory, {
+        operationId: 'browser-extensions.update',
         name: 'patch',
         description: 'Update a browser extension',
-        method: 'patch',
-        path: '/browser-extensions/{extensionId}',
         argNames: ['extensionId'],
         configure: (cmd) => cmd
             .option('--name <name>', 'Display name')
             .option('--input <path>', 'Read full JSON request body from file, or - for stdin'),
         body: async (_args, options) => {
-            if (typeof options.input === 'string')
-                return readJsonFile(options.input);
+            if (typeof options.input === 'string') {
+                return (await readJsonFile(options.input));
+            }
             return { name: options.name };
         },
     }));
-    command.addCommand(createDeleteCommand(factory, {
+    command.addCommand(createOperationDeleteCommand(factory, {
+        operationId: 'browser-extensions.delete',
         description: 'Delete a browser extension',
-        path: '/browser-extensions/{extensionId}',
         argNames: ['extensionId'],
     }));
     return command;

package/dist/commands/file/index.js

@@ -2,12 +2,12 @@ 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')
@@ -29,10 +29,10 @@ export function createFileCommand(factory) {
             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')
@@ -40,11 +40,9 @@ export function createFileCommand(factory) {
         .argument('<path>')
         .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 },
@@ -60,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, {
+    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'
@@ -85,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/help/index.js

@@ -1,17 +1,17 @@
 import { Command } from 'commander';
 import { addOutputFlags } from '../shared/output.js';
-import { requestAndPrint } from '../shared/rest.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 requestAndPrint(factory, 'get', '/help', {
+        await requestOperationAndPrint(factory, 'help', {
             query: {
                 topic: options.topic,
                 audience: options.audience,
             },
-            output: options,
+            output: outputFlags(options),
         });
     });
 }

package/dist/commands/proxy/index.js

@@ -1,39 +1,38 @@
 import { Command } from 'commander';
 import { addOutputFlags } from '../shared/output.js';
-import { addPaginationFlags, createDeleteCommand, createJsonBodyCommand, createListCommand, createViewCommand, requestAndPrint, } from '../shared/rest.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(createListCommand(factory, {
+    command.addCommand(createOperationListCommand(factory, {
+        operationId: 'proxies.list',
         description: 'List proxies',
-        path: '/proxies',
     }));
-    command.addCommand(createViewCommand(factory, {
+    command.addCommand(createOperationViewCommand(factory, {
+        operationId: 'proxies.get',
         name: 'get',
         description: 'Get a proxy',
-        path: '/proxies/{proxyId}',
         argName: 'proxyId',
     }));
-    command.addCommand(createJsonBodyCommand(factory, {
+    command.addCommand(createOperationJsonBodyCommand(factory, {
+        operationId: 'proxies.create',
         name: 'create',
         description: 'Create a proxy',
-        method: 'post',
-        path: '/proxies',
     }));
-    command.addCommand(createJsonBodyCommand(factory, {
+    command.addCommand(createOperationJsonBodyCommand(factory, {
+        operationId: 'proxies.update',
         name: 'patch',
         description: 'Update a proxy',
-        method: 'patch',
-        path: '/proxies/{proxyId}',
         argNames: ['proxyId'],
     }));
     command.addCommand(addOutputFlags(new Command('test').description('Test a proxy').argument('<proxyId>')).action(async (proxyId, options) => {
-        await requestAndPrint(factory, 'post', `/proxies/${encodeURIComponent(proxyId)}/test`, {
-            output: options,
+        await requestOperationAndPrint(factory, 'proxies.test', {
+            pathParams: { proxyId },
+            output: outputFlags(options),
         });
     }));
-    command.addCommand(createDeleteCommand(factory, {
+    command.addCommand(createOperationDeleteCommand(factory, {
+        operationId: 'proxies.delete',
         description: 'Delete a proxy',
-        path: '/proxies/{proxyId}',
         argNames: ['proxyId'],
     }));
     command.addCommand(createProxyPoolCommand(factory));
@@ -41,9 +40,9 @@ export function createProxyCommand(factory) {
 }
 function createProxyPoolCommand(factory) {
     const command = new Command('pool').description('Inspect managed proxy pools');
-    command.addCommand(createListCommand(factory, {
+    command.addCommand(createOperationListCommand(factory, {
+        operationId: 'proxies.pools.list',
         description: 'List proxy pools',
-        path: '/proxies/pools',
         configure: (cmd) => addPaginationFlags(cmd)
             .option('--country <country>', 'Filter by ISO country code')
             .option('--category <category>', 'Filter by category')
@@ -51,16 +50,23 @@ function createProxyPoolCommand(factory) {
         query: (options) => ({
             country: typeof options.country === 'string' ? options.country : undefined,
             category: typeof options.category === 'string' ? options.category : undefined,
-            available: typeof options.available === 'string' ? options.available : 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(createViewCommand(factory, {
+    command.addCommand(createOperationViewCommand(factory, {
+        operationId: 'proxies.pools.get',
         name: 'get',
         description: 'Get a proxy pool',
-        path: '/proxies/pools/{poolId}',
         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,12 +3,12 @@ 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 runs');
-    command.addCommand(createListCommand(factory, {
+    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')
@@ -23,10 +23,10 @@ export function createRunCommand(factory) {
             cursor: typeof options.cursor === 'string' ? options.cursor : undefined,
         }),
     }));
-    command.addCommand(createViewCommand(factory, {
+    command.addCommand(createOperationViewCommand(factory, {
+        operationId: 'runs.get',
         name: 'get',
         description: 'Get a run',
-        path: '/runs/{runId}',
         argName: 'runId',
     }));
     command.addCommand(createRunActivityCommand(factory));
@@ -44,7 +44,7 @@ function createRunActivityCommand(factory) {
     command.addCommand(createSseCommand(factory, {
         name: 'stream',
         description: 'Stream run activities',
-        pathSuffix: 'activity/stream',
+        operationId: 'runs.activity.stream',
         configure: (cmd) => addPaginationFlags(cmd)
             .option('--view <view>', 'Activity view')
             .option('--type <type>', 'Filter by activity type')
@@ -73,7 +73,8 @@ function createRunActivityListCommand(factory) {
         .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 requestAndPrint(factory, 'get', `/runs/${encodeURIComponent(runId)}/activity`, {
+        await requestOperationAndPrint(factory, 'runs.activity.list', {
+            pathParams: { runId },
             query: {
                 view: options.view,
                 type: options.type,
@@ -84,7 +85,7 @@ function createRunActivityListCommand(factory) {
                 limit: options.limit,
                 cursor: options.cursor,
             },
-            output: options,
+            output: outputFlags(options),
         });
     });
 }
@@ -94,7 +95,7 @@ function createRunEventsCommand(factory) {
     command.addCommand(createSseCommand(factory, {
         name: 'stream',
         description: 'Stream run events',
-        pathSuffix: 'events/stream',
+        operationId: 'runs.events.stream',
         configure: (cmd) => addPaginationFlags(cmd)
             .option('--type <type>', 'Filter by event type')
             .option('--status <status>', 'Filter by event status')
@@ -117,7 +118,8 @@ function createRunEventsListCommand(factory) {
         .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 requestAndPrint(factory, 'get', `/runs/${encodeURIComponent(runId)}/events`, {
+        await requestOperationAndPrint(factory, 'runs.events.list', {
+            pathParams: { runId },
             query: {
                 type: options.type,
                 status: options.status,
@@ -126,7 +128,7 @@ function createRunEventsListCommand(factory) {
                 limit: options.limit,
                 cursor: options.cursor,
             },
-            output: options,
+            output: outputFlags(options),
         });
     });
 }
@@ -138,9 +140,14 @@ function createRunFilesCommand(factory) {
 }
 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 requestAndPrint(factory, 'get', `/runs/${encodeURIComponent(runId)}/files`, {
-            query: { type: options.type, limit: options.limit, cursor: options.cursor },
-            output: options,
+        await requestOperationAndPrint(factory, 'runs.files.list', {
+            pathParams: { runId },
+            query: {
+                type: options.type,
+                limit: options.limit,
+                cursor: options.cursor,
+            },
+            output: outputFlags(options),
         });
     });
 }
@@ -152,7 +159,6 @@ function createRunFilesExportCommand(factory) {
         .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 client = await factory.apiClient();
         const body = typeof options.input === 'string'
             ? await readJsonFile(options.input)
             : {
@@ -160,12 +166,17 @@ function createRunFilesExportCommand(factory) {
                 name: options.name,
                 filter: options.type ? { type: options.type } : undefined,
             };
-        const result = await client.post(`/runs/${encodeURIComponent(runId)}/files/export`, { body });
+        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 client.download(`/files/${encodeURIComponent(fileId)}/content`);
+        const data = await downloadOperation(factory, 'files.content', {
+            pathParams: { fileId },
+        });
         await writeBinary(options.to, data);
     });
 }
@@ -174,14 +185,15 @@ function createRunInvocationsCommand(factory) {
         .option('--status <status>', 'Filter by invocation status')
         .option('--action <action>', 'Filter by invocation action'));
     command.action(async (runId, options) => {
-        await requestAndPrint(factory, 'get', `/runs/${encodeURIComponent(runId)}/invocations`, {
+        await requestOperationAndPrint(factory, 'runs.invocations.list', {
+            pathParams: { runId },
             query: {
                 status: options.status,
                 action: options.action,
                 limit: options.limit,
                 cursor: options.cursor,
             },
-            output: options,
+            output: outputFlags(options),
         });
     });
     return command;
@@ -192,24 +204,27 @@ function createRunInvocationCommand(factory) {
         .description('Get a run invocation')
         .argument('<runId>')
         .argument('<invocationId>')).action(async (runId, invocationId, options) => {
-        await requestAndPrint(factory, 'get', `/runs/${encodeURIComponent(runId)}/invocations/${encodeURIComponent(invocationId)}`, { output: options });
+        await requestOperationAndPrint(factory, 'runs.invocations.get', {
+            pathParams: { runId, invocationId },
+            output: outputFlags(options),
+        });
     }));
     return command;
 }
 function createRunViewerCommand(factory, name, description) {
-    return createJsonBodyCommand(factory, {
+    return createOperationJsonBodyCommand(factory, {
+        operationId: name === 'live' ? 'runs.live' : 'runs.recording',
         name,
         description,
-        method: 'post',
-        path: `/runs/{runId}/${name}`,
         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 readJsonFile(options.input);
+            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,
@@ -221,8 +236,10 @@ 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 client = await factory.apiClient();
-        const stream = await client.streamText(`/runs/${encodeURIComponent(runId)}/${config.pathSuffix}`, { query: config.query(options) });
+        const stream = await streamOperationText(factory, config.operationId, {
+            pathParams: { runId },
+            query: config.query(options),
+        });
         await renderSseStream(factory, stream);
     });
 }