@bctrl/cli 0.1.3 → 0.1.4

package/dist/commands/subaccount/index.js

@@ -2,17 +2,35 @@ import { Command } from 'commander';
 import { readJsonFile } 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 { createJsonBodyCommand, addPaginationFlags, createListCommand, createViewCommand, requestAndPrint, } from '../shared/rest.js';
 export function createSubaccountCommand(factory) {
-    const command = new Command('subaccount').description('Manage subaccounts, keys, limits, and usage');
+    const command = new Command('subaccount').description('Manage subaccounts');
     command.addCommand(createListCommand(factory, {
         description: 'List subaccounts',
         path: '/subaccounts',
-        configure: (cmd) => cmd,
+        query: (options) => ({
+            limit: typeof options.limit === 'number' ? options.limit : undefined,
+            cursor: typeof options.cursor === 'string' ? options.cursor : undefined,
+            include: options.includeUsage === true ? 'usage' : undefined,
+            status: typeof options.status === 'string' ? options.status : undefined,
+            externalId: typeof options.externalId === 'string' ? options.externalId : undefined,
+            query: typeof options.query === 'string' ? options.query : undefined,
+        }),
+        configure: (cmd) => addPaginationFlags(cmd)
+            .option('--include-usage', 'Inline current usage')
+            .option('--status <status>', 'Filter by status')
+            .option('--external-id <id>', 'Filter by external id')
+            .option('--query <text>', 'Search by id, name, or external id'),
     }));
     command.addCommand(createViewCommand(factory, {
-        description: 'View a subaccount',
-        path: '/subaccounts/{id}',
+        name: 'get',
+        description: 'Get a subaccount',
+        path: '/subaccounts/{subaccountId}',
+        argName: 'subaccountId',
+        configure: (cmd) => cmd.option('--include <value>', 'Include related data, for example usage'),
+        query: (_id, options) => ({
+            include: typeof options.include === 'string' ? options.include : undefined,
+        }),
     }));
     command.addCommand(createJsonBodyCommand(factory, {
         name: 'create',
@@ -37,11 +55,11 @@ export function createSubaccountCommand(factory) {
         },
     }));
     command.addCommand(createJsonBodyCommand(factory, {
-        name: 'edit',
-        description: 'Edit a subaccount',
+        name: 'patch',
+        description: 'Update a subaccount',
         method: 'patch',
-        path: '/subaccounts/{id}',
-        argNames: ['id'],
+        path: '/subaccounts/{subaccountId}',
+        argNames: ['subaccountId'],
         configure: (cmd) => cmd
             .option('--name <name>', 'Subaccount name')
             .option('--external-id <id>', 'External id')
@@ -69,8 +87,6 @@ export function createSubaccountCommand(factory) {
         });
     }));
     command.addCommand(createSubaccountUsageCommand(factory));
-    command.addCommand(createSubaccountLimitsCommand(factory));
-    command.addCommand(createSubaccountKeyCommand(factory));
     return command;
 }
 function createSubaccountUsageCommand(factory) {
@@ -81,7 +97,8 @@ function createSubaccountUsageCommand(factory) {
         .option('--cursor <cursor>', 'Pagination cursor'))
         .action(async (id, options) => {
         if (id) {
-            await requestAndPrint(factory, 'get', `/subaccounts/${encodeURIComponent(id)}/usage`, {
+            await requestAndPrint(factory, 'get', `/subaccounts/${encodeURIComponent(id)}`, {
+                query: { include: 'usage' },
                 output: options,
             });
             return;
@@ -92,71 +109,3 @@ function createSubaccountUsageCommand(factory) {
         });
     });
 }
-function createSubaccountLimitsCommand(factory) {
-    const command = new Command('limits').description('Manage subaccount limits');
-    command.addCommand(addOutputFlags(new Command('get')
-        .description('View subaccount limits')
-        .argument('<id>'))
-        .action(async (id, options) => {
-        await requestAndPrint(factory, 'get', `/subaccounts/${encodeURIComponent(id)}/limits`, {
-            output: options,
-        });
-    }));
-    command.addCommand(createJsonBodyCommand(factory, {
-        name: 'set',
-        description: 'Update subaccount limits',
-        method: 'patch',
-        path: '/subaccounts/{id}/limits',
-        argNames: ['id'],
-        configure: (cmd) => cmd
-            .option('--max-spaces <number>', 'Maximum spaces')
-            .option('--max-active-runs <number>', 'Maximum active runs')
-            .option('--monthly-spend-micro-usd <number>', 'Monthly spend limit in micro USD')
-            .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);
-            return {
-                spaces: options.maxSpaces ? { max: Number(options.maxSpaces) } : undefined,
-                runs: options.maxActiveRuns ? { maxActive: Number(options.maxActiveRuns) } : undefined,
-                spend: options.monthlySpendMicroUsd
-                    ? { monthlyLimitMicroUsd: Number(options.monthlySpendMicroUsd) }
-                    : undefined,
-            };
-        },
-    }));
-    return command;
-}
-function createSubaccountKeyCommand(factory) {
-    const command = new Command('key').description('Manage subaccount API keys');
-    command.addCommand(addOutputFlags(new Command('list')
-        .description('List subaccount API keys')
-        .argument('<id>'))
-        .action(async (id, options) => {
-        await requestAndPrint(factory, 'get', `/subaccounts/${encodeURIComponent(id)}/api-keys`, {
-            output: options,
-        });
-    }));
-    command.addCommand(createJsonBodyCommand(factory, {
-        name: 'create',
-        description: 'Create a subaccount API key',
-        method: 'post',
-        path: '/subaccounts/{id}/api-keys',
-        argNames: ['id'],
-        configure: (cmd) => cmd
-            .option('--name <name>', 'API key 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);
-            return { name: options.name };
-        },
-    }));
-    command.addCommand(createDeleteCommand(factory, {
-        name: 'revoke',
-        description: 'Revoke a subaccount API key',
-        path: '/subaccounts/{id}/api-keys/{keyId}',
-        argNames: ['id', 'keyId'],
-    }));
-    return command;
-}

package/dist/commands/tool/index.js

@@ -1,15 +1,23 @@
 import { Command } from 'commander';
-import { createDeleteCommand, createJsonBodyCommand, createListCommand, createViewCommand } from '../shared/rest.js';
+import { createDeleteCommand, createJsonBodyCommand, createListCommand, createViewCommand, } from '../shared/rest.js';
 export function createToolCommand(factory) {
-    const command = new Command('tool').description('Manage BCTRL tools');
+    const command = new Command('tool').description('Manage tools');
     command.addCommand(createListCommand(factory, {
         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('--query <text>', 'Search tools')
+            .option('--status <status>', 'Filter by status'),
+        query: (options) => ({
+            spaceId: typeof options.space === 'string' ? options.space : undefined,
+            query: typeof options.query === 'string' ? options.query : undefined,
+            status: typeof options.status === 'string' ? options.status : undefined,
+        }),
     }));
     command.addCommand(createViewCommand(factory, {
-        description: 'View a tool',
+        name: 'get',
+        description: 'Get a tool',
         path: '/tools/{id}',
     }));
     command.addCommand(createJsonBodyCommand(factory, {
@@ -19,8 +27,8 @@ export function createToolCommand(factory) {
         path: '/tools',
     }));
     command.addCommand(createJsonBodyCommand(factory, {
-        name: 'edit',
-        description: 'Edit a tool',
+        name: 'patch',
+        description: 'Update a tool',
         method: 'patch',
         path: '/tools/{id}',
         argNames: ['id'],

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

@@ -6,18 +6,23 @@ export function createToolCallCommand(factory) {
         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, {
+        name: 'get',
         description: 'View a tool call',
         path: '/tool-calls/{id}',
     }));

package/dist/commands/toolset/index.js

@@ -1,14 +1,17 @@
 import { Command } from 'commander';
-import { createDeleteCommand, createJsonBodyCommand, createListCommand, createViewCommand } from '../shared/rest.js';
+import { createDeleteCommand, createJsonBodyCommand, createListCommand, createViewCommand, } from '../shared/rest.js';
 export function createToolsetCommand(factory) {
     const command = new Command('toolset').description('Manage BCTRL toolsets');
     command.addCommand(createListCommand(factory, {
         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, {
+        name: 'get',
         description: 'View a toolset',
         path: '/toolsets/{id}',
     }));
@@ -19,7 +22,7 @@ export function createToolsetCommand(factory) {
         path: '/toolsets',
     }));
     command.addCommand(createJsonBodyCommand(factory, {
-        name: 'edit',
+        name: 'patch',
         description: 'Edit a toolset',
         method: 'patch',
         path: '/toolsets/{id}',

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 { requestAndPrint } from '../shared/rest.js';
+export function createUsageCommand(factory) {
+    const command = addOutputFlags(new Command('usage').description('Get organization usage'));
+    command.action(async (options) => {
+        await requestAndPrint(factory, 'get', '/usage', { output: options });
+    });
+    command.addCommand(addOutputFlags(new Command('get').description('Get organization usage')).action(async (options) => {
+        await requestAndPrint(factory, 'get', '/usage', { output: 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 { createDeleteCommand, createJsonBodyCommand, createListCommand, createViewCommand, pathTemplate, requestAndPrint, } from '../shared/rest.js';
 export function createVaultCommand(factory) {
     const command = new Command('vault').description('Manage vault secrets and TOTP codes');
     command.addCommand(createListCommand(factory, {
         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),
@@ -22,14 +22,18 @@ export function createVaultCommand(factory) {
         }),
     }));
     command.addCommand(createViewCommand(factory, {
+        name: 'get',
         description: 'View vault secret metadata',
-        path: '/vault/secrets/{id}',
+        path: '/vault/secrets/{key}',
+        argName: 'key',
     }));
     command.addCommand(createVaultReadCommand(factory));
     command.addCommand(createVaultSetCommand(factory));
+    command.addCommand(createVaultPatchCommand(factory));
     command.addCommand(createDeleteCommand(factory, {
         description: 'Delete a vault secret',
-        path: '/vault/secrets/{id}',
+        path: '/vault/secrets/{key}',
+        argNames: ['key'],
     }));
     command.addCommand(createVaultTotpCommand(factory));
     return command;
@@ -37,13 +41,12 @@ 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`, {
+        await requestAndPrint(factory, 'get', `/vault/secrets/${encodeURIComponent(key)}/value`, {
             output: options,
         });
     });
@@ -53,13 +56,16 @@ function createVaultSetCommand(factory) {
         name: 'set',
         description: 'Create or replace a vault secret',
         method: 'put',
-        path: '/vault/secrets',
-        argNames: ['id'],
+        path: '/vault/secrets/{key}',
+        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')
@@ -70,27 +76,100 @@ function createVaultSetCommand(factory) {
             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 createJsonBodyCommand(factory, {
+        name: 'patch',
+        description: 'Update a vault secret',
+        method: 'patch',
+        path: '/vault/secrets/{key}',
+        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 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 requestAndPrint(factory, 'get', pathTemplate('/vault/secrets/{key}/totp', { key }), {
+            output: 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();