@jshookmcp/jshook 0.1.5 → 0.1.7

package/dist/modules/monitor/NetworkMonitor.impl.d.ts

@@ -8,6 +8,7 @@ export declare class NetworkMonitor {
     private responses;
     private readonly MAX_NETWORK_RECORDS;
     private readonly MAX_INJECTED_RECORDS;
+    private readonly JS_RESPONSE_CONCURRENCY;
     private responseBodyCache;
     private readonly MAX_BODY_CACHE_ENTRIES;
     private networkListeners;

package/dist/modules/monitor/NetworkMonitor.impl.js

@@ -55,6 +55,7 @@ export class NetworkMonitor {
     responses = new Map();
     MAX_NETWORK_RECORDS = 500;
     MAX_INJECTED_RECORDS = 500;
+    JS_RESPONSE_CONCURRENCY = 6;
     responseBodyCache = new Map();
     MAX_BODY_CACHE_ENTRIES = 200;
     networkListeners = {};
@@ -313,24 +314,30 @@ export class NetworkMonitor {
         }
     }
     async getAllJavaScriptResponses() {
-        const jsResponses = [];
-        for (const [requestId, response] of this.responses.entries()) {
-            if (response.mimeType.includes('javascript') ||
+        const candidates = Array.from(this.responses.entries()).filter(([, response]) => {
+            return (response.mimeType.includes('javascript') ||
                 response.url.endsWith('.js') ||
-                response.url.includes('.js?')) {
+                response.url.includes('.js?'));
+        });
+        const jsResponses = [];
+        for (let i = 0; i < candidates.length; i += this.JS_RESPONSE_CONCURRENCY) {
+            const batch = candidates.slice(i, i + this.JS_RESPONSE_CONCURRENCY);
+            const batchResults = await Promise.all(batch.map(async ([requestId, response]) => {
                 const bodyResult = await this.getResponseBody(requestId);
-                if (bodyResult) {
-                    const content = bodyResult.base64Encoded
-                        ? Buffer.from(bodyResult.body, 'base64').toString('utf-8')
-                        : bodyResult.body;
-                    jsResponses.push({
-                        url: response.url,
-                        content,
-                        size: content.length,
-                        requestId,
-                    });
+                if (!bodyResult) {
+                    return null;
                 }
-            }
+                const content = bodyResult.base64Encoded
+                    ? Buffer.from(bodyResult.body, 'base64').toString('utf-8')
+                    : bodyResult.body;
+                return {
+                    url: response.url,
+                    content,
+                    size: content.length,
+                    requestId,
+                };
+            }));
+            jsResponses.push(...batchResults.filter((value) => value !== null));
         }
         logger.info(`Collected ${jsResponses.length} JavaScript responses`);
         return jsResponses;

package/dist/modules/monitor/PerformanceMonitor.js

@@ -1,4 +1,5 @@
 import { writeFile } from 'node:fs/promises';
+import { setImmediate as waitForImmediate } from 'node:timers/promises';
 import { logger } from '../../utils/logger.js';
 import { PrerequisiteError } from '../../errors/PrerequisiteError.js';
 import { cdpLimit } from '../../utils/concurrency.js';
@@ -65,6 +66,62 @@ function isCDPHeapSamplingNode(value) {
 function isCDPHeapSamplingPayload(value) {
     return isRecord(value) && isRecord(value.profile) && isCDPHeapSamplingNode(value.profile.head);
 }
+async function yieldToEventLoop() {
+    await waitForImmediate();
+}
+function countTraceEvents(traceData) {
+    const eventPattern = /"ph"\s*:/g;
+    let count = 0;
+    while (eventPattern.exec(traceData) !== null) {
+        count++;
+    }
+    return count;
+}
+function insertTopAllocation(topAllocations, candidate, topN) {
+    if (topN <= 0) {
+        return;
+    }
+    if (topAllocations.length === topN &&
+        candidate.selfSize <= topAllocations[topAllocations.length - 1].selfSize) {
+        return;
+    }
+    let insertIndex = topAllocations.findIndex((entry) => candidate.selfSize > entry.selfSize);
+    if (insertIndex === -1) {
+        insertIndex = topAllocations.length;
+    }
+    topAllocations.splice(insertIndex, 0, candidate);
+    if (topAllocations.length > topN) {
+        topAllocations.length = topN;
+    }
+}
+function collectTopHeapAllocations(root, topN) {
+    const stack = [root];
+    const topAllocations = [];
+    let sampleCount = 0;
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (!node) {
+            continue;
+        }
+        if (node.callFrame) {
+            sampleCount++;
+            insertTopAllocation(topAllocations, {
+                functionName: node.callFrame.functionName || '(anonymous)',
+                url: node.callFrame.url || '',
+                selfSize: node.selfSize || 0,
+            }, topN);
+        }
+        if (Array.isArray(node.children)) {
+            for (let i = node.children.length - 1; i >= 0; i--) {
+                const child = node.children[i];
+                if (child) {
+                    stack.push(child);
+                }
+            }
+        }
+    }
+    return { sampleCount, topAllocations };
+}
 export class PerformanceMonitor {
     collector;
     cdpSession = null;
@@ -306,14 +363,7 @@ export class PerformanceMonitor {
                 traceData = traceChunks.join('');
             }
             this.tracingEnabled = false;
-            let eventCount = 0;
-            try {
-                const parsed = JSON.parse(traceData);
-                eventCount = Array.isArray(parsed) ? parsed.length : (parsed.traceEvents?.length ?? 0);
-            }
-            catch {
-                eventCount = (traceData.match(/"ph":/g) || []).length;
-            }
+            const eventCount = countTraceEvents(traceData);
             let savedPath;
             if (options?.artifactPath) {
                 await writeFile(options.artifactPath, traceData, 'utf-8');
@@ -364,28 +414,10 @@ export class PerformanceMonitor {
             await cdp.send('HeapProfiler.disable');
             this.heapSamplingEnabled = false;
             const topN = options?.topN ?? 20;
-            const allNodes = [];
-            function walkNodes(node) {
-                if (!isCDPHeapSamplingNode(node)) {
-                    return;
-                }
-                if (node.callFrame) {
-                    allNodes.push({
-                        functionName: node.callFrame.functionName || '(anonymous)',
-                        url: node.callFrame.url || '',
-                        selfSize: node.selfSize || 0,
-                    });
-                }
-                if (node.children) {
-                    for (const child of node.children) {
-                        walkNodes(child);
-                    }
-                }
-            }
-            walkNodes(profile.head);
-            allNodes.sort((a, b) => b.selfSize - a.selfSize);
-            const topAllocations = allNodes.slice(0, topN);
-            const profileJson = JSON.stringify(profile, null, 2);
+            await yieldToEventLoop();
+            const { sampleCount, topAllocations } = collectTopHeapAllocations(profile.head, topN);
+            await yieldToEventLoop();
+            const profileJson = JSON.stringify(profile);
             let savedPath;
             if (options?.artifactPath) {
                 await writeFile(options.artifactPath, profileJson, 'utf-8');
@@ -400,10 +432,10 @@ export class PerformanceMonitor {
                 await writeFile(absolutePath, profileJson, 'utf-8');
                 savedPath = displayPath;
             }
-            logger.success('Heap sampling profile saved', { sampleCount: allNodes.length, path: savedPath });
+            logger.success('Heap sampling profile saved', { sampleCount, path: savedPath });
             return {
                 artifactPath: savedPath,
-                sampleCount: allNodes.length,
+                sampleCount,
                 topAllocations,
             };
         });

package/dist/modules/process/LinuxProcessManager.d.ts

@@ -19,7 +19,9 @@ export declare class LinuxProcessManager {
         commandLine?: string;
         parentPid?: number;
     }>;
-    checkDebugPort(pid: number): Promise<number | null>;
+    checkDebugPort(pid: number, options?: {
+        commandLine?: string;
+    }): Promise<number | null>;
     launchWithDebug(executablePath: string, debugPort?: number, args?: string[]): Promise<ProcessInfo | null>;
     killProcess(pid: number): Promise<boolean>;
     isRunningOnWayland(): boolean;

package/dist/modules/process/LinuxProcessManager.js

@@ -212,10 +212,10 @@ export class LinuxProcessManager {
             return {};
         }
     }
-    async checkDebugPort(pid) {
+    async checkDebugPort(pid, options) {
         try {
             pid = safePid(pid);
-            const { commandLine } = await this.getProcessCommandLine(pid);
+            const commandLine = options?.commandLine ?? (await this.getProcessCommandLine(pid)).commandLine;
             if (commandLine) {
                 const match = commandLine.match(/--remote-debugging-port=(\d+)/);
                 if (match && match[1]) {
@@ -244,7 +244,11 @@ export class LinuxProcessManager {
             });
             child.unref();
             await new Promise(resolve => setTimeout(resolve, PROCESS_LAUNCH_WAIT_MS));
-            const process = await this.getProcessByPid(child.pid || 0);
+            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,

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

@@ -18,7 +18,9 @@ export declare class MacProcessManager {
         commandLine?: string;
         parentPid?: number;
     }>;
-    checkDebugPort(pid: number): Promise<number | null>;
+    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/modules/process/MacProcessManager.js

@@ -261,10 +261,10 @@ export class MacProcessManager {
             return {};
         }
     }
-    async checkDebugPort(pid) {
+    async checkDebugPort(pid, options) {
         try {
             pid = safePid(pid);
-            const { commandLine } = await this.getProcessCommandLine(pid);
+            const commandLine = options?.commandLine ?? (await this.getProcessCommandLine(pid)).commandLine;
             if (commandLine) {
                 const match = commandLine.match(/--remote-debugging-port=(\d+)/);
                 if (match && match[1]) {
@@ -293,7 +293,11 @@ export class MacProcessManager {
             });
             child.unref();
             await new Promise(resolve => setTimeout(resolve, PROCESS_LAUNCH_WAIT_MS));
-            const process = await this.getProcessByPid(child.pid || 0);
+            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,

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

@@ -5,8 +5,10 @@ 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>;
@@ -15,7 +17,9 @@ export declare class ProcessManager {
         commandLine?: string;
         parentPid?: number;
     }>;
-    checkDebugPort(pid: number): Promise<number | null>;
+    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>;

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

@@ -8,6 +8,7 @@ import { findChromiumProcessesWithConfig } from '../process/ProcessManager.chrom
 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, '');
 }
@@ -21,6 +22,7 @@ export class ProcessManager {
     powershellPath = 'powershell.exe';
     scriptLoader;
     browserDiscovery;
+    processCache = new Map();
     constructor() {
         this.scriptLoader = new ScriptLoader();
         this.browserDiscovery = new BrowserDiscovery();
@@ -29,6 +31,12 @@ export class ProcessManager {
     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`;
@@ -37,20 +45,30 @@ export class ProcessManager {
                 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 processes = [];
             const lines = stdout.trim();
-            if (!lines || lines === 'null' || lines === '') {
-                return processes;
+            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 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;
@@ -60,6 +78,29 @@ export class ProcessManager {
             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);
@@ -142,10 +183,10 @@ export class ProcessManager {
             return {};
         }
     }
-    async checkDebugPort(pid) {
+    async checkDebugPort(pid, options) {
         try {
             pid = safePid(pid);
-            const { commandLine } = await this.getProcessCommandLine(pid);
+            const commandLine = options?.commandLine ?? (await this.getProcessCommandLine(pid)).commandLine;
             if (commandLine) {
                 const match = commandLine.match(/--remote-debugging-port=(\d+)/);
                 if (match && match[1]) {

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

@@ -22,7 +22,9 @@ export declare class UnifiedProcessManager {
     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): Promise<number | null>;
+    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<{

package/dist/modules/process/index.js

@@ -58,8 +58,8 @@ export class UnifiedProcessManager {
     async getProcessWindows(pid) {
         return this.manager.getProcessWindows(pid);
     }
-    async checkDebugPort(pid) {
-        return this.manager.checkDebugPort(pid);
+    async checkDebugPort(pid, options) {
+        return this.manager.checkDebugPort(pid, options);
     }
     async launchWithDebug(executablePath, debugPort, args) {
         return this.manager.launchWithDebug(executablePath, debugPort, args);

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

@@ -0,0 +1,25 @@
+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/modules/process/memory/AuditTrail.js

@@ -0,0 +1,44 @@
+export class MemoryAuditTrail {
+    buffer;
+    head = 0;
+    count = 0;
+    capacity;
+    constructor(capacity = 5000) {
+        this.capacity = Number.isInteger(capacity) && capacity > 0 ? capacity : 5000;
+        this.buffer = [];
+    }
+    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/modules/process/memory/linux/mapsParser.d.ts

@@ -0,0 +1,16 @@
+export interface LinuxMemoryRegion {
+    start: bigint;
+    end: bigint;
+    permissions: {
+        read: boolean;
+        write: boolean;
+        exec: boolean;
+        private: boolean;
+    };
+    offset: bigint;
+    dev: string;
+    inode: number;
+    pathname: string;
+}
+export declare function parseProcMaps(content: string): LinuxMemoryRegion[];
+export declare function formatLinuxProtection(perms: LinuxMemoryRegion['permissions']): string;

package/dist/modules/process/memory/linux/mapsParser.js

@@ -0,0 +1,28 @@
+const PROC_MAPS_LINE_RE = /^([0-9a-f]+)-([0-9a-f]+)\s+([r-][w-][x-][ps])\s+([0-9a-f]+)\s+(\S+)\s+(\d+)\s*(.*)$/i;
+export function parseProcMaps(content) {
+    const regions = [];
+    for (const line of content.split(/\r?\n/)) {
+        const match = line.trimEnd().match(PROC_MAPS_LINE_RE);
+        if (!match)
+            continue;
+        const perms = match[3];
+        regions.push({
+            start: BigInt(`0x${match[1]}`),
+            end: BigInt(`0x${match[2]}`),
+            permissions: {
+                read: perms[0] === 'r',
+                write: perms[1] === 'w',
+                exec: perms[2] === 'x',
+                private: perms[3] === 'p',
+            },
+            offset: BigInt(`0x${match[4]}`),
+            dev: match[5],
+            inode: parseInt(match[6], 10),
+            pathname: match[7]?.trim() ?? '',
+        });
+    }
+    return regions;
+}
+export function formatLinuxProtection(perms) {
+    return `${perms.read ? 'r' : '-'}${perms.write ? 'w' : '-'}${perms.exec ? 'x' : '-'}`;
+}

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

@@ -1,5 +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';
 function buildEnumerateRegionsScript(pid) {
     return `
 Add-Type @"
@@ -111,8 +115,28 @@ try {
   `.trim();
 }
 export async function enumerateRegions(platform, pid) {
+    if (platform === 'linux') {
+        try {
+            const mapsContent = readFileSync(`/proc/${pid}/maps`, 'utf-8');
+            const readableRegions = parseProcMaps(mapsContent).filter(region => region.permissions.read);
+            const regions = readableRegions
+                .map(region => ({
+                baseAddress: `0x${region.start.toString(16)}`,
+                size: Number(region.end - region.start),
+                state: 'COMMIT',
+                protection: formatLinuxProtection(region.permissions),
+                isReadable: true,
+                type: region.pathname || 'anonymous',
+            }));
+            return { success: true, regions };
+        }
+        catch (error) {
+            logger.error('Linux region enumeration failed:', error);
+            return { success: false, error: error instanceof Error ? error.message : String(error) };
+        }
+    }
     if (platform !== 'win32' && platform !== 'darwin') {
-        return { success: false, error: 'Region enumeration currently only implemented for Windows and macOS' };
+        return { success: false, error: 'Region enumeration currently only implemented for Windows, Linux, and macOS' };
     }
     if (platform === 'darwin') {
         try {
@@ -148,6 +172,26 @@ export async function enumerateRegions(platform, pid) {
             return { success: false, error: error instanceof Error ? error.message : String(error) };
         }
     }
+    if (isKoffiAvailable()) {
+        try {
+            const nativeResult = await nativeMemoryManager.enumerateRegions(pid);
+            if (nativeResult.success) {
+                return nativeResult;
+            }
+            logger.warn('Native Windows region enumeration failed, falling back to PowerShell', {
+                pid,
+                error: nativeResult.error,
+                nativeAvailable: isKoffiAvailable(),
+            });
+        }
+        catch (error) {
+            logger.warn('Native Windows region enumeration threw, falling back to PowerShell', {
+                pid,
+                error: error instanceof Error ? error.message : String(error),
+                nativeAvailable: isKoffiAvailable(),
+            });
+        }
+    }
     try {
         const psScript = buildEnumerateRegionsScript(pid);
         const { stdout } = await executePowerShellScript(psScript, {