Unify broker-mode binding changes in database transactions: advance device generation, invalidate pending authorizations/tasks and prior pairing-code epochs, and persist audit plus invalidation outbox. Add authenticated device unbind alongside robot/admin paths. Pairing codes are hashed, generation- fenced and consumed atomically with binding. Replay Redis invalidation effects without undoing committed unbind. Guard online cleanup and delayed kill events by generation. Introduce a separate router admission credential with no platform-event injection authority. Router verifies signed nonce-bound internal admission on handshake, task traffic and periodic checks; reject stale sessions and control-plane outages. Persist task owner/device/generation/session/worker and original message mapping. Sign routing metadata, verify late results, claim replies once and mark ambiguous/crashed tasks unknown instead of replaying writes. Fence notifications across same-user rebind. Release in-memory slots/waiters even when database or Redis cleanup fails. Validation: 213 passed, 3 skipped (real PostgreSQL not configured), 30 existing uvicorn/websockets deprecation warnings. New lifecycle coverage: 28 tests, including real loopback WebSocket isolation, reverse completion, missed kill, periodic unbind checks, outbox recovery, transaction rollback and cleanup failures. Syntax, docs and staged diff checks pass. Default legacy mode remains unchanged. Broker mode now requires coordinated router admission configuration and a v2 client handshake. No production ECS configuration, real credentials or client installer was changed. PostgreSQL, real Redis multi-node, ARM64 and actual Work/client rollout remain stage 5.
663 lines
32 KiB
Python
663 lines
32 KiB
Python
import asyncio
|
|
import base64
|
|
import contextlib
|
|
import hashlib
|
|
import hmac
|
|
import json
|
|
import re
|
|
import secrets
|
|
import sqlite3
|
|
import time
|
|
import uuid
|
|
from contextlib import asynccontextmanager
|
|
from dataclasses import dataclass
|
|
from urllib.parse import unquote, urlsplit
|
|
|
|
from cryptography.hazmat.primitives import hashes, padding
|
|
from cryptography.hazmat.primitives.asymmetric import x25519
|
|
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
|
|
from fastapi import FastAPI, HTTPException, Request
|
|
from fastapi.responses import HTMLResponse, JSONResponse
|
|
from fastapi.exceptions import RequestValidationError
|
|
from pydantic import BaseModel, Field
|
|
from redis.asyncio import Redis
|
|
|
|
from .common import BodyLimitMiddleware, no_cache, peer, rate_limit, require_secret
|
|
from .config import Settings
|
|
from .crypto import (canonical, fingerprint, load_private, open_envelope, raw_public, seal,
|
|
sign, verified, verify_device)
|
|
from .oauth import OAuth
|
|
from .platform import Feishu, PlatformError
|
|
from .store import Store, INTEGRITY_ERRORS
|
|
|
|
|
|
class Register(BaseModel):
|
|
host_id: str = Field(pattern=r"^[a-f0-9]{32}$")
|
|
cert: str = Field(max_length=10000)
|
|
|
|
|
|
class Bind(BaseModel):
|
|
host_id: str = Field(pattern=r"^[a-f0-9]{32}$")
|
|
proof: dict
|
|
|
|
|
|
class Instruction(BaseModel):
|
|
open_id: str = Field(min_length=1, max_length=128)
|
|
text: str = Field(min_length=1, max_length=8000)
|
|
# Stable identity chosen by upstream, not generated again on retries.
|
|
turn_id: str = Field(default_factory=lambda: uuid.uuid4().hex, pattern=r"^[A-Za-z0-9_-]{1,128}$")
|
|
|
|
|
|
@dataclass
|
|
class Pending:
|
|
future: asyncio.Future
|
|
private: object
|
|
public: object
|
|
host: str
|
|
session: str
|
|
|
|
|
|
class Broker:
|
|
def __init__(self, settings, redis, store):
|
|
self.s, self.r, self.store = settings, redis, store
|
|
self.signer = load_private(settings.connector_key)
|
|
self.pending: dict[str, Pending] = {}
|
|
self.worker_id = uuid.uuid4().hex
|
|
self.lifecycle = None
|
|
|
|
async def replies(self, pub):
|
|
async for message in pub.listen():
|
|
if message["type"] != "message":
|
|
continue
|
|
try:
|
|
data = json.loads(message["data"])
|
|
item = self.pending.get(data["turn_id"])
|
|
if not item or item.future.done():
|
|
continue
|
|
plain = open_envelope(data["envelope"], item.private, item.public,
|
|
host_id=item.host, session_id=item.session)
|
|
if plain["turn_id"] != data["turn_id"] or plain.get("type") != "result":
|
|
continue
|
|
result = plain.get("result", "")
|
|
if not isinstance(result, str) or len(result) > self.s.max_result:
|
|
continue
|
|
if self.lifecycle and not self.lifecycle.complete(data["turn_id"],item.host,item.session,self.worker_id):
|
|
continue
|
|
item.future.set_result({"status": "completed", "turn_id": data["turn_id"], "result": result})
|
|
except Exception:
|
|
# Invalid packets never consume a pending result; do not log packet contents.
|
|
continue
|
|
|
|
async def dispatch(self, owner, text, turn, *, chat_id="", source_message_id=""):
|
|
device = self.store.by_owner(owner)
|
|
if not device:
|
|
return {"status": "unavailable", "turn_id": turn, "result": "未绑定设备或设备不可用。"}
|
|
host = device["host_id"]
|
|
await rate_limit(self.r, "dispatch:" + owner, 30)
|
|
if len(self.pending) >= self.s.max_pending:
|
|
raise HTTPException(503, "too many in-flight requests")
|
|
presence = await self.r.get("hn:online:" + host)
|
|
if not presence or await self.r.exists("hn:revoked:" + host):
|
|
return {"status": "offline", "turn_id": turn, "result": "你的电脑当前离线,请开机并连接网络。"}
|
|
try:
|
|
presence = json.loads(presence)
|
|
if fingerprint(presence["cert"]) != device["fingerprint"]:
|
|
raise ValueError("certificate changed")
|
|
public = verify_device(presence["cert"], self.s.ca_cert.read_bytes(), host)
|
|
proof = verified(presence["proof"], public)
|
|
if proof["host_id"] != host or proof["challenge"] != presence["challenge"]:
|
|
raise ValueError("invalid device session")
|
|
session = proof["session_id"]
|
|
if self.lifecycle and (proof.get("binding_owner") != owner
|
|
or proof.get("binding_generation") != device["binding_generation"]):
|
|
raise ValueError("stale binding session")
|
|
except Exception:
|
|
self.store.audit(owner, "dispatch", host, "identity_rejected")
|
|
raise HTTPException(409, "device identity rejected") from None
|
|
if not self.store.begin_turn(turn, owner, host):
|
|
return {"status": "duplicate", "turn_id": turn, "result": "该请求已接收,不会重复执行。"}
|
|
task = None
|
|
if self.lifecycle:
|
|
try:
|
|
task = self.lifecycle.create_task(turn,owner,host,device["binding_generation"],session,
|
|
self.worker_id,time.time()+self.s.request_timeout,chat_id,source_message_id)
|
|
except ValueError:
|
|
self.store.finish(turn,"unbound")
|
|
return {"status":"unbound","turn_id":turn,"result":"绑定已变化,任务未下发。"}
|
|
private = x25519.X25519PrivateKey.generate()
|
|
future = asyncio.get_running_loop().create_future()
|
|
self.pending[turn] = Pending(future, private, public, host, session)
|
|
payload = {"type": "instruction", "turn_id": turn, "owner": owner,
|
|
"text": text, "read_only": True, "channel": "im",
|
|
"reply_key": raw_public(private.public_key())}
|
|
if task:
|
|
payload["task_context"] = {key:task[key] for key in ("environment","app_id","owner","host_id","binding_generation",
|
|
"conversation_id","chat_id","source_message_id")}
|
|
payload["task_context"].update(task_id=turn,channel="work-dm")
|
|
try:
|
|
envelope = seal(payload, proof["kx"], self.signer,host_id=host,session_id=session)
|
|
except Exception:
|
|
self.pending.pop(turn,None)
|
|
self.store.finish(turn,"unknown")
|
|
if task:
|
|
self.lifecycle.transition(turn,"inflight","unknown")
|
|
raise HTTPException(409,"invalid_device_crypto_session") from None
|
|
key = f"hn:inflight:{host}:{turn}"
|
|
try:
|
|
await self.r.set(key, session, ex=self.s.request_timeout + 5)
|
|
packet = {"type":"instruction","envelope":envelope}
|
|
if task:
|
|
packet["routing"] = sign({"turn_id":turn,"host_id":host,"session_id":session,
|
|
"environment":self.s.environment,"app_id":self.s.feishu_app_id,
|
|
"binding_generation":task["binding_generation"],
|
|
"envelope_hash":hashlib.sha256(canonical(envelope)).hexdigest()}, self.signer)
|
|
count = await self.r.publish("hn:down:" + host, json.dumps(packet))
|
|
if not count:
|
|
self.store.finish(turn, "offline")
|
|
if task:
|
|
self.lifecycle.transition(turn,"inflight","offline")
|
|
return {"status": "offline", "turn_id": turn, "result": "你的电脑当前离线。"}
|
|
result = await asyncio.wait_for(future, timeout=self.s.request_timeout)
|
|
self.store.finish(turn, result.get("status","unknown") if task else "completed")
|
|
if task and not source_message_id:
|
|
self.lifecycle.transition(turn,"completed","finished")
|
|
self.store.audit(owner, "instruction", host, result.get("status","unknown") if task else "completed")
|
|
return result
|
|
except asyncio.TimeoutError:
|
|
self.store.finish(turn, "unknown")
|
|
if task:
|
|
self.lifecycle.transition(turn,"inflight","unknown")
|
|
return {"status": "unknown", "turn_id": turn,
|
|
"result": "等待结果超时,执行状态未知;不要直接重发有副作用的任务。"}
|
|
finally:
|
|
self.pending.pop(turn, None)
|
|
if task:
|
|
# Cancellation, publish failures and connector shutdown never replay work.
|
|
with contextlib.suppress(Exception):
|
|
self.lifecycle.transition(turn,"inflight","unknown")
|
|
with contextlib.suppress(Exception):
|
|
await self.r.delete(key)
|
|
|
|
|
|
def create_app(settings=None, redis=None, platform=None):
|
|
s = settings or Settings()
|
|
r = redis or Redis.from_url(s.redis_url, decode_responses=True)
|
|
store = Store(s.data_dir / "metadata.sqlite", s.database_url)
|
|
f = platform or Feishu(s)
|
|
broker = Broker(s, r, store)
|
|
if s.credential_mode == "broker":
|
|
from .credential_api import CredentialAPI
|
|
from .credential_broker import CredentialBroker
|
|
from .credential_store import CredentialStore, CredentialKeyring
|
|
credential_store = CredentialStore(store, CredentialKeyring.from_file(s.credential_keyring_file))
|
|
credential_broker = CredentialBroker(credential_store, r, f, environment=s.environment, app_id=s.feishu_app_id)
|
|
oauth = CredentialAPI(s, r, store, credential_broker)
|
|
from .binding_state import BindingState
|
|
from .device_lifecycle import DeviceLifecycle
|
|
store.lifecycle = BindingState(store,s.environment,s.feishu_app_id)
|
|
broker.lifecycle = store.lifecycle
|
|
lifecycle = DeviceLifecycle(store.lifecycle,r,broker)
|
|
else:
|
|
oauth = OAuth(s, r, f)
|
|
oauth.store = store
|
|
lifecycle = None
|
|
from .notifications import router as notification_router
|
|
background = set()
|
|
|
|
def spawn(coro):
|
|
task = asyncio.create_task(coro)
|
|
background.add(task)
|
|
task.add_done_callback(background.discard)
|
|
# Retrieve errors without displaying possibly sensitive exception text.
|
|
task.add_done_callback(lambda t: t.exception() if not t.cancelled() else None)
|
|
|
|
@asynccontextmanager
|
|
async def lifespan(app):
|
|
await r.ping()
|
|
if lifecycle:
|
|
await lifecycle.maintain()
|
|
for row in store.db.execute("SELECT host_id,fingerprint,revoked FROM devices").fetchall():
|
|
await r.set("hn:device:" + row["host_id"], row["fingerprint"])
|
|
if row["revoked"]:
|
|
await r.set("hn:revoked:" + row["host_id"], "1")
|
|
pub = r.pubsub()
|
|
await pub.subscribe("hn:replies")
|
|
reply_task = asyncio.create_task(broker.replies(pub))
|
|
app.state.reply_task = reply_task
|
|
async def sweep():
|
|
while True:
|
|
await asyncio.sleep(30)
|
|
if s.credential_mode == "legacy":
|
|
async with oauth.lock:
|
|
oauth.prune()
|
|
sweep_task = asyncio.create_task(sweep())
|
|
async def maintenance():
|
|
while True:
|
|
await asyncio.sleep(5)
|
|
try:
|
|
await lifecycle.maintain()
|
|
except Exception:
|
|
# No credentials or raw exception text in background logs.
|
|
pass
|
|
lifecycle_task = asyncio.create_task(maintenance()) if lifecycle else None
|
|
try:
|
|
yield
|
|
finally:
|
|
work = [reply_task,sweep_task,*background] + ([lifecycle_task] if lifecycle_task else [])
|
|
for task in work:
|
|
task.cancel()
|
|
await asyncio.gather(*work, return_exceptions=True)
|
|
if lifecycle:
|
|
with contextlib.suppress(Exception):
|
|
await r.delete("hn:task-worker:"+broker.worker_id)
|
|
await pub.aclose()
|
|
await f.close()
|
|
store.close()
|
|
if redis is None:
|
|
await r.aclose()
|
|
|
|
app = FastAPI(title="Hainuo B1 connector", lifespan=lifespan, docs_url=None, redoc_url=None)
|
|
app.add_middleware(BodyLimitMiddleware, max_body=s.max_body)
|
|
app.include_router(oauth.router)
|
|
app.include_router(notification_router(s, r, store, f, oauth))
|
|
from .web_session import WebSessions
|
|
web_sessions = WebSessions(s, r, store, broker, f)
|
|
app.include_router(web_sessions.router)
|
|
app.state.store, app.state.broker, app.state.oauth = store, broker, oauth
|
|
app.state.platform, app.state.redis = f, r
|
|
app.state.lifecycle = lifecycle
|
|
|
|
if lifecycle:
|
|
from .device_lifecycle import AdmissionRequest
|
|
from .credential_api import DeviceRequest
|
|
@app.post("/work/v2/device/unbind")
|
|
async def device_unbind(body: DeviceRequest, request: Request):
|
|
await oauth.authenticate(body,request)
|
|
try:
|
|
store.lifecycle.invalidate_host(body.host_id,"unbind",expected_owner=body.binding_owner,
|
|
expected_generation=body.binding_generation)
|
|
except ValueError:
|
|
raise HTTPException(409,"binding_changed_retry") from None
|
|
lifecycle.cancel_waiters()
|
|
propagated = await lifecycle.flush()
|
|
return {"status":"unbound","binding_generation":store.device(body.host_id)["binding_generation"],
|
|
"propagation":"published" if propagated else "pending"}
|
|
|
|
@app.post("/internal/devices/{host}/admission")
|
|
async def admission(host: str, body: AdmissionRequest, request: Request):
|
|
require_secret(request.headers.get("X-Router-Admission-Secret"),s.router_admission_secret)
|
|
return sign(await lifecycle.admission(host,body),broker.signer)
|
|
|
|
@app.exception_handler(RequestValidationError)
|
|
async def validation_error(request, exc):
|
|
# FastAPI's default error response includes invalid input values (possibly tokens).
|
|
return JSONResponse({"detail": "invalid request parameters"}, status_code=422)
|
|
|
|
@app.middleware("http")
|
|
async def secure_response(request, call_next):
|
|
return no_cache(await call_next(request))
|
|
|
|
def admin(request):
|
|
require_secret(request.headers.get("X-Admin-Secret"), s.admin_secret)
|
|
|
|
from .enrollment import enrollment_router
|
|
app.include_router(enrollment_router(s, r, store, broker.signer, admin))
|
|
if s.credential_mode == "legacy":
|
|
from .work_api import router as work_router
|
|
app.include_router(work_router(s, r, store, f))
|
|
|
|
@app.get("/health")
|
|
async def health():
|
|
return {"status": "alive", "role": "connector", "version": "0.1.0"}
|
|
|
|
@app.get("/ready")
|
|
async def ready():
|
|
await r.ping()
|
|
store.db.execute("SELECT 1")
|
|
if not getattr(app.state, "reply_task", None) or app.state.reply_task.done():
|
|
raise HTTPException(503, "reply subscriber unavailable")
|
|
return {"status": "ready"}
|
|
|
|
@app.post("/admin/devices", status_code=201)
|
|
async def register(body: Register, request: Request):
|
|
admin(request)
|
|
try:
|
|
verify_device(body.cert, s.ca_cert.read_bytes(), body.host_id)
|
|
except Exception:
|
|
raise HTTPException(400, "invalid device certificate") from None
|
|
if store.db.execute("SELECT COUNT(*) AS total FROM devices").fetchone()["total"] >= s.max_devices:
|
|
raise HTTPException(503, "device capacity reached")
|
|
try:
|
|
fp = fingerprint(body.cert)
|
|
store.add_device(body.host_id, body.cert, fp)
|
|
except INTEGRITY_ERRORS:
|
|
raise HTTPException(409, "device already exists") from None
|
|
await r.set("hn:device:" + body.host_id, fp)
|
|
store.audit("admin", "register", body.host_id, "success")
|
|
return {"host_id": body.host_id, "fingerprint": fp}
|
|
|
|
@app.get("/admin/devices")
|
|
async def devices(request: Request):
|
|
admin(request)
|
|
rows = store.db.execute("SELECT host_id,fingerprint,owner,revoked FROM devices ORDER BY host_id").fetchall()
|
|
return {"devices": [{**dict(row), "online": bool(await r.exists("hn:online:" + row["host_id"]))} for row in rows]}
|
|
|
|
@app.post("/admin/devices/{host}/revoke")
|
|
async def revoke(host: str, request: Request):
|
|
admin(request)
|
|
if not store.device(host):
|
|
raise HTTPException(404, "device not found")
|
|
if lifecycle:
|
|
try:
|
|
store.revoke(host)
|
|
except ValueError:
|
|
raise HTTPException(409,"binding_changed_retry") from None
|
|
lifecycle.cancel_waiters()
|
|
propagated = await lifecycle.flush()
|
|
return {"status":"revoked","propagation":"published" if propagated else "pending"}
|
|
# Persistent source of truth first; router block + disconnect follows.
|
|
store.revoke(host)
|
|
await r.incr("hn:web-generation:" + host)
|
|
await r.set("hn:revoked:" + host, "1")
|
|
await r.delete("hn:online:" + host)
|
|
await r.publish("hn:kill:" + host, "revoke")
|
|
for item in broker.pending.values():
|
|
if item.host == host and not item.future.done():
|
|
item.future.set_result({"status": "revoked", "result": "设备已停用,结果已丢弃。"})
|
|
store.audit("admin", "revoke", host, "success")
|
|
return {"status": "revoked"}
|
|
|
|
@app.post("/admin/reconcile")
|
|
async def reconcile(request: Request):
|
|
"""Rebuild router admission metadata after Redis recovery; no dialogue data."""
|
|
admin(request)
|
|
if lifecycle:
|
|
await lifecycle.maintain()
|
|
rows = store.db.execute("SELECT host_id,fingerprint,revoked FROM devices").fetchall()
|
|
for row in rows:
|
|
await r.set("hn:device:" + row["host_id"], row["fingerprint"])
|
|
if row["revoked"]:
|
|
await r.set("hn:revoked:" + row["host_id"], "1")
|
|
return {"devices": len(rows)}
|
|
|
|
@app.post("/admin/devices/{host}/unbind")
|
|
async def admin_unbind(host: str, request: Request):
|
|
admin(request)
|
|
device = store.device(host)
|
|
if not device:
|
|
raise HTTPException(404, "device not found")
|
|
if lifecycle:
|
|
try:
|
|
store.lifecycle.invalidate_host(host,"unbind")
|
|
except ValueError:
|
|
raise HTTPException(409,"binding_changed_retry") from None
|
|
lifecycle.cancel_waiters()
|
|
propagated = await lifecycle.flush()
|
|
return {"status":"unbound","host_id":host,"revoked":bool(device["revoked"]),
|
|
"propagation":"published" if propagated else "pending"}
|
|
if device["owner"]:
|
|
store.unbind(device["owner"])
|
|
await r.incr("hn:web-generation:" + host)
|
|
await r.delete("hn:online:" + host)
|
|
await r.publish("hn:kill:" + host, "unbind")
|
|
for item in broker.pending.values():
|
|
if item.host == host and not item.future.done():
|
|
item.future.set_result({"status": "unbound", "result": "设备已解绑,结果已丢弃。"})
|
|
store.audit("admin", "unbind", host, "success")
|
|
return {"status": "unbound", "host_id": host, "revoked": bool(device["revoked"])}
|
|
|
|
async def make_binding_code(owner):
|
|
if store.by_owner(owner):
|
|
return "你已绑定电脑,请先发送 /解绑。"
|
|
await rate_limit(r, "binding:" + owner, 5)
|
|
code = secrets.token_urlsafe(12)
|
|
if lifecycle:
|
|
try:
|
|
store.lifecycle.issue_code(owner,code)
|
|
except ValueError:
|
|
return "你已绑定电脑,请先发送 /解绑。"
|
|
else:
|
|
await r.set("hn:bind:" + hashlib.sha256(code.encode()).hexdigest(), owner, ex=300)
|
|
return "请在本人电脑的桥接客户端输入绑定码(5分钟有效):" + code
|
|
|
|
@app.post("/device/bind")
|
|
async def bind(body: Bind, request: Request):
|
|
await rate_limit(r, "bind:" + peer(request), 20)
|
|
device = store.device(body.host_id)
|
|
if not device or device["revoked"]:
|
|
raise HTTPException(404, "device unavailable")
|
|
try:
|
|
public = verify_device(device["cert"], s.ca_cert.read_bytes(), body.host_id)
|
|
proof = verified(body.proof, public)
|
|
if proof["host_id"] != body.host_id or abs(time.time() - proof["ts"]) > 90:
|
|
raise ValueError("invalid proof")
|
|
code = proof["code"]
|
|
if not isinstance(code, str) or len(code) > 128:
|
|
raise ValueError("invalid code")
|
|
except Exception:
|
|
raise HTTPException(403, "invalid device proof") from None
|
|
if lifecycle:
|
|
try:
|
|
owner = store.lifecycle.consume_code(body.host_id,code)
|
|
except LookupError:
|
|
raise HTTPException(404,"binding code unavailable") from None
|
|
except (*INTEGRITY_ERRORS,ValueError):
|
|
raise HTTPException(409,"owner/device already bound; request new code") from None
|
|
return sign({"host_id":body.host_id,"owner":owner,
|
|
"binding_generation":store.device(body.host_id)["binding_generation"],
|
|
"ts":int(time.time())},broker.signer)
|
|
key = "hn:bind:" + hashlib.sha256(code.encode()).hexdigest()
|
|
owner = await r.get(key)
|
|
if not owner:
|
|
raise HTTPException(404, "binding code expired or consumed")
|
|
# GETDEL is atomic across connectors. Invalid device proofs never reach this point.
|
|
owner = await r.getdel(key)
|
|
if not owner:
|
|
raise HTTPException(404, "binding code consumed")
|
|
try:
|
|
store.bind(body.host_id, owner)
|
|
except (*INTEGRITY_ERRORS, ValueError):
|
|
raise HTTPException(409, "owner/device already bound; request new code") from None
|
|
await r.incr("hn:web-generation:" + body.host_id)
|
|
store.audit(owner, "bind", body.host_id, "success")
|
|
return sign({"host_id": body.host_id, "owner": owner,
|
|
"binding_generation": store.device(body.host_id)["binding_generation"],
|
|
"ts": int(time.time())}, broker.signer)
|
|
|
|
@app.post("/admin/test/binding-code")
|
|
async def test_code(body: Instruction, request: Request):
|
|
admin(request)
|
|
if s.environment == "production":
|
|
raise HTTPException(404, "not found")
|
|
return {"message": await make_binding_code(body.open_id)}
|
|
|
|
@app.post("/admin/test/dispatch")
|
|
async def test_dispatch(body: Instruction, request: Request):
|
|
admin(request)
|
|
if s.environment == "production":
|
|
raise HTTPException(404, "not found")
|
|
return await broker.dispatch(body.open_id, body.text, body.turn_id)
|
|
|
|
async def handle_event(data):
|
|
header, event = data.get("header", {}), data.get("event", {})
|
|
if header.get("event_type") != "im.message.receive_v1":
|
|
return
|
|
message, sender = event.get("message", {}), event.get("sender", {})
|
|
owner = sender.get("sender_id", {}).get("open_id")
|
|
message_id = message.get("message_id", "")
|
|
if (message.get("chat_type") != "p2p" or message.get("message_type") != "text"
|
|
or sender.get("sender_type") != "user" or not isinstance(owner,str)
|
|
or not 0 < len(owner) <= 128 or any(ord(c) < 32 for c in owner)
|
|
or not re.fullmatch(r"[A-Za-z0-9_-]{1,128}", message_id)):
|
|
return
|
|
if header.get("app_id") != s.feishu_app_id:
|
|
return
|
|
if lifecycle and (not isinstance(message.get("chat_id"),str) or not 0 < len(message["chat_id"]) <= 128
|
|
or any(ord(c) < 32 for c in message["chat_id"])):
|
|
return
|
|
try:
|
|
text = json.loads(message["content"])["text"].strip()
|
|
if not text or len(text) > 8000:
|
|
return
|
|
# Persistent receipt BEFORE any side effect. Restarts do not execute a delivery twice.
|
|
event_turn = "event_" + hashlib.sha256(message_id.encode()).hexdigest()
|
|
if not store.begin_turn(event_turn, owner, "event"):
|
|
return
|
|
if text == "/绑定":
|
|
result = await make_binding_code(owner)
|
|
elif text == "/解绑":
|
|
old = store.by_owner(owner)
|
|
store.unbind(owner)
|
|
if lifecycle:
|
|
lifecycle.cancel_waiters()
|
|
await lifecycle.flush()
|
|
elif old:
|
|
await r.incr("hn:web-generation:" + old["host_id"])
|
|
await r.publish("hn:kill:" + old["host_id"], "unbind")
|
|
for item in broker.pending.values():
|
|
if item.host == old["host_id"] and not item.future.done():
|
|
item.future.set_result({"status": "unbound", "result": "设备已解绑,结果已丢弃。"})
|
|
result = "已解绑;重新绑定后请更新本机绑定信息。"
|
|
elif text == "/主机名" or text.startswith("/回显 "):
|
|
result = (await broker.dispatch(owner, text, "msg_" + hashlib.sha256(message_id.encode()).hexdigest(),
|
|
**({"chat_id":message["chat_id"],"source_message_id":message_id} if lifecycle else {})))["result"]
|
|
else:
|
|
instruction = text if text.startswith("/助手 ") else "/助手 " + text
|
|
result = (await broker.dispatch(owner, instruction, "msg_" + hashlib.sha256(message_id.encode()).hexdigest(),
|
|
**({"chat_id":message["chat_id"],"source_message_id":message_id} if lifecycle else {})))["result"]
|
|
turn = "msg_"+hashlib.sha256(message_id.encode()).hexdigest()
|
|
task = store.lifecycle.task(turn) if lifecycle else None
|
|
if task and not store.lifecycle.claim_reply(turn,owner,message_id):
|
|
store.finish(event_turn,"result_discarded")
|
|
return
|
|
try:
|
|
await f.reply(message_id, result[:s.max_result])
|
|
except Exception:
|
|
if task:
|
|
store.lifecycle.transition(turn,"replying","reply_unknown")
|
|
raise
|
|
if task:
|
|
store.lifecycle.transition(turn,"replying","replied")
|
|
store.finish(event_turn, "replied")
|
|
except Exception:
|
|
store.audit(owner, "event", message_id, "failed_or_unknown")
|
|
|
|
@app.post("/internal/events")
|
|
async def internal_event(request: Request):
|
|
require_secret(request.headers.get("X-Internal-Secret"), s.internal_secret)
|
|
if not s.feishu_enabled:
|
|
raise HTTPException(503, "platform disabled")
|
|
if len(background) >= s.max_pending:
|
|
raise HTTPException(503, "busy")
|
|
spawn(handle_event(await request.json()))
|
|
return {"accepted": True}
|
|
|
|
@app.post("/feishu/event")
|
|
async def webhook(request: Request):
|
|
if not s.feishu_enabled:
|
|
raise HTTPException(503, "platform disabled")
|
|
if not s.feishu_encrypt_key or not s.feishu_verification_token:
|
|
raise HTTPException(503, "webhook credentials not configured; use selected event source")
|
|
await rate_limit(r, "webhook:" + peer(request), 600)
|
|
raw = await request.body()
|
|
timestamp, nonce, signature = (request.headers.get(x, "") for x in
|
|
("X-Lark-Request-Timestamp", "X-Lark-Request-Nonce", "X-Lark-Signature"))
|
|
try:
|
|
if abs(time.time() - int(timestamp)) > 300 or not nonce or len(nonce) > 128:
|
|
raise ValueError("stale request")
|
|
expected = hashlib.sha256((timestamp + nonce + s.feishu_encrypt_key).encode() + raw).hexdigest()
|
|
if not hmac.compare_digest(expected, signature):
|
|
raise ValueError("bad signature")
|
|
data = json.loads(raw)
|
|
if "encrypt" in data:
|
|
cipher = base64.b64decode(data["encrypt"], validate=True)
|
|
decryptor = Cipher(algorithms.AES(hashlib.sha256(s.feishu_encrypt_key.encode()).digest()),
|
|
modes.CBC(cipher[:16])).decryptor()
|
|
padded = decryptor.update(cipher[16:]) + decryptor.finalize()
|
|
unpadder = padding.PKCS7(128).unpadder()
|
|
data = json.loads(unpadder.update(padded) + unpadder.finalize())
|
|
token = data.get("token", data.get("header", {}).get("token", ""))
|
|
if not hmac.compare_digest(token, s.feishu_verification_token):
|
|
raise ValueError("invalid verification token")
|
|
except Exception:
|
|
raise HTTPException(403, "invalid event authentication") from None
|
|
if data.get("type") == "url_verification":
|
|
return {"challenge": data.get("challenge", "")}
|
|
# Same delivery is ACKed again; durable message_id receipt handles execution deduplication.
|
|
if len(background) >= s.max_pending:
|
|
raise HTTPException(503, "busy")
|
|
spawn(handle_event(data))
|
|
return {"code": 0}
|
|
|
|
@app.get("/api/whoami")
|
|
async def whoami(request: Request):
|
|
if not s.feishu_enabled:
|
|
raise HTTPException(503, "platform disabled")
|
|
await rate_limit(r, "whoami:" + peer(request))
|
|
auth = request.headers.get("Authorization", "")
|
|
if not auth.startswith("Bearer ") or len(auth) > 8192:
|
|
raise HTTPException(401, "user token required")
|
|
try:
|
|
info = await f.user_info(auth[7:])
|
|
except PlatformError:
|
|
raise HTTPException(401, "invalid user token") from None
|
|
device = store.by_owner(info["open_id"])
|
|
if not device:
|
|
raise HTTPException(404, "no device bound")
|
|
if not s.device_domain or not re.fullmatch(r"[a-zA-Z0-9.-]+", s.device_domain):
|
|
raise HTTPException(503, "device web domain not configured")
|
|
return {"host_id": device["host_id"], "url": f"https://h-{device['host_id']}.{s.device_domain}/",
|
|
"online": bool(await r.exists("hn:online:" + device["host_id"])),
|
|
"device_login_required": True}
|
|
|
|
@app.get("/h5", response_class=HTMLResponse)
|
|
async def h5():
|
|
from importlib.resources import files
|
|
return HTMLResponse(files("relay").joinpath("web/index.html").read_text(encoding="utf-8"),
|
|
headers={"Content-Security-Policy": "default-src 'self'; script-src 'self'; style-src 'self'; frame-ancestors 'self'; base-uri 'none'; form-action 'self'"})
|
|
|
|
@app.get("/assets/{name}")
|
|
async def asset(name: str):
|
|
from importlib.resources import files
|
|
from starlette.responses import Response
|
|
if name not in {"app.js", "style.css"}:
|
|
raise HTTPException(404, "not found")
|
|
return Response(files("relay").joinpath("web/" + name).read_bytes(),
|
|
media_type="text/javascript" if name.endswith(".js") else "text/css")
|
|
|
|
@app.get("/proxy")
|
|
async def proxy(request: Request):
|
|
if not s.proxy_enabled or not s.feishu_enabled:
|
|
raise HTTPException(404, "not found")
|
|
auth = request.headers.get("Authorization", "")
|
|
target = request.headers.get("X-Relay-Target", "")
|
|
decoded = unquote(target)
|
|
parts = urlsplit(target)
|
|
allowed = s.proxy_paths.split(",")
|
|
if (not auth.startswith("Bearer ") or len(auth) > 8192 or len(target) > 4096
|
|
or parts.scheme or parts.netloc or parts.fragment or target.startswith("//")
|
|
or any(x in decoded for x in ("..", "\\", "\r", "\n", "#", "%"))
|
|
or not any(parts.path == x or parts.path.startswith(x + "/") for x in allowed)):
|
|
raise HTTPException(403, "target not allowed")
|
|
try:
|
|
info = await f.user_info(auth[7:])
|
|
await rate_limit(r, "proxy:" + info["open_id"], 60)
|
|
# Buffer bounded response; no disk/cache, redirects never followed.
|
|
async with f.http.stream("GET", target, headers={"Authorization": auth}) as response:
|
|
if response.status_code in {301, 302, 303, 307, 308}:
|
|
raise HTTPException(502, "upstream redirect refused")
|
|
chunks, size = [], 0
|
|
async for chunk in response.aiter_bytes():
|
|
size += len(chunk)
|
|
if size > 2 * 1024 * 1024:
|
|
raise HTTPException(502, "response too large")
|
|
chunks.append(chunk)
|
|
from starlette.responses import Response
|
|
store.audit(info["open_id"], "proxy", parts.path, str(response.status_code))
|
|
return Response(b"".join(chunks), status_code=response.status_code,
|
|
media_type=response.headers.get("content-type", "application/json"))
|
|
except PlatformError:
|
|
raise HTTPException(401, "invalid user token") from None
|
|
|
|
return app
|