octoturgeandClaude Opus 5
43242c0410
The `hello` frame carried a `token` field holding the edge JWT. It is gone: the token now travels in an `Authorization: Bearer` header on the WebSocket upgrade request. A token in the first frame means the backend has already accepted a socket, allocated state for it and run its JSON through this schema and a switch statement for a peer that has proved nothing. Every message type refused to act without a verified farm, so nothing could be done with such a connection - but "it cannot do anything" is a weaker guarantee than "it does not exist", and it needed a timeout to stop anyone holding sockets open for free. Verified at the handshake, an unauthenticated peer gets an HTTP 401 and no socket at all. The alternative of a `?token=` query parameter was rejected outright: a bearer credential in a URL lands in access logs, proxy logs and error breadcrumbs, which is exactly what continuum-proxy's hand-written `Debug` for `PrinterCommand` exists to avoid for presigned URLs. `Authorization` is the header every log tool already knows to redact. `farm_id` stays on the message even though the token carries the same claim. It is checked against the token rather than trusted, so sending it is how a misconfigured gateway gets caught instead of silently working against the wrong farm. A browser cannot set headers on a WebSocket, so a future user-facing socket cannot copy this exactly; its equivalent is the subprotocol field, `new WebSocket(url, ["bearer", token])`, which is also verified at the upgrade. Breaking change to the edge protocol, which is free right now: nothing is deployed. `npm run typecheck` and `npm run build` clean. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
continuum-schemas
Single source of truth for the Continuum data model. Everything here is JSON Schema, compiled into two consumer packages:
packages/ts-types- hand-written TypeBox schemas undersrc/schemas/used for runtime validation incontinuum-backend's ElysiaJS routes.packages/rust-types- a Rust crate (continuum-rust-types) with hand-written,serde-derived structs forcontinuum-proxyandcontinuum-ai-worker.
Layout
schemas/continuum/v1/ Continuum's own model
ai/ continuum-backend <-> continuum-ai-worker: the
stream:camera_frames work queue and the
channel:print_alerts notification channel
edge/ continuum-backend <-> continuum-proxy: the
/ws/edge/v1 gateway uplink protocol
material/ printer/ domain objects
vendor.schema.json
schemas/bambulab/ Bambu Lab MQTT wire schemas (v1/v2, report + request)
packages/ts-types/ TypeBox schemas (hand-written, mirrors schemas/)
packages/rust-types/ serde structs (hand-written, mirrors schemas/)
The two inter-service protocols - edge/ and ai/ - are here for a
specific reason: each has two independent implementations, one per repo, and
when there was nothing written down between them they drifted completely
while every test passed. /ws/edge/v1 had an auth handshake the gateway
never sent; stream:camera_frames had a producer writing printerId and a
consumer reading printer_id, so every frame was attributed to a printer
called "unknown". Neither failure was visible from either side alone, which
is what a canonical schema plus a contract test on each end is for.
schemas/continuum/v1/*.schema.json is the canonical shape for each
domain object; packages/ts-types/src/schemas/ and
packages/rust-types/src/lib.rs both mirror it by hand. A mirror is added
per schema only once something actually consumes it, so not every file here
has one, and the two inter-service protocols keep their Rust mirror in the
single repo that consumes it rather than in packages/rust-types:
edge/ in continuum-proxy/src/uplink/protocol.rs, ai/ in
continuum-ai-worker/src/task.rs. The set is small and changes slowly,
which is why keeping hand-synced copies in sync is less overhead than a
codegen pipeline (protoc/ts-proto/prost-build) nothing actually
consumed - see git history for the
protobuf version this replaced, and why it was dropped: every service in
this system talks JSON (JSON Schema for the wire, TypeBox/serde for
runtime validation), so protobuf's actual value - a single schema compiled
into a compact binary wire format for both languages - never applied.
Whenever a domain schema changes, update all three by hand: the JSON Schema file, the TypeBox schema, and the Rust struct.
Build / verify
Requires npm install at the repo root, and a Rust toolchain, first.
npm install
npm run build:rust # cargo build, confirms the Rust structs compile
npm run typecheck # tsc -b, confirms the TypeBox schemas compile
There's no build:ts step - the TS side is hand-written, not generated.