@adhdev/daemon-core 0.5.3

package/src/logging/logger.ts

@@ -0,0 +1,316 @@
+/**
+ * ADHDev Daemon — unified logger (v2)
+ * 
+ * log level: DEBUG < INFO < WARN < ERROR
+ * 
+ * Features:
+ * 1. daemonLog(category, msg, level) — explicit per-category logging
+ * 2. installGlobalInterceptor() — Auto-intercept console.log (once on daemon start)
+ * 3. Recent log ring buffer — for remote transmission via P2P/WS
+ * 4. File logging — ~/Library/Logs/adhdev/daemon.log (10MB rolling)
+ * 
+ * use:
+ * import { daemonLog, LOG } from './daemon-logger';
+ * LOG.info('CDP', 'Connected to cursor on port 9333');
+ * LOG.debug('StatusReport', 'P2P heartbeat sent');
+ * LOG.warn('IdeInstance', 'onTick error: ...');
+ * LOG.error('Server', 'WebSocket disconnected');
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+// ─── Log Level ──────────────────────────────
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+
+const LEVEL_NUM: Record<LogLevel, number> = { debug: 0, info: 1, warn: 2, error: 3 };
+const LEVEL_LABEL: Record<LogLevel, string> = { debug: 'DBG', info: 'INF', warn: 'WRN', error: 'ERR' };
+
+let currentLevel: LogLevel = 'info';
+
+export function setLogLevel(level: LogLevel): void {
+    currentLevel = level;
+    daemonLog('Logger', `Log level set to: ${level}`, 'info');
+}
+
+export function getLogLevel(): LogLevel { return currentLevel; }
+// ─── File logging (date-based rolling) ──────────────────────────────
+const LOG_DIR = process.platform === 'darwin'
+    ? path.join(os.homedir(), 'Library', 'Logs', 'adhdev')
+    : path.join(os.homedir(), '.local', 'share', 'adhdev', 'logs');
+
+const MAX_LOG_SIZE = 5 * 1024 * 1024; // 5MB per day
+const MAX_LOG_DAYS = 7; // 7-day retention
+
+try { fs.mkdirSync(LOG_DIR, { recursive: true }); } catch { }
+
+function getDateStr(): string {
+    return new Date().toISOString().slice(0, 10); // YYYY-MM-DD
+}
+
+let currentDate = getDateStr();
+let currentLogFile = path.join(LOG_DIR, `daemon-${currentDate}.log`);
+
+/** date change detect + old file cleanup */
+function checkDateRotation(): void {
+    const today = getDateStr();
+    if (today !== currentDate) {
+        currentDate = today;
+        currentLogFile = path.join(LOG_DIR, `daemon-${currentDate}.log`);
+        cleanOldLogs();
+    }
+}
+
+/** Auto-delete log files older than MAX_LOG_DAYS */
+function cleanOldLogs(): void {
+    try {
+        const files = fs.readdirSync(LOG_DIR).filter(f => f.startsWith('daemon-') && f.endsWith('.log'));
+        const cutoff = new Date();
+        cutoff.setDate(cutoff.getDate() - MAX_LOG_DAYS);
+        const cutoffStr = cutoff.toISOString().slice(0, 10);
+        for (const file of files) {
+            const dateMatch = file.match(/daemon-(\d{4}-\d{2}-\d{2})/);
+            if (dateMatch && dateMatch[1] < cutoffStr) {
+                try { fs.unlinkSync(path.join(LOG_DIR, file)); } catch { }
+            }
+        }
+    } catch { }
+}
+
+/** Roll to .1 file when size limit reached within same date */
+function rotateSizeIfNeeded(): void {
+    try {
+        const stat = fs.statSync(currentLogFile);
+        if (stat.size > MAX_LOG_SIZE) {
+            const backup = currentLogFile.replace('.log', '.1.log');
+            try { fs.unlinkSync(backup); } catch { }
+            fs.renameSync(currentLogFile, backup);
+        }
+    } catch { /* file doesn't exist yet */ }
+}
+
+// start when cleanup
+cleanOldLogs();
+// Migrate existing daemon.log, daemon.log.old (if present)
+try {
+    const oldLog = path.join(LOG_DIR, 'daemon.log');
+    if (fs.existsSync(oldLog)) {
+        const stat = fs.statSync(oldLog);
+        const oldDate = stat.mtime.toISOString().slice(0, 10);
+        fs.renameSync(oldLog, path.join(LOG_DIR, `daemon-${oldDate}.log`));
+    }
+    const oldLogBackup = path.join(LOG_DIR, 'daemon.log.old');
+    if (fs.existsSync(oldLogBackup)) { fs.unlinkSync(oldLogBackup); }
+} catch { }
+
+let writeCount = 0;
+
+function writeToFile(line: string): void {
+    try {
+ // Check date change + file size every 1000 writes
+        if (++writeCount % 1000 === 0) {
+            checkDateRotation();
+            rotateSizeIfNeeded();
+        }
+        fs.appendFileSync(currentLogFile, line + '\n');
+    } catch { }
+}
+
+// ─── Ring buffer (for remote transmission) ─────────────────
+export interface LogEntry {
+    ts: number;
+    level: LogLevel;
+    category: string;
+    message: string;
+}
+
+const RING_BUFFER_SIZE = 200;
+const ringBuffer: LogEntry[] = [];
+
+/** Get recent N logs (for remote transmission) */
+export function getRecentLogs(count = 50, minLevel: LogLevel = 'info'): LogEntry[] {
+    const minNum = LEVEL_NUM[minLevel];
+    const filtered = ringBuffer.filter(e => LEVEL_NUM[e.level] >= minNum);
+    return filtered.slice(-count);
+}
+
+/** Ring buffer current size */
+export function getLogBufferSize(): number { return ringBuffer.length; }
+
+// ─── Timestamp ─────────────────────────────
+function ts(): string {
+    return new Date().toISOString().slice(11, 23); // HH:mm:ss.SSS
+}
+
+function fullTs(): string {
+    return new Date().toISOString();
+}
+
+// ─── Preserve original console ──────────────────────
+const origConsoleLog = console.log.bind(console);
+const origConsoleError = console.error.bind(console);
+const origConsoleWarn = console.warn.bind(console);
+
+// ─── Core logging function ─────────────────────────
+
+/**
+ * Explicit per-category logging
+ * level filter apply, File logging, Ring buffer save
+ */
+export function daemonLog(category: string, msg: string, level: LogLevel = 'info'): void {
+ // Level filter (console output)
+    const shouldOutput = LEVEL_NUM[level] >= LEVEL_NUM[currentLevel];
+
+    const label = LEVEL_LABEL[level];
+    const line = `[${ts()}] [${label}] [${category}] ${msg}`;
+
+ // Always record to file (including DEBUG)
+    writeToFile(line);
+
+ // Always save to ring buffer (for remote transmission)
+    ringBuffer.push({ ts: Date.now(), level, category, message: msg });
+    if (ringBuffer.length > RING_BUFFER_SIZE) {
+        ringBuffer.splice(0, ringBuffer.length - RING_BUFFER_SIZE);
+    }
+
+ // Apply filter to console output
+    if (shouldOutput) {
+        origConsoleLog(line);
+    }
+}
+
+// ─── Convenience API ────────────────────────────────
+
+/**
+ * Scoped logger instance for a specific component.
+ * Created via LOG.forComponent('CDP:cursor').
+ */
+export interface ScopedLogger {
+    debug: (msg: string) => void;
+    info: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+    /** Returns a plain (msg: string) => void function at the given level.
+     *  Useful as logFn callback for ProviderLoader, DaemonStatusReporter, etc. */
+    asLogFn: (level?: LogLevel) => (msg: string) => void;
+}
+
+/**
+ * LOG — unified logging API
+ *
+ * Usage:
+ *   LOG.info('CDP', 'Connected to cursor on port 9333');
+ *   LOG.debug('StatusReport', 'P2P heartbeat sent');
+ *
+ * Component-scoped logger:
+ *   const log = LOG.forComponent('ACP:cursor');
+ *   log.info('Session created');
+ *   log.debug('Heartbeat');
+ *
+ * As callback for external components:
+ *   new ProviderLoader({ logFn: LOG.forComponent('Provider').asLogFn() });
+ *   new DaemonStatusReporter({ logFn: LOG.forComponent('Status').asLogFn() });
+ */
+export const LOG = {
+    debug: (category: string, msg: string) => daemonLog(category, msg, 'debug'),
+    info: (category: string, msg: string) => daemonLog(category, msg, 'info'),
+    warn: (category: string, msg: string) => daemonLog(category, msg, 'warn'),
+    error: (category: string, msg: string) => daemonLog(category, msg, 'error'),
+
+    /**
+     * Create a scoped logger for a specific component.
+     * Category is baked in so callers only pass the message.
+     */
+    forComponent(category: string): ScopedLogger {
+        return {
+            debug: (msg: string) => daemonLog(category, msg, 'debug'),
+            info: (msg: string) => daemonLog(category, msg, 'info'),
+            warn: (msg: string) => daemonLog(category, msg, 'warn'),
+            error: (msg: string) => daemonLog(category, msg, 'error'),
+            asLogFn: (level: LogLevel = 'info') => (msg: string) => daemonLog(category, msg, level),
+        };
+    },
+};
+
+// ─── global interceptor ────────────────────────
+
+let interceptorInstalled = false;
+
+/**
+ * console.log/warn/error global interceptor install
+ * Prevent recording in places not using daemonLog.
+ * daemon start when 1time call.
+ */
+export function installGlobalInterceptor(): void {
+    if (interceptorInstalled) return;
+    interceptorInstalled = true;
+
+    const stripAnsi = (str: string) => str.replace(/\x1B\[[0-9;]*m/g, '');
+
+ // Ignore lines already recorded via daemonLog (prevent duplicates)
+    const isDaemonLogLine = (msg: string) => /\[(DBG|INF|WRN|ERR)\]/.test(msg);
+
+    console.log = (...args: any[]) => {
+        origConsoleLog(...args);
+        try {
+            const msg = args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ');
+            const clean = stripAnsi(msg);
+ // Skip lines not yet recorded via daemonLog
+            if (isDaemonLogLine(clean)) return;
+            const line = clean.startsWith('[20') ? clean : `[${fullTs()}] ${clean}`;
+            writeToFile(line);
+ // Also save to ring buffer (auto-detect category)
+            const catMatch = clean.match(/\[([^\]]+)\]/);
+            ringBuffer.push({
+                ts: Date.now(),
+                level: 'info',
+                category: catMatch?.[1] || 'System',
+                message: clean,
+            });
+            if (ringBuffer.length > RING_BUFFER_SIZE) {
+                ringBuffer.splice(0, ringBuffer.length - RING_BUFFER_SIZE);
+            }
+        } catch { }
+    };
+
+    console.error = (...args: any[]) => {
+        origConsoleError(...args);
+        try {
+            const msg = args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ');
+            const clean = stripAnsi(msg);
+            if (isDaemonLogLine(clean)) return;
+            const line = `[${fullTs()}] [ERROR] ${clean}`;
+            writeToFile(line);
+            ringBuffer.push({ ts: Date.now(), level: 'error', category: 'System', message: clean });
+            if (ringBuffer.length > RING_BUFFER_SIZE) {
+                ringBuffer.splice(0, ringBuffer.length - RING_BUFFER_SIZE);
+            }
+        } catch { }
+    };
+
+    console.warn = (...args: any[]) => {
+        origConsoleWarn(...args);
+        try {
+            const msg = args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ');
+            const clean = stripAnsi(msg);
+            if (isDaemonLogLine(clean)) return;
+            const line = `[${fullTs()}] [WARN] ${clean}`;
+            writeToFile(line);
+            ringBuffer.push({ ts: Date.now(), level: 'warn', category: 'System', message: clean });
+            if (ringBuffer.length > RING_BUFFER_SIZE) {
+                ringBuffer.splice(0, ringBuffer.length - RING_BUFFER_SIZE);
+            }
+        } catch { }
+    };
+
+    writeToFile(`\n=== ADHDev Daemon started at ${fullTs()} ===`);
+    writeToFile(`Log file: ${currentLogFile}`);
+    writeToFile(`Log level: ${currentLevel}`);
+}
+
+/** current log file path (dateper) */
+export function getLogPath(): string { return currentLogFile; }
+/** LOG_PATH — backward compat (current date file) */
+export const LOG_PATH = path.join(LOG_DIR, `daemon-${getDateStr()}.log`);
+export const LOG_DIR_PATH = LOG_DIR;