preflight-mcp 0.1.1 → 0.1.3

package/dist/bundle/cleanup.js

@@ -0,0 +1,155 @@
+/**
+ * Bundle cleanup utilities for MCP architecture
+ * Designed to run on-demand (startup, list, etc.) rather than as a daemon
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { logger } from '../logging/logger.js';
+import { rmIfExists } from '../utils/index.js';
+/**
+ * Check if a string is a valid UUID (v4 format)
+ */
+function isValidBundleId(id) {
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    return uuidRegex.test(id);
+}
+/**
+ * Check if a bundle is orphaned (incomplete/corrupted)
+ */
+async function isOrphanBundle(storageDir, bundleId) {
+    const bundlePath = path.join(storageDir, bundleId);
+    const manifestPath = path.join(bundlePath, 'manifest.json');
+    try {
+        // Check if manifest exists and is valid
+        const manifestContent = await fs.readFile(manifestPath, 'utf8');
+        const manifest = JSON.parse(manifestContent);
+        // Valid manifest exists
+        if (manifest.bundleId && manifest.schemaVersion) {
+            return { isOrphan: false };
+        }
+        return { isOrphan: true, reason: 'invalid manifest' };
+    }
+    catch {
+        // Manifest missing or unreadable
+        try {
+            const stats = await fs.stat(bundlePath);
+            const ageHours = (Date.now() - stats.mtimeMs) / (1000 * 60 * 60);
+            return { isOrphan: true, reason: 'missing manifest', ageHours };
+        }
+        catch {
+            return { isOrphan: true, reason: 'directory inaccessible' };
+        }
+    }
+}
+/**
+ * Clean up orphan bundles from a single storage directory
+ * Only removes bundles older than minAgeHours to avoid race conditions
+ */
+async function cleanupOrphansInDir(storageDir, options) {
+    const found = [];
+    const cleaned = [];
+    const skipped = [];
+    try {
+        const entries = await fs.readdir(storageDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            // Handle .deleting directories (from background deletion)
+            if (entry.name.endsWith('.deleting')) {
+                // Always clean .deleting directories (they're already marked for deletion)
+                try {
+                    const deletingPath = path.join(storageDir, entry.name);
+                    await rmIfExists(deletingPath);
+                    logger.info(`Cleaned pending deletion: ${entry.name}`);
+                }
+                catch (err) {
+                    logger.warn(`Failed to clean pending deletion ${entry.name}: ${err instanceof Error ? err.message : String(err)}`);
+                }
+                continue;
+            }
+            // Only process directories with valid UUID names
+            if (!isValidBundleId(entry.name)) {
+                continue;
+            }
+            const bundleId = entry.name;
+            const orphanCheck = await isOrphanBundle(storageDir, bundleId);
+            if (orphanCheck.isOrphan) {
+                found.push(bundleId);
+                // Check age threshold
+                if (orphanCheck.ageHours !== undefined && orphanCheck.ageHours < options.minAgeHours) {
+                    skipped.push({
+                        bundleId,
+                        reason: `too new (${orphanCheck.ageHours.toFixed(1)}h < ${options.minAgeHours}h)`,
+                    });
+                    continue;
+                }
+                if (!options.dryRun) {
+                    try {
+                        const bundlePath = path.join(storageDir, bundleId);
+                        await rmIfExists(bundlePath);
+                        cleaned.push(bundleId);
+                        logger.info(`Cleaned orphan bundle: ${bundleId} (${orphanCheck.reason})`);
+                    }
+                    catch (err) {
+                        skipped.push({
+                            bundleId,
+                            reason: `cleanup failed: ${err instanceof Error ? err.message : String(err)}`,
+                        });
+                    }
+                }
+                else {
+                    cleaned.push(bundleId); // In dry-run, mark as "would clean"
+                }
+            }
+        }
+    }
+    catch (err) {
+        logger.warn(`Failed to scan storage dir ${storageDir}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return { found, cleaned, skipped };
+}
+/**
+ * Clean up orphan bundles across all storage directories
+ * Safe to call on every server startup - fast when no orphans exist
+ */
+export async function cleanupOrphanBundles(cfg, options) {
+    const minAgeHours = options?.minAgeHours ?? 1; // Default: 1 hour safety margin
+    const dryRun = options?.dryRun ?? false;
+    const details = [];
+    let totalFound = 0;
+    let totalCleaned = 0;
+    for (const storageDir of cfg.storageDirs) {
+        const result = await cleanupOrphansInDir(storageDir, { minAgeHours, dryRun });
+        totalFound += result.found.length;
+        totalCleaned += result.cleaned.length;
+        if (result.found.length > 0) {
+            details.push({
+                storageDir,
+                ...result,
+            });
+        }
+    }
+    if (totalFound > 0) {
+        logger.info(`Orphan cleanup: found ${totalFound}, cleaned ${totalCleaned}, skipped ${totalFound - totalCleaned}${dryRun ? ' (dry-run)' : ''}`);
+    }
+    return { totalFound, totalCleaned, details };
+}
+/**
+ * Run orphan cleanup on server startup (best-effort, non-blocking)
+ * Only logs warnings on failure, doesn't throw
+ */
+export async function cleanupOnStartup(cfg) {
+    try {
+        const result = await cleanupOrphanBundles(cfg, {
+            minAgeHours: 1,
+            dryRun: false,
+        });
+        if (result.totalCleaned > 0) {
+            logger.info(`Startup cleanup: removed ${result.totalCleaned} orphan bundle(s)`);
+        }
+    }
+    catch (err) {
+        // Non-critical: just log and continue
+        logger.warn(`Startup cleanup failed (non-critical): ${err instanceof Error ? err.message : String(err)}`);
+    }
+}

package/dist/bundle/context7.js

@@ -138,15 +138,34 @@ async function writeJson(targetPath, obj) {
     await ensureDir(path.dirname(targetPath));
     await fs.writeFile(targetPath, JSON.stringify(obj, null, 2) + '\n', 'utf8');
 }
+async function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 async function callOrThrow(client, name, args) {
-    const res = await client.callTool({ name, arguments: args });
-    if (res.isError) {
-        throw new Error(textFromToolResult(res) || `${name} failed`);
+    const maxRetries = 3;
+    let lastError;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            const res = await client.callTool({ name, arguments: args });
+            if (res.isError) {
+                throw new Error(textFromToolResult(res) || `${name} failed`);
+            }
+            return {
+                text: textFromToolResult(res),
+                structured: res.structuredContent,
+            };
+        }
+        catch (err) {
+            lastError = err instanceof Error ? err : new Error(String(err));
+            // Don't retry on last attempt
+            if (attempt < maxRetries - 1) {
+                // Exponential backoff: 1s, 2s, 4s
+                const delayMs = Math.pow(2, attempt) * 1000;
+                await sleep(delayMs);
+            }
+        }
     }
-    return {
-        text: textFromToolResult(res),
-        structured: res.structuredContent,
-    };
+    throw lastError || new Error(`${name} failed after ${maxRetries} retries`);
 }
 async function resolveContext7Id(client, input) {
     const notes = [];
@@ -154,38 +173,48 @@ async function resolveContext7Id(client, input) {
     if (trimmed.startsWith('/')) {
         return { id: trimmed, notes };
     }
-    try {
-        const res = await client.callTool({
-            name: 'resolve-library-id',
-            arguments: { libraryName: trimmed },
-        });
-        if (res.isError) {
-            notes.push(`resolve-library-id error: ${textFromToolResult(res)}`);
-            return { notes };
-        }
-        const text = textFromToolResult(res);
-        // Prefer parsing the structured list output for better selection.
-        const parsed = parseResolveEntries(text);
-        const chosen = chooseBestEntry(parsed, trimmed);
-        if (chosen.id) {
-            notes.push(...chosen.notes);
-            return { id: chosen.id, notes };
-        }
-        // Fallback: regex/structured extraction.
-        const ids = extractContext7IdsFromResult(res);
-        if (ids.length === 0) {
-            notes.push('resolve-library-id returned no Context7 IDs');
-            return { notes };
+    const maxRetries = 3;
+    let lastError;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            const res = await client.callTool({
+                name: 'resolve-library-id',
+                arguments: { libraryName: trimmed },
+            });
+            if (res.isError) {
+                notes.push(`resolve-library-id error: ${textFromToolResult(res)}`);
+                return { notes };
+            }
+            const text = textFromToolResult(res);
+            // Prefer parsing the structured list output for better selection.
+            const parsed = parseResolveEntries(text);
+            const chosen = chooseBestEntry(parsed, trimmed);
+            if (chosen.id) {
+                notes.push(...chosen.notes);
+                return { id: chosen.id, notes };
+            }
+            // Fallback: regex/structured extraction.
+            const ids = extractContext7IdsFromResult(res);
+            if (ids.length === 0) {
+                notes.push('resolve-library-id returned no Context7 IDs');
+                return { notes };
+            }
+            if (ids.length > 1) {
+                notes.push(`resolve-library-id returned multiple IDs; using first: ${ids[0]}`);
+            }
+            return { id: ids[0], notes };
         }
-        if (ids.length > 1) {
-            notes.push(`resolve-library-id returned multiple IDs; using first: ${ids[0]}`);
+        catch (err) {
+            lastError = err instanceof Error ? err : new Error(String(err));
+            // Don't retry on last attempt
+            if (attempt < maxRetries - 1) {
+                const delayMs = Math.pow(2, attempt) * 1000;
+                await sleep(delayMs);
+            }
         }
-        return { id: ids[0], notes };
-    }
-    catch (err) {
-        notes.push(`resolve-library-id threw: ${err instanceof Error ? err.message : String(err)}`);
-        return { notes };
     }
+    notes.push(`resolve-library-id failed after ${maxRetries} retries: ${lastError?.message ?? 'unknown error'}`);
+    return { notes };
 }
 export async function ingestContext7Libraries(params) {
     const libs = (params.libraries ?? []).map((s) => s.trim()).filter(Boolean);