preflight-mcp 0.1.0

package/dist/logging/logger.js

@@ -0,0 +1,311 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+    LogLevel[LogLevel["FATAL"] = 4] = "FATAL";
+})(LogLevel || (LogLevel = {}));
+export class StructuredLogger {
+    config;
+    logBuffer = [];
+    bufferSize = 1000;
+    flushInterval = 5000; // 5秒
+    flushTimer;
+    constructor(config = {}) {
+        this.config = {
+            level: LogLevel.INFO,
+            output: 'both',
+            maxFileSize: 10, // 10MB
+            maxFiles: 5,
+            enableColors: true,
+            enableTimestamp: true,
+            enableMetadata: true,
+            enableStackTrace: true,
+            format: 'text',
+            ...config
+        };
+        this.startFlushTimer();
+    }
+    startFlushTimer() {
+        this.flushTimer = setInterval(() => {
+            this.flush().catch(error => {
+                console.error('Failed to flush logs:', error);
+            });
+        }, this.flushInterval);
+        // Don't keep the process alive just for log flushing (important for tests/CLI runs).
+        this.flushTimer.unref?.();
+    }
+    async flush() {
+        if (this.logBuffer.length === 0) {
+            return;
+        }
+        const entries = [...this.logBuffer];
+        this.logBuffer = [];
+        if (this.config.output === 'file' || this.config.output === 'both') {
+            await this.writeToFile(entries);
+        }
+        if (this.config.output === 'console' || this.config.output === 'both') {
+            this.writeToConsole(entries);
+        }
+    }
+    async writeToFile(entries) {
+        if (!this.config.filePath) {
+            return;
+        }
+        try {
+            // Ensure log directory exists
+            const logDir = path.dirname(this.config.filePath);
+            await fs.mkdir(logDir, { recursive: true });
+            // Check file size and rotate if over limit
+            await this.rotateLogFile();
+            // Write log entries
+            const logLines = entries.map(entry => this.formatLogEntry(entry, 'json'));
+            await fs.appendFile(this.config.filePath, logLines.join('\n') + '\n');
+        }
+        catch (error) {
+            console.error('Failed to write logs to file:', error);
+        }
+    }
+    async rotateLogFile() {
+        if (!this.config.filePath) {
+            return;
+        }
+        try {
+            const stats = await fs.stat(this.config.filePath);
+            const maxSizeBytes = (this.config.maxFileSize || 10) * 1024 * 1024;
+            if (stats.size > maxSizeBytes) {
+                // Rotate log file
+                const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+                const rotatedPath = `${this.config.filePath}.${timestamp}`;
+                await fs.rename(this.config.filePath, rotatedPath);
+                // Cleanup old log files
+                await this.cleanupOldLogFiles();
+            }
+        }
+        catch (error) {
+            // File doesn't exist or other error, ignore
+        }
+    }
+    async cleanupOldLogFiles() {
+        if (!this.config.filePath) {
+            return;
+        }
+        try {
+            const logDir = path.dirname(this.config.filePath);
+            const logName = path.basename(this.config.filePath);
+            const files = await fs.readdir(logDir);
+            // Get file info and sort by mtime
+            const logFilesWithMtime = [];
+            for (const file of files) {
+                if (file.startsWith(logName) && file !== logName) {
+                    const filePath = path.join(logDir, file);
+                    try {
+                        const stats = await fs.stat(filePath);
+                        logFilesWithMtime.push({
+                            name: file,
+                            path: filePath,
+                            mtime: stats.mtime
+                        });
+                    }
+                    catch {
+                        // Skip files that can't be stat'd
+                    }
+                }
+            }
+            // Sort by modification time
+            logFilesWithMtime.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+            // Keep the newest files, delete the rest
+            const maxFiles = this.config.maxFiles || 5;
+            if (logFilesWithMtime.length > maxFiles) {
+                const filesToDelete = logFilesWithMtime.slice(maxFiles);
+                for (const file of filesToDelete) {
+                    try {
+                        await fs.unlink(file.path);
+                    }
+                    catch (error) {
+                        console.error(`Failed to delete old log file ${file.path}:`, error);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error('Failed to cleanup old log files:', error);
+        }
+    }
+    writeToConsole(entries) {
+        for (const entry of entries) {
+            const formatted = this.formatLogEntry(entry, 'text');
+            if (this.config.enableColors) {
+                this.writeColoredConsole(entry, formatted);
+            }
+            else {
+                // MCP stdio servers must log to stderr to avoid interfering with protocol
+                console.error(formatted);
+            }
+        }
+    }
+    writeColoredConsole(entry, formatted) {
+        const colors = {
+            [LogLevel.DEBUG]: '\x1b[36m', // Cyan
+            [LogLevel.INFO]: '\x1b[32m', // Green
+            [LogLevel.WARN]: '\x1b[33m', // Yellow
+            [LogLevel.ERROR]: '\x1b[31m', // Red
+            [LogLevel.FATAL]: '\x1b[35m' // Magenta
+        };
+        const reset = '\x1b[0m';
+        const color = colors[entry.level] || '';
+        // MCP stdio servers must log to stderr to avoid interfering with protocol
+        console.error(`${color}${formatted}${reset}`);
+    }
+    formatLogEntry(entry, format) {
+        if (format === 'json') {
+            return JSON.stringify(entry);
+        }
+        const parts = [];
+        // Timestamp
+        if (this.config.enableTimestamp) {
+            parts.push(`[${entry.timestamp}]`);
+        }
+        // Log level
+        parts.push(`[${entry.levelName}]`);
+        // Module and function info
+        if (entry.module || entry.function) {
+            const location = [entry.module, entry.function].filter(Boolean).join('.');
+            parts.push(`[${location}]`);
+        }
+        // Main message
+        parts.push(entry.message);
+        // Metadata
+        if (entry.metadata && Object.keys(entry.metadata).length > 0) {
+            parts.push(`| ${JSON.stringify(entry.metadata)}`);
+        }
+        // Error info
+        if (entry.error && this.config.enableStackTrace && entry.error.stack) {
+            parts.push(`\n${entry.error.stack}`);
+        }
+        return parts.join(' ');
+    }
+    createLogEntry(level, message, metadata, error) {
+        const stack = new Error().stack;
+        const callerLine = stack?.split('\n')[3]; // 获取调用栈的第3行
+        let module;
+        let func;
+        let line;
+        if (callerLine) {
+            const match = callerLine.match(/at\s+(.+?)\s+\((.+?):(\d+):\d+\)/);
+            if (match && match[1] && match[2] && match[3]) {
+                func = match[1];
+                const filePath = match[2];
+                line = parseInt(match[3], 10);
+                module = path.basename(filePath, '.js');
+            }
+        }
+        return {
+            timestamp: new Date().toISOString(),
+            level,
+            levelName: LogLevel[level],
+            message,
+            module,
+            function: func,
+            line,
+            metadata,
+            error: error ? {
+                name: error.name,
+                message: error.message,
+                stack: error.stack
+            } : undefined
+        };
+    }
+    log(level, message, metadata, error) {
+        if (level < this.config.level) {
+            return;
+        }
+        const entry = this.createLogEntry(level, message, metadata, error);
+        if (this.config.output === 'console' || this.config.output === 'both') {
+            // For console output, write immediately
+            this.writeToConsole([entry]);
+        }
+        if (this.config.output === 'file' || this.config.output === 'both') {
+            // For file output, buffer and batch write
+            this.logBuffer.push(entry);
+            if (this.logBuffer.length >= this.bufferSize) {
+                this.flush().catch(error => {
+                    console.error('Failed to flush logs:', error);
+                });
+            }
+        }
+    }
+    debug(message, metadata) {
+        this.log(LogLevel.DEBUG, message, metadata);
+    }
+    info(message, metadata) {
+        this.log(LogLevel.INFO, message, metadata);
+    }
+    warn(message, metadata) {
+        this.log(LogLevel.WARN, message, metadata);
+    }
+    error(message, error, metadata) {
+        this.log(LogLevel.ERROR, message, metadata, error);
+    }
+    fatal(message, error, metadata) {
+        this.log(LogLevel.FATAL, message, metadata, error);
+    }
+    // Flush buffer immediately
+    async flushNow() {
+        await this.flush();
+    }
+    // Update configuration
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+    // Get current configuration
+    getConfig() {
+        return { ...this.config };
+    }
+    // Close the logger
+    async close() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+        }
+        await this.flush();
+    }
+}
+// Default logger instance
+export const defaultLogger = new StructuredLogger({
+    level: LogLevel.INFO,
+    output: 'both',
+    filePath: './logs/preflight-mcp.log',
+    format: 'text'
+});
+// Convenience functions
+export const logger = {
+    debug: (message, metadata) => defaultLogger.debug(message, metadata),
+    info: (message, metadata) => defaultLogger.info(message, metadata),
+    warn: (message, metadata) => defaultLogger.warn(message, metadata),
+    error: (message, error, metadata) => defaultLogger.error(message, error, metadata),
+    fatal: (message, error, metadata) => defaultLogger.fatal(message, error, metadata),
+    flush: () => defaultLogger.flushNow(),
+    updateConfig: (config) => defaultLogger.updateConfig(config),
+    getConfig: () => defaultLogger.getConfig(),
+    close: () => defaultLogger.close()
+};
+// Create a module-specific logger
+export function createModuleLogger(moduleName, config) {
+    const moduleConfig = {
+        ...config,
+        // Module-specific configuration can be added here
+    };
+    const moduleLogger = new StructuredLogger(moduleConfig);
+    return {
+        debug: (message, metadata) => moduleLogger.debug(message, { module: moduleName, ...metadata }),
+        info: (message, metadata) => moduleLogger.info(message, { module: moduleName, ...metadata }),
+        warn: (message, metadata) => moduleLogger.warn(message, { module: moduleName, ...metadata }),
+        error: (message, error, metadata) => moduleLogger.error(message, error, { module: moduleName, ...metadata }),
+        fatal: (message, error, metadata) => moduleLogger.fatal(message, error, { module: moduleName, ...metadata }),
+        flush: () => moduleLogger.flushNow(),
+        close: () => moduleLogger.close()
+    };
+}

package/dist/mcp/uris.js

@@ -0,0 +1,45 @@
+import path from 'node:path';
+export const PREFLIGHT_URI_PREFIX = 'preflight://bundle/';
+export function toBundleFileUri(ref) {
+    // encodedPath must not contain slashes so it can live as a single path segment
+    const encodedPath = encodeURIComponent(ref.relativePath);
+    return `${PREFLIGHT_URI_PREFIX}${ref.bundleId}/file/${encodedPath}`;
+}
+export function parseBundleFileUri(uri) {
+    if (!uri.startsWith(PREFLIGHT_URI_PREFIX))
+        return null;
+    const rest = uri.slice(PREFLIGHT_URI_PREFIX.length);
+    // rest = <bundleId>/file/<encodedPath>
+    const parts = rest.split('/');
+    if (parts.length !== 3)
+        return null;
+    const [bundleId, fileLiteral, encodedPath] = parts;
+    if (!bundleId || fileLiteral !== 'file' || !encodedPath)
+        return null;
+    const relativePath = decodeURIComponent(encodedPath);
+    return {
+        bundleId,
+        relativePath,
+    };
+}
+export function normalizeRelativePath(p) {
+    // Ensure forward slashes and no leading slash.
+    return p.replaceAll('\\', '/').replace(/^\/+/, '');
+}
+export function safeJoin(rootDir, relativePath) {
+    // Block absolute paths BEFORE normalization.
+    // This catches Unix-style /etc/passwd and Windows-style C:\path.
+    const trimmed = relativePath.trim();
+    if (trimmed.startsWith('/') || trimmed.startsWith('\\') || /^[a-zA-Z]:/.test(trimmed)) {
+        throw new Error('Unsafe path traversal attempt');
+    }
+    // Convert to platform separator for join, but validate containment by resolving.
+    const norm = normalizeRelativePath(relativePath);
+    const joined = path.resolve(rootDir, norm.split('/').join(path.sep));
+    const rootResolved = path.resolve(rootDir);
+    const rel = path.relative(rootResolved, joined);
+    if (rel.startsWith('..') || path.isAbsolute(rel)) {
+        throw new Error('Unsafe path traversal attempt');
+    }
+    return joined;
+}