@bctrl/cli 0.1.7 → 0.1.9

package/dist/commands/tool/index.js

@@ -2,7 +2,7 @@ import { Command } from 'commander';
 import { parsePositiveInteger } from '../shared/options.js';
 import { createOperationDeleteCommand, createOperationJsonBodyCommand, createOperationListCommand, createOperationViewCommand, } from '../shared/operation.js';
 export function createToolCommand(factory) {
-    const command = new Command('tool').description('Manage tools');
+    const command = new Command('tools').description('Manage tools');
     command.addCommand(createOperationListCommand(factory, {
         operationId: 'tools.list',
         description: 'List tools',
@@ -33,10 +33,20 @@ export function createToolCommand(factory) {
         argNames: ['id'],
     }));
     command.addCommand(createOperationJsonBodyCommand(factory, {
-        operationId: 'tools.test',
-        name: 'test',
-        description: 'Test a tool',
-        argNames: ['id'],
+        operationId: 'tools.call',
+        name: 'call',
+        description: 'Call a tool and wait for its result',
+        argNames: ['toolRef'],
+        configure: (cmd) => cmd.option('--runtime <id>', 'Runtime whose active Run should execute the Tool'),
+        runtimeId: (_args, options) => typeof options.runtime === 'string' ? options.runtime : undefined,
+    }));
+    command.addCommand(createOperationJsonBodyCommand(factory, {
+        operationId: 'tools.calls.create',
+        name: 'start',
+        description: 'Start an asynchronous tool call',
+        argNames: ['toolRef'],
+        configure: (cmd) => cmd.option('--runtime <id>', 'Runtime whose active Run should execute the Tool'),
+        runtimeId: (_args, options) => typeof options.runtime === 'string' ? options.runtime : undefined,
     }));
     command.addCommand(createOperationDeleteCommand(factory, {
         operationId: 'tools.delete',

package/dist/commands/tool-call/index.js

@@ -1,7 +1,7 @@
 import { Command } from 'commander';
-import { createOperationListCommand, createOperationViewCommand } from '../shared/operation.js';
+import { createOperationJsonBodyCommand, createOperationListCommand, createOperationViewCommand, } from '../shared/operation.js';
 export function createToolCallCommand(factory) {
-    const command = new Command('tool-call').description('Inspect BCTRL tool calls');
+    const command = new Command('tool-calls').description('Inspect BCTRL tool calls');
     command.addCommand(createOperationListCommand(factory, {
         operationId: 'tool-calls.list',
         description: 'List tool calls',
@@ -9,18 +9,34 @@ export function createToolCallCommand(factory) {
             .option('--space <id>', 'Space id')
             .option('--tool <id>', 'Filter by tool id')
             .option('--run <id>', 'Filter by run id')
-            .option('--invocation <id>', 'Filter by invocation id')
             .option('--status <status>', 'Filter by status')
-            .option('--actor <actor>', 'Filter by actor'),
+            .option('--caller-type <type>', 'Filter by caller type'),
         query: (options) => ({
             spaceId: typeof options.space === 'string' ? options.space : undefined,
             toolId: typeof options.tool === 'string' ? options.tool : undefined,
             runId: typeof options.run === 'string' ? options.run : undefined,
-            invocationId: typeof options.invocation === 'string' ? options.invocation : undefined,
             status: typeof options.status === 'string' ? options.status : undefined,
-            actor: typeof options.actor === 'string' ? options.actor : undefined,
+            callerType: typeof options.callerType === 'string' ? options.callerType : undefined,
         }),
     }));
+    command.addCommand(createOperationJsonBodyCommand(factory, {
+        operationId: 'tool-calls.cancel',
+        name: 'cancel',
+        description: 'Cancel a tool call',
+        argNames: ['toolCallId'],
+    }));
+    command.addCommand(createOperationJsonBodyCommand(factory, {
+        operationId: 'tool-calls.respond',
+        name: 'respond',
+        description: 'Respond to a tool input request',
+        argNames: ['toolCallId'],
+    }));
+    command.addCommand(createOperationViewCommand(factory, {
+        operationId: 'tool-calls.result',
+        name: 'result',
+        description: 'Wait for and return a tool call result',
+        argName: 'toolCallId',
+    }));
     command.addCommand(createOperationViewCommand(factory, {
         operationId: 'tool-calls.get',
         name: 'get',

package/dist/commands/toolset/index.js

@@ -1,7 +1,7 @@
 import { Command } from 'commander';
 import { createOperationDeleteCommand, createOperationJsonBodyCommand, createOperationListCommand, createOperationViewCommand, } from '../shared/operation.js';
 export function createToolsetCommand(factory) {
-    const command = new Command('toolset').description('Manage BCTRL toolsets');
+    const command = new Command('toolsets').description('Manage BCTRL toolsets');
     command.addCommand(createOperationListCommand(factory, {
         operationId: 'toolsets.list',
         description: 'List toolsets',

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

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

package/dist/commands/view/index.js

@@ -0,0 +1,26 @@
+import { Command } from "commander";
+import { createOperationDeleteCommand, createOperationJsonBodyCommand, createOperationListCommand, createOperationViewCommand, } from "../shared/operation.js";
+export function createViewsCommand(factory) {
+    const command = new Command("view").description("Manage expiring human-facing views");
+    command.addCommand(createOperationListCommand(factory, {
+        operationId: "views.list",
+        description: "List active views",
+    }));
+    command.addCommand(createOperationJsonBodyCommand(factory, {
+        operationId: "views.create",
+        name: "create",
+        description: "Create a hosted link or origin-restricted website embed (pass scope, components, presentation, and TTL with --body)",
+    }));
+    command.addCommand(createOperationViewCommand(factory, {
+        operationId: "views.get",
+        name: "get",
+        description: "Get a view",
+        argName: "viewId",
+    }));
+    command.addCommand(createOperationDeleteCommand(factory, {
+        operationId: "views.delete",
+        description: "Revoke a view",
+        argNames: ["viewId"],
+    }));
+    return command;
+}

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

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

package/dist/commands/webhook/index.js

@@ -0,0 +1,64 @@
+import { Command } from 'commander';
+import { addOutputFlags } from '../shared/output.js';
+import { addPaginationFlags, buildOperationInput, createOperationDeleteCommand, createOperationJsonBodyCommand, createOperationListCommand, createOperationViewCommand, outputFlags, requestOperationAndPrint, } from '../shared/operation.js';
+export function createWebhookCommand(factory) {
+    const command = new Command('webhook').description('Manage signed webhook deliveries');
+    command.addCommand(createOperationListCommand(factory, {
+        operationId: 'webhooks.list',
+        description: 'List webhooks',
+    }));
+    command.addCommand(createOperationJsonBodyCommand(factory, {
+        operationId: 'webhooks.create',
+        name: 'create',
+        description: 'Create a webhook (the signing secret is returned once)',
+    }));
+    command.addCommand(createOperationViewCommand(factory, {
+        operationId: 'webhooks.get',
+        name: 'get',
+        description: 'Get a webhook',
+        argName: 'webhookId',
+    }));
+    command.addCommand(createOperationJsonBodyCommand(factory, {
+        operationId: 'webhooks.update',
+        name: 'patch',
+        description: 'Update a webhook',
+        argNames: ['webhookId'],
+    }));
+    command.addCommand(createOperationDeleteCommand(factory, {
+        operationId: 'webhooks.delete',
+        description: 'Delete a webhook',
+        argNames: ['webhookId'],
+    }));
+    command.addCommand(createWebhookActionCommand(factory, 'rotate-secret', 'Rotate a webhook signing secret', 'webhooks.rotate-secret'));
+    command.addCommand(createWebhookActionCommand(factory, 'test', 'Queue a test delivery', 'webhooks.test'));
+    const deliveries = new Command('deliveries').description('Inspect webhook deliveries');
+    deliveries.addCommand(addOutputFlags(addPaginationFlags(new Command('list').description('List webhook deliveries').argument('<webhookId>'))).action(async (webhookId, options) => {
+        await requestOperationAndPrint(factory, 'webhooks.deliveries.list', await buildOperationInput('webhooks.deliveries.list', options, {
+            pathParams: { webhookId },
+            query: {
+                limit: options.limit,
+                cursor: options.cursor,
+            },
+            output: outputFlags(options),
+        }));
+    }));
+    deliveries.addCommand(addOutputFlags(new Command('redeliver')
+        .description('Queue a webhook delivery again')
+        .argument('<webhookId>')
+        .argument('<deliveryId>')).action(async (webhookId, deliveryId, options) => {
+        await requestOperationAndPrint(factory, 'webhooks.deliveries.redeliver', await buildOperationInput('webhooks.deliveries.redeliver', options, {
+            pathParams: { webhookId, deliveryId },
+            output: outputFlags(options),
+        }));
+    }));
+    command.addCommand(deliveries);
+    return command;
+}
+function createWebhookActionCommand(factory, name, description, operationId) {
+    return addOutputFlags(new Command(name).description(description).argument('<webhookId>')).action(async (webhookId, options) => {
+        await requestOperationAndPrint(factory, operationId, await buildOperationInput(operationId, options, {
+            pathParams: { webhookId },
+            output: outputFlags(options),
+        }));
+    });
+}