ForcePilot/backend/package/yuxi/channels/adapters/nostr/adapter.py

from __future__ import annotations

import asyncio
from dataclasses import dataclass
from typing import Any

from yuxi.channels.base import BaseChannelAdapter
from yuxi.channels.capabilities import ChannelCapabilities
from yuxi.channels.meta import ChannelMeta
from yuxi.channels.exceptions import (
    ChannelAuthenticationError,
    ChannelException,
)
from yuxi.channels.models import (
    Attachment,
    ChannelIdentity,
    ChannelMessage,
    ChannelResponse,
    ChannelStatus,
    ChannelType,
    ChatType,
    DeliveryResult,
    EventType,
    HealthStatus,
    MessageType,
)
from yuxi.channels.registry import register_builtin_adapter
from yuxi.channels.adapters.nostr.config import NostrConfig
from yuxi.channels.adapters.nostr.crypto import NostrCrypto, NostrCryptoError
from yuxi.channels.adapters.nostr.relay_manager import RelayManager
from yuxi.channels.adapters.nostr.send import NostrSender
from yuxi.channels.adapters.nostr.monitor import NostrMonitor
from yuxi.channels.adapters.nostr.probe import probe_relay
from yuxi.channels.adapters.nostr.guard import NostrGuard, GuardPolicy
from yuxi.channels.adapters.nostr.health import RelayHealthTracker
from yuxi.channels.adapters.nostr.crypto import normalize_pubkey
from yuxi.channels.adapters.nostr.state_store import NostrStateStore
from yuxi.channels.adapters.nostr.metrics import NostrMetrics
from yuxi.channels.adapters.nostr.send_cache import SendCache
from yuxi.utils.datetime_utils import utc_now_naive
from yuxi.utils.logging_config import logger

import aiohttp
import json as _json


@dataclass
class _AccountComponents:
    crypto: NostrCrypto | None = None
    relay_manager: RelayManager | None = None
    sender: NostrSender | None = None
    monitor: NostrMonitor | None = None
    guard: NostrGuard | None = None
    state_store: NostrStateStore | None = None
    send_cache: SendCache | None = None
    metrics: NostrMetrics | None = None
    config: NostrConfig | None = None


@register_builtin_adapter
class NostrAdapter(BaseChannelAdapter):
    channel_id = "nostr"
    channel_type = ChannelType.NOSTR

    supports_markdown = False
    supports_streaming = True
    streaming_modes = ["off", "block", "progress"]
    max_media_size_mb = 10
    channel_env_vars = ["NOSTR_PRIVATE_KEY"]

    capabilities = ChannelCapabilities(
        chat_types=["direct", "group"],
        reactions=True,
        edit=True,
        unsend=True,
        reply=True,
        media=True,
        supports_markdown=False,
        supports_streaming=True,
        streaming_modes=["off", "block", "progress"],
        text_chunk_limit=4096,
        max_media_size_mb=10,
    )
    meta = ChannelMeta(
        id="nostr",
        label="Nostr",
        selection_label="Nostr (Decentralized)",
        blurb=(
            "Decentralized social network DM protocol. "
            "Supports NIP-04/NIP-17 encryption, message editing, reactions, and streaming."
        ),
        docs_path="/docs/channels/nostr",
        docs_label="Nostr Setup Guide",
        order=60,
        system_image="nostr.svg",
    )

    def __init__(self, config: dict[str, Any] | None = None):
        super().__init__(config)
        self._status = ChannelStatus.DISCONNECTED
        self._nostr_config: NostrConfig | None = None
        self._crypto: NostrCrypto | None = None
        self._relay_manager: RelayManager | None = None
        self._sender: NostrSender | None = None
        self._monitor: NostrMonitor | None = None
        self._guard: NostrGuard | None = None
        self._health_tracker = RelayHealthTracker()
        self._state_store: NostrStateStore | None = None
        self._metrics = NostrMetrics()
        self._send_cache = SendCache()
        self._active_buses: dict[str, Any] = {}
        self._pending_tasks: list[asyncio.Task] = []
        self._state_dir = self._resolve_state_dir()
        self._order_buffer: list[dict] = []
        self._order_lock = asyncio.Lock()
        self._ordering_task: asyncio.Task | None = None
        self._account_managers: dict[str, _AccountComponents] = {}
        self._active_account_id: str = "default"

    async def connect(self) -> None:
        self._status = ChannelStatus.CONNECTING
        logger.info(f"[Nostr] Starting channel '{self.config.get('name', self.channel_id)}'")

        self._nostr_config = NostrConfig.from_dict(self.config)

        await self._init_primary_account(self._nostr_config)

        if self._nostr_config.multi_account_enabled:
            account_configs = self._nostr_config.get_account_configs(self.config)
            for account_id, account_cfg in account_configs.items():
                if account_id == "default":
                    continue
                logger.info(f"[Nostr] 初始化额外账户: {account_id}")
                try:
                    await self._init_additional_account(account_id, account_cfg)
                except ChannelAuthenticationError as e:
                    logger.warning(f"[Nostr] 账户 '{account_id}' 初始化失败: {e}")
                except Exception as e:
                    logger.warning(f"[Nostr] 账户 '{account_id}' 初始化异常: {e}")

        self._relay_manager.on_connect(lambda url: self._on_relay_connected_metrics(url))
        self._relay_manager.on_disconnect(lambda url: self._on_relay_disconnected_metrics(url))

        await self._relay_manager.connect_all()

        for components in self._account_managers.values():
            if components.relay_manager is not self._relay_manager:
                await components.relay_manager.connect_all()

        if self._nostr_config.nip42_auth_enabled:
            await self._perform_nip42_auth()

        await self._monitor.subscribe(self._nostr_config.dm_policy)
        self._monitor.on_event(self._on_relay_event)
        await self._monitor.start()

        for components in self._account_managers.values():
            if components.monitor is not self._monitor:
                await components.monitor.subscribe(components.config.dm_policy)
                components.monitor.on_event(self._on_relay_event)
                await components.monitor.start()

        if self._nostr_config.message_ordering:
            self._ordering_task = asyncio.create_task(self._run_order_buffer())

        self._status = ChannelStatus.CONNECTED
        account_count = 1 + len(self._account_managers)
        logger.info(f"[Nostr] Channel connected. npub: {self._crypto.npub}, 账户数: {account_count}")

    async def _init_primary_account(self, cfg: NostrConfig) -> None:
        try:
            self._crypto = NostrCrypto(cfg.private_key)
        except NostrCryptoError:
            raise ChannelAuthenticationError(
                "Nostr 私钥无效，请在配置中提供有效的 private_key (nsec/hex) 或留空自动生成"
            )

        self._state_store = NostrStateStore(self._state_dir, channel_name="nostr")
        self._send_cache = SendCache(max_size=cfg.send_message_cache_size)
        cached_entries = self._state_store.load_send_cache()
        if cached_entries:
            self._send_cache = SendCache.from_dict_list(cached_entries, max_size=cfg.send_message_cache_size)

        self._relay_manager = RelayManager(
            cfg.relays,
            timeout=cfg.relay_timeout_sec,
            reconnect_interval=cfg.reconnect_interval_sec,
        )
        self._sender = NostrSender(self._crypto, self._relay_manager, cfg)
        self._monitor = NostrMonitor(self._crypto, self._relay_manager, backfill_window_sec=cfg.backfill_window_sec)

        guard_policy = self._build_guard_policy(cfg)
        self._guard = NostrGuard(self._crypto.pubkey_hex(), guard_policy)

        self._restore_state()

    async def _init_additional_account(self, account_id: str, cfg: NostrConfig) -> None:
        try:
            crypto = NostrCrypto(cfg.private_key)
        except NostrCryptoError:
            raise ChannelAuthenticationError(f"账户 '{account_id}' 私钥无效")

        state_store = NostrStateStore(self._state_dir, channel_name=f"nostr_{account_id}")
        send_cache = SendCache(max_size=cfg.send_message_cache_size)

        relay_manager = RelayManager(
            cfg.relays,
            timeout=cfg.relay_timeout_sec,
            reconnect_interval=cfg.reconnect_interval_sec,
        )
        sender = NostrSender(crypto, relay_manager, cfg)
        monitor = NostrMonitor(crypto, relay_manager, backfill_window_sec=cfg.backfill_window_sec)

        guard_policy = self._build_guard_policy(cfg)
        guard = NostrGuard(crypto.pubkey_hex(), guard_policy)

        cached = state_store.load_send_cache()
        if cached:
            send_cache = SendCache.from_dict_list(cached, max_size=cfg.send_message_cache_size)

        relay_manager.on_connect(lambda url: self._on_relay_connected_metrics(url))
        relay_manager.on_disconnect(lambda url: self._on_relay_disconnected_metrics(url))

        self._account_managers[account_id] = _AccountComponents(
            crypto=crypto,
            relay_manager=relay_manager,
            sender=sender,
            monitor=monitor,
            guard=guard,
            state_store=state_store,
            send_cache=send_cache,
            metrics=NostrMetrics(),
            config=cfg,
        )

    @staticmethod
    def _build_guard_policy(cfg: NostrConfig) -> GuardPolicy:
        return GuardPolicy(
            allowed_kinds=set(cfg.guard_policy.allowed_kinds),
            max_ciphertext_bytes=cfg.guard_policy.max_ciphertext_bytes,
            max_plaintext_bytes=cfg.guard_policy.max_plaintext_bytes,
            max_future_skew_sec=cfg.guard_policy.max_future_skew_sec,
            rate_limit_window_ms=cfg.guard_policy.rate_limit.window_ms,
            rate_limit_max_per_sender_per_window=cfg.guard_policy.rate_limit.max_per_sender_per_window,
            rate_limit_max_global_per_window=cfg.guard_policy.rate_limit.max_global_per_window,
            dm_policy=cfg.dm_policy,
            allow_from=cfg.allow_from,
        )

    def _restore_state(self) -> None:
        saved_events = self._state_store.load_seen_events()
        for event_id in saved_events:
            self._guard._seen.mark_seen(event_id)
        saved_inflight = self._state_store.load_inflight()
        for event_id in saved_inflight:
            self._guard._inflight.add(event_id)
        if saved_events or saved_inflight:
            logger.info(
                "[Nostr] 从 state_store 恢复状态: seen=%s, inflight=%s",
                len(saved_events),
                len(saved_inflight),
            )
        last_ts = self._state_store.load_last_processed_at()
        if last_ts and self._monitor._last_subscribe_ts == 0:
            self._monitor._last_subscribe_ts = last_ts

    async def _perform_nip42_auth(self) -> None:
        auth_event = self._crypto.build_and_sign_event(
            kind=22242,
            content="",
            tags=[["relay", url] for url in (self._nostr_config.nip42_auth_urls or self._nostr_config.relays)],
        )
        auth_urls = self._nostr_config.nip42_auth_urls or self._nostr_config.relays
        auth_results: dict[str, bool] = {url: False for url in auth_urls}
        max_retries = 3
        base_delay = 2.0

        for attempt in range(max_retries):
            remaining = [url for url, ok in auth_results.items() if not ok]
            if not remaining:
                break

            result = await self._relay_manager.send_auth(auth_event, urls=remaining)
            for url, ok in result.items():
                if ok:
                    auth_results[url] = True
                    logger.info(f"[Nostr] NIP-42 AUTH 成功: {url}")
                else:
                    logger.warning(f"[Nostr] NIP-42 AUTH 失败: {url} (尝试 {attempt + 1}/{max_retries})")

            if remaining:
                delay = base_delay * (2**attempt)
                await asyncio.sleep(delay)

        failed = [url for url, ok in auth_results.items() if not ok]
        if failed:
            logger.warning(f"[Nostr] NIP-42 AUTH 最终失败 {len(failed)} 个 Relay: {failed}")

    async def disconnect(self) -> None:
        if self._ordering_task:
            self._ordering_task.cancel()
            self._ordering_task = None

        if self._state_store:
            self._state_store.save_last_processed_at(self._monitor._last_subscribe_ts if self._monitor else 0)
            self._state_store.save_send_cache(self._send_cache.to_dict_list())
            if self._guard:
                self._state_store.save_inflight(list(self._guard.inflight))
        tasks = []
        if self._monitor:
            tasks.append(self._monitor.stop())
        if self._relay_manager:
            tasks.append(self._relay_manager.disconnect_all())
        if tasks:
            await asyncio.gather(*tasks)
        self._status = ChannelStatus.DISCONNECTED

    async def send(self, response: ChannelResponse) -> DeliveryResult:
        if not self._sender:
            return DeliveryResult(success=False, error="Sender 未初始化")

        try:
            result = await self._sender.send(response)
            if result.success and result.message_id:
                self._send_cache.record(result.message_id, response.content[:100], "sent")
            return result
        except NostrCryptoError as e:
            return DeliveryResult(success=False, error=f"加密错误: {e}")
        except Exception as e:
            logger.warning(f"[Nostr] 消息发送异常: {e}")
            return DeliveryResult(success=False, error=str(e))

    async def send_media(self, chat_id: str, media_type: str, data: Any) -> DeliveryResult:
        if not self._sender:
            return DeliveryResult(success=False, error="Sender 未初始化")

        receiver_pubkey = ""
        if ":" in chat_id:
            receiver_pubkey = chat_id.split(":")[-1]

        url = data if isinstance(data, str) else ""
        caption = f"[{media_type}]"

        try:
            return await self._sender.send_media_text(
                media_url=url,
                caption=caption,
                receiver_pubkey=receiver_pubkey,
            )
        except Exception as e:
            return DeliveryResult(success=False, error=str(e))

    async def edit_message(self, chat_id: str, msg_id: str, content: str) -> DeliveryResult:
        if not self._sender:
            return DeliveryResult(success=False, error="Sender 未初始化")

        receiver_pubkey = ""
        if ":" in chat_id:
            receiver_pubkey = chat_id.split(":")[-1]

        try:
            return await self._sender.send_edit(
                original_event_id=msg_id,
                new_content=content,
                receiver_pubkey=receiver_pubkey,
            )
        except Exception as e:
            return DeliveryResult(success=False, error=str(e))

    async def delete_message(self, chat_id: str, msg_id: str) -> DeliveryResult:
        if not self._sender:
            return DeliveryResult(success=False, error="Sender 未初始化")

        receiver_pubkey = ""
        chat_type = "direct"
        if ":" in chat_id:
            parts = chat_id.split(":")
            if parts[0] == "dm":
                receiver_pubkey = parts[-1]
                chat_type = "direct"
            else:
                chat_type = "group"

        try:
            return await self._sender.send_delete(msg_id, receiver_pubkey, chat_type)
        except Exception as e:
            return DeliveryResult(success=False, error=str(e))

    async def send_reaction(self, chat_id: str, msg_id: str, emoji: str) -> DeliveryResult:
        if not self._sender:
            return DeliveryResult(success=False, error="Sender 未初始化")

        target_pubkey = msg_id
        if ":" in msg_id:
            parts = msg_id.split(":")
            target_pubkey = parts[-1]
        return await self._sender.send_reaction(chat_id, target_pubkey, emoji)

    async def remove_reaction(self, chat_id: str, msg_id: str) -> DeliveryResult:
        if not self._sender:
            return DeliveryResult(success=False, error="Sender 未初始化")

        target_pubkey = msg_id
        if ":" in msg_id:
            parts = msg_id.split(":")
            target_pubkey = parts[-1]
        return await self._sender.remove_reaction(msg_id, target_pubkey)

    async def send_chat_action(self, chat_id: str, action: str) -> DeliveryResult:
        if not self._sender:
            return DeliveryResult(success=False, error="Sender 未初始化")

        receiver_pubkey = ""
        if ":" in chat_id:
            receiver_pubkey = chat_id.split(":")[-1]
        return await self._sender.send_typing(chat_id, receiver_pubkey)

    async def send_stream_chunk(self, chat_id: str, msg_id: str, chunk: str, finished: bool) -> DeliveryResult:
        receiver_pubkey = ""
        if ":" in chat_id:
            receiver_pubkey = chat_id.split(":")[-1]

        streaming_mode = self._nostr_config.streaming_mode if self._nostr_config else "block"

        if streaming_mode == "off":
            if finished:
                identity = self._build_stream_identity(chat_id, msg_id)
                response = ChannelResponse(identity=identity, content=chunk)
                return await self.send(response)
            return DeliveryResult(success=True, message_id=None)

        if streaming_mode == "block":
            if finished:
                if msg_id and self._sender:
                    return await self._sender.send_edit(
                        original_event_id=msg_id,
                        new_content=chunk,
                        receiver_pubkey=receiver_pubkey,
                    )
                identity = self._build_stream_identity(chat_id, msg_id)
                response = ChannelResponse(identity=identity, content=chunk)
                return await self.send(response)
            return DeliveryResult(success=True, message_id=None)

        # progress 模式：每块都发送编辑
        if finished:
            if msg_id and self._sender:
                return await self._sender.send_edit(
                    original_event_id=msg_id,
                    new_content=chunk,
                    receiver_pubkey=receiver_pubkey,
                )
            identity = self._build_stream_identity(chat_id, msg_id)
            response = ChannelResponse(identity=identity, content=chunk)
            return await self.send(response)

        if msg_id and self._sender:
            return await self._sender.send_edit(
                original_event_id=msg_id,
                new_content=chunk,
                receiver_pubkey=receiver_pubkey,
            )

        identity = self._build_stream_identity(chat_id, msg_id)
        response = ChannelResponse(identity=identity, content=chunk)
        return await self.send(response)

    async def get_user_info(self, channel_user_id: str) -> dict[str, Any]:
        if not self._relay_manager:
            return {}

        filters = [{"kinds": [0], "authors": [channel_user_id], "limit": 1}]
        try:
            events = await self._relay_manager.query(filters, timeout=10)
            for event in events:
                content = event.get("content", "{}")
                metadata = _json.loads(content)
                return {
                    "pubkey": channel_user_id,
                    "name": metadata.get("name", ""),
                    "display_name": metadata.get("display_name", ""),
                    "picture": metadata.get("picture", ""),
                    "banner": metadata.get("banner", ""),
                    "website": metadata.get("website", ""),
                    "about": metadata.get("about", ""),
                    "nip05": metadata.get("nip05", ""),
                }
        except Exception:
            logger.debug(f"[Nostr] 获取用户信息失败: {channel_user_id}", exc_info=True)
        return {"pubkey": channel_user_id}

    async def download_media(self, file_id: str) -> bytes:
        try:
            async with aiohttp.ClientSession() as session:
                async with session.get(file_id, timeout=aiohttp.ClientTimeout(total=30)) as resp:
                    if resp.status == 200:
                        content_length = resp.content_length or 0
                        if content_length > self.max_media_size_mb * 1024 * 1024:
                            raise ChannelException(
                                f"媒体文件超过大小限制 ({self.max_media_size_mb}MB)",
                                retryable=False,
                            )
                        return await resp.read()
                    raise ChannelException(
                        f"媒体下载失败 HTTP {resp.status}",
                        retryable=True,
                    )
        except ChannelException:
            raise
        except Exception as e:
            raise ChannelException(f"媒体下载出错: {e}", retryable=True)

    async def pre_connect(self) -> dict:
        private_key = self.config.get("private_key") or self.config.get("accounts", {}).get("default", {}).get(
            "private_key", ""
        )
        relays = self.config.get("relays") or self.config.get("accounts", {}).get("default", {}).get("relays")
        if not relays:
            relays = [
                "wss://relay.damus.io",
                "wss://relay.primal.net",
                "wss://relay.nostr.info",
                "wss://nos.lol",
            ]

        if not private_key:
            return {"status": "error", "message": "Missing private_key (nsec/hex)"}

        try:
            crypto = NostrCrypto(private_key)
            pubkey_ok = crypto.npub
        except NostrCryptoError as e:
            return {"status": "error", "message": str(e)}

        probe_tasks = [probe_relay(url, timeout=8.0) for url in relays]
        probe_results = await asyncio.gather(*probe_tasks, return_exceptions=True)

        reachable = 0
        probe_details: list[dict] = []
        for result in probe_results:
            if isinstance(result, Exception):
                probe_details.append({"error": str(result)})
                continue
            entry = {
                "url": result.url,
                "connected": result.connected,
                "latency_ms": round(result.latency_ms, 1) if result.latency_ms else None,
            }
            if result.connected:
                reachable += 1
            if result.error:
                entry["error"] = result.error[:120]
            probe_details.append(entry)

        if reachable == 0:
            return {
                "status": "warning",
                "message": "所有 Relay 探测不可达",
                "npub": pubkey_ok,
                "relay_probe": probe_details,
            }

        return {
            "status": "ok",
            "npub": pubkey_ok,
            "relays_reachable": f"{reachable}/{len(relays)}",
            "relay_probe": probe_details,
        }

    def normalize_inbound(self, raw: dict) -> ChannelMessage:
        kind = raw.get("kind", 1)
        content = raw.get("content", "")
        pubkey = raw.get("pubkey", "")
        event_id = raw.get("id", "")
        tags: list[list[str]] = raw.get("tags", [])

        event_type = EventType.MESSAGE_RECEIVED
        if kind == 5:
            event_type = EventType.MESSAGE_DELETED
            e_tags = [t for t in tags if t and t[0] == "e" and len(t) > 1]
            deleted_ids = [t[1] for t in e_tags]
            content = f"(deleted events: {', '.join(deleted_ids[:3])})" if deleted_ids else "(deletion)"
        elif kind == 7:
            e_tags = [t for t in tags if t and t[0] == "e" and len(t) > 1]
            if not content.strip() or content == "+":
                event_type = EventType.REACTION_REMOVED
                content = "(reaction removed)" if e_tags else "(reaction removed)"
            elif e_tags:
                event_type = EventType.REACTION_ADDED
                content = f"reacted with {content}"
            else:
                event_type = EventType.REACTION_ADDED
                content = f"reaction: {content}"

        edit_tags = [t for t in tags if t and t[0] == "e" and len(t) > 3 and t[3] == "edit"]
        if edit_tags and event_type == EventType.MESSAGE_RECEIVED and kind not in (5, 7):
            event_type = EventType.MESSAGE_UPDATED

        chat_type = self._resolve_chat_type(kind, tags)
        reply_to = self._extract_reply_to(tags)
        chat_id = self._resolve_chat_id(chat_type, tags, pubkey)

        attachments = self._extract_attachments(raw)

        mention_list = self._extract_mentions(content)
        mentions = None
        if mention_list:
            from yuxi.channels.models import MentionsInfo

            mentions = MentionsInfo(
                mentioned_user_ids=mention_list,
                is_bot_mentioned=False,
            )

        return ChannelMessage(
            identity=ChannelIdentity(
                channel_id=self.channel_id,
                channel_type=self.channel_type,
                channel_user_id=pubkey,
                channel_chat_id=chat_id,
                channel_message_id=event_id,
            ),
            message_type=MessageType.TEXT if not attachments else MessageType.IMAGE,
            chat_type=ChatType.DIRECT if chat_type == "direct" else ChatType.GROUP,
            content=content,
            attachments=attachments,
            reply_to_message_id=reply_to,
            event_type=event_type,
            mentions=mentions,
        )

    def format_outbound(self, response: ChannelResponse) -> Any:
        return {"content": response.content, "identity": response.identity.model_dump()}

    async def health_check(self) -> HealthStatus:
        if not self._relay_manager:
            return HealthStatus(status="unhealthy", last_error="RelayManager 未初始化")

        active, total = self._relay_manager.active_count()
        if total == 0 or active == 0:
            return HealthStatus(
                status="unhealthy",
                last_error="没有 Relay" if total == 0 else "所有 Relay 断连",
            )

        threshold = self._nostr_config.relay_degraded_threshold if self._nostr_config else 0.5
        if active / total < threshold:
            return HealthStatus(
                status="degraded",
                metadata={"active_relays": active, "total_relays": total},
            )

        health_snapshots = []
        for url in self._nostr_config.relays if self._nostr_config else []:
            snapshot = self._health_tracker.snapshot(url)
            health_snapshots.append(snapshot.url)

        return HealthStatus(
            status="healthy",
            last_connected_at=utc_now_naive(),
            metadata={
                "active_relays": active,
                "total_relays": total,
                "npub": self._crypto.npub if self._crypto else "",
            },
        )

    def _resolve_chat_type(self, kind: int, tags: list[list[str]]) -> str:
        if kind in (4, 1059):
            return "direct"
        if kind == 5:
            p_tags = [t for t in tags if t and t[0] == "p"]
            if len(p_tags) == 1:
                return "direct"
            return "group"
        if kind == 7:
            e_tags = [t for t in tags if t and t[0] == "e"]
            p_tags = [t for t in tags if t and t[0] == "p"]
            if len(p_tags) == 1 and len(e_tags) <= 1:
                return "direct"
            return "group"
        e_tags = [t for t in tags if t and t[0] == "e"]
        if any(len(t) > 3 and t[3] == "root" for t in e_tags):
            return "group"
        p_tags = [t for t in tags if t and t[0] == "p"]
        if len(p_tags) == 1 and len(e_tags) <= 1:
            return "direct"
        return "group"

    def _resolve_chat_id(self, chat_type: str, tags: list[list[str]], pubkey: str) -> str:
        if chat_type == "direct":
            p_tags = [t for t in tags if t and t[0] == "p"]
            other_pubkey = p_tags[0][1] if p_tags and len(p_tags[0]) > 1 else pubkey
            return f"dm:{other_pubkey}"
        e_tags = [t for t in tags if t and t[0] == "e"]
        for tag in e_tags:
            if len(tag) > 3 and tag[3] == "root":
                return f"channel:{tag[1]}"
        if e_tags and len(e_tags[0]) > 1:
            return f"channel:{e_tags[0][1]}"
        return f"channel:{pubkey}"

    def _extract_reply_to(self, tags: list[list[str]]) -> str | None:
        e_tags = [t for t in tags if t and t[0] == "e"]
        for tag in e_tags:
            if len(tag) > 3 and tag[3] in ("reply", "root"):
                continue
            if len(tag) > 1:
                return tag[1]
        if e_tags and len(e_tags[-1]) > 1:
            return e_tags[-1][1]
        return None

    def _extract_attachments(self, raw: dict) -> list[Attachment]:
        attachments: list[Attachment] = []
        tags: list[list[str]] = raw.get("tags", [])

        for tag in tags:
            if tag and tag[0] == "url" and len(tag) > 1:
                url = tag[1]
                attachments.append(
                    Attachment(
                        type=self._guess_media_type(url),
                        url=url,
                    )
                )
            elif tag and tag[0] == "imeta" and len(tag) > 1:
                url = tag[1] if tag[1].startswith("http") else ""
                if url:
                    attachments.append(Attachment(type="image", url=url))

        content = raw.get("content", "")
        if content.startswith("http") and not attachments:
            attachments.append(Attachment(type=self._guess_media_type(content), url=content))

        return attachments

    @staticmethod
    def _guess_media_type(url: str) -> str:
        lower = url.lower()
        if any(lower.endswith(ext) for ext in (".jpg", ".jpeg", ".png", ".gif", ".webp", ".svg")):
            return "image"
        if any(lower.endswith(ext) for ext in (".mp4", ".webm", ".mov", ".avi")):
            return "video"
        if any(lower.endswith(ext) for ext in (".mp3", ".wav", ".ogg", ".flac")):
            return "audio"
        return "file"

    @staticmethod
    def _extract_mentions(content: str) -> list[str]:
        import re

        mentions: list[str] = []
        patterns = [
            r"nostr:(npub1[a-z0-9]+)",
            r"nostr:(nprofile1[a-z0-9]+)",
            r"nostr:([0-9a-f]{64})",
            r"@(npub1[a-z0-9]+)",
        ]
        for pattern in patterns:
            mentions.extend(re.findall(pattern, content, re.IGNORECASE))
        result: list[str] = []
        seen: set[str] = set()
        for m in mentions:
            norm = normalize_pubkey(m)
            if norm and norm not in seen:
                seen.add(norm)
                result.append(norm)
        return result

    def _on_relay_event(self, raw_event: dict) -> None:
        if self._nostr_config and self._nostr_config.message_ordering:
            asyncio.create_task(self._buffer_event(raw_event))
            return

        task = asyncio.ensure_future(self._handle_relay_event(raw_event))
        if not hasattr(self, "_pending_tasks"):
            self._pending_tasks: list[asyncio.Task] = []
        self._pending_tasks = [t for t in self._pending_tasks if not t.done()]
        self._pending_tasks.append(task)

    async def _handle_relay_event(self, raw_event: dict) -> None:
        event_id = raw_event.get("id", "")
        kind = raw_event.get("kind", 0)
        self._metrics.record_event_received(kind)

        if self._guard:
            self._metrics.record_inflight_size(len(self._guard.inflight) + 1)

        try:
            if self._guard:
                since_ts = self._monitor._last_subscribe_ts if self._monitor else 0
                reject_reason = self._guard.check(raw_event, since_ts=since_ts)
                if reject_reason:
                    self._metrics.record_event_rejected(reject_reason.replace(" ", "_"))
                    logger.debug(f"[Nostr] Guard rejected event: {reject_reason}")
                    return

            if self._crypto and not self._crypto.verify_event(raw_event):
                event_short = event_id[:8]
                pubkey_short = raw_event.get("pubkey", "?")[:8]
                self._metrics.record_event_rejected("signature_invalid")
                logger.warning(f"[Nostr] 签名验证失败，丢弃: id={event_short}, pubkey={pubkey_short}")
                return

            if kind == 1059 and self._crypto:
                try:
                    decrypted = await self._crypto.decrypt_nip17(raw_event.get("content", ""))
                    raw_event = {**raw_event, "content": decrypted, "kind": 1059}
                    if self._guard:
                        plaintext_reject = self._guard.check_plaintext_size(decrypted)
                        if plaintext_reject:
                            logger.debug("NIP-17 plaintext rejected: %s", plaintext_reject)
                            raw_event["content"] = f"(plaintext too large: {len(decrypted)} bytes)"
                except Exception as e:
                    logger.debug(
                        "NIP-17 解密失败: event=%s, sender=%s, error=%s",
                        event_id[:8],
                        raw_event.get("pubkey", "?")[:8],
                        e,
                    )

            if kind == 4 and self._crypto:
                try:
                    content = self._crypto.decrypt_nip04(raw_event.get("content", ""), raw_event.get("pubkey", ""))
                    if self._guard:
                        plaintext_reject = self._guard.check_plaintext_size(content)
                        if plaintext_reject:
                            logger.debug("NIP-04 plaintext rejected: %s", plaintext_reject)
                            content = f"(plaintext too large: {len(content)} bytes)"
                    raw_event["content"] = content
                except Exception as e:
                    logger.debug(
                        "NIP-04 解密失败: event=%s, sender=%s, error=%s",
                        event_id[:8],
                        raw_event.get("pubkey", "?")[:8],
                        e,
                    )

            self._metrics.record_event_accepted()
            message = self.normalize_inbound(raw_event)
            await self._handle_message(message)
        finally:
            if self._guard and event_id:
                self._guard.done_processing(event_id)

    async def _on_relay_connected_metrics(self, url: str) -> None:
        self._metrics.record_relay_connect(url)

    async def _on_relay_disconnected_metrics(self, url: str) -> None:
        self._metrics.record_relay_disconnect(url)

    async def _buffer_event(self, raw_event: dict) -> None:
        async with self._order_lock:
            self._order_buffer.append(raw_event)

    async def _run_order_buffer(self) -> None:
        window_ms = self._nostr_config.message_ordering_window_ms if self._nostr_config else 500
        interval = max(window_ms / 2, 100) / 1000

        while True:
            try:
                await asyncio.sleep(interval)
                await self._flush_order_buffer()
            except asyncio.CancelledError:
                await self._flush_order_buffer()
                break

    async def _flush_order_buffer(self) -> None:
        async with self._order_lock:
            if not self._order_buffer:
                return
            batch = self._order_buffer
            self._order_buffer = []

        batch.sort(key=lambda e: e.get("created_at", 0))

        for raw_event in batch:
            task = asyncio.ensure_future(self._handle_relay_event(raw_event))
            if not hasattr(self, "_pending_tasks"):
                self._pending_tasks: list[asyncio.Task] = []
            self._pending_tasks = [t for t in self._pending_tasks if not t.done()]
            self._pending_tasks.append(task)

    def _resolve_state_dir(self) -> str:
        from pathlib import Path

        state_base = Path.home() / ".forcepilot" / "channel_states" / "nostr"
        return str(state_base)

    async def list_peers(self, timeout: float = 15.0) -> list[dict]:
        if not self._relay_manager or not self._crypto:
            return []

        own_pubkey = self._crypto.pubkey_hex()
        filters_kind4 = [{"kinds": [4], "authors": [own_pubkey], "limit": 200}]
        filters_kind0 = [{"kinds": [0], "limit": 200}]

        known_pubkeys: dict[str, dict] = {}

        try:
            kind4_events = await self._relay_manager.query(filters_kind4, timeout=timeout)
            for event in kind4_events:
                tags = event.get("tags", [])
                p_tags = [t for t in tags if t and t[0] == "p" and len(t) > 1]
                for pt in p_tags:
                    pk = pt[1]
                    if pk not in known_pubkeys:
                        known_pubkeys[pk] = {"pubkey": pk, "source": "kind4"}
        except Exception:
            logger.debug("[Nostr] list_peers kind4 query failed", exc_info=True)

        try:
            kind0_events = await self._relay_manager.query(filters_kind0, timeout=timeout)
            for event in kind0_events:
                pk = event.get("pubkey", "")
                if pk and pk not in known_pubkeys:
                    known_pubkeys[pk] = {"pubkey": pk, "source": "kind0"}
        except Exception:
            logger.debug("[Nostr] list_peers kind0 query failed", exc_info=True)

        return list(known_pubkeys.values())

    def get_metrics_snapshot(self) -> dict:

        if self._guard:
            self._metrics.record_seen_tracker_size(len(self._guard._seen))
            self._metrics.record_inflight_size(len(self._guard.inflight))

        snapshot = self._metrics.snapshot()
        return {
            "counters": snapshot.counters,
            "gauges": snapshot.gauges,
            "timestamp": snapshot.timestamp,
        }

    def get_status_snapshot(self) -> dict:
        active, total = self._relay_manager.active_count() if self._relay_manager else (0, 0)
        relay_status = {}
        if self._relay_manager:
            for url in self._nostr_config.relays if self._nostr_config else []:
                ws = self._relay_manager._connections.get(url)
                cb = self._relay_manager._circuit_breakers.get(url)
                health = self._health_tracker.snapshot(url)
                relay_status[url] = {
                    "connected": ws is not None and ws.open,
                    "circuit_state": cb.state if cb else "unknown",
                    "health_score": health.score,
                }

        return {
            "status": self._status.value,
            "npub": self._crypto.npub if self._crypto else "",
            "relays": relay_status,
            "active_relays": active,
            "total_relays": total,
            "inflight": len(self._guard.inflight) if self._guard else 0,
            "send_cache_size": len(self._send_cache),
        }

    async def publish_profile(self, profile_data: dict, account_id: str = "default") -> dict | None:
        from yuxi.channels.adapters.nostr.profile import NostrProfileManager

        manager = NostrProfileManager(
            self._crypto,
            self._relay_manager,
            self._state_store,
        )
        from yuxi.channels.adapters.nostr.models import NostrProfile

        profile = NostrProfile(**profile_data)
        return await manager.publish_profile(profile, account_id)

    async def import_profile(self, pubkey: str) -> dict | None:
        from yuxi.channels.adapters.nostr.profile import NostrProfileManager

        manager = NostrProfileManager(self._crypto, self._relay_manager, self._state_store)
        result = await manager.import_profile_from_relays(pubkey)
        if result:
            return result.model_dump()
        return None

    def get_send_cache(self) -> list[dict]:
        return self._send_cache.to_dict_list()