aria-code 0.52.0__py3-none-any.whl

aria_code/workspace_context.py

@@ -0,0 +1,233 @@
+"""Safe, user-visible workspace context.
+
+The context is deliberately a small allow-list.  It is suitable for a UI
+summary, but is not a place for credentials, provider configuration, raw tool
+responses, or data-source details.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Mapping
+
+
+CONTEXT_VERSION = 1
+CONTEXT_FILE_NAME = "workspace-context.json"
+VALID_ACTIVITY_STATES = {
+    "idle",
+    "queued",
+    "running",
+    "needs_approval",
+    "completed",
+    "attention",
+}
+
+
+def _timestamp(now: datetime | None = None) -> str:
+    value = now or datetime.now(timezone.utc)
+    if value.tzinfo is None:
+        value = value.replace(tzinfo=timezone.utc)
+    return value.astimezone(timezone.utc).isoformat().replace("+00:00", "Z")
+
+
+def _text(value: Any, *, limit: int) -> str:
+    if not isinstance(value, str):
+        return ""
+    return value.strip()[:limit]
+
+
+def _count(value: Any, *, maximum: int = 999_999_999) -> int:
+    if isinstance(value, bool):
+        return 0
+    try:
+        return max(0, min(int(value), maximum))
+    except (TypeError, ValueError):
+        return 0
+
+
+def context_file_path(workspace_root: str | Path | None = None) -> Path:
+    """Return the private, workspace-local state path."""
+
+    root = Path(workspace_root or Path.cwd()).expanduser().resolve()
+    return root / ".aria" / CONTEXT_FILE_NAME
+
+
+def default_workspace_context(
+    workspace_root: str | Path | None = None,
+    *,
+    now: datetime | None = None,
+) -> dict[str, Any]:
+    root = Path(workspace_root or Path.cwd()).expanduser().resolve()
+    project_name = root.name or "Workspace"
+    return {
+        "schemaVersion": CONTEXT_VERSION,
+        "updatedAt": _timestamp(now),
+        "project": {"name": project_name},
+        "activity": {
+            "state": "idle",
+            "requiresApproval": False,
+        },
+        "pendingApprovalCount": 0,
+        "completedTaskCount": 0,
+        "artifacts": [],
+    }
+
+
+def normalize_workspace_context(
+    raw: Mapping[str, Any] | None,
+    workspace_root: str | Path | None = None,
+    *,
+    now: datetime | None = None,
+) -> dict[str, Any]:
+    """Return an allow-listed context, discarding unknown or sensitive input."""
+
+    source: Mapping[str, Any] = raw if isinstance(raw, Mapping) else {}
+    normalized = default_workspace_context(workspace_root, now=now)
+
+    project = source.get("project")
+    if isinstance(project, Mapping):
+        name = _text(project.get("name"), limit=120)
+        symbol = _text(project.get("symbol"), limit=24)
+        if name:
+            normalized["project"]["name"] = name
+        if symbol:
+            normalized["project"]["symbol"] = symbol
+
+    activity = source.get("activity")
+    if isinstance(activity, Mapping):
+        state = _text(activity.get("state"), limit=32)
+        title = _text(activity.get("title"), limit=160)
+        if state in VALID_ACTIVITY_STATES:
+            normalized["activity"]["state"] = state
+        if title:
+            normalized["activity"]["title"] = title
+        if "progress" in activity:
+            normalized["activity"]["progress"] = _count(activity.get("progress"), maximum=100)
+        normalized["activity"]["requiresApproval"] = bool(
+            activity.get("requiresApproval", False)
+        )
+
+    normalized["pendingApprovalCount"] = _count(source.get("pendingApprovalCount"))
+    normalized["completedTaskCount"] = _count(source.get("completedTaskCount"))
+
+    artifacts = source.get("artifacts")
+    if isinstance(artifacts, list):
+        safe_artifacts: list[dict[str, str]] = []
+        for artifact in artifacts[:6]:
+            if not isinstance(artifact, Mapping):
+                continue
+            artifact_id = _text(artifact.get("id"), limit=120)
+            title = _text(artifact.get("title"), limit=160)
+            kind = _text(artifact.get("kind"), limit=60)
+            if not artifact_id or not title:
+                continue
+            entry: dict[str, str] = {
+                "id": artifact_id,
+                "title": title,
+                "status": "ready",
+            }
+            if kind:
+                entry["kind"] = kind
+            safe_artifacts.append(entry)
+        normalized["artifacts"] = safe_artifacts
+
+    return normalized
+
+
+def load_workspace_context(workspace_root: str | Path | None = None) -> dict[str, Any]:
+    path = context_file_path(workspace_root)
+    try:
+        with path.open("r", encoding="utf-8") as handle:
+            raw = json.load(handle)
+    except (FileNotFoundError, OSError, json.JSONDecodeError):
+        raw = None
+    return normalize_workspace_context(raw, workspace_root)
+
+
+def save_workspace_context(
+    context: Mapping[str, Any] | None,
+    workspace_root: str | Path | None = None,
+) -> Path:
+    """Atomically persist only the normalized, user-visible context."""
+
+    path = context_file_path(workspace_root)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    safe_context = normalize_workspace_context(context, workspace_root)
+    safe_context["updatedAt"] = _timestamp()
+
+    temp_path: Path | None = None
+    try:
+        with tempfile.NamedTemporaryFile(
+            mode="w",
+            encoding="utf-8",
+            dir=path.parent,
+            prefix=".workspace-context-",
+            suffix=".tmp",
+            delete=False,
+        ) as handle:
+            temp_path = Path(handle.name)
+            os.chmod(temp_path, 0o600)
+            json.dump(safe_context, handle, ensure_ascii=False, indent=2, sort_keys=True)
+            handle.write("\n")
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.replace(temp_path, path)
+        os.chmod(path, 0o600)
+    finally:
+        if temp_path is not None and temp_path.exists():
+            temp_path.unlink(missing_ok=True)
+    return path
+
+
+def update_workspace_context(
+    patch: Mapping[str, Any],
+    workspace_root: str | Path | None = None,
+) -> dict[str, Any]:
+    """Apply a shallow, allow-listed patch and persist it."""
+
+    current = load_workspace_context(workspace_root)
+    merged: dict[str, Any] = {**current}
+    for key in ("project", "activity"):
+        candidate = patch.get(key)
+        if isinstance(candidate, Mapping):
+            merged[key] = {**current[key], **candidate}
+    for key in ("pendingApprovalCount", "completedTaskCount", "artifacts"):
+        if key in patch:
+            merged[key] = patch[key]
+    safe_context = normalize_workspace_context(merged, workspace_root)
+    save_workspace_context(safe_context, workspace_root)
+    return safe_context
+
+
+def set_workspace_activity(
+    *,
+    state: str,
+    title: str | None = None,
+    progress: int | None = None,
+    requires_approval: bool | None = None,
+    workspace_root: str | Path | None = None,
+) -> dict[str, Any]:
+    activity: dict[str, Any] = {"state": state}
+    if title is not None:
+        activity["title"] = title
+    if progress is not None:
+        activity["progress"] = progress
+    if requires_approval is not None:
+        activity["requiresApproval"] = requires_approval
+    return update_workspace_context({"activity": activity}, workspace_root)
+
+
+def record_workspace_artifact(
+    *,
+    artifact_id: str,
+    title: str,
+    kind: str | None = None,
+    workspace_root: str | Path | None = None,
+) -> dict[str, Any]:
+    current = load_workspace_context(workspace_root)
+    artifacts = [*current["artifacts"], {"id": artifact_id, "title": title, "kind": kind or ""}]
+    return update_workspace_context({"artifacts": artifacts[-6:]}, workspace_root)

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]