preflight-mcp 0.1.0

package/dist/jobs/bundle-auto-update-job.js

@@ -0,0 +1,71 @@
+import { Job } from '../core/scheduler.js';
+import { getConfig } from '../config.js';
+import { listBundles, updateBundle } from '../bundle/service.js';
+import { readManifest } from '../bundle/manifest.js';
+import { logger } from '../logging/logger.js';
+export class BundleAutoUpdateJob extends Job {
+    getName() {
+        return 'BundleAutoUpdateJob';
+    }
+    getMaxRetries() {
+        return 2; // 更新任务重试次数较少
+    }
+    getRetryDelay() {
+        return 5000; // 5秒重试延迟
+    }
+    async run() {
+        const cfg = getConfig();
+        const effectiveDir = cfg.storageDirs[0]; // 使用主存储路径
+        const maxAgeHours = 24; // 24小时未更新的 bundle 需要检查
+        try {
+            const bundleIds = await listBundles(effectiveDir);
+            const results = [];
+            let updated = 0;
+            let failed = 0;
+            logger.info(`Checking ${bundleIds.length} bundles for updates`);
+            for (const bundleId of bundleIds) {
+                try {
+                    const manifestPath = `${effectiveDir}/${bundleId}/manifest.json`;
+                    const manifest = await readManifest(manifestPath);
+                    const updatedAt = new Date(manifest.updatedAt).getTime();
+                    const ageMs = Date.now() - updatedAt;
+                    const ageHours = ageMs / (1000 * 60 * 60);
+                    if (ageHours > maxAgeHours) {
+                        logger.debug(`Bundle ${bundleId} is ${ageHours.toFixed(1)}h old, checking for updates`);
+                        const { changed, summary } = await updateBundle(cfg, bundleId, { force: false });
+                        if (changed) {
+                            updated++;
+                            logger.info(`Bundle ${bundleId} updated successfully`);
+                        }
+                        else {
+                            logger.debug(`Bundle ${bundleId} is up to date`);
+                        }
+                        results.push({ bundleId, success: true });
+                    }
+                    else {
+                        logger.debug(`Bundle ${bundleId} is recent (${ageHours.toFixed(1)}h old), skipping`);
+                        results.push({ bundleId, success: true });
+                    }
+                }
+                catch (error) {
+                    failed++;
+                    const errorMsg = error instanceof Error ? error.message : String(error);
+                    logger.error(`Failed to update bundle ${bundleId}`, error instanceof Error ? error : undefined);
+                    results.push({ bundleId, success: false, error: errorMsg });
+                }
+            }
+            const result = {
+                updated,
+                failed,
+                total: bundleIds.length,
+                details: results
+            };
+            logger.info(`BundleAutoUpdate completed`, { updated, failed, total: bundleIds.length });
+            return result;
+        }
+        catch (error) {
+            logger.error('Failed to list bundles', error instanceof Error ? error : undefined);
+            throw error;
+        }
+    }
+}

package/dist/jobs/health-check-job.js

@@ -0,0 +1,172 @@
+import { Job } from '../core/scheduler.js';
+import { getConfig } from '../config.js';
+import { listBundles, bundleExists } from '../bundle/service.js';
+import { readManifest } from '../bundle/manifest.js';
+import { PreflightScheduler } from '../core/scheduler.js';
+import { logger } from '../logging/logger.js';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export class HealthCheckJob extends Job {
+    getName() {
+        return 'HealthCheckJob';
+    }
+    getMaxRetries() {
+        return 3;
+    }
+    getRetryDelay() {
+        return 2000; // 2秒重试延迟
+    }
+    async run() {
+        logger.debug('Starting system health check');
+        const cfg = getConfig();
+        const result = {
+            status: 'healthy',
+            bundles: {
+                total: 0,
+                healthy: 0,
+                corrupted: 0,
+                outdated: 0
+            },
+            storage: {
+                totalPaths: cfg.storageDirs.length,
+                accessiblePaths: 0,
+                totalSpace: 0,
+                freeSpace: 0
+            },
+            scheduler: {
+                totalJobs: 0,
+                runningJobs: 0,
+                failedJobs: 0
+            },
+            timestamp: new Date().toISOString()
+        };
+        try {
+            // 检查存储路径健康状态
+            await this.checkStorageHealth(cfg, result);
+            // 检查 bundles 健康状态
+            if (result.storage.accessiblePaths > 0) {
+                await this.checkBundlesHealth(cfg, result);
+            }
+            // 检查调度器健康状态
+            this.checkSchedulerHealth(result);
+            this.determineOverallHealth(result);
+            logger.info(`Health check completed: ${result.status}`, {
+                bundles: `${result.bundles.healthy}/${result.bundles.total}`,
+                storage: `${result.storage.accessiblePaths}/${result.storage.totalPaths}`,
+                jobs: result.scheduler.totalJobs
+            });
+            return result;
+        }
+        catch (error) {
+            logger.error('Health check failed', error instanceof Error ? error : undefined);
+            result.status = 'error';
+            return result;
+        }
+    }
+    async checkStorageHealth(cfg, result) {
+        for (const storageDir of cfg.storageDirs) {
+            try {
+                // 检查路径是否可访问
+                await fs.access(storageDir);
+                result.storage.accessiblePaths++;
+                // 获取磁盘空间信息（简化版本，仅适用于某些系统）
+                try {
+                    const stats = await fs.stat(storageDir);
+                    result.storage.totalSpace += 0;
+                    result.storage.freeSpace += 0;
+                }
+                catch (spaceError) {
+                    logger.warn(`Cannot get disk space info for ${storageDir}`);
+                }
+                logger.debug(`Storage path accessible: ${storageDir}`);
+            }
+            catch (error) {
+                logger.warn(`Storage path not accessible: ${storageDir}`);
+            }
+        }
+    }
+    async checkBundlesHealth(cfg, result) {
+        const effectiveDir = cfg.storageDirs[0]; // 使用第一个可访问的路径
+        const maxAgeHours = 72; // 3天未更新认为是过期的
+        const maxAgeMs = maxAgeHours * 60 * 60 * 1000;
+        try {
+            const bundleIds = await listBundles(effectiveDir);
+            result.bundles.total = bundleIds.length;
+            for (const bundleId of bundleIds) {
+                try {
+                    // 检查 bundle 是否存在
+                    const exists = await bundleExists(effectiveDir, bundleId);
+                    if (!exists) {
+                        result.bundles.corrupted++;
+                        logger.warn(`Bundle ${bundleId} missing from filesystem`);
+                        continue;
+                    }
+                    // 检查 manifest 是否可读
+                    const manifestPath = path.join(effectiveDir, bundleId, 'manifest.json');
+                    try {
+                        const manifest = await readManifest(manifestPath);
+                        // 检查是否过期
+                        const updatedAt = new Date(manifest.updatedAt).getTime();
+                        const ageMs = Date.now() - updatedAt;
+                        if (ageMs > maxAgeMs) {
+                            result.bundles.outdated++;
+                        }
+                        result.bundles.healthy++;
+                    }
+                    catch (manifestError) {
+                        result.bundles.corrupted++;
+                        logger.warn(`Bundle ${bundleId} has corrupted manifest`);
+                    }
+                }
+                catch (error) {
+                    result.bundles.corrupted++;
+                    logger.warn(`Bundle ${bundleId} health check failed`);
+                }
+            }
+        }
+        catch (error) {
+            logger.error('Failed to list bundles for health check', error instanceof Error ? error : undefined);
+        }
+    }
+    checkSchedulerHealth(result) {
+        try {
+            const jobsStatus = PreflightScheduler.getAllJobsStatus();
+            result.scheduler.totalJobs = Object.keys(jobsStatus).length;
+            for (const [jobName, status] of Object.entries(jobsStatus)) {
+                if (status.scheduled) {
+                    result.scheduler.runningJobs++;
+                }
+                if (status.lastError && status.retries > 0) {
+                    result.scheduler.failedJobs++;
+                }
+            }
+        }
+        catch (error) {
+            logger.error('Failed to check scheduler health', error instanceof Error ? error : undefined);
+        }
+    }
+    determineOverallHealth(result) {
+        // 如果有任何存储路径不可访问，状态为 error
+        if (result.storage.accessiblePaths < result.storage.totalPaths) {
+            result.status = 'error';
+            return;
+        }
+        // 如果有任何 bundles 损坏，状态为 error
+        if (result.bundles.corrupted > 0) {
+            result.status = 'error';
+            return;
+        }
+        // 如果有过时的 bundles，状态为 warning
+        if (result.bundles.outdated > 0) {
+            result.status = 'warning';
+            return;
+        }
+        // 如果调度器有失败的任务，状态为 warning
+        if (result.scheduler.failedJobs > 0) {
+            result.status = 'warning';
+            return;
+        }
+        // 否则状态为 healthy
+        result.status = 'healthy';
+    }
+}

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

@@ -0,0 +1,148 @@
+import { Job } from '../core/scheduler.js';
+import { getConfig } from '../config.js';
+import { listBundles, bundleExists, clearBundleMulti } from '../bundle/service.js';
+import { readManifest } from '../bundle/manifest.js';
+import { logger } from '../logging/logger.js';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export class StorageCleanupJob extends Job {
+    getName() {
+        return 'StorageCleanupJob';
+    }
+    getMaxRetries() {
+        return 1; // 清理任务通常不需要重试
+    }
+    getRetryDelay() {
+        return 10000; // 10秒重试延迟
+    }
+    async run() {
+        const cfg = getConfig();
+        const maxAgeDays = 30; // 30天未访问的 bundle 被认为是过期的
+        const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1000;
+        try {
+            const effectiveDir = cfg.storageDirs[0];
+            const bundleIds = await listBundles(effectiveDir);
+            let cleanedBundles = 0;
+            let freedSpace = 0;
+            const errors = [];
+            logger.info(`Scanning ${bundleIds.length} bundles for cleanup`, { maxAgeDays });
+            for (const bundleId of bundleIds) {
+                try {
+                    const bundlePath = path.join(effectiveDir, bundleId);
+                    const exists = await bundleExists(effectiveDir, bundleId);
+                    if (!exists) {
+                        logger.warn(`Bundle ${bundleId} not found, skipping`);
+                        continue;
+                    }
+                    // 检查最后访问时间
+                    const manifestPath = path.join(bundlePath, 'manifest.json');
+                    const manifest = await readManifest(manifestPath);
+                    const lastAccess = new Date(manifest.updatedAt).getTime();
+                    const ageMs = Date.now() - lastAccess;
+                    if (ageMs > maxAgeMs) {
+                        const size = await this.calculateDirectorySize(bundlePath);
+                        const ageDays = Math.floor(ageMs / (24 * 60 * 60 * 1000));
+                        logger.info(`Removing old bundle ${bundleId}`, { sizeMB: (size / 1024 / 1024).toFixed(2), ageDays });
+                        const deleted = await clearBundleMulti(cfg.storageDirs, bundleId);
+                        if (deleted) {
+                            cleanedBundles++;
+                            freedSpace += size;
+                        }
+                        else {
+                            errors.push(`Failed to delete bundle ${bundleId}`);
+                        }
+                    }
+                    else {
+                        const ageDays = Math.floor(ageMs / (24 * 60 * 60 * 1000));
+                        logger.debug(`Bundle ${bundleId} is recent, keeping`, { ageDays });
+                    }
+                }
+                catch (error) {
+                    const errorMsg = error instanceof Error ? error.message : String(error);
+                    errors.push(`Error processing bundle ${bundleId}: ${errorMsg}`);
+                    logger.error(`Error processing bundle ${bundleId}`, error instanceof Error ? error : undefined);
+                }
+            }
+            try {
+                const tmpFreed = await this.cleanupTempFiles();
+                freedSpace += tmpFreed;
+                logger.debug(`Cleaned up temporary files`, { freedMB: (tmpFreed / 1024 / 1024).toFixed(2) });
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                errors.push(`Temp file cleanup failed: ${errorMsg}`);
+            }
+            const result = {
+                cleanedBundles,
+                freedSpace,
+                errors,
+                maxAgeDays,
+                totalBundles: bundleIds.length
+            };
+            logger.info('Storage cleanup completed', { cleanedBundles, freedMB: (freedSpace / 1024 / 1024).toFixed(2), errors: errors.length });
+            return result;
+        }
+        catch (error) {
+            logger.error('Failed to cleanup storage', error instanceof Error ? error : undefined);
+            throw error;
+        }
+    }
+    async calculateDirectorySize(dirPath) {
+        let totalSize = 0;
+        try {
+            const entries = await fs.readdir(dirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dirPath, entry.name);
+                if (entry.isDirectory()) {
+                    totalSize += await this.calculateDirectorySize(fullPath);
+                }
+                else if (entry.isFile()) {
+                    const stats = await fs.stat(fullPath);
+                    totalSize += stats.size;
+                }
+            }
+        }
+        catch (error) {
+            logger.debug(`Cannot calculate size for ${dirPath}`);
+        }
+        return totalSize;
+    }
+    async cleanupTempFiles() {
+        const cfg = getConfig();
+        const tmpDir = cfg.tmpDir;
+        let freedSpace = 0;
+        try {
+            // 检查临时目录是否存在
+            try {
+                await fs.access(tmpDir);
+            }
+            catch {
+                // 临时目录不存在，无需清理
+                return 0;
+            }
+            const entries = await fs.readdir(tmpDir, { withFileTypes: true });
+            const now = Date.now();
+            const maxAgeMs = 24 * 60 * 60 * 1000; // 24小时
+            for (const entry of entries) {
+                const fullPath = path.join(tmpDir, entry.name);
+                try {
+                    const stats = await fs.stat(fullPath);
+                    const ageMs = now - stats.mtime.getTime();
+                    if (ageMs > maxAgeMs) {
+                        const size = stats.size;
+                        await fs.rm(fullPath, { recursive: true, force: true });
+                        freedSpace += size;
+                        logger.debug(`Removed old temp file/dir: ${entry.name}`);
+                    }
+                }
+                catch (error) {
+                    logger.debug(`Failed to remove temp file ${entry.name}`);
+                }
+            }
+        }
+        catch (error) {
+            logger.debug('Failed to cleanup temp files');
+        }
+        return freedSpace;
+    }
+}