watchfix 0.1.0

package/dist/watcher/patterns.js

@@ -0,0 +1,92 @@
+const BUILTIN_MATCH_PATTERNS = [
+    // JavaScript
+    /Error:/,
+    /TypeError:/,
+    /ReferenceError:/,
+    /SyntaxError:/,
+    /RangeError:/,
+    /URIError:/,
+    /EvalError:/,
+    // Node.js
+    /UnhandledPromiseRejection/,
+    /\bECONNREFUSED\b/,
+    /\bENOTFOUND\b/,
+    /\bETIMEDOUT\b/,
+    /\bEADDRINUSE\b/,
+    /\bEACCES\b/,
+    /\bEPERM\b/,
+    // Python
+    /Traceback \(most recent call last\)/,
+    /Exception:/,
+    /AssertionError:/,
+    // Go
+    /panic:/,
+    /fatal error:/,
+    /runtime error:/,
+    // Docker
+    /container is not running/i,
+    /unhealthy/i,
+    /OOMKilled/,
+    /no such container/i,
+    /connection refused/i,
+    // Database
+    /SQLSTATE\[/,
+    /deadlock detected/i,
+    /duplicate key/i,
+    /constraint violation/i,
+    // Generic
+    /\b(FATAL|CRITICAL|EMERGENCY)(?:[:\s]|$)/i,
+];
+const BUILTIN_IGNORE_PATTERNS = [
+    /^(DEBUG|TRACE|VERBOSE|INFO)(?:[:\s]|$)/,
+    /\b(successfully|healthy|passed|completed|OK)\b/i,
+];
+const REGEX_PREFIX = 'regex:';
+const matchesRegex = (line, source) => {
+    try {
+        const pattern = new RegExp(source);
+        return pattern.test(line);
+    }
+    catch {
+        return false;
+    }
+};
+const matchesCustomPatterns = (line, patterns) => {
+    if (!patterns || patterns.length === 0) {
+        return false;
+    }
+    const lowerLine = line.toLowerCase();
+    return patterns.some((pattern) => {
+        if (pattern.startsWith(REGEX_PREFIX)) {
+            return matchesRegex(line, pattern.slice(REGEX_PREFIX.length));
+        }
+        return lowerLine.includes(pattern.toLowerCase());
+    });
+};
+const matchesBuiltinPatterns = (line, patterns) => patterns.some((pattern) => pattern.test(line));
+const matchesErrorPattern = (line, customMatch, customIgnore) => {
+    if (matchesBuiltinPatterns(line, BUILTIN_IGNORE_PATTERNS) ||
+        matchesCustomPatterns(line, customIgnore)) {
+        return false;
+    }
+    return (matchesBuiltinPatterns(line, BUILTIN_MATCH_PATTERNS) ||
+        matchesCustomPatterns(line, customMatch));
+};
+const extractErrorType = (message) => {
+    const patterns = [
+        [/^(\w+Error):/, 1],
+        [/^(\w+Exception):/, 1],
+        [/(E[A-Z]{2,})(?:[\s:,]|$)/, 1],
+        [/^(panic):/, 1],
+        [/^(FATAL|CRITICAL):?/i, 1],
+        [/SQLSTATE\[(\w+)\]/, 1],
+    ];
+    for (const [pattern, group] of patterns) {
+        const match = message.match(pattern);
+        if (match) {
+            return match[group];
+        }
+    }
+    return 'Error';
+};
+export { BUILTIN_IGNORE_PATTERNS, BUILTIN_MATCH_PATTERNS, extractErrorType, matchesErrorPattern, };

package/dist/watcher/sources/command.d.ts

@@ -0,0 +1,27 @@
+import { Logger } from '../../utils/logger.js';
+import type { CommandSourceConfig, LogEvent, LogSource } from './types.js';
+type LoggerLike = Pick<Logger, 'warn' | 'info' | 'debug' | 'error'>;
+type CommandSourceOptions = {
+    logger?: LoggerLike;
+    maxLineBuffer?: number;
+};
+export declare class CommandSource implements LogSource {
+    private readonly config;
+    private readonly logger;
+    private readonly emitter;
+    private readonly intervalMs;
+    private readonly maxLineBuffer;
+    private readonly seenHashes;
+    private timer;
+    private running;
+    private stopRequested;
+    constructor(config: CommandSourceConfig, options?: CommandSourceOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    on(event: 'line', handler: (event: LogEvent) => void): void;
+    private schedule;
+    private runOnce;
+    private emitLine;
+    private executeCommand;
+}
+export {};

package/dist/watcher/sources/command.js

@@ -0,0 +1,143 @@
+import { EventEmitter } from 'node:events';
+import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { Logger } from '../../utils/logger.js';
+import { parseDuration } from '../../utils/duration.js';
+const DEFAULT_MAX_LINE_BUFFER = 10_000;
+const hashLine = (line) => createHash('sha256').update(line).digest('hex');
+const normalizeLines = (output) => {
+    if (!output) {
+        return [];
+    }
+    const lines = output.split('\n').map((line) => line.replace(/\r$/, ''));
+    if (lines.length > 0 && lines[lines.length - 1] === '') {
+        lines.pop();
+    }
+    return lines;
+};
+export class CommandSource {
+    config;
+    logger;
+    emitter;
+    intervalMs;
+    maxLineBuffer;
+    seenHashes = new Set();
+    timer = null;
+    running = false;
+    stopRequested = false;
+    constructor(config, options) {
+        this.config = config;
+        this.logger =
+            options?.logger ?? new Logger({ terminalEnabled: false, verbosity: 'normal' });
+        this.emitter = new EventEmitter();
+        this.intervalMs = parseDuration(config.interval);
+        const maxLineBuffer = options?.maxLineBuffer ?? DEFAULT_MAX_LINE_BUFFER;
+        this.maxLineBuffer = Math.max(1, maxLineBuffer);
+    }
+    async start() {
+        if (this.running || this.timer) {
+            return;
+        }
+        this.stopRequested = false;
+        this.schedule(0);
+    }
+    async stop() {
+        this.stopRequested = true;
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+    on(event, handler) {
+        this.emitter.on(event, handler);
+    }
+    schedule(delayMs) {
+        if (this.stopRequested) {
+            return;
+        }
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            void this.runOnce();
+        }, delayMs);
+    }
+    async runOnce() {
+        if (this.running || this.stopRequested) {
+            return;
+        }
+        this.running = true;
+        try {
+            const output = await this.executeCommand();
+            if (output.truncated) {
+                this.logger.warn(`Command output truncated: kept last ${this.maxLineBuffer} of ${output.totalLines} lines`);
+            }
+            if (output.exitCode !== 0) {
+                this.logger.warn(`Command '${this.config.run}' exited with code ${output.exitCode}`);
+            }
+            for (const line of output.lines) {
+                this.emitLine(line);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.logger.error(`Command source '${this.config.name}' failed to run: ${message}`);
+        }
+        finally {
+            this.running = false;
+            if (!this.stopRequested) {
+                this.schedule(this.intervalMs);
+            }
+        }
+    }
+    emitLine(line) {
+        const hash = hashLine(line);
+        if (this.seenHashes.has(hash)) {
+            return;
+        }
+        this.seenHashes.add(hash);
+        this.emitter.emit('line', {
+            source: this.config.name,
+            line,
+            timestamp: new Date(),
+        });
+    }
+    async executeCommand() {
+        return await new Promise((resolve, reject) => {
+            const child = spawn(this.config.run, {
+                shell: true,
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            let stdout = '';
+            let stderr = '';
+            if (child.stdout) {
+                child.stdout.on('data', (data) => {
+                    stdout += String(data);
+                });
+            }
+            if (child.stderr) {
+                child.stderr.on('data', (data) => {
+                    stderr += String(data);
+                });
+            }
+            child.on('error', (error) => {
+                reject(error);
+            });
+            child.on('close', (code) => {
+                const combined = stdout && stderr ? `${stdout}\n${stderr}` : stdout || stderr;
+                const lines = normalizeLines(combined);
+                const totalLines = lines.length;
+                let truncated = false;
+                let keptLines = lines;
+                if (lines.length > this.maxLineBuffer) {
+                    truncated = true;
+                    keptLines = lines.slice(-this.maxLineBuffer);
+                }
+                resolve({
+                    lines: keptLines,
+                    totalLines,
+                    truncated,
+                    exitCode: code ?? -1,
+                });
+            });
+        });
+    }
+}

package/dist/watcher/sources/docker.d.ts

@@ -0,0 +1,28 @@
+import { Logger } from '../../utils/logger.js';
+import type { DockerSourceConfig, LogEvent, LogSource } from './types.js';
+type LoggerLike = Pick<Logger, 'warn' | 'info' | 'debug' | 'error'>;
+type DockerSourceOptions = {
+    logger?: LoggerLike;
+    dockerCommand?: string;
+};
+export declare class DockerSource implements LogSource {
+    private readonly config;
+    private readonly logger;
+    private readonly emitter;
+    private readonly dockerCommand;
+    private child;
+    private reconnectTimer;
+    private stopRequested;
+    private backoffMs;
+    private partialLine;
+    private lastCheckpoint;
+    constructor(config: DockerSourceConfig, options?: DockerSourceOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    on(event: 'line', handler: (event: LogEvent) => void): void;
+    private connect;
+    private scheduleReconnect;
+    private processChunk;
+    private handleLine;
+}
+export {};

package/dist/watcher/sources/docker.js

@@ -0,0 +1,183 @@
+import { EventEmitter } from 'node:events';
+import { spawn } from 'node:child_process';
+import { Logger } from '../../utils/logger.js';
+const BACKOFF_INITIAL_MS = 1000;
+const BACKOFF_MAX_MS = 60_000;
+const KILL_GRACE_MS = 5000;
+const DOCKER_TIMESTAMP = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})(\.\d+)?Z$/;
+const normalizeDockerTimestamp = (value) => {
+    const match = value.match(DOCKER_TIMESTAMP);
+    if (!match) {
+        return null;
+    }
+    const base = match[1];
+    const fraction = match[2];
+    if (!fraction) {
+        return `${base}Z`;
+    }
+    let digits = fraction.slice(1);
+    if (digits.length > 3) {
+        digits = digits.slice(0, 3);
+    }
+    else if (digits.length < 3) {
+        digits = digits.padEnd(3, '0');
+    }
+    return `${base}.${digits}Z`;
+};
+const parseDockerLine = (line) => {
+    const trimmed = line.trimEnd();
+    if (!trimmed) {
+        return null;
+    }
+    const spaceIndex = trimmed.indexOf(' ');
+    if (spaceIndex <= 0) {
+        return null;
+    }
+    const rawTimestamp = trimmed.slice(0, spaceIndex);
+    const message = trimmed.slice(spaceIndex + 1);
+    const normalized = normalizeDockerTimestamp(rawTimestamp);
+    if (!normalized) {
+        return null;
+    }
+    const timestamp = new Date(normalized);
+    if (Number.isNaN(timestamp.getTime())) {
+        return null;
+    }
+    return { timestamp, message, checkpoint: normalized };
+};
+export class DockerSource {
+    config;
+    logger;
+    emitter;
+    dockerCommand;
+    child = null;
+    reconnectTimer = null;
+    stopRequested = false;
+    backoffMs = BACKOFF_INITIAL_MS;
+    partialLine = '';
+    lastCheckpoint = null;
+    constructor(config, options) {
+        this.config = config;
+        this.logger =
+            options?.logger ?? new Logger({ terminalEnabled: false, verbosity: 'normal' });
+        this.emitter = new EventEmitter();
+        this.dockerCommand = options?.dockerCommand ?? 'docker';
+    }
+    async start() {
+        if (this.child || this.reconnectTimer) {
+            return;
+        }
+        this.stopRequested = false;
+        this.connect();
+    }
+    async stop() {
+        this.stopRequested = true;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.child) {
+            const child = this.child;
+            this.child = null;
+            child.kill('SIGTERM');
+            const killTimer = setTimeout(() => {
+                if (child.exitCode === null && child.signalCode === null) {
+                    child.kill('SIGKILL');
+                }
+            }, KILL_GRACE_MS);
+            child.once('close', () => clearTimeout(killTimer));
+        }
+    }
+    on(event, handler) {
+        this.emitter.on(event, handler);
+    }
+    connect() {
+        const args = ['logs', '-f', '--timestamps'];
+        if (this.lastCheckpoint) {
+            args.push(`--since=${this.lastCheckpoint}`);
+        }
+        args.push(this.config.container);
+        this.logger.info(`Connecting to docker logs for ${this.config.container} (since=${this.lastCheckpoint ?? 'beginning'})`);
+        const child = spawn(this.dockerCommand, args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        this.child = child;
+        this.partialLine = '';
+        if (child.stdout) {
+            child.stdout.on('data', (data) => {
+                this.processChunk(String(data));
+            });
+        }
+        else {
+            this.logger.warn('Docker logs stdout stream unavailable');
+        }
+        if (child.stderr) {
+            child.stderr.on('data', (data) => {
+                const text = String(data).trim();
+                if (text) {
+                    this.logger.warn(`Docker logs stderr: ${text}`);
+                }
+            });
+        }
+        child.on('close', (code, signal) => {
+            if (this.child === child) {
+                this.child = null;
+            }
+            if (this.stopRequested) {
+                return;
+            }
+            this.logger.warn(`Docker logs exited for ${this.config.container} (code=${code ?? 'n/a'}, signal=${signal ?? 'n/a'})`);
+            this.scheduleReconnect();
+        });
+        child.on('error', (error) => {
+            if (this.child === child) {
+                this.child = null;
+            }
+            if (this.stopRequested) {
+                return;
+            }
+            this.logger.error(`Docker logs error for ${this.config.container}: ${error.message}`);
+            this.scheduleReconnect();
+        });
+    }
+    scheduleReconnect() {
+        if (this.reconnectTimer || this.stopRequested) {
+            return;
+        }
+        const delay = this.backoffMs;
+        this.backoffMs = Math.min(this.backoffMs * 2, BACKOFF_MAX_MS);
+        this.logger.info(`Reconnecting to docker logs for ${this.config.container} in ${delay}ms`);
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            if (!this.stopRequested) {
+                this.connect();
+            }
+        }, delay);
+    }
+    processChunk(chunk) {
+        const combined = `${this.partialLine}${chunk}`;
+        const lines = combined.split('\n');
+        this.partialLine = lines.pop() ?? '';
+        for (const rawLine of lines) {
+            this.handleLine(rawLine.replace(/\r$/, ''));
+        }
+    }
+    handleLine(line) {
+        const parsed = parseDockerLine(line);
+        if (parsed) {
+            this.lastCheckpoint = parsed.checkpoint;
+            this.backoffMs = BACKOFF_INITIAL_MS;
+            this.emitter.emit('line', {
+                source: this.config.name,
+                line: parsed.message,
+                timestamp: parsed.timestamp,
+            });
+            return;
+        }
+        this.emitter.emit('line', {
+            source: this.config.name,
+            line,
+            timestamp: new Date(),
+        });
+    }
+}

package/dist/watcher/sources/file.d.ts

@@ -0,0 +1,30 @@
+import { Logger } from '../../utils/logger.js';
+import type { FileSourceConfig, LogEvent, LogSource } from './types.js';
+type LoggerLike = Pick<Logger, 'warn' | 'info' | 'debug' | 'error'>;
+type FileSourceOptions = {
+    logger?: LoggerLike;
+};
+export declare class FileSource implements LogSource {
+    private readonly config;
+    private readonly filePath;
+    private readonly logger;
+    private readonly emitter;
+    private watcher;
+    private position;
+    private partialLine;
+    private reading;
+    private queued;
+    private pollTimer;
+    private lastMtimeMs;
+    private lastInode;
+    private forceRead;
+    constructor(config: FileSourceConfig, options?: FileSourceOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    on(event: 'line', handler: (event: LogEvent) => void): void;
+    private queueRead;
+    private readLoop;
+    private readNewLines;
+    private processChunk;
+}
+export {};

package/dist/watcher/sources/file.js

@@ -0,0 +1,177 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { EventEmitter } from 'node:events';
+import chokidar from 'chokidar';
+import { Logger } from '../../utils/logger.js';
+export class FileSource {
+    config;
+    filePath;
+    logger;
+    emitter;
+    watcher = null;
+    position = 0;
+    partialLine = '';
+    reading = false;
+    queued = false;
+    pollTimer = null;
+    lastMtimeMs = null;
+    lastInode = null;
+    forceRead = false;
+    constructor(config, options) {
+        this.config = config;
+        this.filePath = path.resolve(config.path);
+        this.logger =
+            options?.logger ?? new Logger({ terminalEnabled: false, verbosity: 'normal' });
+        this.emitter = new EventEmitter();
+    }
+    async start() {
+        if (this.watcher) {
+            return;
+        }
+        const exists = fs.existsSync(this.filePath);
+        if (exists) {
+            const stats = fs.statSync(this.filePath);
+            const now = Date.now();
+            const RECENT_WINDOW_MS = 1000;
+            const STARTUP_READ_MAX_BYTES = 64 * 1024;
+            const recentWrite = now - stats.mtimeMs <= RECENT_WINDOW_MS;
+            const readFromStart = stats.size > 0 && stats.size <= STARTUP_READ_MAX_BYTES && recentWrite;
+            this.position = readFromStart ? 0 : stats.size;
+            this.lastMtimeMs = stats.mtimeMs;
+            this.lastInode = typeof stats.ino === 'number' ? stats.ino : null;
+        }
+        else {
+            this.position = 0;
+            this.logger.warn(`Log file not found: ${this.filePath}. Waiting for creation.`);
+        }
+        const targets = exists
+            ? [this.filePath]
+            : [this.filePath, path.dirname(this.filePath)];
+        this.watcher = chokidar.watch(targets, {
+            ignoreInitial: true,
+            usePolling: true,
+            interval: 100,
+        });
+        const watcher = this.watcher;
+        const readyPromise = new Promise((resolve, reject) => {
+            watcher.once('ready', () => resolve());
+            watcher.once('error', (error) => reject(error));
+        });
+        watcher.on('add', (eventPath) => {
+            if (path.resolve(eventPath) !== this.filePath) {
+                return;
+            }
+            this.queueRead(true);
+        });
+        watcher.on('change', (eventPath) => {
+            if (path.resolve(eventPath) !== this.filePath) {
+                return;
+            }
+            this.queueRead(true);
+        });
+        await readyPromise;
+        this.pollTimer = setInterval(() => this.queueRead(), 200);
+    }
+    async stop() {
+        if (!this.watcher) {
+            return;
+        }
+        await this.watcher.close();
+        this.watcher = null;
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+        }
+    }
+    on(event, handler) {
+        this.emitter.on(event, handler);
+    }
+    queueRead(force = false) {
+        if (force) {
+            this.forceRead = true;
+        }
+        if (this.reading) {
+            this.queued = true;
+            return;
+        }
+        this.reading = true;
+        void this.readLoop();
+    }
+    async readLoop() {
+        try {
+            do {
+                this.queued = false;
+                await this.readNewLines();
+            } while (this.queued);
+        }
+        finally {
+            this.reading = false;
+        }
+    }
+    async readNewLines() {
+        let stats = null;
+        try {
+            stats = await fs.promises.stat(this.filePath);
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === 'ENOENT') {
+                return;
+            }
+            throw error;
+        }
+        if (!stats) {
+            return;
+        }
+        const inode = typeof stats.ino === 'number' ? stats.ino : null;
+        const mtimeMs = stats.mtimeMs;
+        const shouldForceRead = this.forceRead;
+        this.forceRead = false;
+        const inodeChanged = this.lastInode !== null && inode !== null && inode !== this.lastInode;
+        const mtimeChanged = this.lastMtimeMs !== null && mtimeMs !== this.lastMtimeMs;
+        if (inodeChanged ||
+            stats.size < this.position ||
+            (shouldForceRead && stats.size === this.position && this.position > 0) ||
+            (mtimeChanged && stats.size === this.position && this.position > 0)) {
+            this.position = 0;
+            this.partialLine = '';
+        }
+        if (stats.size === this.position) {
+            this.lastMtimeMs = mtimeMs;
+            this.lastInode = inode;
+            return;
+        }
+        const length = stats.size - this.position;
+        const handle = await fs.promises.open(this.filePath, 'r');
+        try {
+            const buffer = Buffer.alloc(length);
+            const { bytesRead } = await handle.read(buffer, 0, length, this.position);
+            if (bytesRead <= 0) {
+                this.lastMtimeMs = mtimeMs;
+                this.lastInode = inode;
+                return;
+            }
+            this.position += bytesRead;
+            const chunk = buffer.toString('utf8', 0, bytesRead);
+            this.processChunk(chunk);
+            this.lastMtimeMs = mtimeMs;
+            this.lastInode = inode;
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    processChunk(chunk) {
+        const combined = `${this.partialLine}${chunk}`;
+        const lines = combined.split('\n');
+        this.partialLine = lines.pop() ?? '';
+        for (const rawLine of lines) {
+            const line = rawLine.replace(/\r$/, '');
+            this.emitter.emit('line', {
+                source: this.config.name,
+                line,
+                timestamp: new Date(),
+            });
+        }
+    }
+}