- 所有功能历史最多显示100条:relay img-history vis[:150]→[:100]、mcp-usage 流水 LIMIT 300→100 - 前端三处兜底:loadImgHist/ai-gen/poster slice(0,100) - 上轮遗留收口:后台文件管理全量视图/50条分页/100x100缩略图/下载/三类删除、图片历史铁规则 ImgHist 共享层接入7工具 - Home NEW_FEATURES 与 README 同步
746 lines
33 KiB
Python
746 lines
33 KiB
Python
"""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 "
|
||
# 铁规则:所有功能历史最多显示 100 条
|
||
"WHERE at>? ORDER BY at DESC LIMIT 100", (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)
|