@jshookmcp/jshook 0.2.6 → 0.2.7

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

@@ -1,56 +0,0 @@
-import { type PatternType, type MemoryReadResult, type MemoryWriteResult, type MemoryScanResult, type MemoryProtectionInfo, type MemoryPatch, enumerateRegions as _enumerateRegions } from '../process/memory/index.js';
-export type { MemoryReadResult, MemoryWriteResult, MemoryScanResult };
-export declare class MemoryManager {
-    private platform;
-    private monitorManager;
-    constructor();
-    readMemory(pid: number, address: string, size: number): Promise<MemoryReadResult>;
-    writeMemory(pid: number, address: string, data: string, encoding?: 'hex' | 'base64'): Promise<MemoryWriteResult>;
-    batchMemoryWrite(pid: number, patches: MemoryPatch[]): Promise<{
-        success: boolean;
-        results: {
-            address: string;
-            success: boolean;
-            error?: string;
-        }[];
-        error?: string;
-    }>;
-    scanMemory(pid: number, pattern: string, patternType?: PatternType, suspendTarget?: boolean): Promise<MemoryScanResult>;
-    scanMemoryFiltered(pid: number, pattern: string, addresses: string[], patternType?: PatternType): Promise<MemoryScanResult>;
-    dumpMemoryRegion(pid: number, startAddress: string, size: number, outputPath: string): Promise<{
-        success: boolean;
-        error?: string;
-    }>;
-    enumerateRegions(pid: number): ReturnType<typeof _enumerateRegions>;
-    checkMemoryProtection(pid: number, address: string): Promise<MemoryProtectionInfo>;
-    enumerateModules(pid: number): Promise<{
-        success: boolean;
-        modules?: {
-            name: string;
-            baseAddress: string;
-            size: number;
-        }[];
-        error?: string;
-    }>;
-    injectDll(pid: number, dllPath: string): Promise<{
-        success: boolean;
-        remoteThreadId?: number;
-        error?: string;
-    }>;
-    injectShellcode(pid: number, shellcode: string, encoding?: 'hex' | 'base64'): Promise<{
-        success: boolean;
-        remoteThreadId?: number;
-        error?: string;
-    }>;
-    checkDebugPort(pid: number): Promise<{
-        success: boolean;
-        isDebugged?: boolean;
-        error?: string;
-    }>;
-    startMemoryMonitor(pid: number, address: string, size?: number, intervalMs?: number, onChange?: (oldValue: string, newValue: string) => void): string;
-    stopMemoryMonitor(monitorId: string): boolean;
-    checkAvailability(): Promise<{
-        available: boolean;
-        reason?: string;
-    }>;
-}

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

@@ -1,68 +0,0 @@
-import { logger } from '../../utils/logger.js';
-import { readMemory as _readMemory, writeMemory as _writeMemory, batchMemoryWrite as _batchMemoryWrite, scanMemory as _scanMemory, scanMemoryFiltered as _scanMemoryFiltered, dumpMemoryRegion as _dumpMemoryRegion, enumerateRegions as _enumerateRegions, checkMemoryProtection as _checkMemoryProtection, enumerateModules as _enumerateModules, injectDll as _injectDll, injectShellcode as _injectShellcode, MemoryMonitorManager, checkAvailability as _checkAvailability, checkDebugPort as _checkDebugPort, } from '../process/memory/index.js';
-function detectPlatform() {
-    const platform = process.platform;
-    switch (platform) {
-        case 'win32':
-            return 'win32';
-        case 'linux':
-            return 'linux';
-        case 'darwin':
-            return 'darwin';
-        default:
-            return 'unknown';
-    }
-}
-export class MemoryManager {
-    platform;
-    monitorManager = new MemoryMonitorManager();
-    constructor() {
-        this.platform = detectPlatform();
-        logger.info(`MemoryManager initialized for platform: ${this.platform}`);
-    }
-    async readMemory(pid, address, size) {
-        return _readMemory(this.platform, pid, address, size, (p, a) => _checkMemoryProtection(this.platform, p, a));
-    }
-    async writeMemory(pid, address, data, encoding = 'hex') {
-        return _writeMemory(this.platform, pid, address, data, encoding, (p, a) => _checkMemoryProtection(this.platform, p, a));
-    }
-    async batchMemoryWrite(pid, patches) {
-        return _batchMemoryWrite(pid, patches, (p, addr, data, enc) => this.writeMemory(p, addr, data, enc));
-    }
-    async scanMemory(pid, pattern, patternType = 'hex', suspendTarget = false) {
-        return _scanMemory(this.platform, pid, pattern, patternType, suspendTarget);
-    }
-    async scanMemoryFiltered(pid, pattern, addresses, patternType = 'hex') {
-        return _scanMemoryFiltered(pid, pattern, addresses, patternType, (p, addr, size) => this.readMemory(p, addr, size), (p, pat, type) => this.scanMemory(p, pat, type));
-    }
-    async dumpMemoryRegion(pid, startAddress, size, outputPath) {
-        return _dumpMemoryRegion(this.platform, pid, startAddress, size, outputPath);
-    }
-    async enumerateRegions(pid) {
-        return _enumerateRegions(this.platform, pid);
-    }
-    async checkMemoryProtection(pid, address) {
-        return _checkMemoryProtection(this.platform, pid, address);
-    }
-    async enumerateModules(pid) {
-        return _enumerateModules(this.platform, pid);
-    }
-    async injectDll(pid, dllPath) {
-        return _injectDll(this.platform, pid, dllPath);
-    }
-    async injectShellcode(pid, shellcode, encoding = 'hex') {
-        return _injectShellcode(this.platform, pid, shellcode, encoding);
-    }
-    async checkDebugPort(pid) {
-        return _checkDebugPort(this.platform, pid);
-    }
-    startMemoryMonitor(pid, address, size = 4, intervalMs = 1000, onChange) {
-        return this.monitorManager.start(pid, address, size, intervalMs, (p, addr, sz) => this.readMemory(p, addr, sz), onChange);
-    }
-    stopMemoryMonitor(monitorId) {
-        return this.monitorManager.stop(monitorId);
-    }
-    async checkAvailability() {
-        return _checkAvailability(this.platform);
-    }
-}

package/dist/src/modules/process/ProcessManager.chromium.d.ts

@@ -1,12 +0,0 @@
-import type { ChromiumProcess, ProcessInfo, TargetAppConfig, WindowInfo } from '../process/ProcessManager.types.js';
-export interface ChromiumDiscoveryDeps {
-    findProcesses: (pattern: string) => Promise<ProcessInfo[]>;
-    getProcessCommandLine: (pid: number) => Promise<{
-        commandLine?: string;
-        parentPid?: number;
-    }>;
-    getProcessWindows: (pid: number) => Promise<WindowInfo[]>;
-    logInfo: (message: string, payload?: unknown) => void;
-    logError: (message: string, error?: unknown) => void;
-}
-export declare function findChromiumProcessesWithConfig(config: TargetAppConfig, deps: ChromiumDiscoveryDeps): Promise<ChromiumProcess>;

package/dist/src/modules/process/ProcessManager.chromium.js

@@ -1,71 +0,0 @@
-function matchesPattern(value, pattern) {
-    if (!pattern) {
-        return false;
-    }
-    if (typeof pattern === 'string') {
-        return value.includes(pattern);
-    }
-    return pattern.test(value);
-}
-export async function findChromiumProcessesWithConfig(config, deps) {
-    const result = {
-        rendererProcesses: [],
-        utilityProcesses: [],
-    };
-    try {
-        let processes;
-        if (config.processNamePattern instanceof RegExp) {
-            const allProcesses = await deps.findProcesses('');
-            const matcher = config.processNamePattern;
-            processes = allProcesses.filter((proc) => matcher.test(proc.name));
-        }
-        else {
-            const processName = config.processNamePattern || 'chromium';
-            processes = await deps.findProcesses(processName);
-        }
-        for (const proc of processes) {
-            const detailedInfo = await deps.getProcessCommandLine(proc.pid);
-            if (detailedInfo?.commandLine) {
-                const cmd = detailedInfo.commandLine.toLowerCase();
-                if (cmd.includes('--type=renderer')) {
-                    result.rendererProcesses.push({ ...proc, ...detailedInfo });
-                }
-                else if (cmd.includes('--type=gpu-process')) {
-                    result.gpuProcess = { ...proc, ...detailedInfo };
-                }
-                else if (cmd.includes('--type=utility')) {
-                    result.utilityProcesses.push({ ...proc, ...detailedInfo });
-                }
-                else if (!cmd.includes('--type=')) {
-                    result.mainProcess = { ...proc, ...detailedInfo };
-                }
-            }
-            else if (!result.mainProcess) {
-                result.mainProcess = proc;
-            }
-        }
-        const allPids = [result.mainProcess?.pid, ...result.rendererProcesses.map((p) => p.pid)].filter(Boolean);
-        const windowMatcher = (w) => {
-            return (matchesPattern(w.title, config.windowTitlePattern) ||
-                matchesPattern(w.className, config.windowClassPattern));
-        };
-        for (const pid of allPids) {
-            const windows = await deps.getProcessWindows(pid);
-            const targetWindow = windows.find(windowMatcher);
-            if (targetWindow) {
-                result.targetWindow = targetWindow;
-                break;
-            }
-        }
-        deps.logInfo('Chromium processes found:', {
-            main: result.mainProcess?.pid,
-            renderers: result.rendererProcesses.length,
-            hasTargetWindow: !!result.targetWindow,
-        });
-        return result;
-    }
-    catch (error) {
-        deps.logError('Failed to find Chromium processes:', error);
-        return result;
-    }
-}

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

@@ -1,2 +0,0 @@
-export { DEFAULT_CHROMIUM_CONFIG, ProcessManager } from '../process/ProcessManager.impl.js';
-export type { ProcessInfo, WindowInfo, ChromiumProcess, TargetAppConfig, } from '../process/ProcessManager.impl.js';

package/dist/src/modules/process/ProcessManager.impl.d.ts

@@ -1,31 +0,0 @@
-import { type BrowserInfo } from '../browser/BrowserDiscovery.js';
-import { type ChromiumProcess, type ProcessInfo, type TargetAppConfig, type WindowInfo } from '../process/ProcessManager.types.js';
-export { DEFAULT_CHROMIUM_CONFIG, type ChromiumProcess, type ProcessInfo, type TargetAppConfig, type WindowInfo, } from '../process/ProcessManager.types.js';
-export declare class ProcessManager {
-    private powershellPath;
-    private scriptLoader;
-    private browserDiscovery;
-    private processCache;
-    constructor();
-    findProcesses(pattern: string): Promise<ProcessInfo[]>;
-    private computeProcessDiff;
-    getProcessByPid(pid: number): Promise<ProcessInfo | null>;
-    getProcessWindows(pid: number): Promise<WindowInfo[]>;
-    findChromiumProcesses(config?: TargetAppConfig): Promise<ChromiumProcess>;
-    findChromiumAppProcesses(): Promise<ChromiumProcess>;
-    getProcessCommandLine(pid: number): Promise<{
-        commandLine?: string;
-        parentPid?: number;
-    }>;
-    checkDebugPort(pid: number, options?: {
-        commandLine?: string;
-    }): Promise<number | null>;
-    private findPidByListeningPort;
-    launchWithDebug(executablePath: string, debugPort?: number, args?: string[]): Promise<ProcessInfo | null>;
-    injectDll(_pid: number, _dllPath: string): Promise<boolean>;
-    killProcess(pid: number): Promise<boolean>;
-    discoverBrowsers(): Promise<BrowserInfo[]>;
-    findBrowserByWindowClass(classNamePattern: string): Promise<BrowserInfo[]>;
-    findBrowserByProcessName(name: string): Promise<BrowserInfo[]>;
-    detectBrowserDebugPort(pid: number, ports?: number[]): Promise<number | null>;
-}

package/dist/src/modules/process/ProcessManager.impl.js

@@ -1,378 +0,0 @@
-import { exec, spawn } from 'child_process';
-import { promisify } from 'util';
-import { logger } from '../../utils/logger.js';
-import { DEBUG_PORT_CANDIDATES, DEFAULT_DEBUG_PORT, PROCESS_LIST_MAX_BUFFER_BYTES, WIN_DEBUG_PORT_POLL_ATTEMPTS, WIN_DEBUG_PORT_POLL_INTERVAL_MS, } from '../../constants.js';
-import { ScriptLoader } from '../../native/ScriptLoader.js';
-import { BrowserDiscovery } from '../browser/BrowserDiscovery.js';
-import { findChromiumProcessesWithConfig } from '../process/ProcessManager.chromium.js';
-import { DEFAULT_CHROMIUM_CONFIG, } from '../process/ProcessManager.types.js';
-export { DEFAULT_CHROMIUM_CONFIG, } from '../process/ProcessManager.types.js';
-const execAsync = promisify(exec);
-const PROCESS_SNAPSHOT_CACHE_TTL_MS = 3000;
-function sanitizePsPattern(s) {
-    return String(s || '').replace(/[`$"'{}();|<>@#%!\\\n\r]/g, '');
-}
-function safePid(pid) {
-    const n = Math.trunc(Number(pid));
-    if (!Number.isFinite(n) || n <= 0)
-        throw new Error(`Invalid PID: ${pid}`);
-    return n;
-}
-export class ProcessManager {
-    powershellPath = 'powershell.exe';
-    scriptLoader;
-    browserDiscovery;
-    processCache = new Map();
-    constructor() {
-        this.scriptLoader = new ScriptLoader();
-        this.browserDiscovery = new BrowserDiscovery();
-        logger.info('ProcessManager initialized for Windows platform');
-    }
-    async findProcesses(pattern) {
-        try {
-            const normalizedPattern = sanitizePsPattern(String(pattern || '').trim());
-            const cacheKey = normalizedPattern.toLowerCase() || '*';
-            const now = Date.now();
-            const cachedEntry = this.processCache.get(cacheKey);
-            if (cachedEntry && cachedEntry.expiresAt > now) {
-                return cachedEntry.snapshot;
-            }
-            let psCommand;
-            if (normalizedPattern) {
-                psCommand = `Get-Process -Name "*${normalizedPattern.replace(/"/g, '""')}*" -ErrorAction SilentlyContinue | Select-Object Id, ProcessName, Path, MainWindowTitle, MainWindowHandle, CPU, WorkingSet64 | ConvertTo-Json -Compress`;
-            }
-            else {
-                psCommand = `Get-Process -ErrorAction SilentlyContinue | Select-Object Id, ProcessName, Path, MainWindowTitle, MainWindowHandle, CPU, WorkingSet64 | ConvertTo-Json -Compress`;
-            }
-            const { stdout } = await execAsync(`${this.powershellPath} -NoProfile -Command "${psCommand}"`, { maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES });
-            const lines = stdout.trim();
-            const processes = [];
-            if (lines && lines !== 'null') {
-                const data = JSON.parse(lines);
-                const procList = Array.isArray(data) ? data : [data];
-                for (const proc of procList) {
-                    processes.push({
-                        pid: proc.Id,
-                        name: proc.ProcessName,
-                        executablePath: proc.Path,
-                    });
-                }
-            }
-            const byPid = new Map();
-            for (const process of processes) {
-                byPid.set(process.pid, process);
-            }
-            const lastDelta = this.computeProcessDiff(cachedEntry?.byPid ?? new Map(), byPid);
-            this.processCache.set(cacheKey, {
-                expiresAt: now + PROCESS_SNAPSHOT_CACHE_TTL_MS,
-                snapshot: processes,
-                byPid,
-                lastDelta,
-            });
-            const patternStr = normalizedPattern.length > 0 ? `'${normalizedPattern}'` : 'all';
-            logger.info(`Found ${processes.length} processes matching ${patternStr}`);
-            return processes;
-        }
-        catch (error) {
-            logger.error(`Failed to find processes with pattern '${pattern}':`, error);
-            return [];
-        }
-    }
-    computeProcessDiff(previousByPid, nextByPid) {
-        const added = [];
-        const removed = [];
-        const changed = [];
-        for (const [pid, nextProcess] of nextByPid) {
-            const previousProcess = previousByPid.get(pid);
-            if (!previousProcess) {
-                added.push(nextProcess);
-                continue;
-            }
-            if (previousProcess.pid !== nextProcess.pid ||
-                previousProcess.name !== nextProcess.name ||
-                previousProcess.executablePath !== nextProcess.executablePath) {
-                changed.push({ before: previousProcess, after: nextProcess });
-            }
-        }
-        for (const [pid, previousProcess] of previousByPid) {
-            if (!nextByPid.has(pid)) {
-                removed.push(previousProcess);
-            }
-        }
-        return { added, removed, changed };
-    }
-    async getProcessByPid(pid) {
-        try {
-            pid = safePid(pid);
-            const psCommand = `Get-Process -Id ${pid} -ErrorAction SilentlyContinue | Select-Object Id, ProcessName, Path, MainWindowTitle, MainWindowHandle, CPU, WorkingSet64, StartTime | ConvertTo-Json -Compress`;
-            const { stdout } = await execAsync(`${this.powershellPath} -NoProfile -Command "${psCommand}"`, { maxBuffer: 1024 * 1024 });
-            if (!stdout.trim() || stdout.trim() === 'null') {
-                return null;
-            }
-            const proc = JSON.parse(stdout.trim());
-            return {
-                pid: proc.Id,
-                name: proc.ProcessName,
-                executablePath: proc.Path,
-                windowTitle: proc.MainWindowTitle,
-                windowHandle: proc.MainWindowHandle?.toString(),
-                cpuUsage: proc.CPU,
-                memoryUsage: proc.WorkingSet64,
-            };
-        }
-        catch (error) {
-            logger.error(`Failed to get process by PID ${pid}:`, error);
-            return null;
-        }
-    }
-    async getProcessWindows(pid) {
-        try {
-            pid = safePid(pid);
-            const scriptPath = await this.scriptLoader.getScriptPath('enum-windows.ps1');
-            const { stdout } = await execAsync(`${this.powershellPath} -NoProfile -ExecutionPolicy Bypass -File "${scriptPath}" -TargetPid ${pid}`, { maxBuffer: 1024 * 1024 });
-            if (!stdout.trim() || stdout.trim() === 'null') {
-                return [];
-            }
-            const data = JSON.parse(stdout.trim());
-            const windows = [];
-            const winList = Array.isArray(data) ? data : [data];
-            for (const win of winList) {
-                windows.push({
-                    handle: win.Handle,
-                    title: win.Title,
-                    className: win.ClassName,
-                    processId: win.ProcessId,
-                    threadId: 0,
-                });
-            }
-            return windows;
-        }
-        catch (error) {
-            logger.error(`Failed to get windows for PID ${pid}:`, error);
-            return [];
-        }
-    }
-    async findChromiumProcesses(config = DEFAULT_CHROMIUM_CONFIG) {
-        return findChromiumProcessesWithConfig(config, {
-            findProcesses: (pattern) => this.findProcesses(pattern),
-            getProcessCommandLine: (pid) => this.getProcessCommandLine(pid),
-            getProcessWindows: (pid) => this.getProcessWindows(pid),
-            logInfo: (message, payload) => logger.info(message, payload),
-            logError: (message, error) => logger.error(message, error),
-        });
-    }
-    async findChromiumAppProcesses() {
-        return this.findChromiumProcesses();
-    }
-    async getProcessCommandLine(pid) {
-        try {
-            pid = safePid(pid);
-            const psCommand = `Get-CimInstance Win32_Process -Filter 'ProcessId = ${pid}' | Select-Object CommandLine, ParentProcessId | ConvertTo-Json -Compress`;
-            const { stdout } = await execAsync(`${this.powershellPath} -NoProfile -Command "${psCommand}"`, { maxBuffer: 1024 * 1024 });
-            if (!stdout.trim() || stdout.trim() === 'null') {
-                return {};
-            }
-            const data = JSON.parse(stdout.trim());
-            return {
-                commandLine: data.CommandLine,
-                parentPid: data.ParentProcessId,
-            };
-        }
-        catch (error) {
-            logger.error(`Failed to get command line for PID ${pid}:`, error);
-            return {};
-        }
-    }
-    async checkDebugPort(pid, options) {
-        try {
-            pid = safePid(pid);
-            const commandLine = options?.commandLine ?? (await this.getProcessCommandLine(pid)).commandLine;
-            if (commandLine) {
-                const match = commandLine.match(/--remote-debugging-port=(\d+)/);
-                if (match?.[1]) {
-                    return parseInt(match[1], 10);
-                }
-            }
-            const psCommand = `Get-NetTCPConnection -OwningProcess ${pid} -State Listen -ErrorAction SilentlyContinue | Select-Object LocalPort | ConvertTo-Json -Compress`;
-            const { stdout } = await execAsync(`${this.powershellPath} -NoProfile -Command "${psCommand}"`, { maxBuffer: 1024 * 1024 });
-            if (stdout.trim() && stdout.trim() !== 'null') {
-                const data = JSON.parse(stdout.trim());
-                const ports = Array.isArray(data) ? data : [data];
-                for (const port of ports) {
-                    if (DEBUG_PORT_CANDIDATES.includes(port.LocalPort)) {
-                        return port.LocalPort;
-                    }
-                }
-            }
-            return null;
-        }
-        catch (error) {
-            logger.error(`Failed to check debug port for PID ${pid}:`, error);
-            return null;
-        }
-    }
-    async findPidByListeningPort(port) {
-        try {
-            const psCommand = `Get-NetTCPConnection -LocalPort ${port} -State Listen -ErrorAction SilentlyContinue | Select-Object -First 1 OwningProcess | ConvertTo-Json -Compress`;
-            const { stdout } = await execAsync(`${this.powershellPath} -NoProfile -Command "${psCommand}"`, { maxBuffer: 1024 * 1024 });
-            if (!stdout.trim() || stdout.trim() === 'null') {
-                return null;
-            }
-            const data = JSON.parse(stdout.trim());
-            const first = Array.isArray(data) ? data[0] : data;
-            const rawPid = first?.OwningProcess ?? first?.owningProcess ?? first;
-            const pid = Number(rawPid);
-            return Number.isFinite(pid) && pid > 0 ? pid : null;
-        }
-        catch {
-            return null;
-        }
-    }
-    async launchWithDebug(executablePath, debugPort = DEFAULT_DEBUG_PORT, args = []) {
-        try {
-            const debugArgs = [`--remote-debugging-port=${debugPort}`, ...args];
-            const child = spawn(executablePath, debugArgs, {
-                detached: true,
-                stdio: 'ignore',
-            });
-            child.unref();
-            const childPid = child.pid || 0;
-            const executableName = executablePath.split(/[\\/]/).pop() || 'unknown';
-            let resolvedPid = childPid > 0 ? childPid : null;
-            for (let attempt = 0; attempt < WIN_DEBUG_PORT_POLL_ATTEMPTS; attempt++) {
-                const debugPid = await this.findPidByListeningPort(debugPort);
-                if (debugPid && debugPid > 0) {
-                    resolvedPid = debugPid;
-                }
-                if (resolvedPid && resolvedPid > 0) {
-                    const process = await this.getProcessByPid(resolvedPid);
-                    if (process) {
-                        logger.info(`Launched process with debug port ${debugPort}:`, {
-                            pid: child.pid,
-                            resolvedPid,
-                            executable: executablePath,
-                        });
-                        return process;
-                    }
-                    if (debugPid && debugPid === resolvedPid) {
-                        logger.info(`Launched process with debug port ${debugPort}:`, {
-                            pid: child.pid,
-                            resolvedPid,
-                            executable: executablePath,
-                        });
-                        return {
-                            pid: resolvedPid,
-                            name: executableName,
-                            executablePath,
-                        };
-                    }
-                }
-                await new Promise((resolve) => setTimeout(resolve, WIN_DEBUG_PORT_POLL_INTERVAL_MS));
-            }
-            logger.info(`Launched process with debug port ${debugPort}:`, {
-                pid: child.pid,
-                resolvedPid,
-                executable: executablePath,
-            });
-            if (resolvedPid && resolvedPid > 0) {
-                return {
-                    pid: resolvedPid,
-                    name: executableName,
-                    executablePath,
-                };
-            }
-            return null;
-        }
-        catch (error) {
-            logger.error('Failed to launch process with debug:', error);
-            return null;
-        }
-    }
-    async injectDll(_pid, _dllPath) {
-        try {
-            if (!Number.isFinite(_pid) || _pid <= 0) {
-                logger.error(`Invalid PID for injectDll: ${_pid}`);
-                return false;
-            }
-            const scriptPath = this.scriptLoader.getScriptPath('inject-dll.ps1');
-            const normalizedPid = Math.trunc(_pid);
-            const escapedDllPath = String(_dllPath).replace(/'/g, "''");
-            await execAsync(`${this.powershellPath} -NoProfile -ExecutionPolicy Bypass -File "${scriptPath}" -TargetPid ${normalizedPid} -DllPath '${escapedDllPath}'`, { maxBuffer: 1024 * 1024 });
-            logger.warn('DLL injection is disabled for safety in this implementation');
-            return false;
-        }
-        catch (error) {
-            logger.error('DLL injection failed:', error);
-            return false;
-        }
-    }
-    async killProcess(pid) {
-        try {
-            if (!Number.isFinite(pid) || pid <= 0) {
-                logger.error(`Invalid PID for killProcess: ${pid}`);
-                return false;
-            }
-            const normalizedPid = Math.trunc(pid);
-            const psCommand = `Stop-Process -Id ${normalizedPid} -Force -ErrorAction SilentlyContinue; Write-Output "Process ${normalizedPid} killed"`;
-            await execAsync(`${this.powershellPath} -NoProfile -Command "${psCommand}"`, {
-                maxBuffer: 1024 * 1024,
-            });
-            logger.info(`Process ${normalizedPid} killed successfully`);
-            return true;
-        }
-        catch (error) {
-            logger.error(`Failed to kill process ${pid}:`, error);
-            return false;
-        }
-    }
-    async discoverBrowsers() {
-        try {
-            const browsers = await this.browserDiscovery.discoverBrowsers();
-            logger.info(`Discovered ${browsers.length} browser instances`);
-            return browsers;
-        }
-        catch (error) {
-            logger.error('Failed to discover browsers:', error);
-            return [];
-        }
-    }
-    async findBrowserByWindowClass(classNamePattern) {
-        try {
-            const browsers = await this.browserDiscovery.findByWindowClass(classNamePattern);
-            logger.info(`Found ${browsers.length} browsers matching window class '${classNamePattern}'`);
-            return browsers;
-        }
-        catch (error) {
-            logger.error(`Failed to find browser by window class '${classNamePattern}':`, error);
-            return [];
-        }
-    }
-    async findBrowserByProcessName(name) {
-        try {
-            const browsers = await this.browserDiscovery.findByProcessName(name);
-            logger.info(`Found ${browsers.length} browsers matching process name '${name}'`);
-            return browsers;
-        }
-        catch (error) {
-            logger.error(`Failed to find browser by process name '${name}':`, error);
-            return [];
-        }
-    }
-    async detectBrowserDebugPort(pid, ports) {
-        try {
-            const portsToCheck = ports || DEBUG_PORT_CANDIDATES;
-            const debugPort = await this.browserDiscovery.detectDebugPort(pid, portsToCheck);
-            if (debugPort) {
-                logger.info(`Detected debug port ${debugPort} for process ${pid}`);
-            }
-            else {
-                logger.warn(`No debug port detected for process ${pid}`);
-            }
-            return debugPort;
-        }
-        catch (error) {
-            logger.error(`Failed to detect debug port for PID ${pid}:`, error);
-            return null;
-        }
-    }
-}

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

@@ -1 +0,0 @@
-export { DEFAULT_CHROMIUM_CONFIG, ProcessManager } from '../process/ProcessManager.impl.js';

package/dist/src/modules/process/ProcessManager.types.d.ts

@@ -1,37 +0,0 @@
-export interface ProcessInfo {
-    pid: number;
-    name: string;
-    executablePath?: string;
-    commandLine?: string;
-    windowTitle?: string;
-    windowHandle?: string;
-    parentPid?: number;
-    memoryUsage?: number;
-    cpuUsage?: number;
-}
-export interface WindowInfo {
-    handle: string;
-    title: string;
-    className: string;
-    processId: number;
-    threadId: number;
-    bounds?: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
-}
-export interface ChromiumProcess {
-    mainProcess?: ProcessInfo;
-    rendererProcesses: ProcessInfo[];
-    gpuProcess?: ProcessInfo;
-    utilityProcesses: ProcessInfo[];
-    targetWindow?: WindowInfo;
-}
-export interface TargetAppConfig {
-    processNamePattern?: string | RegExp;
-    windowTitlePattern?: string | RegExp;
-    windowClassPattern?: string | RegExp;
-}
-export declare const DEFAULT_CHROMIUM_CONFIG: TargetAppConfig;

package/dist/src/modules/process/ProcessManager.types.js

@@ -1,4 +0,0 @@
-export const DEFAULT_CHROMIUM_CONFIG = {
-    processNamePattern: /^(chromium|chrome|msedge)$/i,
-    windowClassPattern: 'Chrome_WidgetWin',
-};