aria-code 0.69.0__tar.gz → 0.70.0__tar.gz

{aria_code-0.69.0 → aria_code-0.70.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.69.0
+Version: 0.70.0
 Summary: AI coding and research workspace with optional finance and connected-domain tools
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/artheras/aria-code

{aria_code-0.69.0 → aria_code-0.70.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aria-code"
-version = "0.69.0"
+version = "0.70.0"
 description = "AI coding and research workspace with optional finance and connected-domain tools"
 readme = "README.md"
 license = { text = "Apache-2.0" }

{aria_code-0.69.0 → aria_code-0.70.0}/src/aria_code/_version.py

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

{aria_code-0.69.0 → aria_code-0.70.0}/src/aria_code/aria_relay_server.py

@@ -38,7 +38,8 @@ WebSocket 注册流程:
                         飞书 Verification Token（次选）——校验事件体里的 token
                         ⚠️ 二者至少配一个，否则 /feishu/event 一律拒绝。
                         仅本地联调可设 RELAY_ALLOW_UNVERIFIED_EVENTS=1 绕过。
-  RELAY_SECRET          WebSocket 注册鉴权（可选，留空则不鉴权）
+  RELAY_SECRET          部署级别的注册口令（可选）。每台电脑另有自己的令牌和绑定码，
+                        见下方 client_credentials：没有它们，任何人都能冒充或绑定别人的电脑。
   DB_PATH               SQLite 路径（默认 ./relay.db）
   MESSAGE_TIMEOUT       等待用户本机回复的超时秒数（默认 90）
 """
@@ -95,6 +96,23 @@ def _db() -> sqlite3.Connection:
             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("""
@@ -162,6 +180,45 @@ def _is_valid_client_id(client_id: str) -> bool:
     return row is not None
 
 
+def _digest(value: str) -> str:
+    return hashlib.sha256(value.encode("utf-8")).hexdigest()
+
+
+def _normalise_bind_code(code: str) -> str:
+    return "".join(ch for ch in code.upper() if ch.isalnum())
+
+
+def _admit_client(client_id: str, token: str, bind_code: str) -> str:
+    """"" when this registration may proceed, otherwise why not."""
+    if len(token or "") < 32:
+        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)):
+        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()
+    return ""
+
+
+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
+
+
 # ── WebSocket connection registry ─────────────────────────────────────────────
 
 _connections: dict[str, WebSocket] = {}   # client_id → WebSocket
@@ -402,11 +459,17 @@ async def ws_endpoint(websocket: WebSocket):
             await websocket.send_text(json.dumps({"ok": False, "reason": "client_id required"}))
             return
 
-        # Validate RELAY_SECRET if configured
-        if _RELAY_SECRET and msg.get("secret") != _RELAY_SECRET:
+        # Validate RELAY_SECRET if configured (constant-time: it is a secret)
+        if _RELAY_SECRET and not hmac.compare_digest(str(msg.get("secret") or ""), _RELAY_SECRET):
             await websocket.send_text(json.dumps({"ok": False, "reason": "invalid secret"}))
             return
 
+        refused = _admit_client(client_id, str(msg.get("token") or ""), str(msg.get("bind_code") or ""))
+        if refused:
+            logger.warning("refused registration for %s: %s", client_id, refused)
+            await websocket.send_text(json.dumps({"ok": False, "reason": refused}))
+            return
+
         # 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
@@ -561,15 +624,21 @@ async def feishu_event(request: Request):
             text_content = ""
 
         if text_content.upper().startswith("/BIND ") or text_content.upper().startswith("ARIA-BIND-"):
-            raw_code = text_content.upper().replace("/BIND ", "").strip()
-            # Normalize: "ARIA-BIND-ARIA-XXXX" → "aria-xxxx"
-            client_id_upper = raw_code.replace("ARIA-BIND-", "").replace("ARIA-", "aria-").lower()
-            _bind(feishu_user_id, client_id_upper)
+            raw_code = text_content.upper().replace("/BIND ", "").strip().replace("ARIA-BIND-", "")
+            # Only the code generated and shown on the machine binds it. The
+            # client_id is not accepted any more: it was the bind code, so
+            # whoever learned one could route their messages to another
+            # person's machine.
+            client_id = _client_for_bind_code(raw_code)
+            if not client_id:
+                await _send_feishu_text(
+                    feishu_user_id,
+                    "❌ 绑定码无效。请在你电脑上运行 aria-code 的配置向导，使用它显示的绑定码。")
+                return {"code": 0}
+            _bind(feishu_user_id, client_id)
             await _send_feishu_text(
                 feishu_user_id,
-                f"✅ 绑定成功！你的 Aria 实例已连接。\n"
-                f"Client ID: {client_id_upper}\n"
-                f"现在可以直接发消息与你的 Aria 交互了。"
+                "✅ 绑定成功！你的 Aria 实例已连接。\n现在可以直接发消息与你的 Aria 交互了。"
             )
             return {"code": 0}
 

{aria_code-0.69.0 → aria_code-0.70.0}/src/aria_code/clients/aria_relay_client.py

@@ -42,6 +42,56 @@ def _load_env() -> None:
 
 _load_env()
 
+# ── This machine's relay credentials ──────────────────────────────────────────
+#
+# The relay records both on first registration (as hashes): the token proves a
+# later connection is this machine, and the bind code is what a Feishu user
+# sends to bind to it. Both stay in ~/.aria/.env. Before 2026-10-04 there were
+# neither: the client_id was the only identity and also the bind code, so
+# anyone who learned it could impersonate the machine or bind their own Feishu
+# account to it.
+
+_BIND_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789"   # nothing to misread: no 0/O, 1/I
+
+
+def new_token() -> str:
+    import secrets
+    return secrets.token_urlsafe(32)
+
+
+def new_bind_code() -> str:
+    import secrets
+    return "".join(secrets.choice(_BIND_ALPHABET) for _ in range(12))
+
+
+def format_bind_code(code: str) -> str:
+    """ABCDEFGHJKLM → ARIA-BIND-ABCD-EFGH-JKLM, the form a person types."""
+    code = "".join(ch for ch in code.upper() if ch.isalnum())
+    return "ARIA-BIND-" + "-".join(code[i:i + 4] for i in range(0, len(code), 4))
+
+
+def ensure_credentials(env_file: Path = Path.home() / ".aria" / ".env") -> tuple[str, str]:
+    """This machine's (token, bind code), created and saved on first use."""
+    token = os.environ.get("ARIA_RELAY_CLIENT_TOKEN", "").strip()
+    code = os.environ.get("ARIA_RELAY_BIND_CODE", "").strip()
+    fresh = {}
+    if len(token) < 32:
+        token = fresh["ARIA_RELAY_CLIENT_TOKEN"] = new_token()
+    if len(code) < 10:
+        code = fresh["ARIA_RELAY_BIND_CODE"] = new_bind_code()
+    if fresh:
+        env_file.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+        with env_file.open("a", encoding="utf-8") as handle:
+            for key, value in fresh.items():
+                handle.write(f"{key}={value}\n")
+        env_file.chmod(0o600)
+        os.environ.update(fresh)
+        if "ARIA_RELAY_BIND_CODE" in fresh:
+            logger.info("New relay bind code — send this to the Aria bot in Feishu: /bind %s",
+                        format_bind_code(code))
+    return token, code
+
+
 _RELAY_URL = os.environ.get("ARIA_RELAY_URL", "wss://relay.aria.ai")
 _CLIENT_ID = os.environ.get("ARIA_RELAY_CLIENT_ID", "")
 _RECONNECT_DELAY_MAX = 60   # seconds
@@ -91,6 +141,14 @@ async def _handle_message(raw_msg: dict, ws) -> None:
     await ws.send(reply)
 
 
+def register_frame(client_id: str, token: str, bind_code: str) -> dict:
+    frame = {"type": "register", "client_id": client_id, "token": token, "bind_code": bind_code}
+    secret = os.environ.get("ARIA_RELAY_SECRET", "").strip()
+    if secret:
+        frame["secret"] = secret   # the deployment-wide gate, when the relay sets one
+    return frame
+
+
 # ── Sending through the relay ─────────────────────────────────────────────────
 #
 # This machine has no Feishu app credentials in relay mode, so the bot hands
@@ -151,14 +209,15 @@ async def _connect_and_serve(once: bool = False) -> None:
                 open_timeout=15,
             ) as ws:
                 # Register with server
-                await ws.send(json.dumps({
-                    "type": "register",
-                    "client_id": _CLIENT_ID,
-                }))
+                token, bind_code = ensure_credentials()
+                await ws.send(json.dumps(register_frame(_CLIENT_ID, token, bind_code)))
                 ack_raw = await asyncio.wait_for(ws.recv(), timeout=10)
                 ack = json.loads(ack_raw)
                 if not ack.get("ok"):
                     logger.error("Registration rejected: %s", ack.get("reason", "unknown"))
+                    if "another installation" in str(ack.get("reason", "")):
+                        logger.error("This client_id belongs to a different machine on the relay. "
+                                     "Run the setup wizard to create a new one.")
                     await asyncio.sleep(delay)
                     continue
 

{aria_code-0.69.0 → aria_code-0.70.0}/src/aria_code/setup_wizard.py

@@ -376,26 +376,34 @@ def _setup_feishu_relay(env: dict[str, str]) -> None:
     env["ARIA_RELAY_URL"] = relay_url
     env["ARIA_RELAY_MODE"] = "relay"
 
-    # Generate or reuse client_id
+    # Generate or reuse client_id, plus this machine's token and bind code. The
+    # bind code — not the client_id — is what a Feishu user sends to bind:
+    # only someone who can see this screen has it.
+    from aria_code.clients.aria_relay_client import format_bind_code, new_bind_code, new_token
     client_id = env.get("ARIA_RELAY_CLIENT_ID") or f"aria-{uuid.uuid4().hex[:12]}"
     env["ARIA_RELAY_CLIENT_ID"] = client_id
+    if len(env.get("ARIA_RELAY_CLIENT_TOKEN", "")) < 32:
+        env["ARIA_RELAY_CLIENT_TOKEN"] = new_token()
+    if len(env.get("ARIA_RELAY_BIND_CODE", "")) < 10:
+        env["ARIA_RELAY_BIND_CODE"] = new_bind_code()
+    bind_code = format_bind_code(env["ARIA_RELAY_BIND_CODE"])
 
     if _rich:
         console.print(Panel(
             f"[bold]你的绑定码：[/bold]\n\n"
-            f"[bold yellow on black]  ARIA-BIND-{client_id.upper()}  [/bold yellow on black]\n\n"
+            f"[bold yellow on black]  {bind_code}  [/bold yellow on black]\n\n"
             f"[dim]操作步骤：[/dim]\n"
             f"1. 在飞书搜索 [cyan]Aria Bot[/cyan] 并添加好友\n"
-            f"2. 发送：[cyan]/bind ARIA-BIND-{client_id.upper()}[/cyan]\n"
+            f"2. 发送：[cyan]/bind {bind_code}[/cyan]\n"
             f"3. 收到 [green]\"绑定成功\"[/green] 后，飞书消息将转发到你的 Aria\n\n"
             f"[dim]（中继客户端会在 daemon 启动时自动连接）[/dim]",
             title="📱 飞书绑定步骤",
             border_style="yellow",
         ))
     else:
-        print(f"\n你的绑定码: ARIA-BIND-{client_id.upper()}")
+        print(f"\n你的绑定码: {bind_code}  （只发给你自己的飞书账号里的 Aria，不要给别人）")
         print("1. 在飞书搜索 Aria Bot 并添加好友")
-        print(f"2. 发送: /bind ARIA-BIND-{client_id.upper()}")
+        print(f"2. 发送: /bind {bind_code}")
         print("3. 收到绑定成功后继续\n")
 
     if _confirm("是否已完成绑定？（可以稍后运行向导再完成）", default=False):

{aria_code-0.69.0 → aria_code-0.70.0}/src/aria_code.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.69.0
+Version: 0.70.0
 Summary: AI coding and research workspace with optional finance and connected-domain tools
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/artheras/aria-code

{aria_code-0.69.0 → aria_code-0.70.0}/src/aria_code.egg-info/SOURCES.txt

@@ -635,6 +635,7 @@ tests/test_public_service_status.py
 tests/test_quant_engine_namespace.py
 tests/test_rebind_contract.py
 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_release_chain.py

aria_code-0.70.0/tests/test_relay_client_credentials.py

@@ -0,0 +1,161 @@
+"""Knowing a client_id must not let anyone impersonate or bind that machine.
+
+Before 2026-10-04 the client_id was a relay client's only identity and also
+its bind code. Two consequences, both closed here:
+
+  1. Registering with someone's client_id replaced their connection, and their
+     Feishu messages went to the newcomer.
+  2. Sending "/bind ARIA-BIND-<their client_id>" from your own, properly signed
+     Feishu account bound you to their machine, so your messages ran there —
+     on their model quota, against their local data.
+
+Now each machine registers a token (trust on first use) and a bind code it
+generated and shows only on its own screen; the relay stores hashes of both.
+"""
+
+from __future__ import annotations
+
+import importlib
+import json
+import os
+from unittest import mock
+
+import pytest
+
+if os.environ.get("GITHUB_ACTIONS"):
+    import fastapi  # noqa: F401  — CI must run these, not skip them
+
+fastapi_testclient = pytest.importorskip("fastapi.testclient", reason="relay server dependency")
+TestClient = fastapi_testclient.TestClient
+
+TOKEN_A, TOKEN_B = "a" * 43, "b" * 43
+CODE_A, CODE_B = "ABCDEFGHJKLM", "NPQRSTUVWXYZ"
+
+
+@pytest.fixture
+def relay(monkeypatch, tmp_path):
+    monkeypatch.setenv("DB_PATH", str(tmp_path / "relay.db"))
+    for key in ("FEISHU_ENCRYPT_KEY", "RELAY_ALLOW_UNVERIFIED_EVENTS", "RELAY_SECRET"):
+        monkeypatch.delenv(key, raising=False)
+    monkeypatch.setenv("FEISHU_VERIFICATION_TOKEN", "tok")
+    import aria_relay_server
+    return importlib.reload(aria_relay_server)
+
+
+def _register(relay, client_id="aria-victim", token=TOKEN_A, code=CODE_A, **extra):
+    with TestClient(relay.app).websocket_connect("/ws") as ws:
+        ws.send_text(json.dumps({"type": "register", "client_id": client_id,
+                                 "token": token, "bind_code": code, **extra}))
+        return json.loads(ws.receive_text())
+
+
+class TestRegistration:
+    def test_the_first_registration_is_accepted(self, relay):
+        assert _register(relay)["ok"]
+
+    def test_only_hashes_are_stored(self, relay):
+        _register(relay)
+        row = relay.get_db().execute("SELECT * FROM client_credentials").fetchone()
+        assert TOKEN_A not in tuple(row) and CODE_A not in tuple(row)
+
+    def test_the_same_machine_reconnects(self, relay):
+        _register(relay)
+        assert _register(relay)["ok"]
+
+    def test_someone_else_with_the_client_id_is_refused(self, relay):
+        _register(relay)
+        answer = _register(relay, token=TOKEN_B)
+        assert not answer["ok"] and "another installation" in answer["reason"]
+
+    def test_a_client_without_credentials_is_told_to_upgrade(self, relay):
+        with TestClient(relay.app).websocket_connect("/ws") as ws:
+            ws.send_text(json.dumps({"type": "register", "client_id": "aria-old"}))
+            answer = json.loads(ws.receive_text())
+        assert not answer["ok"] and "upgrade" in answer["reason"]
+
+    def test_the_deployment_secret_still_gates_registration(self, relay, monkeypatch):
+        monkeypatch.setattr(relay, "_RELAY_SECRET", "s3cret")
+        assert not _register(relay, secret="wrong")["ok"]
+        assert _register(relay, client_id="aria-other", secret="s3cret")["ok"]
+
+
+def _bind_event(open_id, text):
+    return {"token": "tok", "header": {"event_type": "im.message.receive_v1"}, "event": {
+        "sender": {"sender_id": {"open_id": open_id}},
+        "message": {"message_id": "om_1", "chat_id": "oc_dm", "message_type": "text",
+                    "content": json.dumps({"text": text})}}}
+
+
+class TestBinding:
+    def _post(self, relay, open_id, text):
+        sent = []
+
+        async def send_text(to, text):
+            sent.append(text)
+
+        with mock.patch.object(relay, "_send_feishu_text", send_text):
+            TestClient(relay.app).post("/feishu/event", json=_bind_event(open_id, text))
+        return sent
+
+    def test_the_machines_own_code_binds_it(self, relay):
+        _register(relay)
+        replies = self._post(relay, "ou_owner", "/bind ARIA-BIND-ABCD-EFGH-JKLM")
+        assert "绑定成功" in replies[0]
+        assert relay._lookup_client("ou_owner") == "aria-victim"
+
+    def test_the_client_id_no_longer_binds(self, relay):
+        _register(relay)
+        replies = self._post(relay, "ou_attacker", "/bind ARIA-BIND-ARIA-VICTIM")
+        assert "无效" in replies[0]
+        assert relay._lookup_client("ou_attacker") is None
+
+    def test_a_guessed_code_does_not_bind(self, relay):
+        _register(relay)
+        self._post(relay, "ou_attacker", f"/bind ARIA-BIND-{CODE_B}")
+        assert relay._lookup_client("ou_attacker") is None
+
+    def test_a_rotated_code_replaces_the_old_one(self, relay):
+        _register(relay)
+        _register(relay, code=CODE_B)
+        self._post(relay, "ou_x", f"/bind {CODE_A}")
+        assert relay._lookup_client("ou_x") is None
+        self._post(relay, "ou_owner", f"/bind {CODE_B}")
+        assert relay._lookup_client("ou_owner") == "aria-victim"
+
+    def test_a_rotation_needs_the_token(self, relay):
+        _register(relay)
+        _register(relay, token=TOKEN_B, code=CODE_B)   # refused, so nothing changes
+        self._post(relay, "ou_attacker", f"/bind {CODE_B}")
+        assert relay._lookup_client("ou_attacker") is None
+
+
+# ── The client side ──────────────────────────────────────────────────────────
+
+from aria_code.clients import aria_relay_client as client  # noqa: E402
+
+
+class TestClientCredentials:
+    def test_created_once_saved_privately_and_reused(self, tmp_path, monkeypatch):
+        # setenv (not delenv) so monkeypatch restores whatever
+        # ensure_credentials writes into os.environ.
+        monkeypatch.setenv("ARIA_RELAY_CLIENT_TOKEN", "")
+        monkeypatch.setenv("ARIA_RELAY_BIND_CODE", "")
+        env_file = tmp_path / ".aria" / ".env"
+        first = client.ensure_credentials(env_file)
+        assert oct(env_file.stat().st_mode & 0o777) == "0o600"
+        assert len(first[0]) >= 32 and len(first[1]) == 12
+        assert client.ensure_credentials(env_file) == first
+        assert env_file.read_text().count("ARIA_RELAY_CLIENT_TOKEN=") == 1
+
+    def test_bind_codes_avoid_characters_people_misread(self):
+        codes = "".join(client.new_bind_code() for _ in range(200))
+        assert not set(codes) & set("0O1I")
+
+    def test_the_bind_code_is_typed_in_groups(self):
+        assert client.format_bind_code("abcdefghjklm") == "ARIA-BIND-ABCD-EFGH-JKLM"
+
+    def test_the_register_frame_carries_the_credentials(self, monkeypatch):
+        monkeypatch.setenv("ARIA_RELAY_SECRET", "s3cret")
+        frame = client.register_frame("aria-a", TOKEN_A, CODE_A)
+        assert frame == {"type": "register", "client_id": "aria-a", "token": TOKEN_A,
+                         "bind_code": CODE_A, "secret": "s3cret"}

{aria_code-0.69.0 → aria_code-0.70.0}/tests/test_relay_sends_for_clients.py

@@ -184,7 +184,8 @@ class TestCardPresses:
 class TestOverTheWebSocket:
     def test_a_refused_send_comes_back_as_a_send_result(self, relay):
         with TestClient(relay.app).websocket_connect("/ws") as ws:
-            ws.send_text(json.dumps({"type": "register", "client_id": "aria-a"}))
+            ws.send_text(json.dumps({"type": "register", "client_id": "aria-a",
+                                     "token": "t" * 43, "bind_code": "ABCDEFGHJKLM"}))
             assert json.loads(ws.receive_text())["ok"]
             ws.send_text(json.dumps({"type": "send", "id": "s1", **_send("oc_not_mine")}))
             answer = json.loads(ws.receive_text())