# -*- coding: utf-8 -*- from __future__ import annotations import re import time from copy import deepcopy from datetime import datetime from typing import Any from astrbot.api import logger from quart import request from .companion_interaction_expression import allowed_expression_bands, current_interaction_projection from .helpers import _safe_int from .relationship_ledger import normalize_relationship_mode, record_manual_relationship_change class PrivateCompanionPageApiUsersGroupsMixin: @staticmethod def _relationship_score_input(value: Any) -> int: """Parse the dedicated manual companion intimacy baseline field.""" if isinstance(value, bool): raise ValueError("relationship_score must be an integer") if isinstance(value, int): score = value elif isinstance(value, str) and re.fullmatch(r"[+-]?\d+", value.strip()): score = int(value.strip()) else: raise ValueError("relationship_score must be an integer") if not -1200 <= score <= 1200: raise ValueError("relationship_score must be between -1200 and 1200") return score def _observation_profile_by_user_id_locked( self, data: dict[str, Any], user_id: str, ) -> tuple[str, dict[str, Any]] | None: """Resolve only an exact observation-only identity while the data lock is held.""" identity = self._single_line(user_id, 40) if not identity: return None finder = getattr(self.plugin, "_worldbook_group_observation_profile_by_identity", None) if callable(finder): candidate = finder(identity) if ( isinstance(candidate, tuple) and len(candidate) == 2 and isinstance(candidate[0], str) and isinstance(candidate[1], dict) and bool(candidate[1].get("observation_only")) ): return candidate[0], candidate[1] profiles = data.get("worldbook_member_profiles") if isinstance(data.get("worldbook_member_profiles"), dict) else {} profile = profiles.get(identity) if isinstance(profile, dict) and bool(profile.get("observation_only")): return identity, profile return None def _observation_user_summary(self, profile_id: str, profile: dict[str, Any]) -> dict[str, Any]: """Build a read-only user-page DTO without manufacturing a private user.""" identity = self._single_line(profile.get("user_id") or profile_id, 40) name = self._single_line(profile.get("name"), 60) or identity last_seen = profile.get("last_observed_at", profile.get("auto_registered_ts", 0)) scopes = profile.get("group_observation_scope_ids") if isinstance(profile.get("group_observation_scope_ids"), list) else [] return { "user_id": identity, "display_name": name, "nickname": name, "style": "", "is_qq_user": True, "platform_kind": "onebot", "platform_group": "qq", "platform_label": "QQ", "identity_label": "QQ 群聊观察", "stable_platform_identity": True, "source": "group_observation", "profile_source": "group_observation", "profile_source_label": "群聊观察", "profile_kind": "observation", "observation_only": True, "group_observation_only": True, "enabled": bool(profile.get("enabled", True)), "relationship_role": "observer", "relationship_mode": "observation_only", "relationship_mode_label": "observation only", "relationship_role_label": "仅观察对象", "relationship_score": 0, "relationship_ledger": {"items": [], "trend": "steady", "recent_delta": 0}, "current_interaction": { "expression_band": "relaxed", "label": "relaxed", "source": "group_observation", "reason": "observation_only", "updated_at": last_seen, "expires_at": 0, "manual_override": False, "allowed_bands": [], "reason_codes": ["observation_only"], }, "relationship_stage": "初识", "relationship_state": {"mode": "neutral", "source": "group_observation"}, "proactive_contact_enabled": False, "private_memory_enabled": False, "cross_group_memory_enabled": False, "p4_eligible": False, "effective_daily_limit": 0, "effective_daily_limit_text": "不主动触达", "last_seen_ts": last_seen, "last_seen": self.plugin._format_timestamp_elapsed(last_seen), "last_sent_ts": 0, "last_sent": "", "observed_group_count": len({self._single_line(item, 80) for item in scopes if self._single_line(item, 80)}), "profile_origin": self._single_line(profile.get("profile_origin"), 40) or "group_observation", } def _observation_user_detail(self, profile_id: str, profile: dict[str, Any]) -> dict[str, Any]: detail = self._observation_user_summary(profile_id, profile) member_summary = self._worldbook_member_profile_summary(profile_id, profile) detail.update( { "relationship_panel": { "observation_only": True, "message": "群聊观察档案不进入私聊亲密度、主动联系或安全权限链路。", }, "memory": {}, "expression_profile": {}, "intent_profile": {}, "behavior_habits": {"items": []}, "dialogue_episodes": [], "open_loops": [], "recent_reply_topics": [], "last_user_message": "", "last_companion_message": "", "delivery_route": {"available": False, "reason": "observation_only"}, "worldbook_member": member_summary, "p4_runtime": {"available": False, "reason": "observation_only"}, "formatted": { "relationship": "仅观察:中性,不进入私聊关系链路", "action_affinity": "不主动触达", "next_proactive": "不适用", }, } ) return detail async def list_users(self) -> dict[str, Any]: start = time.perf_counter() try: limit = self._query_int("limit", 80, 1, 300) async with self.plugin._data_lock: users = self.plugin.data.get("users", {}) if not isinstance(users, dict): users = {} user_items = [(user_id, dict(user)) for user_id, user in users.items() if isinstance(user, dict)] profiles = self.plugin.data.get("worldbook_member_profiles", {}) observation_items = [ (str(profile_id), deepcopy(profile)) for profile_id, profile in profiles.items() if isinstance(profile, dict) and bool(profile.get("observation_only")) ] if isinstance(profiles, dict) else [] items = [self._user_summary(user_id, user) for user_id, user in user_items] for item in items: item.setdefault("profile_kind", "private") item.setdefault("profile_source", "private_chat") item.setdefault("profile_source_label", "私聊用户") item.setdefault("observation_only", False) private_ids = {self._single_line(user_id, 40) for user_id, _ in user_items if self._single_line(user_id, 40)} for profile_id, profile in observation_items: identity = self._single_line(profile.get("user_id") or profile_id, 40) # A real private user always wins the display slot. The # observation profile remains a separate, non-authoritative # source until an explicit future merge consumes it. if not identity or identity in private_ids: continue items.append(self._observation_user_summary(profile_id, profile)) items.sort(key=lambda item: item.get("last_seen_ts") or 0, reverse=True) elapsed_ms = int((time.perf_counter() - start) * 1000) if elapsed_ms > 1200: logger.warning("[PrivateCompanionPage] 用户列表接口耗时较高: elapsed=%sms users=%s", elapsed_ms, len(items)) source_counts = { "private_chat": sum(1 for item in items if item.get("profile_kind") == "private"), "group_observation": sum(1 for item in items if item.get("observation_only")), } platform_counts: dict[str, int] = {} for item in items: platform = self._single_line(item.get("platform_group"), 32) or "web_other" platform_counts[platform] = platform_counts.get(platform, 0) + 1 return self._ok( { "items": items[:limit], "total": len(items), "private_total": source_counts["private_chat"], "observation_total": source_counts["group_observation"], "source_counts": source_counts, "platform_counts": platform_counts, } ) except Exception as exc: logger.error(f"[PrivateCompanionPage] 获取用户列表失败: {exc}", exc_info=True) return self._error(str(exc)) async def get_user(self) -> dict[str, Any]: user_id = str(request.args.get("user_id", "")).strip() if not user_id: return self._error("缺少 user_id") try: async with self.plugin._data_lock: user = deepcopy((self.plugin.data.get("users") or {}).get(user_id)) observation = None if not isinstance(user, dict): observation = self._observation_profile_by_user_id_locked(self.plugin.data, user_id) worldbook_member = self._worldbook_member_for_private_user_locked(self.plugin.data, user_id, user if isinstance(user, dict) else {}) if observation is not None: profile_id, profile = observation return self._ok(self._observation_user_detail(profile_id, deepcopy(profile))) if not isinstance(user, dict): return self._error("用户不存在") detail = self._user_summary(user_id, user) detail["relationship_panel"] = self._relationship_panel( user_id, user, relationship_stage=str(detail.get("relationship_stage") or ""), worldbook_member=worldbook_member, ) detail["current_interaction"] = detail["relationship_panel"]["current_interaction"] detail["expression_decision"] = detail["relationship_panel"]["expression_decision"] detail["p4_runtime"] = self._p4_page_status_projection() route_status_getter = getattr(self.plugin, "_private_delivery_route_status", None) delivery_route = route_status_getter(user_id, user) if callable(route_status_getter) else {} detail.update( { "memory": user.get("companion_memory") if isinstance(user.get("companion_memory"), dict) else {}, "expression_profile": self._expression_profile_summary(user), "intent_profile": user.get("intent_profile") if isinstance(user.get("intent_profile"), dict) else {}, "relationship_state": detail.get("relationship_state") if isinstance(detail.get("relationship_state"), dict) else {}, "behavior_habits": self._behavior_habit_summary(user), "dialogue_episodes": self._limited_list(user.get("dialogue_episodes"), 12), "open_loops": self._limited_list(user.get("open_loops"), 12), "recent_reply_topics": self._limited_list(user.get("recent_reply_topics"), 16), "last_user_message": self._display_message_text(user.get("last_user_message"), 500), "last_companion_message": self._display_message_text(user.get("last_companion_message"), 500), "delivery_route": delivery_route if isinstance(delivery_route, dict) else {}, "worldbook_member": worldbook_member, "formatted": { "relationship": self.plugin._format_relationship_summary(user), "action_affinity": self.plugin._format_action_affinity_summary(user), "next_proactive": self.plugin._format_next_proactive(user), }, } ) return self._ok(detail) except Exception as exc: logger.error(f"[PrivateCompanionPage] 获取用户详情失败: {exc}", exc_info=True) return self._error(str(exc)) async def update_user(self) -> dict[str, Any]: payload = await request.get_json(silent=True) or {} user_id = str(payload.get("user_id", "")).strip() if not user_id: return self._error("缺少 user_id") relationship_score = None intimacy_keys = [key for key in ("companion_intimacy", "relationship_score") if key in payload] if len(intimacy_keys) > 1: return self._error("陪伴亲密度字段不能重复提交") if intimacy_keys: try: relationship_score = self._relationship_score_input(payload.get(intimacy_keys[0])) except ValueError as exc: return self._error(str(exc)) requested_mode = str(payload.get("relationship_mode") or "").strip().lower() if "relationship_mode" in payload else None if requested_mode is not None and requested_mode not in {"normal", "owner_exclusive"}: return self._error("relationship_mode must be normal or owner_exclusive") requested_interaction_band = ( str(payload.get("current_interaction_band") or "").strip().lower() if "current_interaction_band" in payload else None ) interaction_expires_at = 0.0 if "current_interaction_expires_at" in payload: raw_expiry = payload.get("current_interaction_expires_at") if isinstance(raw_expiry, bool) or not isinstance(raw_expiry, (int, float)): return self._error("current_interaction_expires_at must be a timestamp") interaction_expires_at = float(raw_expiry) if interaction_expires_at < 0 or interaction_expires_at > time.time() + 366 * 86400: return self._error("current_interaction_expires_at is outside the allowed range") try: action_message = "" async with self.plugin._data_lock: users = self.plugin.data.get("users") if isinstance(self.plugin.data.get("users"), dict) else {} if not isinstance(users.get(user_id), dict) and self._observation_profile_by_user_id_locked(self.plugin.data, user_id): return self._error("仅观察档案不能通过私聊用户接口修改") user = self.plugin._get_user(user_id) expression_voice_needs_refresh = False previous_role = self.plugin._private_user_role(user, user_id) previous_mode = normalize_relationship_mode(user.get("relationship_mode"), previous_role) role = previous_role if "relationship_role" in payload: normalized_role = self.plugin._normalize_private_user_role(payload.get("relationship_role")) if not normalized_role: return self._error("relationship_role must be owner or friend") role = normalized_role next_mode = normalize_relationship_mode(requested_mode if requested_mode is not None else previous_mode, role) if requested_mode == "owner_exclusive" and role != "owner": return self._error("owner_exclusive relationship requires an owner user") if previous_mode == "owner_exclusive" and role != "owner" and requested_mode != "normal": return self._error("switch the relationship to a normal stage before changing the owner role") if previous_mode == "owner_exclusive" and requested_mode == "normal" and relationship_score is None: return self._error("leaving owner_exclusive requires selecting a normal relationship stage") if previous_mode == "owner_exclusive" and relationship_score is not None and requested_mode != "normal": return self._error("owner_exclusive relationship score is frozen; select a normal stage first") if next_mode == "owner_exclusive" and relationship_score is not None: return self._error("owner_exclusive relationship does not accept an exact score") if requested_interaction_band is not None: if not requested_interaction_band: return self._error("current_interaction_band is required") if requested_interaction_band not in allowed_expression_bands(role, next_mode): return self._error("current interaction band is not allowed for this relationship") if "enabled" in payload: enabled = bool(payload.get("enabled")) user["enabled"] = enabled user["manual_enabled"] = enabled user["manual_disabled"] = not enabled user["auto_enabled"] = False if enabled: self.plugin._ensure_private_user_umo(user_id, user) if not enabled: self.plugin._clear_pending_proactive_plan(user) if "nickname" in payload: user["nickname"] = self._single_line(payload.get("nickname"), 24) if "style" in payload: user["style"] = self._single_line(payload.get("style"), 24) if "relationship_role" in payload: user["relationship_role"] = role expression_voice_needs_refresh = role != previous_role if requested_mode is not None: user["relationship_mode"] = next_mode expression_voice_needs_refresh = expression_voice_needs_refresh or next_mode != previous_mode if relationship_score is not None: previous_score = user.get("relationship_score", 0) user["relationship_score"] = relationship_score record_manual_relationship_change( user, previous_score, relationship_score, now=time.time(), reason_code="administrator_manual_relationship_adjustment", ) if requested_interaction_band is not None: changed_at = time.time() user["current_interaction"] = current_interaction_projection( { "expression_band": requested_interaction_band, "source": "manual", "operator": "page_administrator", "reason": self._single_line(payload.get("current_interaction_reason"), 120) or "administrator_manual_override", "updated_at": changed_at, "expires_at": interaction_expires_at, "manual_override": True, }, relationship_role=role, relationship_mode=next_mode, now=changed_at, ) expression_voice_needs_refresh = True elif role != previous_role or next_mode != previous_mode: user["current_interaction"] = current_interaction_projection( user.get("current_interaction"), relationship_role=role, relationship_mode=next_mode, now=time.time(), ) if "proactive_daily_limit" in payload: user["proactive_daily_limit"] = _safe_int(payload.get("proactive_daily_limit"), -1, -1, 30) for key in ( "proactive_idle_minutes", "proactive_min_interval_minutes", "photo_daily_limit", "screen_peek_daily_limit", "poke_daily_limit", ): if key in payload: user[key] = _safe_int(payload.get(key), -1, -1) if self.plugin._private_user_role(user, user_id) == "friend": user["photo_daily_limit"] = -1 user["photo_sent_today"] = 0 user["photo_sent_day"] = "" user["photo_generated_today"] = 0 user["photo_generated_day"] = "" user["last_generated_photo_path"] = "" user["last_generated_photo_at"] = 0 user["screen_peek_daily_limit"] = -1 user["screen_peek_today"] = 0 user["screen_peek_day"] = "" user["screen_peek_last_at"] = 0 if "proactive_boundary_note" in payload: user["proactive_boundary_note"] = self._single_line(payload.get("proactive_boundary_note"), 180) if payload.get("reset_daily"): user["sent_today"] = 0 user["sent_day"] = "" user["ignored_streak"] = 0 user["photo_sent_today"] = 0 user["photo_sent_day"] = "" user["photo_generated_today"] = 0 user["photo_generated_day"] = "" user["screen_peek_today"] = 0 if payload.get("clear_schedule"): self.plugin._clear_pending_proactive_plan(user) if payload.get("clear_emotion_state"): user["intent_profile"] = {} user.pop("relationship_state", None) user["current_interaction"] = current_interaction_projection( None, relationship_role=user.get("relationship_role"), relationship_mode=user.get("relationship_mode"), ) if payload.get("clear_behavior_habits"): user["behavior_habits"] = {} if payload.get("clear_learning"): for key, empty in ( ("companion_memory", {}), ("expression_profile", {}), ("intent_profile", {}), ("recent_reply_topics", []), ("dialogue_episodes", []), ("open_loops", []), ("action_preferences", {}), ): user[key] = empty user.pop("relationship_state", None) user["episode_message_count"] = 0 user["last_episode_refresh_at"] = 0 user["last_memory_refresh_at"] = 0 expression_voice_needs_refresh = True if payload.get("clear_open_loops"): action_message = self.plugin._remove_open_loop_entry(user, "全部") remove_open_loop_text = self._single_line(payload.get("remove_open_loop_text"), 120) if remove_open_loop_text: action_message = self.plugin._remove_open_loop_entry(user, remove_open_loop_text) expression_action = self._single_line(payload.get("expression_action"), 40) if expression_action: action_message = self._apply_expression_profile_action(user, payload) if expression_action in {"approve", "delete_sample"}: expression_voice_needs_refresh = True if expression_voice_needs_refresh: voice_refresher = getattr(self.plugin, "_refresh_expression_voice_profile", None) if callable(voice_refresher): voice_refresher() self.plugin._save_data_sync() snapshot = deepcopy(user) result = self._user_summary(user_id, snapshot) result.update( { "expression_profile": self._expression_profile_summary(snapshot), } ) if action_message: result["message"] = action_message return self._ok(result) except Exception as exc: logger.error(f"[PrivateCompanionPage] 更新用户失败: {exc}", exc_info=True) return self._error(str(exc)) async def delete_user(self) -> dict[str, Any]: payload = await request.get_json(silent=True) or {} user_id = str(payload.get("user_id", "")).strip() if not user_id: return self._error("缺少 user_id") try: async with self.plugin._data_lock: users = self.plugin.data.get("users") if not isinstance(users, dict): users = {} self.plugin.data["users"] = users if not isinstance(users.get(user_id), dict) and self._observation_profile_by_user_id_locked(self.plugin.data, user_id): return self._error("仅观察档案不能通过私聊用户接口删除") canonical_user_id = self.plugin._canonical_private_user_id(user_id) stored_user_id = canonical_user_id if canonical_user_id in users else user_id removed_ids = {user_id, canonical_user_id, stored_user_id} removed_user = users.pop(stored_user_id, None) if isinstance(removed_user, dict): for alias_id in removed_user.get("alias_user_ids") if isinstance(removed_user.get("alias_user_ids"), list) else []: alias_text = str(alias_id or "").strip() if alias_text: removed_ids.add(alias_text) removed_ids = {item for item in removed_ids if item} def keep_expression_scope_ids(raw_values: Any) -> list[str]: kept: list[str] = [] for item in self._normalize_id_list(raw_values or []): canonical_item_getter = getattr(self.plugin, "_expression_private_scope_id", None) canonical_item = canonical_item_getter(item) if callable(canonical_item_getter) else item if item in removed_ids or canonical_item in removed_ids: continue if item not in kept: kept.append(item) return kept old_expression_learning_ids = self._normalize_id_list( getattr(self.plugin, "expression_private_learning_source_ids", []) or [] ) old_expression_application_ids = self._normalize_id_list( getattr(self.plugin, "expression_private_application_user_ids", []) or [] ) expression_learning_ids = keep_expression_scope_ids(old_expression_learning_ids) expression_application_ids = keep_expression_scope_ids(old_expression_application_ids) removed_expression_scope = ( expression_learning_ids != old_expression_learning_ids or expression_application_ids != old_expression_application_ids ) old_target_user_ids = self._normalize_id_list(getattr(self.plugin, "target_user_ids", []) or []) target_user_ids = [item for item in old_target_user_ids if item not in removed_ids] removed_target = len(target_user_ids) != len(old_target_user_ids) private_aliases = { str(alias).strip(): str(target).strip() for alias, target in (getattr(self.plugin, "private_user_aliases", {}) or {}).items() if str(alias).strip() and str(target).strip() and str(alias).strip() not in removed_ids and str(target).strip() not in removed_ids } delivery_aliases = { str(alias).strip(): str(target).strip() for alias, target in (getattr(self.plugin, "private_user_delivery_aliases", {}) or {}).items() if str(alias).strip() and str(target).strip() and str(alias).strip() not in removed_ids and str(target).strip() not in removed_ids } removed_private_aliases = len(private_aliases) != len(getattr(self.plugin, "private_user_aliases", {}) or {}) removed_delivery_aliases = len(delivery_aliases) != len(getattr(self.plugin, "private_user_delivery_aliases", {}) or {}) alias_text = self._format_private_alias_mapping(private_aliases) delivery_alias_text = self._format_private_alias_mapping(delivery_aliases) overrides = { "target_user_ids": target_user_ids, "private_user_aliases": alias_text, "private_user_delivery_aliases": delivery_alias_text, "expression_private_learning_source_ids": expression_learning_ids, "expression_private_application_user_ids": expression_application_ids, } self._apply_config_value("target_user_ids", target_user_ids, overrides) self._apply_config_value("private_user_aliases", alias_text, overrides) self._apply_config_value("private_user_delivery_aliases", delivery_alias_text, overrides) self._apply_config_value("expression_private_learning_source_ids", expression_learning_ids, overrides) self._apply_config_value("expression_private_application_user_ids", expression_application_ids, overrides) voice_refresher = getattr(self.plugin, "_refresh_expression_voice_profile", None) if callable(voice_refresher): voice_refresher() self.plugin._save_data_sync() config_saved = await self._save_config_if_possible() message_parts = [] if removed_user is not None: message_parts.append("已删除私聊用户记录") if removed_target: message_parts.append("已移出主动目标名单") if removed_private_aliases: message_parts.append("已清理身份归并映射") if removed_delivery_aliases: message_parts.append("已清理主动发送映射") if removed_expression_scope: message_parts.append("已清理表达学习范围") message = ",".join(message_parts) if message_parts else "没有找到可删除的私聊用户记录" return self._ok( { "user_id": user_id, "canonical_user_id": canonical_user_id, "removed_ids": sorted(removed_ids), "removed_user": removed_user is not None, "removed_target": removed_target, "removed_private_aliases": removed_private_aliases, "removed_delivery_aliases": removed_delivery_aliases, "removed_expression_scope": removed_expression_scope, "config_saved": config_saved, "message": message, } ) except Exception as exc: logger.error(f"[PrivateCompanionPage] 删除用户失败: {exc}", exc_info=True) return self._error(str(exc)) @staticmethod def _format_private_alias_mapping(mapping: dict[str, str]) -> str: return "\n".join( f"{alias}={target}" for alias, target in sorted( ( (str(alias or "").strip(), str(target or "").strip()) for alias, target in (mapping or {}).items() ), key=lambda item: (item[1], item[0]), ) if alias and target and alias != target ) async def list_groups(self) -> dict[str, Any]: start = time.perf_counter() try: limit = self._query_int("limit", 80, 1, 300) async with self.plugin._data_lock: groups = self.plugin.data.get("groups", {}) if not isinstance(groups, dict): groups = {} visible_groups = [ (group_id, dict(group)) for group_id, group in groups.items() if isinstance(group, dict) and not self._looks_like_member_shadow_group(str(group_id), group) ] shadow_count = len(groups) - len(visible_groups) await self._refresh_group_names_from_platform(visible_groups) items = [ self._group_summary(group_id, self._refresh_group_atmosphere_for_page(group)) for group_id, group in visible_groups ] items.sort(key=lambda item: item.get("last_seen_ts") or 0, reverse=True) elapsed_ms = int((time.perf_counter() - start) * 1000) if elapsed_ms > 1200: logger.warning("[PrivateCompanionPage] 群列表接口耗时较高: elapsed=%sms groups=%s", elapsed_ms, len(items)) return self._ok({"items": items[:limit], "total": len(items), "shadow_total": shadow_count}) except Exception as exc: logger.error(f"[PrivateCompanionPage] 获取群列表失败: {exc}", exc_info=True) return self._error(str(exc)) def _refresh_group_atmosphere_for_page(self, group: dict[str, Any]) -> dict[str, Any]: updater = getattr(self.plugin, "_update_group_atmosphere", None) if callable(updater): try: updater(group) except Exception as exc: logger.info( "[PrivateCompanionPage] 群气氛读取时重算失败: %s", self._single_line(exc, 120), ) return group def _looks_like_member_shadow_group(self, group_id: str, group: dict[str, Any]) -> bool: """Hide historical records created when a sender id was mistaken for a group id.""" gid = str(group_id or group.get("group_id") or "").strip() if not gid or not gid.isdigit(): return False configured = set(self.plugin._configured_group_ids()) | set(self.plugin._configured_group_blacklist_ids()) if gid in configured: return False recent = group.get("recent_messages") if isinstance(group.get("recent_messages"), list) else [] sender_ids = [ str(item.get("sender_id") or "").strip() for item in recent if isinstance(item, dict) and str(item.get("sender_id") or "").strip() ] if not sender_ids: return False members = group.get("members") if isinstance(group.get("members"), dict) else {} same_sender_hits = sum(1 for sender_id in sender_ids if sender_id == gid) unique_senders = {sender_id for sender_id in sender_ids if sender_id} if gid in members and same_sender_hits >= max(1, int(len(sender_ids) * 0.8)) and len(unique_senders) <= 2: return True if not self._single_line(group.get("name") or group.get("group_name"), 80) and same_sender_hits == len(sender_ids) and len(members) <= 2: return True return False def _group_display_name_missing(self, group_id: str, group: dict[str, Any]) -> bool: name = self._single_line(group.get("name") or group.get("group_name") or group.get("display_name"), 80) gid = str(group_id or group.get("group_id") or "").strip() return not name or name == gid or name == f"群 {gid}" or name.isdigit() def _clean_group_display_name(self, value: Any, group_id: str = "") -> str: text = self._single_line(value, 80) gid = str(group_id or "").strip() if not text or text == gid or text == f"群 {gid}" or text.isdigit(): return "" return text def _extract_onebot_list(self, result: Any) -> list[dict[str, Any]]: if isinstance(result, list): return [item for item in result if isinstance(item, dict)] if isinstance(result, dict): data = result.get("data") if isinstance(data, list): return [item for item in data if isinstance(item, dict)] groups = result.get("groups") or result.get("items") or result.get("result") if isinstance(groups, list): return [item for item in groups if isinstance(item, dict)] return [] def _extract_onebot_object(self, result: Any) -> dict[str, Any]: if not isinstance(result, dict): return {} data = result.get("data") if isinstance(data, dict): return data result_obj = result.get("result") if isinstance(result_obj, dict): return result_obj return result def _name_from_group_payload(self, item: dict[str, Any], group_id: str) -> str: return self._clean_group_display_name( item.get("group_name") or item.get("group_remark") or item.get("group_display_name") or item.get("name") or item.get("display_name") or item.get("title"), group_id, ) def _group_names_from_loaded_history(self, target_ids: set[str]) -> dict[str, str]: found: dict[str, str] = {} if not target_ids: return found patterns = { group_id: re.compile(rf"群号\s*{re.escape(group_id)}\(([^)\r\n]{{1,80}})\)") for group_id in target_ids } stack: list[Any] = [getattr(self.plugin, "data", {})] scanned_strings = 0 while stack and len(found) < len(target_ids) and scanned_strings < 20000: value = stack.pop() if isinstance(value, dict): stack.extend(value.values()) continue if isinstance(value, list): stack.extend(value) continue if not isinstance(value, str) or "群号" not in value: continue scanned_strings += 1 for group_id, pattern in patterns.items(): if group_id in found: continue match = pattern.search(value) if not match: continue name = self._clean_group_display_name(match.group(1), group_id) if name: found[group_id] = name return found @staticmethod def _lookup_float(value: Any) -> float: try: return float(value or 0) except Exception: return 0.0 def _page_onebot_call_actions(self) -> list[Any]: candidates: list[Any] = [] finder = getattr(self.plugin, "_qzone_find_runtime_bot", None) if callable(finder): try: bot = finder() if bot is not None: candidates.append(bot) except Exception: pass context = getattr(self.plugin, "context", None) if context is not None: try: platform = context.get_platform("aiocqhttp") except Exception: platform = None if platform is not None: candidates.append(platform) for attr in ("bot", "client", "adapter", "connection", "api"): try: value = getattr(platform, attr, None) except Exception: value = None if value is not None: candidates.append(value) platform_manager = getattr(context, "platform_manager", None) if context is not None else None for attr in ("platform_insts", "platform_instances", "instances", "platforms"): try: value = getattr(platform_manager, attr, None) except Exception: value = None if not value: continue try: iterable = value.values() if isinstance(value, dict) else value candidates.extend(list(iterable or [])) except Exception: pass calls: list[Any] = [] seen: set[int] = set() for candidate in candidates: if candidate is None or id(candidate) in seen: continue seen.add(id(candidate)) api = getattr(candidate, "api", None) call_action = getattr(api, "call_action", None) if not callable(call_action): call_action = getattr(candidate, "call_action", None) if callable(call_action): calls.append(call_action) return calls async def _page_call_onebot_action(self, action: str, **kwargs: Any) -> Any: last_error: Exception | None = None for call_action in self._page_onebot_call_actions(): try: result = call_action(action, **kwargs) return await result if hasattr(result, "__await__") else result except Exception as exc: last_error = exc if last_error is not None: raise last_error raise RuntimeError("没有可用的 OneBot call_action") async def _refresh_group_names_from_platform(self, visible_groups: list[tuple[str, dict[str, Any]]], *, force: bool = False) -> None: now = time.time() display_missing = [ (str(group_id), group) for group_id, group in visible_groups if self._group_display_name_missing(str(group_id), group) ] if not display_missing: return target_ids = {group_id for group_id, _ in display_missing if group_id} found: dict[str, str] = self._group_names_from_loaded_history(target_ids) missing = [ (group_id, group) for group_id, group in display_missing if group_id not in found and (force or now - self._lookup_float(group.get("last_group_name_lookup_at")) > 5 * 60) ] platform_target_ids = {group_id for group_id, _ in missing if group_id} try: if platform_target_ids: raw_groups = await self._page_call_onebot_action("get_group_list") for item in self._extract_onebot_list(raw_groups): group_id = str(item.get("group_id") or item.get("group_uin") or item.get("group_no") or "").strip() if group_id not in platform_target_ids: continue name = self._name_from_group_payload(item, group_id) if name: found[group_id] = name except Exception as exc: logger.info("[PrivateCompanionPage] 群列表名称刷新失败: %s", self._single_line(exc, 120)) if len(found) < len(target_ids) and platform_target_ids: for group_id, _ in missing[:30]: if group_id in found: continue try: raw_item = await self._page_call_onebot_action("get_group_info", group_id=int(group_id) if group_id.isdigit() else group_id) except Exception: continue item = self._extract_onebot_object(raw_item) if not isinstance(item, dict): continue name = self._name_from_group_payload(item, group_id) if name: found[group_id] = name if not found and not missing: return changed = False async with self.plugin._data_lock: groups = self.plugin.data.get("groups") if not isinstance(groups, dict): return for group_id, snapshot in display_missing: group = groups.get(group_id) if not isinstance(group, dict): continue if group_id in platform_target_ids: group["last_group_name_lookup_at"] = now name = found.get(group_id, "") if name: group["name"] = name group["group_name"] = name group["last_group_name_seen_at"] = now snapshot["name"] = name snapshot["group_name"] = name snapshot["last_group_name_seen_at"] = now changed = True if group_id in platform_target_ids: snapshot["last_group_name_lookup_at"] = now if changed: self.plugin._save_data_sync() async def get_group(self) -> dict[str, Any]: group_id = str(request.args.get("group_id", "")).strip() if not group_id: return self._error("缺少 group_id") try: async with self.plugin._data_lock: group = deepcopy((self.plugin.data.get("groups") or {}).get(group_id)) if not isinstance(group, dict): return self._error("群不存在") await self._refresh_group_names_from_platform([(group_id, group)], force=True) self._refresh_group_atmosphere_for_page(group) detail = self._group_summary(group_id, group) safety_getter = getattr(self.plugin, "_group_member_safety_compact_summary", None) member_safety = safety_getter(group) if callable(safety_getter) else {} detail.update( { "members": group.get("members") if isinstance(group.get("members"), dict) else {}, "recent_messages": self._limited_list(group.get("recent_messages"), 30), "topic_threads": self._group_topic_thread_items(group), "group_episodes": self._limited_list(group.get("group_episodes"), 12), "relationship_edges": group.get("relationship_edges") if isinstance(group.get("relationship_edges"), dict) else {}, "interjection_feedback": group.get("interjection_feedback") if isinstance(group.get("interjection_feedback"), dict) else {}, "last_bot_interjection": self._sanitize_last_bot_interjection(group.get("last_bot_interjection")), "group_wakeup_logs": self._group_wakeup_logs(group), "slang_items": self._group_slang_items(group), "member_safety": member_safety, "formatted": { "status": self.plugin._format_group_status(group), "feedback": self.plugin._format_group_interjection_feedback(group), "relationship_graph": self.plugin._format_group_relationship_graph_for_prompt(group), }, } ) return self._ok(detail) except Exception as exc: logger.error(f"[PrivateCompanionPage] 获取群详情失败: {exc}", exc_info=True) return self._error(str(exc)) async def get_group_member_safety(self) -> dict[str, Any]: group_id = str(request.args.get("group_id", "")).strip() if not group_id: return self._error("缺少 group_id") try: async with self.plugin._data_lock: group = deepcopy((self.plugin.data.get("groups") or {}).get(group_id)) if not isinstance(group, dict): return self._error("群不存在") getter = getattr(self.plugin, "_group_member_safety_summary", None) if not callable(getter): return self._error("当前插件版本不支持成员风控") summary = getter(group) summary["group_id"] = group_id summary["group_name"] = self._single_line( group.get("name") or group.get("group_name") or group.get("display_name"), 80 ) return self._ok(summary) except Exception as exc: logger.error(f"[PrivateCompanionPage] 获取成员风控失败: {exc}", exc_info=True) return self._error(str(exc)) async def update_group_member_safety(self) -> dict[str, Any]: payload = await request.get_json(silent=True) or {} group_id = str(payload.get("group_id", "")).strip() user_id = str(payload.get("user_id", "")).strip() action = str(payload.get("action", "")).strip().lower() if not group_id: return self._error("缺少 group_id") if not user_id: return self._error("缺少成员 ID") if action not in {"manual_block", "unblock", "clear_strikes", "exempt", "unexempt"}: return self._error("不支持的成员风控操作") try: async with self.plugin._data_lock: group = self.plugin._get_group(group_id) profiles = group.get("members") if isinstance(group.get("members"), dict) else {} profile = profiles.get(user_id) if isinstance(profiles.get(user_id), dict) else {} name = self._single_line(payload.get("name") or profile.get("name") or profile.get("identity_name"), 60) updater = getattr(self.plugin, "_apply_group_member_safety_action", None) getter = getattr(self.plugin, "_group_member_safety_summary", None) if not callable(updater) or not callable(getter): return self._error("当前插件版本不支持成员风控") item = updater(group, user_id=user_id, action=action, name=name) self.plugin._save_data_sync() summary = getter(group) return self._ok({"item": item, "summary": summary}) except ValueError as exc: return self._error(str(exc)) except Exception as exc: logger.error(f"[PrivateCompanionPage] 更新成员风控失败: {exc}", exc_info=True) return self._error(str(exc)) async def update_group(self) -> dict[str, Any]: payload = await request.get_json(silent=True) or {} group_id = str(payload.get("group_id", "")).strip() if not group_id: return self._error("缺少 group_id") try: async with self.plugin._data_lock: group = self.plugin._get_group(group_id) if "enabled" in payload: group["enabled"] = bool(payload.get("enabled")) if payload.get("reset_interjection"): group["last_interject_at"] = 0 group["interject_day"] = "" group["interject_today"] = 0 group["last_bot_interjection"] = {} group["interjection_feedback"] = {} if payload.get("reset_atmosphere"): current_atmosphere = group.get("atmosphere") if isinstance(group.get("atmosphere"), dict) else {} group["atmosphere"] = {**current_atmosphere, "reset_at": time.time()} updater = getattr(self.plugin, "_update_group_atmosphere", None) if callable(updater): updater(group) else: group["atmosphere"].update( { "pace": "安静", "mood": "平稳", "active_speakers": 0, "recent_count": 0, "updated_at": datetime.now().strftime("%Y-%m-%d %H:%M"), } ) if payload.get("clear_observation"): enabled = bool(group.get("enabled", True)) group.clear() group.update( { "enabled": enabled, "group_id": group_id, "message_count": 0, "last_seen": 0, "last_interject_at": 0, "interject_day": "", "interject_today": 0, "recent_messages": [], "members": {}, "member_safety": {}, "slang_terms": [], "slang_meanings": {}, "topic_signatures": [], "topic_threads": [], "group_episodes": [], "relationship_edges": {}, "interjection_feedback": {}, "last_bot_interjection": {}, "last_speaker": {}, "atmosphere": {}, "last_summary_at": 0, "last_episode_refresh_at": 0, "last_slang_summary_at": 0, } ) voice_refresher = getattr(self.plugin, "_refresh_expression_voice_profile", None) if callable(voice_refresher): voice_refresher() self.plugin._save_data_sync() snapshot = deepcopy(group) return self._ok(self._group_summary(group_id, snapshot)) except Exception as exc: logger.error(f"[PrivateCompanionPage] 更新群失败: {exc}", exc_info=True) return self._error(str(exc)) async def delete_group(self) -> dict[str, Any]: payload = await request.get_json(silent=True) or {} group_id = str(payload.get("group_id", "")).strip() if not group_id: return self._error("缺少 group_id") try: async with self.plugin._data_lock: groups = self.plugin.data.get("groups") if not isinstance(groups, dict): groups = {} self.plugin.data["groups"] = groups removed_group = groups.pop(group_id, None) is not None old_expression_learning_ids = self._normalize_id_list( getattr(self.plugin, "expression_group_learning_source_ids", []) or [] ) old_expression_application_ids = self._normalize_id_list( getattr(self.plugin, "expression_group_application_ids", []) or [] ) expression_learning_ids = [item for item in old_expression_learning_ids if item != group_id] expression_application_ids = [item for item in old_expression_application_ids if item != group_id] removed_expression_scope = ( expression_learning_ids != old_expression_learning_ids or expression_application_ids != old_expression_application_ids ) whitelist = [ str(item).strip() for item in (getattr(self.plugin, "group_whitelist_ids", []) or []) if str(item).strip() and str(item).strip() != group_id ] blacklist = [ str(item).strip() for item in (getattr(self.plugin, "group_blacklist_ids", []) or []) if str(item).strip() and str(item).strip() != group_id ] removed_whitelist = len(whitelist) != len(getattr(self.plugin, "group_whitelist_ids", []) or []) removed_blacklist = len(blacklist) != len(getattr(self.plugin, "group_blacklist_ids", []) or []) self._apply_config_value("group_whitelist_ids", whitelist, {"group_whitelist_ids": whitelist, "group_blacklist_ids": blacklist}) self._apply_config_value("group_blacklist_ids", blacklist, {"group_whitelist_ids": whitelist, "group_blacklist_ids": blacklist}) expression_overrides = { "expression_group_learning_source_ids": expression_learning_ids, "expression_group_application_ids": expression_application_ids, } self._apply_config_value("expression_group_learning_source_ids", expression_learning_ids, expression_overrides) self._apply_config_value("expression_group_application_ids", expression_application_ids, expression_overrides) voice_refresher = getattr(self.plugin, "_refresh_expression_voice_profile", None) if callable(voice_refresher): voice_refresher() self.plugin._save_data_sync() config_saved = await self._save_config_if_possible() message_parts = [] if removed_group: message_parts.append("已删除群聊观测") if removed_whitelist or removed_blacklist: message_parts.append("已移出群聊名单") if removed_expression_scope: message_parts.append("已清理表达学习范围") message = ",".join(message_parts) if message_parts else "没有找到可删除的群聊记录" return self._ok( { "group_id": group_id, "removed_group": removed_group, "removed_whitelist": removed_whitelist, "removed_blacklist": removed_blacklist, "removed_expression_scope": removed_expression_scope, "config_saved": config_saved, "message": message, } ) except Exception as exc: logger.error(f"[PrivateCompanionPage] 删除群失败: {exc}", exc_info=True) return self._error(str(exc)) async def update_group_slang(self) -> dict[str, Any]: payload = await request.get_json(silent=True) or {} group_id = str(payload.get("group_id", "")).strip() term = self._single_line(payload.get("term"), 40) if not group_id: return self._error("缺少 group_id") if not term: return self._error("缺少黑话词") try: async with self.plugin._data_lock: group = self.plugin._get_group(group_id) terms = group.setdefault("slang_terms", []) if not isinstance(terms, list): terms = [] group["slang_terms"] = terms meanings = group.setdefault("slang_meanings", {}) if not isinstance(meanings, dict): meanings = {} group["slang_meanings"] = meanings if payload.get("delete"): group["slang_terms"] = [ item for item in terms if self._single_line(item.get("term") if isinstance(item, dict) else item, 40) != term ] meanings.pop(term, None) else: existing_term = None for item in terms: if isinstance(item, dict) and self._single_line(item.get("term"), 40) == term: existing_term = item break if existing_term is None: existing_term = {"term": term, "count": 0, "last_seen": 0} terms.append(existing_term) previous = meanings.get(term) if isinstance(meanings.get(term), dict) else {} confidence_raw = payload.get("confidence") if "confidence" in payload else previous.get("confidence", 0.85) web_match_raw = payload.get("web_match") if "web_match" in payload else previous.get("web_match", 0.0) confidence = max(0.0, min(1.0, self._float(confidence_raw))) web_match = max(0.0, min(1.0, self._float(web_match_raw))) meanings[term] = { "meaning": self._single_line(payload.get("meaning"), 120), "usage": self._single_line(payload.get("usage"), 120), "type": self._single_line(payload.get("type"), 24), "not_owner": self._single_line(payload.get("not_owner"), 90), "evidence": self._single_line(payload.get("evidence"), 160), "web_evidence": self._single_line(payload.get("web_evidence"), 220), "confidence": f"{confidence:.2f}", "web_match": f"{web_match:.2f}" if web_match > 0 else "", "source": "manual", "updated_at": datetime.now().strftime("%Y-%m-%d %H:%M"), } terms.sort(key=lambda item: (_safe_int(item.get("count"), 0) if isinstance(item, dict) else 0), reverse=True) self.plugin._save_data_sync() snapshot = deepcopy(group) detail = self._group_summary(group_id, snapshot) detail["slang_items"] = self._group_slang_items(snapshot) return self._ok(detail) except Exception as exc: logger.error(f"[PrivateCompanionPage] 更新群黑话失败: {exc}", exc_info=True) return self._error(str(exc))