@jshookmcp/jshook 0.1.5 → 0.1.7

package/dist/modules/process/memory/regions.protection.js

@@ -1,5 +1,9 @@
+import { readFileSync } from 'fs';
 import { logger } from '../../../utils/logger.js';
 import { execAsync, executePowerShellScript } from '../../process/memory/types.js';
+import { parseProcMaps, formatLinuxProtection } from './linux/mapsParser.js';
+import { nativeMemoryManager } from '../../../native/NativeMemoryManager.js';
+import { isKoffiAvailable } from '../../../native/NativeMemoryManager.utils.js';
 function buildProtectionCheckScript(pid, address) {
     return `
 Add-Type @"
@@ -110,8 +114,28 @@ try {
   `.trim();
 }
 export async function checkMemoryProtection(platform, pid, address) {
-    if (platform !== 'win32' && platform !== 'darwin') {
-        return { success: false, error: 'Memory protection check currently only implemented for Windows and macOS' };
+    const addrNum = BigInt(address.startsWith('0x') ? address : `0x${address}`);
+    if (platform === 'linux') {
+        try {
+            const mapsContent = readFileSync(`/proc/${pid}/maps`, 'utf-8');
+            const regions = parseProcMaps(mapsContent);
+            const region = regions.find(r => addrNum >= r.start && addrNum < r.end);
+            if (!region) {
+                return { success: false, error: `Address ${address} not found in any memory region` };
+            }
+            return {
+                success: true,
+                protection: formatLinuxProtection(region.permissions),
+                isReadable: region.permissions.read,
+                isWritable: region.permissions.write,
+                isExecutable: region.permissions.exec,
+                regionStart: `0x${region.start.toString(16)}`,
+                regionSize: Number(region.end - region.start),
+            };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : String(error) };
+        }
     }
     if (platform === 'darwin') {
         try {
@@ -145,6 +169,28 @@ export async function checkMemoryProtection(platform, pid, address) {
             return { success: false, error: error instanceof Error ? error.message : String(error) };
         }
     }
+    if (isKoffiAvailable()) {
+        try {
+            const nativeResult = await nativeMemoryManager.checkMemoryProtection(pid, address);
+            if (nativeResult.success) {
+                return nativeResult;
+            }
+            logger.warn('Native Windows memory protection check failed, falling back to PowerShell', {
+                pid,
+                address,
+                error: nativeResult.error,
+                nativeAvailable: isKoffiAvailable(),
+            });
+        }
+        catch (error) {
+            logger.warn('Native Windows memory protection check threw, falling back to PowerShell', {
+                pid,
+                address,
+                error: error instanceof Error ? error.message : String(error),
+                nativeAvailable: isKoffiAvailable(),
+            });
+        }
+    }
     try {
         const addrNum = parseInt(address, 16);
         if (isNaN(addrNum)) {

package/dist/modules/process/memory/scanner.d.ts

@@ -3,7 +3,10 @@ export declare function buildPatternBytesAndMask(pattern: string, patternType: s
     patternBytes: number[];
     mask: number[];
 };
-export declare function patternToBytesMac(pattern: string, patternType: string): number[];
+export declare function patternToBytesMac(pattern: string, patternType: string): {
+    bytes: number[];
+    mask: number[];
+};
 export declare function scanMemory(platform: Platform, pid: number, pattern: string, patternType?: PatternType): Promise<MemoryScanResult>;
 export declare function scanMemoryFiltered(pid: number, pattern: string, addresses: string[], patternType: PatternType | undefined, _readMemoryFn: (pid: number, address: string, size: number) => Promise<{
     success: boolean;

package/dist/modules/process/memory/scanner.js

@@ -1,6 +1,11 @@
+import { readFileSync, openSync, readSync, closeSync } from 'node:fs';
 import { promises as fs } from 'node:fs';
 import { logger } from '../../../utils/logger.js';
 import { execAsync, executePowerShellScript, } from '../../process/memory/types.js';
+import { nativeMemoryManager } from '../../../native/NativeMemoryManager.js';
+import { isKoffiAvailable } from '../../../native/NativeMemoryManager.utils.js';
+import { parseProcMaps } from './linux/mapsParser.js';
+import { findPatternInBuffer } from '../../../native/NativeMemoryManager.utils.js';
 export function buildPatternBytesAndMask(pattern, patternType) {
     let patternBytes = [];
     let mask = [];
@@ -73,20 +78,27 @@ export function buildPatternBytesAndMask(pattern, patternType) {
     return { patternBytes, mask };
 }
 export function patternToBytesMac(pattern, patternType) {
+    const bytes = [];
+    const mask = [];
     switch (patternType) {
         case 'hex': {
-            const bytes = [];
-            for (const part of pattern.trim().split(/\s+/)) {
-                if (part === '??' || part === '?' || part === '**')
-                    continue;
-                const b = parseInt(part, 16);
-                if (isNaN(b))
-                    throw new Error(`Invalid hex byte: ${part}`);
-                bytes.push(b);
+            const parts = pattern.trim().split(/\s+/);
+            for (const part of parts) {
+                if (part === '??' || part === '?' || part === '**') {
+                    bytes.push(0);
+                    mask.push(0);
+                }
+                else {
+                    const b = parseInt(part, 16);
+                    if (isNaN(b))
+                        throw new Error(`Invalid hex byte: ${part}`);
+                    bytes.push(b);
+                    mask.push(1);
+                }
             }
             if (!bytes.length)
-                throw new Error('Pattern is empty or all wildcards');
-            return bytes;
+                throw new Error('Pattern is empty');
+            break;
         }
         case 'int32': {
             const v = parseInt(pattern);
@@ -94,12 +106,18 @@ export function patternToBytesMac(pattern, patternType) {
                 throw new Error('Invalid int32 value');
             const buf = Buffer.allocUnsafe(4);
             buf.writeInt32LE(v, 0);
-            return Array.from(buf);
+            const arr = Array.from(buf);
+            bytes.push(...arr);
+            mask.push(...arr.map(() => 1));
+            break;
         }
         case 'int64': {
             const buf = Buffer.allocUnsafe(8);
             buf.writeBigInt64LE(BigInt.asIntN(64, BigInt(pattern)), 0);
-            return Array.from(buf);
+            const arr = Array.from(buf);
+            bytes.push(...arr);
+            mask.push(...arr.map(() => 1));
+            break;
         }
         case 'float': {
             const v = parseFloat(pattern);
@@ -107,7 +125,10 @@ export function patternToBytesMac(pattern, patternType) {
                 throw new Error('Invalid float value');
             const buf = Buffer.allocUnsafe(4);
             buf.writeFloatLE(v, 0);
-            return Array.from(buf);
+            const arr = Array.from(buf);
+            bytes.push(...arr);
+            mask.push(...arr.map(() => 1));
+            break;
         }
         case 'double': {
             const v = parseFloat(pattern);
@@ -115,13 +136,21 @@ export function patternToBytesMac(pattern, patternType) {
                 throw new Error('Invalid double value');
             const buf = Buffer.allocUnsafe(8);
             buf.writeDoubleLE(v, 0);
-            return Array.from(buf);
+            const arr = Array.from(buf);
+            bytes.push(...arr);
+            mask.push(...arr.map(() => 1));
+            break;
+        }
+        case 'string': {
+            const arr = Array.from(Buffer.from(pattern, 'utf8'));
+            bytes.push(...arr);
+            mask.push(...arr.map(() => 1));
+            break;
         }
-        case 'string':
-            return Array.from(Buffer.from(pattern, 'utf8'));
         default:
             throw new Error(`Unsupported pattern type: ${patternType}`);
     }
+    return { bytes, mask };
 }
 function buildMemoryScanScript(pid, pattern, patternType) {
     const { patternBytes, mask } = buildPatternBytesAndMask(pattern, patternType);
@@ -255,6 +284,28 @@ try {
 }
 async function scanMemoryWindows(pid, pattern, patternType) {
     try {
+        if (isKoffiAvailable()) {
+            try {
+                const nativeResult = await nativeMemoryManager.scanMemory(pid, pattern, patternType);
+                if (nativeResult.success) {
+                    return nativeResult;
+                }
+                logger.warn('Native Windows memory scan failed, falling back to PowerShell', {
+                    pid,
+                    patternType,
+                    error: nativeResult.error,
+                    nativeAvailable: isKoffiAvailable(),
+                });
+            }
+            catch (error) {
+                logger.warn('Native Windows memory scan threw, falling back to PowerShell', {
+                    pid,
+                    patternType,
+                    error: error instanceof Error ? error.message : String(error),
+                    nativeAvailable: isKoffiAvailable(),
+                });
+            }
+        }
         const psScript = buildMemoryScanScript(pid, pattern, patternType);
         const { stdout, stderr } = await executePowerShellScript(psScript, {
             maxBuffer: 1024 * 1024 * 50,
@@ -283,22 +334,166 @@ async function scanMemoryWindows(pid, pattern, patternType) {
         };
     }
 }
-async function scanMemoryLinux(_pid, _pattern, _patternType) {
-    return {
-        success: false,
-        addresses: [],
-        error: 'Memory scanning on Linux requires scanning /proc/pid/maps and iterating regions. Use scanmem or GameConqueror for now.',
-    };
+function formatLinuxProcAccessError(pid, procFile, error) {
+    const err = error;
+    switch (err?.code) {
+        case 'ENOENT':
+        case 'ESRCH':
+            return `Process ${pid} no longer exists or /proc/${pid}/${procFile} is unavailable.`;
+        case 'EACCES':
+        case 'EPERM':
+            return `Cannot access /proc/${pid}/${procFile}. Requires root privileges or ptrace access.`;
+        default:
+            return err instanceof Error ? err.message : String(error);
+    }
+}
+async function scanMemoryLinux(pid, pattern, patternType) {
+    let patternBytes;
+    let mask;
+    try {
+        const result = buildPatternBytesAndMask(pattern, patternType);
+        patternBytes = result.patternBytes;
+        mask = result.mask;
+    }
+    catch (error) {
+        return {
+            success: false,
+            addresses: [],
+            error: error instanceof Error ? error.message : 'Invalid pattern',
+        };
+    }
+    try {
+        let mapsContent;
+        try {
+            mapsContent = readFileSync(`/proc/${pid}/maps`, 'utf-8');
+        }
+        catch (error) {
+            return {
+                success: false,
+                addresses: [],
+                error: formatLinuxProcAccessError(pid, 'maps', error),
+            };
+        }
+        const linuxRegions = parseProcMaps(mapsContent).filter(r => r.permissions.read);
+        let fd;
+        try {
+            fd = openSync(`/proc/${pid}/mem`, 'r');
+        }
+        catch (error) {
+            return {
+                success: false,
+                addresses: [],
+                error: formatLinuxProcAccessError(pid, 'mem', error),
+            };
+        }
+        const foundAddresses = new Set();
+        const chunkSize = 16 * 1024 * 1024;
+        const maxResults = 10000;
+        const overlap = Math.max(patternBytes.length - 1, 0);
+        try {
+            for (const region of linuxRegions) {
+                if (foundAddresses.size >= maxResults)
+                    break;
+                if (region.end <= region.start)
+                    continue;
+                let chunkOffset = 0n;
+                let carryOver = Buffer.alloc(0);
+                const regionSize = region.end - region.start;
+                while (chunkOffset < regionSize && foundAddresses.size < maxResults) {
+                    const remaining = regionSize - chunkOffset;
+                    const readSize = Number(remaining > BigInt(chunkSize) ? BigInt(chunkSize) : remaining);
+                    const chunkBuffer = Buffer.allocUnsafe(readSize);
+                    let bytesRead;
+                    try {
+                        bytesRead = readSync(fd, chunkBuffer, 0, readSize, region.start + chunkOffset);
+                    }
+                    catch (error) {
+                        const err = error;
+                        if (err?.code === 'EIO' || err?.code === 'EFAULT' || err?.code === 'EACCES' || err?.code === 'EPERM') {
+                            logger.debug('Skipping unreadable Linux memory region chunk', {
+                                pid,
+                                start: `0x${region.start.toString(16)}`,
+                                offset: chunkOffset.toString(),
+                                code: err.code,
+                            });
+                            break;
+                        }
+                        throw error;
+                    }
+                    if (bytesRead <= 0) {
+                        break;
+                    }
+                    const chunk = bytesRead === readSize ? chunkBuffer : chunkBuffer.subarray(0, bytesRead);
+                    const scanBuffer = carryOver.length > 0 ? Buffer.concat([carryOver, chunk]) : chunk;
+                    const scanBase = region.start + chunkOffset - BigInt(carryOver.length);
+                    const chunkAdvance = BigInt(bytesRead);
+                    const isLastChunk = chunkOffset + chunkAdvance >= regionSize || bytesRead < readSize;
+                    const deferredTail = isLastChunk ? 0 : Math.min(overlap, scanBuffer.length);
+                    const reportableLimit = scanBuffer.length - deferredTail;
+                    const matches = findPatternInBuffer(scanBuffer, patternBytes, mask);
+                    for (const matchOffset of matches) {
+                        if (!isLastChunk && matchOffset >= reportableLimit) {
+                            continue;
+                        }
+                        const absoluteAddress = scanBase + BigInt(matchOffset);
+                        if (absoluteAddress < region.start || absoluteAddress >= region.end) {
+                            continue;
+                        }
+                        foundAddresses.add(`0x${absoluteAddress.toString(16)}`);
+                        if (foundAddresses.size >= maxResults) {
+                            break;
+                        }
+                    }
+                    if (deferredTail > 0) {
+                        carryOver = scanBuffer.subarray(scanBuffer.length - deferredTail);
+                    }
+                    else {
+                        carryOver = Buffer.alloc(0);
+                    }
+                    chunkOffset += chunkAdvance;
+                    if (bytesRead < readSize) {
+                        logger.debug('Linux memory scan stopped after short read', {
+                            pid,
+                            start: `0x${region.start.toString(16)}`,
+                            requested: readSize,
+                            bytesRead,
+                        });
+                        break;
+                    }
+                }
+            }
+        }
+        finally {
+            closeSync(fd);
+        }
+        const addresses = Array.from(foundAddresses);
+        return {
+            success: true,
+            addresses,
+            stats: { patternLength: patternBytes.length, resultsFound: addresses.length },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            addresses: [],
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
 }
 async function scanMemoryMac(pid, pattern, patternType) {
     let patternBytes;
+    let patternMask;
     try {
-        patternBytes = patternToBytesMac(pattern, patternType);
+        const result = patternToBytesMac(pattern, patternType);
+        patternBytes = result.bytes;
+        patternMask = result.mask;
     }
     catch (e) {
         return { success: false, addresses: [], error: e instanceof Error ? e.message : 'Invalid pattern' };
     }
     const byteList = patternBytes.map(b => `0x${b.toString(16)}`).join(',');
+    const maskList = patternMask.join(',');
     const tag = `${pid}_${Date.now()}`;
     const pyFile = `/tmp/lldb_scan_${tag}.py`;
     const cmdFile = `/tmp/lldb_scan_${tag}.txt`;
@@ -308,6 +503,7 @@ import lldb, json, sys
 def __lldb_init_module(debugger, internal_dict):
     proc = debugger.GetSelectedTarget().GetProcess()
     pat = bytes([${byteList}])
+    mask = [${maskList}]
     results = []
     rl = proc.GetMemoryRegions()
     for i in range(rl.GetSize()):
@@ -325,7 +521,12 @@ def __lldb_init_module(debugger, internal_dict):
             continue
         n = len(pat)
         for j in range(len(data) - n + 1):
-            if data[j:j+n] == pat:
+            match = True
+            for k in range(n):
+                if mask[k] == 1 and data[j+k] != pat[k]:
+                    match = False
+                    break
+            if match:
                 results.append(hex(s + j))
                 if len(results) >= 1000:
                     break

package/dist/native/NativeMemoryManager.impl.d.ts

@@ -1,5 +1,9 @@
 import type { MemoryRegion, ModuleInfo, NativeMemoryReadResult, NativeMemoryScanResult, NativeMemoryWriteResult } from './NativeMemoryManager.types.js';
 export type { MemoryRegion, ModuleInfo, NativeMemoryReadResult, NativeMemoryScanResult, NativeMemoryWriteResult, } from './NativeMemoryManager.types.js';
+export declare function scanRegionInChunks(region: {
+    baseAddress: bigint;
+    regionSize: number;
+}, patternBytes: number[], mask: number[], readChunk: (address: bigint, size: number) => Buffer<ArrayBufferLike>, chunkSize?: number): bigint[];
 export declare class NativeMemoryManager {
     checkAvailability(): Promise<{
         available: boolean;

package/dist/native/NativeMemoryManager.impl.js

@@ -1,10 +1,38 @@
 import { logger } from '../utils/logger.js';
 import { exec } from 'node:child_process';
 import { promisify } from 'node:util';
+import { cpuLimit } from '../utils/concurrency.js';
 import { PAGE, MEM, openProcessForMemory, CloseHandle, ReadProcessMemory, WriteProcessMemory, VirtualQueryEx, VirtualProtectEx, VirtualAllocEx, CreateRemoteThread, GetModuleHandle, GetProcAddress, NtQueryInformationProcess, EnumProcessModules, GetModuleBaseName, GetModuleInformation, } from './Win32API.js';
 import { findPatternInBuffer, getProtectionString, getStateString, getTypeString, isExecutable, isReadable, isWritable, parsePattern, } from './NativeMemoryManager.utils.js';
 import { checkNativeMemoryAvailability } from './NativeMemoryManager.availability.js';
 const execAsync = promisify(exec);
+const SCAN_CHUNK_SIZE = 16 * 1024 * 1024;
+export function scanRegionInChunks(region, patternBytes, mask, readChunk, chunkSize = SCAN_CHUNK_SIZE) {
+    if (patternBytes.length === 0 || region.regionSize < patternBytes.length || chunkSize <= 0) {
+        return [];
+    }
+    const overlap = Math.max(patternBytes.length - 1, 0);
+    let carryOver = Buffer.alloc(0);
+    const matches = [];
+    for (let chunkOffset = 0; chunkOffset < region.regionSize; chunkOffset += chunkSize) {
+        const readSize = Math.min(chunkSize, region.regionSize - chunkOffset);
+        const chunkAddress = region.baseAddress + BigInt(chunkOffset);
+        const chunk = readChunk(chunkAddress, readSize);
+        const scanBuffer = carryOver.length > 0 ? Buffer.concat([carryOver, chunk]) : chunk;
+        const chunkMatches = findPatternInBuffer(scanBuffer, patternBytes, mask);
+        for (const matchOffset of chunkMatches) {
+            const regionOffset = chunkOffset + matchOffset - carryOver.length;
+            matches.push(region.baseAddress + BigInt(regionOffset));
+        }
+        if (overlap === 0 || chunkOffset + readSize >= region.regionSize) {
+            carryOver = Buffer.alloc(0);
+            continue;
+        }
+        const carrySize = Math.min(overlap, scanBuffer.length);
+        carryOver = scanBuffer.subarray(scanBuffer.length - carrySize);
+    }
+    return matches;
+}
 export class NativeMemoryManager {
     async checkAvailability() {
         return checkNativeMemoryAvailability(execAsync);
@@ -156,45 +184,65 @@ export class NativeMemoryManager {
             if (patternBytes.length === 0) {
                 return { success: false, addresses: [], error: 'Invalid pattern' };
             }
-            const handle = openProcessForMemory(pid, false);
-            const addresses = [];
             const maxResults = 10000;
+            const readableRegions = [];
+            const handle = openProcessForMemory(pid, false);
             try {
                 let address = 0n;
                 const maxAddress = BigInt('0x7FFFFFFF0000');
-                while (address < maxAddress && addresses.length < maxResults) {
+                while (address < maxAddress) {
                     const { success, info } = VirtualQueryEx(handle, address);
                     if (!success || info.RegionSize === 0n) {
                         break;
                     }
-                    if (isReadable(info) && Number(info.RegionSize) > 0 && Number(info.RegionSize) < 1024 * 1024 * 1024) {
-                        try {
-                            const regionBuffer = ReadProcessMemory(handle, info.BaseAddress, Number(info.RegionSize));
-                            const matches = findPatternInBuffer(regionBuffer, patternBytes, mask);
-                            for (const offset of matches) {
-                                const foundAddr = info.BaseAddress + BigInt(offset);
-                                addresses.push(`0x${foundAddr.toString(16).toUpperCase()}`);
-                                if (addresses.length >= maxResults)
-                                    break;
-                            }
-                        }
-                        catch {
-                        }
+                    if (isReadable(info) &&
+                        info.RegionSize > 0n &&
+                        info.RegionSize <= BigInt(Number.MAX_SAFE_INTEGER)) {
+                        readableRegions.push({
+                            baseAddress: info.BaseAddress,
+                            regionSize: Number(info.RegionSize),
+                        });
                     }
                     address = info.BaseAddress + info.RegionSize;
                 }
-                return {
-                    success: true,
-                    addresses,
-                    stats: {
-                        patternLength: patternBytes.length,
-                        resultsFound: addresses.length,
-                    },
-                };
             }
             finally {
                 CloseHandle(handle);
             }
+            const regionMatches = await Promise.all(readableRegions.map(region => cpuLimit(async () => {
+                const scanHandle = openProcessForMemory(pid, false);
+                try {
+                    try {
+                        return scanRegionInChunks(region, patternBytes, mask, (address, size) => ReadProcessMemory(scanHandle, address, size));
+                    }
+                    catch {
+                        return [];
+                    }
+                }
+                finally {
+                    CloseHandle(scanHandle);
+                }
+            })));
+            const addresses = [];
+            for (const matches of regionMatches) {
+                for (const foundAddr of matches) {
+                    addresses.push(`0x${foundAddr.toString(16).toUpperCase()}`);
+                    if (addresses.length >= maxResults) {
+                        break;
+                    }
+                }
+                if (addresses.length >= maxResults) {
+                    break;
+                }
+            }
+            return {
+                success: true,
+                addresses,
+                stats: {
+                    patternLength: patternBytes.length,
+                    resultsFound: addresses.length,
+                },
+            };
         }
         catch (error) {
             logger.error('Native memory scan failed', {

package/dist/native/NativeMemoryManager.utils.d.ts

@@ -1,5 +1,6 @@
 import { type MemoryBasicInfo } from './Win32API.js';
 import type { NativePatternType } from './NativeMemoryManager.types.js';
+export declare function isKoffiAvailable(): boolean;
 export declare function parsePattern(pattern: string, patternType: NativePatternType): {
     patternBytes: number[];
     mask: number[];

package/dist/native/NativeMemoryManager.utils.js

@@ -1,4 +1,7 @@
-import { PAGE, MEM, MEM_TYPE } from './Win32API.js';
+import { PAGE, MEM, MEM_TYPE, isKoffiAvailable as isWin32KoffiAvailable, } from './Win32API.js';
+export function isKoffiAvailable() {
+    return isWin32KoffiAvailable();
+}
 export function parsePattern(pattern, patternType) {
     const patternBytes = [];
     const mask = [];
@@ -67,7 +70,47 @@ export function parsePattern(pattern, patternType) {
     }
     return { patternBytes, mask };
 }
+function findExactPatternBMH(buffer, pattern) {
+    const matches = [];
+    const patternLength = pattern.length;
+    if (patternLength === 0 || buffer.length < patternLength) {
+        return matches;
+    }
+    const lastIndex = patternLength - 1;
+    const skipTable = new Uint32Array(256);
+    skipTable.fill(patternLength);
+    for (let i = 0; i < lastIndex; i++) {
+        const patternByte = pattern[i];
+        if (patternByte !== undefined) {
+            skipTable[patternByte] = lastIndex - i;
+        }
+    }
+    let offset = 0;
+    while (offset <= buffer.length - patternLength) {
+        let patternIndex = lastIndex;
+        while (patternIndex >= 0 && buffer[offset + patternIndex] === pattern[patternIndex]) {
+            patternIndex--;
+        }
+        if (patternIndex < 0) {
+            matches.push(offset);
+            offset += 1;
+            continue;
+        }
+        const skipByte = buffer[offset + lastIndex];
+        if (skipByte === undefined) {
+            break;
+        }
+        offset += skipTable[skipByte] ?? patternLength;
+    }
+    return matches;
+}
 export function findPatternInBuffer(buffer, pattern, mask) {
+    if (pattern.length === 0) {
+        return [];
+    }
+    if (mask.every(value => value === 1)) {
+        return findExactPatternBMH(buffer, pattern);
+    }
     const matches = [];
     for (let i = 0; i <= buffer.length - pattern.length; i++) {
         let found = true;

package/dist/server/MCPServer.search.d.ts

@@ -1,2 +1,5 @@
 import type { MCPServerContext } from './MCPServer.context.js';
+import { ToolSearchEngine } from './ToolSearch.js';
+export declare function buildSearchSignature(ctx: MCPServerContext): string;
+export declare function getSearchEngine(ctx: MCPServerContext): ToolSearchEngine;
 export declare function registerSearchMetaTools(ctx: MCPServerContext): void;

package/dist/server/MCPServer.search.js

@@ -28,7 +28,24 @@ function getCombinedTools(ctx) {
     }
     return [...tools.values()];
 }
-function getSearchEngine(ctx) {
+const searchEngineCache = new WeakMap();
+export function buildSearchSignature(ctx) {
+    const extParts = [];
+    for (const [name, record] of ctx.extensionToolsByName) {
+        extParts.push(`${name}:${record.domain}`);
+    }
+    extParts.sort();
+    return [
+        ctx.currentTier,
+        ctx.extensionWorkflowRuntimeById.size,
+        extParts.join('|'),
+    ].join('::');
+}
+export function getSearchEngine(ctx) {
+    const signature = buildSearchSignature(ctx);
+    const cached = searchEngineCache.get(ctx);
+    if (cached && cached.signature === signature)
+        return cached.engine;
     const tools = getCombinedTools(ctx);
     const extensionDomains = getExtensionDomainMap(ctx);
     const domainScoreMultipliers = new Map();
@@ -43,7 +60,9 @@ function getSearchEngine(ctx) {
         toolScoreMultipliers.set('run_extension_workflow', 1.35);
         toolScoreMultipliers.set('list_extension_workflows', 1.25);
     }
-    return new ToolSearchEngine(tools, extensionDomains, domainScoreMultipliers, toolScoreMultipliers);
+    const engine = new ToolSearchEngine(tools, extensionDomains, domainScoreMultipliers, toolScoreMultipliers);
+    searchEngineCache.set(ctx, { signature, engine });
+    return engine;
 }
 function getToolByName(ctx) {
     return new Map(getCombinedTools(ctx).map((tool) => [tool.name, tool]));

package/dist/server/ToolCallContextGuard.d.ts

@@ -8,11 +8,13 @@ interface TabContextProvider {
 }
 export declare class ToolCallContextGuard {
     private getProvider;
+    private readonly contextSensitiveCache;
     constructor(getProvider: () => TabContextProvider | null);
     isContextSensitive(toolName: string): boolean;
     enrichResponse<T extends {
         content?: unknown[];
         isError?: boolean;
     }>(toolName: string, response: T): T;
+    private spliceTabContext;
 }
 export {};