aria-code 0.167.0__py3-none-win_amd64.whl

aria_code/apps/cli/sandbox.py

@@ -0,0 +1,32 @@
+"""Sandbox execution module for Aria Code."""
+import subprocess
+import os
+
+def run_in_docker_sandbox(command: str, cwd: str = None, timeout: int = 120, image: str = "python:3.11-slim") -> subprocess.CompletedProcess:
+    """Run a shell command securely inside an isolated Docker container.
+    
+    This mounts the current workspace so scripts can operate on files,
+    but prevents access to the host's system files and network interfaces
+    if configured with --network none (optional).
+    """
+    workspace = cwd or os.getcwd()
+    
+    # We use docker run with a volume mount to the workspace.
+    # --rm: remove container after exit
+    # -v: mount workspace to /workspace
+    # -w: set working directory to /workspace
+    docker_cmd = [
+        "docker", "run", "--rm",
+        "-v", f"{workspace}:/workspace",
+        "-w", "/workspace",
+        # "--network", "none", # Uncomment to completely isolate network
+        image,
+        "sh", "-c", command
+    ]
+    
+    return subprocess.run(
+        docker_cmd,
+        capture_output=True,
+        text=True,
+        timeout=timeout
+    )

aria_code/apps/cli/session_export.py

@@ -0,0 +1,120 @@
+"""Session export helpers for Aria Code."""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from typing import Any, Optional, Sequence
+
+from aria_code.artifacts import artifact_summary as build_artifact_summary
+from aria_code.apps.cli.config_paths import config_snapshot
+from aria_code.packages.aria_core import build_session_diagnostic_bundle
+
+
+def _safe_title_from_conversation(conversation: Sequence[dict]) -> str:
+    for msg in conversation:
+        if msg.get("role") == "user":
+            return str(msg.get("content", ""))[:60]
+    return "Aria Code Session"
+
+
+def build_session_export_payload(
+    fmt: str,
+    conversation: Sequence[dict],
+    *,
+    session_id: str = "",
+    config: Optional[dict] = None,
+    paths: Optional[dict] = None,
+    trace: Any = None,
+    provider_health: Optional[list] = None,
+    doctor_report: Any = None,
+    mcp_status: Optional[list] = None,
+    context_health: Optional[dict] = None,
+) -> tuple[str, str, str]:
+    """Return (content, extension, suggested_filename_prefix)."""
+    fmt = (fmt or "json").lower().strip()
+
+    if fmt == "json":
+        content = json.dumps(list(conversation), indent=2, ensure_ascii=False)
+        return content, "json", "aria_code_chat"
+
+    if fmt == "csv":
+        lines = ["role,content"]
+        for msg in conversation:
+            escaped = str(msg.get("content", "")).replace('"', '""').replace("\n", " ")
+            lines.append(f'{msg.get("role", "user")},"{escaped}"')
+        return "\n".join(lines), "csv", "aria_code_chat"
+
+    if fmt == "md":
+        lines = [f"# Aria Code Chat Export — {datetime.now().strftime('%Y-%m-%d %H:%M')}\n"]
+        for msg in conversation:
+            prefix = "**You:**" if msg.get("role") == "user" else "**Aria:**"
+            lines.append(f"{prefix}\n{msg.get('content', '')}\n")
+        return "\n".join(lines), "md", "aria_code_chat"
+
+    if fmt == "sft":
+        pairs = []
+        conv = list(conversation)
+        i = 0
+        while i < len(conv) - 1:
+            if conv[i].get("role") == "user" and conv[i + 1].get("role") == "assistant":
+                user_text = str(conv[i].get("content", "")).strip()
+                assistant_text = str(conv[i + 1].get("content", "")).strip()
+                if len(user_text) > 10 and len(assistant_text) > 20 and not user_text.startswith("Tool results:"):
+                    pairs.append({
+                        "instruction": user_text,
+                        "input": "",
+                        "output": assistant_text,
+                        "source": "aria_cli_export",
+                        "timestamp": datetime.now().strftime("%Y-%m-%d"),
+                    })
+                i += 2
+            else:
+                i += 1
+        if not pairs:
+            raise ValueError("No user→assistant pairs to export")
+        return json.dumps(pairs, indent=2, ensure_ascii=False), "json", "aria_sft"
+
+    if fmt == "ipynb":
+        cells = [{
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [f"# Aria Code Chat Export — {datetime.now().strftime('%Y-%m-%d %H:%M')}\n\n", "*(This notebook contains the conversation history. Math formulas and LaTeX will render natively here.)*"]
+        }]
+        for msg in conversation:
+            if msg.get("role") not in ("user", "assistant"):
+                continue
+            prefix = "**You:**\n\n" if msg.get("role") == "user" else "**Aria:**\n\n"
+            cells.append({
+                "cell_type": "markdown",
+                "metadata": {},
+                "source": [prefix + str(msg.get("content", ""))]
+            })
+        
+        notebook = {
+            "cells": cells,
+            "metadata": {
+                "kernelspec": {"display_name": "Python 3", "language": "python", "name": "python3"},
+                "language_info": {"name": "python"}
+            },
+            "nbformat": 4,
+            "nbformat_minor": 4
+        }
+        return json.dumps(notebook, indent=2, ensure_ascii=False), "ipynb", "aria_code_chat"
+
+    if fmt == "bundle":
+        bundle = build_session_diagnostic_bundle(
+            session_id=session_id,
+            conversation=conversation,
+            config=config,
+            paths=paths or config_snapshot(),
+            trace=trace,
+            provider_health=provider_health,
+            artifact_summary=build_artifact_summary(),
+            doctor_report=doctor_report,
+            mcp_status=mcp_status,
+            context_health=context_health,
+        )
+        return json.dumps(bundle, indent=2, ensure_ascii=False), "json", "aria_bundle"
+
+    raise ValueError("Unsupported export format")

aria_code/apps/cli/session_jsonl.py

@@ -0,0 +1,208 @@
+"""JSONL-backed session persistence for Aria Code.
+
+Why JSONL instead of JSON?
+  • Append-per-turn — no need to rewrite the whole file on every message
+  • Crash-safe — partial writes leave previous turns intact
+  • Streamable — readers can tail -f a live session
+
+File layout:  ~/.arthera/sessions/<session_id>.jsonl
+Each line is one JSON object:
+  {"type": "meta",    "id": "...", "title": "...", "created_at": "..."}
+  {"type": "message", "role": "user",      "content": "...", "ts": "..."}
+  {"type": "message", "role": "assistant", "content": "...", "ts": "..."}
+  {"type": "meta",    "updated_at": "..."}   ← appended on each save
+
+Reading: scan all lines, reconstruct conversation from "message" entries.
+Last "meta" wins for title / timestamps.
+"""
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+from aria_code.packages.aria_core.paths import aria_home
+
+_SESSIONS_DIR = aria_home() / "sessions"
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _session_path(session_id: str) -> Path:
+    return _SESSIONS_DIR / f"{session_id}.jsonl"
+
+
+class JsonlSessionStore:
+    """Read/write JSONL session files."""
+
+    def __init__(self, sessions_dir: Optional[Path] = None) -> None:
+        self.root = sessions_dir or _SESSIONS_DIR
+        self.root.mkdir(parents=True, exist_ok=True)
+
+    def _path(self, session_id: str) -> Path:
+        return self.root / f"{session_id}.jsonl"
+
+    # ── Write ─────────────────────────────────────────────────────────────────
+
+    def init_session(self, session_id: str, title: str = "") -> None:
+        """Write the opening meta line. Call once at session start."""
+        p = self._path(session_id)
+        if p.exists():
+            return
+        line = json.dumps({
+            "type": "meta",
+            "id": session_id,
+            "title": title or "",
+            "created_at": _now(),
+        }, ensure_ascii=False)
+        p.write_text(line + "\n", encoding="utf-8")
+
+    def append_message(self, session_id: str, role: str, content: str) -> None:
+        """Append one message turn. Thread-safe for single-process use."""
+        p = self._path(session_id)
+        line = json.dumps({
+            "type": "message",
+            "role": role,
+            "content": content,
+            "ts": _now(),
+        }, ensure_ascii=False)
+        with p.open("a", encoding="utf-8") as f:
+            f.write(line + "\n")
+
+    def flush_meta(self, session_id: str, title: str = "", extra: Optional[dict] = None) -> None:
+        """Append an updated meta line (title, timestamps)."""
+        p = self._path(session_id)
+        meta: dict = {"type": "meta", "updated_at": _now()}
+        if title:
+            meta["title"] = title
+        if extra:
+            meta.update(extra)
+        with p.open("a", encoding="utf-8") as f:
+            f.write(json.dumps(meta, ensure_ascii=False) + "\n")
+
+    def save_conversation(
+        self,
+        session_id: str,
+        conversation: list[dict],
+        title: str = "",
+    ) -> None:
+        """Full rewrite — used when bulk-importing a JSON session into JSONL."""
+        p = self._path(session_id)
+        lines = []
+        lines.append(json.dumps({
+            "type": "meta",
+            "id": session_id,
+            "title": title or "",
+            "created_at": _now(),
+            "updated_at": _now(),
+        }, ensure_ascii=False))
+        for msg in conversation:
+            lines.append(json.dumps({
+                "type": "message",
+                "role": msg.get("role", "user"),
+                "content": str(msg.get("content", "")),
+                "ts": _now(),
+            }, ensure_ascii=False))
+        p.write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+    # ── Read ──────────────────────────────────────────────────────────────────
+
+    def load_session(self, session_id: str) -> Optional[dict]:
+        """Load a session; returns None if not found."""
+        p = self._path(session_id)
+        if not p.exists():
+            return None
+
+        messages: list[dict] = []
+        meta: dict = {"id": session_id}
+
+        for raw in p.read_text(encoding="utf-8").splitlines():
+            raw = raw.strip()
+            if not raw:
+                continue
+            try:
+                obj = json.loads(raw)
+            except json.JSONDecodeError:
+                continue
+
+            t = obj.get("type")
+            if t == "meta":
+                meta.update({k: v for k, v in obj.items() if k != "type"})
+            elif t == "message":
+                messages.append({
+                    "role": obj.get("role", "user"),
+                    "content": obj.get("content", ""),
+                })
+
+        return {
+            "id": session_id,
+            "messages": messages,
+            "metadata": {
+                "title": meta.get("title", "Untitled"),
+                "created_at": meta.get("created_at", ""),
+                "updated_at": meta.get("updated_at", ""),
+            },
+        }
+
+    def list_sessions(self, limit: int = 20) -> list[dict]:
+        """Return recent sessions sorted by mtime, newest first."""
+        sessions = []
+        for p in sorted(
+            self.root.glob("*.jsonl"),
+            key=lambda x: x.stat().st_mtime,
+            reverse=True,
+        ):
+            session_id = p.stem
+            meta: dict = {}
+            msg_count = 0
+            try:
+                for raw in p.read_text(encoding="utf-8").splitlines():
+                    raw = raw.strip()
+                    if not raw:
+                        continue
+                    obj = json.loads(raw)
+                    if obj.get("type") == "meta":
+                        meta.update(obj)
+                    elif obj.get("type") == "message":
+                        msg_count += 1
+            except Exception:
+                continue
+
+            sessions.append({
+                "id": session_id,
+                "title": meta.get("title", "Untitled"),
+                "messages": msg_count,
+                "updated": meta.get("updated_at", ""),
+                "created": meta.get("created_at", ""),
+            })
+            if len(sessions) >= limit:
+                break
+
+        return sessions
+
+    def delete_session(self, session_id: str) -> bool:
+        p = self._path(session_id)
+        if p.exists():
+            p.unlink()
+            return True
+        return False
+
+    def search_sessions(self, keyword: str, limit: int = 10) -> list[dict]:
+        """Full-text search across all session JSONL files."""
+        kw = keyword.lower()
+        matches = []
+        for p in self.root.glob("*.jsonl"):
+            try:
+                text = p.read_text(encoding="utf-8")
+                if kw not in text.lower():
+                    continue
+                result = self.load_session(p.stem)
+                if result:
+                    matches.append(result)
+            except Exception:
+                continue
+            if len(matches) >= limit:
+                break
+        return matches

aria_code/apps/cli/session_refresh.py

@@ -0,0 +1,123 @@
+"""Keep a Firebase sign-in alive the way Claude Code and Codex keep theirs.
+
+A Firebase ID token lasts an hour. /login stores it with a refresh token, but
+nothing used the refresh token, so an hour after signing in every gateway call
+failed and the user was told to /login again. Claude Code and Codex do not ask:
+they exchange the refresh token for a new access token shortly before the old
+one expires and carry on.
+
+This does the same against Firebase's Secure Token API, which accepts the
+project's public web API key (the one the web and desktop clients ship; see
+google_login.FIREBASE_WEB_API_KEY) and the user's refresh token. The result is
+written back to config.json with owner-only permissions, so every process that
+reads the session, the gateway provider and the Commerce plugin among them,
+sees the fresh token.
+
+Failure is deliberately quiet: if the refresh cannot happen (offline, token
+revoked) the stored token is returned unchanged, the request fails with the
+gateway's own 401, and /login remains the way back in.
+"""
+
+from __future__ import annotations
+
+import json
+import urllib.parse
+import urllib.request
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any, Callable, Dict, Optional
+
+SECURE_TOKEN_URL = "https://securetoken.googleapis.com/v1/token"
+
+#: Refresh when the token has this long or less left, so a request that starts
+#: just before expiry is not sent with a token that dies in flight.
+REFRESH_WITHIN_SECONDS = 300
+
+
+def _parse_expiry(value: Any) -> Optional[datetime]:
+    if not value:
+        return None
+    try:
+        return datetime.fromisoformat(str(value).replace("Z", "+00:00"))
+    except ValueError:
+        return None
+
+
+def needs_refresh(config: Dict[str, Any], now: Optional[datetime] = None) -> bool:
+    """True when the stored token is expired or about to be, and can be renewed."""
+    if not config.get("auth_token") or not config.get("refresh_token"):
+        return False
+    expires = _parse_expiry(config.get("token_expires_at"))
+    if expires is None:
+        # A login from before expiry was recorded: nothing to compare against,
+        # so leave it alone rather than refresh on every call.
+        return False
+    now = now or datetime.now(timezone.utc)
+    return expires - now <= timedelta(seconds=REFRESH_WITHIN_SECONDS)
+
+
+def exchange_refresh_token(refresh_token: str, api_key: str, *, timeout: int = 15,
+                           opener: Callable = urllib.request.urlopen) -> Dict[str, Any]:
+    """Trade a refresh token for a new ID token. Raises on any failure."""
+    body = urllib.parse.urlencode({"grant_type": "refresh_token", "refresh_token": refresh_token}).encode()
+    request = urllib.request.Request(
+        f"{SECURE_TOKEN_URL}?key={urllib.parse.quote(api_key)}", data=body,
+        headers={"Content-Type": "application/x-www-form-urlencoded"}, method="POST",
+    )
+    with opener(request, timeout=timeout) as response:
+        return json.loads(response.read().decode("utf-8"))
+
+
+def refresh_config_file(path: Path, *, now: Optional[datetime] = None,
+                        exchange: Optional[Callable[[str, str], Dict[str, Any]]] = None) -> Optional[str]:
+    """Renew the session stored in `path` if it is due; return the token to use.
+
+    Returns the current (possibly just refreshed) ID token, or None when there
+    is no session. Never raises: a failed refresh returns the stored token.
+    """
+    try:
+        config = json.loads(Path(path).read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    token = config.get("auth_token")
+    token = str(token) if token else None
+    if not token or not needs_refresh(config, now):
+        return token
+
+    from .google_login import FIREBASE_WEB_API_KEY
+
+    try:
+        result = (exchange or exchange_refresh_token)(str(config["refresh_token"]), FIREBASE_WEB_API_KEY)
+        new_token = result.get("id_token") or result.get("idToken")
+        if not new_token:
+            return token
+        # Do not let a slow refresh for account A replace a later login to B.
+        target = Path(path)
+        current = json.loads(target.read_text(encoding="utf-8"))
+        keys = ("user_id", "auth_token", "refresh_token")
+        if any(current.get(key) != config.get(key) for key in keys):
+            return None
+        if config.get("user_id") and result.get("user_id") and result["user_id"] != config["user_id"]:
+            return None
+        config["auth_token"] = new_token
+        if result.get("refresh_token") or result.get("refreshToken"):
+            config["refresh_token"] = result.get("refresh_token") or result.get("refreshToken")
+        seconds = int(result.get("expires_in") or result.get("expiresIn") or 3600)
+        stamp = (now or datetime.now(timezone.utc)) + timedelta(seconds=seconds)
+        config["token_expires_at"] = stamp.isoformat().replace("+00:00", "Z")
+        from aria_code.packages.aria_core.secure_file import write_secret_json
+
+        # Replace the file in one step: this is the whole config, and a crash
+        # halfway through an in-place write would lose every setting in it.
+        target = Path(path)
+        scratch = target.with_name(target.name + ".refresh")
+        write_secret_json(scratch, config)
+        import os
+
+        os.replace(scratch, target)
+        return str(new_token)
+    except Exception:
+        return token
+
+
+__all__ = ["needs_refresh", "refresh_config_file", "exchange_refresh_token", "REFRESH_WITHIN_SECONDS"]

aria_code/apps/cli/session_store.py

@@ -0,0 +1,125 @@
+"""JSON-backed session persistence for Aria Code."""
+
+from __future__ import annotations
+
+import os
+import json
+import tempfile
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+from aria_code.apps.cli.config_paths import resolve_config_dir
+
+
+class SessionManager:
+    """Manage chat sessions with local file persistence."""
+
+    def __init__(self, sessions_dir: Optional[Path] = None):
+        self.root = sessions_dir or (resolve_config_dir() / "sessions")
+        self.root.mkdir(parents=True, exist_ok=True)
+
+    def _path(self, session_id: str) -> Path:
+        return self.root / f"{session_id}.json"
+
+    def save_session(self, session_id: str, conversation: list, metadata: dict = None):
+        meta = dict(metadata or {})
+        if not meta.get("created_at"):
+            meta["created_at"] = datetime.now().isoformat()
+        for msg in conversation:
+            if msg.get("role") == "user":
+                meta.setdefault("title", str(msg.get("content", ""))[:60])
+                break
+        data = {
+            "id": session_id,
+            "messages": conversation,
+            "metadata": meta,
+            "updated_at": datetime.now().isoformat(),
+        }
+        path = self._path(session_id)
+        # A killed terminal must leave either the prior session or the new
+        # one, never a half-written JSON file that cannot be resumed.
+        temporary = None
+        try:
+            with tempfile.NamedTemporaryFile(mode="w", encoding="utf-8", dir=self.root,
+                                             prefix=".session-", suffix=".tmp", delete=False) as f:
+                temporary = f.name
+                json.dump(data, f, indent=2, ensure_ascii=False)
+                f.flush()
+                os.fsync(f.fileno())
+            os.replace(temporary, path)
+        finally:
+            if temporary and os.path.exists(temporary):
+                os.unlink(temporary)
+
+    def load_session(self, session_id: str) -> Optional[dict]:
+        path = self._path(session_id)
+        if path.exists():
+            with open(path, encoding="utf-8") as f:
+                return json.load(f)
+        return None
+
+    def list_sessions(self, limit: int = 20) -> list:
+        sessions = []
+        for path in sorted(self.root.glob("*.json"), key=lambda p: p.stat().st_mtime, reverse=True):
+            try:
+                with open(path, encoding="utf-8") as f:
+                    data = json.load(f)
+                sessions.append({
+                    "id": data.get("id", path.stem),
+                    "title": data.get("metadata", {}).get("title", "Untitled"),
+                    "messages": len(data.get("messages", [])),
+                    "updated": data.get("updated_at", ""),
+                })
+            except Exception:
+                continue
+            if len(sessions) >= limit:
+                break
+        return sessions
+
+    def search_sessions(self, query: str, limit: int = 20) -> list:
+        """Full-text search through session message content."""
+        q = query.lower()
+        results = []
+        for path in sorted(self.root.glob("*.json"), key=lambda p: p.stat().st_mtime, reverse=True):
+            try:
+                with open(path, encoding="utf-8") as f:
+                    data = json.load(f)
+                messages = data.get("messages", [])
+                hits = []
+                for msg in messages:
+                    content = msg.get("content", "")
+                    if isinstance(content, str):
+                        if q in content.lower():
+                            idx = content.lower().index(q)
+                            start = max(0, idx - 20)
+                            end = min(len(content), idx + len(q) + 80)
+                            hits.append(content[start:end])
+                    elif isinstance(content, list):
+                        for block in content:
+                            if isinstance(block, dict):
+                                text = block.get("text", "")
+                                if text and q in text.lower():
+                                    idx = text.lower().index(q)
+                                    start = max(0, idx - 20)
+                                    end = min(len(text), idx + len(q) + 80)
+                                    hits.append(text[start:end])
+                if hits:
+                    results.append({
+                        "id": data.get("id", path.stem),
+                        "title": data.get("metadata", {}).get("title", "Untitled"),
+                        "updated": data.get("updated_at", ""),
+                        "match_count": len(hits),
+                        "preview": hits[0],
+                    })
+            except Exception:
+                continue
+            if len(results) >= limit:
+                break
+        return sorted(results, key=lambda r: r["match_count"], reverse=True)
+
+    def delete_session(self, session_id: str) -> bool:
+        path = self._path(session_id)
+        if path.exists():
+            path.unlink()
+            return True
+        return False