@uptimerobot/cli 0.1.0

package/dist/lib/operation-command.js

@@ -0,0 +1,486 @@
+import { Args, Flags } from '@oclif/core';
+import { createApiClient } from '../api/client.js';
+import { exitCodeFor, normalizeApiError } from '../api/errors.js';
+import { columnsFor, parseColumnsFlag } from '../output/columns.js';
+import { normalizeResult } from '../output/normalize-result.js';
+import { paginationNotice } from '../output/pagination-notice.js';
+import { formatOutput } from '../output/renderer.js';
+import { withRequestProgress } from '../output/request-progress.js';
+import { resolveFormat } from '../output/resolve-format.js';
+import { parseInput } from '../runtime/parse-input.js';
+import { InputValidationError, validateInput } from '../runtime/validate-input.js';
+import { AuthenticationError, resolveApiKey } from './auth.js';
+import { BaseCommand } from './base-command.js';
+import { flagName } from './flag-name.js';
+import { detectInvocationMode, isCI, requestConfirmation } from './invocation.js';
+import { enrichOperationParserError } from './operation-parser-error.js';
+import { curatedRequestBodyField, curatedRequestExampleBody } from './request-curation.js';
+import { synthesizedRequestExample } from './request-example.js';
+import { buildRequestBody, buildUrl, RequestInputError } from './request.js';
+import { redactRequestPreview } from './request-preview.js';
+export function createOperationCommand(operation, options = {}) {
+    const pathParameters = operation.parameters.filter((parameter) => parameter.in === 'path');
+    const optionParameters = operation.parameters.filter((parameter) => parameter.in !== 'path');
+    const commandArgs = Object.fromEntries(pathParameters.map((parameter) => [
+        parameter.name,
+        Args.string({ description: parameter.description, required: parameter.required }),
+    ]));
+    const requestBodyFlags = operation.contentTypes.length > 0
+        ? {
+            body: Flags.string({
+                description: 'JSON request body, @file, or - for stdin',
+                helpValue: '<json|@file|->',
+            }),
+            ...(operation.contentTypes.includes('application/json')
+                ? {
+                    'dry-run': Flags.boolean({
+                        description: 'Compile and validate the request as JSON without authentication or networking',
+                    }),
+                }
+                : {}),
+            ...(operation.contentTypes.includes('multipart/form-data')
+                ? {
+                    file: Flags.string({
+                        description: 'Multipart file as field=path (repeatable)',
+                        helpValue: '<field=path>',
+                        multiple: true,
+                    }),
+                }
+                : {}),
+            set: Flags.string({
+                description: 'Set a request-body field as path=value (repeatable)',
+                helpValue: '<path=value>',
+                multiple: true,
+            }),
+        }
+        : {};
+    const defaultColumns = columnsFor(operation.commandId);
+    const bodyFieldFlags = Object.fromEntries((operation.requestBodyFields ?? []).map((field) => [
+        field.flag,
+        flagForBodyField(curatedRequestBodyField(operation, field)),
+    ]));
+    const commandFlags = {
+        'api-key': Flags.string({
+            description: 'UptimeRobot API key',
+            env: 'UPTIMEROBOT_API_KEY',
+            helpValue: '<key>',
+        }),
+        agent: Flags.boolean({ description: 'Mark this invocation as agent-driven' }),
+        ...(defaultColumns === undefined
+            ? {}
+            : {
+                all: Flags.boolean({
+                    description: 'Show every API field in table or plain output; may expose sensitive API fields',
+                }),
+                columns: Flags.string({
+                    description: 'Comma-separated columns for table or plain output (dot paths allowed)',
+                    helpValue: '<a,b.c>',
+                }),
+            }),
+        ...(operation.destructive
+            ? { confirm: Flags.boolean({ description: 'Explicitly confirm a destructive action' }) }
+            : {}),
+        json: Flags.boolean({
+            description: 'Shorthand for --format json; emit normalized structured JSON',
+        }),
+        format: Flags.string({
+            description: 'Output format; json is normalized and jsonl emits one resource per line',
+            options: ['json', 'jsonl', 'table', 'plain'],
+        }),
+        raw: Flags.boolean({
+            description: 'Emit the untouched API response as JSON; implies --format json',
+        }),
+        ...requestBodyFlags,
+        ...bodyFieldFlags,
+        ...Object.fromEntries(optionParameters.map((parameter) => [flagName(parameter.name), flagForParameter(parameter)])),
+    };
+    class OperationCommand extends BaseCommand {
+        static args = commandArgs;
+        static description = options.canonicalCommand
+            ? `${operation.description ?? operation.summary}
+
+Canonical command: ${options.canonicalCommand}`
+            : (operation.description ?? operation.summary);
+        static examples = examplesFor(operation);
+        static flags = commandFlags;
+        static summary = operation.summary;
+        async catch(error) {
+            enrichOperationParserError(error, operation);
+            return super.catch(error);
+        }
+        async run() {
+            const parsed = await this.parse(OperationCommand);
+            const flags = parsed.flags;
+            const apiUrl = new URL(process.env.UPTIMEROBOT_DEV_API_URL ?? operation.defaultApiUrl);
+            const mode = detectInvocationMode(flags.agent === true);
+            const ci = isCI();
+            const outputFormat = resolveFormat(flags, mode);
+            const jsonOutput = outputFormat === 'json' || outputFormat === 'jsonl';
+            if (flags.json === true && flags.format !== undefined) {
+                return this.fail({ code: 'INVALID_INPUT', message: '--json cannot be combined with --format.' }, 2);
+            }
+            if (flags.raw === true && flags.format !== undefined && flags.format !== 'json') {
+                return this.fail({ code: 'INVALID_INPUT', message: '--raw can only be used with JSON output.' }, 2);
+            }
+            if (flags['dry-run'] === true &&
+                ((flags.format !== undefined && flags.format !== 'json') || flags.raw === true)) {
+                return this.fail({
+                    code: 'INVALID_INPUT',
+                    message: '--dry-run emits a JSON request preview and cannot use this output option.',
+                }, 2);
+            }
+            if (flags.columns !== undefined && flags.all === true) {
+                return this.fail({ code: 'INVALID_INPUT', message: '--columns cannot be combined with --all.' }, 2);
+            }
+            if ((flags.columns !== undefined || flags.all === true) && jsonOutput) {
+                return this.fail({
+                    code: 'INVALID_INPUT',
+                    message: '--columns and --all only apply to table or plain output.',
+                }, 2);
+            }
+            let requestedColumns;
+            try {
+                requestedColumns =
+                    typeof flags.columns === 'string' ? parseColumnsFlag(flags.columns) : undefined;
+            }
+            catch (error) {
+                return this.fail({
+                    code: 'INVALID_INPUT',
+                    message: error instanceof Error ? error.message : String(error),
+                }, 2);
+            }
+            let input;
+            try {
+                input = validateInput(operation, parseInput(operation, parsed.args, flags));
+            }
+            catch (error) {
+                if (error instanceof InputValidationError) {
+                    return this.fail({
+                        code: 'INVALID_INPUT',
+                        expected: error.expected,
+                        message: error.message,
+                        path: error.path,
+                    }, 2);
+                }
+                throw error;
+            }
+            const headers = new Headers({ accept: 'application/json' });
+            let body;
+            try {
+                body = await buildRequestBody(operation, flags, headers);
+            }
+            catch (error) {
+                if (error instanceof RequestInputError) {
+                    return this.fail({
+                        code: error.code,
+                        expected: error.expected,
+                        message: error.message,
+                        path: error.path,
+                    }, error.exitCode);
+                }
+                return this.fail({
+                    code: 'INVALID_INPUT',
+                    message: error instanceof Error ? error.message : String(error),
+                }, 2);
+            }
+            if (flags['dry-run'] === true) {
+                if (typeof body !== 'string') {
+                    return this.fail({ code: 'INVALID_INPUT', message: '--dry-run only supports JSON request bodies.' }, 2);
+                }
+                const url = buildUrl(operation, input, apiUrl);
+                const preview = redactRequestPreview(JSON.parse(body));
+                this.log(JSON.stringify({
+                    body: preview.body,
+                    command: operation.commandId.replaceAll(':', ' '),
+                    contentType: headers.get('content-type'),
+                    dryRun: true,
+                    method: operation.method,
+                    path: `${url.pathname}${url.search}`,
+                    ...(preview.redacted.length > 0 ? { redacted: preview.redacted } : {}),
+                }, null, 2));
+                return;
+            }
+            if (operation.destructive && flags.confirm !== true) {
+                const confirmed = await requestConfirmation(operation, mode);
+                if (!confirmed) {
+                    const error = {
+                        code: 'CONFIRMATION_REQUIRED',
+                        command: operation.commandId.replaceAll(':', ' '),
+                        message: 'Explicit confirmation is required. Re-run with --confirm.',
+                    };
+                    return this.fail(error, 2);
+                }
+            }
+            let apiKey;
+            try {
+                apiKey = await resolveApiKey(flags['api-key'], apiUrl.toString());
+            }
+            catch (error) {
+                if (error instanceof AuthenticationError) {
+                    return this.fail({ code: error.code, message: error.message }, error.exitCode);
+                }
+                throw error;
+            }
+            const url = buildUrl(operation, input, apiUrl);
+            const client = createApiClient({
+                apiKey,
+                apiUrl,
+                environment: ci ? 'ci' : 'local',
+                mode,
+                version: this.config.pjson.version,
+            });
+            let result;
+            try {
+                const showProgress = mode === 'human' &&
+                    (outputFormat === 'plain' || outputFormat === 'table') &&
+                    process.stdout.isTTY === true &&
+                    process.stderr.isTTY === true &&
+                    !ci;
+                result = await withRequestProgress(showProgress, () => client.request(url, { body, headers, method: operation.method }));
+            }
+            catch (error) {
+                return this.fail({
+                    code: 'NETWORK_ERROR',
+                    message: error instanceof Error ? error.message : String(error),
+                }, 1);
+            }
+            const { payload, response } = result;
+            if (!response.ok) {
+                const apiError = normalizeApiError(response.status, payload);
+                return this.fail(apiError, exitCodeFor(response.status));
+            }
+            const normalized = flags.raw === true ? payload : normalizeResult(payload);
+            const output = formatOutput(outputFormat, normalized, {
+                allColumns: flags.all === true,
+                columns: requestedColumns ?? (flags.all === true ? undefined : defaultColumns),
+            });
+            if (output !== undefined)
+                this.log(output);
+            const notice = paginationNotice(outputFormat, normalized);
+            if (notice)
+                this.logToStderr(notice.message);
+        }
+    }
+    return OperationCommand;
+}
+function flagForBodyField(field) {
+    const options = {
+        ...(field.aliases ? { aliases: [...field.aliases] } : {}),
+        ...(field.deprecated ? { deprecated: true } : {}),
+        description: bodyFieldDescription(field),
+        ...(field.hidden ? { hidden: true } : {}),
+    };
+    if (field.type === 'boolean')
+        return Flags.boolean({
+            ...options,
+            allowNo: true,
+            ...(typeof field.default === 'boolean' ? { defaultHelp: field.default } : {}),
+        });
+    if (field.type === 'array') {
+        const itemOptions = field.items?.enum?.every((value) => typeof value === 'string' || typeof value === 'number')
+            ? { options: field.items.enum.map(String) }
+            : {};
+        return Flags.string({
+            ...options,
+            ...itemOptions,
+            ...(Array.isArray(field.default)
+                ? { defaultHelp: field.default.map((value) => String(value)) }
+                : {}),
+            helpValue: field.items?.enum?.every((value) => typeof value === 'string' || typeof value === 'number')
+                ? '<option>'
+                : field.items?.type === 'object' || field.items?.type === 'array'
+                    ? '<json>'
+                    : scalarHelpValue(field.items?.type),
+            multiple: true,
+        });
+    }
+    if ((field.type === 'string' || field.type === 'number' || field.type === 'integer') &&
+        field.enum?.every((value) => typeof value === 'string' || typeof value === 'number')) {
+        return Flags.string({
+            ...options,
+            ...(field.default !== undefined ? { defaultHelp: displayValue(field.default) } : {}),
+            options: field.enum.map(String),
+        });
+    }
+    return Flags.string({
+        ...options,
+        ...(field.default !== undefined ? { defaultHelp: displayValue(field.default) } : {}),
+        helpValue: field.type === 'object' || field.type === 'json'
+            ? '<json>'
+            : field.type === 'number' || field.type === 'integer'
+                ? '<number>'
+                : '<value>',
+    });
+}
+function flagForParameter(parameter) {
+    const common = {
+        description: parameterDescription(parameter),
+        required: parameter.required,
+    };
+    if (parameter.type === 'boolean') {
+        return Flags.boolean({
+            ...common,
+            allowNo: true,
+            ...(typeof parameter.default === 'boolean' ? { defaultHelp: parameter.default } : {}),
+        });
+    }
+    if (parameter.type === 'array') {
+        return Flags.string({
+            ...common,
+            ...(Array.isArray(parameter.default)
+                ? { defaultHelp: parameter.default.map((value) => String(value)) }
+                : {}),
+            helpValue: scalarHelpValue(parameter.itemType),
+            multiple: true,
+        });
+    }
+    const hasPrimitiveEnum = parameter.enum?.every((value) => typeof value === 'string' || typeof value === 'number') ===
+        true;
+    return Flags.string({
+        ...common,
+        ...(hasPrimitiveEnum ? { options: parameter.enum.map(String) } : {}),
+        ...(parameter.default !== undefined ? { defaultHelp: displayValue(parameter.default) } : {}),
+        helpValue: hasPrimitiveEnum
+            ? '<option>'
+            : parameter.type === 'number' || parameter.type === 'integer'
+                ? '<number>'
+                : '<value>',
+    });
+}
+function bodyFieldDescription(field) {
+    const constraints = [];
+    if (field.required)
+        constraints.push('required');
+    if (field.minimum !== undefined)
+        constraints.push(`min: ${field.minimum}`);
+    if (field.maximum !== undefined)
+        constraints.push(`max: ${field.maximum}`);
+    if (field.minLength !== undefined)
+        constraints.push(`min length: ${field.minLength}`);
+    if (field.maxLength !== undefined)
+        constraints.push(`max length: ${field.maxLength}`);
+    if (field.minItems !== undefined)
+        constraints.push(`min items: ${field.minItems}`);
+    if (field.maxItems !== undefined)
+        constraints.push(`max items: ${field.maxItems}`);
+    if (field.requiredWhenParentPresent)
+        constraints.push('required when parent object is provided');
+    if (field.type === 'boolean') {
+        constraints.push(typeof field.default === 'boolean'
+            ? `not sent when omitted; API default: ${field.default ? 'on' : 'off'}`
+            : 'not sent when omitted; API default not documented');
+    }
+    const suffix = constraints.length > 0 ? ` (${constraints.join(', ')})` : '';
+    const itemShape = field.type === 'array' && field.items && schemaHasDisplayDetails(field.items)
+        ? schemaShape(field.items)
+        : undefined;
+    const shapeSuffix = itemShape
+        ? ` Item shape: ${itemShape}.${field.items?.requiredProperties?.length ? ' An asterisk marks a required property.' : ''}`
+        : '';
+    const convenience = field.path === 'assignedAlertContacts'
+        ? ' A bare numeric contact ID is also accepted and uses threshold 0 and recurrence 0.'
+        : '';
+    return `${field.description ?? `Set ${field.path}`}${suffix}.${shapeSuffix}${convenience}`.replace('..', '.');
+}
+function parameterDescription(parameter) {
+    const description = parameter.description ?? `Set ${parameter.name}`;
+    if (parameter.type !== 'boolean')
+        return description;
+    const omission = typeof parameter.default === 'boolean'
+        ? `not sent when omitted; API default: ${parameter.default ? 'on' : 'off'}`
+        : 'not sent when omitted; API default not documented';
+    return `${description.replace(/[.]$/, '')} (${omission}).`;
+}
+function schemaShape(schema) {
+    if (schema.type === 'object' && schema.properties) {
+        const required = new Set(schema.requiredProperties ?? []);
+        const properties = Object.entries(schema.properties).map(([name, property]) => `${name}${required.has(name) ? '*' : ''}:${schemaShape(property)}`);
+        return `{${properties.join(', ')}}${schemaConstraints(schema)}`;
+    }
+    if (schema.type === 'array') {
+        return `array<${schema.items ? schemaShape(schema.items) : 'value'}>${schemaConstraints(schema)}`;
+    }
+    return `${schema.type}${schemaConstraints(schema)}`;
+}
+function schemaConstraints(schema) {
+    const constraints = [];
+    if (schema.enum?.length)
+        constraints.push(`one of: ${schema.enum.map(String).join(', ')}`);
+    if (schema.minimum !== undefined)
+        constraints.push(`min: ${schema.minimum}`);
+    if (schema.maximum !== undefined)
+        constraints.push(`max: ${schema.maximum}`);
+    if (schema.minLength !== undefined)
+        constraints.push(`min length: ${schema.minLength}`);
+    if (schema.maxLength !== undefined)
+        constraints.push(`max length: ${schema.maxLength}`);
+    if (schema.minItems !== undefined)
+        constraints.push(`min items: ${schema.minItems}`);
+    if (schema.maxItems !== undefined)
+        constraints.push(`max items: ${schema.maxItems}`);
+    if (schema.example !== undefined)
+        constraints.push(`example: ${displayValue(schema.example)}`);
+    return constraints.length > 0 ? ` (${constraints.join('; ')})` : '';
+}
+function schemaHasDisplayDetails(schema) {
+    return (schema.type === 'object' ||
+        schema.type === 'array' ||
+        schema.enum !== undefined ||
+        schema.minimum !== undefined ||
+        schema.maximum !== undefined ||
+        schema.minLength !== undefined ||
+        schema.maxLength !== undefined ||
+        schema.minItems !== undefined ||
+        schema.maxItems !== undefined ||
+        schema.example !== undefined);
+}
+function examplesFor(operation) {
+    const command = commandForExample(operation);
+    const authoredExamples = operation.requestBodyExamples?.map((example) => curatedRequestExampleBody(operation, example.body));
+    const synthesized = authoredExamples?.length ? undefined : synthesizedRequestExample(operation);
+    const requestExamples = authoredExamples?.length
+        ? authoredExamples
+        : synthesized === undefined
+            ? []
+            : [synthesized];
+    if (requestExamples.length > 0) {
+        return requestExamples.map((body) => `${command} --body \\\n  ${shellQuote(JSON.stringify(body))}`);
+    }
+    return operation.contentTypes.length === 0 ? [command] : [];
+}
+function commandForExample(operation) {
+    const parts = [`<%= config.bin %>`, operation.commandId.replaceAll(':', ' ')];
+    for (const parameter of operation.parameters.filter((candidate) => candidate.in === 'path')) {
+        parts.push(exampleParameterValue(parameter));
+    }
+    for (const parameter of operation.parameters.filter((candidate) => candidate.in === 'query' && candidate.required)) {
+        const flag = `--${flagName(parameter.name)}`;
+        if (parameter.type === 'boolean')
+            parts.push(flag);
+        else
+            parts.push(flag, exampleParameterValue(parameter));
+    }
+    return parts.join(' ');
+}
+function exampleParameterValue(parameter) {
+    const value = parameter.example ??
+        parameter.enum?.[0] ??
+        (parameter.type === 'number' || parameter.type === 'integer' ? 123 : 'example');
+    const rendered = String(value);
+    return /\s/.test(rendered) ? shellQuote(rendered) : rendered;
+}
+function shellQuote(value) {
+    return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+function scalarHelpValue(type) {
+    if (type === 'number' || type === 'integer')
+        return '<number>';
+    if (type === 'boolean')
+        return '<boolean>';
+    if (type === 'json')
+        return '<json>';
+    return '<value>';
+}
+function displayValue(value) {
+    return typeof value === 'string' ? value : JSON.stringify(value);
+}

package/dist/lib/operation-parser-error.js

@@ -0,0 +1,28 @@
+import { flagName } from './flag-name.js';
+export function enrichOperationParserError(error, operation) {
+    const enumFailure = /^Expected --([^=]+)=.* to be one of: ([^\n]+)/.exec(error.message);
+    if (enumFailure) {
+        const [, flag, options] = enumFailure;
+        const path = pathForFlag(operation, flag);
+        if (path)
+            Object.assign(error, { expected: `one of: ${options}`, path });
+        return;
+    }
+    const missingArgument = /^Missing 1 required arg:\n([^\n]+)/.exec(error.message);
+    if (missingArgument?.[1]) {
+        Object.assign(error, { expected: 'a value', path: missingArgument[1] });
+        return;
+    }
+    const missingFlag = /Missing required flag ([^\s\n]+)/.exec(error.message);
+    if (missingFlag?.[1]) {
+        const path = pathForFlag(operation, missingFlag[1]);
+        if (path)
+            Object.assign(error, { expected: 'a value', path });
+    }
+}
+function pathForFlag(operation, flag) {
+    const bodyField = operation.requestBodyFields?.find((field) => field.flag === flag || field.aliases?.includes(flag));
+    if (bodyField)
+        return bodyField.path;
+    return operation.parameters.find((parameter) => parameter.in === 'query' && flagName(parameter.name) === flag)?.name;
+}

package/dist/lib/request-curation.js

@@ -0,0 +1,76 @@
+import { assignPath, isPlainRecord, valueAtPath } from './objects.js';
+const REQUEST_CURATIONS = {
+    'monitors:create:api': {
+        field: (field) => curateApiAssertionTarget(field, field.path),
+    },
+    'monitors:create:keyword': {
+        defaults: { httpMethodType: 'GET' },
+        field: (field) => field.path === 'httpMethodType'
+            ? {
+                ...field,
+                default: 'GET',
+                description: 'HTTP method to use. The CLI defaults to GET; HEAD is invalid for Keyword monitors',
+                enum: field.enum?.filter((value) => value !== 'HEAD'),
+                example: 'GET',
+            }
+            : field,
+        issue: (body) => body.httpMethodType === 'HEAD'
+            ? {
+                expected: 'a method other than HEAD for Keyword monitors',
+                path: 'httpMethodType',
+            }
+            : undefined,
+    },
+};
+export function cliRequestDefaults(operation) {
+    return curationFor(operation)?.defaults ?? {};
+}
+export function curatedRequestBodyField(operation, field) {
+    return curationFor(operation)?.field?.(field) ?? field;
+}
+export function curatedRequestBodyFields(operation) {
+    return (operation.requestBodyFields ?? []).map((field) => curatedRequestBodyField(operation, field));
+}
+export function curatedRequestExampleBody(operation, body) {
+    if (!isPlainRecord(body))
+        return body;
+    const curated = structuredClone(body);
+    for (const [path, value] of Object.entries(cliRequestDefaults(operation))) {
+        if (valueAtPath(curated, path) === undefined)
+            assignPath(curated, path, value);
+    }
+    return curated;
+}
+export function curatedRequestExamples(operation) {
+    return (operation.requestBodyExamples ?? []).map((example) => ({
+        ...example,
+        body: curatedRequestExampleBody(operation, example.body),
+    }));
+}
+export function requestCurationIssue(operation, body) {
+    return curationFor(operation)?.issue?.(body);
+}
+function curationFor(operation) {
+    return REQUEST_CURATIONS[operation.commandId];
+}
+function curateApiAssertionTarget(schema, path) {
+    const curated = {
+        ...schema,
+        ...(schema.items ? { items: curateApiAssertionTarget(schema.items, `${path}[]`) } : {}),
+        ...(schema.properties
+            ? {
+                properties: Object.fromEntries(Object.entries(schema.properties).map(([name, property]) => [
+                    name,
+                    curateApiAssertionTarget(property, `${path}.${name}`),
+                ])),
+            }
+            : {}),
+    };
+    return path === 'config.apiAssertions.checks[].target' && curated.type === 'object'
+        ? {
+            ...curated,
+            description: 'Temporarily treated as arbitrary JSON because the published schema conflicts with its examples',
+            type: 'json',
+        }
+        : curated;
+}

package/dist/lib/request-example.js

@@ -0,0 +1,82 @@
+import { assignPath, valueAtPath } from './objects.js';
+import { cliRequestDefaults, curatedRequestBodyFields } from './request-curation.js';
+import { isSensitiveFieldName } from './sensitive-fields.js';
+const UNAVAILABLE = Symbol('unavailable request example');
+export function synthesizedRequestExample(operation) {
+    const fields = curatedRequestBodyFields(operation);
+    if (fields.length === 0)
+        return undefined;
+    const body = {};
+    let suppliedField = false;
+    for (const field of fields.filter((candidate) => candidate.required)) {
+        const value = exampleValue(field);
+        if (value === UNAVAILABLE)
+            return undefined;
+        assignPath(body, field.path, value);
+        suppliedField = true;
+    }
+    if (!suppliedField) {
+        const candidate = fields.find((field) => !field.deprecated &&
+            !field.hidden &&
+            !field.path.includes('.') &&
+            !isSensitiveFieldName(field.path) &&
+            exampleValue(field) !== UNAVAILABLE);
+        if (candidate) {
+            assignPath(body, candidate.path, exampleValue(candidate));
+            suppliedField = true;
+        }
+    }
+    for (const [path, value] of Object.entries(cliRequestDefaults(operation))) {
+        if (valueAtPath(body, path) === undefined)
+            assignPath(body, path, structuredClone(value));
+    }
+    for (const [path, value] of Object.entries(operation.requestBodyDefaults ?? {})) {
+        assignPath(body, path, structuredClone(value));
+    }
+    return suppliedField || Object.keys(body).length > 0 ? body : undefined;
+}
+function exampleValue(schema) {
+    if (schema.example !== undefined)
+        return structuredClone(schema.example);
+    if (schema.enum?.length)
+        return structuredClone(schema.enum[0]);
+    switch (schema.type) {
+        case 'array': {
+            if (!schema.items)
+                return [];
+            const item = exampleValue(schema.items);
+            if (item === UNAVAILABLE)
+                return UNAVAILABLE;
+            return Array.from({ length: Math.max(1, schema.minItems ?? 0) }, () => structuredClone(item));
+        }
+        case 'boolean':
+            return typeof schema.default === 'boolean' ? schema.default : false;
+        case 'integer':
+            return Math.ceil(exampleNumber(schema));
+        case 'json':
+            return {};
+        case 'number':
+            return exampleNumber(schema);
+        case 'object': {
+            const value = {};
+            for (const property of schema.requiredProperties ?? []) {
+                const propertySchema = schema.properties?.[property];
+                if (!propertySchema)
+                    return UNAVAILABLE;
+                const propertyValue = exampleValue(propertySchema);
+                if (propertyValue === UNAVAILABLE)
+                    return UNAVAILABLE;
+                value[property] = propertyValue;
+            }
+            return value;
+        }
+        case 'string': {
+            const minimum = schema.minLength ?? 0;
+            return minimum > 7 ? 'x'.repeat(minimum) : 'example';
+        }
+    }
+}
+function exampleNumber(schema) {
+    const minimum = schema.minimum ?? 1;
+    return schema.maximum !== undefined ? Math.min(minimum, schema.maximum) : minimum;
+}