Steven
c194609193
CI / backend (push) Canceled after 0s
生产把应用挂在域名根、路由带 /api/v1 前缀，request.base_url 里没有前缀， 拼出来的地址少了这一段；本地被 Vite 的代理掩盖了。改成从 base_url 截站点根、 前缀一律取 settings.api_prefix，并补一条断言把这个差异钉住。
570 lines
19 KiB
Python
570 lines
19 KiB
Python
"""外部接入：微信（clawbot）发来的消息变成任务 / 知识。
|
||
|
||
## 一条消息是怎么变成事项的
|
||
|
||
微信里发一句话给机器人，clawbot 把消息 POST 到
|
||
|
||
POST /api/v1/integrations/clawbot/{token}
|
||
|
||
令牌在 URL 里，**不带登录态**：机器人不会登我们的账号，它只会照着配置好的
|
||
地址发。令牌是 32 字节随机串，库里只存 sha256。
|
||
|
||
正文按前缀决定去哪个池子：
|
||
|
||
知识：xxx / 笔记：xxx / note: xxx → 知识草稿
|
||
任务：xxx / todo: xxx → 任务（默认也是任务）
|
||
?、帮助、help → 回一段用法说明
|
||
|
||
首行是标题，其余行是正文。首行里的 `#标签` 会被摘出来挂到事项上
|
||
（标签是知识的主要检索入口，手机上敲#比打开网页加标签省事）。
|
||
|
||
## 为什么每条消息都留痕
|
||
|
||
微信会重推（网络抖动、机器人重启）。没有留痕就只能靠猜"那条任务到底进没进"。
|
||
`bot_message.external_id` 上有个部分唯一索引：同一个外部消息 id 第二次到达时
|
||
直接回上次的答案，不会变成两条任务。
|
||
|
||
## 安全边界
|
||
|
||
- 令牌错 → 9002（对外一律"通道不存在"，不区分"错令牌"和"这个工作区没接"）。
|
||
- 通道被停用 → 9003。
|
||
- 消息里不认人：机器人只知道"这是这个工作区的一条消息"，落库按通道创建者记账，
|
||
不会因为消息内容去猜是谁发的。
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import hashlib
|
||
import secrets
|
||
import uuid
|
||
from datetime import datetime, timezone
|
||
from typing import Annotated, Any
|
||
|
||
from fastapi import APIRouter, Body, Query, Request
|
||
from fastapi.responses import PlainTextResponse
|
||
from sqlalchemy import select
|
||
from sqlalchemy.exc import IntegrityError
|
||
|
||
from ..config import get_settings
|
||
from ..db import bind_tenant
|
||
from ..deps import AdminDep, SessionDep
|
||
from ..errors import AppError, ErrorCode
|
||
from ..models import Member, Workspace
|
||
from ..models_integrations import BotChannel, BotMessage
|
||
from ..models_knowledge import KnowledgeDoc
|
||
from ..models_task import Item
|
||
from ..schemas import ok
|
||
from .items import _log, _set_tags
|
||
|
||
webhook_router = APIRouter(prefix="/integrations", tags=["外部接入"])
|
||
admin_router = APIRouter(prefix="/workspaces", tags=["外部接入"])
|
||
|
||
# 标题在 item.title 上是 varchar(200)，留点余量给"…"之类的后缀。
|
||
MAX_TITLE = 180
|
||
MAX_BODY = 20000
|
||
|
||
KNOWLEDGE_PREFIXES = ("知识", "笔记", "note", "knowledge", "kb")
|
||
TASK_PREFIXES = ("任务", "待办", "todo", "task")
|
||
HELP_PREFIXES = ("?", "？", "帮助", "help", "用法")
|
||
|
||
HELP_TEXT = (
|
||
"发什么都能用，写法：\n"
|
||
"· 直接说 → 记成任务\n"
|
||
"· 知识：内容 → 记成知识草稿（也可以写「笔记：」）\n"
|
||
"· 任务：内容 → 明确记成任务\n"
|
||
"首行当标题，后面几行当正文；标题里带 #标签 会自动加上。"
|
||
)
|
||
|
||
|
||
def hash_token(token: str) -> str:
|
||
return hashlib.sha256(token.encode("utf-8")).hexdigest()
|
||
|
||
|
||
def new_token() -> str:
|
||
return secrets.token_urlsafe(32)
|
||
|
||
|
||
def _pick(data: dict[str, Any], *keys: str) -> str | None:
|
||
"""从任意形状的 payload 里挖字段（clawbot 的消息壳子没定死，宽松一点）。"""
|
||
for key in keys:
|
||
value = data.get(key)
|
||
if isinstance(value, str) and value.strip():
|
||
return value
|
||
if isinstance(value, dict):
|
||
nested = _pick(value, "text", "content", "body", "message")
|
||
if nested:
|
||
return nested
|
||
return None
|
||
|
||
|
||
def extract_text(payload: dict[str, Any]) -> str:
|
||
text = _pick(
|
||
payload,
|
||
"text",
|
||
"content",
|
||
"msg",
|
||
"message",
|
||
"query",
|
||
"body",
|
||
"data",
|
||
"payload",
|
||
)
|
||
return (text or "").strip()
|
||
|
||
|
||
def extract_external_id(payload: dict[str, Any]) -> str | None:
|
||
value = _pick(payload, "msg_id", "message_id", "msgid", "id", "uuid", "event_id")
|
||
return value[:128] if value else None
|
||
|
||
|
||
def extract_sender(payload: dict[str, Any]) -> str | None:
|
||
value = _pick(payload, "from", "sender", "from_user", "user", "uid", "sender_id")
|
||
return value[:128] if value else None
|
||
|
||
|
||
def split_command(text: str) -> tuple[str, str]:
|
||
"""返回 (kind, 去掉前缀后的正文)。"""
|
||
head, _, rest = text.partition("\n")
|
||
probe = head.strip().lower()
|
||
for prefix in HELP_PREFIXES:
|
||
if probe == prefix or probe.startswith(f"{prefix}:") or probe.startswith(f"{prefix}："):
|
||
return "help", rest
|
||
for prefix in KNOWLEDGE_PREFIXES:
|
||
for sep in (":", "：", " ", "\u3000"):
|
||
if probe.startswith(f"{prefix}{sep}"):
|
||
offset = len(prefix) + len(sep)
|
||
return "knowledge", (head.strip()[offset:] + ("\n" + rest if rest else "")).strip()
|
||
for prefix in TASK_PREFIXES:
|
||
for sep in (":", "：", " ", "\u3000"):
|
||
if probe.startswith(f"{prefix}{sep}"):
|
||
offset = len(prefix) + len(sep)
|
||
return "task", (head.strip()[offset:] + ("\n" + rest if rest else "")).strip()
|
||
return "task", text
|
||
|
||
|
||
def split_tags(body: str) -> tuple[str, list[str]]:
|
||
"""把 `#标签` 摘出来。只认行首和空白后的 #，免得把 "C#" 吃掉。"""
|
||
tags: list[str] = []
|
||
kept: list[str] = []
|
||
for line in body.splitlines():
|
||
words = line.split(" ")
|
||
rest: list[str] = []
|
||
for word in words:
|
||
if word.startswith("#") and len(word) > 1 and not word[1:].isdigit():
|
||
name = word[1:].strip("，,。.;；")
|
||
if name and name.lower() not in {t.lower() for t in tags}:
|
||
tags.append(name)
|
||
continue
|
||
rest.append(word)
|
||
kept.append(" ".join(rest).rstrip())
|
||
return "\n".join(kept).strip(), tags
|
||
|
||
|
||
def split_title(body: str) -> tuple[str, str]:
|
||
lines = body.splitlines()
|
||
if not lines:
|
||
return "", ""
|
||
title = lines[0].strip()
|
||
rest = "\n".join(lines[1:]).strip()
|
||
return title[:MAX_TITLE], rest[:MAX_BODY]
|
||
|
||
|
||
async def _creator_id(session: SessionDep, channel: BotChannel) -> uuid.UUID:
|
||
"""消息记在谁名下：通道创建者；人没了就退回工作区 owner。"""
|
||
if channel.created_by is not None:
|
||
row = await session.execute(
|
||
select(Member.id).where(
|
||
Member.workspace_id == channel.workspace_id,
|
||
Member.user_id == channel.created_by,
|
||
Member.status == "active",
|
||
)
|
||
)
|
||
if row.first() is not None:
|
||
return channel.created_by
|
||
workspace = await session.get(Workspace, channel.workspace_id)
|
||
if workspace is None: # 理论上不可能：FK 是 CASCADE
|
||
raise AppError(ErrorCode.BOT_TOKEN_INVALID, "接入通道不存在")
|
||
return workspace.owner_id
|
||
|
||
|
||
async def _create_task(
|
||
session: SessionDep,
|
||
*,
|
||
ws_id: uuid.UUID,
|
||
creator_id: uuid.UUID,
|
||
title: str,
|
||
body: str,
|
||
tags: list[str],
|
||
) -> Item:
|
||
item = Item(
|
||
workspace_id=ws_id,
|
||
kind="task",
|
||
title=title,
|
||
body_md=body,
|
||
status="inbox",
|
||
priority=0,
|
||
creator_id=creator_id,
|
||
)
|
||
session.add(item)
|
||
await session.flush()
|
||
if tags:
|
||
await _set_tags(session, ws_id, item, tags)
|
||
await _log(session, item, creator_id, "created", {"via": "wechat_clawbot"})
|
||
return item
|
||
|
||
|
||
async def _create_knowledge(
|
||
session: SessionDep,
|
||
*,
|
||
ws_id: uuid.UUID,
|
||
creator_id: uuid.UUID,
|
||
title: str,
|
||
body: str,
|
||
tags: list[str],
|
||
) -> Item:
|
||
item = Item(
|
||
workspace_id=ws_id,
|
||
kind="knowledge",
|
||
title=title,
|
||
body_md=body,
|
||
status="draft",
|
||
creator_id=creator_id,
|
||
)
|
||
session.add(item)
|
||
await session.flush()
|
||
doc = KnowledgeDoc(
|
||
item_id=item.id,
|
||
workspace_id=ws_id,
|
||
author_id=creator_id,
|
||
source_item_id=None,
|
||
source_kind="manual",
|
||
doc_type="note",
|
||
status_hint="draft",
|
||
generated_by="human",
|
||
)
|
||
session.add(doc)
|
||
await session.flush()
|
||
if tags:
|
||
await _set_tags(session, ws_id, item, tags)
|
||
await _log(session, item, creator_id, "knowledge_created", {"via": "wechat_clawbot"})
|
||
return item
|
||
|
||
|
||
def _link(request: Request, ws_id: uuid.UUID, item: Item) -> str:
|
||
base = str(request.base_url).rstrip("/")
|
||
# base_url 形如 http://host:8200/api/v1/，而页面在站点根上
|
||
base = base.split("/api/")[0]
|
||
if item.kind == "knowledge":
|
||
return f"{base}/w/{ws_id}/knowledge/{item.id}"
|
||
return f"{base}/w/{ws_id}?open={item.id}"
|
||
|
||
|
||
async def _channel_by_token(session: SessionDep, token: str) -> BotChannel:
|
||
from sqlalchemy import text as sql_text
|
||
|
||
# 策略要靠这个值才放行那一行，必须先设。
|
||
await session.execute(
|
||
sql_text("SELECT set_config('app.bot_token_hash', :h, true)"), {"h": hash_token(token)}
|
||
)
|
||
row = (
|
||
await session.execute(select(BotChannel).where(BotChannel.token_hash == hash_token(token)))
|
||
).scalar_one_or_none()
|
||
if row is None:
|
||
raise AppError(ErrorCode.BOT_TOKEN_INVALID, "接入通道不存在或令牌已失效")
|
||
return row
|
||
|
||
|
||
@webhook_router.get("/clawbot/{token}")
|
||
async def clawbot_verify(
|
||
token: str, session: SessionDep, echostr: str | None = Query(default=None)
|
||
):
|
||
"""clawbot 后台通常先 GET 一次确认地址是活的：有 echostr 就原样回。"""
|
||
channel = await _channel_by_token(session, token)
|
||
if channel.status != "active":
|
||
raise AppError(ErrorCode.BOT_DISABLED, "这个通道已停用")
|
||
if echostr is not None:
|
||
return PlainTextResponse(echostr)
|
||
return ok({"channel": channel.name, "status": channel.status})
|
||
|
||
|
||
@webhook_router.post("/clawbot/{token}")
|
||
async def clawbot_message(
|
||
token: str,
|
||
request: Request,
|
||
session: SessionDep,
|
||
payload: Annotated[dict[str, Any] | None, Body()] = None,
|
||
):
|
||
channel = await _channel_by_token(session, token)
|
||
if channel.status != "active":
|
||
raise AppError(ErrorCode.BOT_DISABLED, "这个通道已停用")
|
||
|
||
raw: dict[str, Any] = payload if isinstance(payload, dict) else {}
|
||
text = extract_text(raw)
|
||
external_id = extract_external_id(raw)
|
||
sender = extract_sender(raw)
|
||
|
||
await bind_tenant(session, channel.workspace_id, channel.created_by)
|
||
|
||
# 重推：同一个外部消息 id 再来一次，回上次那句，不再建第二条。
|
||
if external_id:
|
||
previous = (
|
||
await session.execute(
|
||
select(BotMessage).where(
|
||
BotMessage.channel_id == channel.id,
|
||
BotMessage.external_id == external_id,
|
||
)
|
||
)
|
||
).scalar_one_or_none()
|
||
if previous is not None:
|
||
channel.last_seen_at = datetime.now(timezone.utc)
|
||
return ok({"reply": previous.reply, "action": previous.action, "duplicate": True})
|
||
|
||
message = BotMessage(
|
||
workspace_id=channel.workspace_id,
|
||
channel_id=channel.id,
|
||
external_id=external_id,
|
||
sender=sender,
|
||
text=text[:MAX_BODY],
|
||
action="ignored",
|
||
reply="",
|
||
raw=raw if isinstance(raw, dict) else {"value": raw},
|
||
)
|
||
|
||
if not text:
|
||
message.action = "ignored"
|
||
message.reply = "没收到正文，只收到一个空壳。"
|
||
session.add(message)
|
||
return ok({"reply": message.reply, "action": "ignored"})
|
||
|
||
kind, body = split_command(text)
|
||
creator_id = await _creator_id(session, channel)
|
||
|
||
if kind == "help":
|
||
message.action = "help"
|
||
message.reply = HELP_TEXT
|
||
else:
|
||
body, tags = split_tags(body)
|
||
title, rest = split_title(body)
|
||
if not title:
|
||
message.action = "ignored"
|
||
message.reply = "只有标签没有内容，这条没记。"
|
||
elif kind == "knowledge":
|
||
item = await _create_knowledge(
|
||
session,
|
||
ws_id=channel.workspace_id,
|
||
creator_id=creator_id,
|
||
title=title,
|
||
body=rest,
|
||
tags=tags,
|
||
)
|
||
message.action = "knowledge"
|
||
message.item_id = item.id
|
||
link = _link(request, channel.workspace_id, item)
|
||
message.reply = f"已记成知识草稿：《{item.title}》。去核对：{link}"
|
||
else:
|
||
item = await _create_task(
|
||
session,
|
||
ws_id=channel.workspace_id,
|
||
creator_id=creator_id,
|
||
title=title,
|
||
body=rest,
|
||
tags=tags,
|
||
)
|
||
message.action = "task"
|
||
message.item_id = item.id
|
||
message.reply = (
|
||
f"已记成任务：《{item.title}》。打开：{_link(request, channel.workspace_id, item)}"
|
||
)
|
||
|
||
channel.last_seen_at = datetime.now(timezone.utc)
|
||
channel.last_error = None
|
||
try:
|
||
# 用 SAVEPOINT 兜住唯一索引冲突：另一个并发请求刚插了同一条消息，
|
||
# 这里只要认输回同一句就行，不能把整笔事务打挂。
|
||
async with session.begin_nested():
|
||
session.add(message)
|
||
await session.flush()
|
||
except IntegrityError:
|
||
if external_id:
|
||
previous = (
|
||
await session.execute(
|
||
select(BotMessage).where(
|
||
BotMessage.channel_id == channel.id,
|
||
BotMessage.external_id == external_id,
|
||
)
|
||
)
|
||
).scalar_one_or_none()
|
||
if previous is not None:
|
||
return ok({"reply": previous.reply, "action": previous.action, "duplicate": True})
|
||
raise AppError(ErrorCode.BOT_TOKEN_INVALID, "同一条消息重复到达，已忽略") from None
|
||
|
||
return ok({"reply": message.reply, "action": message.action, "duplicate": False})
|
||
|
||
|
||
# ── 工作区里的管理接口（登录 + admin 以上） ─────────────────────────────
|
||
|
||
|
||
def _channel_out(channel: BotChannel) -> dict[str, Any]:
|
||
return {
|
||
"id": str(channel.id),
|
||
"kind": channel.kind,
|
||
"name": channel.name,
|
||
"status": channel.status,
|
||
"created_by": str(channel.created_by) if channel.created_by else None,
|
||
"last_seen_at": channel.last_seen_at,
|
||
"last_error": channel.last_error,
|
||
"created_at": channel.created_at,
|
||
}
|
||
|
||
|
||
def _webhook_url(request: Request, token: str) -> str:
|
||
"""拼出机器人要打的那个地址。
|
||
|
||
不能直接用 `request.base_url`：生产上应用挂在域名根、路由带 `/api/v1` 前缀，
|
||
base_url 里没有前缀，拼出来的地址会 405（本地被 Vite 代理掩盖过这个差异）。
|
||
所以站点根从 base_url 里截，前缀一律取 `settings.api_prefix`。
|
||
"""
|
||
base = str(request.base_url).split("/api/")[0].rstrip("/")
|
||
return f"{base}{get_settings().api_prefix}/integrations/clawbot/{token}"
|
||
|
||
|
||
@admin_router.get("/{ws_id}/integrations")
|
||
async def list_integrations(ws_id: uuid.UUID, ctx: AdminDep, session: SessionDep):
|
||
rows = (
|
||
(
|
||
await session.execute(
|
||
select(BotChannel)
|
||
.where(BotChannel.workspace_id == ws_id)
|
||
.order_by(BotChannel.created_at.desc())
|
||
)
|
||
)
|
||
.scalars()
|
||
.all()
|
||
)
|
||
return ok({"items": [_channel_out(row) for row in rows]})
|
||
|
||
|
||
@admin_router.post("/{ws_id}/integrations")
|
||
async def create_integration(
|
||
ws_id: uuid.UUID,
|
||
ctx: AdminDep,
|
||
session: SessionDep,
|
||
request: Request,
|
||
body: Annotated[dict[str, Any] | None, Body()] = None,
|
||
):
|
||
name = str((body or {}).get("name") or "").strip()[:64] or "微信"
|
||
token = new_token()
|
||
channel = BotChannel(
|
||
workspace_id=ws_id,
|
||
kind="wechat_clawbot",
|
||
name=name,
|
||
token_hash=hash_token(token),
|
||
status="active",
|
||
created_by=ctx.user.id,
|
||
)
|
||
session.add(channel)
|
||
await session.flush()
|
||
return ok(
|
||
{
|
||
"channel": _channel_out(channel),
|
||
# 令牌只在这里出现一次，之后只能"重新生成"。
|
||
"token": token,
|
||
"webhook_url": _webhook_url(request, token),
|
||
}
|
||
)
|
||
|
||
|
||
@admin_router.patch("/{ws_id}/integrations/{channel_id}")
|
||
async def update_integration(
|
||
ws_id: uuid.UUID,
|
||
channel_id: uuid.UUID,
|
||
ctx: AdminDep,
|
||
session: SessionDep,
|
||
body: Annotated[dict[str, Any] | None, Body()] = None,
|
||
):
|
||
channel = await session.get(BotChannel, channel_id)
|
||
if channel is None or channel.workspace_id != ws_id:
|
||
raise AppError(ErrorCode.BOT_TOKEN_INVALID, "接入通道不存在")
|
||
data = body or {}
|
||
if isinstance(data.get("name"), str):
|
||
channel.name = data["name"].strip()[:64]
|
||
if isinstance(data.get("status"), str):
|
||
if data["status"] not in ("active", "disabled"):
|
||
raise AppError(ErrorCode.VALIDATION_ERROR, "状态只能是 active 或 disabled")
|
||
channel.status = data["status"]
|
||
return ok({"channel": _channel_out(channel)})
|
||
|
||
|
||
@admin_router.post("/{ws_id}/integrations/{channel_id}/rotate")
|
||
async def rotate_integration(
|
||
ws_id: uuid.UUID,
|
||
channel_id: uuid.UUID,
|
||
ctx: AdminDep,
|
||
session: SessionDep,
|
||
request: Request,
|
||
):
|
||
channel = await session.get(BotChannel, channel_id)
|
||
if channel is None or channel.workspace_id != ws_id:
|
||
raise AppError(ErrorCode.BOT_TOKEN_INVALID, "接入通道不存在")
|
||
token = new_token()
|
||
channel.token_hash = hash_token(token)
|
||
return ok(
|
||
{
|
||
"channel": _channel_out(channel),
|
||
"token": token,
|
||
"webhook_url": _webhook_url(request, token),
|
||
}
|
||
)
|
||
|
||
|
||
@admin_router.delete("/{ws_id}/integrations/{channel_id}")
|
||
async def delete_integration(
|
||
ws_id: uuid.UUID, channel_id: uuid.UUID, ctx: AdminDep, session: SessionDep
|
||
):
|
||
channel = await session.get(BotChannel, channel_id)
|
||
if channel is None or channel.workspace_id != ws_id:
|
||
raise AppError(ErrorCode.BOT_TOKEN_INVALID, "接入通道不存在")
|
||
await session.delete(channel)
|
||
return ok({"deleted": True})
|
||
|
||
|
||
@admin_router.get("/{ws_id}/integrations/{channel_id}/messages")
|
||
async def list_messages(
|
||
ws_id: uuid.UUID,
|
||
channel_id: uuid.UUID,
|
||
ctx: AdminDep,
|
||
session: SessionDep,
|
||
limit: int = Query(default=20, ge=1, le=100),
|
||
):
|
||
rows = (
|
||
(
|
||
await session.execute(
|
||
select(BotMessage)
|
||
.where(BotMessage.workspace_id == ws_id, BotMessage.channel_id == channel_id)
|
||
.order_by(BotMessage.created_at.desc())
|
||
.limit(limit)
|
||
)
|
||
)
|
||
.scalars()
|
||
.all()
|
||
)
|
||
return ok(
|
||
{
|
||
"items": [
|
||
{
|
||
"id": str(row.id),
|
||
"text": row.text,
|
||
"action": row.action,
|
||
"item_id": str(row.item_id) if row.item_id else None,
|
||
"reply": row.reply,
|
||
"sender": row.sender,
|
||
"created_at": row.created_at,
|
||
}
|
||
for row in rows
|
||
]
|
||
}
|
||
)
|
||
|
||
|
||
__all__ = ["webhook_router", "admin_router"]
|