@jshookmcp/jshook 0.2.2 → 0.2.5

package/dist/src/modules/monitor/FetchInterceptor.js

@@ -0,0 +1,191 @@
+import { logger } from '../../utils/logger.js';
+import { randomUUID } from 'node:crypto';
+export class FetchInterceptor {
+    cdpSession;
+    rules = new Map();
+    enabled = false;
+    eventHandler = null;
+    compiledPatterns = new Map();
+    constructor(cdpSession) {
+        this.cdpSession = cdpSession;
+    }
+    async enable(ruleInputs) {
+        const newRules = [];
+        for (const input of ruleInputs) {
+            const rule = this.createRule(input);
+            this.rules.set(rule.id, rule);
+            this.compiledPatterns.set(rule.id, this.compilePattern(rule));
+            newRules.push(rule);
+        }
+        await this.applyRules();
+        if (!this.eventHandler) {
+            this.eventHandler = (params) => {
+                void this.handleRequestPaused(params);
+            };
+            this.cdpSession.on('Fetch.requestPaused', this.eventHandler);
+        }
+        this.enabled = true;
+        logger.info(`FetchInterceptor enabled with ${this.rules.size} rule(s)`);
+        return newRules;
+    }
+    async disable() {
+        const count = this.rules.size;
+        if (this.eventHandler) {
+            try {
+                this.cdpSession.off('Fetch.requestPaused', this.eventHandler);
+            }
+            catch {
+            }
+            this.eventHandler = null;
+        }
+        try {
+            await this.cdpSession.send('Fetch.disable');
+        }
+        catch (error) {
+            logger.warn('Fetch.disable failed:', error);
+        }
+        this.rules.clear();
+        this.compiledPatterns.clear();
+        this.enabled = false;
+        logger.info(`FetchInterceptor disabled, removed ${count} rule(s)`);
+        return { removedRules: count };
+    }
+    async removeRule(ruleId) {
+        const removed = this.rules.delete(ruleId);
+        this.compiledPatterns.delete(ruleId);
+        if (removed) {
+            if (this.rules.size === 0) {
+                await this.disable();
+            }
+            else {
+                await this.applyRules();
+            }
+        }
+        return removed;
+    }
+    listRules() {
+        const rules = Array.from(this.rules.values());
+        return {
+            enabled: this.enabled,
+            rules,
+            totalHits: rules.reduce((sum, r) => sum + r.hitCount, 0),
+        };
+    }
+    isEnabled() {
+        return this.enabled;
+    }
+    createRule(input) {
+        const headers = [];
+        if (input.responseHeaders) {
+            for (const [name, value] of Object.entries(input.responseHeaders)) {
+                headers.push({ name, value });
+            }
+        }
+        return {
+            id: randomUUID().slice(0, 8),
+            urlPattern: input.urlPattern,
+            urlPatternType: input.urlPatternType ?? 'glob',
+            stage: input.stage ?? 'Response',
+            responseCode: input.responseCode ?? 200,
+            responseHeaders: headers,
+            responseBody: input.responseBody ?? '',
+            hitCount: 0,
+            createdAt: Date.now(),
+        };
+    }
+    compilePattern(rule) {
+        if (rule.urlPatternType === 'regex') {
+            try {
+                return new RegExp(rule.urlPattern, 'i');
+            }
+            catch {
+                return new RegExp(rule.urlPattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'i');
+            }
+        }
+        const escaped = rule.urlPattern
+            .replace(/[.+?^${}()|[\]\\]/g, '\\$&')
+            .replace(/\*\*/g, '⟨GLOBSTAR⟩')
+            .replace(/\*/g, '[^/]*')
+            .replace(/⟨GLOBSTAR⟩/g, '.*');
+        return new RegExp(escaped, 'i');
+    }
+    async applyRules() {
+        const patterns = [];
+        for (const rule of this.rules.values()) {
+            patterns.push({
+                urlPattern: rule.urlPatternType === 'glob' ? rule.urlPattern : '*',
+                requestStage: rule.stage,
+            });
+        }
+        if (patterns.length === 0) {
+            return;
+        }
+        try {
+            try {
+                await this.cdpSession.send('Fetch.disable');
+            }
+            catch {
+            }
+            await this.cdpSession.send('Fetch.enable', {
+                patterns: patterns.length > 0 ? patterns : [{ urlPattern: '*', requestStage: 'Response' }],
+                handleAuthRequests: false,
+            });
+        }
+        catch (error) {
+            logger.error('Failed to apply Fetch interception rules:', error);
+            throw error;
+        }
+    }
+    async handleRequestPaused(params) {
+        const requestUrl = params.request.url;
+        for (const [ruleId, rule] of this.rules) {
+            const pattern = this.compiledPatterns.get(ruleId);
+            if (!pattern)
+                continue;
+            if (pattern.test(requestUrl)) {
+                rule.hitCount++;
+                logger.info(`[FetchInterceptor] Rule "${rule.urlPattern}" matched: ${requestUrl}`);
+                try {
+                    const headers = [...rule.responseHeaders];
+                    if (!headers.some((h) => h.name.toLowerCase() === 'content-type')) {
+                        const body = rule.responseBody;
+                        if (body.startsWith('{') || body.startsWith('[')) {
+                            headers.push({ name: 'Content-Type', value: 'application/json' });
+                        }
+                        else {
+                            headers.push({ name: 'Content-Type', value: 'text/plain' });
+                        }
+                    }
+                    if (!headers.some((h) => h.name.toLowerCase() === 'access-control-allow-origin')) {
+                        headers.push({ name: 'Access-Control-Allow-Origin', value: '*' });
+                    }
+                    await this.cdpSession.send('Fetch.fulfillRequest', {
+                        requestId: params.requestId,
+                        responseCode: rule.responseCode,
+                        responseHeaders: headers,
+                        body: Buffer.from(rule.responseBody, 'utf-8').toString('base64'),
+                    });
+                    return;
+                }
+                catch (error) {
+                    logger.error(`[FetchInterceptor] fulfillRequest failed for ${requestUrl}:`, error);
+                }
+            }
+        }
+        try {
+            if (params.responseStatusCode !== undefined) {
+                await this.cdpSession.send('Fetch.continueResponse', {
+                    requestId: params.requestId,
+                });
+            }
+            else {
+                await this.cdpSession.send('Fetch.continueRequest', {
+                    requestId: params.requestId,
+                });
+            }
+        }
+        catch (error) {
+            logger.warn(`[FetchInterceptor] continue failed for ${requestUrl}:`, error);
+        }
+    }
+}

package/dist/src/modules/monitor/PerformanceMonitor.js

@@ -94,6 +94,12 @@ function collectTopHeapAllocations(root, topN) {
     }
     return { sampleCount, topAllocations };
 }
+async function PING(cdp) {
+    await Promise.race([
+        cdp.send('Runtime.evaluate', { expression: '1', returnByValue: true }),
+        new Promise((_, reject) => setTimeout(() => reject(new Error('cdp_unreachable')), 500)),
+    ]);
+}
 export class PerformanceMonitor {
     collector;
     cdpSession = null;
@@ -107,12 +113,6 @@ export class PerformanceMonitor {
         this.collector = collector;
     }
     async ensureCDPSession() {
-        const PING = async (cdp) => {
-            await Promise.race([
-                cdp.send('Runtime.evaluate', { expression: '1', returnByValue: true }),
-                new Promise((_, reject) => setTimeout(() => reject(new Error('cdp_unreachable')), 500)),
-            ]);
-        };
         if (!this.cdpSession) {
             const page = await this.collector.getActivePage();
             this.cdpSession = await Promise.race([
@@ -133,7 +133,8 @@ export class PerformanceMonitor {
             try {
                 await this.cdpSession.detach();
             }
-            catch { }
+            catch {
+            }
             this.cdpSession = null;
             const page = await this.collector.getActivePage();
             this.cdpSession = await Promise.race([

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

@@ -3,7 +3,7 @@ export declare abstract class BaseMemoryManager {
     abstract readonly platform: string;
     abstract readMemory(pid: number, address: number, size: number): Promise<MemoryReadResult>;
     abstract writeMemory(pid: number, address: number, data: Buffer): Promise<MemoryWriteResult>;
-    abstract scanMemory(pid: number, pattern: string, patternType: PatternType): Promise<MemoryScanResult>;
+    abstract scanMemory(pid: number, pattern: string, patternType: PatternType, suspendTarget?: boolean): Promise<MemoryScanResult>;
     abstract checkMemoryProtection(pid: number, address: number): Promise<MemoryProtectionInfo>;
     abstract enumerateRegions(pid: number): Promise<{
         success: boolean;

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

@@ -42,6 +42,8 @@ export class LinuxProcessManager {
                 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(' ');
@@ -214,7 +216,7 @@ export class LinuxProcessManager {
             const ppidMatch = status.match(/PPid:\s*(\d+)/);
             return {
                 commandLine: cmdline.trim() || undefined,
-                parentPid: ppidMatch && ppidMatch[1] ? parseInt(ppidMatch[1], 10) : undefined,
+                parentPid: ppidMatch?.[1] ? parseInt(ppidMatch[1], 10) : undefined,
             };
         }
         catch (error) {
@@ -228,7 +230,7 @@ export class LinuxProcessManager {
             const commandLine = options?.commandLine ?? (await this.getProcessCommandLine(pid)).commandLine;
             if (commandLine) {
                 const match = commandLine.match(/--remote-debugging-port=(\d+)/);
-                if (match && match[1]) {
+                if (match?.[1]) {
                     return parseInt(match[1], 10);
                 }
             }

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

@@ -275,7 +275,7 @@ export class MacProcessManager {
             const commandLine = options?.commandLine ?? (await this.getProcessCommandLine(pid)).commandLine;
             if (commandLine) {
                 const match = commandLine.match(/--remote-debugging-port=(\d+)/);
-                if (match && match[1]) {
+                if (match?.[1]) {
                     return parseInt(match[1], 10);
                 }
             }

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

@@ -15,7 +15,7 @@ export declare class MemoryManager {
         }[];
         error?: string;
     }>;
-    scanMemory(pid: number, pattern: string, patternType?: PatternType): Promise<MemoryScanResult>;
+    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;

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

@@ -29,8 +29,8 @@ export class MemoryManager {
     async batchMemoryWrite(pid, patches) {
         return _batchMemoryWrite(pid, patches, (p, addr, data, enc) => this.writeMemory(p, addr, data, enc));
     }
-    async scanMemory(pid, pattern, patternType = 'hex') {
-        return _scanMemory(this.platform, pid, pattern, patternType);
+    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));

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

@@ -189,7 +189,7 @@ export class ProcessManager {
             const commandLine = options?.commandLine ?? (await this.getProcessCommandLine(pid)).commandLine;
             if (commandLine) {
                 const match = commandLine.match(/--remote-debugging-port=(\d+)/);
-                if (match && match[1]) {
+                if (match?.[1]) {
                     return parseInt(match[1], 10);
                 }
             }

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

@@ -5,7 +5,7 @@ export class MemoryAuditTrail {
     capacity;
     constructor(capacity = 5000) {
         this.capacity = Number.isInteger(capacity) && capacity > 0 ? capacity : 5000;
-        this.buffer = [];
+        this.buffer = Array.from({ length: this.capacity });
     }
     record(entry) {
         const fullEntry = {

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

@@ -2,7 +2,9 @@ import { promises as fs } from 'node:fs';
 import { logger } from '../../../utils/logger.js';
 import { nativeMemoryManager } from '../../../native/NativeMemoryManager.js';
 import { isKoffiAvailable } from '../../../native/Win32API.js';
+import { MEMORY_MAX_READ_BYTES } from '../../../constants.js';
 import { execAsync, executePowerShellScript, } from '../../process/memory/types.js';
+const HEX_ADDR = /^(?:0x)?[0-9a-fA-F]{1,16}$/;
 async function readMemoryWindows(pid, address, size) {
     try {
         const psScript = `
@@ -107,11 +109,32 @@ async function readMemoryMac(pid, address, size, checkProtectionFn) {
     if (address === 0) {
         return { success: false, error: 'Invalid address: null pointer (0x0)' };
     }
-    const MAX_READ_SIZE = 16 * 1024 * 1024;
-    if (size <= 0 || size > MAX_READ_SIZE) {
-        return { success: false, error: `Invalid size: must be 1–${MAX_READ_SIZE} bytes` };
+    if (size <= 0 || size > MEMORY_MAX_READ_BYTES) {
+        return { success: false, error: `Invalid size: must be 1–${MEMORY_MAX_READ_BYTES} bytes` };
     }
     const addrHex = `0x${address.toString(16)}`;
+    try {
+        const { createPlatformProvider } = await import('../../../native/platform/factory.js');
+        const provider = createPlatformProvider();
+        const avail = await provider.checkAvailability();
+        if (avail.available) {
+            const handle = provider.openProcess(pid, false);
+            try {
+                const result = provider.readMemory(handle, BigInt(address), size);
+                const hex = Array.from(result.data.subarray(0, result.bytesRead))
+                    .map((b) => b.toString(16).padStart(2, '0').toUpperCase())
+                    .join(' ');
+                logger.debug('Native Mach memory read succeeded (zero-pause)');
+                return { success: true, data: hex };
+            }
+            finally {
+                provider.closeProcess(handle);
+            }
+        }
+    }
+    catch (nativeErr) {
+        logger.debug('Native Mach read failed, falling back to lldb:', nativeErr);
+    }
     const prot = await checkProtectionFn(pid, addrHex);
     if (!prot.success) {
         return { success: false, error: `Cannot verify memory region: ${prot.error}` };
@@ -144,10 +167,19 @@ async function readMemoryMac(pid, address, size, checkProtectionFn) {
 }
 export async function readMemory(platform, pid, address, size, checkProtectionFn) {
     try {
+        if (!HEX_ADDR.test(address)) {
+            return { success: false, error: 'Invalid address format. Use hex like "0x12345678"' };
+        }
         const addrNum = parseInt(address, 16);
         if (isNaN(addrNum)) {
             return { success: false, error: 'Invalid address format. Use hex like "0x12345678"' };
         }
+        if (size <= 0 || size > MEMORY_MAX_READ_BYTES) {
+            return {
+                success: false,
+                error: `Read size must be 1–${MEMORY_MAX_READ_BYTES} bytes (${(MEMORY_MAX_READ_BYTES / 1024 / 1024).toFixed(0)} MB)`,
+            };
+        }
         if (platform === 'win32' && isKoffiAvailable()) {
             try {
                 const result = await nativeMemoryManager.readMemory(pid, address, size);

package/dist/src/modules/process/memory/regions.enumerate.js

@@ -1,9 +1,9 @@
 import { readFileSync } from 'fs';
 import { logger } from '../../../utils/logger.js';
 import { execAsync, executePowerShellScript, } from '../../process/memory/types.js';
-import { parseProcMaps, formatLinuxProtection } from './linux/mapsParser.js';
 import { nativeMemoryManager } from '../../../native/NativeMemoryManager.js';
 import { isKoffiAvailable } from '../../../native/NativeMemoryManager.utils.js';
+import { parseProcMaps, formatLinuxProtection } from './linux/mapsParser.js';
 function buildEnumerateRegionsScript(pid) {
     return `
 Add-Type @"

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

@@ -1,9 +1,9 @@
-import { readFileSync } from 'fs';
+import { promises as fsAsync } from 'fs';
 import { logger } from '../../../utils/logger.js';
 import { execAsync, executePowerShellScript, } from '../../process/memory/types.js';
-import { parseProcMaps, formatLinuxProtection } from './linux/mapsParser.js';
 import { nativeMemoryManager } from '../../../native/NativeMemoryManager.js';
 import { isKoffiAvailable } from '../../../native/NativeMemoryManager.utils.js';
+import { parseProcMaps, formatLinuxProtection } from './linux/mapsParser.js';
 function buildProtectionCheckScript(pid, address) {
     return `
 Add-Type @"
@@ -117,7 +117,7 @@ export async function checkMemoryProtection(platform, pid, address) {
     const addrNum = BigInt(address.startsWith('0x') ? address : `0x${address}`);
     if (platform === 'linux') {
         try {
-            const mapsContent = readFileSync(`/proc/${pid}/maps`, 'utf-8');
+            const mapsContent = await fsAsync.readFile(`/proc/${pid}/maps`, 'utf-8');
             const regions = parseProcMaps(mapsContent);
             const region = regions.find((r) => addrNum >= r.start && addrNum < r.end);
             if (!region) {
@@ -139,8 +139,41 @@ export async function checkMemoryProtection(platform, pid, address) {
     }
     if (platform === 'darwin') {
         try {
-            const addrNum = parseInt(address, 16);
-            if (isNaN(addrNum))
+            const { createPlatformProvider } = await import('../../../native/platform/factory.js');
+            const provider = createPlatformProvider();
+            const avail = await provider.checkAvailability();
+            if (avail.available) {
+                const handle = provider.openProcess(pid, false);
+                try {
+                    const region = provider.queryRegion(handle, addrNum);
+                    if (region) {
+                        const protStr = [
+                            region.isReadable ? 'r' : '-',
+                            region.isWritable ? 'w' : '-',
+                            region.isExecutable ? 'x' : '-',
+                        ].join('');
+                        return {
+                            success: true,
+                            protection: protStr,
+                            isReadable: region.isReadable,
+                            isWritable: region.isWritable,
+                            isExecutable: region.isExecutable,
+                            regionStart: `0x${region.baseAddress.toString(16)}`,
+                            regionSize: region.size,
+                        };
+                    }
+                    return { success: false, error: `Address ${address} not found in any memory region` };
+                }
+                finally {
+                    provider.closeProcess(handle);
+                }
+            }
+        }
+        catch {
+        }
+        try {
+            const darwinAddr = parseInt(address, 16);
+            if (isNaN(darwinAddr))
                 return { success: false, error: 'Invalid address format' };
             const { stdout } = await execAsync(`vmmap -v ${pid}`, {
                 timeout: 15000,
@@ -153,7 +186,7 @@ export async function checkMemoryProtection(platform, pid, address) {
                     continue;
                 const start = parseInt(m[2], 16);
                 const end = parseInt(m[3], 16);
-                if (addrNum >= start && addrNum < end) {
+                if (darwinAddr >= start && darwinAddr < end) {
                     const prot = m[4];
                     return {
                         success: true,
@@ -195,11 +228,11 @@ export async function checkMemoryProtection(platform, pid, address) {
         }
     }
     try {
-        const addrNum = parseInt(address, 16);
-        if (isNaN(addrNum)) {
+        const winAddr = parseInt(address, 16);
+        if (isNaN(winAddr)) {
             return { success: false, error: 'Invalid address format' };
         }
-        const psScript = buildProtectionCheckScript(pid, addrNum);
+        const psScript = buildProtectionCheckScript(pid, winAddr);
         const { stdout } = await executePowerShellScript(psScript, {
             maxBuffer: 1024 * 1024,
             timeout: 30000,

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

@@ -1,6 +1,10 @@
 import type { Platform, MemoryScanResult, PatternType } from '../../process/memory/types.js';
 export { buildPatternBytesAndMask, patternToBytesMac } from './scanner.patterns.js';
-export declare function scanMemory(platform: Platform, pid: number, pattern: string, patternType?: PatternType): Promise<MemoryScanResult>;
+export interface ScanOptions {
+    patternType?: PatternType;
+    suspendTarget?: boolean;
+}
+export declare function scanMemory(platform: Platform, pid: number, pattern: string, patternType?: PatternType, suspendTarget?: boolean): Promise<MemoryScanResult>;
 export declare function scanMemoryFiltered(pid: number, pattern: string, addresses: string[], patternType: PatternType | undefined, _readMemoryFn: (pid: number, address: string, size: number) => Promise<{
     success: boolean;
     data?: string;

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

@@ -1,6 +1,8 @@
 import { promises as fs } from 'node:fs';
+import { logger } from '../../../utils/logger.js';
 import { execAsync } from '../../process/memory/types.js';
 import { patternToBytesMac } from './scanner.patterns.js';
+import { findPatternInBuffer } from '../../../native/NativeMemoryManager.utils.js';
 export async function scanMemoryMac(pid, pattern, patternType) {
     let patternBytes;
     let patternMask;
@@ -16,6 +18,61 @@ export async function scanMemoryMac(pid, pattern, patternType) {
             error: e instanceof Error ? e.message : 'Invalid pattern',
         };
     }
+    try {
+        const nativeResult = await scanMemoryMacNative(pid, patternBytes, patternMask);
+        if (nativeResult)
+            return nativeResult;
+    }
+    catch (nativeErr) {
+        logger.debug('Native Mach scan failed, falling back to lldb:', nativeErr);
+    }
+    return scanMemoryMacLldb(pid, patternBytes, patternMask);
+}
+async function scanMemoryMacNative(pid, patternBytes, patternMask) {
+    const { createPlatformProvider } = await import('../../../native/platform/factory.js');
+    const provider = createPlatformProvider();
+    const avail = await provider.checkAvailability();
+    if (!avail.available)
+        return null;
+    const handle = provider.openProcess(pid, false);
+    const foundAddresses = [];
+    const maxResults = 1000;
+    const maxRegionSize = 32 * 1024 * 1024;
+    try {
+        let address = 0n;
+        for (let i = 0; i < 50000 && foundAddresses.length < maxResults; i++) {
+            const region = provider.queryRegion(handle, address);
+            if (!region)
+                break;
+            if (region.isReadable && region.size > 0 && region.size <= maxRegionSize) {
+                try {
+                    const result = provider.readMemory(handle, region.baseAddress, region.size);
+                    const matches = findPatternInBuffer(result.data, patternBytes, patternMask);
+                    for (const offset of matches) {
+                        foundAddresses.push(`0x${(region.baseAddress + BigInt(offset)).toString(16)}`);
+                        if (foundAddresses.length >= maxResults)
+                            break;
+                    }
+                }
+                catch {
+                }
+            }
+            address = region.baseAddress + BigInt(region.size);
+            if (address <= region.baseAddress)
+                break;
+        }
+    }
+    finally {
+        provider.closeProcess(handle);
+    }
+    logger.debug(`Native Mach scan completed (zero-pause): ${foundAddresses.length} results`);
+    return {
+        success: true,
+        addresses: foundAddresses,
+        stats: { patternLength: patternBytes.length, resultsFound: foundAddresses.length },
+    };
+}
+async function scanMemoryMacLldb(pid, patternBytes, patternMask) {
     const byteList = patternBytes.map((b) => `0x${b.toString(16)}`).join(',');
     const maskList = patternMask.join(',');
     const tag = `${pid}_${Date.now()}`;