Import ECS deployed relay source and historical patches (2026-10-27)
This commit is contained in:
@@ -0,0 +1 @@
|
||||
"""Hainuo relay 0.1.0."""
|
||||
@@ -0,0 +1,216 @@
|
||||
import argparse
|
||||
import asyncio
|
||||
import json
|
||||
import os
|
||||
import secrets
|
||||
import ssl
|
||||
import uuid
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from pathlib import Path
|
||||
|
||||
import httpx
|
||||
from cryptography import x509
|
||||
from cryptography.hazmat.primitives import serialization
|
||||
from cryptography.hazmat.primitives.asymmetric import ed25519
|
||||
from cryptography.x509.oid import NameOID
|
||||
|
||||
from .crypto import issue_ca, issue_device, load_private, pem_private
|
||||
|
||||
|
||||
def write_new(path, data, private=False):
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
with path.open("xb") as f:
|
||||
f.write(data if isinstance(data, bytes) else data.encode())
|
||||
if private and os.name != "nt":
|
||||
path.chmod(0o600)
|
||||
|
||||
|
||||
def init_project(root: Path, hostname: str):
|
||||
if (root / ".env").exists():
|
||||
raise RuntimeError(".env exists; init never overwrites credentials")
|
||||
ca_key, ca = issue_ca()
|
||||
signer = ed25519.Ed25519PrivateKey.generate()
|
||||
write_new(root / "operator/ca.key", pem_private(ca_key), True)
|
||||
write_new(root / "runtime/trust/ca.pem", ca.public_bytes(serialization.Encoding.PEM))
|
||||
write_new(root / "runtime/connector/connector.key", pem_private(signer), True)
|
||||
write_new(root / "runtime/trust/connector.pub", signer.public_key().public_bytes(
|
||||
serialization.Encoding.PEM, serialization.PublicFormat.SubjectPublicKeyInfo))
|
||||
tls_key = ed25519.Ed25519PrivateKey.generate()
|
||||
name = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, hostname)])
|
||||
now = datetime.now(timezone.utc)
|
||||
tls = (x509.CertificateBuilder().subject_name(name).issuer_name(name).public_key(tls_key.public_key())
|
||||
.serial_number(x509.random_serial_number()).not_valid_before(now - timedelta(minutes=5))
|
||||
.not_valid_after(now + timedelta(days=30))
|
||||
.add_extension(x509.SubjectAlternativeName([x509.DNSName(hostname)]), critical=False)
|
||||
.sign(tls_key, algorithm=None))
|
||||
write_new(root / "runtime/tls/server.key", pem_private(tls_key), True)
|
||||
write_new(root / "runtime/tls/server.pem", tls.public_bytes(serialization.Encoding.PEM))
|
||||
redis_secret = secrets.token_hex(32)
|
||||
db_secret = secrets.token_hex(32)
|
||||
env = (f"HN_ENVIRONMENT=development\nHN_PUBLIC_HOST={hostname}\nHN_PUBLIC_URL=https://{hostname}\n"
|
||||
f"HN_ROUTER_URL=wss://{hostname}/device/ws\nHN_ADMIN_SECRET={secrets.token_hex(32)}\n"
|
||||
f"HN_INTERNAL_SECRET={secrets.token_hex(32)}\nHN_REDIS_PASSWORD={redis_secret}\n"
|
||||
f"HN_REDIS_URL=redis://:{redis_secret}@redis:6379/0\n"
|
||||
f"HN_POSTGRES_PASSWORD={db_secret}\nHN_DATABASE_URL=postgresql://hainuo:{db_secret}@postgres:5432/hainuo\n"
|
||||
"HN_FEISHU_ENABLED=false\nHN_FEISHU_API_BASE=https://open.feishu.cn\n"
|
||||
"HN_FEISHU_AUTHORIZE_URL=https://open.feishu.cn/open-apis/authen/v1/authorize\n"
|
||||
"HN_FEISHU_APP_ID=\nHN_FEISHU_APP_SECRET=\nHN_FEISHU_ENCRYPT_KEY=\n"
|
||||
"HN_FEISHU_VERIFICATION_TOKEN=\nHN_PROXY_ENABLED=false\nHN_DEVICE_DOMAIN=\n")
|
||||
write_new(root / ".env", env, True)
|
||||
print("已生成配置、连接器密钥、设备CA及临时TLS证书;未输出凭据。")
|
||||
print("operator/ca.key 仅保留在签发工作站,不要上传到ECS。临时TLS证书上线前须替换。")
|
||||
|
||||
|
||||
def device_request(directory):
|
||||
host = uuid.uuid4().hex
|
||||
private = ed25519.Ed25519PrivateKey.generate()
|
||||
write_new(directory / "device.key", pem_private(private), True)
|
||||
public = private.public_key().public_bytes(serialization.Encoding.PEM, serialization.PublicFormat.SubjectPublicKeyInfo).decode()
|
||||
write_new(directory / "request.json", json.dumps({"host_id": host, "public_key": public}, indent=2))
|
||||
print("已在本机生成私钥和 request.json;仅将request.json交给签发工作站。")
|
||||
|
||||
|
||||
def issue(root, request_file, output):
|
||||
request = json.loads(request_file.read_text(encoding="utf-8"))
|
||||
host = request["host_id"]
|
||||
if len(host) != 32 or any(c not in "0123456789abcdef" for c in host):
|
||||
raise ValueError("invalid host identity")
|
||||
ca = x509.load_pem_x509_certificate((root / "runtime/trust/ca.pem").read_bytes())
|
||||
public = serialization.load_pem_public_key(request["public_key"].encode())
|
||||
if not isinstance(public, ed25519.Ed25519PublicKey):
|
||||
raise ValueError("Ed25519 required")
|
||||
cert = issue_device(load_private(root / "operator/ca.key"), ca, host, public)
|
||||
pem = cert.public_bytes(serialization.Encoding.PEM)
|
||||
write_new(output / "device.pem", pem)
|
||||
write_new(output / "ca.pem", (root / "runtime/trust/ca.pem").read_bytes())
|
||||
write_new(output / "connector.pub", (root / "runtime/trust/connector.pub").read_bytes())
|
||||
write_new(output / "device.json", json.dumps({"host_id": host, "owner": None}, indent=2))
|
||||
write_new(output / "registration.json", json.dumps({"host_id": host, "cert": pem.decode()}, indent=2))
|
||||
print("已签发设备证书;将device.pem、ca.pem、connector.pub、device.json交回原设备。")
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description="海诺中继部署和设备工具")
|
||||
sub = parser.add_subparsers(dest="command", required=True)
|
||||
p = sub.add_parser("init")
|
||||
p.add_argument("--root", type=Path, default=Path("."))
|
||||
p.add_argument("--hostname", required=True)
|
||||
p = sub.add_parser("serve")
|
||||
p.add_argument("role", choices=["connector", "router"])
|
||||
p.add_argument("--host", default="127.0.0.1")
|
||||
p.add_argument("--port", type=int, default=8000)
|
||||
p = sub.add_parser("device-request")
|
||||
p.add_argument("--directory", type=Path, required=True)
|
||||
p = sub.add_parser("issue-device")
|
||||
p.add_argument("--root", type=Path, default=Path("."))
|
||||
p.add_argument("--request", type=Path, required=True)
|
||||
p.add_argument("--output", type=Path, required=True)
|
||||
p = sub.add_parser("register")
|
||||
p.add_argument("--registration", type=Path, required=True)
|
||||
p.add_argument("--url", required=True)
|
||||
p.add_argument("--tls-ca", type=Path)
|
||||
p = sub.add_parser("bind")
|
||||
p.add_argument("--directory", type=Path, required=True)
|
||||
p.add_argument("--url", required=True)
|
||||
p.add_argument("--tls-ca", type=Path)
|
||||
p = sub.add_parser("device")
|
||||
p.add_argument("--directory", type=Path, required=True)
|
||||
p.add_argument("--url", required=True)
|
||||
p.add_argument("--tls-ca", type=Path)
|
||||
p.add_argument("--test-root", type=Path)
|
||||
p.add_argument("--agent-url", help="Explicit loopback read-only Agent adapter endpoint")
|
||||
p.add_argument("--hainuo-config", type=Path, help="Native installer-1.065 API adapter config; alternative to --agent-url")
|
||||
p = sub.add_parser("hainuo-probe")
|
||||
p.add_argument("--config", type=Path, required=True)
|
||||
p = sub.add_parser("web-pair")
|
||||
p.add_argument("--directory", type=Path, required=True)
|
||||
p.add_argument("--url", required=True)
|
||||
p.add_argument("--tls-ca", type=Path)
|
||||
for command in ("status", "binding-code", "dispatch", "revoke", "unbind", "reconcile"):
|
||||
p = sub.add_parser(command)
|
||||
p.add_argument("--url", default="http://127.0.0.1:18081")
|
||||
p.add_argument("--tls-ca", type=Path)
|
||||
if command in {"binding-code", "dispatch"}:
|
||||
p.add_argument("--owner", required=True)
|
||||
if command == "dispatch":
|
||||
p.add_argument("--text", required=True)
|
||||
p.add_argument("--turn-id", default=None)
|
||||
if command in {"revoke", "unbind"}:
|
||||
p.add_argument("--host-id", required=True)
|
||||
args = parser.parse_args()
|
||||
if args.command == "init":
|
||||
init_project(args.root, args.hostname)
|
||||
elif args.command == "serve":
|
||||
import uvicorn
|
||||
uvicorn.run(f"relay.{args.role}:create_app", factory=True, host=args.host, port=args.port,
|
||||
workers=1, access_log=False, proxy_headers=False,
|
||||
ws_max_size=262144, ws_max_queue=16, log_level="warning")
|
||||
elif args.command == "device-request":
|
||||
device_request(args.directory)
|
||||
elif args.command == "issue-device":
|
||||
issue(args.root, args.request, args.output)
|
||||
elif args.command == "register":
|
||||
import getpass
|
||||
secret = os.environ.get("HN_ADMIN_SECRET") or getpass.getpass("Admin secret: ")
|
||||
context = ssl.create_default_context(cafile=str(args.tls_ca)) if args.tls_ca else True
|
||||
with httpx.Client(verify=context, follow_redirects=False, timeout=15) as client:
|
||||
response = client.post(args.url.rstrip("/") + "/admin/devices",
|
||||
headers={"X-Admin-Secret": secret},
|
||||
json=json.loads(args.registration.read_text(encoding="utf-8")))
|
||||
if response.status_code != 201:
|
||||
raise RuntimeError(f"register failed: HTTP {response.status_code}")
|
||||
print("设备登记成功。")
|
||||
elif args.command == "bind":
|
||||
import getpass
|
||||
from .device import bind_device
|
||||
code = getpass.getpass("Binding code: ")
|
||||
context = ssl.create_default_context(cafile=str(args.tls_ca)) if args.tls_ca else True
|
||||
asyncio.run(bind_device(args.directory, args.url, code, tls_verify=context))
|
||||
print("绑定成功。")
|
||||
elif args.command == "device":
|
||||
from .device import run_device
|
||||
context = ssl.create_default_context(cafile=str(args.tls_ca)) if args.tls_ca else None
|
||||
asyncio.run(run_device(args.directory, args.url, root=args.test_root, ssl_context=context,
|
||||
agent_url=args.agent_url, hainuo_config=args.hainuo_config))
|
||||
elif args.command == "hainuo-probe":
|
||||
from .hainuo1065 import Hainuo1065Agent
|
||||
async def probe():
|
||||
adapter = Hainuo1065Agent(args.config)
|
||||
try:
|
||||
print(json.dumps(await adapter.probe(), ensure_ascii=False, indent=2))
|
||||
finally:
|
||||
await adapter.close()
|
||||
asyncio.run(probe())
|
||||
elif args.command == "web-pair":
|
||||
from .device import pair_browser
|
||||
context = ssl.create_default_context(cafile=str(args.tls_ca)) if args.tls_ca else True
|
||||
result = asyncio.run(pair_browser(args.directory, args.url, tls_verify=context))
|
||||
print("网页地址:" + result["url"])
|
||||
print("一次性网页配对码(120秒有效):" + result["code"])
|
||||
else:
|
||||
import getpass
|
||||
secret = os.environ.get("HN_ADMIN_SECRET") or getpass.getpass("Admin secret: ")
|
||||
context = ssl.create_default_context(cafile=str(args.tls_ca)) if args.tls_ca else True
|
||||
with httpx.Client(verify=context, timeout=200, follow_redirects=False) as client:
|
||||
paths = {"status": "/admin/devices", "binding-code": "/admin/test/binding-code",
|
||||
"dispatch": "/admin/test/dispatch", "reconcile": "/admin/reconcile"}
|
||||
if args.command in {"revoke", "unbind"}:
|
||||
if len(args.host_id) != 32 or any(c not in "0123456789abcdef" for c in args.host_id):
|
||||
raise ValueError("invalid host identity")
|
||||
path = f"/admin/devices/{args.host_id}/{args.command}"
|
||||
else:
|
||||
path = paths[args.command]
|
||||
body = None
|
||||
if args.command in {"binding-code", "dispatch"}:
|
||||
body = {"open_id": args.owner, "text": getattr(args, "text", "binding")}
|
||||
if getattr(args, "turn_id", None):
|
||||
body["turn_id"] = args.turn_id
|
||||
response = client.request("GET" if args.command == "status" else "POST", args.url.rstrip("/") + path,
|
||||
headers={"X-Admin-Secret": secret}, json=body)
|
||||
if response.status_code != 200:
|
||||
raise RuntimeError(f"operation failed: HTTP {response.status_code}")
|
||||
print(json.dumps(response.json(), ensure_ascii=False, indent=2))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,293 @@
|
||||
"""Per-user Windows connection companion. No platform/application secrets."""
|
||||
import argparse
|
||||
import asyncio
|
||||
import json
|
||||
import os
|
||||
import secrets
|
||||
import socket
|
||||
import ssl
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
|
||||
import httpx
|
||||
import psutil
|
||||
from cryptography.hazmat.primitives import serialization
|
||||
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
|
||||
from .crypto import load_private, load_public, pem_private, raw_public, sign, verified, verify_device
|
||||
from .windows_keys import protect
|
||||
|
||||
BASE = Path(__file__).resolve().parent.parent
|
||||
URL = "https://10.77.76.13"
|
||||
|
||||
|
||||
def save(path, value):
|
||||
temp = path.with_suffix(path.suffix + ".tmp")
|
||||
temp.write_text(json.dumps(value, ensure_ascii=False, indent=2), encoding="utf-8")
|
||||
os.replace(temp, path)
|
||||
|
||||
|
||||
def secure_directory(directory):
|
||||
directory.mkdir(parents=True, exist_ok=True)
|
||||
# SID avoids localized account names. Fail closed if ACL protection fails.
|
||||
result = subprocess.run(["whoami", "/user", "/fo", "csv", "/nh"], capture_output=True, text=True, check=True)
|
||||
import csv
|
||||
sid = list(csv.reader([result.stdout.strip()]))[0][1]
|
||||
subprocess.run(["icacls", str(directory), "/inheritance:r", "/grant:r", f"*{sid}:(OI)(CI)F", "*S-1-5-18:(OI)(CI)F"],
|
||||
capture_output=True, check=True, creationflags=subprocess.CREATE_NO_WINDOW)
|
||||
|
||||
|
||||
def prepare(directory):
|
||||
secure_directory(directory)
|
||||
for name in ("server.pem", "ca.pem", "connector.pub"):
|
||||
target = directory / name
|
||||
if not target.exists():
|
||||
target.write_bytes((BASE / "trust" / name).read_bytes())
|
||||
if not (directory / "device.json").exists():
|
||||
if (directory / "device.key.dpapi").exists() or (directory / "device.key").exists():
|
||||
raise RuntimeError("发现不完整的设备身份,请保留目录并联系管理员恢复。")
|
||||
private = Ed25519PrivateKey.generate()
|
||||
(directory / "device.key.dpapi").write_bytes(protect(pem_private(private)))
|
||||
save(directory / "device.json", {"host_id": uuid.uuid4().hex, "owner": None})
|
||||
|
||||
|
||||
def tls(directory):
|
||||
return ssl.create_default_context(cafile=str(directory / "server.pem"))
|
||||
|
||||
|
||||
def import_existing(directory, source):
|
||||
"""Explicit migration; only public trust and this PC's identity, never app keys."""
|
||||
if source.resolve() == directory.resolve():
|
||||
raise ValueError("请选择旧设备目录。")
|
||||
if any((directory / name).exists() for name in ("device.json", "device.key.dpapi", "device.key")):
|
||||
raise RuntimeError("本目录已有设备身份。请使用已有身份继续,不能用导入覆盖。")
|
||||
config = json.loads((source / "device.json").read_text(encoding="utf-8-sig"))
|
||||
for name in ("server.pem", "ca.pem", "connector.pub"):
|
||||
if (source / name).read_bytes().strip() != (BASE / "trust" / name).read_bytes().strip():
|
||||
raise ValueError("旧设备的服务信任与本安装包不符,请联系管理员。")
|
||||
cert = (source / "device.pem").read_text(encoding="utf-8")
|
||||
public = verify_device(cert, (source / "ca.pem").read_bytes(), config["host_id"])
|
||||
private = load_private(source / "device.key")
|
||||
if raw_public(public) != raw_public(private.public_key()):
|
||||
raise ValueError("设备证书与本机私钥不匹配。")
|
||||
secure_directory(directory)
|
||||
for name in ("device.pem", "server.pem", "ca.pem", "connector.pub"):
|
||||
(directory / name).write_bytes((source / name).read_bytes())
|
||||
(directory / "device.key.dpapi").write_bytes(protect(pem_private(private)))
|
||||
save(directory / "device.json", config)
|
||||
# Preserve local replay journal using SQLite's consistent backup API.
|
||||
if (source / "journal.sqlite").is_file():
|
||||
import sqlite3
|
||||
with sqlite3.connect(source / "journal.sqlite") as original, sqlite3.connect(directory / "journal.sqlite") as target:
|
||||
original.backup(target)
|
||||
return {"message": "旧设备导入成功,Work绑定已保留。请先停止旧PowerShell桥接窗口,再点击启动连接。"}
|
||||
|
||||
|
||||
def enrollment(directory):
|
||||
prepare(directory)
|
||||
cfg = json.loads((directory / "device.json").read_text())
|
||||
if (directory / "device.pem").exists():
|
||||
verify_device((directory / "device.pem").read_text(), (directory / "ca.pem").read_bytes(), cfg["host_id"])
|
||||
return {"message": "设备已注册,可在Work获取绑定码后绑定。已有绑定可直接启动连接。"}
|
||||
with httpx.Client(verify=tls(directory), trust_env=False, timeout=15) as http:
|
||||
key = load_private(directory / "device.key")
|
||||
proof = sign({"host_id": cfg["host_id"], "purpose": "device-enroll-v1", "ts": int(time.time()), "nonce": secrets.token_hex(16)}, key)
|
||||
response = http.post(URL + "/device/register", json={"host_id": cfg["host_id"], "proof": proof,
|
||||
"public_key": key.public_key().public_bytes(serialization.Encoding.PEM, serialization.PublicFormat.SubjectPublicKeyInfo).decode()})
|
||||
if response.status_code not in {200, 201}:
|
||||
raise RuntimeError("自动注册失败:HTTP " + str(response.status_code) + ";请确认ECS已安装1.067自动注册更新。")
|
||||
receipt = verified(response.json(), load_public(directory / "connector.pub"))
|
||||
if receipt.get("status") != "registered" or receipt["host_id"] != cfg["host_id"]:
|
||||
raise ValueError("注册回执身份不符")
|
||||
public = verify_device(receipt["cert"], (directory / "ca.pem").read_bytes(), cfg["host_id"])
|
||||
if raw_public(public) != raw_public(key.public_key()):
|
||||
raise ValueError("注册证书公钥不符")
|
||||
temp = directory / "device.pem.tmp"
|
||||
temp.write_text(receipt["cert"], encoding="utf-8")
|
||||
os.replace(temp, directory / "device.pem")
|
||||
(directory / "enrollment.json").unlink(missing_ok=True)
|
||||
return {"message": "设备已自动注册,无需管理员审批。请在Work获取绑定码,填写后点击绑定并连接。"}
|
||||
|
||||
|
||||
def managed_processes(directory):
|
||||
"""Only processes with our absolute entry path AND exact device directory."""
|
||||
state = directory / "processes.json"
|
||||
if not state.exists():
|
||||
return []
|
||||
result = []
|
||||
for item in json.loads(state.read_text()).get("processes", []):
|
||||
try:
|
||||
proc = psutil.Process(item["pid"])
|
||||
command = proc.cmdline()
|
||||
if (abs(proc.create_time() - item["created"]) < 0.1 and str(BASE / "entry.py") in command
|
||||
and str(directory) in command):
|
||||
result.append(proc)
|
||||
except psutil.Error:
|
||||
pass
|
||||
return result
|
||||
|
||||
|
||||
def stop(directory):
|
||||
procs = managed_processes(directory)
|
||||
# Supervisor owns and terminates only its own child handles in its finally block.
|
||||
(directory / "stop.flag").touch()
|
||||
_, alive = psutil.wait_procs(procs, timeout=8)
|
||||
for proc in alive:
|
||||
proc.terminate()
|
||||
return {"message": "已停止本安装包启动的连接进程。手工启动的旧桥接请在原窗口按Ctrl+C停止。"}
|
||||
|
||||
|
||||
def start(directory, root):
|
||||
from .process_lock import DeviceProcessLock
|
||||
with DeviceProcessLock(directory / "control"):
|
||||
return _start(directory, root)
|
||||
|
||||
|
||||
def _start(directory, root):
|
||||
cfg = json.loads((directory / "device.json").read_text())
|
||||
if not cfg.get("owner") or not (directory / "device.pem").exists():
|
||||
raise RuntimeError("请先完成设备准入和Work绑定。")
|
||||
if managed_processes(directory):
|
||||
return {"message": "连接进程已运行,请点击状态查看。"}
|
||||
(directory / "stop.flag").unlink(missing_ok=True)
|
||||
log = (directory / "bridge.log").open("a", encoding="utf-8")
|
||||
proc = subprocess.Popen([sys.executable, str(BASE / "entry.py"), "supervise", "--directory", str(directory), "--root", str(root)],
|
||||
stdout=log, stderr=log, creationflags=subprocess.CREATE_NO_WINDOW)
|
||||
log.close()
|
||||
save(directory / "processes.json", {"processes": [{"pid": proc.pid, "created": psutil.Process(proc.pid).create_time()}]})
|
||||
return {"message": "连接进程已启动;约30秒后点击状态,再到Work发送 /主机名 验证。"}
|
||||
|
||||
|
||||
def supervise(directory, root):
|
||||
from .process_lock import DeviceProcessLock
|
||||
lockdir = directory / "supervisor"
|
||||
with DeviceProcessLock(lockdir):
|
||||
children = []
|
||||
def record_children():
|
||||
processes = [psutil.Process(os.getpid())] + [psutil.Process(p.pid) for p in children if p.poll() is None]
|
||||
save(directory / "processes.json", {"processes": [{"pid": p.pid, "created": p.create_time()} for p in processes]})
|
||||
try:
|
||||
# Check local bind availability without an HTTP connection. Windows
|
||||
# filtering can time out connections to a closed port rather than
|
||||
# refuse them; that must not prevent starting our own listener.
|
||||
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as port_probe:
|
||||
try:
|
||||
if os.name == "nt":
|
||||
port_probe.setsockopt(socket.SOL_SOCKET, socket.SO_EXCLUSIVEADDRUSE, 1)
|
||||
port_probe.bind(("127.0.0.1", 18643))
|
||||
except OSError:
|
||||
raise RuntimeError("原生API端口18643被占用或不允许绑定,请先检查旧连接。") from None
|
||||
native = subprocess.Popen([sys.executable, str(BASE / "entry.py"), "native", "--directory", str(directory), "--root", str(root)])
|
||||
children.append(native)
|
||||
record_children()
|
||||
for _ in range(90):
|
||||
if (directory / "stop.flag").exists():
|
||||
return
|
||||
if native.poll() is not None:
|
||||
raise RuntimeError("本机原生API启动失败,请检查安装配置。")
|
||||
try:
|
||||
from .hainuo1065 import Hainuo1065Agent
|
||||
async def probe():
|
||||
agent = Hainuo1065Agent(directory / "hainuo-native.json")
|
||||
try:
|
||||
return await agent.probe()
|
||||
finally:
|
||||
await agent.close()
|
||||
asyncio.run(probe())
|
||||
break
|
||||
except Exception:
|
||||
time.sleep(1)
|
||||
else:
|
||||
raise RuntimeError("本机原生API未就绪。")
|
||||
bridge = subprocess.Popen([sys.executable, str(BASE / "entry.py"), "bridge", "--directory", str(directory), "--root", str(root)])
|
||||
children.append(bridge)
|
||||
record_children()
|
||||
while not (directory / "stop.flag").exists():
|
||||
if any(proc.poll() is not None for proc in children):
|
||||
raise RuntimeError("连接子进程已退出,请查看状态后重新启动。")
|
||||
time.sleep(0.5)
|
||||
finally:
|
||||
for proc in reversed(children):
|
||||
if proc.poll() is None:
|
||||
proc.terminate()
|
||||
try:
|
||||
proc.wait(timeout=5)
|
||||
except subprocess.TimeoutExpired:
|
||||
proc.kill()
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("action", choices=["authorize", "import", "enroll", "bind", "start", "stop", "status", "pair", "supervise", "native", "bridge"])
|
||||
parser.add_argument("--directory", type=Path, required=True)
|
||||
parser.add_argument("--root", type=Path, required=True)
|
||||
args = parser.parse_args()
|
||||
directory, root = args.directory.resolve(), args.root.resolve()
|
||||
directory.mkdir(parents=True, exist_ok=True)
|
||||
try:
|
||||
if args.action == "authorize":
|
||||
from .work_client import WorkClient
|
||||
client = WorkClient(directory)
|
||||
try:
|
||||
result = client.status()
|
||||
result["message"] += ("\n" + result["authorization_url"]) if result.get("authorization_url") else ""
|
||||
finally:
|
||||
client.close()
|
||||
elif args.action == "import":
|
||||
result = import_existing(directory, Path(sys.stdin.readline().strip()))
|
||||
elif args.action == "enroll":
|
||||
result = enrollment(directory)
|
||||
elif args.action == "bind":
|
||||
from .device import bind_device
|
||||
code = sys.stdin.readline().strip()
|
||||
if not code:
|
||||
raise ValueError("请填写Work机器人新生成的绑定码。")
|
||||
enrollment(directory)
|
||||
stop(directory)
|
||||
asyncio.run(bind_device(directory, URL, code, tls_verify=tls(directory)))
|
||||
result = start(directory, root)
|
||||
result["message"] = "Work绑定成功。" + result["message"]
|
||||
elif args.action == "start":
|
||||
result = start(directory, root)
|
||||
elif args.action == "stop":
|
||||
result = stop(directory)
|
||||
elif args.action == "pair":
|
||||
from .device import pair_browser
|
||||
receipt = asyncio.run(pair_browser(directory, URL, tls_verify=tls(directory)))
|
||||
result = {"message": "网页:" + receipt["url"] + "\n一次性配对码(120秒):" + receipt["code"]}
|
||||
elif args.action == "status":
|
||||
cfg = json.loads((directory / "device.json").read_text()) if (directory / "device.json").exists() else {}
|
||||
log = directory / "bridge.log"
|
||||
tail = log.read_bytes()[-6000:].decode("utf-8", errors="replace") if log.exists() else ""
|
||||
result = {"message": "设备:" + cfg.get("host_id", "未申请") + "\nWork身份:" + (cfg.get("owner") or "未绑定")
|
||||
+ "\n连接进程:" + ("运行中(请在Work发送 /主机名 确认当前链路)" if managed_processes(directory) else "未运行") + "\n" + tail[-2500:]}
|
||||
elif args.action == "supervise":
|
||||
return supervise(directory, root)
|
||||
elif args.action == "native":
|
||||
os.environ["HN_WORK_DEVICE_DIR"] = str(directory)
|
||||
import importlib.util
|
||||
spec = importlib.util.spec_from_file_location("native_companion", BASE / "hainuo_native_api.py")
|
||||
module = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(module)
|
||||
module.enable_profile_tools(root, "hainuo")
|
||||
key = module.prepare_environment(root, "hainuo", 18643, directory / "hainuo-native.json", enable_tools=True)
|
||||
import logging
|
||||
logging.disable(logging.CRITICAL)
|
||||
return asyncio.run(module.serve_native(18643, key, enable_tools=True))
|
||||
else:
|
||||
from .device import run_device
|
||||
return asyncio.run(run_device(directory, "wss://10.77.76.13/device/ws", ssl_context=tls(directory), hainuo_config=directory / "hainuo-native.json"))
|
||||
print(json.dumps(result, ensure_ascii=False))
|
||||
except KeyboardInterrupt:
|
||||
pass
|
||||
except Exception as error:
|
||||
# Native exception bodies may include URLs or secrets; emit bounded known messages only.
|
||||
message = str(error) if isinstance(error, (RuntimeError, ValueError)) else type(error).__name__ + ";请检查网络、证书、安装目录。"
|
||||
print(json.dumps({"message": message[:600], "error": True}, ensure_ascii=False))
|
||||
raise SystemExit(1) from None
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,61 @@
|
||||
import hashlib
|
||||
import hmac
|
||||
import json
|
||||
import time
|
||||
from fastapi import HTTPException, Request
|
||||
from starlette.responses import JSONResponse
|
||||
|
||||
|
||||
def require_secret(actual, expected):
|
||||
if not actual or not hmac.compare_digest(actual, expected):
|
||||
raise HTTPException(401, "unauthorized")
|
||||
|
||||
|
||||
async def rate_limit(redis, bucket: str, limit=60, seconds=60):
|
||||
# Atomic counter + expiry: a crash cannot leave a permanent bucket.
|
||||
key = "hn:rate:" + hashlib.sha256(bucket.encode()).hexdigest() + ":" + str(int(time.time()) // seconds)
|
||||
pipe = redis.pipeline(transaction=True)
|
||||
pipe.incr(key)
|
||||
pipe.expire(key, seconds * 2)
|
||||
result = (await pipe.execute())[0]
|
||||
if int(result) > limit:
|
||||
raise HTTPException(429, "rate limited", headers={"Retry-After": str(seconds)})
|
||||
|
||||
|
||||
class BodyLimitMiddleware:
|
||||
def __init__(self, app, max_body=262144):
|
||||
self.app, self.max_body = app, max_body
|
||||
|
||||
async def __call__(self, scope, receive, send):
|
||||
if scope["type"] != "http":
|
||||
return await self.app(scope, receive, send)
|
||||
messages, size = [], 0
|
||||
while True:
|
||||
message = await receive()
|
||||
if message["type"] == "http.disconnect":
|
||||
return
|
||||
size += len(message.get("body", b""))
|
||||
if size > self.max_body:
|
||||
return await JSONResponse({"detail": "body too large"}, status_code=413)(scope, receive, send)
|
||||
messages.append(message)
|
||||
if not message.get("more_body", False):
|
||||
break
|
||||
async def buffered():
|
||||
return messages.pop(0) if messages else await receive()
|
||||
await self.app(scope, buffered, send)
|
||||
|
||||
|
||||
def no_cache(response):
|
||||
response.headers["Cache-Control"] = "no-store"
|
||||
response.headers["X-Content-Type-Options"] = "nosniff"
|
||||
response.headers["Referrer-Policy"] = "no-referrer"
|
||||
return response
|
||||
|
||||
|
||||
async def json_pub(redis, channel, data):
|
||||
return await redis.publish(channel, json.dumps(data, separators=(",", ":")))
|
||||
|
||||
|
||||
def peer(request: Request):
|
||||
# Do not trust arbitrary X-Forwarded-For; configure uvicorn trusted proxies explicitly.
|
||||
return request.client.host if request.client else "unknown"
|
||||
@@ -0,0 +1,66 @@
|
||||
from pathlib import Path
|
||||
from pydantic import model_validator
|
||||
from pydantic_settings import BaseSettings, SettingsConfigDict
|
||||
|
||||
|
||||
class Settings(BaseSettings):
|
||||
model_config = SettingsConfigDict(env_prefix="HN_", extra="ignore", hide_input_in_errors=True)
|
||||
environment: str = "production"
|
||||
role: str = "connector"
|
||||
redis_url: str = "redis://127.0.0.1:6379/0"
|
||||
data_dir: Path = Path("runtime/connector")
|
||||
database_url: str = ""
|
||||
admin_secret: str = ""
|
||||
internal_secret: str = ""
|
||||
ca_cert: Path = Path("runtime/pki/ca.pem")
|
||||
connector_key: Path = Path("runtime/pki/connector.key")
|
||||
connector_public_key: Path = Path("runtime/pki/connector.pub")
|
||||
public_url: str = "https://relay.example.invalid"
|
||||
router_url: str = "wss://relay.example.invalid/device/ws"
|
||||
device_domain: str = ""
|
||||
feishu_api_base: str = "https://open.feishu.cn"
|
||||
feishu_authorize_url: str = "https://open.feishu.cn/open-apis/authen/v1/authorize"
|
||||
feishu_oauth_scopes: str = ""
|
||||
feishu_app_id: str = ""
|
||||
feishu_app_secret: str = ""
|
||||
feishu_encrypt_key: str = ""
|
||||
feishu_verification_token: str = ""
|
||||
feishu_enabled: bool = False
|
||||
oauth_enabled: bool = True
|
||||
feishu_event_source: str = "longconn"
|
||||
proxy_enabled: bool = False
|
||||
# A fixed allowlist, never a user supplied upstream URL.
|
||||
proxy_paths: str = "/open-apis/drive/v1/files,/open-apis/docx/v1/documents"
|
||||
request_timeout: int = 45
|
||||
max_body: int = 262144
|
||||
max_pending: int = 1000
|
||||
max_devices: int = 1000
|
||||
max_connections: int = 1000
|
||||
max_result: int = 16000
|
||||
allow_insecure_local: bool = False
|
||||
enrollment_signer_url: str = ""
|
||||
|
||||
@model_validator(mode="after")
|
||||
def validate_runtime(self):
|
||||
if self.environment not in {"production", "test", "development"}:
|
||||
raise ValueError("invalid environment")
|
||||
if self.role == "connector" and min(len(self.admin_secret), len(self.internal_secret)) < 32:
|
||||
raise ValueError("admin/internal secrets must each be at least 32 characters")
|
||||
if self.role == "longconn" and len(self.internal_secret) < 32:
|
||||
raise ValueError("internal credential must be at least 32 characters")
|
||||
if self.role == "connector" and self.admin_secret == self.internal_secret:
|
||||
raise ValueError("admin and internal credentials must be different")
|
||||
if self.environment == "production":
|
||||
if self.allow_insecure_local or not self.public_url.startswith("https://"):
|
||||
raise ValueError("production requires HTTPS")
|
||||
if not self.router_url.startswith("wss://"):
|
||||
raise ValueError("production requires WSS")
|
||||
if not self.feishu_api_base.startswith("https://"):
|
||||
raise ValueError("platform API requires HTTPS")
|
||||
if self.feishu_event_source not in {"longconn", "webhook"}:
|
||||
raise ValueError("invalid platform event source")
|
||||
if self.feishu_enabled and not all((self.feishu_app_id, self.feishu_app_secret)):
|
||||
raise ValueError("platform app ID and secret are required")
|
||||
if self.feishu_enabled and self.feishu_event_source == "webhook" and not all((self.feishu_encrypt_key, self.feishu_verification_token)):
|
||||
raise ValueError("webhook requires encryption key and verification token")
|
||||
return self
|
||||
@@ -0,0 +1,506 @@
|
||||
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 (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] = {}
|
||||
|
||||
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
|
||||
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):
|
||||
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"]
|
||||
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": "该请求已接收,不会重复执行。"}
|
||||
private = x25519.X25519PrivateKey.generate()
|
||||
future = asyncio.get_running_loop().create_future()
|
||||
self.pending[turn] = Pending(future, private, public, host, session)
|
||||
envelope = seal({"type": "instruction", "turn_id": turn, "owner": owner,
|
||||
"text": text, "read_only": True, "channel": "im",
|
||||
"reply_key": raw_public(private.public_key())}, proof["kx"], self.signer,
|
||||
host_id=host, session_id=session)
|
||||
key = f"hn:inflight:{host}:{turn}"
|
||||
try:
|
||||
await self.r.set(key, session, ex=self.s.request_timeout + 5)
|
||||
count = await self.r.publish("hn:down:" + host, json.dumps({"type": "instruction", "envelope": envelope}))
|
||||
if not count:
|
||||
self.store.finish(turn, "offline")
|
||||
return {"status": "offline", "turn_id": turn, "result": "你的电脑当前离线。"}
|
||||
result = await asyncio.wait_for(future, timeout=self.s.request_timeout)
|
||||
self.store.finish(turn, "completed")
|
||||
self.store.audit(owner, "instruction", host, "completed")
|
||||
return result
|
||||
except asyncio.TimeoutError:
|
||||
self.store.finish(turn, "unknown")
|
||||
return {"status": "unknown", "turn_id": turn,
|
||||
"result": "等待结果超时,执行状态未知;不要直接重发有副作用的任务。"}
|
||||
finally:
|
||||
self.pending.pop(turn, None)
|
||||
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)
|
||||
oauth = OAuth(s, r, f)
|
||||
oauth.store = store
|
||||
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()
|
||||
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)
|
||||
async with oauth.lock:
|
||||
oauth.prune()
|
||||
sweep_task = asyncio.create_task(sweep())
|
||||
try:
|
||||
yield
|
||||
finally:
|
||||
for task in [reply_task, sweep_task, *background]:
|
||||
task.cancel()
|
||||
await asyncio.gather(reply_task, sweep_task, *background, return_exceptions=True)
|
||||
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)
|
||||
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.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))
|
||||
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")
|
||||
# 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)
|
||||
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 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)
|
||||
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
|
||||
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, "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 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
|
||||
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 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()))["result"]
|
||||
else:
|
||||
instruction = text if text.startswith("/助手 ") else "/助手 " + text
|
||||
result = (await broker.dispatch(owner, instruction, "msg_" + hashlib.sha256(message_id.encode()).hexdigest()))["result"]
|
||||
await f.reply(message_id, result[:s.max_result])
|
||||
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
|
||||
@@ -0,0 +1,140 @@
|
||||
"""Signed ephemeral X25519 envelopes. The router never receives plaintext keys."""
|
||||
import base64
|
||||
import hashlib
|
||||
import json
|
||||
import secrets
|
||||
import time
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
from cryptography import x509
|
||||
from cryptography.hazmat.primitives import hashes, serialization
|
||||
from cryptography.hazmat.primitives.asymmetric import ed25519, x25519
|
||||
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
|
||||
from cryptography.hazmat.primitives.kdf.hkdf import HKDF
|
||||
from cryptography.x509.oid import ExtendedKeyUsageOID, NameOID
|
||||
|
||||
|
||||
def b64(data: bytes) -> str:
|
||||
return base64.urlsafe_b64encode(data).decode()
|
||||
|
||||
|
||||
def unb64(data: str) -> bytes:
|
||||
return base64.b64decode(data.encode(), altchars=b"-_", validate=True)
|
||||
|
||||
|
||||
def canonical(data: dict) -> bytes:
|
||||
return json.dumps(data, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode()
|
||||
|
||||
|
||||
def raw_public(key) -> str:
|
||||
return b64(key.public_bytes(serialization.Encoding.Raw, serialization.PublicFormat.Raw))
|
||||
|
||||
|
||||
def pem_private(key) -> bytes:
|
||||
return key.private_bytes(serialization.Encoding.PEM, serialization.PrivateFormat.PKCS8,
|
||||
serialization.NoEncryption())
|
||||
|
||||
|
||||
def load_private(path):
|
||||
protected = path.with_name(path.name + ".dpapi")
|
||||
if protected.is_file():
|
||||
from .windows_keys import unprotect
|
||||
data = unprotect(protected.read_bytes())
|
||||
else:
|
||||
data = path.read_bytes()
|
||||
return serialization.load_pem_private_key(data, password=None)
|
||||
|
||||
|
||||
def load_public(path):
|
||||
return serialization.load_pem_public_key(path.read_bytes())
|
||||
|
||||
|
||||
def fingerprint(pem: str) -> str:
|
||||
return x509.load_pem_x509_certificate(pem.encode()).fingerprint(hashes.SHA256()).hex()
|
||||
|
||||
|
||||
def verify_device(pem: str, ca_pem: bytes, host_id: str):
|
||||
"""v1 deliberately accepts only directly issued Ed25519 device certificates."""
|
||||
cert = x509.load_pem_x509_certificate(pem.encode())
|
||||
ca = x509.load_pem_x509_certificate(ca_pem)
|
||||
now = datetime.now(timezone.utc)
|
||||
if not (ca.not_valid_before_utc <= now <= ca.not_valid_after_utc):
|
||||
raise ValueError("expired CA")
|
||||
if not ca.extensions.get_extension_for_class(x509.BasicConstraints).value.ca:
|
||||
raise ValueError("not a CA")
|
||||
cert.verify_directly_issued_by(ca)
|
||||
if not (cert.not_valid_before_utc <= now <= cert.not_valid_after_utc):
|
||||
raise ValueError("expired certificate")
|
||||
if cert.extensions.get_extension_for_class(x509.BasicConstraints).value.ca:
|
||||
raise ValueError("CA cannot be used as device")
|
||||
if ExtendedKeyUsageOID.CLIENT_AUTH not in cert.extensions.get_extension_for_class(x509.ExtendedKeyUsage).value:
|
||||
raise ValueError("clientAuth missing")
|
||||
names = cert.extensions.get_extension_for_class(x509.SubjectAlternativeName).value
|
||||
if names.get_values_for_type(x509.UniformResourceIdentifier) != [f"urn:hainuo:host:{host_id}"]:
|
||||
raise ValueError("host identity mismatch")
|
||||
public = cert.public_key()
|
||||
if not isinstance(public, ed25519.Ed25519PublicKey):
|
||||
raise ValueError("v1 requires Ed25519 device key")
|
||||
return public
|
||||
|
||||
|
||||
def sign(data: dict, key) -> dict:
|
||||
return {**data, "signature": b64(key.sign(canonical(data)))}
|
||||
|
||||
|
||||
def verified(data: dict, key) -> dict:
|
||||
body = {k: v for k, v in data.items() if k != "signature"}
|
||||
key.verify(unb64(data["signature"]), canonical(body))
|
||||
return body
|
||||
|
||||
|
||||
def seal(payload: dict, recipient_public: str, signer, *, host_id: str, session_id: str) -> dict:
|
||||
ephemeral = x25519.X25519PrivateKey.generate()
|
||||
header = {"v": 1, "host_id": host_id, "session_id": session_id,
|
||||
"ts": int(time.time()), "nonce": b64(secrets.token_bytes(12)),
|
||||
"ephemeral": raw_public(ephemeral.public_key())}
|
||||
shared = ephemeral.exchange(x25519.X25519PublicKey.from_public_bytes(unb64(recipient_public)))
|
||||
key = HKDF(algorithm=hashes.SHA256(), length=32, salt=session_id.encode(),
|
||||
info=b"hainuo-relay-envelope-v1").derive(shared)
|
||||
cipher = AESGCM(key).encrypt(unb64(header["nonce"]), canonical(payload), canonical(header))
|
||||
return sign({**header, "ciphertext": b64(cipher)}, signer)
|
||||
|
||||
|
||||
def open_envelope(envelope: dict, recipient_private, sender_public, *, host_id: str, session_id: str) -> dict:
|
||||
body = verified(envelope, sender_public)
|
||||
if body["v"] != 1 or body["host_id"] != host_id or body["session_id"] != session_id:
|
||||
raise ValueError("wrong destination/session")
|
||||
if abs(time.time() - body["ts"]) > 90:
|
||||
raise ValueError("expired envelope")
|
||||
header = {k: v for k, v in body.items() if k != "ciphertext"}
|
||||
shared = recipient_private.exchange(x25519.X25519PublicKey.from_public_bytes(unb64(body["ephemeral"])))
|
||||
key = HKDF(algorithm=hashes.SHA256(), length=32, salt=session_id.encode(),
|
||||
info=b"hainuo-relay-envelope-v1").derive(shared)
|
||||
plain = AESGCM(key).decrypt(unb64(body["nonce"]), unb64(body["ciphertext"]), canonical(header))
|
||||
return json.loads(plain)
|
||||
|
||||
|
||||
def issue_ca():
|
||||
key = ed25519.Ed25519PrivateKey.generate()
|
||||
name = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, "Hainuo device test CA")])
|
||||
now = datetime.now(timezone.utc)
|
||||
cert = (x509.CertificateBuilder().subject_name(name).issuer_name(name)
|
||||
.public_key(key.public_key()).serial_number(x509.random_serial_number())
|
||||
.not_valid_before(now - timedelta(minutes=5)).not_valid_after(now + timedelta(days=3650))
|
||||
.add_extension(x509.BasicConstraints(ca=True, path_length=0), critical=True)
|
||||
.add_extension(x509.KeyUsage(False, False, False, False, False, True, True, False, False), critical=True)
|
||||
.sign(key, algorithm=None))
|
||||
return key, cert
|
||||
|
||||
|
||||
def issue_device(ca_key, ca_cert, host_id: str, public_key, days=30):
|
||||
now = datetime.now(timezone.utc)
|
||||
return (x509.CertificateBuilder()
|
||||
.subject_name(x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, host_id)]))
|
||||
.issuer_name(ca_cert.subject).public_key(public_key)
|
||||
.serial_number(x509.random_serial_number())
|
||||
.not_valid_before(now - timedelta(minutes=5)).not_valid_after(now + timedelta(days=days))
|
||||
.add_extension(x509.BasicConstraints(ca=False, path_length=None), critical=True)
|
||||
.add_extension(x509.SubjectAlternativeName([x509.UniformResourceIdentifier(f"urn:hainuo:host:{host_id}")]), critical=False)
|
||||
.add_extension(x509.ExtendedKeyUsage([ExtendedKeyUsageOID.CLIENT_AUTH]), critical=False)
|
||||
.sign(ca_key, algorithm=None))
|
||||
@@ -0,0 +1,216 @@
|
||||
"""Reference PC bridge. No shell/PowerShell execution; local read-only diagnostics."""
|
||||
import asyncio
|
||||
import contextlib
|
||||
import json
|
||||
import os
|
||||
import secrets
|
||||
import socket
|
||||
import sqlite3
|
||||
import time
|
||||
from pathlib import Path
|
||||
from urllib.parse import urlsplit
|
||||
|
||||
import httpx
|
||||
from cryptography.hazmat.primitives.asymmetric import x25519
|
||||
from websockets.asyncio.client import connect
|
||||
|
||||
from .crypto import (load_private, load_public, open_envelope, raw_public, seal, sign,
|
||||
verified, verify_device)
|
||||
|
||||
|
||||
class DeviceJournal:
|
||||
def __init__(self, path):
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
self.db = sqlite3.connect(path)
|
||||
self.db.execute("CREATE TABLE IF NOT EXISTS consumed(turn_id TEXT PRIMARY KEY, ts REAL NOT NULL)")
|
||||
self.db.commit()
|
||||
|
||||
def consume(self, turn):
|
||||
with self.db:
|
||||
return self.db.execute("INSERT OR IGNORE INTO consumed VALUES(?,?)", (turn, time.time())).rowcount == 1
|
||||
|
||||
def close(self):
|
||||
self.db.close()
|
||||
|
||||
|
||||
async def execute_readonly(text, root: Path | None):
|
||||
if text in {"/主机名", "hostname"}:
|
||||
return socket.gethostname()
|
||||
if text.startswith("/回显 "):
|
||||
return text[4:][:16000]
|
||||
if text.startswith("/读取 "):
|
||||
if root is None:
|
||||
return "未配置测试文件目录。"
|
||||
base = root.resolve(strict=True)
|
||||
try:
|
||||
path = (base / text[4:].strip()).resolve(strict=True)
|
||||
if path == base or not path.is_relative_to(base) or not path.is_file():
|
||||
return "拒绝:文件不在允许的测试目录。"
|
||||
if path.stat().st_size > 32768:
|
||||
return "拒绝:测试文件超过32KB。"
|
||||
return path.read_text(encoding="utf-8")[:16000]
|
||||
except (OSError, UnicodeError, ValueError):
|
||||
return "拒绝:文件不存在、不可读或不是UTF-8文本。"
|
||||
return "当前桥接客户端仅开放只读诊断:/主机名、/回显 内容、/读取 相对路径;尚未接入海诺本地Agent接口。"
|
||||
|
||||
|
||||
class LocalAgent:
|
||||
"""Explicit adapter contract, not a claim of compatibility with installer 1.065."""
|
||||
def __init__(self, url, transport=None):
|
||||
parts = urlsplit(url)
|
||||
if parts.scheme != "http" or parts.hostname not in {"127.0.0.1", "::1"} or parts.username or parts.password or parts.fragment:
|
||||
raise ValueError("local Agent must use a fixed loopback HTTP endpoint")
|
||||
self.url = url
|
||||
self.http = httpx.AsyncClient(timeout=30, follow_redirects=False, transport=transport, trust_env=False)
|
||||
|
||||
async def execute(self, text, owner, turn):
|
||||
headers = {}
|
||||
if os.environ.get("HN_LOCAL_AGENT_TOKEN"):
|
||||
headers["Authorization"] = "Bearer " + os.environ["HN_LOCAL_AGENT_TOKEN"]
|
||||
try:
|
||||
async with self.http.stream("POST", self.url, headers=headers,
|
||||
json={"text": text, "open_id": owner, "turn_id": turn,
|
||||
"channel": "im", "read_only": True}) as response:
|
||||
if response.status_code != 200:
|
||||
return "本机Agent未返回成功结果,请查看本机服务状态。"
|
||||
body = b""
|
||||
async for chunk in response.aiter_bytes():
|
||||
body += chunk
|
||||
if len(body) > 65536:
|
||||
return "本机Agent结果超过限制。"
|
||||
result = json.loads(body)["result"]
|
||||
if not isinstance(result, str):
|
||||
return "本机Agent响应格式不匹配。"
|
||||
return result[:16000]
|
||||
except (httpx.HTTPError, ValueError, KeyError):
|
||||
return "本机Agent连接失败或响应格式不匹配。"
|
||||
|
||||
async def close(self):
|
||||
await self.http.aclose()
|
||||
|
||||
|
||||
async def bind_device(directory: Path, connector_url: str, code: str, *, tls_verify=True):
|
||||
config = json.loads((directory / "device.json").read_text(encoding="utf-8"))
|
||||
private = load_private(directory / "device.key")
|
||||
proof = sign({"host_id": config["host_id"], "code": code, "ts": int(time.time())}, private)
|
||||
async with httpx.AsyncClient(verify=tls_verify, trust_env=False, follow_redirects=False, timeout=15) as http:
|
||||
response = await http.post(connector_url.rstrip("/") + "/device/bind",
|
||||
json={"host_id": config["host_id"], "proof": proof})
|
||||
if response.status_code != 200:
|
||||
raise RuntimeError(f"binding failed: HTTP {response.status_code}")
|
||||
receipt = verified(response.json(), load_public(directory / "connector.pub"))
|
||||
if receipt["host_id"] != config["host_id"]:
|
||||
raise ValueError("wrong binding receipt")
|
||||
config["owner"] = receipt["owner"]
|
||||
temp = directory / "device.json.tmp"
|
||||
temp.write_text(json.dumps(config, ensure_ascii=False, indent=2), encoding="utf-8")
|
||||
temp.replace(directory / "device.json")
|
||||
|
||||
|
||||
async def pair_browser(directory: Path, connector_url: str, *, tls_verify=True):
|
||||
config = json.loads((directory / "device.json").read_text(encoding="utf-8-sig"))
|
||||
if not config.get("owner"):
|
||||
raise RuntimeError("device must be bound first")
|
||||
key = load_private(directory / "device.key")
|
||||
proof = sign({"host_id": config["host_id"], "owner": config["owner"],
|
||||
"purpose": "h5-pair-v1", "ts": int(time.time()), "nonce": secrets.token_hex(16)}, key)
|
||||
async with httpx.AsyncClient(verify=tls_verify, trust_env=False, follow_redirects=False, timeout=15) as client:
|
||||
response = await client.post(connector_url.rstrip("/") + "/device/web-pair",
|
||||
json={"host_id": config["host_id"], "proof": proof})
|
||||
if response.status_code != 200:
|
||||
raise RuntimeError(f"browser pairing failed: HTTP {response.status_code}")
|
||||
result = verified(response.json(), load_public(directory / "connector.pub"))
|
||||
if result["host_id"] != config["host_id"]:
|
||||
raise ValueError("wrong pairing receipt")
|
||||
return result
|
||||
|
||||
|
||||
async def run_device(directory: Path, router_url: str, **kwargs):
|
||||
from .process_lock import DeviceProcessLock
|
||||
with DeviceProcessLock(directory):
|
||||
return await _run_device(directory, router_url, **kwargs)
|
||||
|
||||
|
||||
async def _run_device(directory: Path, router_url: str, *, root=None, once=False, ssl_context=None,
|
||||
stop_event=None, connected_event=None, agent_url=None, hainuo_config=None):
|
||||
config = json.loads((directory / "device.json").read_text(encoding="utf-8"))
|
||||
if not config.get("owner"):
|
||||
raise RuntimeError("bind device before starting")
|
||||
host, owner = config["host_id"], config["owner"]
|
||||
key = load_private(directory / "device.key")
|
||||
connector = load_public(directory / "connector.pub")
|
||||
cert = (directory / "device.pem").read_text(encoding="utf-8")
|
||||
verify_device(cert, (directory / "ca.pem").read_bytes(), host)
|
||||
journal = DeviceJournal(directory / "journal.sqlite")
|
||||
if agent_url and hainuo_config:
|
||||
raise ValueError("choose one Agent adapter")
|
||||
if hainuo_config:
|
||||
from .hainuo1065 import Hainuo1065Agent
|
||||
agent = Hainuo1065Agent(hainuo_config)
|
||||
else:
|
||||
agent = LocalAgent(agent_url) if agent_url else None
|
||||
stop_event = stop_event or asyncio.Event()
|
||||
delay = 1
|
||||
try:
|
||||
while not stop_event.is_set():
|
||||
try:
|
||||
kwargs = {"ssl": ssl_context} if router_url.startswith("wss://") and ssl_context else {}
|
||||
async with connect(router_url, max_size=262144, open_timeout=10, ping_interval=10,
|
||||
proxy=None, **kwargs) as ws:
|
||||
challenge = json.loads(await ws.recv())["challenge"]
|
||||
ephemeral = x25519.X25519PrivateKey.generate()
|
||||
session = secrets.token_hex(16)
|
||||
proof = sign({"host_id": host, "session_id": session, "challenge": challenge,
|
||||
"kx": raw_public(ephemeral.public_key()), "ts": int(time.time())}, key)
|
||||
await ws.send(json.dumps({"host_id": host, "cert": cert, "proof": proof}))
|
||||
accepted = json.loads(await ws.recv())
|
||||
if accepted.get("type") != "connected":
|
||||
raise RuntimeError("device connection rejected")
|
||||
print("设备连接成功,已绑定本人海能Work身份。", flush=True)
|
||||
if connected_event:
|
||||
connected_event.set()
|
||||
delay = 1
|
||||
while not stop_event.is_set():
|
||||
try:
|
||||
raw = await asyncio.wait_for(ws.recv(), timeout=1)
|
||||
except asyncio.TimeoutError:
|
||||
continue
|
||||
data = json.loads(raw)
|
||||
payload = open_envelope(data["envelope"], ephemeral, connector,
|
||||
host_id=host, session_id=session)
|
||||
if payload.get("owner") != owner or payload.get("type") != "instruction":
|
||||
continue
|
||||
turn = payload["turn_id"]
|
||||
if not isinstance(turn, str) or len(turn) > 128:
|
||||
continue
|
||||
if not journal.consume(turn):
|
||||
result = "该请求已处理,拒绝重复执行。"
|
||||
elif payload.get("read_only") is not True or payload.get("channel") != "im":
|
||||
result = "拒绝:通道或操作类型不受支持。"
|
||||
else:
|
||||
if agent and payload["text"].startswith("/助手 "):
|
||||
result = await agent.execute(payload["text"][4:], owner, turn)
|
||||
else:
|
||||
result = await execute_readonly(payload["text"], root)
|
||||
reply = seal({"type": "result", "turn_id": turn, "result": result},
|
||||
payload["reply_key"], key, host_id=host, session_id=session)
|
||||
await ws.send(json.dumps({"type": "reply", "turn_id": turn, "envelope": reply}))
|
||||
if once:
|
||||
return
|
||||
except asyncio.CancelledError:
|
||||
raise
|
||||
except Exception as error:
|
||||
if once:
|
||||
raise
|
||||
from websockets.exceptions import ConnectionClosed
|
||||
if isinstance(error, ConnectionClosed) and error.rcvd and error.rcvd.code == 1008:
|
||||
print("设备被中继拒绝:请检查是否有另一桥接进程、设备准入或证书状态。", flush=True)
|
||||
# No payloads/URLs/credentials in logs, bounded reconnect backoff + jitter.
|
||||
print("设备连接中断,等待重连。", flush=True)
|
||||
with contextlib.suppress(asyncio.TimeoutError):
|
||||
await asyncio.wait_for(stop_event.wait(), timeout=delay + secrets.randbelow(1000) / 1000)
|
||||
delay = min(delay * 2, 30)
|
||||
finally:
|
||||
journal.close()
|
||||
if agent:
|
||||
await agent.close()
|
||||
@@ -0,0 +1,178 @@
|
||||
"""Device registration with key possession proof; Work binding is separate."""
|
||||
import json
|
||||
import secrets
|
||||
import time
|
||||
import httpx
|
||||
|
||||
from cryptography.hazmat.primitives import serialization
|
||||
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
|
||||
from fastapi import APIRouter, HTTPException, Request
|
||||
from pydantic import BaseModel, Field
|
||||
from .common import no_cache, peer, rate_limit
|
||||
from .crypto import verified, sign, raw_public, verify_device, fingerprint
|
||||
from .web_session import digest
|
||||
from fastapi.responses import JSONResponse
|
||||
|
||||
|
||||
def validate_enrollment(body):
|
||||
try:
|
||||
key = serialization.load_pem_public_key(body.public_key.encode())
|
||||
if not isinstance(key, Ed25519PublicKey):
|
||||
raise ValueError()
|
||||
proof = verified(body.proof, key)
|
||||
if (proof["host_id"] != body.host_id or proof["purpose"] != "device-enroll-v1"
|
||||
or abs(time.time() - proof["ts"]) > 90 or len(proof["nonce"]) != 32):
|
||||
raise ValueError()
|
||||
return key
|
||||
except Exception:
|
||||
raise HTTPException(403, "invalid enrollment proof") from None
|
||||
|
||||
|
||||
async def request_certificate(settings, body):
|
||||
async with httpx.AsyncClient(trust_env=False, timeout=15, follow_redirects=False) as http:
|
||||
response = await http.post(settings.enrollment_signer_url.rstrip("/") + "/issue",
|
||||
headers={"X-Internal-Secret": settings.internal_secret},
|
||||
json=body.model_dump())
|
||||
response.raise_for_status()
|
||||
return response.json()["cert"]
|
||||
|
||||
|
||||
class EnrollmentRequest(BaseModel):
|
||||
host_id: str = Field(pattern=r"^[a-f0-9]{32}$")
|
||||
public_key: str = Field(max_length=1024)
|
||||
proof: dict
|
||||
|
||||
|
||||
class EnrollmentApproval(BaseModel):
|
||||
cert: str = Field(max_length=10000)
|
||||
|
||||
|
||||
def enrollment_router(settings, redis, store, signer, admin):
|
||||
router = APIRouter()
|
||||
|
||||
@router.post("/device/register")
|
||||
async def automatic_registration(body: EnrollmentRequest, request: Request):
|
||||
# No human approval: eligibility follows intranet access plus Work app scope.
|
||||
# Proof/TLS/limits protect identity and resources, and do not add user approval.
|
||||
await rate_limit(redis, "auto-register-ip:" + peer(request), 120)
|
||||
key = validate_enrollment(body)
|
||||
await rate_limit(redis, "auto-register-host:" + body.host_id, 30)
|
||||
existing = store.device(body.host_id)
|
||||
|
||||
def check_existing(device):
|
||||
if device["revoked"]:
|
||||
raise HTTPException(403, "device revoked")
|
||||
try:
|
||||
registered = verify_device(device["cert"], settings.ca_cert.read_bytes(), body.host_id)
|
||||
if raw_public(registered) != raw_public(key):
|
||||
raise ValueError()
|
||||
except Exception:
|
||||
raise HTTPException(409, "existing device identity mismatch or certificate expired") from None
|
||||
return device["cert"]
|
||||
|
||||
if existing:
|
||||
cert = check_existing(existing)
|
||||
else:
|
||||
if not settings.enrollment_signer_url:
|
||||
raise HTTPException(503, "automatic registration is not enabled; update ECS first")
|
||||
if store.db.execute("SELECT COUNT(*) AS total FROM devices").fetchone()["total"] >= settings.max_devices:
|
||||
raise HTTPException(503, "device capacity reached")
|
||||
await rate_limit(redis, "auto-register-total", settings.max_pending, 3600)
|
||||
try:
|
||||
cert = await request_certificate(settings, body)
|
||||
issued = verify_device(cert, settings.ca_cert.read_bytes(), body.host_id)
|
||||
if raw_public(issued) != raw_public(key):
|
||||
raise ValueError()
|
||||
except Exception:
|
||||
raise HTTPException(503, "certificate issuer unavailable or invalid response") from None
|
||||
from .store import INTEGRITY_ERRORS
|
||||
try:
|
||||
store.add_device(body.host_id, cert, fingerprint(cert))
|
||||
except INTEGRITY_ERRORS:
|
||||
# A retry/concurrent request must return the original certificate.
|
||||
cert = check_existing(store.device(body.host_id))
|
||||
store.audit("device", "automatic_registration", body.host_id, "success")
|
||||
await redis.set("hn:device:" + body.host_id, fingerprint(cert))
|
||||
return no_cache(JSONResponse(sign({"status": "registered", "host_id": body.host_id,
|
||||
"cert": cert}, signer), status_code=201 if not existing else 200))
|
||||
|
||||
@router.post("/device/enroll")
|
||||
async def request_enrollment(body: EnrollmentRequest, request: Request):
|
||||
await rate_limit(redis, "enroll-ip:" + peer(request), 10)
|
||||
validate_enrollment(body)
|
||||
await rate_limit(redis, "enroll-host:" + body.host_id, 3, 3600)
|
||||
if store.device(body.host_id):
|
||||
raise HTTPException(409, "device already registered; recover its original certificate")
|
||||
# Global rolling capacity bound; prevents anonymous request-table exhaustion.
|
||||
await rate_limit(redis, "enroll-global", settings.max_pending, 1800)
|
||||
identifier, claim_secret = secrets.token_hex(16), secrets.token_urlsafe(32)
|
||||
record = {"host_id": body.host_id, "public_key": body.public_key,
|
||||
"claim_hash": digest(claim_secret), "created": time.time(), "status": "pending"}
|
||||
await redis.set("hn:enroll:" + identifier, json.dumps(record), ex=1800)
|
||||
return no_cache(JSONResponse(sign({"request_id": identifier, "claim_secret": claim_secret,
|
||||
"host_id": body.host_id, "expires_in": 1800}, signer), status_code=201))
|
||||
|
||||
@router.get("/device/enroll/{identifier}")
|
||||
async def claim(identifier: str, request: Request):
|
||||
await rate_limit(redis, "enroll-poll:" + peer(request), 60)
|
||||
data = await redis.get("hn:enroll:" + identifier)
|
||||
if not data:
|
||||
raise HTTPException(404, "request expired")
|
||||
record = json.loads(data)
|
||||
import hmac
|
||||
if not hmac.compare_digest(record["claim_hash"], digest(request.headers.get("X-Enrollment-Secret", ""))):
|
||||
raise HTTPException(404, "request unavailable")
|
||||
if record["status"] == "pending":
|
||||
return no_cache(JSONResponse({"status": "pending"}, status_code=202))
|
||||
device = store.device(record["host_id"])
|
||||
if not device or device["revoked"]:
|
||||
raise HTTPException(403, "device unavailable")
|
||||
# Recoverable for its original claimant for the request TTL; public certificate only.
|
||||
return no_cache(JSONResponse(sign({"status": "approved", "host_id": record["host_id"],
|
||||
"request_id": identifier, "cert": device["cert"]}, signer)))
|
||||
|
||||
@router.get("/admin/enrollments/{identifier}")
|
||||
async def inspect(identifier: str, request: Request):
|
||||
admin(request)
|
||||
encoded = await redis.get("hn:enroll:" + identifier)
|
||||
if not encoded:
|
||||
raise HTTPException(404, "request expired")
|
||||
record = json.loads(encoded)
|
||||
return {k: v for k, v in record.items() if k != "claim_hash"}
|
||||
|
||||
@router.post("/admin/enrollments/{identifier}/approve")
|
||||
async def approve(identifier: str, body: EnrollmentApproval, request: Request):
|
||||
admin(request)
|
||||
encoded = await redis.get("hn:enroll:" + identifier)
|
||||
if not encoded:
|
||||
raise HTTPException(404, "request expired")
|
||||
record = json.loads(encoded)
|
||||
try:
|
||||
public = verify_device(body.cert, settings.ca_cert.read_bytes(), record["host_id"])
|
||||
requested = serialization.load_pem_public_key(record["public_key"].encode())
|
||||
if raw_public(public) != raw_public(requested):
|
||||
raise ValueError()
|
||||
except Exception:
|
||||
raise HTTPException(400, "certificate does not match enrollment") from None
|
||||
if store.db.execute("SELECT COUNT(*) AS total FROM devices").fetchone()["total"] >= settings.max_devices:
|
||||
raise HTTPException(503, "device capacity reached")
|
||||
fp = fingerprint(body.cert)
|
||||
existing = store.device(record["host_id"])
|
||||
if existing and (existing["revoked"] or existing["fingerprint"] != fp):
|
||||
raise HTTPException(409, "device conflict")
|
||||
if not existing:
|
||||
from .store import INTEGRITY_ERRORS
|
||||
try:
|
||||
store.add_device(record["host_id"], body.cert, fp)
|
||||
except INTEGRITY_ERRORS:
|
||||
raise HTTPException(409, "concurrent device registration") from None
|
||||
await redis.set("hn:device:" + record["host_id"], fp)
|
||||
record["status"] = "approved"
|
||||
remaining = await redis.ttl("hn:enroll:" + identifier)
|
||||
if remaining < 1:
|
||||
raise HTTPException(409, "request expired during approval")
|
||||
await redis.set("hn:enroll:" + identifier, json.dumps(record), ex=remaining)
|
||||
store.audit("admin", "enrollment_approved", record["host_id"], "success")
|
||||
return {"status": "approved", "host_id": record["host_id"]}
|
||||
|
||||
return router
|
||||
@@ -0,0 +1,43 @@
|
||||
"""Internal automatic CA issuer. No published host port, no application credentials."""
|
||||
import os
|
||||
from pathlib import Path
|
||||
|
||||
from cryptography import x509
|
||||
from cryptography.hazmat.primitives import serialization
|
||||
from fastapi import FastAPI, Request
|
||||
from .common import BodyLimitMiddleware, require_secret
|
||||
from .crypto import load_private, issue_device, raw_public, verify_device
|
||||
from .enrollment import EnrollmentRequest, validate_enrollment
|
||||
|
||||
|
||||
def create_app(*, ca_key_path=None, ca_cert_path=None, secret=None):
|
||||
key = load_private(Path(ca_key_path or os.environ.get("HN_ISSUER_CA_KEY", "/issuer/ca.key")))
|
||||
ca_bytes = Path(ca_cert_path or os.environ.get("HN_ISSUER_CA_CERT", "/trust/ca.pem")).read_bytes()
|
||||
ca = x509.load_pem_x509_certificate(ca_bytes)
|
||||
if raw_public(key.public_key()) != raw_public(ca.public_key()):
|
||||
raise ValueError("issuer CA key mismatch")
|
||||
token = secret or os.environ.get("HN_INTERNAL_SECRET", "")
|
||||
if len(token) < 32:
|
||||
raise ValueError("issuer requires internal credential")
|
||||
app = FastAPI(docs_url=None, redoc_url=None, openapi_url=None)
|
||||
app.add_middleware(BodyLimitMiddleware, max_body=16384)
|
||||
|
||||
@app.get("/ready")
|
||||
async def ready():
|
||||
return {"status": "ready"}
|
||||
|
||||
@app.post("/issue")
|
||||
async def issue(body: EnrollmentRequest, request: Request):
|
||||
require_secret(request.headers.get("X-Internal-Secret"), token)
|
||||
public = validate_enrollment(body)
|
||||
cert = issue_device(key, ca, body.host_id, public).public_bytes(serialization.Encoding.PEM).decode()
|
||||
verify_device(cert, ca_bytes, body.host_id)
|
||||
return {"cert": cert}
|
||||
|
||||
return app
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
import uvicorn
|
||||
uvicorn.run("relay.enrollment_signer:create_app", factory=True, host="0.0.0.0", port=8000,
|
||||
workers=1, access_log=False, proxy_headers=False, log_level="warning")
|
||||
@@ -0,0 +1,107 @@
|
||||
"""Adapter for the native API actually found in installer 1.065.
|
||||
|
||||
Loopback only, independent API key, no platform secrets, no redirects or retries.
|
||||
The included native launcher offers only text inference with no tools.
|
||||
"""
|
||||
import hashlib
|
||||
import json
|
||||
import re
|
||||
from pathlib import Path
|
||||
from urllib.parse import urlsplit
|
||||
|
||||
import httpx
|
||||
|
||||
|
||||
class NativeAPIError(RuntimeError):
|
||||
"""Contains a sanitized status only, never response body or credentials."""
|
||||
|
||||
|
||||
def read_native_config(path):
|
||||
path = Path(path)
|
||||
data = json.loads(path.read_text(encoding="utf-8-sig"))
|
||||
url = data.get("url", "")
|
||||
parts = urlsplit(url)
|
||||
if (parts.scheme != "http" or parts.hostname != "127.0.0.1" or not parts.port
|
||||
or parts.username or parts.password or parts.query or parts.fragment
|
||||
or parts.path not in {"", "/"}):
|
||||
raise ValueError("native API must be a fixed IPv4 loopback HTTP base URL")
|
||||
if not isinstance(data.get("api_key"), str) or len(data["api_key"]) < 32:
|
||||
raise ValueError("native API requires a dedicated key of at least 32 characters")
|
||||
if data.get("mode") not in {"text-only", "profile-tools"}:
|
||||
raise ValueError("unsupported native API mode")
|
||||
data["url"] = url.rstrip("/")
|
||||
return data
|
||||
|
||||
|
||||
class Hainuo1065Agent:
|
||||
def __init__(self, config_path, transport=None):
|
||||
self.config = read_native_config(config_path)
|
||||
self.http = httpx.AsyncClient(base_url=self.config["url"], timeout=120,
|
||||
follow_redirects=False, trust_env=False, transport=transport)
|
||||
self.headers = {"Authorization": "Bearer " + self.config["api_key"]}
|
||||
|
||||
async def _json(self, method, path, **kwargs):
|
||||
try:
|
||||
async with self.http.stream(method, path, headers={**self.headers, **kwargs.pop("headers", {})}, **kwargs) as response:
|
||||
if response.status_code != 200:
|
||||
raise NativeAPIError(f"native API HTTP {response.status_code}")
|
||||
body = bytearray()
|
||||
async for chunk in response.aiter_bytes():
|
||||
body.extend(chunk)
|
||||
if len(body) > 262144:
|
||||
raise NativeAPIError("native API response exceeds limit")
|
||||
data = json.loads(body)
|
||||
if not isinstance(data, dict):
|
||||
raise NativeAPIError("native API response is not an object")
|
||||
return data
|
||||
except (httpx.HTTPError, ValueError):
|
||||
raise NativeAPIError("native API connection/JSON failure") from None
|
||||
|
||||
async def probe(self):
|
||||
health = await self._json("GET", "/health")
|
||||
if health.get("platform") != "hermes-agent" or health.get("status") != "ok":
|
||||
raise NativeAPIError("endpoint is not the native Hermes API")
|
||||
capabilities = await self._json("GET", "/v1/capabilities")
|
||||
policy = capabilities.get("hainuo_relay_policy", {})
|
||||
# A stock unrestricted API endpoint is deliberately not sufficient.
|
||||
expected_mode = self.config["mode"]
|
||||
expected_tools = "profile" if expected_mode == "profile-tools" else "disabled"
|
||||
if policy != {"mode": expected_mode, "tools": expected_tools, "contract": "hainuo-1065-v1"}:
|
||||
raise NativeAPIError("native API policy missing; start the supplied restricted launcher")
|
||||
models = await self._json("GET", "/v1/models")
|
||||
model = self.config.get("model")
|
||||
available = models.get("data")
|
||||
if not isinstance(available, list) or not available or not all(isinstance(x, dict) and isinstance(x.get("id"), str) for x in available):
|
||||
raise NativeAPIError("native model list invalid")
|
||||
if model and model not in {x["id"] for x in available}:
|
||||
raise NativeAPIError("configured model alias unavailable")
|
||||
self.model = model or available[0]["id"]
|
||||
return {"status": "ready", "platform": "hermes-agent", "model": self.model,
|
||||
"mode": expected_mode, "version": health.get("version", "unknown")}
|
||||
|
||||
async def execute(self, text, owner, turn):
|
||||
try:
|
||||
# Recheck the actual local service before each inference, including reconnects.
|
||||
await self.probe()
|
||||
digest = hashlib.sha256((owner + "\0" + turn).encode()).hexdigest()
|
||||
data = await self._json("POST", "/v1/chat/completions",
|
||||
headers={"Idempotency-Key": "hn-" + digest},
|
||||
json={"model": self.model, "stream": False,
|
||||
"messages": [{"role": "user", "content": text}]})
|
||||
choices = data.get("choices")
|
||||
if not isinstance(choices, list) or not choices or not isinstance(choices[0], dict):
|
||||
raise NativeAPIError("native completion choices missing")
|
||||
choice = choices[0]
|
||||
message = choice.get("message", {})
|
||||
if (choice.get("finish_reason") != "stop" or message.get("tool_calls")
|
||||
or not isinstance(message.get("content"), str)
|
||||
or data.get("hermes", {}).get("failed")
|
||||
or data.get("hermes", {}).get("partial")):
|
||||
raise NativeAPIError("native completion incomplete or unexpected tool call")
|
||||
return message["content"][:16000]
|
||||
except NativeAPIError as error:
|
||||
# Safe generated error strings only; never echo upstream model/API errors.
|
||||
return "海诺原生接口未完成请求:" + str(error) + "。未自动重试。"
|
||||
|
||||
async def close(self):
|
||||
await self.http.aclose()
|
||||
@@ -0,0 +1,83 @@
|
||||
"""Optional official SDK event source, private platform domain explicitly configured."""
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
import threading
|
||||
import time
|
||||
|
||||
import httpx
|
||||
import redis
|
||||
from .config import Settings
|
||||
|
||||
|
||||
def disable_proxy_environment():
|
||||
"""This dedicated SDK worker must connect directly, including discovery and WS."""
|
||||
for key in ("HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY", "http_proxy", "https_proxy", "all_proxy"):
|
||||
os.environ.pop(key, None)
|
||||
os.environ["NO_PROXY"] = "*"
|
||||
os.environ["no_proxy"] = "*"
|
||||
|
||||
|
||||
def main():
|
||||
disable_proxy_environment()
|
||||
import lark_oapi as lark
|
||||
s = Settings(role="longconn")
|
||||
if not s.feishu_enabled or s.feishu_event_source != "longconn":
|
||||
raise RuntimeError("platform is disabled")
|
||||
# The SDK may log websocket URLs, tokens or event bodies. Disable its logging entirely.
|
||||
logging.disable(logging.CRITICAL)
|
||||
r = redis.Redis.from_url(s.redis_url)
|
||||
lease = r.lock("hn:longconn:leader", timeout=30, thread_local=False)
|
||||
if not lease.acquire(blocking=False):
|
||||
raise RuntimeError("another long-connection consumer owns the lease")
|
||||
url = os.environ.get("HN_CONNECTOR_INTERNAL_URL", "http://connector:8000")
|
||||
client = httpx.Client(base_url=url, timeout=10, follow_redirects=False, trust_env=False)
|
||||
done = threading.Event()
|
||||
|
||||
def maintain_lease():
|
||||
while not done.wait(8):
|
||||
try:
|
||||
lease.extend(30, replace_ttl=True)
|
||||
except Exception:
|
||||
# Fail closed. Continuing after lease loss could create two consumers.
|
||||
os._exit(2)
|
||||
|
||||
threading.Thread(target=maintain_lease, daemon=True).start()
|
||||
|
||||
def received(event):
|
||||
data = json.loads(lark.JSON.marshal(event))
|
||||
response = client.post("/internal/events", headers={"X-Internal-Secret": s.internal_secret}, json=data)
|
||||
if response.status_code != 200:
|
||||
raise RuntimeError("connector did not accept event")
|
||||
print(json.dumps({"event": "platform_event_accepted", "type": data.get("header", {}).get("event_type")}), flush=True)
|
||||
|
||||
handler = lark.EventDispatcherHandler.builder("", "").register_p2_im_message_receive_v1(received).build()
|
||||
class ObservableClient(lark.ws.Client):
|
||||
async def _connect(self):
|
||||
try:
|
||||
await super()._connect()
|
||||
if self._conn is not None:
|
||||
print(json.dumps({"event": "platform_connected", "api_host": s.feishu_api_base}), flush=True)
|
||||
except Exception as error:
|
||||
print(json.dumps({"event": "platform_connect_failed", "error_type": type(error).__name__}), flush=True)
|
||||
raise
|
||||
|
||||
try:
|
||||
# domain is an actual supported SDK argument; no public-cloud-domain monkey patch.
|
||||
ObservableClient(s.feishu_app_id, s.feishu_app_secret, event_handler=handler,
|
||||
domain=s.feishu_api_base.rstrip("/"), log_level=lark.LogLevel.ERROR).start()
|
||||
finally:
|
||||
done.set()
|
||||
client.close()
|
||||
try:
|
||||
lease.release()
|
||||
except redis.exceptions.LockError:
|
||||
pass
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
try:
|
||||
main()
|
||||
except Exception as error:
|
||||
print(json.dumps({"event": "platform_consumer_stopped", "error_type": type(error).__name__}), flush=True)
|
||||
raise SystemExit(1) from None
|
||||
@@ -0,0 +1,144 @@
|
||||
import asyncio
|
||||
import hashlib
|
||||
import hmac
|
||||
import secrets
|
||||
import time
|
||||
from dataclasses import dataclass
|
||||
from urllib.parse import urlencode
|
||||
|
||||
from fastapi import APIRouter, HTTPException, Request
|
||||
from fastapi.responses import HTMLResponse, JSONResponse
|
||||
from pydantic import BaseModel, Field
|
||||
from .common import no_cache, peer, rate_limit
|
||||
from .platform import PlatformError
|
||||
|
||||
|
||||
@dataclass
|
||||
class Transaction:
|
||||
secret_hash: str
|
||||
expires: float
|
||||
status: str = "waiting"
|
||||
result: dict | None = None
|
||||
owner: str = ""
|
||||
|
||||
|
||||
class Empty(BaseModel):
|
||||
host_id: str = ""
|
||||
proof: dict = Field(default_factory=dict)
|
||||
|
||||
|
||||
class Refresh(BaseModel):
|
||||
refresh_token: str = Field(min_length=1, max_length=4096)
|
||||
|
||||
|
||||
class OAuth:
|
||||
"""A single connector process owns transactions and tokens in memory only."""
|
||||
def __init__(self, settings, redis, platform):
|
||||
self.settings, self.redis, self.platform = settings, redis, platform
|
||||
self.pending: dict[str, Transaction] = {}
|
||||
self.lock = asyncio.Lock()
|
||||
self.router = APIRouter()
|
||||
self.router.add_api_route("/oauth/start", self.start, methods=["POST"], status_code=201)
|
||||
self.router.add_api_route("/oauth/cb", self.callback, methods=["GET"])
|
||||
self.router.add_api_route("/oauth/claim", self.claim, methods=["GET"])
|
||||
self.router.add_api_route("/oauth/pending", self.status, methods=["GET"])
|
||||
self.router.add_api_route("/oauth/refresh", self.refresh, methods=["POST"])
|
||||
|
||||
def prune(self):
|
||||
now = time.monotonic()
|
||||
for state in list(self.pending):
|
||||
if self.pending[state].expires <= now:
|
||||
del self.pending[state]
|
||||
|
||||
def authenticated(self, state, secret):
|
||||
self.prune()
|
||||
item = self.pending.get(state)
|
||||
digest = hashlib.sha256((secret or "").encode()).hexdigest()
|
||||
if not item or not hmac.compare_digest(item.secret_hash, digest):
|
||||
raise HTTPException(404, "transaction not found")
|
||||
return item
|
||||
|
||||
async def start(self, body: Empty, request: Request):
|
||||
if not self.settings.feishu_enabled or not self.settings.oauth_enabled:
|
||||
raise HTTPException(503, "platform disabled")
|
||||
await rate_limit(self.redis, "oauth:start:" + peer(request), 20)
|
||||
owner = ""
|
||||
if body.host_id:
|
||||
from .work_api import device_owner
|
||||
owner = await device_owner(self.settings, self.redis, self.store, body.host_id,
|
||||
body.proof, "work-oauth-v1", {})
|
||||
async with self.lock:
|
||||
self.prune()
|
||||
if len(self.pending) >= self.settings.max_pending:
|
||||
raise HTTPException(503, "too many pending transactions")
|
||||
state, secret = secrets.token_urlsafe(32), secrets.token_urlsafe(32)
|
||||
self.pending[state] = Transaction(hashlib.sha256(secret.encode()).hexdigest(), time.monotonic() + 600, owner=owner)
|
||||
redirect = self.settings.public_url.rstrip("/") + "/oauth/cb"
|
||||
parameters = {"app_id": self.settings.feishu_app_id, "redirect_uri": redirect, "state": state}
|
||||
if self.settings.feishu_oauth_scopes:
|
||||
parameters["scope"] = self.settings.feishu_oauth_scopes
|
||||
url = self.settings.feishu_authorize_url + "?" + urlencode(parameters)
|
||||
return no_cache(JSONResponse({"state": state, "claim_secret": secret, "authorization_url": url,
|
||||
"redirect_uri": redirect, "expires_in": 600,
|
||||
"code_ttl": 60, "poll_interval": 2}, status_code=201))
|
||||
|
||||
async def callback(self, request: Request, state: str = "", code: str = "", error: str = ""):
|
||||
await rate_limit(self.redis, "oauth:cb:" + peer(request))
|
||||
async with self.lock:
|
||||
self.prune()
|
||||
item = self.pending.get(state)
|
||||
if error and item and item.status == "waiting":
|
||||
item.status = "failed"
|
||||
return no_cache(HTMLResponse("<meta charset='utf-8'><p>授权未完成,请返回客户端重新授权。</p>", status_code=400))
|
||||
if not code or len(code) > 4096 or not item or item.status != "waiting":
|
||||
raise HTTPException(400, "invalid callback")
|
||||
item.status = "exchanging"
|
||||
try:
|
||||
result = await self.platform.exchange(code)
|
||||
info = await self.platform.user_info(result["user_access_token"])
|
||||
if not info.get("open_id") or (item.owner and info["open_id"] != item.owner):
|
||||
raise PlatformError("authorization user mismatch")
|
||||
result["open_id"] = info["open_id"]
|
||||
except PlatformError:
|
||||
async with self.lock:
|
||||
item.status = "failed"
|
||||
raise HTTPException(502, "authorization exchange failed") from None
|
||||
async with self.lock:
|
||||
if state not in self.pending or item.expires <= time.monotonic():
|
||||
self.pending.pop(state, None)
|
||||
raise HTTPException(400, "authorization expired")
|
||||
item.result, item.status = result, "ready"
|
||||
item.expires = min(item.expires, time.monotonic() + 60)
|
||||
return no_cache(HTMLResponse("<meta charset='utf-8'><p>授权完成,请返回客户端。</p>"))
|
||||
|
||||
async def claim(self, request: Request, state: str):
|
||||
await rate_limit(self.redis, "oauth:claim:" + peer(request))
|
||||
async with self.lock:
|
||||
item = self.authenticated(state, request.headers.get("X-OAuth-Claim-Secret"))
|
||||
if item.status == "failed":
|
||||
del self.pending[state]
|
||||
raise HTTPException(502, "authorization failed")
|
||||
if item.status != "ready":
|
||||
return no_cache(JSONResponse({"status": "waiting", "retry_after": 2}, status_code=202))
|
||||
del self.pending[state]
|
||||
return no_cache(JSONResponse({"status": "claimed", **item.result}))
|
||||
|
||||
async def status(self, request: Request, state: str):
|
||||
await rate_limit(self.redis, "oauth:pending:" + peer(request))
|
||||
async with self.lock:
|
||||
item = self.authenticated(state, request.headers.get("X-OAuth-Claim-Secret"))
|
||||
return no_cache(JSONResponse({"status": item.status}))
|
||||
|
||||
async def refresh(self, body: Refresh, request: Request):
|
||||
if not self.settings.feishu_enabled:
|
||||
raise HTTPException(503, "platform disabled")
|
||||
await rate_limit(self.redis, "oauth:refresh:" + peer(request), 20)
|
||||
# Lock and consume before the upstream call; ambiguous failures never retry an old refresh token.
|
||||
digest = hashlib.sha256(body.refresh_token.encode()).hexdigest()
|
||||
if not await self.redis.set("hn:refresh:" + digest, "used", nx=True, ex=2592000):
|
||||
raise HTTPException(409, "refresh already attempted; use returned token or reauthorize")
|
||||
try:
|
||||
result = await self.platform.refresh(body.refresh_token)
|
||||
except PlatformError:
|
||||
raise HTTPException(502, "refresh failed; reauthorize") from None
|
||||
return no_cache(JSONResponse(result))
|
||||
@@ -0,0 +1,92 @@
|
||||
import asyncio
|
||||
import json
|
||||
import time
|
||||
import httpx
|
||||
|
||||
|
||||
class PlatformError(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class Feishu:
|
||||
def __init__(self, settings, transport=None):
|
||||
self.settings = settings
|
||||
self.http = httpx.AsyncClient(base_url=settings.feishu_api_base.rstrip("/"),
|
||||
timeout=15, follow_redirects=False, transport=transport, trust_env=False)
|
||||
self._token = None
|
||||
self._expires = 0
|
||||
self._tenant_token = None
|
||||
self._tenant_expires = 0
|
||||
self._lock = asyncio.Lock()
|
||||
|
||||
async def close(self):
|
||||
await self.http.aclose()
|
||||
|
||||
async def _json(self, method, path, **kwargs):
|
||||
try:
|
||||
response = await self.http.request(method, path, **kwargs)
|
||||
response.raise_for_status()
|
||||
data = response.json()
|
||||
if data.get("code", 0) != 0:
|
||||
raise PlatformError("platform rejected request")
|
||||
return data
|
||||
except (httpx.HTTPError, ValueError, KeyError) as exc:
|
||||
# Never propagate upstream bodies or credentials to caller/logs.
|
||||
raise PlatformError("platform request failed") from None
|
||||
|
||||
async def app_token(self):
|
||||
async with self._lock:
|
||||
if self._token and self._expires > time.monotonic() + 1800:
|
||||
return self._token
|
||||
data = await self._json("POST", "/open-apis/auth/v3/app_access_token/internal",
|
||||
json={"app_id": self.settings.feishu_app_id,
|
||||
"app_secret": self.settings.feishu_app_secret})
|
||||
self._token = data["app_access_token"]
|
||||
self._expires = time.monotonic() + int(data.get("expire", 7200))
|
||||
return self._token
|
||||
|
||||
async def exchange(self, code):
|
||||
token = await self.app_token()
|
||||
data = await self._json("POST", "/open-apis/authen/v1/oidc/access_token",
|
||||
headers={"Authorization": f"Bearer {token}"},
|
||||
json={"grant_type": "authorization_code", "code": code})
|
||||
return self.normalize(data["data"])
|
||||
|
||||
async def tenant_token(self):
|
||||
async with self._lock:
|
||||
if self._tenant_token and self._tenant_expires > time.monotonic() + 1800:
|
||||
return self._tenant_token
|
||||
data = await self._json("POST", "/open-apis/auth/v3/tenant_access_token/internal",
|
||||
json={"app_id": self.settings.feishu_app_id,
|
||||
"app_secret": self.settings.feishu_app_secret})
|
||||
self._tenant_token = data["tenant_access_token"]
|
||||
self._tenant_expires = time.monotonic() + int(data.get("expire", 7200))
|
||||
return self._tenant_token
|
||||
|
||||
async def refresh(self, refresh_token):
|
||||
token = await self.app_token()
|
||||
data = await self._json("POST", "/open-apis/authen/v1/oidc/refresh_access_token",
|
||||
headers={"Authorization": f"Bearer {token}"},
|
||||
json={"grant_type": "refresh_token", "refresh_token": refresh_token})
|
||||
result = self.normalize(data["data"])
|
||||
info = await self.user_info(result["user_access_token"])
|
||||
result["open_id"] = info["open_id"]
|
||||
return result
|
||||
|
||||
@staticmethod
|
||||
def normalize(data):
|
||||
return {"user_access_token": data["access_token"], "refresh_token": data.get("refresh_token", ""),
|
||||
"expires_in": data.get("expires_in", data.get("expire", 0)),
|
||||
"refresh_expires_in": data.get("refresh_expires_in", 0), "open_id": data.get("open_id", "")}
|
||||
|
||||
async def user_info(self, token):
|
||||
data = await self._json("GET", "/open-apis/authen/v1/user_info",
|
||||
headers={"Authorization": f"Bearer {token}"})
|
||||
return data["data"]
|
||||
|
||||
async def reply(self, message_id, text):
|
||||
# Reply to the original message only: no caller-controlled recipient.
|
||||
token = await self.tenant_token()
|
||||
await self._json("POST", f"/open-apis/im/v1/messages/{message_id}/reply",
|
||||
headers={"Authorization": f"Bearer {token}"},
|
||||
json={"msg_type": "text", "content": json.dumps({"text": text}, ensure_ascii=False)})
|
||||
@@ -0,0 +1,46 @@
|
||||
"""Per-device advisory process lock: same-user GUI and CLI cannot race."""
|
||||
import os
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
class DeviceAlreadyRunning(RuntimeError):
|
||||
pass
|
||||
|
||||
|
||||
class DeviceProcessLock:
|
||||
def __init__(self, directory):
|
||||
self.path = Path(directory) / "bridge.lock"
|
||||
self.file = None
|
||||
|
||||
def __enter__(self):
|
||||
self.path.parent.mkdir(parents=True, exist_ok=True)
|
||||
self.file = self.path.open("a+b")
|
||||
self.file.seek(0, 2)
|
||||
if self.file.tell() == 0:
|
||||
self.file.write(b"0")
|
||||
self.file.flush()
|
||||
self.file.seek(0)
|
||||
try:
|
||||
if os.name == "nt":
|
||||
import msvcrt
|
||||
msvcrt.locking(self.file.fileno(), msvcrt.LK_NBLCK, 1)
|
||||
else:
|
||||
import fcntl
|
||||
fcntl.flock(self.file.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
|
||||
except OSError:
|
||||
self.file.close()
|
||||
self.file = None
|
||||
raise DeviceAlreadyRunning("该设备已有桥接进程运行,请勿重复启动。") from None
|
||||
return self
|
||||
|
||||
def __exit__(self, *args):
|
||||
if self.file:
|
||||
self.file.seek(0)
|
||||
if os.name == "nt":
|
||||
import msvcrt
|
||||
msvcrt.locking(self.file.fileno(), msvcrt.LK_UNLCK, 1)
|
||||
else:
|
||||
import fcntl
|
||||
fcntl.flock(self.file.fileno(), fcntl.LOCK_UN)
|
||||
self.file.close()
|
||||
self.file = None
|
||||
@@ -0,0 +1,167 @@
|
||||
import asyncio
|
||||
import contextlib
|
||||
import json
|
||||
import secrets
|
||||
import time
|
||||
from contextlib import asynccontextmanager
|
||||
|
||||
from fastapi import FastAPI, WebSocket, WebSocketDisconnect
|
||||
from redis.asyncio import Redis
|
||||
from redis.exceptions import WatchError
|
||||
|
||||
from .config import Settings
|
||||
from .crypto import fingerprint, raw_public, verified, verify_device
|
||||
|
||||
|
||||
async def compare_delete(redis, key, expected):
|
||||
async with redis.pipeline() as pipe:
|
||||
try:
|
||||
await pipe.watch(key)
|
||||
if await pipe.get(key) != expected:
|
||||
return False
|
||||
pipe.multi()
|
||||
pipe.delete(key)
|
||||
await pipe.execute()
|
||||
return True
|
||||
except WatchError:
|
||||
return False
|
||||
|
||||
|
||||
async def compare_expire(redis, key, expected, ttl):
|
||||
async with redis.pipeline() as pipe:
|
||||
try:
|
||||
await pipe.watch(key)
|
||||
if await pipe.get(key) != expected:
|
||||
return False
|
||||
pipe.multi()
|
||||
pipe.expire(key, ttl)
|
||||
await pipe.execute()
|
||||
return True
|
||||
except WatchError:
|
||||
return False
|
||||
|
||||
|
||||
def create_app(settings=None, redis=None):
|
||||
s = settings or Settings(role="router")
|
||||
r = redis or Redis.from_url(s.redis_url, decode_responses=True)
|
||||
ca = s.ca_cert.read_bytes()
|
||||
active = set()
|
||||
|
||||
@asynccontextmanager
|
||||
async def lifespan(app):
|
||||
await r.ping()
|
||||
yield
|
||||
if redis is None:
|
||||
await r.aclose()
|
||||
|
||||
app = FastAPI(title="Hainuo B2 router", lifespan=lifespan, docs_url=None, redoc_url=None)
|
||||
app.state.redis = r
|
||||
|
||||
@app.get("/health")
|
||||
async def health():
|
||||
return {"status": "alive", "role": "router"}
|
||||
|
||||
@app.get("/ready")
|
||||
async def ready():
|
||||
await r.ping()
|
||||
return {"status": "ready", "connections": len(active)}
|
||||
|
||||
@app.websocket("/device/ws")
|
||||
async def device(ws: WebSocket):
|
||||
from .common import rate_limit
|
||||
from fastapi import HTTPException
|
||||
await ws.accept()
|
||||
if len(active) >= s.max_connections:
|
||||
await ws.close(1013)
|
||||
return
|
||||
ip = ws.client.host if ws.client else "unknown"
|
||||
try:
|
||||
await rate_limit(r, "ws:" + ip, 30)
|
||||
except HTTPException:
|
||||
await ws.close(1008)
|
||||
return
|
||||
challenge = secrets.token_urlsafe(32)
|
||||
host = session = presence = None
|
||||
tasks = []
|
||||
pub = None
|
||||
try:
|
||||
await ws.send_json({"type": "challenge", "challenge": challenge})
|
||||
hello = await asyncio.wait_for(ws.receive_json(), timeout=10)
|
||||
if len(json.dumps(hello)) > 20000:
|
||||
raise ValueError("oversized hello")
|
||||
host = hello["host_id"]
|
||||
if not isinstance(host, str) or len(host) != 32 or any(c not in "0123456789abcdef" for c in host):
|
||||
raise ValueError("invalid host")
|
||||
public = verify_device(hello["cert"], ca, host)
|
||||
proof = verified(hello["proof"], public)
|
||||
if proof["challenge"] != challenge or proof["host_id"] != host or abs(time.time() - proof["ts"]) > 90:
|
||||
raise ValueError("invalid proof")
|
||||
if len(proof["kx"]) > 64 or len(proof["session_id"]) > 64:
|
||||
raise ValueError("invalid session")
|
||||
fp = fingerprint(hello["cert"])
|
||||
if await r.get("hn:device:" + host) != fp or await r.exists("hn:revoked:" + host):
|
||||
raise ValueError("unregistered/revoked")
|
||||
session = proof["session_id"]
|
||||
presence = json.dumps({"cert": hello["cert"], "proof": hello["proof"], "challenge": challenge})
|
||||
if not await r.set("hn:online:" + host, presence, nx=True, ex=30):
|
||||
raise ValueError("already connected")
|
||||
active.add(session)
|
||||
pub = r.pubsub()
|
||||
await pub.subscribe("hn:down:" + host, "hn:kill:" + host)
|
||||
await ws.send_json({"type": "connected", "session_id": session})
|
||||
|
||||
async def downstream():
|
||||
async for msg in pub.listen():
|
||||
if msg["type"] != "message":
|
||||
continue
|
||||
if msg["channel"] == "hn:kill:" + host:
|
||||
await ws.close(1008)
|
||||
return
|
||||
await ws.send_text(msg["data"])
|
||||
|
||||
async def heartbeat():
|
||||
while True:
|
||||
await asyncio.sleep(8)
|
||||
if await r.exists("hn:revoked:" + host) or not await compare_expire(r, "hn:online:" + host, presence, 30):
|
||||
await ws.close(1008)
|
||||
return
|
||||
|
||||
async def upstream():
|
||||
while True:
|
||||
text = await ws.receive_text()
|
||||
if len(text.encode()) > s.max_body:
|
||||
raise ValueError("oversized frame")
|
||||
data = json.loads(text)
|
||||
if data.get("type") == "ping":
|
||||
continue
|
||||
await rate_limit(r, "ws:reply:" + host, 120)
|
||||
turn = data.get("turn_id", "")
|
||||
if data.get("type") != "reply" or await r.get(f"hn:inflight:{host}:{turn}") != session:
|
||||
raise ValueError("unsolicited reply")
|
||||
envelope = data["envelope"]
|
||||
verified(envelope, public)
|
||||
if envelope["host_id"] != host or envelope["session_id"] != session:
|
||||
raise ValueError("wrong reply destination")
|
||||
await r.publish("hn:replies", json.dumps(data))
|
||||
|
||||
tasks = [asyncio.create_task(x()) for x in (downstream, heartbeat, upstream)]
|
||||
done, _ = await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
|
||||
for task in done:
|
||||
task.result()
|
||||
except (WebSocketDisconnect, asyncio.TimeoutError, ValueError, KeyError, TypeError):
|
||||
with contextlib.suppress(Exception):
|
||||
await ws.close(1008)
|
||||
except Exception:
|
||||
with contextlib.suppress(Exception):
|
||||
await ws.close(1011)
|
||||
finally:
|
||||
for task in tasks:
|
||||
task.cancel()
|
||||
await asyncio.gather(*tasks, return_exceptions=True)
|
||||
if pub:
|
||||
await pub.aclose()
|
||||
if presence:
|
||||
await compare_delete(r, "hn:online:" + host, presence)
|
||||
active.discard(session)
|
||||
|
||||
return app
|
||||
@@ -0,0 +1,97 @@
|
||||
"""Connector-owned persistent metadata. Never stores message/file/token bodies."""
|
||||
import sqlite3
|
||||
import time
|
||||
import psycopg
|
||||
from psycopg.rows import dict_row
|
||||
|
||||
INTEGRITY_ERRORS = (sqlite3.IntegrityError, psycopg.IntegrityError)
|
||||
|
||||
|
||||
class Postgres:
|
||||
def __init__(self, url):
|
||||
self.url = url
|
||||
self.conn = psycopg.connect(url, autocommit=True, row_factory=dict_row)
|
||||
self.transaction = None
|
||||
|
||||
def execute(self, sql, params=()):
|
||||
if self.conn.closed or self.conn.broken:
|
||||
self.conn = psycopg.connect(self.url, autocommit=True, row_factory=dict_row)
|
||||
return self.conn.execute(sql.replace("?", "%s"), params)
|
||||
|
||||
def __enter__(self):
|
||||
self.transaction = self.conn.transaction()
|
||||
self.transaction.__enter__()
|
||||
return self
|
||||
|
||||
def __exit__(self, *args):
|
||||
return self.transaction.__exit__(*args)
|
||||
|
||||
def close(self):
|
||||
self.conn.close()
|
||||
|
||||
|
||||
class Store:
|
||||
def __init__(self, path, database_url=""):
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
schema = """
|
||||
CREATE TABLE IF NOT EXISTS devices(
|
||||
host_id TEXT PRIMARY KEY, cert TEXT NOT NULL, fingerprint TEXT NOT NULL,
|
||||
owner TEXT UNIQUE, revoked INTEGER NOT NULL DEFAULT 0);
|
||||
CREATE TABLE IF NOT EXISTS turns(
|
||||
turn_id TEXT PRIMARY KEY, owner TEXT NOT NULL, host_id TEXT NOT NULL,
|
||||
status TEXT NOT NULL, created DOUBLE PRECISION NOT NULL);
|
||||
CREATE TABLE IF NOT EXISTS audit(
|
||||
id INTEGER PRIMARY KEY, ts DOUBLE PRECISION NOT NULL, actor TEXT NOT NULL,
|
||||
action TEXT NOT NULL, resource TEXT NOT NULL, result TEXT NOT NULL);
|
||||
"""
|
||||
if database_url:
|
||||
self.db = Postgres(database_url)
|
||||
self.db.conn.execute(schema.replace("id INTEGER PRIMARY KEY", "id BIGSERIAL PRIMARY KEY"))
|
||||
else:
|
||||
self.db = sqlite3.connect(path, check_same_thread=False)
|
||||
self.db.row_factory = sqlite3.Row
|
||||
self.db.executescript("PRAGMA journal_mode=WAL;" + schema)
|
||||
|
||||
def device(self, host):
|
||||
row = self.db.execute("SELECT * FROM devices WHERE host_id=?", (host,)).fetchone()
|
||||
return dict(row) if row else None
|
||||
|
||||
def by_owner(self, owner):
|
||||
row = self.db.execute("SELECT * FROM devices WHERE owner=? AND revoked=0", (owner,)).fetchone()
|
||||
return dict(row) if row else None
|
||||
|
||||
def add_device(self, host, cert, fp):
|
||||
with self.db:
|
||||
self.db.execute("INSERT INTO devices(host_id,cert,fingerprint) VALUES(?,?,?)", (host, cert, fp))
|
||||
|
||||
def bind(self, host, owner):
|
||||
with self.db:
|
||||
# Conditional update also protects against two connectors racing for the same device.
|
||||
count = self.db.execute("UPDATE devices SET owner=? WHERE host_id=? AND owner IS NULL AND revoked=0", (owner, host)).rowcount
|
||||
if count != 1:
|
||||
raise ValueError("device unavailable or already bound")
|
||||
|
||||
def unbind(self, owner):
|
||||
with self.db:
|
||||
self.db.execute("UPDATE devices SET owner=NULL WHERE owner=?", (owner,))
|
||||
|
||||
def revoke(self, host):
|
||||
with self.db:
|
||||
self.db.execute("UPDATE devices SET revoked=1 WHERE host_id=?", (host,))
|
||||
|
||||
def begin_turn(self, turn, owner, host):
|
||||
with self.db:
|
||||
return self.db.execute("INSERT INTO turns VALUES(?,?,?,?,?) ON CONFLICT(turn_id) DO NOTHING",
|
||||
(turn, owner, host, "inflight", time.time())).rowcount == 1
|
||||
|
||||
def finish(self, turn, status):
|
||||
with self.db:
|
||||
self.db.execute("UPDATE turns SET status=? WHERE turn_id=?", (status, turn))
|
||||
|
||||
def audit(self, actor, action, resource, result):
|
||||
with self.db:
|
||||
self.db.execute("INSERT INTO audit(ts,actor,action,resource,result) VALUES(?,?,?,?,?)",
|
||||
(time.time(), actor, action, resource, result))
|
||||
|
||||
def close(self):
|
||||
self.db.close()
|
||||
@@ -0,0 +1,117 @@
|
||||
"use strict";
|
||||
const byId = id => document.getElementById(id);
|
||||
const statusNode = byId("status");
|
||||
let sending = false;
|
||||
let loggedIn = false;
|
||||
const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
|
||||
function note(text) { statusNode.textContent = text; }
|
||||
function addMessage(text, role) {
|
||||
const item = document.createElement("div");
|
||||
item.className = "message " + role;
|
||||
item.textContent = text;
|
||||
byId("messages").appendChild(item);
|
||||
item.scrollIntoView({block:"nearest"});
|
||||
}
|
||||
async function refresh() {
|
||||
try {
|
||||
const response = await fetch("/web/session", {cache:"no-store", credentials:"same-origin"});
|
||||
if (!response.ok) {
|
||||
loggedIn = false;
|
||||
byId("pair-panel").hidden = false;
|
||||
byId("chat-panel").hidden = true;
|
||||
note(response.status === 401 ? "请使用PC上的一次性配对码连接。" : "会话服务暂不可用。");
|
||||
return;
|
||||
}
|
||||
const data = await response.json();
|
||||
loggedIn = true;
|
||||
byId("pair-panel").hidden = true;
|
||||
byId("chat-panel").hidden = false;
|
||||
byId("device-state").textContent = data.online ? "你的电脑已在线" : "你的电脑当前离线";
|
||||
if (!sending) note(data.online ? "已连接本人设备,可以开始对话。" : "请在PC启动桥接端,随后再发送消息。");
|
||||
} catch (_) { if (!sending) note("网络连接失败,请检查到中继的连接。"); }
|
||||
}
|
||||
byId("pair-form").addEventListener("submit", async event => {
|
||||
event.preventDefault();
|
||||
byId("pair-button").disabled = true;
|
||||
try {
|
||||
const response = await fetch("/web/claim", {method:"POST", credentials:"same-origin",
|
||||
headers:{"Content-Type":"application/json"}, body:JSON.stringify({code:byId("code").value.trim()})});
|
||||
if (!response.ok) throw new Error(response.status === 404 ? "配对码已过期或已使用,请在PC重新生成。" : "配对失败,请确认地址、配对码和设备绑定。");
|
||||
byId("code").value = "";
|
||||
await refresh();
|
||||
} catch (error) { note(error.message); }
|
||||
finally { byId("pair-button").disabled = false; }
|
||||
});
|
||||
byId("chat-form").addEventListener("submit", async event => {
|
||||
event.preventDefault();
|
||||
if (sending || !loggedIn) return;
|
||||
const text = byId("message").value.trim();
|
||||
if (!text) return;
|
||||
const bytes = new Uint8Array(16);
|
||||
crypto.getRandomValues(bytes);
|
||||
const requestId = Array.from(bytes, n => n.toString(16).padStart(2,"0")).join("");
|
||||
sending = true;
|
||||
byId("send").disabled = true;
|
||||
byId("logout").disabled = true;
|
||||
addMessage(text, "user");
|
||||
byId("message").value = "";
|
||||
note("正在等待你的电脑和模型返回结果…");
|
||||
const controller = new AbortController();
|
||||
const timer = setTimeout(() => controller.abort(), 200000);
|
||||
try {
|
||||
const response = await fetch("/web/chat", {method:"POST", credentials:"same-origin", signal:controller.signal,
|
||||
headers:{"Content-Type":"application/json"}, body:JSON.stringify({text, request_id:requestId})});
|
||||
if (!response.ok) throw new Error(response.status === 401 ? "网页会话已失效,请重新配对。" : "请求失败,HTTP " + response.status + "。请核查执行状态后再决定是否重发。");
|
||||
const data = await response.json();
|
||||
addMessage(data.result || "未收到文本结果。", data.status === "completed" ? "assistant" : "notice");
|
||||
note("请求状态:" + data.status);
|
||||
} catch (error) {
|
||||
addMessage(error.name === "AbortError" ? "等待超时,执行状态未知。系统没有自动重发。" : error.message, "notice");
|
||||
note("请求ID:" + requestId + "。请保留此ID排查,勿盲目重发。");
|
||||
} finally {
|
||||
clearTimeout(timer); sending = false;
|
||||
byId("send").disabled = false; byId("logout").disabled = false;
|
||||
}
|
||||
});
|
||||
byId("logout").addEventListener("click", async () => {
|
||||
try {
|
||||
const response = await fetch("/web/logout", {method:"POST", credentials:"same-origin"});
|
||||
if (!response.ok) throw new Error("退出失败,请稍后重试。");
|
||||
byId("messages").replaceChildren();
|
||||
await refresh();
|
||||
} catch (error) { note(error.message); }
|
||||
});
|
||||
byId("login").addEventListener("click", async () => {
|
||||
const popup = window.open("about:blank", "hainuo_authorize");
|
||||
if (!popup) { note("请允许打开授权窗口。"); return; }
|
||||
popup.opener = null;
|
||||
byId("login").disabled = true;
|
||||
try {
|
||||
const started = await fetch("/oauth/start", {method:"POST", headers:{"Content-Type":"application/json"}, body:"{}", cache:"no-store"});
|
||||
if (!started.ok) throw new Error("海能Work授权尚未配置,可先使用PC配对码。");
|
||||
const transaction = await started.json();
|
||||
const url = new URL(transaction.authorization_url);
|
||||
if (url.protocol !== "https:") throw new Error("授权地址必须使用HTTPS。");
|
||||
popup.location = url.href;
|
||||
note("请在授权窗口完成登录。");
|
||||
const until = Date.now() + transaction.expires_in * 1000;
|
||||
let token;
|
||||
while (Date.now() < until) {
|
||||
await sleep(2000);
|
||||
const response = await fetch("/oauth/claim?state=" + encodeURIComponent(transaction.state), {
|
||||
headers:{"X-OAuth-Claim-Secret":transaction.claim_secret}, cache:"no-store"});
|
||||
if (response.status === 202) continue;
|
||||
if (!response.ok) throw new Error("授权已失效,请重新开始。");
|
||||
token = (await response.json()).user_access_token;
|
||||
break;
|
||||
}
|
||||
if (!token) throw new Error("等待授权超时。");
|
||||
const response = await fetch("/web/platform-session", {method:"POST", headers:{Authorization:"Bearer " + token}});
|
||||
token = null;
|
||||
if (!response.ok) throw new Error("请先在海能Work完成本人设备绑定。");
|
||||
await refresh();
|
||||
} catch (error) { note(error.message); try { popup.close(); } catch (_) {} }
|
||||
finally { byId("login").disabled = false; }
|
||||
});
|
||||
refresh();
|
||||
setInterval(() => { if (!sending) refresh(); }, 15000);
|
||||
@@ -0,0 +1,15 @@
|
||||
<!doctype html>
|
||||
<html lang="zh-CN"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
|
||||
<title>海诺 · 我的工作电脑</title><link rel="stylesheet" href="/assets/style.css"><script defer src="/assets/app.js"></script></head>
|
||||
<body><main><div class="mark">海诺 HAINUO <span class="badge">试点 · 纯文本</span></div>
|
||||
<h1>连接你的<br>工作电脑。</h1><p class="intro">电脑上的助手,随时与你对话。先完成本人设备配对,再开始工作。</p>
|
||||
<section class="card" id="pair-panel"><span class="step">01 / 连接本人设备</span><h2>输入电脑上的配对码</h2>
|
||||
<p>在已绑定的PC运行网页配对命令,将生成的一次性配对码填在这里。有效期两分钟,请勿转发。</p>
|
||||
<form id="pair-form"><label for="code">网页配对码</label><input id="code" name="code" autocomplete="off" spellcheck="false" required maxlength="128" placeholder="粘贴PC生成的配对码"><button type="submit" id="pair-button">连接我的电脑 <span>↗</span></button></form>
|
||||
<details><summary>使用海能Work授权</summary><p>需要管理员已配置平台应用与OAuth回调。</p><button id="login" type="button">通过海能Work登录</button></details></section>
|
||||
<section class="card" id="chat-panel" hidden><div class="chat-head"><div><span class="step">02 / 本人设备会话</span><h2 id="device-state">正在连接</h2></div><button id="logout" type="button" class="secondary">解除网页登录</button></div>
|
||||
<p class="hint">当前为纯文本推理。可发送“17加25是多少”,或使用 /主机名 验证目标电脑。暂不开放文件操作。</p>
|
||||
<div id="messages" role="log" aria-live="polite"></div><form id="chat-form"><label for="message">给你的助手发消息</label><textarea id="message" rows="3" maxlength="8000" placeholder="描述你的问题…" required></textarea><button id="send" type="submit">发送消息 <span>↑</span></button></form></section>
|
||||
<p id="status" role="status" aria-live="polite">正在检查网页会话…</p>
|
||||
<footer>PC需保持开机、联网,并运行原生API和桥接端。试点网页由中继在内存中转发正文,不保存聊天记录;当前页关闭后消息不保留。</footer>
|
||||
</main></body></html>
|
||||
@@ -0,0 +1,3 @@
|
||||
:root{color-scheme:light;font-family:system-ui,-apple-system,"Segoe UI","Microsoft YaHei",sans-serif;color:#17372c;background:#f2f4ed}*{box-sizing:border-box}body{margin:0}main{max-width:820px;margin:0 auto;padding:60px 26px}.mark{font-size:13px;letter-spacing:.16em;color:#557764;font-weight:700}h1{font-size:clamp(42px,8vw,70px);letter-spacing:-.05em;line-height:1.12;font-weight:650;margin:40px 0 22px}.intro{font-size:17px;line-height:1.8;color:#56675a;max-width:520px}.card{background:#fff;border:1px solid #dbe3d8;border-radius:20px;padding:30px;margin:40px 0 24px;box-shadow:0 12px 44px #18372c06}.step{font-size:12px;letter-spacing:.1em;color:#6d806c}h2{font-size:24px;margin:16px 0}.card p{line-height:1.8;color:#5b6c60}button{background:#214e3a;color:white;border:0;border-radius:10px;font:inherit;font-weight:600;padding:16px 20px;width:100%;text-align:left;cursor:pointer;margin-top:16px}button span{float:right}button:disabled{opacity:.5;cursor:wait}button:focus-visible,a:focus-visible{outline:3px solid #d0a349;outline-offset:4px}#status{font-size:13px;margin-bottom:0}#open{display:block;margin-top:22px;color:#214e3a;font-weight:600}#open[hidden]{display:none}footer{color:#768373;font-size:12px;line-height:1.8}@media(max-width:480px){main{padding-top:36px}.card{padding:22px}h1{margin-top:28px}}
|
||||
|
||||
[hidden]{display:none!important}.badge{float:right;font-size:11px;letter-spacing:0;background:#e4ebdf;border-radius:20px;padding:6px 10px}label{display:block;font-size:13px;color:#526c5b;margin:12px 0 8px}input,textarea{font:inherit;width:100%;border:1px solid #ccd8ce;border-radius:10px;padding:14px;color:#17372c;background:#fafcf8;resize:vertical}input:focus,textarea:focus{outline:2px solid #6c987b;outline-offset:2px}details{margin-top:24px;font-size:13px;color:#587561}summary{cursor:pointer}.chat-head{display:flex;align-items:center;justify-content:space-between;gap:20px}.secondary{width:auto;background:#edf2e9;color:#31523f;padding:9px 12px;font-size:12px;margin:0}.hint{font-size:13px}#messages{display:flex;flex-direction:column;gap:12px;margin:22px 0;max-height:420px;overflow:auto}.message{padding:14px 16px;border-radius:12px;line-height:1.8;white-space:pre-wrap;overflow-wrap:anywhere;font-size:15px}.message.user{background:#e5eee2;margin-left:36px}.message.assistant{background:#f2f5ef;margin-right:24px}.message.notice{background:#fbf4e5;color:#735c2e}#status{font-size:13px;color:#5f745f;line-height:1.8}#chat-panel h2{font-size:20px}footer{max-width:640px}
|
||||
@@ -0,0 +1,183 @@
|
||||
"""Pilot H5 pairing and conversation. Credentials never appear in URLs."""
|
||||
import hashlib
|
||||
import json
|
||||
import secrets
|
||||
import time
|
||||
from urllib.parse import urlsplit
|
||||
|
||||
from fastapi import APIRouter, HTTPException, Request
|
||||
from fastapi.responses import JSONResponse
|
||||
from pydantic import BaseModel, Field
|
||||
|
||||
from .common import no_cache, peer, rate_limit
|
||||
from .crypto import sign, verified, verify_device
|
||||
from .platform import PlatformError
|
||||
|
||||
COOKIE = "hn_web_session"
|
||||
|
||||
|
||||
def digest(value):
|
||||
return hashlib.sha256(value.encode()).hexdigest()
|
||||
|
||||
|
||||
def origin_tuple(value):
|
||||
try:
|
||||
parts = urlsplit(value)
|
||||
if parts.scheme not in {"https", "http"} or not parts.hostname or parts.username or parts.password:
|
||||
return None
|
||||
return parts.scheme, parts.hostname.lower(), parts.port or (443 if parts.scheme == "https" else 80)
|
||||
except ValueError:
|
||||
return None
|
||||
|
||||
|
||||
class PairProof(BaseModel):
|
||||
host_id: str = Field(pattern=r"^[a-f0-9]{32}$")
|
||||
proof: dict
|
||||
|
||||
|
||||
class Claim(BaseModel):
|
||||
code: str = Field(min_length=12, max_length=128)
|
||||
|
||||
|
||||
class Chat(BaseModel):
|
||||
text: str = Field(min_length=1, max_length=8000)
|
||||
request_id: str = Field(pattern=r"^[a-f0-9]{32}$")
|
||||
|
||||
|
||||
class WebSessions:
|
||||
def __init__(self, settings, redis, store, broker, platform):
|
||||
self.s, self.r, self.store, self.broker, self.platform = settings, redis, store, broker, platform
|
||||
self.router = APIRouter()
|
||||
for path, method, handler in [
|
||||
("/device/web-pair", "POST", self.device_pair),
|
||||
("/web/claim", "POST", self.claim),
|
||||
("/web/session", "GET", self.session),
|
||||
("/web/platform-session", "POST", self.platform_login),
|
||||
("/web/chat", "POST", self.chat),
|
||||
("/web/logout", "POST", self.logout),
|
||||
]:
|
||||
self.router.add_api_route(path, handler, methods=[method])
|
||||
|
||||
def check_origin(self, request):
|
||||
actual = origin_tuple(request.headers.get("Origin", ""))
|
||||
if not actual or actual != origin_tuple(self.s.public_url):
|
||||
raise HTTPException(403, "same-origin browser request required")
|
||||
|
||||
async def valid_device(self, record):
|
||||
device = self.store.device(record["host_id"])
|
||||
if (not device or device["revoked"] or device["owner"] != record["owner"]
|
||||
or device["fingerprint"] != record["fingerprint"]):
|
||||
raise HTTPException(401, "device binding changed; pair again")
|
||||
generation = await self.r.get("hn:web-generation:" + record["host_id"]) or "0"
|
||||
if record.get("generation") != generation:
|
||||
raise HTTPException(401, "device binding changed; pair again")
|
||||
return device
|
||||
|
||||
async def device_pair(self, body: PairProof, request: Request):
|
||||
await rate_limit(self.r, "web-pair-ip:" + peer(request), 20)
|
||||
device = self.store.device(body.host_id)
|
||||
if not device or device["revoked"] or not device["owner"]:
|
||||
raise HTTPException(403, "active bound device required")
|
||||
try:
|
||||
key = verify_device(device["cert"], self.s.ca_cert.read_bytes(), body.host_id)
|
||||
proof = verified(body.proof, key)
|
||||
if (proof["host_id"] != body.host_id or proof["owner"] != device["owner"]
|
||||
or proof["purpose"] != "h5-pair-v1" or abs(time.time() - proof["ts"]) > 90
|
||||
or not isinstance(proof["nonce"], str) or len(proof["nonce"]) != 32):
|
||||
raise ValueError("invalid proof")
|
||||
except Exception:
|
||||
raise HTTPException(403, "invalid device proof") from None
|
||||
replay = "hn:web-pair-proof:" + digest(body.host_id + proof["nonce"])
|
||||
if not await self.r.set(replay, "used", nx=True, ex=180):
|
||||
raise HTTPException(409, "pairing request already used")
|
||||
await rate_limit(self.r, "web-pair-device:" + body.host_id, 5)
|
||||
code = secrets.token_urlsafe(18)
|
||||
record = {"host_id": body.host_id, "owner": device["owner"], "fingerprint": device["fingerprint"],
|
||||
"generation": await self.r.get("hn:web-generation:" + body.host_id) or "0"}
|
||||
await self.r.set("hn:web-code:" + digest(code), json.dumps(record), ex=120)
|
||||
self.store.audit(device["owner"], "web_pair_issued", body.host_id, "success")
|
||||
return no_cache(JSONResponse(sign({"host_id": body.host_id, "code": code, "expires_in": 120,
|
||||
"url": self.s.public_url.rstrip("/") + "/h5"}, self.broker.signer)))
|
||||
|
||||
async def new_session(self, record):
|
||||
token = secrets.token_urlsafe(32)
|
||||
record = {k: record[k] for k in ("host_id", "owner", "fingerprint", "generation")}
|
||||
await self.r.set("hn:web-session:" + digest(token), json.dumps(record), ex=1800)
|
||||
response = no_cache(JSONResponse({"status": "paired", "host_id": record["host_id"], "expires_in": 1800}))
|
||||
response.set_cookie(COOKIE, token, max_age=1800, secure=True, httponly=True, samesite="strict", path="/")
|
||||
return response
|
||||
|
||||
async def claim(self, body: Claim, request: Request):
|
||||
self.check_origin(request)
|
||||
await rate_limit(self.r, "web-claim:" + peer(request), 20)
|
||||
key = "hn:web-code:" + digest(body.code.strip())
|
||||
encoded = await self.r.get(key)
|
||||
if not encoded:
|
||||
raise HTTPException(404, "code expired or consumed")
|
||||
await self.valid_device(json.loads(encoded))
|
||||
encoded = await self.r.getdel(key)
|
||||
if not encoded:
|
||||
raise HTTPException(404, "code already consumed")
|
||||
record = json.loads(encoded)
|
||||
await self.valid_device(record)
|
||||
self.store.audit(record["owner"], "web_pair_claimed", record["host_id"], "success")
|
||||
return await self.new_session(record)
|
||||
|
||||
async def authenticated(self, request):
|
||||
token = request.cookies.get(COOKIE, "")
|
||||
if not token or len(token) > 128:
|
||||
raise HTTPException(401, "pair this browser first")
|
||||
encoded = await self.r.get("hn:web-session:" + digest(token))
|
||||
if not encoded:
|
||||
raise HTTPException(401, "browser session expired")
|
||||
record = json.loads(encoded)
|
||||
await self.valid_device(record)
|
||||
return record
|
||||
|
||||
async def session(self, request: Request):
|
||||
record = await self.authenticated(request)
|
||||
return no_cache(JSONResponse({"authenticated": True, "host_id": record["host_id"],
|
||||
"online": bool(await self.r.exists("hn:online:" + record["host_id"])),
|
||||
"mode": "pilot-text-only", "relay_sees_content": True}))
|
||||
|
||||
async def platform_login(self, request: Request):
|
||||
self.check_origin(request)
|
||||
if not self.s.feishu_enabled:
|
||||
raise HTTPException(503, "platform disabled")
|
||||
await rate_limit(self.r, "web-platform:" + peer(request), 20)
|
||||
auth = request.headers.get("Authorization", "")
|
||||
if not auth.startswith("Bearer ") or len(auth) > 8192:
|
||||
raise HTTPException(401, "user token required")
|
||||
try:
|
||||
info = await self.platform.user_info(auth[7:])
|
||||
except PlatformError:
|
||||
raise HTTPException(401, "invalid user token") from None
|
||||
device = self.store.by_owner(info["open_id"])
|
||||
if not device:
|
||||
raise HTTPException(404, "bind your device first")
|
||||
return await self.new_session({**device, "generation": await self.r.get("hn:web-generation:" + device["host_id"]) or "0"})
|
||||
|
||||
async def chat(self, body: Chat, request: Request):
|
||||
self.check_origin(request)
|
||||
record = await self.authenticated(request)
|
||||
await rate_limit(self.r, "web-chat:" + record["owner"], 20)
|
||||
text = body.text.strip()
|
||||
if not text:
|
||||
raise HTTPException(422, "empty message")
|
||||
# PC accepts only its bound owner and the existing IM read-only channel.
|
||||
if not (text == "/主机名" or text.startswith(("/回显 ", "/读取 ", "/助手 "))):
|
||||
text = "/助手 " + text
|
||||
turn = "web_" + digest(record["owner"] + "\0" + body.request_id)
|
||||
result = await self.broker.dispatch(record["owner"], text, turn)
|
||||
# Revoke/unbind during a long model call invalidates the browser immediately.
|
||||
await self.authenticated(request)
|
||||
return no_cache(JSONResponse(result))
|
||||
|
||||
async def logout(self, request: Request):
|
||||
self.check_origin(request)
|
||||
token = request.cookies.get(COOKIE, "")
|
||||
if token and len(token) <= 128:
|
||||
await self.r.delete("hn:web-session:" + digest(token))
|
||||
response = no_cache(JSONResponse({"status": "logged_out"}))
|
||||
response.delete_cookie(COOKIE, secure=True, httponly=True, samesite="strict", path="/")
|
||||
return response
|
||||
@@ -0,0 +1,40 @@
|
||||
"""Current-user Windows DPAPI for device keys; never uses machine-wide scope."""
|
||||
import ctypes
|
||||
import os
|
||||
from ctypes import wintypes
|
||||
|
||||
|
||||
class Blob(ctypes.Structure):
|
||||
_fields_ = [("cbData", wintypes.DWORD), ("pbData", ctypes.POINTER(ctypes.c_ubyte))]
|
||||
|
||||
|
||||
def transform(data, decrypt=False):
|
||||
if os.name != "nt":
|
||||
raise RuntimeError("DPAPI is supported only on Windows")
|
||||
buffer = (ctypes.c_ubyte * len(data)).from_buffer_copy(data)
|
||||
source = Blob(len(data), buffer)
|
||||
target = Blob()
|
||||
crypt = ctypes.WinDLL("crypt32", use_last_error=True)
|
||||
kernel = ctypes.WinDLL("kernel32", use_last_error=True)
|
||||
if decrypt:
|
||||
fn = crypt.CryptUnprotectData
|
||||
args = [ctypes.byref(source), None, None, None, None, 1, ctypes.byref(target)]
|
||||
else:
|
||||
fn = crypt.CryptProtectData
|
||||
args = [ctypes.byref(source), "Hainuo device identity", None, None, None, 1, ctypes.byref(target)]
|
||||
fn.restype = wintypes.BOOL
|
||||
if not fn(*args):
|
||||
raise ctypes.WinError(ctypes.get_last_error())
|
||||
try:
|
||||
return ctypes.string_at(target.pbData, target.cbData)
|
||||
finally:
|
||||
kernel.LocalFree.argtypes = [ctypes.c_void_p]
|
||||
kernel.LocalFree(target.pbData)
|
||||
|
||||
|
||||
def protect(data):
|
||||
return transform(data)
|
||||
|
||||
|
||||
def unprotect(data):
|
||||
return transform(data, decrypt=True)
|
||||
@@ -0,0 +1,152 @@
|
||||
"""Device-authenticated USER-token business gateway; no tenant-token fallback."""
|
||||
import hashlib
|
||||
import json
|
||||
import re
|
||||
import time
|
||||
from urllib.parse import unquote
|
||||
|
||||
import httpx
|
||||
from fastapi import APIRouter, HTTPException, Request
|
||||
from fastapi.responses import JSONResponse
|
||||
from pydantic import BaseModel, Field
|
||||
from .common import no_cache, rate_limit
|
||||
from .crypto import canonical, verified, verify_device
|
||||
from .store import INTEGRITY_ERRORS
|
||||
|
||||
|
||||
class DeviceProof(BaseModel):
|
||||
host_id: str = Field(pattern=r"^[a-f0-9]{32}$")
|
||||
proof: dict
|
||||
|
||||
|
||||
class BusinessCall(DeviceProof):
|
||||
method: str = Field(pattern=r"^(GET|POST|PATCH|DELETE)$")
|
||||
path: str = Field(max_length=1500)
|
||||
params: dict = Field(default_factory=dict)
|
||||
body: dict = Field(default_factory=dict)
|
||||
operation_id: str = Field(default="", max_length=100)
|
||||
|
||||
|
||||
def business_allowed(method, path):
|
||||
if any(x in unquote(path) for x in ("..", "\\", "%", "?", "#", "\r", "\n")):
|
||||
return False
|
||||
seg = r"[A-Za-z0-9_.@-]+"
|
||||
cal = r"/open-apis/calendar/v4/calendars"
|
||||
rules = {
|
||||
"GET": [cal, cal + "/" + seg, cal + "/" + seg + "/events(?:/" + seg + ")?(?:/attendees)?",
|
||||
r"/open-apis/contact/v3/users/" + seg, r"/open-apis/search/v1/user",
|
||||
r"/open-apis/(?:drive/v1/files|docx/v1/documents|wiki/v2/spaces|bitable/v1/apps)(?:/" + seg + ")*"],
|
||||
"POST": [cal + "/primary", cal + "/" + seg + "/events(?:/" + seg + "/attendees)?"],
|
||||
"PATCH": [cal + "/" + seg + "/events/" + seg],
|
||||
"DELETE": [cal + "/" + seg + "/events/" + seg, cal + "/" + seg + "/events/" + seg + "/attendees/" + seg],
|
||||
}
|
||||
return any(re.fullmatch(p, path) for p in rules.get(method, []))
|
||||
|
||||
|
||||
async def device_owner(settings, redis, store, host, proof, purpose, payload):
|
||||
device = store.device(host)
|
||||
if not device or device["revoked"] or not device["owner"]:
|
||||
raise HTTPException(403, "active bound device required")
|
||||
try:
|
||||
key = verify_device(device["cert"], settings.ca_cert.read_bytes(), host)
|
||||
data = verified(proof, key)
|
||||
if (data["host_id"] != host or data["purpose"] != purpose or abs(time.time() - data["ts"]) > 90
|
||||
or not re.fullmatch(r"[a-f0-9]{32}", data["nonce"])
|
||||
or data["payload_hash"] != hashlib.sha256(canonical(payload)).hexdigest()):
|
||||
raise ValueError()
|
||||
except Exception:
|
||||
raise HTTPException(403, "invalid device request proof") from None
|
||||
if not await redis.set("hn:work-proof:" + host + ":" + data["nonce"], "1", nx=True, ex=180):
|
||||
raise HTTPException(409, "device request replayed")
|
||||
return device["owner"]
|
||||
|
||||
|
||||
def router(settings, redis, store, platform):
|
||||
routes = APIRouter()
|
||||
store.db.execute("""CREATE TABLE IF NOT EXISTS business_operations(
|
||||
owner TEXT NOT NULL, operation_id TEXT NOT NULL, request_hash TEXT NOT NULL,
|
||||
status TEXT NOT NULL, result_meta TEXT NOT NULL, created DOUBLE PRECISION NOT NULL,
|
||||
PRIMARY KEY(owner,operation_id))""")
|
||||
if not settings.database_url:
|
||||
store.db.commit()
|
||||
|
||||
@routes.post("/work/api")
|
||||
async def call(body: BusinessCall, request: Request):
|
||||
if not settings.feishu_enabled:
|
||||
raise HTTPException(503, "platform disabled")
|
||||
auth = request.headers.get("Authorization", "")
|
||||
if not auth.startswith("Bearer ") or not 10 < len(auth) <= 8192:
|
||||
raise HTTPException(401, "user access token required")
|
||||
if not business_allowed(body.method, body.path):
|
||||
raise HTTPException(403, "business method/path not supported")
|
||||
payload = {"method": body.method, "path": body.path, "params": body.params, "body": body.body,
|
||||
"operation_id": body.operation_id, "token_hash": hashlib.sha256(auth[7:].encode()).hexdigest()}
|
||||
owner = await device_owner(settings, redis, store, body.host_id, body.proof, "work-api-v1", payload)
|
||||
await rate_limit(redis, "work-api:" + owner, 60)
|
||||
try:
|
||||
info = await platform.user_info(auth[7:])
|
||||
except Exception:
|
||||
raise HTTPException(401, "user token expired or invalid; refresh or authorize") from None
|
||||
if info.get("open_id") != owner:
|
||||
raise HTTPException(403, "token user does not match bound device owner")
|
||||
write = body.method != "GET" and not body.path.endswith(("/primary", "/batch_get_id"))
|
||||
digest = hashlib.sha256(canonical({k: v for k, v in payload.items() if k != "token_hash"})).hexdigest()
|
||||
if write:
|
||||
if not re.fullmatch(r"[A-Za-z0-9_-]{8,100}", body.operation_id):
|
||||
raise HTTPException(422, "write requires stable operation_id")
|
||||
try:
|
||||
with store.db:
|
||||
store.db.execute("INSERT INTO business_operations VALUES(?,?,?,?,?,?)",
|
||||
(owner, body.operation_id, digest, "inflight", "{}", time.time()))
|
||||
except INTEGRITY_ERRORS:
|
||||
row = dict(store.db.execute("SELECT * FROM business_operations WHERE owner=? AND operation_id=?",
|
||||
(owner, body.operation_id)).fetchone())
|
||||
if row["request_hash"] != digest:
|
||||
raise HTTPException(409, "operation_id reused with different request")
|
||||
return no_cache(JSONResponse({"status": "duplicate", "operation_id": body.operation_id,
|
||||
"previous_status": row["status"], **json.loads(row["result_meta"])}))
|
||||
params = dict(body.params)
|
||||
if write and body.method == "POST" and body.path.endswith("/events"):
|
||||
params["idempotency_key"] = hashlib.sha256((owner + body.operation_id).encode()).hexdigest()
|
||||
try:
|
||||
async with platform.http.stream(body.method, body.path, params=params,
|
||||
json=body.body if body.method != "GET" else None,
|
||||
headers={"Authorization": auth}) as upstream:
|
||||
raw = bytearray()
|
||||
async for chunk in upstream.aiter_bytes():
|
||||
raw.extend(chunk)
|
||||
if len(raw) > 2 * 1024 * 1024:
|
||||
raise ValueError()
|
||||
data = json.loads(raw)
|
||||
if not isinstance(data, dict):
|
||||
raise ValueError()
|
||||
code = data.get("code", 0)
|
||||
if upstream.status_code != 200 or code != 0:
|
||||
status = "platform_rejected"
|
||||
def safe_diagnostic(value):
|
||||
text = str(value)
|
||||
for secret in (auth, auth[7:], settings.feishu_app_secret, settings.admin_secret, settings.internal_secret):
|
||||
if secret:
|
||||
text = text.replace(secret, "[redacted]")
|
||||
return text[:2000]
|
||||
detail = data.get("error") or {}
|
||||
result = {"status": status, "http_status": upstream.status_code, "platform_code": code,
|
||||
"message": "平台拒绝:请核对用户授权、应用scope、资源权限或接口版本。",
|
||||
"platform_message": safe_diagnostic(data.get("msg", data.get("message", ""))),
|
||||
"platform_log_id": safe_diagnostic(detail.get("log_id", "")) if isinstance(detail, dict) else "",
|
||||
"permission_details": safe_diagnostic(detail.get("permission_violations", [])) if isinstance(detail, dict) else ""}
|
||||
else:
|
||||
status, result = "completed", {"status": "completed", "data": data.get("data", {})}
|
||||
except (httpx.HTTPError, ValueError):
|
||||
status = "unknown" if write else "failed"
|
||||
result = {"status": status, "message": "平台请求未取得明确结果;写操作不要换新ID重试,请先核对日历。"}
|
||||
if write:
|
||||
event = result.get("data", {}).get("event", {})
|
||||
meta = {k: event[k] for k in ("event_id", "app_link") if k in event}
|
||||
with store.db:
|
||||
store.db.execute("UPDATE business_operations SET status=?,result_meta=? WHERE owner=? AND operation_id=?",
|
||||
(status, json.dumps(meta), owner, body.operation_id))
|
||||
store.audit(owner, "work_api_" + body.method.lower(), body.path, status)
|
||||
return no_cache(JSONResponse(result))
|
||||
|
||||
return routes
|
||||
@@ -0,0 +1,190 @@
|
||||
"""PC-side user OAuth and calendar operations. Tokens are DPAPI-protected only here."""
|
||||
import hashlib
|
||||
import json
|
||||
import secrets
|
||||
import ssl
|
||||
import time
|
||||
from datetime import datetime
|
||||
from pathlib import Path
|
||||
from urllib.parse import quote, urlsplit
|
||||
|
||||
import httpx
|
||||
from .crypto import canonical, load_private, sign
|
||||
from .windows_keys import protect, unprotect
|
||||
from .process_lock import DeviceProcessLock
|
||||
|
||||
|
||||
class WorkError(RuntimeError):
|
||||
pass
|
||||
|
||||
|
||||
class AuthorizationRequired(WorkError):
|
||||
def __init__(self, url):
|
||||
self.url = url
|
||||
super().__init__("需要本人Work授权,请打开授权链接,完成后重新发起原任务;尚未执行平台写操作。")
|
||||
|
||||
|
||||
def atomic_secret(path, data):
|
||||
temp = path.with_suffix(".tmp")
|
||||
temp.write_bytes(protect(json.dumps(data, ensure_ascii=False).encode()))
|
||||
temp.replace(path)
|
||||
|
||||
|
||||
class WorkClient:
|
||||
def __init__(self, directory, url="https://10.77.76.13", *, transport=None):
|
||||
self.directory = Path(directory)
|
||||
self.config = json.loads((self.directory / "device.json").read_text(encoding="utf-8-sig"))
|
||||
if not self.config.get("owner"):
|
||||
raise WorkError("请先绑定本人Work身份。")
|
||||
context = ssl.create_default_context(cafile=str(self.directory / "server.pem"))
|
||||
self.http = httpx.Client(base_url=url.rstrip("/"), verify=context, trust_env=False,
|
||||
timeout=25, follow_redirects=False, transport=transport)
|
||||
self.owner = self.config["owner"]
|
||||
self.path = self.directory / "work-user-tokens.dpapi"
|
||||
self.pending = self.directory / "work-oauth-pending.dpapi"
|
||||
|
||||
def close(self):
|
||||
self.http.close()
|
||||
|
||||
def read(self, path):
|
||||
return json.loads(unprotect(path.read_bytes()))
|
||||
|
||||
def proof(self, purpose, payload):
|
||||
return sign({"host_id": self.config["host_id"], "purpose": purpose, "ts": int(time.time()),
|
||||
"nonce": secrets.token_hex(16), "payload_hash": hashlib.sha256(canonical(payload)).hexdigest()},
|
||||
load_private(self.directory / "device.key"))
|
||||
|
||||
def authorize(self):
|
||||
if self.pending.exists():
|
||||
data = self.read(self.pending)
|
||||
if data.get("owner") == self.owner and data["deadline"] > time.time():
|
||||
return data["authorization_url"]
|
||||
response = self.http.post("/oauth/start", json={"host_id": self.config["host_id"],
|
||||
"proof": self.proof("work-oauth-v1", {})})
|
||||
if response.status_code != 201:
|
||||
raise WorkError("授权事务创建失败(HTTP " + str(response.status_code) + "),请检查ECS平台配置。")
|
||||
data = response.json()
|
||||
if urlsplit(data["authorization_url"]).scheme != "https":
|
||||
raise WorkError("授权地址必须使用HTTPS。")
|
||||
data.update(owner=self.owner, deadline=time.time() + data["expires_in"])
|
||||
atomic_secret(self.pending, data)
|
||||
return data["authorization_url"]
|
||||
|
||||
def save_tokens(self, data):
|
||||
if data.get("open_id") != self.owner or not data.get("user_access_token"):
|
||||
raise WorkError("授权账号与本机Work绑定账号不一致,请使用本人账号重新授权。")
|
||||
now = time.time()
|
||||
data = {**data, "expires_at": now + int(data["expires_in"]),
|
||||
"refresh_expires_at": now + int(data.get("refresh_expires_in", 0)), "needs_authorization": False}
|
||||
atomic_secret(self.path, data)
|
||||
return data
|
||||
|
||||
def access_token(self):
|
||||
# Shared across GUI and Agent calls; never rotate the same token concurrently.
|
||||
with DeviceProcessLock(self.directory / "work-token-lock"):
|
||||
if self.path.exists():
|
||||
data = self.read(self.path)
|
||||
if data.get("open_id") == self.owner and not data.get("needs_authorization"):
|
||||
if data["expires_at"] > time.time() + 120:
|
||||
return data["user_access_token"]
|
||||
if data.get("refresh_token") and data.get("refresh_expires_at", 0) > time.time():
|
||||
# Mark before network; ambiguous failure must not reuse a rotating refresh token.
|
||||
atomic_secret(self.path, {**data, "needs_authorization": True})
|
||||
try:
|
||||
response = self.http.post("/oauth/refresh", json={"refresh_token": data["refresh_token"]})
|
||||
if response.status_code != 200:
|
||||
raise WorkError("刷新失败")
|
||||
data = self.save_tokens(response.json())
|
||||
return data["user_access_token"]
|
||||
except (httpx.HTTPError, ValueError, WorkError):
|
||||
raise AuthorizationRequired(self.authorize()) from None
|
||||
if self.pending.exists():
|
||||
pending = self.read(self.pending)
|
||||
if pending.get("owner") == self.owner and pending["deadline"] > time.time():
|
||||
response = self.http.get("/oauth/claim", params={"state": pending["state"]},
|
||||
headers={"X-OAuth-Claim-Secret": pending["claim_secret"]})
|
||||
if response.status_code == 200:
|
||||
data = self.save_tokens(response.json())
|
||||
self.pending.unlink(missing_ok=True)
|
||||
return data["user_access_token"]
|
||||
if response.status_code not in {202}:
|
||||
self.pending.unlink(missing_ok=True)
|
||||
raise AuthorizationRequired(self.authorize())
|
||||
|
||||
def status(self):
|
||||
try:
|
||||
token = self.access_token()
|
||||
return {"authorized": True, "owner": self.owner, "message": "本人用户授权可用;令牌未输出。",
|
||||
"local_time": datetime.now().astimezone().isoformat()}
|
||||
except AuthorizationRequired as error:
|
||||
return {"authorized": False, "authorization_url": error.url, "message": str(error)}
|
||||
|
||||
def api(self, method, path, params=None, body=None, operation_id=""):
|
||||
token = self.access_token()
|
||||
payload = {"method": method, "path": path, "params": params or {}, "body": body or {},
|
||||
"operation_id": operation_id, "token_hash": hashlib.sha256(token.encode()).hexdigest()}
|
||||
proof = self.proof("work-api-v1", payload)
|
||||
wire = {k: v for k, v in payload.items() if k != "token_hash"}
|
||||
response = self.http.post("/work/api", headers={"Authorization": "Bearer " + token},
|
||||
json={**wire, "host_id": self.config["host_id"], "proof": proof})
|
||||
if response.status_code == 401:
|
||||
# Do not repeat a business write automatically, even when auth fails.
|
||||
if self.path.exists():
|
||||
data = self.read(self.path)
|
||||
data["expires_at"] = 0
|
||||
atomic_secret(self.path, data)
|
||||
raise WorkError("用户令牌已失效。本次未重试,请检查授权后再核对操作状态。")
|
||||
if response.status_code != 200:
|
||||
raise WorkError("平台代理失败(HTTP " + str(response.status_code) + ");未重试。")
|
||||
return response.json()
|
||||
|
||||
def primary_calendar(self):
|
||||
result = self.api("POST", "/open-apis/calendar/v4/calendars/primary", {"user_id_type": "open_id"})
|
||||
if result.get("status") != "completed":
|
||||
return result
|
||||
calendars = result.get("data", {}).get("calendars", [])
|
||||
own = [c["calendar"] for c in calendars if c.get("user_id") == self.owner and c.get("calendar")]
|
||||
if not own and len(calendars) == 1 and not calendars[0].get("user_id") and calendars[0].get("calendar"):
|
||||
own = [calendars[0]["calendar"]]
|
||||
if len(own) != 1:
|
||||
raise WorkError("没有唯一确定的本人主日历,请先查询日历列表并明确选择。")
|
||||
return {"status": "completed", "calendar": own[0]}
|
||||
|
||||
def create_event(self, summary, start_iso, end_iso, attendee_open_ids, operation_id, description="", calendar_id=""):
|
||||
import re
|
||||
if not re.fullmatch(r"[A-Za-z0-9_-]{8,80}", operation_id):
|
||||
raise WorkError("创建日程需8到80位稳定operation_id,重试不得换ID。")
|
||||
if not summary.strip() or len(summary) > 1000:
|
||||
raise WorkError("日程主题不能为空或超过1000字符。")
|
||||
start, end = datetime.fromisoformat(start_iso), datetime.fromisoformat(end_iso)
|
||||
if start.tzinfo is None or end.tzinfo is None or end <= start:
|
||||
raise WorkError("起止时间必须包含时区且结束晚于开始;不要猜测时区或时长。")
|
||||
if any(not isinstance(x, str) or not x.startswith("ou_") for x in attendee_open_ids):
|
||||
raise WorkError("参会人必须为当前应用身份域的open_id,请先搜索并确认,不能把姓名/工号直接当ID。")
|
||||
if not calendar_id:
|
||||
primary = self.primary_calendar()
|
||||
if primary.get("status") != "completed":
|
||||
return primary
|
||||
calendar_id = primary["calendar"]["calendar_id"]
|
||||
path = "/open-apis/calendar/v4/calendars/" + quote(calendar_id, safe="") + "/events"
|
||||
body = {"summary": summary, "description": description, "need_notification": True,
|
||||
"start_time": {"timestamp": str(int(start.timestamp())), "timezone": "Asia/Shanghai"},
|
||||
"end_time": {"timestamp": str(int(end.timestamp())), "timezone": "Asia/Shanghai"}}
|
||||
result = self.api("POST", path, {"user_id_type": "open_id"}, body, operation_id)
|
||||
event = result.get("data", {}).get("event", {})
|
||||
if result.get("status") == "duplicate" and result.get("previous_status") == "completed":
|
||||
event = {"event_id": result.get("event_id"), "app_link": result.get("app_link")}
|
||||
elif result.get("status") != "completed":
|
||||
return result
|
||||
if not event.get("event_id"):
|
||||
raise WorkError("平台未返回event_id,不能认定创建成功或继续邀请。")
|
||||
ids = sorted(set([self.owner] + list(attendee_open_ids)))
|
||||
invite = self.api("POST", path + "/" + quote(event["event_id"], safe="") + "/attendees",
|
||||
{"user_id_type": "open_id"},
|
||||
{"attendees": [{"type": "user", "user_id": x} for x in ids], "need_notification": True},
|
||||
operation_id + "_attendees")
|
||||
invited = invite.get("status") == "completed" or (invite.get("status") == "duplicate" and invite.get("previous_status") == "completed")
|
||||
return {"status": "completed" if invited else "partial", "event_created": True,
|
||||
"calendar_id": calendar_id, "event_id": event["event_id"], "app_link": event.get("app_link"),
|
||||
"attendees_invited": invited, "invite_result": invite,
|
||||
"message": "日程已创建并提交参会人邀请;不代表对方已接受。" if invited else "日程已创建,但邀请未完成;保留原操作ID和event_id处理,勿重新创建日程。"}
|
||||
@@ -0,0 +1,145 @@
|
||||
"""Hermes native tools backed by the authenticated user-token relay."""
|
||||
import json
|
||||
import os
|
||||
import threading
|
||||
import time
|
||||
from pathlib import Path
|
||||
import httpx
|
||||
from .work_client import WorkClient, WorkError, AuthorizationRequired
|
||||
|
||||
INSTRUCTIONS = """海能Work平台能力已接入本机专用工具:work_authorization、work_calendar、work_contacts、work_api_request。
|
||||
涉及飞书/海能Work日历或文档时优先调用这些工具,勿使用manage_connections寻找公有云连接器,勿索要或搜索App Secret。
|
||||
用户token仅由本机安全存储和ECS换取,第一次需要本人打开授权链接。工具返回authorization_required时将链接完整提供给本人,不能声称已经创建。
|
||||
当前日期以work_authorization返回的local_time为准。创建日程必须确定带时区的起止时间和真实参会人open_id。
|
||||
姓名/工号须用work_contacts搜索核实,多个候选必须澄清,不能猜open_id。平台返回partial表示已创建但邀请未完成,勿再次创建。
|
||||
同一写操作的operation_id必须保持不变,网络异常不得换ID重试。日程创建成功、邀请提交成功、对方接受是不同状态。
|
||||
"""
|
||||
|
||||
_watching = set()
|
||||
_watch_lock = threading.Lock()
|
||||
|
||||
|
||||
def watch_authorization(directory):
|
||||
"""Claim within the server's 60-second result TTL, without keeping tokens in ECS."""
|
||||
name = str(directory)
|
||||
with _watch_lock:
|
||||
if name in _watching:
|
||||
return
|
||||
_watching.add(name)
|
||||
def poll():
|
||||
client = None
|
||||
try:
|
||||
client = WorkClient(directory, os.environ.get("HN_WORK_RELAY_URL", "https://10.77.76.13"))
|
||||
for _ in range(295):
|
||||
time.sleep(2)
|
||||
try:
|
||||
if client.pending.exists() and client.read(client.pending).get("deadline", 0) <= time.time():
|
||||
return
|
||||
if client.status().get("authorized"):
|
||||
return
|
||||
except Exception:
|
||||
# Another local consumer may hold the short token lock.
|
||||
continue
|
||||
except Exception:
|
||||
pass
|
||||
finally:
|
||||
if client:
|
||||
client.close()
|
||||
with _watch_lock:
|
||||
_watching.discard(name)
|
||||
threading.Thread(target=poll, daemon=True, name="work-user-auth-claim").start()
|
||||
|
||||
|
||||
def register(directory):
|
||||
from tools.registry import registry
|
||||
import toolsets
|
||||
definitions = [
|
||||
("work_authorization", "查询或发起本人海能Work用户授权,返回可点击链接和本机时间;不返回token。", {
|
||||
"type": "object", "properties": {}, "additionalProperties": False}),
|
||||
("work_calendar", "本人用户身份的日历:list/primary/list_events/get_event/create_event/invite。写操作operation_id需稳定,起止时间均带时区。", {
|
||||
"type": "object", "properties": {
|
||||
"action": {"type": "string", "enum": ["list", "primary", "list_events", "get_event", "create_event", "invite"]},
|
||||
"calendar_id": {"type": "string"}, "event_id": {"type": "string"},
|
||||
"summary": {"type": "string"}, "description": {"type": "string"},
|
||||
"start_iso": {"type": "string", "description": "ISO8601,例如2026-10-27T09:00:00+08:00"},
|
||||
"end_iso": {"type": "string"}, "attendee_open_ids": {"type": "array", "items": {"type": "string"}},
|
||||
"operation_id": {"type": "string", "description": "8-80位稳定操作ID,同一意图重试不能更换"},
|
||||
"params": {"type": "object"}}, "required": ["action"]}),
|
||||
("work_contacts", "使用本人user token搜索参会人;query可为姓名或工号,返回候选,不能未经核实猜ID。open_id可读取具体用户信息。", {
|
||||
"type": "object", "properties": {"query": {"type": "string"}, "open_id": {"type": "string"}}}),
|
||||
("work_api_request", "携本人user token代理受支持业务API(日历CRUD/邀请、通讯录查询、文档云盘知识库读取)。禁止认证接口,不支持的路径返回403。写操作必须operation_id。", {
|
||||
"type": "object", "properties": {"method": {"type": "string", "enum": ["GET", "POST", "PATCH", "DELETE"]},
|
||||
"path": {"type": "string"}, "params": {"type": "object"}, "body": {"type": "object"},
|
||||
"operation_id": {"type": "string"}}, "required": ["method", "path"]}),
|
||||
]
|
||||
|
||||
def handler_for(name):
|
||||
def handle(args, **kwargs):
|
||||
client = None
|
||||
try:
|
||||
client = WorkClient(directory, os.environ.get("HN_WORK_RELAY_URL", "https://10.77.76.13"))
|
||||
if name == "work_authorization":
|
||||
result = client.status()
|
||||
if not result.get("authorized"):
|
||||
watch_authorization(directory)
|
||||
elif name == "work_api_request":
|
||||
result = client.api(**args)
|
||||
elif name == "work_contacts":
|
||||
from urllib.parse import quote
|
||||
result = client.api("GET", "/open-apis/contact/v3/users/" + quote(args["open_id"], safe=""),
|
||||
{"user_id_type": "open_id"}) if args.get("open_id") else client.api(
|
||||
"GET", "/open-apis/search/v1/user", {"query": args.get("query", ""), "page_size": 20})
|
||||
else:
|
||||
result = calendar(client, args)
|
||||
return json.dumps(result, ensure_ascii=False)
|
||||
except AuthorizationRequired as error:
|
||||
watch_authorization(directory)
|
||||
return json.dumps({"status": "authorization_required", "authorization_url": error.url, "message": str(error)}, ensure_ascii=False)
|
||||
except (WorkError, ValueError, KeyError) as error:
|
||||
return json.dumps({"error": str(error)[:500], "status": "failed"}, ensure_ascii=False)
|
||||
except Exception as error:
|
||||
return json.dumps({"error": type(error).__name__ + ";操作状态未确认,未自动重试。"}, ensure_ascii=False)
|
||||
finally:
|
||||
if client:
|
||||
client.close()
|
||||
return handle
|
||||
|
||||
for name, description, parameters in definitions:
|
||||
registry.register(name=name, toolset="hainuo_work", schema={"name": name, "description": description, "parameters": parameters},
|
||||
handler=handler_for(name), description=description)
|
||||
toolsets.TOOLSETS["hainuo_work"] = {"description": "海能Work本人用户授权及日历业务", "tools": [x[0] for x in definitions], "includes": []}
|
||||
# Present these four small schemas directly; otherwise Hermes defers custom
|
||||
# toolsets behind tool_search and can wrongly search a public-cloud connector.
|
||||
for name, _, _ in definitions:
|
||||
if name not in toolsets._HERMES_CORE_TOOLS:
|
||||
toolsets._HERMES_CORE_TOOLS.append(name)
|
||||
|
||||
|
||||
def calendar(client, args):
|
||||
from urllib.parse import quote
|
||||
action = args["action"]
|
||||
if action == "primary":
|
||||
return client.primary_calendar()
|
||||
if action == "list":
|
||||
return client.api("GET", "/open-apis/calendar/v4/calendars", args.get("params", {}))
|
||||
if action == "create_event":
|
||||
return client.create_event(**{k: v for k, v in args.items() if k != "action" and k != "params"})
|
||||
calendar_id = args.get("calendar_id")
|
||||
if not calendar_id:
|
||||
primary = client.primary_calendar()
|
||||
if primary.get("status") != "completed":
|
||||
return primary
|
||||
calendar_id = primary["calendar"]["calendar_id"]
|
||||
base = "/open-apis/calendar/v4/calendars/" + quote(calendar_id, safe="") + "/events"
|
||||
if action == "list_events":
|
||||
return client.api("GET", base, args.get("params", {}))
|
||||
base += "/" + quote(args["event_id"], safe="")
|
||||
if action == "get_event":
|
||||
return client.api("GET", base, {"user_id_type": "open_id"})
|
||||
if action == "invite":
|
||||
ids = args.get("attendee_open_ids", [])
|
||||
if not ids or any(not x.startswith("ou_") for x in ids):
|
||||
raise WorkError("需要已确认的参会人open_id。")
|
||||
return client.api("POST", base + "/attendees", {"user_id_type": "open_id"},
|
||||
{"attendees": [{"type": "user", "user_id": x} for x in ids], "need_notification": True}, args["operation_id"])
|
||||
raise WorkError("不支持的日历操作。")
|
||||
Reference in New Issue
Block a user