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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.65.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.65.0 → aria_code-0.67.0}/pyproject.toml

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

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

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

@@ -60,3 +60,38 @@ is read through the logistics tools under `ARIA_OWNER_SCOPE`, so a shared
 multi-shipper export yields only that shipper's lines. Configuration problems
 go to the log, not the client's group; a day with nothing to report sends
 nothing.
+
+## Approvals (`approvals.py`)
+
+Bot runs cannot use confirmation-required tools, so a bot that may only
+suggest still leaves someone retyping its suggestion. Approvals are the
+sanctioned way through: the bot stores exactly what it proposes, an
+authorised person presses approve or reject in the chat, and only then does
+the action run — once, under the shipper's scope, with who and when recorded.
+
+| Rule | Why |
+|------|-----|
+| Approvers per channel (`ARIA_CHANNEL_APPROVERS`, plus admins); none by default | fail closed |
+| Only in the conversation that raised it | a forwarded card cannot be approved elsewhere |
+| A single conditional UPDATE claims the request | two presses cannot both execute |
+| Expires after 24 h | stale numbers should be recomputed, not approved |
+| The conversation must still be bound to the same shipper | a rebound group cannot run the old client's action |
+| The payload is frozen at request time | what was approved is what runs |
+| Failures are recorded, not shown in the chat | exceptions can name host paths |
+
+A channel renders the request with two buttons and calls
+`ApprovalStore.decide`; actions are registered in `EXECUTORS`. The first,
+`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.67.0/src/aria_code/apps/channels/approvals.py

@@ -0,0 +1,263 @@
+"""Approvals: a bot may propose an action with consequences, a person decides.
+
+Bot runs cannot use confirmation-required tools, because nobody in a chat can
+answer a terminal prompt. That stops harm and also stops the useful half of
+the job — a reorder list someone still has to retype. This is the other way
+through: the bot writes down exactly what it proposes, an authorised person
+approves or rejects it in the chat, and only then does it happen, with a
+record of who decided what and when.
+
+Platform-neutral like the rest of apps/channels. A channel renders a request
+with approve/reject buttons and calls `decide` when one is pressed; the rules
+below hold whichever platform the button was on:
+
+  - Who may decide: ARIA_CHANNEL_APPROVERS, plus ARIA_CHANNEL_ADMINS, per
+    channel ("feishu:ou_x"). Nobody, when neither is set.
+  - Where: only in the conversation the request was raised in. A card
+    forwarded to another chat cannot be approved there.
+  - Once: the transition out of "pending" is a single conditional UPDATE, so
+    two clicks, or two approvers at the same moment, cannot both execute.
+  - Not late: a request expires after `ttl_seconds` (24 h).
+  - Not for someone else: the conversation must still be bound to the shipper
+    the request was made for, and the action runs under ARIA_OWNER_SCOPE.
+  - What was approved is what runs: the payload is frozen at request time and
+    executed as stored, never recomputed — the approver saw these lines.
+
+Actions are registered in EXECUTORS. The first, "purchase_order_draft", writes
+a CSV draft to an outbox directory (ARIA_APPROVAL_OUTBOX) for the 3PL's own
+purchasing system to pick up. Aria does not place orders: it has no
+integration that could, and pretending otherwise would be the wrong default.
+"""
+
+from __future__ import annotations
+
+import csv
+import json
+import os
+import secrets
+import sqlite3
+import time
+from contextlib import contextmanager
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable, Dict, Iterator, List, Optional, Tuple
+
+from aria_code.apps.channels.conversation import ADMINS_ENV, default_db_path
+from aria_code.tools.logistics_tenancy import OWNER_SCOPE_ENV
+
+APPROVERS_ENV = "ARIA_CHANNEL_APPROVERS"
+OUTBOX_ENV = "ARIA_APPROVAL_OUTBOX"
+
+PENDING, APPROVED, REJECTED, EXPIRED, FAILED = "pending", "approved", "rejected", "expired", "failed"
+
+
+def can_decide(channel: str, sender_ids: Tuple[str, ...], env: Optional[Dict[str, str]] = None) -> bool:
+    env = env if env is not None else os.environ
+    allowed = set()
+    for key in (APPROVERS_ENV, ADMINS_ENV):
+        allowed |= {item.strip() for item in env.get(key, "").split(",") if item.strip()}
+    return any(f"{channel}:{sid}" in allowed for sid in sender_ids if sid)
+
+
+@dataclass(frozen=True)
+class Approval:
+    id: str
+    conversation: str
+    owner_id: str
+    kind: str
+    payload: Dict[str, Any]
+    summary: str
+    requested_by: str
+    requested_at: float
+    status: str
+    decided_by: str = ""
+    decided_at: float = 0.0
+    result: str = ""
+
+
+@dataclass(frozen=True)
+class Decision:
+    ok: bool
+    message: str
+    approval: Optional[Approval] = None
+
+
+@contextmanager
+def _confined_to(owner_id: str) -> Iterator[None]:
+    previous = os.environ.get(OWNER_SCOPE_ENV)
+    os.environ[OWNER_SCOPE_ENV] = owner_id
+    try:
+        yield
+    finally:
+        if previous is None:
+            os.environ.pop(OWNER_SCOPE_ENV, None)
+        else:
+            os.environ[OWNER_SCOPE_ENV] = previous
+
+
+# ── Executors ────────────────────────────────────────────────────────────────
+
+def outbox_dir() -> Path:
+    configured = os.environ.get(OUTBOX_ENV, "").strip()
+    return Path(configured).expanduser() if configured else Path.home() / ".aria" / "outbox"
+
+
+def execute_purchase_order_draft(approval: Approval) -> str:
+    """Write the approved lines, exactly as approved, as a CSV draft."""
+    lines = approval.payload.get("lines") or []
+    if not lines:
+        raise ValueError("nothing to order")
+    folder = outbox_dir() / approval.owner_id
+    folder.mkdir(parents=True, exist_ok=True)
+    os.chmod(folder, 0o700)
+    stamp = time.strftime("%Y%m%d", time.localtime(approval.decided_at or time.time()))
+    path = folder / f"PO-{approval.owner_id}-{stamp}-{approval.id[:8]}.csv"
+    with path.open("x", newline="", encoding="utf-8") as handle:  # never overwrite a draft
+        writer = csv.writer(handle)
+        writer.writerow(["owner_id", "sku", "order_qty", "approval_id", "approved_by", "approved_at"])
+        decided = time.strftime("%Y-%m-%dT%H:%M:%S", time.localtime(approval.decided_at))
+        for line in lines:
+            writer.writerow([approval.owner_id, line["sku"], line["qty"], approval.id,
+                             approval.decided_by, decided])
+    return str(path)
+
+
+EXECUTORS: Dict[str, Callable[[Approval], str]] = {
+    "purchase_order_draft": execute_purchase_order_draft,
+}
+
+
+def propose_reorder(owner_id: str, inventory_path: str) -> Optional[Tuple[str, Dict[str, Any]]]:
+    """A purchase-order draft from the shipper's reorder list, or None if nothing to order."""
+    from aria_code.tools.logistics_inventory import tool_plan_inventory_policy
+
+    with _confined_to(owner_id):
+        result = tool_plan_inventory_policy({"file_path": inventory_path})
+    if not result.get("success"):
+        raise ValueError(result.get("error") or "inventory analysis failed")
+    lines = [{"sku": i["sku"], "qty": int(i["suggested_order_qty"])}
+             for i in result["data"]["items"]
+             if i.get("action") == "reorder" and i.get("suggested_order_qty")]
+    if not lines:
+        return None
+    summary = "\n".join(f"- {line['sku']}：{line['qty']}" for line in lines)
+    return summary, {"lines": lines}
+
+
+# ── Store ────────────────────────────────────────────────────────────────────
+
+class ApprovalStore:
+    """Requests and decisions, in the same SQLite file as the conversations."""
+
+    def __init__(self, path: Optional[Path | str] = None, *, ttl_seconds: float = 24 * 3600,
+                 clock: Callable[[], float] = time.time) -> None:
+        self.path = Path(path) if path else default_db_path()
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self.ttl_seconds = float(ttl_seconds)
+        self._clock = clock
+        with self._db() as db:
+            db.execute(
+                """CREATE TABLE IF NOT EXISTS approvals (
+                    id TEXT PRIMARY KEY, conversation TEXT NOT NULL, owner_id TEXT NOT NULL,
+                    kind TEXT NOT NULL, payload TEXT NOT NULL, summary TEXT NOT NULL,
+                    requested_by TEXT NOT NULL, requested_at REAL NOT NULL,
+                    status TEXT NOT NULL, decided_by TEXT NOT NULL DEFAULT '',
+                    decided_at REAL NOT NULL DEFAULT 0, result TEXT NOT NULL DEFAULT '')"""
+            )
+        try:
+            os.chmod(self.path, 0o600)
+        except OSError:
+            pass
+
+    def _db(self) -> sqlite3.Connection:
+        return sqlite3.connect(str(self.path))
+
+    def request(self, *, conversation: str, owner_id: str, kind: str, payload: Dict[str, Any],
+                summary: str, requested_by: str) -> Approval:
+        if kind not in EXECUTORS:
+            raise ValueError(f"unknown action {kind!r}")
+        approval_id = secrets.token_urlsafe(12)  # unguessable: it travels in a card button
+        with self._db() as db:
+            db.execute(
+                "INSERT INTO approvals (id, conversation, owner_id, kind, payload, summary, "
+                "requested_by, requested_at, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+                (approval_id, conversation, owner_id, kind, json.dumps(payload, ensure_ascii=False),
+                 summary, requested_by, self._clock(), PENDING),
+            )
+        return self.get(approval_id)  # type: ignore[return-value]
+
+    def get(self, approval_id: str) -> Optional[Approval]:
+        with self._db() as db:
+            row = db.execute(
+                "SELECT id, conversation, owner_id, kind, payload, summary, requested_by, requested_at, "
+                "status, decided_by, decided_at, result FROM approvals WHERE id = ?", (approval_id,)
+            ).fetchone()
+        if not row:
+            return None
+        values = list(row)
+        values[4] = json.loads(values[4])
+        return Approval(*values)
+
+    def recent(self, conversation: str, limit: int = 5) -> List[Approval]:
+        with self._db() as db:
+            ids = [r[0] for r in db.execute(
+                "SELECT id FROM approvals WHERE conversation = ? ORDER BY requested_at DESC LIMIT ?",
+                (conversation, limit))]
+        return [a for a in (self.get(i) for i in ids) if a]
+
+    def _transition(self, approval_id: str, status: str, by: str, result: str = "",
+                    expect: str = PENDING) -> bool:
+        with self._db() as db:
+            cursor = db.execute(
+                "UPDATE approvals SET status = ?, decided_by = ?, decided_at = ?, result = ? "
+                "WHERE id = ? AND status = ?",
+                (status, by, self._clock(), result, approval_id, expect),
+            )
+            return cursor.rowcount == 1
+
+    def decide(self, approval_id: str, *, conversation: str, current_owner: Optional[str],
+               decided_by: str, approve: bool, authorised: bool) -> Decision:
+        """Apply one approve/reject press. Every refusal says why, and changes nothing."""
+        approval = self.get(approval_id)
+        if approval is None or approval.conversation != conversation:
+            # The same answer for "no such request" and "not this chat's": a
+            # forwarded card learns nothing about where it came from.
+            return Decision(False, "找不到这条审批，或它不属于本会话。")
+        if not authorised:
+            return Decision(False, "你没有审批权限。", approval)
+        if approval.status != PENDING:
+            who = f"（{approval.decided_by}）" if approval.decided_by else ""
+            return Decision(False, f"这条审批已经是「{_STATUS_LABEL.get(approval.status, approval.status)}」{who}。", approval)
+        if self._clock() - approval.requested_at > self.ttl_seconds:
+            self._transition(approval_id, EXPIRED, "system")
+            return Decision(False, "这条审批已过期，请重新发起。", self.get(approval_id))
+        if current_owner != approval.owner_id:
+            return Decision(False, "本会话绑定的货主已变更，这条审批不能再执行。", approval)
+
+        if not approve:
+            if not self._transition(approval_id, REJECTED, decided_by):
+                return Decision(False, "这条审批刚刚已被处理。", self.get(approval_id))
+            return Decision(True, "已驳回。", self.get(approval_id))
+
+        # Claim it first; only the press that wins the claim executes.
+        if not self._transition(approval_id, APPROVED, decided_by, result="executing"):
+            return Decision(False, "这条审批刚刚已被处理。", self.get(approval_id))
+        claimed = self.get(approval_id)
+        try:
+            with _confined_to(approval.owner_id):
+                outcome = EXECUTORS[approval.kind](claimed)  # type: ignore[arg-type]
+        except Exception as exc:
+            # The reason is kept in the record for the operator; the chat only
+            # learns that it failed, since an exception can name host paths.
+            self._transition(approval_id, FAILED, decided_by, result=str(exc)[:500], expect=APPROVED)
+            return Decision(False, "已批准，但执行失败，原因已记录。", self.get(approval_id))
+        with self._db() as db:
+            db.execute("UPDATE approvals SET result = ? WHERE id = ?", (outcome, approval_id))
+        return Decision(True, "已批准并执行。", self.get(approval_id))
+
+
+_STATUS_LABEL = {PENDING: "待审批", APPROVED: "已批准", REJECTED: "已驳回", EXPIRED: "已过期", FAILED: "执行失败"}
+
+
+def status_label(status: str) -> str:
+    return _STATUS_LABEL.get(status, status)

{aria_code-0.65.0 → aria_code-0.67.0}/src/aria_code/apps/channels/digest.py

@@ -116,7 +116,8 @@ def build_digest(owner_id: str, feeds: Dict[str, Dict[str, str]]) -> Digest:
                 if reorder:
                     sections.append(_section("建议补货", [
                         f"{i['sku']}：订 {i['suggested_order_qty']}（现有可用 {i['inventory_position']:g}，"
-                        f"补货点 {i['reorder_point']}，约可撑 {i['days_of_cover']} 天）" for i in reorder]))
+                        f"补货点 {i['reorder_point']}，约可撑 {i['days_of_cover']} 天）" for i in reorder])
+                        + "\n在群里 @Aria 发送 /补货，可发起采购单草稿审批。")
                 if thin:
                     sections.append(_section("历史不足、未给建议", [
                         f"{i['sku']}：仅 {i['history_days']} 天出库记录" for i in thin]))

{aria_code-0.65.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.65.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
@@ -1117,6 +1118,104 @@ async def _send_digest_now(conversation: str, message_id: str) -> None:
     await reply_card(message_id, digest.title, digest.body, "orange")
 
 
+# ── Approvals (apps/channels/approvals.py) ────────────────────────────────────
+
+def _approval_card(approval) -> Dict[str, Any]:
+    """The request as a card: buttons while pending, the outcome once decided."""
+    from aria_code.apps.channels.approvals import PENDING, status_label
+
+    elements = _build_card_elements(approval.summary)
+    if approval.status == PENDING:
+        elements.append({"tag": "note", "elements": [{"tag": "plain_text", "content":
+            f"审批编号 {approval.id[:8]} · 24 小时内有效 · 批准后生成采购单草稿文件，不会自动下单"}]})
+        elements.append({"tag": "action", "actions": [
+            {"tag": "button", "type": "primary", "text": {"tag": "plain_text", "content": "批准"},
+             "value": {"aria_approval": approval.id, "decision": "approve"}},
+            {"tag": "button", "type": "danger", "text": {"tag": "plain_text", "content": "驳回"},
+             "value": {"aria_approval": approval.id, "decision": "reject"}},
+        ]})
+        template = "orange"
+    else:
+        outcome = f"{status_label(approval.status)} · {approval.decided_by}"
+        # The file name, not the host path; a failure's details stay in the
+        # approval record and the log, not in the client's group.
+        if approval.status == "approved" and approval.result:
+            outcome += f"\n已生成：{Path(approval.result).name}"
+        elif approval.status == "failed":
+            outcome += "\n详情已记录在审批记录中"
+        elements.append({"tag": "note", "elements": [{"tag": "plain_text", "content": outcome}]})
+        template = "green" if approval.status == "approved" else "grey"
+    return {
+        "config": {"wide_screen_mode": True, "update_multi": True},
+        "header": {"title": {"tag": "plain_text", "content": f"🧾 {approval.owner_id} 采购单草稿"},
+                   "template": template},
+        "elements": elements,
+    }
+
+
+async def _request_reorder(inbound: InboundMessage, message_id: str) -> None:
+    """/补货: propose a purchase-order draft from the reorder list, for approval."""
+    from aria_code.apps.channels.approvals import ApprovalStore, propose_reorder
+    from aria_code.apps.channels.digest import feeds_for, load_feeds
+
+    owner = _conversation_store().owner_for(inbound.key)
+    if not owner:
+        await reply_text(message_id, "本群未绑定货主，无法发起补货审批。管理员可发送 /owner <货主ID> 绑定。")
+        return
+    try:
+        inventory = feeds_for(owner, load_feeds()).get("inventory")
+        if not inventory:
+            raise ValueError(f"no inventory feed configured for {owner}")
+        proposal = propose_reorder(owner, inventory)
+    except Exception as exc:
+        logger.warning("reorder proposal for %s failed: %s", owner, exc)
+        await reply_text(message_id, "暂时无法生成补货建议，已记录到运维日志。")
+        return
+    if proposal is None:
+        await reply_text(message_id, f"{owner}：当前没有需要补货的 SKU。")
+        return
+    summary, payload = proposal
+    approval = ApprovalStore(_conversation_db_path()).request(
+        conversation=inbound.key, owner_id=owner, kind="purchase_order_draft", payload=payload,
+        summary=f"**建议订货**\n{summary}\n\n数量未计入起订量和箱规，请审批人核对。",
+        requested_by=f"feishu:{inbound.sender_id}",
+    )
+    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]:
+    """An approve/reject press. The response's toast and card are what the presser sees."""
+    from aria_code.apps.channels.approvals import ApprovalStore, can_decide
+
+    operator = event.get("operator") or {}
+    ids = tuple(i for i in (operator.get("open_id", ""), operator.get("user_id", "")) if i)
+    value = (event.get("action") or {}).get("value") or {}
+    chat_id = (event.get("context") or {}).get("open_chat_id", "")
+    approval_id = str(value.get("aria_approval", ""))
+    if not approval_id:
+        return {}
+
+    def toast(kind: str, text: str, card=None) -> Dict[str, Any]:
+        out: Dict[str, Any] = {"toast": {"type": kind, "content": text}}
+        if card is not None:
+            out["card"] = {"type": "raw", "data": card}
+        return out
+
+    if not authorized_by_binding and not _is_allowed_user(*ids):
+        return toast("error", "你还没有使用 Aria 的权限。")
+    conversation = f"feishu:{chat_id}"
+    decision = ApprovalStore(_conversation_db_path()).decide(
+        approval_id,
+        conversation=conversation,
+        current_owner=_conversation_store().owner_for(conversation),
+        decided_by=f"feishu:{ids[0] if ids else ''}",
+        approve=value.get("decision") == "approve",
+        authorised=can_decide("feishu", ids),
+    )
+    card = _approval_card(decision.approval) if decision.approval is not None else None
+    return toast("success" if decision.ok else "error", decision.message, card)
+
+
 async def send_digest_card(chat_id: str, title: str, body: str) -> bool:
     """The Feishu sender for apps.channels.digest.run_digests."""
     return await send_card_to_chat(chat_id, title, body, "orange")
@@ -1144,6 +1243,10 @@ async def dispatch_event(raw: Dict[str, Any], *, authorized_by_binding: bool = F
     event      = raw.get("event", {})
     event_type = header.get("event_type") or raw.get("type", "")
 
+    # A press on an approval card's button (callback schema 2.0).
+    if event_type == "card.action.trigger":
+        return await _handle_card_action(event, authorized_by_binding=authorized_by_binding)
+
     if event_type not in ("im.message.receive_v1", "message"):
         return {"code": 0}
 
@@ -1189,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", ""))
@@ -1206,6 +1316,9 @@ async def dispatch_event(raw: Dict[str, Any], *, authorized_by_binding: bool = F
         if text.strip().lower() in ("/digest", "/简报"):
             asyncio.create_task(_send_digest_now(inbound.key, msg_id))
             return {"code": 0}
+        if text.strip().lower() in ("/reorder", "/补货"):
+            asyncio.create_task(_request_reorder(inbound, msg_id))
+            return {"code": 0}
 
         # A task copies the context it is created in, so every aria subprocess
         # the tasks below start runs under this conversation's shipper scope.