@jshookmcp/jshook 0.2.5 → 0.2.7

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.d.ts

@@ -1,12 +0,0 @@
-import type { CacheConfig } from '../types/index.js';
-export declare class CacheManager {
-    private config;
-    constructor(config: CacheConfig);
-    init(): Promise<void>;
-    private generateKey;
-    private getCachePath;
-    get<T>(key: string): Promise<T | null>;
-    set<T>(key: string, value: T): Promise<void>;
-    delete(key: string): Promise<void>;
-    clear(): Promise<void>;
-}

package/dist/src/utils/cache.js

@@ -1,97 +0,0 @@
-import { promises as fs } from 'fs';
-import { join } from 'path';
-import { createHash } from 'crypto';
-import { logger } from './logger.js';
-export class CacheManager {
-    config;
-    constructor(config) {
-        this.config = config;
-    }
-    async init() {
-        if (!this.config.enabled) {
-            return;
-        }
-        try {
-            await fs.mkdir(this.config.dir, { recursive: true });
-            logger.debug(`Cache directory initialized: ${this.config.dir}`);
-        }
-        catch (error) {
-            logger.error('Failed to initialize cache directory', error);
-        }
-    }
-    generateKey(key) {
-        return createHash('md5').update(key).digest('hex');
-    }
-    getCachePath(key) {
-        const hashedKey = this.generateKey(key);
-        return join(this.config.dir, `${hashedKey}.json`);
-    }
-    async get(key) {
-        if (!this.config.enabled) {
-            return null;
-        }
-        try {
-            const cachePath = this.getCachePath(key);
-            const data = await fs.readFile(cachePath, 'utf-8');
-            const cached = JSON.parse(data);
-            if (Date.now() - cached.timestamp > this.config.ttl * 1000) {
-                await this.delete(key);
-                return null;
-            }
-            logger.debug(`Cache hit: ${key}`);
-            return cached.value;
-        }
-        catch {
-            logger.debug(`Cache miss: ${key}`);
-            return null;
-        }
-    }
-    async set(key, value) {
-        if (!this.config.enabled) {
-            return;
-        }
-        try {
-            const cachePath = this.getCachePath(key);
-            const data = {
-                timestamp: Date.now(),
-                value,
-            };
-            await fs.writeFile(cachePath, JSON.stringify(data), 'utf-8');
-            logger.debug(`Cache set: ${key}`);
-        }
-        catch (error) {
-            logger.error('Failed to set cache', error);
-        }
-    }
-    async delete(key) {
-        if (!this.config.enabled) {
-            return;
-        }
-        try {
-            const cachePath = this.getCachePath(key);
-            await fs.unlink(cachePath);
-            logger.debug(`Cache deleted: ${key}`);
-        }
-        catch (error) {
-            if (error.code !== 'ENOENT') {
-                logger.warn('Cache delete failed:', error);
-            }
-        }
-    }
-    async clear() {
-        if (!this.config.enabled) {
-            return;
-        }
-        try {
-            const files = await fs.readdir(this.config.dir);
-            await Promise.all(files.map((file) => fs.unlink(join(this.config.dir, file))));
-            logger.info('Cache cleared');
-        }
-        catch (error) {
-            if (error.code === 'ENOENT') {
-                return;
-            }
-            logger.error('Failed to clear cache', error);
-        }
-    }
-}

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

@@ -1,6 +0,0 @@
-export interface CliFastPathResult {
-    handled: boolean;
-    exitCode: number;
-    output?: string;
-}
-export declare function resolveCliFastPath(args: string[], moduleUrl: string): CliFastPathResult;

package/dist/src/utils/cliFastPath.js

@@ -1,70 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-function getPackageVersion(moduleUrl) {
-    try {
-        let dirUrl = new URL('.', moduleUrl);
-        for (let i = 0; i < 5; i++) {
-            try {
-                const candidate = fileURLToPath(new URL('package.json', dirUrl));
-                const pkg = JSON.parse(readFileSync(candidate, 'utf8'));
-                if (pkg.version)
-                    return pkg.version;
-            }
-            catch {
-            }
-            const parentUrl = new URL('../', dirUrl);
-            if (parentUrl.href === dirUrl.href)
-                break;
-            dirUrl = parentUrl;
-        }
-    }
-    catch {
-    }
-    return process.env.npm_package_version ?? '0.0.0';
-}
-function buildHelpText(version) {
-    return [
-        `@jshookmcp/jshook ${version}`,
-        '',
-        'Usage:',
-        '  jshook [--help] [--version]',
-        '  jshookmcp [--help] [--version]',
-        '',
-        'Behavior:',
-        '  Starts the MCP server by default.',
-        '',
-        'Common environment variables:',
-        '  MCP_TRANSPORT=stdio|http',
-        '  MCP_TOOL_PROFILE=search|workflow|full',
-        '',
-    ].join('\n');
-}
-export function resolveCliFastPath(args, moduleUrl) {
-    const normalizedArgs = args.map((arg) => arg.trim()).filter(Boolean);
-    const showHelp = normalizedArgs.includes('--help') ||
-        normalizedArgs.includes('-h') ||
-        normalizedArgs[0] === 'help';
-    const showVersion = normalizedArgs.includes('--version') ||
-        normalizedArgs.includes('-v') ||
-        normalizedArgs.includes('-V') ||
-        normalizedArgs[0] === 'version';
-    if (showHelp) {
-        const version = getPackageVersion(moduleUrl);
-        return {
-            handled: true,
-            exitCode: 0,
-            output: buildHelpText(version),
-        };
-    }
-    if (showVersion) {
-        return {
-            handled: true,
-            exitCode: 0,
-            output: `${getPackageVersion(moduleUrl)}\n`,
-        };
-    }
-    return {
-        handled: false,
-        exitCode: 0,
-    };
-}

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

@@ -1,5 +0,0 @@
-type LimitFunction = <T>(fn: () => Promise<T> | T) => Promise<T>;
-export declare const ioLimit: LimitFunction;
-export declare const cpuLimit: LimitFunction;
-export declare const cdpLimit: LimitFunction;
-export {};

package/dist/src/utils/concurrency.js

@@ -1,43 +0,0 @@
-function pLimit(concurrency) {
-    if (concurrency < 1)
-        throw new RangeError('concurrency must be >= 1');
-    let activeCount = 0;
-    const queue = [];
-    function next() {
-        if (queue.length > 0 && activeCount < concurrency) {
-            activeCount++;
-            const resolve = queue.shift();
-            resolve();
-        }
-    }
-    function run(fn) {
-        return new Promise((resolve, reject) => {
-            const execute = async () => {
-                try {
-                    const result = await fn();
-                    resolve(result);
-                }
-                catch (err) {
-                    reject(err);
-                }
-                finally {
-                    activeCount--;
-                    next();
-                }
-            };
-            if (activeCount < concurrency) {
-                activeCount++;
-                void execute();
-            }
-            else {
-                queue.push(() => {
-                    void execute();
-                });
-            }
-        });
-    }
-    return run;
-}
-export const ioLimit = pLimit(parseInt(process.env.jshook_IO_CONCURRENCY || '4', 10));
-export const cpuLimit = pLimit(parseInt(process.env.jshook_CPU_CONCURRENCY || '2', 10));
-export const cdpLimit = pLimit(parseInt(process.env.jshook_CDP_CONCURRENCY || '2', 10));

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

@@ -1,7 +0,0 @@
-import type { Config } from '../types/index.js';
-export declare const projectRoot: string;
-export declare function getConfig(): Config;
-export declare function validateConfig(config: Config): {
-    valid: boolean;
-    errors: string[];
-};

package/dist/src/utils/config.js

@@ -1,258 +0,0 @@
-import { fileURLToPath } from 'node:url';
-import { join } from 'node:path';
-import { config as dotenvConfig } from 'dotenv';
-import { z } from 'zod';
-import { DEFAULT_SEARCH_CONFIG } from '../config/search-defaults.js';
-export const projectRoot = fileURLToPath(new URL('../..', import.meta.url));
-const envPath = fileURLToPath(new URL('../../.env', import.meta.url));
-let envLoaded = false;
-function loadEnvIfNeeded() {
-    if (envLoaded) {
-        return;
-    }
-    envLoaded = true;
-    const result = dotenvConfig({ path: envPath, quiet: true });
-    const errorCode = result.error?.code;
-    if (result.error && errorCode !== 'ENOENT') {
-        console.error('[Config] Warning: Failed to load .env file from configured path');
-        console.error(`[Config] Error: ${result.error.message}`);
-        console.error('[Config] Will use environment variables or defaults');
-    }
-    else if (!result.error && process.env.DEBUG === 'true') {
-        console.info('[Config] .env file loaded (debug mode)');
-    }
-}
-const envInt = (fallback) => z
-    .string()
-    .optional()
-    .transform((v) => (v ? parseInt(v, 10) : fallback))
-    .pipe(z.number().int().finite());
-const envBool = (fallback) => z
-    .string()
-    .optional()
-    .transform((v) => (v === undefined ? fallback : v === 'true'));
-const ConfigSchema = z.object({
-    PUPPETEER_HEADLESS: envBool(false),
-    PUPPETEER_TIMEOUT: envInt(30000).pipe(z.number().min(1000).max(300000)),
-    PUPPETEER_EXECUTABLE_PATH: z.string().optional(),
-    CHROME_PATH: z.string().optional(),
-    BROWSER_EXECUTABLE_PATH: z.string().optional(),
-    MCP_SERVER_NAME: z.string().optional().default('jshookmcp'),
-    MCP_SERVER_VERSION: z.string().optional().default('0.1.8'),
-    ENABLE_CACHE: envBool(false),
-    CACHE_DIR: z.string().optional().default('.cache'),
-    CACHE_TTL: envInt(3600).pipe(z.number().min(0)),
-    MAX_CONCURRENT_ANALYSIS: envInt(3).pipe(z.number().min(1).max(32)),
-    MAX_CODE_SIZE_MB: envInt(10).pipe(z.number().min(1).max(500)),
-});
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function parseJsonArrayEnv(key) {
-    const raw = process.env[key];
-    if (!raw) {
-        return undefined;
-    }
-    try {
-        const parsed = JSON.parse(raw);
-        return Array.isArray(parsed) ? parsed : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function parseSearchQueryCategoryProfiles() {
-    const parsed = parseJsonArrayEnv('SEARCH_QUERY_CATEGORY_PROFILES_JSON');
-    if (parsed === undefined) {
-        return undefined;
-    }
-    return parsed.flatMap((entry) => {
-        if (!isRecord(entry) ||
-            typeof entry.pattern !== 'string' ||
-            !Array.isArray(entry.domainBoosts)) {
-            return [];
-        }
-        const domainBoosts = entry.domainBoosts.flatMap((boost) => {
-            if (!isRecord(boost) ||
-                typeof boost.domain !== 'string' ||
-                typeof boost.weight !== 'number') {
-                return [];
-            }
-            return [{ domain: boost.domain, weight: boost.weight }];
-        });
-        return [
-            {
-                pattern: entry.pattern,
-                flags: typeof entry.flags === 'string' ? entry.flags : undefined,
-                domainBoosts,
-            },
-        ];
-    });
-}
-function parseCjkQueryAliases() {
-    const parsed = parseJsonArrayEnv('SEARCH_CJK_QUERY_ALIASES_JSON');
-    if (parsed === undefined) {
-        return undefined;
-    }
-    return parsed.flatMap((entry) => {
-        if (!isRecord(entry) || typeof entry.pattern !== 'string' || !Array.isArray(entry.tokens)) {
-            return [];
-        }
-        const tokens = entry.tokens.filter((token) => typeof token === 'string');
-        return [
-            {
-                pattern: entry.pattern,
-                flags: typeof entry.flags === 'string' ? entry.flags : undefined,
-                tokens,
-            },
-        ];
-    });
-}
-function parseIntentToolBoostRules() {
-    const parsed = parseJsonArrayEnv('SEARCH_INTENT_TOOL_BOOST_RULES_JSON');
-    if (parsed === undefined) {
-        return undefined;
-    }
-    return parsed.flatMap((entry) => {
-        if (!isRecord(entry) || typeof entry.pattern !== 'string' || !Array.isArray(entry.boosts)) {
-            return [];
-        }
-        const boosts = entry.boosts.flatMap((boost) => {
-            if (!isRecord(boost) || typeof boost.tool !== 'string' || typeof boost.bonus !== 'number') {
-                return [];
-            }
-            return [{ tool: boost.tool, bonus: boost.bonus }];
-        });
-        return [
-            {
-                pattern: entry.pattern,
-                flags: typeof entry.flags === 'string' ? entry.flags : undefined,
-                boosts,
-            },
-        ];
-    });
-}
-function cloneSearchConfig(search) {
-    return {
-        queryCategoryProfiles: search.queryCategoryProfiles.map((profile) => ({
-            pattern: profile.pattern,
-            flags: profile.flags,
-            domainBoosts: profile.domainBoosts.map((boost) => ({
-                domain: boost.domain,
-                weight: boost.weight,
-            })),
-        })),
-        cjkQueryAliases: search.cjkQueryAliases.map((alias) => ({
-            pattern: alias.pattern,
-            flags: alias.flags,
-            tokens: [...alias.tokens],
-        })),
-        intentToolBoostRules: search.intentToolBoostRules.map((rule) => ({
-            pattern: rule.pattern,
-            flags: rule.flags,
-            boosts: rule.boosts.map((boost) => ({
-                tool: boost.tool,
-                bonus: boost.bonus,
-            })),
-        })),
-    };
-}
-function buildSearchConfig() {
-    const defaults = cloneSearchConfig(DEFAULT_SEARCH_CONFIG);
-    return {
-        queryCategoryProfiles: parseSearchQueryCategoryProfiles() ?? defaults.queryCategoryProfiles,
-        cjkQueryAliases: parseCjkQueryAliases() ?? defaults.cjkQueryAliases,
-        intentToolBoostRules: parseIntentToolBoostRules() ?? defaults.intentToolBoostRules,
-    };
-}
-export function getConfig() {
-    loadEnvIfNeeded();
-    const parsed = ConfigSchema.safeParse(process.env);
-    if (!parsed.success) {
-        const issues = parsed.error.issues.map((i) => `  ${i.path.join('.')}: ${i.message}`);
-        console.error(`[Config] Validation errors:\n${issues.join('\n')}`);
-        console.error('[Config] Falling back to safe defaults for invalid fields');
-    }
-    const env = parsed.success ? parsed.data : process.env;
-    const cacheDir = env.CACHE_DIR || '.cache';
-    const configuredExecutablePath = env.PUPPETEER_EXECUTABLE_PATH ||
-        env.CHROME_PATH ||
-        env.BROWSER_EXECUTABLE_PATH;
-    const absoluteCacheDir = cacheDir.startsWith('/') || cacheDir.match(/^[A-Za-z]:/)
-        ? cacheDir
-        : join(projectRoot, cacheDir);
-    const search = buildSearchConfig();
-    return {
-        puppeteer: {
-            headless: parsed.success
-                ? env.PUPPETEER_HEADLESS
-                : process.env.PUPPETEER_HEADLESS === 'true',
-            timeout: parsed.success
-                ? env.PUPPETEER_TIMEOUT
-                : parseInt(process.env.PUPPETEER_TIMEOUT || '30000', 10),
-            executablePath: configuredExecutablePath?.trim() || undefined,
-        },
-        mcp: {
-            name: env.MCP_SERVER_NAME || 'jshookmcp',
-            version: env.MCP_SERVER_VERSION || '0.1.8',
-        },
-        cache: {
-            enabled: parsed.success
-                ? env.ENABLE_CACHE
-                : process.env.ENABLE_CACHE === 'true',
-            dir: absoluteCacheDir,
-            ttl: parsed.success
-                ? env.CACHE_TTL
-                : parseInt(process.env.CACHE_TTL || '3600', 10),
-        },
-        performance: {
-            maxConcurrentAnalysis: parsed.success
-                ? env.MAX_CONCURRENT_ANALYSIS
-                : parseInt(process.env.MAX_CONCURRENT_ANALYSIS || '3', 10),
-            maxCodeSizeMB: parsed.success
-                ? env.MAX_CODE_SIZE_MB
-                : parseInt(process.env.MAX_CODE_SIZE_MB || '10', 10),
-        },
-        search,
-    };
-}
-export function validateConfig(config) {
-    const errors = [];
-    if (config.performance.maxConcurrentAnalysis < 1) {
-        errors.push('maxConcurrentAnalysis must be at least 1');
-    }
-    if (config.performance.maxCodeSizeMB < 1) {
-        errors.push('maxCodeSizeMB must be at least 1');
-    }
-    if (config.puppeteer.timeout < 1000) {
-        errors.push('puppeteer.timeout must be at least 1000ms');
-    }
-    if (config.cache.ttl < 0) {
-        errors.push('cache.ttl must be non-negative');
-    }
-    for (const profile of config.search.queryCategoryProfiles) {
-        try {
-            void new RegExp(profile.pattern, profile.flags);
-        }
-        catch {
-            errors.push(`search.queryCategoryProfiles contains invalid regex: ${profile.pattern}`);
-        }
-    }
-    for (const alias of config.search.cjkQueryAliases) {
-        try {
-            void new RegExp(alias.pattern, alias.flags);
-        }
-        catch {
-            errors.push(`search.cjkQueryAliases contains invalid regex: ${alias.pattern}`);
-        }
-    }
-    for (const rule of config.search.intentToolBoostRules) {
-        try {
-            void new RegExp(rule.pattern, rule.flags);
-        }
-        catch {
-            errors.push(`search.intentToolBoostRules contains invalid regex: ${rule.pattern}`);
-        }
-    }
-    return { valid: errors.length === 0, errors };
-}

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

@@ -1,27 +0,0 @@
-export type DoctorStatus = 'ok' | 'warn' | 'missing' | 'error';
-export interface DoctorCheck {
-    name: string;
-    status: DoctorStatus;
-    detail: string;
-}
-export interface EnvironmentDoctorReport {
-    success: boolean;
-    generatedAt: string;
-    runtime: {
-        platform: NodeJS.Platform;
-        arch: string;
-        node: string;
-        cwd: string;
-        projectRoot: string;
-    };
-    packages: DoctorCheck[];
-    commands: DoctorCheck[];
-    bridges: DoctorCheck[];
-    config: Record<string, unknown>;
-    limitations: string[];
-    recommendations: string[];
-}
-export declare function runEnvironmentDoctor(options?: {
-    includeBridgeHealth?: boolean;
-}): Promise<EnvironmentDoctorReport>;
-export declare function formatEnvironmentDoctorReport(report: EnvironmentDoctorReport): string;