@elizaos/plugin-shell 1.2.0 → 2.0.0-alpha.2

package/dist/index.js

@@ -1,213 +1,656 @@
-// src/services/shellService.ts
+// actions/clearHistory.ts
 import {
-  Service,
-  logger as logger3
+  logger
 } from "@elizaos/core";
-import spawn from "cross-spawn";
-import path3 from "path";
 
-// src/environment.ts
-import { logger } from "@elizaos/core";
-import joi from "joi";
-import path from "path";
-import fs from "fs";
-var configSchema = joi.object({
-  enabled: joi.boolean().required(),
-  allowedDirectory: joi.string().when("enabled", {
-    is: true,
-    then: joi.required(),
-    otherwise: joi.optional()
-  }),
-  timeout: joi.number().positive().default(3e4),
-  forbiddenCommands: joi.array().items(joi.string()).required()
-});
-var DEFAULT_FORBIDDEN_COMMANDS = [
-  "rm -rf /",
-  // Only block dangerous rm commands, not all rm
-  "rmdir",
-  "chmod 777",
-  // Only block dangerous chmod, not all chmod
-  "chown",
-  "chgrp",
-  "shutdown",
-  "reboot",
-  "halt",
-  "poweroff",
-  "kill -9",
-  // Only block force kill, not all kill
-  "killall",
-  "pkill",
-  "sudo rm -rf",
-  // Block dangerous sudo commands
-  "su",
-  "passwd",
-  "useradd",
-  "userdel",
-  "groupadd",
-  "groupdel",
-  "format",
-  "fdisk",
-  "mkfs",
-  "dd if=/dev/zero",
-  // Only block dangerous dd
-  "shred",
-  ":(){:|:&};:"
-  // Fork bomb
-];
-function loadShellConfig() {
-  const enabled = process.env.SHELL_ENABLED === "true";
-  const allowedDirectory = process.env.SHELL_ALLOWED_DIRECTORY || process.cwd();
-  const timeout = parseInt(process.env.SHELL_TIMEOUT || "30000", 10);
-  const customForbidden = process.env.SHELL_FORBIDDEN_COMMANDS ? process.env.SHELL_FORBIDDEN_COMMANDS.split(",").map((cmd) => cmd.trim()) : [];
-  const forbiddenCommands = [.../* @__PURE__ */ new Set([...DEFAULT_FORBIDDEN_COMMANDS, ...customForbidden])];
-  const config = {
-    enabled,
-    allowedDirectory,
-    timeout,
-    forbiddenCommands
-  };
-  const { error, value } = configSchema.validate(config);
-  if (error) {
-    throw new Error(`Shell plugin configuration error: ${error.message}`);
-  }
-  if (enabled && allowedDirectory) {
-    try {
-      const stats = fs.statSync(allowedDirectory);
-      if (!stats.isDirectory()) {
-        throw new Error(`SHELL_ALLOWED_DIRECTORY is not a directory: ${allowedDirectory}`);
-      }
-      value.allowedDirectory = path.resolve(allowedDirectory);
-      logger.info(`Shell plugin enabled with allowed directory: ${value.allowedDirectory}`);
-    } catch (error2) {
-      if (error2.code === "ENOENT") {
-        throw new Error(`SHELL_ALLOWED_DIRECTORY does not exist: ${allowedDirectory}`);
-      }
-      throw error2;
+// generated/specs/specs.ts
+var coreActionsSpec = {
+  version: "1.0.0",
+  actions: [
+    {
+      name: "CLEAR_SHELL_HISTORY",
+      description: "Clears the recorded history of shell commands for the current conversation",
+      similes: ["RESET_SHELL", "CLEAR_TERMINAL", "CLEAR_HISTORY", "RESET_HISTORY"],
+      parameters: []
+    },
+    {
+      name: "EXECUTE_COMMAND",
+      description: "Execute shell commands including brew install, npm install, apt-get, system commands, file operations, directory navigation, and scripts.",
+      similes: [
+        "RUN_COMMAND",
+        "SHELL_COMMAND",
+        "TERMINAL_COMMAND",
+        "EXEC",
+        "RUN",
+        "EXECUTE",
+        "CREATE_FILE",
+        "WRITE_FILE",
+        "MAKE_FILE",
+        "INSTALL",
+        "BREW_INSTALL",
+        "NPM_INSTALL",
+        "APT_INSTALL"
+      ],
+      parameters: []
+    }
+  ]
+};
+var allActionsSpec = {
+  version: "1.0.0",
+  actions: [
+    {
+      name: "CLEAR_SHELL_HISTORY",
+      description: "Clears the recorded history of shell commands for the current conversation",
+      similes: ["RESET_SHELL", "CLEAR_TERMINAL", "CLEAR_HISTORY", "RESET_HISTORY"],
+      parameters: []
+    },
+    {
+      name: "EXECUTE_COMMAND",
+      description: "Execute shell commands including brew install, npm install, apt-get, system commands, file operations, directory navigation, and scripts.",
+      similes: [
+        "RUN_COMMAND",
+        "SHELL_COMMAND",
+        "TERMINAL_COMMAND",
+        "EXEC",
+        "RUN",
+        "EXECUTE",
+        "CREATE_FILE",
+        "WRITE_FILE",
+        "MAKE_FILE",
+        "INSTALL",
+        "BREW_INSTALL",
+        "NPM_INSTALL",
+        "APT_INSTALL"
+      ],
+      parameters: []
+    }
+  ]
+};
+var coreProvidersSpec = {
+  version: "1.0.0",
+  providers: [
+    {
+      name: "SHELL_HISTORY",
+      description: "Provides recent shell command history, current working directory, and file operations within the restricted environment",
+      dynamic: true
     }
+  ]
+};
+var allProvidersSpec = {
+  version: "1.0.0",
+  providers: [
+    {
+      name: "SHELL_HISTORY",
+      description: "Provides recent shell command history, current working directory, and file operations within the restricted environment",
+      dynamic: true
+    }
+  ]
+};
+var coreEvaluatorsSpec = {
+  version: "1.0.0",
+  evaluators: []
+};
+var allEvaluatorsSpec = {
+  version: "1.0.0",
+  evaluators: []
+};
+var coreActionDocs = coreActionsSpec.actions;
+var allActionDocs = allActionsSpec.actions;
+var coreProviderDocs = coreProvidersSpec.providers;
+var allProviderDocs = allProvidersSpec.providers;
+var coreEvaluatorDocs = coreEvaluatorsSpec.evaluators;
+var allEvaluatorDocs = allEvaluatorsSpec.evaluators;
+
+// generated/specs/spec-helpers.ts
+var coreActionMap = new Map(coreActionDocs.map((doc) => [doc.name, doc]));
+var allActionMap = new Map(allActionDocs.map((doc) => [doc.name, doc]));
+var coreProviderMap = new Map(coreProviderDocs.map((doc) => [doc.name, doc]));
+var allProviderMap = new Map(allProviderDocs.map((doc) => [doc.name, doc]));
+var coreEvaluatorMap = new Map(coreEvaluatorDocs.map((doc) => [doc.name, doc]));
+var allEvaluatorMap = new Map(allEvaluatorDocs.map((doc) => [doc.name, doc]));
+function getActionSpec(name) {
+  return coreActionMap.get(name) ?? allActionMap.get(name);
+}
+function requireActionSpec(name) {
+  const spec = getActionSpec(name);
+  if (!spec) {
+    throw new Error(`Action spec not found: ${name}`);
   }
-  if (!enabled) {
-    logger.info("Shell plugin is disabled. Set SHELL_ENABLED=true to enable.");
+  return spec;
+}
+function getProviderSpec(name) {
+  return coreProviderMap.get(name) ?? allProviderMap.get(name);
+}
+function requireProviderSpec(name) {
+  const spec = getProviderSpec(name);
+  if (!spec) {
+    throw new Error(`Provider spec not found: ${name}`);
   }
-  return value;
+  return spec;
 }
 
-// src/utils/pathUtils.ts
-import path2 from "path";
-import { logger as logger2 } from "@elizaos/core";
-function validatePath(commandPath, allowedDir, currentDir) {
-  try {
-    const resolvedPath = path2.resolve(currentDir, commandPath);
-    const normalizedPath = path2.normalize(resolvedPath);
-    const normalizedAllowed = path2.normalize(allowedDir);
-    if (!normalizedPath.startsWith(normalizedAllowed)) {
-      logger2.warn(
-        `Path validation failed: ${normalizedPath} is outside allowed directory ${normalizedAllowed}`
-      );
-      return null;
+// actions/clearHistory.ts
+var spec = requireActionSpec("CLEAR_SHELL_HISTORY");
+var clearHistory = {
+  name: spec.name,
+  similes: spec.similes ? [...spec.similes] : [],
+  description: spec.description,
+  validate: async (runtime, message, _state) => {
+    const shellService = runtime.getService("shell");
+    if (!shellService) {
+      return false;
     }
-    return normalizedPath;
-  } catch (error) {
-    logger2.error("Error validating path:", error);
-    return null;
-  }
+    const text = message.content.text?.toLowerCase() || "";
+    const clearKeywords = ["clear", "reset", "delete", "remove", "clean"];
+    const historyKeywords = ["history", "terminal", "shell", "command"];
+    const hasClearKeyword = clearKeywords.some((keyword) => text.includes(keyword));
+    const hasHistoryKeyword = historyKeywords.some((keyword) => text.includes(keyword));
+    return hasClearKeyword && hasHistoryKeyword;
+  },
+  handler: async (runtime, message, _state, _options, callback) => {
+    const shellService = runtime.getService("shell");
+    if (!shellService) {
+      if (callback) {
+        await callback({
+          text: "Shell service is not available.",
+          source: message.content.source
+        });
+      }
+      return { success: false, error: "Shell service is not available." };
+    }
+    const conversationId = message.roomId || message.agentId;
+    if (!conversationId) {
+      const errorMsg = "No conversation ID available";
+      if (callback) {
+        await callback({
+          text: errorMsg,
+          source: message.content.source
+        });
+      }
+      return { success: false, error: errorMsg };
+    }
+    shellService.clearCommandHistory(conversationId);
+    logger.info(`Cleared shell history for conversation: ${conversationId}`);
+    const response = {
+      text: "Shell command history has been cleared.",
+      source: message.content.source
+    };
+    if (callback) {
+      await callback(response);
+    }
+    return { success: true, text: response.text };
+  },
+  examples: spec.examples ?? []
+};
+// actions/executeCommand.ts
+import {
+  composePromptFromState,
+  logger as logger2,
+  ModelType,
+  parseJSONObjectFromText
+} from "@elizaos/core";
+
+// generated/prompts/typescript/prompts.ts
+var commandExtractionTemplate = `# Extracting shell command from request
+{{recentMessages}}
+
+# Instructions: {{senderName}} wants to execute a shell command. Extract the COMPLETE shell command they want to run.
+
+IMPORTANT: 
+1. Always return the FULL executable shell command, not just the content or partial command.
+2. If the user mentions installing something, create the appropriate brew/npm/apt command.
+3. If the user directly provides a command (like "brew install X"), use it exactly as provided.
+4. ALWAYS extract a command if the user is asking for ANY kind of system operation.
+
+Common patterns:
+- "run ls -la" -> command: "ls -la"
+- "execute npm test" -> command: "npm test"
+- "show me the files" or "list files" -> command: "ls -la"
+- "what's in this directory" -> command: "ls -la"
+- "check git status" -> command: "git status"
+- "navigate to src folder" -> command: "cd src"
+- "create a file called test.txt" -> command: "touch test.txt"
+- "write hello world to a file" -> command: "echo 'hello world' > file.txt"
+- "create hello.js with javascript code" -> command: "echo 'console.log(\\"Hello, World!\\");' > hello.js"
+- "create hello_world.py and write a python hello world script inside" -> command: "echo 'print(\\"Hello, World!\\")' > hello_world.py"
+- "make a new directory" -> command: "mkdir newdir"
+- "list files inside your filesystem" -> command: "ls -la"
+- "install orbstack" or "brew install orbstack" -> command: "brew install orbstack"
+- "install mullvad vpn" -> command: "brew install --cask mullvad-vpn"
+- "get system info" -> command: "system_profiler SPHardwareDataType"
+- "check memory usage" -> command: "vm_stat"
+- "install package" -> command: "brew install <package>"
+
+Special cases:
+- "Run it in your shell" or "execute it" -> Extract the command from previous context
+- "Install these" -> Look for package names in previous messages
+- Direct commands should be used exactly as provided
+
+Key rules:
+1. For file creation with content, use: echo 'content' > filename
+2. For listing files, use: ls -la (not just ls)
+3. Always include the echo command when writing to files
+4. Include all flags and arguments
+5. When user says "run it", "execute it", or similar, they want you to run the command
+
+Your response must be formatted as a JSON block:
+\`\`\`json
+{
+  "command": "<complete shell command to execute>"
 }
-function isSafeCommand(command) {
-  const pathTraversalPatterns = [
-    /\.\.\//g,
-    // ../
-    /\.\.\\/g,
-    // ..\
-    /\/\.\./g,
-    // /..
-    /\\\.\./g
-    // \..
-  ];
-  const dangerousPatterns = [
-    /\$\(/g,
-    // Command substitution $(
-    /`[^']*`/g,
-    // Command substitution ` (but allow in quotes)
-    /\|\s*sudo/g,
-    // Pipe to sudo
-    /;\s*sudo/g,
-    // Chain with sudo
-    /&\s*&/g,
-    // && chaining
-    /\|\s*\|/g
-    // || chaining
-  ];
-  for (const pattern of pathTraversalPatterns) {
-    if (pattern.test(command)) {
-      logger2.warn(`Path traversal detected in command: ${command}`);
-      return false;
+\`\`\``;
+
+// actions/executeCommand.ts
+var extractCommand = async (runtime, _message, state) => {
+  const prompt = composePromptFromState({
+    state,
+    template: commandExtractionTemplate
+  });
+  for (let i = 0;i < 3; i++) {
+    const response = await runtime.useModel(ModelType.TEXT_SMALL, {
+      prompt
+    });
+    const parsedResponse = parseJSONObjectFromText(response);
+    if (parsedResponse?.command) {
+      return { command: parsedResponse.command };
     }
   }
-  for (const pattern of dangerousPatterns) {
-    if (pattern.test(command)) {
-      logger2.warn(`Dangerous pattern detected in command: ${command}`);
+  return null;
+};
+var spec2 = requireActionSpec("EXECUTE_COMMAND");
+var executeCommand = {
+  name: spec2.name,
+  similes: spec2.similes ? [...spec2.similes] : [],
+  description: spec2.description,
+  validate: async (runtime, message, _state) => {
+    const shellService = runtime.getService("shell");
+    if (!shellService) {
       return false;
     }
-  }
-  const pipeCount = (command.match(/\|/g) || []).length;
-  if (pipeCount > 1) {
-    logger2.warn(`Multiple pipes detected in command: ${command}`);
-    return false;
-  }
-  return true;
-}
-function extractBaseCommand(fullCommand) {
-  const parts = fullCommand.trim().split(/\s+/);
-  return parts[0] || "";
-}
-function isForbiddenCommand(command, forbiddenCommands) {
-  const normalizedCommand = command.trim().toLowerCase();
-  return forbiddenCommands.some((forbidden) => {
-    const forbiddenLower = forbidden.toLowerCase();
-    if (normalizedCommand.startsWith(forbiddenLower)) {
-      return true;
+    const text = message.content.text?.toLowerCase() || "";
+    const commandKeywords = [
+      "run",
+      "execute",
+      "command",
+      "shell",
+      "install",
+      "brew",
+      "npm",
+      "create",
+      "file",
+      "directory",
+      "folder",
+      "list",
+      "show",
+      "system",
+      "info",
+      "check",
+      "status",
+      "cd",
+      "ls",
+      "mkdir",
+      "echo",
+      "cat",
+      "touch",
+      "git",
+      "build",
+      "test"
+    ];
+    const hasCommandKeyword = commandKeywords.some((keyword) => text.includes(keyword));
+    const hasDirectCommand = /^(brew|npm|apt|git|ls|cd|echo|cat|touch|mkdir|rm|mv|cp)\s/i.test(message.content.text || "");
+    return hasCommandKeyword || hasDirectCommand;
+  },
+  handler: async (runtime, message, state, _options, callback) => {
+    const shellService = runtime.getService("shell");
+    if (!shellService) {
+      if (callback) {
+        await callback({
+          text: "Shell service is not available.",
+          source: message.content.source
+        });
+      }
+      return { success: false, error: "Shell service is not available." };
     }
-    if (!forbidden.includes(" ")) {
-      const baseCommand = extractBaseCommand(command);
-      if (baseCommand.toLowerCase() === forbiddenLower) {
-        return true;
+    const commandInfo = await extractCommand(runtime, message, state);
+    if (!commandInfo?.command) {
+      logger2.error("Failed to extract command from message:", message.content.text);
+      if (callback) {
+        await callback({
+          text: "Could not determine which command to execute. Please specify a shell command.",
+          source: message.content.source
+        });
       }
+      return { success: false, error: "Could not extract command." };
     }
-    return false;
-  });
-}
+    logger2.info(`Extracted command: "${commandInfo.command}"`);
+    try {
+      const conversationId = message.roomId || message.agentId;
+      const result = await shellService.executeCommand(commandInfo.command, conversationId);
+      let responseText = "";
+      if (result.success) {
+        responseText = `Command executed successfully in ${result.executedIn}
 
-// src/services/shellService.ts
-var ShellService = class _ShellService extends Service {
-  static serviceType = "shell";
-  shellConfig;
-  currentDirectory;
-  commandHistory;
-  // conversationId -> history
-  maxHistoryPerConversation = 100;
-  constructor(runtime) {
-    super();
-    this.runtime = runtime;
-    this.shellConfig = loadShellConfig();
-    this.currentDirectory = this.shellConfig.allowedDirectory;
-    this.commandHistory = /* @__PURE__ */ new Map();
-  }
-  static async start(runtime) {
-    const instance = new _ShellService(runtime);
-    logger3.info("Shell service initialized with history tracking");
-    return instance;
-  }
-  async stop() {
-    logger3.info("Shell service stopped");
+`;
+        if (result.stdout) {
+          responseText += `Output:
+\`\`\`
+${result.stdout}
+\`\`\``;
+        } else {
+          responseText += "Command completed with no output.";
+        }
+      } else {
+        responseText = `Command failed with exit code ${result.exitCode} in ${result.executedIn}
+
+`;
+        if (result.error) {
+          responseText += `Error: ${result.error}
+`;
+        }
+        if (result.stderr) {
+          responseText += `
+Error output:
+\`\`\`
+${result.stderr}
+\`\`\``;
+        }
+      }
+      const response = {
+        text: responseText,
+        source: message.content.source
+      };
+      if (callback) {
+        await callback(response);
+      }
+      return { success: result.success, text: responseText };
+    } catch (error) {
+      logger2.error("Error executing command:", error);
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (callback) {
+        await callback({
+          text: `Failed to execute command: ${errorMessage}`,
+          source: message.content.source
+        });
+      }
+      return { success: false, error: errorMessage };
+    }
+  },
+  examples: spec2.examples ?? []
+};
+// providers/shellHistoryProvider.ts
+import {
+  addHeader,
+  logger as logger3
+} from "@elizaos/core";
+var MAX_OUTPUT_LENGTH = 8000;
+var TRUNCATE_SEGMENT_LENGTH = 4000;
+var spec3 = requireProviderSpec("SHELL_HISTORY");
+var shellHistoryProvider = {
+  name: spec3.name,
+  description: "Provides recent shell command history, current working directory, and file operations within the restricted environment",
+  position: 99,
+  get: async (runtime, message, _state) => {
+    const shellService = runtime.getService("shell");
+    if (!shellService) {
+      logger3.warn("[shellHistoryProvider] Shell service not found");
+      return {
+        values: {
+          shellHistory: "Shell service is not available",
+          currentWorkingDirectory: "N/A",
+          allowedDirectory: "N/A"
+        },
+        text: addHeader("# Shell Status", "Shell service is not available"),
+        data: { historyCount: 0, cwd: "N/A", allowedDir: "N/A" }
+      };
+    }
+    const conversationId = message.roomId || message.agentId;
+    if (!conversationId) {
+      return {
+        text: "No conversation ID available",
+        values: { historyCount: 0, cwd: "N/A", allowedDir: "N/A" },
+        data: { historyCount: 0, cwd: "N/A", allowedDir: "N/A" }
+      };
+    }
+    const history = shellService.getCommandHistory(conversationId, 10);
+    const cwd = shellService.getCurrentDirectory(conversationId);
+    const allowedDir = shellService.getAllowedDirectory();
+    let historyText = "No commands in history.";
+    if (history.length > 0) {
+      historyText = history.map((entry) => {
+        let entryStr = `[${new Date(entry.timestamp).toISOString()}] ${entry.workingDirectory}> ${entry.command}`;
+        if (entry.stdout) {
+          if (entry.stdout.length > MAX_OUTPUT_LENGTH) {
+            entryStr += `
+  Output: ${entry.stdout.substring(0, TRUNCATE_SEGMENT_LENGTH)}
+  ... [TRUNCATED] ...
+  ${entry.stdout.substring(entry.stdout.length - TRUNCATE_SEGMENT_LENGTH)}`;
+          } else {
+            entryStr += `
+  Output: ${entry.stdout}`;
+          }
+        }
+        if (entry.stderr) {
+          if (entry.stderr.length > MAX_OUTPUT_LENGTH) {
+            entryStr += `
+  Error: ${entry.stderr.substring(0, TRUNCATE_SEGMENT_LENGTH)}
+  ... [TRUNCATED] ...
+  ${entry.stderr.substring(entry.stderr.length - TRUNCATE_SEGMENT_LENGTH)}`;
+          } else {
+            entryStr += `
+  Error: ${entry.stderr}`;
+          }
+        }
+        entryStr += `
+  Exit Code: ${entry.exitCode}`;
+        if (entry.fileOperations && entry.fileOperations.length > 0) {
+          entryStr += `
+  File Operations:`;
+          entry.fileOperations.forEach((op) => {
+            if (op.secondaryTarget) {
+              entryStr += `
+    - ${op.type}: ${op.target} → ${op.secondaryTarget}`;
+            } else {
+              entryStr += `
+    - ${op.type}: ${op.target}`;
+            }
+          });
+        }
+        return entryStr;
+      }).join(`
+
+`);
+    }
+    const recentFileOps = history.filter((entry) => entry.fileOperations && entry.fileOperations.length > 0).flatMap((entry) => entry.fileOperations ?? []).slice(-5);
+    let fileOpsText = "";
+    if (recentFileOps.length > 0) {
+      fileOpsText = `
+
+` + addHeader("# Recent File Operations", recentFileOps.map((op) => {
+        if (op.secondaryTarget) {
+          return `- ${op.type}: ${op.target} → ${op.secondaryTarget}`;
+        }
+        return `- ${op.type}: ${op.target}`;
+      }).join(`
+`));
+    }
+    const text = `Current Directory: ${cwd}
+Allowed Directory: ${allowedDir}
+
+${addHeader("# Shell History (Last 10)", historyText)}${fileOpsText}`;
+    return {
+      values: {
+        shellHistory: historyText,
+        currentWorkingDirectory: cwd,
+        allowedDirectory: allowedDir
+      },
+      text,
+      data: {
+        historyCount: history.length,
+        cwd,
+        allowedDir
+      }
+    };
+  }
+};
+// services/shellService.ts
+import path3 from "node:path";
+import { logger as logger6, Service } from "@elizaos/core";
+import spawn from "cross-spawn";
+
+// utils/config.ts
+import fs from "node:fs";
+import path from "node:path";
+import { logger as logger4 } from "@elizaos/core";
+import { z } from "zod";
+var configSchema = z.object({
+  enabled: z.boolean(),
+  allowedDirectory: z.string(),
+  timeout: z.number().positive().default(30000),
+  forbiddenCommands: z.array(z.string())
+});
+var DEFAULT_FORBIDDEN_COMMANDS = [
+  "rm -rf /",
+  "rmdir",
+  "chmod 777",
+  "chown",
+  "chgrp",
+  "shutdown",
+  "reboot",
+  "halt",
+  "poweroff",
+  "kill -9",
+  "killall",
+  "pkill",
+  "sudo rm -rf",
+  "su",
+  "passwd",
+  "useradd",
+  "userdel",
+  "groupadd",
+  "groupdel",
+  "format",
+  "fdisk",
+  "mkfs",
+  "dd if=/dev/zero",
+  "shred",
+  ":(){:|:&};:"
+];
+function loadShellConfig() {
+  const enabled = process.env.SHELL_ENABLED === "true";
+  const allowedDirectory = process.env.SHELL_ALLOWED_DIRECTORY || process.cwd();
+  const timeout = parseInt(process.env.SHELL_TIMEOUT || "30000", 10);
+  const customForbidden = process.env.SHELL_FORBIDDEN_COMMANDS ? process.env.SHELL_FORBIDDEN_COMMANDS.split(",").map((cmd) => cmd.trim()) : [];
+  const forbiddenCommands = [...new Set([...DEFAULT_FORBIDDEN_COMMANDS, ...customForbidden])];
+  const config = {
+    enabled,
+    allowedDirectory,
+    timeout,
+    forbiddenCommands
+  };
+  const parseResult = configSchema.safeParse(config);
+  if (!parseResult.success) {
+    const errorMessage = parseResult.error.issues?.[0]?.message || parseResult.error.toString();
+    throw new Error(`Shell plugin configuration error: ${errorMessage}`);
+  }
+  if (enabled && allowedDirectory) {
+    try {
+      const stats = fs.statSync(allowedDirectory);
+      if (!stats.isDirectory()) {
+        throw new Error(`SHELL_ALLOWED_DIRECTORY is not a directory: ${allowedDirectory}`);
+      }
+      config.allowedDirectory = path.resolve(allowedDirectory);
+      logger4.info(`Shell plugin enabled with allowed directory: ${config.allowedDirectory}`);
+    } catch (error) {
+      if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+        throw new Error(`SHELL_ALLOWED_DIRECTORY does not exist: ${allowedDirectory}`);
+      }
+      throw error;
+    }
+  }
+  if (!enabled) {
+    logger4.info("Shell plugin is disabled. Set SHELL_ENABLED=true to enable.");
+  }
+  return config;
+}
+// utils/pathUtils.ts
+import path2 from "node:path";
+import { logger as logger5 } from "@elizaos/core";
+function validatePath(commandPath, allowedDir, currentDir) {
+  const resolvedPath = path2.resolve(currentDir, commandPath);
+  const normalizedPath = path2.normalize(resolvedPath);
+  const normalizedAllowed = path2.normalize(allowedDir);
+  if (!normalizedPath.startsWith(normalizedAllowed)) {
+    logger5.warn(`Path validation failed: ${normalizedPath} is outside allowed directory ${normalizedAllowed}`);
+    return null;
+  }
+  return normalizedPath;
+}
+function isSafeCommand(command) {
+  const pathTraversalPatterns = [/\.\.\//g, /\.\.\\/g, /\/\.\./g, /\\\.\./g];
+  const dangerousPatterns = [/\$\(/g, /`[^']*`/g, /\|\s*sudo/g, /;\s*sudo/g, /&\s*&/g, /\|\s*\|/g];
+  for (const pattern of pathTraversalPatterns) {
+    if (pattern.test(command)) {
+      logger5.warn(`Path traversal detected in command: ${command}`);
+      return false;
+    }
+  }
+  for (const pattern of dangerousPatterns) {
+    if (pattern.test(command)) {
+      logger5.warn(`Dangerous pattern detected in command: ${command}`);
+      return false;
+    }
+  }
+  const pipeCount = (command.match(/\|/g) || []).length;
+  if (pipeCount > 1) {
+    logger5.warn(`Multiple pipes detected in command: ${command}`);
+    return false;
+  }
+  return true;
+}
+function extractBaseCommand(fullCommand) {
+  const parts = fullCommand.trim().split(/\s+/);
+  return parts[0] || "";
+}
+function isForbiddenCommand(command, forbiddenCommands) {
+  const normalizedCommand = command.trim().toLowerCase();
+  return forbiddenCommands.some((forbidden) => {
+    const forbiddenLower = forbidden.toLowerCase();
+    if (normalizedCommand.startsWith(forbiddenLower)) {
+      return true;
+    }
+    if (!forbidden.includes(" ")) {
+      const baseCommand = extractBaseCommand(command);
+      if (baseCommand.toLowerCase() === forbiddenLower) {
+        return true;
+      }
+    }
+    return false;
+  });
+}
+// services/shellService.ts
+class ShellService extends Service {
+  static serviceType = "shell";
+  shellConfig;
+  currentDirectory;
+  commandHistory;
+  maxHistoryPerConversation = 100;
+  constructor(runtime) {
+    super(runtime);
+    this.shellConfig = loadShellConfig();
+    this.currentDirectory = this.shellConfig.allowedDirectory;
+    this.commandHistory = new Map;
+  }
+  static async start(runtime) {
+    const instance = new ShellService(runtime);
+    logger6.info("Shell service initialized with history tracking");
+    return instance;
+  }
+  async stop() {
+    logger6.info("Shell service stopped");
   }
   get capabilityDescription() {
     return "Execute shell commands within a restricted directory with history tracking";
   }
-  /**
-   * Executes a shell command within the allowed directory
-   * @param command The command to execute
-   * @param conversationId Optional conversation ID for history tracking
-   * @returns The command execution result
-   */
   async executeCommand(command, conversationId) {
     if (!this.shellConfig.enabled) {
       return {
@@ -244,7 +687,7 @@ var ShellService = class _ShellService extends Service {
       return {
         success: false,
         stdout: "",
-        stderr: `Command is forbidden by security policy`,
+        stderr: "Command is forbidden by security policy",
         exitCode: 1,
         error: "Forbidden command",
         executedIn: this.currentDirectory
@@ -268,11 +711,6 @@ var ShellService = class _ShellService extends Service {
     }
     return result;
   }
-  /**
-   * Handles the cd command to change directory within allowed bounds
-   * @param command The cd command
-   * @returns The command result
-   */
   async handleCdCommand(command) {
     const parts = command.split(/\s+/);
     if (parts.length < 2) {
@@ -286,11 +724,7 @@ var ShellService = class _ShellService extends Service {
       };
     }
     const targetPath = parts.slice(1).join(" ");
-    const validatedPath = validatePath(
-      targetPath,
-      this.shellConfig.allowedDirectory,
-      this.currentDirectory
-    );
+    const validatedPath = validatePath(targetPath, this.shellConfig.allowedDirectory, this.currentDirectory);
     if (!validatedPath) {
       return {
         success: false,
@@ -310,11 +744,6 @@ var ShellService = class _ShellService extends Service {
       executedIn: this.currentDirectory
     };
   }
-  /**
-   * Runs a command using cross-spawn
-   * @param command The command to run
-   * @returns The command result
-   */
   async runCommand(command) {
     return new Promise((resolve) => {
       const useShell = command.includes(">") || command.includes("<") || command.includes("|");
@@ -323,12 +752,12 @@ var ShellService = class _ShellService extends Service {
       if (useShell) {
         cmd = "sh";
         args = ["-c", command];
-        logger3.info(`Executing shell command: sh -c "${command}" in ${this.currentDirectory}`);
+        logger6.info(`Executing shell command: sh -c "${command}" in ${this.currentDirectory}`);
       } else {
         const parts = command.split(/\s+/);
         cmd = parts[0];
         args = parts.slice(1);
-        logger3.info(`Executing command: ${cmd} ${args.join(" ")} in ${this.currentDirectory}`);
+        logger6.info(`Executing command: ${cmd} ${args.join(" ")} in ${this.currentDirectory}`);
       }
       let stdout = "";
       let stderr = "";
@@ -336,723 +765,154 @@ var ShellService = class _ShellService extends Service {
       const child = spawn(cmd, args, {
         cwd: this.currentDirectory,
         env: process.env,
-        // Only use shell: false for direct commands, not for sh -c
         shell: false
       });
       const timeout = setTimeout(() => {
         timedOut = true;
         child.kill("SIGTERM");
-        setTimeout(() => {
-          if (!child.killed) {
-            child.kill("SIGKILL");
-          }
-        }, 5e3);
-      }, this.shellConfig.timeout);
-      if (child.stdout) {
-        child.stdout.on("data", (data) => {
-          stdout += data.toString();
-        });
-      }
-      if (child.stderr) {
-        child.stderr.on("data", (data) => {
-          stderr += data.toString();
-        });
-      }
-      child.on("exit", (code) => {
-        clearTimeout(timeout);
-        if (timedOut) {
-          resolve({
-            success: false,
-            stdout,
-            stderr: stderr + "\nCommand timed out",
-            exitCode: code,
-            error: "Command execution timeout",
-            executedIn: this.currentDirectory
-          });
-          return;
-        }
-        resolve({
-          success: code === 0,
-          stdout,
-          stderr,
-          exitCode: code,
-          executedIn: this.currentDirectory
-        });
-      });
-      child.on("error", (err) => {
-        clearTimeout(timeout);
-        resolve({
-          success: false,
-          stdout,
-          stderr: err.message,
-          exitCode: 1,
-          error: "Failed to execute command",
-          executedIn: this.currentDirectory
-        });
-      });
-    });
-  }
-  /**
-   * Adds a command to the history
-   */
-  addToHistory(conversationId, command, result, fileOperations) {
-    if (!conversationId) return;
-    const historyEntry = {
-      command,
-      stdout: result.stdout,
-      stderr: result.stderr,
-      exitCode: result.exitCode,
-      timestamp: Date.now(),
-      workingDirectory: result.executedIn,
-      fileOperations
-    };
-    if (!this.commandHistory.has(conversationId)) {
-      this.commandHistory.set(conversationId, []);
-    }
-    const history = this.commandHistory.get(conversationId);
-    history.push(historyEntry);
-    if (history.length > this.maxHistoryPerConversation) {
-      history.shift();
-    }
-  }
-  /**
-   * Detects file operations from a command
-   */
-  detectFileOperations(command, cwd) {
-    const operations = [];
-    const parts = command.trim().split(/\s+/);
-    const cmd = parts[0].toLowerCase();
-    if (cmd === "touch" && parts.length > 1) {
-      operations.push({
-        type: "create",
-        target: this.resolvePath(parts[1], cwd)
-      });
-    } else if (cmd === "echo" && command.includes(">")) {
-      const match = command.match(/>\s*([^\s]+)$/);
-      if (match) {
-        operations.push({
-          type: "write",
-          target: this.resolvePath(match[1], cwd)
-        });
-      }
-    } else if (cmd === "mkdir" && parts.length > 1) {
-      operations.push({
-        type: "mkdir",
-        target: this.resolvePath(parts[1], cwd)
-      });
-    } else if (cmd === "cat" && parts.length > 1 && !command.includes(">")) {
-      operations.push({
-        type: "read",
-        target: this.resolvePath(parts[1], cwd)
-      });
-    } else if (cmd === "mv" && parts.length > 2) {
-      operations.push({
-        type: "move",
-        target: this.resolvePath(parts[1], cwd),
-        secondaryTarget: this.resolvePath(parts[2], cwd)
-      });
-    } else if (cmd === "cp" && parts.length > 2) {
-      operations.push({
-        type: "copy",
-        target: this.resolvePath(parts[1], cwd),
-        secondaryTarget: this.resolvePath(parts[2], cwd)
-      });
-    }
-    return operations.length > 0 ? operations : void 0;
-  }
-  /**
-   * Resolves a path relative to the current working directory
-   */
-  resolvePath(filePath, cwd) {
-    if (path3.isAbsolute(filePath)) {
-      return filePath;
-    }
-    return path3.join(cwd, filePath);
-  }
-  /**
-   * Gets command history for a conversation
-   */
-  getCommandHistory(conversationId, limit) {
-    const history = this.commandHistory.get(conversationId) || [];
-    if (limit && limit > 0) {
-      return history.slice(-limit);
-    }
-    return history;
-  }
-  /**
-   * Clears command history for a conversation
-   */
-  clearCommandHistory(conversationId) {
-    this.commandHistory.delete(conversationId);
-    logger3.info(`Cleared command history for conversation: ${conversationId}`);
-  }
-  /**
-   * Gets the current working directory
-   * @param conversationId Optional conversation ID to get conversation-specific directory
-   * @returns The current directory path
-   */
-  getCurrentDirectory(_conversationId) {
-    return this.currentDirectory;
-  }
-  /**
-   * Gets the allowed directory
-   * @returns The allowed directory path
-   */
-  getAllowedDirectory() {
-    return this.shellConfig.allowedDirectory;
-  }
-};
-
-// src/actions/executeCommand.ts
-import {
-  ModelType,
-  composePromptFromState,
-  parseJSONObjectFromText,
-  logger as logger4
-} from "@elizaos/core";
-var commandExtractionTemplate = `# Extracting shell command from request
-{{recentMessages}}
-
-# Instructions: {{senderName}} wants to execute a shell command. Extract the COMPLETE shell command they want to run.
-
-IMPORTANT: 
-1. Always return the FULL executable shell command, not just the content or partial command.
-2. If the user mentions installing something, create the appropriate brew/npm/apt command.
-3. If the user directly provides a command (like "brew install X"), use it exactly as provided.
-4. ALWAYS extract a command if the user is asking for ANY kind of system operation.
-
-Common patterns:
-- "run ls -la" -> command: "ls -la"
-- "execute npm test" -> command: "npm test"
-- "show me the files" or "list files" -> command: "ls -la"
-- "what's in this directory" -> command: "ls -la"
-- "check git status" -> command: "git status"
-- "navigate to src folder" -> command: "cd src"
-- "create a file called test.txt" -> command: "touch test.txt"
-- "write hello world to a file" -> command: "echo 'hello world' > file.txt"
-- "create hello.js with javascript code" -> command: "echo 'console.log("Hello, World!");' > hello.js"
-- "create hello_world.py and write a python hello world script inside" -> command: "echo 'print("Hello, World!")' > hello_world.py"
-- "make a new directory" -> command: "mkdir newdir"
-- "list files inside your filesystem" -> command: "ls -la"
-- "install orbstack" or "brew install orbstack" -> command: "brew install orbstack"
-- "install mullvad vpn" -> command: "brew install --cask mullvad-vpn"
-- "get system info" -> command: "system_profiler SPHardwareDataType"
-- "check memory usage" -> command: "vm_stat"
-- "install package" -> command: "brew install <package>"
-
-Special cases:
-- "Run it in your shell" or "execute it" -> Extract the command from previous context
-- "Install these" -> Look for package names in previous messages
-- Direct commands should be used exactly as provided
-
-Key rules:
-1. For file creation with content, use: echo 'content' > filename
-2. For listing files, use: ls -la (not just ls)
-3. Always include the echo command when writing to files
-4. Include all flags and arguments
-5. When user says "run it", "execute it", or similar, they want you to run the command
-
-Your response must be formatted as a JSON block:
-\`\`\`json
-{
-  "command": "<complete shell command to execute>"
-}
-\`\`\`
-`;
-var extractCommand = async (runtime, _message, state) => {
-  const prompt = composePromptFromState({
-    state,
-    template: commandExtractionTemplate
-  });
-  for (let i = 0; i < 3; i++) {
-    const response = await runtime.useModel(ModelType.TEXT_SMALL, {
-      prompt
-    });
-    const parsedResponse = parseJSONObjectFromText(response);
-    if (parsedResponse?.command) {
-      return { command: parsedResponse.command };
-    }
-  }
-  return null;
-};
-var executeCommand = {
-  name: "EXECUTE_COMMAND",
-  similes: [
-    "RUN_COMMAND",
-    "SHELL_COMMAND",
-    "TERMINAL_COMMAND",
-    "EXEC",
-    "RUN",
-    "EXECUTE",
-    "CREATE_FILE",
-    "WRITE_FILE",
-    "MAKE_FILE",
-    "INSTALL",
-    "BREW_INSTALL",
-    "NPM_INSTALL",
-    "APT_INSTALL"
-  ],
-  description: "Execute ANY shell command in the terminal. Use this to run ANY command including: brew install, npm install, apt-get, system commands, file operations (create, write, delete), navigate directories, execute scripts, or perform any other shell operation. I CAN and SHOULD execute commands when asked. This includes brew, npm, git, ls, cd, echo, touch, cat, mkdir, system_profiler, and literally ANY other terminal command.",
-  validate: async (runtime, message, _state) => {
-    const shellService = runtime.getService("shell");
-    if (!shellService) {
-      return false;
-    }
-    const text = message.content.text?.toLowerCase() || "";
-    const commandKeywords = [
-      "run",
-      "execute",
-      "command",
-      "shell",
-      "install",
-      "brew",
-      "npm",
-      "create",
-      "file",
-      "directory",
-      "folder",
-      "list",
-      "show",
-      "system",
-      "info",
-      "check",
-      "status",
-      "cd",
-      "ls",
-      "mkdir",
-      "echo",
-      "cat",
-      "touch",
-      "git",
-      "build",
-      "test"
-    ];
-    const hasCommandKeyword = commandKeywords.some((keyword) => text.includes(keyword));
-    const hasDirectCommand = /^(brew|npm|apt|git|ls|cd|echo|cat|touch|mkdir|rm|mv|cp)\s/i.test(message.content.text || "");
-    return hasCommandKeyword || hasDirectCommand;
-  },
-  handler: async (runtime, message, state, _options, callback) => {
-    const shellService = runtime.getService("shell");
-    if (!shellService) {
-      await callback({
-        text: "Shell service is not available.",
-        source: message.content.source
-      });
-      return;
-    }
-    const commandInfo = await extractCommand(runtime, message, state);
-    if (!commandInfo?.command) {
-      logger4.error("Failed to extract command from message:", message.content.text);
-      await callback({
-        text: "I couldn't understand which command you want to execute. Please specify a shell command.",
-        source: message.content.source
-      });
-      return;
-    }
-    logger4.info(`User request: "${message.content.text}"`);
-    logger4.info(`Extracted command: "${commandInfo.command}"`);
-    try {
-      const conversationId = message.roomId || message.agentId;
-      const result = await shellService.executeCommand(commandInfo.command, conversationId);
-      let responseText = "";
-      if (result.success) {
-        responseText = `Command executed successfully in ${result.executedIn}
-
-`;
-        if (result.stdout) {
-          responseText += `Output:
-\`\`\`
-${result.stdout}
-\`\`\``;
-        } else {
-          responseText += "Command completed with no output.";
-        }
-      } else {
-        responseText = `Command failed with exit code ${result.exitCode} in ${result.executedIn}
-
-`;
-        if (result.error) {
-          responseText += `Error: ${result.error}
-`;
-        }
-        if (result.stderr) {
-          responseText += `
-Error output:
-\`\`\`
-${result.stderr}
-\`\`\``;
-        }
-      }
-      const response = {
-        text: responseText,
-        source: message.content.source
-      };
-      await callback(response);
-    } catch (error) {
-      logger4.error("Error executing command:", error);
-      await callback({
-        text: `Failed to execute command: ${error instanceof Error ? error.message : "Unknown error"}`,
-        source: message.content.source
-      });
-    }
-  },
-  examples: [
-    [
-      {
-        name: "{{name1}}",
-        content: {
-          text: "run ls -la"
-        }
-      },
-      {
-        name: "{{name2}}",
-        content: {
-          text: "I'll execute that command for you.",
-          actions: ["EXECUTE_COMMAND"]
-        }
-      }
-    ],
-    [
-      {
-        name: "{{name1}}",
-        content: {
-          text: "show me what files are in this directory"
-        }
-      },
-      {
-        name: "{{name2}}",
-        content: {
-          text: "I'll list the files in the current directory.",
-          actions: ["EXECUTE_COMMAND"]
-        }
-      }
-    ],
-    [
-      {
-        name: "{{name1}}",
-        content: {
-          text: "navigate to the src folder"
-        }
-      },
-      {
-        name: "{{name2}}",
-        content: {
-          text: "I'll change to the src directory.",
-          actions: ["EXECUTE_COMMAND"]
-        }
-      }
-    ],
-    [
-      {
-        name: "{{name1}}",
-        content: {
-          text: "check the git status"
-        }
-      },
-      {
-        name: "{{name2}}",
-        content: {
-          text: "I'll check the git repository status.",
-          actions: ["EXECUTE_COMMAND"]
-        }
-      }
-    ],
-    [
-      {
-        name: "{{name1}}",
-        content: {
-          text: "create a file called hello.txt"
-        }
-      },
-      {
-        name: "{{name2}}",
-        content: {
-          text: "I'll create hello.txt for you.",
-          actions: ["EXECUTE_COMMAND"]
-        }
-      }
-    ],
-    [
-      {
-        name: "{{name1}}",
-        content: {
-          text: "create hello_world.py and write a python hello world script inside"
-        }
-      },
-      {
-        name: "{{name2}}",
-        content: {
-          text: "I'll create hello_world.py with a Python hello world script.",
-          actions: ["EXECUTE_COMMAND"]
-        }
-      }
-    ],
-    [
-      {
-        name: "{{name1}}",
-        content: {
-          text: "write some content to a file"
-        }
-      },
-      {
-        name: "{{name2}}",
-        content: {
-          text: "I'll write content to a file for you.",
-          actions: ["EXECUTE_COMMAND"]
-        }
-      }
-    ],
-    [
-      {
-        name: "{{name1}}",
-        content: {
-          text: "brew install orbstack"
-        }
-      },
-      {
-        name: "{{name2}}",
-        content: {
-          text: "I'll install orbstack using brew.",
-          actions: ["EXECUTE_COMMAND"]
-        }
+        setTimeout(() => {
+          if (!child.killed) {
+            child.kill("SIGKILL");
+          }
+        }, 5000);
+      }, this.shellConfig.timeout);
+      if (child.stdout) {
+        child.stdout.on("data", (data) => {
+          stdout += data.toString();
+        });
       }
-    ],
-    [
-      {
-        name: "{{name1}}",
-        content: {
-          text: "install mullvad vpn"
-        }
-      },
-      {
-        name: "{{name2}}",
-        content: {
-          text: "I'll install Mullvad VPN for you.",
-          actions: ["EXECUTE_COMMAND"]
-        }
+      if (child.stderr) {
+        child.stderr.on("data", (data) => {
+          stderr += data.toString();
+        });
       }
-    ],
-    [
-      {
-        name: "{{name1}}",
-        content: {
-          text: "run the command brew install --cask docker"
-        }
-      },
-      {
-        name: "{{name2}}",
-        content: {
-          text: "I'll run that brew install command for you.",
-          actions: ["EXECUTE_COMMAND"]
+      child.on("exit", (code) => {
+        clearTimeout(timeout);
+        if (timedOut) {
+          resolve({
+            success: false,
+            stdout,
+            stderr: `${stderr}
+Command timed out`,
+            exitCode: code,
+            error: "Command execution timeout",
+            executedIn: this.currentDirectory
+          });
+          return;
         }
-      }
-    ]
-  ]
-};
-
-// src/actions/clearHistory.ts
-import {
-  logger as logger5
-} from "@elizaos/core";
-var clearHistory = {
-  name: "CLEAR_SHELL_HISTORY",
-  similes: ["RESET_SHELL", "CLEAR_TERMINAL", "CLEAR_HISTORY", "RESET_HISTORY"],
-  description: "Clears the recorded history of shell commands for the current conversation",
-  validate: async (runtime, message, _state) => {
-    const shellService = runtime.getService("shell");
-    if (!shellService) {
-      return false;
-    }
-    const text = message.content.text?.toLowerCase() || "";
-    const clearKeywords = ["clear", "reset", "delete", "remove", "clean"];
-    const historyKeywords = ["history", "terminal", "shell", "command"];
-    const hasClearKeyword = clearKeywords.some((keyword) => text.includes(keyword));
-    const hasHistoryKeyword = historyKeywords.some((keyword) => text.includes(keyword));
-    return hasClearKeyword && hasHistoryKeyword;
-  },
-  handler: async (runtime, message, _state, _options, callback) => {
-    const shellService = runtime.getService("shell");
-    if (!shellService) {
-      await callback({
-        text: "Shell service is not available.",
-        source: message.content.source
+        resolve({
+          success: code === 0,
+          stdout,
+          stderr,
+          exitCode: code,
+          executedIn: this.currentDirectory
+        });
+      });
+      child.on("error", (err) => {
+        clearTimeout(timeout);
+        resolve({
+          success: false,
+          stdout,
+          stderr: err.message,
+          exitCode: 1,
+          error: "Failed to execute command",
+          executedIn: this.currentDirectory
+        });
       });
+    });
+  }
+  addToHistory(conversationId, command, result, fileOperations) {
+    if (!conversationId)
       return;
+    const historyEntry = {
+      command,
+      stdout: result.stdout,
+      stderr: result.stderr,
+      exitCode: result.exitCode,
+      timestamp: Date.now(),
+      workingDirectory: result.executedIn,
+      fileOperations
+    };
+    if (!this.commandHistory.has(conversationId)) {
+      this.commandHistory.set(conversationId, []);
     }
-    try {
-      const conversationId = message.roomId || message.agentId;
-      shellService.clearCommandHistory(conversationId);
-      logger5.info(`Cleared shell history for conversation: ${conversationId}`);
-      const response = {
-        text: "Shell command history has been cleared.",
-        source: message.content.source
-      };
-      await callback(response);
-    } catch (error) {
-      logger5.error("Error clearing shell history:", error);
-      await callback({
-        text: `Failed to clear shell history: ${error instanceof Error ? error.message : "Unknown error"}`,
-        source: message.content.source
-      });
+    const history = this.commandHistory.get(conversationId);
+    if (!history) {
+      throw new Error(`No history found for conversation ${conversationId}`);
     }
-  },
-  examples: [
-    [
-      {
-        name: "{{name1}}",
-        content: {
-          text: "clear my shell history"
-        }
-      },
-      {
-        name: "{{name2}}",
-        content: {
-          text: "Shell command history has been cleared.",
-          actions: ["CLEAR_SHELL_HISTORY"]
-        }
-      }
-    ],
-    [
-      {
-        name: "{{name1}}",
-        content: {
-          text: "reset the terminal history"
-        }
-      },
-      {
-        name: "{{name2}}",
-        content: {
-          text: "Shell command history has been cleared.",
-          actions: ["CLEAR_SHELL_HISTORY"]
-        }
-      }
-    ],
-    [
-      {
-        name: "{{name1}}",
-        content: {
-          text: "delete command history"
-        }
-      },
-      {
-        name: "{{name2}}",
-        content: {
-          text: "Shell command history has been cleared.",
-          actions: ["CLEAR_SHELL_HISTORY"]
-        }
+    history.push(historyEntry);
+    if (history.length > this.maxHistoryPerConversation) {
+      history.shift();
+    }
+  }
+  detectFileOperations(command, cwd) {
+    const operations = [];
+    const parts = command.trim().split(/\s+/);
+    const cmd = parts[0].toLowerCase();
+    if (cmd === "touch" && parts.length > 1) {
+      operations.push({
+        type: "create",
+        target: this.resolvePath(parts[1], cwd)
+      });
+    } else if (cmd === "echo" && command.includes(">")) {
+      const match = command.match(/>\s*([^\s]+)$/);
+      if (match) {
+        operations.push({
+          type: "write",
+          target: this.resolvePath(match[1], cwd)
+        });
       }
-    ]
-  ]
-};
-
-// src/providers/shellHistoryProvider.ts
-import {
-  addHeader,
-  logger as logger6
-} from "@elizaos/core";
-var MAX_OUTPUT_LENGTH = 8e3;
-var TRUNCATE_SEGMENT_LENGTH = 4e3;
-var shellHistoryProvider = {
-  name: "SHELL_HISTORY",
-  description: "Provides recent shell command history, current working directory, and file operations within the restricted environment",
-  position: 99,
-  get: async (runtime, message, _state) => {
-    const shellService = runtime.getService("shell");
-    if (!shellService) {
-      logger6.warn("[shellHistoryProvider] Shell service not found");
-      return {
-        values: {
-          shellHistory: "Shell service is not available",
-          currentWorkingDirectory: "N/A",
-          allowedDirectory: "N/A"
-        },
-        text: addHeader("# Shell Status", "Shell service is not available"),
-        data: { history: [], cwd: "N/A", allowedDir: "N/A" }
-      };
+    } else if (cmd === "mkdir" && parts.length > 1) {
+      operations.push({
+        type: "mkdir",
+        target: this.resolvePath(parts[1], cwd)
+      });
+    } else if (cmd === "cat" && parts.length > 1 && !command.includes(">")) {
+      operations.push({
+        type: "read",
+        target: this.resolvePath(parts[1], cwd)
+      });
+    } else if (cmd === "mv" && parts.length > 2) {
+      operations.push({
+        type: "move",
+        target: this.resolvePath(parts[1], cwd),
+        secondaryTarget: this.resolvePath(parts[2], cwd)
+      });
+    } else if (cmd === "cp" && parts.length > 2) {
+      operations.push({
+        type: "copy",
+        target: this.resolvePath(parts[1], cwd),
+        secondaryTarget: this.resolvePath(parts[2], cwd)
+      });
     }
-    const conversationId = message.roomId || message.agentId;
-    const history = shellService.getCommandHistory(conversationId, 10);
-    const cwd = shellService.getCurrentDirectory(conversationId);
-    const allowedDir = shellService.getAllowedDirectory();
-    let historyText = "No commands in history.";
-    if (history.length > 0) {
-      historyText = history.map((entry) => {
-        let entryStr = `[${new Date(entry.timestamp).toISOString()}] ${entry.workingDirectory}> ${entry.command}`;
-        if (entry.stdout) {
-          if (entry.stdout.length > MAX_OUTPUT_LENGTH) {
-            entryStr += `
-  Output: ${entry.stdout.substring(0, TRUNCATE_SEGMENT_LENGTH)}
-  ... [TRUNCATED] ...
-  ${entry.stdout.substring(entry.stdout.length - TRUNCATE_SEGMENT_LENGTH)}`;
-          } else {
-            entryStr += `
-  Output: ${entry.stdout}`;
-          }
-        }
-        if (entry.stderr) {
-          if (entry.stderr.length > MAX_OUTPUT_LENGTH) {
-            entryStr += `
-  Error: ${entry.stderr.substring(0, TRUNCATE_SEGMENT_LENGTH)}
-  ... [TRUNCATED] ...
-  ${entry.stderr.substring(entry.stderr.length - TRUNCATE_SEGMENT_LENGTH)}`;
-          } else {
-            entryStr += `
-  Error: ${entry.stderr}`;
-          }
-        }
-        entryStr += `
-  Exit Code: ${entry.exitCode}`;
-        if (entry.fileOperations && entry.fileOperations.length > 0) {
-          entryStr += "\n  File Operations:";
-          entry.fileOperations.forEach((op) => {
-            if (op.secondaryTarget) {
-              entryStr += `
-    - ${op.type}: ${op.target} \u2192 ${op.secondaryTarget}`;
-            } else {
-              entryStr += `
-    - ${op.type}: ${op.target}`;
-            }
-          });
-        }
-        return entryStr;
-      }).join("\n\n");
+    return operations.length > 0 ? operations : undefined;
+  }
+  resolvePath(filePath, cwd) {
+    if (path3.isAbsolute(filePath)) {
+      return filePath;
     }
-    const recentFileOps = history.filter((entry) => entry.fileOperations && entry.fileOperations.length > 0).flatMap((entry) => entry.fileOperations).slice(-5);
-    let fileOpsText = "";
-    if (recentFileOps.length > 0) {
-      fileOpsText = "\n\n" + addHeader(
-        "# Recent File Operations",
-        recentFileOps.map((op) => {
-          if (op.secondaryTarget) {
-            return `- ${op.type}: ${op.target} \u2192 ${op.secondaryTarget}`;
-          }
-          return `- ${op.type}: ${op.target}`;
-        }).join("\n")
-      );
+    return path3.join(cwd, filePath);
+  }
+  getCommandHistory(conversationId, limit) {
+    const history = this.commandHistory.get(conversationId) || [];
+    if (limit && limit > 0) {
+      return history.slice(-limit);
     }
-    const text = `Current Directory: ${cwd}
-Allowed Directory: ${allowedDir}
-
-${addHeader("# Shell History (Last 10)", historyText)}${fileOpsText}`;
-    return {
-      values: {
-        shellHistory: historyText,
-        currentWorkingDirectory: cwd,
-        allowedDirectory: allowedDir,
-        recentFileOperations: recentFileOps
-      },
-      text,
-      data: {
-        history,
-        cwd,
-        allowedDir,
-        fileOperations: recentFileOps
-      }
-    };
+    return history;
   }
-};
+  clearCommandHistory(conversationId) {
+    this.commandHistory.delete(conversationId);
+    logger6.info(`Cleared command history for conversation: ${conversationId}`);
+  }
+  getCurrentDirectory(_conversationId) {
+    return this.currentDirectory;
+  }
+  getAllowedDirectory() {
+    return this.shellConfig.allowedDirectory;
+  }
+}
 
-// src/index.ts
+// index.ts
 var shellPlugin = {
   name: "shell",
   description: "Execute shell commands within a restricted directory with history tracking",
@@ -1060,12 +920,20 @@ var shellPlugin = {
   actions: [executeCommand, clearHistory],
   providers: [shellHistoryProvider]
 };
-var index_default = shellPlugin;
+var typescript_default = shellPlugin;
 export {
-  ShellService,
-  index_default as default,
-  executeCommand,
+  validatePath,
+  shellPlugin,
+  shellHistoryProvider,
   loadShellConfig,
-  shellPlugin
+  isSafeCommand,
+  isForbiddenCommand,
+  extractBaseCommand,
+  executeCommand,
+  typescript_default as default,
+  clearHistory,
+  ShellService,
+  DEFAULT_FORBIDDEN_COMMANDS
 };
-//# sourceMappingURL=index.js.map
+
+//# debugId=660EC61651C6DFA564756E2164756E21