auntui 0.2.0__py3-none-any.whl

aun_daemon.py

@@ -0,0 +1,709 @@
+#!/usr/bin/env python3
+"""AUN Daemon (MVP v0.1) — headless JSON-RPC bridge for AUN Mac App.
+
+Reads NDJSON requests from stdin, writes NDJSON responses + events to stdout.
+Runtime logs go to stderr. Protocol specified in ./protocol.md.
+
+Usage:
+    python3 aun_daemon.py [--data-dir ~/.aun]
+
+Environment:
+    AUN_CLI_DATA   data root dir (default ~/.aun), same semantics as auntui.py
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import logging
+import os
+import re
+import signal
+import sqlite3
+import sys
+import time
+from pathlib import Path
+from typing import Any, Optional
+
+# force utf-8 stdio
+if hasattr(sys.stdout, "reconfigure"):
+    sys.stdout.reconfigure(encoding="utf-8")
+if hasattr(sys.stderr, "reconfigure"):
+    sys.stderr.reconfigure(encoding="utf-8")
+
+logging.basicConfig(
+    level=os.environ.get("AUN_DAEMON_LOG", "INFO").upper(),
+    format="[daemon] %(asctime)s %(levelname)s %(message)s",
+    stream=sys.stderr,
+)
+log = logging.getLogger("aun_daemon")
+
+# ── Paths & config ──────────────────────────────────────────────────────
+AUN_PATH: Path
+DATA_DIR: Path
+CONFIG_FILE: Path
+MAX_RECENT_TARGETS = 10
+
+
+def _init_paths(override: Optional[str]) -> None:
+    global AUN_PATH, DATA_DIR, CONFIG_FILE
+    base = Path(override).expanduser() if override else (
+        Path(os.environ.get("AUN_CLI_DATA", "")).expanduser()
+        if os.environ.get("AUN_CLI_DATA") else Path.home() / ".aun"
+    )
+    AUN_PATH = base
+    DATA_DIR = base / "aun-cli"
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    CONFIG_FILE = DATA_DIR / "config.json"
+
+
+def _load_config() -> dict:
+    if CONFIG_FILE.exists():
+        try:
+            return json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError):
+            pass
+    return {}
+
+
+def _save_config(cfg: dict) -> None:
+    CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
+    CONFIG_FILE.write_text(
+        json.dumps(cfg, ensure_ascii=False, indent=2), encoding="utf-8"
+    )
+
+
+# ── AID / target helpers ────────────────────────────────────────────────
+_AID_RE = re.compile(
+    r"^[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?"
+    r"(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?){2,}$"
+)
+
+
+def _is_valid_aid(name: str) -> bool:
+    return bool(name) and bool(_AID_RE.match(name))
+
+
+def _short_name(aid: str) -> str:
+    return aid.split(".")[0] if aid else "?"
+
+
+def _make_peer_target(aid: str) -> dict:
+    return {"type": "peer", "id": aid, "name": _short_name(aid)}
+
+
+def _normalize_target(value: Any) -> Optional[dict]:
+    if isinstance(value, dict) and value.get("type") == "peer":
+        tid = str(value.get("id") or "")
+        if _is_valid_aid(tid):
+            return {"type": "peer", "id": tid, "name": value.get("name") or _short_name(tid)}
+    if isinstance(value, str) and _is_valid_aid(value):
+        return _make_peer_target(value)
+    return None
+
+
+def _normalize_recent(cfg: dict) -> list[dict]:
+    raw = cfg.get("recent_targets", []) or []
+    out: list[dict] = []
+    for t in raw if isinstance(raw, list) else []:
+        n = _normalize_target(t)
+        if n:
+            out.append(n)
+    return out
+
+
+def _record_target(cfg: dict, target: dict) -> dict:
+    """Update cfg in-place + persist, return updated cfg."""
+    if not target or target.get("type") != "peer":
+        return cfg
+    tid = target["id"]
+    targets = _normalize_recent(cfg)
+    targets = [t for t in targets if t.get("id") != tid]
+    targets.insert(0, target)
+    cfg["recent_targets"] = targets[:MAX_RECENT_TARGETS]
+    _save_config(cfg)
+    return cfg
+
+
+# ── Message store (sqlite, mirror of auntui.MessageStore) ──────────────
+class MessageStore:
+    def __init__(self, db_path: str):
+        self._db_path = db_path
+        self._conn: Optional[sqlite3.Connection] = None
+
+    def _ensure(self) -> None:
+        if self._conn is not None:
+            return
+        Path(self._db_path).parent.mkdir(parents=True, exist_ok=True)
+        self._conn = sqlite3.connect(self._db_path)
+        self._conn.execute("PRAGMA journal_mode=WAL")
+        self._conn.execute(
+            """CREATE TABLE IF NOT EXISTS messages (
+                   id INTEGER PRIMARY KEY AUTOINCREMENT,
+                   message_id TEXT UNIQUE,
+                   conversation_id TEXT NOT NULL,
+                   conversation_type TEXT NOT NULL,
+                   direction TEXT NOT NULL,
+                   sender TEXT NOT NULL,
+                   payload TEXT NOT NULL,
+                   seq INTEGER,
+                   timestamp INTEGER NOT NULL,
+                   is_read INTEGER NOT NULL DEFAULT 0)"""
+        )
+        self._conn.execute(
+            "CREATE INDEX IF NOT EXISTS idx_conv_ts ON messages (conversation_id, timestamp)"
+        )
+        self._conn.execute(
+            "CREATE INDEX IF NOT EXISTS idx_conv_unread ON messages (conversation_id, is_read)"
+        )
+        self._conn.commit()
+
+    def save(self, **row) -> None:
+        self._ensure()
+        assert self._conn is not None
+        try:
+            self._conn.execute(
+                """INSERT OR IGNORE INTO messages
+                   (message_id, conversation_id, conversation_type, direction,
+                    sender, payload, seq, timestamp, is_read)
+                   VALUES (?,?,?,?,?,?,?,?,?)""",
+                (
+                    row.get("message_id"),
+                    row["conversation_id"],
+                    row["conversation_type"],
+                    row["direction"],
+                    row["sender"],
+                    row["payload"],
+                    row.get("seq"),
+                    row["timestamp"],
+                    row.get("is_read", 0),
+                ),
+            )
+            self._conn.commit()
+        except Exception as e:
+            log.warning("store.save failed: %s", e)
+
+    def history(self, conversation_id: str, limit: int, before_id: Optional[int]) -> list[dict]:
+        self._ensure()
+        assert self._conn is not None
+        limit = max(1, min(int(limit or 50), 200))
+        if before_id:
+            cur = self._conn.execute(
+                """SELECT id, message_id, conversation_id, conversation_type,
+                          direction, sender, payload, seq, timestamp, is_read
+                   FROM messages WHERE conversation_id = ? AND id < ?
+                   ORDER BY timestamp DESC LIMIT ?""",
+                (conversation_id, before_id, limit),
+            )
+        else:
+            cur = self._conn.execute(
+                """SELECT id, message_id, conversation_id, conversation_type,
+                          direction, sender, payload, seq, timestamp, is_read
+                   FROM messages WHERE conversation_id = ?
+                   ORDER BY timestamp DESC LIMIT ?""",
+                (conversation_id, limit),
+            )
+        cols = [d[0] for d in cur.description]
+        rows = [dict(zip(cols, r)) for r in cur.fetchall()]
+        rows.reverse()
+        return rows
+
+    def mark_read(self, conversation_id: str) -> None:
+        self._ensure()
+        assert self._conn is not None
+        self._conn.execute(
+            "UPDATE messages SET is_read = 1 WHERE conversation_id = ? AND is_read = 0",
+            (conversation_id,),
+        )
+        self._conn.commit()
+
+    def close(self) -> None:
+        if self._conn is not None:
+            self._conn.close()
+            self._conn = None
+
+
+# ── Errors ──────────────────────────────────────────────────────────────
+class DaemonError(Exception):
+    def __init__(self, code: str, message: str, recoverable: bool = False, data: Any = None):
+        super().__init__(message)
+        self.code = code
+        self.message = message
+        self.recoverable = recoverable
+        self.data = data
+
+    def to_dict(self) -> dict:
+        out: dict[str, Any] = {
+            "code": self.code,
+            "message": self.message,
+            "recoverable": self.recoverable,
+        }
+        if self.data is not None:
+            out["data"] = self.data
+        return out
+
+
+# ── AUN service ─────────────────────────────────────────────────────────
+class AUNService:
+    """Thin wrapper around AUNClient that translates SDK callbacks into daemon events."""
+
+    def __init__(self, emit_event):
+        self._emit = emit_event
+        self.client = None
+        self.aid: Optional[str] = None
+        self.target: Optional[dict] = None
+        self.connected = False
+        self.gateway: Optional[str] = None
+        self._store: Optional[MessageStore] = None
+        self._seen_msg_ids: set[str] = set()
+        self._chat_id = ""
+
+    def _get_store(self) -> MessageStore:
+        if self._store is None:
+            db_dir = AUN_PATH / "AIDs" / (self.aid or "_") if self.aid else DATA_DIR
+            self._store = MessageStore(str(db_dir / "messages.db"))
+        return self._store
+
+    async def initialize(self, aid: Optional[str]) -> dict:
+        from aun_core import AUNClient
+        from aun_core.keystore.file import FileKeyStore
+        try:
+            from importlib.metadata import version as _pkg_version
+            sdk_ver = _pkg_version("fastaun")
+        except Exception:
+            try:
+                from aun_core import __version__ as sdk_ver  # type: ignore
+            except Exception:
+                sdk_ver = "unknown"
+
+        cfg = _load_config()
+        target_aid = aid or cfg.get("aid")
+        if not target_aid:
+            raise DaemonError("NO_AID", "No AID configured. Pass params.aid or configure via aun CLI.")
+        if not _is_valid_aid(target_aid):
+            raise DaemonError("INVALID_AID", f"Invalid AID: {target_aid}")
+
+        ks = FileKeyStore(AUN_PATH)
+        has_dir = (ks._aids_root / target_aid).is_dir()
+        local = ks.load_identity(target_aid)
+        if local is None and not has_dir:
+            raise DaemonError(
+                "AID_NOT_FOUND",
+                f"AID {target_aid} not found in keystore. Create it via: aun aid new {target_aid}",
+            )
+        if local is None or "private_key_pem" not in (local or {}):
+            raise DaemonError(
+                "AID_NOT_FOUND", f"AID {target_aid} private key missing"
+            )
+
+        self.client = AUNClient({"aun_path": str(AUN_PATH)}, debug=False)
+        self.aid = target_aid
+
+        self.client.on("message.received", self._on_message)
+        self.client.on("connection.state", self._on_state)
+
+        try:
+            auth = await self.client.auth.authenticate({"aid": target_aid})
+        except Exception as e:
+            raise DaemonError("AUTH_FAILED", f"Authentication failed: {e}", recoverable=True)
+
+        try:
+            await self.client.connect({
+                "access_token": auth["access_token"],
+                "gateway": auth["gateway"],
+                "auto_reconnect": True,
+                "slot_id": (self.target or {}).get("id") or "default",
+            })
+        except Exception as e:
+            raise DaemonError("GATEWAY_DISCONNECTED", f"Connect failed: {e}", recoverable=True)
+
+        self.connected = True
+        self.gateway = auth.get("gateway")
+        # update device-bound chat_id (used to filter echo-back messages)
+        device_id = getattr(self.client, "_device_id", "") or ""
+        slot = (self.target or {}).get("id") or "default"
+        self._chat_id = f"{target_aid}:{device_id}:{slot}"
+
+        # restore previous target (if any)
+        raw_target = cfg.get("target")
+        self.target = _normalize_target(raw_target)
+
+        # persist current aid
+        cfg["aid"] = target_aid
+        _save_config(cfg)
+
+        recent = _normalize_recent(cfg)
+
+        snapshot = {
+            "aid": target_aid,
+            "target": self.target,
+            "recent_targets": recent,
+            "gateway": self.gateway,
+            "sdk_version": sdk_ver,
+        }
+
+        # emit ready + connection_state events asynchronously
+        self._emit("ready", {
+            "aid": target_aid,
+            "target": self.target,
+            "gateway": self.gateway,
+        })
+        self._emit("connection_state", {"state": "connected", "reason": None})
+        return snapshot
+
+    async def set_target(self, aid: str) -> dict:
+        if not _is_valid_aid(aid):
+            raise DaemonError("INVALID_AID", f"Invalid AID: {aid}")
+        target = _make_peer_target(aid)
+        self.target = target
+        cfg = _load_config()
+        cfg["target"] = target
+        cfg = _record_target(cfg, target)
+        # keep chat_id slot aligned with target so echo filtering works
+        if self.client is not None:
+            device_id = getattr(self.client, "_device_id", "") or ""
+            self._chat_id = f"{self.aid}:{device_id}:{target['id']}"
+        return {"target": target}
+
+    async def send_text(self, text: str, encrypt: bool = True) -> dict:
+        if not self.target:
+            raise DaemonError("NO_TARGET", "No target set. Call set_target first.")
+        if not self.client or not self.connected:
+            raise DaemonError("NOT_CONNECTED", "Not connected to gateway.", recoverable=True)
+        target_id = self.target["id"]
+        payload = {"type": "text", "text": text, "chat_id": self._chat_id}
+        try:
+            result = await self.client.call(
+                "message.send",
+                {"to": target_id, "payload": payload, "encrypt": bool(encrypt)},
+            )
+        except Exception as e:
+            raise DaemonError("SEND_FAILED", f"Send failed: {e}", data={"raw": str(e)})
+
+        ts = int(time.time() * 1000)
+        msg_id = ""
+        if isinstance(result, dict):
+            msg_id = result.get("message_id") or ""
+            if not msg_id:
+                inner = result.get("message")
+                if isinstance(inner, dict):
+                    msg_id = inner.get("message_id") or ""
+        if not msg_id:
+            msg_id = f"sent_{target_id}_{ts}"
+
+        self._get_store().save(
+            message_id=msg_id,
+            conversation_id=target_id,
+            conversation_type="peer",
+            direction="sent",
+            sender=self.aid,
+            payload=text,
+            seq=None,
+            timestamp=ts,
+            is_read=1,
+        )
+        cfg = _load_config()
+        _record_target(cfg, self.target)
+
+        self._emit("message_sent", {
+            "message_id": msg_id,
+            "target": self.target,
+            "text": text,
+            "ts": ts,
+        })
+        return {"message_id": msg_id, "target": self.target, "ts": ts}
+
+    async def list_messages(self, target_id: str, limit: int = 50, before_id: Optional[int] = None) -> dict:
+        if not target_id:
+            raise DaemonError("INVALID_PARAMS", "target_id is required")
+        rows = self._get_store().history(target_id, limit, before_id)
+        messages = [
+            {
+                "id": r["id"],
+                "message_id": r.get("message_id"),
+                "conversation_id": r["conversation_id"],
+                "conversation_type": r["conversation_type"],
+                "direction": r["direction"],
+                "sender": r["sender"],
+                "text": r["payload"],
+                "seq": r.get("seq"),
+                "ts": r["timestamp"],
+                "is_read": r.get("is_read", 0),
+            }
+            for r in rows
+        ]
+        self._get_store().mark_read(target_id)
+        return {"messages": messages}
+
+    async def list_recent_targets(self) -> dict:
+        cfg = _load_config()
+        return {"targets": _normalize_recent(cfg)}
+
+    async def get_status(self) -> dict:
+        return {
+            "connected": self.connected,
+            "aid": self.aid,
+            "target": self.target,
+            "gateway": self.gateway,
+        }
+
+    async def shutdown(self) -> dict:
+        try:
+            if self.client:
+                try:
+                    await self.client.disconnect()
+                except Exception as e:
+                    log.warning("client.disconnect error: %s", e)
+        finally:
+            if self._store:
+                self._store.close()
+        return {"ok": True}
+
+    # ── SDK callbacks → events ──────────────────────────────────────────
+    async def _on_message(self, data):
+        if not isinstance(data, dict):
+            return
+        msg_id = data.get("message_id") or ""
+        if msg_id:
+            if msg_id in self._seen_msg_ids:
+                return
+            self._seen_msg_ids.add(msg_id)
+            if len(self._seen_msg_ids) > 500:
+                self._seen_msg_ids = set(list(self._seen_msg_ids)[-250:])
+
+        from_aid = data.get("from") or "?"
+        if from_aid == self.aid:
+            # echo from our own other instances — ignore in MVP
+            return
+
+        payload = data.get("payload", "")
+        text = (
+            payload.get("text") if isinstance(payload, dict)
+            else str(payload)
+        )
+        if text is None:
+            text = json.dumps(payload, ensure_ascii=False) if isinstance(payload, dict) else ""
+
+        # skip processing/menu status notifications (MVP)
+        if isinstance(payload, dict):
+            ptype = payload.get("type")
+            if ptype in ("processing", "menu.response", "menu.query") or ptype == "event":
+                return
+
+        seq = data.get("seq")
+        ts = int(time.time() * 1000)
+        e2ee = bool(data.get("e2ee"))
+
+        if not msg_id:
+            msg_id = f"recv_{from_aid}_{ts}"
+
+        self._get_store().save(
+            message_id=msg_id,
+            conversation_id=from_aid,
+            conversation_type="peer",
+            direction="recv",
+            sender=from_aid,
+            payload=text,
+            seq=seq,
+            timestamp=ts,
+            is_read=0,
+        )
+
+        cfg = _load_config()
+        _record_target(cfg, _make_peer_target(from_aid))
+
+        self._emit("message_received", {
+            "message_id": msg_id,
+            "from": from_aid,
+            "conversation_id": from_aid,
+            "conversation_type": "peer",
+            "text": text,
+            "seq": seq,
+            "ts": ts,
+            "e2ee": e2ee,
+        })
+
+    async def _on_state(self, data):
+        if not isinstance(data, dict):
+            return
+        state = data.get("state") or "unknown"
+        reason = data.get("reason")
+        self.connected = (state == "connected")
+        self._emit("connection_state", {"state": state, "reason": reason})
+
+
+# ── JSON-RPC dispatcher ─────────────────────────────────────────────────
+class Dispatcher:
+    def __init__(self, service: AUNService):
+        self.service = service
+        self._shutdown_requested = False
+
+    async def dispatch(self, method: str, params: dict) -> Any:
+        p = params or {}
+        if method == "initialize":
+            return await self.service.initialize(aid=p.get("aid"))
+        if method == "set_target":
+            aid = p.get("aid")
+            if not aid:
+                raise DaemonError("INVALID_PARAMS", "aid is required")
+            return await self.service.set_target(aid)
+        if method == "send_text":
+            text = p.get("text")
+            if text is None or not isinstance(text, str):
+                raise DaemonError("INVALID_PARAMS", "text is required and must be a string")
+            return await self.service.send_text(text, encrypt=p.get("encrypt", True))
+        if method == "list_messages":
+            return await self.service.list_messages(
+                target_id=p.get("target_id", ""),
+                limit=p.get("limit", 50),
+                before_id=p.get("before_id"),
+            )
+        if method == "list_recent_targets":
+            return await self.service.list_recent_targets()
+        if method == "get_status":
+            return await self.service.get_status()
+        if method == "shutdown":
+            self._shutdown_requested = True
+            return await self.service.shutdown()
+        raise DaemonError("UNKNOWN_METHOD", f"Unknown method: {method}")
+
+
+# ── Daemon main loop ────────────────────────────────────────────────────
+class Daemon:
+    def __init__(self):
+        self._out_lock = asyncio.Lock()
+        self._event_queue: asyncio.Queue = asyncio.Queue(maxsize=1000)
+        self.service = AUNService(self._emit)
+        self.dispatcher = Dispatcher(self.service)
+        self._stop_event = asyncio.Event()
+
+    def _emit(self, event: str, data: dict) -> None:
+        """Thread-safe event emitter (can be called from sync SDK callbacks)."""
+        try:
+            self._event_queue.put_nowait({"event": event, "data": data})
+        except asyncio.QueueFull:
+            log.warning("event queue full, dropping event: %s", event)
+
+    async def _write(self, obj: dict) -> None:
+        line = json.dumps(obj, ensure_ascii=False, default=str) + "\n"
+        async with self._out_lock:
+            try:
+                sys.stdout.write(line)
+                sys.stdout.flush()
+            except (BrokenPipeError, OSError):
+                self._stop_event.set()
+
+    async def _handle_request(self, raw: str) -> None:
+        try:
+            req = json.loads(raw)
+        except json.JSONDecodeError as e:
+            await self._write({
+                "id": None,
+                "error": {"code": "INVALID_PARAMS", "message": f"Bad JSON: {e}", "recoverable": False},
+            })
+            return
+
+        req_id = req.get("id")
+        method = req.get("method")
+        params = req.get("params") or {}
+
+        if not isinstance(method, str):
+            await self._write({
+                "id": req_id,
+                "error": {"code": "INVALID_PARAMS", "message": "method is required", "recoverable": False},
+            })
+            return
+
+        try:
+            result = await self.dispatcher.dispatch(method, params)
+            await self._write({"id": req_id, "result": result})
+        except DaemonError as e:
+            log.info("method %s → error %s: %s", method, e.code, e.message)
+            await self._write({"id": req_id, "error": e.to_dict()})
+        except Exception as e:
+            log.exception("method %s unexpected exception", method)
+            await self._write({
+                "id": req_id,
+                "error": {
+                    "code": "INTERNAL_ERROR",
+                    "message": f"{type(e).__name__}: {e}",
+                    "recoverable": False,
+                },
+            })
+
+        if self.dispatcher._shutdown_requested and method == "shutdown":
+            self._stop_event.set()
+
+    async def _read_loop(self) -> None:
+        loop = asyncio.get_running_loop()
+        while not self._stop_event.is_set():
+            line = await loop.run_in_executor(None, sys.stdin.readline)
+            if not line:
+                log.info("stdin closed, stopping")
+                self._stop_event.set()
+                break
+            line = line.strip()
+            if not line:
+                continue
+            # handle concurrently so long-running methods don't block short ones
+            asyncio.create_task(self._handle_request(line))
+
+    async def _event_loop(self) -> None:
+        while not self._stop_event.is_set():
+            try:
+                evt = await asyncio.wait_for(self._event_queue.get(), timeout=0.5)
+            except asyncio.TimeoutError:
+                continue
+            await self._write(evt)
+
+    async def run(self) -> int:
+        def _sig_handler(signum, _frame):
+            log.info("signal %s received, stopping", signum)
+            self._stop_event.set()
+
+        try:
+            signal.signal(signal.SIGTERM, _sig_handler)
+            signal.signal(signal.SIGINT, _sig_handler)
+        except ValueError:
+            pass  # non-main thread: skip
+
+        reader = asyncio.create_task(self._read_loop())
+        events = asyncio.create_task(self._event_loop())
+
+        await self._stop_event.wait()
+
+        for t in (reader, events):
+            if not t.done():
+                t.cancel()
+        for t in (reader, events):
+            try:
+                await t
+            except asyncio.CancelledError:
+                pass
+
+        # drain any remaining events briefly
+        while not self._event_queue.empty():
+            try:
+                await self._write(self._event_queue.get_nowait())
+            except Exception:
+                break
+        return 0
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description="AUN headless daemon (MVP v0.1)")
+    ap.add_argument("--data-dir", help="override AUN data dir (default ~/.aun or $AUN_CLI_DATA)")
+    args = ap.parse_args()
+
+    _init_paths(args.data_dir)
+    log.info("aun_daemon starting  data_dir=%s", AUN_PATH)
+
+    try:
+        return asyncio.run(Daemon().run())
+    except KeyboardInterrupt:
+        return 130
+
+
+if __name__ == "__main__":
+    sys.exit(main())