@uptimerobot/cli 0.1.0

package/dist/output/renderer.js

@@ -0,0 +1,145 @@
+import { isRecord } from '../lib/objects.js';
+import { displayWidth, truncateToWidth } from './display-width.js';
+import { paint, statusGlyph } from './style.js';
+const DEFAULT_TABLE_COLUMN_WIDTH = 48;
+const FORMATTERS = {
+    json: formatJson,
+    jsonl: formatJsonLines,
+    plain: formatPlain,
+    table: formatTable,
+};
+export function formatOutput(format, payload, options = {}) {
+    return FORMATTERS[format](payload, options);
+}
+function formatJson(payload) {
+    return JSON.stringify(payload);
+}
+function formatJsonLines(payload) {
+    const collection = extractCollection(payload);
+    if (collection) {
+        if (collection.length === 0)
+            return undefined;
+        return collection.map((item) => JSON.stringify(item)).join('\n');
+    }
+    return JSON.stringify(payload);
+}
+function formatPlain(payload, options) {
+    const collection = extractCollection(payload);
+    if (!collection)
+        return formatValue(payload, '');
+    if (collection.length === 0)
+        return undefined;
+    const columns = resolveColumns(collection, options);
+    return collection
+        .map((item) => isRecord(item)
+        ? columns.map((column) => renderCell(item, column, '')).join('\t')
+        : formatValue(item, ''))
+        .join('\n');
+}
+function formatTable(payload, options) {
+    const data = extractCollection(payload);
+    if (!data)
+        return JSON.stringify(payload, null, 2);
+    if (data.length === 0)
+        return 'No results.';
+    const columns = resolveColumns(data, options);
+    const rows = data.map((item) => {
+        const row = isRecord(item) ? item : { value: item };
+        return columns.map((column) => {
+            const cell = toCell(column.key, singleLine(renderCell(row, column, '—')));
+            return { ...cell, text: truncate(cell.text, column.maxWidth) };
+        });
+    });
+    const headings = columns.map((column) => ({ style: 'bold', text: truncate(column.header, column.maxWidth) }));
+    const widths = columns.map((_, index) => Math.max(displayWidth(headings[index].text), ...rows.map((row) => displayWidth(row[index].text))));
+    return [formatRow(headings, widths), ...rows.map((row) => formatRow(row, widths))].join('\n');
+}
+function resolveColumns(rows, options) {
+    if (options.columns !== undefined && options.columns.length > 0) {
+        return options.columns.map((spec) => ({
+            format: spec.format,
+            header: (spec.header ?? defaultHeader(lastSegment(spec.key))).toUpperCase(),
+            key: spec.key,
+            maxWidth: spec.maxWidth ?? DEFAULT_TABLE_COLUMN_WIDTH,
+        }));
+    }
+    const keys = options.allColumns === true ? allKeys(rows) : firstColumns(rows);
+    return keys.map((key) => ({
+        header: defaultHeader(key),
+        key,
+        maxWidth: DEFAULT_TABLE_COLUMN_WIDTH,
+    }));
+}
+function defaultHeader(key) {
+    return key.replace(/([a-z])([A-Z])/g, '$1 $2').toUpperCase();
+}
+function lastSegment(key) {
+    const segments = key.split('.');
+    return segments[segments.length - 1] ?? key;
+}
+function renderCell(row, column, nullValue) {
+    const value = resolvePath(row, column.key);
+    return formatValue(column.format ? column.format(value, row) : value, nullValue);
+}
+function resolvePath(row, path) {
+    if (!path.includes('.'))
+        return row[path];
+    return path
+        .split('.')
+        .reduce((value, segment) => (isRecord(value) ? value[segment] : undefined), row);
+}
+function toCell(column, text) {
+    if (!/status$/i.test(column))
+        return { text };
+    const status = statusGlyph(text);
+    if (!status)
+        return { text };
+    return { style: status.style, text: `${status.glyph} ${text}` };
+}
+function extractCollection(payload) {
+    if (Array.isArray(payload))
+        return payload;
+    if (!isRecord(payload))
+        return undefined;
+    if (Array.isArray(payload.items))
+        return payload.items;
+    if (Array.isArray(payload.data))
+        return payload.data;
+    return undefined;
+}
+function firstColumns(rows) {
+    const first = rows[0];
+    if (!isRecord(first))
+        return ['value'];
+    return Object.keys(first).slice(0, 8);
+}
+function allKeys(rows) {
+    const keys = new Set();
+    for (const row of rows) {
+        if (!isRecord(row))
+            continue;
+        for (const key of Object.keys(row))
+            keys.add(key);
+    }
+    return keys.size > 0 ? [...keys] : ['value'];
+}
+function formatRow(cells, widths) {
+    return cells
+        .map((cell, index) => {
+        const padding = ' '.repeat(Math.max(0, widths[index] - displayWidth(cell.text)));
+        return (cell.style === undefined ? cell.text : paint(cell.style, cell.text)) + padding;
+    })
+        .join('  ')
+        .trimEnd();
+}
+function truncate(value, maxWidth) {
+    return truncateToWidth(value, maxWidth);
+}
+function singleLine(value) {
+    return value.replace(/[\t\r\n]+/g, ' ');
+}
+function formatValue(value, nullValue) {
+    if (typeof value === 'object' && value !== null)
+        return JSON.stringify(value);
+    return value === undefined || value === null ? nullValue : String(value);
+}

package/dist/output/request-progress.js

@@ -0,0 +1,15 @@
+import { ux } from '@oclif/core';
+export async function withRequestProgress(enabled, request) {
+    if (!enabled)
+        return request();
+    ux.action.start('Loading');
+    try {
+        const result = await request();
+        ux.action.stop(result.response.ok ? 'done' : 'failed');
+        return result;
+    }
+    catch (error) {
+        ux.action.stop('failed');
+        throw error;
+    }
+}

package/dist/output/resolve-format.js

@@ -0,0 +1,32 @@
+const OUTPUT_FORMATS = new Set(['json', 'jsonl', 'plain', 'table']);
+export function resolveFormat(flags, mode, env = process.env) {
+    if (flags.raw === true)
+        return 'json';
+    if (typeof flags.format === 'string')
+        return flags.format;
+    if (flags.json === true)
+        return 'json';
+    const environmentFormat = outputFormatFromEnvironment(env);
+    if (environmentFormat)
+        return environmentFormat;
+    if (mode === 'agent' || process.stdout.isTTY !== true)
+        return 'json';
+    return 'table';
+}
+export function outputFormatFromEnvironment(env) {
+    const value = env.UPTIMEROBOT_OUTPUT?.toLowerCase();
+    return value && OUTPUT_FORMATS.has(value) ? value : undefined;
+}
+export function requestedFormatFromArgv(argv) {
+    let format;
+    for (let index = 0; index < argv.length; index += 1) {
+        const value = argv[index];
+        if (value?.startsWith('--format='))
+            format = value.slice('--format='.length).toLowerCase();
+        else if (value === '--format' && argv[index + 1] !== undefined) {
+            format = argv[index + 1]?.toLowerCase();
+            index += 1;
+        }
+    }
+    return format;
+}

package/dist/output/style.js

@@ -0,0 +1,57 @@
+const ANSI_RESET = '\u001B[0m';
+const ANSI_CODES = {
+    bold: '\u001B[1m',
+    dim: '\u001B[2m',
+    green: '\u001B[32m',
+    red: '\u001B[31m',
+    yellow: '\u001B[33m',
+};
+const OK = { glyph: '●', style: 'green' };
+const BAD = { glyph: '✗', style: 'red' };
+const WARN = { glyph: '▲', style: 'yellow' };
+const MUTED = { glyph: '◌', style: 'dim' };
+// Exact-match on the casing the API emits; unknown values must pass through unstyled.
+const STATUS_GLYPHS = {
+    Active: OK,
+    Archived: MUTED,
+    CantSend: MUTED,
+    DOWN: BAD,
+    ENABLED: OK,
+    InQueue: MUTED,
+    LOOKS_DOWN: BAD,
+    NOT_DELIVERED: BAD,
+    NotActivated: WARN,
+    Offline: MUTED,
+    Ongoing: BAD,
+    PAUSED: MUTED,
+    Paused: MUTED,
+    Pending: WARN,
+    Published: OK,
+    Resolved: OK,
+    STARTED: MUTED,
+    SUCCESS: OK,
+    Sent: OK,
+    ToMigrate: WARN,
+    UP: OK,
+    active: OK,
+    error: BAD,
+    paused: MUTED,
+    success: OK,
+};
+export function colorEnabled() {
+    const noColor = process.env.NO_COLOR;
+    if (noColor !== undefined && noColor !== '')
+        return false;
+    const forceColor = process.env.FORCE_COLOR;
+    if (forceColor !== undefined && forceColor !== '')
+        return forceColor !== '0';
+    return process.stdout.isTTY === true;
+}
+export function paint(style, text) {
+    if (!colorEnabled())
+        return text;
+    return `${ANSI_CODES[style]}${text}${ANSI_RESET}`;
+}
+export function statusGlyph(value) {
+    return STATUS_GLYPHS[value];
+}

package/dist/runtime/parse-input.js

@@ -0,0 +1,35 @@
+import { flagName } from '../lib/flag-name.js';
+export function parseInput(operation, args, flags) {
+    const input = { path: {}, query: {} };
+    for (const parameter of operation.parameters) {
+        const rawValue = parameter.in === 'path' ? args[parameter.name] : flags[flagName(parameter.name)];
+        if (rawValue === undefined)
+            continue;
+        const value = coerceValue(parameter, rawValue);
+        if (parameter.in === 'path')
+            input.path[parameter.name] = value;
+        if (parameter.in === 'query')
+            input.query[parameter.name] = value;
+    }
+    return input;
+}
+function coerceValue(parameter, value) {
+    if (parameter.type === 'array') {
+        const values = Array.isArray(value) ? value : [value];
+        return values.map(String);
+    }
+    if (parameter.type === 'number' || parameter.type === 'integer') {
+        // Keep the raw spelling: validation checks the numeric format, and the
+        // wire value stays exact for 64-bit IDs and cursors that lose precision
+        // as JavaScript numbers.
+        return String(value);
+    }
+    if (parameter.type === 'boolean') {
+        if (value === true || value === 'true')
+            return true;
+        if (value === false || value === 'false')
+            return false;
+        return String(value);
+    }
+    return String(value);
+}

package/dist/runtime/types.js

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

package/dist/runtime/validate-input.js

@@ -0,0 +1,63 @@
+export class InputValidationError extends Error {
+    path;
+    expected;
+    constructor(path, expected, message) {
+        super(message);
+        this.path = path;
+        this.expected = expected;
+    }
+}
+export function validateInput(operation, input) {
+    for (const parameter of operation.parameters) {
+        const value = (parameter.in === 'path' ? input.path : input.query)[parameter.name];
+        if (value === undefined) {
+            if (parameter.required) {
+                throw new InputValidationError(parameter.name, 'a value', `${parameter.name} is required.`);
+            }
+            continue;
+        }
+        const expected = firstIssue(parameter, value);
+        if (expected) {
+            throw new InputValidationError(parameter.name, expected, `Invalid ${parameter.name}: ${expected}`);
+        }
+    }
+    return input;
+}
+function firstIssue(parameter, value) {
+    switch (parameter.type) {
+        case 'array':
+            if (!Array.isArray(value) || value.some((item) => typeof item !== 'string')) {
+                return 'Expected a list of values';
+            }
+            break;
+        case 'boolean':
+            if (typeof value !== 'boolean')
+                return 'Expected a boolean';
+            break;
+        case 'integer':
+            // Numeric formats are validated on the raw string so that 64-bit IDs
+            // and cursors keep their exact spelling on the wire.
+            if (typeof value !== 'string' || !/^-?\d+$/.test(value))
+                return 'Expected an integer';
+            break;
+        case 'number':
+            if (typeof value !== 'string' || !/^-?(?:\d+\.?\d*|\.\d+)$/.test(value)) {
+                return 'Expected a number';
+            }
+            break;
+        default:
+            if (typeof value !== 'string')
+                return 'Expected a string';
+    }
+    const numeric = parameter.type === 'integer' || parameter.type === 'number';
+    if (numeric && parameter.minimum !== undefined && Number(value) < parameter.minimum) {
+        return `Expected at least ${parameter.minimum}`;
+    }
+    if (numeric && parameter.maximum !== undefined && Number(value) > parameter.maximum) {
+        return `Expected at most ${parameter.maximum}`;
+    }
+    if (parameter.enum && !parameter.enum.includes(value)) {
+        return `Expected one of: ${parameter.enum.map(String).join(', ')}`;
+    }
+    return undefined;
+}