@scemoon/cdh 1.0.6 → 1.0.7

package/onecode/agent/tools/permissions.py

@@ -1,77 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from enum import Enum
-from pathlib import Path
-from typing import Optional
-
-from onecode.agent.tools.errors import ToolPermissionError
-
-
-class PermissionResult(str, Enum):
-    ALLOW = "allow"
-    DENY = "deny"
-    ASK = "ask"
-
-
-def _resolve_path(p: str | Path) -> Path:
-    return Path(p).expanduser().resolve()
-
-
-def _is_within(child: Path, parent: Path) -> bool:
-    try:
-        child.relative_to(parent)
-        return True
-    except ValueError:
-        return False
-
-
-@dataclass
-class ToolPermissionContext:
-    deny_names: frozenset[str] = field(default_factory=frozenset)
-    deny_prefixes: tuple[str, ...] = ()
-    workspace_root: Optional[Path] = None
-    additional_working_directories: tuple[Path, ...] = ()
-
-    @classmethod
-    def from_iterables(
-        cls,
-        deny_names: list[str] | None = None,
-        deny_prefixes: list[str] | None = None,
-        *,
-        workspace_root: str | Path | None = None,
-        additional_working_directories: list[str | Path] | None = None,
-    ) -> ToolPermissionContext:
-        return cls(
-            deny_names=frozenset(name.lower() for name in (deny_names or [])),
-            deny_prefixes=tuple(prefix.lower() for prefix in (deny_prefixes or [])),
-            workspace_root=_resolve_path(workspace_root) if workspace_root else None,
-            additional_working_directories=tuple(
-                _resolve_path(p) for p in (additional_working_directories or [])
-            ),
-        )
-
-    def blocks_tool(self, tool_name: str) -> bool:
-        lowered = tool_name.lower()
-        return lowered in self.deny_names or any(
-            lowered.startswith(prefix) for prefix in self.deny_prefixes
-        )
-
-    def allowed_roots(self) -> tuple[Path, ...]:
-        roots: list[Path] = []
-        if self.workspace_root is not None:
-            roots.append(self.workspace_root)
-        roots.extend(self.additional_working_directories)
-        return tuple(roots)
-
-    def ensure_path_allowed(self, path: str | Path) -> Path:
-        resolved = _resolve_path(path)
-        roots = self.allowed_roots()
-        if not roots:
-            return resolved
-        if any(_is_within(resolved, root) for root in roots):
-            return resolved
-        roots_str = ", ".join(str(r) for r in roots)
-        raise ToolPermissionError(
-            f"path is outside allowed working directories: {resolved} (allowed: {roots_str})"
-        )

package/onecode/agent/tools/protocol.py

@@ -1,20 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Any, Literal, Optional
-
-
-@dataclass(frozen=True)
-class ToolCall:
-    name: str
-    input: dict[str, Any]
-    tool_use_id: Optional[str] = None
-
-
-@dataclass(frozen=True)
-class ToolResult:
-    name: str
-    output: Any
-    is_error: bool = False
-    tool_use_id: Optional[str] = None
-    content_type: Literal["text", "json"] = "json"

package/onecode/agent/tools/registry.py

@@ -1,201 +0,0 @@
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
-from typing import Any, Callable, Iterable, Mapping
-
-from onecode.agent.tools.errors import ToolInputError, ToolPermissionError
-from onecode.agent.tools.protocol import ToolCall, ToolResult
-from onecode.agent.tools.schema_validation import validate_json_schema
-
-
-@dataclass(frozen=True)
-class ToolSpec:
-    name: str
-    description: str
-    input_schema: Mapping[str, Any]
-    aliases: tuple[str, ...] = ()
-    is_read_only: bool = False
-    is_destructive: bool = False
-    max_result_size_chars: int = 20_000
-
-
-class Tool(ABC):
-    @abstractmethod
-    def spec(self) -> ToolSpec: ...
-
-    @abstractmethod
-    def run(self, tool_input: dict[str, Any]) -> ToolResult: ...
-
-    async def run_async(
-        self, tool_input: dict[str, Any],
-        cancel_check: Callable[[], bool] | None = None,
-    ) -> ToolResult:
-        return self.run(tool_input)
-
-
-class ToolRegistry:
-    def __init__(
-        self,
-        tools: Iterable[Tool] | None = None,
-    ) -> None:
-        self._tools: list[Tool] = []
-        self._by_name: dict[str, Tool] = {}
-        if tools:
-            for tool in tools:
-                self.register(tool)
-
-    def register(self, tool: Tool) -> None:
-        spec = tool.spec()
-        key = spec.name.lower()
-        if key in self._by_name:
-            raise ValueError(f"duplicate tool name: {spec.name}")
-        self._tools.append(tool)
-        self._by_name[key] = tool
-        for alias in spec.aliases:
-            alias_key = alias.lower()
-            if alias_key in self._by_name:
-                raise ValueError(f"duplicate tool alias: {alias}")
-            self._by_name[alias_key] = tool
-
-    def list_specs(self) -> list[ToolSpec]:
-        return [tool.spec() for tool in self._tools]
-
-    def get(self, name: str) -> Tool | None:
-        return self._by_name.get(name.lower())
-
-    def make_openai_schemas(self) -> list[dict]:
-        schemas = []
-        for spec in self.list_specs():
-            schemas.append({
-                "type": "function",
-                "function": {
-                    "name": spec.name,
-                    "description": spec.description,
-                    "parameters": dict(spec.input_schema),
-                },
-            })
-        return schemas
-
-    async def dispatch_async(
-        self,
-        call: ToolCall,
-        cancel_check: Callable[[], bool] | None = None,
-    ) -> ToolResult:
-        tool = self.get(call.name)
-        if tool is None:
-            return ToolResult(
-                name=call.name,
-                output={"error": f"unknown tool: {call.name}"},
-                is_error=True,
-                tool_use_id=call.tool_use_id,
-            )
-        try:
-            spec = tool.spec()
-            validate_json_schema(call.input, spec.input_schema, tool_name=call.name)
-            result = await tool.run_async(call.input, cancel_check=cancel_check)
-            max_chars = spec.max_result_size_chars
-            if max_chars > 0 and isinstance(result.output, str) and len(result.output) > max_chars:
-                result = ToolResult(
-                    name=result.name,
-                    output=result.output[:max_chars]
-                    + f"\n\n[Output truncated to {max_chars} characters]",
-                    is_error=result.is_error,
-                    tool_use_id=result.tool_use_id or call.tool_use_id,
-                    content_type=result.content_type,
-                )
-            if result.tool_use_id is None:
-                return ToolResult(
-                    name=result.name,
-                    output=result.output,
-                    is_error=result.is_error,
-                    tool_use_id=call.tool_use_id,
-                    content_type=result.content_type,
-                )
-            return result
-        except ToolInputError as e:
-            return ToolResult(
-                name=call.name,
-                output={"error": str(e)},
-                is_error=True,
-                tool_use_id=call.tool_use_id,
-            )
-        except ToolPermissionError as e:
-            return ToolResult(
-                name=call.name,
-                output={"error": str(e)},
-                is_error=True,
-                tool_use_id=call.tool_use_id,
-            )
-        except Exception as e:
-            return ToolResult(
-                name=call.name,
-                output={"error": str(e)},
-                is_error=True,
-                tool_use_id=call.tool_use_id,
-            )
-
-    def dispatch(
-        self,
-        call: ToolCall,
-    ) -> ToolResult:
-        tool = self.get(call.name)
-        if tool is None:
-            return ToolResult(
-                name=call.name,
-                output={"error": f"unknown tool: {call.name}"},
-                is_error=True,
-                tool_use_id=call.tool_use_id,
-            )
-        try:
-            spec = tool.spec()
-
-            # Schema validation
-            validate_json_schema(call.input, spec.input_schema, tool_name=call.name)
-
-            # Execute
-            result = tool.run(call.input)
-
-            # Enforce max result size — truncate oversized output so the
-            # context window is not flooded by a single tool result.
-            max_chars = spec.max_result_size_chars
-            if max_chars > 0 and isinstance(result.output, str) and len(result.output) > max_chars:
-                result = ToolResult(
-                    name=result.name,
-                    output=result.output[:max_chars]
-                    + f"\n\n[Output truncated to {max_chars} characters]",
-                    is_error=result.is_error,
-                    tool_use_id=result.tool_use_id or call.tool_use_id,
-                    content_type=result.content_type,
-                )
-
-            if result.tool_use_id is None:
-                return ToolResult(
-                    name=result.name,
-                    output=result.output,
-                    is_error=result.is_error,
-                    tool_use_id=call.tool_use_id,
-                    content_type=result.content_type,
-                )
-            return result
-        except ToolInputError as e:
-            return ToolResult(
-                name=call.name,
-                output={"error": str(e)},
-                is_error=True,
-                tool_use_id=call.tool_use_id,
-            )
-        except ToolPermissionError as e:
-            return ToolResult(
-                name=call.name,
-                output={"error": str(e)},
-                is_error=True,
-                tool_use_id=call.tool_use_id,
-            )
-        except Exception as e:
-            return ToolResult(
-                name=call.name,
-                output={"error": str(e)},
-                is_error=True,
-                tool_use_id=call.tool_use_id,
-            )

package/onecode/agent/tools/sandbox.py

@@ -1,358 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import enum
-import os
-import resource
-import subprocess
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Callable, Optional
-
-
-class SandboxMode(enum.Enum):
-    NONE = "none"
-    BUBBLEWRAP = "bwrap"
-    DOCKER = "docker"
-
-
-@dataclass
-class ResourceLimits:
-    cpu_time: int = 30
-    memory_mb: int = 512
-    max_procs: int = 10
-    max_open_files: int = 100
-    max_pseudo_terminals: int = 0
-
-
-@dataclass
-class SandboxConfig:
-    workspace_root: Path
-    mode: SandboxMode = SandboxMode.NONE
-    resource_limits: ResourceLimits = field(default_factory=ResourceLimits)
-    read_only_bindings: tuple[str, ...] = ("/usr", "/bin", "/lib", "/lib64", "/opt", "/tmp")
-    network_enabled: bool = False
-    env_whitelist: tuple[str, ...] = ("PATH", "HOME", "USER", "TERM", "LANG", "LC_*")
-
-
-class SandboxError(Exception):
-    pass
-
-
-class Sandbox:
-    def __init__(self, config: SandboxConfig):
-        self.config = config
-        self._bwrap_available: Optional[bool] = None
-
-    def _check_bwrap_available(self) -> bool:
-        if self._bwrap_available is not None:
-            return self._bwrap_available
-        try:
-            subprocess.run(["bwrap", "--version"], capture_output=True, check=True)
-            self._bwrap_available = True
-        except (subprocess.CalledProcessError, FileNotFoundError):
-            self._bwrap_available = False
-        return self._bwrap_available
-
-    def _build_bwrap_cmd(self, cmd: str) -> list[str]:
-        ws = str(self.config.workspace_root.resolve())
-
-        bwrap_args = ["bwrap"]
-
-        bwrap_args.extend(["--dev", "/dev"])
-        bwrap_args.extend(["--proc", "/proc"])
-
-        bwrap_args.extend(["--bind", ws, "/workspace"])
-
-        for ro_path in self.config.read_only_bindings:
-            p = Path(ro_path)
-            if p.exists():
-                bwrap_args.extend(["--ro-bind", str(p), str(p)])
-
-        bwrap_args.extend(["--tmpfs", "/tmp"])
-        bwrap_args.extend(["--tmpfs", "/var/tmp"])
-
-        if not self.config.network_enabled:
-            bwrap_args.append("--unshare-net")
-
-        bwrap_args.extend(["--uid", str(os.getuid())])
-        bwrap_args.extend(["--gid", str(os.getgid())])
-
-        bwrap_args.extend(["--setenv", "HOME", "/workspace"])
-        bwrap_args.extend(["--setenv", "PATH", "/usr/local/sbin:/usr/local/bin:/usr/bin:/bin"])
-
-        bwrap_args.extend(["--chdir", "/workspace"])
-
-        bwrap_args.extend(["--", "sh", "-c", cmd])
-
-        return bwrap_args
-
-    def _set_resource_limits(self) -> None:
-        """Deprecated: applied rlimits to the parent process which broke
-        ``subprocess.run``.  Kept as a no-op for backward compatibility —
-        use :meth:`_exec_direct` (which now applies the limits in a
-        ``preexec_fn``) instead.
-        """
-        return
-
-    def exec(self, cmd: str, timeout: int = 60) -> dict:
-        """Public entry point — dispatches to the right backend for the mode."""
-        mode = self.config.mode
-
-        if mode == SandboxMode.NONE:
-            return self._exec_direct(cmd, timeout)
-        if mode == SandboxMode.BUBBLEWRAP:
-            if self._check_bwrap_available():
-                return self._exec_bwrap(cmd, timeout)
-            return self._exec_direct(cmd, timeout)
-        if mode == SandboxMode.DOCKER:
-            return self._exec_docker(cmd, timeout)
-        return self._exec_direct(cmd, timeout)
-
-    async def exec_async(
-        self, cmd: str, timeout: int = 60,
-        cancel_check: Callable[[], bool] | None = None,
-    ) -> dict:
-        """Async public entry point — supports cancellation mid-execution."""
-        mode = self.config.mode
-
-        if mode == SandboxMode.NONE:
-            return await self._exec_direct_async(cmd, timeout, cancel_check)
-        if mode == SandboxMode.BUBBLEWRAP:
-            if self._check_bwrap_available():
-                return await self._exec_bwrap_async(cmd, timeout, cancel_check)
-            return await self._exec_direct_async(cmd, timeout, cancel_check)
-        if mode == SandboxMode.DOCKER:
-            # Docker exec is async-adaptable via docker-py, but keep sync for now
-            return self._exec_docker(cmd, timeout)
-        return await self._exec_direct_async(cmd, timeout, cancel_check)
-
-    def _exec_direct(self, cmd: str, timeout: int) -> dict:
-        # Apply resource limits in the *child* process only — calling
-        # ``setrlimit`` on the parent (this Python interpreter) shrinks
-        # its own address space, which then fails with ``EAGAIN`` on the
-        # very next ``fork``/``execve`` that ``subprocess.run`` performs.
-        limits = self.config.resource_limits
-
-        def _preexec_apply_rlimits() -> None:  # pragma: no cover (runs in child)
-            try:
-                resource.setrlimit(
-                    resource.RLIMIT_CPU, (limits.cpu_time, limits.cpu_time + 5)
-                )
-            except (ValueError, OSError, resource.error):
-                pass
-            try:
-                mem_bytes = limits.memory_mb * 1024 * 1024
-                resource.setrlimit(
-                    resource.RLIMIT_AS, (mem_bytes, mem_bytes)
-                )
-            except (ValueError, OSError, resource.error):
-                pass
-        try:
-            result = subprocess.run(
-                cmd,
-                shell=True,
-                capture_output=True,
-                text=True,
-                cwd=str(self.config.workspace_root),
-                timeout=timeout,
-                preexec_fn=_preexec_apply_rlimits,
-            )
-            return {
-                "success": result.returncode == 0,
-                "stdout": result.stdout,
-                "stderr": result.stderr,
-                "returncode": result.returncode,
-                "sandbox": "none",
-            }
-        except subprocess.TimeoutExpired:
-            return {"success": False, "error": "Command timed out", "sandbox": "none"}
-        except Exception as e:
-            return {"success": False, "error": str(e), "sandbox": "none"}
-
-    async def _exec_direct_async(
-        self, cmd: str, timeout: int,
-        cancel_check: Callable[[], bool] | None = None,
-    ) -> dict:
-        limits = self.config.resource_limits
-
-        def _preexec_apply_rlimits() -> None:
-            try:
-                resource.setrlimit(
-                    resource.RLIMIT_CPU, (limits.cpu_time, limits.cpu_time + 5)
-                )
-            except (ValueError, OSError, resource.error):
-                pass
-            try:
-                mem_bytes = limits.memory_mb * 1024 * 1024
-                resource.setrlimit(
-                    resource.RLIMIT_AS, (mem_bytes, mem_bytes)
-                )
-            except (ValueError, OSError, resource.error):
-                pass
-        process = await asyncio.create_subprocess_shell(
-            cmd,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-            cwd=str(self.config.workspace_root),
-            preexec_fn=_preexec_apply_rlimits,
-        )
-        try:
-            if cancel_check is not None and cancel_check():
-                process.terminate()
-                await process.wait()
-                return {"success": False, "error": "Cancelled", "sandbox": "none"}
-            stdout, stderr = await asyncio.wait_for(
-                process.communicate(), timeout=timeout,
-            )
-            stdout = stdout.decode("utf-8", errors="replace") if isinstance(stdout, bytes) else stdout
-            stderr = stderr.decode("utf-8", errors="replace") if isinstance(stderr, bytes) else stderr
-            return {
-                "success": process.returncode == 0,
-                "stdout": stdout,
-                "stderr": stderr,
-                "returncode": process.returncode,
-                "sandbox": "none",
-            }
-        except asyncio.TimeoutError:
-            process.terminate()
-            await process.wait()
-            return {"success": False, "error": "Command timed out", "sandbox": "none"}
-        except Exception as e:
-            process.terminate()
-            await process.wait()
-            return {"success": False, "error": str(e), "sandbox": "none"}
-
-    async def _exec_bwrap_async(
-        self, cmd: str, timeout: int,
-        cancel_check: Callable[[], bool] | None = None,
-    ) -> dict:
-        bwrap_cmd = self._build_bwrap_cmd(cmd)
-        process = await asyncio.create_subprocess_exec(
-            *bwrap_cmd,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-            cwd=str(self.config.workspace_root),
-        )
-        try:
-            if cancel_check is not None and cancel_check():
-                process.terminate()
-                await process.wait()
-                return {"success": False, "error": "Cancelled", "sandbox": "bwrap"}
-            stdout, stderr = await asyncio.wait_for(
-                process.communicate(), timeout=timeout,
-            )
-            stdout = stdout.decode("utf-8", errors="replace") if isinstance(stdout, bytes) else stdout
-            stderr = stderr.decode("utf-8", errors="replace") if isinstance(stderr, bytes) else stderr
-            return {
-                "success": process.returncode == 0,
-                "stdout": stdout,
-                "stderr": stderr,
-                "returncode": process.returncode,
-                "sandbox": "bwrap",
-            }
-        except asyncio.TimeoutError:
-            process.terminate()
-            await process.wait()
-            return {"success": False, "error": "Command timed out", "sandbox": "bwrap"}
-        except Exception as e:
-            process.terminate()
-            await process.wait()
-            return {"success": False, "error": str(e), "sandbox": "bwrap"}
-
-    def _exec_bwrap(self, cmd: str, timeout: int) -> dict:
-        bwrap_cmd = self._build_bwrap_cmd(cmd)
-
-        try:
-            result = subprocess.run(
-                bwrap_cmd,
-                capture_output=True,
-                text=True,
-                cwd=str(self.config.workspace_root),
-                timeout=timeout,
-            )
-            return {
-                "success": result.returncode == 0,
-                "stdout": result.stdout,
-                "stderr": result.stderr,
-                "returncode": result.returncode,
-                "sandbox": "bwrap",
-            }
-        except subprocess.TimeoutExpired:
-            return {"success": False, "error": "Command timed out", "sandbox": "bwrap"}
-        except FileNotFoundError:
-            return {"success": False, "error": "bwrap not installed", "sandbox": "bwrap"}
-        except Exception as e:
-            return {"success": False, "error": str(e), "sandbox": "bwrap"}
-
-    def _exec_docker(self, cmd: str, timeout: int) -> dict:
-        import docker
-
-        ws = str(self.config.workspace_root.resolve())
-
-        docker_cmd = [
-            "sh", "-c",
-            f"cd /workspace && {cmd}"
-        ]
-
-        try:
-            client = docker.from_env()
-            container = client.containers.run(
-                "alpine:latest",
-                docker_cmd,
-                detach=True,
-                mem_limit=f"{self.config.resource_limits.memory_mb}m",
-                cpu_period=100000,
-                cpu_quota=self.config.resource_limits.cpu_time * 1000,
-                network_mode="none" if not self.config.network_enabled else "bridge",
-                volumes={ws: {"bind": "/workspace", "mode": "rw"}},
-                working_dir="/workspace",
-                user=f"{os.getuid()}:{os.getgid()}",
-                remove=True,
-            )
-            result = container.wait(timeout=timeout)
-            logs = container.logs().decode("utf-8", errors="replace")
-            return {
-                "success": result["StatusCode"] == 0,
-                "stdout": logs,
-                "stderr": "",
-                "returncode": result["StatusCode"],
-                "sandbox": "docker",
-            }
-        except docker.errors.DockerException:
-            return {"success": False, "error": "Docker not available", "sandbox": "docker"}
-        except docker.errors.TimeoutError:
-            return {"success": False, "error": "Container timed out", "sandbox": "docker"}
-        except Exception as e:
-            return {"success": False, "error": str(e), "sandbox": "docker"}
-
-
-def create_sandbox(
-    workspace_root: Path,
-    mode: str = "auto",
-    **kwargs,
-) -> Sandbox:
-    if mode == "auto":
-        sandbox_mode = SandboxMode.NONE
-        if Path("/usr/bin/bwrap").exists():
-            sandbox_mode = SandboxMode.BUBBLEWRAP
-        elif Path("/var/run/docker.sock").exists():
-            try:
-                subprocess.run(["docker", "info"], capture_output=True, check=True)
-                sandbox_mode = SandboxMode.DOCKER
-            except (subprocess.CalledProcessError, FileNotFoundError):
-                pass
-    elif mode == "bwrap":
-        sandbox_mode = SandboxMode.BUBBLEWRAP
-    elif mode == "docker":
-        sandbox_mode = SandboxMode.DOCKER
-    else:
-        sandbox_mode = SandboxMode.NONE
-
-    config = SandboxConfig(
-        workspace_root=workspace_root,
-        mode=sandbox_mode,
-        resource_limits=ResourceLimits(**kwargs) if kwargs else ResourceLimits(),
-    )
-
-    return Sandbox(config)