@jshookmcp/jshook 0.1.5 → 0.1.6

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

@@ -5,60 +5,60 @@ import { execAsync, executePowerShellScript, } from '../../process/memory/types.
 async function writeMemoryWindows(pid, address, data) {
     try {
         const hexData = data.toString('hex').toUpperCase();
-        const psScript = `
-        Add-Type @"
-          using System;
-          using System.Runtime.InteropServices;
-          using System.ComponentModel;
-
-          public class MemoryWriter {
-            [DllImport("kernel32.dll", SetLastError = true)]
-            public static extern IntPtr OpenProcess(int access, bool inherit, int pid);
-
-            [DllImport("kernel32.dll", SetLastError = true)]
-            public static extern bool WriteProcessMemory(IntPtr hProcess, IntPtr addr, byte[] buffer, int size, out int written);
-
-            [DllImport("kernel32.dll", SetLastError = true)]
-            public static extern bool CloseHandle(IntPtr handle);
-
-            const int PROCESS_VM_WRITE = 0x0020;
-            const int PROCESS_VM_OPERATION = 0x0008;
-
-            public static int WriteMemory(int pid, long address, string hexData) {
-              IntPtr hProcess = OpenProcess(PROCESS_VM_WRITE | PROCESS_VM_OPERATION, false, pid);
-              if (hProcess == IntPtr.Zero) {
-                int error = Marshal.GetLastWin32Error();
-                throw new Win32Exception(error, "Failed to open process. Run as Administrator.");
-              }
-
-              try {
-                byte[] buffer = new byte[hexData.Length / 2];
-                for (int i = 0; i < hexData.Length; i += 2) {
-                  buffer[i / 2] = Convert.ToByte(hexData.Substring(i, 2), 16);
-                }
-
-                int bytesWritten;
-                bool success = WriteProcessMemory(hProcess, (IntPtr)address, buffer, buffer.Length, out bytesWritten);
-
-                if (!success) {
-                  int error = Marshal.GetLastWin32Error();
-                  throw new Win32Exception(error, "Failed to write memory");
-                }
-
-                return bytesWritten;
-              } finally {
-                CloseHandle(hProcess);
-              }
-            }
-          }
-"@
-
-        try {
-          $bytesWritten = [MemoryWriter]::WriteMemory(${pid}, ${address}, "${hexData}")
-          @{ success = $true; bytesWritten = $bytesWritten } | ConvertTo-Json -Compress
-        } catch {
-          @{ success = $false; error = $_.Exception.Message } | ConvertTo-Json -Compress
-        }
+        const psScript = `
+        Add-Type @"
+          using System;
+          using System.Runtime.InteropServices;
+          using System.ComponentModel;
+
+          public class MemoryWriter {
+            [DllImport("kernel32.dll", SetLastError = true)]
+            public static extern IntPtr OpenProcess(int access, bool inherit, int pid);
+
+            [DllImport("kernel32.dll", SetLastError = true)]
+            public static extern bool WriteProcessMemory(IntPtr hProcess, IntPtr addr, byte[] buffer, int size, out int written);
+
+            [DllImport("kernel32.dll", SetLastError = true)]
+            public static extern bool CloseHandle(IntPtr handle);
+
+            const int PROCESS_VM_WRITE = 0x0020;
+            const int PROCESS_VM_OPERATION = 0x0008;
+
+            public static int WriteMemory(int pid, long address, string hexData) {
+              IntPtr hProcess = OpenProcess(PROCESS_VM_WRITE | PROCESS_VM_OPERATION, false, pid);
+              if (hProcess == IntPtr.Zero) {
+                int error = Marshal.GetLastWin32Error();
+                throw new Win32Exception(error, "Failed to open process. Run as Administrator.");
+              }
+
+              try {
+                byte[] buffer = new byte[hexData.Length / 2];
+                for (int i = 0; i < hexData.Length; i += 2) {
+                  buffer[i / 2] = Convert.ToByte(hexData.Substring(i, 2), 16);
+                }
+
+                int bytesWritten;
+                bool success = WriteProcessMemory(hProcess, (IntPtr)address, buffer, buffer.Length, out bytesWritten);
+
+                if (!success) {
+                  int error = Marshal.GetLastWin32Error();
+                  throw new Win32Exception(error, "Failed to write memory");
+                }
+
+                return bytesWritten;
+              } finally {
+                CloseHandle(hProcess);
+              }
+            }
+          }
+"@
+
+        try {
+          $bytesWritten = [MemoryWriter]::WriteMemory(${pid}, ${address}, "${hexData}")
+          @{ success = $true; bytesWritten = $bytesWritten } | ConvertTo-Json -Compress
+        } catch {
+          @{ success = $false; error = $_.Exception.Message } | ConvertTo-Json -Compress
+        }
       `;
         const { stdout } = await executePowerShellScript(psScript, { maxBuffer: 1024 * 1024 });
         const _trimmed = stdout.trim();

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/native/scripts/linux/enum-windows.sh

@@ -1,12 +1,12 @@
-#!/bin/bash
-# enum-windows.sh
-# Linux window enumeration script (placeholder)
-
-TARGET_PID=$1
-
-# Use xdotool or wmctrl for window enumeration
-# This is a placeholder for future implementation
-
-if command -v xdotool &> /dev/null; then
-    xdotool search --pid "$TARGET_PID" --name "" get-window-name
-fi
+#!/bin/bash
+# enum-windows.sh
+# Linux window enumeration script (placeholder)
+
+TARGET_PID=$1
+
+# Use xdotool or wmctrl for window enumeration
+# This is a placeholder for future implementation
+
+if command -v xdotool &> /dev/null; then
+    xdotool search --pid "$TARGET_PID" --name "" get-window-name
+fi

package/dist/native/scripts/macos/enum-windows.applescript

@@ -1,22 +1,22 @@
--- enum-windows.applescript
--- macOS window enumeration script (placeholder)
-
-param TargetPid
-
--- AppleScript implementation for window enumeration
--- This is a placeholder for future implementation
-
-tell application "System Events"
-    set windowList to {}
-    repeat with proc in (every process whose unix id is TargetPid)
-        repeat with win in windows of proc
-            set end of windowList to {¬
-                title: name of win, ¬
-                position: position of win, ¬
-                size: size of win ¬
-            }
-        end repeat
-    end repeat
-end tell
-
-return windowList
+-- enum-windows.applescript
+-- macOS window enumeration script (placeholder)
+
+param TargetPid
+
+-- AppleScript implementation for window enumeration
+-- This is a placeholder for future implementation
+
+tell application "System Events"
+    set windowList to {}
+    repeat with proc in (every process whose unix id is TargetPid)
+        repeat with win in windows of proc
+            set end of windowList to {¬
+                title: name of win, ¬
+                position: position of win, ¬
+                size: size of win ¬
+            }
+        end repeat
+    end repeat
+end tell
+
+return windowList

package/dist/native/scripts/windows/enum-windows-by-class.ps1

@@ -1,51 +1,51 @@
-param(
-    [string]$ClassPattern
-)
-
-Add-Type @"
-  using System;
-  using System.Runtime.InteropServices;
-  public class Win32 {
-    [DllImport("user32.dll")] public static extern IntPtr FindWindowEx(IntPtr parent, IntPtr childAfter, string className, string title);
-    [DllImport("user32.dll")] public static extern int GetWindowThreadProcessId(IntPtr hWnd, out int pid);
-    [DllImport("user32.dll")] public static extern int GetWindowText(IntPtr hWnd, System.Text.StringBuilder text, int count);
-    [DllImport("user32.dll")] public static extern int GetClassName(IntPtr hWnd, System.Text.StringBuilder className, int maxCount);
-  }
-"@
-
-$windows = @()
-$hwnd = [IntPtr]::Zero
-while ($true) {
-  $hwnd = [Win32]::FindWindowEx([IntPtr]::Zero, $hwnd, $null, $null)
-  if ($hwnd -eq [IntPtr]::Zero) { break }
-
-  $className = New-Object System.Text.StringBuilder 256
-  [Win32]::GetClassName($hwnd, $className, 256) | Out-Null
-  $classNameStr = $className.ToString()
-
-  # Support wildcard pattern matching
-  $isMatch = $false
-  if ($ClassPattern -eq $classNameStr) {
-    $isMatch = $true
-  } elseif ($ClassPattern.Contains('*')) {
-    # Convert wildcard pattern to regex
-    $regexPattern = [regex]::Escape($ClassPattern).Replace('\*', '.*')
-    if ($classNameStr -match $regexPattern) {
-      $isMatch = $true
-    }
-  }
-
-  if ($isMatch) {
-    $windowPid = 0
-    [Win32]::GetWindowThreadProcessId($hwnd, [ref]$windowPid) | Out-Null
-    $title = New-Object System.Text.StringBuilder 256
-    [Win32]::GetWindowText($hwnd, $title, 256) | Out-Null
-    $windows += @{
-      Handle = $hwnd.ToString()
-      Title = $title.ToString()
-      ClassName = $classNameStr
-      ProcessId = $windowPid
-    }
-  }
-}
-$windows | ConvertTo-Json -Compress
+param(
+    [string]$ClassPattern
+)
+
+Add-Type @"
+  using System;
+  using System.Runtime.InteropServices;
+  public class Win32 {
+    [DllImport("user32.dll")] public static extern IntPtr FindWindowEx(IntPtr parent, IntPtr childAfter, string className, string title);
+    [DllImport("user32.dll")] public static extern int GetWindowThreadProcessId(IntPtr hWnd, out int pid);
+    [DllImport("user32.dll")] public static extern int GetWindowText(IntPtr hWnd, System.Text.StringBuilder text, int count);
+    [DllImport("user32.dll")] public static extern int GetClassName(IntPtr hWnd, System.Text.StringBuilder className, int maxCount);
+  }
+"@
+
+$windows = @()
+$hwnd = [IntPtr]::Zero
+while ($true) {
+  $hwnd = [Win32]::FindWindowEx([IntPtr]::Zero, $hwnd, $null, $null)
+  if ($hwnd -eq [IntPtr]::Zero) { break }
+
+  $className = New-Object System.Text.StringBuilder 256
+  [Win32]::GetClassName($hwnd, $className, 256) | Out-Null
+  $classNameStr = $className.ToString()
+
+  # Support wildcard pattern matching
+  $isMatch = $false
+  if ($ClassPattern -eq $classNameStr) {
+    $isMatch = $true
+  } elseif ($ClassPattern.Contains('*')) {
+    # Convert wildcard pattern to regex
+    $regexPattern = [regex]::Escape($ClassPattern).Replace('\*', '.*')
+    if ($classNameStr -match $regexPattern) {
+      $isMatch = $true
+    }
+  }
+
+  if ($isMatch) {
+    $windowPid = 0
+    [Win32]::GetWindowThreadProcessId($hwnd, [ref]$windowPid) | Out-Null
+    $title = New-Object System.Text.StringBuilder 256
+    [Win32]::GetWindowText($hwnd, $title, 256) | Out-Null
+    $windows += @{
+      Handle = $hwnd.ToString()
+      Title = $title.ToString()
+      ClassName = $classNameStr
+      ProcessId = $windowPid
+    }
+  }
+}
+$windows | ConvertTo-Json -Compress

package/dist/native/scripts/windows/enum-windows.ps1

@@ -1,44 +1,44 @@
-param(
-    [int]$TargetPid
-)
-
-Add-Type @"
-  using System;
-  using System.Runtime.InteropServices;
-  public class Win32 {
-    [DllImport("user32.dll")] public static extern IntPtr FindWindowEx(IntPtr parent, IntPtr childAfter, string className, string title);
-    [DllImport("user32.dll")] public static extern int GetWindowThreadProcessId(IntPtr hWnd, out int pid);
-    [DllImport("user32.dll")] public static extern int GetWindowText(IntPtr hWnd, System.Text.StringBuilder text, int count);
-    [DllImport("user32.dll")] public static extern int GetClassName(IntPtr hWnd, System.Text.StringBuilder className, int maxCount);
-    [DllImport("user32.dll")] public static extern bool GetWindowRect(IntPtr hWnd, out RECT rect);
-    [StructLayout(LayoutKind.Sequential)] public struct RECT { public int Left, Top, Right, Bottom; }
-  }
-"@
-
-$windows = @()
-$hwnd = [IntPtr]::Zero
-while ($true) {
-  $hwnd = [Win32]::FindWindowEx([IntPtr]::Zero, $hwnd, $null, $null)
-  if ($hwnd -eq [IntPtr]::Zero) { break }
-  $windowPid = 0
-  [Win32]::GetWindowThreadProcessId($hwnd, [ref]$windowPid) | Out-Null
-  if ($windowPid -eq $TargetPid) {
-    $title = New-Object System.Text.StringBuilder 256
-    $className = New-Object System.Text.StringBuilder 256
-    [Win32]::GetWindowText($hwnd, $title, 256) | Out-Null
-    [Win32]::GetClassName($hwnd, $className, 256) | Out-Null
-    $rect = New-Object Win32+RECT
-    [Win32]::GetWindowRect($hwnd, [ref]$rect) | Out-Null
-    $windows += @{
-      Handle = $hwnd.ToString()
-      Title = $title.ToString()
-      ClassName = $className.ToString()
-      ProcessId = $windowPid
-      Left = $rect.Left
-      Top = $rect.Top
-      Right = $rect.Right
-      Bottom = $rect.Bottom
-    }
-  }
-}
-$windows | ConvertTo-Json -Compress
+param(
+    [int]$TargetPid
+)
+
+Add-Type @"
+  using System;
+  using System.Runtime.InteropServices;
+  public class Win32 {
+    [DllImport("user32.dll")] public static extern IntPtr FindWindowEx(IntPtr parent, IntPtr childAfter, string className, string title);
+    [DllImport("user32.dll")] public static extern int GetWindowThreadProcessId(IntPtr hWnd, out int pid);
+    [DllImport("user32.dll")] public static extern int GetWindowText(IntPtr hWnd, System.Text.StringBuilder text, int count);
+    [DllImport("user32.dll")] public static extern int GetClassName(IntPtr hWnd, System.Text.StringBuilder className, int maxCount);
+    [DllImport("user32.dll")] public static extern bool GetWindowRect(IntPtr hWnd, out RECT rect);
+    [StructLayout(LayoutKind.Sequential)] public struct RECT { public int Left, Top, Right, Bottom; }
+  }
+"@
+
+$windows = @()
+$hwnd = [IntPtr]::Zero
+while ($true) {
+  $hwnd = [Win32]::FindWindowEx([IntPtr]::Zero, $hwnd, $null, $null)
+  if ($hwnd -eq [IntPtr]::Zero) { break }
+  $windowPid = 0
+  [Win32]::GetWindowThreadProcessId($hwnd, [ref]$windowPid) | Out-Null
+  if ($windowPid -eq $TargetPid) {
+    $title = New-Object System.Text.StringBuilder 256
+    $className = New-Object System.Text.StringBuilder 256
+    [Win32]::GetWindowText($hwnd, $title, 256) | Out-Null
+    [Win32]::GetClassName($hwnd, $className, 256) | Out-Null
+    $rect = New-Object Win32+RECT
+    [Win32]::GetWindowRect($hwnd, [ref]$rect) | Out-Null
+    $windows += @{
+      Handle = $hwnd.ToString()
+      Title = $title.ToString()
+      ClassName = $className.ToString()
+      ProcessId = $windowPid
+      Left = $rect.Left
+      Top = $rect.Top
+      Right = $rect.Right
+      Bottom = $rect.Bottom
+    }
+  }
+}
+$windows | ConvertTo-Json -Compress

package/dist/native/scripts/windows/inject-dll.ps1

@@ -1,21 +1,21 @@
-param(
-    [int]$TargetPid,
-    [string]$DllPath
-)
-
-Add-Type @"
-  using System;
-  using System.Runtime.InteropServices;
-  public class Injector {
-    [DllImport("kernel32.dll")] public static extern IntPtr OpenProcess(int access, bool inherit, int pid);
-    [DllImport("kernel32.dll")] public static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr addr, int size, int alloc, int protect);
-    [DllImport("kernel32.dll")] public static extern bool WriteProcessMemory(IntPtr hProcess, IntPtr addr, byte[] buffer, int size, out int written);
-    [DllImport("kernel32.dll")] public static extern IntPtr CreateRemoteThread(IntPtr hProcess, IntPtr attr, int stack, IntPtr start, IntPtr param, int flags, out int threadId);
-    [DllImport("kernel32.dll")] public static extern IntPtr GetModuleHandle(string name);
-    [DllImport("kernel32.dll")] public static extern IntPtr GetProcAddress(IntPtr hModule, string name);
-    [DllImport("kernel32.dll")] public static extern bool CloseHandle(IntPtr handle);
-  }
-"@
-
-# Injection requires elevated privileges and is disabled for safety
-Write-Output "DLL injection is disabled for safety in this implementation. PID: $TargetPid, DLL: $DllPath"
+param(
+    [int]$TargetPid,
+    [string]$DllPath
+)
+
+Add-Type @"
+  using System;
+  using System.Runtime.InteropServices;
+  public class Injector {
+    [DllImport("kernel32.dll")] public static extern IntPtr OpenProcess(int access, bool inherit, int pid);
+    [DllImport("kernel32.dll")] public static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr addr, int size, int alloc, int protect);
+    [DllImport("kernel32.dll")] public static extern bool WriteProcessMemory(IntPtr hProcess, IntPtr addr, byte[] buffer, int size, out int written);
+    [DllImport("kernel32.dll")] public static extern IntPtr CreateRemoteThread(IntPtr hProcess, IntPtr attr, int stack, IntPtr start, IntPtr param, int flags, out int threadId);
+    [DllImport("kernel32.dll")] public static extern IntPtr GetModuleHandle(string name);
+    [DllImport("kernel32.dll")] public static extern IntPtr GetProcAddress(IntPtr hModule, string name);
+    [DllImport("kernel32.dll")] public static extern bool CloseHandle(IntPtr handle);
+  }
+"@
+
+# Injection requires elevated privileges and is disabled for safety
+Write-Output "DLL injection is disabled for safety in this implementation. PID: $TargetPid, DLL: $DllPath"

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;