# -*- coding: utf-8 -*- from __future__ import annotations import asyncio import base64 import hashlib import ipaddress import mimetypes import re import socket import time from pathlib import Path from types import SimpleNamespace from typing import Any from urllib.parse import parse_qs, unquote, urljoin, urlparse from astrbot.api import logger from astrbot.api.event import AstrMessageEvent from .helpers import _now_ts, _safe_float, _safe_int, _single_line from .qzone_recent_parser import parse_qzone_h5_index_html QZONE_IMAGE_UPLOAD_URL = "https://up.qzone.qq.com/cgi-bin/upload/cgi_upload_image" QZONE_PUBLISH_URL = "https://user.qzone.qq.com/proxy/domain/taotao.qzone.qq.com/cgi-bin/emotion_cgi_publish_v6" QZONE_REMOTE_IMAGE_MAX_BYTES = 12 * 1024 * 1024 QZONE_UNSAFE_MEDIA_HOSTS = {"localhost", "localhost.localdomain"} class QzoneIntegrationError(RuntimeError): """User-facing Qzone error with a coarse failure stage.""" def __init__(self, stage: str, message: str): self.stage = stage super().__init__(f"{stage}:{message}") class QzoneMediaMixin: """QZone image reading, upload and publish helpers.""" @staticmethod def _qzone_auth_failure_message(message: Any) -> bool: text = str(message or "").lower() if not text: return False markers = ( "code=-3000", "请先登录", "未登录", "login", "cookie", "p_skey", "pskey", "skey", "g_tk", "gtk", ) return any(marker in text for marker in markers) def _qzone_state_dict(self) -> dict[str, Any]: data = getattr(self, "data", None) if not isinstance(data, dict): return {} state = data.setdefault("qzone_integration", {}) if not isinstance(state, dict): data["qzone_integration"] = {} state = data["qzone_integration"] return state def _qzone_format_block_until(self, ts: float) -> str: try: return time.strftime("%m-%d %H:%M", time.localtime(float(ts))) except Exception: return "" def _qzone_auto_publish_block_reason(self, state: dict[str, Any] | None = None, *, now: float | None = None) -> str: state = state if isinstance(state, dict) else self._qzone_state_dict() if not isinstance(state, dict): return "" current = _now_ts() if now is None else float(now) until = _safe_float(state.get("auth_block_until"), 0) if until <= current: return "" reason = _single_line(state.get("last_auth_failure_reason") or "QQ 空间登录状态异常", 100) if ( ("没有可用的 OneBot 连接" in reason or "未配置手动 QZONE_COOKIE" in reason) and callable(getattr(self, "_qzone_find_runtime_bot", None)) and self._qzone_find_runtime_bot() is not None ): self._qzone_clear_auth_failure(state) return "" if "qzonetoken" in reason.lower() or "qzonetoken 未在 H5 首页中找到" in reason: self._qzone_clear_auth_failure(state) return "" until_text = self._qzone_format_block_until(until) return f"{reason},自动说说已暂停到 {until_text}" if until_text else reason def _qzone_mark_auth_failure( self, reason: str, *, source: str = "", cooldown_hours: float = 12.0, state: dict[str, Any] | None = None, save: bool = True, ) -> None: state = state if isinstance(state, dict) else self._qzone_state_dict() if not isinstance(state, dict): return now = _now_ts() clean_reason = _single_line(reason or "QQ 空间登录状态异常", 160) last_failed_at = _safe_float(state.get("last_auth_failed_at"), 0) previous_count = _safe_int(state.get("auth_failure_count"), 0, 0, 999) if last_failed_at and now - last_failed_at > 7 * 24 * 3600: previous_count = 0 failure_count = previous_count + 1 if failure_count <= 1: effective_hours = max(1.0, float(cooldown_hours or 12.0)) status = "blocked" elif failure_count == 2: effective_hours = 24.0 status = "blocked" else: effective_hours = 24.0 * 7 status = "stopped" cooldown_seconds = effective_hours * 3600.0 state["last_auth_failed_at"] = now state["last_auth_failure_reason"] = clean_reason state["last_auth_failure_source"] = _single_line(source, 40) state["auth_failure_count"] = failure_count state["auth_block_until"] = now + cooldown_seconds state["last_auth_status"] = status if status == "stopped": logger.warning( "[PrivateCompanion] QQ 空间认证连续失败,自动说说进入保守等待: count=%s until=%s reason=%s", failure_count, self._qzone_format_block_until(state["auth_block_until"]), clean_reason, ) if save: saver = getattr(self, "_save_data_sync", None) if callable(saver): try: saver() except Exception: pass def _qzone_clear_auth_failure(self, state: dict[str, Any] | None = None) -> None: state = state if isinstance(state, dict) else self._qzone_state_dict() if not isinstance(state, dict): return changed = False for key in ( "auth_block_until", "last_auth_status", "auth_failure_count", "last_auth_failure_source", "last_auth_failure_reason", ): if key in state: state.pop(key, None) changed = True for key in ("last_life_publish_status", "last_emotional_vent_status"): value = str(state.get(key) or "") if value.startswith("paused:auth:"): state[key] = "ready:auth_ok" changed = True if changed: saver = getattr(self, "_save_data_sync", None) if callable(saver): try: saver() except Exception: pass async def _qzone_preflight_auto_publish( self, event: AstrMessageEvent | None, *, state: dict[str, Any] | None = None, source: str = "auto", ) -> str: state = state if isinstance(state, dict) else self._qzone_state_dict() block_reason = self._qzone_auto_publish_block_reason(state) if block_reason: return block_reason try: cookie_header = await self._qzone_get_cookies(event) ctx = self._qzone_context_from_cookies(cookie_header) token = ctx.get("qzonetoken") or await self._qzone_ensure_qzonetoken(event, cookie_header=cookie_header, ctx=ctx) if not str(token or "").strip(): state["last_qzonetoken_status"] = "missing:h5_index" logger.info("[PrivateCompanion] QQ 空间自动发布预检继续: qzonetoken 未找到,纯文字发布仍可使用 g_tk") else: state["last_qzonetoken_status"] = "ok" except Exception as exc: reason = _single_line(exc, 160) self._qzone_mark_auth_failure(reason, source=source, state=state, save=False) return reason self._qzone_clear_auth_failure(state) return "" async def _qzone_h5_index_snapshot( self, event: AstrMessageEvent | None, *, cookie_header: str, ctx: dict[str, Any], max_cache_age: float = 0.0, ) -> dict[str, Any]: cache = getattr(self, "_qzone_qzonetoken_cache", None) if not isinstance(cache, dict): cache = {} self._qzone_qzonetoken_cache = cache cache_key = str(ctx.get("uin") or "") cached = cache.get(cache_key) if ( max_cache_age > 0 and isinstance(cached, dict) and _now_ts() - _safe_float(cached.get("at"), 0) < max_cache_age and isinstance(cached.get("payload"), dict) ): return { "token": str(cached.get("token") or "").strip(), "payload": dict(cached.get("payload") or {}), "cached": True, "http_status": _safe_int(cached.get("http_status"), 200, 0), } import aiohttp url = "https://h5.qzone.qq.com/mqzone/index" headers = { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36", "Cookie": ctx.get("cookie_header") or cookie_header, "Referer": f"https://user.qzone.qq.com/{ctx['uin']}", "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8", } try: timeout = aiohttp.ClientTimeout(total=12) async with aiohttp.ClientSession(timeout=timeout, headers=headers) as session: async with session.get(url) as response: text = await response.text() if response.status >= 400: logger.info("[PrivateCompanion] QQ 空间 qzonetoken 获取失败: HTTP %s", response.status) return {"token": "", "payload": {}, "cached": False, "http_status": response.status} except Exception as exc: logger.info("[PrivateCompanion] QQ 空间 qzonetoken 获取失败: %s", _single_line(exc, 120)) return {"token": "", "payload": {}, "cached": False, "http_status": 0} parsed = parse_qzone_h5_index_html(text) parsed_token = str(parsed.get("token") or "").strip() token = str( parsed_token or ctx.get("qzonetoken") or (cached.get("token") if isinstance(cached, dict) else "") or "" ).strip() payload = parsed.get("payload") if isinstance(parsed.get("payload"), dict) else {} cache[cache_key] = { "token": token, "payload": payload, "at": _now_ts(), "http_status": response.status, } if not parsed_token: logger.info("[PrivateCompanion] QQ 空间 qzonetoken 未在 H5 首页中找到") else: logger.info("[PrivateCompanion] QQ 空间 qzonetoken 已自动获取: uin=%s", ctx.get("uin")) return { "token": token, "payload": payload, "cached": False, "http_status": response.status, } async def _qzone_ensure_qzonetoken( self, event: AstrMessageEvent | None, *, cookie_header: str, ctx: dict[str, Any], ) -> str: token = str(ctx.get("qzonetoken") or "").strip() if token: return token cache = getattr(self, "_qzone_qzonetoken_cache", None) cached = cache.get(str(ctx.get("uin") or "")) if isinstance(cache, dict) else None if isinstance(cached, dict) and _now_ts() - _safe_float(cached.get("at"), 0) < 1800: token = str(cached.get("token") or "").strip() if token: return token snapshot = await self._qzone_h5_index_snapshot( event, cookie_header=cookie_header, ctx=ctx, max_cache_age=1800, ) return str(snapshot.get("token") or "").strip() @staticmethod def _qzone_find_first(payload: Any, keys: tuple[str, ...], *, _depth: int = 0, _seen: set[int] | None = None) -> Any: if payload is None or _depth > 8: return None if _seen is None: _seen = set() if isinstance(payload, dict): obj_id = id(payload) if obj_id in _seen: return None _seen.add(obj_id) normalized = {str(key).lower().replace("-", "_"): value for key, value in payload.items()} for key in keys: value = normalized.get(str(key).lower().replace("-", "_")) if value not in (None, ""): return value for value in payload.values(): found = QzoneMediaMixin._qzone_find_first(value, keys, _depth=_depth + 1, _seen=_seen) if found not in (None, ""): return found elif isinstance(payload, (list, tuple)): for item in payload: found = QzoneMediaMixin._qzone_find_first(item, keys, _depth=_depth + 1, _seen=_seen) if found not in (None, ""): return found return None async def _qzone_call_platform_action(self, event: AstrMessageEvent | None, action: str, **kwargs: Any) -> Any: if event is None: return None caller = getattr(self, "_call_platform_action", None) if callable(caller): try: return await caller(event, action, **kwargs) except Exception: pass bot = getattr(event, "bot", None) direct = getattr(bot, action, None) if callable(direct): try: maybe = direct(**kwargs) return await maybe if hasattr(maybe, "__await__") else maybe except Exception: pass api = getattr(bot, "api", None) call_action = getattr(api, "call_action", None) if callable(call_action): try: maybe = call_action(action, **kwargs) return await maybe if hasattr(maybe, "__await__") else maybe except Exception: return None return None async def _qzone_resolve_onebot_image_source(self, event: AstrMessageEvent | None, source: str) -> str: text = str(source or "").strip() if not text or event is None: return "" if Path(text).exists() or re.match(r"^(?:https?://|file://|data:|base64://)", text, flags=re.I): return "" attempts = ( ("get_image", {"file": text}), ("get_image", {"file_id": text}), ("get_file", {"file": text}), ("get_file", {"file_id": text}), ) for action, kwargs in attempts: result = await self._qzone_call_platform_action(event, action, **kwargs) if not result: continue for key_group in ( ("path", "file_path", "local_path", "local_file", "file"), ("url", "origin_url", "source_url"), ): found = self._qzone_find_first(result, key_group) candidate = str(found or "").strip() if candidate and candidate != text: return candidate return "" @staticmethod def _qzone_guess_image_type(source: str, image_bytes: bytes, content_type: str = "") -> tuple[str, str]: probe = (content_type or mimetypes.guess_type(str(source or ""))[0] or "").lower() head = image_bytes[:16] if head.startswith(b"\x89PNG\r\n\x1a\n") or "png" in probe: return "png", "image/png" if head.startswith(b"GIF8") or "gif" in probe: return "gif", "image/gif" if (head.startswith(b"RIFF") and b"WEBP" in image_bytes[:32]) or "webp" in probe: return "webp", "image/webp" return "jpg", "image/jpeg" @staticmethod def _qzone_supported_image_header(image_bytes: bytes) -> bool: head = image_bytes[:16] return bool( head.startswith(b"\xff\xd8\xff") or head.startswith(b"\x89PNG\r\n\x1a\n") or head.startswith(b"GIF8") or head.startswith(b"BM") or (head.startswith(b"RIFF") and b"WEBP" in image_bytes[:32]) ) def _qzone_validate_image_bytes(self, image_bytes: bytes, *, filename: str = "") -> None: size = len(image_bytes or b"") if size <= 0: raise QzoneIntegrationError("图片校验失败", "图片内容为空") max_bytes = QZONE_REMOTE_IMAGE_MAX_BYTES if size > max_bytes: raise QzoneIntegrationError("图片校验失败", f"图片过大,超过 {max_bytes // 1024 // 1024}MB") if not self._qzone_supported_image_header(image_bytes): raise QzoneIntegrationError("图片校验失败", f"不是 QQ 空间支持的图片文件:{_single_line(filename, 80) or 'unknown'}") try: from PIL import Image as PILImage import io with PILImage.open(io.BytesIO(image_bytes)) as image: width, height = image.size if min(width, height) < 16: raise QzoneIntegrationError("图片校验失败", f"图片尺寸过小:{width}x{height}") except QzoneIntegrationError: raise except Exception: # PIL may be unavailable in some AstrBot environments; magic header validation still protects the upload. return @staticmethod def _qzone_is_unsafe_media_host(host: str) -> bool: normalized = str(host or "").strip().lower().rstrip(".") if not normalized or normalized in QZONE_UNSAFE_MEDIA_HOSTS or normalized.endswith(".localhost"): return True try: address = ipaddress.ip_address(normalized.strip("[]")) except ValueError: return False return bool( address.is_private or address.is_loopback or address.is_link_local or address.is_multicast or address.is_reserved or address.is_unspecified ) @classmethod def _qzone_remote_media_url_allowed(cls, source: str) -> bool: parsed = urlparse(str(source or "").strip()) if parsed.scheme.lower() not in {"http", "https"} or not parsed.netloc: return False host = parsed.hostname if not host or cls._qzone_is_unsafe_media_host(host): return False try: ipaddress.ip_address(host.strip("[]")) return True except ValueError: pass try: infos = socket.getaddrinfo(host.rstrip("."), None, type=socket.SOCK_STREAM) except OSError: return False addresses = {item[4][0] for item in infos if item and item[4]} return bool(addresses) and not any(cls._qzone_is_unsafe_media_host(address) for address in addresses) @classmethod def _qzone_safe_redirect_url(cls, current_url: str, location: str) -> str: if not location: return "" target = urljoin(current_url, location) return target if cls._qzone_remote_media_url_allowed(target) else "" async def _qzone_load_image_bytes( self, event: AstrMessageEvent | None, source: Any, *, cookie_header: str, ) -> tuple[bytes, str, str]: import aiohttp if isinstance(source, bytes): return source, "image.jpg", "image/jpeg" text = str(source or "").strip().strip('"') if not text: raise QzoneIntegrationError("图片读取失败", "图片路径为空") if text.startswith("data:") and "," in text: meta, encoded = text.split(",", 1) content_type = meta[5:].split(";", 1)[0] or "image/jpeg" estimated_size = (len(encoded) * 3) // 4 if estimated_size > QZONE_REMOTE_IMAGE_MAX_BYTES + 3: raise QzoneIntegrationError("图片校验失败", "图片过大,已跳过上传") try: return base64.b64decode(encoded), f"image.{content_type.rsplit('/', 1)[-1]}", content_type except Exception as exc: raise QzoneIntegrationError("图片读取失败", f"图片 data URL 解析失败:{_single_line(exc, 80)}") from exc if text.startswith("file://"): text = unquote(urlparse(text).path or "") if re.match(r"^/[A-Za-z]:/", text): text = text[1:] path = Path(text) if path.exists() and path.is_file(): data = path.read_bytes() image_type, content_type = self._qzone_guess_image_type(str(path), data) return data, path.name or f"image.{image_type}", content_type if re.match(r"^https?://", text, flags=re.I): if not self._qzone_remote_media_url_allowed(text): raise QzoneIntegrationError("图片读取失败", "图片 URL 指向本机、内网或不可安全解析的地址") timeout = aiohttp.ClientTimeout(total=30) headers = { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36", "Accept": "image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8", "Referer": f"https://user.qzone.qq.com/{self._qzone_context_from_cookies(cookie_header)['uin']}", } async with aiohttp.ClientSession(timeout=timeout, headers=headers) as session: current_url = text for _redirect in range(4): async with session.get(current_url, allow_redirects=False) as response: if response.status in {301, 302, 303, 307, 308}: location = response.headers.get("Location") or response.headers.get("location") or "" redirected = self._qzone_safe_redirect_url(current_url, location) if not redirected: raise QzoneIntegrationError("图片读取失败", "图片重定向目标不安全,已拒绝下载") current_url = redirected continue if response.status >= 400: raise QzoneIntegrationError("图片读取失败", f"图片下载失败 HTTP {response.status}") content_type = str(response.headers.get("Content-Type") or "").split(";", 1)[0].strip().lower() length = _safe_int(response.headers.get("Content-Length"), 0, 0) if length and length > QZONE_REMOTE_IMAGE_MAX_BYTES: raise QzoneIntegrationError("图片校验失败", "图片过大,已跳过上传") data = await response.read() if len(data) > QZONE_REMOTE_IMAGE_MAX_BYTES: raise QzoneIntegrationError("图片校验失败", "图片过大,已跳过上传") image_type, guessed_type = self._qzone_guess_image_type(current_url, data, content_type) name = Path(urlparse(current_url).path).name or f"image.{image_type}" return data, name, content_type or guessed_type raise QzoneIntegrationError("图片读取失败", "图片重定向次数过多,已停止下载") resolved = await self._qzone_resolve_onebot_image_source(event, text) if resolved and resolved != text: return await self._qzone_load_image_bytes(event, resolved, cookie_header=cookie_header) raise QzoneIntegrationError("图片读取失败", f"无法读取图片:{_single_line(text, 120)}") @staticmethod def _qzone_extract_pic_bo(value: Any) -> str: text = str(value or "").strip() if not text: return "" parsed = urlparse(text) query = parse_qs(parsed.query) for key in ("bo", "pic_bo", "picbo"): values = query.get(key) if values and values[0]: return str(values[0]).strip() match = re.search(r"(?:^|[?&])(?:bo|pic_bo|picbo)=([^&\s]+)", text) return match.group(1).strip() if match else "" @staticmethod def _qzone_build_richval(upload_payload: dict[str, Any]) -> str: albumid = str(QzoneMediaMixin._qzone_find_first(upload_payload, ("albumid", "album_id")) or "").strip() lloc = str(QzoneMediaMixin._qzone_find_first(upload_payload, ("lloc",)) or "").strip() sloc = str(QzoneMediaMixin._qzone_find_first(upload_payload, ("sloc",)) or "").strip() image_type = str(QzoneMediaMixin._qzone_find_first(upload_payload, ("type", "phototype", "image_type")) or "").strip() or "1" height = str(QzoneMediaMixin._qzone_find_first(upload_payload, ("height", "h")) or "").strip() or "0" width = str(QzoneMediaMixin._qzone_find_first(upload_payload, ("width", "w")) or "").strip() or "0" if albumid and lloc and sloc: return ",".join(["", albumid, lloc, sloc, image_type, height, width, "", height, width]) return "" async def _qzone_upload_image( self, event: AstrMessageEvent | None, source: Any, *, cookie_header: str, ctx: dict[str, Any], ) -> dict[str, str]: image_bytes, filename, content_type = await self._qzone_load_image_bytes(event, source, cookie_header=cookie_header) return await self._qzone_upload_image_bytes( event, image_bytes, filename=filename, content_type=content_type, source=source, cookie_header=cookie_header, ctx=ctx, ) async def _qzone_upload_image_bytes( self, event: AstrMessageEvent | None, image_bytes: bytes, *, filename: str, content_type: str, source: Any, cookie_header: str, ctx: dict[str, Any], ) -> dict[str, str]: if not image_bytes: raise QzoneIntegrationError("图片读取失败", "图片内容为空") self._qzone_validate_image_bytes(image_bytes, filename=filename) image_type, _ = self._qzone_guess_image_type(filename, image_bytes, content_type) encoded = base64.b64encode(image_bytes).decode("ascii") referrer = f"https://user.qzone.qq.com/{ctx['uin']}" payload = await self._qzone_request( event, "POST", QZONE_IMAGE_UPLOAD_URL, params={"g_tk": ctx["gtk"]}, data={ "filename": filename, "uin": ctx["uin"], "skey": ctx.get("skey") or ctx.get("p_skey") or "", "p_skey": ctx.get("p_skey") or ctx.get("skey") or "", "zzpaneluin": ctx["uin"], "p_uin": ctx["uin"], "qzonetoken": ctx.get("qzonetoken") or "", "zzpanelkey": "", "uploadtype": "1", "albumtype": "7", "exttype": "0", "refer": "shuoshuo", "output_type": "json", "charset": "utf-8", "output_charset": "utf-8", "upload_hd": "1", "hd_width": "2048", "hd_height": "10000", "hd_quality": "96", "backUrls": "http://upbak.photo.qzone.qq.com/cgi-bin/upload/cgi_upload_image,http://119.147.64.75/cgi-bin/upload/cgi_upload_image", "url": f"{QZONE_IMAGE_UPLOAD_URL}?g_tk={ctx['gtk']}", "base64": "1", "picfile": encoded, "qzreferrer": referrer, }, headers={ "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8", "Accept": "application/json, text/javascript, */*; q=0.01", "Origin": "https://user.qzone.qq.com", "Referer": referrer, "X-Requested-With": "XMLHttpRequest", }, timeout_seconds=60.0, cookie_header=cookie_header, ) code = payload.get("code", payload.get("ret", payload.get("_raw_code", 0))) if code not in {0, "0", None, ""}: raise QzoneIntegrationError("图片上传失败", _single_line(payload.get("message") or payload.get("msg") or payload.get("_raw_message") or f"code={code}", 160)) richval = self._qzone_build_richval(payload) pic_bo = str(self._qzone_find_first(payload, ("pic_bo", "picbo", "bo")) or "").strip() if not pic_bo: pic_bo = self._qzone_extract_pic_bo(self._qzone_find_first(payload, ("url", "origin_url", "pre", "raw_url"))) if not richval: raise QzoneIntegrationError("图片上传失败", "图片上传成功但未返回 richval 所需字段") if not pic_bo: raise QzoneIntegrationError("图片上传失败", "图片上传成功但未返回 pic_bo") return { "source": _single_line(source, 160), "filename": filename, "type": image_type, "richval": richval, "pic_bo": pic_bo, } async def _qzone_image_sources_from_event(self, event: AstrMessageEvent | None) -> list[str]: if event is None: return [] sources: list[str] = [] def add(value: Any) -> None: text = str(value or "").strip() if text and text not in sources: sources.append(text) extractor = getattr(self, "_extract_image_sources_from_message_obj", None) message_obj = getattr(event, "message_obj", None) if callable(extractor): try: for source in extractor(message_obj): add(source) except Exception: pass try: for source in extractor(getattr(message_obj, "message", None) if message_obj is not None else None): add(source) except Exception: pass components_getter = getattr(self, "_event_components", None) components: list[Any] = [] if callable(components_getter): try: components = list(components_getter(event) or []) except Exception: components = [] image_component_count = 0 image_source_getter = getattr(self, "_image_component_source", None) for comp in components: class_name = comp.__class__.__name__.lower() if isinstance(comp, dict): class_name = str(comp.get("type") or "").lower() if class_name != "image": continue image_component_count += 1 if callable(image_source_getter): try: add(image_source_getter(comp)) except Exception: pass converter = getattr(comp, "convert_to_file_path", None) if callable(converter): try: maybe = converter() add(await maybe if hasattr(maybe, "__await__") else maybe) except Exception: pass data = getattr(comp, "data", None) if not isinstance(data, dict) and isinstance(comp, dict): data = comp.get("data") if isinstance(comp.get("data"), dict) else {} for key in ("url", "origin_url", "source_url", "src", "path", "file", "image_path", "file_path", "local_path"): if isinstance(data, dict): add(data.get(key)) if isinstance(comp, dict): add(comp.get(key)) else: add(getattr(comp, key, None)) reply_image_getter = getattr(self, "_find_reply_image_sources_for_event", None) if callable(reply_image_getter): try: for source in await reply_image_getter(event): add(source) except Exception as exc: logger.info("[PrivateCompanion] QQ 空间引用图片读取失败: %s", _single_line(exc, 120)) normalized: list[str] = [] for source in sources: resolved = await self._qzone_resolve_onebot_image_source(event, source) candidate = resolved or source if candidate and candidate not in normalized: normalized.append(candidate) if image_component_count <= 1 and len(normalized) > 1: def rank(source: str) -> tuple[int, int]: text = str(source or "").strip() path_text = text[len("file://"):] if text.startswith("file://") else text path = Path(path_text) if path.exists() and path.is_file(): suffix_score = 3 if path.suffix.lower() in {".jpg", ".jpeg", ".png", ".webp", ".gif"} else 2 return (suffix_score, len(str(path))) if re.match(r"^https?://", text, flags=re.I): return (1, len(text)) return (0, len(text)) best = sorted(normalized, key=rank, reverse=True)[0] logger.info("[PrivateCompanion] QQ 空间单图消息解析到多个来源,已选择一个: candidates=%s chosen=%s", len(normalized), _single_line(best, 120)) return [best] return normalized[:9] @staticmethod def _qzone_select_image_sources(command_text: str, image_sources: list[str]) -> tuple[list[str], str]: sources = [str(item).strip() for item in list(image_sources or []) if str(item or "").strip()] if len(sources) <= 1: return sources, "" text = _single_line(command_text, 120) if re.search(r"(全部|所有|都发|全发|多图|这几张|这些图)", text): return sources[:9], "" cn_digits = {"一": 1, "二": 2, "两": 2, "三": 3, "四": 4, "五": 5, "六": 6, "七": 7, "八": 8, "九": 9} match = re.search(r"(?:第)?([1-9]\d*)\s*张", text) if not match: match = re.search(r"第([一二两三四五六七八九])张", text) if match: raw = match.group(1) index = int(raw) if raw.isdigit() else cn_digits.get(raw, 0) if 1 <= index <= len(sources): return [sources[index - 1]], "" return [], f"检测到 {len(sources)} 张图片,但你指定的第 {index} 张不存在。" return [], ( f"检测到 {len(sources)} 张图片。为避免误发公开说说,请补充:" f"“陪伴 发说说 全部 <正文>” 或 “陪伴 发说说 第1张 <正文>”。" ) @staticmethod def _qzone_clean_publish_text(command_text: str) -> str: text = _single_line(command_text, 300) text = re.sub(r"^(?:全部|所有|都发|全发|多图|这几张|这些图)\s*", "", text) text = re.sub(r"^(?:第)?[1-9]\d*\s*张\s*", "", text) text = re.sub(r"^第[一二两三四五六七八九]张\s*", "", text) return _single_line(text, 300) async def _qzone_publish_post( self, event: AstrMessageEvent | None = None, *, text: str = "", images: list[str] | None = None, ) -> Any: cookie_header = await self._qzone_get_cookies(event) ctx = self._qzone_context_from_cookies(cookie_header) ctx["qzonetoken"] = ctx.get("qzonetoken") or await self._qzone_ensure_qzonetoken(event, cookie_header=cookie_header, ctx=ctx) content = _single_line(text, 300) if not content and not images: raise RuntimeError("说说内容为空") publish_content = content or (" " if images else "") referrer = f"https://user.qzone.qq.com/{ctx['uin']}" prepared_images: list[dict[str, Any]] = [] seen_hashes: set[str] = set() for image in list(images or [])[:12]: image_bytes, filename, content_type = await self._qzone_load_image_bytes(event, image, cookie_header=cookie_header) self._qzone_validate_image_bytes(image_bytes, filename=filename) digest = hashlib.sha256(image_bytes).hexdigest() if digest in seen_hashes: continue seen_hashes.add(digest) prepared_images.append( { "source": image, "bytes": image_bytes, "filename": filename, "content_type": content_type, "sha256": digest, } ) if len(prepared_images) >= 9: break uploaded_images: list[dict[str, str]] = [] seen_pic_bos: set[str] = set() for image in prepared_images: uploaded = await self._qzone_upload_image_bytes( event, image["bytes"], filename=str(image.get("filename") or "image.jpg"), content_type=str(image.get("content_type") or "image/jpeg"), source=image.get("source"), cookie_header=cookie_header, ctx=ctx, ) pic_bo = str(uploaded.get("pic_bo") or "") if pic_bo and pic_bo in seen_pic_bos: continue if pic_bo: seen_pic_bos.add(pic_bo) uploaded_images.append(uploaded) pic_bos = [item.get("pic_bo", "") for item in uploaded_images if item.get("pic_bo")] richvals = [item.get("richval", "") for item in uploaded_images if item.get("richval")] base_data = { "syn_tweet_verson": "1", "paramstr": "1", "who": "1", "con": publish_content, "feedversion": "1", "ver": "1", "ugc_right": 1, "to_sign": 0, "hostuin": ctx["uin"], "code_version": "1", "issyncweibo": 0, "format": "json", "qzreferrer": referrer, } if uploaded_images: base_data.update( { "richtype": "1", "subrichtype": "1", "richval": "\t".join(richvals), "pic_bo": ",".join(pic_bos), "pic_template": "", } ) headers = { "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8", "Referer": referrer, "Accept": "application/json, text/javascript, */*; q=0.01", "X-Requested-With": "XMLHttpRequest", } endpoint = QZONE_PUBLISH_URL payload: dict[str, Any] = {} data = dict(base_data) payload = await self._qzone_request( event, "POST", endpoint, params={"g_tk": ctx["gtk"]}, data=data, headers=headers, cookie_header=cookie_header, ) code = payload.get("code", 0) if code not in {0, "0"}: message = _single_line(payload.get("message") or payload.get("msg") or f"code={code}", 160) if str(code) not in message: message = _single_line(f"code={code} {message}", 160) logger.info( "[PrivateCompanion] QQ 空间发布失败: endpoint=%s code=%s msg=%s", urlparse(endpoint).netloc, code, message, ) stage = "Cookie/g_tk" if self._qzone_auth_failure_message(message) else "发布失败" raise QzoneIntegrationError(stage, message) logger.info( "[PrivateCompanion] QQ 空间说说发布成功: endpoint=%s images=%s", urlparse(endpoint).netloc, len(richvals), ) return SimpleNamespace( tid=str(payload.get("tid") or ""), uin=int(ctx["uin"]), name=str(ctx["uin"]), text=content, images=uploaded_images or (images or []), create_time=payload.get("now") or int(time.time()), status="approved", ) async def _qzone_verify_published_post( self, event: AstrMessageEvent | None, post: Any, *, expected_text: str, expected_images: int, ) -> dict[str, Any]: tid = str(getattr(post, "tid", "") or "") expected_clean = _single_line(expected_text, 80) last_error = "" for attempt, delay in enumerate((0.0, 0.8, 1.8), start=1): if delay > 0: await asyncio.sleep(delay) try: feeds = await self._qzone_query_feeds(event, target_id=str(getattr(post, "uin", "") or ""), pos=0, num=5, with_detail=False) except Exception as exc: last_error = _single_line(exc, 120) if attempt >= 3: return {"verified": False, "message": f"反查失败:{last_error}"} continue for feed in feeds: feed_tid = str(getattr(feed, "tid", "") or "") feed_text = _single_line(getattr(feed, "text", "") or getattr(feed, "rt_con", ""), 120) feed_images = len(list(getattr(feed, "images", []) or [])) tid_match = bool(tid and feed_tid and tid == feed_tid) text_match = bool(expected_clean and expected_clean in feed_text) image_match = expected_images <= 0 or feed_images >= expected_images if tid_match or (image_match and (text_match or not expected_clean)): return { "verified": True, "message": f"已反查到最近说说,图片 {feed_images} 张", "tid": feed_tid or tid, "images": feed_images, } if last_error: return {"verified": False, "message": f"反查失败:{last_error}"} return {"verified": False, "message": "发布接口已返回成功,但最近说说中暂未反查到匹配内容"} async def _publish_qzone_text( self, text: str, event: AstrMessageEvent | None = None, images: list[str] | None = None, auto_generate_image: bool = False, publish_reason: str = "manual_publish", ) -> dict[str, Any]: availability = getattr(self, "_qzone_available", None) if callable(availability) and not availability(event): supported = getattr(self, "_qzone_platform_supported", None) if callable(supported) and not supported(event): message_getter = getattr(self, "_qzone_platform_unavailable_message", None) message = message_getter() if callable(message_getter) else "当前平台不支持 QQ 空间" return {"success": False, "message": message} return {"success": False, "message": "QQ 空间动态层未启用"} if not callable(availability) and not self.enable_qzone_integration: return {"success": False, "message": "QQ 空间动态层未启用"} content = _single_line(text, 300) image_list = [str(item).strip() for item in list(images or []) if str(item or "").strip()] if auto_generate_image and content and not image_list: image_generator = getattr(self, "_maybe_generate_qzone_publish_image", None) if callable(image_generator): try: generated = await image_generator( post_text=content, reason="manual_publish", state=self._qzone_state_dict(), force=True, ) image_list = [str(item).strip() for item in list(generated or []) if str(item or "").strip()] except Exception as exc: logger.info( "[PrivateCompanion] QQ 空间手动发说说自动配图失败,继续纯文字发布: %s", _single_line(exc, 160), ) if not content and not image_list: return {"success": False, "message": "说说内容为空"} async def publish_once(candidates: list[str]) -> dict[str, Any]: post = await self._qzone_publish_post(event, text=content, images=candidates) self._qzone_clear_auth_failure() post_images = list(getattr(post, "images", []) or []) verification = await self._qzone_verify_published_post( event, post, expected_text=content, expected_images=len(post_images), ) verified_images = _safe_int(verification.get("images"), len(post_images), 0, 99) result = { "success": True, "text": _single_line(getattr(post, "text", content), 300) or content, "tid": str(getattr(post, "tid", "") or ""), "uin": str(getattr(post, "uin", "") or ""), "images": post_images, "image_count": max(len(post_images), verified_images if bool(verification.get("verified")) else 0), "verified": bool(verification.get("verified")), "verify_message": verification.get("message") or "", } recorder = getattr(self, "_qzone_record_published_post", None) if callable(recorder): try: await recorder( result.get("text") or content, reason=publish_reason, tid=result.get("tid", ""), image_count=_safe_int(result.get("image_count"), 0, 0, 99), verified=bool(result.get("verified")), event=event, ) except Exception as record_exc: logger.debug("[PrivateCompanion] QQ 空间发布后自我记录失败: %s", _single_line(record_exc, 120)) return result try: return await publish_once(image_list) except Exception as exc: message = _single_line(exc, 180) if isinstance(exc, QzoneIntegrationError): if exc.stage == "Cookie/g_tk" or self._qzone_auth_failure_message(message): self._qzone_mark_auth_failure(message, source="publish", save=True) if content and image_list and exc.stage in {"图片读取失败", "图片校验失败", "图片上传失败"}: logger.warning( "[PrivateCompanion] QQ 空间图片发布失败,尝试降级纯文字: stage=%s msg=%s", exc.stage, message, ) try: fallback = await publish_once([]) fallback["image_fallback"] = True fallback["image_fallback_stage"] = exc.stage fallback["image_fallback_message"] = message fallback["image_count"] = 0 fallback["images"] = [] return fallback except Exception as retry_exc: retry_message = _single_line(retry_exc, 180) if isinstance(retry_exc, QzoneIntegrationError) and ( retry_exc.stage == "Cookie/g_tk" or self._qzone_auth_failure_message(retry_message) ): self._qzone_mark_auth_failure(retry_message, source="publish", save=True) return { "success": False, "stage": exc.stage, "message": f"{message};降级纯文字也失败:{retry_message}", "image_fallback_failed": True, } return {"success": False, "stage": exc.stage, "message": message} lowered = message.lower() if "cookie" in lowered or "p_skey" in lowered or "skey" in lowered or "g_tk" in lowered or "登录" in message: self._qzone_mark_auth_failure(message, source="publish", save=True) return {"success": False, "stage": "Cookie/g_tk", "message": f"Cookie/g_tk:{message}"} if "权限" in message or "403" in message: return {"success": False, "stage": "权限失败", "message": f"权限失败:{message}"} return {"success": False, "stage": "发布失败", "message": f"发布失败:{message}"}