@jshookmcp/jshook 0.2.6 → 0.2.8

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;

package/dist/src/utils/environmentDoctor.js

@@ -1,324 +0,0 @@
-import { promisify } from 'node:util';
-import { execFile } from 'node:child_process';
-import { createRequire } from 'node:module';
-import { ToolRegistry } from '../modules/external/ToolRegistry.js';
-import { GHIDRA_BRIDGE_ENDPOINT, IDA_BRIDGE_ENDPOINT } from '../constants.js';
-import { getProjectRoot } from './outputPaths.js';
-import { getArtifactRetentionConfig } from './artifactRetention.js';
-import { probeBetterSqlite3 } from './betterSqlite3.js';
-const execFileAsync = promisify(execFile);
-const require = createRequire(import.meta.url);
-export async function runEnvironmentDoctor(options) {
-    const includeBridgeHealth = options?.includeBridgeHealth ?? true;
-    const registry = new ToolRegistry();
-    const externalResults = await registry.probeAll(true);
-    const gitCommand = await checkCommand('git', ['--version']);
-    const pythonCommand = await checkCommand('python', ['--version']);
-    const pnpmCommand = await checkPnpmCommand();
-    const corepackCommand = normalizeCorepackCheck(await checkCommand('corepack', ['--version']), pnpmCommand);
-    const packages = [
-        checkPackage('@modelcontextprotocol/sdk'),
-        checkPackage('rebrowser-puppeteer-core'),
-        checkBetterSqlite3(),
-        checkPackage('camoufox-js', 'Optional Firefox anti-detect driver'),
-        checkPackage('playwright-core', 'Optional browser automation dependency'),
-        checkNativeMemory(),
-    ];
-    const commands = [
-        gitCommand,
-        pythonCommand,
-        pnpmCommand,
-        corepackCommand,
-        ...Object.entries(externalResults).map(([name, result]) => ({
-            name,
-            status: (result.available ? 'ok' : 'missing'),
-            detail: result.available
-                ? `${result.path ?? 'PATH'}${result.version ? ` (${result.version})` : ''}`
-                : (result.reason ?? 'Unavailable'),
-        })),
-    ];
-    const bridges = includeBridgeHealth
-        ? await Promise.all([
-            checkHttpEndpoint('ghidra-bridge', `${GHIDRA_BRIDGE_ENDPOINT.replace(/\/$/, '')}/health`),
-            checkHttpEndpoint('ida-bridge', `${IDA_BRIDGE_ENDPOINT.replace(/\/$/, '')}/health`),
-            checkHttpEndpoint('burp-mcp-sse', process.env.BURP_MCP_SSE_URL?.trim() || 'http://127.0.0.1:9876'),
-        ])
-        : [];
-    const limitations = buildPlatformLimitations();
-    const recommendations = buildRecommendations(packages, commands, bridges, limitations);
-    const success = [...packages, ...commands, ...bridges].every((item) => item.status !== 'error');
-    return {
-        success,
-        generatedAt: new Date().toISOString(),
-        runtime: {
-            platform: process.platform,
-            arch: process.arch,
-            node: process.version,
-            cwd: process.cwd(),
-            projectRoot: getProjectRoot(),
-        },
-        packages,
-        commands,
-        bridges,
-        config: {
-            transport: (process.env.MCP_TRANSPORT ?? 'stdio').toLowerCase(),
-            toolProfile: (process.env.MCP_TOOL_PROFILE ?? 'search').toLowerCase(),
-            pluginRoots: process.env.MCP_PLUGIN_ROOTS ?? '<jshook-install>/plugins',
-            workflowRoots: process.env.MCP_WORKFLOW_ROOTS ?? '<jshook-install>/workflows',
-            pluginSignatureRequired: process.env.MCP_PLUGIN_SIGNATURE_REQUIRED ??
-                (process.env.NODE_ENV === 'production' ? 'true (production default)' : 'false'),
-            pluginStrictLoad: process.env.MCP_PLUGIN_STRICT_LOAD ??
-                (process.env.NODE_ENV === 'production' ? 'true (production default)' : 'false'),
-            artifactRetention: getArtifactRetentionConfig(),
-        },
-        limitations,
-        recommendations,
-    };
-}
-export function formatEnvironmentDoctorReport(report) {
-    const lines = [];
-    lines.push(`JSHook Environment Doctor — ${report.generatedAt}`);
-    lines.push('');
-    lines.push(`Runtime: ${report.runtime.platform} ${report.runtime.arch} | Node ${report.runtime.node}`);
-    lines.push(`CWD: ${report.runtime.cwd}`);
-    lines.push(`Project root: ${report.runtime.projectRoot}`);
-    lines.push('');
-    lines.push('Packages:');
-    for (const item of report.packages)
-        lines.push(`- [${item.status}] ${item.name}: ${item.detail}`);
-    lines.push('');
-    lines.push('Commands:');
-    for (const item of report.commands)
-        lines.push(`- [${item.status}] ${item.name}: ${item.detail}`);
-    if (report.bridges.length > 0) {
-        lines.push('');
-        lines.push('Bridge health:');
-        for (const item of report.bridges)
-            lines.push(`- [${item.status}] ${item.name}: ${item.detail}`);
-    }
-    lines.push('');
-    lines.push('Config:');
-    for (const [key, value] of Object.entries(report.config)) {
-        lines.push(`- ${key}: ${typeof value === 'string' ? value : JSON.stringify(value)}`);
-    }
-    if (report.limitations.length > 0) {
-        lines.push('');
-        lines.push('Platform limitations:');
-        for (const item of report.limitations)
-            lines.push(`- ${item}`);
-    }
-    if (report.recommendations.length > 0) {
-        lines.push('');
-        lines.push('Recommendations:');
-        for (const item of report.recommendations)
-            lines.push(`- ${item}`);
-    }
-    lines.push('');
-    lines.push(`Overall: ${report.success ? 'ok' : 'review warnings above'}`);
-    return lines.join('\n');
-}
-function checkPackage(packageName, missingHint) {
-    try {
-        const packageJsonPath = require.resolve(`${packageName}/package.json`);
-        const packageJson = require(packageJsonPath);
-        return {
-            name: packageName,
-            status: 'ok',
-            detail: packageJson.version ? `installed (${packageJson.version})` : 'installed',
-        };
-    }
-    catch {
-        return {
-            name: packageName,
-            status: 'missing',
-            detail: missingHint ?? 'Not installed',
-        };
-    }
-}
-function checkBetterSqlite3() {
-    const result = probeBetterSqlite3();
-    return {
-        name: 'better-sqlite3',
-        status: result.status,
-        detail: result.detail,
-    };
-}
-function isPnpmOperational(pnpm) {
-    return pnpm.status === 'ok' || pnpm.detail.includes('npx fallback works');
-}
-async function checkPnpmCommand() {
-    const direct = await checkCommand('pnpm', ['--version']);
-    if (direct.status === 'ok') {
-        return direct;
-    }
-    const npxFallback = await checkCommand('npx', ['pnpm', '--version'], 10_000);
-    if (npxFallback.status === 'ok') {
-        return {
-            name: 'pnpm',
-            status: 'warn',
-            detail: `direct pnpm command unavailable; npx fallback works (${npxFallback.detail})`,
-        };
-    }
-    return direct;
-}
-function normalizeCorepackCheck(corepack, pnpm) {
-    if (corepack.status !== 'missing' || !isPnpmOperational(pnpm)) {
-        return corepack;
-    }
-    return {
-        name: corepack.name,
-        status: 'warn',
-        detail: process.platform === 'win32'
-            ? pnpm.detail.includes('npx fallback works')
-                ? 'corepack not found; use `npx pnpm` directly (common with nvm4w-managed Node on Windows)'
-                : 'corepack not found; standalone pnpm is available (common with nvm4w-managed Node on Windows)'
-            : pnpm.detail.includes('npx fallback works')
-                ? 'corepack not found; use `npx pnpm` directly'
-                : 'corepack not found; standalone pnpm is available',
-    };
-}
-function checkNativeMemory() {
-    try {
-        const koffiPkg = require.resolve('koffi/package.json');
-        const koffiJson = require(koffiPkg);
-        const koffiVersion = koffiJson.version ?? 'unknown';
-        if (process.platform === 'win32') {
-            return {
-                name: 'native-memory',
-                status: 'ok',
-                detail: `koffi ${koffiVersion} — Win32 kernel32.dll available`,
-            };
-        }
-        if (process.platform === 'darwin') {
-            try {
-                const koffi = require('koffi');
-                const lib = koffi.load('/usr/lib/libSystem.B.dylib');
-                lib.unload();
-                return {
-                    name: 'native-memory',
-                    status: 'ok',
-                    detail: `koffi ${koffiVersion} — macOS libSystem.B.dylib available (Mach APIs need root + SIP config)`,
-                };
-            }
-            catch {
-                return {
-                    name: 'native-memory',
-                    status: 'warn',
-                    detail: `koffi ${koffiVersion} installed but cannot load libSystem.B.dylib`,
-                };
-            }
-        }
-        return {
-            name: 'native-memory',
-            status: 'warn',
-            detail: `koffi ${koffiVersion} — no native FFI memory provider for ${process.platform} (proc-based ops available on Linux)`,
-        };
-    }
-    catch {
-        return {
-            name: 'native-memory',
-            status: 'missing',
-            detail: 'koffi not installed — native memory tools unavailable. Install with: pnpm add koffi',
-        };
-    }
-}
-async function checkCommand(command, args, timeout = 4000) {
-    try {
-        const { stdout, stderr } = await execFileAsync(command, args, {
-            timeout,
-            windowsHide: true,
-        });
-        const detail = `${stdout || stderr}`.trim().split(/\r?\n/)[0] || 'available';
-        return { name: command, status: 'ok', detail };
-    }
-    catch (error) {
-        let finalError = error;
-        if (process.platform === 'win32') {
-            try {
-                const { stdout, stderr } = await execFileAsync('cmd', ['/c', command, ...args], {
-                    timeout,
-                    windowsHide: true,
-                });
-                const detail = `${stdout || stderr}`.trim().split(/\r?\n/)[0] || 'available';
-                return { name: command, status: 'ok', detail: `${detail} (via cmd)` };
-            }
-            catch (cmdError) {
-                finalError = cmdError;
-            }
-        }
-        const detail = finalError instanceof Error ? finalError.message : String(finalError);
-        const missing = /ENOENT|not recognized|not found/i.test(detail);
-        return {
-            name: command,
-            status: missing ? 'missing' : 'warn',
-            detail,
-        };
-    }
-}
-async function checkHttpEndpoint(name, url) {
-    try {
-        const res = await fetch(url, {
-            method: 'GET',
-            signal: AbortSignal.timeout(3000),
-        });
-        return {
-            name,
-            status: res.ok ? 'ok' : 'warn',
-            detail: `${url} -> HTTP ${res.status}`,
-        };
-    }
-    catch (error) {
-        return {
-            name,
-            status: 'warn',
-            detail: `${url} -> ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-}
-function buildPlatformLimitations() {
-    const limitations = [];
-    if (process.platform === 'darwin') {
-        limitations.push('26 cross-platform memory tools available (scan, pointer-chain, structure-analysis, heap). ' +
-            '15 Windows-only tools unavailable (PE analysis, anti-cheat, code injection, speedhack, hardware breakpoints).');
-        limitations.push('Native memory operations (mach_vm_read/write) require root privileges and may require SIP configuration on ARM64.');
-    }
-    else if (process.platform === 'linux') {
-        limitations.push('Process management available via /proc. Native FFI memory provider not implemented — memory read/write uses /proc/pid/mem (requires root or CAP_SYS_PTRACE).');
-        limitations.push('Camoufox runs on Linux, but some Chrome/CDP-heavy workflows are better served by the Chrome driver.');
-    }
-    else if (process.platform !== 'win32') {
-        limitations.push(`Platform ${process.platform} is not supported for native memory operations. Use Windows or macOS.`);
-    }
-    return limitations;
-}
-function buildRecommendations(packages, commands, bridges, limitations) {
-    const recommendations = [];
-    const pnpmCommand = commands.find((item) => item.name === 'pnpm');
-    const corepackCommand = commands.find((item) => item.name === 'corepack');
-    if (packages.some((item) => item.name === 'better-sqlite3' && item.status !== 'ok')) {
-        recommendations.push('Install or rebuild the optional SQLite trace backend with `pnpm add -O better-sqlite3@12.6.2` or `npm rebuild better-sqlite3 --foreground-scripts` under the active Node version if you need trace tooling.');
-    }
-    if (packages.some((item) => item.name === 'camoufox-js' && item.status !== 'ok')) {
-        recommendations.push('Install optional browser dependencies with `pnpm run install:full` if you need Camoufox support.');
-    }
-    if (commands.some((item) => item.name.startsWith('wabt.') && item.status !== 'ok')) {
-        recommendations.push('Install wabt if you need full WASM disassembly/decompilation; otherwise the server will stay in basic mode.');
-    }
-    if (pnpmCommand && !isPnpmOperational(pnpmCommand)) {
-        recommendations.push('Install pnpm or enable Corepack (`corepack enable`) before running package-management workflows.');
-    }
-    else if (pnpmCommand?.detail.includes('npx fallback works')) {
-        recommendations.push('Use `npx pnpm` directly on this machine or repair the local pnpm/Corepack shim if scripts expect bare `pnpm`.');
-    }
-    else if (corepackCommand?.status === 'warn' &&
-        corepackCommand.detail.includes('standalone pnpm')) {
-        recommendations.push('Use `pnpm` or `npx pnpm` directly on this machine; `corepack` is optional and may be absent on nvm4w-managed Windows installs.');
-    }
-    if (bridges.some((item) => item.status !== 'ok')) {
-        recommendations.push('Check local bridge endpoints (Ghidra / IDA / Burp) before relying on native-bridge workflows.');
-    }
-    if (limitations.length > 0) {
-        recommendations.push('Review platform limitations before using process/memory tooling on non-Windows hosts.');
-    }
-    return recommendations;
-}

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

@@ -1,15 +0,0 @@
-export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
-declare class Logger {
-    private level;
-    constructor(level?: LogLevel);
-    private shouldLog;
-    private formatMessage;
-    debug(message: string, ...args: unknown[]): void;
-    info(message: string, ...args: unknown[]): void;
-    warn(message: string, ...args: unknown[]): void;
-    error(message: string, ...args: unknown[]): void;
-    success(message: string, ...args: unknown[]): void;
-    setLevel(level: LogLevel): void;
-}
-export declare const logger: Logger;
-export {};

package/dist/src/utils/logger.js

@@ -1,65 +0,0 @@
-import chalk from 'chalk';
-const SENSITIVE_KEYS = /^(auth(orization)?|cookie|set[_-]?cookie|x[_-]?api[_-]?key|token|access[_-]?token|refresh[_-]?token|id[_-]?token|secret|client[_-]?secret|password|passwd|api[_-]?key|private[_-]?key|credentials?|session[_-]?id|csrf[_-]?token)$/i;
-const SENSITIVE_VALUE_PATTERNS = /^(Bearer\s+\S|eyJ[A-Za-z0-9_-]{10,}|[A-Fa-f0-9]{32,}|sk[_-][A-Za-z0-9]{20,})/;
-function sensitiveReplacer(key, value) {
-    if (key && SENSITIVE_KEYS.test(key) && typeof value === 'string') {
-        return '[REDACTED]';
-    }
-    if (typeof value === 'string' && SENSITIVE_VALUE_PATTERNS.test(value)) {
-        return '[REDACTED]';
-    }
-    return value;
-}
-class Logger {
-    level;
-    constructor(level = 'info') {
-        this.level = level;
-    }
-    shouldLog(level) {
-        const levels = ['debug', 'info', 'warn', 'error'];
-        return levels.indexOf(level) >= levels.indexOf(this.level);
-    }
-    formatMessage(level, message, ...args) {
-        const timestamp = new Date().toISOString();
-        const prefix = `[${timestamp}] [${level.toUpperCase()}]`;
-        let formattedArgs = '';
-        if (args.length > 0) {
-            try {
-                formattedArgs = ' ' + JSON.stringify(args, sensitiveReplacer, undefined);
-            }
-            catch {
-                formattedArgs = ' [unserializable]';
-            }
-        }
-        return `${prefix} ${message}${formattedArgs}`;
-    }
-    debug(message, ...args) {
-        if (this.shouldLog('debug')) {
-            console.error(chalk.gray(this.formatMessage('debug', message, ...args)));
-        }
-    }
-    info(message, ...args) {
-        if (this.shouldLog('info')) {
-            console.error(chalk.blue(this.formatMessage('info', message, ...args)));
-        }
-    }
-    warn(message, ...args) {
-        if (this.shouldLog('warn')) {
-            console.error(chalk.yellow(this.formatMessage('warn', message, ...args)));
-        }
-    }
-    error(message, ...args) {
-        if (this.shouldLog('error')) {
-            console.error(chalk.red(this.formatMessage('error', message, ...args)));
-        }
-    }
-    success(message, ...args) {
-        if (this.shouldLog('info')) {
-            console.error(chalk.green(this.formatMessage('info', message, ...args)));
-        }
-    }
-    setLevel(level) {
-        this.level = level;
-    }
-}
-export const logger = new Logger(process.env.LOG_LEVEL || 'info');