preflight-mcp 0.1.0 → 0.1.2

package/dist/config.js

@@ -50,6 +50,7 @@ export function getConfig() {
         githubToken: process.env.GITHUB_TOKEN,
         context7ApiKey: process.env.CONTEXT7_API_KEY,
         context7McpUrl: process.env.CONTEXT7_MCP_URL ?? 'https://mcp.context7.com/mcp',
+        gitCloneTimeoutMs: envNumber('PREFLIGHT_GIT_CLONE_TIMEOUT_MS', 5 * 60_000),
         maxFileBytes: envNumber('PREFLIGHT_MAX_FILE_BYTES', 512 * 1024),
         maxTotalBytes: envNumber('PREFLIGHT_MAX_TOTAL_BYTES', 50 * 1024 * 1024),
         analysisMode,

package/dist/context7/client.js

@@ -19,7 +19,7 @@ export async function connectContext7(cfg) {
             maxRetries: 1,
         },
     });
-    const client = new Client({ name: 'preflight-context7', version: '0.1.0' });
+    const client = new Client({ name: 'preflight-context7', version: '0.1.1' });
     await client.connect(transport);
     return {
         client,

package/dist/core/concurrency-limiter.js

@@ -0,0 +1,100 @@
+/**
+ * Concurrency limiter to prevent DoS attacks via resource exhaustion.
+ * Limits the number of concurrent operations (e.g., bundle creations).
+ */
+import { logger } from '../logging/logger.js';
+export class ConcurrencyLimiter {
+    activeCount = 0;
+    maxConcurrent;
+    queue = [];
+    queueTimeoutMs;
+    constructor(maxConcurrent, queueTimeoutMs = 5 * 60 * 1000) {
+        if (maxConcurrent <= 0) {
+            throw new Error('maxConcurrent must be positive');
+        }
+        this.maxConcurrent = maxConcurrent;
+        this.queueTimeoutMs = queueTimeoutMs;
+    }
+    /**
+     * Acquire a slot for executing an operation.
+     * Waits in queue if all slots are occupied.
+     * Throws if waiting exceeds queueTimeoutMs.
+     */
+    async acquire() {
+        if (this.activeCount < this.maxConcurrent) {
+            this.activeCount++;
+            logger.debug(`Concurrency slot acquired (${this.activeCount}/${this.maxConcurrent})`);
+            return;
+        }
+        // Queue is full, wait for a slot
+        logger.info(`Concurrency limit reached (${this.maxConcurrent}), queuing request. Queue size: ${this.queue.length}`);
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                // Remove from queue
+                const index = this.queue.findIndex(item => item.resolve === resolve);
+                if (index >= 0) {
+                    this.queue.splice(index, 1);
+                }
+                reject(new Error(`Operation timed out waiting in queue (${this.queueTimeoutMs}ms)`));
+            }, this.queueTimeoutMs);
+            this.queue.push({
+                resolve: () => {
+                    clearTimeout(timeoutId);
+                    this.activeCount++;
+                    logger.debug(`Concurrency slot acquired from queue (${this.activeCount}/${this.maxConcurrent})`);
+                    resolve();
+                },
+                reject: (err) => {
+                    clearTimeout(timeoutId);
+                    reject(err);
+                },
+                addedAt: Date.now(),
+            });
+        });
+    }
+    /**
+     * Release a slot after operation completes.
+     */
+    release() {
+        if (this.activeCount <= 0) {
+            logger.warn('ConcurrencyLimiter.release() called with no active operations');
+            return;
+        }
+        this.activeCount--;
+        logger.debug(`Concurrency slot released (${this.activeCount}/${this.maxConcurrent})`);
+        // Process next item in queue
+        if (this.queue.length > 0) {
+            const next = this.queue.shift();
+            if (next) {
+                const waitTime = Date.now() - next.addedAt;
+                logger.info(`Processing queued request (waited ${waitTime}ms)`);
+                next.resolve();
+            }
+        }
+    }
+    /**
+     * Execute a function with concurrency control.
+     */
+    async run(fn) {
+        await this.acquire();
+        try {
+            return await fn();
+        }
+        finally {
+            this.release();
+        }
+    }
+    /**
+     * Get current status for monitoring.
+     */
+    getStatus() {
+        return {
+            active: this.activeCount,
+            max: this.maxConcurrent,
+            queued: this.queue.length,
+        };
+    }
+}
+// Global limiter for bundle creation operations
+// Default: allow 10 concurrent bundle creations
+export const bundleCreationLimiter = new ConcurrencyLimiter(parseInt(process.env.PREFLIGHT_MAX_CONCURRENT_BUNDLES ?? '10', 10));

package/dist/core/scheduler.js

@@ -96,7 +96,10 @@ export class Scheduler {
                 }
                 jobTask.retryTimeout = setTimeout(() => {
                     jobTask.retryTimeout = undefined;
-                    void this.executeJob(jobName, job, true);
+                    // Properly handle Promise rejection
+                    this.executeJob(jobName, job, true).catch((err) => {
+                        logger.error(`Unhandled error in retry for job ${jobName}`, err instanceof Error ? err : undefined);
+                    });
                 }, delay);
                 jobTask.retryTimeout.unref?.();
             }

package/dist/jobs/tmp-cleanup-job.js

@@ -0,0 +1,71 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { Job } from '../core/scheduler.js';
+import { logger } from '../logging/logger.js';
+import { getConfig } from '../config.js';
+/**
+ * Cleanup job for temporary directories.
+ * Removes temporary checkout directories older than 24 hours.
+ */
+export class TmpCleanupJob extends Job {
+    maxAgeHours = 24;
+    getName() {
+        return 'tmp-cleanup';
+    }
+    getMaxRetries() {
+        return 2; // Fewer retries for cleanup jobs
+    }
+    async run() {
+        const cfg = getConfig();
+        const checkoutsDir = path.join(cfg.tmpDir, 'checkouts');
+        try {
+            const exists = await this.pathExists(checkoutsDir);
+            if (!exists) {
+                logger.debug('Checkouts directory does not exist, skipping cleanup');
+                return;
+            }
+            const entries = await fs.readdir(checkoutsDir, { withFileTypes: true });
+            const now = Date.now();
+            const maxAgeMs = this.maxAgeHours * 60 * 60 * 1000;
+            let cleanedCount = 0;
+            let errorCount = 0;
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const entryPath = path.join(checkoutsDir, entry.name);
+                try {
+                    const stats = await fs.stat(entryPath);
+                    const ageMs = now - stats.mtimeMs;
+                    if (ageMs > maxAgeMs) {
+                        logger.info(`Cleaning up old temporary directory: ${entry.name} (age: ${Math.round(ageMs / 3600000)}h)`);
+                        await fs.rm(entryPath, { recursive: true, force: true });
+                        cleanedCount++;
+                    }
+                }
+                catch (err) {
+                    logger.warn(`Failed to cleanup temporary directory ${entry.name}`, err instanceof Error ? err : undefined);
+                    errorCount++;
+                }
+            }
+            if (cleanedCount > 0) {
+                logger.info(`Temporary directory cleanup completed: ${cleanedCount} removed, ${errorCount} errors`);
+            }
+            else {
+                logger.debug('No old temporary directories to clean up');
+            }
+        }
+        catch (err) {
+            logger.error('Temporary directory cleanup failed', err instanceof Error ? err : undefined);
+            throw err;
+        }
+    }
+    async pathExists(p) {
+        try {
+            await fs.access(p);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/mcp/errorKinds.js

@@ -0,0 +1,54 @@
+function msgOf(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+function codeOf(err) {
+    const anyErr = err;
+    const code = anyErr?.code;
+    return typeof code === 'string' ? code : undefined;
+}
+function isLikelyIndexProblemMessage(message) {
+    const m = message.toLowerCase();
+    return ((m.includes('sqlite') || m.includes('fts') || m.includes('database')) &&
+        (m.includes('unable to open database file') ||
+            m.includes('cannot open') ||
+            m.includes('cantopen') ||
+            m.includes('no such table') ||
+            m.includes('malformed') ||
+            m.includes('file is not a database') ||
+            m.includes('disk i/o')));
+}
+export function classifyPreflightErrorKind(err) {
+    const message = msgOf(err);
+    const m = message.toLowerCase();
+    const code = codeOf(err);
+    if (m.includes('bundle not found'))
+        return 'bundle_not_found';
+    // Path traversal attempts from safeJoin.
+    if (m.includes('unsafe path traversal attempt'))
+        return 'invalid_path';
+    // Filesystem errors.
+    if (code === 'ENOENT')
+        return 'file_not_found';
+    if (code === 'EACCES' || code === 'EPERM')
+        return 'permission_denied';
+    // Common string forms when error.code is not preserved.
+    if (m.includes('enoent') && m.includes('no such file or directory'))
+        return 'file_not_found';
+    if ((m.includes('eacces') || m.includes('eperm')) && m.includes('permission'))
+        return 'permission_denied';
+    if (m.includes('deprecated') && (m.includes('ensurefresh') || m.includes('autorepairindex'))) {
+        return 'deprecated_parameter';
+    }
+    if (isLikelyIndexProblemMessage(message))
+        return 'index_missing_or_corrupt';
+    return 'unknown';
+}
+export function formatPreflightError(kind, message) {
+    // Stable, machine-parseable prefix for UIs.
+    return `[preflight_error kind=${kind}] ${message}`;
+}
+export function wrapPreflightError(err) {
+    const message = msgOf(err);
+    const kind = classifyPreflightErrorKind(err);
+    return new Error(formatPreflightError(kind, message));
+}

package/dist/mcp/uris.js

@@ -27,19 +27,39 @@ export function normalizeRelativePath(p) {
     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');
+    // Early rejection of obviously malicious patterns
+    if (!trimmed || trimmed.length > 4096) {
+        throw new Error('Invalid path: empty or too long');
     }
-    // Convert to platform separator for join, but validate containment by resolving.
+    // Block UNC paths (\\server\share or \\?\C:\path)
+    if (trimmed.startsWith('\\\\')) {
+        throw new Error('Unsafe path traversal attempt: UNC path not allowed');
+    }
+    // Block Windows device paths (CON, PRN, AUX, NUL, COM1-9, LPT1-9)
+    const devicePattern = /^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(\..*)?$/i;
+    const baseName = path.basename(trimmed);
+    if (devicePattern.test(baseName)) {
+        throw new Error('Unsafe path: Windows device name not allowed');
+    }
+    // Normalize FIRST to canonicalize the path
     const norm = normalizeRelativePath(relativePath);
+    // After normalization, check for absolute path indicators
+    if (norm.startsWith('/') || /^[a-zA-Z]:/.test(norm)) {
+        throw new Error('Unsafe path traversal attempt: absolute path after normalization');
+    }
+    // Check for null bytes (path injection)
+    if (norm.includes('\0')) {
+        throw new Error('Unsafe path: null byte not allowed');
+    }
+    // Resolve and validate containment
     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');
+    // Ensure normalized form of joined path starts with root
+    const joinedNorm = path.normalize(joined);
+    const rootNorm = path.normalize(rootResolved);
+    if (!joinedNorm.startsWith(rootNorm + path.sep) && joinedNorm !== rootNorm) {
+        throw new Error('Unsafe path traversal attempt: path escapes root directory');
     }
     return joined;
 }

package/dist/search/sqliteFts.js

@@ -123,43 +123,64 @@ export async function incrementalIndexUpdate(dbPath, files, opts) {
         const updateTransaction = db.transaction((updateFiles) => {
             const now = new Date().toISOString();
             for (const f of updateFiles) {
-                // Delete old lines
-                deleteLines.run(f.bundleNormRelativePath);
-                // Insert new lines
-                const text = fsSync.readFileSync(f.bundleNormAbsPath, 'utf8');
-                const lines = text.split('\n');
-                for (let i = 0; i < lines.length; i++) {
-                    const line = lines[i] ?? '';
-                    if (!line.trim())
-                        continue;
-                    insertLine.run(line, f.bundleNormRelativePath, f.repoId, f.kind, i + 1);
+                try {
+                    // Delete old lines
+                    deleteLines.run(f.bundleNormRelativePath);
+                    // Insert new lines
+                    const text = fsSync.readFileSync(f.bundleNormAbsPath, 'utf8');
+                    const lines = text.split('\n');
+                    for (let i = 0; i < lines.length; i++) {
+                        const line = lines[i] ?? '';
+                        if (!line.trim())
+                            continue;
+                        insertLine.run(line, f.bundleNormRelativePath, f.repoId, f.kind, i + 1);
+                    }
+                    // Update metadata
+                    upsertMeta.run(f.bundleNormRelativePath, f.sha256, now);
+                }
+                catch (err) {
+                    // Log error but continue with other files to avoid transaction rollback
+                    console.error(`Failed to index file ${f.bundleNormRelativePath}:`, err);
+                    throw err; // Re-throw to trigger transaction rollback and ensure finally block runs
                 }
-                // Update metadata
-                upsertMeta.run(f.bundleNormRelativePath, f.sha256, now);
             }
         });
         // Process new files
         const insertTransaction = db.transaction((newFiles) => {
             const now = new Date().toISOString();
             for (const f of newFiles) {
-                const text = fsSync.readFileSync(f.bundleNormAbsPath, 'utf8');
-                const lines = text.split('\n');
-                for (let i = 0; i < lines.length; i++) {
-                    const line = lines[i] ?? '';
-                    if (!line.trim())
-                        continue;
-                    insertLine.run(line, f.bundleNormRelativePath, f.repoId, f.kind, i + 1);
+                try {
+                    const text = fsSync.readFileSync(f.bundleNormAbsPath, 'utf8');
+                    const lines = text.split('\n');
+                    for (let i = 0; i < lines.length; i++) {
+                        const line = lines[i] ?? '';
+                        if (!line.trim())
+                            continue;
+                        insertLine.run(line, f.bundleNormRelativePath, f.repoId, f.kind, i + 1);
+                    }
+                    // Insert metadata
+                    upsertMeta.run(f.bundleNormRelativePath, f.sha256, now);
+                }
+                catch (err) {
+                    console.error(`Failed to index file ${f.bundleNormRelativePath}:`, err);
+                    throw err; // Re-throw to trigger transaction rollback and ensure finally block runs
                 }
-                // Insert metadata
-                upsertMeta.run(f.bundleNormRelativePath, f.sha256, now);
             }
         });
-        // Execute transactions
+        // Execute transactions in batches to avoid memory overflow
+        // Process 100 files at a time to keep memory usage bounded
+        const BATCH_SIZE = 100;
         if (filesToUpdate.length > 0) {
-            updateTransaction(filesToUpdate);
+            for (let i = 0; i < filesToUpdate.length; i += BATCH_SIZE) {
+                const batch = filesToUpdate.slice(i, i + BATCH_SIZE);
+                updateTransaction(batch);
+            }
         }
         if (filesToIndex.length > 0) {
-            insertTransaction(filesToIndex);
+            for (let i = 0; i < filesToIndex.length; i += BATCH_SIZE) {
+                const batch = filesToIndex.slice(i, i + BATCH_SIZE);
+                insertTransaction(batch);
+            }
         }
         return {
             added,
@@ -226,21 +247,32 @@ export async function rebuildIndex(dbPathOrFiles, filesOrDbPath, opts) {
                     continue;
                 if (f.kind === 'code' && !opts.includeCode)
                     continue;
-                // Read file synchronously inside transaction for better performance.
-                const text = fsSync.readFileSync(f.bundleNormAbsPath, 'utf8');
-                const lines = text.split('\n');
-                for (let i = 0; i < lines.length; i++) {
-                    const line = lines[i] ?? '';
-                    // Skip empty lines to keep the index smaller.
-                    if (!line.trim())
-                        continue;
-                    insertLine.run(line, f.bundleNormRelativePath, f.repoId, f.kind, i + 1);
+                try {
+                    // Read file synchronously inside transaction for better performance.
+                    const text = fsSync.readFileSync(f.bundleNormAbsPath, 'utf8');
+                    const lines = text.split('\n');
+                    for (let i = 0; i < lines.length; i++) {
+                        const line = lines[i] ?? '';
+                        // Skip empty lines to keep the index smaller.
+                        if (!line.trim())
+                            continue;
+                        insertLine.run(line, f.bundleNormRelativePath, f.repoId, f.kind, i + 1);
+                    }
+                    // Store file metadata for incremental updates
+                    insertMeta.run(f.bundleNormRelativePath, f.sha256, now);
+                }
+                catch (err) {
+                    console.error(`Failed to index file ${f.bundleNormRelativePath}:`, err);
+                    throw err;
                 }
-                // Store file metadata for incremental updates
-                insertMeta.run(f.bundleNormRelativePath, f.sha256, now);
             }
         });
-        insertMany(files);
+        // Process files in batches to avoid memory overflow
+        const BATCH_SIZE = 100;
+        for (let i = 0; i < files.length; i += BATCH_SIZE) {
+            const batch = files.slice(i, i + BATCH_SIZE);
+            insertMany(batch);
+        }
     }
     finally {
         db.close();

package/dist/server/optimized-server.js

@@ -2,6 +2,7 @@ import { PreflightScheduler } from '../core/scheduler.js';
 import { BundleAutoUpdateJob } from '../jobs/bundle-auto-update-job.js';
 import { StorageCleanupJob } from '../jobs/storage-cleanup-job.js';
 import { HealthCheckJob } from '../jobs/health-check-job.js';
+import { TmpCleanupJob } from '../jobs/tmp-cleanup-job.js';
 import { getStorageManager } from '../storage/storage-adapter.js';
 import { compressData, decompressData, detectCompressionType } from '../storage/compression.js';
 import { logger, createModuleLogger } from '../logging/logger.js';
@@ -85,6 +86,9 @@ export class OptimizedPreflightServer {
         // 健康检查任务 - 每30分钟执行一次
         PreflightScheduler.build(HealthCheckJob).schedule('*/30 * * * *');
         moduleLogger.info('Health check job scheduled (every 30 minutes)');
+        // 临时目录清理任务 - 每6小时执行一次
+        PreflightScheduler.build(TmpCleanupJob).schedule('0 */6 * * *');
+        moduleLogger.info('Temporary directory cleanup job scheduled (every 6 hours)');
         moduleLogger.info('All scheduled jobs configured', {
             totalJobs: PreflightScheduler.getAllJobsStatus()
         });