@bctrl/cli 0.1.3 → 0.1.5

package/dist/commands/tool/index.js

@@ -1,40 +1,46 @@
 import { Command } from 'commander';
-import { createDeleteCommand, createJsonBodyCommand, createListCommand, createViewCommand } from '../shared/rest.js';
+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 BCTRL tools');
-    command.addCommand(createListCommand(factory, {
+    const command = new Command('tool').description('Manage tools');
+    command.addCommand(createOperationListCommand(factory, {
+        operationId: 'tools.list',
         description: 'List tools',
-        path: '/tools',
-        configure: (cmd) => cmd.option('--space <id>', 'Filter by space id'),
-        query: (options) => ({ spaceId: typeof options.space === 'string' ? options.space : undefined }),
+        configure: (cmd) => cmd
+            .option('--space <id>', 'Filter by space id')
+            .option('-L, --limit <number>', 'Maximum number of results to return', parsePositiveInteger)
+            .option('--cursor <cursor>', 'Pagination cursor'),
+        query: (options) => ({
+            spaceId: typeof options.space === 'string' ? options.space : undefined,
+            limit: typeof options.limit === 'number' ? options.limit : undefined,
+            cursor: typeof options.cursor === 'string' ? options.cursor : undefined,
+        }),
     }));
-    command.addCommand(createViewCommand(factory, {
-        description: 'View a tool',
-        path: '/tools/{id}',
+    command.addCommand(createOperationViewCommand(factory, {
+        operationId: 'tools.get',
+        name: 'get',
+        description: 'Get a tool',
     }));
-    command.addCommand(createJsonBodyCommand(factory, {
+    command.addCommand(createOperationJsonBodyCommand(factory, {
+        operationId: 'tools.create',
         name: 'create',
         description: 'Create a tool',
-        method: 'post',
-        path: '/tools',
     }));
-    command.addCommand(createJsonBodyCommand(factory, {
-        name: 'edit',
-        description: 'Edit a tool',
-        method: 'patch',
-        path: '/tools/{id}',
+    command.addCommand(createOperationJsonBodyCommand(factory, {
+        operationId: 'tools.update',
+        name: 'patch',
+        description: 'Update a tool',
         argNames: ['id'],
     }));
-    command.addCommand(createJsonBodyCommand(factory, {
+    command.addCommand(createOperationJsonBodyCommand(factory, {
+        operationId: 'tools.test',
         name: 'test',
         description: 'Test a tool',
-        method: 'post',
-        path: '/tools/{id}/test',
         argNames: ['id'],
     }));
-    command.addCommand(createDeleteCommand(factory, {
+    command.addCommand(createOperationDeleteCommand(factory, {
+        operationId: 'tools.delete',
         description: 'Delete a tool',
-        path: '/tools/{id}',
     }));
     return command;
 }

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

@@ -1,25 +1,30 @@
 import { Command } from 'commander';
-import { createListCommand, createViewCommand } from '../shared/rest.js';
+import { createOperationListCommand, createOperationViewCommand } from '../shared/operation.js';
 export function createToolCallCommand(factory) {
     const command = new Command('tool-call').description('Inspect BCTRL tool calls');
-    command.addCommand(createListCommand(factory, {
+    command.addCommand(createOperationListCommand(factory, {
+        operationId: 'tool-calls.list',
         description: 'List tool calls',
-        path: '/tool-calls',
         configure: (cmd) => cmd
+            .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('--status <status>', 'Filter by status')
+            .option('--actor <actor>', 'Filter by actor'),
         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,
         }),
     }));
-    command.addCommand(createViewCommand(factory, {
+    command.addCommand(createOperationViewCommand(factory, {
+        operationId: 'tool-calls.get',
+        name: 'get',
         description: 'View a tool call',
-        path: '/tool-calls/{id}',
     }));
     return command;
 }

package/dist/commands/toolset/index.js

@@ -1,33 +1,34 @@
 import { Command } from 'commander';
-import { createDeleteCommand, createJsonBodyCommand, createListCommand, createViewCommand } from '../shared/rest.js';
+import { createOperationDeleteCommand, createOperationJsonBodyCommand, createOperationListCommand, createOperationViewCommand, } from '../shared/operation.js';
 export function createToolsetCommand(factory) {
     const command = new Command('toolset').description('Manage BCTRL toolsets');
-    command.addCommand(createListCommand(factory, {
+    command.addCommand(createOperationListCommand(factory, {
+        operationId: 'toolsets.list',
         description: 'List toolsets',
-        path: '/toolsets',
         configure: (cmd) => cmd.option('--space <id>', 'Filter by space id'),
-        query: (options) => ({ spaceId: typeof options.space === 'string' ? options.space : undefined }),
+        query: (options) => ({
+            spaceId: typeof options.space === 'string' ? options.space : undefined,
+        }),
     }));
-    command.addCommand(createViewCommand(factory, {
+    command.addCommand(createOperationViewCommand(factory, {
+        operationId: 'toolsets.get',
+        name: 'get',
         description: 'View a toolset',
-        path: '/toolsets/{id}',
     }));
-    command.addCommand(createJsonBodyCommand(factory, {
+    command.addCommand(createOperationJsonBodyCommand(factory, {
+        operationId: 'toolsets.create',
         name: 'create',
         description: 'Create a toolset',
-        method: 'post',
-        path: '/toolsets',
     }));
-    command.addCommand(createJsonBodyCommand(factory, {
-        name: 'edit',
+    command.addCommand(createOperationJsonBodyCommand(factory, {
+        operationId: 'toolsets.update',
+        name: 'patch',
         description: 'Edit a toolset',
-        method: 'patch',
-        path: '/toolsets/{id}',
         argNames: ['id'],
     }));
-    command.addCommand(createDeleteCommand(factory, {
+    command.addCommand(createOperationDeleteCommand(factory, {
+        operationId: 'toolsets.delete',
         description: 'Delete a toolset',
-        path: '/toolsets/{id}',
     }));
     return command;
 }

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

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

package/dist/commands/usage/index.js

@@ -0,0 +1,13 @@
+import { Command } from 'commander';
+import { addOutputFlags } from '../shared/output.js';
+import { outputFlags, requestOperationAndPrint } from '../shared/operation.js';
+export function createUsageCommand(factory) {
+    const command = addOutputFlags(new Command('usage').description('Get organization usage'));
+    command.action(async (options) => {
+        await requestOperationAndPrint(factory, 'usage.get', { output: outputFlags(options) });
+    });
+    command.addCommand(addOutputFlags(new Command('get').description('Get organization usage')).action(async (options) => {
+        await requestOperationAndPrint(factory, 'usage.get', { output: outputFlags(options) });
+    }));
+    return command;
+}

package/dist/commands/vault/index.js

@@ -3,14 +3,14 @@ import { CliError } from '../../runtime/errors.js';
 import { readJsonFile, readText } from '../shared/io.js';
 import { parsePositiveInteger } from '../shared/options.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 createVaultCommand(factory) {
     const command = new Command('vault').description('Manage vault secrets and TOTP codes');
-    command.addCommand(createListCommand(factory, {
+    command.addCommand(createOperationListCommand(factory, {
+        operationId: 'vault.secrets.list',
         description: 'List vault secret metadata',
-        path: '/vault/secrets',
         configure: (cmd) => cmd
-            .option('--prefix <prefix>', 'Filter by secret id prefix')
+            .option('--prefix <prefix>', 'Filter by secret key prefix')
             .option('--origin <origin>', 'Filter by origin')
             .option('--has-totp', 'Only show secrets with TOTP')
             .option('-L, --limit <number>', 'Maximum number of results to return', parsePositiveInteger),
@@ -21,15 +21,19 @@ export function createVaultCommand(factory) {
             limit: typeof options.limit === 'number' ? options.limit : undefined,
         }),
     }));
-    command.addCommand(createViewCommand(factory, {
+    command.addCommand(createOperationViewCommand(factory, {
+        operationId: 'vault.secrets.get',
+        name: 'get',
         description: 'View vault secret metadata',
-        path: '/vault/secrets/{id}',
+        argName: 'key',
     }));
     command.addCommand(createVaultReadCommand(factory));
     command.addCommand(createVaultSetCommand(factory));
-    command.addCommand(createDeleteCommand(factory, {
+    command.addCommand(createVaultPatchCommand(factory));
+    command.addCommand(createOperationDeleteCommand(factory, {
+        operationId: 'vault.secrets.delete',
         description: 'Delete a vault secret',
-        path: '/vault/secrets/{id}',
+        argNames: ['key'],
     }));
     command.addCommand(createVaultTotpCommand(factory));
     return command;
@@ -37,60 +41,137 @@ export function createVaultCommand(factory) {
 function createVaultReadCommand(factory) {
     return addOutputFlags(new Command('read')
         .description('Read a vault secret value')
-        .argument('<id>')
-        .option('--reveal', 'Allow printing a secret to an interactive terminal'))
-        .action(async (id, options) => {
+        .argument('<key>')
+        .option('--reveal', 'Allow printing a secret to an interactive terminal')).action(async (key, options) => {
         if (factory.io.isStdoutTTY() && options.reveal !== true) {
             throw new CliError('Refusing to print a secret to a terminal without --reveal');
         }
-        await requestAndPrint(factory, 'get', `/vault/secrets/${encodeURIComponent(id)}/value`, {
-            output: options,
+        await requestOperationAndPrint(factory, 'vault.secrets.value', {
+            pathParams: { key },
+            output: outputFlags(options),
         });
     });
 }
 function createVaultSetCommand(factory) {
-    return createJsonBodyCommand(factory, {
+    return createOperationJsonBodyCommand(factory, {
+        operationId: 'vault.secrets.upsert',
         name: 'set',
         description: 'Create or replace a vault secret',
-        method: 'put',
-        path: '/vault/secrets',
-        argNames: ['id'],
+        argNames: ['key'],
         configure: (cmd) => cmd
+            .option('--type <type>', 'Secret type: login or value')
+            .option('--value <value>', 'Generic secret value')
+            .option('--value-from-file <path>', 'Read generic secret value from file, or - for stdin')
             .option('--username <value>', 'Credential username')
             .option('--password <value>', 'Credential password')
             .option('--password-from-file <path>', 'Read password from file, or - for stdin')
-            .option('--totp <secret>', 'TOTP seed')
+            .option('--totp-secret <secret>', 'TOTP seed')
             .option('--label <label>', 'Display label')
             .option('--origin <origin...>', 'Allowed origin')
             .option('--origin-pattern <pattern...>', 'Allowed origin pattern')
             .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));
+            }
             const password = typeof options.passwordFromFile === 'string'
                 ? (await readText(options.passwordFromFile)).trimEnd()
                 : options.password;
+            const value = typeof options.valueFromFile === 'string'
+                ? (await readText(options.valueFromFile)).trimEnd()
+                : options.value;
+            const common = {
+                label: options.label,
+                origins: options.origin,
+                originPatterns: options.originPattern,
+            };
+            const type = options.type === 'value' || options.type === 'login'
+                ? options.type
+                : typeof value === 'string'
+                    ? 'value'
+                    : 'login';
+            if (typeof options.type === 'string' &&
+                options.type !== 'value' &&
+                options.type !== 'login') {
+                throw new CliError('Vault secret type must be "login" or "value"');
+            }
+            if (type === 'value') {
+                if (typeof value !== 'string') {
+                    throw new CliError('Vault value secrets require --value, --value-from-file, or --input');
+                }
+                return {
+                    ...common,
+                    type: 'value',
+                    value,
+                };
+            }
+            if (typeof options.username !== 'string' || typeof password !== 'string') {
+                throw new CliError('Vault login secrets require --username and --password, --password-from-file, or --input');
+            }
             return {
-                id: args.id,
-                value: {
-                    username: options.username,
-                    password,
-                    totp: options.totp,
-                },
-                metadata: {
-                    label: options.label,
-                    origins: options.origin,
-                    originPatterns: options.originPattern,
-                },
+                ...common,
+                type: 'login',
+                username: options.username,
+                password,
+                totpSecret: options.totpSecret,
             };
         },
     });
 }
+function createVaultPatchCommand(factory) {
+    return createOperationJsonBodyCommand(factory, {
+        operationId: 'vault.secrets.update',
+        name: 'patch',
+        description: 'Update a vault secret',
+        argNames: ['key'],
+        configure: (cmd) => cmd
+            .option('--value <value>', 'Generic secret value')
+            .option('--value-from-file <path>', 'Read generic secret value from file, or - for stdin')
+            .option('--username <value>', 'Credential username')
+            .option('--password <value>', 'Credential password')
+            .option('--password-from-file <path>', 'Read password from file, or - for stdin')
+            .option('--totp-secret <secret>', 'TOTP seed')
+            .option('--clear-totp', 'Remove the TOTP seed')
+            .option('--label <label>', 'Display label')
+            .option('--clear-label', 'Remove the display label')
+            .option('--origin <origin...>', 'Allowed origin')
+            .option('--clear-origins', 'Remove origins')
+            .option('--origin-pattern <pattern...>', 'Allowed origin pattern')
+            .option('--clear-origin-patterns', 'Remove origin patterns')
+            .option('--input <path>', 'Read full JSON request body from file, or - for stdin'),
+        body: async (_args, options) => {
+            if (typeof options.input === 'string') {
+                return (await readJsonFile(options.input));
+            }
+            const password = typeof options.passwordFromFile === 'string'
+                ? (await readText(options.passwordFromFile)).trimEnd()
+                : options.password;
+            const value = typeof options.valueFromFile === 'string'
+                ? (await readText(options.valueFromFile)).trimEnd()
+                : options.value;
+            const body = {
+                value,
+                username: options.username,
+                password,
+                totpSecret: options.clearTotp === true ? null : options.totpSecret,
+                label: options.clearLabel === true ? null : options.label,
+                origins: options.clearOrigins === true ? null : options.origin,
+                originPatterns: options.clearOriginPatterns === true ? null : options.originPattern,
+            };
+            if (!Object.values(body).some((value) => value !== undefined)) {
+                throw new CliError('Vault patch requires at least one field or --input');
+            }
+            return body;
+        },
+    });
+}
 function createVaultTotpCommand(factory) {
     return addOutputFlags(new Command('totp')
         .description('Generate the current TOTP code for a vault secret')
-        .argument('<id>'))
-        .action(async (id, options) => {
-        await requestAndPrint(factory, 'post', '/vault/totp', { body: { id }, output: options });
+        .argument('<key>')).action(async (key, options) => {
+        await requestOperationAndPrint(factory, 'vault.secrets.totp', {
+            pathParams: { key },
+            output: outputFlags(options),
+        });
     });
 }

package/dist/config/auth-store.d.ts

@@ -1,15 +1,14 @@
 import { z } from 'zod';
 export declare const StoredWhoamiSchema: z.ZodObject<{
-    authenticated: z.ZodLiteral<true>;
     email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    keyKind: z.ZodEnum<{
-        user: "user";
+    scope: z.ZodEnum<{
+        organization: "organization";
         subaccount: "subaccount";
     }>;
     organizationId: z.ZodString;
-    subaccountId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    userId: z.ZodString;
-    apiKeyId: z.ZodString;
+    subaccountId: z.ZodNullable<z.ZodString>;
+    defaultSpaceId: z.ZodString;
+    keyId: z.ZodString;
     plan: z.ZodString;
 }, z.core.$strict>;
 export type StoredWhoami = z.infer<typeof StoredWhoamiSchema>;
@@ -17,16 +16,15 @@ export declare const StoredAuthSchema: z.ZodObject<{
     apiBaseUrl: z.ZodString;
     token: z.ZodString;
     whoami: z.ZodObject<{
-        authenticated: z.ZodLiteral<true>;
         email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        keyKind: z.ZodEnum<{
-            user: "user";
+        scope: z.ZodEnum<{
+            organization: "organization";
             subaccount: "subaccount";
         }>;
         organizationId: z.ZodString;
-        subaccountId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        userId: z.ZodString;
-        apiKeyId: z.ZodString;
+        subaccountId: z.ZodNullable<z.ZodString>;
+        defaultSpaceId: z.ZodString;
+        keyId: z.ZodString;
         plan: z.ZodString;
     }, z.core.$strict>;
     createdAt: z.ZodString;

package/dist/config/auth-store.js

@@ -5,13 +5,12 @@ import { z } from 'zod';
 const DEFAULT_AUTH_FILE_NAME = 'auth.json';
 export const StoredWhoamiSchema = z
     .object({
-    authenticated: z.literal(true),
     email: z.string().email().nullable().optional(),
-    keyKind: z.enum(['user', 'subaccount']),
+    scope: z.enum(['organization', 'subaccount']),
     organizationId: z.string().min(1),
-    subaccountId: z.string().min(1).nullable().optional(),
-    userId: z.string().min(1),
-    apiKeyId: z.string().min(1),
+    subaccountId: z.string().min(1).nullable(),
+    defaultSpaceId: z.string().min(1),
+    keyId: z.string().min(1),
     plan: z.string().min(1),
 })
     .strict();