aria-code 0.52.0__py3-none-any.whl

aria_code/clients/aria_relay_client.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+"""
+aria_relay_client.py — 连接 Aria 中继服务器的 WebSocket 客户端
+================================================================
+本机运行，把中继服务器转发来的飞书消息交给 aria_feishu_bot 处理，
+并把 LLM 回复返回给中继服务器，再由服务器推送到飞书。
+
+启动方式:
+  python3 aria_relay_client.py              # 单次连接（断线自动重连）
+  python3 aria_relay_client.py --once       # 调试：收到第一条消息后退出
+
+所需环境变量（读取 ~/.aria/.env）:
+  ARIA_RELAY_URL        wss://relay.aria.ai（或自建服务器地址）
+  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()
+
+_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
+_RECONNECT_DELAY_BASE = 3
+
+
+# ── 本地 aria_feishu_bot import ───────────────────────────────────────────────
+
+def _get_feishu_bot():
+    aria_dir = Path(__file__).parent
+    if str(aria_dir) not in sys.path:
+        sys.path.insert(0, str(aria_dir))
+    try:
+        import aria_feishu_bot
+        return aria_feishu_bot
+    except ImportError as e:
+        logger.warning("aria_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": "aria_feishu_bot unavailable"}
+    else:
+        try:
+            result = await bot.dispatch_event(payload)
+        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)
+
+
+# ── 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)
+
+    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
+                await ws.send(json.dumps({
+                    "type": "register",
+                    "client_id": _CLIENT_ID,
+                }))
+                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"))
+                    await asyncio.sleep(delay)
+                    continue
+
+                logger.info("Registered. Waiting for messages…")
+                delay = _RECONNECT_DELAY_BASE  # reset on success
+
+                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") == "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)
+
+        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_code/clients/canva_client.py

@@ -0,0 +1,284 @@
+"""Canva Connect API client — OAuth2 + Autofill (report design drafts).
+
+Canva has no headless "create a design from scratch" API — Autofill is the
+real capability: fill a brand template you already made in the Canva app
+with data, and export the result. That's the only "generate a report design"
+path Canva actually supports server-side, so that's all this module does.
+
+One-time setup (outside this code, on Canva's side):
+    1. Register a Connect app at https://www.canva.com/developers/ — get a
+       client_id / client_secret.
+    2. Create a brand template in Canva with the fields you want to autofill,
+       note its template_id.
+    3. Run `/canva connect` in aria-code once to do the OAuth handshake.
+
+Token storage follows the same providers.json pattern as other data-service
+keys (apps/cli/config_paths.py's providers_file, "data" section), extended
+with refresh_token/expires_at — this is the first OAuth-based integration in
+the codebase, so the refresh-before-expiry logic below is new, not reused
+from elsewhere.
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import http.server
+import json
+import secrets
+import time
+import urllib.parse
+import webbrowser
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+AUTH_URL = "https://www.canva.com/api/oauth/authorize"
+TOKEN_URL = "https://api.canva.com/rest/v1/oauth/token"
+API_BASE = "https://api.canva.com/rest/v1"
+REDIRECT_PORT = 53219
+REDIRECT_URI = f"http://127.0.0.1:{REDIRECT_PORT}/callback"
+SCOPES = "design:content:write design:content:read"
+
+
+def _providers_path() -> Path:
+    from apps.cli.config_paths import resolve_paths
+    return resolve_paths().providers_file
+
+
+def _load_canva_config() -> Dict[str, Any]:
+    path = _providers_path()
+    if not path.exists():
+        return {}
+    try:
+        raw = json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return {}
+    return raw.get("data", {}).get("canva", {}) or {}
+
+
+def _save_canva_config(entry: Dict[str, Any]) -> None:
+    path = _providers_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    existing: Dict[str, Any] = {}
+    if path.exists():
+        try:
+            existing = json.loads(path.read_text(encoding="utf-8"))
+        except Exception:
+            pass
+    data_section = existing.get("data", {})
+    data_section["canva"] = entry
+    existing["data"] = data_section
+    path.write_text(json.dumps(existing, indent=2, ensure_ascii=False), encoding="utf-8")
+
+
+class _CallbackHandler(http.server.BaseHTTPRequestHandler):
+    code: Optional[str] = None
+    error: Optional[str] = None
+
+    def do_GET(self):  # noqa: N802
+        parsed = urllib.parse.urlparse(self.path)
+        qs = urllib.parse.parse_qs(parsed.query)
+        _CallbackHandler.code = qs.get("code", [None])[0]
+        _CallbackHandler.error = qs.get("error", [None])[0]
+        self.send_response(200)
+        self.send_header("Content-Type", "text/html; charset=utf-8")
+        self.end_headers()
+        msg = "授权成功，可以关闭这个标签页了。" if _CallbackHandler.code else f"授权失败: {_CallbackHandler.error}"
+        self.wfile.write(f"<html><body><p>{msg}</p></body></html>".encode("utf-8"))
+
+    def log_message(self, *args):
+        pass  # silence default stderr logging
+
+
+def connect(client_id: str, client_secret: str, *, timeout: float = 120.0) -> Dict[str, Any]:
+    """Run the OAuth2 authorization-code + PKCE flow, store tokens, return the saved entry."""
+    verifier = secrets.token_urlsafe(64)[:64]
+    challenge = base64.urlsafe_b64encode(hashlib.sha256(verifier.encode()).digest()).decode().rstrip("=")
+    state = secrets.token_urlsafe(16)
+
+    params = {
+        "response_type": "code",
+        "client_id": client_id,
+        "redirect_uri": REDIRECT_URI,
+        "scope": SCOPES,
+        "state": state,
+        "code_challenge": challenge,
+        "code_challenge_method": "S256",
+    }
+    url = f"{AUTH_URL}?{urllib.parse.urlencode(params)}"
+
+    _CallbackHandler.code = None
+    _CallbackHandler.error = None
+    server = http.server.HTTPServer(("127.0.0.1", REDIRECT_PORT), _CallbackHandler)
+    server.timeout = timeout
+
+    webbrowser.open(url)
+    deadline = time.time() + timeout
+    while _CallbackHandler.code is None and _CallbackHandler.error is None and time.time() < deadline:
+        server.handle_request()
+    server.server_close()
+
+    if _CallbackHandler.error:
+        return {"success": False, "error": _CallbackHandler.error}
+    if not _CallbackHandler.code:
+        return {"success": False, "error": f"Timed out waiting for Canva authorization (>{timeout:.0f}s)."}
+
+    import requests
+
+    resp = requests.post(
+        TOKEN_URL,
+        data={
+            "grant_type": "authorization_code",
+            "code": _CallbackHandler.code,
+            "redirect_uri": REDIRECT_URI,
+            "code_verifier": verifier,
+        },
+        auth=(client_id, client_secret),
+        timeout=15,
+    )
+    if resp.status_code != 200:
+        return {"success": False, "error": f"Token exchange failed: {resp.status_code} {resp.text[:300]}"}
+    tok = resp.json()
+    entry = {
+        "client_id": client_id,
+        "client_secret": client_secret,
+        "access_token": tok["access_token"],
+        "refresh_token": tok.get("refresh_token", ""),
+        "expires_at": time.time() + float(tok.get("expires_in", 3600)),
+    }
+    _save_canva_config(entry)
+    return {"success": True}
+
+
+def _refresh_if_needed(entry: Dict[str, Any]) -> Dict[str, Any]:
+    if float(entry.get("expires_at", 0)) - time.time() > 60:
+        return entry
+    if not entry.get("refresh_token"):
+        raise RuntimeError("Canva access token expired and no refresh_token stored — run /canva connect again.")
+    import requests
+
+    resp = requests.post(
+        TOKEN_URL,
+        data={"grant_type": "refresh_token", "refresh_token": entry["refresh_token"]},
+        auth=(entry["client_id"], entry["client_secret"]),
+        timeout=15,
+    )
+    resp.raise_for_status()
+    tok = resp.json()
+    entry = {
+        **entry,
+        "access_token": tok["access_token"],
+        "refresh_token": tok.get("refresh_token", entry["refresh_token"]),
+        "expires_at": time.time() + float(tok.get("expires_in", 3600)),
+    }
+    _save_canva_config(entry)
+    return entry
+
+
+def _access_token() -> str:
+    entry = _load_canva_config()
+    if not entry.get("access_token"):
+        raise RuntimeError("Canva not connected — run /canva connect first.")
+    entry = _refresh_if_needed(entry)
+    return entry["access_token"]
+
+
+def upload_asset(file_path: str, *, poll_timeout: float = 60.0) -> Dict[str, Any]:
+    """Upload a local image/video file (e.g. a report chart PNG) to Canva and
+    return its asset_id, for use as an {"type": "image", "asset_id": ...}
+    value in autofill_design()'s `data`.
+
+    Blocking (uses requests) — same threading note as autofill_design.
+    """
+    import base64
+    import json
+    import requests
+
+    path = Path(file_path)
+    if not path.exists():
+        return {"success": False, "error": f"File not found: {file_path}"}
+
+    token = _access_token()
+    name_b64 = base64.b64encode(path.name.encode("utf-8")).decode("ascii")
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Content-Type": "application/octet-stream",
+        "Asset-Upload-Metadata": json.dumps({"name_base64": name_b64}),
+    }
+
+    create_resp = requests.post(
+        f"{API_BASE}/asset-uploads",
+        headers=headers,
+        data=path.read_bytes(),
+        timeout=30,
+    )
+    if create_resp.status_code not in (200, 201, 202):
+        return {"success": False, "error": f"Asset upload failed: {create_resp.status_code} {create_resp.text[:300]}"}
+    job = create_resp.json().get("job", {})
+    job_id = job.get("id", "")
+    if not job_id:
+        return {"success": False, "error": "Canva did not return an asset-upload job id"}
+
+    poll_headers = {"Authorization": f"Bearer {token}"}
+    deadline = time.time() + poll_timeout
+    while time.time() < deadline:
+        poll_resp = requests.get(f"{API_BASE}/asset-uploads/{job_id}", headers=poll_headers, timeout=15)
+        poll_resp.raise_for_status()
+        job = poll_resp.json().get("job", {})
+        status = job.get("status", "")
+        if status == "success":
+            asset = job.get("asset", {})
+            return {"success": True, "asset_id": asset.get("id", ""), "name": asset.get("name", "")}
+        if status == "failed":
+            return {"success": False, "error": job.get("error", {}).get("message", "asset upload job failed")}
+        time.sleep(2)
+    return {"success": False, "error": f"Asset upload job timed out after {poll_timeout:.0f}s (job_id={job_id})"}
+
+
+def autofill_design(template_id: str, data: Dict[str, Any], *, poll_timeout: float = 60.0) -> Dict[str, Any]:
+    """Fill a Canva brand template with data and return the exported design.
+
+    `data` values must be typed DatasetValue objects per the Canva Autofill
+    API, not bare strings, e.g.:
+        {"headline": {"type": "text", "text": "Q3 Report"},
+         "chart_img": {"type": "image", "asset_id": "<uploaded-asset-id>"}}
+    Supported value "type"s: text, image, video, chart, sheet.
+
+    Blocking (uses requests) — callers on an event loop should run this in
+    an executor, same as every other broker/report call in this codebase.
+    """
+    import requests
+
+    token = _access_token()
+    headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
+
+    create_resp = requests.post(
+        f"{API_BASE}/autofills",
+        headers=headers,
+        json={"type": "create_from_brand_template", "brand_template_id": template_id, "data": data},
+        timeout=15,
+    )
+    if create_resp.status_code not in (200, 201, 202):
+        return {"success": False, "error": f"Autofill job creation failed: {create_resp.status_code} {create_resp.text[:300]}"}
+    job = create_resp.json().get("job", {})
+    job_id = job.get("id", "")
+    if not job_id:
+        return {"success": False, "error": "Canva did not return a job id"}
+
+    deadline = time.time() + poll_timeout
+    while time.time() < deadline:
+        poll_resp = requests.get(f"{API_BASE}/autofills/{job_id}", headers=headers, timeout=15)
+        poll_resp.raise_for_status()
+        job = poll_resp.json().get("job", {})
+        status = job.get("status", "")
+        if status == "success":
+            result = job.get("result", {})
+            return {
+                "success": True,
+                "design_id": result.get("design", {}).get("id", ""),
+                "design_url": result.get("design", {}).get("url", ""),
+            }
+        if status == "failed":
+            return {"success": False, "error": job.get("error", {}).get("message", "autofill job failed")}
+        time.sleep(2)
+    return {"success": False, "error": f"Autofill job timed out after {poll_timeout:.0f}s (job_id={job_id})"}

aria_code/clients/figma_client.py

@@ -0,0 +1,100 @@
+"""figma_client.py — read-only Figma REST API client.
+
+Figma has no public API for creating/editing designs from a server-side
+script — only the in-app Plugin API can do that, which requires a human
+running it inside Figma itself. So this module only reads: file structure
+(page/frame names, not the full multi-MB node tree) and comments. Nothing
+here writes to Figma.
+
+Auth: a Personal Access Token, stored the same way as every other data-service
+key in this codebase — /apikey set figma <token> (see aria_cli.py's
+_DATA_KEY_MAP), read back via _get_provider_key("figma")/env FIGMA_API_KEY.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+API_BASE = "https://api.figma.com/v1"
+
+
+def _token() -> str:
+    import os
+
+    token = os.getenv("FIGMA_API_KEY", "")
+    if token:
+        return token
+    try:
+        from apps.cli.config_paths import resolve_paths
+        import json
+
+        path = resolve_paths().providers_file
+        if path.exists():
+            raw = json.loads(path.read_text(encoding="utf-8"))
+            entry = raw.get("data", {}).get("figma", {})
+            if entry.get("api_key"):
+                return entry["api_key"]
+    except Exception:
+        pass
+    return ""
+
+
+def _headers() -> Dict[str, str]:
+    token = _token()
+    if not token:
+        raise RuntimeError("Figma not configured — run /apikey set figma <personal_access_token> first.")
+    return {"X-Figma-Token": token}
+
+
+def _summarize_node(node: Dict[str, Any], depth: int) -> Dict[str, Any]:
+    summary: Dict[str, Any] = {"name": node.get("name", ""), "type": node.get("type", "")}
+    children = node.get("children") or []
+    if children and depth > 0:
+        summary["children"] = [_summarize_node(c, depth - 1) for c in children]
+    elif children:
+        summary["child_count"] = len(children)
+    return summary
+
+
+def get_file_summary(file_key: str, *, depth: int = 2) -> Dict[str, Any]:
+    """Return {name, last_modified, pages: [{name, top_level_nodes: [...]}]} for a Figma file.
+
+    Depth-limited on purpose: a raw Figma file's `document` tree can be
+    megabytes of deeply nested nodes — this returns page names and the
+    first `depth` levels of each page's structure, not the full document.
+    """
+    import requests
+
+    resp = requests.get(f"{API_BASE}/files/{file_key}", headers=_headers(), timeout=20)
+    if resp.status_code != 200:
+        return {"success": False, "error": f"Figma API error {resp.status_code}: {resp.text[:300]}"}
+    data = resp.json()
+    document = data.get("document", {})
+    pages = [_summarize_node(page, depth) for page in document.get("children", [])]
+    return {
+        "success": True,
+        "name": data.get("name", ""),
+        "last_modified": data.get("lastModified", ""),
+        "pages": pages,
+    }
+
+
+def list_comments(file_key: str) -> Dict[str, Any]:
+    import requests
+
+    resp = requests.get(f"{API_BASE}/files/{file_key}/comments", headers=_headers(), timeout=20)
+    if resp.status_code != 200:
+        return {"success": False, "error": f"Figma API error {resp.status_code}: {resp.text[:300]}"}
+    comments = resp.json().get("comments", [])
+    return {
+        "success": True,
+        "comments": [
+            {
+                "message": c.get("message", ""),
+                "user": (c.get("user") or {}).get("handle", ""),
+                "created_at": c.get("created_at", ""),
+                "resolved_at": c.get("resolved_at"),
+            }
+            for c in comments
+        ],
+    }