@codebolt/agent 1.2.1 → 2.2.2

package/dist/processor-pieces/messageModifiers/workingDirectoryMessageModifier.js

@@ -0,0 +1,194 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkingDirectoryMessageModifier = void 0;
+const processor_1 = require("../../processor");
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+const path = __importStar(require("path"));
+class WorkingDirectoryMessageModifier extends processor_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super({ context: options });
+        this.showFolderStructureSummary = options.showFolderStructureSummary || false;
+        this.listFiles = options.listFiles || false;
+        this.listFilesDepth = options.listFilesDepth || 2;
+        this.listFilesLimit = options.listFilesLimit || 200;
+        this.listFilesIgnoreFromGitignore = options.listFilesIgnoreFromGitignore || true;
+        this.listFilesIgnore = options.listFilesIgnore || ['node_modules', '.git', 'dist', 'build'];
+    }
+    async modify(input) {
+        try {
+            const { originalRequest, createdMessage, context } = input;
+            const contextParts = [];
+            // Get project information
+            try {
+                const projectPathResponse = await codeboltjs_1.default.project.getProjectPath();
+                const projectPath = typeof projectPathResponse === 'string'
+                    ? projectPathResponse
+                    : (projectPathResponse === null || projectPathResponse === void 0 ? void 0 : projectPathResponse.path) || String(projectPathResponse) || '';
+                contextParts.push(`Project Directory: ${projectPath}`);
+                if (this.showFolderStructureSummary) {
+                    const summary = await this.generateFolderStructureSummary(projectPath);
+                    contextParts.push(`Folder Structure Summary:\n${summary}`);
+                }
+                if (this.listFiles) {
+                    const filesList = await this.generateFilesList(projectPath);
+                    contextParts.push(`Files List:\n${filesList}`);
+                }
+            }
+            catch (error) {
+                console.error('Error getting project information:', error);
+                contextParts.push('Working Directory: Unable to access project information');
+            }
+            // Create context message if we have any context parts
+            if (contextParts.length > 0) {
+                const contextMessage = {
+                    role: 'system',
+                    content: contextParts.join('\n\n'),
+                    name: 'working-directory-context'
+                };
+                return {
+                    messages: [contextMessage, ...createdMessage.messages],
+                    metadata: {
+                        ...createdMessage.metadata,
+                        workingDirectoryContextAdded: true,
+                        contextParts: contextParts.length
+                    }
+                };
+            }
+            return createdMessage;
+        }
+        catch (error) {
+            console.error('Error in WorkingDirectoryMessageModifier:', error);
+            throw error;
+        }
+    }
+    async generateFolderStructureSummary(projectPath) {
+        try {
+            // Use CodeBolt's directory listing with recursive option
+            const response = await codeboltjs_1.default.fs.listDirectory({
+                path: projectPath,
+                show_hidden: false,
+                detailed: false,
+                limit: 200,
+                notifyUser: false
+            });
+            const directories = new Set();
+            // Extract directories from the response
+            if (response && response.success) {
+                let entries;
+                if (typeof response.result === 'string') {
+                    // If result is a string, we'll need to parse it or work with what we have
+                    return response.result.split('\n').slice(0, 20).join('\n');
+                }
+                else if (response.result && response.result.entries) {
+                    entries = response.result.entries;
+                }
+                else if (response.entries) {
+                    entries = response.entries;
+                }
+                if (entries) {
+                    entries.forEach((entry) => {
+                        if (entry.type === 'directory' && !this.shouldIgnore(entry.path || entry.name)) {
+                            directories.add(entry.path || entry.name);
+                        }
+                        // Also get parent directories of files
+                        const dir = path.dirname(entry.path || entry.name);
+                        if (dir !== '.' && !this.shouldIgnore(dir)) {
+                            directories.add(dir);
+                        }
+                    });
+                }
+            }
+            const sortedDirs = Array.from(directories).sort();
+            return sortedDirs.length > 0
+                ? sortedDirs.slice(0, 20).join('\n')
+                : 'No accessible directories found';
+        }
+        catch (error) {
+            return 'Unable to generate folder structure summary';
+        }
+    }
+    async generateFilesList(projectPath) {
+        try {
+            // Use CodeBolt's directory listing to get files
+            const response = await codeboltjs_1.default.fs.listDirectory({
+                path: projectPath,
+                show_hidden: false,
+                detailed: false,
+                limit: this.listFilesLimit,
+                notifyUser: false
+            });
+            const files = [];
+            // Extract files from the response
+            if (response && response.success) {
+                let entries;
+                if (typeof response.result === 'string') {
+                    // If result is a string, split and filter for files
+                    return response.result.split('\n')
+                        .filter((line) => !this.shouldIgnore(line))
+                        .slice(0, this.listFilesLimit)
+                        .join('\n');
+                }
+                else if (response.result && response.result.entries) {
+                    entries = response.result.entries;
+                }
+                else if (response.entries) {
+                    entries = response.entries;
+                }
+                if (entries) {
+                    entries.forEach((entry) => {
+                        if (entry.type === 'file' && !this.shouldIgnore(entry.path || entry.name)) {
+                            files.push(entry.path || entry.name);
+                        }
+                    });
+                }
+            }
+            const filteredFiles = files.slice(0, this.listFilesLimit);
+            return filteredFiles.length > 0
+                ? filteredFiles.join('\n')
+                : 'No accessible files found';
+        }
+        catch (error) {
+            return 'Unable to generate files list';
+        }
+    }
+    shouldIgnore(filePath) {
+        return this.listFilesIgnore.some(ignore => filePath.includes(ignore) || path.basename(filePath) === ignore);
+    }
+}
+exports.WorkingDirectoryMessageModifier = WorkingDirectoryMessageModifier;

package/dist/processor-pieces/postInferenceProcessors/loopDetectionModifier.d.ts

@@ -0,0 +1,29 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BasePostInferenceProcessor } from "../base";
+import { LLMResponse } from "@codebolt/types/sdk";
+export interface LoopDetectionOptions {
+    maxSimilarMessages?: number;
+    similarityThreshold?: number;
+    timeWindowMs?: number;
+    enableLoopPrevention?: boolean;
+}
+interface MessageHistory {
+    content: string;
+    timestamp: number;
+    role: string;
+}
+export declare class LoopDetectionModifier extends BasePostInferenceProcessor {
+    private readonly options;
+    private messageHistory;
+    private loopDetected;
+    constructor(options?: LoopDetectionOptions);
+    modify(llmMessageSent: ProcessedMessage, llmResponseMessage: LLMResponse, nextPrompt: ProcessedMessage): Promise<ProcessedMessage>;
+    private detectLoop;
+    private checkSimilarMessages;
+    private calculateSimilarity;
+    private levenshteinDistance;
+    private cleanOldMessages;
+    resetLoopDetection(): void;
+    getMessageHistory(): MessageHistory[];
+}
+export {};

package/dist/processor-pieces/postInferenceProcessors/loopDetectionModifier.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoopDetectionModifier = void 0;
+const base_1 = require("../base");
+class LoopDetectionModifier extends base_1.BasePostInferenceProcessor {
+    constructor(options = {}) {
+        super();
+        this.messageHistory = [];
+        this.loopDetected = false;
+        this.options = {
+            maxSimilarMessages: options.maxSimilarMessages || 3,
+            similarityThreshold: options.similarityThreshold || 0.8,
+            timeWindowMs: options.timeWindowMs || 60000, // 1 minute
+            enableLoopPrevention: options.enableLoopPrevention !== false
+        };
+    }
+    modify(llmMessageSent, llmResponseMessage, nextPrompt) {
+        try {
+            if (!this.options.enableLoopPrevention) {
+                return Promise.resolve(nextPrompt);
+            }
+            const currentTime = Date.now();
+            // Add LLM response to history
+            if (llmResponseMessage.content) {
+                this.messageHistory.push({
+                    content: llmResponseMessage.content,
+                    timestamp: currentTime,
+                    role: llmResponseMessage.role
+                });
+            }
+            // Add any choice messages from LLM response to history
+            if (llmResponseMessage.choices) {
+                for (const choice of llmResponseMessage.choices) {
+                    if (choice.message && choice.message.content) {
+                        this.messageHistory.push({
+                            content: choice.message.content,
+                            timestamp: currentTime,
+                            role: choice.message.role
+                        });
+                    }
+                }
+            }
+            // Add the original sent message to history if it exists
+            for (const message of llmMessageSent.message.messages) {
+                if (typeof message.content === 'string') {
+                    this.messageHistory.push({
+                        content: message.content,
+                        timestamp: currentTime,
+                        role: message.role
+                    });
+                }
+            }
+            // Clean old messages from history
+            this.cleanOldMessages(currentTime);
+            // Check for loops
+            const loopDetected = this.detectLoop();
+            if (loopDetected && !this.loopDetected) {
+                this.loopDetected = true;
+                // Add loop detection warning to the next prompt
+                const warningMessage = {
+                    role: 'system',
+                    content: `[Loop Detection Warning] Similar messages detected in recent conversation. This may indicate a conversational loop. Consider rephrasing your request or providing more specific information.`
+                };
+                const updatedMessages = [...nextPrompt.message.messages, warningMessage];
+                return Promise.resolve({
+                    message: {
+                        ...nextPrompt.message,
+                        messages: updatedMessages
+                    },
+                    metadata: {
+                        ...nextPrompt.metadata,
+                        loopDetected: true,
+                        loopDetectionWarningAdded: true
+                    }
+                });
+            }
+            // Reset loop detection if we haven't detected a loop recently
+            if (!loopDetected && this.loopDetected) {
+                this.loopDetected = false;
+            }
+            return Promise.resolve({
+                message: nextPrompt.message,
+                metadata: {
+                    ...nextPrompt.metadata,
+                    loopDetectionChecked: true,
+                    loopDetected: false
+                }
+            });
+        }
+        catch (error) {
+            console.error('Error in LoopDetectionModifier:', error);
+            return Promise.resolve(nextPrompt);
+        }
+    }
+    detectLoop() {
+        if (this.messageHistory.length < this.options.maxSimilarMessages) {
+            return false;
+        }
+        // Get recent messages grouped by role
+        const recentUserMessages = this.messageHistory
+            .filter(msg => msg.role === 'user')
+            .slice(-this.options.maxSimilarMessages);
+        const recentAssistantMessages = this.messageHistory
+            .filter(msg => msg.role === 'assistant')
+            .slice(-this.options.maxSimilarMessages);
+        // Check for similar user messages
+        if (recentUserMessages.length >= this.options.maxSimilarMessages) {
+            const userLoop = this.checkSimilarMessages(recentUserMessages);
+            if (userLoop)
+                return true;
+        }
+        // Check for similar assistant messages
+        if (recentAssistantMessages.length >= this.options.maxSimilarMessages) {
+            const assistantLoop = this.checkSimilarMessages(recentAssistantMessages);
+            if (assistantLoop)
+                return true;
+        }
+        return false;
+    }
+    checkSimilarMessages(messages) {
+        if (messages.length < 2)
+            return false;
+        // Compare each message with every other message
+        for (let i = 0; i < messages.length - 1; i++) {
+            for (let j = i + 1; j < messages.length; j++) {
+                const similarity = this.calculateSimilarity(messages[i].content, messages[j].content);
+                if (similarity >= this.options.similarityThreshold) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    calculateSimilarity(text1, text2) {
+        // Simple similarity calculation using Levenshtein distance
+        const distance = this.levenshteinDistance(text1.toLowerCase(), text2.toLowerCase());
+        const maxLength = Math.max(text1.length, text2.length);
+        if (maxLength === 0)
+            return 1;
+        return 1 - (distance / maxLength);
+    }
+    levenshteinDistance(str1, str2) {
+        const matrix = [];
+        for (let i = 0; i <= str2.length; i++) {
+            matrix[i] = [i];
+        }
+        for (let j = 0; j <= str1.length; j++) {
+            matrix[0][j] = j;
+        }
+        for (let i = 1; i <= str2.length; i++) {
+            for (let j = 1; j <= str1.length; j++) {
+                if (str2.charAt(i - 1) === str1.charAt(j - 1)) {
+                    matrix[i][j] = matrix[i - 1][j - 1];
+                }
+                else {
+                    matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
+                }
+            }
+        }
+        return matrix[str2.length][str1.length];
+    }
+    cleanOldMessages(currentTime) {
+        const cutoffTime = currentTime - this.options.timeWindowMs;
+        this.messageHistory = this.messageHistory.filter(msg => msg.timestamp >= cutoffTime);
+    }
+    resetLoopDetection() {
+        this.messageHistory = [];
+        this.loopDetected = false;
+    }
+    getMessageHistory() {
+        return [...this.messageHistory];
+    }
+}
+exports.LoopDetectionModifier = LoopDetectionModifier;

package/dist/processor-pieces/postToolCallProcessors/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/processor-pieces/postToolCallProcessors/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/processor-pieces/postToolCallProcessors/shellProcessorModifier.d.ts

@@ -0,0 +1,25 @@
+import { PostToolCallProcessorInput, PostToolCallProcessorOutput } from "@codebolt/types/agent";
+import { BasePostToolCallProcessor } from "../base";
+export interface ShellProcessorOptions {
+    enableShellExecution?: boolean;
+    maxExecutionTime?: number;
+    allowedCommands?: string[];
+    blockedCommands?: string[];
+    workingDirectory?: string;
+}
+export declare class ShellProcessorModifier extends BasePostToolCallProcessor {
+    private readonly options;
+    private readonly execAsync;
+    private readonly SHELL_TRIGGER;
+    private readonly SHELL_CLOSE;
+    private readonly ARGS_PLACEHOLDER;
+    constructor(options?: ShellProcessorOptions);
+    modify(input: PostToolCallProcessorInput): Promise<PostToolCallProcessorOutput>;
+    private processShellInToolResults;
+    private processShellInjections;
+    private extractShellInjections;
+    private validateCommand;
+    private executeCommand;
+    private escapeShellArg;
+    private escapeRegex;
+}

package/dist/processor-pieces/postToolCallProcessors/shellProcessorModifier.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShellProcessorModifier = void 0;
+const base_1 = require("../base");
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+class ShellProcessorModifier extends base_1.BasePostToolCallProcessor {
+    constructor(options = {}) {
+        super();
+        this.execAsync = (0, util_1.promisify)(child_process_1.exec);
+        this.SHELL_TRIGGER = '!{';
+        this.SHELL_CLOSE = '}';
+        this.ARGS_PLACEHOLDER = '{{args}}';
+        this.options = {
+            enableShellExecution: options.enableShellExecution || false, // Disabled by default for security
+            maxExecutionTime: options.maxExecutionTime || 10000, // 10 seconds
+            allowedCommands: options.allowedCommands || ['ls', 'pwd', 'echo', 'cat', 'head', 'tail', 'grep', 'find', 'wc'],
+            blockedCommands: options.blockedCommands || ['rm', 'del', 'format', 'sudo', 'su', 'chmod', 'chown', 'kill', 'killall'],
+            workingDirectory: options.workingDirectory || process.cwd()
+        };
+    }
+    async modify(input) {
+        var _a;
+        try {
+            const { llmMessageSent, rawLLMResponseMessage, nextPrompt, toolResults } = input;
+            // Process shell commands in tool results if they exist
+            let processedNextPrompt = nextPrompt;
+            let shouldExit = false;
+            if (toolResults && toolResults.length > 0) {
+                // Look for shell-related tool results or commands in the content
+                const shellResults = toolResults.filter(result => 
+                // Check if the tool call ID suggests it's a shell command
+                (result.tool_call_id && (result.tool_call_id.includes('run_terminal_cmd') ||
+                    result.tool_call_id.includes('shell'))) ||
+                    // Check if content contains shell triggers or placeholders
+                    (result.content && typeof result.content === 'string' &&
+                        (result.content.includes(this.SHELL_TRIGGER) || result.content.includes(this.ARGS_PLACEHOLDER))));
+                if (shellResults.length > 0) {
+                    processedNextPrompt = await this.processShellInToolResults(nextPrompt, shellResults);
+                }
+            }
+            // Also process any shell injections in the next prompt messages
+            const updatedMessages = [];
+            let contentModified = false;
+            for (const message of processedNextPrompt.message.messages) {
+                if (typeof message.content === 'string') {
+                    let processedContent = message.content;
+                    // Replace {{args}} placeholders if metadata has args
+                    const args = ((_a = processedNextPrompt.metadata) === null || _a === void 0 ? void 0 : _a.args) || '';
+                    if (processedContent.includes(this.ARGS_PLACEHOLDER)) {
+                        processedContent = processedContent.replace(new RegExp(this.escapeRegex(this.ARGS_PLACEHOLDER), 'g'), args);
+                        contentModified = true;
+                    }
+                    // Process shell injections if enabled
+                    if (this.options.enableShellExecution && processedContent.includes(this.SHELL_TRIGGER)) {
+                        processedContent = await this.processShellInjections(processedContent, args);
+                        contentModified = true;
+                    }
+                    updatedMessages.push({
+                        ...message,
+                        content: processedContent
+                    });
+                }
+                else {
+                    updatedMessages.push(message);
+                }
+            }
+            if (contentModified) {
+                processedNextPrompt = {
+                    message: {
+                        ...processedNextPrompt.message,
+                        messages: updatedMessages
+                    },
+                    metadata: {
+                        ...processedNextPrompt.metadata,
+                        shellProcessed: true,
+                        argsReplaced: true
+                    }
+                };
+            }
+            return {
+                nextPrompt: processedNextPrompt,
+                shouldExit
+            };
+        }
+        catch (error) {
+            console.error('Error in ShellProcessorModifier:', error);
+            return {
+                nextPrompt: input.nextPrompt,
+                shouldExit: false
+            };
+        }
+    }
+    async processShellInToolResults(nextPrompt, shellResults) {
+        var _a;
+        // Process shell commands found in tool results
+        let processedPrompt = nextPrompt;
+        for (const result of shellResults) {
+            if (result.content && typeof result.content === 'string') {
+                const args = ((_a = processedPrompt.metadata) === null || _a === void 0 ? void 0 : _a.args) || '';
+                // Process any shell injections in the tool result content
+                if (result.content.includes(this.SHELL_TRIGGER)) {
+                    const processedContent = await this.processShellInjections(result.content, args);
+                    // Add the processed result as a system message
+                    const systemMessage = {
+                        role: 'system',
+                        content: `[Shell Tool Result]: ${processedContent}`
+                    };
+                    processedPrompt = {
+                        message: {
+                            ...processedPrompt.message,
+                            messages: [...processedPrompt.message.messages, systemMessage]
+                        },
+                        metadata: {
+                            ...processedPrompt.metadata,
+                            shellToolResultsProcessed: true
+                        }
+                    };
+                }
+            }
+        }
+        return processedPrompt;
+    }
+    async processShellInjections(content, args) {
+        let processedContent = content;
+        const injections = this.extractShellInjections(content);
+        // Process injections in reverse order to maintain correct indices
+        for (let i = injections.length - 1; i >= 0; i--) {
+            const injection = injections[i];
+            try {
+                // Replace {{args}} in the command with shell-escaped args
+                const command = injection.command.replace(new RegExp(this.escapeRegex(this.ARGS_PLACEHOLDER), 'g'), this.escapeShellArg(args));
+                // Validate and execute command
+                this.validateCommand(command);
+                const result = await this.executeCommand(command);
+                const replacement = result;
+                processedContent = processedContent.substring(0, injection.startIndex) +
+                    replacement +
+                    processedContent.substring(injection.endIndex);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                const replacement = `[Shell command error: ${errorMessage}]`;
+                processedContent = processedContent.substring(0, injection.startIndex) +
+                    replacement +
+                    processedContent.substring(injection.endIndex);
+            }
+        }
+        return processedContent;
+    }
+    extractShellInjections(content) {
+        const injections = [];
+        let searchIndex = 0;
+        while (true) {
+            const startIndex = content.indexOf(this.SHELL_TRIGGER, searchIndex);
+            if (startIndex === -1)
+                break;
+            const contentStart = startIndex + this.SHELL_TRIGGER.length;
+            const endIndex = content.indexOf(this.SHELL_CLOSE, contentStart);
+            if (endIndex === -1) {
+                // No closing brace found, skip this occurrence
+                searchIndex = contentStart;
+                continue;
+            }
+            const command = content.substring(contentStart, endIndex).trim();
+            if (command.length > 0) {
+                injections.push({
+                    startIndex,
+                    endIndex: endIndex + this.SHELL_CLOSE.length,
+                    command
+                });
+            }
+            searchIndex = endIndex + this.SHELL_CLOSE.length;
+        }
+        return injections;
+    }
+    validateCommand(command) {
+        if (!this.options.enableShellExecution) {
+            throw new Error('Shell execution is disabled');
+        }
+        // Extract the base command (first word)
+        const baseCommand = command.trim().split(/\s+/)[0];
+        // Check blocked commands
+        if (this.options.blockedCommands.some(blocked => baseCommand.includes(blocked))) {
+            throw new Error(`Command '${baseCommand}' is blocked for security reasons`);
+        }
+        // Check allowed commands (if allowlist is defined)
+        if (this.options.allowedCommands.length > 0 &&
+            !this.options.allowedCommands.some(allowed => baseCommand.includes(allowed))) {
+            throw new Error(`Command '${baseCommand}' is not in the allowed commands list`);
+        }
+        // Additional security checks
+        if (command.includes('&&') || command.includes('||') || command.includes(';') || command.includes('|')) {
+            throw new Error('Command chaining and piping are not allowed');
+        }
+    }
+    async executeCommand(command) {
+        try {
+            const { stdout, stderr } = await this.execAsync(command, {
+                cwd: this.options.workingDirectory,
+                timeout: this.options.maxExecutionTime,
+                maxBuffer: 1024 * 1024 // 1MB buffer
+            });
+            let result = stdout;
+            if (stderr) {
+                result += `\n[stderr]: ${stderr}`;
+            }
+            return result || '[Command executed successfully with no output]';
+        }
+        catch (error) {
+            if (error.killed && error.signal === 'SIGTERM') {
+                throw new Error(`Command timed out after ${this.options.maxExecutionTime}ms`);
+            }
+            throw new Error(`Command failed: ${error.message}`);
+        }
+    }
+    escapeShellArg(arg) {
+        // Basic shell escaping - in production, use a proper shell escaping library
+        return `"${arg.replace(/"/g, '\\"')}"`;
+    }
+    escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+}
+exports.ShellProcessorModifier = ShellProcessorModifier;