@supermodeltools/mcp-server 0.4.3 → 0.4.5

package/dist/utils/zip-repository.js

@@ -0,0 +1,332 @@
+"use strict";
+/**
+ * Automatic repository zipping with gitignore support
+ * Creates temporary ZIP files for codebase analysis
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zipRepository = zipRepository;
+exports.cleanupOldZips = cleanupOldZips;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const archiver_1 = __importDefault(require("archiver"));
+const ignore_1 = __importDefault(require("ignore"));
+const crypto_1 = require("crypto");
+/**
+ * Standard exclusions for security and size optimization
+ * These patterns are applied in addition to .gitignore
+ */
+const STANDARD_EXCLUSIONS = [
+    // Version control
+    '.git',
+    '.svn',
+    '.hg',
+    // Dependencies
+    'node_modules',
+    'vendor',
+    'venv',
+    '.venv',
+    'env',
+    'virtualenv',
+    'target', // Rust/Java
+    // Build outputs
+    'dist',
+    'build',
+    'out',
+    '.next',
+    '__pycache__',
+    '*.pyc',
+    '*.pyo',
+    '*.so',
+    '*.dylib',
+    '*.dll',
+    '*.class',
+    // IDE files
+    '.idea',
+    '.vscode',
+    '.vs',
+    '*.swp',
+    '*.swo',
+    '*~',
+    '.DS_Store',
+    // Sensitive files (CRITICAL - prevent credential leaks)
+    '.env',
+    '.env.local',
+    '.env.*.local',
+    '*.pem',
+    '*.key',
+    '*.p12',
+    '*.pfx',
+    '*.jks',
+    'secrets.yml',
+    'secrets.yaml',
+    'secrets.json',
+    'credentials.json',
+    'serviceaccount.json',
+    '.aws/credentials',
+    '.ssh/id_rsa',
+    '.ssh/id_ed25519',
+    // Large binary files
+    '*.mp4',
+    '*.avi',
+    '*.mov',
+    '*.zip',
+    '*.tar',
+    '*.gz',
+    '*.rar',
+    '*.7z',
+    '*.iso',
+    '*.dmg',
+];
+/**
+ * Create a ZIP archive of a directory with gitignore support
+ */
+async function zipRepository(directoryPath, options = {}) {
+    const maxSizeBytes = options.maxSizeBytes || 500 * 1024 * 1024; // 500MB default
+    // Validate directory exists
+    try {
+        const stats = await fs_1.promises.stat(directoryPath);
+        if (!stats.isDirectory()) {
+            throw new Error(`Path is not a directory: ${directoryPath}`);
+        }
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new Error(`Directory does not exist: ${directoryPath}`);
+        }
+        if (error.code === 'EACCES') {
+            throw new Error(`Permission denied accessing directory: ${directoryPath}`);
+        }
+        throw error;
+    }
+    // Parse gitignore files
+    const ignoreFilter = await buildIgnoreFilter(directoryPath, options.additionalExclusions);
+    // Create temp file path
+    const tempDir = (0, os_1.tmpdir)();
+    const zipFileName = `supermodel-${(0, crypto_1.randomBytes)(8).toString('hex')}.zip`;
+    const zipPath = (0, path_1.join)(tempDir, zipFileName);
+    console.error('[DEBUG] Creating ZIP:', zipPath);
+    console.error('[DEBUG] Source directory:', directoryPath);
+    // Create ZIP archive
+    let fileCount = 0;
+    let totalSize = 0;
+    const output = (0, fs_1.createWriteStream)(zipPath);
+    const archive = (0, archiver_1.default)('zip', {
+        zlib: { level: 6 } // Balanced compression
+    });
+    // Track errors
+    let archiveError = null;
+    archive.on('error', (err) => {
+        archiveError = err;
+    });
+    archive.on('warning', (err) => {
+        if (err.code === 'ENOENT') {
+            console.error('[WARN] File not found (skipping):', err.message);
+        }
+        else {
+            console.error('[WARN] Archive warning:', err.message);
+        }
+    });
+    // Track progress
+    archive.on('entry', (entry) => {
+        fileCount++;
+        totalSize += entry.stats?.size || 0;
+        // Check size limit
+        if (totalSize > maxSizeBytes) {
+            archive.abort();
+            archiveError = new Error(`ZIP size exceeds limit (${formatBytes(maxSizeBytes)}). ` +
+                `Current size: ${formatBytes(totalSize)}. ` +
+                `Consider excluding more directories or analyzing a subdirectory.`);
+        }
+    });
+    // Pipe to file
+    archive.pipe(output);
+    // Add files recursively with filtering
+    await addFilesRecursively(archive, directoryPath, directoryPath, ignoreFilter);
+    // Finalize archive
+    await archive.finalize();
+    // Wait for output stream to finish
+    await new Promise((resolve, reject) => {
+        output.on('close', () => {
+            if (archiveError) {
+                reject(archiveError);
+            }
+            else {
+                resolve();
+            }
+        });
+        output.on('error', reject);
+    });
+    // Check for errors during archiving
+    if (archiveError) {
+        // Clean up partial ZIP
+        await fs_1.promises.unlink(zipPath).catch(() => { });
+        throw archiveError;
+    }
+    // Get final file size
+    const zipStats = await fs_1.promises.stat(zipPath);
+    const zipSizeBytes = zipStats.size;
+    console.error('[DEBUG] ZIP created successfully');
+    console.error('[DEBUG] Files included:', fileCount);
+    console.error('[DEBUG] ZIP size:', formatBytes(zipSizeBytes));
+    // Create cleanup function
+    const cleanup = async () => {
+        try {
+            await fs_1.promises.unlink(zipPath);
+            console.error('[DEBUG] Cleaned up ZIP:', zipPath);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                console.error('[WARN] Failed to cleanup ZIP:', error.message);
+            }
+        }
+    };
+    return {
+        path: zipPath,
+        cleanup,
+        fileCount,
+        sizeBytes: zipSizeBytes,
+    };
+}
+/**
+ * Build ignore filter from .gitignore files and standard exclusions
+ */
+async function buildIgnoreFilter(rootDir, additionalExclusions = []) {
+    const ig = (0, ignore_1.default)();
+    // Add standard exclusions
+    ig.add(STANDARD_EXCLUSIONS);
+    // Add custom exclusions
+    if (additionalExclusions.length > 0) {
+        ig.add(additionalExclusions);
+    }
+    // Parse .gitignore in root
+    const gitignorePath = (0, path_1.join)(rootDir, '.gitignore');
+    try {
+        const gitignoreContent = await fs_1.promises.readFile(gitignorePath, 'utf-8');
+        const patterns = gitignoreContent
+            .split('\n')
+            .map(line => line.trim())
+            .filter(line => line && !line.startsWith('#'));
+        if (patterns.length > 0) {
+            ig.add(patterns);
+            console.error('[DEBUG] Loaded .gitignore with', patterns.length, 'patterns');
+        }
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT') {
+            console.error('[WARN] Failed to read .gitignore:', error.message);
+        }
+    }
+    return ig;
+}
+/**
+ * Recursively add files to archive with filtering
+ */
+async function addFilesRecursively(archive, rootDir, currentDir, ignoreFilter) {
+    let entries;
+    try {
+        entries = await fs_1.promises.readdir(currentDir);
+    }
+    catch (error) {
+        if (error.code === 'EACCES') {
+            console.error('[WARN] Permission denied:', currentDir);
+            return;
+        }
+        throw error;
+    }
+    for (const entry of entries) {
+        const fullPath = (0, path_1.join)(currentDir, entry);
+        const relativePath = (0, path_1.relative)(rootDir, fullPath);
+        // Normalize path for ignore matching (use forward slashes)
+        const normalizedRelativePath = relativePath.split(path_1.sep).join('/');
+        // Check if ignored
+        if (ignoreFilter.ignores(normalizedRelativePath)) {
+            continue;
+        }
+        let stats;
+        try {
+            stats = await fs_1.promises.stat(fullPath);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                // Symlink pointing to non-existent file, skip
+                continue;
+            }
+            console.error('[WARN] Failed to stat:', fullPath, error.message);
+            continue;
+        }
+        if (stats.isDirectory()) {
+            // Check if directory itself should be ignored
+            const dirPath = normalizedRelativePath + '/';
+            if (ignoreFilter.ignores(dirPath)) {
+                continue;
+            }
+            // Recurse into directory
+            await addFilesRecursively(archive, rootDir, fullPath, ignoreFilter);
+        }
+        else if (stats.isFile()) {
+            // Add file to archive
+            try {
+                archive.file(fullPath, { name: normalizedRelativePath });
+            }
+            catch (error) {
+                console.error('[WARN] Failed to add file:', fullPath, error.message);
+            }
+        }
+        // Skip symlinks, sockets, etc.
+    }
+}
+/**
+ * Format bytes as human-readable string
+ */
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(2)} KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+/**
+ * Clean up old ZIP files from temp directory
+ * Removes ZIPs older than the specified age
+ */
+async function cleanupOldZips(maxAgeMs = 24 * 60 * 60 * 1000) {
+    const tempDir = (0, os_1.tmpdir)();
+    const now = Date.now();
+    try {
+        const entries = await fs_1.promises.readdir(tempDir);
+        let removedCount = 0;
+        for (const entry of entries) {
+            // Only process our ZIP files
+            if (!entry.startsWith('supermodel-') || !entry.endsWith('.zip')) {
+                continue;
+            }
+            const fullPath = (0, path_1.join)(tempDir, entry);
+            try {
+                const stats = await fs_1.promises.stat(fullPath);
+                const ageMs = now - stats.mtimeMs;
+                if (ageMs > maxAgeMs) {
+                    await fs_1.promises.unlink(fullPath);
+                    removedCount++;
+                }
+            }
+            catch (error) {
+                // File might have been deleted already, ignore
+                if (error.code !== 'ENOENT') {
+                    console.error('[WARN] Failed to cleanup:', fullPath, error.message);
+                }
+            }
+        }
+        if (removedCount > 0) {
+            console.error('[DEBUG] Cleaned up', removedCount, 'old ZIP files');
+        }
+    }
+    catch (error) {
+        console.error('[WARN] Failed to cleanup temp directory:', error.message);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supermodeltools/mcp-server",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "description": "MCP server for Supermodel API - code graph generation for AI agents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -36,10 +36,13 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.1",
     "@supermodeltools/sdk": "^0.3.8",
+    "archiver": "^7.0.1",
+    "ignore": "^7.0.5",
     "jq-web": "^0.6.2",
     "zod": "^3.22.4"
   },
   "devDependencies": {
+    "@types/archiver": "^7.0.0",
     "@types/node": "^20.11.0",
     "typescript": "^5.3.3"
   }