salmon-loop 0.2.3

package/dist/core/observability/logger.js

@@ -0,0 +1,457 @@
+import chalk from 'chalk';
+import { FileAdapter } from '../adapters/fs/index.js';
+import { sanitizeObject, sanitizeErrorMessage } from '../utils/sanitizer.js';
+import { recordAuditEvent } from './audit-trail.js';
+import { mapErrorForDisplay } from './error-mapping.js';
+/**
+ * Standard Console Reporter
+ */
+export class ConsoleReporter {
+    verboseLevel;
+    constructor(verboseLevel = 'none') {
+        this.verboseLevel = verboseLevel;
+    }
+    setVerbose(level) {
+        this.verboseLevel = level;
+    }
+    get isBasic() {
+        return this.verboseLevel === 'basic' || this.verboseLevel === 'extended';
+    }
+    get isExtended() {
+        return this.verboseLevel === 'extended';
+    }
+    log(level, message, metadata) {
+        const safeMessage = mapErrorForDisplay({
+            message,
+            code: metadata?.code,
+        }).message;
+        switch (level) {
+            case 'info':
+            case 'log':
+            case 'bold':
+                console.log(level === 'bold' ? chalk.bold(safeMessage) : safeMessage);
+                break;
+            case 'success':
+                console.log(chalk.green(safeMessage));
+                break;
+            case 'warn':
+            case 'degraded':
+                console.warn(level === 'degraded'
+                    ? chalk.magenta(`[DEGRADED] ${safeMessage}`)
+                    : chalk.yellow(safeMessage));
+                break;
+            case 'error':
+                console.error(chalk.red(safeMessage));
+                break;
+            case 'debug':
+                if (this.isBasic)
+                    console.log(chalk.gray(safeMessage));
+                break;
+            case 'trace':
+                if (this.isExtended)
+                    console.log(chalk.gray(safeMessage));
+                break;
+            case 'cyan':
+                console.log(chalk.cyan(safeMessage));
+                break;
+            case 'dim':
+                console.log(chalk.dim(safeMessage));
+                break;
+            case 'step':
+                if (this.isBasic) {
+                    const phase = metadata?.phase || 'STEP';
+                    console.log(chalk.blue(`\n[${phase.toUpperCase()}] `) + safeMessage);
+                }
+                break;
+            case 'audit': {
+                const timestamp = new Date().toISOString();
+                console.log(chalk.bgBlue.white(`[AUDIT] ${timestamp} - ${safeMessage}`));
+                break;
+            }
+        }
+    }
+    clear() {
+        console.clear();
+    }
+}
+/**
+ * Stderr-only reporter for protocols that reserve stdout (e.g., ACP stdio).
+ */
+export class StderrReporter {
+    verboseLevel;
+    constructor(verboseLevel = 'none') {
+        this.verboseLevel = verboseLevel;
+    }
+    setVerbose(level) {
+        this.verboseLevel = level;
+    }
+    get isBasic() {
+        return this.verboseLevel === 'basic' || this.verboseLevel === 'extended';
+    }
+    get isExtended() {
+        return this.verboseLevel === 'extended';
+    }
+    log(level, message, metadata) {
+        const safeMessage = mapErrorForDisplay({
+            message,
+            code: metadata?.code,
+        }).message;
+        switch (level) {
+            case 'info':
+            case 'log':
+            case 'bold':
+                console.error(level === 'bold' ? chalk.bold(safeMessage) : safeMessage);
+                break;
+            case 'success':
+                console.error(chalk.green(safeMessage));
+                break;
+            case 'warn':
+            case 'degraded':
+                console.error(level === 'degraded'
+                    ? chalk.magenta(`[DEGRADED] ${safeMessage}`)
+                    : chalk.yellow(safeMessage));
+                break;
+            case 'error':
+                console.error(chalk.red(safeMessage));
+                break;
+            case 'debug':
+                if (this.isBasic)
+                    console.error(chalk.gray(safeMessage));
+                break;
+            case 'trace':
+                if (this.isExtended)
+                    console.error(chalk.gray(safeMessage));
+                break;
+            case 'cyan':
+                console.error(chalk.cyan(safeMessage));
+                break;
+            case 'dim':
+                console.error(chalk.dim(safeMessage));
+                break;
+            case 'step':
+                if (this.isBasic) {
+                    const phase = metadata?.phase || 'STEP';
+                    console.error(chalk.blue(`\n[${phase.toUpperCase()}] `) + safeMessage);
+                }
+                break;
+            case 'audit': {
+                const timestamp = new Date().toISOString();
+                console.error(chalk.bgBlue.white(`[AUDIT] ${timestamp} - ${safeMessage}`));
+                break;
+            }
+        }
+    }
+    clear() {
+        // No-op: stderr cannot be cleared reliably without side effects.
+    }
+}
+/**
+ * Plain text reporter without colors for environments where ANSI colors should be disabled.
+ */
+export class PlainReporter {
+    verboseLevel;
+    constructor(verboseLevel = 'none') {
+        this.verboseLevel = verboseLevel;
+    }
+    setVerbose(level) {
+        this.verboseLevel = level;
+    }
+    get isBasic() {
+        return this.verboseLevel === 'basic' || this.verboseLevel === 'extended';
+    }
+    get isExtended() {
+        return this.verboseLevel === 'extended';
+    }
+    log(level, message, metadata) {
+        const safeMessage = mapErrorForDisplay({
+            message,
+            code: metadata?.code,
+        }).message;
+        const writeLine = (line) => {
+            console.error(line);
+        };
+        switch (level) {
+            case 'info':
+            case 'log':
+            case 'bold':
+                writeLine(safeMessage);
+                break;
+            case 'success':
+                writeLine(safeMessage);
+                break;
+            case 'warn':
+            case 'degraded':
+                writeLine(level === 'degraded' ? `[DEGRADED] ${safeMessage}` : safeMessage);
+                break;
+            case 'error':
+                writeLine(safeMessage);
+                break;
+            case 'debug':
+                if (this.isBasic)
+                    writeLine(safeMessage);
+                break;
+            case 'trace':
+                if (this.isExtended)
+                    writeLine(safeMessage);
+                break;
+            case 'cyan':
+                writeLine(safeMessage);
+                break;
+            case 'dim':
+                writeLine(safeMessage);
+                break;
+            case 'step':
+                if (this.isBasic) {
+                    const phase = metadata?.phase || 'STEP';
+                    writeLine(`\n[${phase.toUpperCase()}] ${safeMessage}`);
+                }
+                break;
+            case 'audit': {
+                const timestamp = new Date().toISOString();
+                writeLine(`[AUDIT] ${timestamp} - ${safeMessage}`);
+                break;
+            }
+        }
+    }
+    clear() {
+        // No-op: stderr cannot be cleared reliably without side effects.
+    }
+}
+export class Logger {
+    verboseLevel = 'none';
+    prefix;
+    logFile;
+    silent = false;
+    fileAdapter = new FileAdapter();
+    logQueue = [];
+    isFlushing = false;
+    reporter;
+    constructor(options) {
+        this.setVerbose(options?.verbose);
+        this.prefix = options?.prefix ?? '';
+        this.logFile = options?.logFile;
+        this.silent = options?.silent ?? false;
+        this.reporter = new ConsoleReporter(this.verboseLevel);
+    }
+    setReporter(reporter) {
+        this.reporter = reporter;
+    }
+    getReporter() {
+        return this.reporter;
+    }
+    setVerbose(level) {
+        if (level === true) {
+            this.verboseLevel = 'basic';
+        }
+        else if (level === false || level === undefined) {
+            this.verboseLevel = 'none';
+        }
+        else {
+            this.verboseLevel = level;
+        }
+        const maybeVerbose = this.reporter;
+        if (typeof maybeVerbose?.setVerbose === 'function') {
+            maybeVerbose.setVerbose(this.verboseLevel);
+        }
+    }
+    setPrefix(prefix) {
+        this.prefix = prefix;
+    }
+    setSilent(silent) {
+        this.silent = silent;
+    }
+    getSilent() {
+        return this.silent;
+    }
+    setLogFile(path) {
+        this.logFile = path;
+    }
+    get isBasic() {
+        return this.verboseLevel === 'basic' || this.verboseLevel === 'extended';
+    }
+    get isExtended() {
+        return this.verboseLevel === 'extended';
+    }
+    formatMessage(message) {
+        return this.prefix ? `${this.prefix} ${message}` : message;
+    }
+    writeToLog(level, message) {
+        if (this.logFile) {
+            const timestamp = new Date().toISOString();
+            // eslint-disable-next-line no-control-regex
+            const cleanMessage = message.replace(/\x1b\[[0-9;]*m/g, ''); // Remove ANSI colors
+            this.logQueue.push(`[${timestamp}] [${level.toUpperCase()}] ${cleanMessage}\n`);
+            this.scheduleFlush();
+        }
+    }
+    async scheduleFlush() {
+        if (this.isFlushing || this.logQueue.length === 0 || !this.logFile) {
+            return;
+        }
+        this.isFlushing = true;
+        const contentToFlush = [...this.logQueue];
+        try {
+            const content = contentToFlush.join('');
+            await this.fileAdapter.appendFile(this.logFile, content);
+            // Only remove from queue if write was successful
+            this.logQueue.splice(0, contentToFlush.length);
+        }
+        catch {
+            // Keep logs in queue for next retry
+        }
+        finally {
+            this.isFlushing = false;
+            if (this.logQueue.length > 0) {
+                this.scheduleFlush();
+            }
+        }
+    }
+    /**
+     * Manually flush all pending logs to disk
+     */
+    async flush() {
+        if (!this.logFile || this.logQueue.length === 0)
+            return;
+        // If already flushing, wait for it or trigger another one
+        while (this.isFlushing) {
+            await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+        await this.scheduleFlush();
+    }
+    info(message) {
+        const formatted = this.formatMessage(message);
+        this.writeToLog('info', formatted);
+        if (!this.silent)
+            this.reporter.log('info', formatted);
+    }
+    success(message) {
+        const formatted = this.formatMessage(message);
+        this.writeToLog('success', formatted);
+        if (!this.silent)
+            this.reporter.log('success', formatted);
+    }
+    warn(message) {
+        const formatted = this.formatMessage(message);
+        this.writeToLog('warn', formatted);
+        if (!this.silent)
+            this.reporter.log('warn', formatted);
+    }
+    error(message, errorOrExit, maybeExit) {
+        let error;
+        let exit = false;
+        // Handle polymorphism for backward compatibility:
+        // Case 1: error(msg, exit)
+        if (typeof errorOrExit === 'boolean' && maybeExit === undefined) {
+            exit = errorOrExit;
+        }
+        // Case 2: error(msg, err, exit)
+        else {
+            error = errorOrExit;
+            exit = maybeExit ?? false;
+        }
+        const sanitizedMessage = this.sanitizeLogMessage(this.formatMessage(sanitizeErrorMessage(message)));
+        const sanitizedError = error ? sanitizeObject(error) : undefined;
+        this.writeToLog('error', sanitizedMessage + (sanitizedError ? ` | ${JSON.stringify(sanitizedError)}` : ''));
+        if (!this.silent) {
+            this.reporter.log('error', sanitizedMessage);
+            // Removed: console.error(sanitizedError) to prevent JSON leakage to UI
+        }
+        if (exit)
+            process.exit(1);
+    }
+    debug(message) {
+        const formatted = this.formatMessage(message);
+        this.writeToLog('debug', formatted);
+        if (!this.silent)
+            this.reporter.log('debug', formatted);
+    }
+    trace(message) {
+        const formatted = this.formatMessage(message);
+        this.writeToLog('trace', formatted);
+        if (!this.silent)
+            this.reporter.log('trace', formatted);
+    }
+    step(phase, message) {
+        const formatted = this.formatMessage(message);
+        this.writeToLog(`step:${phase}`, formatted);
+        if (!this.silent)
+            this.reporter.log('step', formatted, { phase });
+    }
+    cyan(message) {
+        const formatted = this.formatMessage(message);
+        this.writeToLog('cyan', formatted);
+        if (!this.silent)
+            this.reporter.log('cyan', formatted);
+    }
+    bold(message) {
+        const formatted = this.formatMessage(message);
+        this.writeToLog('bold', formatted);
+        if (!this.silent)
+            this.reporter.log('bold', formatted);
+    }
+    dim(message) {
+        const formatted = this.formatMessage(message);
+        this.writeToLog('dim', formatted);
+        if (!this.silent)
+            this.reporter.log('dim', formatted);
+    }
+    log(message) {
+        const formatted = this.formatMessage(message);
+        this.writeToLog('log', formatted);
+        if (!this.silent)
+            this.reporter.log('log', formatted);
+    }
+    degrade(message) {
+        const formatted = this.formatMessage(message);
+        this.writeToLog('degraded', formatted);
+        if (!this.silent)
+            this.reporter.log('degraded', formatted);
+    }
+    clear() {
+        if (!this.silent && this.reporter.clear)
+            this.reporter.clear();
+    }
+    audit(action, details, meta) {
+        const sanitizedDetails = sanitizeObject(details);
+        const rawMessage = `${action}: ${JSON.stringify(sanitizedDetails)}`;
+        const formatted = this.formatMessage(this.sanitizeLogMessage(rawMessage));
+        const auditMeta = typeof meta === 'string' ? { source: meta } : meta;
+        recordAuditEvent(action, sanitizedDetails, auditMeta);
+        this.writeToLog('audit', formatted);
+        if (!this.silent)
+            this.reporter.log('audit', formatted);
+    }
+    sanitizeLogMessage(message) {
+        let result = '';
+        for (let i = 0; i < message.length; i += 1) {
+            const code = message.charCodeAt(i);
+            if (code < 32 || code === 127) {
+                result += ' ';
+            }
+            else {
+                result += message[i];
+            }
+        }
+        return result;
+    }
+}
+export function createLogger(options) {
+    return new Logger(options);
+}
+let activeLogger = null;
+export function setLogger(next) {
+    activeLogger = next;
+}
+export function getLogger() {
+    if (!activeLogger) {
+        throw new Error('Logger is not initialized. Call setLogger(createLogger()) at startup.');
+    }
+    return activeLogger;
+}
+export function tryGetLogger() {
+    return activeLogger;
+}
+export function clearLogger() {
+    activeLogger = null;
+}
+//# sourceMappingURL=logger.js.map

package/dist/core/observability/loop-event-reporter.js

@@ -0,0 +1,46 @@
+import { mapErrorForDisplay } from './error-mapping.js';
+import { sanitizeUiLogMessage } from './ui-log-sanitize.js';
+function mapLevel(level) {
+    switch (level) {
+        case 'error':
+            return 'error';
+        case 'warn':
+        case 'degraded':
+            return 'warn';
+        case 'debug':
+            return 'debug';
+        case 'trace':
+            return 'trace';
+        // success/log/info/bold/cyan/dim/step/audit => info
+        default:
+            return 'info';
+    }
+}
+/**
+ * A GUI-safe reporter: emits structured `LoopEvent` log events without touching stdout/stderr.
+ * This avoids Ink console patching paths and enforces sanitization/limits at the core boundary.
+ */
+export class LoopEventReporter {
+    emit;
+    source;
+    constructor(emit, options) {
+        this.emit = emit;
+        this.source = options?.source ?? 'core.logger';
+    }
+    log(level, message) {
+        const mapped = mapLevel(level);
+        const sanitized = sanitizeUiLogMessage(message, mapped);
+        const finalMessage = mapErrorForDisplay({ message: sanitized }).message;
+        this.emit({
+            type: 'log',
+            level: mapped,
+            source: this.source,
+            message: finalMessage,
+            timestamp: new Date(),
+        });
+    }
+    clear() {
+        // No-op: GUI controls rendering.
+    }
+}
+//# sourceMappingURL=loop-event-reporter.js.map