elizaos-plugin-code 2.0.0a4__tar.gz

elizaos_plugin_code-2.0.0a4/.gitignore

@@ -0,0 +1,12 @@
+dist
+node_modules
+.env
+.elizadb
+.turbo
+target/
+__pycache__
+*.pyc
+.venv
+*.egg-info
+.DS_Store
+package-lock.json

elizaos_plugin_code-2.0.0a4/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: elizaos-plugin-code
+Version: 2.0.0a4
+Summary: elizaOS Coder Plugin - filesystem + shell + git (restricted)
+Project-URL: Homepage, https://github.com/elizaos/eliza
+Project-URL: Repository, https://github.com/elizaos/eliza
+Author: elizaOS Contributors
+License-Expression: MIT
+Keywords: agents,ai,coding,elizaos,filesystem,git,shell
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: pydantic>=2.10.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.14.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.24.0; extra == 'dev'
+Requires-Dist: pytest-cov>=6.0.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.9.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# elizaos-plugin-code (Python)
+
+Python implementation of the Eliza Coder plugin: filesystem + shell + git, restricted to an allowed directory.
+

elizaos_plugin_code-2.0.0a4/README.md

@@ -0,0 +1,4 @@
+# elizaos-plugin-code (Python)
+
+Python implementation of the Eliza Coder plugin: filesystem + shell + git, restricted to an allowed directory.
+

elizaos_plugin_code-2.0.0a4/elizaos_plugin_eliza_coder/__init__.py

@@ -0,0 +1,58 @@
+from elizaos_plugin_eliza_coder.actions import (
+    ChangeDirectoryAction,
+    EditFileAction,
+    ExecuteShellAction,
+    GitAction,
+    ListFilesAction,
+    ReadFileAction,
+    SearchFilesAction,
+    WriteFileAction,
+)
+from elizaos_plugin_eliza_coder.config import load_coder_config
+from elizaos_plugin_eliza_coder.path_utils import (
+    DEFAULT_FORBIDDEN_COMMANDS,
+    extract_base_command,
+    is_forbidden_command,
+    is_safe_command,
+    validate_path,
+)
+from elizaos_plugin_eliza_coder.providers import CoderStatusProvider
+from elizaos_plugin_eliza_coder.service import CoderService
+from elizaos_plugin_eliza_coder.types import (
+    CoderConfig,
+    CommandHistoryEntry,
+    CommandResult,
+    FileOperation,
+    FileOperationType,
+)
+
+__version__ = "1.0.0"
+
+PLUGIN_NAME = "code"
+PLUGIN_DESCRIPTION = "Filesystem + shell + git tools within a restricted directory"
+
+__all__ = [
+    "CoderConfig",
+    "CommandResult",
+    "CommandHistoryEntry",
+    "FileOperation",
+    "FileOperationType",
+    "CoderService",
+    "ReadFileAction",
+    "WriteFileAction",
+    "EditFileAction",
+    "ListFilesAction",
+    "SearchFilesAction",
+    "ChangeDirectoryAction",
+    "ExecuteShellAction",
+    "GitAction",
+    "CoderStatusProvider",
+    "load_coder_config",
+    "validate_path",
+    "is_safe_command",
+    "extract_base_command",
+    "is_forbidden_command",
+    "DEFAULT_FORBIDDEN_COMMANDS",
+    "PLUGIN_NAME",
+    "PLUGIN_DESCRIPTION",
+]

elizaos_plugin_code-2.0.0a4/elizaos_plugin_eliza_coder/actions/__init__.py

@@ -0,0 +1,19 @@
+from elizaos_plugin_eliza_coder.actions.change_directory import ChangeDirectoryAction
+from elizaos_plugin_eliza_coder.actions.edit_file import EditFileAction
+from elizaos_plugin_eliza_coder.actions.execute_shell import ExecuteShellAction
+from elizaos_plugin_eliza_coder.actions.git import GitAction
+from elizaos_plugin_eliza_coder.actions.list_files import ListFilesAction
+from elizaos_plugin_eliza_coder.actions.read_file import ReadFileAction
+from elizaos_plugin_eliza_coder.actions.search_files import SearchFilesAction
+from elizaos_plugin_eliza_coder.actions.write_file import WriteFileAction
+
+__all__ = [
+    "ReadFileAction",
+    "WriteFileAction",
+    "EditFileAction",
+    "ListFilesAction",
+    "SearchFilesAction",
+    "ChangeDirectoryAction",
+    "ExecuteShellAction",
+    "GitAction",
+]

elizaos_plugin_code-2.0.0a4/elizaos_plugin_eliza_coder/actions/change_directory.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from elizaos_plugin_eliza_coder.actions.common import ActionResult, Message, conversation_id
+from elizaos_plugin_eliza_coder.service import CoderService
+
+
+@dataclass
+class ChangeDirectoryAction:
+    @property
+    def name(self) -> str:
+        return "CHANGE_DIRECTORY"
+
+    async def validate(self, _message: Message, _state: dict) -> bool:
+        return True
+
+    async def handler(
+        self,
+        message: Message,
+        state: dict,
+        service: CoderService | None = None,
+    ) -> ActionResult:
+        if service is None:
+            return ActionResult(False, "Coder service is not available.", "missing_service")
+
+        target = str(state.get("path", "")).strip()
+        if not target:
+            return ActionResult(False, "Missing path.", "missing_path")
+
+        result = await service.change_directory(conversation_id(message), target)
+        return ActionResult(result.success, result.stdout if result.success else result.stderr)

elizaos_plugin_code-2.0.0a4/elizaos_plugin_eliza_coder/actions/common.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TypedDict
+
+
+class MessageContent(TypedDict, total=False):
+    text: str
+
+
+class Message(TypedDict, total=False):
+    content: MessageContent
+    room_id: str
+    agent_id: str
+
+
+@dataclass(frozen=True)
+class ActionResult:
+    success: bool
+    text: str
+    error: str | None = None
+
+
+def conversation_id(message: Message) -> str:
+    return message.get("room_id") or message.get("agent_id") or "default"

elizaos_plugin_code-2.0.0a4/elizaos_plugin_eliza_coder/actions/edit_file.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from elizaos_plugin_eliza_coder.actions.common import ActionResult, Message, conversation_id
+from elizaos_plugin_eliza_coder.service import CoderService
+
+
+@dataclass
+class EditFileAction:
+    @property
+    def name(self) -> str:
+        return "EDIT_FILE"
+
+    async def validate(self, _message: Message, _state: dict) -> bool:
+        return True
+
+    async def handler(
+        self, message: Message, state: dict, service: CoderService | None = None
+    ) -> ActionResult:
+        if service is None:
+            return ActionResult(False, "Coder service is not available.", "missing_service")
+
+        filepath = str(state.get("filepath", "")).strip()
+        old_str = str(state.get("old_str", ""))
+        new_str = str(state.get("new_str", ""))
+        if not filepath or not old_str:
+            return ActionResult(False, "Missing filepath or old_str.", "missing_args")
+
+        ok, err = await service.edit_file(conversation_id(message), filepath, old_str, new_str)
+        if not ok:
+            return ActionResult(False, err, "edit_failed")
+        return ActionResult(True, f"Edited {filepath}")

elizaos_plugin_code-2.0.0a4/elizaos_plugin_eliza_coder/actions/execute_shell.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from elizaos_plugin_eliza_coder.actions.common import ActionResult, Message, conversation_id
+from elizaos_plugin_eliza_coder.service import CoderService
+
+
+@dataclass
+class ExecuteShellAction:
+    @property
+    def name(self) -> str:
+        return "EXECUTE_SHELL"
+
+    async def validate(self, _message: Message, _state: dict) -> bool:
+        return True
+
+    async def handler(
+        self,
+        message: Message,
+        state: dict,
+        service: CoderService | None = None,
+    ) -> ActionResult:
+        if service is None:
+            return ActionResult(False, "Coder service is not available.", "missing_service")
+
+        cmd = str(state.get("command", "")).strip()
+        if not cmd:
+            return ActionResult(False, "Missing command.", "missing_command")
+
+        res = await service.execute_shell(conversation_id(message), cmd)
+        return ActionResult(res.success, res.stdout if res.success else res.stderr)

elizaos_plugin_code-2.0.0a4/elizaos_plugin_eliza_coder/actions/git.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from elizaos_plugin_eliza_coder.actions.common import ActionResult, Message, conversation_id
+from elizaos_plugin_eliza_coder.service import CoderService
+
+
+@dataclass
+class GitAction:
+    @property
+    def name(self) -> str:
+        return "GIT"
+
+    async def validate(self, _message: Message, _state: dict) -> bool:
+        return True
+
+    async def handler(
+        self,
+        message: Message,
+        state: dict,
+        service: CoderService | None = None,
+    ) -> ActionResult:
+        if service is None:
+            return ActionResult(False, "Coder service is not available.", "missing_service")
+
+        args = str(state.get("args", "")).strip()
+        if not args:
+            return ActionResult(False, "Missing args.", "missing_args")
+
+        res = await service.git(conversation_id(message), args)
+        return ActionResult(res.success, res.stdout if res.success else res.stderr)

elizaos_plugin_code-2.0.0a4/elizaos_plugin_eliza_coder/actions/list_files.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from elizaos_plugin_eliza_coder.actions.common import ActionResult, Message, conversation_id
+from elizaos_plugin_eliza_coder.service import CoderService
+
+
+@dataclass
+class ListFilesAction:
+    @property
+    def name(self) -> str:
+        return "LIST_FILES"
+
+    async def validate(self, _message: Message, _state: dict) -> bool:
+        return True
+
+    async def handler(
+        self, message: Message, state: dict, service: CoderService | None = None
+    ) -> ActionResult:
+        if service is None:
+            return ActionResult(False, "Coder service is not available.", "missing_service")
+
+        path_arg = str(state.get("path", ".")).strip() or "."
+        ok, res = await service.list_files(conversation_id(message), path_arg)
+        if not ok:
+            return ActionResult(False, str(res), "list_failed")
+        items = res if isinstance(res, list) else []
+        return ActionResult(True, "\n".join(items) if items else "(empty)")

elizaos_plugin_code-2.0.0a4/elizaos_plugin_eliza_coder/actions/read_file.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from elizaos_plugin_eliza_coder.actions.common import ActionResult, Message, conversation_id
+from elizaos_plugin_eliza_coder.service import CoderService
+
+
+@dataclass
+class ReadFileAction:
+    @property
+    def name(self) -> str:
+        return "READ_FILE"
+
+    async def validate(self, _message: Message, _state: dict) -> bool:
+        return True
+
+    async def handler(
+        self, message: Message, _state: dict, service: CoderService | None = None
+    ) -> ActionResult:
+        if service is None:
+            return ActionResult(False, "Coder service is not available.", "missing_service")
+
+        text = (message.get("content", {}) or {}).get("text", "")
+        filepath = ""
+        if '"' in text:
+            parts = text.split('"')
+            if len(parts) >= 2:
+                filepath = parts[1]
+
+        if not filepath:
+            return ActionResult(False, "Missing filepath.", "missing_filepath")
+
+        ok, out = await service.read_file(conversation_id(message), filepath)
+        if not ok:
+            return ActionResult(False, out, "read_failed")
+        return ActionResult(True, out)

elizaos_plugin_code-2.0.0a4/elizaos_plugin_eliza_coder/actions/search_files.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from elizaos_plugin_eliza_coder.actions.common import ActionResult, Message, conversation_id
+from elizaos_plugin_eliza_coder.service import CoderService, SearchMatch
+
+
+@dataclass
+class SearchFilesAction:
+    @property
+    def name(self) -> str:
+        return "SEARCH_FILES"
+
+    async def validate(self, _message: Message, _state: dict) -> bool:
+        return True
+
+    async def handler(
+        self, message: Message, state: dict, service: CoderService | None = None
+    ) -> ActionResult:
+        if service is None:
+            return ActionResult(False, "Coder service is not available.", "missing_service")
+
+        pattern = str(state.get("pattern", "")).strip()
+        dirpath = str(state.get("path", ".")).strip() or "."
+        max_matches = (
+            int(state.get("max_matches", 50)) if str(state.get("max_matches", "")).strip() else 50
+        )
+
+        if not pattern:
+            return ActionResult(False, "Missing pattern.", "missing_pattern")
+
+        ok, res = await service.search_files(
+            conversation_id(message), pattern, dirpath, max_matches
+        )
+        if not ok:
+            return ActionResult(False, str(res), "search_failed")
+        matches = res if isinstance(res, list) else []
+        if not matches:
+            return ActionResult(True, f'No matches for "{pattern}".')
+        lines = [f"{m.file}:L{m.line}: {m.content}" for m in matches if isinstance(m, SearchMatch)]
+        return ActionResult(True, "\n".join(lines))

elizaos_plugin_code-2.0.0a4/elizaos_plugin_eliza_coder/actions/write_file.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from elizaos_plugin_eliza_coder.actions.common import ActionResult, Message, conversation_id
+from elizaos_plugin_eliza_coder.service import CoderService
+
+
+@dataclass
+class WriteFileAction:
+    @property
+    def name(self) -> str:
+        return "WRITE_FILE"
+
+    async def validate(self, _message: Message, _state: dict) -> bool:
+        return True
+
+    async def handler(
+        self, message: Message, state: dict, service: CoderService | None = None
+    ) -> ActionResult:
+        if service is None:
+            return ActionResult(False, "Coder service is not available.", "missing_service")
+
+        filepath = str(state.get("filepath", "")).strip()
+        content = str(state.get("content", ""))
+        if not filepath:
+            return ActionResult(False, "Missing filepath.", "missing_filepath")
+
+        ok, err = await service.write_file(conversation_id(message), filepath, content)
+        if not ok:
+            return ActionResult(False, err, "write_failed")
+        return ActionResult(True, f"Wrote {filepath} ({len(content)} chars)")

elizaos_plugin_code-2.0.0a4/elizaos_plugin_eliza_coder/config.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from elizaos_plugin_eliza_coder.types import CoderConfig
+
+
+def _parse_bool(value: str | None) -> bool:
+    v = (value or "").strip().lower()
+    return v in {"1", "true", "yes", "on"}
+
+
+def _parse_int(value: str | None, fallback: int) -> int:
+    raw = (value or "").strip()
+    try:
+        parsed = int(raw)
+    except ValueError:
+        return fallback
+    if parsed <= 0:
+        return fallback
+    return parsed
+
+
+def load_coder_config() -> CoderConfig:
+    enabled = _parse_bool(os.environ.get("CODER_ENABLED"))
+    allowed_raw = (os.environ.get("CODER_ALLOWED_DIRECTORY") or "").strip()
+    allowed = Path(allowed_raw).resolve() if allowed_raw else Path.cwd().resolve()
+    timeout_ms = _parse_int(os.environ.get("CODER_TIMEOUT"), 30_000)
+    forbidden = [
+        s.strip()
+        for s in (os.environ.get("CODER_FORBIDDEN_COMMANDS") or "").split(",")
+        if s.strip()
+    ]
+    return CoderConfig(
+        enabled=enabled,
+        allowed_directory=os.fspath(allowed),
+        timeout_ms=timeout_ms,
+        forbidden_commands=forbidden,
+    )

elizaos_plugin_code-2.0.0a4/elizaos_plugin_eliza_coder/path_utils.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+DEFAULT_FORBIDDEN_COMMANDS: list[str] = [
+    "rm -rf /",
+    "rm -rf ~",
+    "sudo rm",
+    "mkfs",
+    "dd if=/dev",
+]
+
+
+def extract_base_command(command: str) -> str:
+    trimmed = command.strip()
+    if not trimmed:
+        return ""
+    return trimmed.split()[0]
+
+
+def is_safe_command(command: str) -> bool:
+    c = command.strip()
+    if not c:
+        return False
+    if "&&" in c or "||" in c or ";" in c:
+        return False
+    if "$(" in c or "`" in c:
+        return False
+    return True
+
+
+def is_forbidden_command(command: str, additional_forbidden: list[str]) -> bool:
+    lower = command.lower()
+    for f in DEFAULT_FORBIDDEN_COMMANDS:
+        if f.lower() in lower:
+            return True
+    for f in additional_forbidden:
+        if f.strip() and f.lower() in lower:
+            return True
+    return False
+
+
+def validate_path(target_path: str, allowed_directory: str, current_directory: str) -> str | None:
+    allowed = Path(allowed_directory).resolve()
+    base = Path(current_directory).resolve() if current_directory else allowed
+    resolved = (base / target_path).resolve()
+
+    try:
+        resolved.relative_to(allowed)
+    except ValueError:
+        return None
+
+    return os.fspath(resolved)

elizaos_plugin_code-2.0.0a4/elizaos_plugin_eliza_coder/providers/__init__.py

@@ -0,0 +1,3 @@
+from elizaos_plugin_eliza_coder.providers.coder_status import CoderStatusProvider
+
+__all__ = ["CoderStatusProvider"]

elizaos_plugin_code-2.0.0a4/elizaos_plugin_eliza_coder/providers/coder_status.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from elizaos_plugin_eliza_coder.actions.common import Message, conversation_id
+from elizaos_plugin_eliza_coder.service import CoderService
+
+
+@dataclass(frozen=True)
+class ProviderResult:
+    values: dict[str, str]
+    text: str
+    data: dict[str, str | int]
+
+
+class CoderStatusProvider:
+    @property
+    def name(self) -> str:
+        return "CODER_STATUS"
+
+    @property
+    def description(self) -> str:
+        return "Provides current working directory, allowed directory, and recent command history"
+
+    @property
+    def position(self) -> int:
+        return 99
+
+    async def get(
+        self,
+        message: Message,
+        _state: dict,
+        service: CoderService | None = None,
+    ) -> ProviderResult:
+        if service is None:
+            return ProviderResult(
+                values={
+                    "coderStatus": "Coder service is not available",
+                    "currentWorkingDirectory": "N/A",
+                    "allowedDirectory": "N/A",
+                },
+                text="# Coder Status\n\nCoder service is not available",
+                data={"historyCount": 0, "cwd": "N/A", "allowedDir": "N/A"},
+            )
+
+        conv = conversation_id(message)
+        history = service.get_command_history(conv, limit=10)
+        cwd = service.get_current_directory(conv)
+        allowed = service.allowed_directory
+
+        history_text = "No commands in history."
+        if history:
+            history_text = "\n".join([f"{h.working_directory}> {h.command}" for h in history])
+
+        text = f"Current Directory: {cwd}\nAllowed Directory: {allowed}\n\n{history_text}"
+        return ProviderResult(
+            values={
+                "coderStatus": history_text,
+                "currentWorkingDirectory": cwd,
+                "allowedDirectory": allowed,
+            },
+            text=text,
+            data={"historyCount": len(history), "cwd": cwd, "allowedDir": allowed},
+        )

elizaos_plugin_code-2.0.0a4/elizaos_plugin_eliza_coder/py.typed

@@ -0,0 +1 @@
+

elizaos_plugin_code-2.0.0a4/elizaos_plugin_eliza_coder/service.py

@@ -0,0 +1,351 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+import shlex
+import subprocess
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from elizaos_plugin_eliza_coder.config import load_coder_config
+from elizaos_plugin_eliza_coder.path_utils import (
+    is_forbidden_command,
+    is_safe_command,
+    validate_path,
+)
+from elizaos_plugin_eliza_coder.types import (
+    CommandHistoryEntry,
+    CommandResult,
+    FileOperation,
+)
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class SearchMatch:
+    file: str
+    line: int
+    content: str
+
+
+class CoderService:
+    def __init__(self) -> None:
+        self._config = load_coder_config()
+        self._cwd_by_conversation: dict[str, str] = {}
+        self._history_by_conversation: dict[str, list[CommandHistoryEntry]] = {}
+        self._max_history = 100
+
+    @property
+    def allowed_directory(self) -> str:
+        return self._config.allowed_directory
+
+    def get_current_directory(self, conversation_id: str) -> str:
+        return self._cwd_by_conversation.get(conversation_id, self._config.allowed_directory)
+
+    def _set_current_directory(self, conversation_id: str, directory: str) -> None:
+        self._cwd_by_conversation[conversation_id] = directory
+
+    def get_command_history(self, conversation_id: str, limit: int) -> list[CommandHistoryEntry]:
+        if limit <= 0:
+            return []
+        return self._history_by_conversation.get(conversation_id, [])[-limit:]
+
+    def _add_history(
+        self,
+        conversation_id: str,
+        command: str,
+        result: CommandResult,
+        file_ops: list[FileOperation] | None = None,
+    ) -> None:
+        items = self._history_by_conversation.get(conversation_id, [])
+        items.append(
+            CommandHistoryEntry(
+                timestamp=time.time(),
+                working_directory=result.executed_in,
+                command=command,
+                stdout=result.stdout,
+                stderr=result.stderr,
+                exit_code=result.exit_code,
+                file_operations=file_ops,
+            )
+        )
+        if len(items) > self._max_history:
+            items = items[-self._max_history :]
+        self._history_by_conversation[conversation_id] = items
+
+    def _ensure_enabled(self) -> str | None:
+        if self._config.enabled:
+            return None
+        return "Coder plugin is disabled. Set CODER_ENABLED=true to enable."
+
+    def _resolve_within(self, conversation_id: str, target: str) -> str | None:
+        cwd = self.get_current_directory(conversation_id)
+        return validate_path(target, self._config.allowed_directory, cwd)
+
+    async def change_directory(self, conversation_id: str, target: str) -> CommandResult:
+        disabled = self._ensure_enabled()
+        if disabled:
+            return CommandResult(
+                success=False,
+                stdout="",
+                stderr=disabled,
+                exit_code=1,
+                error="Coder disabled",
+                executed_in=self.get_current_directory(conversation_id),
+            )
+
+        resolved = self._resolve_within(conversation_id, target)
+        if not resolved:
+            return CommandResult(
+                success=False,
+                stdout="",
+                stderr="Cannot navigate outside allowed directory",
+                exit_code=1,
+                error="Permission denied",
+                executed_in=self.get_current_directory(conversation_id),
+            )
+
+        p = Path(resolved)
+        if not p.is_dir():
+            return CommandResult(
+                success=False,
+                stdout="",
+                stderr="Not a directory",
+                exit_code=1,
+                error="Not a directory",
+                executed_in=self.get_current_directory(conversation_id),
+            )
+
+        self._set_current_directory(conversation_id, resolved)
+        return CommandResult(
+            success=True,
+            stdout=f"Changed directory to: {resolved}",
+            stderr="",
+            exit_code=0,
+            executed_in=resolved,
+        )
+
+    async def read_file(self, conversation_id: str, filepath: str) -> tuple[bool, str]:
+        disabled = self._ensure_enabled()
+        if disabled:
+            return False, disabled
+
+        resolved = self._resolve_within(conversation_id, filepath)
+        if not resolved:
+            return False, "Cannot access path outside allowed directory"
+
+        p = Path(resolved)
+        if p.is_dir():
+            return False, "Path is a directory"
+        if not p.exists():
+            return False, "File not found"
+        return True, p.read_text(encoding="utf-8")
+
+    async def write_file(
+        self, conversation_id: str, filepath: str, content: str
+    ) -> tuple[bool, str]:
+        """Write content to a file, creating parent directories as needed."""
+        disabled = self._ensure_enabled()
+        if disabled:
+            return False, disabled
+
+        if not filepath or not filepath.strip():
+            return False, "File path cannot be empty"
+
+        resolved = self._resolve_within(conversation_id, filepath)
+        if not resolved:
+            return False, "Cannot access path outside allowed directory"
+
+        p = Path(resolved)
+        if p.parent != Path(resolved).parent or str(p.parent):
+            p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_text(content, encoding="utf-8")
+        return True, ""
+
+    async def edit_file(
+        self, conversation_id: str, filepath: str, old_str: str, new_str: str
+    ) -> tuple[bool, str]:
+        disabled = self._ensure_enabled()
+        if disabled:
+            return False, disabled
+
+        resolved = self._resolve_within(conversation_id, filepath)
+        if not resolved:
+            return False, "Cannot access path outside allowed directory"
+
+        p = Path(resolved)
+        if not p.exists():
+            return False, "File not found"
+        content = p.read_text(encoding="utf-8")
+        if old_str not in content:
+            return False, "Could not find old_str in file"
+        p.write_text(content.replace(old_str, new_str, 1), encoding="utf-8")
+        return True, ""
+
+    async def list_files(self, conversation_id: str, dirpath: str) -> tuple[bool, list[str] | str]:
+        disabled = self._ensure_enabled()
+        if disabled:
+            return False, disabled
+
+        resolved = self._resolve_within(conversation_id, dirpath)
+        if not resolved:
+            return False, "Cannot access path outside allowed directory"
+
+        p = Path(resolved)
+        if not p.exists():
+            return False, "Directory not found"
+        if not p.is_dir():
+            return False, "Not a directory"
+
+        items: list[str] = []
+        for child in sorted(p.iterdir(), key=lambda x: x.name):
+            if child.name.startswith("."):
+                continue
+            items.append(f"{child.name}/" if child.is_dir() else child.name)
+        return True, items
+
+    async def search_files(
+        self, conversation_id: str, pattern: str, dirpath: str, max_matches: int
+    ) -> tuple[bool, list[SearchMatch] | str]:
+        disabled = self._ensure_enabled()
+        if disabled:
+            return False, disabled
+
+        needle = pattern.strip()
+        if not needle:
+            return False, "Missing pattern"
+
+        resolved = self._resolve_within(conversation_id, dirpath)
+        if not resolved:
+            return False, "Cannot access path outside allowed directory"
+
+        limit = max(1, min(500, int(max_matches))) if max_matches > 0 else 50
+        matches: list[SearchMatch] = []
+        await self._search_dir(Path(resolved), needle.lower(), matches, limit)
+        return True, matches
+
+    async def _search_dir(
+        self, dirpath: Path, needle_lower: str, matches: list[SearchMatch], limit: int
+    ) -> None:
+        if len(matches) >= limit:
+            return
+        for entry in sorted(dirpath.iterdir(), key=lambda x: x.name):
+            if len(matches) >= limit:
+                break
+            if entry.name.startswith("."):
+                continue
+            if entry.is_dir():
+                if entry.name in {"node_modules", "dist", "build", "coverage", ".git"}:
+                    continue
+                await self._search_dir(entry, needle_lower, matches, limit)
+                continue
+            if not entry.is_file():
+                continue
+            try:
+                text = entry.read_text(encoding="utf-8")
+            except UnicodeDecodeError:
+                continue
+            for idx, line in enumerate(text.splitlines(), start=1):
+                if len(matches) >= limit:
+                    break
+                if needle_lower in line.lower():
+                    matches.append(
+                        SearchMatch(
+                            file=str(entry.relative_to(Path(self.allowed_directory))),
+                            line=idx,
+                            content=line.strip()[:240],
+                        )
+                    )
+
+    async def execute_shell(self, conversation_id: str, command: str) -> CommandResult:
+        disabled = self._ensure_enabled()
+        if disabled:
+            return CommandResult(
+                success=False,
+                stdout="",
+                stderr=disabled,
+                exit_code=1,
+                error="Coder disabled",
+                executed_in=self.get_current_directory(conversation_id),
+            )
+
+        trimmed = command.strip()
+        if not trimmed:
+            return CommandResult(
+                success=False,
+                stdout="",
+                stderr="Invalid command",
+                exit_code=1,
+                error="Empty command",
+                executed_in=self.get_current_directory(conversation_id),
+            )
+
+        if not is_safe_command(trimmed):
+            return CommandResult(
+                success=False,
+                stdout="",
+                stderr="Command contains forbidden patterns",
+                exit_code=1,
+                error="Security policy violation",
+                executed_in=self.get_current_directory(conversation_id),
+            )
+
+        if is_forbidden_command(trimmed, self._config.forbidden_commands):
+            return CommandResult(
+                success=False,
+                stdout="",
+                stderr="Command is forbidden by security policy",
+                exit_code=1,
+                error="Forbidden command",
+                executed_in=self.get_current_directory(conversation_id),
+            )
+
+        cwd = self.get_current_directory(conversation_id)
+        use_shell = any(ch in trimmed for ch in [">", "<", "|"])
+        try:
+            if use_shell:
+                cmd_args = ["sh", "-c", trimmed]
+            else:
+                cmd_args = shlex.split(trimmed)
+
+            timeout_seconds = self._config.timeout_ms / 1000.0
+            proc = await asyncio.wait_for(
+                asyncio.create_subprocess_exec(
+                    *cmd_args,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    cwd=cwd,
+                ),
+                timeout=timeout_seconds,
+            )
+            stdout_b, stderr_b = await asyncio.wait_for(
+                proc.communicate(),
+                timeout=timeout_seconds,
+            )
+            stdout = stdout_b.decode("utf-8", errors="replace")
+            stderr = stderr_b.decode("utf-8", errors="replace")
+            result = CommandResult(
+                success=proc.returncode == 0,
+                stdout=stdout,
+                stderr=stderr,
+                exit_code=proc.returncode,
+                executed_in=cwd,
+            )
+            self._add_history(conversation_id, trimmed, result)
+            return result
+        except TimeoutError:
+            result = CommandResult(
+                success=False,
+                stdout="",
+                stderr="Command timed out",
+                exit_code=None,
+                error="Command execution timeout",
+                executed_in=cwd,
+            )
+            self._add_history(conversation_id, trimmed, result)
+            return result
+
+    async def git(self, conversation_id: str, args: str) -> CommandResult:
+        return await self.execute_shell(conversation_id, f"git {args}")

elizaos_plugin_code-2.0.0a4/elizaos_plugin_eliza_coder/types.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal
+
+
+@dataclass(frozen=True)
+class CoderConfig:
+    enabled: bool
+    allowed_directory: str
+    timeout_ms: int
+    forbidden_commands: list[str]
+
+
+FileOperationType = Literal["read", "write", "edit", "list", "search"]
+
+
+@dataclass(frozen=True)
+class FileOperation:
+    type: FileOperationType
+    target: str
+
+
+@dataclass(frozen=True)
+class CommandResult:
+    success: bool
+    stdout: str
+    stderr: str
+    exit_code: int | None
+    executed_in: str
+    error: str | None = None
+
+
+@dataclass(frozen=True)
+class CommandHistoryEntry:
+    timestamp: float
+    working_directory: str
+    command: str
+    stdout: str
+    stderr: str
+    exit_code: int | None
+    file_operations: list[FileOperation] | None = None

elizaos_plugin_code-2.0.0a4/pyproject.toml

@@ -0,0 +1,79 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "elizaos-plugin-code"
+version = "2.0.0a4"
+description = "elizaOS Coder Plugin - filesystem + shell + git (restricted)"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.11"
+authors = [{ name = "elizaOS Contributors" }]
+keywords = ["ai", "agents", "coding", "filesystem", "shell", "git", "elizaos"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Typing :: Typed",
+]
+dependencies = ["pydantic>=2.10.0"]
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=8.0.0",
+  "pytest-asyncio>=0.24.0",
+  "pytest-cov>=6.0.0",
+  "mypy>=1.14.0",
+  "ruff>=0.9.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/elizaos/eliza"
+Repository = "https://github.com/elizaos/eliza"
+
+[tool.hatch.build.targets.wheel]
+packages = ["elizaos_plugin_eliza_coder"]
+
+[tool.hatch.build.targets.sdist]
+include = ["/elizaos_plugin_eliza_coder", "/tests", "/README.md"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = "test_*.py"
+python_functions = "test_*"
+addopts = "-v -p no:anchorpy"
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+
+[tool.mypy]
+python_version = "3.11"
+strict = true
+warn_return_any = true
+warn_unused_ignores = true
+disallow_untyped_defs = true
+disallow_incomplete_defs = true
+check_untyped_defs = true
+no_implicit_optional = true
+
+[tool.ruff]
+target-version = "py311"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "W", "F", "I", "B", "C4", "UP", "ANN", "S"]
+ignore = [
+  "E501",
+  "ANN101",
+  "ANN102",
+  "S101",
+  "S603",
+  "S607",
+]
+
+[tool.ruff.lint.isort]
+known-first-party = ["elizaos_plugin_eliza_coder"]
+

elizaos_plugin_code-2.0.0a4/tests/conftest.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import pytest
+
+from elizaos_plugin_eliza_coder.service import CoderService
+
+
+@pytest.fixture
+def tmp_allowed_dir(tmp_path: Path) -> Path:
+    return tmp_path
+
+
+@pytest.fixture
+def coder_env(tmp_allowed_dir: Path) -> None:
+    os.environ["CODER_ENABLED"] = "true"
+    os.environ["CODER_ALLOWED_DIRECTORY"] = str(tmp_allowed_dir)
+    os.environ["CODER_TIMEOUT"] = "30000"
+    os.environ.pop("CODER_FORBIDDEN_COMMANDS", None)
+
+
+@pytest.fixture
+def service(coder_env: None) -> CoderService:
+    # Reads config from env during init.
+    return CoderService()

elizaos_plugin_code-2.0.0a4/tests/test_actions.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from elizaos_plugin_eliza_coder.actions import (
+    ChangeDirectoryAction,
+    EditFileAction,
+    ExecuteShellAction,
+    GitAction,
+    ListFilesAction,
+    ReadFileAction,
+    SearchFilesAction,
+    WriteFileAction,
+)
+from elizaos_plugin_eliza_coder.service import CoderService
+
+
+def _message(text: str) -> dict:
+    return {"content": {"text": text}, "room_id": "room-1", "agent_id": "agent-1"}
+
+
+async def test_write_then_read(service: CoderService) -> None:
+    write = WriteFileAction()
+    res = await write.handler(_message("write"), {"filepath": "a.txt", "content": "hello"}, service)
+    assert res.success
+
+    read = ReadFileAction()
+    res2 = await read.handler(_message('"a.txt"'), {}, service)
+    assert res2.success
+    assert "hello" in res2.text
+
+
+async def test_edit_file(service: CoderService) -> None:
+    write = WriteFileAction()
+    await write.handler(_message("write"), {"filepath": "b.txt", "content": "abc"}, service)
+
+    edit = EditFileAction()
+    res = await edit.handler(
+        _message("edit"),
+        {"filepath": "b.txt", "old_str": "b", "new_str": "B"},
+        service,
+    )
+    assert res.success
+
+    read = ReadFileAction()
+    res2 = await read.handler(_message('"b.txt"'), {}, service)
+    assert "aBc" in res2.text
+
+
+async def test_list_files(service: CoderService) -> None:
+    write = WriteFileAction()
+    await write.handler(_message("write"), {"filepath": "c.txt", "content": "x"}, service)
+
+    ls = ListFilesAction()
+    res = await ls.handler(_message("list"), {"path": "."}, service)
+    assert res.success
+    assert "c.txt" in res.text
+
+
+async def test_search_files(service: CoderService) -> None:
+    write = WriteFileAction()
+    await write.handler(_message("write"), {"filepath": "d.txt", "content": "needle here"}, service)
+
+    search = SearchFilesAction()
+    res = await search.handler(
+        _message("search"),
+        {"pattern": "needle", "path": ".", "max_matches": 50},
+        service,
+    )
+    assert res.success
+    assert "d.txt" in res.text
+
+
+async def test_change_directory_rejects_escape(service: CoderService) -> None:
+    cd = ChangeDirectoryAction()
+    res = await cd.handler(_message("cd"), {"path": ".."}, service)
+    assert not res.success
+
+
+async def test_execute_shell_pwd(service: CoderService) -> None:
+    sh = ExecuteShellAction()
+    res = await sh.handler(_message("shell"), {"command": "pwd"}, service)
+    assert res.success
+
+
+async def test_git_requires_repo(service: CoderService) -> None:
+    g = GitAction()
+    res = await g.handler(_message("git"), {"args": "status"}, service)
+    assert not res.success

elizaos_plugin_code-2.0.0a4/tests/test_provider.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from elizaos_plugin_eliza_coder.providers import CoderStatusProvider
+from elizaos_plugin_eliza_coder.service import CoderService
+
+
+async def test_coder_status_provider(service: CoderService) -> None:
+    provider = CoderStatusProvider()
+    result = await provider.get(
+        {"room_id": "room-1", "agent_id": "agent-1", "content": {"text": ""}}, {}, service
+    )
+    assert result.values["allowedDirectory"] == service.allowed_directory