aria-code 0.161.0__tar.gz → 0.163.0__tar.gz

{aria_code-0.161.0/src/aria_code.egg-info → aria_code-0.163.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.161.0
+Version: 0.163.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
@@ -172,7 +172,7 @@ Numbers you can check, client data kept apart, actions a person approves.</p>
 <p align="center">
   <a href="https://www.npmjs.com/package/@artheras/aria-code"><img src="https://img.shields.io/npm/v/@artheras/aria-code/latest?style=flat-square&logo=npm&label=npm" alt="npm version"></a>
   <!-- Release automation pins PyPI: the default endpoint still selects legacy 4.x. -->
-  <a href="https://pypi.org/project/aria-code/0.161.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.161.0%2Fjson&amp;query=%24.info.version&amp;prefix=v&amp;style=flat-square&amp;logo=pypi&amp;label=PyPI&amp;color=blue&amp;cacheSeconds=300" alt="PyPI version"></a>
+  <a href="https://pypi.org/project/aria-code/0.163.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.163.0%2Fjson&amp;query=%24.info.version&amp;prefix=v&amp;style=flat-square&amp;logo=pypi&amp;label=PyPI&amp;color=blue&amp;cacheSeconds=300" alt="PyPI version"></a>
   <a href="https://github.com/artheras/aria-code/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/artheras/aria-code/ci.yml?branch=main&style=flat-square&logo=githubactions&label=CI" alt="CI status"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-Apache%202.0-64748b?style=flat-square" alt="Apache License 2.0"></a>
 </p>

{aria_code-0.161.0 → aria_code-0.163.0}/README.md

@@ -15,7 +15,7 @@ Numbers you can check, client data kept apart, actions a person approves.</p>
 <p align="center">
   <a href="https://www.npmjs.com/package/@artheras/aria-code"><img src="https://img.shields.io/npm/v/@artheras/aria-code/latest?style=flat-square&logo=npm&label=npm" alt="npm version"></a>
   <!-- Release automation pins PyPI: the default endpoint still selects legacy 4.x. -->
-  <a href="https://pypi.org/project/aria-code/0.161.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.161.0%2Fjson&amp;query=%24.info.version&amp;prefix=v&amp;style=flat-square&amp;logo=pypi&amp;label=PyPI&amp;color=blue&amp;cacheSeconds=300" alt="PyPI version"></a>
+  <a href="https://pypi.org/project/aria-code/0.163.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.163.0%2Fjson&amp;query=%24.info.version&amp;prefix=v&amp;style=flat-square&amp;logo=pypi&amp;label=PyPI&amp;color=blue&amp;cacheSeconds=300" alt="PyPI version"></a>
   <a href="https://github.com/artheras/aria-code/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/artheras/aria-code/ci.yml?branch=main&style=flat-square&logo=githubactions&label=CI" alt="CI status"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-Apache%202.0-64748b?style=flat-square" alt="Apache License 2.0"></a>
 </p>

{aria_code-0.161.0 → aria_code-0.163.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aria-code"
-version = "0.161.0"
+version = "0.163.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.161.0 → aria_code-0.163.0}/src/aria_code/_version.py

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

{aria_code-0.161.0 → aria_code-0.163.0}/src/aria_code/apps/cli/app_server.py

@@ -285,6 +285,9 @@ class Server:
         # The host draws its own turn footer. Keep this presentation flag out
         # of saved user settings and retain normal Python CLI behaviour.
         terminal._native_frontend = True
+        # Commands that need a choice (/model) draw it in the host's own menu.
+        # This process's stdin is a pipe, so the TTY arrow picker can never run.
+        terminal._native_select = self.select
         execute = terminal.tool_executor.execute_local
         def tracked(*args, **kwargs):
             with self.tool_lock:

{aria_code-0.161.0 → aria_code-0.163.0}/src/aria_code/apps/cli/bootstrap.py

@@ -154,10 +154,8 @@ DEFAULT_MODEL = os.getenv("ARIA_DEFAULT_MODEL", "google/gemini-3.5-flash")
 
 def default_config() -> dict:
     return {
-        "api_url": os.getenv(
-            "ARTHERA_API_URL",
-            "http://localhost:8000",
-        ),
+        # The Arthera backend and gateway. Not localhost: see endpoint_migration.
+        "api_url": os.getenv("ARTHERA_API_URL", "").strip() or "https://api.arthera.xyz",
         "local_url": "http://localhost:8000",
         "ollama_url": os.getenv("OLLAMA_URL", "http://localhost:11434"),
         # Which backend serves a bare, unprefixed model name. Only consulted

{aria_code-0.161.0 → aria_code-0.163.0}/src/aria_code/apps/cli/commands/auth_cmds.py

@@ -145,18 +145,25 @@ class AuthCommandsMixin:
         """
         import asyncio as _asyncio
 
-        from ..google_login import run_google_login
+        from ..google_login import login_api_url, run_google_login
+        import os as _os
+
+        from ..web_login import run_web_login
 
         rich = self.context.has_rich
+        api_url = login_api_url(self.terminal.api_url)
         self.context.console.print(
             "[dim]Opening your browser to sign in or create an account…[/dim]"
             if rich else "Opening your browser to sign in or create an account…"
         )
 
         try:
-            session = await _asyncio.to_thread(
-                run_google_login, self.terminal.api_url
-            )
+            # The account page (a choice of Google, Apple or email, with sign-up)
+            # is opt-in until it is deployed; until then this goes straight to Google.
+            if _os.getenv("ARIA_LOGIN_PAGE") == "1":
+                session = await _asyncio.to_thread(run_web_login, api_url)
+            else:
+                session = await _asyncio.to_thread(run_google_login, api_url)
         except RuntimeError as exc:
             print_error(self.context, str(exc), "login")
             return

{aria_code-0.161.0 → aria_code-0.163.0}/src/aria_code/apps/cli/commands/model_cmds.py

@@ -387,6 +387,8 @@ class ModelCommandsMixin:
             _term_cols = os.get_terminal_size().columns
         except Exception:
             _term_cols = 80
+        if getattr(self.terminal, "_native_select", None) is not None:
+            _term_cols = 110  # the host's menu is about this wide; not a TTY to measure
 
         def _cjk_width(s: str) -> int:
             """Display-column width (CJK = 2 cols each)."""
@@ -448,6 +450,19 @@ class ModelCommandsMixin:
         options: list = []   # (label_str, desc_str)  for _arrow_select
         all_ids: list = []
 
+        # ── Native frontend: pick in the host's menu, not from a printed list ─
+        # Arrow keys and Enter, the way Claude and ChatGPT do it. The list used
+        # to be printed and the user had to type a number back.
+        native_select = getattr(self.terminal, "_native_select", None)
+        if native_select is not None and not name:
+            await self._pick_model_in_host(
+                native_select, picker_title=_picker_title, current_id=current_id,
+                current_provider=current_provider, rich_models=rich_models,
+                aria_ids=aria_ids, status_tag=_status_tag, short_desc=_short_desc,
+                lang=_lang,
+            )
+            return
+
         # ── Print numbered list only in non-interactive (-p) mode ────────────
         # In interactive TTY mode the arrow picker below already shows all items.
         # Printing twice causes the visual duplication seen in the session log.
@@ -570,6 +585,49 @@ class ModelCommandsMixin:
 
         self._set_model_by_id(all_ids[choice], provider=current_provider)
 
+    async def _pick_model_in_host(self, native_select, *, picker_title, current_id, current_provider,
+                                  rich_models, aria_ids, status_tag, short_desc, lang):
+        """Offer every model in the frontend's menu and apply the choice.
+
+        One row per model: the name (with a mark for the current one and for
+        whether it is installed) and, beneath it, what it is for and its
+        limits. Aria's catalogue comes first, then community Ollama models.
+        """
+        zh = str(lang).lower().startswith("zh")
+        rows: list = []  # (model_id, label, help)
+        for m in _get_MODELS().values():
+            mid = m["id"]
+            tags = short_desc(m)
+            current = ("  ✓ 当前" if zh else "  ✓ current") if mid == current_id else ""
+            rows.append((mid, f"{status_tag(mid, m.get('badge', ''))} {m['name']}{current}", tags))
+        if current_provider == "ollama":
+            for cm in rich_models:
+                if cm["name"] in aria_ids:
+                    continue
+                current = ("  ✓ 当前" if zh else "  ✓ current") if cm["name"] == current_id else ""
+                rows.append((cm["name"], f"● {cm['name']}{current}", "社区模型 (Ollama)" if zh else "Community model (Ollama)"))
+        if not rows:
+            return
+        start = next((i for i, row in enumerate(rows) if row[0] == current_id), 0)
+        options = [(label, help_text) for _mid, label, help_text in rows]
+        # select() blocks on the user's answer, so keep it off the event loop.
+        import asyncio as _asyncio
+
+        try:
+            choice = await _asyncio.to_thread(native_select, options, start, picker_title)
+        except (KeyboardInterrupt, ValueError):
+            choice = -1
+        if not isinstance(choice, int) or not 0 <= choice < len(rows):
+            msg = "已取消，模型未改变。" if zh else "Cancelled; the model is unchanged."
+            self.context.console.print(f"[dim]{msg}[/dim]" if self.context.has_rich else msg)
+            return
+        chosen = rows[choice][0]
+        if "/" in chosen:
+            # provider/model: the route that checks credentials and sets the provider.
+            await self.cmd_model(chosen)
+        else:
+            self._set_model_by_id(chosen)
+
     def _set_model(self, key: str):
         """Set model by _get_MODELS() key."""
         m = _get_MODELS()[key]

{aria_code-0.161.0 → aria_code-0.163.0}/src/aria_code/apps/cli/config_store.py

@@ -66,6 +66,16 @@ def load_cli_config(
     """
     service = build_settings_service(paths, defaults, sync_policy=sync_policy)
     config = service.load()
+    # The old localhost default is replaced once; see endpoint_migration.
+    from aria_code.apps.cli.endpoint_migration import migrate_config as migrate_endpoint
+
+    moved = migrate_endpoint(config)
+    if moved:
+        try:
+            service.save(config)
+        except Exception:
+            pass
+        _announce_endpoint(moved, config)
     # A model Google has retired fails on every request. The user's own saved
     # choice is replaced once and written back; see model_retirement.
     from aria_code.apps.cli.model_retirement import migrate_config
@@ -93,6 +103,27 @@ def load_cli_config(
 _ANNOUNCED: set[tuple[str, str]] = set()
 
 
+def _announce_endpoint(changes, config: dict) -> None:
+    """Say once per process that the old localhost default was replaced."""
+    import sys
+
+    zh = str(config.get("ui_lang", "")).lower().startswith("zh")
+    for _key, old, new in changes:
+        if (old, new) in _ANNOUNCED:
+            continue
+        _ANNOUNCED.add((old, new))
+        if zh:
+            msg = (f"ℹ 服务器地址 {old} 是旧版默认值，已改为 {new}。"
+                   "如需使用本机后端，请设置环境变量 ARTHERA_API_URL，或在配置里加 api_url_pinned: true。")
+        else:
+            msg = (f"ℹ The server address {old} was the old default and is now {new}. "
+                   "For a local backend set ARTHERA_API_URL, or add api_url_pinned: true to the config.")
+        try:
+            print(msg, file=sys.stderr)
+        except Exception:
+            pass
+
+
 def _announce(changes, config: dict, *, pinned: bool) -> None:
     """One line on stderr per retired model, once per process."""
     import sys

aria_code-0.163.0/src/aria_code/apps/cli/endpoint_migration.py

@@ -0,0 +1,58 @@
+"""The server an install talks to, and the old default that stranded it on localhost.
+
+``default_config()`` used to save ``api_url = http://localhost:8000``. That
+looked like a default but was written into every user's config.json on first
+run, where it became indistinguishable from a choice. Anyone who installed
+from GitHub then had every backend call, and Google sign-in, aimed at a
+developer backend on their own machine: a refused connection, or on a machine
+that happened to run one, a page reading ``{"detail":"Not Found"}``. Fixing the
+default in code cannot reach a config that already holds the old value, so the
+old default is recognised here and replaced once, written back and announced,
+the same way a retired model is (see model_retirement).
+
+What counts as a choice and is left alone:
+
+* ``ARTHERA_API_URL`` in the environment, which now also overrides a saved value
+  (in memory only), so a developer with a real local backend sets it once;
+* any ``api_url`` other than the exact old default, such as a staging server;
+* ``api_url_pinned: true``, an escape hatch for someone who wants localhost.
+
+``local_mode`` is not touched: choosing a local model is a different decision
+from where the backend lives.
+"""
+
+from __future__ import annotations
+
+import os
+
+PRODUCTION_API_URL = "https://api.arthera.xyz"
+LEGACY_DEFAULT_API_URL = "http://localhost:8000"
+# The product moved from arthera.finance to arthera.xyz and the old domain no
+# longer answers, so a config that was migrated to (or installed with) the old
+# production address points at nothing. It is replaced the same way the
+# localhost default is.
+RETIRED_API_URLS = ("http://localhost:8000", "https://api.arthera.finance")
+
+
+def _norm(url: object) -> str:
+    return str(url or "").strip().rstrip("/").lower()
+
+
+def migrate_config(config: dict) -> list[tuple[str, str, str]]:
+    """Move the old localhost default to production in place; return (key, old, new)."""
+    env = os.getenv("ARTHERA_API_URL", "").strip()
+    if env:
+        # An explicit environment choice wins over the file for this run only;
+        # nothing is rewritten, so unsetting the variable restores the file.
+        config["api_url"] = env.rstrip("/")
+        return []
+    if config.get("api_url_pinned"):
+        return []
+    old = config.get("api_url")
+    if _norm(old) not in RETIRED_API_URLS:
+        return []
+    config["api_url"] = PRODUCTION_API_URL
+    return [("api_url", str(old), PRODUCTION_API_URL)]
+
+
+__all__ = ["LEGACY_DEFAULT_API_URL", "PRODUCTION_API_URL", "RETIRED_API_URLS", "migrate_config"]

{aria_code-0.161.0 → aria_code-0.163.0}/src/aria_code/apps/cli/google_login.py

@@ -116,6 +116,47 @@ def exchange_google_token_for_firebase(google_id_token: str) -> Dict[str, Any]:
     )
 
 
+def login_api_url(configured: str) -> str:
+    """Which server serves Google sign-in for this install.
+
+    Sign-in is a route of the Arthera gateway, and the credential it returns is
+    used against that gateway. The saved ``api_url`` is something else: a
+    fresh install writes ``http://localhost:8000`` there, a developer backend
+    that has no such route, so /login opened a browser on a page reading
+    ``{"detail":"Not Found"}`` (or on a refused connection when nothing listens).
+
+    ``ARIA_API_URL`` wins, as it does for the gateway provider. Otherwise a
+    loopback ``api_url`` means "no real server was ever configured" and the
+    production gateway is used. Any other configured server is respected.
+    """
+    import os
+
+    from ...providers.llm.arthera_gateway import DEFAULT_API_URL
+
+    override = os.getenv("ARIA_API_URL", "").strip()
+    if override:
+        return override.rstrip("/")
+    host = (urllib.parse.urlparse(configured or "").hostname or "").lower()
+    if not configured or host in {"localhost", "127.0.0.1", "::1", "0.0.0.0"}:
+        return DEFAULT_API_URL
+    return configured.rstrip("/")
+
+
+def login_page_origin(api_url: str) -> str:
+    """Where the browser is sent to sign in.
+
+    The same Arthera login route is also served on the brand's auth host
+    (auth.arthera.xyz), so the address bar can read like the product, the
+    way Claude Code and Codex open their own accounts site, rather than an API
+    hostname. Opt-in with ARIA_AUTH_URL until that path has been exercised end
+    to end; the handoff exchange below always goes to the API origin.
+    """
+    import os
+
+    override = os.getenv("ARIA_AUTH_URL", "").strip()
+    return (override or api_url).rstrip("/")
+
+
 def run_google_login(api_url: str, region: str = "GLOBAL") -> Dict[str, Any]:
     """Drive the whole flow and return the stored-credential fields.
 
@@ -134,7 +175,7 @@ def run_google_login(api_url: str, region: str = "GLOBAL") -> Dict[str, Any]:
 
     try:
         login_url = (
-            f"{api_url}/api/v2/auth/google/login?"
+            f"{login_page_origin(api_url)}/api/v2/auth/google/login?"
             + urllib.parse.urlencode(
                 {"platform": "cli", "region": region, "port": port}
             )
@@ -193,4 +234,4 @@ def run_google_login(api_url: str, region: str = "GLOBAL") -> Dict[str, Any]:
     }
 
 
-__all__ = ["run_google_login", "exchange_google_token_for_firebase"]
+__all__ = ["run_google_login", "exchange_google_token_for_firebase", "login_api_url", "login_page_origin"]

aria_code-0.163.0/src/aria_code/apps/cli/session_refresh.py

@@ -0,0 +1,115 @@
+"""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
+        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-0.163.0/src/aria_code/apps/cli/web_login.py

@@ -0,0 +1,135 @@
+"""Sign in through the account page, the way Claude Code and Codex do.
+
+``/login`` opens a page on Arthera's own auth host. The user chooses how to sign
+in there (Google, Apple or email, and email can be a new account) and the page
+hands the session back to this process on a loopback port. Nothing is typed in
+the terminal and no provider is chosen for the user.
+
+The hand-back is bound to this process, not merely to "whoever is listening":
+
+* ``state`` is random and checked on the way back, so a callback this run did
+  not start is ignored;
+* a PKCE ``code_verifier`` stays here; only its SHA-256 goes into the page. The
+  one-time code in the redirect is useless without it, so a program that sees
+  the redirect cannot redeem it;
+* the credential never appears in a URL. The redirect carries a short code and
+  the session is fetched over POST.
+
+Page: the /cli-login route of apps/web. Server side: apps/api/src/routes/auth_v2_routes.py
+(/cli/handoff, /cli/exchange).
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import http.server
+import os
+import secrets
+import threading
+import urllib.parse
+import webbrowser
+from typing import Any, Dict
+
+from .google_login import _CallbackResult, _free_port, _post_json
+
+# The apex is Firebase Hosting and the Firebase auth domain, so the page and the
+# sign-in popup are same-origin there.
+AUTH_ORIGIN = "https://arthera.xyz"
+LOGIN_PATH = "/cli-login"
+_TIMEOUT_SECONDS = 300
+
+
+def auth_origin() -> str:
+    """The host that serves the sign-in page. ARIA_AUTH_URL overrides it for staging."""
+    return (os.getenv("ARIA_AUTH_URL", "").strip() or AUTH_ORIGIN).rstrip("/")
+
+
+def pkce_pair() -> tuple[str, str]:
+    """A code verifier and its S256 challenge (RFC 7636)."""
+    verifier = secrets.token_urlsafe(48)  # 64 characters, inside the 43-128 the spec allows
+    digest = hashlib.sha256(verifier.encode("ascii")).digest()
+    return verifier, base64.urlsafe_b64encode(digest).rstrip(b"=").decode("ascii")
+
+
+def _handler(result: _CallbackResult, state: str):
+    class Handler(http.server.BaseHTTPRequestHandler):
+        def do_GET(self):  # noqa: N802 - name fixed by BaseHTTPRequestHandler
+            parsed = urllib.parse.urlparse(self.path)
+            params = {k: v[0] for k, v in urllib.parse.parse_qs(parsed.query).items()}
+            if parsed.path != "/callback" or not secrets.compare_digest(params.get("state", ""), state):
+                # Not this run's callback: ignore it and keep waiting for ours.
+                self.send_response(404)
+                self.end_headers()
+                return
+            ok = "handoff_code" in params
+            body = (
+                "<html><body style='font-family:system-ui;padding:3rem'>"
+                f"<h2>{'Signed in.' if ok else 'Sign-in failed.'}</h2>"
+                "<p>You can close this tab and return to the terminal.</p>"
+                "</body></html>"
+            ).encode("utf-8")
+            self.send_response(200 if ok else 400)
+            self.send_header("Content-Type", "text/html; charset=utf-8")
+            self.send_header("Content-Length", str(len(body)))
+            self.send_header("Referrer-Policy", "no-referrer")
+            self.send_header("Cache-Control", "no-store")
+            self.end_headers()
+            self.wfile.write(body)
+            result.params = params
+            result.received.set()
+
+        def log_message(self, *args):  # keep the terminal clean
+            return
+
+    return Handler
+
+
+def run_web_login(api_url: str, *, open_browser=webbrowser.open, timeout: int = _TIMEOUT_SECONDS) -> Dict[str, Any]:
+    """Drive the whole flow; return the stored-credential fields.
+
+    Raises RuntimeError with a message suitable for display on any failure.
+    """
+    api_url = api_url.rstrip("/")
+    port = _free_port()
+    state = secrets.token_urlsafe(24)
+    verifier, challenge = pkce_pair()
+    result = _CallbackResult()
+    server = http.server.HTTPServer(("127.0.0.1", port), _handler(result, state))
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    try:
+        url = f"{auth_origin()}{LOGIN_PATH}?" + urllib.parse.urlencode(
+            {"port": port, "state": state, "code_challenge": challenge, "code_challenge_method": "S256"}
+        )
+        if not open_browser(url):
+            raise RuntimeError("Could not open a browser. Visit this URL manually:\n  " + url)
+        if not result.received.wait(timeout=timeout):
+            raise RuntimeError(f"Timed out after {timeout}s waiting for the browser.")
+    finally:
+        server.shutdown()
+        server.server_close()
+
+    code = result.params.get("handoff_code")
+    if not code:
+        raise RuntimeError(result.params.get("message") or "The sign-in did not carry a handoff code.")
+    try:
+        reply = _post_json(f"{api_url}/api/v2/auth/cli/exchange",
+                           {"code": code, "code_verifier": verifier, "state": state})
+    except Exception as exc:
+        raise RuntimeError(f"Could not redeem the sign-in: {exc}") from exc
+    data = reply.get("data") or {}
+    if not data.get("auth_token"):
+        raise RuntimeError("The sign-in did not return a session.")
+    return {
+        "auth_token": data["auth_token"],
+        "refresh_token": data.get("refresh_token"),
+        "expires_in": str(data["expires_in"]) if data.get("expires_in") is not None else None,
+        "user_id": data.get("user_id"),
+        "email": data.get("email"),
+        "display_name": data.get("display_name"),
+        "provider": "firebase",
+    }
+
+
+__all__ = ["run_web_login", "pkce_pair", "auth_origin", "AUTH_ORIGIN"]

{aria_code-0.161.0 → aria_code-0.163.0}/src/aria_code/mcp_client.py

@@ -159,15 +159,53 @@ class MCPServer:
                         else:
                             fut.set_result(msg.get("result"))
         except asyncio.CancelledError:
-            pass
+            return  # stop() cancelled us; nothing is waiting on an answer
         except Exception as exc:
             logger.debug("[MCP:%s] Reader loop error: %s", self.name, exc)
+        # stdout closed: the server has exited. Nothing can answer a request that
+        # is still waiting, so fail those now. Without this, a server that
+        # refuses to start (a missing environment variable, say) is waited on
+        # for the whole timeout, 30 s at every launch, and the reason it gave on
+        # stderr is never shown.
+        await self._fail_pending()
+
+    async def _fail_pending(self):
+        reason = await self._exit_reason()
+        for rid, fut in list(self._pending.items()):
+            self._pending.pop(rid, None)
+            if not fut.done():
+                fut.set_exception(RuntimeError(f"MCP server {self.name!r} exited before answering{reason}"))
+
+    async def _exit_reason(self) -> str:
+        """Exit code and the server's own last words, for the error message."""
+        proc = self._proc
+        if proc is None:
+            return ""
+        try:
+            code = await asyncio.wait_for(proc.wait(), timeout=2)
+        except Exception:
+            code = None
+        said = ""
+        try:
+            if proc.stderr is not None:
+                said = (await asyncio.wait_for(proc.stderr.read(2000), timeout=1)).decode("utf-8", errors="ignore").strip()
+        except Exception:
+            pass
+        said = " ".join(said.split())[:300]
+        detail = f" (exit {code})" if code is not None else ""
+        return f"{detail}: {said}" if said else detail
 
     async def _request(self, method: str, params: Any = None) -> Any:
+        if self._proc is not None and self._proc.returncode is not None:
+            raise RuntimeError(f"MCP server {self.name!r} has exited (exit {self._proc.returncode})")
         rid = self._next_id()
         fut = asyncio.get_event_loop().create_future()
         self._pending[rid] = fut
-        await self._send(_make_request(method, params, rid))
+        try:
+            await self._send(_make_request(method, params, rid))
+        except (BrokenPipeError, ConnectionResetError) as exc:
+            self._pending.pop(rid, None)
+            raise RuntimeError(f"MCP server {self.name!r} closed its input: {exc}") from exc
         try:
             return await asyncio.wait_for(fut, timeout=self.timeout)
         except asyncio.TimeoutError: