@jshookmcp/jshook 0.2.5 → 0.2.7

package/dist/src/native/platform/types.d.ts

@@ -1,50 +0,0 @@
-export interface ProcessHandle {
-    readonly pid: number;
-    readonly writeAccess: boolean;
-}
-export declare enum MemoryProtection {
-    NoAccess = 0,
-    Read = 1,
-    Write = 2,
-    Execute = 4,
-    ReadWrite = 3,
-    ReadExecute = 5,
-    ReadWriteExecute = 7,
-    Guard = 8,
-    WriteCopy = 16
-}
-export type MemoryRegionState = 'committed' | 'reserved' | 'free';
-export type MemoryRegionType = 'image' | 'mapped' | 'private' | 'unknown';
-export interface MemoryRegionInfo {
-    readonly baseAddress: bigint;
-    readonly size: number;
-    readonly protection: MemoryProtection;
-    readonly state: MemoryRegionState;
-    readonly type: MemoryRegionType;
-    readonly isReadable: boolean;
-    readonly isWritable: boolean;
-    readonly isExecutable: boolean;
-}
-export interface ModuleInfo {
-    readonly name: string;
-    readonly baseAddress: bigint;
-    readonly size: number;
-}
-export interface MemoryReadResult {
-    readonly data: Buffer;
-    readonly bytesRead: number;
-}
-export interface MemoryWriteResult {
-    readonly bytesWritten: number;
-}
-export interface ProtectionChangeResult {
-    readonly oldProtection: MemoryProtection;
-}
-export interface AllocationResult {
-    readonly address: bigint;
-}
-export interface PlatformAvailability {
-    readonly available: boolean;
-    readonly reason?: string;
-    readonly platform: 'win32' | 'darwin';
-}

package/dist/src/native/platform/types.js

@@ -1,12 +0,0 @@
-export var MemoryProtection;
-(function (MemoryProtection) {
-    MemoryProtection[MemoryProtection["NoAccess"] = 0] = "NoAccess";
-    MemoryProtection[MemoryProtection["Read"] = 1] = "Read";
-    MemoryProtection[MemoryProtection["Write"] = 2] = "Write";
-    MemoryProtection[MemoryProtection["Execute"] = 4] = "Execute";
-    MemoryProtection[MemoryProtection["ReadWrite"] = 3] = "ReadWrite";
-    MemoryProtection[MemoryProtection["ReadExecute"] = 5] = "ReadExecute";
-    MemoryProtection[MemoryProtection["ReadWriteExecute"] = 7] = "ReadWriteExecute";
-    MemoryProtection[MemoryProtection["Guard"] = 8] = "Guard";
-    MemoryProtection[MemoryProtection["WriteCopy"] = 16] = "WriteCopy";
-})(MemoryProtection || (MemoryProtection = {}));

package/dist/src/native/platform/win32/Win32MemoryProvider.d.ts

@@ -1,15 +0,0 @@
-import type { PlatformMemoryAPI } from '../PlatformMemoryAPI.js';
-import { MemoryProtection, type ProcessHandle, type MemoryRegionInfo, type MemoryReadResult, type MemoryWriteResult, type ProtectionChangeResult, type AllocationResult, type ModuleInfo, type PlatformAvailability } from '../types.js';
-export declare class Win32MemoryProvider implements PlatformMemoryAPI {
-    readonly platform: "win32";
-    checkAvailability(): Promise<PlatformAvailability>;
-    openProcess(pid: number, writeAccess: boolean): ProcessHandle;
-    closeProcess(handle: ProcessHandle): void;
-    readMemory(handle: ProcessHandle, address: bigint, size: number): MemoryReadResult;
-    writeMemory(handle: ProcessHandle, address: bigint, data: Buffer): MemoryWriteResult;
-    queryRegion(handle: ProcessHandle, address: bigint): MemoryRegionInfo | null;
-    changeProtection(handle: ProcessHandle, address: bigint, size: number, newProtection: MemoryProtection): ProtectionChangeResult;
-    allocateMemory(handle: ProcessHandle, size: number, protection: MemoryProtection): AllocationResult;
-    freeMemory(handle: ProcessHandle, address: bigint, _size: number): void;
-    enumerateModules(handle: ProcessHandle): ModuleInfo[];
-}

package/dist/src/native/platform/win32/Win32MemoryProvider.js

@@ -1,155 +0,0 @@
-import { MemoryProtection, } from '../types.js';
-import { openProcessForMemory, CloseHandle, ReadProcessMemory, WriteProcessMemory, VirtualQueryEx, VirtualProtectEx, VirtualAllocEx, VirtualFreeEx, EnumProcessModules, GetModuleBaseName, GetModuleInformation, isWindows, isKoffiAvailable, PAGE, MEM, } from '../../Win32API.js';
-const handleMap = new WeakMap();
-function getWin32Handle(handle) {
-    const h = handleMap.get(handle);
-    if (h === undefined)
-        throw new Error('Invalid ProcessHandle — not a Win32 handle');
-    return h;
-}
-function win32ProtToMemoryProtection(prot) {
-    let flags = MemoryProtection.NoAccess;
-    if (prot & PAGE.READONLY)
-        flags |= MemoryProtection.Read;
-    if (prot & PAGE.READWRITE)
-        flags |= MemoryProtection.ReadWrite;
-    if (prot & PAGE.WRITECOPY)
-        flags |= MemoryProtection.Read | MemoryProtection.WriteCopy;
-    if (prot & PAGE.EXECUTE)
-        flags |= MemoryProtection.Execute;
-    if (prot & PAGE.EXECUTE_READ)
-        flags |= MemoryProtection.ReadExecute;
-    if (prot & PAGE.EXECUTE_READWRITE)
-        flags |= MemoryProtection.ReadWriteExecute;
-    if (prot & PAGE.EXECUTE_WRITECOPY)
-        flags |= MemoryProtection.Execute | MemoryProtection.Read | MemoryProtection.WriteCopy;
-    if (prot & PAGE.GUARD)
-        flags |= MemoryProtection.Guard;
-    return flags;
-}
-function memoryProtectionToWin32Prot(prot) {
-    const hasRead = (prot & MemoryProtection.Read) !== 0;
-    const hasWrite = (prot & MemoryProtection.Write) !== 0;
-    const hasExec = (prot & MemoryProtection.Execute) !== 0;
-    let page = PAGE.NOACCESS;
-    if (hasRead && hasWrite && hasExec)
-        page = PAGE.EXECUTE_READWRITE;
-    else if (hasRead && hasExec)
-        page = PAGE.EXECUTE_READ;
-    else if (hasRead && hasWrite)
-        page = PAGE.READWRITE;
-    else if (hasExec)
-        page = PAGE.EXECUTE;
-    else if (hasRead)
-        page = PAGE.READONLY;
-    if ((prot & MemoryProtection.Guard) !== 0)
-        page |= PAGE.GUARD;
-    return page;
-}
-function win32StateToState(state) {
-    if (state === MEM.COMMIT)
-        return 'committed';
-    if (state === MEM.RESERVE)
-        return 'reserved';
-    return 'free';
-}
-function win32TypeToType(type) {
-    if (type === 0x1000000)
-        return 'image';
-    if (type === 0x40000)
-        return 'mapped';
-    if (type === 0x20000)
-        return 'private';
-    return 'unknown';
-}
-export class Win32MemoryProvider {
-    platform = 'win32';
-    async checkAvailability() {
-        if (!isWindows()) {
-            return { available: false, reason: 'Not running on Windows', platform: 'win32' };
-        }
-        if (!isKoffiAvailable()) {
-            return { available: false, reason: 'koffi FFI library not available', platform: 'win32' };
-        }
-        return { available: true, platform: 'win32' };
-    }
-    openProcess(pid, writeAccess) {
-        const nativeHandle = openProcessForMemory(pid, writeAccess);
-        const handle = { pid, writeAccess };
-        handleMap.set(handle, nativeHandle);
-        return handle;
-    }
-    closeProcess(handle) {
-        const h = getWin32Handle(handle);
-        CloseHandle(h);
-    }
-    readMemory(handle, address, size) {
-        const h = getWin32Handle(handle);
-        const buffer = ReadProcessMemory(h, address, size);
-        return { data: buffer, bytesRead: buffer.length };
-    }
-    writeMemory(handle, address, data) {
-        const h = getWin32Handle(handle);
-        const bytesWritten = WriteProcessMemory(h, address, data);
-        return { bytesWritten };
-    }
-    queryRegion(handle, address) {
-        const h = getWin32Handle(handle);
-        const { success, info } = VirtualQueryEx(h, address);
-        if (!success || info.RegionSize === 0n)
-            return null;
-        const protection = win32ProtToMemoryProtection(info.Protect);
-        return {
-            baseAddress: info.BaseAddress,
-            size: Number(info.RegionSize),
-            protection,
-            state: win32StateToState(info.State),
-            type: win32TypeToType(info.Type),
-            isReadable: (protection & MemoryProtection.Read) !== 0,
-            isWritable: (protection & MemoryProtection.Write) !== 0,
-            isExecutable: (protection & MemoryProtection.Execute) !== 0,
-        };
-    }
-    changeProtection(handle, address, size, newProtection) {
-        const h = getWin32Handle(handle);
-        const win32Prot = memoryProtectionToWin32Prot(newProtection);
-        const { success, oldProtect } = VirtualProtectEx(h, address, size, win32Prot);
-        if (!success)
-            throw new Error('VirtualProtectEx failed');
-        return { oldProtection: win32ProtToMemoryProtection(oldProtect) };
-    }
-    allocateMemory(handle, size, protection) {
-        const h = getWin32Handle(handle);
-        const win32Prot = memoryProtectionToWin32Prot(protection);
-        const address = VirtualAllocEx(h, 0n, size, MEM.COMMIT | MEM.RESERVE, win32Prot);
-        if (!address)
-            throw new Error('VirtualAllocEx failed');
-        return { address };
-    }
-    freeMemory(handle, address, _size) {
-        const h = getWin32Handle(handle);
-        VirtualFreeEx(h, address, 0, MEM.RELEASE);
-    }
-    enumerateModules(handle) {
-        const h = getWin32Handle(handle);
-        const { success, modules: handles, count } = EnumProcessModules(h);
-        if (!success)
-            throw new Error('EnumProcessModules failed');
-        const modules = [];
-        for (let i = 0; i < count; i++) {
-            const hModule = handles[i];
-            if (!hModule)
-                continue;
-            const name = GetModuleBaseName(h, hModule);
-            const { success: infoSuccess, info } = GetModuleInformation(h, hModule);
-            if (infoSuccess && info) {
-                modules.push({
-                    name,
-                    baseAddress: BigInt(info.lpBaseOfDll),
-                    size: info.SizeOfImage,
-                });
-            }
-        }
-        return modules;
-    }
-}

package/dist/src/native/platform/win32/index.d.ts

@@ -1 +0,0 @@
-export { Win32MemoryProvider } from './Win32MemoryProvider.js';

package/dist/src/native/platform/win32/index.js

@@ -1 +0,0 @@
-export { Win32MemoryProvider } from './Win32MemoryProvider.js';

package/dist/src/server/EventBus.d.ts

@@ -1,85 +0,0 @@
-export type EventHandler<T = unknown> = (payload: T) => void | Promise<void>;
-export interface ServerEventMap {
-    [key: string]: unknown;
-    'tool:activated': {
-        toolName: string;
-        domain: string;
-        timestamp: string;
-    };
-    'tool:deactivated': {
-        toolName: string;
-        domain: string;
-        timestamp: string;
-    };
-    'tool:called': {
-        toolName: string;
-        domain: string | null;
-        timestamp: string;
-        success: boolean;
-    };
-    'domain:loaded': {
-        domain: string;
-        toolCount: number;
-        timestamp: string;
-    };
-    'domain:unloaded': {
-        domain: string;
-        timestamp: string;
-    };
-    'extension:loaded': {
-        pluginId: string;
-        toolCount: number;
-        source: string;
-        timestamp: string;
-    };
-    'extension:unloaded': {
-        pluginId: string;
-        timestamp: string;
-    };
-    'session:browser_launched': {
-        mode: string;
-        timestamp: string;
-    };
-    'session:browser_closed': {
-        reason: string;
-        timestamp: string;
-    };
-    'debugger:breakpoint_hit': {
-        scriptId: string;
-        lineNumber: number;
-        timestamp: string;
-    };
-    'browser:navigated': {
-        url: string;
-        timestamp: string;
-    };
-    'memory:scan_completed': {
-        scanType: string;
-        resultCount: number;
-        timestamp: string;
-    };
-    'activation:domain_boosted': {
-        domain: string;
-        reason: string;
-        timestamp: string;
-    };
-    'activation:domain_pruned': {
-        domain: string;
-        reason: string;
-        timestamp: string;
-    };
-}
-export declare class EventBus<TMap extends Record<string, unknown> = ServerEventMap> {
-    private readonly listeners;
-    private readonly wildcardListeners;
-    on<K extends keyof TMap>(event: K, handler: EventHandler<TMap[K]>): () => void;
-    once<K extends keyof TMap>(event: K, handler: EventHandler<TMap[K]>): () => void;
-    onAny(handler: EventHandler<{
-        event: string;
-        payload: unknown;
-    }>): () => void;
-    emit<K extends keyof TMap>(event: K, payload: TMap[K]): Promise<void>;
-    removeAllListeners(event?: keyof TMap): void;
-    listenerCount(event: keyof TMap): number;
-}
-export declare function createServerEventBus(): EventBus<ServerEventMap>;

package/dist/src/server/EventBus.js

@@ -1,87 +0,0 @@
-export class EventBus {
-    listeners = new Map();
-    wildcardListeners = [];
-    on(event, handler) {
-        const subs = this.listeners.get(event) ?? [];
-        const subscription = { handler: handler, once: false };
-        subs.push(subscription);
-        this.listeners.set(event, subs);
-        return () => {
-            const list = this.listeners.get(event);
-            if (list) {
-                const idx = list.indexOf(subscription);
-                if (idx >= 0)
-                    list.splice(idx, 1);
-            }
-        };
-    }
-    once(event, handler) {
-        const subs = this.listeners.get(event) ?? [];
-        const subscription = { handler: handler, once: true };
-        subs.push(subscription);
-        this.listeners.set(event, subs);
-        return () => {
-            const list = this.listeners.get(event);
-            if (list) {
-                const idx = list.indexOf(subscription);
-                if (idx >= 0)
-                    list.splice(idx, 1);
-            }
-        };
-    }
-    onAny(handler) {
-        const subscription = {
-            handler: handler,
-            once: false,
-        };
-        this.wildcardListeners.push(subscription);
-        return () => {
-            const idx = this.wildcardListeners.indexOf(subscription);
-            if (idx >= 0)
-                this.wildcardListeners.splice(idx, 1);
-        };
-    }
-    async emit(event, payload) {
-        const subs = this.listeners.get(event);
-        if (subs) {
-            const toRemove = [];
-            for (let i = 0; i < subs.length; i++) {
-                const sub = subs[i];
-                if (!sub)
-                    continue;
-                try {
-                    await sub.handler(payload);
-                }
-                catch {
-                }
-                if (sub.once)
-                    toRemove.push(i);
-            }
-            for (let i = toRemove.length - 1; i >= 0; i--) {
-                subs.splice(toRemove[i], 1);
-            }
-        }
-        for (const sub of this.wildcardListeners) {
-            try {
-                await sub.handler({ event, payload });
-            }
-            catch {
-            }
-        }
-    }
-    removeAllListeners(event) {
-        if (event) {
-            this.listeners.delete(event);
-        }
-        else {
-            this.listeners.clear();
-            this.wildcardListeners.length = 0;
-        }
-    }
-    listenerCount(event) {
-        return this.listeners.get(event)?.length ?? 0;
-    }
-}
-export function createServerEventBus() {
-    return new EventBus();
-}

package/dist/src/server/MCPServer.activation.ttl.d.ts

@@ -1,11 +0,0 @@
-import type { MCPServerContext } from './MCPServer.context.js';
-export interface DomainTtlEntry {
-    timer: ReturnType<typeof setTimeout>;
-    ttlMs: number;
-    toolNames: Set<string>;
-}
-export declare function startDomainTtl(ctx: MCPServerContext, domain: string, ttlMinutes: number, toolNames: Iterable<string>): void;
-export declare function refreshDomainTtl(ctx: MCPServerContext, domain: string): void;
-export declare function refreshDomainTtlForTool(ctx: MCPServerContext, toolName: string): void;
-export declare function clearDomainTtl(ctx: MCPServerContext, domain: string): void;
-export declare function deactivateDomainOnExpiry(ctx: MCPServerContext, domain: string): Promise<void>;

package/dist/src/server/MCPServer.activation.ttl.js

@@ -1,100 +0,0 @@
-import { logger } from '../utils/logger.js';
-import { getToolDomain } from './ToolCatalog.js';
-export function startDomainTtl(ctx, domain, ttlMinutes, toolNames) {
-    clearDomainTtl(ctx, domain);
-    if (ttlMinutes <= 0)
-        return;
-    const ttlMs = ttlMinutes * 60 * 1000;
-    const names = new Set(toolNames);
-    const timer = setTimeout(() => {
-        logger.info(`Domain "${domain}" TTL expired (${ttlMinutes}min) — auto-deactivating ${names.size} tools`);
-        void deactivateDomainOnExpiry(ctx, domain).catch((err) => {
-            logger.error(`Failed to deactivate domain "${domain}" on TTL expiry:`, err);
-        });
-    }, ttlMs);
-    ctx.domainTtlEntries.set(domain, { timer, ttlMs, toolNames: names });
-}
-export function refreshDomainTtl(ctx, domain) {
-    const entry = ctx.domainTtlEntries.get(domain);
-    if (!entry)
-        return;
-    clearTimeout(entry.timer);
-    const ttlMinutes = entry.ttlMs / 60_000;
-    entry.timer = setTimeout(() => {
-        logger.info(`Domain "${domain}" TTL expired (${ttlMinutes}min) — auto-deactivating`);
-        void deactivateDomainOnExpiry(ctx, domain).catch((err) => {
-            logger.error(`Failed to deactivate domain "${domain}" on TTL expiry:`, err);
-        });
-    }, entry.ttlMs);
-}
-export function refreshDomainTtlForTool(ctx, toolName) {
-    let domain = getToolDomain(toolName);
-    if (!domain) {
-        const extRecord = ctx.extensionToolsByName.get(toolName);
-        if (extRecord)
-            domain = extRecord.domain;
-    }
-    if (domain && ctx.domainTtlEntries.has(domain)) {
-        refreshDomainTtl(ctx, domain);
-    }
-}
-export function clearDomainTtl(ctx, domain) {
-    const entry = ctx.domainTtlEntries.get(domain);
-    if (entry) {
-        clearTimeout(entry.timer);
-        ctx.domainTtlEntries.delete(domain);
-    }
-}
-export async function deactivateDomainOnExpiry(ctx, domain) {
-    const entry = ctx.domainTtlEntries.get(domain);
-    if (!entry)
-        return;
-    const toolNames = entry.toolNames;
-    ctx.domainTtlEntries.delete(domain);
-    let removedCount = 0;
-    for (const name of toolNames) {
-        if (!ctx.activatedToolNames.has(name))
-            continue;
-        const registeredTool = ctx.activatedRegisteredTools.get(name);
-        if (registeredTool) {
-            try {
-                registeredTool.remove();
-            }
-            catch (e) {
-                logger.warn(`Failed to remove tool "${name}" on domain TTL expiry:`, e);
-            }
-        }
-        ctx.router.removeHandler(name);
-        ctx.activatedToolNames.delete(name);
-        ctx.activatedRegisteredTools.delete(name);
-        const extRecord = ctx.extensionToolsByName.get(name);
-        if (extRecord) {
-            extRecord.registeredTool = undefined;
-        }
-        removedCount++;
-    }
-    if (removedCount > 0) {
-        ctx.enabledDomains.delete(domain);
-        for (const activeName of ctx.activatedToolNames) {
-            const d = getToolDomain(activeName);
-            if (d === domain) {
-                ctx.enabledDomains.add(domain);
-                break;
-            }
-        }
-        for (const selectedTool of ctx.selectedTools) {
-            const d = getToolDomain(selectedTool.name);
-            if (d === domain) {
-                ctx.enabledDomains.add(domain);
-                break;
-            }
-        }
-        try {
-            await ctx.server.sendToolListChanged();
-        }
-        catch (e) {
-            logger.warn('sendToolListChanged failed after domain TTL expiry:', e);
-        }
-        logger.info(`Domain "${domain}" deactivated: removed ${removedCount} tools`);
-    }
-}

package/dist/src/server/MCPServer.context.d.ts

@@ -1,104 +0,0 @@
-import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { Server } from 'node:http';
-import type { Socket } from 'node:net';
-import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-import type { Config } from '../types/index.js';
-import type { ToolArgs, ToolResponse } from './types.js';
-import type { ToolProfile } from './ToolCatalog.js';
-import type { ToolExecutionRouter } from './ToolExecutionRouter.js';
-import type { ToolHandlerDeps } from './registry/contracts.js';
-import type { TokenBudgetManager } from '../utils/TokenBudgetManager.js';
-import type { UnifiedCacheManager } from '../utils/UnifiedCacheManager.js';
-import type { DetailedDataManager } from '../utils/DetailedDataManager.js';
-import type { ExtensionListResult, ExtensionPluginRecord, ExtensionPluginRuntimeRecord, ExtensionReloadResult, ExtensionToolRecord, ExtensionWorkflowRecord, ExtensionWorkflowRuntimeRecord } from './extensions/types.js';
-export interface ServerCore {
-    config: Config;
-    server: McpServer;
-    tokenBudget: TokenBudgetManager;
-    unifiedCache: UnifiedCacheManager;
-    detailedData: DetailedDataManager;
-    eventBus: import('./EventBus.js').EventBus<import('./EventBus.js').ServerEventMap>;
-}
-export interface ToolRegistryState {
-    selectedTools: Tool[];
-    enabledDomains: Set<string>;
-    router: ToolExecutionRouter;
-    handlerDeps: ToolHandlerDeps;
-}
-export interface MetaToolInfo {
-    name: string;
-    description: string;
-    inputSchema: Tool['inputSchema'];
-}
-export interface ActivationState {
-    baseTier: ToolProfile;
-    activatedToolNames: Set<string>;
-    activatedRegisteredTools: Map<string, RegisteredTool>;
-    domainTtlEntries: Map<string, import('./MCPServer.activation.ttl.js').DomainTtlEntry>;
-    metaToolsByName: Map<string, MetaToolInfo>;
-    clientSupportsListChanged: boolean;
-}
-export interface TransportState {
-    httpServer?: Server;
-    httpSockets: Set<Socket>;
-}
-export interface ExtensionState {
-    extensionToolsByName: Map<string, ExtensionToolRecord>;
-    extensionPluginsById: Map<string, ExtensionPluginRecord>;
-    extensionPluginRuntimeById: Map<string, ExtensionPluginRuntimeRecord>;
-    extensionWorkflowsById: Map<string, ExtensionWorkflowRecord>;
-    extensionWorkflowRuntimeById: Map<string, ExtensionWorkflowRuntimeRecord>;
-    lastExtensionReloadAt?: string;
-}
-export interface DomainInstances {
-    readonly domainInstanceMap: Map<string, unknown>;
-    getDomainInstance<T>(key: string): T | undefined;
-    setDomainInstance(key: string, value: unknown): void;
-    collector?: import('../modules/collector/CodeCollector.js').CodeCollector;
-    pageController?: import('../modules/collector/PageController.js').PageController;
-    domInspector?: import('../modules/collector/DOMInspector.js').DOMInspector;
-    scriptManager?: import('../modules/debugger/ScriptManager.js').ScriptManager;
-    debuggerManager?: import('../modules/debugger/DebuggerManager.js').DebuggerManager;
-    runtimeInspector?: import('../modules/debugger/RuntimeInspector.js').RuntimeInspector;
-    consoleMonitor?: import('../modules/monitor/ConsoleMonitor.js').ConsoleMonitor;
-    browserHandlers?: import('./domains/browser/index.js').BrowserToolHandlers;
-    debuggerHandlers?: import('./domains/debugger/index.js').DebuggerToolHandlers;
-    advancedHandlers?: import('./domains/network/index.js').AdvancedToolHandlers;
-    aiHookHandlers?: import('./domains/hooks/index.js').AIHookToolHandlers;
-    hookPresetHandlers?: import('./domains/hooks/index.js').HookPresetToolHandlers;
-    deobfuscator?: import('../modules/deobfuscator/Deobfuscator.js').Deobfuscator;
-    advancedDeobfuscator?: import('../modules/deobfuscator/AdvancedDeobfuscator.js').AdvancedDeobfuscator;
-    astOptimizer?: import('../modules/deobfuscator/ASTOptimizer.js').ASTOptimizer;
-    obfuscationDetector?: import('../modules/detector/ObfuscationDetector.js').ObfuscationDetector;
-    analyzer?: import('../modules/analyzer/CodeAnalyzer.js').CodeAnalyzer;
-    cryptoDetector?: import('../modules/crypto/CryptoDetector.js').CryptoDetector;
-    hookManager?: import('../modules/hook/HookManager.js').HookManager;
-    coreAnalysisHandlers?: import('./domains/analysis/index.js').CoreAnalysisHandlers;
-    coreMaintenanceHandlers?: import('./domains/maintenance/index.js').CoreMaintenanceHandlers;
-    extensionManagementHandlers?: import('./domains/maintenance/index.js').ExtensionManagementHandlers;
-    processHandlers?: import('./domains/process/index.js').ProcessToolHandlers;
-    workflowHandlers?: import('./domains/workflow/index.js').WorkflowHandlers;
-    wasmHandlers?: import('./domains/wasm/index.js').WasmToolHandlers;
-    streamingHandlers?: import('./domains/streaming/index.js').StreamingToolHandlers;
-    encodingHandlers?: import('./domains/encoding/index.js').EncodingToolHandlers;
-    antidebugHandlers?: import('./domains/antidebug/index.js').AntiDebugToolHandlers;
-    graphqlHandlers?: import('./domains/graphql/index.js').GraphQLToolHandlers;
-    platformHandlers?: import('./domains/platform/index.js').PlatformToolHandlers;
-    sourcemapHandlers?: import('./domains/sourcemap/index.js').SourcemapToolHandlers;
-    transformHandlers?: import('./domains/transform/index.js').TransformToolHandlers;
-    coordinationHandlers?: import('./domains/coordination/index.js').CoordinationHandlers;
-    traceRecorder?: import('../modules/trace/TraceRecorder.js').TraceRecorder;
-    traceHandlers?: import('./domains/trace/index.js').TraceToolHandlers;
-    evidenceHandlers?: import('./domains/evidence/index.js').EvidenceHandlers;
-    instrumentationHandlers?: import('./domains/instrumentation/index.js').InstrumentationHandlers | undefined;
-}
-export interface ServerMethods {
-    registerCaches(): Promise<void>;
-    resolveEnabledDomains(tools: Tool[]): Set<string>;
-    registerSingleTool(toolDef: Tool): RegisteredTool;
-    reloadExtensions(): Promise<ExtensionReloadResult>;
-    listExtensions(): ExtensionListResult;
-    executeToolWithTracking(name: string, args: ToolArgs): Promise<ToolResponse>;
-}
-export interface MCPServerContext extends ServerCore, ToolRegistryState, ActivationState, TransportState, ExtensionState, DomainInstances, ServerMethods {
-}

package/dist/src/server/MCPServer.context.js

@@ -1 +0,0 @@
-export {};