aria-code 0.167.0__py3-none-win_amd64.whl

aria_code/workspace/files.py

@@ -0,0 +1,219 @@
+"""Safe workspace file operations for Aria Code."""
+
+from __future__ import annotations
+
+import pathlib
+import re
+import tempfile
+import os
+from dataclasses import dataclass
+from typing import Any, Dict, List
+
+
+@dataclass(frozen=True)
+class ReadResult:
+    path: str
+    lines: int
+    content: str
+
+
+class WorkspaceSecurity:
+    """Path security policy shared by CLI tools and future runtimes."""
+
+    BLOCKED_ROOTS = (
+        "/etc",
+        "/sys",
+        "/proc",
+        "/dev",
+        "/boot",
+        "/root",
+    )
+
+    def __init__(
+        self,
+        cwd: str | pathlib.Path | None = None,
+        *,
+        allowed_roots: List[str | pathlib.Path] | None = None,
+        write_roots: List[str | pathlib.Path] | None = None,
+        allow_home: bool | None = None,
+    ) -> None:
+        self.cwd = pathlib.Path(cwd or pathlib.Path.cwd()).expanduser().resolve()
+        self._configured_roots = tuple(
+            pathlib.Path(root).expanduser().resolve() for root in (allowed_roots or ())
+        )
+        self._write_roots = tuple(
+            pathlib.Path(root).expanduser().resolve() for root in (write_roots or ())
+        )
+        if allow_home is None:
+            # Local CLI keeps its historical convenience. Remote/API workers must
+            # set ARIA_RUNTIME_SCOPE=remote (or pass allow_home=False) so one user
+            # can never inspect the worker account's home directory.
+            allow_home = os.getenv("ARIA_RUNTIME_SCOPE", "local").strip().lower() != "remote"
+        self.allow_home = bool(allow_home)
+
+    def allowed_roots(self) -> List[pathlib.Path]:
+        roots = [self.cwd, *self._configured_roots, *self._write_roots]
+        if self.allow_home:
+            roots.append(pathlib.Path.home().resolve())
+        # Temporary roots are required by the local CLI, but a remote worker is
+        # confined to its explicitly assigned workspace root.
+        if not self.allow_home:
+            return list(dict.fromkeys(roots))
+        roots.append(pathlib.Path("/tmp").resolve())
+        for tmp_candidate in (
+            "/var/folders",
+            "/private/tmp",
+            "/private/var/folders",
+            "/var/tmp",
+            "/private/var/tmp",
+            tempfile.gettempdir(),
+        ):
+            try:
+                root = pathlib.Path(tmp_candidate).resolve()
+                if root not in roots:
+                    roots.append(root)
+            except Exception:
+                pass
+        return roots
+
+    @classmethod
+    def from_tool_params(cls, params: dict):
+        unrestricted = params.get("_permission_mode") == "full-access" and not params.get("_workspace_restricted")
+        return cls(
+            cwd=params.get("_workspace") or os.getcwd(),
+            allowed_roots=["/"] if unrestricted else params.get("_allowed_read_roots", ()),
+            write_roots=["/"] if unrestricted else params.get("_allowed_write_roots", ()),
+            allow_home=False if params.get("_workspace_restricted") else None,
+        )
+
+    def writable_roots(self) -> List[pathlib.Path]:
+        roots = [self.cwd, *self._write_roots]
+        if self.allow_home:
+            roots += [pathlib.Path("/tmp").resolve(), pathlib.Path(tempfile.gettempdir()).resolve()]
+            try:
+                from aria_code.artifacts import artifact_root, user_output_root
+                roots += [pathlib.Path(artifact_root()).resolve(), pathlib.Path(user_output_root()).resolve()]
+            except ImportError:
+                pass
+        return list(dict.fromkeys(roots))
+
+    def resolve(self, path: str | pathlib.Path) -> pathlib.Path:
+        target = pathlib.Path(path).expanduser()
+        return (target if target.is_absolute() else self.cwd / target).resolve()
+
+    def is_safe_path(self, path: str | pathlib.Path, *, write: bool = False) -> bool:
+        resolved = self.resolve(path)
+        for blocked in self.BLOCKED_ROOTS:
+            try:
+                resolved.relative_to(pathlib.Path(blocked).resolve())
+                return False
+            except ValueError:
+                pass
+        for root in self.writable_roots() if write else self.allowed_roots():
+            try:
+                resolved.relative_to(root)
+                return True
+            except ValueError:
+                pass
+        return False
+
+    def require_safe(self, path: str | pathlib.Path, *, write: bool = False) -> pathlib.Path:
+        resolved = self.resolve(path)
+        if not self.is_safe_path(resolved, write=write):
+            raise PermissionError(f"Access denied: path '{resolved}' is outside allowed directories")
+        return resolved
+
+
+class WorkspaceFiles:
+    """Read, list, and search files under Aria Code's safety policy."""
+
+    MAX_READ_BYTES = 2_000_000
+    LARGE_FILE_BYTES = 500_000
+    LARGE_FILE_DEFAULT_LINES = 500
+    MAX_SEARCH_BYTES = 5_000_000
+
+    def __init__(self, security: WorkspaceSecurity | None = None) -> None:
+        self.security = security or WorkspaceSecurity()
+
+    def read_file(self, path: str, offset: int = 0, limit: int = 0) -> ReadResult:
+        target = self.security.require_safe(path)
+        if not target.exists():
+            raise FileNotFoundError(f"File not found: {target}")
+        if not target.is_file():
+            raise ValueError(f"Not a file: {target}")
+        size = target.stat().st_size
+        if size > self.MAX_READ_BYTES:
+            raise ValueError(
+                f"File too large: {size:,} bytes (max 2 MB). "
+                "Use offset/limit parameters to read sections."
+            )
+        text = target.read_text(encoding="utf-8", errors="replace")
+        lines = text.splitlines()
+        total_lines = len(lines)
+        if not offset and not limit and size > self.LARGE_FILE_BYTES:
+            limit = self.LARGE_FILE_DEFAULT_LINES
+        if offset or limit:
+            end = offset + limit if limit else total_lines
+            shown = lines[offset:end]
+            content = "\n".join(f"{i + offset + 1:4d}│ {line}" for i, line in enumerate(shown))
+            if limit and end < total_lines:
+                content += f"\n... [{len(shown)} of {total_lines} lines shown — use offset/limit to read more]"
+            return ReadResult(str(target), len(shown), content[:30000])
+        content = "\n".join(f"{i + 1:4d}│ {line}" for i, line in enumerate(lines))
+        return ReadResult(str(target), len(lines), content[:30000])
+
+    def list_files(self, path: str = ".", pattern: str = "*") -> Dict[str, Any]:
+        target = self.security.require_safe(path)
+        if not target.exists():
+            raise FileNotFoundError(f"Path not found: {target}")
+        if target.is_file():
+            read = self.read_file(str(target))
+            return {
+                "path": read.path,
+                "pattern": pattern,
+                "count": 1,
+                "items": [{"name": target.name, "type": "file", "size": target.stat().st_size}],
+                "content": read.content,
+            }
+        matches = sorted(target.glob(pattern))[:100]
+        items = []
+        for match in matches:
+            try:
+                self.security.require_safe(match)
+            except PermissionError:
+                continue
+            rel = match.relative_to(target) if match.is_relative_to(target) else match
+            kind = "dir" if match.is_dir() else "file"
+            size = match.stat().st_size if match.is_file() else 0
+            items.append({"name": str(rel), "type": kind, "size": size})
+        return {"path": str(target), "pattern": pattern, "count": len(items), "items": items}
+
+    def search_code(self, pattern: str, path: str = ".", file_glob: str = "**/*.py") -> Dict[str, Any]:
+        if not pattern:
+            raise ValueError("Missing 'pattern' parameter")
+        target = self.security.require_safe(path)
+        regex = re.compile(pattern, re.IGNORECASE)
+        matches = []
+        for file_path in sorted(target.glob(file_glob))[:200]:
+            try:
+                safe_file = self.security.require_safe(file_path)
+            except PermissionError:
+                continue
+            if not safe_file.is_file() or safe_file.stat().st_size > self.MAX_SEARCH_BYTES:
+                continue
+            try:
+                lines = safe_file.read_text(encoding="utf-8", errors="replace").splitlines()
+            except Exception:
+                continue
+            for line_number, line in enumerate(lines, 1):
+                if regex.search(line):
+                    matches.append({
+                        "file": str(safe_file.relative_to(target) if safe_file.is_relative_to(target) else safe_file),
+                        "line": line_number,
+                        "content": line.strip()[:200],
+                    })
+                    if len(matches) >= 50:
+                        break
+            if len(matches) >= 50:
+                break
+        return {"pattern": pattern, "path": str(target), "count": len(matches), "matches": matches}

aria_code/workspace/verify.py

@@ -0,0 +1,167 @@
+"""Verification planning for Aria Code workspaces."""
+
+from __future__ import annotations
+
+import ast
+import json
+import os
+import pathlib
+import shlex
+import subprocess
+from dataclasses import dataclass
+from typing import Iterable, List
+
+
+@dataclass(frozen=True)
+class VerificationPlan:
+    commands: List[str]
+    reason: str
+
+
+class VerificationPlanner:
+    """Infer focused verification commands from changed files and project files."""
+
+    def __init__(self, root: str | pathlib.Path = ".") -> None:
+        self.root = pathlib.Path(root).expanduser().resolve()
+
+    def infer(self, paths: Iterable[str] | None = None) -> VerificationPlan:
+        changed = [p for p in (paths or []) if p]
+        if not changed:
+            changed = self._git_changed_files()
+        commands: List[str] = []
+        reasons: List[str] = []
+
+        py_files = [p for p in changed if p.endswith(".py")]
+        if py_files:
+            quoted = " ".join(shlex.quote(p) for p in py_files[:20])
+            commands.append(f"python3 -m py_compile {quoted}")
+            reasons.append("Python files changed")
+            if (self._has_any("pytest.ini", "pyproject.toml", "setup.cfg", "tox.ini")
+                    or (self.root / "tests").exists() or self._has_python_tests()):
+                commands.append(self._python_test_command())
+
+        frontend_files = [
+            p for p in changed
+            if p.endswith((".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".css"))
+        ]
+        if frontend_files and (self.root / "package.json").exists():
+            scripts = self._package_scripts()
+            reasons.append("Node/TypeScript files changed")
+            if "test" in scripts:
+                commands.append("npm test")
+            if "build" in scripts:
+                commands.append("npm run build")
+            elif (self.root / "tsconfig.json").exists():
+                commands.append("npx tsc --noEmit")
+
+        if not commands:
+            if (self.root / "pyproject.toml").exists() or (self.root / "tests").exists():
+                commands.append(self._python_test_command())
+                reasons.append("Python project detected")
+            elif (self.root / "package.json").exists():
+                scripts = self._package_scripts()
+                if "test" in scripts:
+                    commands.append("npm test")
+                    reasons.append("Node project detected")
+                elif "build" in scripts:
+                    commands.append("npm run build")
+                    reasons.append("Node project detected")
+
+        deduped = list(dict.fromkeys(commands))
+        reason = "; ".join(dict.fromkeys(reasons)) if reasons else "No focused check inferred"
+        return VerificationPlan(deduped, reason)
+
+    def _has_python_tests(self) -> bool:
+        """Test files beside the code count as a test suite.
+
+        Small projects and scripts keep `test_x.py` next to `x.py`, with no config
+        file and no `tests/` directory. Without this they were "verified" by
+        `py_compile` alone, which only says the syntax is valid; the acceptance
+        gate then reported a fix as verified without ever running its tests.
+        """
+        skip = {".git", "node_modules", ".venv", "venv", "env", "__pycache__", "build", "dist", "site-packages"}
+        for current, dirs, files in os.walk(self.root):
+            depth = len(pathlib.Path(current).relative_to(self.root).parts)
+            dirs[:] = [d for d in dirs if d not in skip and not d.startswith(".")] if depth < 2 else []
+            if any(f.startswith("test_") and f.endswith(".py") or f.endswith("_test.py") or f == "conftest.py"
+                   for f in files):
+                return True
+        return False
+
+    def _has_any(self, *names: str) -> bool:
+        return any((self.root / name).exists() for name in names)
+
+    def _python_test_command(self) -> str:
+        """Choose the project's runner without importing its test code.
+
+        A tests directory does not imply pytest. For a stdlib unittest project,
+        forcing pytest makes the agent install an unnecessary dependency just
+        to satisfy the acceptance gate.
+        """
+        for path in (self.root / "pytest.ini", self.root / "pyproject.toml", self.root / "setup.cfg"):
+            if path.is_file():
+                text = path.read_text(encoding="utf-8", errors="replace")
+                if path.name == "pytest.ini" or "[tool.pytest" in text or "[tool:pytest]" in text:
+                    return "python3 -m pytest -q"
+        tests_root = self.root / "tests" if (self.root / "tests").is_dir() else self.root
+        candidates = (list(tests_root.glob("**/test*.py"))[:100] if tests_root != self.root
+                      else (list(self.root.glob("test*.py")) + list(self.root.glob("*_test.py")))[:100])
+        uses_unittest = False
+        for path in candidates:
+            try:
+                tree = ast.parse(path.read_text(encoding="utf-8"))
+            except (OSError, SyntaxError, UnicodeError):
+                return "python3 -m pytest -q"
+            for node in ast.walk(tree):
+                modules = ([alias.name.split(".")[0] for alias in node.names] if isinstance(node, ast.Import)
+                           else [str(node.module or "").split(".")[0]] if isinstance(node, ast.ImportFrom) else [])
+                if "pytest" in modules:
+                    return "python3 -m pytest -q"
+                uses_unittest |= "unittest" in modules
+            if any(isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and node.name.startswith("test") for node in tree.body):
+                return "python3 -m pytest -q"
+        if uses_unittest:
+            directory = "tests" if tests_root != self.root else "."
+            return f"python3 -m unittest discover -s {directory} -v"
+        return "python3 -m pytest -q"
+
+    def _package_scripts(self) -> dict:
+        try:
+            data = json.loads((self.root / "package.json").read_text(encoding="utf-8"))
+            return data.get("scripts", {}) if isinstance(data.get("scripts", {}), dict) else {}
+        except Exception:
+            return {}
+
+    def _git_changed_files(self) -> List[str]:
+        try:
+            proc = subprocess.run(
+                ["git", "diff", "--name-only", "HEAD"],
+                cwd=self.root,
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
+            )
+            if proc.returncode == 0 and proc.stdout.strip():
+                return [line.strip() for line in proc.stdout.splitlines() if line.strip()]
+        except Exception:
+            pass
+        try:
+            proc = subprocess.run(
+                ["git", "status", "--short"],
+                cwd=self.root,
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
+            )
+            if proc.returncode != 0:
+                return []
+            files = []
+            for line in proc.stdout.splitlines():
+                if not line.strip():
+                    continue
+                files.append(line[3:].strip())
+            return files
+        except Exception:
+            return []

aria_code/workspace_changes.py

@@ -0,0 +1,199 @@
+"""Approval-ready text changes for isolated Aria Code workspaces."""
+
+from __future__ import annotations
+
+import difflib
+import hashlib
+import json
+import os
+import secrets
+import tempfile
+from dataclasses import asdict, dataclass
+from datetime import datetime, timezone
+from pathlib import Path, PurePosixPath
+from typing import Any
+
+from aria_code.project_review import _is_sensitive
+from aria_code.workspace_service import WorkspaceService, WorkspaceServiceError
+
+
+MAX_CHANGE_BYTES = 1 * 1024 * 1024
+MAX_DIFF_CHARS = 120_000
+
+
+class WorkspaceChangeError(ValueError):
+    pass
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _digest(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest()
+
+
+@dataclass(frozen=True)
+class WorkspaceChange:
+    schema_version: str
+    change_id: str
+    workspace_id: str
+    path: str
+    operation: str
+    status: str
+    base_sha256: str
+    proposed_sha256: str
+    created_at: str
+    updated_at: str
+    diff: str
+
+    def public_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+class WorkspaceChangeService:
+    """Stages text changes outside the source tree until approval is verified."""
+
+    def __init__(self, workspaces: WorkspaceService) -> None:
+        self.workspaces = workspaces
+
+    def _change_root(self, workspace_id: str) -> Path:
+        root = self.workspaces._workspace_dir(workspace_id) / ".aria-changes"
+        root.mkdir(mode=0o700, exist_ok=True)
+        return root
+
+    def _directory(self, workspace_id: str, change_id: str) -> Path:
+        if not change_id.startswith("chg_") or len(change_id) != 28:
+            raise WorkspaceChangeError("Invalid change id.")
+        root = self._change_root(workspace_id).resolve()
+        directory = (root / change_id).resolve()
+        if directory.parent != root:
+            raise WorkspaceChangeError("Invalid change path.")
+        return directory
+
+    @staticmethod
+    def _metadata(directory: Path) -> Path:
+        return directory / "change.json"
+
+    def propose(
+        self,
+        workspace_id: str,
+        *,
+        owner_id: str,
+        path: str,
+        content: str,
+        expected_sha256: str | None = None,
+    ) -> WorkspaceChange:
+        relative = PurePosixPath(str(path or "").replace("\\", "/"))
+        if not relative.parts or relative.is_absolute() or ".." in relative.parts:
+            raise WorkspaceChangeError("Change path must be relative to the workspace.")
+        if _is_sensitive(relative):
+            raise WorkspaceChangeError("Sensitive configuration and key files cannot be written.")
+        proposed = content.encode("utf-8")
+        if len(proposed) > MAX_CHANGE_BYTES:
+            raise WorkspaceChangeError("Proposed file exceeds the 1 MB text-change limit.")
+        try:
+            target = self.workspaces.source_path(workspace_id, str(relative), owner_id=owner_id)
+        except WorkspaceServiceError as exc:
+            raise WorkspaceChangeError(str(exc)) from exc
+        if target.exists() and not target.is_file():
+            raise WorkspaceChangeError("Change target is not a regular file.")
+        try:
+            before = target.read_bytes() if target.exists() else b""
+            before_text = before.decode("utf-8")
+        except (OSError, UnicodeDecodeError) as exc:
+            raise WorkspaceChangeError("Only UTF-8 text files can be changed.") from exc
+        base_hash = _digest(before)
+        if expected_sha256 and not secrets.compare_digest(expected_sha256, base_hash):
+            raise WorkspaceChangeError("File changed since it was reviewed; refresh before proposing a patch.")
+        if before == proposed:
+            raise WorkspaceChangeError("Proposed content is identical to the current file.")
+        diff = "".join(difflib.unified_diff(
+            before_text.splitlines(keepends=True),
+            content.splitlines(keepends=True),
+            fromfile=f"a/{relative}",
+            tofile=f"b/{relative}",
+        ))
+        if len(diff) > MAX_DIFF_CHARS:
+            diff = diff[:MAX_DIFF_CHARS] + "\n... diff truncated ...\n"
+        change_id = f"chg_{secrets.token_hex(12)}"
+        directory = self._directory(workspace_id, change_id)
+        directory.mkdir(mode=0o700)
+        (directory / "before.bin").write_bytes(before)
+        (directory / "proposed.txt").write_bytes(proposed)
+        created = _now()
+        change = WorkspaceChange(
+            schema_version="aria.workspace-change.v1",
+            change_id=change_id,
+            workspace_id=workspace_id,
+            path=str(relative),
+            operation="update" if target.exists() else "create",
+            status="proposed",
+            base_sha256=base_hash,
+            proposed_sha256=_digest(proposed),
+            created_at=created,
+            updated_at=created,
+            diff=diff,
+        )
+        self._metadata(directory).write_text(json.dumps(asdict(change), indent=2), encoding="utf-8")
+        return change
+
+    def get(self, workspace_id: str, change_id: str, *, owner_id: str) -> WorkspaceChange:
+        self.workspaces.get(workspace_id, owner_id=owner_id)
+        try:
+            raw = json.loads(self._metadata(self._directory(workspace_id, change_id)).read_text(encoding="utf-8"))
+            return WorkspaceChange(**raw)
+        except (OSError, TypeError, ValueError, json.JSONDecodeError) as exc:
+            raise WorkspaceChangeError("Change proposal not found.") from exc
+
+    def _store(self, change: WorkspaceChange) -> None:
+        directory = self._directory(change.workspace_id, change.change_id)
+        self._metadata(directory).write_text(json.dumps(asdict(change), indent=2), encoding="utf-8")
+
+    def apply(self, workspace_id: str, change_id: str, *, owner_id: str) -> WorkspaceChange:
+        change = self.get(workspace_id, change_id, owner_id=owner_id)
+        if change.status != "proposed":
+            raise WorkspaceChangeError("Only a proposed change can be applied.")
+        target = self.workspaces.source_path(workspace_id, change.path, owner_id=owner_id)
+        current = target.read_bytes() if target.exists() else b""
+        if not secrets.compare_digest(_digest(current), change.base_sha256):
+            raise WorkspaceChangeError("File changed after the proposal; approval is stale.")
+        proposed = (self._directory(workspace_id, change_id) / "proposed.txt").read_bytes()
+        if not secrets.compare_digest(_digest(proposed), change.proposed_sha256):
+            raise WorkspaceChangeError("Stored proposal failed its integrity check.")
+        target.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+        fd, temporary = tempfile.mkstemp(prefix=f".{target.name}.", dir=target.parent)
+        try:
+            with os.fdopen(fd, "wb") as stream:
+                stream.write(proposed)
+                stream.flush()
+                os.fsync(stream.fileno())
+            os.chmod(temporary, 0o600)
+            os.replace(temporary, target)
+        finally:
+            if os.path.exists(temporary):
+                os.unlink(temporary)
+        updated = WorkspaceChange(**{**asdict(change), "status": "applied", "updated_at": _now()})
+        self._store(updated)
+        return updated
+
+    def rollback(self, workspace_id: str, change_id: str, *, owner_id: str) -> WorkspaceChange:
+        change = self.get(workspace_id, change_id, owner_id=owner_id)
+        if change.status != "applied":
+            raise WorkspaceChangeError("Only an applied change can be rolled back.")
+        target = self.workspaces.source_path(workspace_id, change.path, owner_id=owner_id)
+        current = target.read_bytes() if target.exists() else b""
+        if not secrets.compare_digest(_digest(current), change.proposed_sha256):
+            raise WorkspaceChangeError("File changed after apply; automatic rollback would overwrite newer work.")
+        before = (self._directory(workspace_id, change_id) / "before.bin").read_bytes()
+        if change.operation == "create":
+            target.unlink(missing_ok=True)
+        else:
+            target.write_bytes(before)
+            try:
+                target.chmod(0o600)
+            except OSError:
+                pass
+        updated = WorkspaceChange(**{**asdict(change), "status": "rolled_back", "updated_at": _now()})
+        self._store(updated)
+        return updated