@jshookmcp/jshook 0.2.5 → 0.2.7

package/dist/src/modules/process/index.d.ts

@@ -1,38 +0,0 @@
-import { ProcessManager as WindowsProcessManager } from '../process/ProcessManager.js';
-import { LinuxProcessManager } from '../process/LinuxProcessManager.js';
-import { MacProcessManager } from '../process/MacProcessManager.js';
-export type { ProcessInfo, WindowInfo, ChromiumProcess, TargetAppConfig, } from '../process/ProcessManager.js';
-export { DEFAULT_CHROMIUM_CONFIG } from '../process/ProcessManager.js';
-export type { ChromeProcess as LinuxChromeProcess } from '../process/LinuxProcessManager.js';
-export type { ChromeProcess as MacChromeProcess } from '../process/MacProcessManager.js';
-export { WindowsProcessManager };
-export { LinuxProcessManager };
-export { MacProcessManager };
-export { MemoryManager, type MemoryReadResult, type MemoryWriteResult, type MemoryScanResult, } from '../process/MemoryManager.js';
-export { scanMemory, dumpMemory, listMemoryRegions, checkProtection, scanFiltered, batchWrite, startMonitor, stopMonitor, injectDll, injectShellcode, checkDebugPort, enumerateModules, } from '../process/memoryUtils.js';
-export type Platform = 'win32' | 'linux' | 'darwin' | 'unknown';
-export declare function detectPlatform(): Platform;
-export declare function createProcessManager(): WindowsProcessManager | LinuxProcessManager | MacProcessManager;
-export declare function isProcessManagementSupported(): boolean;
-export declare class UnifiedProcessManager {
-    private manager;
-    private platform;
-    constructor();
-    getPlatform(): Platform;
-    findProcesses(pattern: string): Promise<import("../process/ProcessManager.js").ProcessInfo[]>;
-    getProcessByPid(pid: number): Promise<import("../process/ProcessManager.js").ProcessInfo | null>;
-    getProcessWindows(pid: number): Promise<import("../process/ProcessManager.js").WindowInfo[]>;
-    checkDebugPort(pid: number, options?: {
-        commandLine?: string;
-    }): Promise<number | null>;
-    launchWithDebug(executablePath: string, debugPort?: number, args?: string[]): Promise<import("../process/ProcessManager.js").ProcessInfo | null>;
-    killProcess(pid: number): Promise<boolean>;
-    getProcessCommandLine(pid: number): Promise<{
-        commandLine?: string;
-        parentPid?: number;
-    }>;
-    findBrowserProcesses(config?: {
-        processNamePattern?: string;
-        windowClassPattern?: string;
-    }): Promise<import("../process/ProcessManager.js").ChromiumProcess | null>;
-}

package/dist/src/modules/process/index.js

@@ -1,91 +0,0 @@
-import { ProcessManager as WindowsProcessManager } from '../process/ProcessManager.js';
-import { LinuxProcessManager } from '../process/LinuxProcessManager.js';
-import { MacProcessManager } from '../process/MacProcessManager.js';
-import { logger } from '../../utils/logger.js';
-export { DEFAULT_CHROMIUM_CONFIG } from '../process/ProcessManager.js';
-export { WindowsProcessManager };
-export { LinuxProcessManager };
-export { MacProcessManager };
-export { MemoryManager, } from '../process/MemoryManager.js';
-export { scanMemory, dumpMemory, listMemoryRegions, checkProtection, scanFiltered, batchWrite, startMonitor, stopMonitor, injectDll, injectShellcode, checkDebugPort, enumerateModules, } from '../process/memoryUtils.js';
-export function detectPlatform() {
-    const platform = process.platform;
-    switch (platform) {
-        case 'win32':
-            return 'win32';
-        case 'linux':
-            return 'linux';
-        case 'darwin':
-            return 'darwin';
-        default:
-            logger.warn(`Unsupported platform: ${platform}`);
-            return 'unknown';
-    }
-}
-export function createProcessManager() {
-    const platform = detectPlatform();
-    logger.info(`Creating ProcessManager for platform: ${platform}`);
-    switch (platform) {
-        case 'win32':
-            return new WindowsProcessManager();
-        case 'linux':
-            return new LinuxProcessManager();
-        case 'darwin':
-            return new MacProcessManager();
-        default:
-            throw new Error(`Unsupported platform: ${platform}. ProcessManager requires Windows, Linux, or macOS.`);
-    }
-}
-export function isProcessManagementSupported() {
-    return detectPlatform() !== 'unknown';
-}
-export class UnifiedProcessManager {
-    manager;
-    platform;
-    constructor() {
-        this.platform = detectPlatform();
-        this.manager = createProcessManager();
-    }
-    getPlatform() {
-        return this.platform;
-    }
-    async findProcesses(pattern) {
-        return this.manager.findProcesses(pattern);
-    }
-    async getProcessByPid(pid) {
-        return this.manager.getProcessByPid(pid);
-    }
-    async getProcessWindows(pid) {
-        return this.manager.getProcessWindows(pid);
-    }
-    async checkDebugPort(pid, options) {
-        return this.manager.checkDebugPort(pid, options);
-    }
-    async launchWithDebug(executablePath, debugPort, args) {
-        return this.manager.launchWithDebug(executablePath, debugPort, args);
-    }
-    async killProcess(pid) {
-        return this.manager.killProcess(pid);
-    }
-    async getProcessCommandLine(pid) {
-        return this.manager.getProcessCommandLine(pid);
-    }
-    async findBrowserProcesses(config) {
-        if (this.platform === 'win32') {
-            if (config?.processNamePattern || config?.windowClassPattern) {
-                return this.manager.findChromiumProcesses({
-                    processNamePattern: config.processNamePattern,
-                    windowClassPattern: config.windowClassPattern,
-                });
-            }
-            return this.manager.findChromiumAppProcesses();
-        }
-        else if (this.platform === 'linux') {
-            return this.manager.findChromeProcesses();
-        }
-        else if (this.platform === 'darwin') {
-            return this.manager.findChromeProcesses();
-        }
-        return null;
-    }
-}

package/dist/src/modules/process/memory/AuditTrail.d.ts

@@ -1,25 +0,0 @@
-export interface AuditEntry {
-    timestamp: string;
-    operation: string;
-    pid: number | null;
-    address: string | null;
-    size: number | null;
-    result: 'success' | 'failure';
-    error?: string;
-    durationMs: number;
-    user: string;
-    pattern?: string;
-    resultsCount?: number;
-    dllPath?: string;
-}
-export declare class MemoryAuditTrail {
-    private buffer;
-    private head;
-    private count;
-    private readonly capacity;
-    constructor(capacity?: number);
-    record(entry: Omit<AuditEntry, 'timestamp' | 'user'>): void;
-    exportJson(): string;
-    clear(): void;
-    size(): number;
-}

package/dist/src/modules/process/memory/AuditTrail.js

@@ -1,44 +0,0 @@
-export class MemoryAuditTrail {
-    buffer;
-    head = 0;
-    count = 0;
-    capacity;
-    constructor(capacity = 5000) {
-        this.capacity = Number.isInteger(capacity) && capacity > 0 ? capacity : 5000;
-        this.buffer = Array.from({ length: this.capacity });
-    }
-    record(entry) {
-        const fullEntry = {
-            ...entry,
-            timestamp: new Date().toISOString(),
-            user: process.env.USERNAME || process.env.USER || 'unknown',
-        };
-        if (this.count < this.capacity) {
-            const writeIndex = (this.head + this.count) % this.capacity;
-            this.buffer[writeIndex] = fullEntry;
-            this.count += 1;
-            return;
-        }
-        this.buffer[this.head] = fullEntry;
-        this.head = (this.head + 1) % this.capacity;
-    }
-    exportJson() {
-        const entries = [];
-        for (let i = 0; i < this.count; i += 1) {
-            const index = (this.head + i) % this.capacity;
-            const entry = this.buffer[index];
-            if (entry) {
-                entries.push(entry);
-            }
-        }
-        return JSON.stringify(entries, null, 2);
-    }
-    clear() {
-        this.buffer = [];
-        this.head = 0;
-        this.count = 0;
-    }
-    size() {
-        return this.count;
-    }
-}

package/dist/src/modules/process/memory/availability.d.ts

@@ -1,10 +0,0 @@
-import { type Platform } from '../../process/memory/types.js';
-export declare function checkAvailability(platform: Platform): Promise<{
-    available: boolean;
-    reason?: string;
-}>;
-export declare function checkDebugPort(platform: Platform, pid: number): Promise<{
-    success: boolean;
-    isDebugged?: boolean;
-    error?: string;
-}>;

package/dist/src/modules/process/memory/availability.js

@@ -1,179 +0,0 @@
-import { executePowerShellScript, execAsync } from '../../process/memory/types.js';
-const WINDOWS_CACHE_TTL_MS = 45_000;
-let windowsAvailabilityCache = null;
-function getExecErrorStream(error, key) {
-    if (typeof error !== 'object' || error === null)
-        return '';
-    const stream = error[key];
-    return typeof stream === 'string' ? stream : '';
-}
-function getWindowsAvailabilityFailureReason(error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    const stderr = getExecErrorStream(error, 'stderr');
-    const combined = `${errorMessage}\n${stderr}`.toLowerCase();
-    if (combined.includes('enoent') ||
-        combined.includes('command not found') ||
-        combined.includes('is not recognized as an internal or external command') ||
-        (combined.includes('cannot find') && combined.includes('powershell'))) {
-        return 'PowerShell is unavailable. Windows memory operations require powershell.exe to verify Administrator privileges.';
-    }
-    return `PowerShell command execution failed while checking Administrator privileges: ${errorMessage}`;
-}
-async function runWindowsAdminAvailabilityCheck() {
-    try {
-        const { stdout } = await executePowerShellScript('([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)', { timeout: 5000 });
-        const normalizedOutput = stdout.trim().toLowerCase();
-        if (normalizedOutput === 'true') {
-            return { available: true };
-        }
-        if (normalizedOutput === 'false') {
-            return {
-                available: false,
-                reason: 'Windows memory operations require Administrator privileges. Please run your terminal/IDE as Administrator and retry.',
-            };
-        }
-        return {
-            available: false,
-            reason: `PowerShell command execution failed while checking Administrator privileges: unexpected output "${stdout.trim() || '(empty)'}".`,
-        };
-    }
-    catch (error) {
-        return {
-            available: false,
-            reason: getWindowsAvailabilityFailureReason(error),
-        };
-    }
-}
-async function checkWindowsAvailability() {
-    const now = Date.now();
-    if (windowsAvailabilityCache && windowsAvailabilityCache.expiresAt > now) {
-        return windowsAvailabilityCache.result;
-    }
-    const result = await runWindowsAdminAvailabilityCheck();
-    windowsAvailabilityCache = { expiresAt: now + WINDOWS_CACHE_TTL_MS, result };
-    return result;
-}
-export async function checkAvailability(platform) {
-    switch (platform) {
-        case 'win32':
-            return checkWindowsAvailability();
-        case 'linux':
-            try {
-                const { stdout } = await execAsync('id -u', { timeout: 2000 });
-                if (stdout.trim() === '0') {
-                    return { available: true };
-                }
-                try {
-                    await execAsync('capsh --print 2>/dev/null | grep -q "cap_sys_ptrace"', {
-                        timeout: 2000,
-                    });
-                    return { available: true };
-                }
-                catch {
-                    return {
-                        available: false,
-                        reason: 'Linux memory operations require root privileges or CAP_SYS_PTRACE capability. Run with sudo.',
-                    };
-                }
-            }
-            catch {
-                return {
-                    available: false,
-                    reason: 'Requires root privileges for /proc/pid/mem access. Run with sudo.',
-                };
-            }
-        case 'darwin':
-            try {
-                await execAsync('which lldb', { timeout: 3000 });
-                const isRoot = process.getuid?.() === 0;
-                return {
-                    available: true,
-                    reason: isRoot
-                        ? undefined
-                        : 'Running without root — memory access works for own processes only. Use sudo for other processes.',
-                };
-            }
-            catch {
-                return {
-                    available: false,
-                    reason: 'lldb not found. Install Xcode Command Line Tools: xcode-select --install',
-                };
-            }
-        default:
-            return {
-                available: false,
-                reason: `Platform ${platform} not supported for memory operations.`,
-            };
-    }
-}
-export async function checkDebugPort(platform, pid) {
-    if (platform !== 'win32') {
-        return { success: false, error: 'Debug port check currently only implemented for Windows' };
-    }
-    try {
-        const psScript = `
-Add-Type @"
-using System;
-using System.Runtime.InteropServices;
-using System.ComponentModel;
-
-public class DebugChecker {
-    [DllImport("ntdll.dll")]
-    public static extern int NtQueryInformationProcess(IntPtr processHandle, int processInformationClass, out IntPtr processInformation, int processInformationLength, out int returnLength);
-
-    [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 CloseHandle(IntPtr handle);
-
-    const int PROCESS_QUERY_INFORMATION = 0x0400;
-    const int ProcessDebugPort = 7;
-
-    public static object Check(int pid) {
-        IntPtr hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, false, pid);
-        if (hProcess == IntPtr.Zero) {
-            int error = Marshal.GetLastWin32Error();
-            throw new Win32Exception(error, "Failed to open process");
-        }
-
-        try {
-            IntPtr debugPort;
-            int returnLength;
-            int status = NtQueryInformationProcess(hProcess, ProcessDebugPort, out debugPort, IntPtr.Size, out returnLength);
-
-            if (status != 0) {
-                return new { success = false, error = "NtQueryInformationProcess failed with status: 0x" + status.ToString("X") };
-            }
-
-            return new { success = true, isDebugged = debugPort != IntPtr.Zero };
-        } finally {
-            CloseHandle(hProcess);
-        }
-    }
-}
-"@
-
-try {
-    $result = [DebugChecker]::Check(${pid})
-    $result | ConvertTo-Json -Compress
-} catch {
-    @{ success = $false; error = $_.Exception.Message } | ConvertTo-Json -Compress
-}
-    `;
-        const { stdout } = await executePowerShellScript(psScript, {
-            maxBuffer: 1024 * 1024,
-            timeout: 10000,
-        });
-        const _trimmed = stdout.trim();
-        if (!_trimmed)
-            throw new Error('PowerShell returned empty output');
-        return JSON.parse(_trimmed);
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: error instanceof Error ? error.message : 'PowerShell execution failed',
-        };
-    }
-}

package/dist/src/modules/process/memory/index.d.ts

@@ -1,8 +0,0 @@
-export type { Platform, PatternType, MemoryReadResult, MemoryWriteResult, MemoryScanResult, MemoryRegion, MemoryProtectionInfo, ModuleInfo, MemoryPatch, MemoryMonitorEntry, } from '../../process/memory/types.js';
-export { readMemory } from '../../process/memory/reader.js';
-export { writeMemory, batchMemoryWrite } from '../../process/memory/writer.js';
-export { scanMemory, scanMemoryFiltered } from '../../process/memory/scanner.js';
-export { dumpMemoryRegion, enumerateRegions, checkMemoryProtection, enumerateModules, } from '../../process/memory/regions.js';
-export { injectDll, injectShellcode } from '../../process/memory/injector.js';
-export { MemoryMonitorManager } from '../../process/memory/monitor.js';
-export { checkAvailability, checkDebugPort } from '../../process/memory/availability.js';

package/dist/src/modules/process/memory/index.js

@@ -1,7 +0,0 @@
-export { readMemory } from '../../process/memory/reader.js';
-export { writeMemory, batchMemoryWrite } from '../../process/memory/writer.js';
-export { scanMemory, scanMemoryFiltered } from '../../process/memory/scanner.js';
-export { dumpMemoryRegion, enumerateRegions, checkMemoryProtection, enumerateModules, } from '../../process/memory/regions.js';
-export { injectDll, injectShellcode } from '../../process/memory/injector.js';
-export { MemoryMonitorManager } from '../../process/memory/monitor.js';
-export { checkAvailability, checkDebugPort } from '../../process/memory/availability.js';

package/dist/src/modules/process/memory/injector.d.ts

@@ -1,11 +0,0 @@
-import { type Platform } from '../../process/memory/types.js';
-export declare function injectDll(platform: Platform, pid: number, dllPath: string): Promise<{
-    success: boolean;
-    remoteThreadId?: number;
-    error?: string;
-}>;
-export declare function injectShellcode(platform: Platform, pid: number, shellcode: string, encoding?: 'hex' | 'base64'): Promise<{
-    success: boolean;
-    remoteThreadId?: number;
-    error?: string;
-}>;

package/dist/src/modules/process/memory/injector.js

@@ -1,257 +0,0 @@
-import { logger } from '../../../utils/logger.js';
-import { executePowerShellScript } from '../../process/memory/types.js';
-function buildDllInjectionScript(pid, dllPath) {
-    return `
-Add-Type @"
-using System;
-using System.Runtime.InteropServices;
-using System.ComponentModel;
-using System.IO;
-
-public class DllInjector {
-    [DllImport("kernel32.dll", SetLastError = true)]
-    public static extern IntPtr OpenProcess(int access, bool inherit, int pid);
-
-    [DllImport("kernel32.dll", SetLastError = true)]
-    public static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr addr, int size, int allocType, int protect);
-
-    [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 IntPtr CreateRemoteThread(IntPtr hProcess, IntPtr attr, int stackSize, IntPtr startAddr, IntPtr param, int flags, out int threadId);
-
-    [DllImport("kernel32.dll", SetLastError = true)]
-    public static extern IntPtr GetModuleHandle(string name);
-
-    [DllImport("kernel32.dll", SetLastError = true)]
-    public static extern IntPtr GetProcAddress(IntPtr hModule, string name);
-
-    [DllImport("kernel32.dll", SetLastError = true)]
-    public static extern bool CloseHandle(IntPtr handle);
-
-    [DllImport("kernel32.dll", SetLastError = true)]
-    public static extern bool VirtualFreeEx(IntPtr hProcess, IntPtr addr, int size, int freeType);
-
-    const int PROCESS_CREATE_THREAD = 0x0002;
-    const int PROCESS_QUERY_INFORMATION = 0x0400;
-    const int PROCESS_VM_OPERATION = 0x0008;
-    const int PROCESS_VM_WRITE = 0x0020;
-    const int MEM_COMMIT = 0x1000;
-    const int MEM_RESERVE = 0x2000;
-    const int PAGE_READWRITE = 0x04;
-    const int MEM_RELEASE = 0x8000;
-
-    public static object Inject(int pid, string dllPath) {
-        if (!File.Exists(dllPath)) {
-            return new { success = false, error = "DLL not found: " + dllPath };
-        }
-
-        IntPtr hProcess = OpenProcess(PROCESS_CREATE_THREAD | PROCESS_QUERY_INFORMATION | PROCESS_VM_OPERATION | PROCESS_VM_WRITE, false, pid);
-        if (hProcess == IntPtr.Zero) {
-            int error = Marshal.GetLastWin32Error();
-            throw new Win32Exception(error, "Failed to open process. Run as Administrator.");
-        }
-
-        try {
-            byte[] dllBytes = System.Text.Encoding.ASCII.GetBytes(dllPath + "\\0");
-            IntPtr remoteMem = VirtualAllocEx(hProcess, IntPtr.Zero, dllBytes.Length, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
-            if (remoteMem == IntPtr.Zero) {
-                int error = Marshal.GetLastWin32Error();
-                throw new Win32Exception(error, "Failed to allocate memory in target");
-            }
-
-            try {
-                int written;
-                if (!WriteProcessMemory(hProcess, remoteMem, dllBytes, dllBytes.Length, out written)) {
-                    int error = Marshal.GetLastWin32Error();
-                    throw new Win32Exception(error, "Failed to write DLL path to target");
-                }
-
-                IntPtr hKernel32 = GetModuleHandle("kernel32.dll");
-                IntPtr loadLibraryAddr = GetProcAddress(hKernel32, "LoadLibraryA");
-                if (loadLibraryAddr == IntPtr.Zero) {
-                    throw new Exception("Failed to get LoadLibraryA address");
-                }
-
-                int threadId;
-                IntPtr hThread = CreateRemoteThread(hProcess, IntPtr.Zero, 0, loadLibraryAddr, remoteMem, 0, out threadId);
-                if (hThread == IntPtr.Zero) {
-                    int error = Marshal.GetLastWin32Error();
-                    throw new Win32Exception(error, "Failed to create remote thread");
-                }
-
-                CloseHandle(hThread);
-                return new { success = true, remoteThreadId = threadId };
-            } finally {
-                VirtualFreeEx(hProcess, remoteMem, 0, MEM_RELEASE);
-            }
-        } finally {
-            CloseHandle(hProcess);
-        }
-    }
-}
-"@
-
-try {
-    $result = [DllInjector]::Inject(${pid}, "${dllPath.replace(/\\/g, '\\\\').replace(/"/g, '`"').replace(/`/g, '``').replace(/\$/g, '`$')}")
-    $result | ConvertTo-Json -Compress
-} catch {
-    @{ success = $false; error = $_.Exception.Message } | ConvertTo-Json -Compress
-}
-  `.trim();
-}
-export async function injectDll(platform, pid, dllPath) {
-    if (platform !== 'win32') {
-        return { success: false, error: 'DLL injection currently only implemented for Windows' };
-    }
-    try {
-        const psScript = buildDllInjectionScript(pid, dllPath);
-        const { stdout } = await executePowerShellScript(psScript, {
-            maxBuffer: 1024 * 1024,
-            timeout: 30000,
-        });
-        const _trimmed = stdout.trim();
-        if (!_trimmed)
-            throw new Error('PowerShell returned empty output');
-        const result = JSON.parse(_trimmed);
-        return {
-            success: result.success,
-            remoteThreadId: result.remoteThreadId,
-            error: result.error,
-        };
-    }
-    catch (error) {
-        logger.error('DLL injection failed:', error);
-        return {
-            success: false,
-            error: error instanceof Error ? error.message : 'PowerShell execution failed',
-        };
-    }
-}
-function buildShellcodeInjectionScript(pid, shellcode) {
-    return `
-Add-Type @"
-using System;
-using System.Runtime.InteropServices;
-using System.ComponentModel;
-
-public class ShellcodeInjector {
-    [DllImport("kernel32.dll", SetLastError = true)]
-    public static extern IntPtr OpenProcess(int access, bool inherit, int pid);
-
-    [DllImport("kernel32.dll", SetLastError = true)]
-    public static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr addr, int size, int allocType, int protect);
-
-    [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 IntPtr CreateRemoteThread(IntPtr hProcess, IntPtr attr, int stackSize, IntPtr startAddr, IntPtr param, int flags, out int threadId);
-
-    [DllImport("kernel32.dll", SetLastError = true)]
-    public static extern bool CloseHandle(IntPtr handle);
-
-    [DllImport("kernel32.dll", SetLastError = true)]
-    public static extern bool VirtualProtectEx(IntPtr hProcess, IntPtr addr, int size, int newProtect, out int oldProtect);
-
-    const int PROCESS_CREATE_THREAD = 0x0002;
-    const int PROCESS_QUERY_INFORMATION = 0x0400;
-    const int PROCESS_VM_OPERATION = 0x0008;
-    const int PROCESS_VM_WRITE = 0x0020;
-    const int MEM_COMMIT = 0x1000;
-    const int MEM_RESERVE = 0x2000;
-    const int PAGE_READWRITE = 0x04;
-    const int PAGE_EXECUTE_READWRITE = 0x40;
-
-    public static object Inject(int pid, byte[] shellcode) {
-        IntPtr hProcess = OpenProcess(PROCESS_CREATE_THREAD | PROCESS_QUERY_INFORMATION | PROCESS_VM_OPERATION | PROCESS_VM_WRITE, false, pid);
-        if (hProcess == IntPtr.Zero) {
-            int error = Marshal.GetLastWin32Error();
-            throw new Win32Exception(error, "Failed to open process. Run as Administrator.");
-        }
-
-        try {
-            IntPtr remoteMem = VirtualAllocEx(hProcess, IntPtr.Zero, shellcode.Length, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
-            if (remoteMem == IntPtr.Zero) {
-                int error = Marshal.GetLastWin32Error();
-                throw new Win32Exception(error, "Failed to allocate memory in target");
-            }
-
-            try {
-                int written;
-                if (!WriteProcessMemory(hProcess, remoteMem, shellcode, shellcode.Length, out written)) {
-                    int error = Marshal.GetLastWin32Error();
-                    throw new Win32Exception(error, "Failed to write shellcode to target");
-                }
-
-                int oldProtect;
-                if (!VirtualProtectEx(hProcess, remoteMem, shellcode.Length, PAGE_EXECUTE_READWRITE, out oldProtect)) {
-                    int error = Marshal.GetLastWin32Error();
-                    throw new Win32Exception(error, "Failed to change memory protection to executable");
-                }
-
-                int threadId;
-                IntPtr hThread = CreateRemoteThread(hProcess, IntPtr.Zero, 0, remoteMem, IntPtr.Zero, 0, out threadId);
-                if (hThread == IntPtr.Zero) {
-                    int error = Marshal.GetLastWin32Error();
-                    throw new Win32Exception(error, "Failed to create remote thread");
-                }
-
-                CloseHandle(hThread);
-                return new { success = true, remoteThreadId = threadId };
-            } finally {
-                // Note: Memory is not freed to allow shellcode to execute
-            }
-        } finally {
-            CloseHandle(hProcess);
-        }
-    }
-}
-"@
-
-try {
-    $shellcode = @(${Array.from(shellcode).join(',')})
-    $result = [ShellcodeInjector]::Inject(${pid}, $shellcode)
-    $result | ConvertTo-Json -Compress
-} catch {
-    @{ success = $false; error = $_.Exception.Message } | ConvertTo-Json -Compress
-}
-  `.trim();
-}
-export async function injectShellcode(platform, pid, shellcode, encoding = 'hex') {
-    if (platform !== 'win32') {
-        return { success: false, error: 'Shellcode injection currently only implemented for Windows' };
-    }
-    try {
-        let shellcodeBytes;
-        if (encoding === 'base64') {
-            shellcodeBytes = Buffer.from(shellcode, 'base64');
-        }
-        else {
-            const cleanHex = shellcode.replace(/\s/g, '');
-            shellcodeBytes = Buffer.from(cleanHex, 'hex');
-        }
-        const psScript = buildShellcodeInjectionScript(pid, shellcodeBytes);
-        const { stdout } = await executePowerShellScript(psScript, {
-            maxBuffer: 1024 * 1024,
-            timeout: 30000,
-        });
-        const _trimmed = stdout.trim();
-        if (!_trimmed)
-            throw new Error('PowerShell returned empty output');
-        const result = JSON.parse(_trimmed);
-        return {
-            success: result.success,
-            remoteThreadId: result.remoteThreadId,
-            error: result.error,
-        };
-    }
-    catch (error) {
-        logger.error('Shellcode injection failed:', error);
-        return {
-            success: false,
-            error: error instanceof Error ? error.message : 'PowerShell execution failed',
-        };
-    }
-}