aria-code 0.167.0__py3-none-win_amd64.whl

aria_code/runtime/windows_job.py

@@ -0,0 +1,115 @@
+"""Keep a Windows background command's descendants in one owned Job Object.
+
+Lazy-imported only on Windows. Closing the last handle kills descendants,
+including those still running after the command's original parent exited.
+This manages lifetime; it is not a filesystem/network sandbox.
+"""
+from __future__ import annotations
+
+import ctypes as c
+from ctypes import wintypes as w
+
+
+class _Limits(c.Structure):
+    _fields_ = [("process_time", c.c_longlong), ("job_time", c.c_longlong),
+                ("flags", w.DWORD), ("min_working", c.c_size_t), ("max_working", c.c_size_t),
+                ("active_limit", w.DWORD), ("affinity", c.c_size_t),
+                ("priority", w.DWORD), ("scheduling", w.DWORD)]
+
+
+class _IOCounters(c.Structure):
+    _fields_ = [(name, c.c_ulonglong) for name in ("read_ops", "write_ops", "other_ops",
+                                                 "read_bytes", "write_bytes", "other_bytes")]
+
+
+class _ExtendedLimits(c.Structure):
+    _fields_ = [("basic", _Limits), ("io", _IOCounters), ("process_memory", c.c_size_t),
+                ("job_memory", c.c_size_t), ("peak_process_memory", c.c_size_t),
+                ("peak_job_memory", c.c_size_t)]
+
+
+class _Accounting(c.Structure):
+    _fields_ = [(name, c.c_longlong) for name in ("user_time", "kernel_time", "period_user", "period_kernel")]
+    _fields_ += [(name, w.DWORD) for name in ("page_faults", "total", "active", "terminated")]
+
+
+class _ThreadEntry(c.Structure):
+    _fields_ = [("size", w.DWORD), ("usage", w.DWORD), ("thread_id", w.DWORD),
+                ("owner_pid", w.DWORD), ("priority", w.LONG), ("delta", w.LONG), ("flags", w.DWORD)]
+
+
+class WindowsJob:
+    def __init__(self, popen):
+        self.api = c.WinDLL("kernel32", use_last_error=True)
+        signatures = {
+            "CreateJobObjectW": ([c.c_void_p, w.LPCWSTR], w.HANDLE),
+            "SetInformationJobObject": ([w.HANDLE, c.c_int, c.c_void_p, w.DWORD], w.BOOL),
+            "AssignProcessToJobObject": ([w.HANDLE, w.HANDLE], w.BOOL),
+            "QueryInformationJobObject": ([w.HANDLE, c.c_int, c.c_void_p, w.DWORD, c.c_void_p], w.BOOL),
+            "TerminateJobObject": ([w.HANDLE, w.UINT], w.BOOL),
+            "CloseHandle": ([w.HANDLE], w.BOOL),
+            "CreateToolhelp32Snapshot": ([w.DWORD, w.DWORD], w.HANDLE),
+            "Thread32First": ([w.HANDLE, c.POINTER(_ThreadEntry)], w.BOOL),
+            "Thread32Next": ([w.HANDLE, c.POINTER(_ThreadEntry)], w.BOOL),
+            "OpenThread": ([w.DWORD, w.BOOL, w.DWORD], w.HANDLE),
+            "ResumeThread": ([w.HANDLE], w.DWORD),
+        }
+        for name, (args, result) in signatures.items():
+            fn = getattr(self.api, name)
+            fn.argtypes, fn.restype = args, result
+        self.handle = self.api.CreateJobObjectW(None, None)
+        if not self.handle:
+            raise c.WinError(c.get_last_error())
+        try:
+            limits = _ExtendedLimits()
+            limits.basic.flags = 0x2000  # JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE
+            if not self.api.SetInformationJobObject(self.handle, 9, c.byref(limits), c.sizeof(limits)):
+                raise c.WinError(c.get_last_error())
+            if not self.api.AssignProcessToJobObject(self.handle, int(popen._handle)):
+                raise c.WinError(c.get_last_error())
+        except BaseException:
+            self.close()
+            raise
+
+    def resume(self, pid: int) -> None:
+        # Popen closes CreateProcess's thread handle. Find the sole suspended
+        # initial thread using the documented Toolhelp API, then resume it.
+        snapshot = self.api.CreateToolhelp32Snapshot(0x4, 0)  # TH32CS_SNAPTHREAD
+        if snapshot == c.c_void_p(-1).value:
+            raise c.WinError(c.get_last_error())
+        try:
+            entry = _ThreadEntry()
+            entry.size = c.sizeof(entry)
+            more = self.api.Thread32First(snapshot, c.byref(entry))
+            while more:
+                if entry.owner_pid == pid:
+                    thread = self.api.OpenThread(0x2, False, entry.thread_id)  # THREAD_SUSPEND_RESUME
+                    if not thread:
+                        raise c.WinError(c.get_last_error())
+                    try:
+                        if self.api.ResumeThread(thread) == 0xFFFFFFFF:
+                            raise c.WinError(c.get_last_error())
+                        return
+                    finally:
+                        self.api.CloseHandle(thread)
+                more = self.api.Thread32Next(snapshot, c.byref(entry))
+            raise OSError("Cannot find the background command's suspended thread")
+        finally:
+            self.api.CloseHandle(snapshot)
+
+    def running(self) -> bool:
+        if not self.handle:
+            return False
+        info = _Accounting()
+        if not self.api.QueryInformationJobObject(self.handle, 1, c.byref(info), c.sizeof(info), None):
+            raise c.WinError(c.get_last_error())
+        return bool(info.active)
+
+    def terminate(self) -> None:
+        if self.handle and not self.api.TerminateJobObject(self.handle, 1):
+            raise c.WinError(c.get_last_error())
+
+    def close(self) -> None:
+        if self.handle:
+            self.api.CloseHandle(self.handle)
+            self.handle = None

aria_code/runtime/workflows.py

@@ -0,0 +1,222 @@
+"""User-defined workflows: ``.aria/workflows/<name>.yaml``, run as ``/<name>``.
+
+A release is the same five steps every time — test, build, review, write
+the changelog, open the PR — and typing them is where one gets skipped. A
+workflow file names them once::
+
+    # .aria/workflows/release.yaml
+    description: Test, build, review, changelog, PR
+    steps:
+      - name: Tests
+        run: python -m pytest -q
+      - name: Build
+        run: python -m build
+        timeout: 600
+      - name: Security review
+        command: /review --base main
+      - name: Changelog
+        prompt: Add a CHANGELOG.md entry for the changes since the last tag. {{args}}
+      - name: Open the PR
+        run: gh pr create --fill
+        confirm: true
+
+A step has exactly one of ``run`` (a shell command, through the same
+``run_command`` tool, policy and sandbox as the model's commands),
+``prompt`` (a full Aria turn with tools — its checks decide whether it
+passed) or ``command`` (any slash command). ``confirm`` asks before the step,
+``continue_on_error`` keeps going past a failure, ``timeout`` bounds a
+``run``. ``{{args}}`` is what followed the command, ``{{date}}`` today.
+
+The file comes with the repository, so whoever wrote it chose those
+commands. The first run of a workflow — and the first after its file
+changes — shows every step and asks; the answer is remembered by content
+hash in ``<aria home>/trusted_workflows.json``.
+"""
+
+from __future__ import annotations
+
+import datetime as _dt
+import hashlib
+import json
+import os
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+STEP_KINDS = ("run", "prompt", "command")
+_STEP_KEYS = {"name", "run", "prompt", "command", "confirm", "continue_on_error", "timeout"}
+_TOP_KEYS = {"name", "description", "steps"}
+_NAME = re.compile(r"^[a-z0-9][a-z0-9_-]*$")
+_PLACEHOLDER = re.compile(r"\{\{\s*(\w+)\s*\}\}")
+
+
+class WorkflowError(ValueError):
+    """A workflow file that cannot be run, with the reason."""
+
+
+@dataclass(frozen=True)
+class WorkflowStep:
+    name: str
+    kind: str          # run | prompt | command
+    body: str
+    confirm: bool = False
+    continue_on_error: bool = False
+    timeout: int = 300
+
+    def render(self, variables: dict) -> str:
+        return _PLACEHOLDER.sub(lambda m: str(variables.get(m.group(1), m.group(0))), self.body).strip()
+
+
+@dataclass(frozen=True)
+class Workflow:
+    name: str
+    path: str
+    description: str
+    steps: tuple[WorkflowStep, ...]
+    digest: str = ""
+
+    def outline(self) -> list[str]:
+        lines = [f"/{self.name} — {self.description}" if self.description else f"/{self.name}",
+                 f"  from {self.path}"]
+        for index, step in enumerate(self.steps, 1):
+            flags = [flag for flag, on in (("asks first", step.confirm),
+                                           ("continues on error", step.continue_on_error)) if on]
+            suffix = f"  ({', '.join(flags)})" if flags else ""
+            body = " ".join(step.body.split())
+            lines.append(f"  {index}. {step.name} — {step.kind}: {body[:90]}{suffix}")
+        return lines
+
+
+def workflow_dirs(workspace: Path | str) -> list[Path]:
+    """``.aria/workflows`` in the workspace, then in its git root if different."""
+    start = Path(workspace).expanduser().resolve()
+    dirs = [start / ".aria" / "workflows"]
+    for parent in start.parents:
+        if (parent / ".git").exists():
+            if parent / ".aria" / "workflows" not in dirs:
+                dirs.append(parent / ".aria" / "workflows")
+            break
+    return [d for d in dirs if d.is_dir()]
+
+
+def _files(workspace: Path | str) -> dict[str, Path]:
+    found: dict[str, Path] = {}
+    for directory in workflow_dirs(workspace):
+        for path in sorted(directory.glob("*.y*ml")):
+            if path.suffix in (".yaml", ".yml"):
+                found.setdefault(path.stem.lower(), path)
+    return found
+
+
+def names(workspace: Path | str) -> list[str]:
+    return sorted(_files(workspace))
+
+
+def _parse_step(index: int, raw: object, path: Path) -> WorkflowStep:
+    where = f"{path.name}, step {index}"
+    if not isinstance(raw, dict):
+        raise WorkflowError(f"{where}: a step is a mapping with run, prompt or command")
+    unknown = set(raw) - _STEP_KEYS
+    if unknown:
+        raise WorkflowError(f"{where}: unknown key {', '.join(sorted(unknown))}")
+    kinds = [kind for kind in STEP_KINDS if raw.get(kind) not in (None, "")]
+    if len(kinds) != 1:
+        raise WorkflowError(f"{where}: needs exactly one of run, prompt, command")
+    kind = kinds[0]
+    body = str(raw[kind])
+    if kind == "command" and not body.lstrip().startswith("/"):
+        raise WorkflowError(f"{where}: command must be a slash command, e.g. /review")
+    try:
+        timeout = int(raw.get("timeout", 300))
+    except (TypeError, ValueError):
+        raise WorkflowError(f"{where}: timeout must be a number of seconds") from None
+    default_name = " ".join(body.split())[:40]
+    return WorkflowStep(name=str(raw.get("name") or default_name), kind=kind, body=body,
+                        confirm=bool(raw.get("confirm", False)),
+                        continue_on_error=bool(raw.get("continue_on_error", False)),
+                        timeout=max(1, timeout))
+
+
+def parse(path: Path | str) -> Workflow:
+    path = Path(path)
+    try:
+        text = path.read_text(encoding="utf-8")
+    except OSError as exc:
+        raise WorkflowError(f"{path}: cannot read: {exc}") from exc
+    try:
+        import yaml
+
+        data = yaml.safe_load(text)
+    except Exception as exc:
+        raise WorkflowError(f"{path.name}: not valid YAML: {exc}") from exc
+    if not isinstance(data, dict):
+        raise WorkflowError(f"{path.name}: expected a mapping with steps")
+    unknown = set(data) - _TOP_KEYS
+    if unknown:
+        raise WorkflowError(f"{path.name}: unknown key {', '.join(sorted(unknown))}")
+    steps = data.get("steps")
+    if not isinstance(steps, list) or not steps:
+        raise WorkflowError(f"{path.name}: steps must be a non-empty list")
+    name = str(data.get("name") or path.stem).lower()
+    if not _NAME.match(name):
+        raise WorkflowError(f"{path.name}: name '{name}' must be lowercase letters, digits, - or _")
+    return Workflow(
+        name=name, path=str(path), description=str(data.get("description") or ""),
+        steps=tuple(_parse_step(i, raw, path) for i, raw in enumerate(steps, 1)),
+        digest=hashlib.sha256(text.encode("utf-8")).hexdigest(),
+    )
+
+
+def find(workspace: Path | str, name: str) -> Optional[Workflow]:
+    """The workflow called ``name`` (``/name`` works too), or None. Invalid files raise."""
+    path = _files(workspace).get(name.lstrip("/").lower())
+    return parse(path) if path is not None else None
+
+
+def variables(workflow: Workflow, args: str) -> dict:
+    return {"args": args.strip(), "date": _dt.date.today().isoformat(), "workflow": workflow.name}
+
+
+# ── trust ──────────────────────────────────────────────────────────────────
+
+@dataclass
+class TrustStore:
+    path: Path
+    entries: dict = field(default_factory=dict)
+
+    @classmethod
+    def load(cls, path: Optional[Path] = None) -> "TrustStore":
+        if path is None:
+            from ..packages.aria_core.paths import aria_home
+
+            path = aria_home() / "trusted_workflows.json"
+        try:
+            entries = json.loads(Path(path).read_text(encoding="utf-8"))
+        except (OSError, ValueError):
+            entries = {}
+        return cls(Path(path), entries if isinstance(entries, dict) else {})
+
+    def trusted(self, workflow: Workflow) -> bool:
+        return self.entries.get(str(Path(workflow.path).resolve())) == workflow.digest
+
+    def trust(self, workflow: Workflow) -> None:
+        self.entries[str(Path(workflow.path).resolve())] = workflow.digest
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        temp = self.path.with_suffix(".tmp")
+        temp.write_text(json.dumps(self.entries, indent=2, sort_keys=True), encoding="utf-8")
+        os.replace(temp, self.path)
+
+
+TEMPLATE = """\
+# /{name} — run with /{name} [args]; {{{{args}}}} is what you type after it.
+description: Test, review and summarise the current change
+steps:
+  - name: Tests
+    run: python -m pytest -q
+  - name: Review
+    command: /review
+  - name: Summary
+    prompt: Summarise the current change for a pull request description. {{{{args}}}}
+    continue_on_error: true
+"""

aria_code/runtime/worktrees.py

@@ -0,0 +1,215 @@
+"""Git worktree isolation for write-capable background agents."""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+
+class WorktreeError(RuntimeError):
+    """Raised when an isolated worktree cannot be created safely."""
+
+
+@dataclass(frozen=True)
+class WorktreeSpec:
+    task_id: str
+    repository: str
+    path: str
+    branch: str
+    base_revision: str
+
+
+@dataclass(frozen=True)
+class WorktreeApplyResult:
+    paths: tuple[str, ...]
+    tracked_paths: tuple[str, ...]
+    untracked_paths: tuple[str, ...]
+
+
+class WorktreeManager:
+    """Create task-specific worktrees without changing the caller's cwd."""
+
+    def __init__(self, root: Path | str) -> None:
+        self.root = Path(root).expanduser().resolve()
+        self.root.mkdir(parents=True, exist_ok=True)
+
+    @staticmethod
+    def _git(*args: str, cwd: Path) -> str:
+        try:
+            completed = subprocess.run(
+                ["git", *args],
+                cwd=str(cwd),
+                text=True,
+                capture_output=True,
+                timeout=30,
+                check=False,
+            )
+        except (OSError, subprocess.SubprocessError) as exc:
+            raise WorktreeError(f"Unable to run git: {exc}") from exc
+        if completed.returncode != 0:
+            detail = (completed.stderr or completed.stdout).strip()
+            raise WorktreeError(detail or f"git {' '.join(args)} failed")
+        return completed.stdout.strip()
+
+    @classmethod
+    def repository_root(cls, workspace: Path | str) -> Path:
+        path = Path(workspace).expanduser().resolve()
+        output = cls._git("rev-parse", "--show-toplevel", cwd=path)
+        return Path(output).resolve()
+
+    @classmethod
+    def is_clean(cls, repository: Path | str) -> bool:
+        repo = Path(repository).expanduser().resolve()
+        return not cls._git("status", "--porcelain", "--untracked-files=all", cwd=repo)
+
+    def create(
+        self,
+        *,
+        task_id: str,
+        workspace: Path | str,
+        require_clean: bool = True,
+    ) -> WorktreeSpec:
+        repository = self.repository_root(workspace)
+        if require_clean and not self.is_clean(repository):
+            raise WorktreeError(
+                "The repository has uncommitted changes. Commit or stash them before "
+                "starting a write-capable isolated subagent."
+            )
+        base_revision = self._git("rev-parse", "HEAD", cwd=repository)
+        branch = f"aria/task-{task_id}"
+        destination = (self.root / repository.name / task_id).resolve()
+        if destination.exists():
+            raise WorktreeError(f"Worktree path already exists: {destination}")
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        try:
+            self._git(
+                "worktree",
+                "add",
+                "-b",
+                branch,
+                str(destination),
+                base_revision,
+                cwd=repository,
+            )
+        except Exception:
+            if destination.exists():
+                shutil.rmtree(destination, ignore_errors=True)
+            raise
+        return WorktreeSpec(
+            task_id=task_id,
+            repository=str(repository),
+            path=str(destination),
+            branch=branch,
+            base_revision=base_revision,
+        )
+
+    def remove(self, spec: WorktreeSpec, *, force: bool = False) -> None:
+        repository = Path(spec.repository)
+        path = Path(spec.path)
+        args = ["worktree", "remove"]
+        if force:
+            args.append("--force")
+        args.append(str(path))
+        self._git(*args, cwd=repository)
+
+    def delete_branch(self, spec: WorktreeSpec, *, force: bool = False) -> None:
+        flag = "-D" if force else "-d"
+        self._git("branch", flag, spec.branch, cwd=Path(spec.repository))
+
+    @classmethod
+    def diff(cls, spec: WorktreeSpec) -> str:
+        worktree = Path(spec.path)
+        diff_stat = cls._git("diff", "--stat", spec.base_revision, cwd=worktree)
+        untracked = cls._git("ls-files", "--others", "--exclude-standard", cwd=worktree)
+        parts = [part for part in (diff_stat, untracked) if part]
+        return "\n".join(parts)
+
+    @staticmethod
+    def _git_binary(*args: str, cwd: Path, input_data: bytes | None = None) -> bytes:
+        try:
+            completed = subprocess.run(
+                ["git", *args],
+                cwd=str(cwd),
+                input=input_data,
+                capture_output=True,
+                timeout=30,
+                check=False,
+            )
+        except (OSError, subprocess.SubprocessError) as exc:
+            raise WorktreeError(f"Unable to run git: {exc}") from exc
+        if completed.returncode != 0:
+            detail = (completed.stderr or completed.stdout).decode("utf-8", errors="replace").strip()
+            raise WorktreeError(detail or f"git {' '.join(args)} failed")
+        return completed.stdout
+
+    def apply(self, spec: WorktreeSpec) -> WorktreeApplyResult:
+        """Apply an isolated worktree's unstaged result to a clean main worktree."""
+        repository = Path(spec.repository)
+        worktree = Path(spec.path)
+        if not self.is_clean(repository):
+            raise WorktreeError(
+                "The target workspace changed after the subagent started. "
+                "Commit or stash those changes before applying the task result."
+            )
+        target_revision = self._git("rev-parse", "HEAD", cwd=repository)
+        if target_revision != spec.base_revision:
+            raise WorktreeError(
+                "The target branch advanced after the subagent started. "
+                "Review or rebase the task worktree before applying it."
+            )
+
+        tracked, untracked = self.changed_paths(spec)
+        if not tracked and not untracked:
+            raise WorktreeError("The subagent worktree contains no changes to apply.")
+
+        for relative in untracked:
+            destination = repository / relative
+            if destination.exists():
+                raise WorktreeError(
+                    f"Refusing to overwrite an existing untracked path: {destination}"
+                )
+
+        patch = self._git_binary(
+            "diff", "--binary", spec.base_revision, cwd=worktree
+        )
+        if patch:
+            self._git_binary("apply", "--check", "-", cwd=repository, input_data=patch)
+
+        copied: list[Path] = []
+        patch_applied = False
+        try:
+            if patch:
+                self._git_binary("apply", "-", cwd=repository, input_data=patch)
+                patch_applied = True
+            for relative in untracked:
+                source = worktree / relative
+                destination = repository / relative
+                if source.is_symlink():
+                    raise WorktreeError(f"Refusing to copy an untracked symlink: {source}")
+                destination.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(source, destination)
+                copied.append(destination)
+        except Exception:
+            for destination in reversed(copied):
+                if destination.exists():
+                    destination.unlink()
+            if patch_applied:
+                self._git_binary("apply", "--reverse", "-", cwd=repository, input_data=patch)
+            raise
+
+        paths = tuple(dict.fromkeys([*tracked, *untracked]))
+        return WorktreeApplyResult(paths, tracked, untracked)
+
+    def changed_paths(self, spec: WorktreeSpec) -> tuple[tuple[str, ...], tuple[str, ...]]:
+        worktree = Path(spec.path)
+        tracked_text = self._git(
+            "diff", "--name-only", spec.base_revision, cwd=worktree
+        )
+        tracked = tuple(path for path in tracked_text.splitlines() if path)
+        untracked_text = self._git(
+            "ls-files", "--others", "--exclude-standard", cwd=worktree
+        )
+        untracked = tuple(path for path in untracked_text.splitlines() if path)
+        return tracked, untracked

aria_code/runway_video_client.py

@@ -0,0 +1,4 @@
+"""Compatibility import for :mod:`clients.runway_video_client`."""
+from importlib import import_module as _import_module
+import sys as _sys
+_sys.modules[__name__] = _import_module("clients.runway_video_client")

aria_code/safety/__init__.py

@@ -0,0 +1,27 @@
+"""Safety and permission primitives for Aria Code."""
+
+from .service import SafetyService
+from .permissions import (
+    PermissionDecision,
+    PermissionMode,
+    PermissionService,
+    PolicyDecision,
+    classify_command_risk,
+    evaluate_command_policy,
+    normalize_command,
+)
+from .risk import RiskAssessment, assess_command, assess_tool
+
+__all__ = [
+    "SafetyService",
+    "PermissionDecision",
+    "PermissionMode",
+    "PermissionService",
+    "PolicyDecision",
+    "classify_command_risk",
+    "RiskAssessment",
+    "assess_command",
+    "assess_tool",
+    "evaluate_command_policy",
+    "normalize_command",
+]