@aragon-agent/cli 0.5.0 → 0.5.2

package/dist/logging/cli-commands.js

@@ -0,0 +1,221 @@
+/**
+ * `aragon logs path | list | tail | clear | open` — the non-interactive surface.
+ *
+ * Exit codes follow the existing convention: 0 success · 1 run-time failure ·
+ * 2 usage error.
+ *
+ * THE WHOLE GROUP IS EXEMPT from the "every subcommand records one info line"
+ * rule, and that is a correctness requirement rather than tidiness. Recording a
+ * line opens today's log file, and Node opens files without
+ * `FILE_SHARE_DELETE`; on Windows — the platform this feature was asked for —
+ * `aragon logs clear --yes` would then be unable to delete the very file its own
+ * announcement had just created. These commands are the log's operations
+ * surface; giving them observable side effects on the log is backwards.
+ */
+import { existsSync, readFileSync, readdirSync, rmSync, statSync, unwatchFile, watchFile, } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { join } from 'node:path';
+import process from 'node:process';
+import { getLogsDir } from '../config/app-paths.js';
+import { loadConfig } from '../config/load.js';
+import { isLogFileName } from './file-sink.js';
+import { getLogger } from './logger.js';
+import { LOG_LEVELS, isLogLevel } from './levels.js';
+const EXIT_OK = 0;
+const EXIT_RUNTIME = 1;
+const EXIT_USAGE = 2;
+const DEFAULT_TAIL_LINES = 100;
+/** `watchFile` poll interval for `--follow` (Q2). */
+const FOLLOW_POLL_MS = 500;
+/** The effective log directory for this run (flag › env › file › default). */
+function resolveLogsDir(flags) {
+    const configured = loadConfig(flags).log.dir.trim();
+    return configured.length > 0 ? configured : getLogsDir();
+}
+function listLogFiles(dir) {
+    if (!existsSync(dir))
+        return [];
+    try {
+        return readdirSync(dir)
+            .filter(isLogFileName)
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+export async function runLogsCommand(subcommand, opts, flags) {
+    const dir = resolveLogsDir(flags);
+    switch (subcommand) {
+        case 'path':
+            return runPath(dir);
+        case 'list':
+            return runList(dir);
+        case 'tail':
+            return runTail(dir, opts);
+        case 'clear':
+            return runClear(dir, opts);
+        case 'open':
+            return runOpen(dir);
+        default:
+            process.stderr.write(`Unknown logs subcommand "${subcommand}". Try: path | list | tail | clear | open.\n`);
+            return EXIT_USAGE;
+    }
+}
+function runPath(dir) {
+    const logger = getLogger();
+    process.stdout.write(`${logger.currentLogPath()}\n`);
+    process.stdout.write(`directory: ${dir}\n`);
+    // `debug` and `trace` write prompt and tool output verbatim; a user about to
+    // attach a log to a bug report should be told that here, not discover it.
+    process.stdout.write('level: ' + logger.level + ' (debug/trace record prompt and tool content)\n');
+    if (logger.sinkDisabled) {
+        process.stdout.write(`WARNING: logging is disabled after write failures: ${logger.sinkError}\n`);
+    }
+    return EXIT_OK;
+}
+function runList(dir) {
+    const files = listLogFiles(dir);
+    if (files.length === 0) {
+        process.stdout.write(`No log files in ${dir}.\n`);
+        return EXIT_OK;
+    }
+    for (const name of files) {
+        try {
+            const stat = statSync(join(dir, name));
+            process.stdout.write(`${name}  ${stat.size} bytes  ${stat.mtime.toISOString()}\n`);
+        }
+        catch {
+            process.stdout.write(`${name}  (unreadable)\n`);
+        }
+    }
+    return EXIT_OK;
+}
+/** Render one JSONL record as a human-readable line; pass unparseable ones through. */
+function renderRecord(line) {
+    try {
+        const record = JSON.parse(line);
+        const data = record.data ? ` ${JSON.stringify(record.data)}` : '';
+        const level = (record.lv ?? '?').padEnd(5);
+        return `${record.ts ?? ''} ${level} ${record.scope ?? '-'}: ${record.msg ?? ''}${data}`;
+    }
+    catch {
+        return line;
+    }
+}
+function passesLevel(line, min) {
+    if (!min)
+        return true;
+    try {
+        const record = JSON.parse(line);
+        if (!isLogLevel(record.lv))
+            return true;
+        return LOG_LEVELS[record.lv] <= LOG_LEVELS[min];
+    }
+    catch {
+        return true;
+    }
+}
+function printLines(lines, opts, min) {
+    for (const line of lines) {
+        if (line.trim().length === 0)
+            continue;
+        if (!passesLevel(line, min))
+            continue;
+        process.stdout.write(`${opts.json ? line : renderRecord(line)}\n`);
+    }
+}
+function runTail(dir, opts) {
+    const files = listLogFiles(dir);
+    const target = files.length > 0 ? join(dir, files[files.length - 1]) : null;
+    if (!target) {
+        process.stdout.write(`No log files in ${dir}.\n`);
+        return EXIT_OK;
+    }
+    if (opts.level !== undefined && !isLogLevel(opts.level)) {
+        process.stderr.write(`Unknown level "${opts.level}".\n`);
+        return EXIT_USAGE;
+    }
+    const min = opts.level;
+    const count = Number.parseInt(opts.lines ?? '', 10);
+    const wanted = Number.isFinite(count) && count > 0 ? count : DEFAULT_TAIL_LINES;
+    let consumed = 0;
+    try {
+        const raw = readFileSync(target, 'utf-8');
+        consumed = raw.length;
+        printLines(raw.split('\n').slice(-wanted), opts, min);
+    }
+    catch (err) {
+        process.stderr.write(`Could not read ${target}: ${err instanceof Error ? err.message : err}\n`);
+        return EXIT_RUNTIME;
+    }
+    if (!opts.follow)
+        return EXIT_OK;
+    // `watchFile` (polling) rather than `fs.watch`: these files are ROTATED by
+    // rename, which is exactly the case `fs.watch` reports inconsistently across
+    // platforms. Half a second of latency is invisible to someone reading a log.
+    watchFile(target, { interval: FOLLOW_POLL_MS }, () => {
+        try {
+            const raw = readFileSync(target, 'utf-8');
+            if (raw.length < consumed)
+                consumed = 0; // truncated or rotated underneath us
+            printLines(raw.slice(consumed).split('\n'), opts, min);
+            consumed = raw.length;
+        }
+        catch {
+            // The file may vanish mid-rotation; the next poll picks the new one up.
+        }
+    });
+    process.on('SIGINT', () => unwatchFile(target));
+    return EXIT_OK;
+}
+/**
+ * Delete every log file.
+ *
+ * Closes this process's own sink first — otherwise the day's file is held open
+ * by the very command trying to remove it. Failures are reported PER FILE
+ * rather than aborting: another `aragon` window holding one file open should
+ * not stop the other nine from being cleared.
+ */
+function runClear(dir, opts) {
+    if (!opts.yes) {
+        process.stderr.write('Refusing to delete log files without --yes.\n');
+        return EXIT_USAGE;
+    }
+    getLogger().closeSink();
+    const files = listLogFiles(dir);
+    const blocked = [];
+    let removed = 0;
+    for (const name of files) {
+        try {
+            rmSync(join(dir, name), { force: true });
+            removed += 1;
+        }
+        catch {
+            blocked.push(name);
+        }
+    }
+    process.stdout.write(`Deleted ${removed} log file(s).\n`);
+    if (blocked.length === 0)
+        return EXIT_OK;
+    process.stderr.write(`In use, not deleted: ${blocked.join(', ')}\n`);
+    return EXIT_RUNTIME;
+}
+/**
+ * Open the log directory in the platform file manager.
+ *
+ * A convenience, so a failure degrades to printing the path and still exits 0 —
+ * being unable to launch a file manager is not an error in a logging command.
+ */
+function runOpen(dir) {
+    const opener = process.platform === 'win32' ? 'explorer' : process.platform === 'darwin' ? 'open' : 'xdg-open';
+    try {
+        const child = spawn(opener, [dir], { stdio: 'ignore', detached: true });
+        child.on('error', () => process.stdout.write(`${dir}\n`));
+        child.unref();
+    }
+    catch {
+        process.stdout.write(`${dir}\n`);
+    }
+    return EXIT_OK;
+}

package/dist/logging/file-sink.d.ts

@@ -0,0 +1,114 @@
+/**
+ * The file sink — a memory queue in front of ONE synchronous append fd.
+ *
+ * WHY NOT `createWriteStream` (design P1-4). Three reasons, each fatal on its
+ * own:
+ *   - a stream's internal buffer is DISCARDED by `process.exit()`, and the
+ *     records still sitting in it during a crash are the ones worth having;
+ *   - an exit-path `appendFileSync` plus a steady-state stream are two writers
+ *     on one file with no defined ordering between them;
+ *   - a stream reports write failures through an async `'error'` event, which
+ *     THROWS when nobody is listening — so "make the log directory read-only"
+ *     would take the whole CLI down instead of degrading.
+ *
+ * With `openSync` + `writeSync` every failure is a synchronous throw one
+ * `try/catch` away, and `flushSync()` and the steady-state flush are literally
+ * the same code path. `O_APPEND` keeps concurrent `aragon` processes from
+ * truncating each other, and one batched `writeSync` stays far below any size
+ * that could tear a line.
+ */
+export interface FileSinkOptions {
+    dir: string;
+    maxFileBytes: number;
+    maxFiles: number;
+    /**
+     * Renders the "records were dropped" warning line. Not a persisted setting —
+     * the sink handles LINES and has no session id or clock of its own, so the
+     * logger supplies the rendering and the sink decides when it is needed.
+     */
+    formatDropNotice?: (count: number) => string;
+    /** Called once, when the sink gives up on writing. */
+    onFailure?: (reason: string) => void;
+}
+/**
+ * `YYYY-MM-DD` in LOCAL time.
+ *
+ * Local, not UTC, and the record timestamps use the same clock deliberately: a
+ * user west of UTC would otherwise find an evening's records filed under the
+ * previous local day and stamped with the next one, which makes "open today's
+ * log" a lie twice over.
+ */
+export declare function localDateStamp(date?: Date): string;
+/**
+ * Delete the oldest files until at most `maxFiles` remain.
+ *
+ * A STANDALONE STEP, called on three occasions — first write of the process,
+ * midnight roll-over, and size rotation — because retention that only ran
+ * during size rotation would never fire for the many users who never reach
+ * `maxFileBytes`: one file per day, forever, under a setting that says 10.
+ *
+ * Never throws. On Windows another `aragon` process may hold a handle on a file
+ * we would like to remove; that is a reason to skip it, not to fail a write.
+ */
+export declare function enforceRetention(dir: string, maxFiles: number): void;
+export declare class FileSink {
+    private options;
+    private queue;
+    private dropped;
+    private fd;
+    private currentFile;
+    private currentDay;
+    private currentSize;
+    private timer;
+    private failures;
+    private failed;
+    private failureReason;
+    private retentionRun;
+    constructor(options: FileSinkOptions);
+    get disabled(): boolean;
+    get lastError(): string | undefined;
+    /** The file records are going to right now (may not exist until first write). */
+    get currentPath(): string;
+    /** Enqueue one already-serialised line (including its trailing newline). */
+    write(line: string): void;
+    /** Threshold/timer flush. Identical to `flushSync` — see the module header. */
+    flush(): void;
+    /** Idempotent: safe to call from `exit`, a signal handler and a crash handler. */
+    flushSync(): void;
+    close(): void;
+    /**
+     * Apply new settings. Changing the directory closes the current fd so the next
+     * write lazily opens the new one; the sink never eagerly creates a directory
+     * the user may never write a record into.
+     */
+    reconfigure(options: FileSinkOptions): void;
+    private takeBatch;
+    /** Open (or roll) the target file so `incomingBytes` can be appended to it. */
+    private prepareTarget;
+    private openTarget;
+    /**
+     * flush → close → rename → open → retention, in that order.
+     *
+     * `closeSync` MUST precede `renameSync`: on Windows renaming a file the
+     * process still holds a handle on fails with EPERM. A failed rename is
+     * swallowed and writing continues into the original file — two instances
+     * rotating at once should cost an extra small file, not the log itself.
+     */
+    private rotateBySize;
+    /** Highest existing `aragon-<day>.<n>.log` index, plus one. */
+    private nextRotationIndex;
+    private closeFd;
+    /**
+     * Logging failure must never become CLI failure, and must never write to the
+     * terminal itself (invariant I-4 — a stray line permanently misaligns the
+     * full-screen frame). The owner is told once through `onFailure`, which routes
+     * to a toast when the TUI is mounted and to stderr when it is not.
+     */
+    private recordFailure;
+    private startTimer;
+    private stopTimer;
+}
+/** Exposed for the CLI's `logs` commands, which list the same file family. */
+export declare function isLogFileName(name: string): boolean;
+/** The log file the CURRENT day would use inside a log directory. */
+export declare function currentLogFileName(date?: Date): string;

package/dist/logging/file-sink.js

@@ -0,0 +1,326 @@
+/**
+ * The file sink — a memory queue in front of ONE synchronous append fd.
+ *
+ * WHY NOT `createWriteStream` (design P1-4). Three reasons, each fatal on its
+ * own:
+ *   - a stream's internal buffer is DISCARDED by `process.exit()`, and the
+ *     records still sitting in it during a crash are the ones worth having;
+ *   - an exit-path `appendFileSync` plus a steady-state stream are two writers
+ *     on one file with no defined ordering between them;
+ *   - a stream reports write failures through an async `'error'` event, which
+ *     THROWS when nobody is listening — so "make the log directory read-only"
+ *     would take the whole CLI down instead of degrading.
+ *
+ * With `openSync` + `writeSync` every failure is a synchronous throw one
+ * `try/catch` away, and `flushSync()` and the steady-state flush are literally
+ * the same code path. `O_APPEND` keeps concurrent `aragon` processes from
+ * truncating each other, and one batched `writeSync` stays far below any size
+ * that could tear a line.
+ */
+import { closeSync, existsSync, mkdirSync, openSync, readdirSync, renameSync, rmSync, statSync, writeSync, } from 'node:fs';
+import { join } from 'node:path';
+/** Flush triggers: whichever of the two comes first. */
+const FLUSH_AT_RECORDS = 64;
+const FLUSH_INTERVAL_MS = 200;
+/**
+ * Hard queue ceiling. On overflow the NEWEST records are dropped and the head
+ * is kept: in a flood, the oldest lines are the ones that explain how it
+ * started, so discarding them first would throw away the log's whole value at
+ * the moment it finally has some.
+ *
+ * A backstop rather than a working limit — `write()` flushes at
+ * `FLUSH_AT_RECORDS` and the flush is synchronous, so the queue does not
+ * normally grow past that. It stays because the batching threshold is a tuning
+ * knob and an unbounded array behind one is not something to rediscover later.
+ * The drop COUNTER, by contrast, is reached routinely: see `flushSync`, where a
+ * failed write would otherwise discard its batch without a word.
+ */
+const MAX_QUEUED_RECORDS = 5000;
+/** Consecutive write failures after which the sink stops trying (§4.4.6). */
+const MAX_CONSECUTIVE_FAILURES = 3;
+const FILE_PREFIX = 'aragon-';
+const FILE_SUFFIX = '.log';
+/**
+ * `YYYY-MM-DD` in LOCAL time.
+ *
+ * Local, not UTC, and the record timestamps use the same clock deliberately: a
+ * user west of UTC would otherwise find an evening's records filed under the
+ * previous local day and stamped with the next one, which makes "open today's
+ * log" a lie twice over.
+ */
+export function localDateStamp(date = new Date()) {
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}
+/**
+ * Delete the oldest files until at most `maxFiles` remain.
+ *
+ * A STANDALONE STEP, called on three occasions — first write of the process,
+ * midnight roll-over, and size rotation — because retention that only ran
+ * during size rotation would never fire for the many users who never reach
+ * `maxFileBytes`: one file per day, forever, under a setting that says 10.
+ *
+ * Never throws. On Windows another `aragon` process may hold a handle on a file
+ * we would like to remove; that is a reason to skip it, not to fail a write.
+ */
+export function enforceRetention(dir, maxFiles) {
+    try {
+        const files = readdirSync(dir)
+            .filter((name) => name.startsWith(FILE_PREFIX) && name.endsWith(FILE_SUFFIX))
+            .map((name) => {
+            const full = join(dir, name);
+            try {
+                return { full, mtime: statSync(full).mtimeMs };
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((entry) => entry !== null)
+            .sort((a, b) => a.mtime - b.mtime);
+        for (const entry of files.slice(0, Math.max(0, files.length - maxFiles))) {
+            try {
+                rmSync(entry.full, { force: true });
+            }
+            catch {
+                // Locked by another instance. Retention is best-effort by design.
+            }
+        }
+    }
+    catch {
+        // Directory does not exist yet, or is unreadable. Nothing to retain.
+    }
+}
+export class FileSink {
+    options;
+    queue = [];
+    dropped = 0;
+    fd = null;
+    currentFile = null;
+    currentDay = '';
+    currentSize = 0;
+    timer = null;
+    failures = 0;
+    failed = false;
+    failureReason;
+    retentionRun = false;
+    constructor(options) {
+        this.options = { ...options };
+    }
+    get disabled() {
+        return this.failed;
+    }
+    get lastError() {
+        return this.failureReason;
+    }
+    /** The file records are going to right now (may not exist until first write). */
+    get currentPath() {
+        if (this.currentFile)
+            return this.currentFile;
+        return join(this.options.dir, `${FILE_PREFIX}${localDateStamp()}${FILE_SUFFIX}`);
+    }
+    /** Enqueue one already-serialised line (including its trailing newline). */
+    write(line) {
+        if (this.failed)
+            return;
+        if (this.queue.length >= MAX_QUEUED_RECORDS) {
+            this.dropped += 1;
+            return;
+        }
+        this.queue.push(line);
+        if (this.queue.length >= FLUSH_AT_RECORDS) {
+            this.flushSync();
+            return;
+        }
+        this.startTimer();
+    }
+    /** Threshold/timer flush. Identical to `flushSync` — see the module header. */
+    flush() {
+        this.flushSync();
+    }
+    /** Idempotent: safe to call from `exit`, a signal handler and a crash handler. */
+    flushSync() {
+        if (this.queue.length === 0 && this.dropped === 0)
+            return;
+        if (this.failed) {
+            this.queue = [];
+            return;
+        }
+        const pending = this.queue.length;
+        const droppedBefore = this.dropped;
+        const batch = this.takeBatch();
+        try {
+            this.prepareTarget(Buffer.byteLength(batch));
+            writeSync(this.fd, batch);
+            this.currentSize += Buffer.byteLength(batch);
+            this.failures = 0;
+        }
+        catch (err) {
+            // The batch is gone — retrying it would need the queue to grow unbounded
+            // behind a directory that may never become writable. But it is ACCOUNTED
+            // FOR: the count (including the notice this batch was carrying) rides
+            // along to the next flush that succeeds. Silently losing records is the
+            // one thing a logger must not do.
+            this.dropped = droppedBefore + pending;
+            this.recordFailure(err);
+        }
+    }
+    close() {
+        this.flushSync();
+        this.stopTimer();
+        this.closeFd();
+    }
+    /**
+     * Apply new settings. Changing the directory closes the current fd so the next
+     * write lazily opens the new one; the sink never eagerly creates a directory
+     * the user may never write a record into.
+     */
+    reconfigure(options) {
+        const dirChanged = options.dir !== this.options.dir;
+        if (dirChanged) {
+            this.flushSync();
+            this.closeFd();
+            this.retentionRun = false;
+        }
+        this.options = { ...this.options, ...options };
+    }
+    // -------------------------------------------------------------------------
+    // Internals
+    // -------------------------------------------------------------------------
+    takeBatch() {
+        const lines = this.queue;
+        this.queue = [];
+        if (this.dropped > 0) {
+            const notice = this.options.formatDropNotice?.(this.dropped);
+            this.dropped = 0;
+            // Appended, not prepended: it describes what happened to the records that
+            // would have followed these, and silence about a drop is unacceptable.
+            if (notice)
+                lines.push(notice);
+        }
+        return lines.join('');
+    }
+    /** Open (or roll) the target file so `incomingBytes` can be appended to it. */
+    prepareTarget(incomingBytes) {
+        const day = localDateStamp();
+        if (this.fd !== null && day !== this.currentDay) {
+            // Midnight: yesterday's file keeps its own name, so there is nothing to
+            // rename — just close it and open today's. Retention runs here because
+            // this is the path a user who never hits `maxFileBytes` takes every day.
+            this.closeFd();
+            this.openTarget(day);
+            enforceRetention(this.options.dir, this.options.maxFiles);
+        }
+        if (this.fd === null) {
+            this.openTarget(day);
+            if (!this.retentionRun) {
+                this.retentionRun = true;
+                enforceRetention(this.options.dir, this.options.maxFiles);
+            }
+        }
+        if (this.currentSize + incomingBytes > this.options.maxFileBytes) {
+            this.rotateBySize(day);
+        }
+    }
+    openTarget(day) {
+        mkdirSync(this.options.dir, { recursive: true, mode: 0o700 });
+        const file = join(this.options.dir, `${FILE_PREFIX}${day}${FILE_SUFFIX}`);
+        this.fd = openSync(file, 'a', 0o600);
+        this.currentFile = file;
+        this.currentDay = day;
+        this.currentSize = existsSync(file) ? statSync(file).size : 0;
+    }
+    /**
+     * flush → close → rename → open → retention, in that order.
+     *
+     * `closeSync` MUST precede `renameSync`: on Windows renaming a file the
+     * process still holds a handle on fails with EPERM. A failed rename is
+     * swallowed and writing continues into the original file — two instances
+     * rotating at once should cost an extra small file, not the log itself.
+     */
+    rotateBySize(day) {
+        const previous = this.currentFile;
+        const index = this.nextRotationIndex(day);
+        const target = join(this.options.dir, `${FILE_PREFIX}${day}.${index}${FILE_SUFFIX}`);
+        this.closeFd();
+        if (previous) {
+            try {
+                renameSync(previous, target);
+            }
+            catch {
+                // Another instance won the race, or holds a handle. Keep writing.
+            }
+        }
+        this.openTarget(day);
+        enforceRetention(this.options.dir, this.options.maxFiles);
+    }
+    /** Highest existing `aragon-<day>.<n>.log` index, plus one. */
+    nextRotationIndex(day) {
+        const prefix = `${FILE_PREFIX}${day}.`;
+        let max = 0;
+        try {
+            for (const name of readdirSync(this.options.dir)) {
+                if (!name.startsWith(prefix) || !name.endsWith(FILE_SUFFIX))
+                    continue;
+                const n = Number.parseInt(name.slice(prefix.length, name.length - FILE_SUFFIX.length), 10);
+                if (Number.isFinite(n) && n > max)
+                    max = n;
+            }
+        }
+        catch {
+            // Unreadable directory: index 1 is as good a guess as any.
+        }
+        return max + 1;
+    }
+    closeFd() {
+        if (this.fd === null)
+            return;
+        try {
+            closeSync(this.fd);
+        }
+        catch {
+            // Already closed by a racing handler; nothing to do.
+        }
+        this.fd = null;
+        this.currentFile = null;
+        this.currentSize = 0;
+    }
+    /**
+     * Logging failure must never become CLI failure, and must never write to the
+     * terminal itself (invariant I-4 — a stray line permanently misaligns the
+     * full-screen frame). The owner is told once through `onFailure`, which routes
+     * to a toast when the TUI is mounted and to stderr when it is not.
+     */
+    recordFailure(err) {
+        this.failures += 1;
+        this.failureReason = err instanceof Error ? err.message : String(err);
+        this.closeFd();
+        if (this.failures < MAX_CONSECUTIVE_FAILURES)
+            return;
+        this.failed = true;
+        this.stopTimer();
+        this.options.onFailure?.(this.failureReason);
+    }
+    startTimer() {
+        if (this.timer)
+            return;
+        this.timer = setInterval(() => this.flushSync(), FLUSH_INTERVAL_MS);
+        // Without `unref`, an `aragon --version` that logs one line would be held
+        // open by this timer for 200ms after it had nothing left to do.
+        this.timer.unref?.();
+    }
+    stopTimer() {
+        if (!this.timer)
+            return;
+        clearInterval(this.timer);
+        this.timer = null;
+    }
+}
+/** Exposed for the CLI's `logs` commands, which list the same file family. */
+export function isLogFileName(name) {
+    return name.startsWith(FILE_PREFIX) && name.endsWith(FILE_SUFFIX);
+}
+/** The log file the CURRENT day would use inside a log directory. */
+export function currentLogFileName(date = new Date()) {
+    return `${FILE_PREFIX}${localDateStamp(date)}${FILE_SUFFIX}`;
+}