@bctrl/cli 0.1.6 → 0.1.8

package/dist/commands/run/index.js

@@ -1,9 +1,9 @@
 import { Command } from 'commander';
 import { CliError } from '../../runtime/errors.js';
-import { readJsonFile, writeBinary } from '../shared/io.js';
+import { writeBinary } from '../shared/io.js';
 import { parsePositiveInteger } from '../shared/options.js';
 import { addOutputFlags } from '../shared/output.js';
-import { addPaginationFlags, createOperationJsonBodyCommand, createOperationListCommand, createOperationViewCommand, downloadOperation, outputFlags, requestOperation, requestOperationAndPrint, streamOperationText, } from '../shared/operation.js';
+import { actingSubaccountOption, addPaginationFlags, buildOperationInput, 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(createOperationListCommand(factory, {
@@ -18,10 +18,10 @@ export function createRunCommand(factory) {
             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,
         }),
+        actingSubaccountId: actingSubaccountOption('subaccount'),
     }));
     command.addCommand(createOperationViewCommand(factory, {
         operationId: 'runs.get',
@@ -72,8 +72,9 @@ function createRunActivityListCommand(factory) {
         .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', {
+        .option('--file <id>', 'Filter by file id')
+        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')).action(async (runId, options) => {
+        await requestOperationAndPrint(factory, 'runs.activity.list', await buildOperationInput('runs.activity.list', options, {
             pathParams: { runId },
             query: {
                 view: options.view,
@@ -86,7 +87,7 @@ function createRunActivityListCommand(factory) {
                 cursor: options.cursor,
             },
             output: outputFlags(options),
-        });
+        }));
     });
 }
 function createRunEventsCommand(factory) {
@@ -117,8 +118,9 @@ function createRunEventsListCommand(factory) {
         .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', {
+        .option('--context-id <id>', 'Filter by browser context id')
+        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')).action(async (runId, options) => {
+        await requestOperationAndPrint(factory, 'runs.events.list', await buildOperationInput('runs.events.list', options, {
             pathParams: { runId },
             query: {
                 type: options.type,
@@ -129,7 +131,7 @@ function createRunEventsListCommand(factory) {
                 cursor: options.cursor,
             },
             output: outputFlags(options),
-        });
+        }));
     });
 }
 function createRunFilesCommand(factory) {
@@ -139,8 +141,10 @@ function createRunFilesCommand(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', {
+    return addOutputFlags(addPaginationFlags(new Command('list').description('List run files').argument('<runId>'))
+        .option('--type <type>', 'Filter by file type')
+        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')).action(async (runId, options) => {
+        await requestOperationAndPrint(factory, 'runs.files.list', await buildOperationInput('runs.files.list', options, {
             pathParams: { runId },
             query: {
                 type: options.type,
@@ -148,7 +152,7 @@ function createRunFilesListCommand(factory) {
                 cursor: options.cursor,
             },
             output: outputFlags(options),
-        });
+        }));
     });
 }
 function createRunFilesExportCommand(factory) {
@@ -157,15 +161,12 @@ function createRunFilesExportCommand(factory) {
         .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,
-            };
+        .option('--type <type...>', 'Filter exported file types')).action(async (runId, options) => {
+        const body = {
+            format: 'zip',
+            name: options.name,
+            filter: options.type ? { type: options.type } : undefined,
+        };
         const result = (await requestOperation(factory, 'runs.files.export', {
             pathParams: { runId },
             body: body,
@@ -183,9 +184,10 @@ function createRunFilesExportCommand(factory) {
 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'));
+        .option('--action <action>', 'Filter by invocation action')
+        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)'));
     command.action(async (runId, options) => {
-        await requestOperationAndPrint(factory, 'runs.invocations.list', {
+        await requestOperationAndPrint(factory, 'runs.invocations.list', await buildOperationInput('runs.invocations.list', options, {
             pathParams: { runId },
             query: {
                 status: options.status,
@@ -194,7 +196,7 @@ function createRunInvocationsCommand(factory) {
                 cursor: options.cursor,
             },
             output: outputFlags(options),
-        });
+        }));
     });
     return command;
 }
@@ -203,11 +205,12 @@ function createRunInvocationCommand(factory) {
     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', {
+        .argument('<invocationId>')
+        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')).action(async (runId, invocationId, options) => {
+        await requestOperationAndPrint(factory, 'runs.invocations.get', await buildOperationInput('runs.invocations.get', options, {
             pathParams: { runId, invocationId },
             output: outputFlags(options),
-        });
+        }));
     }));
     return command;
 }
@@ -219,12 +222,8 @@ function createRunViewerCommand(factory, 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'),
+            .option('--control <none|input>', 'Live viewer control mode'),
         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,

package/dist/commands/runtime/index.js

@@ -1,9 +1,10 @@
 import { Command, Option } from 'commander';
-import { readBlob, readJsonFile } from '../shared/io.js';
-import { addPaginationFlags, createOperationJsonBodyCommand, outputFlags, requestOperationAndPrint, uploadOperationFile, } from '../shared/operation.js';
+import { parseJsonString, readBlob, readJsonFile } from '../shared/io.js';
+import { addPaginationFlags, buildOperationInput, createOperationJsonBodyCommand, outputFlags, requestOperationAndPrint, uploadOperationFile, } from '../shared/operation.js';
 import { parsePositiveInteger } from '../shared/options.js';
 import { addOutputFlags, outputData } from '../shared/output.js';
 import { CliError } from '../../runtime/errors.js';
+import { addCliOperationHelp } from '../shared/help.js';
 export function createRuntimeCommand(factory) {
     const command = new Command('runtime').description('Manage runtimes');
     command.addCommand(addOutputFlags(addPaginationFlags(new Command('list').description('List runtimes'))
@@ -12,8 +13,9 @@ export function createRuntimeCommand(factory) {
         'active',
         'failed',
         'stopped',
-    ]))).action(async (options) => {
-        await requestOperationAndPrint(factory, 'runtimes.list', {
+    ]))
+        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')).action(async (options) => {
+        await requestOperationAndPrint(factory, 'runtimes.list', await buildOperationInput('runtimes.list', options, {
             query: {
                 spaceId: options.space,
                 status: options.status ? [options.status] : undefined,
@@ -21,13 +23,16 @@ export function createRuntimeCommand(factory) {
                 cursor: options.cursor,
             },
             output: outputFlags(options),
-        });
+        }));
     }));
-    command.addCommand(addOutputFlags(new Command('get').description('Get a runtime').argument('<runtimeId>')).action(async (runtimeId, options) => {
-        await requestOperationAndPrint(factory, 'runtimes.get', {
+    command.addCommand(addOutputFlags(new Command('get')
+        .description('Get a runtime')
+        .argument('<runtimeId>')
+        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')).action(async (runtimeId, options) => {
+        await requestOperationAndPrint(factory, 'runtimes.get', await buildOperationInput('runtimes.get', options, {
             pathParams: { runtimeId },
             output: outputFlags(options),
-        });
+        }));
     }));
     command.addCommand(createRuntimeCreateCommand(factory));
     command.addCommand(createRuntimePatchCommand(factory));
@@ -35,84 +40,101 @@ export function createRuntimeCommand(factory) {
         .description('Delete a runtime and its browser state')
         .argument('<runtimeId>')
         .option('-y, --yes', 'Confirm deletion')
-        .option('--force', 'Stop the runtime first if it is still active')).action(async (runtimeId, options) => {
+        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')).action(async (runtimeId, options) => {
         if (options.yes !== true) {
             throw new CliError('Refusing to delete without --yes');
         }
-        await requestOperationAndPrint(factory, 'runtimes.delete', {
+        await requestOperationAndPrint(factory, 'runtimes.delete', await buildOperationInput('runtimes.delete', options, {
             pathParams: { runtimeId },
-            query: { force: options.force === true ? true : undefined },
             output: outputFlags(options),
-        });
+        }));
     }));
     command.addCommand(createRuntimeStartCommand(factory));
-    command.addCommand(addOutputFlags(new Command('stop').description('Stop a runtime').argument('<runtimeId>')).action(async (runtimeId, options) => {
-        await requestOperationAndPrint(factory, 'runtimes.stop', {
+    command.addCommand(addOutputFlags(new Command('stop')
+        .description('Stop a runtime')
+        .argument('<runtimeId>')
+        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')).action(async (runtimeId, options) => {
+        await requestOperationAndPrint(factory, 'runtimes.stop', await buildOperationInput('runtimes.stop', options, {
             pathParams: { runtimeId },
             output: outputFlags(options),
-        });
+        }));
     }));
     command.addCommand(createRuntimeFileCommand(factory));
     command.addCommand(createRuntimeInvocationCommand(factory));
+    command.addCommand(createRuntimeHumanActionCommand(factory));
     command.addCommand(createRuntimeTargetCommand(factory));
     return command;
 }
 function createRuntimeTargetCommand(factory) {
     const command = new Command('target').description('Manage runtime targets (tabs)');
-    command.addCommand(addOutputFlags(new Command('list').description('List targets').argument('<runtimeId>')).action(async (runtimeId, options) => {
-        await requestOperationAndPrint(factory, 'runtimes.targets.list', {
+    command.addCommand(addOutputFlags(new Command('list')
+        .description('List targets')
+        .argument('<runtimeId>')
+        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')).action(async (runtimeId, options) => {
+        await requestOperationAndPrint(factory, 'runtimes.targets.list', await buildOperationInput('runtimes.targets.list', options, {
             pathParams: { runtimeId },
             output: outputFlags(options),
-        });
+        }));
     }));
     command.addCommand(addOutputFlags(new Command('create')
         .description('Open a new target')
         .argument('<runtimeId>')
         .option('--uri <uri>', 'Navigate the new target to this URI')
-        .option('--activate', 'Focus the new target')).action(async (runtimeId, options) => {
-        await requestOperationAndPrint(factory, 'runtimes.targets.create', {
+        .option('--activate', 'Focus the new target')
+        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')
+        .option('--body <json>', 'Request body as JSON (inline, @file, or - for stdin)')).action(async (runtimeId, options) => {
+        await requestOperationAndPrint(factory, 'runtimes.targets.create', await buildOperationInput('runtimes.targets.create', options, {
             pathParams: { runtimeId },
             body: {
                 ...(options.uri ? { uri: options.uri } : {}),
                 ...(options.activate ? { activate: true } : {}),
             },
             output: outputFlags(options),
-        });
+        }));
     }));
-    command.addCommand(addOutputFlags(new Command('get').description('Get a target').argument('<runtimeId>').argument('<targetId>')).action(async (runtimeId, targetId, options) => {
-        await requestOperationAndPrint(factory, 'runtimes.targets.get', {
+    command.addCommand(addOutputFlags(new Command('get')
+        .description('Get a target')
+        .argument('<runtimeId>')
+        .argument('<targetId>')
+        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')).action(async (runtimeId, targetId, options) => {
+        await requestOperationAndPrint(factory, 'runtimes.targets.get', await buildOperationInput('runtimes.targets.get', options, {
             pathParams: { runtimeId, targetId },
             output: outputFlags(options),
-        });
+        }));
     }));
     command.addCommand(addOutputFlags(new Command('activate')
         .description('Focus a target')
         .argument('<runtimeId>')
-        .argument('<targetId>')).action(async (runtimeId, targetId, options) => {
-        await requestOperationAndPrint(factory, 'runtimes.targets.activate', {
+        .argument('<targetId>')
+        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')).action(async (runtimeId, targetId, options) => {
+        await requestOperationAndPrint(factory, 'runtimes.targets.activate', await buildOperationInput('runtimes.targets.activate', options, {
             pathParams: { runtimeId, targetId },
             output: outputFlags(options),
-        });
+        }));
     }));
     command.addCommand(addOutputFlags(new Command('delete')
         .description('Close a target')
         .argument('<runtimeId>')
-        .argument('<targetId>')).action(async (runtimeId, targetId, options) => {
-        await requestOperationAndPrint(factory, 'runtimes.targets.delete', {
+        .argument('<targetId>')
+        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')).action(async (runtimeId, targetId, options) => {
+        await requestOperationAndPrint(factory, 'runtimes.targets.delete', await buildOperationInput('runtimes.targets.delete', options, {
             pathParams: { runtimeId, targetId },
             output: outputFlags(options),
-        });
+        }));
     }));
     return command;
 }
 function createRuntimeCreateCommand(factory) {
-    return addOutputFlags(new Command('create')
+    return addOutputFlags(addCliOperationHelp(new Command('create')
         .description('Create a runtime')
         .option('--space <id>', 'Space id; omitted uses caller default space')
         .option('--name <name>', 'Runtime name')
         .option('--profile', 'Persist browser state across runtime starts')
         .option('--proxy <id-or-url>', 'Saved proxy id or inline custom proxy URL')
-        .addOption(new Option('--device <device>', 'Fingerprint device filter').choices(['desktop', 'mobile']))
+        .addOption(new Option('--device <device>', 'Fingerprint device filter').choices([
+        'desktop',
+        'mobile',
+    ]))
         .addOption(new Option('--os <os>', 'Fingerprint OS filter').choices([
         'windows',
         'macos',
@@ -128,24 +150,26 @@ function createRuntimeCreateCommand(factory) {
         .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')).action(async (options) => {
+        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')
+        .option('--body <json>', 'Full request body as JSON (inline, @file, or - for stdin)'), 'runtimes.create')).action(async (options) => {
+        // --body (raw JSON) is the complete body; otherwise build it from
+        // the curated flags. --params can still add query params. The control-plane
+        // validates the body against the runtimes.create schema either way.
         const config = typeof options.configFile === 'string'
             ? await readJsonFile(options.configFile, '--config-file')
             : undefined;
-        await requestOperationAndPrint(factory, 'runtimes.create', {
-            body: typeof options.input === 'string'
-                ? (await readJsonFile(options.input))
-                : {
-                    type: 'browser',
-                    spaceId: options.space,
-                    name: options.name,
-                    config: buildRuntimeCreateConfig(config, options),
-                    metadata: typeof options.metadataFile === 'string'
-                        ? await readJsonFile(options.metadataFile, '--metadata-file')
-                        : undefined,
-                },
+        await requestOperationAndPrint(factory, 'runtimes.create', await buildOperationInput('runtimes.create', options, {
+            body: {
+                type: 'browser',
+                spaceId: options.space,
+                name: options.name,
+                config: buildRuntimeCreateConfig(config, options),
+                metadata: typeof options.metadataFile === 'string'
+                    ? await readJsonFile(options.metadataFile, '--metadata-file')
+                    : undefined,
+            },
             output: outputFlags(options),
-        });
+        }));
     });
 }
 function collectLocale(value, previous) {
@@ -195,34 +219,34 @@ function createRuntimePatchCommand(factory) {
         .description('Update a runtime')
         .argument('<runtimeId>')
         .option('--name <name>', 'Runtime name')
-        .option('--idle-timeout-minutes <minutes>', 'Idle timeout in minutes', parsePositiveInteger)
+        .option('--idle-timeout-seconds <seconds>', 'Idle timeout in seconds', parsePositiveInteger)
         .option('--config-file <path>', 'Runtime config JSON file')
-        .option('--input <path>', 'Read full JSON request body from file, or - for stdin')).action(async (runtimeId, options) => {
-        await requestOperationAndPrint(factory, 'runtimes.update', {
+        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')
+        .option('--body <json>', 'Request body as JSON (inline, @file, or - for stdin)')).action(async (runtimeId, options) => {
+        await requestOperationAndPrint(factory, 'runtimes.update', await buildOperationInput('runtimes.update', options, {
             pathParams: { runtimeId },
-            body: typeof options.input === 'string'
-                ? (await readJsonFile(options.input))
-                : {
-                    name: options.name,
-                    idleTimeoutMinutes: options.idleTimeoutMinutes,
-                    config: typeof options.configFile === 'string'
-                        ? await readJsonFile(options.configFile, '--config-file')
-                        : undefined,
-                },
+            body: {
+                name: options.name,
+                idleTimeoutSeconds: options.idleTimeoutSeconds,
+                config: typeof options.configFile === 'string'
+                    ? await readJsonFile(options.configFile, '--config-file')
+                    : undefined,
+            },
             output: outputFlags(options),
-        });
+        }));
     });
 }
 function createRuntimeStartCommand(factory) {
     return addOutputFlags(new Command('start')
         .description('Start a runtime')
         .argument('<runtimeId>')
-        .option('--idempotency-key <key>', 'Idempotency key for retry-safe start')).action(async (runtimeId, options) => {
-        await requestOperationAndPrint(factory, 'runtimes.start', {
+        .option('--idempotency-key <key>', 'Idempotency key for retry-safe start')
+        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')).action(async (runtimeId, options) => {
+        await requestOperationAndPrint(factory, 'runtimes.start', await buildOperationInput('runtimes.start', options, {
             pathParams: { runtimeId },
             idempotencyKey: options.idempotencyKey,
             output: outputFlags(options),
-        });
+        }));
     });
 }
 function createRuntimeInvocationCommand(factory) {
@@ -232,11 +256,12 @@ function createRuntimeInvocationCommand(factory) {
     command.addCommand(addOutputFlags(new Command('cancel')
         .description('Cancel an invocation')
         .argument('<runtimeId>')
-        .argument('<invocationId>')).action(async (runtimeId, invocationId, options) => {
-        await requestOperationAndPrint(factory, 'runtimes.invocations.cancel', {
+        .argument('<invocationId>')
+        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')).action(async (runtimeId, invocationId, options) => {
+        await requestOperationAndPrint(factory, 'runtimes.invocations.cancel', await buildOperationInput('runtimes.invocations.cancel', options, {
             pathParams: { runtimeId, invocationId },
             output: outputFlags(options),
-        });
+        }));
     }));
     return command;
 }
@@ -250,30 +275,29 @@ function createRuntimeInvocationCreateCommand(factory) {
         .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('--timeout-seconds <seconds>', 'Invocation timeout in seconds', 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 requestOperationAndPrint(factory, 'runtimes.invocations.create', {
+        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')
+        .option('--body <json>', 'Request body as JSON (inline, @file, or - for stdin)')).action(async (runtimeId, options) => {
+        const body = {
+            action: options.action,
+            instruction: options.instruction,
+            target: options.target === undefined
+                ? undefined
+                : options.target === 'active' || options.target === 'new'
+                    ? options.target
+                    : { id: options.target },
+            model: options.model,
+            toolIds: options.tool,
+            toolsetId: options.toolset,
+            timeoutSeconds: options.timeoutSeconds,
+        };
+        await requestOperationAndPrint(factory, 'runtimes.invocations.create', await buildOperationInput('runtimes.invocations.create', options, {
             pathParams: { runtimeId },
             body: body,
             idempotencyKey: options.idempotencyKey,
             output: outputFlags(options),
-        });
+        }));
     });
 }
 function createRuntimeInvocationWaitCommand(factory) {
@@ -283,20 +307,80 @@ function createRuntimeInvocationWaitCommand(factory) {
         description: 'Wait for an invocation',
         argNames: ['runtimeId', 'invocationId'],
         configure: (cmd) => cmd
-            .option('--timeout-ms <ms>', 'Wait timeout in milliseconds', parsePositiveInteger)
-            .option('--input <path>', 'Read JSON request body from file, or - for stdin'),
+            .option('--timeout-seconds <seconds>', 'Wait timeout in seconds', parsePositiveInteger),
         body: async (_args, options) => {
-            if (typeof options.input === 'string') {
-                return (await readJsonFile(options.input));
-            }
-            return { timeoutMs: options.timeoutMs };
+            return {
+                timeoutSeconds: options.timeoutSeconds,
+            };
         },
     });
 }
+function createRuntimeHumanActionCommand(factory) {
+    const command = new Command('human-action').description('Manage runtime human actions');
+    command.addCommand(createOperationJsonBodyCommand(factory, {
+        operationId: 'runtimes.human-actions.create',
+        name: 'create',
+        description: 'Request human action',
+        argNames: ['runtimeId'],
+        configure: (cmd) => cmd
+            .option('--message <message>', 'Instructions for the human')
+            .option('--timeout-seconds <seconds>', 'Human action timeout in seconds', parsePositiveInteger),
+        body: async (_args, options) => {
+            return {
+                message: options.message,
+                timeoutSeconds: options.timeoutSeconds,
+            };
+        },
+    }));
+    command.addCommand(addOutputFlags(addCliOperationHelp(new Command('get')
+        .description('Get a human action')
+        .argument('<runtimeId>')
+        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)'), 'runtimes.human-actions.get')).action(async (runtimeId, options) => {
+        await requestOperationAndPrint(factory, 'runtimes.human-actions.get', await buildOperationInput('runtimes.human-actions.get', options, {
+            pathParams: { runtimeId },
+            output: outputFlags(options),
+        }));
+    }));
+    command.addCommand(addOutputFlags(addCliOperationHelp(new Command('complete')
+        .description('Complete a human action')
+        .argument('<runtimeId>')
+        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)'), 'runtimes.human-actions.complete')).action(async (runtimeId, options) => {
+        await requestOperationAndPrint(factory, 'runtimes.human-actions.complete', await buildOperationInput('runtimes.human-actions.complete', options, {
+            pathParams: { runtimeId },
+            output: outputFlags(options),
+        }));
+    }));
+    command.addCommand(addOutputFlags(addCliOperationHelp(new Command('cancel')
+        .description('Cancel a human action')
+        .argument('<runtimeId>')
+        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)'), 'runtimes.human-actions.cancel')).action(async (runtimeId, options) => {
+        await requestOperationAndPrint(factory, 'runtimes.human-actions.cancel', await buildOperationInput('runtimes.human-actions.cancel', options, {
+            pathParams: { runtimeId },
+            output: outputFlags(options),
+        }));
+    }));
+    command.addCommand(addOutputFlags(addCliOperationHelp(new Command('wait')
+        .description('Wait for a human action')
+        .argument('<runtimeId>')
+        .option('--timeout-seconds <seconds>', 'Long-poll timeout', parsePositiveInteger)
+        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')
+        .option('--body <json>', 'Request body as JSON (inline, @file, or - for stdin)'), 'runtimes.human-actions.wait')).action(async (runtimeId, options) => {
+        await requestOperationAndPrint(factory, 'runtimes.human-actions.wait', await buildOperationInput('runtimes.human-actions.wait', options, {
+            pathParams: { runtimeId },
+            body: {
+                timeoutSeconds: options.timeoutSeconds,
+            },
+            output: outputFlags(options),
+        }));
+    }));
+    return command;
+}
 function createRuntimeFileCommand(factory) {
     const command = new Command('file').description('Move files into and out of runtimes');
-    command.addCommand(addOutputFlags(addPaginationFlags(new Command('list').description('List runtime files').argument('<runtimeId>')).option('--type <type>', 'Filter by file type')).action(async (runtimeId, options) => {
-        await requestOperationAndPrint(factory, 'runtimes.files.list', {
+    command.addCommand(addOutputFlags(addPaginationFlags(new Command('list').description('List runtime files').argument('<runtimeId>'))
+        .option('--type <type>', 'Filter by file type')
+        .option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)')).action(async (runtimeId, options) => {
+        await requestOperationAndPrint(factory, 'runtimes.files.list', await buildOperationInput('runtimes.files.list', options, {
             pathParams: { runtimeId },
             query: {
                 type: options.type,
@@ -304,7 +388,7 @@ function createRuntimeFileCommand(factory) {
                 cursor: options.cursor,
             },
             output: outputFlags(options),
-        });
+        }));
     }));
     command.addCommand(createRuntimeFileUploadCommand(factory));
     command.addCommand(createRuntimeFileStageCommand(factory));
@@ -319,11 +403,14 @@ function createRuntimeFileUploadCommand(factory) {
         .option('--destination-path <path>', 'Durable BCTRL storage destination')
         .option('--runtime-path <path>', 'Runtime workspace destination')
         .option('--name <name>', 'Display name')
+        .option('--metadata <json>', 'Metadata as inline JSON (overrides --metadata-file)')
         .option('--metadata-file <path>', 'Metadata JSON file')).action(async (runtimeId, localPath, options) => {
         const file = await readBlob(localPath);
-        const metadata = typeof options.metadataFile === 'string'
-            ? JSON.stringify(await readJsonFile(options.metadataFile, '--metadata-file'))
-            : undefined;
+        const metadata = options.metadata !== undefined
+            ? JSON.stringify(parseJsonString(options.metadata, '--metadata'))
+            : typeof options.metadataFile === 'string'
+                ? JSON.stringify(await readJsonFile(options.metadataFile, '--metadata-file'))
+                : undefined;
         const result = await uploadOperationFile(factory, 'runtimes.files.upload', {
             pathParams: { runtimeId },
             file: file.blob,
@@ -347,12 +434,8 @@ function createRuntimeFileStageCommand(factory) {
         configure: (cmd) => cmd
             .option('--file <id>', 'Durable file id')
             .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'),
+            .option('--name <name>', 'Runtime-local display name'),
         body: async (_args, options) => {
-            if (typeof options.input === 'string') {
-                return (await readJsonFile(options.input));
-            }
             return {
                 fileId: options.file,
                 runtimePath: options.runtimePath,
@@ -370,12 +453,8 @@ function createRuntimeFileCollectCommand(factory) {
         configure: (cmd) => cmd
             .requiredOption('--runtime-path <path>', 'Runtime workspace source')
             .option('--name <name>', 'Durable file name')
-            .option('--destination-path <path>', 'Durable BCTRL storage destination')
-            .option('--input <path>', 'Read JSON request body from file, or - for stdin'),
+            .option('--destination-path <path>', 'Durable BCTRL storage destination'),
         body: async (_args, options) => {
-            if (typeof options.input === 'string') {
-                return (await readJsonFile(options.input));
-            }
             return {
                 runtimePath: options.runtimePath,
                 name: options.name,