aria-code 0.167.0__py3-none-win_amd64.whl

aria_code/workspace_service.py

@@ -0,0 +1,196 @@
+"""Isolated, non-executing source workspaces for remote Aria Code runs."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+import secrets
+import shutil
+import tempfile
+from dataclasses import asdict, dataclass
+from datetime import datetime, timedelta, timezone
+from pathlib import Path, PurePosixPath
+from typing import Any
+
+from aria_code.project_review import (
+    MAX_ARCHIVE_BYTES,
+    MAX_EXTRACTED_BYTES,
+    MAX_FILES,
+    ProjectReviewError,
+    _archive_entries,
+    _is_sensitive,
+    _safe_member_path,
+    _should_ignore,
+)
+from aria_code.workspace import WorkspaceFiles, WorkspaceSecurity
+
+
+_WORKSPACE_ID = re.compile(r"^ws_[a-f0-9]{24}$")
+
+
+class WorkspaceServiceError(ValueError):
+    pass
+
+
+def _now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def _subject_hash(value: str) -> str:
+    return hashlib.sha256(value.strip().encode("utf-8")).hexdigest()
+
+
+@dataclass(frozen=True)
+class WorkspaceManifest:
+    schema_version: str
+    workspace_id: str
+    owner_hash: str
+    run_hash: str
+    archive_name: str
+    file_count: int
+    extracted_bytes: int
+    skipped_sensitive_files: int
+    created_at: str
+    expires_at: str
+    execution_enabled: bool = False
+    network_enabled: bool = False
+
+    def public_dict(self) -> dict[str, Any]:
+        data = asdict(self)
+        data.pop("owner_hash", None)
+        data.pop("run_hash", None)
+        return data
+
+
+class WorkspaceService:
+    """Owns bounded project trees; never executes their contents."""
+
+    def __init__(self, root: str | Path | None = None, ttl_hours: int = 24) -> None:
+        configured = root or os.getenv("ARIA_CODE_WORKSPACE_ROOT")
+        self.root = Path(configured or (Path.home() / ".aria" / "runtime" / "workspaces")).expanduser().resolve()
+        self.ttl_hours = max(1, min(int(ttl_hours), 168))
+        self.root.mkdir(parents=True, exist_ok=True, mode=0o700)
+        try:
+            self.root.chmod(0o700)
+        except OSError:
+            pass
+
+    def _workspace_dir(self, workspace_id: str) -> Path:
+        if not _WORKSPACE_ID.fullmatch(workspace_id):
+            raise WorkspaceServiceError("Invalid workspace id.")
+        target = (self.root / workspace_id).resolve()
+        if target.parent != self.root:
+            raise WorkspaceServiceError("Invalid workspace path.")
+        return target
+
+    @staticmethod
+    def _manifest_path(directory: Path) -> Path:
+        return directory / ".aria-workspace.json"
+
+    def create_from_archive(self, payload: bytes, filename: str, *, owner_id: str, run_id: str) -> WorkspaceManifest:
+        if not owner_id.strip() or not run_id.strip():
+            raise WorkspaceServiceError("owner_id and run_id are required.")
+        if not payload or len(payload) > MAX_ARCHIVE_BYTES:
+            raise WorkspaceServiceError("Project archive is empty or exceeds the upload limit.")
+
+        workspace_id = f"ws_{secrets.token_hex(12)}"
+        final_dir = self._workspace_dir(workspace_id)
+        staging = Path(tempfile.mkdtemp(prefix=f".{workspace_id}-", dir=self.root))
+        source_root = staging / "source"
+        source_root.mkdir(mode=0o700)
+        count = total = skipped_sensitive = 0
+        try:
+            for raw_path, data in _archive_entries(payload, filename):
+                relative = _safe_member_path(raw_path)
+                if _should_ignore(relative):
+                    continue
+                if _is_sensitive(relative):
+                    skipped_sensitive += 1
+                    continue
+                count += 1
+                total += len(data)
+                if count > MAX_FILES or total > MAX_EXTRACTED_BYTES:
+                    raise WorkspaceServiceError("Expanded project exceeds workspace limits.")
+                target = (source_root / Path(*relative.parts)).resolve()
+                if source_root != target and source_root not in target.parents:
+                    raise WorkspaceServiceError("Archive path escapes the workspace.")
+                target.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+                target.write_bytes(data)
+                try:
+                    target.chmod(0o600)
+                except OSError:
+                    pass
+            if count == 0:
+                raise WorkspaceServiceError("No safe project files were found.")
+            created = _now()
+            manifest = WorkspaceManifest(
+                schema_version="aria.workspace.v1",
+                workspace_id=workspace_id,
+                owner_hash=_subject_hash(owner_id),
+                run_hash=_subject_hash(run_id),
+                archive_name=PurePosixPath(filename).name[:180],
+                file_count=count,
+                extracted_bytes=total,
+                skipped_sensitive_files=skipped_sensitive,
+                created_at=created.isoformat(),
+                expires_at=(created + timedelta(hours=self.ttl_hours)).isoformat(),
+            )
+            self._manifest_path(staging).write_text(json.dumps(asdict(manifest), indent=2), encoding="utf-8")
+            staging.rename(final_dir)
+            return manifest
+        except (ProjectReviewError, OSError) as exc:
+            shutil.rmtree(staging, ignore_errors=True)
+            if isinstance(exc, ProjectReviewError):
+                raise WorkspaceServiceError(str(exc)) from exc
+            raise WorkspaceServiceError("Could not create isolated workspace.") from exc
+        except Exception:
+            shutil.rmtree(staging, ignore_errors=True)
+            raise
+
+    def get(self, workspace_id: str, *, owner_id: str) -> WorkspaceManifest:
+        directory = self._workspace_dir(workspace_id)
+        try:
+            raw = json.loads(self._manifest_path(directory).read_text(encoding="utf-8"))
+            manifest = WorkspaceManifest(**raw)
+        except (OSError, TypeError, ValueError, json.JSONDecodeError) as exc:
+            raise WorkspaceServiceError("Workspace not found.") from exc
+        if not secrets.compare_digest(manifest.owner_hash, _subject_hash(owner_id)):
+            # Do not reveal whether another tenant owns the identifier.
+            raise WorkspaceServiceError("Workspace not found.")
+        return manifest
+
+    def files(self, workspace_id: str, *, owner_id: str) -> WorkspaceFiles:
+        self.get(workspace_id, owner_id=owner_id)
+        source_root = self._workspace_dir(workspace_id) / "source"
+        return WorkspaceFiles(WorkspaceSecurity(cwd=source_root, allow_home=False))
+
+    def source_path(self, workspace_id: str, relative_path: str, *, owner_id: str) -> Path:
+        self.get(workspace_id, owner_id=owner_id)
+        source_root = (self._workspace_dir(workspace_id) / "source").resolve()
+        relative = PurePosixPath(str(relative_path or ".").replace("\\", "/"))
+        if relative.is_absolute() or ".." in relative.parts:
+            raise WorkspaceServiceError("Path must stay inside the workspace.")
+        target = (source_root / Path(*relative.parts)).resolve()
+        if target != source_root and source_root not in target.parents:
+            raise WorkspaceServiceError("Path must stay inside the workspace.")
+        return target
+
+    def delete(self, workspace_id: str, *, owner_id: str) -> None:
+        self.get(workspace_id, owner_id=owner_id)
+        shutil.rmtree(self._workspace_dir(workspace_id))
+
+    def cleanup_expired(self, now: datetime | None = None) -> int:
+        threshold = now or _now()
+        removed = 0
+        for directory in self.root.glob("ws_*"):
+            try:
+                raw = json.loads(self._manifest_path(directory).read_text(encoding="utf-8"))
+                expires = datetime.fromisoformat(str(raw["expires_at"]))
+                if expires <= threshold:
+                    shutil.rmtree(directory)
+                    removed += 1
+            except (OSError, KeyError, ValueError, json.JSONDecodeError):
+                continue
+        return removed

aria_code/workspace_tools.py

@@ -0,0 +1,150 @@
+"""Read-only tool profile bound to one isolated remote workspace."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from aria_code.workspace_service import WorkspaceService, WorkspaceServiceError
+from aria_code.workspace_changes import WorkspaceChangeError, WorkspaceChangeService
+
+
+def build_workspace_read_tools(
+    service: WorkspaceService,
+    workspace_id: str,
+    owner_id: str,
+) -> tuple[dict[str, tuple[Any, dict[str, Any]]], list[dict[str, Any]]]:
+    """Return ToolExecutor-compatible handlers without exposing host paths."""
+
+    def read_file(params: dict[str, Any]) -> dict[str, Any]:
+        relative = str(params.get("path") or "")
+        if not relative:
+            return {"success": False, "error": "path is required"}
+        try:
+            target = service.source_path(workspace_id, relative, owner_id=owner_id)
+            result = service.files(workspace_id, owner_id=owner_id).read_file(
+                str(target),
+                offset=max(0, int(params.get("offset") or 0)),
+                limit=max(0, min(int(params.get("limit") or 0), 2000)),
+            )
+            return {"success": True, "path": relative, "lines": result.lines, "content": result.content}
+        except (WorkspaceServiceError, OSError, ValueError) as exc:
+            return {"success": False, "error": str(exc)}
+
+    def list_files(params: dict[str, Any]) -> dict[str, Any]:
+        relative = str(params.get("path") or ".")
+        pattern = str(params.get("pattern") or "*")[:200]
+        try:
+            target = service.source_path(workspace_id, relative, owner_id=owner_id)
+            result = service.files(workspace_id, owner_id=owner_id).list_files(str(target), pattern)
+            result["path"] = relative
+            return {"success": True, **result}
+        except (WorkspaceServiceError, OSError, ValueError) as exc:
+            return {"success": False, "error": str(exc)}
+
+    def search_code(params: dict[str, Any]) -> dict[str, Any]:
+        relative = str(params.get("path") or ".")
+        pattern = str(params.get("pattern") or "")[:500]
+        file_glob = str(params.get("file_glob") or "**/*")[:200]
+        try:
+            target = service.source_path(workspace_id, relative, owner_id=owner_id)
+            result = service.files(workspace_id, owner_id=owner_id).search_code(
+                pattern, str(target), file_glob
+            )
+            result["path"] = relative
+            return {"success": True, **result}
+        except (WorkspaceServiceError, OSError, ValueError) as exc:
+            return {"success": False, "error": str(exc)}
+
+    schemas = [
+        {
+            "type": "function",
+            "function": {
+                "name": "workspace_read_file",
+                "description": "Read a UTF-8 text file inside the assigned project workspace.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "path": {"type": "string"},
+                        "offset": {"type": "integer", "minimum": 0},
+                        "limit": {"type": "integer", "minimum": 0, "maximum": 2000},
+                    },
+                    "required": ["path"],
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "workspace_list_files",
+                "description": "List files below a relative directory in the assigned workspace.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {"path": {"type": "string"}, "pattern": {"type": "string"}},
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "workspace_search_code",
+                "description": "Search project text using a regular expression without executing code.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "pattern": {"type": "string"},
+                        "path": {"type": "string"},
+                        "file_glob": {"type": "string"},
+                    },
+                    "required": ["pattern"],
+                },
+            },
+        },
+    ]
+    handlers = {
+        "workspace_read_file": (read_file, schemas[0]),
+        "workspace_list_files": (list_files, schemas[1]),
+        "workspace_search_code": (search_code, schemas[2]),
+    }
+    return handlers, schemas
+
+
+def build_workspace_proposal_tools(
+    service: WorkspaceService,
+    workspace_id: str,
+    owner_id: str,
+) -> tuple[dict[str, tuple[Any, dict[str, Any]]], list[dict[str, Any]]]:
+    """Expose proposal creation only; applying still requires control-plane approval."""
+    schema = {
+        "type": "function",
+        "function": {
+            "name": "workspace_propose_change",
+            "description": (
+                "Stage a complete UTF-8 file replacement and return its diff. "
+                "This does not modify the project; a user must approve the returned change id."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "path": {"type": "string"},
+                    "content": {"type": "string"},
+                    "expected_sha256": {"type": "string"},
+                },
+                "required": ["path", "content"],
+            },
+        },
+    }
+
+    def propose(params: dict[str, Any]) -> dict[str, Any]:
+        try:
+            change = WorkspaceChangeService(service).propose(
+                workspace_id,
+                owner_id=owner_id,
+                path=str(params.get("path") or ""),
+                content=str(params.get("content") or ""),
+                expected_sha256=(str(params["expected_sha256"]) if params.get("expected_sha256") else None),
+            )
+            return {"success": True, **change.public_dict(), "requires_approval": True}
+        except (WorkspaceChangeError, WorkspaceServiceError, OSError, ValueError) as exc:
+            return {"success": False, "error": str(exc)}
+
+    return {"workspace_propose_change": (propose, schema)}, [schema]