agentpool 2.1.9__py3-none-any.whl → 2.5.0__py3-none-any.whl

agentpool_server/opencode_server/OPENCODE_UI_TOOLS_COMPLETE.md

@@ -0,0 +1,202 @@
+# OpenCode Tools with UI Metadata Support - Complete List
+
+## ALL OpenCode Tools That Get Special UI Treatment
+
+These are **all** tools registered in OpenCode's UI (`message-part.tsx`) that use metadata for enhanced rendering:
+
+| # | Tool | AgentPool Status | Metadata Fields | UI Feature |
+|---|------|------------------|-----------------|------------|
+| 1 | `read` | ✅ **DONE** | `preview`, `truncated` | Shows file preview, truncation badge |
+| 2 | `list` | ✅ **DONE** | `count`, `truncated` | File count, directory tree |
+| 3 | `glob` | ❌ **MISSING** | `count`, `truncated` | File count, pattern display |
+| 4 | `grep` | ✅ **DONE** | `matches`, `truncated` | Match count badge |
+| 5 | `webfetch` | ❌ **MISSING** | `url`, `format` | URL display, format indicator |
+| 6 | `task` | ❌ **MISSING** | `summary`, `sessionId` | Sub-agent tool list, navigation |
+| 7 | `bash` | ✅ **DONE** | `output`, `exit`, `description` | Live output, exit code, command |
+| 8 | `edit` | ✅ **DONE** | `diff`, `filediff`, `diagnostics` | **Diff viewer**, LSP errors |
+| 9 | `write` | ⚠️ **PARTIAL** | `diagnostics`, `filepath`, `exists` | Code viewer, LSP errors |
+| 10 | `todowrite` | ✅ **DONE** | `todos` | **Interactive checkbox list** |
+| 11 | `question` | ✅ **DONE** | `answers` | **Q&A display** |
+
+---
+
+## Summary
+
+**Total OpenCode UI Tools:** 11  
+**Implemented:** 6 (✅)  
+**Partial:** 1 (⚠️)  
+**Missing:** 4 (❌)
+
+### ✅ Implemented (6/11)
+- `read`, `list`, `grep`, `bash`, `edit`, `todowrite`, `question`
+
+### ⚠️ Partial (1/11)
+- `write` - exists but missing diagnostics integration
+
+### ❌ Missing (4/11)
+1. **`glob`** - File pattern matching (like grep but for filenames)
+2. **`webfetch`** - Fetch web content
+3. **`task`** - Sub-agent execution with tool summary
+4. **`write` diagnostics** - Need LSP integration
+
+---
+
+## Detailed Metadata Specifications
+
+### 1. read ✅
+```typescript
+metadata: {
+  preview: string      // First 20 lines
+  truncated: boolean   // Was content cut off?
+}
+```
+
+### 2. list ✅
+```typescript
+metadata: {
+  count: number        // Total files/dirs
+  truncated: boolean   // Hit max limit?
+}
+```
+
+### 3. glob ❌ NOT IMPLEMENTED
+```typescript
+metadata: {
+  count: number        // Files matched
+  truncated: boolean   // Results limited?
+}
+```
+
+### 4. grep ✅
+```typescript
+metadata: {
+  matches: number      // Match count
+  truncated: boolean   // Results limited?
+}
+```
+
+### 5. webfetch ❌ NOT IMPLEMENTED
+```typescript
+metadata: {
+  url: string          // Target URL
+  format: string       // "markdown" | "html" | "text"
+  timeout?: number     // Request timeout
+}
+```
+
+### 6. task ❌ NOT IMPLEMENTED
+```typescript
+metadata: {
+  summary: Array<{     // Sub-agent's tool calls
+    id: string
+    tool: string
+    state: {
+      status: string
+      title?: string
+    }
+  }>
+  sessionId: string    // For navigation to sub-agent session
+}
+```
+
+### 7. bash ✅
+```typescript
+metadata: {
+  output: string       // Combined stdout+stderr
+  exit: number | null  // Exit code
+  description: string  // Command description
+}
+```
+
+### 8. edit ✅
+```typescript
+metadata: {
+  diff: string         // Unified diff format
+  filediff: {
+    file: string
+    before: string
+    after: string
+    additions: number
+    deletions: number
+  }
+  diagnostics: Record<string, Diagnostic[]>
+}
+```
+
+### 9. write ⚠️ PARTIAL
+```typescript
+metadata: {
+  diagnostics: Record<string, Diagnostic[]>  // ⚠️ Not implemented
+  filepath: string
+  exists: boolean      // Did file exist before?
+}
+```
+
+### 10. todowrite ✅
+```typescript
+metadata: {
+  todos: Array<{
+    content: string
+    status: "completed" | "pending" | "in_progress"
+  }>
+}
+```
+
+### 11. question ✅
+```typescript
+metadata: {
+  answers: Array<Array<string>>  // One array per question
+}
+```
+
+---
+
+## Implementation Priority
+
+### Must Have (P0) - Core Functionality
+- ✅ All filesystem tools: read, list, grep
+- ✅ Basic execution: bash
+- ✅ File editing: edit
+- ✅ Planning: todowrite
+- ✅ Interaction: question
+
+### Should Have (P1) - Enhanced Features
+- ❌ **`glob`** - File pattern search (HIGH - complements grep)
+- ❌ **`task`** - Sub-agent tracking (HIGH - important for delegation)
+- ⚠️ **`write` diagnostics** - LSP integration (MEDIUM)
+
+### Nice to Have (P2) - Optional
+- ❌ **`webfetch`** - Web content (LOW - external dependency)
+
+---
+
+## What's Missing vs OpenCode
+
+OpenCode has these additional tools that we don't implement:
+
+| OpenCode Tool | Purpose | Why Not in AgentPool? |
+|---------------|---------|----------------------|
+| `plan` | Plan management | We use `get_plan`/`set_plan` instead |
+| `todoread` | Read todos | Handled by `get_plan` |
+| `batch` | Parallel tool execution | Generic utility, not core |
+| `multiedit` | Multi-file edits | Advanced feature |
+| `patch` | Apply git patches | Git-specific |
+| `lsp` | LSP queries | We have LSP but not as a tool |
+| `skill` | Execute skills | OpenCode-specific |
+| `codesearch` | Semantic search | Advanced feature |
+| `websearch` | Web search | External service |
+
+**Note:** These are all valid tools but not part of the core UI metadata rendering system.
+
+---
+
+## Next Steps
+
+To achieve 100% OpenCode UI compatibility:
+
+1. **Implement `glob` tool** - File pattern matching with metadata
+2. **Implement `task` tool** - Sub-agent execution tracking
+3. **Add diagnostics to `write`** - LSP integration
+4. **Implement `webfetch`** - Web content fetching (optional)
+
+After these 4 implementations, we'll have **complete** OpenCode UI metadata support!

agentpool_server/opencode_server/__init__.py

@@ -0,0 +1,19 @@
+"""OpenCode-compatible API server.
+
+This module provides a FastAPI-based server that implements the OpenCode API,
+allowing OpenCode SDK clients to interact with AgentPool agents.
+
+Example usage:
+
+    from agentpool_server.opencode_server import OpenCodeServer
+
+    server = OpenCodeServer(port=4096)
+    server.run()
+
+Or programmatically:
+
+    from agentpool_server.opencode_server import create_app
+
+    app = create_app(working_dir="/path/to/project")
+    # Use with uvicorn or other ASGI server
+"""

agentpool_server/opencode_server/command_validation.py

@@ -0,0 +1,172 @@
+"""Shell command validation and security checks.
+
+Provides validation for shell commands to prevent dangerous operations
+like destructive commands, privilege escalation, and path traversal.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+import re
+import shlex
+
+from fastapi import HTTPException
+
+
+# Patterns for dangerous commands that should always be blocked
+DANGEROUS_PATTERNS: list[tuple[re.Pattern[str], str]] = [
+    # Destructive file operations
+    (re.compile(r"\brm\s+(-[a-zA-Z]*)?.*\s+/\s*$"), "rm on root directory"),
+    (re.compile(r"\brm\s+-[a-zA-Z]*r[a-zA-Z]*f.*\s+/"), "recursive force delete"),
+    (re.compile(r"\brm\s+-[a-zA-Z]*f[a-zA-Z]*r.*\s+/"), "recursive force delete"),
+    (re.compile(r"\bmkfs\b"), "filesystem format"),
+    (re.compile(r"\bdd\s+.*of=/dev/"), "direct disk write"),
+    (re.compile(r">\s*/dev/sd[a-z]"), "overwrite disk device"),
+    # Privilege escalation
+    (re.compile(r"\bsudo\b"), "sudo command"),
+    (re.compile(r"\bsu\s+-?\s*$"), "switch user"),
+    (re.compile(r"\bsu\s+root\b"), "switch to root"),
+    (re.compile(r"\bdoas\b"), "doas command"),
+    # Remote code execution patterns
+    (re.compile(r"\bcurl\b.*\|\s*(ba)?sh"), "curl pipe to shell"),
+    (re.compile(r"\bwget\b.*\|\s*(ba)?sh"), "wget pipe to shell"),
+    (re.compile(r"\bcurl\b.*\|\s*python"), "curl pipe to python"),
+    (re.compile(r"\bwget\b.*\|\s*python"), "wget pipe to python"),
+    # Fork bombs and resource exhaustion
+    (re.compile(r":\(\)\s*\{\s*:\|:&\s*\}\s*;"), "fork bomb"),
+    (re.compile(r"\bfork\s*bomb\b", re.IGNORECASE), "fork bomb"),
+    # History/credential theft
+    (re.compile(r">\s*~/.bash_history"), "history manipulation"),
+    (re.compile(r"cat.*\.ssh/"), "SSH key access"),
+    (re.compile(r"cat.*/etc/shadow"), "shadow file access"),
+    # Shutdown/reboot
+    (re.compile(r"\bshutdown\b"), "shutdown command"),
+    (re.compile(r"\breboot\b"), "reboot command"),
+    (re.compile(r"\binit\s+0\b"), "init shutdown"),
+    (re.compile(r"\binit\s+6\b"), "init reboot"),
+]
+
+# Sensitive paths that should not be accessed
+SENSITIVE_PATHS = {
+    "/etc/passwd",
+    "/etc/shadow",
+    "/etc/sudoers",
+    "/etc/ssh",
+    "/root",
+    "~/.ssh",
+    "~/.gnupg",
+    "~/.aws",
+    "~/.config/gcloud",
+}
+
+# Patterns that indicate path traversal attempts
+PATH_TRAVERSAL_PATTERN = re.compile(r"\.\.(/|\\)")
+
+
+def validate_command(command: str, working_dir: str) -> None:
+    """Validate a shell command for security issues.
+
+    Args:
+        command: The shell command to validate.
+        working_dir: The working directory for the command.
+
+    Raises:
+        HTTPException: If the command is dangerous or restricted.
+    """
+    # Check for dangerous patterns
+    for pattern, description in DANGEROUS_PATTERNS:
+        if pattern.search(command):
+            raise HTTPException(
+                status_code=403,
+                detail=f"Command restricted: {description}",
+            )
+
+    # Check for sensitive path access
+    command_lower = command.lower()
+    for sensitive_path in SENSITIVE_PATHS:
+        # Normalize ~ to actual pattern
+        path_pattern = sensitive_path.replace("~", "(/home/[^/]+|~)")
+        if re.search(path_pattern, command_lower):
+            raise HTTPException(
+                status_code=403,
+                detail=f"Command restricted: access to sensitive path {sensitive_path}",
+            )
+
+    # Check for path traversal in the command
+    if PATH_TRAVERSAL_PATTERN.search(command):
+        # Parse the command to check if traversal escapes working_dir
+        _check_path_traversal(command, working_dir)
+
+
+def _check_path_traversal(command: str, working_dir: str) -> None:
+    """Check if command contains path traversal that escapes working directory.
+
+    Args:
+        command: The shell command to check.
+        working_dir: The working directory.
+
+    Raises:
+        HTTPException: If path traversal escapes the working directory.
+    """
+    working_path = Path(working_dir).resolve()
+
+    # Try to extract paths from the command
+    try:
+        tokens = shlex.split(command)
+    except ValueError:
+        # If we can't parse, be conservative
+        tokens = command.split()
+
+    for token in tokens:
+        # Skip flags and operators
+        if token.startswith("-") or token in ("&&", "||", "|", ";", ">", "<", ">>"):
+            continue
+
+        # Check if token looks like a path with traversal
+        if ".." in token:
+            # Resolve the path relative to working_dir
+            try:
+                if token.startswith("/"):
+                    resolved = Path(token).resolve()
+                else:
+                    resolved = (working_path / token).resolve()
+
+                # Check if resolved path is within working_dir
+                try:
+                    resolved.relative_to(working_path)
+                except ValueError:
+                    raise HTTPException(
+                        status_code=403,
+                        detail="Command restricted: path escapes project directory",
+                    ) from None
+            except (OSError, RuntimeError):
+                # Path resolution failed, be conservative and block
+                raise HTTPException(
+                    status_code=403,
+                    detail="Command restricted: invalid path in command",
+                ) from None
+
+
+def validate_workdir(workdir: str | None, project_dir: str) -> None:
+    """Validate that a working directory is within the project.
+
+    Args:
+        workdir: The requested working directory (may be None).
+        project_dir: The project root directory.
+
+    Raises:
+        HTTPException: If workdir escapes the project directory.
+    """
+    if workdir is None:
+        return
+
+    project_path = Path(project_dir).resolve()
+    work_path = Path(workdir).resolve()
+
+    try:
+        work_path.relative_to(project_path)
+    except ValueError:
+        raise HTTPException(
+            status_code=403,
+            detail="Command restricted: working directory outside project",
+        ) from None