@jshookmcp/jshook 0.2.5 → 0.2.7

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

@@ -1,290 +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, PROCESS_LAUNCH_WAIT_MS, } from '../../constants.js';
-const execAsync = promisify(exec);
-function sanitizePattern(s) {
-    return String(s || '').replace(/[^\w\s.@/\-:,+]/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 LinuxProcessManager {
-    isWayland = false;
-    constructor() {
-        void this.detectDisplayServer();
-        logger.info('LinuxProcessManager initialized', {
-            displayServer: this.isWayland ? 'Wayland' : 'X11',
-        });
-    }
-    async detectDisplayServer() {
-        try {
-            const { stdout } = await execAsync('echo $XDG_SESSION_TYPE');
-            this.isWayland = stdout.trim() === 'wayland';
-        }
-        catch {
-            this.isWayland = false;
-        }
-    }
-    async findProcesses(pattern) {
-        try {
-            const safePattern = sanitizePattern(pattern);
-            const { stdout } = await execAsync(`ps aux | grep -i "${safePattern}" | grep -v grep || true`, { maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES });
-            const processes = [];
-            const lines = stdout
-                .trim()
-                .split('\n')
-                .filter((line) => line.trim());
-            for (const line of lines) {
-                const parts = line.trim().split(/\s+/);
-                if (parts.length >= 11) {
-                    const pid = parseInt(parts[1] || '0', 10);
-                    if (isNaN(pid))
-                        continue;
-                    const cpu = parseFloat(parts[2] || '0');
-                    const mem = parseFloat(parts[3] || '0');
-                    const command = parts.slice(10).join(' ');
-                    processes.push({
-                        pid,
-                        name: parts[10] || command.split(' ')[0] || 'unknown',
-                        commandLine: command,
-                        cpuUsage: cpu,
-                        memoryUsage: mem * 1024 * 1024,
-                    });
-                }
-            }
-            logger.info(`Found ${processes.length} processes matching '${pattern}'`);
-            return processes;
-        }
-        catch (error) {
-            logger.error(`Failed to find processes with pattern '${pattern}':`, error);
-            return [];
-        }
-    }
-    async getProcessByPid(pid) {
-        try {
-            pid = safePid(pid);
-            const { stdout } = await execAsync(`cat /proc/${pid}/status 2>/dev/null || echo ""`);
-            const { stdout: cmdline } = await execAsync(`cat /proc/${pid}/cmdline 2>/dev/null | tr '\0' ' ' || echo ""`);
-            const { stdout: stat } = await execAsync(`cat /proc/${pid}/stat 2>/dev/null || echo ""`);
-            if (!stdout.trim()) {
-                return null;
-            }
-            const status = {};
-            for (const line of stdout.split('\n')) {
-                const [key, value] = line.split(':');
-                if (key && value) {
-                    status[key.trim()] = value.trim();
-                }
-            }
-            const statParts = stat.trim().split(' ');
-            const utime = statParts.length > 13 ? parseInt(statParts[13] || '0', 10) : 0;
-            const stime = statParts.length > 14 ? parseInt(statParts[14] || '0', 10) : 0;
-            return {
-                pid,
-                name: status['Name'] || 'unknown',
-                executablePath: await this.getProcessPath(pid),
-                commandLine: cmdline.trim() || undefined,
-                parentPid: status['PPid'] ? parseInt(status['PPid'], 10) : undefined,
-                memoryUsage: status['VmRSS']
-                    ? parseInt(status['VmRSS'].replace(/\D/g, ''), 10) * 1024
-                    : undefined,
-                cpuUsage: utime + stime,
-            };
-        }
-        catch (error) {
-            logger.error(`Failed to get process by PID ${pid}:`, error);
-            return null;
-        }
-    }
-    async getProcessPath(pid) {
-        try {
-            pid = safePid(pid);
-            const { stdout } = await execAsync(`readlink -f /proc/${pid}/exe 2>/dev/null || echo ""`);
-            return stdout.trim() || undefined;
-        }
-        catch {
-            return undefined;
-        }
-    }
-    async getProcessWindows(pid) {
-        if (this.isWayland) {
-            logger.warn('Window enumeration on Wayland is limited. Consider using X11 or xdotool.');
-            return [];
-        }
-        try {
-            pid = safePid(pid);
-            const { stdout: xdotoolCheck } = await execAsync('which xdotool 2>/dev/null || echo ""');
-            if (!xdotoolCheck.trim()) {
-                logger.warn('xdotool not found. Install it for window management: sudo apt-get install xdotool');
-                return [];
-            }
-            const { stdout } = await execAsync(`xdotool search --all --pid ${pid} 2>/dev/null || true`);
-            const windows = [];
-            const windowIds = stdout
-                .trim()
-                .split('\n')
-                .filter((id) => id.trim());
-            for (const windowId of windowIds) {
-                try {
-                    const { stdout: title } = await execAsync(`xdotool getwindowname ${windowId} 2>/dev/null || echo ""`);
-                    const { stdout: className } = await execAsync(`xdotool getwindowclassname ${windowId} 2>/dev/null || echo ""`);
-                    windows.push({
-                        handle: windowId,
-                        title: title.trim(),
-                        className: className.trim(),
-                        processId: pid,
-                        threadId: 0,
-                    });
-                }
-                catch {
-                }
-            }
-            return windows;
-        }
-        catch (error) {
-            logger.error(`Failed to get windows for PID ${pid}:`, error);
-            return [];
-        }
-    }
-    async findChromeProcesses() {
-        const result = {
-            rendererProcesses: [],
-            utilityProcesses: [],
-        };
-        try {
-            const processes = await this.findProcesses('chrome');
-            const detailedInfos = await Promise.all(processes.map((proc) => this.getProcessByPid(proc.pid)));
-            for (let i = 0; i < processes.length; i++) {
-                const proc = processes[i];
-                const detailedInfo = detailedInfos[i];
-                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);
-            for (const pid of allPids) {
-                const windows = await this.getProcessWindows(pid);
-                const targetWindow = windows.find((w) => w.title.includes('Chrome') ||
-                    w.className.includes('Chrome') ||
-                    w.title.includes('Chromium'));
-                if (targetWindow) {
-                    result.targetWindow = targetWindow;
-                    break;
-                }
-            }
-            logger.info('Chrome processes found:', {
-                main: result.mainProcess?.pid,
-                renderers: result.rendererProcesses.length,
-                hasTargetWindow: !!result.targetWindow,
-            });
-            return result;
-        }
-        catch (error) {
-            logger.error('Failed to find Chrome processes:', error);
-            return result;
-        }
-    }
-    async getProcessCommandLine(pid) {
-        try {
-            pid = safePid(pid);
-            const { stdout: cmdline } = await execAsync(`cat /proc/${pid}/cmdline 2>/dev/null | tr '\0' ' ' || echo ""`);
-            const { stdout: status } = await execAsync(`cat /proc/${pid}/status 2>/dev/null | grep PPid || echo ""`);
-            const ppidMatch = status.match(/PPid:\s*(\d+)/);
-            return {
-                commandLine: cmdline.trim() || undefined,
-                parentPid: ppidMatch?.[1] ? parseInt(ppidMatch[1], 10) : undefined,
-            };
-        }
-        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 { stdout } = await execAsync(`ss -tlnp 2>/dev/null | grep "pid=${pid}" || netstat -tlnp 2>/dev/null | grep "${pid}" || true`, { maxBuffer: 1024 * 1024 });
-            for (const port of DEBUG_PORT_CANDIDATES) {
-                if (stdout.includes(`:${port}`)) {
-                    return port;
-                }
-            }
-            return null;
-        }
-        catch (error) {
-            logger.error(`Failed to check debug port for PID ${pid}:`, error);
-            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();
-            await new Promise((resolve) => setTimeout(resolve, PROCESS_LAUNCH_WAIT_MS));
-            if (!child.pid) {
-                logger.error(`Failed to spawn process: PID is undefined for ${executablePath}`);
-                return null;
-            }
-            const process = await this.getProcessByPid(child.pid);
-            logger.info(`Launched process with debug port ${debugPort}:`, {
-                pid: child.pid,
-                executable: executablePath,
-            });
-            return process;
-        }
-        catch (error) {
-            logger.error('Failed to launch process with debug:', error);
-            return null;
-        }
-    }
-    async killProcess(pid) {
-        try {
-            pid = safePid(pid);
-            await execAsync(`kill -9 ${pid} 2>/dev/null || kill -15 ${pid}`);
-            logger.info(`Process ${pid} killed successfully`);
-            return true;
-        }
-        catch (error) {
-            logger.error(`Failed to kill process ${pid}:`, error);
-            return false;
-        }
-    }
-    isRunningOnWayland() {
-        return this.isWayland;
-    }
-}

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

@@ -1,26 +0,0 @@
-import type { ProcessInfo, WindowInfo } from '../process/ProcessManager.js';
-export interface ChromeProcess {
-    mainProcess?: ProcessInfo;
-    rendererProcesses: ProcessInfo[];
-    gpuProcess?: ProcessInfo;
-    utilityProcesses: ProcessInfo[];
-    targetWindow?: WindowInfo;
-}
-export declare class MacProcessManager {
-    constructor();
-    findProcesses(pattern: string): Promise<ProcessInfo[]>;
-    getProcessByPid(pid: number): Promise<ProcessInfo | null>;
-    private getProcessPath;
-    getProcessWindows(pid: number): Promise<WindowInfo[]>;
-    getProcessWindowsCG(pid: number): Promise<WindowInfo[]>;
-    findChromeProcesses(): Promise<ChromeProcess>;
-    getProcessCommandLine(pid: number): Promise<{
-        commandLine?: string;
-        parentPid?: number;
-    }>;
-    checkDebugPort(pid: number, options?: {
-        commandLine?: string;
-    }): Promise<number | null>;
-    launchWithDebug(executablePath: string, debugPort?: number, args?: string[]): Promise<ProcessInfo | null>;
-    killProcess(pid: number): Promise<boolean>;
-}

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

@@ -1,332 +0,0 @@
-import { exec, execFile, 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, PROCESS_LAUNCH_WAIT_MS, } from '../../constants.js';
-import { ScriptLoader } from '../../native/ScriptLoader.js';
-const execAsync = promisify(exec);
-const execFileAsync = promisify(execFile);
-function sanitizePattern(s) {
-    return String(s || '').replace(/[^\w\s.@/\-:,+]/g, '');
-}
-function safePid(pid) {
-    const n = Math.trunc(Number(pid));
-    if (!Number.isFinite(n) || n <= 0)
-        throw new Error(`Invalid PID: ${pid}`);
-    return n;
-}
-function renderScriptTemplate(template, placeholders) {
-    let output = template;
-    for (const [key, value] of Object.entries(placeholders)) {
-        const marker = new RegExp(`\\{\\{${key}\\}\\}`, 'g');
-        output = output.replace(marker, String(value));
-    }
-    return output;
-}
-export class MacProcessManager {
-    constructor() {
-        logger.info('MacProcessManager initialized');
-    }
-    async findProcesses(pattern) {
-        try {
-            const safePattern = sanitizePattern(pattern);
-            const { stdout } = await execAsync(`ps aux | grep -i "${safePattern}" | grep -v grep || true`, { maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES });
-            const processes = [];
-            const lines = stdout
-                .trim()
-                .split('\n')
-                .filter((line) => line.trim());
-            for (const line of lines) {
-                const parts = line.trim().split(/\s+/);
-                if (parts.length >= 11) {
-                    const pid = parseInt(parts[1] || '0', 10);
-                    if (isNaN(pid))
-                        continue;
-                    const cpu = parseFloat(parts[2] || '0');
-                    const mem = parseFloat(parts[3] || '0');
-                    const command = parts.slice(10).join(' ');
-                    processes.push({
-                        pid,
-                        name: parts[10] || command.split(' ')[0] || 'unknown',
-                        commandLine: command,
-                        cpuUsage: cpu,
-                        memoryUsage: mem * 1024 * 1024,
-                    });
-                }
-            }
-            logger.info(`Found ${processes.length} processes matching '${pattern}'`);
-            return processes;
-        }
-        catch (error) {
-            logger.error(`Failed to find processes with pattern '${pattern}':`, error);
-            return [];
-        }
-    }
-    async getProcessByPid(pid) {
-        try {
-            pid = safePid(pid);
-            const { stdout } = await execAsync(`ps -p ${pid} -o pid,ppid,pcpu,pmem,comm,args 2>/dev/null || echo ""`);
-            const lines = stdout
-                .trim()
-                .split('\n')
-                .filter((line) => line.trim());
-            if (lines.length < 2) {
-                return null;
-            }
-            const dataLine = lines[1] || '';
-            const parts = dataLine.trim().split(/\s+/);
-            if (parts.length >= 6) {
-                return {
-                    pid: parseInt(parts[0] || '0', 10),
-                    parentPid: parseInt(parts[1] || '0', 10),
-                    name: parts[4] || 'unknown',
-                    executablePath: await this.getProcessPath(pid),
-                    commandLine: parts.slice(5).join(' '),
-                    cpuUsage: parseFloat(parts[2] || '0'),
-                    memoryUsage: parseFloat(parts[3] || '0') * 1024 * 1024,
-                };
-            }
-            return null;
-        }
-        catch (error) {
-            logger.error(`Failed to get process by PID ${pid}:`, error);
-            return null;
-        }
-    }
-    async getProcessPath(pid) {
-        try {
-            pid = safePid(pid);
-            const { stdout } = await execAsync(`ps -p ${pid} -o comm= 2>/dev/null || echo ""`);
-            return stdout.trim() || undefined;
-        }
-        catch {
-            return undefined;
-        }
-    }
-    async getProcessWindows(pid) {
-        try {
-            pid = safePid(pid);
-            const process = await this.getProcessByPid(pid);
-            if (!process) {
-                return [];
-            }
-            const appleScript = `
-        tell application "System Events"
-          set processList to {}
-          try
-            set targetProcess to first process whose unix id is ${pid}
-            set procName to name of targetProcess
-            set windowList to {}
-
-            tell targetProcess
-              repeat with win in windows
-                set winInfo to {|
-                  title:name of win,
-                  className:procName,
-                  processId:${pid},
-                  handle:"applescript-window"
-                |}
-                set end of windowList to winInfo
-              end repeat
-            end tell
-
-            return windowList
-          on error
-            return {}
-          end try
-        end tell
-      `;
-            const { stdout } = await execAsync(`osascript -e '${appleScript.replace(/'/g, "'\"'\"'")}' 2>/dev/null || echo "[]"`, { timeout: 5000 });
-            const windows = [];
-            if (stdout.trim() && stdout.trim() !== '[]') {
-                const titles = stdout.match(/title:([^,}]+)/g);
-                if (titles) {
-                    for (const title of titles) {
-                        const cleanTitle = title.replace('title:', '').trim();
-                        windows.push({
-                            handle: `mac-window-${pid}`,
-                            title: cleanTitle,
-                            className: process.name,
-                            processId: pid,
-                            threadId: 0,
-                        });
-                    }
-                }
-            }
-            return windows;
-        }
-        catch (error) {
-            logger.error(`Failed to get windows for PID ${pid}:`, error);
-            return [];
-        }
-    }
-    async getProcessWindowsCG(pid) {
-        try {
-            pid = safePid(pid);
-            const loader = new ScriptLoader();
-            const pythonTemplate = await loader.loadScript('process_list.py');
-            const pythonScript = renderScriptTemplate(pythonTemplate, {
-                PID: pid,
-            });
-            const { stdout } = await execFileAsync('python3', ['-c', pythonScript], {
-                timeout: 10_000,
-                windowsHide: true,
-            });
-            const windows = [];
-            try {
-                const data = JSON.parse(stdout.trim());
-                for (const win of data) {
-                    windows.push({
-                        handle: win.handle,
-                        title: win.title,
-                        className: win.className,
-                        processId: win.processId,
-                        threadId: 0,
-                        bounds: win.bounds
-                            ? {
-                                x: win.bounds.X || 0,
-                                y: win.bounds.Y || 0,
-                                width: win.bounds.Width || 0,
-                                height: win.bounds.Height || 0,
-                            }
-                            : undefined,
-                    });
-                }
-            }
-            catch {
-            }
-            return windows;
-        }
-        catch (error) {
-            logger.error(`Failed to get windows via CoreGraphics for PID ${pid}:`, error);
-            return [];
-        }
-    }
-    async findChromeProcesses() {
-        const result = {
-            rendererProcesses: [],
-            utilityProcesses: [],
-        };
-        try {
-            const processes = await this.findProcesses('chrome');
-            const detailedInfos = await Promise.all(processes.map((proc) => this.getProcessByPid(proc.pid)));
-            for (let i = 0; i < processes.length; i++) {
-                const proc = processes[i];
-                const detailedInfo = detailedInfos[i];
-                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;
-                    }
-                }
-            }
-            if (result.mainProcess) {
-                const windows = await this.getProcessWindowsCG(result.mainProcess.pid);
-                if (windows.length > 0) {
-                    result.targetWindow = windows[0];
-                }
-            }
-            logger.info('Chrome processes found:', {
-                main: result.mainProcess?.pid,
-                renderers: result.rendererProcesses.length,
-                hasTargetWindow: !!result.targetWindow,
-            });
-            return result;
-        }
-        catch (error) {
-            logger.error('Failed to find Chrome processes:', error);
-            return result;
-        }
-    }
-    async getProcessCommandLine(pid) {
-        try {
-            pid = safePid(pid);
-            const { stdout } = await execAsync(`ps -p ${pid} -o ppid=,args= 2>/dev/null || echo ""`);
-            const parts = stdout.trim().split(/\s+/);
-            if (parts.length >= 2) {
-                return {
-                    parentPid: parseInt(parts[0] || '0', 10),
-                    commandLine: parts.slice(1).join(' ') || undefined,
-                };
-            }
-            return {};
-        }
-        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 { stdout } = await execAsync(`lsof -Pan -p ${pid} -i 2>/dev/null | grep LISTEN || true`, { maxBuffer: 1024 * 1024 });
-            for (const port of DEBUG_PORT_CANDIDATES) {
-                if (stdout.includes(`:${port}`)) {
-                    return port;
-                }
-            }
-            return null;
-        }
-        catch (error) {
-            logger.error(`Failed to check debug port for PID ${pid}:`, error);
-            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();
-            await new Promise((resolve) => setTimeout(resolve, PROCESS_LAUNCH_WAIT_MS));
-            if (!child.pid) {
-                logger.error(`Failed to spawn process: PID is undefined for ${executablePath}`);
-                return null;
-            }
-            const process = await this.getProcessByPid(child.pid);
-            logger.info(`Launched process with debug port ${debugPort}:`, {
-                pid: child.pid,
-                executable: executablePath,
-            });
-            return process;
-        }
-        catch (error) {
-            logger.error('Failed to launch process with debug:', error);
-            return null;
-        }
-    }
-    async killProcess(pid) {
-        try {
-            pid = safePid(pid);
-            await execAsync(`kill -9 ${pid} 2>/dev/null || kill -15 ${pid}`);
-            logger.info(`Process ${pid} killed successfully`);
-            return true;
-        }
-        catch (error) {
-            logger.error(`Failed to kill process ${pid}:`, error);
-            return false;
-        }
-    }
-}