@bctrl/cli 0.1.0

package/dist/commands/runtime/index.js

@@ -0,0 +1,197 @@
+import { Command } from 'commander';
+import { CliError } from '../../runtime/errors.js';
+import { readBlob, readJsonFile, writeBinary } from '../shared/io.js';
+import { parsePositiveInteger } from '../shared/options.js';
+import { addOutputFlags, outputData } from '../shared/output.js';
+import { addPaginationFlags, createJsonBodyCommand, createListCommand, createViewCommand, pathTemplate, requestAndPrint, } from '../shared/rest.js';
+export function createRuntimeCommand(factory) {
+    const command = new Command('runtime').description('Launch and manage BCTRL runtimes');
+    command.addCommand(createListCommand(factory, {
+        description: 'List runtimes',
+        path: '/runtimes',
+        configure: (cmd) => addPaginationFlags(cmd)
+            .option('--space <id>', 'Filter by space id')
+            .option('--status <status>', 'Filter by runtime status'),
+        query: (options) => ({
+            spaceId: typeof options.space === 'string' ? options.space : undefined,
+            status: typeof options.status === 'string' ? options.status : undefined,
+            limit: typeof options.limit === 'number' ? options.limit : undefined,
+            cursor: typeof options.cursor === 'string' ? options.cursor : undefined,
+        }),
+    }));
+    command.addCommand(createViewCommand(factory, {
+        description: 'View a runtime',
+        path: '/runtimes/{id}',
+    }));
+    command.addCommand(createJsonBodyCommand(factory, {
+        name: 'create',
+        description: 'Create a runtime',
+        method: 'post',
+        path: '/runtimes',
+        configure: (cmd) => cmd
+            .requiredOption('--space <id>', 'Space id')
+            .option('--name <name>', 'Runtime name')
+            .option('--config-file <path>', 'Runtime config JSON file')
+            .option('--metadata-file <path>', 'Runtime metadata JSON file')
+            .option('--from-file <path>', 'Read full JSON request body from file, or - for stdin'),
+        body: async (_args, options) => {
+            if (typeof options.fromFile === 'string')
+                return readJsonFile(options.fromFile);
+            return {
+                spaceId: options.space,
+                name: options.name,
+                config: typeof options.configFile === 'string' ? await readJsonFile(options.configFile, '--config-file') : undefined,
+                metadata: typeof options.metadataFile === 'string'
+                    ? await readJsonFile(options.metadataFile, '--metadata-file')
+                    : undefined,
+            };
+        },
+    }));
+    command.addCommand(addOutputFlags(new Command('stop')
+        .description('Stop a runtime')
+        .argument('<id>'))
+        .action(async (id, options) => {
+        await requestAndPrint(factory, 'post', `/runtimes/${encodeURIComponent(id)}/stop`, {
+            output: options,
+        });
+    }));
+    command.addCommand(createRuntimeConnectionCommand(factory));
+    command.addCommand(createRuntimeFileCommand(factory));
+    command.addCommand(addOutputFlags(new Command('runs')
+        .description('List runs for a runtime')
+        .argument('<id>')
+        .option('-L, --limit <number>', 'Maximum number of results to return', parsePositiveInteger)
+        .option('--cursor <cursor>', 'Pagination cursor'))
+        .action(async (id, options) => {
+        await requestAndPrint(factory, 'get', `/runtimes/${encodeURIComponent(id)}/runs`, {
+            query: { limit: options.limit, cursor: options.cursor },
+            output: options,
+        });
+    }));
+    return command;
+}
+function createRuntimeConnectionCommand(factory) {
+    const command = new Command('connection').description('Manage runtime connections');
+    command.addCommand(addOutputFlags(new Command('list')
+        .description('List runtime connections')
+        .argument('<runtime>')
+        .option('--status <status>', 'Filter by connection status')
+        .option('-L, --limit <number>', 'Maximum number of results to return', parsePositiveInteger))
+        .action(async (runtime, options) => {
+        await requestAndPrint(factory, 'get', `/runtimes/${encodeURIComponent(runtime)}/connections`, {
+            query: { status: options.status, limit: options.limit },
+            output: options,
+        });
+    }));
+    command.addCommand(createJsonBodyCommand(factory, {
+        name: 'create',
+        description: 'Create a runtime connection',
+        method: 'post',
+        path: '/runtimes/{runtime}/connections',
+        argNames: ['runtime'],
+        configure: (cmd) => cmd
+            .option('--protocol <protocol>', 'Connection protocol', 'cdp')
+            .option('--ttl-seconds <seconds>', 'Connection TTL in seconds')
+            .option('--from-file <path>', 'Read JSON request body from file, or - for stdin'),
+        body: async (_args, options) => {
+            if (typeof options.fromFile === 'string')
+                return readJsonFile(options.fromFile);
+            return {
+                protocol: options.protocol,
+                ttlSeconds: options.ttlSeconds ? Number(options.ttlSeconds) : undefined,
+            };
+        },
+    }));
+    command.addCommand(addOutputFlags(new Command('delete')
+        .description('Revoke a runtime connection')
+        .argument('<runtime>')
+        .argument('<connection>'))
+        .action(async (runtime, connection, options) => {
+        await requestAndPrint(factory, 'delete', pathTemplate('/runtimes/{runtime}/connections/{connection}', { runtime, connection }), { output: options });
+    }));
+    return command;
+}
+function createRuntimeFileCommand(factory) {
+    const command = new Command('file').description('Move files into and out of runtimes');
+    command.addCommand(addOutputFlags(new Command('push')
+        .description('Upload and stage a local file into a runtime')
+        .argument('<runtime>')
+        .argument('<local-path>')
+        .option('--storage-path <path>', 'Advanced: durable BCTRL storage path')
+        .option('--name <name>', 'Display name')
+        .option('--metadata-file <path>', 'Metadata JSON file'))
+        .action(async (runtime, localPath, options) => {
+        const client = await factory.apiClient();
+        const file = await readBlob(localPath);
+        const metadata = typeof options.metadataFile === 'string'
+            ? JSON.stringify(await readJsonFile(options.metadataFile, '--metadata-file'))
+            : undefined;
+        const result = await client.uploadFile(`/runtimes/${encodeURIComponent(runtime)}/files/upload`, {
+            file: file.blob,
+            fileName: options.name ?? file.fileName,
+            fields: {
+                ...(options.storagePath ? { storagePath: options.storagePath } : {}),
+                ...(options.name ? { name: options.name } : {}),
+                ...(metadata ? { metadata } : {}),
+            },
+        });
+        await outputData(factory.io, result, options);
+    }));
+    command.addCommand(addOutputFlags(new Command('pull')
+        .description('Collect a runtime file and download it locally')
+        .argument('<runtime>')
+        .argument('<runtime-path>')
+        .requiredOption('--to <path>', 'Output path, or - for stdout')
+        .option('--name <name>', 'Durable file name')
+        .option('--storage-path <path>', 'Advanced: durable BCTRL storage path'))
+        .action(async (runtime, runtimePath, options) => {
+        const client = await factory.apiClient();
+        const collected = await client.post(`/runtimes/${encodeURIComponent(runtime)}/files/collect`, {
+            body: {
+                path: runtimePath,
+                name: options.name,
+                storagePath: options.storagePath,
+            },
+        });
+        if (!collected.id) {
+            throw new CliError('Expected runtime file collect response to include id');
+        }
+        const data = await client.download(`/files/${encodeURIComponent(collected.id)}/content`);
+        await writeBinary(options.to, data);
+    }));
+    command.addCommand(createJsonBodyCommand(factory, {
+        name: 'stage',
+        description: 'Stage a durable file into a runtime',
+        method: 'post',
+        path: '/runtimes/{runtime}/files/stage',
+        argNames: ['runtime'],
+        configure: (cmd) => cmd
+            .option('--file <id>', 'Durable file id')
+            .option('--storage-path <path>', 'Advanced: durable BCTRL storage path')
+            .option('--name <name>', 'Runtime-local name')
+            .option('--from-file <path>', 'Read JSON request body from file, or - for stdin'),
+        body: async (_args, options) => {
+            if (typeof options.fromFile === 'string')
+                return readJsonFile(options.fromFile);
+            return { fileId: options.file, storagePath: options.storagePath, name: options.name };
+        },
+    }));
+    command.addCommand(createJsonBodyCommand(factory, {
+        name: 'collect',
+        description: 'Collect a runtime-local file into durable storage',
+        method: 'post',
+        path: '/runtimes/{runtime}/files/collect',
+        argNames: ['runtime'],
+        configure: (cmd) => cmd
+            .requiredOption('--path <path>', 'Runtime-local path')
+            .option('--name <name>', 'Durable file name')
+            .option('--storage-path <path>', 'Advanced: durable BCTRL storage path')
+            .option('--from-file <path>', 'Read JSON request body from file, or - for stdin'),
+        body: async (_args, options) => {
+            if (typeof options.fromFile === 'string')
+                return readJsonFile(options.fromFile);
+            return { path: options.path, name: options.name, storagePath: options.storagePath };
+        },
+    }));
+    return command;
+}

package/dist/commands/shared/hidden-input.d.ts

@@ -0,0 +1,2 @@
+import type { IOStreams } from '../../io/streams.js';
+export declare function readHiddenInput(io: IOStreams, prompt: string): Promise<string>;

package/dist/commands/shared/hidden-input.js

@@ -0,0 +1,60 @@
+import { CliError } from '../../runtime/errors.js';
+export async function readHiddenInput(io, prompt) {
+    if (!io.canPrompt()) {
+        throw new CliError('Cannot prompt for an API key in this terminal. Use: bctrl auth login --with-token');
+    }
+    const input = io.in;
+    if (typeof input.setRawMode !== 'function') {
+        throw new CliError('This terminal does not support hidden input. Use: bctrl auth login --with-token');
+    }
+    const setRawMode = input.setRawMode.bind(input);
+    io.writeErr(prompt);
+    return new Promise((resolve, reject) => {
+        let value = '';
+        let settled = false;
+        let onData;
+        const cleanup = () => {
+            input.off('data', onData);
+            setRawMode(false);
+            input.pause();
+            io.writeErr('\n');
+        };
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            resolve(result);
+        };
+        const fail = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(error);
+        };
+        onData = (chunk) => {
+            const text = chunk.toString('utf8');
+            for (const char of text) {
+                if (char === '\u0003') {
+                    fail(new CliError('Authentication cancelled'));
+                    return;
+                }
+                if (char === '\r' || char === '\n') {
+                    finish(value.trim());
+                    return;
+                }
+                if (char === '\u007f' || char === '\b') {
+                    value = value.slice(0, -1);
+                    continue;
+                }
+                if (char >= ' ') {
+                    value += char;
+                }
+            }
+        };
+        setRawMode(true);
+        input.resume();
+        input.on('data', onData);
+    });
+}

package/dist/commands/shared/io.d.ts

@@ -0,0 +1,9 @@
+export declare function readText(path: string): Promise<string>;
+export declare function readJsonFile(path: string, label?: string): Promise<unknown>;
+export declare function readStdinText(): Promise<string>;
+export declare function writeBinary(path: string, data: Uint8Array): Promise<void>;
+export declare function readBlob(path: string): Promise<{
+    blob: Blob;
+    fileName: string;
+}>;
+export declare function parseKeyValueList(values: string[] | undefined): Record<string, unknown> | undefined;

package/dist/commands/shared/io.js

@@ -0,0 +1,58 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { basename } from 'node:path';
+import { stdin as processStdin } from 'node:process';
+import { CliError } from '../../runtime/errors.js';
+export async function readText(path) {
+    if (path === '-') {
+        return readStdinText();
+    }
+    return readFile(path, 'utf8');
+}
+export async function readJsonFile(path, label = '--from-file') {
+    const text = await readText(path);
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new CliError(`Invalid JSON in ${label}: ${reason}`);
+    }
+}
+export async function readStdinText() {
+    const chunks = [];
+    for await (const chunk of processStdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}
+export async function writeBinary(path, data) {
+    if (path === '-') {
+        process.stdout.write(data);
+        return;
+    }
+    await writeFile(path, data);
+}
+export async function readBlob(path) {
+    if (path === '-') {
+        const chunks = [];
+        for await (const chunk of processStdin) {
+            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        }
+        return { blob: new Blob([Buffer.concat(chunks)]), fileName: 'stdin' };
+    }
+    const data = await readFile(path);
+    return { blob: new Blob([data]), fileName: basename(path) };
+}
+export function parseKeyValueList(values) {
+    if (!values || values.length === 0)
+        return undefined;
+    const result = {};
+    for (const item of values) {
+        const eq = item.indexOf('=');
+        if (eq === -1) {
+            throw new CliError(`Expected KEY=VALUE, got ${item}`);
+        }
+        result[item.slice(0, eq)] = item.slice(eq + 1);
+    }
+    return result;
+}

package/dist/commands/shared/options.d.ts

@@ -0,0 +1,2 @@
+export declare function parsePositiveInteger(value: string): number;
+export declare function parsePositiveNumber(value: string): number;

package/dist/commands/shared/options.js

@@ -0,0 +1,15 @@
+import { InvalidArgumentError } from 'commander';
+export function parsePositiveInteger(value) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1) {
+        throw new InvalidArgumentError(`invalid positive integer: ${value}`);
+    }
+    return parsed;
+}
+export function parsePositiveNumber(value) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new InvalidArgumentError(`invalid positive number: ${value}`);
+    }
+    return parsed;
+}

package/dist/commands/shared/output.d.ts

@@ -0,0 +1,10 @@
+import { Command } from 'commander';
+import type { IOStreams } from '../../io/streams.js';
+export type OutputFlags = {
+    json?: boolean | string;
+    jq?: string;
+    template?: string;
+};
+export declare function addOutputFlags(command: Command): Command;
+export declare function outputData(io: IOStreams, value: unknown, flags?: OutputFlags | undefined): Promise<void>;
+export declare function writeJson(io: IOStreams, value: unknown): void;

package/dist/commands/shared/output.js

@@ -0,0 +1,105 @@
+import Handlebars from 'handlebars';
+import jqPromise from 'jq-web';
+import { CliError } from '../../runtime/errors.js';
+Handlebars.registerHelper('json', (value) => JSON.stringify(value));
+Handlebars.registerHelper('newline', () => '\n');
+Handlebars.registerHelper('tab', () => '\t');
+export function addOutputFlags(command) {
+    return command
+        .option('--json [fields]', 'Output JSON with optional comma-separated fields')
+        .option('--jq <expression>', 'Filter JSON output using a jq expression')
+        .option('--template <template>', 'Format JSON output using a template');
+}
+export async function outputData(io, value, flags = {}) {
+    const output = resolveOutput(flags);
+    const projected = projectFields(value, output.fields);
+    if (output.jq) {
+        const jq = await jqPromise;
+        const result = jq.raw(JSON.stringify(projected), output.jq, ['-r']);
+        io.writeOut(result.endsWith('\n') ? result : `${result}\n`);
+        return;
+    }
+    if (output.template) {
+        io.writeOut(renderTemplate(projected, output.template));
+        return;
+    }
+    writeJson(io, projected);
+}
+export function writeJson(io, value) {
+    io.writeOut(`${JSON.stringify(value, null, 2)}\n`);
+}
+function resolveOutput(flags) {
+    const jsonChanged = flags.json !== undefined;
+    if (flags.jq && !jsonChanged) {
+        throw new CliError('cannot use --jq without specifying --json');
+    }
+    if (flags.template && !jsonChanged) {
+        throw new CliError('cannot use --template without specifying --json');
+    }
+    return {
+        fields: parseJsonFields(flags.json),
+        jq: flags.jq,
+        template: flags.template,
+    };
+}
+function parseJsonFields(value) {
+    if (value === undefined || value === true || value === false)
+        return undefined;
+    return value
+        .split(',')
+        .map((field) => field.trim())
+        .filter(Boolean);
+}
+function projectFields(value, fields) {
+    if (!fields || fields.length === 0)
+        return value;
+    if (Array.isArray(value)) {
+        return value.map((item) => projectObject(item, fields));
+    }
+    if (isRecord(value)) {
+        if (Array.isArray(value.data)) {
+            return {
+                ...value,
+                data: value.data.map((item) => projectObject(item, fields)),
+            };
+        }
+        if (isRecord(value.data)) {
+            return {
+                ...value,
+                data: projectObject(value.data, fields),
+            };
+        }
+        return projectObject(value, fields);
+    }
+    return value;
+}
+function projectObject(value, fields) {
+    if (!isRecord(value))
+        return value;
+    const projected = {};
+    for (const field of fields) {
+        projected[field] = getPath(value, field);
+    }
+    return projected;
+}
+function getPath(value, path) {
+    let current = value;
+    for (const part of path.split('.')) {
+        if (!isRecord(current))
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+function renderTemplate(value, template) {
+    try {
+        return Handlebars.compile(template, { noEscape: true })(value);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new CliError(`Template rendering failed: ${reason}`);
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/commands/shared/rest.d.ts

@@ -0,0 +1,54 @@
+import { Command } from 'commander';
+import type { BctrlApiClient } from '../../api/client.js';
+import type { Factory } from '../../factory.js';
+import type { IOStreams } from '../../io/streams.js';
+import { type OutputFlags } from './output.js';
+type ClientMethod = 'get' | 'post' | 'patch' | 'put' | 'delete';
+export type ApiDeps = {
+    io: IOStreams;
+    apiClient: () => Promise<BctrlApiClient>;
+};
+export declare function pathTemplate(template: string, params: Record<string, string>): string;
+export declare function addPaginationFlags(command: Command): Command;
+export declare function addJsonBodyFlag(command: Command): Command;
+export declare function requestAndPrint(deps: ApiDeps, method: ClientMethod, path: string, options?: {
+    query?: Record<string, string | number | boolean | undefined>;
+    body?: unknown;
+    output?: OutputFlags;
+}): Promise<void>;
+export declare function bodyFromFileOption(path: string | undefined): Promise<unknown>;
+export declare function createListCommand(factory: Factory, config: {
+    name?: string;
+    description: string;
+    path: string;
+    query?: (options: Record<string, unknown>) => Record<string, string | number | boolean | undefined>;
+    configure?: (command: Command) => Command;
+}): Command;
+export declare function createViewCommand(factory: Factory, config: {
+    name?: string;
+    description: string;
+    path: string;
+    argName?: string;
+    configure?: (command: Command) => Command;
+    query?: (id: string, options: Record<string, unknown>) => Record<string, string | number | boolean | undefined>;
+}): Command;
+export declare function createDeleteCommand(factory: Factory, config: {
+    name?: string;
+    description: string;
+    path: string;
+    argNames?: string[];
+    configure?: (command: Command) => Command;
+    query?: (args: Record<string, string>, options: Record<string, unknown>) => Record<string, string | number | boolean | undefined>;
+}): Command;
+export declare function createJsonBodyCommand(factory: Factory, config: {
+    name: string;
+    description: string;
+    method: Exclude<ClientMethod, 'get' | 'delete'>;
+    path: string;
+    argNames?: string[];
+    configure?: (command: Command) => Command;
+    body?: (args: Record<string, string>, options: Record<string, unknown>) => Promise<unknown>;
+    query?: (args: Record<string, string>, options: Record<string, unknown>) => Record<string, string | number | boolean | undefined>;
+}): Command;
+export declare function outputFlags(options: Record<string, unknown>): OutputFlags;
+export {};

package/dist/commands/shared/rest.js

@@ -0,0 +1,121 @@
+import { Command } from 'commander';
+import { CliError } from '../../runtime/errors.js';
+import { readJsonFile } from './io.js';
+import { parsePositiveInteger } from './options.js';
+import { addOutputFlags, outputData } from './output.js';
+export function pathTemplate(template, params) {
+    return template.replace(/\{(\w+)\}/g, (_, key) => encodeURIComponent(params[key] ?? ''));
+}
+export function addPaginationFlags(command) {
+    return command
+        .option('-L, --limit <number>', 'Maximum number of results to return', parsePositiveInteger)
+        .option('--cursor <cursor>', 'Pagination cursor');
+}
+export function addJsonBodyFlag(command) {
+    return command.option('--from-file <path>', 'Read JSON request body from file, or - for stdin');
+}
+export async function requestAndPrint(deps, method, path, options) {
+    const client = await deps.apiClient();
+    const result = method === 'get'
+        ? await client.get(path, options)
+        : method === 'post'
+            ? await client.post(path, options)
+            : method === 'patch'
+                ? await client.patch(path, options)
+                : method === 'put'
+                    ? await client.put(path, options)
+                    : await client.delete(path, options);
+    await outputData(deps.io, result, options?.output);
+}
+export async function bodyFromFileOption(path) {
+    return path ? readJsonFile(path) : {};
+}
+export function createListCommand(factory, config) {
+    let command = new Command(config.name ?? 'list').description(config.description);
+    command = config.configure ? config.configure(command) : addPaginationFlags(command);
+    command = addOutputFlags(command);
+    return command.action(async (options) => {
+        await requestAndPrint(factory, 'get', config.path, {
+            query: config.query ? config.query(options) : defaultListQuery(options),
+            output: outputFlags(options),
+        });
+    });
+}
+export function createViewCommand(factory, config) {
+    const argName = config.argName ?? 'id';
+    let command = new Command(config.name ?? 'view')
+        .description(config.description)
+        .argument(`<${argName}>`);
+    command = config.configure ? config.configure(command) : command;
+    command = addOutputFlags(command);
+    return command.action(async (id, options) => {
+        await requestAndPrint(factory, 'get', pathTemplate(config.path, { [argName]: id, id }), {
+            query: config.query ? config.query(id, options) : undefined,
+            output: outputFlags(options),
+        });
+    });
+}
+export function createDeleteCommand(factory, config) {
+    const argNames = config.argNames ?? ['id'];
+    let command = new Command(config.name ?? 'delete').description(config.description);
+    for (const arg of argNames)
+        command = command.argument(`<${arg}>`);
+    command = command.option('-y, --yes', 'Confirm deletion');
+    command = config.configure ? config.configure(command) : command;
+    command = addOutputFlags(command);
+    return command.action(async (...args) => {
+        const options = getActionOptions(args);
+        if (options.yes !== true) {
+            throw new CliError('Refusing to delete without --yes');
+        }
+        const params = {};
+        for (let i = 0; i < argNames.length; i += 1)
+            params[argNames[i]] = String(args[i]);
+        await requestAndPrint(factory, 'delete', pathTemplate(config.path, params), {
+            query: config.query ? config.query(params, options) : undefined,
+            output: outputFlags(options),
+        });
+    });
+}
+export function createJsonBodyCommand(factory, config) {
+    const argNames = config.argNames ?? [];
+    let command = new Command(config.name).description(config.description);
+    for (const arg of argNames)
+        command = command.argument(`<${arg}>`);
+    command = config.configure ? config.configure(command) : addJsonBodyFlag(command);
+    command = addOutputFlags(command);
+    return command.action(async (...actionArgs) => {
+        const options = getActionOptions(actionArgs);
+        const args = {};
+        for (let i = 0; i < argNames.length; i += 1)
+            args[argNames[i]] = String(actionArgs[i]);
+        const body = config.body ? await config.body(args, options) : await bodyFromFileOption(String(options.fromFile ?? ''));
+        await requestAndPrint(factory, config.method, pathTemplate(config.path, args), {
+            body,
+            query: config.query ? config.query(args, options) : undefined,
+            output: outputFlags(options),
+        });
+    });
+}
+function defaultListQuery(options) {
+    return {
+        limit: typeof options.limit === 'number' ? options.limit : undefined,
+        cursor: typeof options.cursor === 'string' ? options.cursor : undefined,
+    };
+}
+export function outputFlags(options) {
+    return {
+        ...(typeof options.json === 'string' || typeof options.json === 'boolean'
+            ? { json: options.json }
+            : {}),
+        ...(typeof options.jq === 'string' ? { jq: options.jq } : {}),
+        ...(typeof options.template === 'string' ? { template: options.template } : {}),
+    };
+}
+function getActionOptions(args) {
+    const candidate = args.at(-2);
+    return isRecord(candidate) ? candidate : {};
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

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

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