aria-code 0.71.0__tar.gz → 0.73.0__tar.gz

{aria_code-0.71.0/src/aria_code.egg-info → aria_code-0.73.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.71.0
+Version: 0.73.0
 Summary: Open-source AI agent for logistics and finance work: 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.71.0 → aria_code-0.73.0}/pyproject.toml

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

{aria_code-0.71.0 → aria_code-0.73.0}/src/aria_code/_version.py

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

{aria_code-0.71.0 → aria_code-0.73.0}/src/aria_code/apps/cli/hooks.py

@@ -170,7 +170,7 @@ def create_example_hooks(path: Path) -> None:
         return
     path.parent.mkdir(parents=True, exist_ok=True)
     example = {
-        "_comment": "Aria Code hooks — https://aria.code/docs/hooks",
+        "_comment": "Aria Code hooks — schema: https://github.com/artheras/aria-code/blob/main/src/aria_code/apps/cli/hooks.py",
         "PreToolUse": [],
         "PostToolUse": [],
         "ResponseDone": [],

{aria_code-0.71.0 → aria_code-0.73.0}/src/aria_code/aria_cli.py

@@ -6067,17 +6067,6 @@ class ArtheraTerminal:
         """Run the interactive REPL loop."""
         self.print_header()
         await self._startup_health_check()
-        try:
-            from ui.banner import render_session_banner
-            render_session_banner(
-                self.session_id,
-                console=console,
-                has_rich=HAS_RICH,
-                lang=self.config.get("ui_lang", "en") or "en",
-                web_url=self.config.get("web_url", "https://arthera.finance"),
-            )
-        except Exception:
-            pass
 
         # Background: settle pending market calls (>24h) vs live prices so the
         # prediction track record + DPO signals accrue with zero user effort.

{aria_code-0.71.0 → aria_code-0.73.0}/src/aria_code/aria_relay_server.py

@@ -40,6 +40,9 @@ WebSocket 注册流程:
                         仅本地联调可设 RELAY_ALLOW_UNVERIFIED_EVENTS=1 绕过。
   RELAY_SECRET          部署级别的注册口令（可选）。每台电脑另有自己的令牌和绑定码，
                         见下方 client_credentials：没有它们，任何人都能冒充或绑定别人的电脑。
+  RELAY_STORE           状态存储：sqlite（默认，DB_PATH）或 firestore。Cloud Run 上必须用
+                        firestore——容器文件系统每次部署都会清空，SQLite 里的绑定和电脑凭证会丢。
+  RELAY_FIRESTORE_PROJECT / RELAY_FIRESTORE_DATABASE  可选，默认当前项目和 (default) 数据库
   DB_PATH               SQLite 路径（默认 ./relay.db）
   MESSAGE_TIMEOUT       等待用户本机回复的超时秒数（默认 90）
 """
@@ -78,106 +81,44 @@ _MSG_TIMEOUT       = int(os.environ.get("MESSAGE_TIMEOUT", "90"))
 _FEISHU_API        = "https://open.feishu.cn/open-apis"
 
 
-# ── SQLite store ──────────────────────────────────────────────────────────────
+# ── Persistent state (relay_store.py) ─────────────────────────────────────────
+#
+# SQLite by default; RELAY_STORE=firestore on Cloud Run, where the container
+# filesystem — and with it a SQLite file — is discarded on every deploy.
+#
+# Each machine's credentials are recorded on its first registration (trust on
+# first use), only as hashes: the token proves a later connection is the same
+# machine; the bind code is the only thing /bind accepts. The bind code used to
+# be the client_id, so anyone who learned one could bind their own Feishu
+# account to someone else's machine.
+
+_store_instance = None
 
-def _db() -> sqlite3.Connection:
-    conn = sqlite3.connect(_DB_PATH, check_same_thread=False)
-    conn.row_factory = sqlite3.Row
-    conn.execute("""
-        CREATE TABLE IF NOT EXISTS bindings (
-            feishu_user_id TEXT PRIMARY KEY,
-            client_id      TEXT NOT NULL,
-            bound_at       REAL NOT NULL
-        )
-    """)
-    conn.execute("""
-        CREATE TABLE IF NOT EXISTS pending_binds (
-            client_id  TEXT PRIMARY KEY,
-            created_at REAL NOT NULL
-        )
-    """)
-    # Each machine's own credentials, recorded the first time it registers
-    # (trust on first use) and only as hashes:
-    #   token_hash     — later registrations of this client_id must present the
-    #                    same token, so knowing a client_id is not enough to
-    #                    impersonate the machine and take over its messages;
-    #   bind_code_hash — /bind accepts only this code, which is generated and
-    #                    shown on the machine itself. The bind code used to be the
-    #                    client_id, so anyone who learned one could bind their own
-    #                    Feishu account to someone else's machine.
-    conn.execute("""
-        CREATE TABLE IF NOT EXISTS client_credentials (
-            client_id      TEXT PRIMARY KEY,
-            token_hash     TEXT NOT NULL,
-            bind_code_hash TEXT NOT NULL,
-            created_at     REAL NOT NULL
-        )
-    """)
-    # Chats a client's bound user has spoken to the bot in: the only chats the
-    # client may later send to unprompted (the daily digest).
-    conn.execute("""
-        CREATE TABLE IF NOT EXISTS client_chats (
-            client_id TEXT NOT NULL,
-            chat_id   TEXT NOT NULL,
-            last_seen REAL NOT NULL,
-            PRIMARY KEY (client_id, chat_id)
-        )
-    """)
-    # Cards the relay posted for a client: a press on one is routed back to
-    # that client, which holds the approval it belongs to.
-    conn.execute("""
-        CREATE TABLE IF NOT EXISTS card_origins (
-            message_id TEXT PRIMARY KEY,
-            client_id  TEXT NOT NULL,
-            created_at REAL NOT NULL
-        )
-    """)
-    conn.commit()
-    return conn
 
+def _store():
+    global _store_instance
+    if _store_instance is None:
+        from aria_code.relay_store import open_store
+        _store_instance = open_store()
+    return _store_instance
 
-_db_conn: Optional[sqlite3.Connection] = None
+
+def _ephemeral_store() -> bool:
+    """SQLite inside a Cloud Run container is discarded with the container."""
+    return bool(os.environ.get("K_SERVICE")) and _store().kind == "sqlite"
 
 
 def get_db() -> sqlite3.Connection:
-    global _db_conn
-    if _db_conn is None:
-        _db_conn = _db()
-    return _db_conn
+    """The SQLite connection, when that is the store (tests and local use)."""
+    return _store().db
 
 
 def _lookup_client(feishu_user_id: str) -> Optional[str]:
-    row = get_db().execute(
-        "SELECT client_id FROM bindings WHERE feishu_user_id = ?",
-        (feishu_user_id,),
-    ).fetchone()
-    return row["client_id"] if row else None
+    return _store().client_for_user(feishu_user_id)
 
 
 def _bind(feishu_user_id: str, client_id: str) -> None:
-    get_db().execute(
-        "INSERT OR REPLACE INTO bindings VALUES (?, ?, ?)",
-        (feishu_user_id, client_id, time.time()),
-    )
-    get_db().execute(
-        "DELETE FROM pending_binds WHERE client_id = ?", (client_id,)
-    )
-    get_db().commit()
-
-
-def _register_pending(client_id: str) -> None:
-    get_db().execute(
-        "INSERT OR REPLACE INTO pending_binds VALUES (?, ?)",
-        (client_id, time.time()),
-    )
-    get_db().commit()
-
-
-def _is_valid_client_id(client_id: str) -> bool:
-    row = get_db().execute(
-        "SELECT client_id FROM pending_binds WHERE client_id = ?", (client_id,)
-    ).fetchone()
-    return row is not None
+    _store().bind_user(feishu_user_id, client_id)
 
 
 def _digest(value: str) -> str:
@@ -194,19 +135,18 @@ def _admit_client(client_id: str, token: str, bind_code: str) -> str:
         return "this Aria version is too old for the relay; upgrade aria-code"
     if len(_normalise_bind_code(bind_code or "")) < 10:
         return "bind code missing; upgrade aria-code"
-    row = get_db().execute(
-        "SELECT token_hash FROM client_credentials WHERE client_id = ?", (client_id,)).fetchone()
-    if row is None:
-        get_db().execute("INSERT INTO client_credentials VALUES (?, ?, ?, ?)",
-                         (client_id, _digest(token), _digest(_normalise_bind_code(bind_code)), time.time()))
-        get_db().commit()
-        return ""
-    if not hmac.compare_digest(row["token_hash"], _digest(token)):
+    store = _store()
+    code_hash = _digest(_normalise_bind_code(bind_code))
+    known = store.credentials(client_id)
+    if known is None:
+        if store.claim_credentials(client_id, _digest(token), code_hash):
+            return ""
+        known = store.credentials(client_id)   # lost a race for the same id
+    if not known or not hmac.compare_digest(known["token_hash"], _digest(token)):
         return "client_id is registered to another installation"
     # The machine may rotate its bind code; the token proves it is the same one.
-    get_db().execute("UPDATE client_credentials SET bind_code_hash = ? WHERE client_id = ?",
-                     (_digest(_normalise_bind_code(bind_code)), client_id))
-    get_db().commit()
+    if known["bind_code_hash"] != code_hash:
+        store.set_bind_code(client_id, code_hash)
     return ""
 
 
@@ -214,9 +154,7 @@ def _client_for_bind_code(code: str) -> Optional[str]:
     normalised = _normalise_bind_code(code)
     if len(normalised) < 10:
         return None
-    row = get_db().execute("SELECT client_id FROM client_credentials WHERE bind_code_hash = ?",
-                           (_digest(normalised),)).fetchone()
-    return row["client_id"] if row else None
+    return _store().client_for_bind_code(_digest(normalised))
 
 
 # ── WebSocket connection registry ─────────────────────────────────────────────
@@ -253,9 +191,7 @@ def _remember_forward(client_id: str, message_id: str, chat_id: str) -> None:
     if message_id:
         _forwarded[message_id] = (client_id, now + _FORWARD_TTL)
     if chat_id:
-        get_db().execute(
-            "INSERT OR REPLACE INTO client_chats VALUES (?, ?, ?)", (client_id, chat_id, now))
-        get_db().commit()
+        _store().remember_chat(client_id, chat_id)
 
 
 def _may_send(client_id: str, request: dict) -> str:
@@ -272,10 +208,7 @@ def _may_send(client_id: str, request: dict) -> str:
     elif op == "send":
         if request.get("receive_id_type", "chat_id") != "chat_id":
             return "send is only to chats"
-        row = get_db().execute(
-            "SELECT 1 FROM client_chats WHERE client_id = ? AND chat_id = ?", (client_id, target)
-        ).fetchone()
-        if not row:
+        if not _store().has_chat(client_id, target):
             return "this client has no conversation in that chat"
     else:
         return "op must be reply or send"
@@ -309,17 +242,13 @@ async def _send_for_client(client_id: str, request: dict) -> dict:
         return {"code": -1, "msg": "relay could not reach Feishu"}
     sent_id = ((result.get("data") or {}).get("message_id") or "")
     if result.get("code") == 0 and request["msg_type"] == "interactive" and sent_id:
-        get_db().execute("INSERT OR REPLACE INTO card_origins VALUES (?, ?, ?)",
-                         (sent_id, client_id, time.time()))
-        get_db().commit()
+        _store().remember_card(sent_id, client_id)
     return {"code": result.get("code"), "msg": result.get("msg", ""),
             "data": {"message_id": sent_id} if sent_id else {}}
 
 
 def _card_origin(message_id: str) -> Optional[str]:
-    row = get_db().execute("SELECT client_id FROM card_origins WHERE message_id = ?",
-                           (message_id,)).fetchone()
-    return row["client_id"] if row else None
+    return _store().card_origin(message_id) if message_id else None
 
 
 # ── Feishu API helpers ────────────────────────────────────────────────────────
@@ -430,7 +359,10 @@ async def lifespan(app: FastAPI):
         datefmt="%H:%M:%S",
     )
     logger.info("Aria Relay Server started  db=%s", _DB_PATH)
-    get_db()  # init tables
+    logger.info("Relay state store: %s", _store().kind)
+    if _ephemeral_store():
+        logger.warning("Running on Cloud Run with SQLite: bindings and machine credentials are "
+                       "lost on every deploy. Set RELAY_STORE=firestore.")
     yield
     logger.info("Relay Server shutting down")
 
@@ -472,8 +404,6 @@ async def ws_endpoint(websocket: WebSocket):
 
         # Register in-memory + mark as pending bind (if first time)
         _connections[client_id] = websocket
-        if _lookup_client.__module__:  # always true; used as noop to be explicit
-            _register_pending(client_id)
 
         await websocket.send_text(json.dumps({"ok": True, "client_id": client_id}))
         logger.info("Client connected: %s", client_id)
@@ -675,7 +605,10 @@ async def status(request: Request):
     """
     body = {
         "connected_clients": len(_connections),
-        "total_bindings": get_db().execute("SELECT COUNT(*) FROM bindings").fetchone()[0],
+        "total_bindings": _store().binding_count(),
+        "store": _store().kind,
+        **({"store_warning": "sqlite on Cloud Run — bindings are lost on every deploy; "
+                             "set RELAY_STORE=firestore"} if _ephemeral_store() else {}),
         "feishu_app_configured": bool(_FEISHU_APP_ID),
         "event_verification": (
             "encrypt_key" if _FEISHU_ENCRYPT_KEY

{aria_code-0.71.0 → aria_code-0.73.0}/src/aria_code/clients/aria_relay_client.py

@@ -10,7 +10,7 @@ aria_relay_client.py — 连接 Aria 中继服务器的 WebSocket 客户端
   python3 aria_relay_client.py --once       # 调试：收到第一条消息后退出
 
 所需环境变量（读取 ~/.aria/.env）:
-  ARIA_RELAY_URL        wss://relay.aria.ai（或自建服务器地址）
+  ARIA_RELAY_URL        中继地址，配置向导默认填 Arthera 运营的中继（见 OFFICIAL_RELAY_URL）
   ARIA_RELAY_CLIENT_ID  setup_wizard 生成的 12 位 hex id
 """
 
@@ -92,7 +92,44 @@ def ensure_credentials(env_file: Path = Path.home() / ".aria" / ".env") -> tuple
     return token, code
 
 
-_RELAY_URL = os.environ.get("ARIA_RELAY_URL", "wss://relay.aria.ai")
+# The relay Arthera runs. Offered as the setup wizard's default, never used as
+# a silent fallback.
+OFFICIAL_RELAY_URL = "wss://aria-code-741336310848.europe-west2.run.app/ws"
+
+# The default used to be wss://relay.aria.ai. aria.ai belongs to an unrelated
+# party (registered 2017); the subdomain does not resolve today, but its owner
+# could create it at any time, and every client left on the default would then
+# send its machine token, bind code and Feishu traffic there. Anyone who ran
+# the wizard before 2026-10-04 has it saved in ~/.aria/.env, so it is refused
+# by name, not merely no longer suggested.
+_UNOWNED_RELAY_HOSTS = {"relay.aria.ai"}
+
+
+def relay_url_problem(url: str) -> str:
+    """"" when the client may connect to `url`, otherwise why not."""
+    from urllib.parse import urlparse
+
+    if not url:
+        return "ARIA_RELAY_URL is not set — run the setup wizard (relay mode) to configure it"
+    parsed = urlparse(url)
+    host = (parsed.hostname or "").lower()
+    if host in _UNOWNED_RELAY_HOSTS or host.endswith(".aria.ai") or host == "aria.ai":
+        return (f"{host} is not run by Arthera; run the setup wizard again to switch to "
+                f"{OFFICIAL_RELAY_URL}")
+    if parsed.scheme == "wss" and host:
+        return ""
+    if parsed.scheme == "ws" and host in ("localhost", "127.0.0.1", "::1"):
+        return ""
+    return "ARIA_RELAY_URL must be wss:// — this machine's token is sent when it connects (ws:// only to localhost)"
+
+
+def default_relay_url(current: str) -> str:
+    """What the setup wizard offers: the saved URL, unless it is unusable."""
+    current = (current or "").strip()
+    return current if current and not relay_url_problem(current) else OFFICIAL_RELAY_URL
+
+
+_RELAY_URL = os.environ.get("ARIA_RELAY_URL", "").strip()
 _CLIENT_ID = os.environ.get("ARIA_RELAY_CLIENT_ID", "")
 _RECONNECT_DELAY_MAX = 60   # seconds
 _RECONNECT_DELAY_BASE = 3
@@ -191,6 +228,11 @@ async def _connect_and_serve(once: bool = False) -> None:
         logger.error("websockets package not installed — run: pip install websockets")
         sys.exit(1)
 
+    problem = relay_url_problem(_RELAY_URL)
+    if problem:
+        logger.error("Not connecting to the relay: %s", problem)
+        sys.exit(1)
+
     if not _CLIENT_ID:
         logger.error(
             "ARIA_RELAY_CLIENT_ID is not set. "

aria_code-0.73.0/src/aria_code/relay_store.py

@@ -0,0 +1,194 @@
+"""Where the relay keeps what it must not forget.
+
+Bindings (which Feishu user reaches which machine), each machine's
+credentials, the chats a client may post to, and which client posted which
+card. All of it used to live in a SQLite file inside the container — and a
+Cloud Run container's filesystem is discarded on every deploy and restart, so
+every merge to main unbound every user and reset every machine's credentials
+to "first use". `RELAY_STORE=firestore` keeps it in Firestore instead.
+
+SQLite stays the default: right for local development and for a self-hosted
+relay with a persistent disk.
+
+Both stores implement the same small contract, and tests/test_relay_store.py
+runs one set of tests against both. The one operation that must be atomic is
+claim_credentials: the first registration of a client_id wins, and two
+connections racing for the same id cannot both. SQLite gets that from the
+primary key, Firestore from create(), which fails if the document exists.
+
+Firestore layout — every read is by document id, never a query:
+    relay_bindings/{feishu_user_id}        {client_id, bound_at}
+    relay_clients/{client_id}              {token_hash, bind_code_hash, created_at}
+    relay_bind_codes/{bind_code_hash}      {client_id}
+    relay_client_chats/{sha256(client:chat)} {client_id, chat_id, last_seen}
+    relay_card_origins/{message_id}        {client_id, created_at}
+"""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import sqlite3
+import time
+from typing import Optional
+
+
+class SqliteStore:
+    kind = "sqlite"
+
+    def __init__(self, path: str) -> None:
+        self.db = sqlite3.connect(path, check_same_thread=False)
+        self.db.row_factory = sqlite3.Row
+        self.db.executescript("""
+            CREATE TABLE IF NOT EXISTS bindings (
+                feishu_user_id TEXT PRIMARY KEY, client_id TEXT NOT NULL, bound_at REAL NOT NULL);
+            CREATE TABLE IF NOT EXISTS client_credentials (
+                client_id TEXT PRIMARY KEY, token_hash TEXT NOT NULL,
+                bind_code_hash TEXT NOT NULL, created_at REAL NOT NULL);
+            CREATE TABLE IF NOT EXISTS client_chats (
+                client_id TEXT NOT NULL, chat_id TEXT NOT NULL, last_seen REAL NOT NULL,
+                PRIMARY KEY (client_id, chat_id));
+            CREATE TABLE IF NOT EXISTS card_origins (
+                message_id TEXT PRIMARY KEY, client_id TEXT NOT NULL, created_at REAL NOT NULL);
+        """)
+        self.db.commit()
+
+    def client_for_user(self, feishu_user_id: str) -> Optional[str]:
+        row = self.db.execute("SELECT client_id FROM bindings WHERE feishu_user_id = ?",
+                              (feishu_user_id,)).fetchone()
+        return row["client_id"] if row else None
+
+    def bind_user(self, feishu_user_id: str, client_id: str) -> None:
+        self.db.execute("INSERT OR REPLACE INTO bindings VALUES (?, ?, ?)",
+                        (feishu_user_id, client_id, time.time()))
+        self.db.commit()
+
+    def binding_count(self) -> int:
+        return self.db.execute("SELECT COUNT(*) FROM bindings").fetchone()[0]
+
+    def credentials(self, client_id: str) -> Optional[dict]:
+        row = self.db.execute("SELECT token_hash, bind_code_hash FROM client_credentials "
+                              "WHERE client_id = ?", (client_id,)).fetchone()
+        return dict(row) if row else None
+
+    def claim_credentials(self, client_id: str, token_hash: str, bind_code_hash: str) -> bool:
+        try:
+            self.db.execute("INSERT INTO client_credentials VALUES (?, ?, ?, ?)",
+                            (client_id, token_hash, bind_code_hash, time.time()))
+            self.db.commit()
+            return True
+        except sqlite3.IntegrityError:
+            return False
+
+    def set_bind_code(self, client_id: str, bind_code_hash: str) -> None:
+        self.db.execute("UPDATE client_credentials SET bind_code_hash = ? WHERE client_id = ?",
+                        (bind_code_hash, client_id))
+        self.db.commit()
+
+    def client_for_bind_code(self, bind_code_hash: str) -> Optional[str]:
+        row = self.db.execute("SELECT client_id FROM client_credentials WHERE bind_code_hash = ?",
+                              (bind_code_hash,)).fetchone()
+        return row["client_id"] if row else None
+
+    def remember_chat(self, client_id: str, chat_id: str) -> None:
+        self.db.execute("INSERT OR REPLACE INTO client_chats VALUES (?, ?, ?)",
+                        (client_id, chat_id, time.time()))
+        self.db.commit()
+
+    def has_chat(self, client_id: str, chat_id: str) -> bool:
+        return self.db.execute("SELECT 1 FROM client_chats WHERE client_id = ? AND chat_id = ?",
+                               (client_id, chat_id)).fetchone() is not None
+
+    def remember_card(self, message_id: str, client_id: str) -> None:
+        self.db.execute("INSERT OR REPLACE INTO card_origins VALUES (?, ?, ?)",
+                        (message_id, client_id, time.time()))
+        self.db.commit()
+
+    def card_origin(self, message_id: str) -> Optional[str]:
+        row = self.db.execute("SELECT client_id FROM card_origins WHERE message_id = ?",
+                              (message_id,)).fetchone()
+        return row["client_id"] if row else None
+
+
+class FirestoreStore:
+    kind = "firestore"
+
+    def __init__(self, client, already_exists: type = Exception) -> None:
+        self.client = client
+        self._already_exists = already_exists
+
+    def _doc(self, collection: str, doc_id: str):
+        return self.client.collection(collection).document(doc_id)
+
+    def _get(self, collection: str, doc_id: str) -> Optional[dict]:
+        if not doc_id:
+            return None
+        snapshot = self._doc(collection, doc_id).get()
+        return snapshot.to_dict() if snapshot.exists else None
+
+    @staticmethod
+    def _chat_key(client_id: str, chat_id: str) -> str:
+        return hashlib.sha256(f"{client_id}\0{chat_id}".encode("utf-8")).hexdigest()
+
+    def client_for_user(self, feishu_user_id: str) -> Optional[str]:
+        return (self._get("relay_bindings", feishu_user_id) or {}).get("client_id")
+
+    def bind_user(self, feishu_user_id: str, client_id: str) -> None:
+        self._doc("relay_bindings", feishu_user_id).set({"client_id": client_id, "bound_at": time.time()})
+
+    def binding_count(self) -> int:
+        # Fine at a relay's scale; an aggregation query would need an index.
+        return sum(1 for _ in self.client.collection("relay_bindings").list_documents())
+
+    def credentials(self, client_id: str) -> Optional[dict]:
+        data = self._get("relay_clients", client_id)
+        return {"token_hash": data["token_hash"], "bind_code_hash": data["bind_code_hash"]} if data else None
+
+    def claim_credentials(self, client_id: str, token_hash: str, bind_code_hash: str) -> bool:
+        try:
+            self._doc("relay_clients", client_id).create(
+                {"token_hash": token_hash, "bind_code_hash": bind_code_hash, "created_at": time.time()})
+        except self._already_exists:
+            return False
+        self._doc("relay_bind_codes", bind_code_hash).set({"client_id": client_id})
+        return True
+
+    def set_bind_code(self, client_id: str, bind_code_hash: str) -> None:
+        old = (self._get("relay_clients", client_id) or {}).get("bind_code_hash")
+        if old and old != bind_code_hash:
+            self._doc("relay_bind_codes", old).delete()
+        self._doc("relay_bind_codes", bind_code_hash).set({"client_id": client_id})
+        self._doc("relay_clients", client_id).set({"bind_code_hash": bind_code_hash}, merge=True)
+
+    def client_for_bind_code(self, bind_code_hash: str) -> Optional[str]:
+        return (self._get("relay_bind_codes", bind_code_hash) or {}).get("client_id")
+
+    def remember_chat(self, client_id: str, chat_id: str) -> None:
+        self._doc("relay_client_chats", self._chat_key(client_id, chat_id)).set(
+            {"client_id": client_id, "chat_id": chat_id, "last_seen": time.time()})
+
+    def has_chat(self, client_id: str, chat_id: str) -> bool:
+        return self._get("relay_client_chats", self._chat_key(client_id, chat_id)) is not None
+
+    def remember_card(self, message_id: str, client_id: str) -> None:
+        self._doc("relay_card_origins", message_id).set({"client_id": client_id, "created_at": time.time()})
+
+    def card_origin(self, message_id: str) -> Optional[str]:
+        return (self._get("relay_card_origins", message_id) or {}).get("client_id")
+
+
+def open_store():
+    """The store RELAY_STORE names: "sqlite" (default, DB_PATH) or "firestore"."""
+    kind = os.environ.get("RELAY_STORE", "sqlite").strip().lower()
+    if kind == "firestore":
+        from google.api_core.exceptions import AlreadyExists
+        from google.cloud import firestore
+
+        client = firestore.Client(
+            project=os.environ.get("RELAY_FIRESTORE_PROJECT") or None,
+            database=os.environ.get("RELAY_FIRESTORE_DATABASE") or "(default)",
+        )
+        return FirestoreStore(client, already_exists=AlreadyExists)
+    if kind != "sqlite":
+        raise ValueError(f"RELAY_STORE must be sqlite or firestore, not {kind!r}")
+    return SqliteStore(os.environ.get("DB_PATH", "./relay.db"))

{aria_code-0.71.0 → aria_code-0.73.0}/src/aria_code/setup_wizard.py

@@ -371,8 +371,11 @@ def setup_feishu(env: dict[str, str]) -> None:
 
 def _setup_feishu_relay(env: dict[str, str]) -> None:
     """Connect via Aria Relay Server — no Feishu developer account needed."""
-    relay_url = env.get("ARIA_RELAY_URL", "wss://relay.aria.ai")
-    relay_url = _ask("中继服务器地址", default=relay_url)
+    from aria_code.clients.aria_relay_client import default_relay_url, relay_url_problem
+    relay_url = _ask("中继服务器地址", default=default_relay_url(env.get("ARIA_RELAY_URL", "")))
+    while relay_url_problem(relay_url):
+        print(f"  ✗ {relay_url_problem(relay_url)}")
+        relay_url = _ask("中继服务器地址", default=default_relay_url(""))
     env["ARIA_RELAY_URL"] = relay_url
     env["ARIA_RELAY_MODE"] = "relay"
 

{aria_code-0.71.0 → aria_code-0.73.0}/src/aria_code/ui/banner.py

@@ -375,37 +375,6 @@ def render_startup_dashboard(
     console.print(Panel(body, title=panel_title, title_align="left", box=panel_box, border_style=border_style, padding=(0, 1)))
 
 
-def render_session_banner(
-    session_id: str,
-    *,
-    console,
-    has_rich: bool,
-    lang: str = "en",
-    web_url: str = "https://arthera.finance",
-) -> None:
-    """Render the 'Keep working from anywhere' card with session sync link."""
-    is_zh = lang.lower().startswith("zh")
-    title = "随时随地继续工作" if is_zh else "Keep working from anywhere"
-    line1 = (
-        f"在网页端、移动 App 或飞书中查看或回复此会话："
-        if is_zh else
-        f"Check progress or reply to any session from mobile app, desktop app, or"
-    )
-    line2 = f"{web_url}/sessions/{session_id}"
-    line3 = "仅在本终端保留请运行 /remote-control" if is_zh else "To keep session in this terminal only, run /remote-control"
-
-    if has_rich:
-        console.print(f"[dim]│[/dim] [bold]{title}[/bold]")
-        console.print(f"[dim]│[/dim] [dim]{line1}[/dim]")
-        console.print(f"[dim]│[/dim] [underline]{line2}[/underline]. [dim]{line3}[/dim]")
-        console.print()
-    else:
-        print(f"| {title}")
-        print(f"| {line1}")
-        print(f"| {line2}. {line3}")
-        print()
-
-
 def render_compact_banner(
     *,
     version: str,

{aria_code-0.71.0 → aria_code-0.73.0/src/aria_code.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.71.0
+Version: 0.73.0
 Summary: Open-source AI agent for logistics and finance work: 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.71.0 → aria_code-0.73.0}/src/aria_code.egg-info/SOURCES.txt

@@ -56,6 +56,7 @@ src/aria_code/project_review_api.py
 src/aria_code/project_review_server.py
 src/aria_code/project_tools.py
 src/aria_code/realty_data_tools.py
+src/aria_code/relay_store.py
 src/aria_code/report_exporters.py
 src/aria_code/report_generator.py
 src/aria_code/runway_video_client.py
@@ -572,6 +573,7 @@ tests/test_google_cloud_routing.py
 tests/test_google_login.py
 tests/test_google_search_provider.py
 tests/test_headless_is_agentic.py
+tests/test_honest_surfaces.py
 tests/test_image_gen_tools.py
 tests/test_image_inputs.py
 tests/test_import_graph_budget.py
@@ -638,6 +640,8 @@ tests/test_rebind_namespace_contract.py
 tests/test_relay_client_credentials.py
 tests/test_relay_event_verification.py
 tests/test_relay_sends_for_clients.py
+tests/test_relay_store.py
+tests/test_relay_url.py
 tests/test_release_chain.py
 tests/test_release_commit_identity.py
 tests/test_release_push_is_atomic.py