Import ECS deployed relay source and historical patches (2026-10-27)

This commit is contained in:
ex_tianzy
2026-10-27 17:26:58 +08:00
commit 011a7797ee
319 changed files with 34265 additions and 0 deletions
@@ -0,0 +1,10 @@
FROM python:3.12-slim-bookworm
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 PIP_NO_CACHE_DIR=1
WORKDIR /app
COPY wheelhouse /wheels
COPY requirements.lock pyproject.toml ./
COPY relay ./relay
RUN pip install --no-index --find-links=/wheels --no-cache-dir -r requirements.lock && rm -rf /wheels
RUN chmod -R a+rX /app
USER 10001:10001
ENTRYPOINT ["python", "-m", "relay.cli"]
@@ -0,0 +1,78 @@
# H5配对和真实海诺对话 · 2026-10-26增量
## 已有环境无需重做
- ECS:10.77.76.13:443,目录 `/home/cnooc/hainuo-offline-arm64/hainuo-relay`。
- PC已绑定 `ou_test_tianzeyuan`,证书目录 `D:\HainuoRelayDevice`。
- 实际海诺安装位置 `%LOCALAPPDATA%\Hainuo`,不是示例D:\Hainuo1065。
- 本机原生API:127.0.0.1:8643,纯文本模式;ECS→桥接端→真实模型已经返回42。
本次新增:网页配对、Secure/HttpOnly浏览器会话、设备在线状态、纯文本聊天、离线提示、请求去重、退出登录及绑定变更失效。暂不依赖海能Work OAuth配置。
## 1. 更新ECS
将 `hainuo-relay-h5-update-20261026.tar.gz`上传到 `/home/cnooc`,执行:
```bash
tar -xzf /home/cnooc/hainuo-relay-h5-update-20261026.tar.gz \
-C /home/cnooc/hainuo-offline-arm64
cd /home/cnooc/hainuo-offline-arm64/hainuo-relay
sudo bash scripts/update-h5.sh
```
增量包只包含源码、网页资源、更新脚本、Dockerfile和说明,不包含.env、runtime、证书、CA或数据库。更新先保留旧镜像标签,使用原wheelhouse离线构建,只重建连接器;其他组件不重装。连接器重启时在途请求可能中断,等当前任务完成后再更新。
不要运行旧的install.sh重新初始化,不要重新解压整包覆盖更新后的源码。后续recreate使用compose.h5.yaml,以保留180秒模型等待时间。
## 2. Windows生成网页配对码
本机项目已更新 `web-pair`命令,原生API与桥接端保持运行。Windows PowerShell执行:
```powershell
cd "C:\Users\huawei\Desktop\海能h5连接海诺客户端\hainuo-relay"
& "..\.venv\Scripts\python.exe" -m relay.cli web-pair `
--directory D:\HainuoRelayDevice `
--url https://10.77.76.13 `
--tls-ca D:\HainuoRelayDevice\server.pem
```
输出网页地址和一次性配对码。有效期120秒;不要发到群里、工单或聊天截图。生成失败HTTP404表示ECS仍是旧版,先完成步骤1。
## 3. 浏览器配对和聊天
打开 `https://10.77.76.13/h5`,必要时Ctrl+F5刷新。页面应出现“输入电脑上的配对码”和“连接我的电脑”,不再只有原OAuth按钮。
粘贴配对码后点击连接。网页显示“你的电脑已在线”后,发送:
```text
请计算17加25,只回复计算结果。
```
预期回复42。普通文本自动加 `/助手`转给本机真实海诺API;`/主机名`和`/回显 内容`保留用于核对目标设备。
每个消息有独立请求ID;同一ID不会重复执行。网络失败不自动重发;出现状态未知时先核查,不要重复提交有副作用的任务。当前所有原生模型调用禁止工具,不能执行删除等指令。
## 会话和安全边界
- 网页登录依靠本机设备私钥签名申请的高熵一次性码,不接受网页自报owner/host作为身份。
- 配对码120秒一次消费、会话30分钟固定过期。服务端只保存配对/会话凭据的SHA256索引;浏览器凭据只放Secure、HttpOnly、SameSite=Strict Cookie,不放URL或localStorage。
- 网页POST必须Origin与HN_PUBLIC_URL一致;ECS当前应为 `https://10.77.76.13`。不开放任意Origin,不用管理员密钥给网页登录。
- 请求主体由浏览器会话确定;切换用户、解绑、吊销或绑定代次变化会失效。另一用户不能通过提交open_id调用你的电脑。
- 这是**试点中继网页模式**:浏览器HTTPS在入口终止,B1在内存中处理网页正文,再应用层加密发到PC;B2只见密文。中继不保存聊天正文,网页关闭或退出后当前页面历史不保留。
- 这与领导原方案“浏览器TLS直接终止在PC、中心看不到网页正文”不同。不能将本模式称作浏览器到PC端到端加密或正式生产安全验收通过。
- 海能Work授权入口仍保留;只有配置真实平台OAuth后才能使用。后续可独立切换平台身份来源。
- 本地原生API+桥接端目前是后台进程,电脑重启后需要按原生接入手册恢复启动;尚未实现Windows服务自启动。
## 验收
1. 未配对网页不可派发任务,直接访问/web/chat应401。
2. 配对后收到42,/主机名与Windows hostname一致。
3. 同一配对码第二个浏览器使用失败。
4. 退出网页登录后,原Cookie立即无效。
5. PC停止桥接端时网页显示离线,新问题返回离线提示;重连后恢复。
6. 两个设备不同账号分别配对,消息不串机。
7. 跨站Origin不能兑换配对码或派发任务。
本地自动化用真实HTTP/WebSocket与模拟平台/模型检验链路;真实ECS H5页面更新后的配对与对话,仍需按上述步骤执行验收。
本轮回归结果:48项通过、1项真实PostgreSQL用例因本地环境缺失跳过。新增9项包含H5会话与原生HTTP组合链路,覆盖一次配对码、并发消费、跨站拒绝、两账号隔离、去重、退出与过期、绑定变更失效。
@@ -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", "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 == "revoke":
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 == "revoke":
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}/revoke"
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,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,60 @@
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_app_id: str = ""
feishu_app_secret: str = ""
feishu_encrypt_key: str = ""
feishu_verification_token: str = ""
feishu_enabled: bool = False
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
@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_enabled and not all((self.feishu_app_id, self.feishu_app_secret,
self.feishu_encrypt_key,
self.feishu_verification_token)):
raise ValueError("complete platform credentials are required")
return self
@@ -0,0 +1,478 @@
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)
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)
@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)}
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 = "已解绑;重新绑定后请更新本机绑定信息。"
else:
result = (await broker.dispatch(owner, text, "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")
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,134 @@
"""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):
return serialization.load_pem_private_key(path.read_bytes(), 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,206 @@
"""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, 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, *, 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")
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:
if once:
raise
# 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,105 @@
"""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") != "text-only":
raise ValueError("only verified text-only mode is supported")
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.
if policy != {"mode": "text-only", "tools": "disabled", "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": "text-only", "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,59 @@
"""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 main():
import lark_oapi as lark
s = Settings(role="longconn")
if not s.feishu_enabled:
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)
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")
handler = lark.EventDispatcherHandler.builder("", "").register_p2_im_message_receive_v1(received).build()
try:
# domain is an actual supported SDK argument; no public-cloud-domain monkey patch.
lark.ws.Client(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__":
main()
@@ -0,0 +1,127 @@
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
class Empty(BaseModel):
pass
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:
raise HTTPException(503, "platform disabled")
await rate_limit(self.redis, "oauth:start:" + peer(request), 20)
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)
redirect = self.settings.public_url.rstrip("/") + "/oauth/cb"
url = self.settings.feishu_authorize_url + "?" + urlencode({"app_id": self.settings.feishu_app_id,
"redirect_uri": redirect, "state": state})
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 = ""):
await rate_limit(self.redis, "oauth:cb:" + peer(request))
async with self.lock:
self.prune()
item = self.pending.get(state)
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)
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"
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,89 @@
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)
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})
return self.normalize(data["data"])
@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["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,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,132 @@
"""Run the actual 1.065 API adapter, isolated from bot/scheduler startup.
Run with the installed Hermes Python, not the relay Python. No installer code
or existing profiles are edited. Only a separate loopback listener is started.
"""
import argparse
import asyncio
import json
import logging
import os
import secrets
import sys
from pathlib import Path
def prepare_environment(install_root, profile, port, config_path):
if not profile or any(c not in "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-" for c in profile):
raise ValueError("invalid profile")
source = install_root / "hermes-agent"
home = install_root if profile == "default" else install_root / "profiles" / profile
if not (source / "gateway/platforms/api_server.py").is_file() or not (home / "config.yaml").is_file():
raise RuntimeError("installation/profile does not match installer 1.065 layout")
# Environment must be selected before importing any Hermes module (global caches).
os.environ["HERMES_HOME"] = str(home.resolve())
os.environ["API_SERVER_HOST"] = "127.0.0.1"
os.environ["API_SERVER_PORT"] = str(port)
os.environ["API_SERVER_CORS_ORIGINS"] = ""
os.environ["HERMES_SKIP_CWD_MIGRATION"] = "1"
sys.path.insert(0, str(source.resolve()))
# Use the package's own dotenv support to reuse the real profile model credentials.
from dotenv import load_dotenv
load_dotenv(install_root / ".env", override=False)
if home != install_root:
load_dotenv(home / ".env", override=True)
if config_path.exists():
data = json.loads(config_path.read_text(encoding="utf-8-sig"))
if data.get("url") != f"http://127.0.0.1:{port}" or data.get("mode") != "text-only" or len(data.get("api_key", "")) < 32:
raise ValueError("existing local adapter config does not match listener")
key = data["api_key"]
else:
key = secrets.token_hex(32)
data = {"url": f"http://127.0.0.1:{port}", "api_key": key, "mode": "text-only"}
config_path.parent.mkdir(parents=True, exist_ok=True)
with config_path.open("x", encoding="utf-8") as out:
json.dump(data, out, indent=2)
if os.name != "nt":
config_path.chmod(0o600)
os.environ["API_SERVER_KEY"] = key
return key
def restricted_adapter_class(native_class, tools_config):
original_tools = tools_config._get_platform_tools
def without_remote_tools(config, platform, **kwargs):
if platform == "api_server":
return set()
return original_tools(config, platform, **kwargs)
tools_config._get_platform_tools = without_remote_tools
class RestrictedNativeAPI(native_class):
def _wire_plugin_handlers(self, app):
# Native connect() normally appends plugin HTTP handlers after the
# route table. Do not let that reopen the restricted companion API.
return None
def _create_agent(self, *args, **kwargs):
agent = super()._create_agent(*args, **kwargs)
# Model/tool construction is native. Fail BEFORE run_conversation if
# any plugin/recovery path silently reintroduced tools.
if getattr(agent, "tools", None) or getattr(agent, "valid_tool_names", None):
raise RuntimeError("text-only relay listener refuses an Agent with tools")
return agent
def _http_route_table(self):
allowed = {("GET", "/health"), ("GET", "/v1/models"),
("GET", "/v1/capabilities"), ("POST", "/v1/chat/completions")}
return [(method, path, handler) for method, path, handler in super()._http_route_table()
if (method, path) in allowed]
async def _handle_capabilities(self, request):
response = await super()._handle_capabilities(request)
data = json.loads(response.body)
data["hainuo_relay_policy"] = {"mode": "text-only", "tools": "disabled", "contract": "hainuo-1065-v1"}
# Do not advertise native admin/session/tool operations removed above.
endpoints = data.get("endpoints", {})
data["endpoints"] = {k: v for k, v in endpoints.items() if k in {"health", "models", "capabilities", "chat_completions"}}
data["features"] = {"text_only": True, "tools": False, "streaming": False}
from aiohttp import web
return web.json_response(data)
return RestrictedNativeAPI
async def serve_native(port, key):
from gateway.config import PlatformConfig
from gateway.platforms.api_server import APIServerAdapter
from hermes_cli import tools_config
adapter_class = restricted_adapter_class(APIServerAdapter, tools_config)
adapter = adapter_class(PlatformConfig(enabled=True, extra={"host": "127.0.0.1", "port": port,
"key": key, "model_name": "hainuo-relay-text"}))
try:
if not await adapter.connect():
raise RuntimeError("native API did not start; verify port and native installation")
print(f"海诺原生API已启动:http://127.0.0.1:{port}(纯文本,无工具;凭据未回显)", flush=True)
await asyncio.Event().wait()
finally:
await adapter.disconnect()
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--install-root", type=Path, required=True)
parser.add_argument("--profile", default="hainuo")
parser.add_argument("--port", type=int, default=8643)
parser.add_argument("--config", type=Path, required=True)
args = parser.parse_args()
if not 1024 <= args.port <= 65535:
raise ValueError("invalid port")
# Native logs can contain provider/user content; this companion emits status only.
logging.disable(logging.CRITICAL)
key = prepare_environment(args.install_root.resolve(), args.profile, args.port, args.config.resolve())
try:
asyncio.run(serve_native(args.port, key))
except KeyboardInterrupt:
print("海诺原生API已停止。")
except Exception as error:
print(f"原生API启动失败({type(error).__name__});未输出凭据。请使用安装包自带Python,并核对安装根目录与Profile。", file=sys.stderr)
raise SystemExit(1) from None
if __name__ == "__main__":
main()
@@ -0,0 +1,32 @@
#!/usr/bin/env bash
set -euo pipefail
cd "$(dirname "$0")/.."
test -f .env || { echo 'Run inside the existing deployment; .env missing.'; exit 1; }
test -d wheelhouse || { echo 'Existing offline wheelhouse missing.'; exit 1; }
backup_tag="hainuo-relay:before-h5-$(date +%Y%m%d-%H%M%S)"
docker image tag hainuo-relay:0.1.0 "$backup_tag"
echo "Rollback image: $backup_tag"
# Offline dependencies are unchanged; do not pull images or initialize a new database.
docker build --network none --pull=false -f Dockerfile.offline -t hainuo-relay:0.1.0 .
cat > compose.h5.yaml <<'YAML'
services:
connector:
environment:
HN_REQUEST_TIMEOUT: "180"
YAML
args=(-f compose.yaml -f compose.offline.yaml)
if [ -f compose.edge-fix.yaml ]; then args+=(-f compose.edge-fix.yaml); fi
args+=(-f compose.h5.yaml)
docker compose "${args[@]}" config --quiet
docker compose "${args[@]}" up -d --no-build --pull never --no-deps --force-recreate connector
for attempt in {1..30}; do
if docker compose "${args[@]}" exec -T connector python -c \
"import urllib.request; urllib.request.urlopen('http://127.0.0.1:8000/ready',timeout=2)" 2>/dev/null; then
docker compose "${args[@]}" exec -T connector python -c \
"import urllib.request; t=urllib.request.urlopen('http://127.0.0.1:8000/h5').read(); assert b'pair-form' in t; print('H5 pairing/chat revision is ready')"
exit 0
fi
sleep 2
done
echo 'Connector not ready. Read: sudo docker compose logs --tail 80 connector'
exit 1
@@ -0,0 +1,116 @@
import asyncio
import contextlib
import json
import socket
import fakeredis.aioredis
import httpx
import pytest_asyncio
import uvicorn
from relay.cli import device_request, init_project, issue
from relay.config import Settings
from relay.connector import create_app as connector_app
from relay.router import create_app as router_app
class PlatformStub:
def __init__(self):
self.replies = []
self.exchanges = 0
self.refreshes = 0
async def exchange(self, code):
self.exchanges += 1
await asyncio.sleep(0.01)
return {"user_access_token": "fake-user-token", "refresh_token": "fake-refresh-token",
"expires_in": 6900, "refresh_expires_in": 2592000, "open_id": "ou_test"}
async def refresh(self, token):
self.refreshes += 1
await asyncio.sleep(0.01)
return {"user_access_token": "new-fake-token", "refresh_token": "rotated-fake-token",
"expires_in": 7200, "open_id": "ou_test"}
async def user_info(self, token):
return {"open_id": "ou_test"}
async def reply(self, message, text):
self.replies.append((message, text))
async def close(self):
pass
async def serve(app):
sock = socket.socket()
sock.bind(("127.0.0.1", 0))
sock.listen(128)
port = sock.getsockname()[1]
server = uvicorn.Server(uvicorn.Config(app, log_level="critical", access_log=False, lifespan="on"))
task = asyncio.create_task(server.serve(sockets=[sock]))
for _ in range(200):
if server.started:
return server, task, port
if task.done():
task.result()
raise RuntimeError("server failed")
await asyncio.sleep(0.01)
raise RuntimeError("server startup timeout")
@pytest_asyncio.fixture
async def env(tmp_path):
init_project(tmp_path, "localhost")
settings = Settings(environment="test", admin_secret="a" * 40, internal_secret="b" * 40,
data_dir=tmp_path / "runtime/connector", ca_cert=tmp_path / "runtime/trust/ca.pem",
connector_key=tmp_path / "runtime/connector/connector.key",
connector_public_key=tmp_path / "runtime/trust/connector.pub",
feishu_enabled=True, feishu_app_id="cli_test", feishu_app_secret="fake-app-secret",
feishu_encrypt_key="fake-encrypt-key", feishu_verification_token="fake-verification",
public_url="http://localhost", router_url="ws://localhost/device/ws", request_timeout=2)
redis = fakeredis.aioredis.FakeRedis(decode_responses=True)
platform = PlatformStub()
connector = connector_app(settings, redis=redis, platform=platform)
router = router_app(settings, redis=redis)
cs, ct, cp = await serve(connector)
rs, rt, rp = await serve(router)
client = httpx.AsyncClient(base_url=f"http://127.0.0.1:{cp}", timeout=10)
state = {"settings": settings, "redis": redis, "platform": platform, "connector": connector,
"router": router, "client": client, "root": tmp_path,
"connector_url": f"http://127.0.0.1:{cp}", "router_url": f"ws://127.0.0.1:{rp}/device/ws",
"admin": {"X-Admin-Secret": settings.admin_secret}, "tasks": []}
yield state
for task in state["tasks"]:
task.cancel()
await asyncio.gather(*state["tasks"], return_exceptions=True)
await client.aclose()
cs.should_exit = rs.should_exit = True
await asyncio.wait_for(asyncio.gather(ct, rt), timeout=10)
await redis.aclose()
async def provision(env, owner="ou_test"):
directory = env["root"] / owner
device_request(directory)
output = env["root"] / (owner + "-issued")
issue(env["root"], directory / "request.json", output)
for name in ["device.pem", "ca.pem", "connector.pub", "device.json"]:
(directory / name).write_bytes((output / name).read_bytes())
registration = json.loads((output / "registration.json").read_text())
response = await env["client"].post("/admin/devices", json=registration, headers=env["admin"])
assert response.status_code == 201, response.text
response = await env["client"].post("/admin/test/binding-code", json={"open_id": owner, "text": "ignored"}, headers=env["admin"])
code = response.json()["message"].split(":")[-1]
from relay.device import bind_device
await bind_device(directory, env["connector_url"], code)
return directory, registration["host_id"]
async def connect_device(env, directory, root=None):
from relay.device import run_device
connected = asyncio.Event()
task = asyncio.create_task(run_device(directory, env["router_url"], root=root, connected_event=connected))
env["tasks"].append(task)
await asyncio.wait_for(connected.wait(), 5)
return task
@@ -0,0 +1,24 @@
import json
import httpx
import pytest
from relay.device import LocalAgent
async def test_local_agent_contract_and_no_redirect():
requests = []
def handler(request):
requests.append(json.loads(request.content))
return httpx.Response(200, json={"result": "本机助手结果"})
agent = LocalAgent("http://127.0.0.1:8765/relay/read-only", transport=httpx.MockTransport(handler))
assert await agent.execute("整理测试文件", "ou_test", "turn") == "本机助手结果"
assert requests[0] == {"text": "整理测试文件", "open_id": "ou_test", "turn_id": "turn", "channel": "im", "read_only": True}
await agent.close()
agent = LocalAgent("http://127.0.0.1:8765/relay/read-only", transport=httpx.MockTransport(
lambda request: httpx.Response(302, headers={"Location": "https://evil.invalid"})))
assert "未返回成功" in await agent.execute("text", "owner", "turn")
await agent.close()
def test_agent_rejects_nonlocal_endpoint():
with pytest.raises(ValueError):
LocalAgent("https://external.example.invalid/run")
@@ -0,0 +1,141 @@
import asyncio
import hashlib
import json
import secrets
import time
import pytest
from cryptography.hazmat.primitives import padding
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from websockets.asyncio.client import connect
from relay.crypto import load_private, sign
from relay.device import DeviceJournal
from relay.config import Settings
from .conftest import provision, connect_device
from .test_integration import dispatch, event
async def test_expired_and_capacity_oauth(env):
client = env["client"]
data = (await client.post("/oauth/start", json={})).json()
env["connector"].state.oauth.pending[data["state"]].expires = time.monotonic() - 1
assert (await client.get("/oauth/cb", params={"state": data["state"], "code": "x"})).status_code == 400
env["settings"].max_pending = 1
assert (await client.post("/oauth/start", json={})).status_code == 201
assert (await client.post("/oauth/start", json={})).status_code == 503
async def test_binding_wrong_signature_does_not_consume(env):
# Provision one device but remove initial binding to exercise a second code.
directory, host = await provision(env)
env["connector"].state.store.unbind("ou_test")
response = await env["client"].post("/admin/test/binding-code", headers=env["admin"],
json={"open_id": "ou_test", "text": "ignored"})
code = response.json()["message"].split(":")[-1]
proof = sign({"host_id": host, "code": code, "ts": int(time.time())}, load_private(directory / "device.key"))
damaged = {**proof, "signature": "AAAA"}
assert (await env["client"].post("/device/bind", json={"host_id": host, "proof": damaged})).status_code == 403
assert (await env["client"].post("/device/bind", json={"host_id": host, "proof": proof})).status_code == 200
assert (await env["client"].post("/device/bind", json={"host_id": host, "proof": proof})).status_code == 404
async def test_timeout_is_unknown_and_cannot_reexecute(env):
directory, host = await provision(env)
# A live session is required: pause reply processing to reproduce an ambiguous result.
await connect_device(env, directory)
env["connector"].state.reply_task.cancel()
await asyncio.sleep(0)
result = await dispatch(env, "ou_test", "/回显 delayed", "timeout-turn")
assert result.json()["status"] == "unknown"
assert (await dispatch(env, "ou_test", "/回显 retried", "timeout-turn")).json()["status"] == "duplicate"
assert (await env["client"].get("/ready")).status_code == 503
async def test_duplicate_device_connection_rejected(env):
from relay.crypto import raw_public
from cryptography.hazmat.primitives.asymmetric import x25519
directory, host = await provision(env)
await connect_device(env, directory)
async with connect(env["router_url"], proxy=None) as ws:
challenge = json.loads(await ws.recv())["challenge"]
proof = sign({"host_id": host, "session_id": secrets.token_hex(16), "challenge": challenge,
"kx": raw_public(x25519.X25519PrivateKey.generate().public_key()), "ts": int(time.time())},
load_private(directory / "device.key"))
await ws.send(json.dumps({"host_id": host, "cert": (directory / "device.pem").read_text(), "proof": proof}))
from websockets.exceptions import ConnectionClosed
with pytest.raises(ConnectionClosed):
await ws.recv()
assert (await dispatch(env, "ou_test", "/回显 original")).json()["result"] == "original"
async def test_encrypted_webhook_and_stale_signature(env):
directory, _ = await provision(env)
await connect_device(env, directory)
s = env["settings"]
raw_event = json.dumps(event(env, "om_encrypted"), ensure_ascii=False).encode()
pad = padding.PKCS7(128).padder()
padded = pad.update(raw_event) + pad.finalize()
iv = secrets.token_bytes(16)
enc = Cipher(algorithms.AES(hashlib.sha256(s.feishu_encrypt_key.encode()).digest()), modes.CBC(iv)).encryptor()
import base64
raw = json.dumps({"encrypt": base64.b64encode(iv + enc.update(padded) + enc.finalize()).decode()}).encode()
timestamp, nonce = str(int(time.time())), "encrypted-nonce"
headers = {"X-Lark-Request-Timestamp": timestamp, "X-Lark-Request-Nonce": nonce,
"X-Lark-Signature": hashlib.sha256((timestamp + nonce + s.feishu_encrypt_key).encode() + raw).hexdigest()}
assert (await env["client"].post("/feishu/event", content=raw, headers=headers)).status_code == 200
for _ in range(100):
if env["platform"].replies:
break
await asyncio.sleep(0.01)
assert env["platform"].replies == [("om_encrypted", "平台事件")]
headers["X-Lark-Request-Timestamp"] = str(int(time.time()) - 600)
assert (await env["client"].post("/feishu/event", content=raw, headers=headers)).status_code == 403
async def test_h5_and_whoami_only_returns_owned_static_domain(env):
await provision(env)
env["settings"].device_domain = "pc.example.invalid"
response = await env["client"].get("/h5")
assert response.status_code == 200
assert "script-src 'self'" in response.headers["content-security-policy"]
assert (await env["client"].get("/assets/app.js")).status_code == 200
assert (await env["client"].get("/api/whoami")).status_code == 401
response = await env["client"].get("/api/whoami?target=https://evil.invalid", headers={"Authorization": "Bearer fake-user"})
assert response.status_code == 200
assert response.json()["url"].endswith(".pc.example.invalid/")
assert response.json()["device_login_required"] is True
async def test_proxy_blocks_auth_endpoints_absolute_urls_and_traversal(env):
env["settings"].proxy_enabled = True
for target in ["https://evil.invalid/", "//evil.invalid/", "/open-apis/auth/v3/tenant_access_token/internal",
"/open-apis/authen/v1/user_info", "/open-apis/drive/v1/files/%2e%2e/auth", "/open-apis/drive/v1/files%0d%0aX:evil"]:
result = await env["client"].get("/proxy", headers={"Authorization": "Bearer fake-user", "X-Relay-Target": target})
assert result.status_code == 403, target
def test_device_journal_survives_restart(tmp_path):
path = tmp_path / "journal.sqlite"
journal = DeviceJournal(path)
assert journal.consume("turn")
journal.close()
journal = DeviceJournal(path)
assert not journal.consume("turn")
journal.close()
def test_production_fails_closed():
with pytest.raises(ValueError):
Settings(environment="production", admin_secret="short", internal_secret="short")
with pytest.raises(ValueError):
Settings(environment="production", admin_secret="a" * 40, internal_secret="b" * 40,
public_url="http://localhost")
async def test_validation_errors_do_not_echo_tokens(env):
token = "fake-confidential-token-" * 300
response = await env["client"].post("/oauth/refresh", json={"refresh_token": token})
assert response.status_code == 422
assert "fake-confidential" not in response.text
assert response.json() == {"detail": "invalid request parameters"}
@@ -0,0 +1,38 @@
import copy
import time
import pytest
from cryptography.exceptions import InvalidSignature, InvalidTag
from cryptography.hazmat.primitives.asymmetric import ed25519, x25519
from cryptography.hazmat.primitives import serialization
from relay.crypto import (issue_ca, issue_device, raw_public, seal, open_envelope, verify_device)
def test_encrypted_and_authenticated():
signer = ed25519.Ed25519PrivateKey.generate()
recipient = x25519.X25519PrivateKey.generate()
envelope = seal({"text": "秘密合同"}, raw_public(recipient.public_key()), signer, host_id="host", session_id="session")
assert "秘密" not in str(envelope)
assert open_envelope(envelope, recipient, signer.public_key(), host_id="host", session_id="session")["text"] == "秘密合同"
damaged = copy.deepcopy(envelope)
damaged["ciphertext"] = damaged["ciphertext"][:-4] + "AAAA"
with pytest.raises(InvalidSignature):
open_envelope(damaged, recipient, signer.public_key(), host_id="host", session_id="session")
with pytest.raises(ValueError):
open_envelope(envelope, recipient, signer.public_key(), host_id="other", session_id="session")
# Long-term signing key alone cannot recover a recorded session's data.
with pytest.raises(InvalidTag):
open_envelope(envelope, x25519.X25519PrivateKey.generate(), signer.public_key(), host_id="host", session_id="session")
def test_certificate_identity_and_trust():
ca_key, ca = issue_ca()
device = ed25519.Ed25519PrivateKey.generate()
pem = issue_device(ca_key, ca, "a" * 32, device.public_key()).public_bytes(serialization.Encoding.PEM).decode()
ca_pem = ca.public_bytes(serialization.Encoding.PEM)
verify_device(pem, ca_pem, "a" * 32)
with pytest.raises(ValueError):
verify_device(pem, ca_pem, "b" * 32)
_, other_ca = issue_ca()
with pytest.raises((ValueError, InvalidSignature)):
verify_device(pem, other_ca.public_bytes(serialization.Encoding.PEM), "a" * 32)
@@ -0,0 +1,150 @@
import asyncio
import importlib.util
import json
from pathlib import Path
from types import SimpleNamespace
import httpx
import pytest
from relay.hainuo1065 import Hainuo1065Agent, NativeAPIError, read_native_config
from .conftest import provision
from .test_integration import dispatch
POLICY = {"mode": "text-only", "tools": "disabled", "contract": "hainuo-1065-v1"}
def config(tmp_path, url="http://127.0.0.1:8643"):
path = tmp_path / "native.json"
path.write_text(json.dumps({"url": url, "api_key": "fake-local-key-" * 4, "mode": "text-only"}))
return path
def native_handler(seen, *, policy=POLICY, completion=None):
def handler(request):
seen.append(request)
assert request.headers["Authorization"].startswith("Bearer fake-local-key-")
if request.url.path == "/health":
return httpx.Response(200, json={"status": "ok", "platform": "hermes-agent", "version": "package-fixture"})
if request.url.path == "/v1/capabilities":
return httpx.Response(200, json={"hainuo_relay_policy": policy})
if request.url.path == "/v1/models":
return httpx.Response(200, json={"data": [{"id": "hainuo-relay-text"}]})
assert request.url.path == "/v1/chat/completions"
return httpx.Response(200, json=completion or {"choices": [{"message": {"role": "assistant", "content": "真实API格式结果"}, "finish_reason": "stop"}]})
return handler
async def test_native_api_request_fields_idempotency_and_result(tmp_path):
seen = []
adapter = Hainuo1065Agent(config(tmp_path), transport=httpx.MockTransport(native_handler(seen)))
assert await adapter.execute("只回复联调通过", "ou_a", "turn_1") == "真实API格式结果"
post = seen[-1]
assert json.loads(post.content) == {"model": "hainuo-relay-text", "stream": False,
"messages": [{"role": "user", "content": "只回复联调通过"}]}
assert post.headers["Idempotency-Key"].startswith("hn-")
idem = post.headers["Idempotency-Key"]
await adapter.execute("只回复联调通过", "ou_a", "turn_1")
assert seen[-1].headers["Idempotency-Key"] == idem
await adapter.execute("只回复联调通过", "ou_b", "turn_1")
assert seen[-1].headers["Idempotency-Key"] != idem
await adapter.close()
async def test_refuses_stock_unrestricted_api(tmp_path):
seen = []
adapter = Hainuo1065Agent(config(tmp_path), transport=httpx.MockTransport(native_handler(seen, policy={})))
result = await adapter.execute("anything", "owner", "turn")
assert "policy missing" in result
assert all(request.method != "POST" for request in seen)
await adapter.close()
@pytest.mark.parametrize("completion", [
{"choices": []},
{"choices": [{"message": {"content": "partial"}, "finish_reason": "length"}]},
{"choices": [{"message": {"content": "tool", "tool_calls": [{"id": "x"}]}, "finish_reason": "stop"}]},
])
async def test_incomplete_native_results_fail_closed(tmp_path, completion):
adapter = Hainuo1065Agent(config(tmp_path), transport=httpx.MockTransport(native_handler([], completion=completion)))
assert "未完成请求" in await adapter.execute("anything", "owner", "turn")
await adapter.close()
async def test_native_redirect_no_retry_and_no_error_body_leak(tmp_path):
seen = []
def handler(request):
seen.append(request)
return httpx.Response(302, headers={"Location": "https://outside.invalid/"}, text="fake-confidential-body")
adapter = Hainuo1065Agent(config(tmp_path), transport=httpx.MockTransport(handler))
result = await adapter.execute("anything", "owner", "turn")
assert "fake-confidential" not in result and "HTTP 302" in result
assert len(seen) == 1
await adapter.close()
@pytest.mark.parametrize("url", ["http://example.invalid:8643", "http://localhost:8643", "https://127.0.0.1:8643", "http://127.0.0.1:8643/p/other", "http://user:pass@127.0.0.1:8643"])
def test_native_target_cannot_be_remote_or_profile_switched(tmp_path, url):
with pytest.raises(ValueError):
read_native_config(config(tmp_path, url))
def test_native_launcher_enforces_no_tools_and_endpoint_whitelist():
script = Path(__file__).resolve().parents[1] / "scripts/hainuo_native_api.py"
spec = importlib.util.spec_from_file_location("native_launcher_test", script)
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
class Native:
def _create_agent(self):
return SimpleNamespace(tools=[{"name": "terminal"}], valid_tool_names={"terminal"})
def _http_route_table(self):
return [("GET", "/health", None), ("POST", "/v1/chat/completions", None),
("DELETE", "/api/sessions/x", None), ("POST", "/api/jobs", None)]
tools = SimpleNamespace(_get_platform_tools=lambda config, platform, **kwargs: {"terminal"})
Restricted = module.restricted_adapter_class(Native, tools)
assert tools._get_platform_tools({}, "api_server") == set()
assert tools._get_platform_tools({}, "feishu") == {"terminal"}
assert len(Restricted()._http_route_table()) == 2
assert Restricted()._wire_plugin_handlers(object()) is None
with pytest.raises(RuntimeError, match="refuses an Agent with tools"):
Restricted()._create_agent()
async def test_encrypted_ecs_device_native_http_and_return(env):
"""Real socket chain; native API is a contract fixture, not installed Hermes."""
from fastapi import FastAPI, Request
from .conftest import serve
from relay.device import run_device
app = FastAPI()
seen = []
@app.get("/health")
async def health():
return {"status": "ok", "platform": "hermes-agent", "version": "contract-fixture"}
@app.get("/v1/capabilities")
async def capabilities():
return {"hainuo_relay_policy": POLICY}
@app.get("/v1/models")
async def models():
return {"data": [{"id": "hainuo-relay-text"}]}
@app.post("/v1/chat/completions")
async def chat(request: Request):
seen.append(await request.json())
assert request.headers.get("Idempotency-Key")
return {"choices": [{"message": {"content": "本机API对接成功"}, "finish_reason": "stop"}]}
server, server_task, port = await serve(app)
directory, _ = await provision(env)
cfg = config(env["root"], f"http://127.0.0.1:{port}")
connected = asyncio.Event()
device = asyncio.create_task(run_device(directory, env["router_url"], connected_event=connected, hainuo_config=cfg))
env["tasks"].append(device)
try:
await asyncio.wait_for(connected.wait(), 5)
response = await dispatch(env, "ou_test", "/助手 只回复本机API对接成功", "native-turn")
assert response.json()["result"] == "本机API对接成功"
assert seen[0]["messages"][0]["content"] == "只回复本机API对接成功"
assert (await dispatch(env, "ou_test", "/助手 repeat", "native-turn")).json()["status"] == "duplicate"
assert len(seen) == 1
finally:
server.should_exit = True
await asyncio.wait_for(server_task, 5)
@@ -0,0 +1,38 @@
import hashlib
import io
import json
import tarfile
from scripts.fetch_official_images import export_image, digest_file
def test_offline_docker_archive_preserves_config_and_rootfs(tmp_path):
cache, output = tmp_path / "cache", tmp_path / "out"
cache.mkdir()
output.mkdir()
layer = io.BytesIO()
with tarfile.open(fileobj=layer, mode="w") as tar:
content = b"hello ARM64\n"
info = tarfile.TarInfo("test.txt")
info.size, info.mode = len(content), 0o644
tar.addfile(info, io.BytesIO(content))
raw = layer.getvalue()
raw_digest = hashlib.sha256(raw).hexdigest()
import gzip
compressed = gzip.compress(raw)
blob_digest = hashlib.sha256(compressed).hexdigest()
(cache / (blob_digest + ".blob")).write_bytes(compressed)
config = json.dumps({"architecture": "arm64", "os": "linux", "config": {"Env": []},
"rootfs": {"type": "layers", "diff_ids": ["sha256:" + raw_digest]}}).encode()
config_digest = hashlib.sha256(config).hexdigest()
(cache / (config_digest + ".blob")).write_bytes(config)
record = {"name": "test", "tag": "arm64", "config": {"digest": "sha256:" + config_digest},
"layers": [{"digest": "sha256:" + blob_digest}]}
export_image(record, cache, output)
path = output / record["archive"]
assert record["archive_sha256"] == digest_file(path)
with tarfile.open(path) as tar:
manifest = json.load(tar.extractfile("manifest.json"))[0]
assert manifest["RepoTags"] == ["test:arm64"]
assert tar.extractfile(manifest["Config"]).read() == config
assert tar.extractfile(manifest["Layers"][0]).read() == raw
@@ -0,0 +1,143 @@
import asyncio
import hashlib
import json
import time
import uuid
from relay.crypto import load_private, sign
from .conftest import provision, connect_device
async def dispatch(env, owner, text, turn=None):
return await env["client"].post("/admin/test/dispatch", headers=env["admin"],
json={"open_id": owner, "text": text, "turn_id": turn or uuid.uuid4().hex})
async def test_two_devices_encrypted_isolation_and_dedup(env):
a, ah = await provision(env, "ou_a")
b, bh = await provision(env, "ou_b")
await connect_device(env, a)
await connect_device(env, b)
responses = await asyncio.gather(dispatch(env, "ou_a", "/回显 A的唯一结果"), dispatch(env, "ou_b", "/回显 B的唯一结果"))
assert [x.json()["result"] for x in responses] == ["A的唯一结果", "B的唯一结果"]
first = await dispatch(env, "ou_a", "/回显 once", "same-turn")
again = await dispatch(env, "ou_a", "/回显 twice", "same-turn")
assert first.json()["status"] == "completed"
assert again.json()["status"] == "duplicate"
# Directory compromise cannot silently substitute B's certificate for A.
presence_b = await env["redis"].get("hn:online:" + bh)
await env["redis"].set("hn:online:" + ah, presence_b)
assert (await dispatch(env, "ou_a", "/回显 leaked")).status_code == 409
async def test_offline_revoke_and_persistence(env):
directory, host = await provision(env)
assert (await dispatch(env, "ou_test", "/主机名")).json()["status"] == "offline"
await connect_device(env, directory)
assert (await dispatch(env, "ou_test", "/主机名")).json()["status"] == "completed"
result = await env["client"].post(f"/admin/devices/{host}/revoke", headers=env["admin"])
assert result.status_code == 200
assert (await dispatch(env, "ou_test", "/主机名")).json()["status"] == "unavailable"
await asyncio.sleep(0.05)
assert not await env["redis"].exists("hn:online:" + host)
from relay.store import Store
db = Store(env["settings"].data_dir / "metadata.sqlite")
assert db.device(host)["revoked"] == 1
db.close()
async def test_device_read_boundary(env):
directory, host = await provision(env)
root = env["root"] / "test-files"
root.mkdir()
(root / "allowed.txt").write_text("授权内容", encoding="utf-8")
(env["root"] / "outside.txt").write_text("不该读到", encoding="utf-8")
await connect_device(env, directory, root)
assert (await dispatch(env, "ou_test", "/读取 allowed.txt")).json()["result"] == "授权内容"
assert "拒绝" in (await dispatch(env, "ou_test", "/读取 ../outside.txt")).json()["result"]
assert "只读诊断" in (await dispatch(env, "ou_test", "rm -rf /")).json()["result"]
async def test_binding_requires_device_proof_and_one_time_code(env):
directory, host = await provision(env)
response = await env["client"].post("/device/bind", json={"host_id": host, "proof": {}})
assert response.status_code == 403
response = await env["client"].post("/admin/devices", json={"host_id": host, "cert": "invalid"})
assert response.status_code == 401
async def test_oauth_wrong_secret_does_not_destroy_and_claim_once(env):
client = env["client"]
start = await client.post("/oauth/start?state=attacker", json={})
assert start.status_code == 201
data = start.json()
assert data["state"] != "attacker"
assert data["claim_secret"] not in data["authorization_url"]
cb = await client.get("/oauth/cb", params={"state": data["state"], "code": "fake-code"})
assert cb.status_code == 200
bad = await client.get("/oauth/claim", params={"state": data["state"]}, headers={"X-OAuth-Claim-Secret": "bad"})
assert bad.status_code == 404
good = await client.get("/oauth/claim", params={"state": data["state"]}, headers={"X-OAuth-Claim-Secret": data["claim_secret"]})
assert good.status_code == 200
assert good.json()["expires_in"] == 6900
assert "code" not in good.json()
assert good.headers["cache-control"] == "no-store"
assert (await client.get("/oauth/claim", params={"state": data["state"]}, headers={"X-OAuth-Claim-Secret": data["claim_secret"]})).status_code == 404
assert (await client.get("/oauth/cb?state=unknown&code=x")).status_code == 400
async def test_oauth_concurrent_callbacks_claims_and_refresh(env):
client = env["client"]
data = (await client.post("/oauth/start", json={})).json()
responses = await asyncio.gather(*[client.get("/oauth/cb", params={"state": data["state"], "code": "same"}) for _ in range(2)])
assert sorted(x.status_code for x in responses) == [200, 400]
assert env["platform"].exchanges == 1
responses = await asyncio.gather(*[client.get("/oauth/claim", params={"state": data["state"]}, headers={"X-OAuth-Claim-Secret": data["claim_secret"]}) for _ in range(2)])
assert sorted(x.status_code for x in responses) == [200, 404]
responses = await asyncio.gather(*[client.post("/oauth/refresh", json={"refresh_token": "same-fake-refresh"}) for _ in range(2)])
assert sorted(x.status_code for x in responses) == [200, 409]
assert env["platform"].refreshes == 1
async def test_body_limit_proxy_disabled_and_rate_limit(env):
client = env["client"]
assert (await client.post("/oauth/start", content=b"x" * 300000)).status_code == 413
assert (await client.get("/proxy", headers={"X-Relay-Target": "https://evil.invalid"})).status_code == 404
statuses = [(await client.post("/oauth/start", json={})).status_code for _ in range(21)]
assert statuses[-1] == 429
def event(env, message_id="om_test", text="/回显 平台事件", chat_type="p2p"):
return {"header": {"event_type": "im.message.receive_v1", "app_id": env["settings"].feishu_app_id,
"token": env["settings"].feishu_verification_token},
"event": {"sender": {"sender_type": "user", "sender_id": {"open_id": "ou_test"}},
"message": {"message_id": message_id, "chat_type": chat_type, "message_type": "text",
"content": json.dumps({"text": text}, ensure_ascii=False)}}}
async def test_webhook_signature_event_routing_and_replay(env):
directory, _ = await provision(env)
await connect_device(env, directory)
raw = json.dumps(event(env), ensure_ascii=False).encode()
timestamp, nonce = str(int(time.time())), "nonce"
signature = hashlib.sha256((timestamp + nonce + env["settings"].feishu_encrypt_key).encode() + raw).hexdigest()
headers = {"X-Lark-Request-Timestamp": timestamp, "X-Lark-Request-Nonce": nonce, "X-Lark-Signature": signature}
assert (await env["client"].post("/feishu/event", content=raw)).status_code == 403
for _ in range(2):
assert (await env["client"].post("/feishu/event", content=raw, headers=headers)).status_code == 200
for _ in range(100):
if env["platform"].replies:
break
await asyncio.sleep(0.02)
assert env["platform"].replies == [("om_test", "平台事件")]
# No transcript or credentials persisted in either connector metadata or device journal.
for db in [env["settings"].data_dir / "metadata.sqlite", directory / "journal.sqlite"]:
assert "平台事件".encode() not in db.read_bytes()
async def test_group_events_ignored(env):
result = await env["client"].post("/internal/events", json=event(env, chat_type="group"),
headers={"X-Internal-Secret": env["settings"].internal_secret})
assert result.status_code == 200
await asyncio.sleep(0.05)
assert env["platform"].replies == []
@@ -0,0 +1,36 @@
import httpx
import pytest
from relay.platform import Feishu, PlatformError
async def test_private_platform_domain_and_reply_target(env):
seen = []
def handler(request):
seen.append(request)
if request.url.path.endswith("app_access_token/internal"):
return httpx.Response(200, json={"code": 0, "app_access_token": "fake-app-token", "expire": 7200})
if request.url.path.endswith("tenant_access_token/internal"):
return httpx.Response(200, json={"code": 0, "tenant_access_token": "fake-tenant-token", "expire": 7200})
if request.url.path.endswith("oidc/access_token"):
return httpx.Response(200, json={"code": 0, "data": {"access_token": "fake-user-token",
"refresh_token": "fake-refresh", "expires_in": 6900, "open_id": "ou_test"}})
return httpx.Response(200, json={"code": 0, "data": {}})
env["settings"].feishu_api_base = "https://private.example.invalid"
f = Feishu(env["settings"], transport=httpx.MockTransport(handler))
result = await f.exchange("fake-code")
assert result["expires_in"] == 6900
await f.reply("om_original", "你好")
assert all(x.url.host == "private.example.invalid" for x in seen)
assert seen[-1].url.path == "/open-apis/im/v1/messages/om_original/reply"
assert seen[-1].headers["Authorization"] == "Bearer fake-tenant-token"
assert len([x for x in seen if x.url.path.endswith("app_access_token/internal")]) == 1
await f.close()
async def test_platform_errors_never_echo_credentials(env):
f = Feishu(env["settings"], transport=httpx.MockTransport(
lambda request: httpx.Response(400, text="fake-secret-that-must-not-appear")))
with pytest.raises(PlatformError) as error:
await f.app_token()
assert "fake-secret" not in str(error.value)
await f.close()
@@ -0,0 +1,33 @@
"""Opt-in real PostgreSQL verification in an isolated, newly created schema."""
import os
import uuid
import psycopg
import pytest
from psycopg import sql
from relay.store import Store
@pytest.mark.skipif(not os.environ.get("HN_TEST_DATABASE_URL"), reason="real PostgreSQL URL not supplied")
def test_postgres_metadata_and_duplicate_claim(tmp_path):
url = os.environ["HN_TEST_DATABASE_URL"]
schema = "hn_test_" + uuid.uuid4().hex
conn = psycopg.connect(url, autocommit=True)
conn.execute(sql.SQL("CREATE SCHEMA {}").format(sql.Identifier(schema)))
from psycopg.conninfo import make_conninfo
isolated = make_conninfo(url, options=f"-c search_path={schema}")
store = None
try:
store = Store(tmp_path / "unused.sqlite", isolated)
store.add_device("host", "cert", "fingerprint")
store.bind("host", "owner")
assert store.by_owner("owner")["host_id"] == "host"
assert store.begin_turn("turn", "owner", "host")
assert not store.begin_turn("turn", "owner", "host")
store.audit("owner", "instruction", "host", "completed")
store.revoke("host")
assert not store.by_owner("owner")
finally:
if store:
store.close()
conn.execute(sql.SQL("DROP SCHEMA {} CASCADE").format(sql.Identifier(schema)))
conn.close()
@@ -0,0 +1,44 @@
import asyncio
import json
import secrets
from fastapi import FastAPI
from relay.device import run_device
from .conftest import provision, serve
from .test_hainuo1065 import POLICY, config
from .test_web_session import browser
async def test_h5_cookie_to_encrypted_device_to_native_http_result(env):
"""Real loopback HTTP + WS, with a native model contract fixture."""
app = FastAPI()
@app.get("/health")
async def health():
return {"status": "ok", "platform": "hermes-agent"}
@app.get("/v1/capabilities")
async def capabilities():
return {"hainuo_relay_policy": POLICY}
@app.get("/v1/models")
async def models():
return {"data": [{"id": "hainuo-relay-text"}]}
@app.post("/v1/chat/completions")
async def chat():
return {"choices": [{"message": {"content": "42"}, "finish_reason": "stop"}]}
server, task, port = await serve(app)
directory, host = await provision(env)
cfg = config(env["root"], f"http://127.0.0.1:{port}")
connected = asyncio.Event()
device = asyncio.create_task(run_device(directory, env["router_url"], connected_event=connected, hainuo_config=cfg))
env["tasks"].append(device)
try:
await asyncio.wait_for(connected.wait(), 5)
headers = await browser(env, directory, host)
response = await env["client"].post("/web/chat", headers=headers,
json={"text": "17加25", "request_id": secrets.token_hex(16)})
assert response.status_code == 200
assert response.json()["status"] == "completed"
assert response.json()["result"] == "42"
finally:
server.should_exit = True
await asyncio.wait_for(task, 5)
@@ -0,0 +1,141 @@
import asyncio
import json
import secrets
import time
import httpx
import pytest
from relay.crypto import load_private, sign
from relay.web_session import COOKIE, digest
from .conftest import provision, connect_device
async def issue(env, directory, host):
config = json.loads((directory / "device.json").read_text())
proof = sign({"host_id": host, "owner": config["owner"], "purpose": "h5-pair-v1",
"nonce": secrets.token_hex(16), "ts": int(time.time())}, load_private(directory / "device.key"))
response = await env["client"].post("/device/web-pair", json={"host_id": host, "proof": proof})
assert response.status_code == 200, response.text
return response.json(), proof
async def claim(env, code):
return await env["client"].post("/web/claim", json={"code": code}, headers={"Origin": env["settings"].public_url})
def cookie(response):
return {"Cookie": COOKIE + "=" + response.cookies.get(COOKIE)}
async def browser(env, directory, host):
issued, _ = await issue(env, directory, host)
response = await claim(env, issued["code"])
assert response.status_code == 200, response.text
return {**cookie(response), "Origin": env["settings"].public_url}
async def test_browser_pairing_one_time_signed_and_secure_cookie(env):
directory, host = await provision(env)
issued, proof = await issue(env, directory, host)
assert "signature" in issued
# The anonymous browser can neither name an owner nor invent a device signature.
assert (await env["client"].post("/device/web-pair", json={"host_id": host, "proof": {}})).status_code == 403
assert (await env["client"].post("/device/web-pair", json={"host_id": host, "proof": proof})).status_code == 409
response = await claim(env, issued["code"])
assert response.status_code == 200
header = response.headers["set-cookie"].lower()
assert "secure" in header and "httponly" in header and "samesite=strict" in header
assert "code" not in response.json() and "owner" not in response.json()
assert (await claim(env, issued["code"])).status_code == 404
assert (await env["client"].get("/web/session")).status_code == 401 # Secure cookies never sent over test HTTP.
session = await env["client"].get("/web/session", headers=cookie(response))
assert session.status_code == 200 and session.json()["host_id"] == host
assert session.headers["cache-control"] == "no-store"
async def test_cross_origin_cannot_consume_pair_code_or_send_chat(env):
directory, host = await provision(env)
issued, _ = await issue(env, directory, host)
for origin in [None, "https://evil.invalid", "null", "http://localhost.evil.invalid"]:
headers = {} if origin is None else {"Origin": origin}
result = await env["client"].post("/web/claim", json={"code": issued["code"]}, headers=headers)
assert result.status_code == 403
response = await claim(env, issued["code"])
assert response.status_code == 200
result = await env["client"].post("/web/chat", headers={**cookie(response), "Origin": "https://evil.invalid"},
json={"text": "hello", "request_id": secrets.token_hex(16)})
assert result.status_code == 403
async def test_web_devices_are_isolated_and_chat_deduplicates(env):
a, ah = await provision(env, "ou_a")
b, bh = await provision(env, "ou_b")
await connect_device(env, a)
await connect_device(env, b)
a_headers = await browser(env, a, ah)
b_headers = await browser(env, b, bh)
rid = secrets.token_hex(16)
a_result, b_result = await asyncio.gather(
env["client"].post("/web/chat", headers=a_headers, json={"text": "/回显 A独立回复", "request_id": rid}),
env["client"].post("/web/chat", headers=b_headers, json={"text": "/回显 B独立回复", "request_id": rid}))
assert a_result.json()["result"] == "A独立回复"
assert b_result.json()["result"] == "B独立回复"
again = await env["client"].post("/web/chat", headers=a_headers, json={"text": "/回显 repeat", "request_id": rid})
assert again.json()["status"] == "duplicate"
# Redis contains only pairing/session metadata, never the plaintext chat transcript.
for key in await env["redis"].keys("hn:web*"):
value = await env["redis"].get(key)
assert "独立回复" not in str(value)
async def test_logout_expiry_and_revoke_invalidate_browser(env):
directory, host = await provision(env)
headers = await browser(env, directory, host)
assert (await env["client"].post("/web/logout", headers=headers)).status_code == 200
assert (await env["client"].get("/web/session", headers=headers)).status_code == 401
headers = await browser(env, directory, host)
await env["redis"].delete("hn:web-session:" + digest(headers["Cookie"].split("=", 1)[1]))
assert (await env["client"].get("/web/session", headers=headers)).status_code == 401
headers = await browser(env, directory, host)
await env["client"].post(f"/admin/devices/{host}/revoke", headers=env["admin"])
assert (await env["client"].get("/web/session", headers=headers)).status_code == 401
async def test_binding_generation_invalidates_old_codes_and_sessions(env):
directory, host = await provision(env)
issued, _ = await issue(env, directory, host)
headers = await browser(env, directory, host)
await env["redis"].incr("hn:web-generation:" + host)
assert (await claim(env, issued["code"])).status_code == 401
assert (await env["client"].get("/web/session", headers=headers)).status_code == 401
async def test_pair_code_expiry_and_anonymous_chat_denied(env):
directory, host = await provision(env)
issued, _ = await issue(env, directory, host)
await env["redis"].delete("hn:web-code:" + digest(issued["code"]))
assert (await claim(env, issued["code"])).status_code == 404
assert (await env["client"].post("/web/chat", headers={"Origin": env["settings"].public_url},
json={"text": "hello", "request_id": secrets.token_hex(16)})).status_code == 401
async def test_unprefixed_question_uses_native_agent_prefix(env):
directory, host = await provision(env)
headers = await browser(env, directory, host)
seen = []
async def capture(owner, text, turn):
seen.append((owner, text))
return {"status": "completed", "result": "42", "turn_id": turn}
env["connector"].state.broker.dispatch = capture
response = await env["client"].post("/web/chat", headers=headers,
json={"text": "17加25", "request_id": secrets.token_hex(16), "open_id": "attacker"})
assert response.json()["result"] == "42"
assert seen == [("ou_test", "/助手 17加25")]
async def test_concurrent_claim_exactly_one_browser(env):
directory, host = await provision(env)
issued, _ = await issue(env, directory, host)
results = await asyncio.gather(claim(env, issued["code"]), claim(env, issued["code"]))
assert sorted(x.status_code for x in results) == [200, 404]