The codex-daochi-client-mesh-client-rename integration, committed as that task staged it: mesh_client replaces daochi_client, account storage and tests move to the Mesh names, and docs, locales and CI follow, with existing accounts, encrypted records and local storage kept compatible. The task stopped before its dependency versions were pushed; the next commit moves Breeze to the pushed pins it needs. Co-Authored-By: Claude Opus 5.5 <[email protected]>
204 lines
8.9 KiB
Python
204 lines
8.9 KiB
Python
#!/usr/bin/env python3
|
|
"""Exercise Inbe's Ziran Mesh adapter through a disposable HTTP server."""
|
|
|
|
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
|
from pathlib import Path
|
|
import hashlib
|
|
import json
|
|
import os
|
|
import re
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import threading
|
|
|
|
|
|
ROOT = Path(__file__).resolve().parent.parent
|
|
COMPILER = Path(sys.argv[1]) if len(sys.argv) > 1 else ROOT / "build/packages/ziran/build/bin/zi2c"
|
|
MESH_CLIENT = Path(os.environ.get("MESH_CLIENT_DIR", ROOT / "build/packages/mesh-client"))
|
|
USER_ID = "a" * 64
|
|
NONCE = "c" * 64
|
|
|
|
|
|
|
|
def GeneratedSource(generated, name):
|
|
"""A generated C file; package modules carry their package's prefix."""
|
|
path = generated / name
|
|
if path.exists():
|
|
return path
|
|
prefixed = sorted(path.parent.glob("p" + "[0-9a-f]" * 16 + "_" + path.name))
|
|
return prefixed[0] if len(prefixed) == 1 else path
|
|
|
|
|
|
def ResolveGeneratedAuthSessionType(header_text):
|
|
"""Resolve the common Session pointer in the generated account API."""
|
|
signatures = {
|
|
"LoginAccount": r"String base_url, AccountKeys\* account, String client_id, {session}\* session",
|
|
"RequestAccount": r"String base_url, AccountKeys\* account, String client_id, {session}\* session, int64_t now, String method, String path, String body, Slice output, int32_t\* status",
|
|
"SyncAccountPayload": r"String base_url, AccountKeys\* account, String client_id, {session}\* session, Device device, int64_t now, String body, Slice output, int32_t\* status",
|
|
}
|
|
types = set()
|
|
for name, parameters in signatures.items():
|
|
declarations = re.findall(r"\b" + name + r"\s*\([^;{}]*\)\s*;", header_text)
|
|
pattern = r"AuthResult\s+" + name + r"\s*\(\s*" + parameters.format(
|
|
session=r"(?P<session>[A-Za-z_]\w*)"
|
|
) + r"\s*\)\s*;"
|
|
matches = list(re.finditer(pattern, header_text))
|
|
if len(declarations) != 1 or len(matches) != 1:
|
|
raise ValueError(f"generated auth contract: missing, ambiguous or malformed {name} declaration")
|
|
types.add(matches[0].group("session"))
|
|
if len(types) != 1:
|
|
raise ValueError("generated auth contract: account functions use different Session types")
|
|
session_type = types.pop()
|
|
typedef = rf"\btypedef\s+struct\s+{re.escape(session_type)}\s+{re.escape(session_type)}\s*;"
|
|
if len(re.findall(typedef, header_text)) != 1:
|
|
raise ValueError(f"generated auth contract: missing or ambiguous typedef for {session_type}")
|
|
return session_type
|
|
|
|
|
|
class Handler(BaseHTTPRequestHandler):
|
|
friends_requests = 0
|
|
registrations = 0
|
|
syncs = 0
|
|
|
|
def log_message(self, *_args):
|
|
pass
|
|
|
|
def respond(self, status, body):
|
|
self.send_response(status)
|
|
self.send_header("Content-Type", "application/json")
|
|
self.send_header("Content-Length", str(len(body)))
|
|
self.end_headers()
|
|
self.wfile.write(body)
|
|
|
|
def do_GET(self):
|
|
if self.path == f"/api/v1/sync/challenge?user_id={USER_ID}":
|
|
self.respond(200, json.dumps({"nonce": NONCE}).encode())
|
|
return
|
|
if self.path == "/api/v1/friends":
|
|
assert self.headers.get("Authorization") == "Bearer token-from-server"
|
|
assert self.headers.get("X-Daochi-User") == USER_ID
|
|
assert self.headers.get("X-Daochi-Client") == "client-1"
|
|
type(self).friends_requests += 1
|
|
if type(self).friends_requests == 1:
|
|
self.respond(401, b"{}")
|
|
else:
|
|
self.respond(200, b'{"friends":[]}')
|
|
return
|
|
self.respond(404, b"{}")
|
|
|
|
def do_POST(self):
|
|
body = self.rfile.read(int(self.headers.get("Content-Length", "0")))
|
|
if self.path == "/api/v1/account/devices":
|
|
data = json.loads(body)
|
|
assert self.headers.get("Authorization") == "Bearer token-from-server"
|
|
assert data["app_id"] == "inbe"
|
|
assert data["device_key_id"] == "b" * 64
|
|
assert data["public_key"] == "b" * 64
|
|
assert data["nonce"] == "01" * 32
|
|
assert data["expires_at"] == 1700000301
|
|
assert data["signature"] == "bb" * 2420
|
|
type(self).registrations += 1
|
|
self.respond(200, b"{}")
|
|
return
|
|
if self.path == "/api/v1/sync":
|
|
envelope = json.loads(self.headers["X-Daochi-Tx"])
|
|
assert self.headers.get("Authorization") == "Bearer token-from-server"
|
|
assert envelope["protocol_version"] == 6
|
|
assert envelope["app_id"] == "inbe"
|
|
assert envelope["device_key_id"] == "b" * 64
|
|
assert envelope["tx_id"] == "02" * 32
|
|
assert envelope["nonce"] == "03" * 32
|
|
assert envelope["expires_at"] == 1700000301
|
|
assert envelope["body_sha256"] == hashlib.sha256(body).hexdigest()
|
|
assert envelope["signature"] == "bb" * 2420
|
|
assert envelope["device_signature"] == "d" * 128
|
|
assert body == b'{"protocol_version":6}'
|
|
type(self).syncs += 1
|
|
self.respond(200, b'{"server_version":7}')
|
|
return
|
|
try:
|
|
data = json.loads(body)
|
|
signature = bytes.fromhex(self.headers.get("X-Daochi-Signature", ""))
|
|
except ValueError:
|
|
data = {}
|
|
signature = b""
|
|
valid = (self.path == "/api/v1/sync/login" and
|
|
self.headers.get("X-Daochi-User") == USER_ID and
|
|
self.headers.get("Content-Type") == "application/json" and
|
|
data.get("user_id_hash") == USER_ID and
|
|
data.get("public_key") == "pub" and
|
|
len(signature) == 2420 and
|
|
signature[:64] == hashlib.sha256(body).hexdigest().encode() and
|
|
signature[64:128] == NONCE.encode() and
|
|
signature[128:] == b"\xbb" * (2420 - 128))
|
|
if not valid:
|
|
self.respond(400, b"{}")
|
|
elif data.get("client_id") == "bad-client":
|
|
self.respond(401, b"{}")
|
|
elif data.get("client_id") == "client-1":
|
|
self.respond(200, json.dumps({
|
|
"auth_token": "token-from-server",
|
|
"expires_in_seconds": 1800,
|
|
"server_time": 1700000000,
|
|
}).encode())
|
|
else:
|
|
self.respond(400, b"{}")
|
|
|
|
|
|
(ROOT / "build/tests").mkdir(parents=True, exist_ok=True)
|
|
with tempfile.TemporaryDirectory(prefix="mesh-native-", dir=ROOT / "build/tests") as temporary:
|
|
generated = Path(temporary) / "generated"
|
|
executable = Path(temporary) / "client"
|
|
subprocess.run([
|
|
str(COMPILER), "--no-main", "--root", str(ROOT / "src"),
|
|
"--module-path", str(ROOT / "build/packages/ziran/std"),
|
|
"--module-path", str(MESH_CLIENT),
|
|
"--module-path", str(ROOT / "build/packages/kryon/src/ui"),
|
|
*subprocess.check_output(["sh", str(ROOT / "scripts/package-paths.sh"), str(ROOT / "build/packages")], text=True).split(),
|
|
"--module-path", str(ROOT / "build/packages/kryon/src/backend"),
|
|
"--module-path", str(ROOT / "build/packages/css/src"),
|
|
"--module-path", str(ROOT / "build/packages/game2d/src"),
|
|
"-o", str(generated), str(ROOT / "src/storage/mesh_native.zi"),
|
|
], check=True)
|
|
session_type = ResolveGeneratedAuthSessionType(
|
|
(generated / "storage/mesh_native.h").read_text()
|
|
+ "\n" + GeneratedSource(generated, "auth.h").read_text()
|
|
)
|
|
# Only the account path is linked; unused storage code is dropped.
|
|
sources = [
|
|
"storage/mesh_native.c", "mesh_account.c", "delegate_store.c",
|
|
"client.c", "auth.c", "url.c", "wire.c",
|
|
"sync.c", "transaction.c", "keys.c", "crypto.c", "sha256.c", "Oqs.c",
|
|
"net_http.c", "net_http_curl_linux.c", "json_scan.c", "json_bytes.c", "text.c", "text_buffer.c",
|
|
"byte_text_linux.c", "c_string.c",
|
|
]
|
|
subprocess.run([
|
|
os.environ.get("CC", "cc"), "-std=c11", "-O0", "-Wall", "-Wextra",
|
|
"-Werror", "-Wno-unused-function", "-Wno-unused-variable",
|
|
"-ffunction-sections", "-fdata-sections", "-Wl,--gc-sections",
|
|
f"-DMESH_FIXTURE_SESSION_TYPE={session_type}",
|
|
f"-I{ROOT / 'build/packages/ziran/include'}", f"-I{generated}",
|
|
f"-I{generated / 'storage'}",
|
|
str(ROOT / "tests/mesh_native_zi_test.c"),
|
|
*(str(GeneratedSource(generated, source)) for source in sources),
|
|
"-l:libcurl.so.4", "-lz", "-o", str(executable),
|
|
], check=True)
|
|
server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
|
|
thread = threading.Thread(target=server.serve_forever, daemon=True)
|
|
thread.start()
|
|
try:
|
|
environment = os.environ.copy()
|
|
environment.pop("DISPLAY", None)
|
|
environment.pop("WAYLAND_DISPLAY", None)
|
|
subprocess.run([
|
|
str(executable), f"127.0.0.1:{server.server_port}"
|
|
], check=True, env=environment)
|
|
assert Handler.friends_requests == 2
|
|
assert Handler.registrations == 1
|
|
assert Handler.syncs == 1
|
|
finally:
|
|
server.shutdown()
|
|
server.server_close()
|
|
thread.join()
|