16 Commits
Author SHA1 Message Date
jinghui 5d79d653ac feat: AI换脸+海报门控——PROTECTED_TOOLS加face-swap/poster-maker; /ai/face-swap处理器(403授权提示/log_usage/multipart/换脸主流程走ai/img图链路); 换脸引擎懒加载(buffalo_l+inswapper_128, CPUExecutionProvider, 多脸取最大); Dockerfile pip装insightface+COPY face-models(855MB不入库) 2026-11-13 19:35:04 +08:00
jinghui 0cec894ba8 feat: 中文提示词自动转英文再发上游——_translate_prompt(mimo-v2.6-flash,缓存300,失败回退原文), gen/edit接入, 响应带prompt_en 2026-11-13 11:53:22 +08:00
jinghui dcf7e9006e feat: AI生图上游真实配额落地——CF共享池173张/天全站计数(已授权同样保护)、quota端点带model返回upstream/配额出处、403文案含官方数字 2026-11-13 09:43:30 +08:00
3970260761 049fb73231 feat(ai-gen): 每日免费次数配额 - /ai/quota 端点 + check_gen 门禁 + 成功扣次
- DAILY_FREE_LIMIT(默认10)/DAILY_FILE(daily_gen.json),北京时间0点重置,线程锁防并发写
- check_gen(machine, own_provider): 已授权不限次;未授权内置渠道按日计次;自带KEY不计次
- gen-image/edit-image/custom-models 门禁切 check_gen,内置成功后 daily_consume
- 新增 POST /ai/quota 返回 authorized/limit/used/remaining(remaining=-1表示不限)
- 403 文案改为「需要授权,或今日内置免费生图次数(N次/天)已用完——可配置自己的API KEY」
2026-11-13 01:19:24 +08:00
3970260761 77f91fad99 feat(users): 用户表新增 last_login 最后登录时间
- users 表 ALTER 增加 last_login REAL DEFAULT 0(启动自动迁移)
- /user/login 登录成功与 /user/register 注册时写入当前时间
- /admin/overview 返回 last_login 字段供管理后台展示
2026-11-13 00:15:25 +08:00
3970260761 cf4e57cf79 feat(ai-gen): 自定义提供商转发 + 生成图落盘历史端点
- POST /ai/custom-models: 测试 OpenAI 兼容提供商并拉取模型(KEY仅请求透传不落盘)
- POST /ai/gen-image: 可选 provider 字段 → _provider_images_gen 用用户 base_url+KEY 直连上游
- 生成成功落盘 DATA_DIR/gen_images/<machine>/ + index.json(每机100张超限清旧, thread lock)
- GET /ai/img-history?machine= 历史列表; GET /ai/img/<m>/<id>[?dl=1] 图片文件/附件下载
- 图片文件端点从尾部解析路径段(兼容 nginx 剥 /relay 前缀与直连两条链路)
2026-11-12 22:54:17 +08:00
3970260761 b30ffda52e fix: compose/README 补回 -v /:/hostfs(canonical run line 同款)+ config.json 持久挂载
6cae4e9 落盘 compose 时丢了 /:/hostfs:_load_storage_root 经 HOST_PREFIX 解析
storage_root,缺挂载则 DATA_DIR 漂移到容器易失 /vol3/... 层,重建容器后
用户库/.auth_secret/上传全丢(历史用户登录失败、新注册写易失层)。
同时挂载 config.json 双保险,并修正 storage_root=宿主真实数据路径
(容器路径 /app/data 在 hostfs 下会被前缀化到宿主无关目录)。
2026-11-12 20:04:17 +08:00
3970260761 0bc283dc49 docs: README run/compose 部署段同步 config.json 持久挂载(对齐 docker-compose.yml) 2026-11-12 19:54:46 +08:00
3970260761 a17ac893c2 fix: 注册接口 INSERT 列数不匹配导致注册失败(502);config.json 挂载修复容器重建后 DATA_DIR 漂移到易失层
- server.py: users 表经 ALTER 迁移为 9 列后注册仍按 4 列全量 VALUES 插入,
  SQLite 抛 OperationalError → nginx 502「注册失败」;改为显式列名插入,
  其余列走 DEFAULT(与 _ensure_admin 写法一致)
- docker-compose.yml: 挂载 ./data/config.json 到 DEFAULT_HOST_ROOT 容器路径,
  _load_storage_root() 才能读到 storage_root=/app/data;此前配置落在容器易失层,
  重建容器后 DATA_DIR 漂移到 /vol3/... 易失目录,用户库/密钥/上传全丢(历史用户登录失败)
2026-11-12 19:48:15 +08:00
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
jinghui 853d9d3c8c feat(online): /relay/online 端点 + 90s内存窗口 + admin/usage 返回online 2026-11-12 12:52:51 +08:00
jinghui 6cae4e9cf9 fix: 落盘 docker-compose.yml 并对齐 run/compose 部署参数(代理+add-host+NO_PROXY)
- README 声称的 compose 文件此前不存在,容器恢复全靠 inspect 复制
- 补齐 HTTPS_PROXY/NO_PROXY/--add-host/NET_ADMIN/DEFAULT_HOST_ROOT 实际参数
- BBC RSS 等境外源必须走宿主代理,否则 Network unreachable
2026-11-12 12:15:44 +08:00
3970260761 66966f6990 feat(usage): POST /usage 访客工具使用上报(含未登录) — tool格式校验+同机同工具10min去重+每IP 10min 300条限流; /admin/usage 返回guest聚合(次数/最近时间) 2026-11-12 11:35:38 +08:00
3970260761 cd0bcc2516 feat(hub): 授权中心hub接口 — GET /hub/announcements(项目公告双保险过滤) + POST /hub/report(安装登记+心跳在线统计); 先心跳后check-update规避heartbeat清空client_version/device_info 2026-11-12 10:32:55 +08:00
3970260761 d5cf278073 feat(feedback): 留言反馈API — 提交(图形验证码+IP一小时限1条)、后台列表/改状态/删除(X-Admin-Token鉴权) 2026-11-12 02:00:44 +08:00
jinghui 16e649633b docs: README 补充 Docker Compose 部署方式(方式二)
粘贴完整 docker-compose.yml(含全部参数)并给出 up 命令;保留原有 docker run 说明。
2026-11-08 01:45:18 +08:00
6 changed files with 2075 additions and 20 deletions

No files matched your search

+1
View File
@@ -6,5 +6,6 @@ hf-cache/
piper-models/
ai-models/
waifu2x/
face-models/
*.log
.venv-hf/
+4 -1
View File
@@ -7,13 +7,16 @@ RUN apt-get update \
# models are pre-downloaded on the host (build env has no internet)
RUN pip install --no-cache-dir piper-tts faster-whisper
RUN pip install --no-cache-dir -i https://pypi.tuna.tsinghua.edu.cn/simple "rembg[cpu]"
# AI 换脸: insightface(纯Python wheel 免编译) + buffalo_l人脸检测 + inswapper_128换脸模型(宿主已预置)
RUN pip install --no-cache-dir -i https://pypi.tuna.tsinghua.edu.cn/simple insightface
COPY hf-cache /root/.cache/huggingface
COPY face-models /app/face-models
COPY piper-models /app/piper-models
# AI 图片: u2net 抠图模型(预下载) + waifu2x-ncnn-vulkan 无损放大(CPU)
COPY ai-models/u2net.onnx /root/.u2net/u2net.onnx
COPY waifu2x/waifu2x-ncnn-vulkan-20220728-ubuntu /app/waifu2x
WORKDIR /app
COPY server.py video_ops.py audio_ops.py .
COPY server.py video_ops.py audio_ops.py mcp_ops.py .
ENV HF_HOME=/root/.cache/huggingface
EXPOSE 8091
CMD ["python", "server.py"]
+152
View File
@@ -0,0 +1,152 @@
# it-tools-relay
IT-Tools 的自建后端中继服务(Python 标准库 `http.server`,**监听 8091**,无第三方框架依赖)。为 IT-Tools 前端提供:
- **翻译代理** `GET /translate` —— 转发 Google Translate(走 `HTTPS_PROXY` 出网,解决国内不通)
- **授权校验** `GET /check` —— 供 nginx `auth_request` 调用,卡密授权 / 试用窗口判定(网络故障 fail-open,不锁死付费用户)
- **AI 生图额度** `POST /ai/quota`(前端经 `/relay/ai/quota`,带 `model` 返回上游真实配额 `upstream/upstream_daily/upstream_remaining/upstream_note`)—— **两级真实限额**:
- 机器级:未授权用内置渠道每日 `DAILY_FREE_LIMIT` 次(默认 10,北京时间 0 点重置,`daily_gen.json` 落盘),**生成成功才扣次**,**自带提供商/KEY 生成不计次**;
- 上游共享池(**已授权同样受保护**——内置模型上游是站主免费额度,不存在无限次):`flux*`/`dall-e-3` 走 Cloudflare Workers AI,**官方 10,000 Neurons/天 ÷ 57.6 Neurons/张(1024×1024/4 步)≈ 173 张/天**(`CF_DAILY_LIMIT` 默认 173,北京时间约 08:00 重置,`daily_gen_cf.json` 全站计数);`pollinations-*` 走 Pollinations(API Key 预算制,无固定日限,上游错误透传);
- 额度用尽生图返回 403(含官方配额出处文案)并引导配置自己的 KEY
- **卡密激活** `POST /activate` —— 代理 CardAuth 验卡,`CARD_AUTH_KEY` 只留在容器内
- **授权中心 hub** `GET /hub/announcements`(拉项目公告,服务端双保险过滤 `project_id`)+ `POST /hub/report`(安装登记 + 心跳在线统计,`X-Api-Key`/`X-Project-Id=6` 只存在服务端;**先心跳后 check-update**——实测 CardAuth heartbeat 会清空 `client_version/device_info`,check-update 放最后保证版本号落库)
- 另有大量 AI 对话/生图、TTS/ASR、视频、格式转换、网速测速、IP 查询等接口(`server.py`,约 3700 行)
Docker 镜像内置:calibre(`ebook-convert`)、ffmpeg、Piper(本地 TTS)、faster-whisper(本地 ASR)、rembg(抠图)、waifu2x(无损放大)、中文回退字体。模型文件(`hf-cache/`、`piper-models/`、`ai-models/`、`waifu2x/`)已预下载到构建上下文,**构建不需要联网**。
镜像也可直接拉取:`192.168.68.19:3200/jinghui/it-tools-relay:latest`(Gitea Container Registry,免登录)。
## 环境变量(`.env`)
```bash
cat > .env <<'EOF'
# CardAuth 授权中心(/check、/activate 用)
CARD_AUTH_KEY=your-cardauth-project-key
AUTH_BASE=https://auth.88531.cn/api
AUTH_USER=admin
AUTH_PASS=your-auth-pass
PROJECT_NAME=IT-Tools
PROJECT_ID=6
PROJECT_ALIASES=IT-Tools,IT-TOOLS-PRO
# IT-Tools 前端接入的中继地址(前端调用方填,非本容器变量)
# 中继监听 8091
# 管理员 / 人机验证
DEFAULT_ADMIN_USER=admin
DEFAULT_ADMIN_PW=change-me
ADMIN_TOKEN=
TURNSTILE_SECRET=
# AI 网关(可选,/ai/* 接口用)
NEWAPI_URL=https://your-newapi-host/v1/chat/completions
NEWAPI_KEY=sk-xxx
NEWAPI_MODEL=qwen3.8-flash
# AI 生图内置免费额度(可选)
DAILY_FREE_LIMIT=10 # 未授权机器每日次数(北京 0 点重置)
CF_DAILY_LIMIT=173 # Cloudflare 共享池张数/天(官方 10,000 Neurons ÷ 57.6/张)
CF_DAILY_FILE=/app/data/daily_gen_cf.json
# 出网代理(翻译等走 Google 的接口用,可选)
HTTPS_PROXY=http://host.docker.internal:7890
RELAY_TIMEOUT=25
# 上传限制(MB)
MAX_UPLOAD_MB=50
EOF
```
## 方式一:docker run
```bash
docker build -t it-tools-relay .
docker run -d --name it-tools-relay --restart always \
--network ittools-net -p 8091:8091 --env-file .env \
-e DEFAULT_HOST_ROOT=/vol3/1000/HD3/docker/it-tools-relay/data \
-e HTTPS_PROXY=http://host.docker.internal:7890 \
-e HTTP_PROXY=http://host.docker.internal:7890 \
-e NO_PROXY=localhost,127.0.0.1,192.168.68.19 \
--add-host host.docker.internal:host-gateway \
--cap-add NET_ADMIN \
-v /:/hostfs \
-v /vol3/1000/HD3/docker/it-tools-relay/data:/app/data \
-v /vol3/1000/HD3/docker/it-tools-relay/data/config.json:/vol3/1000/HD3/docker/it-tools-relay/data/config.json \
it-tools-relay
```
已有镜像时可省去构建:`docker run ... 192.168.68.19:3200/jinghui/it-tools-relay:latest`。
数据(试用记录、用量库、用户库、news.json)持久化在目录 `data/`。要被 IT-Tools 的 nginx 按容器名反代,需加 `--network ittools-net`(`docker network create ittools-net`)。
注意事项(缺一不可):
- `--add-host host.docker.internal:host-gateway` 必须有,代理与宿主服务访问依赖该解析,缺失时境外 RSS 抓取报 `Network unreachable`;
- `HTTPS_PROXY/HTTP_PROXY` 指向宿主 Mihomo(BBC 等境外源直连不可达),`NO_PROXY` 必须包含内网地址(NewAPI/OCR/授权中心),否则内网请求被绕进代理;
- 国际新闻走代理抓取,改动代理配置后删除 `data/news.json` 再访问一次 `/news` 即可强制重抓。
## 方式二:Docker Compose 部署
本仓库根目录 `docker-compose.yml`(含全部参数):
```yaml
services:
it-tools-relay:
image: 192.168.68.19:3200/jinghui/it-tools-relay:latest
container_name: it-tools-relay
restart: always
ports:
- "8091:8091"
env_file:
- .env
environment:
# 宿主数据目录(/hostfs、宿主路径访问类接口用)
- DEFAULT_HOST_ROOT=/vol3/1000/HD3/docker/it-tools-relay/data
# 容器出网走宿主 Mihomo 代理(BBC RSS 等境外源直连不可达)
- HTTPS_PROXY=http://host.docker.internal:7890
- HTTP_PROXY=http://host.docker.internal:7890
# 内网服务(NewAPI/OCR/授权中心)直连,不走代理
- NO_PROXY=localhost,127.0.0.1,192.168.68.19
volumes:
# 数据持久化:试用记录 / 用量库 / 用户库 / news.json
- ./data:/app/data
# 宿主全路径(run 段同款):缺失则 DATA_DIR 漂移到容器易失层,重建后用户库/密钥全丢
- /:/hostfs
# 存储根配置必须持久:不挂载则落在容器易失层,重建容器后 storage_root 丢失
# → DATA_DIR 漂移到易失目录 → 用户库/密钥/上传全丢
- ./data/config.json:/vol3/1000/HD3/docker/it-tools-relay/data/config.json
cap_add:
- NET_ADMIN
extra_hosts:
# 缺失会导致境外 RSS 抓取 Network unreachable
- "host.docker.internal:host-gateway"
networks:
- ittools-net
networks:
# 接入既有 ittools-net 供 it-tools nginx 反代;external=true 防止重建同名网络
ittools-net:
external: true
```
```bash
git clone http://192.168.68.19:3200/jinghui/it-tools-relay.git
cd it-tools-relay
cat > .env # 按上表内容创建 .env
docker compose up -d --build
docker compose ps # it-tools-relay 为 running 即就绪
curl -s http://127.0.0.1:8091/auth-status # 返回 JSON 即服务正常
```
只重建代码(模型目录已缓存):`docker compose up -d --build it-tools-relay`。
## 中文提示词自动转英文(2026-11-13)
`_handle_gen_image` / `_handle_edit_image` 发起生成前经 `_translate_prompt()`:提示词含中文时用 `IMG_PROMPT_MODEL`(默认 `mimo-v2.6-flash`,走 NEWAPI_URL + NEWAPI_KEY)转成高质量英文生图提示词再发上游(Flux/SDXL 系对英文理解最好);进程内缓存 300 条;翻译失败/超时/结果仍含中文一律回退原文,**绝不阻断生图**;纯英文提示词原样透传。实际发送的英文随响应 `prompt_en` 字段返回(前端结果图操作行显示「🌐 已自动转英文发送(悬停查看)」);生成历史仍存用户原文。
## 其他镜像变体
| 文件 | 用途 |
|---|---|
| `Dockerfile` | 主镜像(完整模型 + AI 接口) |
| `Dockerfile.patch` | `FROM it-tools-relay:latest`,只覆盖 `server.py` / `video_ops.py` / `audio_ops.py` 的热更镜像(构建秒级) |
| `Dockerfile.lt` | `FROM it-tools-relay:se-patch`,LibreTranslate 相关补丁,需 `docker/lt` 目录的翻译栈配合(见 it-tools-pro 仓库) |
+39
View File
@@ -0,0 +1,39 @@
services:
it-tools-relay:
image: 192.168.68.19:3200/jinghui/it-tools-relay:latest
container_name: it-tools-relay
restart: always
ports:
- "8091:8091"
env_file:
- .env
environment:
# 宿主数据目录(/hostfs、宿主路径访问类接口用)
- DEFAULT_HOST_ROOT=/vol3/1000/HD3/docker/it-tools-relay/data
# 容器出网走宿主 Mihomo 代理(BBC RSS 等境外源直连不可达,必须走代理)
- HTTPS_PROXY=http://host.docker.internal:7890
- HTTP_PROXY=http://host.docker.internal:7890
# 内网服务(NewAPI/OCR/授权中心)直连,不走代理
- NO_PROXY=localhost,127.0.0.1,192.168.68.19
volumes:
# 数据持久化:试用记录 / 用量库 / 用户库 / news.json
- ./data:/app/data
# 宿主全路径(canonical run line 同款):_load_storage_root 经 /hostfs 解析 config.json,
# 缺失则 DATA_DIR 漂移到容器易失 /vol3/... 层 → 重建容器后用户库/密钥全丢
- /:/hostfs
# 存储根配置必须持久:不挂载则落在容器易失层,重建容器后 storage_root 丢失
# → DATA_DIR 漂移到易失目录 → 用户库/密钥/上传全丢
- ./data/config.json:/vol3/1000/HD3/docker/it-tools-relay/data/config.json
cap_add:
- NET_ADMIN
extra_hosts:
# 代理/宿主服务访问依赖此解析(缺失会导致出网 Network unreachable)
- "host.docker.internal:host-gateway"
networks:
- ittools-net
networks:
# 必须接入既有 ittools-net,供 it-tools 的 nginx 按容器名反代;
# 已存在则必须 external=true,否则 compose 会重建同名网络导致孤立
ittools-net:
external: true
+744
View File
@@ -0,0 +1,744 @@
"""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)
+1135 -19
View File
File diff suppressed because it is too large. Load diff