@basis-theory-labs/cli 4.2.0 → 4.4.0

package/dist/logs/format.js

@@ -0,0 +1,162 @@
+"use strict";
+/* Public log fields intentionally mirror the Events JSON contract. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatRuntimeLogRecord = void 0;
+const unsafeTerminalCharacters = /[\u007F-\u009F\u061C\u200E\u200F\u2028-\u202E\u2066-\u2069]/gu;
+const serialize = (value, spacing) => JSON.stringify(value, undefined, spacing).replace(unsafeTerminalCharacters, (character) => `\\u${character.charCodeAt(0).toString(16).padStart(4, '0')}`);
+const inlineText = (value) => serialize(value).slice(1, -1);
+const colorize = (text, color) => color ? `\u001B[${color}m${text}\u001B[0m` : text;
+const recordColor = (record) => {
+    var _a;
+    if (record.record_type === 'lifecycle') {
+        if (record.outcome === 'failure') {
+            return '31';
+        }
+        if (record.outcome === 'success') {
+            return '32';
+        }
+        return '36';
+    }
+    switch ((_a = record.level) === null || _a === void 0 ? void 0 : _a.toLowerCase()) {
+        case 'debug':
+            return '2';
+        case 'info':
+            return undefined;
+        case 'warn':
+        case 'warning':
+            return '33';
+        case 'error':
+            return '31';
+        default:
+            return '36';
+    }
+};
+const publicRecord = (record) => ({
+    occurred_at: record.occurred_at,
+    ...(record.level !== undefined ? { level: record.level } : {}),
+    ...(record.event !== undefined ? { event: record.event } : {}),
+    ...(record.trace_id !== undefined ? { trace_id: record.trace_id } : {}),
+    ...(record.transform_type !== undefined
+        ? { transform_type: record.transform_type }
+        : {}),
+    ...(Object.prototype.hasOwnProperty.call(record, 'message')
+        ? { message: record.message }
+        : {}),
+    ...(record.outcome !== undefined ? { outcome: record.outcome } : {}),
+    ...(record.duration_ms !== undefined
+        ? { duration_ms: record.duration_ms }
+        : {}),
+    ...(record.error !== undefined ? { error: record.error } : {}),
+    ...(record.attributes !== undefined ? { attributes: record.attributes } : {}),
+});
+const highlightJson = (json, record) => {
+    let depth = 0;
+    let rootField;
+    // Consume whole strings so escaped quotes cannot become structural tokens.
+    return json.replace(/"(?:\\.|[^"\\])*"(:)?|[{}[\],]/gu, (fragment, keySuffix) => {
+        var _a;
+        if (fragment === '{' || fragment === '[') {
+            depth++;
+            return fragment;
+        }
+        if (fragment === '}' || fragment === ']') {
+            depth--;
+            return fragment;
+        }
+        if (fragment === ',') {
+            if (depth === 1) {
+                rootField = undefined;
+            }
+            return fragment;
+        }
+        if (keySuffix !== undefined) {
+            const key = fragment.slice(0, -keySuffix.length);
+            if (depth === 1) {
+                rootField = JSON.parse(key);
+            }
+            return `${colorize(key, '2')}${keySuffix}`;
+        }
+        let color;
+        if (rootField === 'error') {
+            color = '31';
+        }
+        else if (depth === 1 && rootField === 'level') {
+            color = recordColor(record);
+        }
+        else if (depth === 1 && rootField === 'message') {
+            const level = (_a = record.level) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+            if (level === 'error') {
+                color = '31';
+            }
+            else if (level === 'warn' || level === 'warning') {
+                color = '33';
+            }
+        }
+        else if (depth === 1 &&
+            rootField === 'outcome' &&
+            record.record_type === 'lifecycle' &&
+            (record.outcome === 'success' || record.outcome === 'failure')) {
+            color = recordColor(record);
+        }
+        return colorize(fragment, color);
+    });
+};
+const prettyRecord = (record, options) => {
+    var _a;
+    const color = options.color ? recordColor(record) : undefined;
+    const prefix = options.includeResourceHeader
+        ? `${colorize(`${record.resource_type} ${inlineText(record.resource_id)}`, options.color ? '36' : undefined)}\n`
+        : '';
+    const trace = record.trace_id !== undefined
+        ? ` trace=${inlineText(record.trace_id)}`
+        : '';
+    const transform = record.transform_type !== undefined ? ` ${record.transform_type}` : '';
+    let summary;
+    if (record.record_type === 'lifecycle') {
+        const event = record.event !== undefined ? inlineText(record.event) : '';
+        const lifecycle = [
+            record.outcome !== undefined
+                ? `outcome=${inlineText(record.outcome)}`
+                : undefined,
+            record.duration_ms !== undefined
+                ? `duration=${record.duration_ms}ms`
+                : undefined,
+        ]
+            .filter((value) => value !== undefined)
+            .join(' ');
+        const message = Object.prototype.hasOwnProperty.call(record, 'message')
+            ? ` message=${record.message === null
+                ? 'null'
+                : inlineText(record.message)}`
+            : '';
+        summary = `${colorize(event, color)}${trace}${transform}${lifecycle ? ` ${lifecycle}` : ''}${message}`;
+    }
+    else {
+        const severity = inlineText(((_a = record.level) !== null && _a !== void 0 ? _a : 'log').toUpperCase());
+        const message = Object.prototype.hasOwnProperty.call(record, 'message')
+            ? record.message === null
+                ? 'null'
+                : inlineText(record.message)
+            : '';
+        summary = `${colorize(severity, color)}${trace}${transform} ${message}`;
+    }
+    const attributes = record.attributes !== undefined ? ` | ${serialize(record.attributes)}` : '';
+    const lines = [`${record.occurred_at} ${summary}${attributes}`];
+    if (record.error !== undefined) {
+        lines.push(`  error:\n${serialize(record.error, 2)
+            .split('\n')
+            .map((line) => `  ${line}`)
+            .join('\n')}`);
+    }
+    // The shared writer adds the second newline separating pretty entries.
+    return `${prefix}${lines.join('\n')}\n`;
+};
+const formatRuntimeLogRecord = (record, options) => {
+    if (options.format === 'pretty') {
+        return prettyRecord(record, options);
+    }
+    const json = serialize(publicRecord(record), options.format === 'json-pretty' ? 2 : undefined);
+    return `${options.color ? highlightJson(json, record) : json}\n`;
+};
+exports.formatRuntimeLogRecord = formatRuntimeLogRecord;
+/* eslint-enable camelcase, unicorn/no-null */

package/dist/logs/index.js

@@ -6,13 +6,30 @@ const connect_1 = require("./connect");
 const server_1 = require("./server");
 const DEFAULT_LOGS_SERVER_PORT = 8220;
 exports.DEFAULT_LOGS_SERVER_PORT = DEFAULT_LOGS_SERVER_PORT;
+const legacyWarningHeading = () => {
+    const heading = 'Warning: You are using deprecated tunnel-based logging.';
+    const color = process.stderr.isTTY === true &&
+        process.env.NO_COLOR === undefined &&
+        process.env.TERM !== 'dumb';
+    return color ? `\u001B[33m${heading}\u001B[0m\n` : `${heading}\n`;
+};
 const showProxyLogs = async (bt, id, port = DEFAULT_LOGS_SERVER_PORT) => {
+    process.stderr.write(`${legacyWarningHeading()}This command opens a local tunnel and updates logging configuration.\n\n` +
+        `For runtime logs, use: bt proxies logs tail <id>\n` +
+        `Enable runtime logging and use a key with event:read permission. Logs may take time to appear.\n` +
+        `Learn more and set up runtime logs:\n` +
+        `https://developers.basistheory.com/docs/concepts/runtimes/runtime-logs\n\n`);
     const url = await (0, server_1.createLogServer)(port);
     await (0, connect_1.connectToProxy)(bt, id, url);
     (0, utils_1.cleanUpOnExit)(() => (0, connect_1.disconnectFromProxy)(bt, id));
 };
 exports.showProxyLogs = showProxyLogs;
 const showReactorLogs = async (bt, id, port = DEFAULT_LOGS_SERVER_PORT) => {
+    process.stderr.write(`${legacyWarningHeading()}This command opens a local tunnel and updates logging configuration.\n\n` +
+        `For runtime logs, use: bt reactors logs tail <id>\n` +
+        `Enable runtime logging and use a key with event:read permission. Logs may take time to appear.\n` +
+        `Learn more and set up runtime logs:\n` +
+        `https://developers.basistheory.com/docs/concepts/runtimes/runtime-logs\n\n`);
     const url = await (0, server_1.createLogServer)(port);
     await (0, connect_1.connectToReactor)(bt, id, url);
     (0, utils_1.cleanUpOnExit)(() => (0, connect_1.disconnectFromReactor)(bt, id));

package/dist/logs/runtime.d.ts

@@ -0,0 +1,18 @@
+import type { EventLogFilters, ResourceType } from './events';
+import type { RuntimeLogFormat } from './format';
+import type { LogWindow } from './time';
+interface RuntimeLogOptions extends EventLogFilters {
+    apiKey: string;
+    apiBaseUrl?: string;
+    resourceType: ResourceType;
+    resourceId: string;
+    format: RuntimeLogFormat;
+    window?: LogWindow;
+}
+/** Retrieve one finite query window, including every continuation, then finish. */
+declare const readEventLogs: (options: RuntimeLogOptions & {
+    window: LogWindow;
+}) => Promise<void>;
+/** Retrieve initial context, then keep reading overlapping live windows. */
+declare const followEventLogs: (options: RuntimeLogOptions) => Promise<void>;
+export { followEventLogs, readEventLogs };

package/dist/logs/runtime.js

@@ -0,0 +1,364 @@
+"use strict";
+/* Sequential loops preserve cursor exhaustion and ordered output behavior. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readEventLogs = exports.followEventLogs = void 0;
+const events_1 = require("./events");
+const format_1 = require("./format");
+const time_1 = require("./time");
+const LOOKBACK_MS = time_1.DEFAULT_LOOKBACK_MS;
+const POLL_INTERVAL_MS = 5000;
+const REQUEST_DEADLINE_MS = 20000;
+const CYCLE_DEADLINE_MS = 60000;
+const MAX_PAGES = 125;
+const MAX_BATCHES = 2500;
+const MAX_CYCLE_BYTES = 64 * 1024 * 1024;
+const MAX_IDENTITIES = 100000;
+const MAX_IDENTITY_BYTES = 16 * 1024 * 1024;
+const reasonOf = (signal) => signal.reason instanceof Error ? signal.reason : new Error('Logs cancelled');
+const checkDeadline = (signal, deadline) => {
+    if (signal.aborted) {
+        throw reasonOf(signal);
+    }
+    if (performance.now() >= deadline) {
+        throw new Error('Events log window exceeded its 60-second deadline');
+    }
+};
+const waitFor = (milliseconds, signal) => new Promise((resolve, reject) => {
+    if (signal.aborted) {
+        reject(reasonOf(signal));
+        return;
+    }
+    const onAbort = () => {
+        // The handler is registered only after the timer has been initialized.
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        clearTimeout(timer);
+        signal.removeEventListener('abort', onAbort);
+        reject(reasonOf(signal));
+    };
+    const timer = setTimeout(() => {
+        signal.removeEventListener('abort', onAbort);
+        resolve();
+    }, milliseconds);
+    signal.addEventListener('abort', onAbort, { once: true });
+});
+// Each request needs its own cancellation closure over that request's controller.
+const abortOnSignal = (controller, signal) => () => controller.abort(reasonOf(signal));
+// A successful callback alone is insufficient when write() reports backpressure.
+// Listen before write() so synchronous test streams cannot lose a drain event.
+const writeLine = (stream, line, signal) => new Promise((resolve, reject) => {
+    if (signal.aborted) {
+        reject(reasonOf(signal));
+        return;
+    }
+    const streamError = stream.errored;
+    // Already-failed streams need not emit another error after a write callback.
+    if (stream.destroyed || streamError) {
+        reject(streamError !== null && streamError !== void 0 ? streamError : new Error('Output stream is closed'));
+        return;
+    }
+    let callbackDone = false;
+    let drained = false;
+    let returned = false;
+    let settled = false;
+    const finish = (error) => {
+        if (settled || (!error && !(returned && callbackDone && drained))) {
+            return;
+        }
+        settled = true;
+        // Handlers cannot run until cleanup and every listener are initialized.
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        cleanup();
+        if (error) {
+            reject(error);
+        }
+        else {
+            resolve();
+        }
+    };
+    const onDrain = () => {
+        drained = true;
+        finish();
+    };
+    const onError = (error) => finish(error);
+    const onAbort = () => finish(reasonOf(signal));
+    const cleanup = () => {
+        stream.removeListener('drain', onDrain);
+        stream.removeListener('error', onError);
+        signal.removeEventListener('abort', onAbort);
+    };
+    stream.on('drain', onDrain);
+    stream.on('error', onError);
+    signal.addEventListener('abort', onAbort, { once: true });
+    try {
+        const accepted = stream.write(`${line}\n`, 'utf8', (error) => {
+            // Writable emits an error after its failed callback. Keep the listeners
+            // alive until that event, rather than leaving it unhandled after cleanup.
+            if (!error) {
+                callbackDone = true;
+                finish();
+            }
+        });
+        returned = true;
+        drained || (drained = accepted);
+        finish();
+    }
+    catch (error) {
+        finish(error instanceof Error ? error : new Error('Output write failed'));
+    }
+});
+const recordIdentity = (record) => {
+    var _a;
+    return JSON.stringify([
+        record.tenant_id,
+        record.resource_type,
+        record.resource_id,
+        (_a = record.transform_type) !== null && _a !== void 0 ? _a : null,
+        record.invocation_id,
+        record.sequence,
+    ]);
+};
+const isBrokenPipe = (error) => error.code === 'EPIPE';
+/** Both actions share bounded window reads and the complete output/cancellation lifecycle. */
+const streamEventLogs = async (options, mode) => {
+    var _a, _b, _c;
+    const initialWindow = (_a = options.window) !== null && _a !== void 0 ? _a : (mode === 'tail' ? (0, time_1.resolveTailWindow)({}) : (0, time_1.resolveLogWindow)({}));
+    const isLiveTailStart = mode === 'tail' && initialWindow.start === initialWindow.end;
+    const origin = (0, events_1.resolveEventsOrigin)(options.apiBaseUrl);
+    const session = new AbortController();
+    let stopStatus;
+    const stop = (status, error) => {
+        if (!session.signal.aborted) {
+            stopStatus = status;
+            session.abort(error);
+        }
+    };
+    const onInterrupt = () => stop(130, new Error('SIGINT'));
+    const onTerminate = () => stop(143, new Error('SIGTERM'));
+    const onStdoutError = (error) => {
+        if (isBrokenPipe(error)) {
+            stop(0, error);
+        }
+        else {
+            session.abort(error);
+        }
+    };
+    const onStderrError = (error) => session.abort(error);
+    const color = process.stdout.isTTY === true &&
+        process.env.NO_COLOR === undefined &&
+        process.env.TERM !== 'dumb';
+    const identities = new Map();
+    let identityBytes = 0;
+    let resourceHeaderWritten = false;
+    let lastCompletedEnd = isLiveTailStart
+        ? initialWindow.end
+        : undefined;
+    // Oclif's eager stdout error handler throws before command-level cleanup.
+    // Own stdout failures during log reads, preserving the prior handlers on exit.
+    const stdoutErrorListeners = process.stdout.rawListeners('error');
+    for (const listener of stdoutErrorListeners) {
+        process.stdout.removeListener('error', listener);
+    }
+    process.on('SIGINT', onInterrupt);
+    process.on('SIGTERM', onTerminate);
+    process.stdout.on('error', onStdoutError);
+    process.stderr.on('error', onStderrError);
+    try {
+        if (isLiveTailStart) {
+            await writeLine(process.stderr, 'Waiting for logs...', session.signal);
+        }
+        while (!session.signal.aborted) {
+            const end = lastCompletedEnd === undefined ? initialWindow.end : Date.now();
+            if (lastCompletedEnd !== undefined && end <= lastCompletedEnd) {
+                await waitFor(POLL_INTERVAL_MS, session.signal);
+                continue;
+            }
+            const cycleStarted = performance.now();
+            const deadline = cycleStarted + CYCLE_DEADLINE_MS;
+            const start = lastCompletedEnd === undefined
+                ? initialWindow.start
+                : Math.max(initialWindow.start, end - LOOKBACK_MS);
+            const cycle = new AbortController();
+            const cancelCycle = () => cycle.abort(reasonOf(session.signal));
+            const cycleTimer = setTimeout(() => cycle.abort(new Error('Events log window exceeded its 60-second deadline')), CYCLE_DEADLINE_MS);
+            session.signal.addEventListener('abort', cancelCycle, { once: true });
+            let receivedBytes = 0;
+            let returnedBatches = 0;
+            let pages = 0;
+            let cursor;
+            const cursors = new Set();
+            const countCycleBytes = (bytes) => {
+                receivedBytes += bytes;
+                checkDeadline(cycle.signal, deadline);
+                if (receivedBytes > MAX_CYCLE_BYTES) {
+                    throw new Error('Events log window exceeded its 64 MiB received-byte limit');
+                }
+            };
+            try {
+                do {
+                    checkDeadline(cycle.signal, deadline);
+                    if (pages >= MAX_PAGES) {
+                        throw new Error('Events log window exceeded its 125-page limit');
+                    }
+                    let page;
+                    let retrying = false;
+                    for (let attempt = 1; attempt <= 3; attempt++) {
+                        checkDeadline(cycle.signal, deadline);
+                        const request = new AbortController();
+                        const cancelRequest = abortOnSignal(request, cycle.signal);
+                        const requestDeadline = Math.min(performance.now() + REQUEST_DEADLINE_MS, deadline);
+                        const requestTimer = setTimeout(() => request.abort(new Error('Events request deadline exceeded')), Math.max(0, requestDeadline - performance.now()));
+                        cycle.signal.addEventListener('abort', cancelRequest, {
+                            once: true,
+                        });
+                        try {
+                            page = await (0, events_1.readEventPage)({
+                                origin,
+                                apiKey: options.apiKey,
+                                resourceType: options.resourceType,
+                                resourceId: options.resourceId,
+                                traceId: options.traceId,
+                                transformType: options.transformType,
+                                start,
+                                end,
+                                cursor,
+                                signal: request.signal,
+                                onBytes: countCycleBytes,
+                            });
+                            checkDeadline(cycle.signal, deadline);
+                            if (performance.now() >= requestDeadline) {
+                                throw new events_1.EventsReadError('Events request deadline exceeded', {
+                                    retryable: true,
+                                });
+                            }
+                            break;
+                        }
+                        catch (error) {
+                            clearTimeout(requestTimer);
+                            cycle.signal.removeEventListener('abort', cancelRequest);
+                            checkDeadline(cycle.signal, deadline);
+                            if (!(error instanceof events_1.EventsReadError) ||
+                                !error.retryable ||
+                                attempt === 3) {
+                                throw error;
+                            }
+                            if (!retrying) {
+                                await writeLine(process.stderr, 'Events temporarily unavailable; retrying the current page.', cycle.signal);
+                                retrying = true;
+                            }
+                            // Never advance the cursor or requested window after a failed page.
+                            await waitFor(Math.max(POLL_INTERVAL_MS, (_b = error.retryAfterMs) !== null && _b !== void 0 ? _b : 0), cycle.signal);
+                        }
+                        finally {
+                            clearTimeout(requestTimer);
+                            cycle.signal.removeEventListener('abort', cancelRequest);
+                        }
+                    }
+                    if (!page) {
+                        throw new Error('Events page could not be read');
+                    }
+                    if (retrying) {
+                        await writeLine(process.stderr, 'Events reads recovered.', cycle.signal);
+                    }
+                    pages++;
+                    returnedBatches += page.batches.length;
+                    if (returnedBatches > MAX_BATCHES) {
+                        throw new Error('Events log window exceeded its batch limit');
+                    }
+                    if (page.next !== null && cursors.has(page.next)) {
+                        throw new Error('Events returned a repeated pagination cursor');
+                    }
+                    for (const batch of page.batches) {
+                        for (const record of batch) {
+                            checkDeadline(cycle.signal, deadline);
+                            const identity = recordIdentity(record);
+                            const timestamp = Date.parse(record.event_timestamp);
+                            const retained = identities.get(identity);
+                            if (retained) {
+                                retained.timestamp = Math.max(retained.timestamp, timestamp);
+                                continue;
+                            }
+                            const bytes = Buffer.byteLength(identity, 'utf8');
+                            if (identities.size >= MAX_IDENTITIES ||
+                                identityBytes + bytes > MAX_IDENTITY_BYTES) {
+                                throw new Error(`Events ${mode} exceeded its retained-identity limit`);
+                            }
+                            await writeLine(process.stdout, (0, format_1.formatRuntimeLogRecord)(record, {
+                                format: options.format,
+                                color,
+                                includeResourceHeader: options.format === 'pretty' && !resourceHeaderWritten,
+                            }), cycle.signal);
+                            resourceHeaderWritten || (resourceHeaderWritten = options.format === 'pretty');
+                            checkDeadline(cycle.signal, deadline);
+                            identities.set(identity, {
+                                timestamp,
+                                bytes,
+                            });
+                            identityBytes += bytes;
+                        }
+                    }
+                    cursor = (_c = page.next) !== null && _c !== void 0 ? _c : undefined;
+                    if (cursor !== undefined) {
+                        cursors.add(cursor);
+                    }
+                } while (cursor !== undefined);
+                if (lastCompletedEnd === undefined && returnedBatches === 0) {
+                    await writeLine(process.stderr, mode === 'read'
+                        ? 'No matching runtime logs found in the requested time window.'
+                        : 'No matching runtime logs found in the initial window. Waiting for new logs...', cycle.signal);
+                }
+                checkDeadline(cycle.signal, deadline);
+                lastCompletedEnd = end;
+                for (const [identity, retained] of identities) {
+                    if (retained.timestamp < lastCompletedEnd - LOOKBACK_MS) {
+                        identities.delete(identity);
+                        identityBytes -= retained.bytes;
+                    }
+                }
+            }
+            finally {
+                clearTimeout(cycleTimer);
+                session.signal.removeEventListener('abort', cancelCycle);
+            }
+            if (mode === 'read') {
+                break;
+            }
+            const delay = POLL_INTERVAL_MS - (performance.now() - cycleStarted);
+            if (delay > 0) {
+                await waitFor(delay, session.signal);
+            }
+        }
+    }
+    catch (error) {
+        if (stopStatus === undefined) {
+            // Callback-based streams can surface EPIPE before their error event.
+            if (error instanceof Error && isBrokenPipe(error)) {
+                stopStatus = 0;
+            }
+            else {
+                const message = error instanceof Error ? error.message : 'Unknown Events log failure';
+                throw new Error(`Partial ${mode}: ${message}. Already displayed records are retained, but completeness is not guaranteed; retry with a smaller window if a work limit was reached.`);
+            }
+        }
+    }
+    finally {
+        session.abort(new Error('Logs closed'));
+        process.removeListener('SIGINT', onInterrupt);
+        process.removeListener('SIGTERM', onTerminate);
+        process.stdout.removeListener('error', onStdoutError);
+        for (let index = stdoutErrorListeners.length - 1; index >= 0; index--) {
+            process.stdout.prependListener('error', stdoutErrorListeners[index]);
+        }
+        process.stderr.removeListener('error', onStderrError);
+        if (stopStatus !== undefined) {
+            process.exitCode = stopStatus;
+        }
+    }
+};
+/** Retrieve one finite query window, including every continuation, then finish. */
+const readEventLogs = (options) => streamEventLogs(options, 'read');
+exports.readEventLogs = readEventLogs;
+/** Retrieve initial context, then keep reading overlapping live windows. */
+const followEventLogs = (options) => streamEventLogs(options, 'tail');
+exports.followEventLogs = followEventLogs;
+/* eslint-enable unicorn/no-null */
+/* eslint-enable no-await-in-loop, no-continue */

package/dist/logs/time.d.ts

@@ -0,0 +1,16 @@
+declare const DEFAULT_LOOKBACK_MS = 300000;
+interface LogWindow {
+    start: number;
+    end: number;
+}
+/** Resolve explicit relative values against one clock, and defaults against the end. */
+declare const resolveLogWindow: (flags: {
+    since?: string;
+    until?: string;
+}, now?: number) => LogWindow;
+/** Resolve tail history only when an explicit --since value is supplied. */
+declare const resolveTailWindow: (flags: {
+    since?: string;
+}, now?: number) => LogWindow;
+export type { LogWindow };
+export { DEFAULT_LOOKBACK_MS, resolveLogWindow, resolveTailWindow };

package/dist/logs/time.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTailWindow = exports.resolveLogWindow = exports.DEFAULT_LOOKBACK_MS = void 0;
+const DEFAULT_LOOKBACK_MS = 300000;
+exports.DEFAULT_LOOKBACK_MS = DEFAULT_LOOKBACK_MS;
+const invalidTime = (flag) => {
+    throw new Error(`--${flag} must be a positive whole-number duration (30s, 5m, 2h, 1d, 1w) or an ISO 8601 timestamp with a timezone and at most millisecond precision.`);
+};
+const parseTime = (value, now, flag) => {
+    const duration = /^(\d+)([smhdw])$/u.exec(value);
+    let instant;
+    if (duration) {
+        const units = {
+            s: 1000,
+            m: 60000,
+            h: 3600000,
+            d: 86400000,
+            w: 604800000,
+        };
+        const milliseconds = Number(duration[1]) * units[duration[2]];
+        if (!Number.isSafeInteger(milliseconds) || milliseconds <= 0) {
+            return invalidTime(flag);
+        }
+        instant = now - milliseconds;
+    }
+    else {
+        const timestamp = 
+        // eslint-disable-next-line security/detect-unsafe-regex -- Fixed-width ISO components cannot cause catastrophic backtracking.
+        /^(\d{4})-(\d{2})-(\d{2})T([01]\d|2[0-3]):([0-5]\d):([0-5]\d)(?:\.\d{1,3})?(Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/u.exec(value);
+        if (!timestamp) {
+            return invalidTime(flag);
+        }
+        const year = Number(timestamp[1]);
+        const month = Number(timestamp[2]);
+        const day = Number(timestamp[3]);
+        if (year < 1970 ||
+            month < 1 ||
+            month > 12 ||
+            day < 1 ||
+            day > new Date(Date.UTC(year, month, 0)).getUTCDate()) {
+            return invalidTime(flag);
+        }
+        instant = Date.parse(value);
+    }
+    if (!Number.isSafeInteger(instant) ||
+        instant < 0 ||
+        !Number.isFinite(new Date(instant).getTime())) {
+        return invalidTime(flag);
+    }
+    return instant;
+};
+/** Resolve explicit relative values against one clock, and defaults against the end. */
+const resolveLogWindow = (flags, now = Date.now()) => {
+    const end = flags.until === undefined ? now : parseTime(flags.until, now, 'until');
+    const start = flags.since === undefined
+        ? end - DEFAULT_LOOKBACK_MS
+        : parseTime(flags.since, now, 'since');
+    if (start < 0 || start >= end) {
+        throw new Error('The log window must start before it ends, on or after 1970-01-01.');
+    }
+    return {
+        start,
+        end,
+    };
+};
+exports.resolveLogWindow = resolveLogWindow;
+/** Resolve tail history only when an explicit --since value is supplied. */
+const resolveTailWindow = (flags, now = Date.now()) => flags.since === undefined
+    ? {
+        start: now,
+        end: now,
+    }
+    : resolveLogWindow(flags, now);
+exports.resolveTailWindow = resolveTailWindow;