Author SHA1 Message Date
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
5 changed files with 1417 additions and 7 deletions

No files matched your search

+1 -1
View File
@@ -13,7 +13,7 @@ COPY piper-models /app/piper-models
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"]
+132
View File
@@ -0,0 +1,132 @@
# it-tools-relay
IT-Tools 的自建后端中继服务(Python 标准库 `http.server`,**监听 8091**,无第三方框架依赖)。为 IT-Tools 前端提供:
- **翻译代理** `GET /translate` —— 转发 Google Translate(走 `HTTPS_PROXY` 出网,解决国内不通)
- **授权校验** `GET /check` —— 供 nginx `auth_request` 调用,卡密授权 / 试用窗口判定(网络故障 fail-open,不锁死付费用户)
- **卡密激活** `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
# 出网代理(翻译等走 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 /vol3/1000/HD3/docker/it-tools-relay/data:/app/data \
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
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`。
## 其他镜像变体
| 文件 | 用途 |
|---|---|
| `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 仓库) |
+36
View File
@@ -0,0 +1,36 @@
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
# 存储根配置必须持久:_load_storage_root() 读 DEFAULT_HOST_ROOT 容器路径下的 config.json,
# 不挂载则落在容器易失层,重建容器后 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)
+504 -6
View File
@@ -32,6 +32,8 @@ import zipfile
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from urllib import parse, request
import mcp_ops
UPSTREAM = "https://translate.googleapis.com/translate_a/single"
PROXY = os.environ.get("HTTPS_PROXY") or os.environ.get("https_proxy") or ""
TIMEOUT = float(os.environ.get("RELAY_TIMEOUT", "25"))
@@ -907,6 +909,80 @@ def log_usage(machine: str, tool: str):
pass
# ---- 前端工具使用上报(未登录访客也统计):10 分钟同机同工具去重 + 每 IP 限流防刷 ----
_USE_SEEN: dict = {} # "<machine|ip>|<tool>" -> last report ts
_USE_IP: dict = {} # ip -> [recent ts...]
_USE_LOCK = threading.Lock()
def usage_track(payload: dict, handler) -> tuple:
"""POST /usage:任意访客(含未登录)上报工具使用,落 usage.db。
10 分钟内同一机器+同一工具只计一次(防刷新刷量);每 IP 10 分钟上限 300 条。"""
tool = str(payload.get("tool") or "").strip()
if not tool or len(tool) > 64 or not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9\-_.]*", tool):
return 400, {"code": 400, "message": "无效 tool"}
machine = str(payload.get("machine_id") or "").strip()
if machine and not MACHINE_RE.match(machine):
machine = ""
try:
ip = (handler.headers.get("X-Real-IP") or "").strip() or handler.client_address[0]
except Exception:
ip = ""
now = time.time()
key = f"{machine or ip}|{tool}"
with _USE_LOCK:
if len(_USE_SEEN) > 20000: # 修剪过期键,防内存膨胀
for k in [k for k, t in _USE_SEEN.items() if now - t >= 600]:
_USE_SEEN.pop(k, None)
last = _USE_SEEN.get(key)
if last is not None and now - last < 600:
return 200, {"code": 200, "message": "ok", "data": {"dup": 1}}
recent = [t for t in _USE_IP.get(ip, []) if now - t < 600]
if len(recent) >= 300:
_USE_IP[ip] = recent
return 200, {"code": 200, "message": "ok", "data": {"capped": 1}}
recent.append(now)
_USE_IP[ip] = recent
_USE_SEEN[key] = now
log_usage(machine, tool)
return 200, {"code": 200, "message": "ok", "data": {"ok": 1}}
# ---- 在线统计:仅未登录访客,前端停留满 1 分钟才开始心跳 ----
ONLINE_WINDOW = 90.0 # 心跳每 30s 一次(后台标签被节流为 60s),超 90s 无心跳判离线
_ONLINE: dict = {} # machine_id -> 最近心跳时间戳(进程内存)
_ONLINE_LOCK = threading.Lock()
def online_beat(payload: dict) -> tuple:
"""POST /online:访客在线心跳。
- guest=true(未登录)→ 记为在线;guest=false(已登录)→ 移出统计。
- 「停留超过 1 分钟才算在线」由前端控制:打开满 60s 才发首次心跳。
"""
machine = str(payload.get("machine_id") or "").strip()
if not machine or not MACHINE_RE.match(machine):
return 400, {"code": 400, "message": "无效 machine_id"}
guest = bool(payload.get("guest"))
now = time.time()
with _ONLINE_LOCK:
if guest:
_ONLINE[machine] = now
else:
_ONLINE.pop(machine, None) # 登录用户不统计
if len(_ONLINE) > 5000: # 防内存膨胀:修剪过期
for k in [k for k, t in _ONLINE.items() if now - t > ONLINE_WINDOW]:
_ONLINE.pop(k, None)
count = sum(1 for t in _ONLINE.values() if now - t <= ONLINE_WINDOW)
return 200, {"code": 200, "message": "ok", "data": {"online": count}}
def online_count() -> int:
now = time.time()
with _ONLINE_LOCK:
return sum(1 for t in _ONLINE.values() if now - t <= ONLINE_WINDOW)
def _dir_size(path: str) -> int:
total = 0
for root, _dirs, files in os.walk(path):
@@ -1196,6 +1272,28 @@ def admin_api(method: str, sub: str, payload: dict, handler):
_save_reco(clean)
return 200, {"code": 200, "message": "ok"}
# ---------- 站内留言反馈(管理端查看/改状态/删除) ----------
if method == "GET" and sub == "/feedback":
items = sorted(_load_feedback(), key=lambda x: float(x.get("ts") or 0), reverse=True)
return 200, {"code": 200, "message": "ok", "data": items}
if method == "POST" and sub == "/feedback":
fid = str(payload.get("id") or "")
if not fid:
return 400, {"code": 400, "message": "缺少留言 id"}
with FEEDBACK_LOCK:
items = _load_feedback()
hit = next((it for it in items if it.get("id") == fid), None)
if not hit:
return 404, {"code": 404, "message": "留言不存在"}
if str(payload.get("action") or "") == "delete":
items = [it for it in items if it.get("id") != fid]
else:
status = str(payload.get("status") or "new")
hit["status"] = status if status in ("new", "replied", "done") else "new"
_save_feedback(items)
return 200, {"code": 200, "message": "ok"}
if method == "GET" and sub == "/storage":
total = _dir_size(USERS_ROOT) if os.path.isdir(USERS_ROOT) else 0
for extra in ("users.db", "usage.db", "trials.json"):
@@ -1279,14 +1377,23 @@ def admin_api(method: str, sub: str, payload: dict, handler):
by_tool = conn.execute("SELECT tool, COUNT(*) c FROM usage WHERE at>? GROUP BY tool ORDER BY c DESC LIMIT 30", (since,)).fetchall()
by_user = conn.execute("SELECT username, COUNT(*) c, MAX(at) last FROM usage WHERE at>? AND username!='' GROUP BY username ORDER BY c DESC LIMIT 50", (since,)).fetchall()
total = conn.execute("SELECT COUNT(*) FROM usage WHERE at>?", (since,)).fetchone()[0]
# 未登录访客(username 为空)聚合:访客的功能使用也统计并展示
g = conn.execute("SELECT COUNT(*) c, MAX(at) last FROM usage WHERE at>? AND username=''", (since,)).fetchone()
conn.close()
return 200, {"code": 200, "message": "ok", "data": {
"days": days,
"total": total,
"by_tool": [{"tool": t, "count": c} for t, c in by_tool],
"by_user": [{"username": u, "count": c, "last": int(l or 0)} for u, c, l in by_user],
"guest": {"count": int(g[0] or 0), "last": int(g[1] or 0)},
"online": online_count(),
}}
if method == "GET" and sub == "/mcp-usage":
qs = parse.parse_qs(parse.urlparse(handler.path).query)
days = _int_str((qs.get("days") or ["7"])[0], 1, 365, 7)
return 200, {"code": 200, "message": "ok", "data": mcp_ops.mcp_usage_query(days)}
return 404, {"code": 404, "message": "unknown admin api"}
@@ -1294,11 +1401,282 @@ def _req_machine(handler):
return handler.headers.get("X-Machine-Id", "") if handler else ""
# ---- 本地图片验证码(替代 Cloudflare Turnstile:不依赖外网,服务端出图) ----
try:
from PIL import Image, ImageDraw, ImageFont
_HAS_PIL = True
except Exception: # pragma: no cover
_HAS_PIL = False
CAPTCHA_TTL = 300 # 验证码有效期(秒)
_CAPTCHA_MAX = 5000 # 内存上限(防撑爆)
_CAPTCHAS = {} # id -> (code, expire_ts),单次核销
_CAPTCHA_LOCK = threading.Lock()
_CAPTCHA_CHARS = "ABCDEFGHJKMNPQRSTUVWXYZ23456789" # 去掉易混字符 0/O/1/I/L
def _gen_captcha():
"""返回 (captcha_id, png_base64)。4 位干扰码,5 分钟过期,取用即销毁。"""
import base64
import random
import uuid
code = "".join(random.choice(_CAPTCHA_CHARS) for _ in range(4))
cid = uuid.uuid4().hex
w, h = 148, 52
img = Image.new("RGB", (w, h), (247, 248, 251))
d = ImageDraw.Draw(img)
try:
font = ImageFont.load_default(size=36)
except TypeError: # pragma: no cover
font = ImageFont.load_default()
# 干扰线 + 噪点
for _ in range(7):
d.line([random.randrange(w), random.randrange(h),
random.randrange(w), random.randrange(h)],
fill=(random.randint(160, 210), random.randint(160, 210), random.randint(160, 210)),
width=1)
for _ in range(60):
d.point((random.randrange(w), random.randrange(h)),
fill=(random.randint(150, 220), random.randint(150, 220), random.randint(150, 220)))
# 逐字带抖动绘制
x = 14
for ch in code:
d.text((x, 6 + random.randint(-4, 4)), ch, font=font,
fill=(random.randint(10, 90), random.randint(10, 90), random.randint(10, 90)))
x += 33
buf = io.BytesIO()
img.save(buf, format="PNG")
now = time.time()
with _CAPTCHA_LOCK:
for k in [k for k, v in _CAPTCHAS.items() if v[1] < now]:
_CAPTCHAS.pop(k, None)
while len(_CAPTCHAS) >= _CAPTCHA_MAX:
_CAPTCHAS.pop(next(iter(_CAPTCHAS)), None)
_CAPTCHAS[cid] = (code, now + CAPTCHA_TTL)
return cid, base64.b64encode(buf.getvalue()).decode()
def verify_captcha(payload) -> bool:
"""核销 captcha_id + captcha_code(单次有效,大小写不敏感)。"""
cid = str(payload.get("captcha_id") or "")
got = str(payload.get("captcha_code") or "").strip().upper()
if not cid or not got:
return False
with _CAPTCHA_LOCK:
entry = _CAPTCHAS.pop(cid, None) # 无论对错都销毁,防爆破
if not entry:
return False
stored, exp = entry
if time.time() > exp:
return False
import secrets as _secrets
return _secrets.compare_digest(stored, got)
# ============ 站内留言反馈(独立于卡密/授权系统,任何人可用) ============
# ---- CardAuth hub 接入(项目 6):在线统计上报 + 公告推送,失败开放(不可达不影响站点) ----
HUB_TIMEOUT = 8
def hub_announcements(limit: int = 20) -> tuple[int, dict]:
"""GET /hub/announcements — 服务端拉本项目公告,双保险过滤 project_id。"""
try:
res = _get_json(
f"/public/announcements?target=client&project_id={PROJECT_ID}&limit={max(1, min(int(limit), 50))}",
{}, timeout=HUB_TIMEOUT)
except Exception as exc: # noqa: BLE001
print(f"[hub] announcements failed: {exc}", flush=True)
return 503, {"code": 503, "message": "公告服务暂不可用",
"data": {"list": [], "popup": []}}
data = (res or {}).get("data") or {}
def mine(arr) -> list:
out = []
for a in arr or []:
if not isinstance(a, dict):
continue
pid = a.get("project_id")
if pid in (None, "", 0) or str(pid) == str(PROJECT_ID):
out.append(a)
return out
return 200, {"code": 200, "message": "ok",
"data": {"list": mine(data.get("list")), "popup": mine(data.get("popup"))}}
def hub_report(payload: dict) -> tuple[int, dict]:
"""POST /hub/report {machine_id, client_version, device_info}
— 安装登记(安装统计)+ 心跳(在线统计),顺带返回版本推送信息。"""
machine = str(payload.get("machine_id") or "")
version = str(payload.get("client_version") or "0")[:40]
device = str(payload.get("device_info") or "")[:200] or "web"
if not MACHINE_RE.match(machine):
return 400, {"code": 400, "message": "机器码格式错误"}
if not (CARD_AUTH_KEY and PROJECT_ID):
return 503, {"code": 503, "message": "授权中心未配置"}
hdr = {"X-Api-Key": CARD_AUTH_KEY, "X-Project-Id": str(PROJECT_ID)}
out: dict = {"install_id": None, "latest_version": "",
"update_available": False, "update_required": False,
"download_url": None, "changelog": None, "online": False}
# 心跳必须在 check-update 之前:实测 CardAuth heartbeat 会把
# client_version/device_info 清空,check-update 放最后确保版本号落库
try:
hb = _post_json("/public/installations/heartbeat", {"machine_id": machine},
hdr, timeout=HUB_TIMEOUT)
out["online"] = (hb or {}).get("code") == 200
except Exception as exc: # noqa: BLE001
print(f"[hub] heartbeat failed: {exc}", flush=True)
try:
res = _post_json("/public/installations/check-update",
{"machine_id": machine, "client_version": version,
"device_info": device}, hdr, timeout=HUB_TIMEOUT)
d = (res or {}).get("data") or {}
out.update({
"install_id": d.get("install_id"),
"latest_version": d.get("latest_version") or "",
"update_available": bool(d.get("update_available")),
"update_required": bool(d.get("update_required")),
"download_url": d.get("download_url"),
"changelog": d.get("changelog"),
})
except Exception as exc: # noqa: BLE001
print(f"[hub] check-update failed: {exc}", flush=True)
return 503, {"code": 503, "message": "授权中心暂不可用", "data": out}
return 200, {"code": 200, "message": "ok", "data": out}
# GET /feedback/captcha 图形验证码
# POST /feedback {type,content,contact,captcha_id,captcha_code}
FEEDBACK_FILE = os.path.join(DATA_DIR, "feedback.json")
FEEDBACK_TYPES = ("功能建议", "意见反馈")
FEEDBACK_WINDOW = 3600 # 同一 IP 两次提交的最小间隔(秒,1 小时)
FEEDBACK_MAX = 2000 # 存档上限,超出丢弃最旧
FEEDBACK_LOCK = threading.Lock()
def _load_feedback() -> list:
try:
with open(FEEDBACK_FILE, "r", encoding="utf-8") as fh:
data = json.load(fh)
return data if isinstance(data, list) else []
except Exception: # noqa: BLE001
return []
def _save_feedback(items: list) -> None:
tmp = FEEDBACK_FILE + ".tmp"
with open(tmp, "w", encoding="utf-8") as fh:
json.dump(items, fh, ensure_ascii=False, indent=1)
os.replace(tmp, FEEDBACK_FILE)
def _ip_is_public(value: str) -> bool:
try:
import ipaddress
ip = ipaddress.ip_address(value)
except Exception: # noqa: BLE001
return False
return not (
ip.is_private or ip.is_loopback or ip.is_link_local
or ip.is_reserved or ip.is_multicast
)
def _real_client_ip(handler) -> str:
"""取真实客户端 IP(限频用)。
链路:浏览器 → nps/frp 隧道(注入真实 IP 的 X-Forwarded-For)
→ nginx(再追加 $remote_addr = 隧道/内网地址)→ relay。
因此 XFF 从右往左取第一个公网地址:先跳过隧道与内网地址,
客户端在链路最左侧伪造的头也不会被采信。
"""
raw = handler.headers.get("X-Forwarded-For") or handler.headers.get("X-Real-IP") or ""
parts = [p.strip() for p in raw.split(",") if p.strip()]
for part in reversed(parts):
if _ip_is_public(part):
return part
if parts:
return parts[0]
try:
return handler.client_address[0] or "unknown"
except Exception: # noqa: BLE001
return "unknown"
def feedback_api(method: str, payload: dict, handler) -> tuple:
"""公开留言接口:GET 出图形验证码,POST 提交留言。"""
if method == "GET":
if not _HAS_PIL:
return 503, {"code": 503, "message": "验证码组件未就绪,请稍后再试"}
cid, img_b64 = _gen_captcha()
return 200, {"code": 200, "message": "ok", "data": {"id": cid, "img": img_b64}}
# POST:先人机验证,再业务校验,最后同 IP 1 小时限频
if not verify_captcha(payload):
return 403, {"code": 403, "message": "人机验证失败,请刷新验证码后重试"}
ftype = str(payload.get("type") or "").strip()
if ftype not in FEEDBACK_TYPES:
return 400, {"code": 400, "message": "请选择留言类型:功能建议 / 意见反馈"}
content = str(payload.get("content") or "").replace("\r\n", "\n").strip()
if not content:
return 400, {"code": 400, "message": "请填写留言内容"}
if len(content) > 1000:
return 400, {"code": 400, "message": "留言内容最多 1000 字"}
contact = str(payload.get("contact") or "").strip()
if len(contact) > 64:
return 400, {"code": 400, "message": "联系方式最多 64 字"}
if any(ord(c) < 32 for c in contact):
return 400, {"code": 400, "message": "联系方式含非法字符"}
ip = _real_client_ip(handler)
now = time.time()
with FEEDBACK_LOCK:
items = _load_feedback()
last_ts = 0.0
for it in reversed(items):
if it.get("ip") == ip:
try:
last_ts = float(it.get("ts") or 0)
except Exception: # noqa: BLE001
last_ts = 0.0
break
if now - last_ts < FEEDBACK_WINDOW:
wait_min = max(int((FEEDBACK_WINDOW - (now - last_ts)) / 60), 1)
return 429, {"code": 429, "message": f"同一 IP 一小时内只能提交一次,请 {wait_min} 分钟后再试"}
items.append({
"id": f"{int(now)}-{secrets.token_hex(4)}",
"ts": int(now),
"ip": ip,
"type": ftype,
"content": content,
"contact": contact,
"status": "new",
})
if len(items) > FEEDBACK_MAX:
items = items[-FEEDBACK_MAX:]
_save_feedback(items)
print(f"[feedback] new from {ip} [{ftype}] {len(content)} chars", flush=True)
return 200, {"code": 200, "message": "ok"}
def user_api(method, sub, payload, handler):
"""returns (status, body_dict)"""
if method == "GET" and sub == "/captcha":
if not _HAS_PIL:
return 503, {"code": 503, "message": "验证码组件未就绪"}
cid, img_b64 = _gen_captcha()
return 200, {"code": 200, "message": "ok", "data": {"id": cid, "img": img_b64}}
if method == "POST" and sub == "/register":
if not verify_turnstile(str(payload.get("cf_token") or "")):
return 403, {"code": 403, "message": "人机验证失败,请完成验证后重试"}
if not verify_captcha(payload):
return 403, {"code": 403, "message": "人机验证失败,请刷新验证码后重试"}
username = str(payload.get("username") or "").strip()
password = str(payload.get("password") or "")
if not USER_NAME_RE.match(username):
@@ -1308,7 +1686,7 @@ def user_api(method, sub, payload, handler):
conn = _db()
try:
salt = secrets.token_hex(16)
conn.execute("INSERT INTO users VALUES (?,?,?,?)", (username, salt, _hash_pw(password, salt), time.time()))
conn.execute("INSERT INTO users (username, salt, pw_hash, created) VALUES (?,?,?,?)", (username, salt, _hash_pw(password, salt), time.time()))
conn.commit()
except sqlite3.IntegrityError:
return 409, {"code": 409, "message": "用户名已被注册"}
@@ -1321,10 +1699,10 @@ def user_api(method, sub, payload, handler):
if method == "POST" and sub == "/login":
username = str(payload.get("username") or "").strip()
password = str(payload.get("password") or "")
# admin accounts skip the human check (admin panel login has no Turnstile widget)
# admin accounts skip the human check (admin panel login has no captcha widget)
role, _disabled = _user_attr(username)
if role != "admin" and not verify_turnstile(str(payload.get("cf_token") or "")):
return 403, {"code": 403, "message": "人机验证失败,请完成验证后重试"}
if role != "admin" and not verify_captcha(payload):
return 403, {"code": 403, "message": "人机验证失败,请刷新验证码后重试"}
conn = _db()
row = conn.execute("SELECT salt, pw_hash FROM users WHERE username=?", (username,)).fetchone()
conn.close()
@@ -1572,6 +1950,23 @@ class Handler(BaseHTTPRequestHandler):
if parsed.path == "/ai/models":
self._handle_ai_models()
return
if parsed.path == "/mcp":
info = {"code": 200,
"message": "IT-TOOLS-PRO MCP endpoint (Streamable HTTP / JSON-RPC 2.0)",
"protocol": "mcp",
"endpoint": "/mcp",
"auth": "Authorization: Bearer <MCP令牌>(站内「MCP 接入」页购买卡密后生成)",
"tools": [t["name"] for t in mcp_ops.TOOLS]}
self._reply(200, json.dumps(info, ensure_ascii=False).encode("utf-8"), "application/json")
return
if parsed.path == "/mcp/tokens":
qs = parse.parse_qs(parsed.query)
status, body = mcp_ops.tokens_api("GET", {}, qs)
self._reply(status, json.dumps(body, ensure_ascii=False).encode("utf-8"), "application/json")
return
if parsed.path.startswith("/mcp/file/"):
mcp_ops.handle_get_file(self, parsed.path[len("/mcp/file/"):])
return
if parsed.path.startswith("/admin"):
self._handle_admin("GET")
return
@@ -1591,6 +1986,21 @@ class Handler(BaseHTTPRequestHandler):
self._reply(200, json.dumps(body, ensure_ascii=False).encode("utf-8"), "application/json")
return
if parsed.path == "/feedback/captcha":
status, body = feedback_api("GET", {}, self)
self._reply(status, json.dumps(body, ensure_ascii=False).encode("utf-8"), "application/json")
return
if parsed.path == "/hub/announcements":
qs = parse.parse_qs(parsed.query or "")
try:
limit = int((qs.get("limit") or ["20"])[0] or 20)
except ValueError:
limit = 20
status, body = hub_announcements(limit)
self._reply(status, json.dumps(body, ensure_ascii=False).encode("utf-8"), "application/json")
return
if parsed.path == "/reco":
items = [x for x in _load_reco() if x.get("enabled")][:24]
body = json.dumps({"code": 200, "message": "ok", "data": items}, ensure_ascii=False).encode("utf-8")
@@ -1677,6 +2087,16 @@ class Handler(BaseHTTPRequestHandler):
self._reply(200, json.dumps({"code": 200, "message": "ok", "data": data}, ensure_ascii=False).encode("utf-8"), "application/json")
return
# ---- 代理/VPN 判定(/ip-check?ip= 浏览器侧自己的公网 IP)----
if parsed.path == "/ip-check":
ipq = (parse.parse_qs(parsed.query or "").get("ip") or [""])[0].strip()
if not ipq or not _ip_valid(ipq):
self._reply(400, json.dumps({"code": 400, "message": "缺少或非法 ip 参数"}, ensure_ascii=False).encode("utf-8"), "application/json")
return
data = _ip_check(ipq)
self._reply(200, json.dumps({"code": 200, "message": "ok", "data": data}, ensure_ascii=False).encode("utf-8"), "application/json")
return
self._reply(404, b"not found")
# ---------- POST ----------
@@ -2465,6 +2885,35 @@ class Handler(BaseHTTPRequestHandler):
if parsed.path == "/speed":
self._handle_speed_post()
return
if parsed.path == "/feedback":
payload = self._read_payload()
status, body = feedback_api("POST", payload, self)
self._reply(status, json.dumps(body, ensure_ascii=False).encode("utf-8"), "application/json")
return
if parsed.path == "/hub/report":
payload = self._read_payload() or {}
status, body = hub_report(payload)
self._reply(status, json.dumps(body, ensure_ascii=False).encode("utf-8"), "application/json")
return
if parsed.path == "/usage":
payload = self._read_payload() or {}
status, body = usage_track(payload, self)
self._reply(status, json.dumps(body, ensure_ascii=False).encode("utf-8"), "application/json")
return
if parsed.path == "/online":
payload = self._read_payload() or {}
status, body = online_beat(payload)
self._reply(status, json.dumps(body, ensure_ascii=False).encode("utf-8"), "application/json")
return
if parsed.path == "/mcp":
status, body, ctype = mcp_ops.handle_post(self)
self._reply(status, body, ctype)
return
if parsed.path == "/mcp/tokens":
payload = self._read_payload() or {}
status, body = mcp_ops.tokens_api("POST", payload, {})
self._reply(status, json.dumps(body, ensure_ascii=False).encode("utf-8"), "application/json")
return
if parsed.path.startswith("/admin"):
self._handle_admin("POST")
return
@@ -3476,6 +3925,47 @@ def _ip_info(ip):
return info
# ---------- 代理/VPN 判定(proxycheck.io 免 key,内存缓存) ----------
_IPCHECK_CACHE = {}
def _ip_check(ip):
"""出口 IP 代理/VPN/数据中心判定:proxycheck.io + 内存缓存;内网地址不外查。
返回 {ip, lan, proxy(bool|None), type, provider, hostname, asn};
查询失败 proxy=None(前端降级为“无法判定”)。"""
ip = (ip or "").strip()
if not ip or not _ip_valid(ip):
return None
import ipaddress
addr = ipaddress.ip_address(ip)
lan = bool(addr.is_private or addr.is_loopback or addr.is_link_local)
cached = _IPCHECK_CACHE.get(ip)
if cached is not None:
return cached
out = {"ip": ip, "lan": lan, "proxy": None, "type": "", "provider": "", "hostname": "", "asn": ""}
if not lan:
try:
url = "http://proxycheck.io/v2/%s?vpn=1&asn=1" % ip
with request.urlopen(url, timeout=8) as resp:
d = json.loads(resp.read().decode("utf-8", "ignore"))
if d.get("status") == "ok":
rec = d.get(ip) or {}
out = {
"ip": ip, "lan": False,
"proxy": str(rec.get("proxy") or "").lower() == "yes",
"type": rec.get("type") or "",
"provider": rec.get("provider") or rec.get("organisation") or "",
"hostname": rec.get("hostname") or "",
"asn": rec.get("asn") or "",
}
except Exception:
pass
if len(_IPCHECK_CACHE) > 1500:
_IPCHECK_CACHE.clear()
_IPCHECK_CACHE[ip] = out
return out
def _tr_chunks(text: str, limit: int = 1200):
"""按行/长度切块,保留换行结构;返回 [(块文本, 块后是否接换行)]"""
lines = text.split("\n")
@@ -3766,5 +4256,13 @@ def _news_loop():
if __name__ == "__main__":
_ensure_admin()
mcp_ops.setup(
data_dir=DATA_DIR,
usage_db=USAGE_DB,
query_authorized=query_authorized,
account_ok=_account_license_ok,
machine_ok=lambda m: bool(MACHINE_RE.match(m)),
public_base=os.environ.get("MCP_PUBLIC_BASE", ""),
)
threading.Thread(target=_news_loop, daemon=True).start()
ThreadingHTTPServer(("0.0.0.0", 8091), Handler).serve_forever()