Files
it-tools-relay/mcp_ops.py
T
3970260761 5bea806f07 feat(mcp): MCP Streamable HTTP 端点 + 卡密授权令牌 + 调用记录
- /mcp JSON-RPC 2.0:initialize/tools/list 免鉴权,tools/call 强制 Bearer mcpt_ 令牌
- 令牌管理 GET/POST /mcp/tokens + POST action=delete,每步复验卡密授权(未授权 403)
- 调用记录 mcp_usage 表 + /admin/mcp-usage 汇总/流水
- 文件类入参 /hostfs 转换、二进制结果落盘返回下载 URL
- 修:生成令牌返回 data.token 为字符串(record 单独放 record 键)
2026-11-12 16:47:06 +08:00

745 lines
33 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""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/<name>,同令牌鉴权)。
- 每次 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令牌>(站内「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/<name> —— 令牌鉴权后提供结果文件下载。"""
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)