@jshookmcp/jshook 0.2.6 → 0.2.8

package/dist/src/utils/UnifiedCacheManager.js

@@ -1,205 +0,0 @@
-import { logger } from './logger.js';
-import { CACHE_GLOBAL_MAX_SIZE_BYTES, CACHE_LOW_HIT_RATE_THRESHOLD } from '../constants.js';
-export class UnifiedCacheManager {
-    static instance;
-    GLOBAL_MAX_SIZE = CACHE_GLOBAL_MAX_SIZE_BYTES;
-    LOW_HIT_RATE_THRESHOLD = CACHE_LOW_HIT_RATE_THRESHOLD;
-    caches = new Map();
-    constructor() {
-        logger.info('UnifiedCacheManager initialized');
-    }
-    static getInstance() {
-        if (!this.instance) {
-            this.instance = new UnifiedCacheManager();
-        }
-        return this.instance;
-    }
-    registerCache(cache) {
-        this.caches.set(cache.name, cache);
-        logger.info(`Registered cache: ${cache.name}`);
-    }
-    unregisterCache(name) {
-        this.caches.delete(name);
-        logger.info(`Unregistered cache: ${name}`);
-    }
-    async getGlobalStats() {
-        let totalEntries = 0;
-        let totalSize = 0;
-        let totalHits = 0;
-        let totalMisses = 0;
-        const cacheStats = [];
-        for (const [name, cache] of this.caches) {
-            try {
-                const stats = await cache.getStats();
-                totalEntries += stats.entries;
-                totalSize += stats.size;
-                totalHits += stats.hits || 0;
-                totalMisses += stats.misses || 0;
-                cacheStats.push({
-                    name,
-                    entries: stats.entries,
-                    size: stats.size,
-                    sizeMB: (stats.size / 1024 / 1024).toFixed(2),
-                    hitRate: stats.hitRate,
-                    ttl: stats.ttl,
-                });
-            }
-            catch (error) {
-                logger.error(`Failed to get stats for cache ${name}:`, error);
-            }
-        }
-        const hitRate = totalHits + totalMisses > 0 ? totalHits / (totalHits + totalMisses) : 0;
-        const recommendations = this.generateRecommendations(totalSize, hitRate, cacheStats);
-        return {
-            totalEntries,
-            totalSize,
-            totalSizeMB: (totalSize / 1024 / 1024).toFixed(2),
-            hitRate,
-            caches: cacheStats,
-            recommendations,
-        };
-    }
-    async smartCleanup(targetSize) {
-        const target = targetSize || this.GLOBAL_MAX_SIZE * 0.7;
-        const beforeStats = await this.getGlobalStats();
-        const beforeSize = beforeStats.totalSize;
-        if (beforeSize <= target) {
-            logger.info('No cleanup needed');
-            return {
-                before: beforeSize,
-                after: beforeSize,
-                freed: 0,
-                freedPercentage: 0,
-            };
-        }
-        logger.info(`Smart cleanup: current ${beforeStats.totalSizeMB}MB, ` +
-            `target ${(target / 1024 / 1024).toFixed(2)}MB`);
-        await this.cleanupExpired();
-        let currentStats = await this.getGlobalStats();
-        if (currentStats.totalSize <= target) {
-            return this.calculateCleanupResult(beforeSize, currentStats.totalSize);
-        }
-        await this.cleanupLowHitRate();
-        currentStats = await this.getGlobalStats();
-        if (currentStats.totalSize <= target) {
-            return this.calculateCleanupResult(beforeSize, currentStats.totalSize);
-        }
-        await this.cleanupLargeItems();
-        const afterStats = await this.getGlobalStats();
-        return this.calculateCleanupResult(beforeSize, afterStats.totalSize);
-    }
-    async cleanupExpired() {
-        logger.info('Cleaning up expired data...');
-        for (const [name, cache] of this.caches) {
-            if (cache.cleanup) {
-                try {
-                    await cache.cleanup();
-                    logger.debug(`Cleaned up expired data in ${name}`);
-                }
-                catch (error) {
-                    logger.error(`Failed to cleanup ${name}:`, error);
-                }
-            }
-        }
-    }
-    async cleanupLowHitRate() {
-        logger.info('Cleaning up low hit rate caches...');
-        const stats = await this.getGlobalStats();
-        const avgHitRate = stats.hitRate;
-        for (const cacheStats of stats.caches) {
-            if (cacheStats.hitRate !== undefined &&
-                cacheStats.hitRate < avgHitRate * this.LOW_HIT_RATE_THRESHOLD) {
-                const cache = this.caches.get(cacheStats.name);
-                if (cache?.clear) {
-                    try {
-                        await cache.clear();
-                        logger.info(`Cleared low hit rate cache: ${cacheStats.name} (${(cacheStats.hitRate * 100).toFixed(1)}%)`);
-                    }
-                    catch (error) {
-                        logger.error(`Failed to clear ${cacheStats.name}:`, error);
-                    }
-                }
-            }
-        }
-    }
-    async cleanupLargeItems() {
-        logger.info('Cleaning up large caches...');
-        const stats = await this.getGlobalStats();
-        const sortedCaches = stats.caches.toSorted((a, b) => b.size - a.size);
-        for (const cacheStats of sortedCaches.slice(0, 2)) {
-            const cache = this.caches.get(cacheStats.name);
-            if (cache?.clear) {
-                try {
-                    await cache.clear();
-                    logger.info(`Cleared large cache: ${cacheStats.name} (${cacheStats.sizeMB}MB)`);
-                }
-                catch (error) {
-                    logger.error(`Failed to clear ${cacheStats.name}:`, error);
-                }
-            }
-        }
-    }
-    calculateCleanupResult(before, after) {
-        const freed = before - after;
-        const freedPercentage = Math.round((freed / this.GLOBAL_MAX_SIZE) * 100);
-        logger.info(`Cleanup complete! Freed ${(freed / 1024 / 1024).toFixed(2)}MB (${freedPercentage}%). ` +
-            `Usage: ${(after / 1024 / 1024).toFixed(2)}MB/${(this.GLOBAL_MAX_SIZE / 1024 / 1024).toFixed(0)}MB`);
-        return {
-            before,
-            after,
-            freed,
-            freedPercentage,
-        };
-    }
-    async clearAll() {
-        logger.info('Clearing all caches...');
-        for (const [name, cache] of this.caches) {
-            if (cache.clear) {
-                try {
-                    await cache.clear();
-                    logger.info(`Cleared cache: ${name}`);
-                }
-                catch (error) {
-                    logger.error(`Failed to clear ${name}:`, error);
-                }
-            }
-        }
-        logger.success('All caches cleared');
-    }
-    async preheat(urls) {
-        logger.info(`Preheating cache for ${urls.length} URLs...`);
-        logger.info('Cache preheat completed');
-    }
-    generateRecommendations(totalSize, hitRate, cacheStats) {
-        const recommendations = [];
-        const sizeRatio = totalSize / this.GLOBAL_MAX_SIZE;
-        if (sizeRatio >= 0.9) {
-            recommendations.push(' CRITICAL: Cache size at 90%. Run smart_cache_cleanup immediately!');
-        }
-        else if (sizeRatio >= 0.7) {
-            recommendations.push('WARNING: Cache size at 70%. Consider cleanup soon.');
-        }
-        else if (sizeRatio >= 0.5) {
-            recommendations.push('INFO: Cache size at 50%. Monitor usage.');
-        }
-        if (hitRate < 0.3) {
-            recommendations.push(' Low cache hit rate (<30%). Consider adjusting TTL or cache strategy.');
-        }
-        else if (hitRate > 0.7) {
-            recommendations.push(' Good cache hit rate (>70%). Cache is working well.');
-        }
-        for (const cache of cacheStats) {
-            const cacheRatio = cache.size / totalSize;
-            if (cacheRatio > 0.5) {
-                recommendations.push(` ${cache.name} uses ${Math.round(cacheRatio * 100)}% of total cache. Consider cleanup.`);
-            }
-            if (cache.hitRate !== undefined && cache.hitRate < 0.2) {
-                recommendations.push(` ${cache.name} has low hit rate (${(cache.hitRate * 100).toFixed(1)}%). Consider disabling or adjusting.`);
-            }
-        }
-        if (recommendations.length === 0) {
-            recommendations.push(' Cache health is good. No action needed.');
-        }
-        return recommendations;
-    }
-}

package/dist/src/utils/WorkerPool.d.ts

@@ -1,38 +0,0 @@
-import { type ResourceLimits } from 'node:worker_threads';
-export interface WorkerPoolOptions {
-    name?: string;
-    workerScript: string;
-    minWorkers?: number;
-    maxWorkers?: number;
-    idleTimeoutMs?: number;
-    resourceLimits?: ResourceLimits;
-}
-export declare class WorkerPool<TPayload extends Record<string, unknown>, TResult> {
-    private readonly name;
-    private readonly workerScript;
-    private readonly minWorkers;
-    private readonly maxWorkers;
-    private readonly idleTimeoutMs;
-    private readonly resourceLimits?;
-    private readonly workers;
-    private readonly queuedJobs;
-    private readonly activeJobs;
-    private nextWorkerId;
-    private nextJobId;
-    private closed;
-    constructor(options: WorkerPoolOptions);
-    submit(payload: TPayload, timeoutMs?: number): Promise<TResult>;
-    close(): Promise<void>;
-    private ensureMinWorkers;
-    private pumpQueue;
-    private findIdleWorker;
-    private spawnWorker;
-    private dispatchJob;
-    private handleWorkerMessage;
-    private handleWorkerFailure;
-    private handleWorkerExit;
-    private handleJobTimeout;
-    private armIdleTimer;
-    private terminateWorker;
-    private toError;
-}

package/dist/src/utils/WorkerPool.js

@@ -1,272 +0,0 @@
-import { Worker } from 'node:worker_threads';
-import { WORKER_POOL_MIN_WORKERS, WORKER_POOL_MAX_WORKERS, WORKER_POOL_IDLE_TIMEOUT_MS, WORKER_POOL_JOB_TIMEOUT_MS, } from '../constants.js';
-const DEFAULT_MIN_WORKERS = WORKER_POOL_MIN_WORKERS;
-const DEFAULT_MAX_WORKERS = WORKER_POOL_MAX_WORKERS;
-const DEFAULT_IDLE_TIMEOUT_MS = WORKER_POOL_IDLE_TIMEOUT_MS;
-const DEFAULT_JOB_TIMEOUT_MS = WORKER_POOL_JOB_TIMEOUT_MS;
-export class WorkerPool {
-    name;
-    workerScript;
-    minWorkers;
-    maxWorkers;
-    idleTimeoutMs;
-    resourceLimits;
-    workers = new Map();
-    queuedJobs = [];
-    activeJobs = new Map();
-    nextWorkerId = 1;
-    nextJobId = 1;
-    closed = false;
-    constructor(options) {
-        this.name = options.name ?? 'worker-pool';
-        this.workerScript = options.workerScript;
-        this.minWorkers = options.minWorkers ?? DEFAULT_MIN_WORKERS;
-        this.maxWorkers = options.maxWorkers ?? DEFAULT_MAX_WORKERS;
-        this.idleTimeoutMs = options.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
-        this.resourceLimits = options.resourceLimits;
-        if (!this.workerScript || this.workerScript.trim().length === 0) {
-            throw this.toError('workerScript must be a non-empty string');
-        }
-        if (!Number.isInteger(this.minWorkers) || this.minWorkers < 0) {
-            throw this.toError('minWorkers must be an integer >= 0');
-        }
-        if (!Number.isInteger(this.maxWorkers) || this.maxWorkers < 1) {
-            throw this.toError('maxWorkers must be an integer >= 1');
-        }
-        if (this.minWorkers > this.maxWorkers) {
-            throw this.toError('minWorkers cannot be greater than maxWorkers');
-        }
-        this.ensureMinWorkers();
-    }
-    submit(payload, timeoutMs = DEFAULT_JOB_TIMEOUT_MS) {
-        if (this.closed) {
-            return Promise.reject(this.toError('pool is closed'));
-        }
-        return new Promise((resolve, reject) => {
-            const job = {
-                id: this.nextJobId++,
-                payload,
-                timeoutMs,
-                resolve,
-                reject,
-            };
-            this.queuedJobs.push(job);
-            this.pumpQueue();
-        });
-    }
-    async close() {
-        if (this.closed)
-            return;
-        this.closed = true;
-        const closeError = this.toError('pool is closed');
-        while (this.queuedJobs.length > 0) {
-            const job = this.queuedJobs.shift();
-            job?.reject(closeError);
-        }
-        for (const activeJob of this.activeJobs.values()) {
-            if (activeJob.timeoutHandle) {
-                clearTimeout(activeJob.timeoutHandle);
-            }
-            activeJob.reject(closeError);
-        }
-        this.activeJobs.clear();
-        const workerIds = Array.from(this.workers.keys());
-        await Promise.all(workerIds.map((workerId) => this.terminateWorker(workerId)));
-    }
-    ensureMinWorkers() {
-        if (this.closed)
-            return;
-        while (this.workers.size < this.minWorkers) {
-            this.spawnWorker();
-        }
-    }
-    pumpQueue() {
-        if (this.closed)
-            return;
-        while (this.queuedJobs.length > 0) {
-            let worker = this.findIdleWorker();
-            if (!worker) {
-                if (this.workers.size < this.maxWorkers) {
-                    worker = this.spawnWorker();
-                }
-                else {
-                    return;
-                }
-            }
-            const job = this.queuedJobs.shift();
-            if (!job)
-                return;
-            this.dispatchJob(worker, job);
-        }
-    }
-    findIdleWorker() {
-        for (const worker of this.workers.values()) {
-            if (!worker.busy)
-                return worker;
-        }
-        return undefined;
-    }
-    spawnWorker() {
-        const id = this.nextWorkerId++;
-        const worker = new Worker(this.workerScript, {
-            eval: true,
-            resourceLimits: this.resourceLimits,
-        });
-        const pooled = {
-            id,
-            worker,
-            busy: false,
-            activeJobId: null,
-            idleTimer: null,
-        };
-        worker.on('message', (message) => this.handleWorkerMessage(id, message));
-        worker.on('error', (error) => this.handleWorkerFailure(id, error));
-        worker.on('exit', (code) => this.handleWorkerExit(id, code));
-        this.workers.set(id, pooled);
-        return pooled;
-    }
-    dispatchJob(worker, job) {
-        worker.busy = true;
-        worker.activeJobId = job.id;
-        if (worker.idleTimer) {
-            clearTimeout(worker.idleTimer);
-            worker.idleTimer = null;
-        }
-        const timeoutHandle = setTimeout(() => {
-            this.handleJobTimeout(job.id, job.timeoutMs);
-        }, job.timeoutMs);
-        this.activeJobs.set(job.id, {
-            ...job,
-            workerId: worker.id,
-            timeoutHandle,
-        });
-        try {
-            worker.worker.postMessage({
-                jobId: job.id,
-                payload: job.payload,
-            });
-        }
-        catch (error) {
-            const activeJob = this.activeJobs.get(job.id);
-            if (activeJob?.timeoutHandle)
-                clearTimeout(activeJob.timeoutHandle);
-            this.activeJobs.delete(job.id);
-            worker.busy = false;
-            worker.activeJobId = null;
-            job.reject(this.toError(error instanceof Error ? error.message : String(error)));
-            void this.terminateWorker(worker.id).then(() => {
-                this.ensureMinWorkers();
-                this.pumpQueue();
-            });
-        }
-    }
-    handleWorkerMessage(workerId, message) {
-        const envelope = message;
-        if (!envelope || typeof envelope !== 'object' || typeof envelope.jobId !== 'number') {
-            return;
-        }
-        const activeJob = this.activeJobs.get(envelope.jobId);
-        if (!activeJob)
-            return;
-        if (activeJob.timeoutHandle)
-            clearTimeout(activeJob.timeoutHandle);
-        this.activeJobs.delete(envelope.jobId);
-        const worker = this.workers.get(workerId);
-        if (worker) {
-            worker.busy = false;
-            worker.activeJobId = null;
-            this.armIdleTimer(worker);
-        }
-        if (!envelope.ok) {
-            activeJob.reject(this.toError(envelope.error ?? 'worker task failed'));
-        }
-        else if (typeof envelope.result === 'undefined') {
-            activeJob.reject(this.toError('worker returned empty result'));
-        }
-        else {
-            activeJob.resolve(envelope.result);
-        }
-        this.pumpQueue();
-    }
-    handleWorkerFailure(workerId, error) {
-        const worker = this.workers.get(workerId);
-        if (!worker)
-            return;
-        const activeJobId = worker.activeJobId;
-        if (activeJobId !== null) {
-            const activeJob = this.activeJobs.get(activeJobId);
-            if (activeJob) {
-                if (activeJob.timeoutHandle)
-                    clearTimeout(activeJob.timeoutHandle);
-                this.activeJobs.delete(activeJobId);
-                activeJob.reject(this.toError(error.message));
-            }
-        }
-        void this.terminateWorker(workerId).then(() => {
-            this.ensureMinWorkers();
-            this.pumpQueue();
-        });
-    }
-    handleWorkerExit(workerId, code) {
-        const worker = this.workers.get(workerId);
-        if (!worker)
-            return;
-        const activeJobId = worker.activeJobId;
-        this.workers.delete(workerId);
-        if (worker.idleTimer)
-            clearTimeout(worker.idleTimer);
-        if (activeJobId !== null) {
-            const activeJob = this.activeJobs.get(activeJobId);
-            if (activeJob) {
-                if (activeJob.timeoutHandle)
-                    clearTimeout(activeJob.timeoutHandle);
-                this.activeJobs.delete(activeJobId);
-                activeJob.reject(this.toError(`worker exited unexpectedly with code ${code}`));
-            }
-        }
-        this.ensureMinWorkers();
-        this.pumpQueue();
-    }
-    handleJobTimeout(jobId, timeoutMs) {
-        const activeJob = this.activeJobs.get(jobId);
-        if (!activeJob)
-            return;
-        this.activeJobs.delete(jobId);
-        activeJob.reject(this.toError(`worker task timed out after ${timeoutMs}ms`));
-        void this.terminateWorker(activeJob.workerId).then(() => {
-            this.ensureMinWorkers();
-            this.pumpQueue();
-        });
-    }
-    armIdleTimer(worker) {
-        if (this.idleTimeoutMs <= 0 || this.workers.size <= this.minWorkers)
-            return;
-        if (worker.idleTimer)
-            clearTimeout(worker.idleTimer);
-        worker.idleTimer = setTimeout(() => {
-            const current = this.workers.get(worker.id);
-            if (!current || current.busy || this.workers.size <= this.minWorkers)
-                return;
-            void this.terminateWorker(worker.id);
-        }, this.idleTimeoutMs);
-    }
-    async terminateWorker(workerId) {
-        const worker = this.workers.get(workerId);
-        if (!worker)
-            return;
-        this.workers.delete(workerId);
-        if (worker.idleTimer)
-            clearTimeout(worker.idleTimer);
-        worker.worker.removeAllListeners('message');
-        worker.worker.removeAllListeners('error');
-        worker.worker.removeAllListeners('exit');
-        try {
-            await worker.worker.terminate();
-        }
-        catch {
-        }
-    }
-    toError(message) {
-        return new Error(`[${this.name}] ${message}`);
-    }
-}

package/dist/src/utils/artifactRetention.d.ts

@@ -1,30 +0,0 @@
-export interface ArtifactRetentionConfig {
-    enabled: boolean;
-    retentionDays: number;
-    maxTotalBytes: number;
-    cleanupOnStart: boolean;
-    cleanupIntervalMinutes: number;
-}
-export interface ArtifactCleanupResult {
-    success: boolean;
-    scannedFiles: number;
-    removedFiles: number;
-    removedBytes: number;
-    removedByAge: number;
-    removedBySize: number;
-    remainingFiles: number;
-    remainingBytes: number;
-    dryRun: boolean;
-    directories: string[];
-    removedSample: string[];
-    config: ArtifactRetentionConfig;
-}
-export declare function getArtifactRetentionConfig(env?: NodeJS.ProcessEnv): ArtifactRetentionConfig;
-export declare function cleanupArtifacts(options?: {
-    retentionDays?: number;
-    maxTotalBytes?: number;
-    dryRun?: boolean;
-    now?: number;
-    directories?: string[];
-}): Promise<ArtifactCleanupResult>;
-export declare function startArtifactRetentionScheduler(): (() => void) | null;