@bctrl/cli 0.1.6 → 0.1.8

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

@@ -1,10 +1,11 @@
-import type { Command } from 'commander';
-import { type CliHelpCommandId } from '../../generated/help.js';
+import type { Command } from "commander";
+import { type CliHelpCommandId } from "../../generated/help.js";
 export type CommandHelpField = {
     name: string;
     type: string;
     required?: boolean;
     description?: string;
+    values?: string[];
 };
 export type CommandHelpFlag = {
     name: string;
@@ -12,10 +13,32 @@ export type CommandHelpFlag = {
     description: string;
     mapsTo?: string;
 };
+export type CommandHelpDocLink = {
+    title: string;
+    url: string;
+    markdownUrl?: string;
+};
 export type CommandHelpSpec = {
     purpose: string;
+    docs?: CommandHelpDocLink[];
     flags?: CommandHelpFlag[];
-    input?: CommandHelpField[];
+    inputs?: {
+        path?: CommandHelpField[];
+        query?: CommandHelpField[];
+        headers?: CommandHelpField[];
+        body?: {
+            schema?: string;
+            fields?: CommandHelpField[];
+            discriminator?: {
+                property: string;
+                variants: Array<{
+                    value: string;
+                    schema?: string;
+                    summary?: string;
+                }>;
+            };
+        };
+    };
     output?: CommandHelpField[];
     examples?: string[];
     next?: string[];

package/dist/commands/shared/help.js

@@ -1,13 +1,15 @@
-import { CLI_HELP_COMMANDS } from '../../generated/help.js';
+import { CLI_HELP_COMMANDS, } from "../../generated/help.js";
 export function addStructuredHelp(command, spec) {
-    command.addHelpText('after', `\n${renderStructuredHelp(spec)}`);
+    command.addHelpText("after", `\n${renderStructuredHelp(spec)}`);
     return command;
 }
 export function addCliHelp(command, commandId) {
     return addStructuredHelp(command, toCommandHelpSpec(CLI_HELP_COMMANDS[commandId]));
 }
 export function addCliOperationHelp(command, operationId) {
-    return isCliHelpCommandId(operationId) ? addCliHelp(command, operationId) : command;
+    return isCliHelpCommandId(operationId)
+        ? addCliHelp(command, operationId)
+        : command;
 }
 function isCliHelpCommandId(value) {
     return value in CLI_HELP_COMMANDS;
@@ -16,61 +18,123 @@ function toCommandHelpSpec(help) {
     const raw = help;
     return {
         purpose: raw.summary,
+        docs: raw.docs?.map((doc) => ({ ...doc })),
         flags: raw.cli?.flags?.map((flag) => ({ ...flag })),
-        input: raw.input?.fields.map((field) => ({ ...field })),
+        inputs: cloneInputs(raw.inputs),
         output: raw.output?.fields.map((field) => ({ ...field })),
-        examples: raw.examples?.map(formatHelpItem).filter((value) => Boolean(value)),
-        next: raw.next?.map(formatHelpItem).filter((value) => Boolean(value)),
+        examples: raw.examples
+            ?.map(formatHelpItem)
+            .filter((value) => Boolean(value)),
+        next: raw.next
+            ?.map(formatHelpItem)
+            .filter((value) => Boolean(value)),
     };
 }
 function formatHelpItem(value) {
-    if (typeof value === 'string')
+    if (typeof value === "string")
         return value;
-    if (!value || typeof value !== 'object' || Array.isArray(value))
+    if (!value || typeof value !== "object" || Array.isArray(value))
         return undefined;
     const record = value;
-    if (typeof record.command === 'string')
+    if (typeof record.command === "string")
         return record.command;
-    if (typeof record.topic === 'string')
+    if (typeof record.topic === "string")
         return record.topic;
     return undefined;
 }
 function renderStructuredHelp(spec) {
     const sections = [
         renderPurpose(spec.purpose),
-        spec.flags && spec.flags.length > 0 ? renderFlags(spec.flags) : '',
-        spec.input && spec.input.length > 0 ? renderFields('Input', spec.input) : '',
-        spec.output && spec.output.length > 0 ? renderFields('Output', spec.output) : '',
-        spec.examples && spec.examples.length > 0 ? renderList('Examples', spec.examples) : '',
-        spec.next && spec.next.length > 0 ? renderList('Next', spec.next) : '',
+        spec.docs && spec.docs.length > 0 ? renderDocs(spec.docs) : "",
+        spec.flags && spec.flags.length > 0 ? renderFlags(spec.flags) : "",
+        spec.inputs ? renderInputs(spec.inputs) : "",
+        spec.output && spec.output.length > 0
+            ? renderFields("Output", spec.output)
+            : "",
+        spec.examples && spec.examples.length > 0
+            ? renderList("Examples", spec.examples)
+            : "",
+        spec.next && spec.next.length > 0 ? renderList("Next", spec.next) : "",
     ].filter(Boolean);
-    return sections.join('\n\n');
+    return sections.join("\n\n");
+}
+function cloneInputs(inputs) {
+    if (!inputs)
+        return undefined;
+    return {
+        path: inputs.path?.map((field) => ({ ...field })),
+        query: inputs.query?.map((field) => ({ ...field })),
+        headers: inputs.headers?.map((field) => ({ ...field })),
+        body: inputs.body
+            ? {
+                schema: inputs.body.schema,
+                fields: inputs.body.fields?.map((field) => ({ ...field })),
+                discriminator: inputs.body.discriminator
+                    ? {
+                        property: inputs.body.discriminator.property,
+                        variants: inputs.body.discriminator.variants.map((variant) => ({ ...variant })),
+                    }
+                    : undefined,
+            }
+            : undefined,
+    };
+}
+function renderDocs(docs) {
+    return renderList("Docs", docs.map((doc) => doc.markdownUrl ?? doc.url));
 }
 function renderPurpose(purpose) {
     return `Purpose:\n  ${purpose}`;
 }
 function renderFlags(flags) {
     const rows = flags.map((flag) => {
-        const left = [flag.name, flag.value].filter(Boolean).join(' ');
-        const suffix = flag.mapsTo ? ` Maps to ${flag.mapsTo}.` : '';
+        const left = [flag.name, flag.value].filter(Boolean).join(" ");
+        const suffix = flag.mapsTo ? ` Maps to ${flag.mapsTo}.` : "";
         return { left, right: `${flag.description}${suffix}` };
     });
-    return renderRows('Flags', rows);
+    return renderRows("Flags", rows);
+}
+function renderInputs(inputs) {
+    const sections = [
+        inputs.path && inputs.path.length > 0 ? renderFields("Path params", inputs.path) : "",
+        inputs.query && inputs.query.length > 0 ? renderFields("Query params", inputs.query) : "",
+        inputs.headers && inputs.headers.length > 0 ? renderFields("Headers", inputs.headers) : "",
+        inputs.body ? renderBodyInput(inputs.body) : "",
+    ].filter(Boolean);
+    return sections.join("\n\n");
+}
+function renderBodyInput(body) {
+    const lines = [
+        body.schema ? `Schema: ${body.schema}` : "",
+        body.fields && body.fields.length > 0 ? renderFields("Body", body.fields) : "",
+        body.discriminator ? renderDiscriminator(body.discriminator) : "",
+    ].filter(Boolean);
+    return lines.join("\n");
+}
+function renderDiscriminator(discriminator) {
+    const rows = discriminator.variants.map((variant) => ({
+        left: variant.value,
+        right: [variant.schema, variant.summary].filter(Boolean).join(" "),
+    }));
+    return renderRows(`Body variants (${discriminator.property})`, rows);
 }
 function renderFields(title, fields) {
     const rows = fields.map((field) => ({
         left: field.name,
-        right: [field.type, field.required === true ? 'required' : 'optional', field.description]
+        right: [
+            field.type,
+            field.required === true ? "required" : "optional",
+            field.description,
+        ]
             .filter(Boolean)
-            .join(' '),
+            .join(" "),
     }));
     return renderRows(title, rows);
 }
 function renderRows(title, rows) {
     const width = Math.max(...rows.map((row) => row.left.length));
     const lines = rows.map((row) => `  ${row.left.padEnd(width)}  ${row.right}`);
-    return `${title}:\n${lines.join('\n')}`;
+    return `${title}:\n${lines.join("\n")}`;
 }
 function renderList(title, lines) {
-    return `${title}:\n${lines.map((line) => `  ${line}`).join('\n')}`;
+    return `${title}:\n${lines.map((line) => `  ${line}`).join("\n")}`;
 }

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

@@ -1,4 +1,5 @@
 export declare function readText(path: string): Promise<string>;
+export declare function parseJsonString(text: string, label?: string): unknown;
 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>;

package/dist/commands/shared/io.js

@@ -8,8 +8,7 @@ export async function readText(path) {
     }
     return readFile(path, 'utf8');
 }
-export async function readJsonFile(path, label = '--input') {
-    const text = await readText(path);
+export function parseJsonString(text, label = 'json input') {
     try {
         return JSON.parse(text);
     }
@@ -18,6 +17,9 @@ export async function readJsonFile(path, label = '--input') {
         throw new CliError(`Invalid JSON in ${label}: ${reason}`);
     }
 }
+export async function readJsonFile(path, label = 'json input') {
+    return parseJsonString(await readText(path), label);
+}
 export async function readStdinText() {
     const chunks = [];
     for await (const chunk of processStdin) {

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

@@ -11,9 +11,14 @@ type UploadFileInput<OperationId extends CliOperationId> = OperationPathInput<Op
     file: Blob;
     fileName: string;
     fields?: Record<string, string>;
+    actingSubaccountId?: string;
+};
+type DownloadInput<OperationId extends CliOperationId> = OperationPathInput<OperationId> & {
+    actingSubaccountId?: string;
+};
+type StreamInput<OperationId extends CliOperationId> = OperationPathInput<OperationId> & OperationQueryInput<OperationId> & {
+    actingSubaccountId?: string;
 };
-type DownloadInput<OperationId extends CliOperationId> = OperationPathInput<OperationId>;
-type StreamInput<OperationId extends CliOperationId> = OperationPathInput<OperationId> & OperationQueryInput<OperationId>;
 type OperationPathInput<OperationId extends CliOperationId> = [
     CliOperationPathParams<OperationId>
 ] extends [never] ? {
@@ -37,10 +42,48 @@ type OperationBodyInput<OperationId extends CliOperationId> = [
 };
 export type OperationRequestInput<OperationId extends CliOperationId> = OperationPathInput<OperationId> & OperationQueryInput<OperationId> & OperationBodyInput<OperationId> & {
     idempotencyKey?: string;
+    actingSubaccountId?: string;
     output?: OutputFlags;
 };
+export declare function optionString(options: Record<string, unknown>, name: string): string | undefined;
+export declare function actingSubaccountOption(name?: string): (options: Record<string, unknown>) => string | undefined;
 export declare function addPaginationFlags(command: Command): Command;
-export declare function addJsonBodyFlag(command: Command): Command;
+/**
+ * Generic request-override flags every operation command accepts, so the FULL
+ * request surface is reachable without curated per-field flags:
+ *  --params  path + query parameters as one JSON object
+ *  --body    the request body as JSON (POST/PUT/PATCH)
+ * Each accepts inline JSON, `@file`, or `-` for stdin. (`--json` is taken by the
+ * output formatter, so the body flag is `--body`.)
+ */
+export declare function addRequestOverrideFlags(command: Command, opts?: {
+    body?: boolean;
+}): Command;
+/**
+ * Turn the generic `--params` / `--body` flags into request-input
+ * overrides. `--params` keys that match the route's `{placeholders}` become path
+ * params; the rest become query params. `--body` becomes the body.
+ */
+export declare function resolveRequestOverrides(operationId: CliOperationId, options: Record<string, unknown>): Promise<{
+    pathParams?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    body?: unknown;
+}>;
+/**
+ * Merge the generic `--params` / `--body` overrides into a hand-written
+ * command's curated request input. Use this in any command whose `.action` calls
+ * `requestOperationAndPrint` directly (not via createOperation*Command), so it gains
+ * full `--params`/`--body` coverage with one wrap:
+ *
+ *   await requestOperationAndPrint(factory, 'op.id',
+ *     await buildOperationInput('op.id', options, {
+ *       pathParams: { id }, body, query, idempotencyKey, output: outputFlags(options),
+ *     }));
+ *
+ * Precedence: `--body` replaces the curated body; `--params` keys fill the
+ * route's path placeholders / query, with curated path+query values overlaid on top.
+ */
+export declare function buildOperationInput<OperationId extends CliOperationId>(operationId: OperationId, options: Record<string, unknown>, curated: OperationRequestInput<OperationId>): Promise<OperationRequestInput<OperationId>>;
 export declare function outputFlags(options: Record<string, unknown>): OutputFlags;
 export declare function operationPath<OperationId extends CliOperationId>(operationId: OperationId, pathParams?: CliOperationPathParams<OperationId>): string;
 export declare function requestOperationAndPrint<OperationId extends CliOperationId>(deps: ApiDeps, operationId: OperationId, input: OperationRequestInput<OperationId>): Promise<void>;
@@ -54,6 +97,7 @@ export declare function createOperationListCommand<OperationId extends CliOperat
     description: string;
     configure?: (command: Command) => Command;
     query?: (options: Record<string, unknown>) => CliOperationQuery<OperationId>;
+    actingSubaccountId?: (options: Record<string, unknown>) => string | undefined;
 }): Command;
 export declare function createOperationViewCommand<OperationId extends CliOperationId>(factory: ApiDeps, config: {
     operationId: OperationId;
@@ -62,6 +106,7 @@ export declare function createOperationViewCommand<OperationId extends CliOperat
     argName?: string;
     configure?: (command: Command) => Command;
     query?: (id: string, options: Record<string, unknown>) => CliOperationQuery<OperationId>;
+    actingSubaccountId?: (id: string, options: Record<string, unknown>) => string | undefined;
 }): Command;
 export declare function createOperationDeleteCommand<OperationId extends CliOperationId>(factory: ApiDeps, config: {
     operationId: OperationId;
@@ -70,6 +115,7 @@ export declare function createOperationDeleteCommand<OperationId extends CliOper
     argNames?: string[];
     configure?: (command: Command) => Command;
     query?: (args: Record<string, string>, options: Record<string, unknown>) => CliOperationQuery<OperationId>;
+    actingSubaccountId?: (args: Record<string, string>, options: Record<string, unknown>) => string | undefined;
 }): Command;
 export declare function createOperationJsonBodyCommand<OperationId extends CliOperationId>(factory: ApiDeps, config: {
     operationId: OperationId;
@@ -79,5 +125,6 @@ export declare function createOperationJsonBodyCommand<OperationId extends CliOp
     configure?: (command: Command) => Command;
     body?: (args: Record<string, string>, options: Record<string, unknown>) => Promise<CliOperationJsonBody<OperationId>>;
     query?: (args: Record<string, string>, options: Record<string, unknown>) => CliOperationQuery<OperationId>;
+    actingSubaccountId?: (args: Record<string, string>, options: Record<string, unknown>) => string | undefined;
 }): Command;
 export {};

package/dist/commands/shared/operation.js

@@ -5,13 +5,139 @@ import { parsePositiveInteger } from './options.js';
 import { addOutputFlags, outputData } from './output.js';
 import { CliError } from '../../runtime/errors.js';
 import { addCliOperationHelp } from './help.js';
+export function optionString(options, name) {
+    return typeof options[name] === 'string' ? options[name] : undefined;
+}
+export function actingSubaccountOption(name = 'subaccountId') {
+    return (options) => optionString(options, name);
+}
+function withActingSubaccount(input, actingSubaccountId) {
+    return {
+        ...input,
+        ...(actingSubaccountId ? { actingSubaccountId } : {}),
+    };
+}
 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('--input <path>', 'Read JSON request body from file, or - for stdin');
+/**
+ * Generic request-override flags every operation command accepts, so the FULL
+ * request surface is reachable without curated per-field flags:
+ *  --params  path + query parameters as one JSON object
+ *  --body    the request body as JSON (POST/PUT/PATCH)
+ * Each accepts inline JSON, `@file`, or `-` for stdin. (`--json` is taken by the
+ * output formatter, so the body flag is `--body`.)
+ */
+export function addRequestOverrideFlags(command, opts = {}) {
+    command = command.option('--params <json>', 'Path/query parameters as a JSON object (inline, @file, or - for stdin)');
+    if (opts.body) {
+        command = command.option('--body <json>', 'Request body as JSON (inline, @file, or - for stdin)');
+    }
+    return command;
+}
+/** Parse a JSON argument: inline JSON, `@path` for a file, or `-` for stdin. */
+async function parseJsonArg(value, label) {
+    const trimmed = value.trim();
+    if (trimmed === '-')
+        return readJsonFile('-', label);
+    if (trimmed.startsWith('@'))
+        return readJsonFile(trimmed.slice(1), label);
+    try {
+        return JSON.parse(value);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new CliError(`Invalid JSON in ${label}: ${reason}`);
+    }
+}
+function pathParamNames(operationId) {
+    const names = new Set();
+    CLI_OPENAPI_ROUTES[operationId].path.replace(/\{([^}]+)\}/g, (_m, key) => {
+        names.add(key);
+        return '';
+    });
+    return names;
+}
+/**
+ * Turn the generic `--params` / `--body` flags into request-input
+ * overrides. `--params` keys that match the route's `{placeholders}` become path
+ * params; the rest become query params. `--body` becomes the body.
+ */
+export async function resolveRequestOverrides(operationId, options) {
+    const overrides = {};
+    if (typeof options.params === 'string') {
+        const parsed = await parseJsonArg(options.params, '--params');
+        if (!isRecord(parsed)) {
+            throw new CliError('--params must be a JSON object, e.g. \'{"limit":50}\'');
+        }
+        const pathNames = pathParamNames(operationId);
+        const pathParams = {};
+        const query = {};
+        for (const [key, value] of Object.entries(parsed)) {
+            if (pathNames.has(key))
+                pathParams[key] = value;
+            else
+                query[key] = value;
+        }
+        if (Object.keys(pathParams).length > 0)
+            overrides.pathParams = pathParams;
+        if (Object.keys(query).length > 0)
+            overrides.query = query;
+    }
+    if (typeof options.body === 'string') {
+        overrides.body = await parseJsonArg(options.body, '--body');
+    }
+    return overrides;
+}
+/**
+ * Merge the generic `--params` / `--body` overrides into a hand-written
+ * command's curated request input. Use this in any command whose `.action` calls
+ * `requestOperationAndPrint` directly (not via createOperation*Command), so it gains
+ * full `--params`/`--body` coverage with one wrap:
+ *
+ *   await requestOperationAndPrint(factory, 'op.id',
+ *     await buildOperationInput('op.id', options, {
+ *       pathParams: { id }, body, query, idempotencyKey, output: outputFlags(options),
+ *     }));
+ *
+ * Precedence: `--body` replaces the curated body; `--params` keys fill the
+ * route's path placeholders / query, with curated path+query values overlaid on top.
+ */
+export async function buildOperationInput(operationId, options, curated) {
+    const overrides = await resolveRequestOverrides(operationId, options);
+    const c = curated;
+    const merged = {};
+    const pathParams = overlayDefined(overrides.pathParams, c.pathParams);
+    if (pathParams)
+        merged.pathParams = pathParams;
+    const query = overlayDefined(overrides.query, c.query);
+    if (query)
+        merged.query = query;
+    const body = overrides.body !== undefined ? overrides.body : c.body;
+    if (body !== undefined)
+        merged.body = body;
+    if (c.idempotencyKey)
+        merged.idempotencyKey = c.idempotencyKey;
+    if (c.actingSubaccountId)
+        merged.actingSubaccountId = c.actingSubaccountId;
+    if (c.output)
+        merged.output = c.output;
+    return merged;
+}
+/** Overlay only the defined keys of `overlay` onto `base` (curated values win). */
+function overlayDefined(base, overlay) {
+    if (!base)
+        return overlay;
+    if (!overlay)
+        return base;
+    const merged = { ...base };
+    for (const [key, value] of Object.entries(overlay)) {
+        if (value !== undefined)
+            merged[key] = value;
+    }
+    return merged;
 }
 export function outputFlags(options) {
     return {
@@ -44,6 +170,7 @@ export async function requestOperation(deps, operationId, input) {
         ...('query' in input && input.query !== undefined ? { query: input.query } : {}),
         ...('body' in input && input.body !== undefined ? { body: input.body } : {}),
         ...(input.idempotencyKey ? { idempotencyKey: input.idempotencyKey } : {}),
+        ...(input.actingSubaccountId ? { actingSubaccountId: input.actingSubaccountId } : {}),
     };
     const options = Object.keys(requestOptions).length > 0 ? requestOptions : undefined;
     const result = route.method === 'get'
@@ -64,28 +191,37 @@ export async function uploadOperationFile(deps, operationId, input) {
         fileName: input.fileName,
         ...('query' in input && input.query !== undefined ? { query: input.query } : {}),
         ...(input.fields ? { fields: input.fields } : {}),
+        ...(input.actingSubaccountId ? { actingSubaccountId: input.actingSubaccountId } : {}),
     });
 }
 export async function downloadOperation(deps, operationId, input) {
     const client = await deps.apiClient();
-    return client.download(operationPath(operationId, input.pathParams));
+    return client.download(operationPath(operationId, input.pathParams), {
+        ...(input.actingSubaccountId ? { actingSubaccountId: input.actingSubaccountId } : {}),
+    });
 }
 export async function streamOperationText(deps, operationId, input) {
     const client = await deps.apiClient();
     return client.streamText(operationPath(operationId, input.pathParams), {
         ...('query' in input && input.query !== undefined ? { query: input.query } : {}),
+        ...(input.actingSubaccountId ? { actingSubaccountId: input.actingSubaccountId } : {}),
     });
 }
 export function createOperationListCommand(factory, config) {
     let command = new Command(config.name ?? 'list').description(config.description);
     command = addCliOperationHelp(command, config.operationId);
     command = config.configure ? config.configure(command) : addPaginationFlags(command);
+    command = addRequestOverrideFlags(command);
     command = addOutputFlags(command);
     return command.action(async (options) => {
-        await requestOperationAndPrint(factory, config.operationId, {
-            query: config.query ? config.query(options) : defaultListQuery(options),
+        const overrides = await resolveRequestOverrides(config.operationId, options);
+        const curatedQuery = config.query ? config.query(options) : defaultListQuery(options);
+        const actingSubaccountId = config.actingSubaccountId?.(options);
+        await requestOperationAndPrint(factory, config.operationId, withActingSubaccount({
+            ...(overrides.pathParams ? { pathParams: overrides.pathParams } : {}),
+            query: overlayDefined(overrides.query, curatedQuery),
             output: outputFlags(options),
-        });
+        }, actingSubaccountId));
     });
 }
 export function createOperationViewCommand(factory, config) {
@@ -95,13 +231,17 @@ export function createOperationViewCommand(factory, config) {
         .argument(`<${argName}>`);
     command = addCliOperationHelp(command, config.operationId);
     command = config.configure ? config.configure(command) : command;
+    command = addRequestOverrideFlags(command);
     command = addOutputFlags(command);
     return command.action(async (id, options) => {
-        await requestOperationAndPrint(factory, config.operationId, {
-            pathParams: { [argName]: id, id },
-            query: config.query ? config.query(id, options) : undefined,
+        const overrides = await resolveRequestOverrides(config.operationId, options);
+        const curatedQuery = config.query ? config.query(id, options) : undefined;
+        const actingSubaccountId = config.actingSubaccountId?.(id, options);
+        await requestOperationAndPrint(factory, config.operationId, withActingSubaccount({
+            pathParams: overlayDefined(overrides.pathParams, { [argName]: id, id }),
+            query: overlayDefined(overrides.query, curatedQuery),
             output: outputFlags(options),
-        });
+        }, actingSubaccountId));
     });
 }
 export function createOperationDeleteCommand(factory, config) {
@@ -112,6 +252,7 @@ export function createOperationDeleteCommand(factory, config) {
         command = command.argument(`<${arg}>`);
     command = command.option('-y, --yes', 'Confirm deletion');
     command = config.configure ? config.configure(command) : command;
+    command = addRequestOverrideFlags(command);
     command = addOutputFlags(command);
     return command.action(async (...actionArgs) => {
         const options = getActionOptions(actionArgs);
@@ -121,11 +262,14 @@ export function createOperationDeleteCommand(factory, config) {
         const params = {};
         for (let i = 0; i < argNames.length; i += 1)
             params[argNames[i]] = String(actionArgs[i]);
-        await requestOperationAndPrint(factory, config.operationId, {
-            pathParams: params,
-            query: config.query ? config.query(params, options) : undefined,
+        const overrides = await resolveRequestOverrides(config.operationId, options);
+        const curatedQuery = config.query ? config.query(params, options) : undefined;
+        const actingSubaccountId = config.actingSubaccountId?.(params, options);
+        await requestOperationAndPrint(factory, config.operationId, withActingSubaccount({
+            pathParams: overlayDefined(overrides.pathParams, params),
+            query: overlayDefined(overrides.query, curatedQuery),
             output: outputFlags(options),
-        });
+        }, actingSubaccountId));
     });
 }
 export function createOperationJsonBodyCommand(factory, config) {
@@ -134,22 +278,27 @@ export function createOperationJsonBodyCommand(factory, config) {
     command = addCliOperationHelp(command, config.operationId);
     for (const arg of argNames)
         command = command.argument(`<${arg}>`);
-    command = config.configure ? config.configure(command) : addJsonBodyFlag(command);
+    command = config.configure ? config.configure(command) : command;
+    command = addRequestOverrideFlags(command, { body: true });
     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 bodyFromInputOption(String(options.input ?? ''));
-        await requestOperationAndPrint(factory, config.operationId, {
-            pathParams: args,
+        const overrides = await resolveRequestOverrides(config.operationId, options);
+        // --body (raw JSON) takes the whole body; otherwise fall back to the
+        // curated per-flag body. Either way the server validates against the schema.
+        const curatedBody = config.body ? await config.body(args, options) : undefined;
+        const body = overrides.body !== undefined ? overrides.body : (curatedBody ?? {});
+        const curatedQuery = config.query ? config.query(args, options) : undefined;
+        const actingSubaccountId = config.actingSubaccountId?.(args, options);
+        await requestOperationAndPrint(factory, config.operationId, withActingSubaccount({
+            pathParams: overlayDefined(overrides.pathParams, args),
             body,
-            query: config.query ? config.query(args, options) : undefined,
+            query: overlayDefined(overrides.query, curatedQuery),
             output: outputFlags(options),
-        });
+        }, actingSubaccountId));
     });
 }
 function defaultListQuery(options) {
@@ -158,9 +307,6 @@ function defaultListQuery(options) {
         cursor: typeof options.cursor === 'string' ? options.cursor : undefined,
     };
 }
-async function bodyFromInputOption(path) {
-    return path ? readJsonFile(path) : {};
-}
 function getActionOptions(args) {
     const candidate = args.at(-2);
     return isRecord(candidate) ? candidate : {};

package/dist/commands/shared/output.js

@@ -29,13 +29,9 @@ 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');
-    }
+    // --jq / --template are JSON-only transforms, so their presence implies JSON
+    // output; they no longer require an explicit --json. --json's remaining job is
+    // field projection (`--json a,b`). Default output is already JSON either way.
     return {
         fields: parseJsonFields(flags.json),
         jq: flags.jq,