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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.71.0
+Version: 0.72.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.72.0}/pyproject.toml

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

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

{aria_code-0.71.0 → aria_code-0.72.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.72.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.72.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.72.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.72.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
@@ -638,6 +639,7 @@ 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_release_chain.py
 tests/test_release_commit_identity.py
 tests/test_release_push_is_atomic.py