@elizaos/plugin-shell 1.2.0

package/dist/index.js

@@ -0,0 +1,1071 @@
+// src/services/shellService.ts
+import {
+  Service,
+  logger as logger3
+} 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;
+    }
+  }
+  if (!enabled) {
+    logger.info("Shell plugin is disabled. Set SHELL_ENABLED=true to enable.");
+  }
+  return value;
+}
+
+// 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;
+    }
+    return normalizedPath;
+  } catch (error) {
+    logger2.error("Error validating path:", error);
+    return null;
+  }
+}
+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;
+    }
+  }
+  for (const pattern of dangerousPatterns) {
+    if (pattern.test(command)) {
+      logger2.warn(`Dangerous pattern detected in command: ${command}`);
+      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;
+    }
+    if (!forbidden.includes(" ")) {
+      const baseCommand = extractBaseCommand(command);
+      if (baseCommand.toLowerCase() === forbiddenLower) {
+        return true;
+      }
+    }
+    return false;
+  });
+}
+
+// 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");
+  }
+  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 {
+        success: false,
+        stdout: "",
+        stderr: "Shell plugin is disabled. Set SHELL_ENABLED=true to enable.",
+        exitCode: 1,
+        error: "Shell plugin disabled",
+        executedIn: this.currentDirectory
+      };
+    }
+    if (!command || typeof command !== "string") {
+      return {
+        success: false,
+        stdout: "",
+        stderr: "Invalid command",
+        exitCode: 1,
+        error: "Command must be a non-empty string",
+        executedIn: this.currentDirectory
+      };
+    }
+    const trimmedCommand = command.trim();
+    if (!isSafeCommand(trimmedCommand)) {
+      return {
+        success: false,
+        stdout: "",
+        stderr: "Command contains forbidden patterns",
+        exitCode: 1,
+        error: "Security policy violation",
+        executedIn: this.currentDirectory
+      };
+    }
+    if (isForbiddenCommand(trimmedCommand, this.shellConfig.forbiddenCommands)) {
+      return {
+        success: false,
+        stdout: "",
+        stderr: `Command is forbidden by security policy`,
+        exitCode: 1,
+        error: "Forbidden command",
+        executedIn: this.currentDirectory
+      };
+    }
+    if (trimmedCommand.startsWith("cd ")) {
+      const result2 = await this.handleCdCommand(trimmedCommand);
+      this.addToHistory(conversationId, trimmedCommand, result2);
+      return result2;
+    }
+    const result = await this.runCommand(trimmedCommand);
+    if (result.success) {
+      const fileOps = this.detectFileOperations(trimmedCommand, this.currentDirectory);
+      if (fileOps && conversationId) {
+        this.addToHistory(conversationId, trimmedCommand, result, fileOps);
+      } else {
+        this.addToHistory(conversationId, trimmedCommand, result);
+      }
+    } else {
+      this.addToHistory(conversationId, trimmedCommand, result);
+    }
+    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) {
+      this.currentDirectory = this.shellConfig.allowedDirectory;
+      return {
+        success: true,
+        stdout: `Changed directory to: ${this.currentDirectory}`,
+        stderr: "",
+        exitCode: 0,
+        executedIn: this.currentDirectory
+      };
+    }
+    const targetPath = parts.slice(1).join(" ");
+    const validatedPath = validatePath(
+      targetPath,
+      this.shellConfig.allowedDirectory,
+      this.currentDirectory
+    );
+    if (!validatedPath) {
+      return {
+        success: false,
+        stdout: "",
+        stderr: "Cannot navigate outside allowed directory",
+        exitCode: 1,
+        error: "Permission denied",
+        executedIn: this.currentDirectory
+      };
+    }
+    this.currentDirectory = validatedPath;
+    return {
+      success: true,
+      stdout: `Changed directory to: ${this.currentDirectory}`,
+      stderr: "",
+      exitCode: 0,
+      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("|");
+      let cmd;
+      let args;
+      if (useShell) {
+        cmd = "sh";
+        args = ["-c", command];
+        logger3.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}`);
+      }
+      let stdout = "";
+      let stderr = "";
+      let timedOut = false;
+      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"]
+        }
+      }
+    ],
+    [
+      {
+        name: "{{name1}}",
+        content: {
+          text: "install mullvad vpn"
+        }
+      },
+      {
+        name: "{{name2}}",
+        content: {
+          text: "I'll install Mullvad VPN for you.",
+          actions: ["EXECUTE_COMMAND"]
+        }
+      }
+    ],
+    [
+      {
+        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"]
+        }
+      }
+    ]
+  ]
+};
+
+// 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
+      });
+      return;
+    }
+    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
+      });
+    }
+  },
+  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"]
+        }
+      }
+    ]
+  ]
+};
+
+// 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" }
+      };
+    }
+    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");
+    }
+    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")
+      );
+    }
+    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
+      }
+    };
+  }
+};
+
+// src/index.ts
+var shellPlugin = {
+  name: "shell",
+  description: "Execute shell commands within a restricted directory with history tracking",
+  services: [ShellService],
+  actions: [executeCommand, clearHistory],
+  providers: [shellHistoryProvider]
+};
+var index_default = shellPlugin;
+export {
+  ShellService,
+  index_default as default,
+  executeCommand,
+  loadShellConfig,
+  shellPlugin
+};
+//# sourceMappingURL=index.js.map