RRRosmontis
34089d0042
Include utility modules, shared channels, prompts, read-only skills, wardrobe memory and regression tests. Externalize legacy credentials and exclude private runtime state.
827 lines
42 KiB
Python
827 lines
42 KiB
Python
"""Validated asynchronous tool execution on top of legacy bot handlers."""
|
||
|
||
from __future__ import annotations
|
||
|
||
import asyncio
|
||
import importlib
|
||
import inspect
|
||
import re
|
||
import shlex
|
||
from typing import Any, Awaitable, Callable, Dict, Mapping, Optional
|
||
|
||
from .artifacts import ArtifactError, ArtifactStore
|
||
from .capture import CaptureChannel
|
||
from .models import ToolContext, ToolResult
|
||
|
||
|
||
_MODULES = {
|
||
"setu": "setu",
|
||
"pixiv": "pixiv",
|
||
"jm": "jm",
|
||
"mail": "mail",
|
||
"akaros_mail": "for-bot_mail",
|
||
"ginkgo": "ginkgostu",
|
||
"live": "live_monitor",
|
||
"schedule": "scheduler",
|
||
"memo": "notebook",
|
||
"todo": "notebook",
|
||
"wardrobe": "wardrobe",
|
||
"my": "identity_cmd",
|
||
"server": "for_admin_komari_agent",
|
||
"deepseek": "deepseek.deepseek_balance",
|
||
"log": "for_admin_catch_log",
|
||
}
|
||
_ADMIN_TOOLS = frozenset(("server", "deepseek", "log"))
|
||
_ADMIN_ACTIONS = {
|
||
"setu": frozenset(("del-cache",)),
|
||
"pixiv": frozenset(("del-cache",)),
|
||
"jm": frozenset(("del-cache",)),
|
||
}
|
||
_MEDIA_AUTOSEND = frozenset(("setu", "pixiv", "jm"))
|
||
_OUTBOUND = frozenset(("send_image", "send_file", "send_sticker"))
|
||
_ACTIONS = {
|
||
"setu": ("help", "get", "del-cache"),
|
||
"pixiv": ("help", "get", "del-cache"),
|
||
"jm": ("help", "get", "search", "del-cache"),
|
||
"mail": ("help", "bind", "unbind", "account", "default", "list", "info", "push", "new", "send"),
|
||
"akaros_mail": ("send", "list", "info"),
|
||
"ginkgo": ("help", "rule", "bind", "unbind", "status", "sign", "notice", "auto-sign-in"),
|
||
"live": ("help", "status", "follow", "unfollow"),
|
||
"schedule": ("create", "list", "cancel"),
|
||
"memo": ("add", "list", "delete"),
|
||
"todo": ("add", "list", "complete", "delete"),
|
||
"wardrobe": ("add", "list", "update", "delete"),
|
||
"my": ("help", "account", "bind", "unbind", "push"),
|
||
"server": ("help", "status", "list", "load", "polling"),
|
||
"deepseek": ("help", "balance", "threshold", "polling", "alert"),
|
||
"log": ("help", "tail"),
|
||
"send_image": ("send",),
|
||
"send_file": ("send",),
|
||
"send_sticker": ("send",),
|
||
}
|
||
_DESCRIPTIONS = {
|
||
"setu": "获取涩图；params: tags(字符串数组), r18/ai(布尔)。媒体直接投递，文本交给模型。",
|
||
"pixiv": "按 pid 获取 Pixiv 图片；params: pid。媒体直接投递，文本交给模型。",
|
||
"jm": "JM 下载或搜索；get params: jm_id, range；search params: keyword, page。",
|
||
"mail": "邮件绑定、查询和发送。new/send 支持 to_address, subject, body_text, from_address, artifact_ids。",
|
||
"akaros_mail": "使用 shirobana@akaros.si 收发 Akaros 邮件。send params: to(地址或数组), subject, text, html/cc/bcc(可选)；list params: folder,limit,query,direction；info params: id。发件地址不可改写。",
|
||
"ginkgo": "白果云账户绑定、签到、通知和自动签到；敏感参数不会写入结果 data。",
|
||
"live": "直播关注；follow/unfollow params: room(0..100), site(1/2，可省)。",
|
||
"schedule": "创建、查看和取消持久化定时提醒。create params: message, kind(once/daily/weekly), run_at(once所需ISO8601时间), time_of_day(daily/weekly所需HH:MM), weekdays(weekly所需1..7数组)；list无参数；cancel params: id。只管理当前会话的任务。",
|
||
"memo": "用户显式维护的长期备忘录，不是自动聊天记忆。add params: content；list params: query(可选关键词)；delete params: id。",
|
||
"todo": "基于时间的个人约定，与主动提醒不同。add params: content, due_at(ISO8601), expires_at(可选，默认到期后24小时)；list params: include_completed(可选布尔)；complete/delete params: id。过期事项自动删除。",
|
||
"wardrobe": "仅私聊：白花在当前用户设定中的独立衣柜；支持任何衣物，包括内衣、内裤、袜子。日常提到已给白花买了/送给白花/白花已获得的衣物时主动add，无需保存指令或额外确认；排除用户自己的衣物、计划、假设、否定和没买成，勿凭空或仅凭图片猜测赠予。add params: name,description(可选详细外观),category(可选)；list params: query,limit(1..20默认10),offset(可选)；update params: id及name/description/category；delete params: id。衣物外观仅作背景理解，不每次复述完整描述，不代表实际购买或当前穿着。",
|
||
"my": "统一身份查询、绑定和平台推送设置。",
|
||
"server": "管理员：Komari 节点状态、负载和轮询设置。",
|
||
"deepseek": "管理员：DeepSeek 余额查询和监控设置。",
|
||
"log": "管理员：读取最近日志；tail params: lines(1..100)。",
|
||
"send_image": "只按 artifact_id 发送已捕获图片，不接受路径、URL 或 base64。",
|
||
"send_file": "只按 artifact_id 发送已捕获文件，严格禁止任意路径。",
|
||
"send_sticker": "只按 artifact_id 将已捕获图片作为贴纸发送。",
|
||
}
|
||
|
||
|
||
class ToolExecutor:
|
||
"""Validate tool calls and directly await existing business handlers.
|
||
|
||
No call passes through ``dispatch`` and no background ``create_task`` is
|
||
used. Legacy output is captured first. Only media from setu/pixiv/jm is
|
||
automatically delivered; all other captured text remains model-facing.
|
||
``modules`` and ``send_message`` are injectable solely to keep tests fully
|
||
isolated from network and real user delivery.
|
||
"""
|
||
|
||
def __init__(
|
||
self,
|
||
artifacts: Optional[ArtifactStore] = None,
|
||
*,
|
||
modules: Optional[Mapping[str, Any]] = None,
|
||
send_message: Optional[Callable[..., Awaitable[Any]]] = None,
|
||
) -> None:
|
||
self.artifacts = artifacts or ArtifactStore()
|
||
self._modules = dict(modules or {})
|
||
self._send_message = send_message
|
||
|
||
def prompt_schema(self, ctx: ToolContext) -> list:
|
||
"""Return model-facing JSON schemas, filtered by execution privileges."""
|
||
schemas = []
|
||
for name, actions in _ACTIONS.items():
|
||
if name == "wardrobe" and ctx.msg_type != "private":
|
||
continue
|
||
if name in _ADMIN_TOOLS and not ctx.is_admin:
|
||
continue
|
||
visible_actions = [
|
||
action for action in actions
|
||
if ctx.is_admin or action not in _ADMIN_ACTIONS.get(name, ())
|
||
]
|
||
schemas.append({
|
||
"name": name,
|
||
"description": _DESCRIPTIONS[name],
|
||
"parameters": {
|
||
"type": "object",
|
||
"properties": {
|
||
"action": {"type": "string", "enum": visible_actions},
|
||
"params": {"type": "object", "additionalProperties": True},
|
||
},
|
||
"required": ["action"],
|
||
"additionalProperties": False,
|
||
},
|
||
})
|
||
return schemas
|
||
|
||
def _module(self, name: str) -> Any:
|
||
if name not in self._modules:
|
||
self._modules[name] = importlib.import_module(_MODULES[name])
|
||
return self._modules[name]
|
||
|
||
@staticmethod
|
||
def _error(code: str, message: str, retryable: bool = False) -> ToolResult:
|
||
return ToolResult(False, code, message, retryable=retryable)
|
||
|
||
@staticmethod
|
||
def _check_params(
|
||
params: Dict[str, Any],
|
||
allowed: tuple = (),
|
||
required: tuple = (),
|
||
) -> None:
|
||
unknown = set(params) - set(allowed)
|
||
missing = [key for key in required if key not in params]
|
||
if unknown or missing:
|
||
details = []
|
||
if missing:
|
||
details.append("缺少参数 " + ", ".join(missing))
|
||
if unknown:
|
||
details.append("不支持的参数 " + ", ".join(sorted(unknown)))
|
||
raise ValueError("；".join(details) or "工具参数无效")
|
||
|
||
@staticmethod
|
||
def _string(
|
||
value: Any,
|
||
field: str,
|
||
*,
|
||
max_length: int = 200,
|
||
no_whitespace: bool = False,
|
||
) -> str:
|
||
if not isinstance(value, str) or not value.strip() or len(value) > max_length:
|
||
raise ValueError("invalid %s" % field)
|
||
value = value.strip()
|
||
if "\x00" in value or "\r" in value or "\n" in value:
|
||
raise ValueError("invalid %s" % field)
|
||
if no_whitespace and any(char.isspace() for char in value):
|
||
raise ValueError("invalid %s" % field)
|
||
return value
|
||
|
||
@staticmethod
|
||
def _integer(value: Any, field: str, minimum: int, maximum: int) -> int:
|
||
if isinstance(value, bool) or not isinstance(value, int):
|
||
raise ValueError("invalid %s" % field)
|
||
if not minimum <= value <= maximum:
|
||
raise ValueError("invalid %s" % field)
|
||
return value
|
||
|
||
@staticmethod
|
||
def _enabled(params: Dict[str, Any], key: str = "enabled") -> str:
|
||
value = params.get(key)
|
||
if isinstance(value, bool):
|
||
return "on" if value else "off"
|
||
if value in ("on", "off"):
|
||
return value
|
||
raise ValueError("invalid enabled flag")
|
||
|
||
@staticmethod
|
||
def _address(value: Any, field: str = "address") -> str:
|
||
address = ToolExecutor._string(value, field, max_length=320, no_whitespace=True).lower()
|
||
if not re.fullmatch(r"[^@\s]+@[^@\s]+", address):
|
||
raise ValueError("invalid %s" % field)
|
||
return address
|
||
|
||
@staticmethod
|
||
def _raw(prefix: str, action: str, *values: Any) -> str:
|
||
"""Construct a whitespace-parsed legacy command without invoking a shell."""
|
||
tail = [str(value) for value in values if value is not None and value != ""]
|
||
return "." + prefix + (" " + " ".join([action, *tail]) if action else "")
|
||
|
||
@staticmethod
|
||
def _mail_raw(action: str, *values: Any) -> str:
|
||
"""Mail alone uses ``shlex.split``; quote its subject/body accordingly."""
|
||
tail = [str(value) for value in values if value is not None and value != ""]
|
||
return ".mail " + shlex.join([action, *tail])
|
||
|
||
async def execute(self, name: str, args: Dict[str, Any], ctx: ToolContext) -> ToolResult:
|
||
"""Validate and execute one tool, returning errors instead of tracebacks."""
|
||
if name not in _ACTIONS:
|
||
return self._error("unknown_tool", "未知工具")
|
||
if not isinstance(args, dict):
|
||
return self._error("invalid_args", "工具参数必须是对象")
|
||
# Outbound tools also accept the convenient direct {artifact_id: ...} form.
|
||
if name in _OUTBOUND and "action" not in args:
|
||
action, params = "send", args
|
||
else:
|
||
if set(args) - {"action", "params"}:
|
||
return self._error("invalid_args", "工具调用只允许 action 和 params")
|
||
action = args.get("action")
|
||
params = args.get("params", {})
|
||
if not isinstance(action, str) or action not in _ACTIONS[name] or not isinstance(params, dict):
|
||
return self._error("invalid_args", "工具 action 或 params 无效")
|
||
if name in _ADMIN_TOOLS and not ctx.is_admin:
|
||
return self._error("permission_denied", "该工具仅管理员可用")
|
||
if action in _ADMIN_ACTIONS.get(name, ()) and not ctx.is_admin:
|
||
return self._error("permission_denied", "该操作仅管理员可用")
|
||
if name == "wardrobe" and ctx.msg_type != "private":
|
||
return self._error("permission_denied", "衣柜仅在所属用户的私聊中使用")
|
||
try:
|
||
if name == "wardrobe":
|
||
return await self._execute_wardrobe(action, params, ctx)
|
||
if name == "akaros_mail":
|
||
return await self._execute_akaros_mail(action, params)
|
||
if name in ("memo", "todo"):
|
||
return await self._execute_notebook(name, action, params, ctx)
|
||
if name == "schedule":
|
||
return await self._execute_schedule(action, params, ctx)
|
||
if name in _OUTBOUND:
|
||
return await self._execute_outbound(name, params, ctx)
|
||
if name == "mail" and action in ("new", "send") and "artifact_ids" in params:
|
||
return await self._mail_with_attachments(params, ctx)
|
||
capture = CaptureChannel(ctx, self.artifacts)
|
||
await self._dispatch(name, action, params, ctx, capture)
|
||
return await self._captured_result(name, capture, ctx)
|
||
except ArtifactError as exc:
|
||
return self._error("invalid_artifact", str(exc))
|
||
except ValueError as exc:
|
||
return self._error("invalid_args", str(exc) or "工具参数无效")
|
||
except Exception:
|
||
# Do not expose credentials, local paths or tracebacks to the model.
|
||
return self._error(
|
||
"handler_error",
|
||
"工具执行失败，请稍后重试",
|
||
retryable=True,
|
||
)
|
||
|
||
@staticmethod
|
||
def _wardrobe_item(item: dict) -> dict:
|
||
# Model needs stable IDs for later edits, never owner IDs or DB timestamps.
|
||
return {key: item[key] for key in ("id", "name", "category", "description") if key in item}
|
||
|
||
async def _execute_wardrobe(self, action: str, params: Dict[str, Any], ctx: ToolContext) -> ToolResult:
|
||
module = self._module("wardrobe")
|
||
store = module.wardrobe
|
||
if action == "add":
|
||
self._check_params(params, ("name", "description", "category"), ("name",))
|
||
item = await asyncio.to_thread(store.add, ctx, params["name"],
|
||
params.get("description", ""), params.get("category", "其他"))
|
||
return ToolResult(True, "ok", f"已保存到衣柜：{item['name']}。",
|
||
data={"action": "add", "item": self._wardrobe_item(item)})
|
||
if action == "list":
|
||
self._check_params(params, ("query", "limit", "offset"))
|
||
limit = self._integer(params.get("limit", 10), "limit", 1, 20)
|
||
offset = self._integer(params.get("offset", 0), "offset", 0, 200)
|
||
items = await asyncio.to_thread(store.list, ctx, params.get("query"))
|
||
selected, parts, size = [], [], 0
|
||
for item in items[offset:offset + limit]:
|
||
formatted = f"{item['name']}（{item['category']}）" + (f"：{item['description']}" if item['description'] else "")
|
||
if size + len(formatted) > 12000:
|
||
break
|
||
selected.append(self._wardrobe_item(item)); parts.append(formatted); size += len(formatted)
|
||
next_offset = offset + len(selected)
|
||
text = "衣柜为空" if not items else "衣柜记录：\n" + "\n".join(parts)
|
||
if next_offset < len(items):
|
||
text += "\n还有未展示的衣物，可以继续查询；这不是全部库存。"
|
||
return ToolResult(True, "ok", text, data={"items": selected, "total": len(items),
|
||
"next_offset": next_offset if next_offset < len(items) else None})
|
||
if action == "update":
|
||
self._check_params(params, ("id", "name", "description", "category"), ("id",))
|
||
changes = {k: params[k] for k in ("name", "description", "category") if k in params}
|
||
if not changes:
|
||
raise ValueError("至少提供一项衣物修改")
|
||
item = await asyncio.to_thread(store.update, ctx, params["id"], **changes)
|
||
return ToolResult(True, "ok", f"衣物细节已经改好：{item['name']}。",
|
||
data={"action": "update", "item": self._wardrobe_item(item)})
|
||
self._check_params(params, ("id",), ("id",))
|
||
item = await asyncio.to_thread(store.delete, ctx, params["id"])
|
||
return ToolResult(True, "ok", f"已从衣柜移除：{item['name']}",
|
||
data={"action": "delete", "item": self._wardrobe_item(item)})
|
||
|
||
async def _execute_akaros_mail(self, action: str, params: Dict[str, Any]) -> ToolResult:
|
||
module = self._module("akaros_mail")
|
||
if action == "send":
|
||
self._check_params(params, ("to", "subject", "text", "html", "cc", "bcc"),
|
||
("to", "subject", "text"))
|
||
try:
|
||
result = await asyncio.to_thread(
|
||
module.send_email, params["to"], params["subject"], params["text"],
|
||
params.get("html"), params.get("cc"), params.get("bcc"))
|
||
except Exception as exc:
|
||
return self._error("send_unknown", f"Akaros 发件结果未知：{str(exc)[:300]}")
|
||
return ToolResult(True, "ok", "Akaros 邮件已接受发送", data=result)
|
||
if action == "list":
|
||
self._check_params(params, ("folder", "limit", "query", "direction"))
|
||
result = await asyncio.to_thread(
|
||
module.list_messages, params.get("folder", "inbox"),
|
||
params.get("limit", 10), params.get("query"), params.get("direction"))
|
||
return ToolResult(True, "ok", module.format_messages(result), data=result)
|
||
self._check_params(params, ("id",), ("id",))
|
||
result = await asyncio.to_thread(module.get_message, params["id"])
|
||
return ToolResult(True, "ok", module.format_message(result), data=result)
|
||
|
||
async def _execute_notebook(self, name: str, action: str, params: Dict[str, Any], ctx: ToolContext) -> ToolResult:
|
||
module = self._module(name)
|
||
store = module.notebook
|
||
if name == "memo":
|
||
if action == "add":
|
||
self._check_params(params, ("content",), ("content",))
|
||
item = await asyncio.to_thread(store.add_memo, ctx, params["content"])
|
||
return ToolResult(True, "ok", "备忘录已保存：" + module.format_memo(item), data={"item": item})
|
||
if action == "list":
|
||
self._check_params(params, ("query",))
|
||
query = params.get("query")
|
||
if query is not None:
|
||
query = self._string(query, "query", max_length=200)
|
||
items = await asyncio.to_thread(store.list_memos, ctx, query)
|
||
text = "备忘录为空" if not items else "备忘录：\n" + "\n".join(module.format_memo(x) for x in items)
|
||
return ToolResult(True, "ok", text, data={"items": items})
|
||
self._check_params(params, ("id",), ("id",))
|
||
item_id = self._string(params["id"], "id", max_length=32, no_whitespace=True)
|
||
item = await asyncio.to_thread(store.delete_memo, ctx, item_id)
|
||
return ToolResult(True, "ok", f"已删除备忘录 {item['id']}：{item['content']}", data={"item": item})
|
||
|
||
if action == "add":
|
||
self._check_params(params, ("content", "due_at", "expires_at"), ("content", "due_at"))
|
||
item = await asyncio.to_thread(
|
||
store.add_todo, ctx, params["content"], params["due_at"], params.get("expires_at"))
|
||
return ToolResult(True, "ok", "待办已保存：" + module.format_todo(item), data={"item": item})
|
||
if action == "list":
|
||
self._check_params(params, ("include_completed",))
|
||
include = params.get("include_completed", False)
|
||
if not isinstance(include, bool):
|
||
raise ValueError("include_completed 必须是布尔值")
|
||
items = await asyncio.to_thread(store.list_todos, ctx, include)
|
||
text = "没有待办事项" if not items else "待办事项：\n" + "\n".join(module.format_todo(x) for x in items)
|
||
return ToolResult(True, "ok", text, data={"items": items})
|
||
self._check_params(params, ("id",), ("id",))
|
||
item_id = self._string(params["id"], "id", max_length=32, no_whitespace=True)
|
||
if action == "complete":
|
||
item = await asyncio.to_thread(store.complete_todo, ctx, item_id)
|
||
return ToolResult(True, "ok", f"已完成待办 {item['id']}：{item['content']}", data={"item": item})
|
||
item = await asyncio.to_thread(store.delete_todo, ctx, item_id)
|
||
return ToolResult(True, "ok", f"已删除待办 {item['id']}：{item['content']}", data={"item": item})
|
||
|
||
async def _execute_schedule(self, action: str, params: Dict[str, Any], ctx: ToolContext) -> ToolResult:
|
||
module = self._module("schedule")
|
||
if action == "create":
|
||
task = await asyncio.to_thread(module.scheduler.create_from_params, ctx, params)
|
||
return ToolResult(
|
||
True, "ok", "定时任务已创建：" + module.format_task(task),
|
||
data={"task": task},
|
||
)
|
||
if action == "list":
|
||
self._check_params(params)
|
||
tasks = await asyncio.to_thread(module.scheduler.list_for_context, ctx)
|
||
if not tasks:
|
||
return ToolResult(True, "ok", "当前会话没有进行中的定时任务", data={"tasks": []})
|
||
text = "当前定时任务：\n" + "\n".join(module.format_task(task) for task in tasks)
|
||
return ToolResult(True, "ok", text, data={"tasks": tasks})
|
||
self._check_params(params, ("id",), ("id",))
|
||
task_id = self._string(params["id"], "id", max_length=32, no_whitespace=True)
|
||
task = await asyncio.to_thread(module.scheduler.cancel_for_context, ctx, task_id)
|
||
return ToolResult(
|
||
True, "ok", f"已取消定时任务 {task['id']}：{task['message']}",
|
||
data={"task": task},
|
||
)
|
||
|
||
async def _dispatch(
|
||
self,
|
||
name: str,
|
||
action: str,
|
||
params: Dict[str, Any],
|
||
ctx: ToolContext,
|
||
capture: CaptureChannel,
|
||
) -> None:
|
||
"""Route to a typed builder and directly await its original handler."""
|
||
module = self._module(name)
|
||
if name == "setu":
|
||
await self._setu(module, action, params, ctx, capture)
|
||
elif name == "live":
|
||
await self._live(module, action, params, ctx, capture)
|
||
elif name == "my":
|
||
raw = self._my_command(action, params)
|
||
await module.handle_my(capture, ctx.msg_type, ctx.target_id, ctx.user_id, ctx.user_id, raw[3:].strip())
|
||
else:
|
||
raw = self._legacy_command(name, action, params)
|
||
handler_name = {
|
||
"pixiv": "handle_pixiv",
|
||
"jm": "handle_jm",
|
||
"mail": "handle_mail",
|
||
"ginkgo": "handle_ginkgo",
|
||
}.get(name, "handle_command")
|
||
handler = getattr(module, handler_name)
|
||
if name in ("pixiv", "jm", "mail", "ginkgo"):
|
||
await handler(capture, ctx.msg_type, ctx.target_id, ctx.user_id, raw)
|
||
else:
|
||
await handler(capture, ctx.msg_type, ctx.target_id, raw)
|
||
|
||
async def _setu(
|
||
self,
|
||
module: Any,
|
||
action: str,
|
||
params: Dict[str, Any],
|
||
ctx: ToolContext,
|
||
capture: CaptureChannel,
|
||
) -> None:
|
||
if action == "help":
|
||
self._check_params(params)
|
||
await capture.send(ctx.msg_type, ctx.target_id, module.HELP_TEXT)
|
||
return
|
||
if action == "del-cache":
|
||
self._check_params(params)
|
||
await module.handle_del_cache(capture, ctx.msg_type, ctx.target_id, ctx.user_id)
|
||
return
|
||
self._check_params(params, ("tags", "r18", "ai"))
|
||
tags = params.get("tags", [])
|
||
if not isinstance(tags, list) or len(tags) > 3:
|
||
raise ValueError("tags must be an array of at most three items")
|
||
clean_tags = []
|
||
for tag in tags:
|
||
tag = self._string(tag, "tag", max_length=80, no_whitespace=True)
|
||
if not re.fullmatch(r"[\w一-鿿]+", tag):
|
||
raise ValueError("invalid tag")
|
||
clean_tags.append(tag)
|
||
flags = []
|
||
for key, positive, negative in (("r18", "允许r18", "不要r18"), ("ai", "允许ai", "不要ai")):
|
||
value = params.get(key)
|
||
if value is not None and not isinstance(value, bool):
|
||
raise ValueError("invalid %s" % key)
|
||
flags.append(positive if value is True else negative if value is False else None)
|
||
await module.handle_setu(
|
||
clean_tags, flags[0], flags[1], ctx.msg_type, ctx.target_id, capture,
|
||
)
|
||
|
||
def _legacy_command(self, name: str, action: str, params: Dict[str, Any]) -> str:
|
||
if name == "pixiv":
|
||
if action == "get":
|
||
self._check_params(params, ("pid",), ("pid",))
|
||
pid = str(params["pid"])
|
||
if not pid.isdigit() or len(pid) > 20:
|
||
raise ValueError("invalid pid")
|
||
return self._raw(name, pid)
|
||
self._check_params(params)
|
||
return self._raw(name, action)
|
||
if name == "jm":
|
||
if action == "get":
|
||
self._check_params(params, ("jm_id", "range"), ("jm_id",))
|
||
jm_id = str(params["jm_id"])
|
||
chapter_range = params.get("range")
|
||
if not jm_id.isdigit() or len(jm_id) > 20:
|
||
raise ValueError("invalid jm_id")
|
||
if chapter_range is not None and (
|
||
not isinstance(chapter_range, str)
|
||
or not re.fullmatch(r"\d{1,4}-\d{1,4}", chapter_range)
|
||
):
|
||
raise ValueError("invalid chapter range")
|
||
return self._raw(name, "zip", jm_id, chapter_range)
|
||
if action == "search":
|
||
self._check_params(params, ("keyword", "page"), ("keyword",))
|
||
keyword = self._string(params["keyword"], "keyword", max_length=100)
|
||
page = self._integer(params.get("page", 1), "page", 1, 10000)
|
||
return self._raw(name, "ss", keyword, page)
|
||
self._check_params(params)
|
||
return self._raw(name, action)
|
||
if name == "mail":
|
||
return self._mail_command(action, params)
|
||
if name == "ginkgo":
|
||
return self._ginkgo_command(action, params)
|
||
if name == "server":
|
||
return self._server_command(action, params)
|
||
if name == "deepseek":
|
||
return self._deepseek_command(action, params)
|
||
if name == "log":
|
||
if action == "tail":
|
||
self._check_params(params, ("lines",))
|
||
lines = self._integer(params.get("lines", 5), "lines", 1, 100)
|
||
return self._raw(name, str(lines))
|
||
self._check_params(params)
|
||
return self._raw(name, "help")
|
||
raise ValueError("unsupported tool")
|
||
|
||
def _mail_command(self, action: str, params: Dict[str, Any]) -> str:
|
||
if action in ("new", "send"):
|
||
self._check_params(
|
||
params,
|
||
("to_address", "subject", "body_text", "from_address"),
|
||
("to_address", "subject", "body_text"),
|
||
)
|
||
to_address = self._address(params["to_address"], "to_address")
|
||
subject = self._string(params["subject"], "subject", max_length=500)
|
||
body = params["body_text"]
|
||
if not isinstance(body, str) or len(body) > 100000 or "\x00" in body:
|
||
raise ValueError("invalid body_text")
|
||
from_address = params.get("from_address")
|
||
if from_address is not None:
|
||
from_address = self._address(from_address, "from_address")
|
||
return self._mail_raw("new", to_address, subject, body, from_address)
|
||
if action in ("bind", "unbind", "default"):
|
||
self._check_params(params, ("address",), ("address",))
|
||
return self._mail_raw(action, self._address(params["address"]))
|
||
if action == "list":
|
||
self._check_params(params, ("window", "address", "limit", "count"))
|
||
window = params.get("window")
|
||
limit = params.get("limit", params.get("count"))
|
||
if window is not None and limit is not None:
|
||
raise ValueError("window 与 limit/count 只能选择一个")
|
||
if limit is not None:
|
||
window = str(self._integer(limit, "limit", 1, 10))
|
||
if window is not None and (
|
||
not isinstance(window, str) or not re.fullmatch(r"\d{1,6}[dhm]?", window)
|
||
):
|
||
raise ValueError("invalid window")
|
||
address = params.get("address")
|
||
return self._mail_raw("list", window, self._address(address) if address else None)
|
||
if action == "info":
|
||
self._check_params(params, ("message_id", "mid", "id"))
|
||
value = params.get("message_id", params.get("mid", params.get("id")))
|
||
if value is None:
|
||
raise ValueError("缺少邮件编号 message_id/mid/id")
|
||
return self._mail_raw("info", self._integer(value, "message_id", 0, 2**63 - 1))
|
||
if action == "push":
|
||
self._check_params(params, ("enabled", "interval"), ("enabled",))
|
||
enabled = self._enabled(params)
|
||
interval = params.get("interval")
|
||
if interval is not None:
|
||
interval = self._integer(interval, "interval", 1, 10080)
|
||
return self._mail_raw("push", enabled, interval)
|
||
self._check_params(params)
|
||
return self._mail_raw(action)
|
||
|
||
def _ginkgo_command(self, action: str, params: Dict[str, Any]) -> str:
|
||
if action == "bind":
|
||
self._check_params(params, ("account", "password"), ("account", "password"))
|
||
account = self._string(params["account"], "account", no_whitespace=True)
|
||
password = self._string(params["password"], "password", no_whitespace=True)
|
||
return self._raw("ginkgo", "bind", account, password)
|
||
if action == "unbind":
|
||
self._check_params(params, ("account",))
|
||
account = params.get("account")
|
||
return self._raw("ginkgo", "unbind", self._string(account, "account", no_whitespace=True) if account else None)
|
||
if action == "notice":
|
||
self._check_params(params, ("count", "enabled"))
|
||
if "enabled" in params:
|
||
return self._raw("ginkgo", "notice", self._enabled(params))
|
||
count = self._integer(params.get("count", 5), "count", 1, 20)
|
||
return self._raw("ginkgo", "notice", count)
|
||
if action == "auto-sign-in":
|
||
self._check_params(params, ("enabled",), ("enabled",))
|
||
return self._raw("ginkgo", action, self._enabled(params))
|
||
self._check_params(params)
|
||
return self._raw("ginkgo", action)
|
||
|
||
def _my_command(self, action: str, params: Dict[str, Any]) -> str:
|
||
if action == "account":
|
||
self._check_params(params)
|
||
return ".my account"
|
||
if action == "bind":
|
||
self._check_params(params, ("value",), ("value",))
|
||
value = self._string(params["value"], "value", max_length=30, no_whitespace=True)
|
||
if not value.isdigit():
|
||
raise ValueError("bind value must be numeric")
|
||
return self._raw("my account", "bind", value)
|
||
if action == "unbind":
|
||
self._check_params(params, ("qq",))
|
||
qq = params.get("qq")
|
||
if qq is not None and (not str(qq).isdigit()):
|
||
raise ValueError("invalid qq")
|
||
return self._raw("my account", "unbind", qq)
|
||
if action == "push":
|
||
self._check_params(params, ("platform", "enabled"), ("platform", "enabled"))
|
||
if params["platform"] not in ("qq", "tg"):
|
||
raise ValueError("invalid platform")
|
||
return self._raw("my", params["platform"] + "-push", self._enabled(params))
|
||
self._check_params(params)
|
||
return ".my help"
|
||
|
||
def _server_command(self, action: str, params: Dict[str, Any]) -> str:
|
||
if action == "status":
|
||
self._check_params(params, ("seconds", "node"))
|
||
seconds = params.get("seconds")
|
||
node = params.get("node")
|
||
if seconds is not None:
|
||
seconds = self._integer(seconds, "seconds", 1, 30)
|
||
if node is not None:
|
||
node = self._string(str(node), "node", max_length=100, no_whitespace=True)
|
||
return self._raw("server", "status", seconds, node)
|
||
if action == "load":
|
||
self._check_params(params, ("node", "hours", "metric"), ("node",))
|
||
node = self._string(params["node"], "node", max_length=100, no_whitespace=True)
|
||
hours = self._integer(params.get("hours", 1), "hours", 1, 720)
|
||
metric = params.get("metric", "all")
|
||
allowed = ("cpu", "ram", "swap", "load", "temp", "disk", "network", "process", "connections", "all")
|
||
if metric not in allowed:
|
||
raise ValueError("invalid metric")
|
||
return self._raw("server", "load", node, hours, metric)
|
||
if action == "polling":
|
||
self._check_params(params, ("enabled", "minutes"), ("enabled",))
|
||
minutes = params.get("minutes")
|
||
if minutes is not None:
|
||
minutes = self._integer(minutes, "minutes", 1, 1440)
|
||
return self._raw("server", "polling", self._enabled(params), minutes)
|
||
self._check_params(params)
|
||
return self._raw("server", action)
|
||
|
||
def _deepseek_command(self, action: str, params: Dict[str, Any]) -> str:
|
||
if action in ("threshold", "polling"):
|
||
self._check_params(params, ("value",), ("value",))
|
||
minimum = 0 if action == "threshold" else 1
|
||
return self._raw("deepseek", action, self._integer(params["value"], "value", minimum, 100000))
|
||
if action == "alert":
|
||
self._check_params(params, ("enabled",), ("enabled",))
|
||
return self._raw("deepseek", action, self._enabled(params))
|
||
self._check_params(params)
|
||
return self._raw("deepseek", action)
|
||
|
||
async def _live(
|
||
self,
|
||
module: Any,
|
||
action: str,
|
||
params: Dict[str, Any],
|
||
ctx: ToolContext,
|
||
capture: CaptureChannel,
|
||
) -> None:
|
||
"""Live has no legacy async handler, so use its public storage functions."""
|
||
if action == "help":
|
||
self._check_params(params)
|
||
await capture.send(ctx.msg_type, ctx.target_id, module.HELP_TEXT)
|
||
return
|
||
if action == "status":
|
||
self._check_params(params)
|
||
text = module.status_text(ctx.msg_type, ctx.target_id, self._channel_name(ctx))
|
||
await capture.send(ctx.msg_type, ctx.target_id, text)
|
||
return
|
||
self._check_params(params, ("room", "site"), ("room",))
|
||
room = self._integer(params["room"], "room", 0, 100)
|
||
site = params.get("site")
|
||
if site is not None:
|
||
site = self._integer(site, "site", 1, 2)
|
||
site_value = str(site or "")
|
||
if ctx.msg_type == "group":
|
||
follow_channel, follow_id = self._channel_name(ctx), ctx.target_id
|
||
else:
|
||
identity = importlib.import_module("identity")
|
||
if not identity.push_targets(ctx.user_id):
|
||
await capture.send(ctx.msg_type, ctx.target_id, "身份异常：找不到可用的推送目标，请联系管理员")
|
||
return
|
||
follow_channel, follow_id = "tg", ctx.user_id
|
||
function = module.add_follow if action == "follow" else module.remove_follow
|
||
await asyncio.to_thread(function, str(room), ctx.msg_type, follow_id, site_value, follow_channel)
|
||
label = {"1": "主站", "2": "副站", "": "全部"}[site_value]
|
||
verb = "已经添加" if action == "follow" else "已经取消"
|
||
await capture.send(ctx.msg_type, ctx.target_id, f"{verb}对{label}直播间{room}的关注！")
|
||
|
||
@staticmethod
|
||
def _channel_name(ctx: ToolContext) -> str:
|
||
return getattr(ctx.channel, "name", "unknown")
|
||
|
||
async def _sender(self) -> Callable[..., Awaitable[Any]]:
|
||
if self._send_message is None:
|
||
self._send_message = importlib.import_module("channel").send_message
|
||
return self._send_message
|
||
|
||
async def _captured_result(
|
||
self,
|
||
name: str,
|
||
capture: CaptureChannel,
|
||
ctx: ToolContext,
|
||
) -> ToolResult:
|
||
artifacts = capture.public_artifacts()
|
||
deliveries = []
|
||
if name in _MEDIA_AUTOSEND:
|
||
for media in capture.media:
|
||
deliveries.append(await self._deliver_captured(media, ctx))
|
||
data = {
|
||
"request_id": ctx.request_id,
|
||
"task_id": ctx.task_id,
|
||
"captured_text": list(capture.texts),
|
||
"deliveries": deliveries,
|
||
}
|
||
if capture.capture_errors:
|
||
data["capture_errors"] = list(capture.capture_errors)
|
||
failed = any(not item["ok"] for item in deliveries)
|
||
text = capture.safe_text()
|
||
legacy_failure = any(marker in text for marker in (
|
||
"发送失败", "多次尝试", "请手动访问", "未绑定", "参数错误", "参数解析失败",
|
||
"仅管理员", "无法", "不存在", "暂时不可用", "请求图片失败", "获取图片信息失败",
|
||
"读取邮件失败", "未找到", "没有找到",
|
||
))
|
||
mail_send_unknown = name == "mail" and "发送失败" in text
|
||
code = ("delivery_failed" if failed else "send_unknown" if mail_send_unknown
|
||
else "legacy_failure" if legacy_failure
|
||
else "media_capture_failed" if capture.capture_errors else "ok")
|
||
return ToolResult(
|
||
ok=not failed and not legacy_failure and not capture.capture_errors,
|
||
code=code,
|
||
safe_message=text,
|
||
data=data,
|
||
artifacts=artifacts,
|
||
retryable=(not mail_send_unknown and (
|
||
failed or any(marker in text for marker in ("失败", "不可用", "超时"))
|
||
)),
|
||
)
|
||
|
||
async def _deliver_captured(self, media: Dict[str, Any], ctx: ToolContext) -> Dict[str, Any]:
|
||
artifact_id = media["artifact_id"]
|
||
record = {"artifact_id": artifact_id, "media_type": media["type"], "ok": False}
|
||
try:
|
||
path = await asyncio.to_thread(self.artifacts.materialize, artifact_id, ctx)
|
||
data = dict(media["data"])
|
||
data["file"] = path.as_uri()
|
||
sender = await self._sender()
|
||
result = await sender(ctx.channel, ctx.msg_type, ctx.target_id, [{"type": media["type"], "data": data}])
|
||
record["ok"] = result is not False
|
||
except Exception:
|
||
record["ok"] = False
|
||
return record
|
||
|
||
async def _mail_with_attachments(self, params: Dict[str, Any], ctx: ToolContext) -> ToolResult:
|
||
"""Call the attachment-aware mail API without routing through ``.mail new``."""
|
||
self._check_params(
|
||
params,
|
||
("to_address", "subject", "body_text", "from_address", "artifact_ids"),
|
||
("to_address", "subject", "body_text", "artifact_ids"),
|
||
)
|
||
to_address = self._address(params["to_address"], "to_address")
|
||
subject = self._string(params["subject"], "subject", max_length=500)
|
||
body = params["body_text"]
|
||
if not isinstance(body, str) or len(body) > 100000 or "\x00" in body:
|
||
raise ValueError("invalid body_text")
|
||
artifact_ids = params["artifact_ids"]
|
||
if not isinstance(artifact_ids, list) or not artifact_ids or len(artifact_ids) > 10:
|
||
raise ValueError("artifact_ids must contain 1..10 ids")
|
||
if any(not isinstance(value, str) for value in artifact_ids):
|
||
raise ValueError("invalid artifact id")
|
||
module = self._module("mail")
|
||
data = await asyncio.to_thread(module._load_user, ctx.user_id)
|
||
from_address = params.get("from_address") or data.get("default")
|
||
if not from_address:
|
||
return self._error("mail_identity_required", "尚未绑定邮箱或未设默认地址")
|
||
from_address = self._address(from_address, "from_address")
|
||
if from_address not in data.get("addresses", []):
|
||
return self._error("mail_identity_required", "发件地址未绑定")
|
||
paths = [
|
||
await asyncio.to_thread(self.artifacts.materialize, artifact_id, ctx)
|
||
for artifact_id in artifact_ids
|
||
]
|
||
send = getattr(module, "send_with_attachments")
|
||
result = send(
|
||
ctx.user_id, from_address, to_address, subject, body,
|
||
[str(path) for path in paths],
|
||
)
|
||
if inspect.isawaitable(result):
|
||
result = await result
|
||
if not isinstance(result, dict) or not result.get("ok"):
|
||
error_code = str(result.get("error_code") or "send_failed") if isinstance(result, dict) else "send_failed"
|
||
error = str(result.get("error") or "附件邮件发送失败") if isinstance(result, dict) else "附件邮件发送失败"
|
||
return ToolResult(
|
||
False, error_code, error,
|
||
data={"request_id": ctx.request_id, "task_id": ctx.task_id},
|
||
artifacts=[self.artifacts.get(artifact_id, ctx) for artifact_id in artifact_ids],
|
||
retryable=error_code in ("send_failed", "upstream_unavailable"),
|
||
)
|
||
return ToolResult(
|
||
True,
|
||
"sent",
|
||
"邮件及附件已发送",
|
||
data={"request_id": ctx.request_id, "task_id": ctx.task_id,
|
||
"attachment_count": len(paths), "mail": result},
|
||
artifacts=[self.artifacts.get(artifact_id, ctx) for artifact_id in artifact_ids],
|
||
)
|
||
|
||
async def _execute_outbound(self, name: str, params: Dict[str, Any], ctx: ToolContext) -> ToolResult:
|
||
"""Deliver only a registered artifact; no arbitrary filesystem input exists."""
|
||
self._check_params(params, ("artifact_id",), ("artifact_id",))
|
||
artifact_id = params["artifact_id"]
|
||
if not isinstance(artifact_id, str):
|
||
raise ValueError("invalid artifact id")
|
||
public = self.artifacts.get(artifact_id, ctx)
|
||
if name in ("send_image", "send_sticker") and public["media_type"] != "image":
|
||
return self._error("invalid_artifact", "该 artifact 不是图片")
|
||
path = await asyncio.to_thread(self.artifacts.materialize, artifact_id, ctx)
|
||
segment_type = "file" if name == "send_file" else "image"
|
||
data: Dict[str, Any] = {"file": path.as_uri()}
|
||
if name == "send_file":
|
||
data["name"] = public["filename"]
|
||
if name == "send_sticker":
|
||
data["sub_type"] = 1
|
||
delivery = {"artifact_id": artifact_id, "media_type": segment_type, "ok": False}
|
||
try:
|
||
sender = await self._sender()
|
||
result = await sender(ctx.channel, ctx.msg_type, ctx.target_id, [{"type": segment_type, "data": data}])
|
||
delivery["ok"] = result is not False
|
||
except Exception:
|
||
delivery["ok"] = False
|
||
if not delivery["ok"]:
|
||
return ToolResult(
|
||
False, "delivery_failed", "媒体发送失败，请稍后重试",
|
||
data={"delivery": delivery}, artifacts=[public], retryable=True,
|
||
)
|
||
return ToolResult(
|
||
True, "sent", "媒体已发送",
|
||
data={"delivery": delivery}, artifacts=[public],
|
||
)
|