Fix: update agents/sandbox_agent.py

agents/sandbox_agent.py

@@ -1,40 +1,30 @@
 """
-SandboxAgent — HF VSCode Space + local subprocess execution
-Replaces E2B with HuggingFace VS Code Space HTTP API
-Falls back to local subprocess if HF VSCode unavailable
+SandboxAgent — Persistent VS Code sandbox execution (Devin-style)
+Controls file system, terminal, git operations in workspace
 """
 import asyncio
 import json
 import os
+import subprocess
+import tempfile
 from typing import Dict, List, Optional
-
-import httpx
 import structlog
 from .base_agent import BaseAgent
 
 log = structlog.get_logger()
 
-WORKSPACE     = os.environ.get("WORKSPACE_DIR", "/tmp/god_workspace")
-HF_VSCODE_URL = os.environ.get("HF_VSCODE_URL", "")        # e.g. https://user-vscode.hf.space
-HF_TOKEN      = os.environ.get("HF_TOKEN", "")
+WORKSPACE = os.environ.get("WORKSPACE_DIR", "/tmp/god_workspace")
 
 
 class SandboxAgent(BaseAgent):
-    """
-    Sandbox execution agent.
-    Priority: HF VS Code Space HTTP API → local subprocess
-    """
-
     def __init__(self, ws_manager=None, ai_router=None):
         super().__init__("SandboxAgent", ws_manager, ai_router)
         os.makedirs(WORKSPACE, exist_ok=True)
-        self._hf_available: Optional[bool] = None   # lazy probe
-
-    # ─── Router ───────────────────────────────────────────────────────────────
 
     async def run(self, task: str, context: Dict = {}, **kwargs) -> str:
         session_id = kwargs.get("session_id", "")
-        task_id    = kwargs.get("task_id", "")
+        task_id = kwargs.get("task_id", "")
+
         task_lower = task.lower()
 
         if "execute" in task_lower or "run" in task_lower or "terminal" in task_lower:
@@ -42,7 +32,7 @@ class SandboxAgent(BaseAgent):
             return await self.execute(cmd, task_id=task_id, session_id=session_id)
         elif "write file" in task_lower or "create file" in task_lower:
             filename = context.get("filename", "output.txt")
-            content  = context.get("content", "")
+            content = context.get("content", "")
             return await self.write_file(filename, content, task_id=task_id, session_id=session_id)
         elif "read file" in task_lower:
             filename = context.get("filename", "")
@@ -52,70 +42,30 @@ class SandboxAgent(BaseAgent):
         else:
             return await self.execute(task, task_id=task_id, session_id=session_id)
 
-    # ─── HF VS Code Probe ─────────────────────────────────────────────────────
-
-    async def _probe_hf_vscode(self) -> bool:
-        """Check if HF VS Code Space is reachable."""
-        if not HF_VSCODE_URL:
-            return False
-        try:
-            async with httpx.AsyncClient(timeout=5.0) as client:
-                resp = await client.get(f"{HF_VSCODE_URL}/", headers=_hf_headers())
-                return resp.status_code < 500
-        except Exception:
-            return False
-
-    async def _hf_execute(self, command: str) -> str:
-        """Execute command via HF VS Code Space HTTP API."""
-        headers = _hf_headers()
-        payload = {"command": command, "cwd": WORKSPACE}
-        async with httpx.AsyncClient(timeout=60.0) as client:
-            resp = await client.post(
-                f"{HF_VSCODE_URL}/api/execute",
-                headers=headers,
-                json=payload,
-            )
-            resp.raise_for_status()
-            data = resp.json()
-            return data.get("output", data.get("result", str(data)))
-
     # ─── Terminal Execution ───────────────────────────────────────────────────
 
     async def execute(
         self,
         command: str,
         cwd: str = "",
-        timeout: int = 60,
+        timeout: int = 30,
         task_id: str = "",
         session_id: str = "",
     ) -> str:
+        """Execute shell command in sandbox workspace."""
         work_dir = cwd or WORKSPACE
 
         # Safety: block dangerous commands
         blocked = ["rm -rf /", ":(){ :|:& };:", "mkfs", "shutdown", "reboot", "halt", "dd if=/dev/"]
         for b in blocked:
             if b in command:
-                return f"❌ Blocked dangerous command: {command[:60]}"
-
-        await self.emit(task_id, "sandbox_exec", {"command": command[:200], "cwd": work_dir}, session_id)
-
-        # Try HF VS Code first
-        if HF_VSCODE_URL:
-            if self._hf_available is None:
-                self._hf_available = await self._probe_hf_vscode()
-            if self._hf_available:
-                try:
-                    result = await self._hf_execute(command)
-                    await self.emit(task_id, "sandbox_result", {
-                        "source": "hf_vscode", "command": command[:100],
-                        "success": True, "output_length": len(result),
-                    }, session_id)
-                    return result[:4000]
-                except Exception as e:
-                    log.warning("HF VSCode execution failed, falling back to local", error=str(e))
-                    self._hf_available = False
-
-        # Local subprocess fallback
+                return f"❌ Blocked dangerous command: {command[:50]}"
+
+        await self.emit(task_id, "sandbox_exec", {
+            "command": command[:200],
+            "cwd": work_dir,
+        }, session_id)
+
         try:
             proc = await asyncio.create_subprocess_shell(
                 command,
@@ -125,15 +75,17 @@ class SandboxAgent(BaseAgent):
             )
             stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=timeout)
             output = stdout.decode("utf-8", errors="replace")
-            err    = stderr.decode("utf-8", errors="replace")
+            err = stderr.decode("utf-8", errors="replace")
 
-            result = output[:4000]
+            result = output[:3000]
             if err and proc.returncode != 0:
                 result += f"\n⚠️ stderr:\n{err[:500]}"
 
             await self.emit(task_id, "sandbox_result", {
-                "source": "local", "command": command[:100],
-                "exit_code": proc.returncode, "success": proc.returncode == 0,
+                "command": command[:100],
+                "exit_code": proc.returncode,
+                "output_length": len(output),
+                "success": proc.returncode == 0,
             }, session_id)
 
             return result or f"Command executed (exit code: {proc.returncode})"
@@ -144,27 +96,44 @@ class SandboxAgent(BaseAgent):
 
     # ─── File Operations ──────────────────────────────────────────────────────
 
-    async def write_file(self, filename: str, content: str,
-                          task_id: str = "", session_id: str = "") -> str:
+    async def write_file(
+        self,
+        filename: str,
+        content: str,
+        task_id: str = "",
+        session_id: str = "",
+    ) -> str:
+        """Write file to workspace."""
         filepath = os.path.join(WORKSPACE, filename)
         os.makedirs(os.path.dirname(filepath), exist_ok=True)
         try:
             with open(filepath, "w", encoding="utf-8") as f:
                 f.write(content)
             await self.emit(task_id, "file_written", {
-                "filename": filename, "size": len(content),
-                "lines": len(content.split("\n")), "path": filepath,
+                "filename": filename,
+                "size": len(content),
+                "lines": len(content.split("\n")),
+                "path": filepath,
             }, session_id)
-            return f"✅ File written: `{filename}` ({len(content)} chars)"
+            return f"✅ File written: `{filename}` ({len(content)} chars, {len(content.split(chr(10)))} lines)"
         except Exception as e:
             return f"❌ Write failed: {str(e)}"
 
-    async def read_file(self, filename: str, task_id: str = "", session_id: str = "") -> str:
+    async def read_file(
+        self,
+        filename: str,
+        task_id: str = "",
+        session_id: str = "",
+    ) -> str:
+        """Read file from workspace."""
         filepath = os.path.join(WORKSPACE, filename)
         try:
             with open(filepath, "r", encoding="utf-8") as f:
                 content = f.read()
-            await self.emit(task_id, "file_read", {"filename": filename, "size": len(content)}, session_id)
+            await self.emit(task_id, "file_read", {
+                "filename": filename,
+                "size": len(content),
+            }, session_id)
             return content[:5000]
         except FileNotFoundError:
             return f"❌ File not found: {filename}"
@@ -172,76 +141,109 @@ class SandboxAgent(BaseAgent):
             return f"❌ Read failed: {str(e)}"
 
     async def list_files(self, path: str = "") -> List[str]:
+        """List files in workspace."""
         target = os.path.join(WORKSPACE, path) if path else WORKSPACE
-        result = []
         try:
+            result = []
             for root, dirs, files in os.walk(target):
-                dirs[:] = [d for d in dirs if not d.startswith(".") and d not in ("__pycache__", "node_modules")]
+                # Skip hidden and cache dirs
+                dirs[:] = [d for d in dirs if not d.startswith(".") and d != "__pycache__" and d != "node_modules"]
                 for f in files:
                     rel = os.path.relpath(os.path.join(root, f), WORKSPACE)
                     result.append(rel)
-                if len(result) > 200:
+                if len(result) > 100:
                     break
+            return result
         except Exception:
-            pass
-        return result
+            return []
 
     # ─── Git Operations ───────────────────────────────────────────────────────
 
-    async def git_operation(self, task: str, repo_path: str = "",
-                             task_id: str = "", session_id: str = "") -> str:
-        work_dir   = repo_path or WORKSPACE
+    async def git_operation(
+        self,
+        task: str,
+        repo_path: str = "",
+        task_id: str = "",
+        session_id: str = "",
+    ) -> str:
+        """Perform git operations in workspace."""
+        work_dir = repo_path or WORKSPACE
         task_lower = task.lower()
 
         if "clone" in task_lower:
+            # Extract URL
             words = task.split()
-            urls  = [w for w in words if "github.com" in w or "gitlab.com" in w or ".git" in w]
+            urls = [w for w in words if "github.com" in w or "gitlab.com" in w or ".git" in w]
             if urls:
-                return await self.execute(f"git clone {urls[0]}", cwd=WORKSPACE,
-                                          task_id=task_id, session_id=session_id)
+                url = urls[0]
+                return await self.execute(f"git clone {url}", cwd=WORKSPACE, task_id=task_id, session_id=session_id)
             return "❌ No git URL found in task."
+
         elif "commit" in task_lower:
-            msg  = task.replace("commit", "").strip() or "God Agent automated commit"
-            out1 = await self.execute("git add -A", cwd=work_dir, task_id=task_id, session_id=session_id)
-            out2 = await self.execute(f'git commit -m "{msg}"', cwd=work_dir, task_id=task_id, session_id=session_id)
-            return f"{out1}\n{out2}"
+            msg = task.replace("commit", "").strip() or "God Agent automated commit"
+            cmds = [
+                "git add -A",
+                f'git commit -m "{msg}"',
+            ]
+            results = []
+            for cmd in cmds:
+                r = await self.execute(cmd, cwd=work_dir, task_id=task_id, session_id=session_id)
+                results.append(r)
+            return "\n".join(results)
+
         elif "push" in task_lower:
             return await self.execute("git push", cwd=work_dir, task_id=task_id, session_id=session_id)
+
         elif "status" in task_lower:
             return await self.execute("git status", cwd=work_dir, task_id=task_id, session_id=session_id)
+
         elif "log" in task_lower:
             return await self.execute("git log --oneline -10", cwd=work_dir, task_id=task_id, session_id=session_id)
+
         elif "init" in task_lower:
             return await self.execute("git init && git add -A", cwd=work_dir, task_id=task_id, session_id=session_id)
+
         else:
             return await self.execute(task, cwd=work_dir, task_id=task_id, session_id=session_id)
 
     # ─── Package Management ───────────────────────────────────────────────────
 
-    async def install_packages(self, packages: List[str], manager: str = "pip",
-                                task_id: str = "", session_id: str = "") -> str:
+    async def install_packages(
+        self,
+        packages: List[str],
+        manager: str = "pip",
+        task_id: str = "",
+        session_id: str = "",
+    ) -> str:
+        """Install packages in workspace."""
         pkg_str = " ".join(packages)
-        cmds = {"pip": f"pip install {pkg_str}", "npm": f"npm install {pkg_str}",
-                "pnpm": f"pnpm add {pkg_str}"}
-        cmd = cmds.get(manager, f"{manager} install {pkg_str}")
-        await self.emit(task_id, "installing_packages", {"manager": manager, "packages": packages}, session_id)
+        if manager == "pip":
+            cmd = f"pip install {pkg_str}"
+        elif manager == "npm":
+            cmd = f"npm install {pkg_str}"
+        elif manager == "pnpm":
+            cmd = f"pnpm add {pkg_str}"
+        else:
+            cmd = f"{manager} install {pkg_str}"
+
+        await self.emit(task_id, "installing_packages", {
+            "manager": manager,
+            "packages": packages,
+        }, session_id)
         return await self.execute(cmd, task_id=task_id, session_id=session_id)
 
+    # ─── Workspace Info ───────────────────────────────────────────────────────
+
     async def get_workspace_info(self) -> Dict:
+        """Get workspace status."""
         files = await self.list_files()
         try:
             disk = await self.execute("df -h /tmp | tail -1")
         except Exception:
             disk = "N/A"
         return {
-            "path": WORKSPACE, "file_count": len(files),
-            "files": files[:20], "disk_usage": disk,
-            "hf_vscode": {"url": HF_VSCODE_URL, "available": bool(self._hf_available)},
+            "path": WORKSPACE,
+            "file_count": len(files),
+            "files": files[:20],
+            "disk_usage": disk,
         }
-
-
-def _hf_headers() -> Dict:
-    h = {"Content-Type": "application/json"}
-    if HF_TOKEN:
-        h["Authorization"] = f"Bearer {HF_TOKEN}"
-    return h