aria-code 0.92.0__tar.gz → 0.93.0__tar.gz

{aria_code-0.92.0/src/aria_code.egg-info → aria_code-0.93.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.92.0
+Version: 0.93.0
 Summary: Open-source AI agent for coding, financial analysis and logistics operations: numbers you can check, client data kept apart, actions a person approves
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/artheras/aria-code

{aria_code-0.92.0 → aria_code-0.93.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aria-code"
-version = "0.92.0"
+version = "0.93.0"
 description = "Open-source AI agent for coding, financial analysis and logistics operations: numbers you can check, client data kept apart, actions a person approves"
 readme = "README.md"
 license = { text = "Apache-2.0" }

{aria_code-0.92.0 → aria_code-0.93.0}/src/aria_code/_version.py

@@ -17,4 +17,4 @@ from __future__ import annotations
 
 __all__ = ["__version__"]
 
-__version__ = "0.92.0"
+__version__ = "0.93.0"

{aria_code-0.92.0 → aria_code-0.93.0}/src/aria_code/apps/cli/local_tool_schemas.py

@@ -204,13 +204,16 @@ def build_local_tool_schemas(
         "type": "function",
         "function": {
             "name": "run_command",
-            "description": "Run a shell command. Use for: git, pip, python, pytest, ls, etc.",
+            "description": "Run a shell command. Use for: git, pip, python, pytest, ls, etc. For a server, watcher or anything that keeps running, set background=true.",
             "parameters": {
                 "type": "object",
                 "properties": {
                     "command": {"type": "string", "description": "Shell command to run"},
                     "cwd": {"type": "string", "description": "Working directory (optional)"},
                     "timeout": {"type": "integer", "description": "Timeout in seconds (max 300, default 120). Use 180+ for data-heavy scripts."},
+                    "background": {"type": "boolean", "description": "Start a long-running command (dev server, watcher, interactive program) and return at once with a process_id; use the process tool to read its output, send input or stop it"},
+                    "wait_seconds": {"type": "number", "description": "With background: how long to wait for first output (default 3, max 30)"},
+                    "until": {"type": "string", "description": "With background: return as soon as this regex appears in the output, e.g. 'Listening on'"},
                     "sandbox": {"type": "boolean", "description": "Set to true to securely execute the command inside an isolated Docker container instead of the host machine. Mandatory for running third-party or untested code."}
                 },
                 "required": ["command"],
@@ -534,4 +537,5 @@ def build_local_tool_schemas(
             }
         }
     },
+        __import__("aria_code.runtime.processes", fromlist=["PROCESS_SCHEMA"]).PROCESS_SCHEMA,
     ]

{aria_code-0.92.0 → aria_code-0.93.0}/src/aria_code/apps/cli/providers/llm/ollama_stream.py

@@ -413,7 +413,7 @@ async def stream_ollama(ollama_url: str, message: str, history: list,
     _CU_TOOL_NAMES = {"browser_navigate", "browser_screenshot",
                       "computer_screenshot", "computer_action"}
     _CODE_TOOL_NAMES = {"read_file", "write_file", "edit_file", "list_files",
-                        "search_code", "run_command", "github",
+                        "search_code", "run_command", "process", "github",
                         "glob", "notebook_read", "notebook_edit"}
     _FINANCE_TOOL_NAMES = {
         "get_market_data", "get_market_history", "calculate_factors",

{aria_code-0.92.0 → aria_code-0.93.0}/src/aria_code/apps/cli/tools/system_tools.py

@@ -198,6 +198,9 @@ def tool_run_command(
                     argv = None
 
         sandbox = params.get("sandbox", False)
+        if params.get("background"):
+            return _start_background(params, command, argv, use_shell, cwd, mode, network,
+                                     docker=bool(sandbox), console=console, has_rich=has_rich)
         if sandbox:
             try:
                 from aria_code.apps.cli.sandbox import run_in_docker_sandbox
@@ -272,6 +275,32 @@ def tool_run_command(
         return {"success": False, "error": str(e)}
 
 
+def _start_background(params, command, argv, use_shell, cwd, mode, network, *, docker,
+                      console, has_rich) -> dict:
+    """Start a long-running command (server, watcher) and return its first output."""
+    if docker:
+        return {"success": False, "error": "background=true is not available with the Docker sandbox."}
+    from aria_code.runtime import processes
+    from aria_code.safety import sandbox as _os_sandbox
+
+    target = argv if (argv and not use_shell) else command
+    confined = _os_sandbox.wrap(target, use_shell=use_shell, mode=mode, network=network, cwd=cwd,
+                                setting=params.get("os_sandbox"))
+    result = processes.start(confined or target, shell=use_shell and not confined, cwd=cwd,
+                             label=command, wait=min(float(params.get("wait_seconds", 3) or 0), 30.0),
+                             until=params.get("until"))
+    if result.get("success"):
+        data = result["data"]
+        state = "running" if data["running"] else f"exited {data['exit_code']}"
+        _cprint(f"  [dim]⎿ background {data['process_id']} · {state}[/dim]",
+                console=console, has_rich=has_rich)
+        if confined and not data["running"]:
+            hint = _os_sandbox.denial_hint(data.get("output", ""), mode=mode, network=network)
+            if hint:
+                data["hint"] = hint
+    return result
+
+
 _PIP_NAMES = {
     "sklearn": "scikit-learn", "cv2": "opencv-python", "bs4": "beautifulsoup4",
     "PIL": "Pillow", "yaml": "PyYAML",

{aria_code-0.92.0 → aria_code-0.93.0}/src/aria_code/aria_cli.py

@@ -1034,6 +1034,8 @@ from aria_code.apps.cli.tool_executor import *
 # Populated in place — the container is owned by apps/cli/tool_registry.py.
 # Rebinding it here instead would leave every reader over there with an
 # empty registry and no error.
+from aria_code.runtime.processes import tool_process as _tool_process
+
 LOCAL_TOOLS.update({
     # ── Core file tools ──────────────────────────────────────────────────────
     "read_file":      (_tool_read_file,      "Read a file's contents"),
@@ -1047,6 +1049,7 @@ LOCAL_TOOLS.update({
     "search_code":    (_tool_search_code,    "Search for patterns in code (grep)"),
     "search":         (_tool_search_code,    "Search for patterns in code (alias for search_code)"),
     "run_command":    (_tool_run_command,    "Execute a shell command"),
+    "process":        (_tool_process,        "Read, write to or stop a background command"),
     # These four had schemas in local_tool_schemas.py and no handler here,
     # which is the mirror of the earlier defect: a schema with nothing
     # behind it offers the model a tool that cannot run.
@@ -2694,6 +2697,7 @@ _TOOL_ACTION_LABELS: dict = {
     "list_files":                "listing files",
     "search_code":               "searching codebase",
     "run_command":               "executing command",
+    "process":                   "checking background process",
     # Macro / realty
     "get_macro_data":            "loading macro indicators",
     "get_house_price_index":     "loading house price data",

{aria_code-0.92.0 → aria_code-0.93.0}/src/aria_code/packages/aria_tools/registry.py

@@ -20,6 +20,7 @@ _PERMISSION_BY_TOOL = {
     "edit_file": [PermissionLevel.WORKSPACE_WRITE],
     "notebook_edit": [PermissionLevel.WORKSPACE_WRITE],
     "run_command": [PermissionLevel.WORKSPACE_WRITE],
+    "process": [PermissionLevel.WORKSPACE_WRITE],
     "web_fetch": [PermissionLevel.NETWORK],
     "github": [PermissionLevel.NETWORK],
     "get_market_data": [PermissionLevel.NETWORK],
@@ -96,7 +97,7 @@ def _capabilities_for_tool(name: str) -> List[str]:
         return ["workspace.read"]
     if name in ("write_file", "edit_file", "notebook_edit"):
         return ["workspace.write"]
-    if name == "run_command":
+    if name in ("run_command", "process"):
         return ["shell"]
     if name in ("web_fetch", "github"):
         return ["network"]

{aria_code-0.92.0 → aria_code-0.93.0}/src/aria_code/runtime/agent_loop.py

@@ -19,7 +19,7 @@ from .tool_executor import ToolExecutor
 from .budget import BudgetTracker
 
 
-DEFAULT_SERIAL_TOOLS = {"write_file", "edit_file", "multi_edit", "run_command"}
+DEFAULT_SERIAL_TOOLS = {"write_file", "edit_file", "multi_edit", "run_command", "process"}
 
 # Phrases the model uses to signal task completion
 _DONE_PHRASES = frozenset([

aria_code-0.93.0/src/aria_code/runtime/processes.py

@@ -0,0 +1,255 @@
+"""Long-running commands: start one, read its output later, send it input, stop it.
+
+run_command waited for a command to finish, so a dev server, a test watcher
+or anything interactive either blocked the turn until the timeout or could
+not be used at all: there was no way to start a server and then test against
+it. ``run_command`` with ``background: true`` starts the process here, under
+the same approval and sandbox as any command, and the ``process`` tool reads
+what it has printed since the last look, writes to its stdin, or stops it.
+
+Output goes through pipes, not a terminal, so a program that insists on a TTY
+behaves as it does when piped. Every process gets its own process group, so
+stopping it stops what it started; all of them are stopped when Aria exits.
+"""
+
+from __future__ import annotations
+
+import atexit
+import itertools
+import os
+import re
+import signal
+import subprocess
+import threading
+import time
+from dataclasses import dataclass, field
+from typing import Sequence
+
+MAX_RUNNING = 8
+MAX_BUFFER = 1_000_000         # characters kept per process; older output is dropped
+MAX_READ = 8_000               # characters returned by one read
+MAX_WAIT = 30.0
+
+_ids = itertools.count(1)
+_lock = threading.Lock()
+
+
+@dataclass
+class _Process:
+    id: str
+    command: str
+    cwd: str
+    popen: subprocess.Popen
+    started: float = field(default_factory=time.time)
+    text: str = ""             # the kept tail of everything printed
+    dropped: int = 0           # characters dropped from the front of `text`
+    read_upto: int = 0         # absolute position the caller has read to
+    done: bool = False         # exited, and everything it printed has been read in
+    changed: threading.Condition = field(default_factory=threading.Condition)
+
+    @property
+    def running(self) -> bool:
+        return self.popen.poll() is None
+
+    def end(self) -> int:
+        return self.dropped + len(self.text)
+
+
+_processes: dict[str, _Process] = {}
+
+
+def _pump(proc: _Process) -> None:
+    stream = proc.popen.stdout
+    try:
+        while True:
+            chunk = stream.read1(4096) if hasattr(stream, "read1") else stream.read(4096)
+            if not chunk:
+                break
+            text = chunk.decode("utf-8", errors="replace")
+            with proc.changed:
+                proc.text += text
+                if len(proc.text) > MAX_BUFFER:
+                    cut = len(proc.text) - MAX_BUFFER
+                    proc.text = proc.text[cut:]
+                    proc.dropped += cut
+                proc.changed.notify_all()
+    except (OSError, ValueError):
+        pass
+    finally:
+        proc.popen.wait()
+        with proc.changed:
+            proc.done = True
+            proc.changed.notify_all()
+
+
+def start(argv: str | Sequence[str], *, shell: bool, cwd: str | None, label: str,
+          wait: float = 3.0, until: str | None = None) -> dict:
+    with _lock:
+        running = [p for p in _processes.values() if p.running]
+        if len(running) >= MAX_RUNNING:
+            ids = ", ".join(p.id for p in running)
+            return {"success": False, "error": f"{MAX_RUNNING} background processes are already running "
+                                               f"({ids}). Stop one with the process tool first."}
+        popen = subprocess.Popen(
+            argv, shell=shell, cwd=cwd, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT, start_new_session=True,
+        )
+        proc = _Process(id=f"p{next(_ids)}", command=label, cwd=cwd or os.getcwd(), popen=popen)
+        _processes[proc.id] = proc
+    threading.Thread(target=_pump, args=(proc,), daemon=True, name=f"aria-{proc.id}").start()
+    return {"success": True, "data": read(proc.id, wait=wait, until=until)["data"] | {"background": True}}
+
+
+def _get(process_id: str) -> _Process | None:
+    return _processes.get(str(process_id or "").strip())
+
+
+def _unknown(process_id: str) -> dict:
+    known = ", ".join(_processes) or "none"
+    return {"success": False, "error": f"No background process '{process_id}' (known: {known})."}
+
+
+def read(process_id: str, *, wait: float = 0.0, until: str | None = None) -> dict:
+    """Output printed since the last read.
+
+    Waits up to ``wait`` seconds, returning early when the process exits or,
+    with ``until``, when that regular expression appears in the new output (a
+    server's "Listening on"). Returning at the first byte gave half a line
+    and a process that had not yet exited.
+    """
+    proc = _get(process_id)
+    if proc is None:
+        return _unknown(process_id)
+    pattern = None
+    if until:
+        try:
+            pattern = re.compile(until)
+        except re.error as exc:
+            return {"success": False, "error": f"Invalid 'until' pattern: {exc}"}
+    deadline = time.monotonic() + max(0.0, min(float(wait or 0), MAX_WAIT))
+
+    def ready() -> bool:
+        if proc.done:
+            return True
+        return bool(pattern and pattern.search(proc.text[max(0, proc.read_upto - proc.dropped):]))
+
+    with proc.changed:
+        while not ready():
+            left = deadline - time.monotonic()
+            if left <= 0:
+                break
+            proc.changed.wait(left)
+        start_at = max(proc.read_upto, proc.dropped)
+        missed = start_at - proc.read_upto
+        new = proc.text[start_at - proc.dropped:]
+        proc.read_upto = proc.end()
+    clipped = len(new) > MAX_READ
+    data = {
+        "process_id": proc.id,
+        "command": proc.command,
+        "running": not proc.done,
+        "exit_code": proc.popen.returncode if proc.done else None,
+        "output": new[-MAX_READ:],
+    }
+    if clipped or missed:
+        data["output_dropped_chars"] = missed + (len(new) - MAX_READ if clipped else 0)
+    if pattern is not None:
+        data["matched"] = bool(pattern.search(new))
+    return {"success": True, "data": data}
+
+
+def write(process_id: str, text: str, *, wait: float = 1.0) -> dict:
+    proc = _get(process_id)
+    if proc is None:
+        return _unknown(process_id)
+    if not proc.running:
+        return {"success": False, "error": f"{proc.id} has exited (code {proc.popen.returncode})."}
+    try:
+        proc.popen.stdin.write(str(text).encode("utf-8"))
+        proc.popen.stdin.flush()
+    except (BrokenPipeError, OSError) as exc:
+        return {"success": False, "error": f"Could not write to {proc.id}: {exc}"}
+    return read(proc.id, wait=wait)
+
+
+def stop(process_id: str, *, grace: float = 3.0) -> dict:
+    proc = _get(process_id)
+    if proc is None:
+        return _unknown(process_id)
+    if proc.running:
+        for sig, pause in ((signal.SIGTERM, grace), (signal.SIGKILL, 2.0)):
+            try:
+                os.killpg(proc.popen.pid, sig)
+            except (ProcessLookupError, PermissionError):
+                break
+            try:
+                proc.popen.wait(timeout=pause)
+                break
+            except subprocess.TimeoutExpired:
+                continue
+    result = read(proc.id, wait=0.5)
+    result["data"]["stopped"] = True
+    return result
+
+
+def listing() -> dict:
+    rows = [{
+        "process_id": p.id, "command": p.command, "cwd": p.cwd, "running": p.running,
+        "exit_code": p.popen.returncode, "seconds": round(time.time() - p.started, 1),
+        "unread_chars": max(0, p.end() - max(p.read_upto, p.dropped)),
+    } for p in _processes.values()]
+    return {"success": True, "data": {"processes": rows}}
+
+
+def stop_all() -> None:
+    for proc in list(_processes.values()):
+        if proc.running:
+            stop(proc.id, grace=1.0)
+
+
+atexit.register(stop_all)
+
+
+def tool_process(params: dict) -> dict:
+    """The ``process`` tool: output | input | stop | list."""
+    action = str(params.get("action") or "output").strip().lower()
+    pid = params.get("process_id", "")
+    if action == "list":
+        return listing()
+    if action == "output":
+        return read(pid, wait=params.get("wait_seconds", 2), until=params.get("until"))
+    if action == "input":
+        if "text" not in params:
+            return {"success": False, "error": "input needs 'text' (include \\n to press Enter)."}
+        return write(pid, params["text"], wait=params.get("wait_seconds", 1))
+    if action == "stop":
+        return stop(pid)
+    return {"success": False, "error": f"Unknown action '{action}': use output, input, stop or list."}
+
+
+PROCESS_SCHEMA = {
+    "type": "function",
+    "function": {
+        "name": "process",
+        "description": (
+            "Manage a command started with run_command background=true (a dev server, a watcher, an "
+            "interactive program). action=output returns what it printed since the last read, "
+            "waiting up to wait_seconds, or until a regex `until` appears; action=input writes `text` "
+            "to its stdin (include \\n for Enter); action=stop ends it and everything it started; "
+            "action=list shows all background processes. Stop servers when you are done with them."
+        ),
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "action": {"type": "string", "enum": ["output", "input", "stop", "list"]},
+                "process_id": {"type": "string", "description": "The id run_command returned, e.g. p1"},
+                "text": {"type": "string", "description": "For input: the text to send"},
+                "wait_seconds": {"type": "number", "description": "How long to wait for output (max 30)"},
+                "until": {"type": "string", "description": "For output: a regex to wait for, e.g. 'Listening on'"},
+            },
+            "required": ["action"],
+        },
+    },
+}
+
+__all__ = ["start", "read", "write", "stop", "listing", "stop_all", "tool_process", "PROCESS_SCHEMA"]

{aria_code-0.92.0 → aria_code-0.93.0/src/aria_code.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.92.0
+Version: 0.93.0
 Summary: Open-source AI agent for coding, financial analysis and logistics operations: numbers you can check, client data kept apart, actions a person approves
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/artheras/aria-code

{aria_code-0.92.0 → aria_code-0.93.0}/src/aria_code.egg-info/SOURCES.txt

@@ -437,6 +437,7 @@ src/aria_code/runtime/events.py
 src/aria_code/runtime/gateway.py
 src/aria_code/runtime/lsp.py
 src/aria_code/runtime/orchestrator.py
+src/aria_code/runtime/processes.py
 src/aria_code/runtime/repo_map.py
 src/aria_code/runtime/run_state.py
 src/aria_code/runtime/run_store.py
@@ -506,6 +507,7 @@ tests/test_aria_sdk.py
 tests/test_artifact_publishing.py
 tests/test_artifacts_and_reports.py
 tests/test_ashare_prediction_cmds.py
+tests/test_background_processes.py
 tests/test_backtest_cmds.py
 tests/test_backtest_engine.py
 tests/test_backtest_report.py

aria_code-0.93.0/tests/test_background_processes.py

@@ -0,0 +1,117 @@
+"""A long-running command can be started, read, written to and stopped.
+
+run_command waited for every command to finish, so a dev server blocked the
+turn until the timeout and there was no way to start one and test against it.
+"""
+
+from __future__ import annotations
+
+import shlex
+import sys
+import time
+
+import pytest
+
+from aria_code.runtime import processes
+
+PY = shlex.quote(sys.executable)
+
+
+@pytest.fixture(autouse=True)
+def clean(tmp_path, monkeypatch):
+    monkeypatch.setenv("ARIA_ARTIFACT_ROOT", str(tmp_path / "artifacts"))
+    yield
+    processes.stop_all()
+    processes._processes.clear()
+
+
+def start(command, cwd, **extra):
+    from aria_code.apps.cli.tools.system_tools import tool_run_command
+
+    return tool_run_command({"command": command, "background": True, "policy": "balanced",
+                             "cwd": str(cwd), "permission_mode": "workspace-write",
+                             "network_enabled": False, **extra}, has_rich=False)
+
+
+SERVER = (f"{PY} -u -c \"import time; print('booting'); time.sleep(0.5); print('Listening on 8000');"
+          " [print('tick', i) or time.sleep(0.2) for i in range(200)]\"")
+
+
+def test_start_returns_at_once_and_waits_for_the_ready_line(tmp_path):
+    began = time.monotonic()
+    result = start(SERVER, tmp_path, until="Listening on", wait_seconds=10)
+    data = result["data"]
+    assert result["success"] and data["background"] and data["running"]
+    assert data["matched"] and "Listening on 8000" in data["output"]
+    assert time.monotonic() - began < 5
+
+
+def test_output_is_what_came_since_the_last_read(tmp_path):
+    pid = start(SERVER, tmp_path, until="Listening on", wait_seconds=10)["data"]["process_id"]
+    first = processes.tool_process({"action": "output", "process_id": pid, "wait_seconds": 2})["data"]
+    second = processes.tool_process({"action": "output", "process_id": pid, "wait_seconds": 2})["data"]
+    assert "tick" in first["output"] and "tick" in second["output"]
+    assert "Listening on" not in first["output"] + second["output"]
+
+
+def test_input_reaches_the_program(tmp_path):
+    echo = f"{PY} -u -c \"import sys; [print('got', line.strip()) for line in sys.stdin]\""
+    pid = start(echo, tmp_path, wait_seconds=0.5)["data"]["process_id"]
+    reply = processes.tool_process({"action": "input", "process_id": pid, "text": "hello\n",
+                                    "wait_seconds": 3})["data"]
+    assert "got hello" in reply["output"]
+
+
+def test_stop_ends_the_process_and_its_children(tmp_path):
+    parent = f"{PY} -u -c \"import subprocess, sys, time; subprocess.Popen([sys.executable, '-c', 'import time; time.sleep(60)']); print('up'); time.sleep(60)\""
+    pid = start(parent, tmp_path, until="up", wait_seconds=10)["data"]["process_id"]
+    proc = processes._processes[pid]
+    stopped = processes.tool_process({"action": "stop", "process_id": pid})["data"]
+    assert stopped["stopped"] and not stopped["running"]
+    import os
+    with pytest.raises(ProcessLookupError):
+        os.killpg(proc.popen.pid, 0)
+
+
+def test_a_command_that_ends_reports_its_exit_code(tmp_path):
+    data = start(f"{PY} -c \"print('done')\"", tmp_path, wait_seconds=5)["data"]
+    assert data["running"] is False and data["exit_code"] == 0 and "done" in data["output"]
+
+
+def test_list_and_unknown_ids(tmp_path):
+    pid = start(SERVER, tmp_path, wait_seconds=0.2)["data"]["process_id"]
+    rows = processes.tool_process({"action": "list"})["data"]["processes"]
+    assert [r["process_id"] for r in rows] == [pid]
+    missing = processes.tool_process({"action": "output", "process_id": "p999"})
+    assert not missing["success"] and pid in missing["error"]
+
+
+def test_too_many_running_is_refused(tmp_path, monkeypatch):
+    monkeypatch.setattr(processes, "MAX_RUNNING", 1)
+    start(SERVER, tmp_path, wait_seconds=0.1)
+    second = start(SERVER, tmp_path, wait_seconds=0.1)
+    assert not second["success"] and "already running" in second["error"]
+
+
+def test_the_policy_still_applies(tmp_path):
+    blocked = start("curl https://example.com", tmp_path)
+    assert not blocked["success"]
+
+
+@pytest.mark.skipif(not __import__("aria_code.safety.sandbox", fromlist=["available"]).available(),
+                    reason="needs macOS sandbox-exec")
+def test_background_commands_run_in_the_sandbox(tmp_path):
+    from pathlib import Path
+
+    target = Path.home() / ".aria-bg-sandbox-test.txt"
+    data = start(f"echo hi > {target}", tmp_path, wait_seconds=5)["data"]
+    assert not target.exists()
+    assert data["exit_code"] != 0 and "sandbox" in data.get("hint", "")
+
+
+def test_the_model_is_offered_the_tool_and_the_flag():
+    from aria_code import aria_cli
+
+    names = {s["function"]["name"]: s["function"] for s in aria_cli.LOCAL_TOOL_SCHEMAS if "function" in s}
+    assert "process" in names and "process" in aria_cli.LOCAL_TOOLS
+    assert "background" in names["run_command"]["parameters"]["properties"]