@uptimerobot/cli 0.1.0

package/dist/lib/request-preview.js

@@ -0,0 +1,25 @@
+import { isRecord } from './objects.js';
+import { isSensitiveFieldName } from './sensitive-fields.js';
+const REDACTED = '[REDACTED]';
+export function redactRequestPreview(body) {
+    const redacted = [];
+    return { body: redactValue(body, [], redacted), redacted };
+}
+function redactValue(value, path, redacted) {
+    if (Array.isArray(value)) {
+        return value.map((item, index) => redactValue(item, [...path, String(index)], redacted));
+    }
+    if (!isRecord(value))
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([key, child]) => {
+        const childPath = [...path, key];
+        if (isSensitiveFieldName(key)) {
+            redacted.push(formatPath(childPath));
+            return [key, REDACTED];
+        }
+        return [key, redactValue(child, childPath, redacted)];
+    }));
+}
+function formatPath(segments) {
+    return segments.reduce((path, segment) => /^\d+$/.test(segment) ? `${path}[${segment}]` : path ? `${path}.${segment}` : segment, '');
+}

package/dist/lib/request.js

@@ -0,0 +1,301 @@
+import { readFile } from 'node:fs/promises';
+import { basename } from 'node:path';
+import { assignPath, isPlainRecord, valueAtPath } from './objects.js';
+import { cliRequestDefaults, curatedRequestBodyFields, requestCurationIssue, } from './request-curation.js';
+export class RequestInputError extends Error {
+    path;
+    expected;
+    code = 'INVALID_INPUT';
+    exitCode = 2;
+    constructor(path, expected, message = `Invalid ${path}: expected ${expected}.`) {
+        super(message);
+        this.path = path;
+        this.expected = expected;
+        this.name = 'RequestInputError';
+    }
+}
+export function buildUrl(operation, input, apiUrl) {
+    let path = operation.path;
+    for (const parameter of operation.parameters.filter((candidate) => candidate.in === 'path')) {
+        const value = input.path[parameter.name];
+        if (value !== undefined)
+            path = path.replace(`{${parameter.name}}`, encodeURIComponent(String(value)));
+    }
+    const base = apiUrl.toString().replace(/\/$/, '');
+    const url = new URL(`${base}${path}`);
+    for (const parameter of operation.parameters.filter((candidate) => candidate.in === 'query')) {
+        const value = input.query[parameter.name];
+        if (Array.isArray(value))
+            value.forEach((item) => url.searchParams.append(parameter.name, item));
+        else if (value !== undefined)
+            url.searchParams.set(parameter.name, String(value));
+    }
+    return url;
+}
+export async function buildRequestBody(operation, flags, headers) {
+    const bodyValue = typeof flags.body === 'string' ? await readBodyFlag(flags.body) : undefined;
+    const assignments = Array.isArray(flags.set) ? flags.set : [];
+    const files = Array.isArray(flags.file) ? flags.file : [];
+    const bodyFields = curatedRequestBodyFields(operation);
+    const hasNamedFields = bodyFields.some((field) => flags[field.flag] !== undefined);
+    const hasDefaults = Object.keys(operation.requestBodyDefaults ?? {}).length > 0;
+    const hasBodyInput = bodyValue !== undefined ||
+        assignments.length > 0 ||
+        files.length > 0 ||
+        hasNamedFields ||
+        hasDefaults;
+    if (!hasBodyInput) {
+        if (operation.requestBodyRequired)
+            throw new Error('A request body is required. Pass --body or --set.');
+        if (['PATCH', 'POST', 'PUT'].includes(operation.method)) {
+            headers.set('content-type', 'application/json');
+            return '{}';
+        }
+        return undefined;
+    }
+    const objectBody = toObject(bodyValue);
+    for (const field of bodyFields) {
+        const value = flags[field.flag];
+        if (value !== undefined)
+            assignPath(objectBody, field.path, parseBodyField(field, value));
+    }
+    for (const assignment of assignments)
+        assignValue(objectBody, assignment);
+    for (const [path, value] of Object.entries(operation.requestBodyDefaults ?? {})) {
+        const supplied = valueAtPath(objectBody, path);
+        if (supplied !== undefined && supplied !== value) {
+            throw new RequestInputError(path, String(value), `${path} is fixed to ${String(value)} for this command.`);
+        }
+        assignPath(objectBody, path, value);
+    }
+    applyRequestCuration(operation, objectBody);
+    validateBodyFields(bodyFields, objectBody);
+    if (operation.contentTypes.includes('multipart/form-data')) {
+        const form = new FormData();
+        appendFormValues(form, objectBody);
+        for (const file of files) {
+            const [field, path] = splitAssignment(file, '--file');
+            const bytes = await readFile(path);
+            form.append(field, new Blob([bytes]), basename(path));
+        }
+        return form;
+    }
+    headers.set('content-type', 'application/json');
+    return JSON.stringify(objectBody);
+}
+function applyRequestCuration(operation, body) {
+    for (const [path, value] of Object.entries(cliRequestDefaults(operation))) {
+        if (valueAtPath(body, path) === undefined)
+            assignPath(body, path, value);
+    }
+    const issue = requestCurationIssue(operation, body);
+    if (issue)
+        throw new RequestInputError(issue.path, issue.expected);
+}
+function appendFormValues(form, values) {
+    for (const [key, value] of Object.entries(values)) {
+        if (Array.isArray(value))
+            value.forEach((item) => form.append(key, stringifyFormValue(item)));
+        else if (value !== undefined && value !== null)
+            form.append(key, stringifyFormValue(value));
+    }
+}
+function stringifyFormValue(value) {
+    return typeof value === 'object' ? JSON.stringify(value) : String(value);
+}
+async function readBodyFlag(value) {
+    const source = value === '-'
+        ? await readStandardInput()
+        : value.startsWith('@')
+            ? await readFile(value.slice(1), 'utf8')
+            : value;
+    try {
+        return JSON.parse(source);
+    }
+    catch {
+        throw new Error('Request body must be valid JSON.');
+    }
+}
+async function readStandardInput() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(Buffer.from(chunk));
+    return Buffer.concat(chunks).toString('utf8');
+}
+function toObject(value) {
+    if (value === undefined)
+        return {};
+    if (!isPlainRecord(value)) {
+        throw new Error('Request body must be a JSON object.');
+    }
+    return structuredClone(value);
+}
+function assignValue(target, assignment) {
+    const [path, rawValue] = splitAssignment(assignment, '--set');
+    assignPath(target, path, parseValue(rawValue));
+}
+function splitAssignment(value, flag) {
+    const separator = value.indexOf('=');
+    if (separator <= 0 || separator === value.length - 1)
+        throw new Error(`${flag} expects name=value.`);
+    return [value.slice(0, separator), value.slice(separator + 1)];
+}
+function parseValue(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function parseBodyField(field, rawValue) {
+    if (field.type === 'array') {
+        const values = Array.isArray(rawValue) ? rawValue : [rawValue];
+        const itemSchema = field.items ?? { type: 'string' };
+        return values.map((value, index) => {
+            if (field.path === 'assignedAlertContacts' && itemSchema.type === 'object') {
+                const contactId = numericId(value);
+                if (contactId !== undefined) {
+                    return { alertContactId: contactId, recurrence: 0, threshold: 0 };
+                }
+            }
+            return parseTypedValue(itemSchema, value, `${field.path}[${index}]`);
+        });
+    }
+    return parseTypedValue(field, rawValue, field.path);
+}
+function parseTypedValue(schema, rawValue, path) {
+    if (schema.type === 'boolean') {
+        if (rawValue === true || rawValue === false)
+            return rawValue;
+        if (rawValue === 'true')
+            return true;
+        if (rawValue === 'false')
+            return false;
+        return rawValue;
+    }
+    if (schema.type === 'integer' || schema.type === 'number')
+        return Number(rawValue);
+    if (schema.type === 'object') {
+        const value = typeof rawValue === 'string' ? parseJsonValue(rawValue, path) : rawValue;
+        if (!isPlainRecord(value))
+            throw new RequestInputError(path, 'an object');
+        return value;
+    }
+    if (schema.type === 'array') {
+        const value = typeof rawValue === 'string' ? parseJsonValue(rawValue, path) : rawValue;
+        if (!Array.isArray(value))
+            throw new RequestInputError(path, 'an array');
+        return value;
+    }
+    if (schema.type === 'json' && typeof rawValue === 'string')
+        return parseValue(rawValue);
+    return String(rawValue);
+}
+function parseJsonValue(value, path) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        throw new RequestInputError(path, 'valid JSON');
+    }
+}
+function validateBodyFields(fields, body) {
+    for (const field of fields) {
+        const value = valueAtPath(body, field.path);
+        if (value === undefined) {
+            if (field.required) {
+                throw new RequestInputError(field.path, 'a value', `${field.path} is required. Pass --${field.flag} or --set.`);
+            }
+            if (field.requiredWhenParentPresent) {
+                const parentPath = field.path.split('.').slice(0, -1).join('.');
+                if (parentPath && valueAtPath(body, parentPath) !== undefined) {
+                    throw new RequestInputError(field.path, 'a value because its parent object is present');
+                }
+            }
+            continue;
+        }
+        validateSchemaValue(field, value, field.path);
+    }
+}
+function validateSchemaValue(schema, value, path) {
+    if (value === null && schema.nullable)
+        return;
+    if (schema.type === 'json')
+        return;
+    if (schema.type === 'array') {
+        if (!Array.isArray(value))
+            throw new RequestInputError(path, 'an array');
+        if (schema.minItems !== undefined && value.length < schema.minItems)
+            throw new RequestInputError(path, `at least ${schema.minItems} items`);
+        if (schema.maxItems !== undefined && value.length > schema.maxItems)
+            throw new RequestInputError(path, `at most ${schema.maxItems} items`);
+        if (schema.items) {
+            value.forEach((item, index) => validateSchemaValue(schema.items, item, `${path}[${index}]`));
+        }
+        return;
+    }
+    if (schema.type === 'object') {
+        if (!isPlainRecord(value))
+            throw new RequestInputError(path, 'an object');
+        const properties = schema.properties ?? {};
+        for (const property of schema.requiredProperties ?? []) {
+            if (value[property] === undefined) {
+                throw new RequestInputError(`${path}.${property}`, `required property ${property}`);
+            }
+        }
+        for (const [name, propertySchema] of Object.entries(properties)) {
+            if (value[name] !== undefined)
+                validateSchemaValue(propertySchema, value[name], `${path}.${name}`);
+        }
+        if (schema.additionalProperties === false) {
+            const unknownProperty = Object.keys(value).find((name) => !(name in properties));
+            if (unknownProperty !== undefined) {
+                throw new RequestInputError(`${path}.${unknownProperty}`, 'a documented property');
+            }
+        }
+        else if (typeof schema.additionalProperties === 'object') {
+            for (const [name, propertyValue] of Object.entries(value)) {
+                if (!(name in properties)) {
+                    validateSchemaValue(schema.additionalProperties, propertyValue, `${path}.${name}`);
+                }
+            }
+        }
+        return;
+    }
+    if (schema.type === 'boolean' && typeof value !== 'boolean')
+        throw new RequestInputError(path, 'a boolean');
+    if ((schema.type === 'integer' || schema.type === 'number') && !isFiniteNumber(value))
+        throw new RequestInputError(path, 'a number');
+    if (schema.type === 'integer' && typeof value === 'number' && !Number.isInteger(value))
+        throw new RequestInputError(path, 'an integer');
+    if (schema.type === 'string' && typeof value !== 'string')
+        throw new RequestInputError(path, 'a string');
+    if (schema.enum && !schema.enum.includes(value)) {
+        throw new RequestInputError(path, `one of: ${schema.enum.map(String).join(', ')}`);
+    }
+    if (typeof value === 'number') {
+        if (schema.minimum !== undefined && value < schema.minimum)
+            throw new RequestInputError(path, `at least ${schema.minimum}`);
+        if (schema.maximum !== undefined && value > schema.maximum)
+            throw new RequestInputError(path, `at most ${schema.maximum}`);
+    }
+    if (typeof value === 'string') {
+        const length = [...value].length;
+        if (schema.minLength !== undefined && length < schema.minLength)
+            throw new RequestInputError(path, `at least ${schema.minLength} characters`);
+        if (schema.maxLength !== undefined && length > schema.maxLength)
+            throw new RequestInputError(path, `at most ${schema.maxLength} characters`);
+    }
+}
+function numericId(value) {
+    if (typeof value === 'number' && Number.isSafeInteger(value) && value >= 0)
+        return value;
+    if (typeof value !== 'string' || !/^\d+$/.test(value))
+        return undefined;
+    const id = Number(value);
+    return Number.isSafeInteger(id) ? id : undefined;
+}
+function isFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}

package/dist/lib/sensitive-fields.js

@@ -0,0 +1,19 @@
+/**
+ * Field names that look like they carry credentials. Used to redact dry-run
+ * previews and to avoid picking secret-looking fields in synthesized examples.
+ */
+const SENSITIVE_FIELD_SUFFIXES = [
+    'apikey',
+    'authorization',
+    'cookie',
+    'credential',
+    'password',
+    'passphrase',
+    'privatekey',
+    'secret',
+    'token',
+];
+export function isSensitiveFieldName(name) {
+    const normalized = name.replace(/[^a-z0-9]/gi, '').toLowerCase();
+    return SENSITIVE_FIELD_SUFFIXES.some((suffix) => normalized.endsWith(suffix));
+}

package/dist/lib/types.js

@@ -0,0 +1 @@
+export {};

package/dist/output/columns.js

@@ -0,0 +1,221 @@
+import { isRecord } from '../lib/objects.js';
+export const COLLECTION_COMMAND_IDS = [
+    'alert-contacts:list',
+    'incidents:activity-log',
+    'incidents:alerts',
+    'incidents:comments:list',
+    'incidents:list',
+    'integrations:list',
+    'maintenance-windows:list',
+    'monitor-groups:list',
+    'monitors:list',
+    'status-pages:announcements:list',
+    'status-pages:list',
+    'tags:list',
+    'user:alert-contacts',
+    'user:all-alert-contacts',
+];
+const ALERT_CONTACT_COLUMNS = [
+    { key: 'id' },
+    { key: 'status' },
+    { header: 'NAME', key: 'friendlyName', maxWidth: 28 },
+    { key: 'type' },
+    { key: 'value', maxWidth: 36 },
+    { header: 'NOTIFY FOR', key: 'enableNotificationsFor' },
+];
+export const COMMAND_COLUMNS = {
+    'alert-contacts:list': ALERT_CONTACT_COLUMNS,
+    'incidents:activity-log': [
+        { header: 'TIME', key: 'date' },
+        { format: activityEvent, header: 'EVENT', key: 'type' },
+        { format: activityDetail, header: 'DETAIL', key: 'reason', maxWidth: 48 },
+        { format: activityRegion, header: 'REGION', key: 'region' },
+        { format: activityResult, header: 'RESULT', key: 'notificationStatus' },
+    ],
+    'incidents:alerts': [
+        { key: 'timestamp' },
+        { key: 'status' },
+        { header: 'RECIPIENT', key: 'recipientName', maxWidth: 28 },
+        { header: 'CONTACT', key: 'recipientValue', maxWidth: 36 },
+        { header: 'CHANNEL', key: 'channelType' },
+    ],
+    'incidents:comments:list': [
+        { key: 'id' },
+        { key: 'created' },
+        { header: 'AUTHOR', key: 'user.fullName', maxWidth: 28 },
+        { key: 'comment', maxWidth: 48 },
+    ],
+    'incidents:list': [
+        { key: 'id' },
+        { key: 'status' },
+        { header: 'MONITOR', key: 'monitor.friendlyName', maxWidth: 28 },
+        { key: 'type' },
+        { format: rootCause, header: 'ROOT CAUSE', key: 'reason', maxWidth: 48 },
+        { header: 'STARTED', key: 'startedAt' },
+        { format: durationSeconds, key: 'duration' },
+        { header: 'COMMENTS', key: 'commentsCount' },
+    ],
+    'integrations:list': [
+        { key: 'id' },
+        { key: 'status' },
+        { header: 'NAME', key: 'friendlyName', maxWidth: 28 },
+        { key: 'type' },
+        { header: 'NOTIFY FOR', key: 'enableNotificationsFor' },
+    ],
+    'maintenance-windows:list': [
+        { key: 'id' },
+        { key: 'status' },
+        { key: 'name', maxWidth: 28 },
+        { header: 'REPEAT', key: 'interval' },
+        { key: 'date' },
+        { key: 'time' },
+        { header: 'DURATION (MIN)', key: 'duration' },
+    ],
+    'monitor-groups:list': [
+        { key: 'id' },
+        { key: 'name', maxWidth: 28 },
+        { key: 'createdAt' },
+        { key: 'updatedAt' },
+    ],
+    'monitors:list': [
+        { key: 'id' },
+        { key: 'status' },
+        { format: nameOrUrl, header: 'NAME', key: 'friendlyName', maxWidth: 28 },
+        { key: 'type' },
+        { header: 'TARGET', key: 'url', maxWidth: 40 },
+        { format: durationSeconds, key: 'interval' },
+        { format: stateAge, header: 'IN STATE', key: 'currentStateDuration' },
+        { format: joinNames, key: 'tags', maxWidth: 32 },
+    ],
+    'status-pages:announcements:list': [
+        { key: 'id' },
+        { key: 'title', maxWidth: 40 },
+        { key: 'status' },
+        { key: 'type' },
+        { key: 'startDate' },
+        { key: 'endDate' },
+        { key: 'deliveryStatus' },
+    ],
+    'status-pages:list': [
+        { key: 'id' },
+        { key: 'status' },
+        { header: 'NAME', key: 'friendlyName', maxWidth: 28 },
+        { key: 'urlKey' },
+        { key: 'customDomain', maxWidth: 36 },
+        { header: 'MONITORS', key: 'monitorsCount' },
+        { format: accessLevel, header: 'ACCESS', key: 'isPasswordSet' },
+    ],
+    'tags:list': [{ key: 'id' }, { key: 'name', maxWidth: 28 }],
+    'user:alert-contacts': ALERT_CONTACT_COLUMNS,
+    'user:all-alert-contacts': [
+        { header: 'USER ID', key: 'user.id' },
+        { header: 'USER', key: 'user.name', maxWidth: 28 },
+        { key: 'notifyOnly' },
+        { format: joinNames, header: 'CONTACTS', key: 'alertContacts', maxWidth: 32 },
+    ],
+};
+export function columnsFor(commandId) {
+    if (!Object.hasOwn(COMMAND_COLUMNS, commandId))
+        return undefined;
+    return COMMAND_COLUMNS[commandId];
+}
+export function parseColumnsFlag(value) {
+    const keys = value
+        .split(',')
+        .map((key) => key.trim())
+        .filter((key) => key.length > 0);
+    if (keys.length === 0)
+        throw new Error('--columns must contain at least one column name.');
+    return keys.map((key) => ({ key }));
+}
+function nameOrUrl(value, row) {
+    return value ?? row.url;
+}
+function rootCause(value, row) {
+    return value ?? row.cause;
+}
+function activityEvent(value, row) {
+    if (value === 'STATUS_UPDATE') {
+        return firstString(row.incidentStatus, row.alertLogType) ?? 'Status update';
+    }
+    if (value === 'COMMENT')
+        return 'Comment';
+    if (value === 'NOTIFICATION')
+        return firstString(row.notificationType) ?? 'Notification';
+    return value;
+}
+function activityDetail(_value, row) {
+    if (row.type === 'STATUS_UPDATE')
+        return row.reason;
+    if (row.type === 'COMMENT')
+        return firstString(row.commentFullName, row.commentEmail);
+    if (row.type === 'NOTIFICATION')
+        return firstString(row.sentToFullName, row.sentToValue);
+    return undefined;
+}
+function activityRegion(value, row) {
+    const region = firstString(value);
+    if (region !== undefined)
+        return region;
+    if (!isRecord(row.remoteNode))
+        return undefined;
+    const location = [row.remoteNode.city, row.remoteNode.country].filter((part) => typeof part === 'string' && part.length > 0);
+    return location.length > 0 ? location.join(', ') : undefined;
+}
+function activityResult(value, row) {
+    if (row.type === 'STATUS_UPDATE') {
+        return typeof row.responseTime === 'number' && Number.isFinite(row.responseTime)
+            ? `${row.responseTime} ms`
+            : undefined;
+    }
+    if (row.type === 'NOTIFICATION')
+        return value;
+    return undefined;
+}
+function firstString(...values) {
+    return values.find((value) => typeof value === 'string' && value.length > 0);
+}
+function durationSeconds(value) {
+    return humanizeDuration(value, 4);
+}
+// State ages reach hundreds of days, where trailing minutes and seconds are
+// noise in a scannable column.
+function stateAge(value) {
+    return humanizeDuration(value, 2);
+}
+function humanizeDuration(value, maxUnits) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0)
+        return undefined;
+    const units = [
+        ['d', 86_400],
+        ['h', 3600],
+        ['m', 60],
+        ['s', 1],
+    ];
+    const parts = [];
+    let remaining = Math.floor(value);
+    for (const [suffix, size] of units) {
+        const amount = Math.floor(remaining / size);
+        remaining %= size;
+        if (amount > 0)
+            parts.push(`${amount}${suffix}`);
+        if (parts.length === maxUnits)
+            break;
+    }
+    return parts.length > 0 ? parts.join(' ') : '0s';
+}
+function joinNames(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const names = value
+        .map((item) => (isRecord(item) ? item.name : undefined))
+        .filter((name) => typeof name === 'string');
+    return names.length > 0 ? names.join(', ') : undefined;
+}
+function accessLevel(value) {
+    if (value === true)
+        return 'password';
+    if (value === false)
+        return 'public';
+    return undefined;
+}

package/dist/output/display-width.js

@@ -0,0 +1,34 @@
+/**
+ * Terminal display width for table layout. Grapheme clusters are the unit of
+ * truncation so surrogate pairs, combining marks, and ZWJ sequences are never
+ * split; East Asian wide/fullwidth characters and emoji count as two columns.
+ */
+const graphemeSegmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
+// Wide/fullwidth ranges per wcwidth, plus emoji blocks. The variation
+// selector U+FE0F upgrades a cluster to emoji presentation (width 2);
+// it is intentionally matched as a combining mark inside a grapheme cluster.
+const WIDE_OR_EMOJI = 
+// oxlint-disable-next-line no-misleading-character-class
+/[\u1100-\u115F\u2329\u232A\u2E80-\uA4CF\uA960-\uA97F\uAC00-\uD7A3\uF900-\uFAFF\uFE10-\uFE19\uFE30-\uFE6F\uFF00-\uFF60\uFFE0-\uFFE6\uFE0F\u{1F000}-\u{1FAFF}\u{20000}-\u{3FFFD}]/u;
+export function displayWidth(text) {
+    let width = 0;
+    for (const { segment } of graphemeSegmenter.segment(text)) {
+        width += WIDE_OR_EMOJI.test(segment) ? 2 : 1;
+    }
+    return width;
+}
+export function truncateToWidth(text, maxWidth) {
+    if (displayWidth(text) <= maxWidth)
+        return text;
+    const budget = maxWidth - 1;
+    let width = 0;
+    let kept = '';
+    for (const { segment } of graphemeSegmenter.segment(text)) {
+        const segmentWidth = WIDE_OR_EMOJI.test(segment) ? 2 : 1;
+        if (width + segmentWidth > budget)
+            break;
+        width += segmentWidth;
+        kept += segment;
+    }
+    return `${kept}…`;
+}

package/dist/output/normalize-result.js

@@ -0,0 +1,28 @@
+import { isRecord } from '../lib/objects.js';
+export function normalizeResult(payload) {
+    if (Array.isArray(payload))
+        return { items: payload, nextCursor: null };
+    if (!isRecord(payload) || !Array.isArray(payload.data))
+        return payload;
+    return {
+        items: payload.data,
+        nextCursor: cursorFromNextLink(payload.nextLink) ??
+            cursorFromValue(payload.nextCursor) ??
+            cursorFromValue(payload.nextCursorId),
+    };
+}
+function cursorFromNextLink(nextLink) {
+    if (typeof nextLink !== 'string')
+        return null;
+    try {
+        return new URL(nextLink, 'https://api.uptimerobot.com').searchParams.get('cursor');
+    }
+    catch {
+        return null;
+    }
+}
+function cursorFromValue(value) {
+    if (typeof value === 'string')
+        return value.length > 0 ? value : null;
+    return typeof value === 'number' && Number.isFinite(value) ? String(value) : null;
+}

package/dist/output/pagination-notice.js

@@ -0,0 +1,27 @@
+import { isRecord } from '../lib/objects.js';
+export function paginationNotice(format, normalizedResult) {
+    if ((format !== 'table' && format !== 'plain') || !isRecord(normalizedResult))
+        return undefined;
+    const cursor = normalizedResult.nextCursor;
+    if (typeof cursor !== 'string' || cursor.length === 0)
+        return undefined;
+    return {
+        message: `More results are available. Next cursor: ${printableCursor(cursor)}`,
+        stream: 'stderr',
+    };
+}
+function printableCursor(cursor) {
+    return Array.from(cursor, (character) => {
+        if (character === '\n')
+            return '\\n';
+        if (character === '\r')
+            return '\\r';
+        if (character === '\t')
+            return '\\t';
+        const codePoint = character.codePointAt(0);
+        if (codePoint <= 0x1f || (codePoint >= 0x7f && codePoint <= 0x9f)) {
+            return `\\u${codePoint.toString(16).padStart(4, '0')}`;
+        }
+        return character;
+    }).join('');
+}