aria-code 0.66.0__tar.gz → 0.67.0__tar.gz

{aria_code-0.66.0 → aria_code-0.67.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.66.0
+Version: 0.67.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
@@ -108,6 +108,9 @@ Requires-Dist: pytest-asyncio>=0.23.7; extra == "dev"
 Requires-Dist: pytest-timeout>=2.3.0; extra == "dev"
 Requires-Dist: ruff>=0.4.0; extra == "dev"
 Requires-Dist: mypy>=1.10.0; extra == "dev"
+Requires-Dist: fastapi>=0.110.0; extra == "dev"
+Requires-Dist: uvicorn>=0.29.0; extra == "dev"
+Requires-Dist: python-multipart>=0.0.9; extra == "dev"
 Provides-Extra: full
 Requires-Dist: google-genai>=1.0.0; extra == "full"
 Requires-Dist: akshare>=1.14.68; extra == "full"

{aria_code-0.66.0 → aria_code-0.67.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aria-code"
-version = "0.66.0"
+version = "0.67.0"
 description = "AI coding and research workspace with optional finance and connected-domain tools"
 readme = "README.md"
 license = { text = "Apache-2.0" }
@@ -156,6 +156,12 @@ dev = [
     "pytest-timeout>=2.3.0",
     "ruff>=0.4.0",
     "mypy>=1.10.0",
+    # The relay server's and the project-review service's tests. Without
+    # these, importorskip skipped them all in CI — the relay's account-hijack
+    # regressions included — and nobody noticed.
+    "fastapi>=0.110.0",
+    "uvicorn>=0.29.0",
+    "python-multipart>=0.0.9",
 ]
 
 # ── Full feature set (what the bootstrap installers install by default) ────────

{aria_code-0.66.0 → aria_code-0.67.0}/src/aria_code/_version.py

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

{aria_code-0.66.0 → aria_code-0.67.0}/src/aria_code/apps/channels/README.md

@@ -84,3 +84,14 @@ A channel renders the request with two buttons and calls
 `purchase_order_draft`, writes a CSV to `ARIA_APPROVAL_OUTBOX/<shipper>/` for
 the 3PL's purchasing system: Aria has no integration that places orders, and
 does not pretend to.
+
+## Relay mode
+
+In relay mode the user's machine has no Feishu app credentials — the app
+secret stays on the relay — so `aria_feishu_bot._send_message` hands every
+message back over the relay WebSocket and the relay sends it. The relay
+accepts a send only where the client has standing: a reply to a message it
+forwarded to that client (within an hour), or a post to a chat that client's
+bound user has spoken to the bot in; text or cards, rate-limited. A press on a
+card is routed to the client that posted the card, which holds the approval.
+Attachments still need the app's credentials and are declined with a message.

{aria_code-0.66.0 → aria_code-0.67.0}/src/aria_code/aria_daemon.py

@@ -1089,9 +1089,11 @@ async def _run_shipper_digests() -> None:
         from apps.channels.digest import run_digests
 
         senders = {}
-        if os.environ.get("FEISHU_APP_ID") and os.environ.get("FEISHU_APP_SECRET"):
-            from aria_feishu_bot import send_digest_card
-            senders["feishu"] = send_digest_card
+        import aria_feishu_bot
+        # With the app's credentials (self-hosted), or through the relay client
+        # this daemon runs in relay mode — the bot knows which it has.
+        if aria_feishu_bot.can_send():
+            senders["feishu"] = aria_feishu_bot.send_digest_card
         report = await run_digests(ConversationStore(), senders)
         for line in report:
             logger.info("shipper digest %s: %s", line["conversation"], line["status"])

{aria_code-0.66.0 → aria_code-0.67.0}/src/aria_code/aria_feishu_bot.py

@@ -157,6 +157,48 @@ async def _get_access_token() -> Optional[str]:
 
 # ── Send message helpers ───────────────────────────────────────────────────────
 
+# Set by the relay client while it is connected. In relay mode this machine has
+# no Feishu app credentials — by design, the app secret stays on the relay — so
+# every message goes back over the WebSocket and the relay sends it. Before
+# 2026-10-03 nothing did this, and relay mode silently dropped every answer.
+_RELAY_SEND = None
+
+
+def set_relay_sender(sender) -> None:
+    """Route sends through the relay: sender(request) -> Feishu-style result dict."""
+    global _RELAY_SEND
+    _RELAY_SEND = sender
+
+
+def can_send() -> bool:
+    """Whether this process can deliver a message at all."""
+    has_app = bool(os.environ.get("FEISHU_APP_ID") and os.environ.get("FEISHU_APP_SECRET"))
+    return has_app or _RELAY_SEND is not None
+
+
+async def _send_message(op: str, target: str, msg_type: str, content: str,
+                        receive_id_type: str = "chat_id") -> Optional[dict]:
+    """The one place a message leaves: directly with app credentials, else via the relay.
+
+    op "reply" answers message `target`; op "send" posts to chat `target`.
+    """
+    token = await _get_access_token()
+    if token:
+        if op == "reply":
+            return await _feishu_post(f"{_FEISHU_API}/im/v1/messages/{target}/reply", token,
+                                      {"msg_type": msg_type, "content": content})
+        return await _feishu_post(f"{_FEISHU_API}/im/v1/messages?receive_id_type={receive_id_type}",
+                                  token, {"receive_id": target, "msg_type": msg_type, "content": content})
+    if _RELAY_SEND is not None:
+        try:
+            return await _RELAY_SEND({"op": op, "target": target, "msg_type": msg_type,
+                                      "content": content, "receive_id_type": receive_id_type})
+        except Exception as exc:
+            logger.warning("relay send failed: %s", exc)
+            return None
+    logger.error("cannot send: no Feishu app credentials and no relay connection")
+    return None
+
 async def _feishu_post(url: str, token: str, payload: dict) -> Optional[dict]:
     """POST to Feishu API; log the response code on error."""
     try:
@@ -187,16 +229,8 @@ async def reply_text(message_id: str, text: str) -> None:
     if not message_id:
         logger.error("reply_text: empty message_id — cannot reply")
         return
-    token = await _get_access_token()
-    if not token:
-        logger.error("reply_text: no access token")
-        return
     logger.info("reply_text → message_id=%s len=%d", message_id, len(text))
-    await _feishu_post(
-        f"{_FEISHU_API}/im/v1/messages/{message_id}/reply",
-        token,
-        {"msg_type": "text", "content": json.dumps({"text": text[:3000]})},
-    )
+    await _send_message("reply", message_id, "text", json.dumps({"text": text[:3000]}))
 
 
 async def reply_card(message_id: str, title: str, body: str,
@@ -205,10 +239,6 @@ async def reply_card(message_id: str, title: str, body: str,
     if not message_id:
         logger.error("reply_card: empty message_id — cannot reply")
         return
-    token = await _get_access_token()
-    if not token:
-        await reply_text(message_id, f"【{title}】\n{body}")
-        return
     elements = _build_card_elements(body, footer)
     card = {
         "config": {"wide_screen_mode": True},
@@ -216,11 +246,7 @@ async def reply_card(message_id: str, title: str, body: str,
         "elements": elements,
     }
     logger.info("reply_card → message_id=%s title=%s", message_id, title[:40])
-    result = await _feishu_post(
-        f"{_FEISHU_API}/im/v1/messages/{message_id}/reply",
-        token,
-        {"msg_type": "interactive", "content": json.dumps(card)},
-    )
+    result = await _send_message("reply", message_id, "interactive", json.dumps(card))
     # If card failed, fall back to plain text
     if result and result.get("code") != 0:
         logger.info("reply_card: card failed (code %s), falling back to text", result.get("code"))
@@ -280,20 +306,13 @@ def _build_card_elements(body: str, footer: str = "") -> list:
 async def _reply_card_raw(message_id: str, title: str, body: str,
                           color: str = "blue", footer: str = "") -> Optional[dict]:
     """Reply with a card; return raw API response dict."""
-    token = await _get_access_token()
-    if not token:
-        return None
     elements = _build_card_elements(body, footer)
     card = {
         "config": {"wide_screen_mode": True},
         "header": {"title": {"tag": "plain_text", "content": title}, "template": color},
         "elements": elements,
     }
-    return await _feishu_post(
-        f"{_FEISHU_API}/im/v1/messages/{message_id}/reply",
-        token,
-        {"msg_type": "interactive", "content": json.dumps(card)},
-    )
+    return await _send_message("reply", message_id, "interactive", json.dumps(card))
 
 
 async def send_card_to_chat(chat_id: str, title: str, body: str,
@@ -305,31 +324,13 @@ async def send_card_to_chat(chat_id: str, title: str, body: str,
     was never read, so every proactive send failed without a trace. Nothing
     scheduled depended on it until the shipper digest.
     """
-    token = await _get_access_token()
-    if not token:
-        return False
     elements = _build_card_elements(body)
     card = {
         "config": {"wide_screen_mode": True},
         "header": {"title": {"tag": "plain_text", "content": title}, "template": color},
         "elements": elements,
     }
-    try:
-        import httpx
-        async with httpx.AsyncClient(timeout=15) as client:
-            resp = await client.post(
-                f"{_FEISHU_API}/im/v1/messages?receive_id_type={receive_id_type}",
-                headers={"Authorization": f"Bearer {token}"},
-                json={
-                    "receive_id": chat_id,
-                    "msg_type":   "interactive",
-                    "content":    json.dumps(card),
-                },
-            )
-        result = resp.json()
-    except Exception as exc:
-        logger.warning("send_card_to_chat failed: %s", exc)
-        return False
+    result = await _send_message("send", chat_id, "interactive", json.dumps(card), receive_id_type) or {}
     if result.get("code") != 0:
         logger.warning("send_card_to_chat rejected: code=%s msg=%s", result.get("code"), result.get("msg"))
         return False
@@ -1179,10 +1180,7 @@ async def _request_reorder(inbound: InboundMessage, message_id: str) -> None:
         summary=f"**建议订货**\n{summary}\n\n数量未计入起订量和箱规，请审批人核对。",
         requested_by=f"feishu:{inbound.sender_id}",
     )
-    token = await _get_access_token()
-    if token:
-        await _feishu_post(f"{_FEISHU_API}/im/v1/messages/{message_id}/reply", token,
-                           {"msg_type": "interactive", "content": json.dumps(_approval_card(approval))})
+    await _send_message("reply", message_id, "interactive", json.dumps(_approval_card(approval)))
 
 
 async def _handle_card_action(event: Dict[str, Any], *, authorized_by_binding: bool = False) -> Dict[str, Any]:
@@ -1294,6 +1292,13 @@ async def dispatch_event(raw: Dict[str, Any], *, authorized_by_binding: bool = F
     if msg.get("chat_type") != "p2p" and msg_type not in ("text", "post"):
         return {"code": 0}
 
+    # Attachments are downloaded with the app's credentials, which relay mode
+    # does not have on this machine; say so instead of failing silently.
+    if msg_type in ("audio", "image", "file") and not (
+            os.environ.get("FEISHU_APP_ID") and os.environ.get("FEISHU_APP_SECRET")):
+        await reply_text(msg_id, "中继模式下暂不支持图片、语音和文件，请直接发送文字。")
+        return {"code": 0}
+
     # ── Text message ──────────────────────────────────────────────────────────
     if msg_type == "text":
         text = _strip_mentions(content.get("text", ""))

{aria_code-0.66.0 → aria_code-0.67.0}/src/aria_code/aria_relay_server.py

@@ -95,6 +95,25 @@ def _db() -> sqlite3.Connection:
             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
 
@@ -149,6 +168,103 @@ _connections: dict[str, WebSocket] = {}   # client_id → WebSocket
 _pending_responses: dict[str, asyncio.Future] = {}   # request_id → Future
 
 
+# ── Sending on a client's behalf ─────────────────────────────────────────────
+#
+# Until 2026-10-03 a client could not answer at all. The relay forwarded each
+# event and replied to Feishu only when the client was offline; the client's
+# bot then tried to reply itself, with app credentials that relay mode
+# deliberately never gives it — so every answer was dropped without a trace.
+#
+# Now the client hands its message back over the WebSocket and the relay sends
+# it. That turns the relay's bot identity into something any connected client
+# can use, so a send is accepted only where the client has standing:
+#   reply — to a message the relay forwarded to this client, within an hour;
+#   send  — to a chat this client's bound user has spoken to the bot in;
+#   at most _SEND_LIMIT messages per client per minute;
+#   msg_type text or interactive, content at most 30 KB.
+
+_FORWARD_TTL = 3600
+_SEND_LIMIT = 60
+_forwarded: dict[str, tuple[str, float]] = {}       # message_id → (client_id, expires)
+_send_times: dict[str, list[float]] = {}             # client_id → recent send timestamps
+
+
+def _remember_forward(client_id: str, message_id: str, chat_id: str) -> None:
+    now = time.time()
+    for mid in [m for m, (_, exp) in _forwarded.items() if exp < now]:
+        _forwarded.pop(mid, 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()
+
+
+def _may_send(client_id: str, request: dict) -> str:
+    """"" when the request is allowed, otherwise why not."""
+    op, target = request.get("op"), str(request.get("target") or "")
+    if request.get("msg_type") not in ("text", "interactive"):
+        return "msg_type must be text or interactive"
+    if len(str(request.get("content") or "")) > 30_000:
+        return "content too large"
+    if op == "reply":
+        owner = _forwarded.get(target)
+        if not owner or owner[0] != client_id or owner[1] < time.time():
+            return "not a message forwarded to this client"
+    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:
+            return "this client has no conversation in that chat"
+    else:
+        return "op must be reply or send"
+    now = time.time()
+    recent = [t for t in _send_times.get(client_id, []) if t > now - 60]
+    if len(recent) >= _SEND_LIMIT:
+        return "rate limit"
+    recent.append(now)
+    _send_times[client_id] = recent
+    return ""
+
+
+async def _send_for_client(client_id: str, request: dict) -> dict:
+    refused = _may_send(client_id, request)
+    if refused:
+        logger.warning("refused send for %s: %s", client_id, refused)
+        return {"code": -1, "msg": f"relay refused: {refused}"}
+    token = await _get_tenant_token()
+    body = {"msg_type": request["msg_type"], "content": request["content"]}
+    if request["op"] == "reply":
+        url = f"{_FEISHU_API}/im/v1/messages/{request['target']}/reply"
+    else:
+        url = f"{_FEISHU_API}/im/v1/messages?receive_id_type=chat_id"
+        body["receive_id"] = request["target"]
+    try:
+        async with httpx.AsyncClient() as client:
+            resp = await client.post(url, headers={"Authorization": f"Bearer {token}"}, json=body, timeout=15)
+        result = resp.json()
+    except Exception as exc:
+        logger.warning("send for %s failed: %s", client_id, exc)
+        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()
+    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
+
+
 # ── Feishu API helpers ────────────────────────────────────────────────────────
 
 _feishu_token_cache: dict[str, Any] = {}
@@ -217,7 +333,13 @@ async def _route_to_local(feishu_user_id: str, payload: dict) -> Optional[Any]:
     client_id = _lookup_client(feishu_user_id)
     if not client_id:
         return None
+    message = (payload.get("event") or {}).get("message") or {}
+    _remember_forward(client_id, message.get("message_id", ""), message.get("chat_id", ""))
+    return await _route_to_client(client_id, payload)
+
 
+async def _route_to_client(client_id: str, payload: dict, timeout: Optional[float] = None) -> Optional[Any]:
+    """Send an event to one connected client and wait for its result."""
     ws = _connections.get(client_id)
     if not ws:
         return None
@@ -232,7 +354,7 @@ async def _route_to_local(feishu_user_id: str, payload: dict) -> Optional[Any]:
             "id": req_id,
             "payload": payload,
         }))
-        result = await asyncio.wait_for(future, timeout=_MSG_TIMEOUT)
+        result = await asyncio.wait_for(future, timeout=timeout or _MSG_TIMEOUT)
         return result
     except asyncio.TimeoutError:
         logger.warning("Timeout waiting for response from client_id=%s", client_id)
@@ -303,6 +425,14 @@ async def ws_endpoint(websocket: WebSocket):
             if response_msg.get("type") == "pong":
                 continue
 
+            if response_msg.get("type") == "send":
+                async def _answer(request=response_msg, cid=client_id):
+                    result = await _send_for_client(cid, request)
+                    await websocket.send_text(json.dumps(
+                        {"type": "send_result", "id": request.get("id", ""), "result": result}))
+                asyncio.create_task(_answer())
+                continue
+
             if response_msg.get("type") == "response":
                 req_id = response_msg.get("id", "")
                 future = _pending_responses.get(req_id)
@@ -398,6 +528,20 @@ async def feishu_event(request: Request):
     if "challenge" in payload:
         return {"challenge": payload["challenge"]}
 
+    # A button press on a card. Routed to the client that posted the card —
+    # it holds the approval and checks the presser against its approvers —
+    # and answered synchronously, because Feishu shows the response's toast
+    # and card to the presser and waits at most 3 s for it.
+    if (payload.get("header") or {}).get("event_type") == "card.action.trigger":
+        context = (payload.get("event") or {}).get("context") or {}
+        origin = _card_origin(context.get("open_message_id", ""))
+        if not origin:
+            return {"toast": {"type": "error", "content": "这张卡片已失效。"}}
+        result = await _route_to_client(origin, payload, timeout=2.5)
+        if isinstance(result, dict) and ("toast" in result or "card" in result):
+            return result
+        return {"toast": {"type": "error", "content": "Aria 本机未及时响应，请稍后再试。"}}
+
     # Extract sender + message_id
     event = payload.get("event", {})
     message = event.get("message", {})

{aria_code-0.66.0 → aria_code-0.67.0}/src/aria_code/clients/aria_relay_client.py

@@ -91,6 +91,39 @@ async def _handle_message(raw_msg: dict, ws) -> None:
     await ws.send(reply)
 
 
+# ── Sending through the relay ─────────────────────────────────────────────────
+#
+# This machine has no Feishu app credentials in relay mode, so the bot hands
+# each outgoing message to the relay, which sends it — and refuses anything
+# that is not a reply to a message it forwarded here, or a post to a chat this
+# user has spoken to the bot in.
+
+_pending_sends: dict[str, asyncio.Future] = {}
+_SEND_TIMEOUT = 20
+
+
+def _relay_sender(ws):
+    async def send(request: dict) -> dict:
+        import uuid
+        send_id = f"send_{uuid.uuid4().hex[:10]}"
+        future = asyncio.get_running_loop().create_future()
+        _pending_sends[send_id] = future
+        try:
+            await ws.send(json.dumps({"type": "send", "id": send_id, **request}))
+            return await asyncio.wait_for(future, timeout=_SEND_TIMEOUT)
+        except asyncio.TimeoutError:
+            return {"code": -1, "msg": "relay did not confirm the send"}
+        finally:
+            _pending_sends.pop(send_id, None)
+    return send
+
+
+def _settle_send(msg: dict) -> None:
+    future = _pending_sends.get(msg.get("id", ""))
+    if future is not None and not future.done():
+        future.set_result(msg.get("result") or {})
+
+
 # ── Main loop ─────────────────────────────────────────────────────────────────
 
 async def _connect_and_serve(once: bool = False) -> None:
@@ -131,6 +164,9 @@ async def _connect_and_serve(once: bool = False) -> None:
 
                 logger.info("Registered. Waiting for messages…")
                 delay = _RECONNECT_DELAY_BASE  # reset on success
+                bot = _get_feishu_bot()
+                if bot is not None and hasattr(bot, "set_relay_sender"):
+                    bot.set_relay_sender(_relay_sender(ws))
 
                 async for raw in ws:
                     try:
@@ -143,6 +179,10 @@ async def _connect_and_serve(once: bool = False) -> None:
                         await ws.send(json.dumps({"type": "pong"}))
                         continue
 
+                    if msg.get("type") == "send_result":
+                        _settle_send(msg)
+                        continue
+
                     if msg.get("type") == "message":
                         asyncio.create_task(_handle_message(msg, ws))
 
@@ -157,6 +197,10 @@ async def _connect_and_serve(once: bool = False) -> None:
         except Exception as e:
             logger.warning("Relay error: %s — retry in %ds", e, delay)
 
+        # Disconnected: sends must not go to a closed socket while we retry.
+        bot = _get_feishu_bot()
+        if bot is not None and hasattr(bot, "set_relay_sender"):
+            bot.set_relay_sender(None)
         await asyncio.sleep(delay)
         delay = min(delay * 2, _RECONNECT_DELAY_MAX)
 

{aria_code-0.66.0 → aria_code-0.67.0}/src/aria_code.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.66.0
+Version: 0.67.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
@@ -108,6 +108,9 @@ Requires-Dist: pytest-asyncio>=0.23.7; extra == "dev"
 Requires-Dist: pytest-timeout>=2.3.0; extra == "dev"
 Requires-Dist: ruff>=0.4.0; extra == "dev"
 Requires-Dist: mypy>=1.10.0; extra == "dev"
+Requires-Dist: fastapi>=0.110.0; extra == "dev"
+Requires-Dist: uvicorn>=0.29.0; extra == "dev"
+Requires-Dist: python-multipart>=0.0.9; extra == "dev"
 Provides-Extra: full
 Requires-Dist: google-genai>=1.0.0; extra == "full"
 Requires-Dist: akshare>=1.14.68; extra == "full"

{aria_code-0.66.0 → aria_code-0.67.0}/src/aria_code.egg-info/SOURCES.txt

@@ -635,6 +635,7 @@ tests/test_quant_engine_namespace.py
 tests/test_rebind_contract.py
 tests/test_rebind_namespace_contract.py
 tests/test_relay_event_verification.py
+tests/test_relay_sends_for_clients.py
 tests/test_release_chain.py
 tests/test_release_commit_identity.py
 tests/test_release_push_is_atomic.py

{aria_code-0.66.0 → aria_code-0.67.0}/src/aria_code.egg-info/requires.txt

@@ -91,6 +91,9 @@ pytest-asyncio>=0.23.7
 pytest-timeout>=2.3.0
 ruff>=0.4.0
 mypy>=1.10.0
+fastapi>=0.110.0
+uvicorn>=0.29.0
+python-multipart>=0.0.9
 
 [files]
 pdfplumber>=0.11.0

{aria_code-0.66.0 → aria_code-0.67.0}/tests/test_project_review_api.py

@@ -1,8 +1,8 @@
 """HTTP-level coverage for the internal project-review/workspace service.
 
-Requires the optional "service" extra (fastapi, uvicorn, python-multipart);
-skips cleanly when it is not installed, matching how the local CLI keeps
-this dependency optional.
+Needs fastapi and python-multipart, which the dev extra and every CI test job
+install. It still skips without them, for a local run of the core suite —
+but it used to skip in CI too, because no workflow installed them.
 """
 
 from __future__ import annotations