@plainconceptsplatform/loop-task 2.6.0

package/dist/core/logging/bounded-log-reader.js

@@ -0,0 +1,368 @@
+import fs from "node:fs";
+const DEFAULT_TAIL_WINDOW = 64 * 1024;
+const INCREMENTAL_READ_CHUNK = 64 * 1024;
+const MAX_RESPONSE_BYTES = 10 * 1024 * 1024;
+export function tailFileBounded(logPath, lineCount, windowBytes = DEFAULT_TAIL_WINDOW) {
+    if (!fs.existsSync(logPath))
+        return [];
+    const size = fs.statSync(logPath).size;
+    if (size === 0)
+        return [];
+    if (lineCount <= 0) {
+        const data = readBounded(logPath, 0, Math.min(size, MAX_RESPONSE_BYTES));
+        return splitLines(data);
+    }
+    const readSize = Math.min(windowBytes, size);
+    const offset = size - readSize;
+    const fd = fs.openSync(logPath, "r");
+    const buf = Buffer.allocUnsafe(readSize);
+    let bytesRead;
+    try {
+        bytesRead = fs.readSync(fd, buf, 0, readSize, offset);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    const text = buf.toString("utf-8", 0, bytesRead);
+    const lines = text.split("\n").filter((l) => l.length > 0);
+    return lines.slice(-lineCount);
+}
+export function readByteRange(logPath, start, end) {
+    if (!fs.existsSync(logPath))
+        return "";
+    const size = fs.statSync(logPath).size;
+    if (size === 0 || start >= size)
+        return "";
+    const effectiveEnd = end ?? size;
+    const readEnd = Math.min(effectiveEnd, size);
+    const readLen = Math.min(readEnd - start, MAX_RESPONSE_BYTES);
+    if (readLen <= 0)
+        return "";
+    const fd = fs.openSync(logPath, "r");
+    const buf = Buffer.allocUnsafe(readLen);
+    let bytesRead;
+    try {
+        bytesRead = fs.readSync(fd, buf, 0, readLen, start);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    return buf.toString("utf-8", 0, bytesRead);
+}
+export function readBounded(logPath, offset, maxBytes = MAX_RESPONSE_BYTES) {
+    if (!fs.existsSync(logPath))
+        return "";
+    const size = fs.statSync(logPath).size;
+    if (size === 0 || offset >= size)
+        return "";
+    const readLen = Math.min(size - offset, maxBytes);
+    const fd = fs.openSync(logPath, "r");
+    const buf = Buffer.allocUnsafe(readLen);
+    let bytesRead;
+    try {
+        bytesRead = fs.readSync(fd, buf, 0, readLen, offset);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    return buf.toString("utf-8", 0, bytesRead);
+}
+export function readIncremental(logPath, fromOffset, highWaterMark = INCREMENTAL_READ_CHUNK, maxTotalBytes = MAX_RESPONSE_BYTES) {
+    if (!fs.existsSync(logPath))
+        return { lines: [], newOffset: fromOffset };
+    const size = fs.statSync(logPath).size;
+    if (size <= fromOffset)
+        return { lines: [], newOffset: fromOffset };
+    const totalToRead = Math.min(size - fromOffset, maxTotalBytes);
+    const fd = fs.openSync(logPath, "r");
+    try {
+        const chunks = [];
+        let totalRead = 0;
+        let currentOffset = fromOffset;
+        while (totalRead < totalToRead) {
+            const chunkSize = Math.min(highWaterMark, totalToRead - totalRead);
+            const buf = Buffer.allocUnsafe(chunkSize);
+            const bytesRead = fs.readSync(fd, buf, 0, chunkSize, currentOffset);
+            if (bytesRead === 0)
+                break;
+            chunks.push(bytesRead < chunkSize ? buf.subarray(0, bytesRead) : buf);
+            totalRead += bytesRead;
+            currentOffset += bytesRead;
+        }
+        if (chunks.length === 0) {
+            return { lines: [], newOffset: fromOffset };
+        }
+        const text = chunks.length === 1
+            ? chunks[0].toString("utf-8")
+            : Buffer.concat(chunks, totalRead).toString("utf-8");
+        return { lines: splitLines(text), newOffset: fromOffset + totalRead };
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+const DEFAULT_REATTACH_DELAY_MS = 25;
+const DEFAULT_MAX_REATTACH_ATTEMPTS = 40;
+const DEFAULT_POLL_INTERVAL_MS = 100;
+const GENERATION_SCAN_MAX = 20;
+function readFdBatch(fd, offset, maxBytes) {
+    const buf = Buffer.allocUnsafe(maxBytes);
+    const bytesRead = fs.readSync(fd, buf, 0, maxBytes, offset);
+    return { text: buf.toString("utf-8", 0, bytesRead), bytesRead };
+}
+export class IncrementalFileWatcher {
+    constructor(options) {
+        this.watcher = null;
+        this.closed = false;
+        this.paused = false;
+        this.polling = false;
+        this.pendingPoll = false;
+        this.reattachTimer = null;
+        this.reattachAttempts = 0;
+        this.pollTimer = null;
+        this.currentIno = null;
+        this.catchup = [];
+        this.logPath = options.logPath;
+        this.currentOffset = options.initialOffset;
+        this.onLines = options.onLines;
+        this.onEnd = options.onEnd;
+        this.onError = options.onError;
+        this.reattachDelayMs = options.reattachDelayMs ?? DEFAULT_REATTACH_DELAY_MS;
+        this.maxReattachAttempts = options.maxReattachAttempts ?? DEFAULT_MAX_REATTACH_ATTEMPTS;
+        this.readBatchBytes = options.readBatchBytes ?? MAX_RESPONSE_BYTES;
+        this.pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    }
+    start() {
+        this.attach();
+        this.pollTimer = setInterval(() => {
+            this.pendingPoll = true;
+            this.drain();
+        }, this.pollIntervalMs);
+        this.pollTimer.unref?.();
+    }
+    pause() {
+        this.paused = true;
+    }
+    resume() {
+        if (!this.paused)
+            return;
+        this.paused = false;
+        if (this.closed)
+            return;
+        this.pendingPoll = true;
+        setImmediate(() => this.drain());
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        if (this.reattachTimer) {
+            clearTimeout(this.reattachTimer);
+            this.reattachTimer = null;
+        }
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+        }
+        for (const entry of this.catchup) {
+            try {
+                fs.closeSync(entry.fd);
+            }
+            catch { /* */ }
+        }
+        this.catchup = [];
+        this.watcher?.close();
+        this.watcher = null;
+    }
+    attach() {
+        if (this.closed)
+            return;
+        try {
+            this.watcher = fs.watch(this.logPath, (eventType) => this.handleEvent(eventType));
+        }
+        catch {
+            this.scheduleReattach();
+            return;
+        }
+        this.reattachAttempts = 0;
+        this.pendingPoll = true;
+        this.drain();
+    }
+    detach() {
+        this.watcher?.close();
+        this.watcher = null;
+    }
+    handleEvent(eventType) {
+        if (this.closed)
+            return;
+        if (eventType === "rename") {
+            this.detach();
+            this.recoverFromRotation();
+            return;
+        }
+        this.pendingPoll = true;
+        this.drain();
+    }
+    recoverFromRotation() {
+        if (this.closed)
+            return;
+        if (!fs.existsSync(this.logPath)) {
+            this.scheduleReattach();
+            return;
+        }
+        try {
+            const stat = fs.statSync(this.logPath);
+            if (this.isRotation(stat)) {
+                this.beginCatchup(stat);
+            }
+        }
+        catch {
+            /* raced another rotation */
+        }
+        this.attach();
+    }
+    isRotation(stat) {
+        if (stat.size < this.currentOffset)
+            return true;
+        if (this.currentIno !== null && stat.ino) {
+            return stat.ino !== this.currentIno;
+        }
+        return false;
+    }
+    beginCatchup(currentStat) {
+        const gens = [];
+        for (let index = 1; index <= GENERATION_SCAN_MAX; index++) {
+            const genPath = `${this.logPath}.${index}`;
+            if (!fs.existsSync(genPath))
+                break;
+            try {
+                const fd = fs.openSync(genPath, "r");
+                const stat = fs.fstatSync(fd);
+                gens.push({ fd, ino: stat.ino, size: stat.size });
+            }
+            catch {
+                break;
+            }
+        }
+        let matched = -1;
+        if (this.currentIno !== null) {
+            matched = gens.findIndex((g) => g.ino !== 0 && g.ino === this.currentIno);
+        }
+        if (matched === -1 && this.currentOffset > 0 && gens.length > 0 && gens[0].size > this.currentOffset) {
+            matched = 0;
+        }
+        for (let index = matched; index >= 0; index--) {
+            const gen = gens[index];
+            const offset = index === matched ? Math.min(this.currentOffset, gen.size) : 0;
+            if (offset < gen.size) {
+                this.catchup.push({ fd: gen.fd, size: gen.size, offset });
+            }
+            else {
+                try {
+                    fs.closeSync(gen.fd);
+                }
+                catch { /* */ }
+            }
+        }
+        for (let index = matched + 1; index < gens.length; index++) {
+            try {
+                fs.closeSync(gens[index].fd);
+            }
+            catch { /* */ }
+        }
+        this.currentOffset = 0;
+        this.currentIno = currentStat.ino || null;
+    }
+    drainCatchupBatch() {
+        const head = this.catchup[0];
+        const toRead = Math.min(this.readBatchBytes, head.size - head.offset);
+        const { text, bytesRead } = readFdBatch(head.fd, head.offset, toRead);
+        head.offset += bytesRead;
+        if (head.offset >= head.size || bytesRead === 0) {
+            try {
+                fs.closeSync(head.fd);
+            }
+            catch { /* */ }
+            this.catchup.shift();
+        }
+        this.pendingPoll = true;
+        const lines = splitLines(text);
+        if (lines.length > 0) {
+            this.onLines(lines);
+        }
+    }
+    scheduleReattach() {
+        if (this.closed || this.reattachTimer)
+            return;
+        if (this.reattachAttempts >= this.maxReattachAttempts) {
+            this.close();
+            this.onEnd();
+            return;
+        }
+        this.reattachAttempts++;
+        this.reattachTimer = setTimeout(() => {
+            this.reattachTimer = null;
+            if (this.closed)
+                return;
+            if (fs.existsSync(this.logPath)) {
+                this.attach();
+            }
+            else {
+                this.scheduleReattach();
+            }
+        }, this.reattachDelayMs);
+        this.reattachTimer.unref?.();
+    }
+    drain() {
+        if (this.closed || this.paused || this.polling || !this.pendingPoll)
+            return;
+        this.polling = true;
+        this.pendingPoll = false;
+        try {
+            this.drainOnce();
+        }
+        catch (err) {
+            this.polling = false;
+            if (err.code === "ENOENT") {
+                this.detach();
+                this.pendingPoll = true;
+                this.recoverFromRotation();
+                return;
+            }
+            this.close();
+            this.onError(err instanceof Error ? err : new Error(String(err)));
+            return;
+        }
+        this.polling = false;
+        if (this.pendingPoll && !this.paused && !this.closed) {
+            setImmediate(() => this.drain());
+        }
+    }
+    drainOnce() {
+        if (this.catchup.length > 0) {
+            this.drainCatchupBatch();
+            return;
+        }
+        const stat = fs.statSync(this.logPath);
+        if (this.isRotation(stat)) {
+            this.beginCatchup(stat);
+            this.pendingPoll = true;
+            return;
+        }
+        this.currentIno = stat.ino || null;
+        if (stat.size > this.currentOffset) {
+            const startOffset = this.currentOffset;
+            const result = readIncremental(this.logPath, this.currentOffset, INCREMENTAL_READ_CHUNK, this.readBatchBytes);
+            this.currentOffset = result.newOffset;
+            if (result.newOffset - startOffset >= this.readBatchBytes) {
+                this.pendingPoll = true;
+            }
+            if (result.lines.length > 0) {
+                this.onLines(result.lines);
+            }
+        }
+    }
+}
+function splitLines(text) {
+    return text.split("\n").filter((l) => l.length > 0);
+}

package/dist/core/logging/log-follower.js

@@ -0,0 +1,26 @@
+import { IncrementalFileWatcher } from "./bounded-log-reader.js";
+import { FOLLOW_READ_BATCH_BYTES } from "../../shared/config/constants.js";
+export function followLogFile(options) {
+    const { logPath, initialOffset, dest, formatLine, onEnd, onError } = options;
+    const watcher = new IncrementalFileWatcher({
+        logPath,
+        initialOffset,
+        readBatchBytes: FOLLOW_READ_BATCH_BYTES,
+        onLines: (lines) => {
+            if (dest.destroyed)
+                return;
+            let writable = true;
+            for (const line of lines) {
+                writable = dest.write(formatLine(line));
+            }
+            if (!writable) {
+                watcher.pause();
+                dest.once("drain", () => watcher.resume());
+            }
+        },
+        onEnd,
+        onError,
+    });
+    watcher.start();
+    return watcher;
+}

package/dist/core/logging/log-parser.js

@@ -0,0 +1,29 @@
+const RUN_HEADER_RE = /^\[Run #(\d+)/;
+const EXIT_MARKER_RE = /^\[exit /;
+export function splitLogByRuns(content) {
+    const lines = content.split("\n");
+    const runs = [];
+    let currentRun = null;
+    for (const line of lines) {
+        const headerMatch = line.match(RUN_HEADER_RE);
+        if (headerMatch) {
+            if (currentRun) {
+                runs.push(currentRun);
+            }
+            currentRun = { runNumber: parseInt(headerMatch[1], 10), lines: [] };
+            continue;
+        }
+        if (currentRun && EXIT_MARKER_RE.test(line)) {
+            runs.push(currentRun);
+            currentRun = null;
+            continue;
+        }
+        if (currentRun) {
+            currentRun.lines.push(line);
+        }
+    }
+    if (currentRun) {
+        runs.push(currentRun);
+    }
+    return runs;
+}

package/dist/core/logging/log-rotator.js

@@ -0,0 +1,34 @@
+import fs from "node:fs";
+import { MAX_LOG_BYTES, MAX_LOG_GENERATIONS } from "../../shared/config/constants.js";
+import { RotatingWriteStream } from "./rotating-log-stream.js";
+export function rotateLogIfNeeded(logPath, currentStream) {
+    if (!fs.existsSync(logPath)) {
+        return currentStream;
+    }
+    const size = fs.statSync(logPath).size;
+    if (size < MAX_LOG_BYTES) {
+        return currentStream;
+    }
+    if (currentStream instanceof RotatingWriteStream) {
+        currentStream.end();
+    }
+    else {
+        currentStream?.end();
+    }
+    for (let index = MAX_LOG_GENERATIONS; index >= 1; index--) {
+        const currentPath = `${logPath}.${index}`;
+        if (!fs.existsSync(currentPath)) {
+            continue;
+        }
+        if (index === MAX_LOG_GENERATIONS) {
+            fs.unlinkSync(currentPath);
+            continue;
+        }
+        fs.renameSync(currentPath, `${logPath}.${index + 1}`);
+    }
+    fs.renameSync(logPath, `${logPath}.1`);
+    return RotatingWriteStream.create(logPath);
+}
+export function createLogStream(logPath) {
+    return RotatingWriteStream.create(logPath);
+}

package/dist/core/logging/rotating-log-stream.js

@@ -0,0 +1,137 @@
+import fs from "node:fs";
+import { Writable } from "node:stream";
+import { MAX_LOG_BYTES, MAX_LOG_GENERATIONS } from "../../shared/config/constants.js";
+function safeCreateWriteStream(path) {
+    const stream = fs.createWriteStream(path, { flags: "a" });
+    stream.on("error", () => { });
+    return stream;
+}
+export class RotatingWriteStream extends Writable {
+    static create(basePath, maxBytes = MAX_LOG_BYTES, maxGenerations = MAX_LOG_GENERATIONS) {
+        return new RotatingWriteStream(basePath, maxBytes, maxGenerations);
+    }
+    constructor(basePath, maxBytes, maxGenerations) {
+        super({ decodeStrings: true, highWaterMark: 64 * 1024 });
+        this._bytesWritten = 0;
+        this._rotating = false;
+        this._rotationWaiters = [];
+        this.basePath = basePath;
+        this.maxBytes = maxBytes;
+        this.maxGenerations = maxGenerations;
+        this.innerStream = safeCreateWriteStream(basePath);
+        try {
+            if (fs.existsSync(basePath)) {
+                this._bytesWritten = fs.statSync(basePath).size;
+            }
+        }
+        catch {
+            this._bytesWritten = 0;
+        }
+    }
+    get bytesWritten() {
+        return this._bytesWritten;
+    }
+    _write(chunk, _encoding, callback) {
+        const proceed = () => this.writeChunk(chunk, callback);
+        if (this._rotating) {
+            this._rotationWaiters.push(proceed);
+            return;
+        }
+        if (this._bytesWritten >= this.maxBytes) {
+            this.rotateThen(proceed);
+            return;
+        }
+        proceed();
+    }
+    writeChunk(chunk, callback) {
+        this._bytesWritten += chunk.byteLength;
+        if (!this.innerStream.writable) {
+            callback(new Error("stream not writable"));
+            return;
+        }
+        const canWrite = this.innerStream.write(chunk);
+        if (canWrite) {
+            callback();
+            return;
+        }
+        const inner = this.innerStream;
+        const onDrain = () => {
+            inner.off("error", onError);
+            callback();
+        };
+        const onError = () => {
+            inner.off("drain", onDrain);
+            callback();
+        };
+        inner.once("drain", onDrain);
+        inner.once("error", onError);
+    }
+    _final(callback) {
+        const finish = () => {
+            this.innerStream.end(() => {
+                callback();
+            });
+        };
+        if (this._rotating) {
+            this._rotationWaiters.push(finish);
+        }
+        else {
+            finish();
+        }
+    }
+    rotateIfNeeded() {
+        if (this._rotating)
+            return false;
+        if (this._bytesWritten < this.maxBytes)
+            return false;
+        this.rotateThen(() => { });
+        return true;
+    }
+    rotateThen(next) {
+        this._rotationWaiters.push(next);
+        if (this._rotating)
+            return;
+        this._rotating = true;
+        this._bytesWritten = 0;
+        const old = this.innerStream;
+        let finished = false;
+        const finishRotation = () => {
+            if (finished)
+                return;
+            finished = true;
+            this.shiftGenerations();
+            this._rotating = false;
+            const waiters = this._rotationWaiters;
+            this._rotationWaiters = [];
+            for (const waiter of waiters)
+                waiter();
+        };
+        old.once("error", finishRotation);
+        old.end(finishRotation);
+    }
+    shiftGenerations() {
+        try {
+            for (let index = this.maxGenerations; index >= 1; index--) {
+                const currentPath = `${this.basePath}.${index}`;
+                if (!fs.existsSync(currentPath))
+                    continue;
+                if (index === this.maxGenerations) {
+                    fs.unlinkSync(currentPath);
+                    continue;
+                }
+                fs.renameSync(currentPath, `${this.basePath}.${index + 1}`);
+            }
+            if (fs.existsSync(this.basePath)) {
+                fs.renameSync(this.basePath, `${this.basePath}.1`);
+            }
+        }
+        catch {
+            /* a locked or vanished generation must not break logging */
+        }
+        const dir = this.basePath.substring(0, this.basePath.lastIndexOf("/"));
+        if (dir && !fs.existsSync(dir)) {
+            return;
+        }
+        this.innerStream = safeCreateWriteStream(this.basePath);
+    }
+}