"""MCP (Model Context Protocol) 接入模块 — IT-TOOLS-PRO 授权应用的 AI 调用入口。 设计(与 video_ops/audio_ops 同为 server.py 伴星模块): - 令牌:MCP 令牌存 DATA_DIR/mcp_tokens.json,与本机机器码绑定;生成与每次调用都复验 query_authorized / 账号授权,卡密过期令牌即失效("购买卡密才能调用")。 - 协议端点:POST /mcp —— MCP Streamable HTTP(JSON-RPC 2.0,无会话状态)。 initialize / tools/list 免鉴权(让客户端先发现工具),tools/call 必须 Bearer 令牌。 - 13 个工具经本机 loopback http://127.0.0.1:8091 直调 relay 自身端点(完整走 check() 授权 + log_usage() 统计),OCR 直打宿主 rapidocr:5000。 - 文件类结果落 DATA_DIR/mcp_files/,响应里返回可下载 URL(GET /mcp/file/,同令牌鉴权)。 - 每次 tools/call 记 mcp_usage 表(令牌尾号/机器/工具/耗时/成败),供后台「MCP 调用」页查询。 """ import json import os import re import secrets import sqlite3 import time import urllib.error import urllib.parse import urllib.request import uuid # ---- 由 server.py 启动时注入(避免循环 import) ---- _CTX = { "data_dir": "/app/data", "usage_db": "/app/data/usage.db", "query_authorized": lambda machine: False, "account_ok": lambda machine: False, "machine_ok": lambda m: bool(re.match(r"^\d{13,20}$", m)), "public_base": "", # 空则按请求 Host 推断 } def setup(**kw): _CTX.update({k: v for k, v in kw.items() if v is not None}) _ensure_table() def _tokens_file(): return os.path.join(_CTX["data_dir"], "mcp_tokens.json") def _files_dir(): d = os.path.join(_CTX["data_dir"], "mcp_files") os.makedirs(d, exist_ok=True) return d def _ensure_table(): try: conn = sqlite3.connect(_CTX["usage_db"]) conn.execute("CREATE TABLE IF NOT EXISTS mcp_usage (" "id INTEGER PRIMARY KEY AUTOINCREMENT, token_tail TEXT, machine TEXT, " "tool TEXT, ok INTEGER, err TEXT, dur_ms INTEGER, at REAL)") conn.commit() conn.close() except Exception: pass def log_mcp(token_tail: str, machine: str, tool: str, ok: bool, err: str, dur_ms: int): try: conn = sqlite3.connect(_CTX["usage_db"]) conn.execute("INSERT INTO mcp_usage (token_tail, machine, tool, ok, err, dur_ms, at) " "VALUES (?,?,?,?,?,?,?)", (token_tail, machine, tool, 1 if ok else 0, (err or "")[:400], int(dur_ms), time.time())) conn.commit() conn.close() except Exception: pass def mcp_usage_query(days: int = 7) -> dict: since = time.time() - days * 86400 conn = sqlite3.connect(_CTX["usage_db"]) rows = conn.execute( "SELECT token_tail, machine, tool, ok, err, dur_ms, at FROM mcp_usage " "WHERE at>? ORDER BY at DESC LIMIT 300", (since,)).fetchall() by_tool = conn.execute( "SELECT tool, COUNT(*), SUM(ok) FROM mcp_usage WHERE at>? GROUP BY tool ORDER BY COUNT(*) DESC", (since,)).fetchall() total = conn.execute("SELECT COUNT(*), SUM(ok) FROM mcp_usage WHERE at>?", (since,)).fetchone() conn.close() return { "days": days, "total": int(total[0] or 0), "ok_total": int(total[1] or 0), "by_tool": [{"tool": t, "count": int(c), "ok": int(o or 0)} for t, c, o in by_tool], "rows": [{"token_tail": r[0], "machine": r[1], "tool": r[2], "ok": bool(r[3]), "err": r[4] or "", "dur_ms": int(r[5] or 0), "at": int(r[6] or 0)} for r in rows], } # ---------------------------------------------------------------- 令牌管理 def _load_tokens() -> list: try: with open(_tokens_file(), "r", encoding="utf-8") as f: data = json.load(f) return data if isinstance(data, list) else [] except Exception: return [] def _save_tokens(items: list): tmp = _tokens_file() + ".tmp" with open(tmp, "w", encoding="utf-8") as f: json.dump(items, f, ensure_ascii=False, indent=1) os.replace(tmp, _tokens_file()) def _authorized(machine: str) -> bool: if not machine or not _CTX["machine_ok"](machine): return False try: return bool(_CTX["query_authorized"](machine)) or bool(_CTX["account_ok"](machine)) except Exception: return False def _bearer(handler) -> str: auth = handler.headers.get("Authorization", "") or "" if auth.lower().startswith("bearer "): return auth[7:].strip() return (handler.headers.get("X-MCP-Token", "") or "").strip() def _find_token(tok: str): if not tok: return None for it in _load_tokens(): if it.get("token") == tok: return it return None def tokens_api(method: str, payload: dict, qs: dict) -> tuple[int, dict]: """令牌管理:GET /mcp/tokens、POST /mcp/tokens(生成)、POST /mcp/tokens/delete。""" machine = (payload.get("machine_id") or payload.get("machine") or (qs.get("machine_id") or qs.get("machine") or [""])[0] or "").strip() if not _authorized(machine): return 403, {"code": 403, "message": "本设备尚未授权:购买卡密并激活后才能生成 MCP 令牌"} items = _load_tokens() if method == "GET": mine = [it for it in items if it.get("machine") == machine] return 200, {"code": 200, "message": "ok", "data": {"tokens": mine, "count": len(mine), "authorized": True}} if method == "POST" and payload.get("action") == "delete": tok = payload.get("token") or "" kept = [it for it in items if not (it.get("token") == tok and it.get("machine") == machine)] if len(kept) != len(items): _save_tokens(kept) return 200, {"code": 200, "message": "已删除", "data": {"tokens": [i for i in kept if i.get("machine") == machine]}} return 404, {"code": 404, "message": "令牌不存在"} # 生成 mine = [it for it in items if it.get("machine") == machine] if len(mine) >= 10: return 400, {"code": 400, "message": "每台设备最多 10 个 MCP 令牌,请先删除不用的"} note = (payload.get("note") or "").strip()[:40] rec = { "token": "mcpt_" + secrets.token_hex(24), "machine": machine, "note": note or "MCP 客户端", "created": int(time.time()), "last_used": 0, "calls": 0, } items.append(rec) _save_tokens(items) return 200, {"code": 200, "message": "ok", "data": {"token": rec["token"], "record": rec}} def _touch_token(tok: str): items = _load_tokens() changed = False for it in items: if it.get("token") == tok: it["last_used"] = int(time.time()) it["calls"] = int(it.get("calls") or 0) + 1 changed = True break if changed: try: _save_tokens(items) except Exception: pass # ---------------------------------------------------------------- http 内调 _LOOPBACK = "http://127.0.0.1:8091" _OCR_URL = "http://host.docker.internal:5000/ocr" def _req(base: str, method: str, path: str, headers: dict, body=None, timeout: int = 600): h = {"User-Agent": "ittools-mcp/1.0"} if headers: h.update(headers) url = base + path req = urllib.request.Request(url, data=body, headers=h, method=method) try: with urllib.request.urlopen(req, timeout=timeout) as r: return r.status, dict(r.headers), r.read() except urllib.error.HTTPError as e: return e.code, dict(e.headers), e.read() def _hdr(machine: str, tool: str, ct: str = "") -> dict: h = {"X-Machine-Id": machine, "X-Tool": tool} if ct: h["Content-Type"] = ct return h def _check(status, raw): if status == 403: raise RuntimeError("授权校验未通过(403):设备授权缺失或已过期") if status >= 400: raise RuntimeError(f"HTTP {status}: {raw.decode('utf-8', 'ignore')[:300]}") return raw def _json_api(status, raw): _check(status, raw) try: j = json.loads(raw.decode("utf-8")) except Exception: return raw.decode("utf-8", "ignore")[:5000] if isinstance(j, dict) and j.get("code") not in (None, 200, 0): raise RuntimeError(j.get("message") or f"接口返回 code={j.get('code')}") return j def _multipart(fields, files): boundary = uuid.uuid4().hex out = bytearray() for k, v in fields.items(): out += f"--{boundary}\r\nContent-Disposition: form-data; name=\"{k}\"\r\n\r\n{v}\r\n".encode() for field, fname, data, ct in files: out += (f"--{boundary}\r\nContent-Disposition: form-data; name=\"{field}\"; " f"filename=\"{fname}\"\r\nContent-Type: {ct}\r\n\r\n").encode() out += data + b"\r\n" out += f"--{boundary}--\r\n".encode() return bytes(out), f"multipart/form-data; boundary={boundary}" def _mime(path: str) -> str: ext = os.path.splitext(path)[1].lower() return { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".webp": "image/webp", ".gif": "image/gif", ".pdf": "application/pdf", ".mp3": "audio/mpeg", ".wav": "audio/wav", ".m4a": "audio/mp4", ".mp4": "video/mp4", ".mov": "video/quicktime", ".mkv": "video/x-matroska", ".avi": "video/x-msvideo", ".webm": "video/webm", ".doc": "application/msword", ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document", ".xls": "application/vnd.ms-excel", ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", ".ppt": "application/vnd.ms-powerpoint", ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation", ".txt": "text/plain", ".srt": "application/x-subrip", ".json": "application/json", }.get(ext, "application/octet-stream") def _save_file(data: bytes, name_hint: str, headers=None) -> dict: name = name_hint cd = (headers or {}).get("Content-Disposition") or "" m = re.search(r"filename\*=UTF-8''([^;]+)", cd) or re.search(r'filename="([^"]+)"', cd) if m: name = urllib.parse.unquote(m.group(1)) safe = re.sub(r"[^\w.\-]+", "_", name)[-80:] or "result.bin" if "." not in safe: safe += ".bin" fname = f"{time.strftime('%Y%m%d-%H%M%S')}-{uuid.uuid4().hex[:6]}-{safe}" with open(os.path.join(_files_dir(), fname), "wb") as f: f.write(data) return {"file": fname, "name": safe, "bytes": len(data), "url": f"/mcp/file/{fname}"} def _host_path(path: str) -> str: """AI 客户端(与宿主同机)传宿主绝对路径(/vol1/…),relay 容器内经 /:/hostfs 挂载可达。""" if not path or not str(path).startswith("/"): return path if os.path.isfile(path): return path alt = "/hostfs" + path if os.path.isfile(alt): return alt return path def _read_file(path: str) -> bytes: path = _host_path(path) if not path or not os.path.isfile(path): raise RuntimeError(f"文件不存在: {path}") with open(path, "rb") as f: return f.read() def _ok(data): return json.dumps({"ok": True, "data": data}, ensure_ascii=False, default=str) def _err(e): return json.dumps({"ok": False, "error": str(e)[:1500]}, ensure_ascii=False) # ---------------------------------------------------------------- 13 个工具 def tool_translate_text(machine, text, source="auto", target="zh-CN"): q = urllib.parse.urlencode({"client": "gtx", "sl": source, "tl": target, "dt": "t", "q": text}) status, _, raw = _req(_LOOPBACK, "GET", "/translate?" + q, _hdr(machine, "translator"), timeout=60) j = json.loads(_check(status, raw).decode("utf-8")) segs = j[0] if isinstance(j, list) and j else [] return _ok({"text": "".join(s[0] for s in segs if isinstance(s, list) and s and s[0])}) def tool_ocr(machine, path): path = _host_path(path) if path.lower().endswith(".pdf"): pages = _pdf_pages(path) result = [] for fn, data in pages: body, ct = _multipart({}, [("image_file", fn, data, "image/jpeg")]) status, _, raw = _req("http://host.docker.internal:5000", "POST", "/ocr", _hdr(machine, "pdf-ocr", ct), body, timeout=120) j = json.loads(_check(status, raw).decode("utf-8")) lines = [{"text": j[k].get("rec_txt", ""), "score": j[k].get("score", 0)} for k in sorted(j, key=lambda x: int(x)) if j[k].get("rec_txt")] result.append({"page": fn, "lines": lines}) return _ok({"pages": len(result), "detail": result, "text": "\n".join(l["text"] for p in result for l in p["lines"])}) data = _read_file(path) body, ct = _multipart({}, [("image_file", os.path.basename(path), data, _mime(path))]) status, _, raw = _req("http://host.docker.internal:5000", "POST", "/ocr", _hdr(machine, "image-ocr", ct), body, timeout=120) j = json.loads(_check(status, raw).decode("utf-8")) lines = [{"text": j[k].get("rec_txt", ""), "score": j[k].get("score", 0)} for k in sorted(j, key=lambda x: int(x)) if j[k].get("rec_txt")] return _ok({"lines": lines, "text": "\n".join(l["text"] for l in lines)}) def _pdf_pages(path, dpi=150): try: import subprocess tmp = os.path.join(_files_dir(), f".pdf-{uuid.uuid4().hex[:8]}") os.makedirs(tmp, exist_ok=True) proc = subprocess.run(["pdftoppm", "-jpeg", "-r", str(dpi), path, os.path.join(tmp, "p")], capture_output=True, timeout=120) if proc.returncode == 0: pages = [] for fn in sorted(os.listdir(tmp)): if fn.endswith(".jpg"): with open(os.path.join(tmp, fn), "rb") as f: pages.append((fn, f.read())) if pages: return pages except Exception: pass try: import fitz except ImportError: raise RuntimeError("PDF 渲染组件缺失(需 pdftoppm 或 pymupdf)") with open(path, "rb") as f: data = f.read() doc = fitz.open(stream=data, filetype="pdf") return [(f"page-{i + 1}.jpg", p.get_pixmap(dpi=dpi).tobytes("jpg")) for i, p in enumerate(doc)] def tool_translate_doc(machine, path, to="en"): data = _read_file(path) body, ct = _multipart({"to": to}, [("file", os.path.basename(path), data, _mime(path))]) status, _, raw = _req(_LOOPBACK, "POST", "/translate-doc", _hdr(machine, "translator", ct), body, timeout=480) j = _json_api(status, raw) d = j.get("data") or {} return _ok({"text": d.get("text"), "chars": d.get("chars"), "target": to}) def tool_tts(machine, text, voice="", rate="", pitch=""): body = json.dumps({"text": text, "voice": voice, "rate": rate, "pitch": pitch}).encode() status, hdrs, raw = _req(_LOOPBACK, "POST", "/tts", _hdr(machine, "audio-tools", "application/json"), body, timeout=180) _check(status, raw) if raw[:1] in (b"{", b"["): raise RuntimeError(json.loads(raw.decode("utf-8")).get("message") or "TTS 失败") return _ok(_save_file(raw, "tts.mp3", hdrs)) def tool_speech_to_text(machine, path, language="auto"): data = _read_file(path) body, ct = _multipart({"language": language}, [("file", os.path.basename(path), data, _mime(path))]) status, _, raw = _req(_LOOPBACK, "POST", "/asr", _hdr(machine, "audio-tools", ct), body, timeout=300) j = _json_api(status, raw) d = j.get("data") or {} return _ok({"text": d.get("text"), "language": d.get("language"), "segments": d.get("segments")}) def tool_extract_subtitle(machine, path, lang=""): data = _read_file(path) body, ct = _multipart({}, [("file", os.path.basename(path), data, _mime(path))]) status, _, raw = _req(_LOOPBACK, "POST", "/subtitle?lang=" + urllib.parse.quote(lang), _hdr(machine, "video-tools", ct), body, timeout=600) j = _json_api(status, raw) d = j.get("data") or {} return _ok({"segments": d.get("segments"), "language": d.get("language")}) _VIDEO_OPS = ("convert", "gif", "gif2video", "compress", "trim", "rotate", "flip", "speed", "mute", "watermark", "unwatermark", "audio", "screenshot") def tool_video_process(machine, path, op, options=None): if op == "subtitle": return tool_extract_subtitle(machine, path) if op not in _VIDEO_OPS: raise RuntimeError(f"op 须为 {'/'.join(_VIDEO_OPS)} 或 subtitle") data = _read_file(path) fields = {"op": op} for k, v in (options or {}).items(): fields[k] = str(v) body, ct = _multipart(fields, [("file", os.path.basename(path), data, _mime(path))]) status, hdrs, raw = _req(_LOOPBACK, "POST", "/video", _hdr(machine, "video-tools", ct), body, timeout=600) _check(status, raw) if raw[:1] in (b"{", b"["): raise RuntimeError(json.loads(raw.decode("utf-8")).get("message") or "视频处理失败") return _ok(_save_file(raw, f"{op}-out.bin", hdrs)) def tool_gen_image(machine, prompt, model="pollinations-flux", width=1024, height=1024): body = json.dumps({"machine": machine, "prompt": prompt, "model": model, "width": int(width), "height": int(height)}).encode() status, _, raw = _req(_LOOPBACK, "POST", "/ai/gen-image", _hdr(machine, "ai-gen", "application/json"), body, timeout=300) j = _json_api(status, raw) d = (j.get("data") or {}) if isinstance(j, dict) else {} if d.get("b64"): import base64 b64 = d["b64"].split(",", 1)[-1] return _ok(_save_file(base64.b64decode(b64), "ai-gen.png")) if d.get("url"): req = urllib.request.Request(d["url"], headers={"User-Agent": "ittools-mcp/1.0"}) with urllib.request.urlopen(req, timeout=120) as r: return _ok(_save_file(r.read(), "ai-gen.png", dict(r.headers))) raise RuntimeError("接口未返回图片数据") def tool_convert_doc(machine, path, format): data = _read_file(path) body, ct = _multipart({"format": format}, [("files", os.path.basename(path), data, _mime(path))]) status, hdrs, raw = _req(_LOOPBACK, "POST", "/convert", _hdr(machine, "doc-convert", ct), body, timeout=300) _check(status, raw) if raw[:1] in (b"{", b"["): raise RuntimeError(json.loads(raw.decode("utf-8")).get("message") or "格式转换失败") return _ok(_save_file(raw, os.path.basename(path) + f".{format.lstrip('.')}", hdrs)) def _raw_image_op(machine, path, api_path, ct_override=None, timeout=300): data = _read_file(path) status, hdrs, raw = _req(_LOOPBACK, "POST", api_path, _hdr(machine, "image-tools", ct_override or _mime(path)), data, timeout=timeout) _check(status, raw) if raw[:1] in (b"{", b"["): raise RuntimeError(json.loads(raw.decode("utf-8")).get("message") or "图片处理失败") ext = ".png" if raw[:8] == b"\x89PNG\r\n\x1a\n" else (".jpg" if raw[:2] == b"\xff\xd8" else ".webp") return _ok(_save_file(raw, "out" + ext, hdrs)) def tool_remove_bg(machine, path): return _raw_image_op(machine, path, "/remove-bg", timeout=300) def tool_upscale_image(machine, path, scale=2, noise=1): if int(scale) not in (2, 4): raise RuntimeError("scale 仅支持 2 或 4") return _raw_image_op(machine, path, f"/upscale?scale={int(scale)}&noise={int(noise)}", timeout=400) _COPY_SCENES = ("rewrite", "deaigc", "titles", "xhs", "moments") def tool_copywriting(machine, text, scene="rewrite", model="mimo-v2.6-flash"): if scene not in _COPY_SCENES: raise RuntimeError(f"scene 须为 {'/'.join(_COPY_SCENES)}") body = json.dumps({"machine": machine, "scene": scene, "text": text, "model": model}).encode() status, _, raw = _req(_LOOPBACK, "POST", "/ai/copy", _hdr(machine, "", "application/json"), body, timeout=180) j = _json_api(status, raw) d = j.get("data") if isinstance(j, dict) else j if isinstance(d, dict) and (d.get("text") or d.get("reply")): return _ok({"text": d.get("text") or d.get("reply")}) if isinstance(d, str): return _ok({"text": d}) return _ok({"result": d}) def tool_vision_qa(machine, image_path, question="描述这张图片的内容"): import base64 data = _read_file(image_path) body = json.dumps({"machine": machine, "image": base64.b64encode(data).decode(), "question": question}).encode() status, _, raw = _req(_LOOPBACK, "POST", "/ai/vision", _hdr(machine, "image-tools", "application/json"), body, timeout=180) j = _json_api(status, raw) d = j.get("data") if isinstance(j, dict) else j if isinstance(d, dict) and (d.get("text") or d.get("answer") or d.get("reply")): return _ok({"answer": d.get("text") or d.get("answer") or d.get("reply")}) if isinstance(d, str): return _ok({"answer": d}) return _ok({"result": d}) # ---------------------------------------------------------------- 工具注册表 _S = {"type": "object"} TOOLS = [ {"name": "translate_text", "fn": tool_translate_text, "description": "翻译一段文本(谷歌引擎,多语言互译)。", "inputSchema": {"type": "object", "properties": { "text": {"type": "string"}, "source": {"type": "string", "default": "auto"}, "target": {"type": "string", "default": "zh-CN"}}, "required": ["text"]}}, {"name": "ocr", "fn": tool_ocr, "description": "识别图片/PDF 中的文字,返回逐行文本与置信度(PDF 自动逐页)。", "inputSchema": {"type": "object", "properties": {"path": {"type": "string", "description": "服务器可访问的文件路径或已上传文件名"}}, "required": ["path"]}}, {"name": "translate_doc", "fn": tool_translate_doc, "description": "整篇文档翻译(docx/pdf 等 → 译文全文),耗时可达数分钟。", "inputSchema": {"type": "object", "properties": {"path": {"type": "string"}, "to": {"type": "string", "default": "en"}}, "required": ["path"]}}, {"name": "tts", "fn": tool_tts, "description": "文字合成语音,返回 mp3 下载 URL。", "inputSchema": {"type": "object", "properties": {"text": {"type": "string"}, "voice": {"type": "string"}, "rate": {"type": "string"}, "pitch": {"type": "string"}}, "required": ["text"]}}, {"name": "speech_to_text", "fn": tool_speech_to_text, "description": "音频转文字(ASR),返回识别文本与时间分段。", "inputSchema": {"type": "object", "properties": {"path": {"type": "string"}, "language": {"type": "string", "default": "auto"}}, "required": ["path"]}}, {"name": "extract_subtitle", "fn": tool_extract_subtitle, "description": "视频/音频 AI 字幕生成:输出带时间轴的识别分段。", "inputSchema": {"type": "object", "properties": {"path": {"type": "string"}, "lang": {"type": "string"}}, "required": ["path"]}}, {"name": "video_process", "fn": tool_video_process, "description": "视频批处理:转码/压缩/裁剪/旋转/翻转/调速/消音/加去水印/提取音频/截图/GIF 等。", "inputSchema": {"type": "object", "properties": { "path": {"type": "string"}, "op": {"type": "string", "enum": list(_VIDEO_OPS) + ["subtitle"]}, "options": {"type": "object", "description": "按 op 传参:trim={start,end}; speed={speed}; rotate={angle}; flip={dir}; watermark={text}; unwatermark={x,y,w,h}; convert={format}; gif={fps,w,h}"}}, "required": ["path", "op"]}}, {"name": "gen_image", "fn": tool_gen_image, "description": "AI 文生图,返回图片下载 URL。", "inputSchema": {"type": "object", "properties": {"prompt": {"type": "string"}, "model": {"type": "string", "default": "pollinations-flux"}, "width": {"type": "integer", "default": 1024}, "height": {"type": "integer", "default": 1024}}, "required": ["prompt"]}}, {"name": "convert_doc", "fn": tool_convert_doc, "description": "文档格式转换(pdf/docx/xlsx/pptx 互转等),返回结果下载 URL。", "inputSchema": {"type": "object", "properties": {"path": {"type": "string"}, "format": {"type": "string"}}, "required": ["path", "format"]}}, {"name": "remove_bg", "fn": tool_remove_bg, "description": "图片抠图去背景,输出透明底 PNG 下载 URL。", "inputSchema": {"type": "object", "properties": {"path": {"type": "string"}}, "required": ["path"]}}, {"name": "upscale_image", "fn": tool_upscale_image, "description": "图片超分辨率放大(2x/4x)并降噪。", "inputSchema": {"type": "object", "properties": {"path": {"type": "string"}, "scale": {"type": "integer", "default": 2}, "noise": {"type": "integer", "default": 1}}, "required": ["path"]}}, {"name": "copywriting", "fn": tool_copywriting, "description": "文案工具箱:改写/降AIGC率/爆款标题/小红书笔记/朋友圈文案。", "inputSchema": {"type": "object", "properties": { "text": {"type": "string"}, "scene": {"type": "string", "enum": list(_COPY_SCENES)}, "model": {"type": "string", "default": "mimo-v2.6-flash"}}, "required": ["text", "scene"]}}, {"name": "vision_qa", "fn": tool_vision_qa, "description": "看图问答:描述图片内容/提取图中信息/判断图片状态。", "inputSchema": {"type": "object", "properties": {"image_path": {"type": "string"}, "question": {"type": "string"}}, "required": ["image_path"]}}, ] TOOLS_MAP = {t["name"]: t for t in TOOLS} def tools_schema() -> list: return [{k: t[k] for k in ("name", "description", "inputSchema")} for t in TOOLS] # ---------------------------------------------------------------- JSON-RPC def _public_base(handler) -> str: if _CTX.get("public_base"): return _CTX["public_base"].rstrip("/") host = handler.headers.get("Host", "") or "it.88531.cn" # 带端口的内网访问走 http,否则公网 https scheme = "http" if ":" in host else "https" return f"{scheme}://{host}" def _rpc_result(rid, result): return {"jsonrpc": "2.0", "id": rid, "result": result} def _rpc_error(rid, code, message): return {"jsonrpc": "2.0", "id": rid, "error": {"code": code, "message": message}} def _handle_rpc(req: dict, token_rec: dict | None, handler) -> dict | None: """处理单个 JSON-RPC 请求;notification 返回 None。""" method = req.get("method") rid = req.get("id") params = req.get("params") or {} if method in ("notifications/initialized", "notifications/cancelled", "notifications/roots/list_changed"): return None if rid is None and method and method.startswith("notifications/"): return None if method == "ping": return _rpc_result(rid, {}) if method == "initialize": return _rpc_result(rid, { "protocolVersion": params.get("protocolVersion", "2025-06-18"), "capabilities": {"tools": {}}, "serverInfo": {"name": "it-tools-pro", "version": "1.0.0", "title": "IT-TOOLS-PRO 授权应用 MCP"}, "instructions": "本站 13 个授权工具的 MCP 入口。文件类入参传服务器可见的文件路径;" "结果中的 url 字段为可下载地址(需同款 Bearer 令牌)。", }) if method == "tools/list": return _rpc_result(rid, {"tools": tools_schema()}) if method == "tools/call": if not token_rec: return _rpc_error(rid, -32001, "未授权:请在请求头携带 Authorization: Bearer (站内「MCP 接入」页购买卡密后生成)") machine = token_rec.get("machine") or "" if not _authorized(machine): return _rpc_error(rid, -32001, "授权已失效:卡密过期或设备授权撤销,请重新激活") name = params.get("name") args = params.get("arguments") or {} tool = TOOLS_MAP.get(name) if not tool: return _rpc_error(rid, -32602, f"unknown tool: {name}") if name in ("ocr", "translate_doc", "tts", "speech_to_text", "extract_subtitle", "video_process", "convert_doc", "remove_bg", "upscale_image", "vision_qa"): # 文件类入参:允许直接传文件名(mcp_files 内已上传文件)或绝对路径 for key in ("path", "image_path"): if key in args and args[key] and not os.path.isabs(str(args[key])): cand = os.path.join(_files_dir(), os.path.basename(str(args[key]))) if os.path.isfile(cand): args[key] = cand t0 = time.time() ok, err = True, "" try: text = tool["fn"](machine, **args) except Exception as e: # noqa: BLE001 text, ok, err = _err(e), False, str(e) dur = int((time.time() - t0) * 1000) log_mcp((token_rec.get("token") or "")[-6:], machine, name, ok, err, dur) _touch_token(token_rec.get("token") or "") # 下载 URL 补全域前缀 try: obj = json.loads(text) base = _public_base(handler) def _abs(o): if isinstance(o, dict): return {k: (base + v if k == "url" and isinstance(v, str) and v.startswith("/mcp/") else _abs(v)) for k, v in o.items()} if isinstance(o, list): return [_abs(x) for x in o] return o text = json.dumps(_abs(obj), ensure_ascii=False) except Exception: pass return _rpc_result(rid, {"content": [{"type": "text", "text": text}], "isError": not ok}) return _rpc_error(rid, -32601, f"method not found: {method}") def handle_post(handler) -> tuple[int, bytes, str]: """POST /mcp —— 返回 (status, body, content_type)。""" try: length = int(handler.headers.get("Content-Length") or 0) except ValueError: length = 0 raw = handler.rfile.read(length) if length else b"{}" try: payload = json.loads(raw.decode("utf-8") or "{}") except Exception: return 400, json.dumps({"jsonrpc": "2.0", "id": None, "error": {"code": -32700, "message": "parse error"}}, ensure_ascii=False).encode(), "application/json" tok = _bearer(handler) token_rec = _find_token(tok) # initialize/tools/list 免鉴权(发现能力),tools/call 必须有效令牌 requests = payload if isinstance(payload, list) else [payload] needs_auth = any(isinstance(r, dict) and r.get("method") == "tools/call" for r in requests) if needs_auth and not token_rec: return 401, json.dumps({"error": "unauthorized", "message": "缺少或无效的 MCP 令牌(Authorization: Bearer mcpt_…)"}, ensure_ascii=False).encode(), "application/json" out = [] for r in requests: if not isinstance(r, dict): continue resp = _handle_rpc(r, token_rec, handler) if resp is not None: out.append(resp) if not out: return 202, b"", "application/json" body = out[0] if len(out) == 1 else out return 200, json.dumps(body, ensure_ascii=False).encode("utf-8"), "application/json" def handle_get_file(handler, fname: str): """GET /mcp/file/ —— 令牌鉴权后提供结果文件下载。""" tok = _bearer(handler) if not _find_token(tok): handler.send_response(401) handler.send_header("Content-Type", "application/json") handler.end_headers() handler.wfile.write(b'{"error":"unauthorized"}') return safe = os.path.basename(fname) path = os.path.join(_files_dir(), safe) if not os.path.isfile(path): handler.send_response(404) handler.end_headers() handler.wfile.write(b'{"error":"not found"}') return with open(path, "rb") as f: data = f.read() handler.send_response(200) handler.send_header("Content-Type", "application/octet-stream") handler.send_header("Content-Length", str(len(data))) handler.send_header("Content-Disposition", f'attachment; filename="{safe}"; filename*=UTF-8\'\'{urllib.parse.quote(safe)}') handler.end_headers() handler.wfile.write(data)