@jshookmcp/jshook 0.2.6 → 0.2.8

package/dist/src/utils/artifactRetention.js

@@ -1,206 +0,0 @@
-import { readdir, rm, stat } from 'node:fs/promises';
-import { join, resolve } from 'node:path';
-import { getArtifactDir, getArtifactsRoot } from './artifacts.js';
-import { getProjectRoot, resolveOutputDirectory } from './outputPaths.js';
-import { logger } from './logger.js';
-const DAY_MS = 24 * 60 * 60 * 1000;
-export function getArtifactRetentionConfig(env = process.env) {
-    const retentionDays = Math.max(0, parseInt(env.MCP_ARTIFACT_RETENTION_DAYS ?? '0', 10) || 0);
-    const maxTotalMb = Math.max(0, parseInt(env.MCP_ARTIFACT_MAX_TOTAL_MB ?? '0', 10) || 0);
-    const cleanupIntervalMinutes = Math.max(0, parseInt(env.MCP_ARTIFACT_CLEANUP_INTERVAL_MINUTES ?? '0', 10) || 0);
-    const cleanupOnStart = ['1', 'true'].includes((env.MCP_ARTIFACT_CLEANUP_ON_START ?? '').toLowerCase());
-    return {
-        enabled: retentionDays > 0 || maxTotalMb > 0,
-        retentionDays,
-        maxTotalBytes: maxTotalMb * 1024 * 1024,
-        cleanupOnStart,
-        cleanupIntervalMinutes,
-    };
-}
-export async function cleanupArtifacts(options) {
-    const envConfig = getArtifactRetentionConfig();
-    const config = {
-        ...envConfig,
-        retentionDays: options?.retentionDays ?? envConfig.retentionDays,
-        maxTotalBytes: options?.maxTotalBytes ?? envConfig.maxTotalBytes,
-    };
-    const now = options?.now ?? Date.now();
-    const dryRun = options?.dryRun ?? false;
-    const directories = options?.directories ?? getManagedArtifactDirectories();
-    const entries = await collectArtifactFiles(directories);
-    let remaining = [...entries];
-    const removedSample = [];
-    let removedFiles = 0;
-    let removedBytes = 0;
-    let removedByAge = 0;
-    let removedBySize = 0;
-    const cutoff = config.retentionDays > 0 ? now - config.retentionDays * DAY_MS : 0;
-    if (cutoff > 0) {
-        const agedOut = remaining
-            .filter((entry) => entry.mtimeMs < cutoff)
-            .toSorted((a, b) => a.mtimeMs - b.mtimeMs);
-        if (agedOut.length > 0) {
-            const agedOutPaths = new Set(agedOut.map((entry) => entry.path));
-            remaining = remaining.filter((entry) => !agedOutPaths.has(entry.path));
-            removedFiles += agedOut.length;
-            removedBytes += agedOut.reduce((sum, entry) => sum + entry.size, 0);
-            removedByAge += agedOut.reduce((sum, entry) => sum + entry.size, 0);
-            removedSample.push(...agedOut.slice(0, 20 - removedSample.length).map((entry) => entry.relativePath));
-            if (!dryRun) {
-                await Promise.all(agedOut.map((entry) => rm(entry.path, { force: true })));
-            }
-        }
-    }
-    if (config.maxTotalBytes > 0) {
-        let totalBytes = remaining.reduce((sum, entry) => sum + entry.size, 0);
-        if (totalBytes > config.maxTotalBytes) {
-            const sizeCandidates = [...remaining].toSorted((a, b) => a.mtimeMs - b.mtimeMs);
-            const removedPaths = new Set();
-            for (const entry of sizeCandidates) {
-                if (totalBytes <= config.maxTotalBytes)
-                    break;
-                totalBytes -= entry.size;
-                removedPaths.add(entry.path);
-                removedFiles += 1;
-                removedBytes += entry.size;
-                removedBySize += entry.size;
-                if (removedSample.length < 20)
-                    removedSample.push(entry.relativePath);
-                if (!dryRun) {
-                    await rm(entry.path, { force: true });
-                }
-            }
-            remaining = remaining.filter((entry) => !removedPaths.has(entry.path));
-        }
-    }
-    if (!dryRun) {
-        await Promise.all(directories.map((dir) => pruneEmptyDirectories(dir)));
-    }
-    return {
-        success: true,
-        scannedFiles: entries.length,
-        removedFiles,
-        removedBytes,
-        removedByAge,
-        removedBySize,
-        remainingFiles: remaining.length,
-        remainingBytes: remaining.reduce((sum, entry) => sum + entry.size, 0),
-        dryRun,
-        directories,
-        removedSample,
-        config,
-    };
-}
-export function startArtifactRetentionScheduler() {
-    const config = getArtifactRetentionConfig();
-    if (!config.enabled || config.cleanupIntervalMinutes <= 0) {
-        return null;
-    }
-    const handle = setInterval(() => {
-        void cleanupArtifacts()
-            .then((result) => {
-            if (result.removedFiles > 0) {
-                logger.info(`[artifacts] retention cleanup removed ${result.removedFiles} files (${result.removedBytes} bytes)`);
-            }
-        })
-            .catch((error) => {
-            logger.warn('[artifacts] retention cleanup failed', error);
-        });
-    }, config.cleanupIntervalMinutes * 60 * 1000);
-    handle.unref();
-    return () => clearInterval(handle);
-}
-function getManagedArtifactDirectories() {
-    const projectRoot = getProjectRoot();
-    const directories = new Set([
-        getArtifactsRoot(),
-        resolveOutputDirectory(process.env.MCP_SCREENSHOT_DIR, 'screenshots'),
-        resolve(projectRoot, 'debugger-sessions'),
-        resolve(process.cwd(), 'debugger-sessions'),
-    ]);
-    const categories = [
-        'wasm',
-        'traces',
-        'profiles',
-        'dumps',
-        'reports',
-        'har',
-        'sessions',
-        'tmp',
-    ];
-    for (const category of categories) {
-        directories.add(getArtifactDir(category));
-    }
-    return [...directories];
-}
-async function collectArtifactFiles(directories) {
-    const root = getProjectRoot();
-    const files = [];
-    for (const directory of directories) {
-        await walk(directory, async (path) => {
-            const info = await stat(path);
-            if (!info.isFile())
-                return;
-            files.push({
-                path,
-                relativePath: relativePathFromRoot(root, path),
-                size: info.size,
-                mtimeMs: info.mtimeMs,
-            });
-        });
-    }
-    return dedupeFiles(files);
-}
-async function walk(directory, onFile) {
-    let entries;
-    try {
-        entries = await readdir(directory, { withFileTypes: true });
-    }
-    catch {
-        return;
-    }
-    for (const entry of entries) {
-        const path = join(directory, entry.name);
-        if (entry.isDirectory()) {
-            await walk(path, onFile);
-        }
-        else if (entry.isFile()) {
-            await onFile(path);
-        }
-    }
-}
-async function pruneEmptyDirectories(directory) {
-    let entries;
-    try {
-        entries = await readdir(directory, { withFileTypes: true });
-    }
-    catch {
-        return;
-    }
-    await Promise.all(entries
-        .filter((entry) => entry.isDirectory())
-        .map((entry) => pruneEmptyDirectories(join(directory, entry.name))));
-    try {
-        const after = await readdir(directory);
-        if (after.length === 0) {
-            await rm(directory, { recursive: true, force: true });
-        }
-    }
-    catch {
-    }
-}
-function dedupeFiles(files) {
-    const byPath = new Map();
-    for (const file of files) {
-        byPath.set(file.path, file);
-    }
-    return [...byPath.values()];
-}
-function relativePathFromRoot(root, path) {
-    return path.startsWith(root)
-        ? path
-            .slice(root.length)
-            .replace(/^[\\/]/, '')
-            .replace(/\\/g, '/')
-        : path.replace(/\\/g, '/');
-}

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

@@ -1,13 +0,0 @@
-export type ArtifactCategory = 'wasm' | 'traces' | 'profiles' | 'dumps' | 'reports' | 'har' | 'sessions' | 'tmp';
-export declare function resolveArtifactPath(options: {
-    category: ArtifactCategory;
-    toolName: string;
-    target?: string;
-    ext: string;
-    customDir?: string;
-}): Promise<{
-    absolutePath: string;
-    displayPath: string;
-}>;
-export declare function getArtifactsRoot(): string;
-export declare function getArtifactDir(category: ArtifactCategory): string;

package/dist/src/utils/artifacts.js

@@ -1,37 +0,0 @@
-import { mkdir } from 'node:fs/promises';
-import { resolve, relative, normalize, sep } from 'node:path';
-import { getProjectRoot } from './outputPaths.js';
-const ARTIFACT_BASE = 'artifacts';
-export async function resolveArtifactPath(options) {
-    const { category, toolName, target, ext, customDir } = options;
-    const root = getProjectRoot();
-    const dir = customDir ? resolve(root, customDir) : resolve(root, ARTIFACT_BASE, category);
-    const normalizedRoot = normalize(root);
-    const normalizedDir = normalize(dir);
-    if (normalizedDir !== normalizedRoot && !normalizedDir.startsWith(`${normalizedRoot}${sep}`)) {
-        throw new Error(`Path traversal blocked: artifact directory "${customDir}" escapes project root`);
-    }
-    await mkdir(dir, { recursive: true });
-    const ts = new Date().toISOString().replace(/[:.]/g, '-').replace('T', '_').slice(0, 19);
-    const shortId = Math.random().toString(36).substring(2, 8);
-    const safeName = sanitizeFilename(toolName);
-    const safeTarget = target ? `-${sanitizeFilename(target)}` : '';
-    const safeExt = ext.replace(/^\./, '');
-    const filename = `${safeName}${safeTarget}-${ts}-${shortId}.${safeExt}`;
-    const absolutePath = resolve(dir, filename);
-    const displayPath = relative(root, absolutePath).replace(/\\/g, '/');
-    return { absolutePath, displayPath };
-}
-export function getArtifactsRoot() {
-    return resolve(getProjectRoot(), ARTIFACT_BASE);
-}
-export function getArtifactDir(category) {
-    return resolve(getProjectRoot(), ARTIFACT_BASE, category);
-}
-function sanitizeFilename(name) {
-    return name
-        .replace(/[^a-zA-Z0-9_-]/g, '_')
-        .replace(/_+/g, '_')
-        .replace(/^_|_$/g, '')
-        .substring(0, 60);
-}

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

@@ -1,11 +0,0 @@
-export type BetterSqlite3Issue = 'missing' | 'abi-mismatch' | 'load-failed';
-export interface BetterSqlite3ProbeResult {
-    status: 'ok' | 'missing' | 'warn';
-    detail: string;
-    version: string | null;
-    issue?: BetterSqlite3Issue;
-}
-export declare function isBetterSqlite3RelatedError(error: unknown): boolean;
-export declare function classifyBetterSqlite3Issue(error: unknown): BetterSqlite3Issue;
-export declare function formatBetterSqlite3Error(error: unknown): string;
-export declare function probeBetterSqlite3(): BetterSqlite3ProbeResult;

package/dist/src/utils/betterSqlite3.js

@@ -1,88 +0,0 @@
-import { createRequire } from 'node:module';
-const require = createRequire(import.meta.url);
-const BETTER_SQLITE3_VERSION = '12.6.2';
-const INSTALL_HINT = `pnpm add -O better-sqlite3@${BETTER_SQLITE3_VERSION}`;
-const REBUILD_HINT = 'npm rebuild better-sqlite3 --foreground-scripts';
-function extractErrorMessage(error) {
-    if (error instanceof Error) {
-        return error.message;
-    }
-    return String(error);
-}
-export function isBetterSqlite3RelatedError(error) {
-    return /better-sqlite3|better_sqlite3\.node|NODE_MODULE_VERSION|compiled against a different Node\.js version/i.test(extractErrorMessage(error));
-}
-export function classifyBetterSqlite3Issue(error) {
-    const message = extractErrorMessage(error);
-    if (/Cannot find module 'better-sqlite3'|Cannot find package 'better-sqlite3'|better-sqlite3 is not installed/i.test(message)) {
-        return 'missing';
-    }
-    if (/better_sqlite3\.node|NODE_MODULE_VERSION|compiled against a different Node\.js version|module was compiled against/i.test(message)) {
-        return 'abi-mismatch';
-    }
-    return 'load-failed';
-}
-export function formatBetterSqlite3Error(error) {
-    const issue = classifyBetterSqlite3Issue(error);
-    const message = extractErrorMessage(error);
-    if (issue === 'missing') {
-        return `better-sqlite3 is not installed. Install the optional trace backend with \`${INSTALL_HINT}\`.`;
-    }
-    if (issue === 'abi-mismatch') {
-        return `better-sqlite3 is installed but its native binary is incompatible with the current Node.js runtime (${process.version}, ABI ${process.versions.modules}). Rebuild it with \`${REBUILD_HINT}\` or reinstall dependencies under the active Node version. Original error: ${message}`;
-    }
-    return `better-sqlite3 failed to initialize. Try \`${REBUILD_HINT}\` or reinstall dependencies under the active Node version. Original error: ${message}`;
-}
-function readBetterSqlite3Version() {
-    try {
-        const packageJsonPath = require.resolve('better-sqlite3/package.json');
-        const packageJson = require(packageJsonPath);
-        return packageJson.version ?? null;
-    }
-    catch {
-        return null;
-    }
-}
-export function probeBetterSqlite3() {
-    const version = readBetterSqlite3Version();
-    if (!version) {
-        return {
-            status: 'missing',
-            detail: `Optional SQLite backend for trace tools is not installed. Install it with: ${INSTALL_HINT}`,
-            version: null,
-            issue: 'missing',
-        };
-    }
-    try {
-        const Database = require('better-sqlite3');
-        const db = new Database(':memory:');
-        try {
-            db.prepare('SELECT 1 AS ok').get();
-        }
-        finally {
-            db.close();
-        }
-        return {
-            status: 'ok',
-            detail: `installed (${version}) — native trace backend healthy`,
-            version,
-        };
-    }
-    catch (error) {
-        const issue = classifyBetterSqlite3Issue(error);
-        if (issue === 'missing') {
-            return {
-                status: 'missing',
-                detail: `Optional SQLite backend for trace tools is not installed. Install it with: ${INSTALL_HINT}`,
-                version,
-                issue,
-            };
-        }
-        return {
-            status: 'warn',
-            detail: `installed (${version}) but ${formatBetterSqlite3Error(error)}`,
-            version,
-            issue,
-        };
-    }
-}

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

@@ -1,4 +0,0 @@
-export declare function findBrowserExecutable(): string | undefined;
-export declare function clearBrowserPathCache(): void;
-export declare function getCachedBrowserPath(): string | undefined;
-export declare const resolveBrowserExecutablePath: typeof findBrowserExecutable;

package/dist/src/utils/browserExecutable.js

@@ -1,41 +0,0 @@
-import { existsSync } from 'fs';
-import { executablePath } from 'rebrowser-puppeteer-core';
-const ENV_KEYS = ['CHROME_PATH', 'PUPPETEER_EXECUTABLE_PATH', 'BROWSER_EXECUTABLE_PATH'];
-let cachedBrowserPath = null;
-function resolveFromEnvironment() {
-    for (const key of ENV_KEYS) {
-        const candidate = process.env[key]?.trim();
-        if (candidate && existsSync(candidate)) {
-            return candidate;
-        }
-    }
-    return undefined;
-}
-function resolveFromPuppeteer() {
-    try {
-        const candidate = executablePath('chrome');
-        if (candidate && existsSync(candidate)) {
-            return candidate;
-        }
-    }
-    catch {
-    }
-    return undefined;
-}
-export function findBrowserExecutable() {
-    if (cachedBrowserPath !== null) {
-        if (!cachedBrowserPath || existsSync(cachedBrowserPath)) {
-            return cachedBrowserPath;
-        }
-        cachedBrowserPath = null;
-    }
-    cachedBrowserPath = resolveFromEnvironment() ?? resolveFromPuppeteer();
-    return cachedBrowserPath;
-}
-export function clearBrowserPathCache() {
-    cachedBrowserPath = null;
-}
-export function getCachedBrowserPath() {
-    return cachedBrowserPath ?? undefined;
-}
-export const resolveBrowserExecutablePath = findBrowserExecutable;

package/dist/src/utils/cache/CachedDecorator.d.ts

@@ -1,8 +0,0 @@
-import { PersistentCache } from './PersistentCache.js';
-export interface CachedOptions {
-    ttlMs?: number;
-    keyFn?: (...args: unknown[]) => string;
-    cache?: PersistentCache;
-}
-export declare function cached(options?: CachedOptions): (_target: object, propertyKey: string | symbol, descriptor: PropertyDescriptor) => PropertyDescriptor;
-export declare function withCache<T extends (...args: unknown[]) => Promise<unknown>>(fn: T, options?: CachedOptions): T;

package/dist/src/utils/cache/CachedDecorator.js

@@ -1,55 +0,0 @@
-import { PersistentCache } from './PersistentCache.js';
-function generateDefaultKey(...args) {
-    try {
-        return JSON.stringify(args);
-    }
-    catch {
-        return args.map((arg) => String(arg)).join('|');
-    }
-}
-export function cached(options = {}) {
-    return function (_target, propertyKey, descriptor) {
-        const originalMethod = descriptor.value;
-        const cache = options.cache ??
-            new PersistentCache({
-                name: `cached-${String(propertyKey)}`,
-                dbPath: '.jshookmcp/cache.db',
-            });
-        descriptor.value = async function (...args) {
-            const keyGenerator = options.keyFn ?? generateDefaultKey;
-            const key = keyGenerator(...args);
-            if (!cache.isReady()) {
-                await cache.init();
-            }
-            const hasKey = await cache.has(key);
-            if (hasKey) {
-                return await cache.get(key);
-            }
-            const result = await originalMethod.apply(this, args);
-            await cache.set(key, result, options.ttlMs);
-            return result;
-        };
-        return descriptor;
-    };
-}
-export function withCache(fn, options = {}) {
-    const cache = options.cache ??
-        new PersistentCache({
-            name: `withCache-${fn.name}`,
-            dbPath: '.jshookmcp/cache.db',
-        });
-    const keyGenerator = options.keyFn ?? generateDefaultKey;
-    return async function (...args) {
-        const key = keyGenerator(...args);
-        if (!cache.isReady()) {
-            await cache.init();
-        }
-        const hasKey = await cache.has(key);
-        if (hasKey) {
-            return await cache.get(key);
-        }
-        const result = await fn.apply(this, args);
-        await cache.set(key, result, options.ttlMs);
-        return result;
-    };
-}

package/dist/src/utils/cache/PersistentCache.d.ts

@@ -1,33 +0,0 @@
-export interface PersistentCacheOptions {
-    name?: string;
-    dbPath?: string;
-    defaultTTL?: number;
-    enabled?: boolean;
-}
-export declare class PersistentCache {
-    private db;
-    private options;
-    private initialized;
-    private stats;
-    constructor(options?: PersistentCacheOptions);
-    init(): Promise<void>;
-    private loadDatabase;
-    private resolveDbPath;
-    private createTables;
-    has(key: string): Promise<boolean>;
-    get<T>(key: string, ttlMs?: number): Promise<T | null>;
-    set<T>(key: string, value: T, ttlMs?: number): Promise<boolean>;
-    delete(key: string): Promise<boolean>;
-    clear(): Promise<void>;
-    cleanup(): Promise<number>;
-    getStats(): Promise<{
-        entries: number;
-        size: number;
-        hits: number;
-        misses: number;
-        hitRate: number;
-        ttl: number;
-    }>;
-    close(): Promise<void>;
-    isReady(): boolean;
-}