"""AstrBot ImageStudio plugin entrypoint helpers. The plugin is mounted inside AstrBot. This module exposes pure metadata and dispatch helpers for the runtime layer without starting a standalone server. """ from __future__ import annotations import asyncio import base64 import binascii import inspect import importlib import json import sys from uuid import uuid4 from pathlib import Path from typing import Any, Callable, Mapping PLUGIN_ROOT = Path(__file__).resolve().parent if str(PLUGIN_ROOT) not in sys.path: # AstrBot may import the plugin entrypoint without adding the plugin root. sys.path.insert(0, str(PLUGIN_ROOT)) from adapters.astrbot_adapter import ( dispatch_extension_request, normalize_extension_path, register_astrbot_runtime, runtime_health, runtime_registration_manifest, runtime_route_table, ) from adapters.astrbot_command_adapter import ( accepted_text, access_denied_text, command_allowed, command_context_from_event, help_text, message_text_from_event, ) from adapters.astrbot_card_renderer import render_help_card, render_profile_card, render_status_card from adapters.astrbot_command_parser import parse_single_image_command, single_image_usage from adapters.astrbot_media_adapter import image_references_from_event from backend.dto.chat_command_dto import ChatCommandParseError from backend.services.chat_workflow_service import ChatWorkflowService from backend.services.chat_session_service import ChatSessionStore from adapters.webui_adapter import get_web_mount_manifest from backend.route_registry import ROUTES from backend.services.model_provider_bootstrap import ( sync_generation_provider_from_config, sync_vision_provider_from_config, ) from backend.services.model_provider_service import ModelProviderService from backend.services.ui_service import API_BASE from core.identity import RequestContext from core.media_proxy import MediaProxy from database import db_helper as _database_db_helper from database.repositories.model_provider_repository import ModelProviderRepository from database.seed import seed_default_material_categories try: if not hasattr(_database_db_helper, "set_runtime_config_overrides"): _database_db_helper = importlib.reload(_database_db_helper) except Exception: pass Database = _database_db_helper.Database DatabaseSettings = _database_db_helper.DatabaseSettings load_database_settings = _database_db_helper.load_database_settings PLUGIN_NAME = "astrbot_plugin_imagestudio" PLUGIN_DESC = "AstrBot ImageStudio role asset production and image-generation workspace." PLUGIN_VERSION = "3.1.0" BRIDGE_PERMISSIONS = frozenset( {"can_write", "can_manage_config", "can_manage_materials", "can_retry_tasks"} ) _MISSING = object() try: from astrbot.api.star import Star as AstrBotStar from astrbot.api.star import register as astrbot_star_register from astrbot.api.event import AstrMessageEvent, filter as astrbot_filter from astrbot.api.event import MessageChain as AstrBotMessageChain from astrbot.api.message_components import Image as AstrBotImage from astrbot.api.message_components import Plain as AstrBotPlain except Exception: # pragma: no cover - AstrBot is only present in runtime. class AstrBotStar: # type: ignore[no-redef] def __init__(self, context: Any | None = None, *args: Any, **kwargs: Any) -> None: self.context = context def astrbot_star_register(*args: Any, **kwargs: Any) -> Any: def decorator(cls: type[Any]) -> type[Any]: return cls return decorator AstrMessageEvent = Any # type: ignore[misc,assignment] AstrBotImage = None # type: ignore[assignment] AstrBotPlain = None # type: ignore[assignment] AstrBotMessageChain = None # type: ignore[assignment] class _FallbackCommandGroup: def __call__(self, function: Callable[..., Any]) -> Callable[..., Any]: setattr(function, "command", self.command) return function def command(self, *args: Any, **kwargs: Any) -> Callable[[Callable[..., Any]], Callable[..., Any]]: return lambda function: function class _FallbackFilter: class EventMessageType: ALL = "all" @staticmethod def command_group(*args: Any, **kwargs: Any) -> _FallbackCommandGroup: return _FallbackCommandGroup() @staticmethod def event_message_type(*args: Any, **kwargs: Any) -> Callable[[Callable[..., Any]], Callable[..., Any]]: return lambda function: function astrbot_filter = _FallbackFilter() def get_plugin_manifest() -> dict[str, Any]: web_manifest = get_web_mount_manifest() runtime = runtime_registration_manifest() return { "plugin_name": PLUGIN_NAME, "api_base": API_BASE, "contract_url": f"{API_BASE}/contract", "web": web_manifest, "routes": runtime_route_table(), "runtime": runtime, "health": runtime["health"], } def register_plugin(runtime: Any) -> dict[str, Any]: result = register_astrbot_runtime(runtime, runtime_registration_manifest()) result["bridge_api"] = register_bridge_api(runtime) return result def get_runtime_health() -> dict[str, Any]: return runtime_health() def initialize_runtime_database(settings: DatabaseSettings | None = None) -> dict[str, Any]: database = Database(settings or load_database_settings()) database.initialize() seed = seed_default_material_categories(database) model_provider_service = ModelProviderService(ModelProviderRepository(database)) config_payload = _database_db_helper.load_config_payload() generation_provider = sync_generation_provider_from_config(model_provider_service, config_payload) vision_provider = sync_vision_provider_from_config(model_provider_service, config_payload) return { "initialized": True, "backend": database.backend, "seed": {"material_categories": seed}, "generation_provider": generation_provider, "vision_provider": vision_provider, } def apply_astrbot_config_overrides(config: Any | None) -> dict[str, Any]: mapping = _mapping_from_runtime_config(config) patch = _runtime_config_patch_from_mapping(mapping) _set_runtime_config_overrides(patch) return {"applied": bool(patch), "keys": _flatten_config_keys(patch)} def dispatch_web_request( ctx: RequestContext, method: str, path: str, *, query: dict[str, Any] | None = None, payload: dict[str, Any] | None = None, ) -> dict[str, Any]: return dispatch_extension_request(ctx, method, path, query=query, payload=payload) def register_bridge_api(runtime: Any) -> dict[str, Any]: """Register AstrBot Plugin Page bridge endpoints under /api/plug/{plugin}.""" registrar = getattr(runtime, "register_web_api", None) if not callable(registrar): return {"registered": False, "routes_registered": 0, "missing_capabilities": ["register_web_api"]} registered = 0 errors: list[dict[str, Any]] = [] for route in _bridge_registration_routes(): handler = _make_bridge_handler(endpoint=route["endpoint"], method=route["method"]) try: if _call_web_api_registrar(registrar, route["path"], handler, route["method"]): registered += 1 except Exception as exc: # pragma: no cover - depends on AstrBot runtime version. errors.append( { "method": route["method"], "path": route["path"], "message": str(exc), "exception": exc.__class__.__name__, } ) return { "registered": registered > 0, "routes_registered": registered, "missing_capabilities": [], "errors": errors, } async def dispatch_bridge_request( endpoint: str, *, method: str = "GET", request: Any | None = None, query: dict[str, Any] | None = None, payload: dict[str, Any] | None = None, ) -> Any: ctx = _request_context_from_astrbot_request(request) request_method = _request_method(request, fallback=method) request_payload = payload if payload is not None else await _request_payload(request) dispatch_method, dispatch_payload = _unwrap_method_override(request_method, request_payload) dispatch_endpoint = _bridge_endpoint(endpoint, request) dispatch_query = query if query is not None else _request_query(request) if dispatch_method == "GET" and normalize_extension_path(dispatch_endpoint) == "media/fetch": file_response = await _to_media_file_response(dispatch_query) if file_response is not None: return file_response response = await asyncio.to_thread( dispatch_web_request, ctx, dispatch_method, dispatch_endpoint, query=dispatch_query, payload=dispatch_payload, ) media_response = _to_media_http_response(dispatch_endpoint, response) if media_response is not None: return media_response return _to_bridge_response(response) def _register_star_class(cls: type[Any]) -> type[Any]: try: return astrbot_star_register(PLUGIN_NAME, "YokiiroBW", PLUGIN_DESC, PLUGIN_VERSION)(cls) except Exception: return cls @_register_star_class class Main(AstrBotStar): """Minimal AstrBot plugin class for runtime discovery.""" def __init__(self, context: Any | None = None, *args: Any, **kwargs: Any) -> None: runtime_config = _runtime_config_argument(args, kwargs) try: super().__init__(context, *args, **kwargs) except TypeError: try: super().__init__(*args, **kwargs) except TypeError: super().__init__() self.context = context self.astrbot_config = runtime_config if runtime_config is not None else _attr(self, "config") self.registration_result: dict[str, Any] | None = None self.database_result: dict[str, Any] | None = None self.runtime_config_result: dict[str, Any] | None = None self.chat_workflow_service = ChatWorkflowService(dispatch_web_request) self.chat_sessions = ChatSessionStore(ttl_seconds=600, max_sessions=1000) self.chat_background_tasks: set[asyncio.Task[Any]] = set() async def initialize(self) -> None: self.runtime_config_result = apply_astrbot_config_overrides(self.astrbot_config) if self.context is not None: self.registration_result = register_plugin(self.context) if self.registration_result.get("bridge_api", {}).get("registered"): self.database_result = initialize_runtime_database() return None async def terminate(self) -> None: for task in list(self.chat_background_tasks): task.cancel() if self.chat_background_tasks: await asyncio.gather(*self.chat_background_tasks, return_exceptions=True) return None @astrbot_filter.command_group("影棚") def imagestudio_command(self) -> None: """ImageStudio chat command group.""" return None @imagestudio_command.command("帮助") async def imagestudio_help(self, event: AstrMessageEvent): yield self._card_result(event, self._help_card, help_text()) @imagestudio_command.command("状态") async def imagestudio_status(self, event: AstrMessageEvent): health = get_runtime_health() state = "正常" if health.get("healthy") is not False else "异常" database = "已初始化" if self.database_result else "等待初始化" text = f"🛰 ImageStudio 状态:{state}\n版本:{PLUGIN_VERSION}\nAPI:{API_BASE}\n数据库:{database}" yield self._card_result(event, lambda: render_status_card(state=state, version=PLUGIN_VERSION, database=database, api=API_BASE), text) @imagestudio_command.command("快速角色") async def imagestudio_quick_profile(self, event: AstrMessageEvent, description: str = ""): context = command_context_from_event(event) config = _database_db_helper.load_config_payload() if not command_allowed(config, "quick_profile", context): self._record_chat_denied(context, "quick_profile") yield event.plain_result(access_denied_text("快速角色", context)) return try: draft = await asyncio.to_thread(self.chat_workflow_service.create_quick_profile_draft, description, context) except Exception as exc: yield event.plain_result(f"❌ 快速角色草稿创建失败:{exc}") return self.chat_sessions.put(self._session_key(context), "confirm_quick_profile", {"draft": draft}) preview = draft.get("profile_preview", {}) text = ( f"🧩 快速角色草稿\n\n名称:{preview.get('name')}\n基础:{preview.get('base_prompt') or '—'}\n" f"外观:{preview.get('appearance_prompt') or '—'}\n风格:{preview.get('style_prompt') or '—'}\n\n" "发送 /yp 确认 保存,或 /yp 放弃 取消。" ) yield self._card_result( event, lambda: render_profile_card( name=str(preview.get("name") or ""), base=str(preview.get("base_prompt") or ""), appearance=str(preview.get("appearance_prompt") or ""), style=str(preview.get("style_prompt") or ""), ), text, ) @imagestudio_command.command("工作流") async def imagestudio_workflow(self, event: AstrMessageEvent, profile: str = ""): context = command_context_from_event(event) config = _database_db_helper.load_config_payload() if not command_allowed(config, "character_workflow", context): self._record_chat_denied(context, "character_workflow") yield event.plain_result(access_denied_text("角色工作流", context)) return try: detail = await asyncio.to_thread(self.chat_workflow_service.create_or_resume_character_workflow, profile, context) except Exception as exc: yield event.plain_result(f"❌ 工作流创建失败:{exc}") return yield event.plain_result(self._format_workflow(detail)) @imagestudio_command.command("确认") async def imagestudio_confirm(self, event: AstrMessageEvent): context = command_context_from_event(event) session = self.chat_sessions.pop(self._session_key(context)) if session is None: yield event.plain_result("当前没有等待确认的 ImageStudio 操作。") return if session.action == "confirm_quick_profile": try: result = await asyncio.to_thread(self.chat_workflow_service.save_quick_profile_draft, session.payload["draft"], context) nodes = result.get("nodes", []) if nodes: self.chat_sessions.put(self._session_key(context), "quick_profile_ready", {"node_id": nodes[0]["node_id"]}) yield event.plain_result(f"✅ 快速角色已保存\n角色:{result['profile']['name']}\nID:{result['profile']['profile_id']}\n工作流:{result.get('workflow', {}).get('workflow_id', '—')}") except Exception as exc: yield event.plain_result(f"❌ 保存失败:{exc}") return if session.action == "confirm_materials": confirmed = [] try: for material_id in session.payload["material_ids"]: confirmed.append(await asyncio.to_thread(self.chat_workflow_service.confirm_material, material_id, context)) yield event.plain_result("✅ 素材已确认:" + "、".join(item["material_id"] for item in confirmed)) except Exception as exc: yield event.plain_result(f"❌ 素材确认失败:{exc}") return if session.action == "confirm_material": try: result = await asyncio.to_thread(self.chat_workflow_service.confirm_material, session.payload["material_id"], context) yield event.plain_result(f"✅ 素材已确认:{result['material_id']}") except Exception as exc: yield event.plain_result(f"❌ 素材确认失败:{exc}") return yield event.plain_result("该会话暂不支持确认。") @imagestudio_command.command("放弃") async def imagestudio_discard(self, event: AstrMessageEvent): session = self.chat_sessions.pop(self._session_key(command_context_from_event(event))) yield event.plain_result("已取消当前操作。" if session else "当前没有待取消的操作。") @imagestudio_command.command("修改") async def imagestudio_modify_draft(self, event: AstrMessageEvent, addition: str = ""): context = command_context_from_event(event) session = self.chat_sessions.get(self._session_key(context)) if session is None or session.action != "confirm_quick_profile": yield event.plain_result("当前没有等待修改的快速角色草稿。") return preview = session.payload["draft"].get("profile_preview", {}) description = f"{preview.get('name', '')} {preview.get('base_prompt', '')} {addition}".strip() try: draft = await asyncio.to_thread(self.chat_workflow_service.create_quick_profile_draft, description, context) self.chat_sessions.put(self._session_key(context), "confirm_quick_profile", {"draft": draft}) updated = draft.get("profile_preview", {}) yield event.plain_result(f"📝 草稿已更新\n名称:{updated.get('name')}\n设定:{updated.get('base_prompt')}\n发送 /yp 确认 保存。") except Exception as exc: yield event.plain_result(f"❌ 修改失败:{exc}") @imagestudio_command.command("节点") async def imagestudio_nodes(self, event: AstrMessageEvent, workflow_id: str = ""): try: detail = await asyncio.to_thread(self.chat_workflow_service.workflow_detail, workflow_id.strip(), command_context_from_event(event)) yield event.plain_result(self._format_workflow(detail)) except Exception as exc: yield event.plain_result(f"❌ 节点查询失败:{exc}") @imagestudio_command.command("生成") async def imagestudio_generate_node(self, event: AstrMessageEvent, node_id: str = ""): context = command_context_from_event(event) try: result = await asyncio.to_thread(self.chat_workflow_service.generate_node, node_id.strip(), context) images = result.get("images", []) if images: self.chat_sessions.put(self._session_key(context), "select_image", {"node_id": node_id.strip(), "image_ids": [item["image_id"] for item in images]}) yield self._generation_result(event, f"✅ 节点生成完成\n节点:{node_id}\n任务:{result.get('task_id') or result.get('request_id') or '—'}\n回复数字选图,或使用 /yp 选择 <序号>。", images) except Exception as exc: yield event.plain_result(f"❌ 节点生成失败:{exc}") @imagestudio_command.command("重试节点") async def imagestudio_retry_node(self, event: AstrMessageEvent, node_id: str = ""): try: result = await asyncio.to_thread(self.chat_workflow_service.retry_node, node_id.strip(), command_context_from_event(event)) yield event.plain_result(f"✅ 节点已重试:{result.get('task_id') or node_id}") except Exception as exc: yield event.plain_result(f"❌ 节点重试失败:{exc}") @imagestudio_command.command("完成节点") async def imagestudio_complete_node(self, event: AstrMessageEvent, node_id: str = ""): try: result = await asyncio.to_thread(self.chat_workflow_service.complete_node, node_id.strip(), command_context_from_event(event)) yield event.plain_result(f"✅ 节点已完成:{result.get('node_id', node_id)}") except Exception as exc: yield event.plain_result(f"❌ 完成节点失败:{exc}") @imagestudio_command.command("下一步") async def imagestudio_next_step(self, event: AstrMessageEvent, workflow_id: str = ""): try: result = await asyncio.to_thread(self.chat_workflow_service.next_workflow_step, workflow_id.strip(), command_context_from_event(event)) if result.get("completed"): yield event.plain_result(f"✅ 工作流已没有待执行节点:{workflow_id}") else: yield event.plain_result(f"✅ 已执行下一节点\n节点:{result['node']['node_id']}\n任务:{result['generation'].get('task_id') or '—'}") except Exception as exc: yield event.plain_result(f"❌ 下一步执行失败:{exc}") @imagestudio_command.command("选图") async def imagestudio_select_image(self, event: AstrMessageEvent, node_id: str = "", image_id: str = ""): try: if image_id.strip().isdigit(): result = await asyncio.to_thread(self.chat_workflow_service.select_node_image_by_number, node_id.strip(), int(image_id), command_context_from_event(event)) else: result = await asyncio.to_thread(self.chat_workflow_service.select_node_image, node_id.strip(), image_id.strip(), command_context_from_event(event)) yield event.plain_result(f"✅ 已选择图片:{result.get('image_id', image_id)}") except Exception as exc: yield event.plain_result(f"❌ 选图失败:{exc}") @imagestudio_command.command("候选图") async def imagestudio_candidate_images(self, event: AstrMessageEvent, node_id: str = ""): context = command_context_from_event(event) try: images = await asyncio.to_thread(self.chat_workflow_service.list_node_images, node_id.strip(), context) except Exception as exc: yield event.plain_result(f"❌ 候选图读取失败:{exc}") return if not images: yield event.plain_result("当前节点没有候选图。") return self.chat_sessions.put( self._session_key(context), "select_image", {"node_id": node_id.strip(), "image_ids": [item["image_id"] for item in images]}, ) yield self._generation_result(event, "回复 /yp 选择 1 采用第一张候选图。", images) @imagestudio_command.command("选择") async def imagestudio_choose_candidate(self, event: AstrMessageEvent, number: str = ""): context = command_context_from_event(event) session = self.chat_sessions.get(self._session_key(context)) if session is None or session.action != "select_image": yield event.plain_result("当前没有等待选择的候选图。") return try: index = int(number) - 1 image_id = session.payload["image_ids"][index] result = await asyncio.to_thread( self.chat_workflow_service.select_node_image, session.payload["node_id"], image_id, context, ) self.chat_sessions.pop(self._session_key(context)) yield event.plain_result(f"✅ 已采用第 {index + 1} 张:{result.get('image_id', image_id)}\n可继续使用 /yp 下一步、/yp 重试节点 或 /yp 审核。") except (ValueError, IndexError): yield event.plain_result(f"请输入 1 到 {len(session.payload['image_ids'])} 之间的序号。") except Exception as exc: yield event.plain_result(f"❌ 选图失败:{exc}") @imagestudio_command.command("审核") async def imagestudio_review(self, event: AstrMessageEvent, target_id: str = ""): try: result = await asyncio.to_thread(self.chat_workflow_service.review, target_id.strip(), command_context_from_event(event)) yield event.plain_result("🔎 审核结果\n" + json.dumps(result, ensure_ascii=False, indent=2)[:3000]) except Exception as exc: yield event.plain_result(f"❌ 审核失败:{exc}") @imagestudio_command.command("高清") async def imagestudio_hires(self, event: AstrMessageEvent, image_id: str = "", size: str = "2K"): normalized_size = {"1K": "1920x1080", "2K": "2560x1440", "4K": "3840x2160"}.get(size.upper()) if not image_id.strip() or normalized_size is None: yield event.plain_result("用法:/yp 高清 2K|4K") return try: result = await asyncio.to_thread(self.chat_workflow_service.hires_fix, image_id.strip(), normalized_size, command_context_from_event(event)) yield self._generation_result(event, f"✅ 高清修复完成\n原图:{image_id}\n尺寸:{normalized_size}", result.get("images", [])) except Exception as exc: yield event.plain_result(f"❌ 高清修复失败:{exc}") @imagestudio_command.command("素材导入") async def imagestudio_import_material(self, event: AstrMessageEvent, category: str = ""): references = image_references_from_event(event) if not category.strip() or not references: yield event.plain_result("用法:发送图片并附带 /yp 素材导入 <现有分类名称或ID>") return context = command_context_from_event(event) try: results = [await asyncio.to_thread(self.chat_workflow_service.import_material, reference, category.strip(), context) for reference in references] except Exception as exc: yield event.plain_result(f"❌ 素材导入或识别失败:{exc}") return material = results[0]["material"] material_ids = [item["material"]["material_id"] for item in results] profile_names = [item.get("name") for item in results[0].get("profiles", []) if item.get("name")] self.chat_sessions.put(self._session_key(context), "confirm_materials", {"material_ids": material_ids}) yield event.plain_result( f"🧵 已识别 {len(results)} 个素材\nID:{'、'.join(material_ids)}\n分类:{results[0]['category']['name']}\n" f"提示词:{material.get('prompt') or '—'}\n标签:{'、'.join(material.get('tags') or [])}\n\n" f"可用角色:{'、'.join(profile_names[:10]) or '暂无'}\n\n发送 /yp 确认 保存素材,或 /yp 放弃 取消。" ) @imagestudio_command.command("重新识别") async def imagestudio_re_recognize_material(self, event: AstrMessageEvent, material_id: str = ""): try: result = await asyncio.to_thread(self.chat_workflow_service.re_recognize_material, material_id.strip(), command_context_from_event(event)) yield event.plain_result(f"✅ 素材已重新识别\nID:{result['material_id']}\n提示词:{result.get('prompt') or '—'}") except Exception as exc: yield event.plain_result(f"❌ 重新识别失败:{exc}") @imagestudio_command.command("加入衣橱") async def imagestudio_add_wardrobe(self, event: AstrMessageEvent, material_id: str = "", profile: str = "", category: str = "top"): try: result = await asyncio.to_thread(self.chat_workflow_service.add_material_to_wardrobe, material_id.strip(), profile.strip(), category.strip(), command_context_from_event(event)) yield event.plain_result(f"✅ 素材已加入角色衣橱:{result.get('wardrobe_item_id') or material_id}") except Exception as exc: yield event.plain_result(f"❌ 加入衣橱失败:{exc}") @imagestudio_command.command("单图") async def imagestudio_single_image(self, event: AstrMessageEvent, prompt: str = ""): context = command_context_from_event(event) config = _database_db_helper.load_config_payload() if not command_allowed(config, "single_image", context): self._record_chat_denied(context, "single_image") yield event.plain_result(access_denied_text("单图生成", context)) return try: command = parse_single_image_command(prompt) except ChatCommandParseError as exc: yield event.plain_result(single_image_usage(str(exc))) return request_id = f"chatreq_{uuid4().hex}" task = asyncio.create_task(self._run_single_image_background(command, context, request_id)) self.chat_background_tasks.add(task) task.add_done_callback(self.chat_background_tasks.discard) yield event.plain_result( "✅ 单图请求已进入后台执行\n\n" f"请求:{request_id}\n尺寸:{command.size}\n数量:{command.count}\n" f"模型:{command.model_route or 'quick_generation'}\n\n生成完成后会自动发送到当前会话。" ) @imagestudio_command.command("任务") async def imagestudio_jobs(self, event: AstrMessageEvent, task_id: str = ""): context = command_context_from_event(event) try: result = await asyncio.to_thread(self.chat_workflow_service.list_jobs, context, task_id=task_id.strip() or None) except Exception as exc: yield event.plain_result(f"❌ 任务查询失败:{exc}") return yield event.plain_result(self._format_jobs(result)) @imagestudio_command.command("取消") async def imagestudio_cancel_job(self, event: AstrMessageEvent, task_id: str = ""): if not task_id.strip(): yield event.plain_result("请提供任务 ID,例如:/yp 取消 task_xxx") return try: result = await asyncio.to_thread(self.chat_workflow_service.cancel_job, command_context_from_event(event), task_id.strip()) yield event.plain_result(f"✅ 任务已取消:{result.get('task_id', task_id)}") except Exception as exc: yield event.plain_result(f"❌ 取消失败:{exc}") @imagestudio_command.command("重试") async def imagestudio_retry_job(self, event: AstrMessageEvent, task_id: str = ""): if not task_id.strip(): yield event.plain_result("请提供任务 ID,例如:/yp 重试 task_xxx") return try: result = await asyncio.to_thread(self.chat_workflow_service.retry_job, command_context_from_event(event), task_id.strip()) yield event.plain_result(f"✅ 已创建重试任务:{result.get('task_id', task_id)}") except Exception as exc: yield event.plain_result(f"❌ 重试失败:{exc}") async def _chat_command_result(self, event: AstrMessageEvent, action: str, label: str, argument: str): context = command_context_from_event(event) config = _database_db_helper.load_config_payload() if not command_allowed(config, action, context): yield event.plain_result(access_denied_text(label, context)) return yield event.plain_result(accepted_text(label, argument, context)) @astrbot_filter.event_message_type(astrbot_filter.EventMessageType.ALL) async def imagestudio_session_reply(self, event: AstrMessageEvent): text = message_text_from_event(event) if not text or text.startswith(("/", "!", "!")): return context = command_context_from_event(event) session = self.chat_sessions.get(self._session_key(context)) if session is None: return normalized = text.strip().lower() if normalized in {"取消", "退出", "放弃", "cancel"}: self.chat_sessions.pop(self._session_key(context)) yield event.plain_result("已取消当前 ImageStudio 会话。") return if normalized in {"确认", "保存", "confirm"}: async for result in self.imagestudio_confirm(event): yield result return if session.action == "select_image" and normalized.isdigit(): async for result in self.imagestudio_choose_candidate(event, normalized): yield result return if session.action == "quick_profile_ready" and normalized in {"生成", "开始", "generate"}: self.chat_sessions.pop(self._session_key(context)) async for result in self.imagestudio_generate_node(event, session.payload["node_id"]): yield result @astrbot_filter.command_group("yp") def imagestudio_short_command(self) -> None: """Short alias for the ImageStudio command group.""" return None @imagestudio_short_command.command("帮助") async def imagestudio_short_help(self, event: AstrMessageEvent): async for result in self.imagestudio_help(event): yield result @imagestudio_short_command.command("状态") async def imagestudio_short_status(self, event: AstrMessageEvent): async for result in self.imagestudio_status(event): yield result @imagestudio_short_command.command("快速角色") async def imagestudio_short_quick_profile(self, event: AstrMessageEvent, description: str = ""): async for result in self.imagestudio_quick_profile(event, description): yield result @imagestudio_short_command.command("工作流") async def imagestudio_short_workflow(self, event: AstrMessageEvent, profile: str = ""): async for result in self.imagestudio_workflow(event, profile): yield result @imagestudio_short_command.command("单图") async def imagestudio_short_single_image(self, event: AstrMessageEvent, prompt: str = ""): async for result in self.imagestudio_single_image(event, prompt): yield result @imagestudio_short_command.command("任务") async def imagestudio_short_jobs(self, event: AstrMessageEvent, task_id: str = ""): async for result in self.imagestudio_jobs(event, task_id): yield result @imagestudio_short_command.command("取消") async def imagestudio_short_cancel_job(self, event: AstrMessageEvent, task_id: str = ""): async for result in self.imagestudio_cancel_job(event, task_id): yield result @imagestudio_short_command.command("重试") async def imagestudio_short_retry_job(self, event: AstrMessageEvent, task_id: str = ""): async for result in self.imagestudio_retry_job(event, task_id): yield result @imagestudio_short_command.command("确认") async def imagestudio_short_confirm(self, event: AstrMessageEvent): async for result in self.imagestudio_confirm(event): yield result @imagestudio_short_command.command("放弃") async def imagestudio_short_discard(self, event: AstrMessageEvent): async for result in self.imagestudio_discard(event): yield result @imagestudio_short_command.command("修改") async def imagestudio_short_modify_draft(self, event: AstrMessageEvent, addition: str = ""): async for result in self.imagestudio_modify_draft(event, addition): yield result @imagestudio_short_command.command("节点") async def imagestudio_short_nodes(self, event: AstrMessageEvent, workflow_id: str = ""): async for result in self.imagestudio_nodes(event, workflow_id): yield result @imagestudio_short_command.command("生成") async def imagestudio_short_generate_node(self, event: AstrMessageEvent, node_id: str = ""): async for result in self.imagestudio_generate_node(event, node_id): yield result @imagestudio_short_command.command("重试节点") async def imagestudio_short_retry_node(self, event: AstrMessageEvent, node_id: str = ""): async for result in self.imagestudio_retry_node(event, node_id): yield result @imagestudio_short_command.command("完成节点") async def imagestudio_short_complete_node(self, event: AstrMessageEvent, node_id: str = ""): async for result in self.imagestudio_complete_node(event, node_id): yield result @imagestudio_short_command.command("下一步") async def imagestudio_short_next_step(self, event: AstrMessageEvent, workflow_id: str = ""): async for result in self.imagestudio_next_step(event, workflow_id): yield result @imagestudio_short_command.command("选图") async def imagestudio_short_select_image(self, event: AstrMessageEvent, node_id: str = "", image_id: str = ""): async for result in self.imagestudio_select_image(event, node_id, image_id): yield result @imagestudio_short_command.command("审核") async def imagestudio_short_review(self, event: AstrMessageEvent, target_id: str = ""): async for result in self.imagestudio_review(event, target_id): yield result @imagestudio_short_command.command("高清") async def imagestudio_short_hires(self, event: AstrMessageEvent, image_id: str = "", size: str = "2K"): async for result in self.imagestudio_hires(event, image_id, size): yield result @imagestudio_short_command.command("素材导入") async def imagestudio_short_import_material(self, event: AstrMessageEvent, category: str = ""): async for result in self.imagestudio_import_material(event, category): yield result @imagestudio_short_command.command("重新识别") async def imagestudio_short_re_recognize_material(self, event: AstrMessageEvent, material_id: str = ""): async for result in self.imagestudio_re_recognize_material(event, material_id): yield result @imagestudio_short_command.command("加入衣橱") async def imagestudio_short_add_wardrobe(self, event: AstrMessageEvent, material_id: str = "", profile: str = "", category: str = "top"): async for result in self.imagestudio_add_wardrobe(event, material_id, profile, category): yield result @imagestudio_short_command.command("候选图") async def imagestudio_short_candidate_images(self, event: AstrMessageEvent, node_id: str = ""): async for result in self.imagestudio_candidate_images(event, node_id): yield result @imagestudio_short_command.command("选择") async def imagestudio_short_choose_candidate(self, event: AstrMessageEvent, number: str = ""): async for result in self.imagestudio_choose_candidate(event, number): yield result @staticmethod def _format_jobs(result: Any) -> str: if isinstance(result, dict) and "task_id" in result: request = result.get("request") if isinstance(result.get("request"), dict) else {} return ( f"📋 任务 {result['task_id']}\n状态:{result.get('status', 'unknown')}\n" f"进度:{result.get('progress', 0)}%\n模型:{result.get('model_route') or '—'}\n" f"尺寸:{request.get('size') or '—'}\n数量:{request.get('count') or '—'}\n" f"节点:{result.get('node_id') or '—'}\n创建:{result.get('created_at') or '—'}" ) items = result.get("items", []) if isinstance(result, dict) else result if isinstance(result, list) else [] if not items: return "当前没有任务。" lines = ["📋 最近任务"] for item in items[:10]: request = item.get("request") if isinstance(item.get("request"), dict) else {} lines.append(f"• {item.get('task_id')} · {item.get('status')} · {item.get('progress', 0)}% · {request.get('size') or '默认尺寸'} · {item.get('model_route') or '默认模型'}") return "\n".join(lines) @staticmethod def _session_key(context: Any) -> str: return f"{context.platform}:{context.message_origin}:{context.user_id}" @staticmethod def _format_workflow(detail: dict[str, Any]) -> str: workflow = detail.get("workflow", detail) nodes = detail.get("nodes", []) lines = [f"📋 {detail.get('profile', {}).get('name', '角色')} 工作流", f"ID:{workflow.get('workflow_id')}", f"状态:{workflow.get('status')}"] for node in nodes: marker = "▶" if node.get("node_id") == workflow.get("current_node_id") else "✅" if node.get("status") == "completed" else "○" lines.append(f"{marker} {node.get('display_name') or node.get('node_key')} · {node.get('status')}") return "\n".join(lines) def _help_card(self) -> Path: return render_help_card([ "/影棚 帮助 /yp 帮助", "/影棚 状态 /yp 状态", "/影棚 快速角色 <角色描述>", "/影棚 工作流 <角色名或 ID>", "/影棚 单图 <提示词>", ]) def _card_result(self, event: AstrMessageEvent, renderer: Callable[[], Path], fallback: str): if AstrBotImage is not None and hasattr(event, "chain_result"): try: return event.chain_result([AstrBotImage.fromFileSystem(str(renderer()))]) except Exception: pass return event.plain_result(fallback) def _generation_result(self, event: AstrMessageEvent, text: str, images: list[dict[str, Any]]): if AstrBotImage is not None and AstrBotPlain is not None and hasattr(event, "chain_result"): try: chain: list[Any] = [AstrBotPlain(text)] for index, item in enumerate(images, 1): url = item.get("image_url") or item.get("thumbnail_url") if url: chain.extend([AstrBotPlain(f"\n候选图 {index}\n"), AstrBotImage.fromURL(str(url))]) if len(chain) > 1: return event.chain_result(chain) except Exception: pass suffix = "".join( f"\n候选图 {index}:{item.get('image_url') or item.get('image_id')}" for index, item in enumerate(images, 1) ) return event.plain_result(text + suffix) async def _run_single_image_background(self, command: Any, context: Any, request_id: str) -> None: try: result = await asyncio.to_thread(self.chat_workflow_service.submit_single_image, command, context) generation = result["generation"] text = ( f"✅ 单图生成完成\n请求:{request_id}\n任务:{generation.get('task_id') or '—'}\n" f"工作流:{result['workflow']['workflow_id']}\n节点:{result['node']['node_id']}" ) await self._send_proactive(context.message_origin, text, result.get("images", [])) except asyncio.CancelledError: raise except Exception as exc: await self._send_proactive(context.message_origin, f"❌ 单图生成失败\n请求:{request_id}\n错误:{exc}", []) async def _send_proactive(self, message_origin: str, text: str, images: list[dict[str, Any]]) -> None: sender = getattr(self.context, "send_message", None) if not callable(sender) or not message_origin: return try: components: list[Any] = [] if AstrBotPlain is not None: components.append(AstrBotPlain(text)) for index, item in enumerate(images, 1): url = item.get("image_url") or item.get("thumbnail_url") if url and AstrBotImage is not None: if AstrBotPlain is not None: components.append(AstrBotPlain(f"\n候选图 {index}\n")) components.append(AstrBotImage.fromURL(str(url))) message = AstrBotMessageChain(components) if AstrBotMessageChain is not None else components result = sender(message_origin, message) if inspect.isawaitable(result): await result except Exception: return def _record_chat_denied(self, context: Any, action: str) -> None: try: self.chat_workflow_service.guard.record(context, action, allowed=False, details={"reason": "allowlist"}) except Exception: return def get_plugin_manifest(self) -> dict[str, Any]: return get_plugin_manifest() def register_plugin(self, runtime: Any) -> dict[str, Any]: return register_plugin(runtime) def _bridge_registration_routes() -> list[dict[str, str]]: path = f"/{PLUGIN_NAME}/" return [ {"method": method, "path": path, "endpoint": ""} for method in sorted({route.method for route in ROUTES}) ] def _mapping_from_runtime_config(config: Any | None) -> dict[str, Any]: if config is None: return {} mapping = _mapping_from_any(config) if mapping: return mapping for method_name in ("to_dict", "dict", "model_dump"): method = getattr(config, method_name, None) if not callable(method): continue try: mapping = _mapping_from_any(method()) except Exception: mapping = {} if mapping: return mapping for attr_name in ("config", "data", "_config", "_data"): mapping = _mapping_from_any(_attr(config, attr_name)) if mapping: return mapping known_keys = ( "default_generation_model", "generation_provider_id", "generation_provider_base_url", "generation_provider_image_endpoint", "generation_provider_model", "generation_provider_route", "generation_provider_api_key_env_var", "generation_provider_timeout_seconds", "vision_provider_id", "vision_provider_base_url", "vision_provider_endpoint", "vision_provider_model", "vision_provider_route", "vision_provider_api_key_env_var", "vision_provider_timeout_seconds", "vision_provider_enabled", "model_material_recognition", "model_profile_parse", "model_persona_split", "model_prompt_planning", "model_cross_review_primary", "model_cross_review_secondary", "model_quick_generation", "model_portrait_generation", "model_halfbody_generation", "model_fullbody_generation", "model_sheet_generation", "model_hires_fix", "chat_group_allowlist", "chat_user_allowlist", "chat_user_concurrency_limit", "chat_group_concurrency_limit", "chat_daily_user_generation_limit", "chat_daily_group_generation_limit", "chat_allow_2k", "chat_allow_4k", "enable_private_companion_integration", "database_backend", "sqlite_path", "postgresql_enabled", "postgresql_dsn", "postgresql_host", "postgresql_port", "postgresql_database", "postgresql_user", "postgresql_password", ) getter = getattr(config, "get", None) if not callable(getter): return {} values: dict[str, Any] = {} for key in known_keys: try: value = getter(key, _MISSING) except TypeError: try: value = getter(key) except Exception: value = _MISSING except Exception: value = _MISSING if value is not _MISSING: values[key] = value return values def _set_runtime_config_overrides(patch: Mapping[str, Any]) -> None: setter = getattr(_database_db_helper, "set_runtime_config_overrides", None) if callable(setter): setter(patch) def _runtime_config_argument(args: tuple[Any, ...], kwargs: Mapping[str, Any]) -> Any | None: if "config" in kwargs and kwargs["config"] is not None: return kwargs["config"] if "plugin_config" in kwargs and kwargs["plugin_config"] is not None: return kwargs["plugin_config"] return args[0] if args else None def _runtime_config_patch_from_mapping(mapping: Mapping[str, Any]) -> dict[str, Any]: patch: dict[str, Any] = {} if not mapping: return patch database = _mapping_from_any(mapping.get("database")) sqlite = _mapping_from_any(database.get("sqlite")) if database else {} postgresql = _mapping_from_any(database.get("postgresql")) if database else {} features = _mapping_from_any(mapping.get("features")) plugin = _mapping_from_any(mapping.get("plugin")) vision = _mapping_from_any(mapping.get("vision")) vision_provider_config = _mapping_from_any(vision.get("provider")) if vision else {} display_name = _runtime_text(_runtime_value(mapping, "display_name", fallback=plugin.get("display_name", _MISSING))) if display_name: _set_nested(patch, ("plugin", "display_name"), display_name) default_model = _runtime_text(_runtime_value(mapping, "default_generation_model")) if default_model: _set_nested(patch, ("generation", "default_model"), default_model) generation_provider_fields = { "provider_id": "generation_provider_id", "base_url": "generation_provider_base_url", "image_endpoint": "generation_provider_image_endpoint", "model_id": "generation_provider_model", "route_name": "generation_provider_route", "api_key_env_var": "generation_provider_api_key_env_var", } generation_provider: dict[str, Any] = {} for target_key, source_key in generation_provider_fields.items(): value = _runtime_text(_runtime_value(mapping, source_key)) if value: generation_provider[target_key] = value timeout = _runtime_text(_runtime_value(mapping, "generation_provider_timeout_seconds")) if timeout: try: generation_provider["timeout_seconds"] = int(timeout) except ValueError: generation_provider["timeout_seconds"] = timeout if generation_provider: _set_nested(patch, ("generation", "provider"), generation_provider) vision_route = _runtime_text( _runtime_value( mapping, "vision_provider_route", fallback=vision_provider_config.get("route_name", vision.get("default_route", _MISSING)), ) ) if vision_route: _set_nested(patch, ("vision", "default_route"), vision_route) vision_provider_fields = { "provider_id": "vision_provider_id", "base_url": "vision_provider_base_url", "vision_endpoint": "vision_provider_endpoint", "model_id": "vision_provider_model", "route_name": "vision_provider_route", "api_key_env_var": "vision_provider_api_key_env_var", } vision_provider: dict[str, Any] = {} for target_key, source_key in vision_provider_fields.items(): value = _runtime_text( _runtime_value(mapping, source_key, fallback=vision_provider_config.get(target_key, _MISSING)) ) if value: vision_provider[target_key] = value vision_timeout = _runtime_text( _runtime_value( mapping, "vision_provider_timeout_seconds", fallback=vision_provider_config.get("timeout_seconds", _MISSING), ) ) if vision_timeout: try: vision_provider["timeout_seconds"] = int(vision_timeout) except ValueError: vision_provider["timeout_seconds"] = vision_timeout vision_enabled = _runtime_value( mapping, "vision_provider_enabled", fallback=vision_provider_config.get("enabled", _MISSING), ) if vision_enabled is not _MISSING: vision_provider["enabled"] = _runtime_bool(vision_enabled) if vision_provider: _set_nested(patch, ("vision", "provider"), vision_provider) assignment_fields = { "material_recognition": "model_material_recognition", "profile_parse": "model_profile_parse", "persona_split": "model_persona_split", "prompt_planning": "model_prompt_planning", "cross_review_primary": "model_cross_review_primary", "cross_review_secondary": "model_cross_review_secondary", "quick_generation": "model_quick_generation", "portrait_generation": "model_portrait_generation", "halfbody_generation": "model_halfbody_generation", "fullbody_generation": "model_fullbody_generation", "sheet_generation": "model_sheet_generation", "hires_fix": "model_hires_fix", } for target_key, source_key in assignment_fields.items(): value = _runtime_text(_runtime_value(mapping, source_key)) if value: _set_nested(patch, ("model_assignments", target_key), value) for target_key, source_key in { "group_allowlist": "chat_group_allowlist", "user_allowlist": "chat_user_allowlist", }.items(): value = _runtime_value(mapping, source_key) if isinstance(value, (list, tuple, set, frozenset)): _set_nested(patch, ("chat_access", target_key), [str(item).strip() for item in value if str(item).strip()]) for target_key, source_key in { "user_concurrency_limit": "chat_user_concurrency_limit", "group_concurrency_limit": "chat_group_concurrency_limit", "daily_user_generation_limit": "chat_daily_user_generation_limit", "daily_group_generation_limit": "chat_daily_group_generation_limit", "allow_2k": "chat_allow_2k", "allow_4k": "chat_allow_4k", }.items(): value = _runtime_value(mapping, source_key) if value is not None: _set_nested(patch, ("chat_access", target_key), value) private_companion = _runtime_value( mapping, "enable_private_companion_integration", fallback=features.get("private_companion_integration", _MISSING), ) if private_companion is not _MISSING: _set_nested(patch, ("features", "private_companion_integration"), _runtime_bool(private_companion)) backend = _runtime_text(_runtime_value(mapping, "database_backend", fallback=database.get("backend", _MISSING))).lower() if backend: _set_nested(patch, ("database", "backend"), backend) sqlite_path = _runtime_text(_runtime_value(mapping, "sqlite_path", fallback=sqlite.get("path", _MISSING))) if sqlite_path: _set_nested(patch, ("database", "sqlite", "path"), sqlite_path) pg_patch: dict[str, Any] = {} pg_enabled = _runtime_value(mapping, "postgresql_enabled", fallback=postgresql.get("enabled", _MISSING)) if pg_enabled is not _MISSING and (_runtime_bool(pg_enabled) or backend == "sqlite"): pg_patch["enabled"] = _runtime_bool(pg_enabled) elif backend in {"postgresql", "postgres", "pg"}: pg_patch["enabled"] = True pg_text_fields = { "dsn": ("postgresql_dsn", "dsn"), "host": ("postgresql_host", "host"), "database": ("postgresql_database", "database"), "user": ("postgresql_user", "user"), "password": ("postgresql_password", "password"), } for target_key, (flat_key, nested_key) in pg_text_fields.items(): value = _runtime_text(_runtime_value(mapping, flat_key, fallback=postgresql.get(nested_key, _MISSING))) if value: pg_patch[target_key] = value pg_port = _runtime_text(_runtime_value(mapping, "postgresql_port", fallback=postgresql.get("port", _MISSING))) if pg_port: try: pg_patch["port"] = int(pg_port) except ValueError: pg_patch["port"] = pg_port has_connection_fields = any(key in pg_patch for key in ("dsn", "host", "database", "user", "password")) if has_connection_fields and backend != "sqlite" and "enabled" not in pg_patch: pg_patch["enabled"] = True if pg_patch: _set_nested(patch, ("database", "postgresql"), pg_patch) return patch def _runtime_value(mapping: Mapping[str, Any], key: str, *, fallback: Any = _MISSING) -> Any: if key in mapping: return mapping[key] return fallback def _runtime_text(value: Any) -> str: if value is _MISSING or value is None: return "" return str(value).strip() def _runtime_bool(value: Any) -> bool: if isinstance(value, bool): return value if isinstance(value, str): return value.strip().lower() in {"1", "true", "yes", "on", "enabled", "启用", "是"} return bool(value) def _set_nested(target: dict[str, Any], path: tuple[str, ...], value: Any) -> None: current = target for key in path[:-1]: child = current.get(key) if not isinstance(child, dict): child = {} current[key] = child current = child current[path[-1]] = value def _flatten_config_keys(value: Mapping[str, Any], prefix: str = "") -> list[str]: keys: list[str] = [] for key, child in value.items(): path = f"{prefix}.{key}" if prefix else str(key) if isinstance(child, Mapping): keys.extend(_flatten_config_keys(child, path)) else: keys.append(path) return sorted(keys) def _call_web_api_registrar(registrar: Callable[..., Any], path: str, handler: Callable[..., Any], method: str) -> bool: methods = [method] desc = f"ImageStudio {method} {path}" attempts = ( lambda: registrar(route=path, view_handler=handler, methods=methods, desc=desc), lambda: registrar(route=path, view_handler=handler, methods=methods), lambda: registrar(path=path, handler=handler, methods=methods), lambda: registrar(path=path, handler=handler, methods=methods, desc=desc), lambda: registrar(path=path, handler=handler, method=method), lambda: registrar(endpoint=path, handler=handler, methods=methods), lambda: registrar(path, handler, methods, desc), lambda: registrar(path, handler, methods=methods), lambda: registrar(path, handler, methods=methods, desc=desc), lambda: registrar(path, handler, method=method), lambda: registrar(path, methods, handler), lambda: registrar(path, method, handler), lambda: registrar(path, handler), ) last_error: TypeError | None = None for attempt in attempts: try: attempt() return True except TypeError as exc: last_error = exc if last_error is not None: raise last_error return False def _make_bridge_handler(endpoint: str, method: str) -> Callable[..., Any]: async def handler(request: Any | None = None, **kwargs: Any) -> Any: positional_endpoint = request if isinstance(request, str) else None actual_request = None if positional_endpoint is not None else request or kwargs.get("request") actual_request = actual_request or _current_astrbot_web_request() actual_endpoint = endpoint or _first_text( positional_endpoint, kwargs.get("endpoint"), kwargs.get("path"), kwargs.get("route_path"), kwargs.get("wildcard"), ) actual_query = _mapping_from_any(kwargs.get("query") or kwargs.get("params")) actual_payload = _mapping_from_any(kwargs.get("payload") or kwargs.get("body") or kwargs.get("data")) return await dispatch_bridge_request( actual_endpoint, method=method, request=actual_request, query=actual_query or None, payload=actual_payload or None, ) return handler def _current_astrbot_web_request() -> Any | None: try: from astrbot.api.web import request as astrbot_web_request except Exception: astrbot_web_request = None if astrbot_web_request is not None: try: getattr(astrbot_web_request, "method") return astrbot_web_request except Exception: pass try: from quart import request as quart_request getattr(quart_request, "method") return quart_request except Exception: return None def _request_context_from_astrbot_request(request: Any | None) -> RequestContext: username = _first_text( _attr(request, "username"), _current_quart_username(), ) or None user_id = _first_text( _attr(request, "user_id"), username, ) or None # AstrBot authenticates extension routes before invoking the plugin, but # PluginRequest currently exposes only the authenticated username. Grant # the capabilities that exist today explicitly instead of a wildcard so a # future permission cannot become enabled accidentally. permissions = BRIDGE_PERMISSIONS if username or user_id else frozenset() return RequestContext.from_astrbot( username=username, user_id=user_id, client_ip=_client_ip(request), source="astrbot_plugin_page", permissions=permissions, ) def _request_method(request: Any | None, *, fallback: str) -> str: return (_first_text(_attr(request, "method"), fallback) or "GET").upper() def _bridge_endpoint(endpoint: str | None, request: Any | None) -> str: candidate = _first_text( endpoint, _mapping_value(_attr(request, "path_params"), "endpoint", "path", "route_path", "wildcard"), _mapping_value(_attr(request, "match_info"), "endpoint", "path", "route_path", "wildcard"), _attr(request, "path"), _nested_attr(request, "url", "path"), _attr(request, "rel_url"), ) normalized = str(candidate or "").split("?", 1)[0].replace("\\", "/").strip("/") prefixes = ( f"api/plug/{PLUGIN_NAME}/", f"api/v1/plugins/extensions/{PLUGIN_NAME}/", f"{API_BASE.strip('/')}/", ) for prefix in prefixes: if normalized.startswith(prefix): normalized = normalized[len(prefix) :] break return normalize_extension_path(normalized) def _request_query(request: Any | None) -> dict[str, Any]: for candidate in ( _attr(request, "query"), _attr(request, "query_params"), _attr(request, "args"), _attr(request, "GET"), ): query = _mapping_from_any(candidate) if query: return query return {} async def _request_payload(request: Any | None) -> dict[str, Any]: if request is None or _request_method(request, fallback="GET") == "GET": return {} for name in ("json", "get_json"): loader = getattr(request, name, None) payload = _mapping_from_any(loader) if payload: return payload if not callable(loader): continue try: try: loaded = loader(default={}) if name == "json" else loader(silent=True) except TypeError: loaded = loader() if inspect.isawaitable(loaded): loaded = await loaded payload = _mapping_from_any(loaded) return payload except Exception: continue body = getattr(request, "body", None) if callable(body): body = body() if inspect.isawaitable(body): body = await body if isinstance(body, bytes): body = body.decode("utf-8") if isinstance(body, str) and body.strip(): try: return _mapping_from_any(json.loads(body)) except json.JSONDecodeError: return {} return {} def _unwrap_method_override(method: str, payload: dict[str, Any]) -> tuple[str, dict[str, Any]]: normalized_method = str(method or "GET").upper() if normalized_method != "POST": return normalized_method, payload override = str(payload.get("__imagestudio_method") or "").strip().upper() if override not in {"PUT", "DELETE", "PATCH"}: return normalized_method, payload body = payload.get("__imagestudio_body", {}) return override, _mapping_from_any(body) def _to_bridge_response(response: dict[str, Any]) -> dict[str, Any]: if response.get("ok"): return { "status": "ok", "message": "", "data": response.get("data"), "request_id": response.get("request_id"), } return { "status": "error", "message": str(response.get("message") or "request failed"), "data": response, "request_id": response.get("request_id"), } def _to_media_http_response(endpoint: str, response: dict[str, Any]) -> Any | None: if normalize_extension_path(endpoint) != "media/fetch" or not response.get("ok"): return None data = _mapping_from_any(response.get("data")) encoded = str(data.get("body_base64") or "") try: body = base64.urlsafe_b64decode(encoded + ("=" * (-len(encoded) % 4))) except (binascii.Error, ValueError): return None content_type = str(data.get("content_type") or "application/octet-stream") cache_control = str(data.get("cache_control") or "private, max-age=300") headers = {"Cache-Control": cache_control} try: from astrbot.api.web import request as _astrbot_request # noqa: F401 from starlette.responses import Response return Response(content=body, media_type=content_type, headers=headers) except Exception: pass try: from quart import Response return Response(body, content_type=content_type, headers=headers) except Exception: return None async def _to_media_file_response(query: dict[str, Any]) -> Any | None: """Use AstrBot/Quart native file responses to avoid base64 memory copies.""" token = str(query.get("token") or "").strip() if not token: return None try: path, metadata = MediaProxy().resolve_file(token) except Exception: return None content_type = str(metadata.get("content_type") or "application/octet-stream") headers = {"Cache-Control": "private, max-age=300"} try: from astrbot.api.web import file_response return file_response(path, content_type=content_type, headers=headers) except Exception: pass try: from quart import send_file response = send_file(path, mimetype=content_type, conditional=True, max_age=300) if inspect.isawaitable(response): response = await response response.headers["Cache-Control"] = headers["Cache-Control"] return response except Exception: return None def _mapping_from_any(value: Any) -> dict[str, Any]: if value is None: return {} if isinstance(value, dict): return dict(value) if hasattr(value, "items"): return {str(key): item for key, item in value.items()} return {} def _mapping_value(value: Any, *keys: str) -> Any: mapping = _mapping_from_any(value) for key in keys: if key in mapping: return mapping[key] return None def _attr(value: Any, name: str) -> Any: if value is None: return None try: return getattr(value, name, None) except Exception: return None def _nested_attr(value: Any, *names: str) -> Any: current = value for name in names: current = _attr(current, name) if current is None: return None return current def _first_text(*values: Any) -> str: for value in values: if value is None: continue text = str(value).strip() if text: return text return "" def _current_quart_username() -> str: try: from quart import g return _first_text(getattr(g, "username", None)) except Exception: return "" def _client_ip(request: Any | None) -> str | None: client_host = _attr(request, "client_host") if client_host: return str(client_host) remote_addr = _attr(request, "remote_addr") if remote_addr: return str(remote_addr) client = _attr(request, "client") host = _attr(client, "host") if host: return str(host) remote = _attr(request, "remote") return str(remote) if remote else None