aria-code 0.167.0__py3-none-win_amd64.whl

aria_bots/relay_client.py

@@ -0,0 +1,326 @@
+#!/usr/bin/env python3
+"""
+aria_bots.relay_client — 连接 Aria 中继服务器的 WebSocket 客户端
+================================================================
+本机运行，把中继服务器转发来的飞书消息交给 aria_feishu_bot 处理，
+并把 LLM 回复返回给中继服务器，再由服务器推送到飞书。
+
+启动方式:
+  python3 aria_relay_client.py              # 单次连接（断线自动重连）
+  python3 aria_relay_client.py --once       # 调试：收到第一条消息后退出
+
+所需环境变量（读取 ~/.aria/.env）:
+  ARIA_RELAY_URL        中继地址，配置向导默认填 Arthera 运营的中继（见 OFFICIAL_RELAY_URL）
+  ARIA_RELAY_CLIENT_ID  setup_wizard 生成的 12 位 hex id
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import sys
+import time
+from pathlib import Path
+
+logger = logging.getLogger("aria.relay_client")
+
+# ── 加载 ~/.aria/.env ──────────────────────────────────────────────────────
+
+def _load_env() -> None:
+    env_file = Path.home() / ".aria" / ".env"
+    if env_file.exists():
+        for line in env_file.read_text().splitlines():
+            line = line.strip()
+            if line and not line.startswith("#") and "=" in line:
+                k, _, v = line.partition("=")
+                k = k.strip()
+                if k not in os.environ:
+                    os.environ[k] = v.strip()
+
+
+_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
+
+
+# The relay Arthera runs. Offered as the setup wizard's default, never used as
+# a silent fallback.
+OFFICIAL_RELAY_URL = "wss://aria-code-741336310848.europe-west2.run.app/ws"
+
+# The default used to be wss://relay.aria.ai. aria.ai belongs to an unrelated
+# party (registered 2017); the subdomain does not resolve today, but its owner
+# could create it at any time, and every client left on the default would then
+# send its machine token, bind code and Feishu traffic there. Anyone who ran
+# the wizard before 2026-10-04 has it saved in ~/.aria/.env, so it is refused
+# by name, not merely no longer suggested.
+_UNOWNED_RELAY_HOSTS = {"relay.aria.ai"}
+
+
+def relay_url_problem(url: str) -> str:
+    """"" when the client may connect to `url`, otherwise why not."""
+    from urllib.parse import urlparse
+
+    if not url:
+        return "ARIA_RELAY_URL is not set — run the setup wizard (relay mode) to configure it"
+    parsed = urlparse(url)
+    host = (parsed.hostname or "").lower()
+    if host in _UNOWNED_RELAY_HOSTS or host.endswith(".aria.ai") or host == "aria.ai":
+        return (f"{host} is not run by Arthera; run the setup wizard again to switch to "
+                f"{OFFICIAL_RELAY_URL}")
+    if parsed.scheme == "wss" and host:
+        return ""
+    if parsed.scheme == "ws" and host in ("localhost", "127.0.0.1", "::1"):
+        return ""
+    return "ARIA_RELAY_URL must be wss:// — this machine's token is sent when it connects (ws:// only to localhost)"
+
+
+def default_relay_url(current: str) -> str:
+    """What the setup wizard offers: the saved URL, unless it is unusable."""
+    current = (current or "").strip()
+    return current if current and not relay_url_problem(current) else OFFICIAL_RELAY_URL
+
+
+_RELAY_URL = os.environ.get("ARIA_RELAY_URL", "").strip()
+_CLIENT_ID = os.environ.get("ARIA_RELAY_CLIENT_ID", "")
+_RECONNECT_DELAY_MAX = 60   # seconds
+_RECONNECT_DELAY_BASE = 3
+
+
+# ── 本地 aria_feishu_bot import ───────────────────────────────────────────────
+
+def _get_feishu_bot():
+    try:
+        from aria_bots import feishu_bot
+        return feishu_bot
+    except ImportError as e:
+        logger.warning("feishu_bot not importable: %s", e)
+        return None
+
+
+# ── Message handler ───────────────────────────────────────────────────────────
+
+async def _handle_message(raw_msg: dict, ws) -> None:
+    """
+    Server sends:
+      {"type": "message", "id": "req_xxx", "payload": <feishu_event_dict>}
+
+    We reply:
+      {"type": "response", "id": "req_xxx", "result": <any>}
+    """
+    req_id  = raw_msg.get("id", "")
+    payload = raw_msg.get("payload", {})
+
+    bot = _get_feishu_bot()
+    if bot is None:
+        result = {"error": "feishu_bot unavailable"}
+    else:
+        try:
+            # The relay routes an event only to the machine its sender bound
+            # with a code shown here, so that binding is the authorization.
+            result = await bot.dispatch_event(payload, authorized_by_binding=True)
+        except Exception as e:
+            logger.exception("dispatch_event error")
+            result = {"error": str(e)[:300]}
+
+    reply = json.dumps({"type": "response", "id": req_id, "result": result})
+    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
+# 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:
+    try:
+        import websockets  # type: ignore
+    except ImportError:
+        logger.error("websockets package not installed — run: pip install websockets")
+        sys.exit(1)
+
+    problem = relay_url_problem(_RELAY_URL)
+    if problem:
+        logger.error("Not connecting to the relay: %s", problem)
+        sys.exit(1)
+
+    if not _CLIENT_ID:
+        logger.error(
+            "ARIA_RELAY_CLIENT_ID is not set. "
+            "Run setup_wizard.py to generate your client ID."
+        )
+        sys.exit(1)
+
+    delay = _RECONNECT_DELAY_BASE
+    while True:
+        try:
+            logger.info("Connecting to %s (client_id=%s)", _RELAY_URL, _CLIENT_ID)
+            async with websockets.connect(
+                _RELAY_URL,
+                ping_interval=30,
+                ping_timeout=10,
+                open_timeout=15,
+            ) as ws:
+                # Register with server
+                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
+
+                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:
+                        msg = json.loads(raw)
+                    except json.JSONDecodeError:
+                        logger.warning("Invalid JSON from relay: %r", raw[:100])
+                        continue
+
+                    if msg.get("type") == "ping":
+                        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))
+
+                    if once:
+                        return
+
+        except (OSError, ConnectionRefusedError) as e:
+            logger.warning("Connection failed: %s — retry in %ds", e, delay)
+        except asyncio.CancelledError:
+            logger.info("Relay client cancelled")
+            return
+        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)
+
+
+def main() -> None:
+    import argparse
+    parser = argparse.ArgumentParser(description="Aria 中继客户端")
+    parser.add_argument("--once", action="store_true", help="接收一条消息后退出（调试用）")
+    parser.add_argument("--verbose", "-v", action="store_true")
+    args = parser.parse_args()
+
+    logging.basicConfig(
+        level=logging.DEBUG if args.verbose else logging.INFO,
+        format="%(asctime)s [aria-relay] %(message)s",
+        datefmt="%H:%M:%S",
+    )
+
+    try:
+        asyncio.run(_connect_and_serve(once=args.once))
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    main()

aria_bots/telegram_bot.py

@@ -0,0 +1,299 @@
+"""
+aria_bots.telegram_bot — Telegram client and the aria-telegram-bot command handler.
+
+Uses the Telegram Bot API directly via httpx (no heavy python-telegram-bot dep).
+Supports long-polling updates and sending messages/documents back to users.
+
+Commands handled:
+  /price SYMBOL         — quick quote
+  /report SYMBOL        — full analysis (async, returns text summary)
+  /brief                — morning brief
+  /alerts               — list active alerts
+  /alert SYMBOL cond v  — add alert (e.g. /alert 600362 price_below 39.5)
+  /help                 — command list
+
+Usage:
+    from aria_bots.telegram_bot import TelegramBot
+    bot = TelegramBot(token="...", allowed_ids={123456})
+    await bot.start(command_handler)   # command_handler(cmd, args, chat_id) -> str
+"""
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Any, Callable, Coroutine, Optional, Set
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+_API = "https://api.telegram.org/bot{token}/{method}"
+
+
+class TelegramBot:
+    def __init__(
+        self,
+        token: str,
+        allowed_chat_ids: Optional[Set[int]] = None,
+        poll_timeout: int = 30,
+    ):
+        self.token = token
+        self.allowed_chat_ids = allowed_chat_ids or set()
+        self.poll_timeout = poll_timeout
+        self._offset = 0
+        self._running = False
+        self._client: Optional[httpx.AsyncClient] = None
+
+    def is_allowed(self, chat_id: int) -> bool:
+        """Fails closed: an empty allowlist allows nobody."""
+        return chat_id in self.allowed_chat_ids
+
+    # ── Low-level API ─────────────────────────────────────────────────────────
+
+    def _url(self, method: str) -> str:
+        return _API.format(token=self.token, method=method)
+
+    async def _call(self, method: str, **kwargs: Any) -> Optional[dict]:
+        try:
+            if self._client is None:
+                self._client = httpx.AsyncClient(timeout=self.poll_timeout + 5)
+            resp = await self._client.post(self._url(method), json=kwargs)
+            data = resp.json()
+            if not data.get("ok"):
+                logger.warning("Telegram %s error: %s", method, data.get("description"))
+                return None
+            return data.get("result")
+        except Exception as exc:
+            logger.error("Telegram API call %s failed: %s", method, exc)
+            return None
+
+    # ── Sending ───────────────────────────────────────────────────────────────
+
+    async def send_message(
+        self, chat_id: int, text: str, parse_mode: str = "Markdown"
+    ) -> bool:
+        # Telegram has a 4096-char message limit
+        if len(text) > 4096:
+            text = text[:4090] + "\n…"
+        result = await self._call(
+            "sendMessage",
+            chat_id=chat_id,
+            text=text,
+            parse_mode=parse_mode,
+            disable_web_page_preview=True,
+        )
+        return result is not None
+
+    async def send_long_message(self, chat_id: int, text: str) -> None:
+        """Split and send messages that exceed Telegram's 4096-char limit."""
+        chunks = [text[i : i + 4000] for i in range(0, len(text), 4000)]
+        for chunk in chunks:
+            await self.send_message(chat_id, chunk)
+
+    async def send_typing(self, chat_id: int) -> None:
+        await self._call("sendChatAction", chat_id=chat_id, action="typing")
+
+    async def send_document(
+        self, chat_id: int, file_path: str, caption: str = ""
+    ) -> bool:
+        """Send a file as a document attachment."""
+        try:
+            import aiofiles
+            url = self._url("sendDocument")
+            async with aiofiles.open(file_path, "rb") as f:
+                content = await f.read()
+            import os
+            filename = os.path.basename(file_path)
+            if self._client is None:
+                self._client = httpx.AsyncClient(timeout=60)
+            resp = await self._client.post(
+                url,
+                data={"chat_id": str(chat_id), "caption": caption},
+                files={"document": (filename, content)},
+            )
+            return resp.json().get("ok", False)
+        except ImportError:
+            # Fallback: just send caption as text
+            await self.send_message(chat_id, caption or "File ready (aiofiles not installed)")
+            return False
+        except Exception as exc:
+            logger.error("send_document failed: %s", exc)
+            return False
+
+    # ── Polling loop ─────────────────────────────────────────────────────────
+
+    async def get_updates(self) -> list[dict]:
+        result = await self._call(
+            "getUpdates",
+            offset=self._offset,
+            timeout=self.poll_timeout,
+            allowed_updates=["message"],
+        )
+        return result or []
+
+    async def start(
+        self,
+        command_handler: Callable[[str, str, int], Coroutine[Any, Any, str]],
+    ) -> None:
+        """
+        Start long-polling. For each received message, parse the command and
+        call command_handler(command, args, chat_id) → reply text.
+        command_handler should be an async coroutine.
+        """
+        self._running = True
+        logger.info("Telegram bot polling started")
+        while self._running:
+            try:
+                updates = await self.get_updates()
+            except asyncio.CancelledError:
+                break
+            except Exception as exc:
+                logger.error("Polling error: %s", exc)
+                await asyncio.sleep(5)
+                continue
+
+            for update in updates:
+                self._offset = max(self._offset, update["update_id"] + 1)
+                msg = update.get("message", {})
+                text = (msg.get("text") or "").strip()
+                chat_id = msg.get("chat", {}).get("id")
+                if not text or not chat_id:
+                    continue
+
+                # ACL check. Fails closed: an empty TELEGRAM_ALLOWED_IDS allows
+                # nobody. It used to allow everybody — anyone who found the bot
+                # could drive the daemon's commands.
+                if not self.is_allowed(chat_id):
+                    await self.send_message(
+                        chat_id,
+                        "⛔ 未授权。请将你的 Chat ID 添加到 `TELEGRAM_ALLOWED_IDS`。\n你的 ID: `" + str(chat_id) + "`",
+                    )
+                    continue
+
+                asyncio.create_task(self._handle(text, chat_id, command_handler))
+
+    async def _handle(
+        self,
+        text: str,
+        chat_id: int,
+        command_handler: Callable[[str, str, int], Coroutine[Any, Any, str]],
+    ) -> None:
+        # Parse "/command args" or plain text
+        if text.startswith("/"):
+            parts = text[1:].split(None, 1)
+            cmd  = parts[0].lower().split("@")[0]  # strip @botname suffix
+            args = parts[1] if len(parts) > 1 else ""
+        else:
+            cmd  = "chat"
+            args = text
+
+        await self.send_typing(chat_id)
+        try:
+            reply = await command_handler(cmd, args, chat_id)
+        except Exception as exc:
+            reply = f"⚠️ 执行出错: {exc}"
+            logger.exception("command_handler error cmd=%s", cmd)
+
+        if reply:
+            await self.send_long_message(chat_id, reply)
+
+    async def stop(self) -> None:
+        self._running = False
+        if self._client:
+            await self._client.aclose()
+            self._client = None
+
+    async def get_me(self) -> Optional[dict]:
+        return await self._call("getMe")
+
+
+# ── Commands (aria-telegram-bot) ─────────────────────────────────────────────
+
+HELP = (
+    "*Aria 命令列表*\n\n"
+    "`/price SYMBOL` — 实时报价\n"
+    "`/report SYMBOL` — 研报\n"
+    "`/brief` — 今日晨报\n"
+    "`/alert SYMBOL cond value` — 添加价格预警\n"
+    "    条件: price\\_above / price\\_below / pct\\_change\\_above / pct\\_change\\_below\n"
+    "`/alerts` — 查看预警列表\n"
+    "`/status` — Daemon 运行状态\n"
+    "\n直接发文字也可对话 Aria。"
+)
+
+
+async def handle_command(cmd: str, args: str, chat_id: int) -> str:
+    """Answer one Telegram command: market commands go to aria-runtime daemon,
+    everything else is a turn on the Go engine."""
+    from . import engine, market
+
+    args = args.strip()
+    try:
+        if cmd in ("help", "start"):
+            return HELP
+        if cmd in ("price", "p"):
+            symbol = args.split()[0].upper() if args else ""
+            if not symbol:
+                return "用法: `/price AAPL` 或 `/price 600519.SS`"
+            title, body, _ = market.price_card(await market.quote(symbol))
+            return f"*{title}*\n" + body.replace("**", "*")
+        if cmd in ("brief", "morning", "briefing"):
+            title, body = await market.brief("morning-brief")
+            return f"*{title}*\n{body}"
+        if cmd == "alert":
+            parts = args.split()
+            if len(parts) != 3:
+                return "用法: `/alert AAPL price_above 200`"
+            symbol, condition, value = parts[0].upper(), parts[1], parts[2]
+            await market.add_alert(symbol, condition, value)
+            return f"✅ 预警已添加：*{symbol}* {condition} `{value}`"
+        if cmd == "alerts":
+            table = await market.list_alerts()
+            return "暂无预警" if len(table.splitlines()) < 2 else f"```\n{table}\n```"
+        if cmd == "status":
+            return await market.status()
+    except market.MarketError as exc:
+        return f"⚠️ {exc}"
+
+    runtime = engine.find_engine()
+    if not runtime:
+        return "⚠️ 未找到 aria-runtime：请安装，或用 ARIA_RUNTIME 指向它。"
+    if cmd == "report":
+        symbol = args.split()[0].upper() if args else ""
+        if not symbol:
+            return "用法: `/report AAPL` 或 `/report 600519.SS`"
+        prompt = (f"为 {symbol} 写一份简明研报：最新行情、技术面、基本面要点、主要风险和结论。"
+                  "只用工具取到的数据，注明来源与日期。")
+        return await engine.run_turn(prompt, engine=runtime, timeout=240)
+    if cmd == "chat":
+        return await engine.run_turn(args, engine=runtime) if args else HELP
+    return f"未知命令 `/{cmd}`。发送 `/help` 查看命令列表。"
+
+
+def allowed_ids(raw: str) -> Set[int]:
+    return {int(x.strip()) for x in raw.split(",") if x.strip().lstrip("-").isdigit()}
+
+
+def main() -> int:
+    """aria-telegram-bot: long-poll Telegram with TELEGRAM_BOT_TOKEN, answering
+    only chats in TELEGRAM_ALLOWED_IDS."""
+    import os
+
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s [telegram] %(levelname)s %(message)s")
+    token = os.environ.get("TELEGRAM_BOT_TOKEN", "").strip()
+    if not token:
+        logger.error("TELEGRAM_BOT_TOKEN is not set")
+        return 2
+    ids = allowed_ids(os.environ.get("TELEGRAM_ALLOWED_IDS", ""))
+    if not ids:
+        logger.warning("TELEGRAM_ALLOWED_IDS is empty: every chat will be refused")
+    bot = TelegramBot(token=token, allowed_chat_ids=ids)
+    try:
+        asyncio.run(bot.start(handle_command))
+    except KeyboardInterrupt:
+        pass
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())