From 28f4eb2a4cad913ba129ff9f6d8092be68815d06 Mon Sep 17 00:00:00 2001 From: deymosh <232244450+deymosh@users.noreply.github.com> Date: Tue, 17 Nov 2026 19:53:19 +0100 Subject: [PATCH 1/6] feat(protocol): the browser's stream and its signed frames The bridge's web page is going to drive sessions, which means running commands on the machine, so a browser's commands must carry more than a bearer cookie. protocol::web is the spec for its stream: JSON arrays over one WebSocket (CHALLENGE, HELLO, READY/CLOSED, CMD/OK, MSG, PAGE/REPLY), every browser frame signed by a WebCrypto ECDSA P-256 key of the browser's own over the machine, the browser id, the connection's challenge, the seq and the body exactly as sent. BrowserKey reads the raw uncompressed point the page exports (refusing one off the curve), derives the browser's public id from its SHA-256, and verifies WebCrypto's r||s signatures with RustCrypto's p256 (pure Rust). A test vector made by WebCrypto proves the bridge reads what a browser writes. The decoder is total: the corpus gains webFrames, and the totality properties run the new decoder and key parser. Co-Authored-By: Claude Code --- Cargo.lock | 167 +++++++++++ crates/protocol/Cargo.toml | 4 + crates/protocol/fixtures/corpus.json | 29 ++ crates/protocol/src/lib.rs | 1 + crates/protocol/src/web.rs | 321 +++++++++++++++++++++ crates/protocol/tests/codec_conformance.rs | 16 + crates/protocol/tests/totality_props.rs | 9 +- 7 files changed, 545 insertions(+), 2 deletions(-) create mode 100644 crates/protocol/src/web.rs diff --git a/Cargo.lock b/Cargo.lock index f029a0eb..6c05f615 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -252,6 +252,12 @@ dependencies = [ "windows-link", ] +[[package]] +name = "base16ct" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf" + [[package]] name = "base64" version = "0.22.1" @@ -692,6 +698,12 @@ version = "1.0.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570" +[[package]] +name = "const-oid" +version = "0.9.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8" + [[package]] name = "core_detect" version = "1.0.0" @@ -716,6 +728,18 @@ dependencies = [ "libc", ] +[[package]] +name = "crypto-bigint" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76" +dependencies = [ + "generic-array", + "rand_core 0.6.4", + "subtle", + "zeroize", +] + [[package]] name = "crypto-common" version = "0.1.7" @@ -773,6 +797,16 @@ dependencies = [ "thiserror 2.0.20", ] +[[package]] +name = "der" +version = "0.7.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb" +dependencies = [ + "const-oid", + "zeroize", +] + [[package]] name = "deranged" version = "0.5.8" @@ -786,6 +820,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" dependencies = [ "block-buffer", + "const-oid", "crypto-common", "subtle", ] @@ -807,12 +842,45 @@ version = "1.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "75b325c5dbd37f80359721ad39aca5a29fb04c89279657cffdda8736d0c0b9d2" +[[package]] +name = "ecdsa" +version = "0.16.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca" +dependencies = [ + "der", + "digest", + "elliptic-curve", + "rfc6979", + "signature", + "spki", +] + [[package]] name = "either" version = "1.18.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "252afb9ae5eaa683babdc6a068b3f5726eb19e05070c731f9b2a23a7c3e8ed34" +[[package]] +name = "elliptic-curve" +version = "0.13.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47" +dependencies = [ + "base16ct", + "crypto-bigint", + "digest", + "ff", + "generic-array", + "group", + "pkcs8", + "rand_core 0.6.4", + "sec1", + "subtle", + "zeroize", +] + [[package]] name = "env_filter" version = "0.1.4" @@ -880,6 +948,16 @@ version = "2.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223" +[[package]] +name = "ff" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0b50bfb653653f9ca9095b427bed08ab8d75a137839d9ad64eb11810d5b6393" +dependencies = [ + "rand_core 0.6.4", + "subtle", +] + [[package]] name = "filedescriptor" version = "0.8.3" @@ -981,6 +1059,7 @@ checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" dependencies = [ "typenum", "version_check", + "zeroize", ] [[package]] @@ -1043,6 +1122,17 @@ dependencies = [ "scroll", ] +[[package]] +name = "group" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63" +dependencies = [ + "ff", + "rand_core 0.6.4", + "subtle", +] + [[package]] name = "hashbrown" version = "0.15.5" @@ -1607,6 +1697,18 @@ version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381" +[[package]] +name = "p256" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c9863ad85fa8f4460f9c48cb909d38a0d689dba1f6f6988a5e3e0d31071bcd4b" +dependencies = [ + "ecdsa", + "elliptic-curve", + "primeorder", + "sha2", +] + [[package]] name = "password-hash" version = "0.5.0" @@ -1640,6 +1742,16 @@ version = "0.2.17" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" +[[package]] +name = "pkcs8" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7" +dependencies = [ + "der", + "spki", +] + [[package]] name = "pkg-config" version = "0.3.34" @@ -1735,6 +1847,15 @@ dependencies = [ "zerocopy", ] +[[package]] +name = "primeorder" +version = "0.13.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "353e1ca18966c16d9deb1c69278edbc5f194139612772bd9537af60ac231e1e6" +dependencies = [ + "elliptic-curve", +] + [[package]] name = "proc-macro-crate" version = "3.5.0" @@ -1781,9 +1902,11 @@ dependencies = [ "hex", "miniz_oxide", "nostr", + "p256", "proptest", "serde", "serde_json", + "sha2", "specta", "specta-typescript", "thiserror 1.0.69", @@ -2016,6 +2139,16 @@ dependencies = [ "webpki-roots 1.0.9", ] +[[package]] +name = "rfc6979" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2" +dependencies = [ + "hmac", + "subtle", +] + [[package]] name = "ring" version = "0.17.14" @@ -2178,6 +2311,20 @@ dependencies = [ "sha2", ] +[[package]] +name = "sec1" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc" +dependencies = [ + "base16ct", + "der", + "generic-array", + "pkcs8", + "subtle", + "zeroize", +] + [[package]] name = "secp256k1" version = "0.29.1" @@ -2337,6 +2484,16 @@ dependencies = [ "libc", ] +[[package]] +name = "signature" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de" +dependencies = [ + "digest", + "rand_core 0.6.4", +] + [[package]] name = "siphasher" version = "1.0.4" @@ -2413,6 +2570,16 @@ dependencies = [ "specta", ] +[[package]] +name = "spki" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d" +dependencies = [ + "base64ct", + "der", +] + [[package]] name = "stable_deref_trait" version = "1.2.1" diff --git a/crates/protocol/Cargo.toml b/crates/protocol/Cargo.toml index 63a2c2cf..f1f8d116 100644 --- a/crates/protocol/Cargo.toml +++ b/crates/protocol/Cargo.toml @@ -21,6 +21,10 @@ serde_json = "1" # Packing a message before it is encrypted (`packing.rs`): raw deflate, # pure Rust, and the base64 the rest of the workspace already uses. miniz_oxide = { version = "0.8", features = ["with-alloc"] } +# The web page's browser key (`web.rs`): WebCrypto's ECDSA P-256 over +# SHA-256, verified in pure Rust (RustCrypto), nothing to cross-compile. +p256 = { version = "0.13", default-features = false, features = ["ecdsa", "std"] } +sha2 = "0.10" base64 = "0.22" # The agent host's TypeScript types are generated FROM these types (the # driver protocol reuses them; see agent-protocol's gen_ts_bindings test), diff --git a/crates/protocol/fixtures/corpus.json b/crates/protocol/fixtures/corpus.json index 18ff848e..e5a6b055 100644 --- a/crates/protocol/fixtures/corpus.json +++ b/crates/protocol/fixtures/corpus.json @@ -283,6 +283,35 @@ ["OK", "aa", true] ] }, + "webFrames": { + "valid": [ + ["CHALLENGE", "q3Jv8c1Ew7Xh2mY0aZ5tUe9kQnB4sLfD6pR1oG8iVxM"], + ["HELLO", "w_qyb5iAhcG-HSkLYHw3VlPFGm-W3hwPwMyJ0kKbvItoSB6Ml-lqPy5PkVOWj4QCZnYi8IbgUTBwim6pcXFklQ"], + ["READY"], + ["CLOSED", "expired"], + ["CMD", 1, "{\"v\":12,\"type\":\"input\",\"sessionId\":\"s\",\"text\":\"hi\",\"inputId\":\"i1\"}", "w_qyb5iAhcG-HSkLYHw3VlPFGm-W3hwPwMyJ0kKbvItoSB6Ml-lqPy5PkVOWj4QCZnYi8IbgUTBwim6pcXFklQ"], + ["OK", 1, false, "not from a browser"], + ["MSG", { "v": 12, "type": "input-ack", "sessionId": "s", "inputId": "i1" }], + ["PAGE", 2, "{\"type\":\"config\"}", "w_qyb5iAhcG-HSkLYHw3VlPFGm-W3hwPwMyJ0kKbvItoSB6Ml-lqPy5PkVOWj4QCZnYi8IbgUTBwim6pcXFklQ"], + ["REPLY", 2, { "fields": [] }] + ], + "rejected": [ + "not json", + {}, + [], + ["EVENT", {}], + ["HELLO"], + ["HELLO", 1], + ["CMD", 1, { "v": 12, "type": "input" }, "s"], + ["CMD", -1, "{}", "s"], + ["CMD", 9007199254740992, "{}", "s"], + ["CMD", 1, "{}"], + ["OK", 1, "yes", ""], + ["MSG", "{}"], + ["REPLY", 2], + ["READY", 1] + ] + }, "forwardCompatible": [ { "dir": "b2p", "msg": { "v": 12, "type": "agent-style", "agent": "x", "style": { "userMessage": { "shape": "card", "corner": 3 }, "futureKnob": 1 } } }, { "dir": "p2b", "msg": { "v": 12, "type": "input", "sessionId": "s", "text": "hi", "unknownFutureField": 1 } }, diff --git a/crates/protocol/src/lib.rs b/crates/protocol/src/lib.rs index 74cacf32..1a7d715a 100644 --- a/crates/protocol/src/lib.rs +++ b/crates/protocol/src/lib.rs @@ -28,6 +28,7 @@ pub mod ranges; pub mod recipients; pub mod relays; pub mod tristate; +pub mod web; pub use codec::{ decode_bridge_to_phone, decode_phone_to_bridge, encode_bridge_to_phone, encode_phone_to_bridge, diff --git a/crates/protocol/src/web.rs b/crates/protocol/src/web.rs new file mode 100644 index 00000000..a107560c --- /dev/null +++ b/crates/protocol/src/web.rs @@ -0,0 +1,321 @@ +//! The browser's stream: how the bridge's web page drives sessions. +//! +//! The page is served only on the direct link's `wss://` listener, so a +//! browser reaches the bridge over TLS and never through a relay. It needs +//! no Nostr event and no NIP-44: it sends the protocol's own messages +//! ([`crate::commands::PhoneToBridge`] up, [`crate::events::BridgeToPhone`] +//! down) as JSON over one WebSocket. What TLS does not give is who sent a +//! command — the page's cookie is a bearer token — so every frame the +//! browser sends is signed by a key of its own: a WebCrypto ECDSA P-256 key +//! whose private half the page can use but never read, bound to the browser +//! when a paired phone approved its sign-in. +//! +//! Each frame is one WebSocket text message, a JSON array: +//! +//! ```text +//! bridge → browser ["CHALLENGE", ] on connect +//! browser → bridge ["HELLO", ] signs seq 0, empty body +//! bridge → browser ["READY"] | ["CLOSED", ] +//! browser → bridge ["CMD", , , ] body: a PhoneToBridge, as JSON text +//! bridge → browser ["OK", , , ] +//! bridge → browser ["MSG", ] a BridgeToPhone, as a JSON object +//! browser → bridge ["PAGE", , , ] a page request, as JSON text +//! bridge → browser ["REPLY", , ] its answer, a JSON value +//! ``` +//! +//! A signature is over [`signed_input`]: the machine, the browser, the +//! connection's challenge, the frame's `seq` and its body exactly as sent — +//! so neither side canonicalizes JSON, and a signature is good once, on one +//! connection to one bridge. `seq` grows on every signed frame of a +//! connection; several tabs are several connections, each with its own +//! challenge. + +use base64::Engine as _; +use p256::ecdsa::signature::Verifier as _; +use p256::ecdsa::{Signature, VerifyingKey}; +use serde_json::{json, Value}; +use sha2::{Digest, Sha256}; + +/// What every signed input starts with, so a signature made for this stream +/// can be nothing else. +pub const SIGNING_CONTEXT: &str = "codedeck-web-v1"; +/// A public key on the wire: the raw uncompressed P-256 point. +pub const PUBLIC_KEY_LEN: usize = 65; +/// A signature on the wire: WebCrypto's `r‖s`. +pub const SIGNATURE_LEN: usize = 64; +/// The largest `seq`: a JavaScript number holds integers exactly up to it. +pub const MAX_SEQ: u64 = (1 << 53) - 1; +/// How many hex characters of the key's SHA-256 are a browser's public id. +pub const BROWSER_ID_LEN: usize = 16; + +/// One frame on the browser's stream. +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum WebFrame { + Challenge(String), + Hello { sig: String }, + Ready, + Closed(String), + /// `body`: the JSON text of one `PhoneToBridge`, exactly as signed. + Cmd { seq: u64, body: String, sig: String }, + Ok { seq: u64, accepted: bool, message: String }, + /// `message`: the JSON text of one `BridgeToPhone`, sent as an object. + /// Decoding re-serializes it, so its keys come back sorted: only a + /// browser reads these, and it reads them as JSON, not as text. + Msg(String), + /// `body`: the JSON text of a page request, exactly as signed. + Page { seq: u64, body: String, sig: String }, + /// `reply`: the JSON text of the answer, sent as a value. + Reply { seq: u64, reply: String }, +} + +#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)] +#[error("bad web frame: {0}")] +pub struct WebDecodeError(pub String); + +/// Why the bridge closed a stream: the `reason` of `["CLOSED", reason]`. +pub mod closed { + /// The `HELLO` or a later frame did not verify, or its `seq` did not grow. + pub const BAD_SIGNATURE: &str = "bad-signature"; + /// The browser's sign-in lapsed (30 days, or 7 idle). + pub const EXPIRED: &str = "expired"; + /// It was signed out, or revoked by a phone or another browser. + pub const SIGNED_OUT: &str = "signed-out"; + /// It fell behind on what the bridge sends, or too many streams are open. + pub const BUSY: &str = "busy"; + /// A frame that is not one the browser may send. + pub const BAD_FRAME: &str = "bad-frame"; +} + +pub fn encode_web_frame(frame: &WebFrame) -> String { + match frame { + WebFrame::Challenge(c) => json!(["CHALLENGE", c]).to_string(), + WebFrame::Hello { sig } => json!(["HELLO", sig]).to_string(), + WebFrame::Ready => json!(["READY"]).to_string(), + WebFrame::Closed(reason) => json!(["CLOSED", reason]).to_string(), + WebFrame::Cmd { seq, body, sig } => json!(["CMD", seq, body, sig]).to_string(), + WebFrame::Ok { seq, accepted, message } => json!(["OK", seq, accepted, message]).to_string(), + // The message is already JSON: it goes in as it is, not re-parsed. + WebFrame::Msg(message) => format!("[\"MSG\",{message}]"), + WebFrame::Page { seq, body, sig } => json!(["PAGE", seq, body, sig]).to_string(), + WebFrame::Reply { seq, reply } => format!("[\"REPLY\",{seq},{reply}]"), + } +} + +/// Decode one frame. Total: anything malformed is an error, never a panic. +pub fn decode_web_frame(text: &str) -> Result { + let bad = |why: &str| WebDecodeError(why.to_string()); + let value: Value = serde_json::from_str(text).map_err(|e| bad(&e.to_string()))?; + let items = value.as_array().ok_or_else(|| bad("not an array"))?; + let label = items.first().and_then(Value::as_str).ok_or_else(|| bad("no label"))?; + let string = |i: usize, what: &str| items.get(i).and_then(Value::as_str).map(str::to_string).ok_or_else(|| bad(what)); + let seq = || items.get(1).and_then(Value::as_u64).filter(|s| *s <= MAX_SEQ).ok_or_else(|| bad("bad seq")); + let arity = |n: usize| if items.len() == n { Ok(()) } else { Err(bad("wrong length")) }; + match label { + "CHALLENGE" => { + arity(2)?; + Ok(WebFrame::Challenge(string(1, "bad challenge")?)) + } + "HELLO" => { + arity(2)?; + Ok(WebFrame::Hello { sig: string(1, "bad signature")? }) + } + "READY" => { + arity(1)?; + Ok(WebFrame::Ready) + } + "CLOSED" => { + arity(2)?; + Ok(WebFrame::Closed(string(1, "bad reason")?)) + } + "CMD" => { + arity(4)?; + Ok(WebFrame::Cmd { seq: seq()?, body: string(2, "bad body")?, sig: string(3, "bad signature")? }) + } + "OK" => { + arity(4)?; + Ok(WebFrame::Ok { + seq: seq()?, + accepted: items.get(2).and_then(Value::as_bool).ok_or_else(|| bad("bad accepted"))?, + message: string(3, "bad message")?, + }) + } + "MSG" => { + arity(2)?; + let message = items.get(1).filter(|m| m.is_object()).ok_or_else(|| bad("bad message"))?; + Ok(WebFrame::Msg(message.to_string())) + } + "PAGE" => { + arity(4)?; + Ok(WebFrame::Page { seq: seq()?, body: string(2, "bad body")?, sig: string(3, "bad signature")? }) + } + "REPLY" => { + arity(3)?; + let reply = items.get(2).ok_or_else(|| bad("no reply"))?; + Ok(WebFrame::Reply { seq: seq()?, reply: reply.to_string() }) + } + _ => Err(bad("unknown label")), + } +} + +/// A browser's public key, checked: base64url of the raw uncompressed point, +/// and a point on the curve. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct BrowserKey { + raw: Vec, + key: VerifyingKey, +} + +impl BrowserKey { + /// Read a key as the page sends it; `None` for anything that is not an + /// uncompressed P-256 point on the curve. + pub fn parse(base64url: &str) -> Option { + let raw = base64::engine::general_purpose::URL_SAFE_NO_PAD.decode(base64url.trim_end_matches('=')).ok()?; + if raw.len() != PUBLIC_KEY_LEN || raw[0] != 0x04 { + return None; + } + let key = VerifyingKey::from_sec1_bytes(&raw).ok()?; + Some(Self { raw, key }) + } + + /// The key as the page sent it: base64url, no padding. + pub fn to_base64url(&self) -> String { + base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(&self.raw) + } + + /// The browser's public id: the first [`BROWSER_ID_LEN`] hex characters + /// of the SHA-256 of the raw key. What `web-browsers` lists and + /// `web-browser-sign-out` names; it proves nothing by itself. + pub fn id(&self) -> String { + let mut id = hex::encode(Sha256::digest(&self.raw)); + id.truncate(BROWSER_ID_LEN); + id + } + + /// Whether `sig` (base64url `r‖s`) is this key's signature over `input`. + pub fn verifies(&self, input: &[u8], sig: &str) -> bool { + let Ok(bytes) = base64::engine::general_purpose::URL_SAFE_NO_PAD.decode(sig.trim_end_matches('=')) else { return false }; + if bytes.len() != SIGNATURE_LEN { + return false; + } + let Ok(signature) = Signature::from_slice(&bytes) else { return false }; + self.key.verify(input, &signature).is_ok() + } +} + +/// What a frame's signature is over: the UTF-8 of +/// `codedeck-web-v1\n\n\n\n\n`, with +/// `seq` in decimal. `HELLO` is seq 0 with an empty body. +pub fn signed_input(machine_npub: &str, browser_id: &str, challenge: &str, seq: u64, body: &str) -> Vec { + format!("{SIGNING_CONTEXT}\n{machine_npub}\n{browser_id}\n{challenge}\n{seq}\n{body}").into_bytes() +} + +#[cfg(test)] +mod tests { + use super::*; + + /// Made by WebCrypto (Node's, the same API the page uses): + /// `generateKey({name: "ECDSA", namedCurve: "P-256"})`, then `sign` with + /// SHA-256 over [`VECTOR_INPUT`]. Proves the bridge reads what a browser + /// writes: the raw point, and `r‖s` rather than DER. + const VECTOR_KEY: &str = "BFl8gfTaV0Lvl6YQA7eW4XLPT_Fjrid-TAPYwqFzPeNymcU9tbDYtN0tnATTjXLtL4aKeMaf4RhN6Kx2js17LaE"; + const VECTOR_SIG: &str = "w_qyb5iAhcG-HSkLYHw3VlPFGm-W3hwPwMyJ0kKbvItoSB6Ml-lqPy5PkVOWj4QCZnYi8IbgUTBwim6pcXFklQ"; + const VECTOR_BODY: &str = r#"{"v":12,"type":"refresh-sessions"}"#; + + fn vector_input() -> Vec { + signed_input("npub1machine", "0123456789abcdef", "challenge", 1, VECTOR_BODY) + } + + #[test] + fn a_webcrypto_signature_verifies() { + let key = BrowserKey::parse(VECTOR_KEY).expect("a WebCrypto raw key"); + assert!(key.verifies(&vector_input(), VECTOR_SIG)); + } + + #[test] + fn a_signature_is_good_only_for_what_it_signed() { + let key = BrowserKey::parse(VECTOR_KEY).unwrap(); + for (machine, browser, challenge, seq, body) in [ + ("npub1other", "0123456789abcdef", "challenge", 1, VECTOR_BODY), + ("npub1machine", "fedcba9876543210", "challenge", 1, VECTOR_BODY), + ("npub1machine", "0123456789abcdef", "another", 1, VECTOR_BODY), + ("npub1machine", "0123456789abcdef", "challenge", 2, VECTOR_BODY), + ("npub1machine", "0123456789abcdef", "challenge", 1, r#"{"v":12,"type":"refresh-sessions" }"#), + ] { + assert!(!key.verifies(&signed_input(machine, browser, challenge, seq, body), VECTOR_SIG), "{machine} {browser} {challenge} {seq} {body}"); + } + } + + #[test] + fn another_key_or_a_mangled_signature_does_not_verify() { + let mut other = base64::engine::general_purpose::URL_SAFE_NO_PAD.decode(VECTOR_KEY).unwrap(); + // The generator point: on the curve, but not the signer. + other[1..33].copy_from_slice(&hex::decode("6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296").unwrap()); + other[33..].copy_from_slice(&hex::decode("4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5").unwrap()); + let other = BrowserKey::parse(&base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(other)).expect("on the curve"); + assert!(!other.verifies(&vector_input(), VECTOR_SIG)); + + let key = BrowserKey::parse(VECTOR_KEY).unwrap(); + assert!(!key.verifies(&vector_input(), "not base64!")); + assert!(!key.verifies(&vector_input(), &VECTOR_SIG[..40]), "short"); + let mut flipped = base64::engine::general_purpose::URL_SAFE_NO_PAD.decode(VECTOR_SIG).unwrap(); + flipped[10] ^= 1; + assert!(!key.verifies(&vector_input(), &base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(flipped))); + } + + #[test] + fn only_an_uncompressed_point_on_the_curve_is_a_key() { + let raw = base64::engine::general_purpose::URL_SAFE_NO_PAD.decode(VECTOR_KEY).unwrap(); + let enc = |b: &[u8]| base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(b); + assert!(BrowserKey::parse(&enc(&raw[..64])).is_none(), "short"); + let mut compressed = vec![0x02 | (raw[64] & 1)]; + compressed.extend_from_slice(&raw[1..33]); + assert!(BrowserKey::parse(&enc(&compressed)).is_none(), "compressed"); + let mut off_curve = raw.clone(); + off_curve[64] ^= 1; + assert!(BrowserKey::parse(&enc(&off_curve)).is_none(), "not on the curve"); + assert!(BrowserKey::parse("%%%").is_none()); + assert_eq!(BrowserKey::parse(VECTOR_KEY).unwrap().to_base64url(), VECTOR_KEY); + } + + #[test] + fn the_id_is_the_keys_hash_prefix() { + let key = BrowserKey::parse(VECTOR_KEY).unwrap(); + let raw = base64::engine::general_purpose::URL_SAFE_NO_PAD.decode(VECTOR_KEY).unwrap(); + assert_eq!(key.id(), hex::encode(Sha256::digest(&raw))[..BROWSER_ID_LEN]); + } + + #[test] + fn frames_round_trip() { + for frame in [ + WebFrame::Challenge("c1".into()), + WebFrame::Hello { sig: "s".into() }, + WebFrame::Ready, + WebFrame::Closed(closed::EXPIRED.into()), + WebFrame::Cmd { seq: 1, body: VECTOR_BODY.into(), sig: "s".into() }, + WebFrame::Ok { seq: 1, accepted: false, message: "not from a browser".into() }, + WebFrame::Msg(r#"{"inputId":"i","sessionId":"s","type":"input-ack","v":12}"#.into()), + WebFrame::Page { seq: 2, body: r#"{"type":"devices"}"#.into(), sig: "s".into() }, + WebFrame::Reply { seq: 2, reply: r#"{"devices":[]}"#.into() }, + ] { + assert_eq!(decode_web_frame(&encode_web_frame(&frame)), Ok(frame)); + } + } + + #[test] + fn malformed_frames_are_errors() { + for text in [ + "", + "{}", + "[]", + r#"["NOPE"]"#, + r#"["HELLO"]"#, + r#"["CMD", -1, "{}", "s"]"#, + r#"["CMD", 9007199254740992, "{}", "s"]"#, + r#"["CMD", 1, {}, "s"]"#, + r#"["MSG", "text"]"#, + r#"["READY", 1]"#, + ] { + assert!(decode_web_frame(text).is_err(), "{text}"); + } + } +} diff --git a/crates/protocol/tests/codec_conformance.rs b/crates/protocol/tests/codec_conformance.rs index ad15fe82..1dc68c04 100644 --- a/crates/protocol/tests/codec_conformance.rs +++ b/crates/protocol/tests/codec_conformance.rs @@ -252,3 +252,19 @@ fn direct_frames_decode_round_trip_and_rejections_stay_rejected() { assert!(decode_direct_frame(&text).is_err(), "directFrames.rejected[{i}] {text} decoded but should not have"); } } + +#[test] +fn web_frames_decode_round_trip_and_rejections_stay_rejected() { + use protocol::web::{decode_web_frame, encode_web_frame}; + let corpus = corpus(); + for (i, frame) in corpus["webFrames"]["valid"].as_array().unwrap().iter().enumerate() { + let text = frame.to_string(); + let decoded = decode_web_frame(&text).unwrap_or_else(|e| panic!("webFrames.valid[{i}] {text} -> {e}")); + assert_eq!(decode_web_frame(&encode_web_frame(&decoded)), Ok(decoded), "webFrames.valid[{i}] not a round-trip"); + } + for (i, frame) in corpus["webFrames"]["rejected"].as_array().unwrap().iter().enumerate() { + // A string fixture is the raw frame text, anything else its JSON. + let text = frame.as_str().map(str::to_string).unwrap_or_else(|| frame.to_string()); + assert!(decode_web_frame(&text).is_err(), "webFrames.rejected[{i}] {text} decoded but should not have"); + } +} diff --git a/crates/protocol/tests/totality_props.rs b/crates/protocol/tests/totality_props.rs index 459d2d8b..e2ba5a1e 100644 --- a/crates/protocol/tests/totality_props.rs +++ b/crates/protocol/tests/totality_props.rs @@ -12,6 +12,7 @@ use proptest::prelude::*; use protocol::chunking::{frame_encoded_message, parse_chunk_envelope, ChunkAssembler}; use protocol::direct::decode_direct_frame; +use protocol::web::{decode_web_frame, BrowserKey}; use protocol::{decode_bridge_to_phone, decode_phone_to_bridge}; use serde_json::Value; @@ -35,6 +36,8 @@ fn exercise_ingest(text: &str) { let _ = decode_phone_to_bridge(text); let _ = decode_bridge_to_phone(text); let _ = decode_direct_frame(text); + let _ = decode_web_frame(text); + let _ = BrowserKey::parse(text); let _ = parse_chunk_envelope(text); let mut assembler = ChunkAssembler::new(); let _ = assembler.offer(text, 0); @@ -55,8 +58,10 @@ fn valid_wire_messages() -> &'static [String] { out.push(msg.as_str().map(str::to_string).unwrap_or_else(|| msg.to_string())); } } - for frame in corpus["directFrames"]["valid"].as_array().expect("a valid list") { - out.push(frame.to_string()); + for list in ["directFrames", "webFrames"] { + for frame in corpus[list]["valid"].as_array().expect("a valid list") { + out.push(frame.to_string()); + } } let large = format!(r#"{{"type":"output","sessionId":"s","seq":1,"content":"{}"}}"#, "x".repeat(200_000)); out.extend(frame_encoded_message(&large, || "cid-property".to_string())); From cd0507f3c761e03ea6389684380ce328b356725c Mon Sep 17 00:00:00 2001 From: deymosh <232244450+deymosh@users.noreply.github.com> Date: Tue, 17 Nov 2026 20:00:13 +0100 Subject: [PATCH 2/6] feat(bridge-core): a browser on the web page as a client of its identity A browser that a paired phone let in is now a principal of the engine: a client of the identity that approved it, addressed as Addressee::browser(identity, id), whose copies the runtime writes to the browser's stream instead of encrypting them. Copies to an identity reach its browsers with a stream open, live text only those watching that session (presence works as for a phone's client, with the same catch-up), never a terminal's output; a reply goes to the asking browser alone. browser_may_send names every command: a browser drives sessions and reads, and never sends what belongs to an identity (session-key, pair-request, web-sign-in: no browser lets in another), what moves a secret or a sign-in, a terminal command (the allowlist names devices), an upload or an agent-configuration write. The engine ignores the rest, and a command from a browser whose identity is no longer paired. Unpairing an identity ends the browsers it let in (Effect::WebEndBrowsers, which the runtime's page carries out). dispatch now takes the terminal's TerminalVia rather than the relay Via, the only thing it used it for. Co-Authored-By: Claude Code --- crates/bridge-core/src/engine/mod.rs | 9 +- crates/bridge-core/src/engine/pairing.rs | 7 +- crates/bridge-core/src/engine/phone.rs | 20 +- crates/bridge-core/src/engine/session_keys.rs | 9 +- crates/bridge-core/src/engine/web.rs | 161 +++++++++++++++- crates/bridge-core/src/io.rs | 33 +++- crates/bridge-core/src/lib.rs | 2 +- crates/bridge-core/tests/web_client.rs | 172 ++++++++++++++++++ crates/bridge-runtime/src/runtime.rs | 5 + crates/bridge-runtime/src/web.rs | 18 ++ 10 files changed, 415 insertions(+), 21 deletions(-) create mode 100644 crates/bridge-core/tests/web_client.rs diff --git a/crates/bridge-core/src/engine/mod.rs b/crates/bridge-core/src/engine/mod.rs index 919120ff..5b95fa67 100644 --- a/crates/bridge-core/src/engine/mod.rs +++ b/crates/bridge-core/src/engine/mod.rs @@ -27,7 +27,7 @@ mod permission_rules; mod phone; mod session_keys; pub use session_keys::MAX_CLIENTS; -pub use web::MAX_WEB_SIGN_IN_CODES; +pub use web::{browser_may_send, MAX_WEB_SIGN_IN_CODES}; mod settings; mod terminal; pub use terminal::{TerminalAllowlist, TerminalAuditRecord, TerminalAuditWhat, TerminalConfig, PendingDevice}; @@ -177,6 +177,9 @@ pub struct Engine { pairing_epoch: u64, /// The sign-in codes the web page is showing. web_sign_ins: web::WebSignIns, + /// The web page's browsers with a stream open: clients of the + /// identities that let them in. + browsers: web::Browsers, nacks: NackBudget, started: bool, stopped: bool, @@ -239,6 +242,7 @@ impl Engine { terminals, pairing: None, web_sign_ins: web::WebSignIns::default(), + browsers: web::Browsers::new(), pairing_epoch: 0, nacks: NackBudget::default(), started: false, @@ -288,6 +292,9 @@ impl Engine { Input::Shutdown => self.shutdown(), Input::WebSignInPending { code, expires_ms } => self.on_web_sign_in_pending(code, expires_ms), Input::WebSignInWithdrawn { code } => self.on_web_sign_in_withdrawn(&code), + Input::WebBrowserOnline { id, by } => self.on_web_browser_online(id, &by), + Input::WebBrowserOffline { id } => self.on_web_browser_offline(&id), + Input::WebCommand { id, by, msg } => self.on_web_command(id, &by, *msg), } self.requester = None; self.flush(); diff --git a/crates/bridge-core/src/engine/pairing.rs b/crates/bridge-core/src/engine/pairing.rs index 05e7be66..93ef1584 100644 --- a/crates/bridge-core/src/engine/pairing.rs +++ b/crates/bridge-core/src/engine/pairing.rs @@ -129,13 +129,12 @@ impl Engine { /// machine's terminals are not left running for a phone that is no longer /// paired. pub(super) fn unpair(&mut self, identity: &str) { - let before = self.paired.len(); + let Some(npub) = self.paired.iter().find(|p| p.pubkey_hex == identity).map(|p| p.npub.clone()) else { return }; self.paired.retain(|p| p.pubkey_hex != identity); - if self.paired.len() == before { - return; - } log::info!("[Engine] Unpaired {}...", identity.get(..8).unwrap_or(identity)); self.close_identity_terminals(identity, TerminalEndReason::Killed); + // The browsers it let in on the web page were its; they end too. + self.end_identity_browsers(identity, &npub); self.store_paired(); // Nothing from that author is heard any more, and every other phone's // list changed. diff --git a/crates/bridge-core/src/engine/phone.rs b/crates/bridge-core/src/engine/phone.rs index c5f09cbf..98f59437 100644 --- a/crates/bridge-core/src/engine/phone.rs +++ b/crates/bridge-core/src/engine/phone.rs @@ -6,7 +6,7 @@ use protocol::commands::{ PluginActionMsg, QuestionAnswer, QuestionResponseMsg, SetOptionMsg, UploadFileMsg, }; use protocol::common::{ - is_valid_provider_base_url, AgentAction, AgentStyle, EntryBody, Role, SessionOption, PROVIDER_BASE_URL_ERROR, + TerminalVia, is_valid_provider_base_url, AgentAction, AgentStyle, EntryBody, Role, SessionOption, PROVIDER_BASE_URL_ERROR, }; use protocol::events::{ AgentAckMsg, BridgeToPhone, CloseSessionAckMsg, FolderAckMsg, InputAckMsg, InputFailedMsg, @@ -131,14 +131,16 @@ impl Engine { self.grant_session_key(&event.pubkey, m.session_key, &key); } PhoneToBridge::Presence(_) => {} - msg => self.dispatch(msg, &event.pubkey, via), + msg => self.dispatch(msg, &event.pubkey, super::terminal::via_of(via)), } self.requester = None; } } } - fn dispatch(&mut self, msg: PhoneToBridge, phone: &str, via: Via) { + /// Run one command of `phone` (an identity, hex). `via` is the way it + /// came, which only the terminal keeps, for its audit. + pub(super) fn dispatch(&mut self, msg: PhoneToBridge, phone: &str, via: TerminalVia) { match msg { PhoneToBridge::Input(m) => self.on_input(m), PhoneToBridge::PermissionResponse(m) => self.on_permission_response(m), @@ -200,12 +202,12 @@ impl Engine { } // Terminals: the engine decides, the runtime runs their shells // (see the `terminal` module). - PhoneToBridge::TerminalOpen(m) => self.on_terminal_open(m, super::terminal::via_of(via)), - PhoneToBridge::TerminalInput(m) => self.on_terminal_input(m, super::terminal::via_of(via)), - PhoneToBridge::TerminalResize(m) => self.on_terminal_resize(m, super::terminal::via_of(via)), - PhoneToBridge::TerminalReplay(m) => self.on_terminal_replay(m, super::terminal::via_of(via)), - PhoneToBridge::TerminalTakeover(m) => self.on_terminal_takeover(m, super::terminal::via_of(via)), - PhoneToBridge::TerminalClose(m) => self.on_terminal_close(m, super::terminal::via_of(via)), + PhoneToBridge::TerminalOpen(m) => self.on_terminal_open(m, via), + PhoneToBridge::TerminalInput(m) => self.on_terminal_input(m, via), + PhoneToBridge::TerminalResize(m) => self.on_terminal_resize(m, via), + PhoneToBridge::TerminalReplay(m) => self.on_terminal_replay(m, via), + PhoneToBridge::TerminalTakeover(m) => self.on_terminal_takeover(m, via), + PhoneToBridge::TerminalClose(m) => self.on_terminal_close(m, via), PhoneToBridge::WebSignIn(m) => self.on_web_sign_in(&m.code, phone), PhoneToBridge::WebBrowsersRequest(_) => self.on_web_browsers_request(), PhoneToBridge::WebBrowserSignOut(m) => self.on_web_browser_sign_out(m.id), diff --git a/crates/bridge-core/src/engine/session_keys.rs b/crates/bridge-core/src/engine/session_keys.rs index 1dc063c5..b3a96013 100644 --- a/crates/bridge-core/src/engine/session_keys.rs +++ b/crates/bridge-core/src/engine/session_keys.rs @@ -300,7 +300,7 @@ impl Engine { /// shows are complete instead of waiting for the entry that completes /// each part. A part that outgrew the cap has nothing to send, and a /// session with no live parts nothing either. - fn catch_up_live_text(&mut self, identity: &str, client_key: &str, session_id: &str) { + pub(super) fn catch_up_live_text(&mut self, identity: &str, client_key: &str, session_id: &str) { let Some(run) = self.sessions.get(session_id).and_then(|s| s.run.as_ref()) else { return }; let messages: Vec = run .parts @@ -406,7 +406,12 @@ impl Engine { Stream::Terminal(term) => self.copy_keys_watching_terminal(&a.phone, now, term), Stream::Everyone => self.copy_keys(&a.phone, now), }; - keys.into_iter().map(|key| Addressee { phone: a.phone.clone(), key }).collect() + let mut copies: Vec = + keys.into_iter().map(|key| Addressee { phone: a.phone.clone(), key }).collect(); + // The identity's browsers on the web page are its + // clients too. + copies.extend(self.browser_copies(&a.phone, message)); + copies } else { vec![a.clone()] } diff --git a/crates/bridge-core/src/engine/web.rs b/crates/bridge-core/src/engine/web.rs index 684b3e3f..0f3742f8 100644 --- a/crates/bridge-core/src/engine/web.rs +++ b/crates/bridge-core/src/engine/web.rs @@ -7,12 +7,84 @@ //! ([`Effect::WebSignedIn`]). A code works once, and only until it lapses: //! anyone who reads it off the screen still needs a paired phone to use it. -use std::collections::HashMap; +use std::collections::{BTreeMap, HashMap}; +use protocol::commands::PhoneToBridge; +use protocol::common::TerminalVia; use protocol::events::{BridgeToPhone, WebSignInResultMsg}; use super::Engine; -use crate::io::Effect; +use crate::io::{Addressee, Effect, WatchState}; + +/// Whether a browser may send `msg`. A browser drives sessions and reads; +/// what belongs to an identity (its keys, letting in another browser, +/// pairing), what moves a secret or a sign-in, the terminal (whose allowlist +/// names devices, and a browser is none), uploads and the agents' +/// configuration stay with the phone. Every command is named, so a new one +/// is decided here rather than let through by default. +pub fn browser_may_send(msg: &PhoneToBridge) -> bool { + match msg { + PhoneToBridge::Input(_) + | PhoneToBridge::PermissionResponse(_) + | PhoneToBridge::QuestionResponse(_) + | PhoneToBridge::PlanResponse(_) + | PhoneToBridge::SetOption(_) + | PhoneToBridge::SyncRequest(_) + | PhoneToBridge::SyncAck(_) + | PhoneToBridge::CreateSession(_) + | PhoneToBridge::RefreshSessions(_) + | PhoneToBridge::CloseSession(_) + | PhoneToBridge::Interrupt(_) + | PhoneToBridge::StopTask(_) + | PhoneToBridge::CreateFolder(_) + | PhoneToBridge::Presence(_) + | PhoneToBridge::UsageRequest(_) + | PhoneToBridge::ModelsRequest(_) + | PhoneToBridge::AgentStyleRequest(_) + | PhoneToBridge::CommandsRequest(_) + | PhoneToBridge::PersonasRequest(_) + | PhoneToBridge::PluginsRequest(_) + | PhoneToBridge::McpRequest(_) + | PhoneToBridge::SessionMcpRequest(_) + | PhoneToBridge::PermissionRulesRequest(_) + | PhoneToBridge::AccountsRequest(_) + | PhoneToBridge::ProviderProfilesRequest(_) + | PhoneToBridge::WebBrowsersRequest(_) + | PhoneToBridge::WebBrowserSignOut(_) => true, + PhoneToBridge::SessionKey(_) + | PhoneToBridge::PairRequest(_) + | PhoneToBridge::WebSignIn(_) + | PhoneToBridge::SetCredentials(_) + | PhoneToBridge::SetProviderProfile(_) + | PhoneToBridge::AccountAction(_) + | PhoneToBridge::TerminalOpen(_) + | PhoneToBridge::TerminalInput(_) + | PhoneToBridge::TerminalResize(_) + | PhoneToBridge::TerminalReplay(_) + | PhoneToBridge::TerminalTakeover(_) + | PhoneToBridge::TerminalClose(_) + | PhoneToBridge::UploadFile(_) + | PhoneToBridge::PluginAction(_) + | PhoneToBridge::McpAction(_) + | PhoneToBridge::AgentAction(_) + | PhoneToBridge::SessionMcpToggle(_) + | PhoneToBridge::PermissionRulesRemove(_) => false, + } +} + +/// A browser with a stream open: a present client of the identity that let +/// it in. One whose streams all closed is not kept — it gets nothing until it +/// opens one, and says again what it watches. +#[derive(Debug)] +pub(super) struct BrowserClient { + /// The identity that let it in (hex). + identity: String, + /// Which session's live text it wants. + watch: WatchState, +} + +/// The browsers with a stream open, by their public id. +pub(super) type Browsers = BTreeMap; /// Codes the page is showing at once; the soonest to lapse goes first past /// it. The page caps its own pending sign-ins at this too, and withdraws a @@ -89,6 +161,91 @@ impl Engine { self.out.push(Effect::WebBrowserSignOut { id, client }); } } + + /// The paired identity whose npub is `by`, as hex. + fn identity_of_npub(&self, by: &str) -> Option { + self.paired.iter().find(|p| p.npub == by).map(|p| p.pubkey_hex.clone()) + } + + /// A browser that `by` let in opened its first stream. An identity that + /// is no longer paired lets nothing in: its browsers are ended. + pub(super) fn on_web_browser_online(&mut self, id: String, by: &str) { + let Some(identity) = self.identity_of_npub(by) else { + self.out.push(Effect::WebEndBrowsers { by: by.to_string() }); + return; + }; + self.browser_present(&id, &identity); + } + + /// `id` is a present client of `identity`; one that was not gets a + /// heartbeat of its own, as a phone's client back from away does. + fn browser_present(&mut self, id: &str, identity: &str) { + if self.browsers.contains_key(id) { + return; + } + log::info!("[Engine] A browser of {}... is online", identity.get(..8).unwrap_or(identity)); + self.want_list(Addressee::browser(identity, id)); + self.browsers.insert(id.to_string(), BrowserClient { identity: identity.to_string(), watch: WatchState::Unknown }); + } + + pub(super) fn on_web_browser_offline(&mut self, id: &str) { + self.browsers.remove(id); + } + + /// A command from browser `id`, whose signature the runtime checked. + /// It runs as its identity's — the reply goes to the browser alone — + /// unless the identity is no longer paired or the command is one a + /// browser may not send ([`browser_may_send`]). + pub(super) fn on_web_command(&mut self, id: String, by: &str, msg: PhoneToBridge) { + let Some(identity) = self.identity_of_npub(by) else { + log::info!("[Engine] Ignoring a browser command: the identity that let it in is not paired"); + self.out.push(Effect::WebEndBrowsers { by: by.to_string() }); + return; + }; + if !browser_may_send(&msg) { + log::info!("[Engine] Ignoring a command a browser may not send"); + return; + } + self.browser_present(&id, &identity); + let client = Addressee::browser(&identity, &id); + if let PhoneToBridge::Presence(m) = &msg { + let next = WatchState::Watching(if m.away { None } else { m.watching.clone() }); + let Some(browser) = self.browsers.get_mut(&id) else { return }; + if browser.watch != next { + browser.watch = next.clone(); + // A browser that starts watching a session is caught up on + // its live parts at once, as a phone's client is. + if let WatchState::Watching(Some(session)) = next { + self.catch_up_live_text(&identity, &client.key, &session); + } + } + return; + } + self.requester = Some(client); + self.dispatch(msg, &identity, TerminalVia::Unknown); + } + + /// The browsers of `identity` a copy of `message` goes to: every one + /// with a stream open, narrowed to those watching the session for live + /// text. Never a terminal's output — a browser opens no terminal. + pub(super) fn browser_copies(&self, identity: &str, message: &BridgeToPhone) -> Vec { + self.browsers + .iter() + .filter(|(_, b)| b.identity == identity) + .filter(|(_, b)| match message { + BridgeToPhone::Partial(m) => b.watch.wants(&m.session_id), + BridgeToPhone::TerminalOutput(_) => false, + _ => true, + }) + .map(|(id, _)| Addressee::browser(identity, id)) + .collect() + } + + /// `identity` was unpaired: the browsers it let in go with it. + pub(super) fn end_identity_browsers(&mut self, identity: &str, npub: &str) { + self.browsers.retain(|_, b| b.identity != identity); + self.out.push(Effect::WebEndBrowsers { by: npub.to_string() }); + } } #[cfg(test)] diff --git a/crates/bridge-core/src/io.rs b/crates/bridge-core/src/io.rs index 1787ec1e..beb613dd 100644 --- a/crates/bridge-core/src/io.rs +++ b/crates/bridge-core/src/io.rs @@ -7,7 +7,7 @@ //! runtime did not provide — the same inputs always give the same effects. use agent_protocol::{BridgeFrame, HostFrame}; -use protocol::commands::UploadFileMsg; +use protocol::commands::{PhoneToBridge, UploadFileMsg}; use protocol::common::TerminalEndReason; use protocol::events::BridgeToPhone; use serde::{Deserialize, Serialize}; @@ -171,15 +171,32 @@ pub struct Addressee { /// session key, or the identity when it has granted none. The copy's /// recipient tag is derived from it (`protocol::recipients`). Inside the /// engine only, an empty key stands for every present client of the - /// identity, until it is addressed. + /// identity, until it is addressed. For a browser on the web page, see + /// [`Addressee::browser`]. pub key: String, } +/// What a browser's [`Addressee::key`] starts with. A Nostr key is 64 hex +/// characters, so no client key can be mistaken for one. +const BROWSER_KEY_PREFIX: &str = "web:"; + impl Addressee { /// Every present client of `phone`. pub(crate) fn identity(phone: &str) -> Self { Self { phone: phone.to_string(), key: String::new() } } + + /// The web page's browser `id`, signed in by `identity`: a client of + /// that identity whose copies are neither encrypted nor signed — the + /// runtime writes them to the browser's stream, over TLS. + pub fn browser(identity: &str, id: &str) -> Self { + Self { phone: identity.to_string(), key: format!("{BROWSER_KEY_PREFIX}{id}") } + } + + /// The browser this copy is for, if it is for one. + pub fn browser_id(&self) -> Option<&str> { + self.key.strip_prefix(BROWSER_KEY_PREFIX) + } } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -259,6 +276,15 @@ pub enum Input { /// dropped to make room, before a phone sent it. A phone sending it now /// would be told a browser was let in that is no longer there. WebSignInWithdrawn { code: String }, + /// A signed-in browser opened its first stream: it is a present client + /// of the identity `by` (an npub) that let it in, and gets a heartbeat. + WebBrowserOnline { id: String, by: String }, + /// A browser's last stream closed: it gets nothing until it opens one. + WebBrowserOffline { id: String }, + /// A command from a browser, its signature already checked by the + /// runtime against the key the browser signed in with. `by` is the npub + /// of the identity that let it in. + WebCommand { id: String, by: String, msg: Box }, } #[derive(Debug)] @@ -336,6 +362,9 @@ pub enum Effect { /// with the fresh list, so an id that matches nothing is still answered /// with the truth rather than silence. WebBrowserSignOut { id: String, client: Addressee }, + /// The identity `by` (an npub) is no longer paired: every browser it let + /// in is signed out, and its streams closed. + WebEndBrowsers { by: String }, } /// Well-known [`Store`](crate::ports::Store) keys. diff --git a/crates/bridge-core/src/lib.rs b/crates/bridge-core/src/lib.rs index 8a777df0..2f13449c 100644 --- a/crates/bridge-core/src/lib.rs +++ b/crates/bridge-core/src/lib.rs @@ -34,7 +34,7 @@ pub mod time; pub use engine::{ Config, Engine, PendingDevice, TerminalAllowlist, TerminalAuditRecord, TerminalAuditWhat, TerminalConfig, - DEFAULT_HEARTBEAT_INTERVAL_MS, MAX_CLIENTS, MAX_WEB_SIGN_IN_CODES, + browser_may_send, DEFAULT_HEARTBEAT_INTERVAL_MS, MAX_CLIENTS, MAX_WEB_SIGN_IN_CODES, }; pub use sync::SyncConfig; pub use io::*; diff --git a/crates/bridge-core/tests/web_client.rs b/crates/bridge-core/tests/web_client.rs new file mode 100644 index 00000000..cf6f40a1 --- /dev/null +++ b/crates/bridge-core/tests/web_client.rs @@ -0,0 +1,172 @@ +//! A browser on the bridge's web page as a client of the identity that let it +//! in: what it may send, what it gets, and what ends it. The runtime has +//! already checked each command's signature; the engine decides what a +//! browser's command may do. + +mod support; + +use agent_protocol::{BridgeMessage, SessionEvent}; +use bridge_core::{Addressee, Effect, Input}; +use protocol::commands::PhoneToBridge; +use protocol::common::PartialKind; +use protocol::events::BridgeToPhone; +use serde_json::{json, Value}; +use support::*; + +const BROWSER: &str = "0123456789abcdef"; +const OTHER_BROWSER: &str = "fedcba9876543210"; + +fn command(msg: Value) -> Box { + let mut msg = msg; + msg["v"] = json!(protocol::capabilities::PROTOCOL_VERSION); + Box::new(serde_json::from_value(msg).expect("a command")) +} + +/// A browser `id` of the rig's phone, with its stream open. +fn online(rig: &mut Rig, id: &str) { + let by = rig.phone.npub.clone(); + rig.input(Input::WebBrowserOnline { id: id.into(), by }); +} + +/// A command from browser `id`, let in by the rig's phone; its effects. +fn from_browser(rig: &mut Rig, id: &str, msg: Value) -> Vec { + rig.take(); + let by = rig.phone.npub.clone(); + rig.input(Input::WebCommand { id: id.into(), by, msg: command(msg) }); + rig.take() +} + +/// Every publish's addressees, with the message. +fn publishes(effects: &[Effect]) -> Vec<(Vec, BridgeToPhone)> { + effects + .iter() + .filter_map(|e| match e { + Effect::Publish { to, message } => Some((to.clone(), message.clone())), + _ => None, + }) + .collect() +} + +fn to_browser(rig: &Rig, id: &str) -> Addressee { + Addressee::browser(&rig.phone.pubkey_hex, id) +} + +#[test] +fn a_browser_online_gets_a_heartbeat_of_its_own() { + let mut rig = Rig::new(); + rig.take(); + online(&mut rig, BROWSER); + let sent = publishes(&rig.take()); + assert!( + sent.iter().any(|(to, m)| matches!(m, BridgeToPhone::Sessions(_)) && to.contains(&to_browser(&rig, BROWSER))), + "{sent:#?}" + ); +} + +#[test] +fn a_browser_drives_a_session_as_its_identity() { + let mut rig = Rig::new(); + rig.host_up(); + online(&mut rig, BROWSER); + rig.take(); + let by = rig.phone.npub.clone(); + rig.input(Input::WebCommand { id: BROWSER.into(), by, msg: command(json!({"type":"create-session","agent":"alpha"})) }); + let (id, params) = rig.start_request(); + rig.host_reply(&id, agent_protocol::HostMessage::Ack); + rig.host_event(¶ms.session_id, SessionEvent::Ready {}); + rig.take(); + + let effects = from_browser(&mut rig, BROWSER, json!({"type":"input","sessionId":params.session_id,"text":"hi","inputId":"i1"})); + assert!( + effects.iter().any(|e| matches!(e, Effect::Host(f) if matches!(&f.message, BridgeMessage::Prompt { .. }))), + "the input reached the agent: {effects:#?}" + ); + let acks: Vec<_> = publishes(&effects).into_iter().filter(|(_, m)| matches!(m, BridgeToPhone::InputAck(_))).collect(); + assert!(acks.iter().any(|(to, _)| to.contains(&to_browser(&rig, BROWSER))), "the browser hears its ack: {acks:#?}"); +} + +#[test] +fn a_reply_goes_to_the_asking_browser_alone() { + let mut rig = Rig::new(); + online(&mut rig, BROWSER); + online(&mut rig, OTHER_BROWSER); + let sent = publishes(&from_browser(&mut rig, BROWSER, json!({"type":"refresh-sessions"}))); + let lists: Vec<_> = sent.into_iter().filter(|(_, m)| matches!(m, BridgeToPhone::Sessions(_))).collect(); + assert_eq!(lists.len(), 1, "{lists:#?}"); + assert_eq!(lists[0].0, vec![to_browser(&rig, BROWSER)]); +} + +#[test] +fn a_command_a_browser_may_not_send_does_nothing() { + let mut rig = Rig::new(); + rig.input(Input::WebSignInPending { code: "K7QM-4XPA".into(), expires_ms: T0 + 60_000 }); + online(&mut rig, BROWSER); + for msg in [ + json!({"type":"web-sign-in","code":"K7QM-4XPA"}), + json!({"type":"set-credentials","agent":"alpha","values":{"anthropic_api_key":"sk-ant-x"}}), + json!({"type":"mcp-action","agent":"alpha","action":"remove","names":["github"]}), + json!({"type":"terminal-open","openId":"o1","cols":80,"rows":24}), + ] { + let Ok(parsed) = serde_json::from_value::({ + let mut m = msg.clone(); + m["v"] = json!(protocol::capabilities::PROTOCOL_VERSION); + m + }) else { + panic!("not a command: {msg}") + }; + assert!(!bridge_core::browser_may_send(&parsed), "{msg}"); + let effects = from_browser(&mut rig, BROWSER, msg.clone()); + assert!(effects.is_empty(), "{msg} did something: {effects:#?}"); + } +} + +#[test] +fn live_text_reaches_only_a_browser_watching_that_session() { + let mut rig = Rig::new(); + rig.host_up(); + let s1 = rig.ready_session("alpha"); + let s2 = rig.ready_session("alpha"); + online(&mut rig, BROWSER); + online(&mut rig, OTHER_BROWSER); + from_browser(&mut rig, BROWSER, json!({"type":"presence","watching":s1})); + from_browser(&mut rig, OTHER_BROWSER, json!({"type":"presence","watching":s2})); + rig.take(); + + let partial = SessionEvent::Partial { key: "p1".into(), entry_type: PartialKind::Text, subagent: None, offset: 0, text: "x".into() }; + rig.host_event(&s1, partial); + let to: Vec = publishes(&rig.take()) + .into_iter() + .filter(|(_, m)| matches!(m, BridgeToPhone::Partial(_))) + .flat_map(|(to, _)| to) + .filter(|a| a.browser_id().is_some()) + .collect(); + assert_eq!(to, vec![to_browser(&rig, BROWSER)]); +} + +#[test] +fn a_browser_offline_gets_nothing() { + let mut rig = Rig::new(); + online(&mut rig, BROWSER); + rig.input(Input::WebBrowserOffline { id: BROWSER.into() }); + rig.take(); + rig.input(Input::WorkspaceChanged); + let sent = publishes(&rig.take()); + assert!(!sent.is_empty(), "a heartbeat went out"); + assert!(sent.iter().all(|(to, _)| to.iter().all(|a| a.browser_id().is_none())), "{sent:#?}"); +} + +#[test] +fn unpairing_ends_the_browsers_it_let_in() { + let mut rig = Rig::new(); + online(&mut rig, BROWSER); + rig.take(); + let identity = rig.phone.pubkey_hex.clone(); + rig.input(Input::Unpaired { identity }); + let npub = rig.phone.npub.clone(); + assert!(rig.take().iter().any(|e| matches!(e, Effect::WebEndBrowsers { by } if *by == npub))); + + // A command still in flight from one of them does nothing but end them. + let effects = from_browser(&mut rig, BROWSER, json!({"type":"refresh-sessions"})); + assert!(effects.iter().all(|e| matches!(e, Effect::WebEndBrowsers { .. })), "{effects:#?}"); + assert!(!effects.is_empty()); +} diff --git a/crates/bridge-runtime/src/runtime.rs b/crates/bridge-runtime/src/runtime.rs index d2f14597..72abcc42 100644 --- a/crates/bridge-runtime/src/runtime.rs +++ b/crates/bridge-runtime/src/runtime.rs @@ -411,6 +411,11 @@ impl Runtime { let message = BridgeToPhone::WebBrowsers(WebBrowsersMsg { browsers: self.web_browsers() }); self.relays.publish(vec![client], message); } + Effect::WebEndBrowsers { by } => { + if let Some(direct) = &self.direct { + direct.web.end_by(&by); + } + } Effect::Host(frame) => self.host.send(&frame), Effect::SetTimer { id, after_ms } => { let inputs = self.inputs.clone(); diff --git a/crates/bridge-runtime/src/web.rs b/crates/bridge-runtime/src/web.rs index e8a93942..93bf36dd 100644 --- a/crates/bridge-runtime/src/web.rs +++ b/crates/bridge-runtime/src/web.rs @@ -385,6 +385,24 @@ impl Web { } } + /// Sign out every browser the identity `by` (an npub) let in: it is no + /// longer paired, and what it let in goes with it. + pub fn end_by(&self, by: &str) { + let keys: Vec = self + .browsers + .borrow() + .iter() + .filter(|(_, b)| matches!(&b.access, Access::SignedIn { by: approver, .. } if approver == by)) + .map(|(key, _)| key.clone()) + .collect(); + if !keys.is_empty() { + log::info!("[Web] {} browser(s) signed out: the identity that let them in was unpaired", keys.len()); + } + for key in keys { + self.sign_out(&key); + } + } + fn next_order(&self) -> u64 { let order = self.order.get(); self.order.set(order + 1); From d7247999aee0830947178536d176b7ebf4f90170 Mon Sep 17 00:00:00 2001 From: deymosh <232244450+deymosh@users.noreply.github.com> Date: Tue, 17 Nov 2026 20:10:57 +0100 Subject: [PATCH 3/6] feat(bridge-runtime): the web page's signed stream for browsers A browser now signs in with a key: POST /api/sign-in carries the public half of a WebCrypto P-256 key, bound to the pending sign-in before any phone sees its code. Its id is the key's (protocol::web), and the key is kept in web-sessions.json beside the cookie's hash. GET /api/stream (a WebSocket on the page's path; every other upgrade is still a phone's direct link) is let through only for an allowed Host, the page's own Origin and a signed-in cookie. The browser then signs the connection's challenge and every frame after it, each with a growing seq; a frame that does not verify, or replays a seq, closes the stream. A verified command is checked against bridge_core::browser_may_send and handed to the engine as Input::WebCommand; the first and last stream of a browser make it a present client of its identity or not. What the engine sends a browser goes down its stream through the direct link's lane: never waited on, and a browser that stops reading is closed as busy. The cookie alone now reaches only /api/me (which also tells the page its machine and id), the QR and its own sign-out. The status, browsers, devices and config routes are gone: the heartbeat arrives on the stream, the browser list through the phone's own web-browsers commands, and devices/config as signed page requests. A browser signed in for 30 days also lapses after 7 days without signing anything. Only a signature moves lastSeenMs, so a copied cookie cannot keep it alive; web-browsers' expiresMs is when it actually lapses. A lapse, sign-out, revocation or unpairing closes its streams with the reason. Data: a web-sessions.json record from before browser keys has none, and is skipped on load; those browsers sign in again. Co-Authored-By: Claude Code --- Cargo.lock | 1 + crates/bridge-runtime/Cargo.toml | 2 + crates/bridge-runtime/src/direct.rs | 46 +- crates/bridge-runtime/src/lib.rs | 1 + crates/bridge-runtime/src/runtime.rs | 35 +- crates/bridge-runtime/src/web.rs | 1089 +++++++++++++++-------- crates/bridge-runtime/src/web_stream.rs | 387 ++++++++ 7 files changed, 1169 insertions(+), 392 deletions(-) create mode 100644 crates/bridge-runtime/src/web_stream.rs diff --git a/Cargo.lock b/Cargo.lock index 6c05f615..dd889409 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -443,6 +443,7 @@ dependencies = [ "nix", "nostr", "nostr-transport", + "p256", "portable-pty", "protocol", "qrcode", diff --git a/crates/bridge-runtime/Cargo.toml b/crates/bridge-runtime/Cargo.toml index 8ea40e03..3d24f352 100644 --- a/crates/bridge-runtime/Cargo.toml +++ b/crates/bridge-runtime/Cargo.toml @@ -66,6 +66,8 @@ portable-pty = "0.9" nix = { version = "0.28", features = ["hostname", "term", "user"] } [dev-dependencies] +# Signs as a browser's WebCrypto key does, for the web stream's tests. +p256 = { version = "0.13", default-features = false, features = ["ecdsa", "std"] } tempfile = "3" # Paused time for the tests that wait on timers (`start_paused`). tokio = { version = "1", features = ["test-util"] } diff --git a/crates/bridge-runtime/src/direct.rs b/crates/bridge-runtime/src/direct.rs index 2a9f8c44..cc3d9c9c 100644 --- a/crates/bridge-runtime/src/direct.rs +++ b/crates/bridge-runtime/src/direct.rs @@ -171,7 +171,7 @@ struct Conn { /// larger than the bounds can still be delivered to a phone that is reading: /// the bounds decide whether the phone has *stopped* reading, not how big one /// publish pass may be. -struct FrameLane { +pub(crate) struct FrameLane { queue: RefCell>, bytes: Cell, /// When the serve loop last took a frame out. @@ -182,7 +182,7 @@ struct FrameLane { } impl FrameLane { - fn new() -> Self { + pub(crate) fn new() -> Self { Self { queue: RefCell::new(VecDeque::new()), bytes: Cell::new(0), @@ -195,7 +195,7 @@ impl FrameLane { /// Queue a frame; false once the connection has been closed as stalled. /// An over-cap queue while frames are still being taken is accepted: it /// is a big burst, and the phone will drain it. - fn push(&self, frame: String) -> bool { + pub(crate) fn push(&self, frame: String) -> bool { if self.closed.get() { return false; } @@ -219,21 +219,21 @@ impl FrameLane { true } - fn pop(&self) -> Option { + pub(crate) fn pop(&self) -> Option { let frame = self.queue.borrow_mut().pop_front()?; self.bytes.set(self.bytes.get().saturating_sub(frame.len())); self.last_taken.set(std::time::Instant::now()); Some(frame) } - fn is_closed(&self) -> bool { + pub(crate) fn is_closed(&self) -> bool { self.closed.get() } /// Stop accepting frames and wake the serve loop, which sends its /// `closed` frame and ends. The lane is shared with that loop, so /// dropping the connection is not enough to end it. - fn close(&self) { + pub(crate) fn close(&self) { self.closed.set(true); self.wake.notify_one(); } @@ -241,7 +241,7 @@ impl FrameLane { /// Ready once a frame is waiting or the lane is closed. A `push` while /// nobody waits leaves `Notify`'s permit behind, so no wake-up is lost /// between the check and the wait. - async fn ready(&self) { + pub(crate) async fn ready(&self) { while self.queue.borrow().is_empty() && !self.closed.get() { self.wake.notified().await; } @@ -316,6 +316,22 @@ fn recipient_of(event: &SignedEvent) -> Option<&str> { } impl Hub { + /// A browser's stream from `peer` stops counting against its host's + /// connections ([`MAX_CONNECTIONS_PER_HOST`]): the page caps streams + /// itself, and on an IPv6 LAN — one /64 for every device — a few tabs + /// would otherwise lock the phones on it out of their direct link. + /// [`Hub::retake_host_slot`] gives the slot back when the stream ends, + /// so the accept loop's own release still balances. + pub(crate) fn release_host_slot(&self, peer: IpAddr) { + if let Some(held) = self.open_by_host.borrow_mut().get_mut(&crate::web::rate_key(peer)) { + *held = held.saturating_sub(1); + } + } + + pub(crate) fn retake_host_slot(&self, peer: IpAddr) { + *self.open_by_host.borrow_mut().entry(crate::web::rate_key(peer)).or_insert(0) += 1; + } + pub fn new(bridge_pubkey: String, inputs: mpsc::UnboundedSender) -> Rc { Rc::new(Self { bridge_pubkey, @@ -637,7 +653,13 @@ where async fn route(mut stream: S, peer: IpAddr, hub: &Hub, web: &crate::web::Web, limits: Limits) { let Ok(Some(head)) = tokio::time::timeout(limits.handshake, crate::web::read_head(&mut stream)).await else { return }; if crate::web::is_websocket(&head) { - serve(Replay { prefix: head, at: 0, inner: stream }, hub, limits).await; + // A browser's stream is the page's, on its own path; every other + // upgrade is a phone's direct link. + if crate::web::is_stream_request(&head) { + crate::web_stream::serve(head, stream, web, Some((hub, peer))).await; + } else { + serve(Replay::new(head, stream), hub, limits).await; + } } else { crate::web::serve(&head, stream, peer, web).await; } @@ -646,12 +668,18 @@ async fn route(mut stream: S, peer: IpAddr, h /// A stream that yields `prefix` before reading on from `inner`: the request /// head [`route`] read to tell a WebSocket from a page, given back to the /// WebSocket handshake that needs it. -struct Replay { +pub(crate) struct Replay { prefix: Vec, at: usize, inner: S, } +impl Replay { + pub(crate) fn new(prefix: Vec, inner: S) -> Self { + Self { prefix, at: 0, inner } + } +} + impl AsyncRead for Replay { fn poll_read(mut self: std::pin::Pin<&mut Self>, cx: &mut std::task::Context<'_>, buf: &mut ReadBuf<'_>) -> std::task::Poll> { if self.at < self.prefix.len() { diff --git a/crates/bridge-runtime/src/lib.rs b/crates/bridge-runtime/src/lib.rs index 9781b322..cffae0dd 100644 --- a/crates/bridge-runtime/src/lib.rs +++ b/crates/bridge-runtime/src/lib.rs @@ -12,6 +12,7 @@ pub mod direct; pub mod host; pub mod uploads; pub mod web; +pub mod web_stream; pub mod pairing; pub mod qr; pub mod relay; diff --git a/crates/bridge-runtime/src/runtime.rs b/crates/bridge-runtime/src/runtime.rs index 72abcc42..0fce5294 100644 --- a/crates/bridge-runtime/src/runtime.rs +++ b/crates/bridge-runtime/src/runtime.rs @@ -17,7 +17,7 @@ use base64::engine::general_purpose::STANDARD; use base64::Engine as _; use bridge_core::ports::{Ports, System}; use bridge_core::{ - Config as EngineConfig, Effect, Engine, Input, NotifyLevel, PairingCloseReason, PairingWindowInfo, TerminalConfig, + Addressee, Config as EngineConfig, Effect, Engine, Input, NotifyLevel, PairingCloseReason, PairingWindowInfo, TerminalConfig, TimerId, }; use protocol::commands::UploadFileMsg; @@ -373,6 +373,22 @@ impl Runtime { self.direct.as_ref().map(|direct| direct.web.browsers()).unwrap_or_default() } + /// Send `message` to `to`: a browser's copy goes down its stream on the + /// web page as it is (TLS carries it; no message holds a secret), every + /// other copy to the relays and the direct link, encrypted and signed. + fn publish(&self, to: Vec, message: BridgeToPhone) { + let (browsers, phones): (Vec, Vec) = to.into_iter().partition(|a| a.browser_id().is_some()); + if let (false, Some(direct)) = (browsers.is_empty(), &self.direct) { + let text = protocol::encode_bridge_to_phone(&message); + for browser in browsers.iter().filter_map(Addressee::browser_id) { + direct.web.deliver(browser, &text); + } + } + if !phones.is_empty() { + self.relays.publish(phones, message); + } + } + /// Carry out one effect; true for [`Effect::Stopped`]. Async because one /// effect does blocking file work that must not run here: opening a /// terminal's recording, which is handed to a blocking task before its @@ -380,14 +396,13 @@ impl Runtime { async fn execute(&mut self, effect: Effect) -> bool { match effect { Effect::Publish { to, message } => { - if let (protocol::events::BridgeToPhone::Sessions(list), Some(direct)) = (&message, &self.direct) { - direct.web.set_heartbeat(list); - // The devices API follows the heartbeat: the paired - // phones are cheap to hand over, and this is where they - // change. + if let (protocol::events::BridgeToPhone::Sessions(_), Some(direct)) = (&message, &self.direct) { + // The page's devices view follows the heartbeat: the + // paired phones are cheap to hand over, and this is where + // they change. direct.web.set_devices(self.engine.paired_phones()); } - self.relays.publish(to, message) + self.publish(to, message); } Effect::WebSignedIn { code, by } => { if let Some(direct) = &self.direct { @@ -400,7 +415,7 @@ impl Runtime { // fresh list. Both go to the asking client alone. Effect::WebBrowsers { client } => { let message = BridgeToPhone::WebBrowsers(WebBrowsersMsg { browsers: self.web_browsers() }); - self.relays.publish(vec![client], message); + self.publish(vec![client], message); } Effect::WebBrowserSignOut { id, client } => { // `revoke` persists through the web page's own writer thread, @@ -409,7 +424,7 @@ impl Runtime { direct.web.revoke(&id); } let message = BridgeToPhone::WebBrowsers(WebBrowsersMsg { browsers: self.web_browsers() }); - self.relays.publish(vec![client], message); + self.publish(vec![client], message); } Effect::WebEndBrowsers { by } => { if let Some(direct) = &self.direct { @@ -556,7 +571,7 @@ impl Runtime { data: STANDARD.encode(data), replay: Some(true), }); - self.relays.publish(vec![client], message); + self.publish(vec![client], message); } } Effect::TerminalClose { term } => self.terminals.close(&term), diff --git a/crates/bridge-runtime/src/web.rs b/crates/bridge-runtime/src/web.rs index 93bf36dd..483da172 100644 --- a/crates/bridge-runtime/src/web.rs +++ b/crates/bridge-runtime/src/web.rs @@ -48,7 +48,8 @@ use std::time::Duration; use base64::Engine as _; use bridge_core::{Input, PairedPhone}; -use protocol::events::{SessionListMsg, WebBrowserInfo}; +use protocol::events::WebBrowserInfo; +use protocol::web::BrowserKey; use serde_json::Value; use sha2::{Digest, Sha256}; use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt}; @@ -62,8 +63,15 @@ const MAX_BODY_BYTES: usize = 16 * 1024; const BODY_TIMEOUT: Duration = Duration::from_secs(10); /// How long a sign-in code shown on the page can be approved. pub const PENDING_TTL_MS: u64 = 5 * 60 * 1000; -/// How long a signed-in browser stays signed in. +/// How long a signed-in browser stays signed in, at most. const SESSION_TTL_MS: u64 = 30 * 24 * 3600 * 1000; +/// How long a signed-in browser stays signed in without signing anything: a +/// browser left behind lapses well before its 30 days. +pub(crate) const IDLE_TTL_MS: u64 = 7 * 24 * 3600 * 1000; +/// Streams one browser may hold open (its tabs). +const MAX_STREAMS_PER_BROWSER: usize = 4; +/// Streams open at once, every browser together. +const MAX_STREAMS: usize = 16; /// How often a signed-in browser's `lastSeenMs` is written to disk at most; /// a request touches it in memory every time, but the file no more often. const LAST_SEEN_WRITE_MS: u64 = 60 * 1000; @@ -84,8 +92,8 @@ const COOKIE: &str = "__Host-codedeck"; /// The characters a sign-in code is drawn from: no 0/O, 1/I/L, so it can be /// read off a screen and typed on a phone without doubt. const CODE_ALPHABET: &[u8] = b"23456789ABCDEFGHJKMNPQRSTUVWXYZ"; -/// How many hex characters of a browser's key are its public id. -const ID_LEN: usize = 16; +/// How many hex characters of a browser's public id there are. +const ID_LEN: usize = protocol::web::BROWSER_ID_LEN; /// Longest `User-Agent` kept for a browser; the header is the client's, so it /// is bounded before it is stored or shown. const AGENT_MAX_CHARS: usize = 120; @@ -110,6 +118,9 @@ enum Access { #[derive(Debug, Clone)] struct Browser { access: Access, + /// The key the browser made for this sign-in, sent with its start: every + /// frame on its stream must be signed by it. Its id is the browser's. + key: BrowserKey, peer: IpAddr, /// When it got where it stands, as a count: what the caps drop the /// lowest of (a clock can give two browsers the same millisecond). @@ -118,11 +129,50 @@ struct Browser { /// (control characters stripped, at most [`AGENT_MAX_CHARS`]). Shown on /// the page so the owner can tell one browser from another. agent: String, - /// When it last made an authenticated request. Kept in memory on every - /// one, written at most every [`LAST_SEEN_WRITE_MS`]. + /// When it last signed something on its stream: only a signature moves + /// it, so a copied cookie cannot keep a sign-in alive. Kept in memory on + /// every one, written at most every [`LAST_SEEN_WRITE_MS`]. last_seen_ms: u64, } +impl Browser { + /// When it stops being let in: a pending code's lapse, or for a signed-in + /// browser the sooner of its 30 days and [`IDLE_TTL_MS`] since it last + /// signed anything. + fn lapses_ms(&self) -> u64 { + match self.access { + Access::Pending { expires_ms, .. } => expires_ms, + Access::SignedIn { expires_ms, .. } => expires_ms.min(self.last_seen_ms.saturating_add(IDLE_TTL_MS)), + } + } +} + +/// A browser allowed to open a stream: its cookie names a signed-in one. +#[derive(Debug)] +pub(crate) struct StreamGrant { + /// The SHA-256 of its cookie: how the page finds it again. + pub key: String, + /// Its public id. + pub id: String, + /// The npub of the identity that let it in. + pub by: String, + pub browser_key: BrowserKey, +} + +/// An open stream as its server holds it: its number, its lane, and the cell +/// the page leaves its closing reason in. +pub(crate) type OpenStream = (u64, Rc, Rc>); + +/// One open stream of a browser. +struct WebStream { + /// The browser's cookie hash. + key: String, + id: String, + lane: Rc, + /// Why the page closed it, for its `CLOSED` frame. + reason: Rc>, +} + /// What the page's config API needs: where `config.json` lives, and the view /// of the config as it is in effect (flags and environment already applied). #[derive(Clone, Default)] @@ -138,6 +188,11 @@ pub struct ConfigView { #[serde(rename_all = "camelCase")] struct StoredSession { key: String, + /// The browser's public key (base64url of the raw point). A record + /// without one predates browser keys and is skipped: that browser signs + /// in again. + #[serde(default)] + public_key: String, by: String, since_ms: u64, expires_ms: u64, @@ -174,7 +229,6 @@ pub struct Web { /// Host names (lowercase, no port) a request may name besides an IP /// address and `localhost`. hosts: Vec, - heartbeat: RefCell>, /// By the SHA-256 of the cookie's value, so the table holds no token a /// memory dump could replay. browsers: RefCell>, @@ -197,6 +251,11 @@ pub struct Web { writer: Writer, /// Page requests being served now ([`MAX_PAGE_REQUESTS`]). serving: Cell, + /// The browsers' open streams, by a number of their own. + streams: RefCell>, + next_stream: Cell, + /// The clock (ms since the Unix epoch); a test moves it. + clock: Box u64>, } impl Web { @@ -206,10 +265,21 @@ impl Web { inputs: mpsc::UnboundedSender, home: &Path, config: ConfigView, + ) -> Rc { + Self::with_clock(machine_npub, endpoints, inputs, home, config, Box::new(now_ms)) + } + + pub(crate) fn with_clock( + machine_npub: String, + endpoints: &[String], + inputs: mpsc::UnboundedSender, + home: &Path, + config: ConfigView, + clock: Box u64>, ) -> Rc { let hosts = endpoints.iter().filter_map(|url| endpoint_host(url)).collect(); let sessions_path = home.join("web-sessions.json"); - let browsers = load_sessions(&sessions_path); + let browsers = load_sessions(&sessions_path, clock()); let order = browsers.values().map(|b| b.order).max().unwrap_or(0) + 1; if !browsers.is_empty() { log::info!("[Web] {} signed-in browser(s) restored from {}", browsers.len(), sessions_path.display()); @@ -217,7 +287,6 @@ impl Web { Rc::new(Self { machine_npub, hosts, - heartbeat: RefCell::default(), browsers: RefCell::new(browsers), starts: RefCell::default(), order: Cell::new(order), @@ -229,12 +298,25 @@ impl Web { last_persist_ms: Cell::new(0), writer: Writer::spawn(), serving: Cell::new(0), + streams: RefCell::default(), + next_stream: Cell::new(1), + clock, }) } - /// The heartbeat the bridge just published, which the status page shows. - pub fn set_heartbeat(&self, list: &SessionListMsg) { - *self.heartbeat.borrow_mut() = Some(list.clone()); + fn now(&self) -> u64 { + (self.clock)() + } + + /// The machine this page belongs to (its npub): part of every signed + /// input, so a signature for another bridge is good for nothing here. + pub(crate) fn machine(&self) -> &str { + &self.machine_npub + } + + /// Where a browser's verified commands go: the engine's inputs. + pub(crate) fn inputs(&self) -> &mpsc::UnboundedSender { + &self.inputs } /// The paired identities, refreshed alongside the heartbeat: what the @@ -259,7 +341,7 @@ impl Web { /// A phone of `by` sent `code`, and the engine matched it to a code this /// page showed: that browser is signed in. pub fn signed_in(&self, code: &str, by: &str) { - let now = now_ms(); + let now = self.now(); { let mut browsers = self.browsers.borrow_mut(); for browser in browsers.values_mut() { @@ -274,46 +356,47 @@ impl Web { } evict_oldest(&mut browsers, MAX_SESSIONS, |b| matches!(b.access, Access::SignedIn { .. })); } + self.close_orphan_streams(); self.persist(); } + /// The browser a cookie names, by its key, unless it has lapsed — a + /// lapsed one is ended here. A cookie alone never moves `lastSeenMs`: + /// only a signature does ([`Self::seen`]). fn browser(&self, token: Option<&str>) -> Option<(String, Browser)> { - let key = token_key(token?); - let now = now_ms(); - let mut expired = false; - let mut touched = false; - { - let mut browsers = self.browsers.borrow_mut(); - let browser = browsers.get_mut(&key)?; - let expires_ms = match browser.access { - Access::Pending { expires_ms, .. } | Access::SignedIn { expires_ms, .. } => expires_ms, - }; - if expires_ms <= now { - expired = true; - } else if matches!(browser.access, Access::SignedIn { .. }) { - // An authenticated request: its `lastSeenMs` moves, and the - // file follows at most once a minute. - browser.last_seen_ms = now; - touched = true; - } - } - if expired { - self.browsers.borrow_mut().remove(&key); - self.persist(); + self.by_key(&token_key(token?)) + } + + /// [`Self::browser`], by the cookie's hash. + fn by_key(&self, key: &str) -> Option<(String, Browser)> { + let lapsed = self.browsers.borrow().get(key)?.lapses_ms() <= self.now(); + if lapsed { + self.sign_out_for(key, protocol::web::closed::EXPIRED); return None; } - if touched && now.saturating_sub(self.last_persist_ms.get()) >= LAST_SEEN_WRITE_MS { + self.browsers.borrow().get(key).map(|b| (key.to_string(), b.clone())) + } + + /// The browser `key` signed a frame: it is in use, so its idle limit + /// starts again. The file follows at most once a minute. + pub(crate) fn seen(&self, key: &str) { + let now = self.now(); + if let Some(browser) = self.browsers.borrow_mut().get_mut(key) { + browser.last_seen_ms = now; + } + if now.saturating_sub(self.last_persist_ms.get()) >= LAST_SEEN_WRITE_MS { self.last_persist_ms.set(now); self.persist(); } - self.browsers.borrow().get(&key).map(|b| (key.clone(), b.clone())) } - /// Start a sign-in for a browser at `peer` (its `User-Agent` is `agent`): - /// a new code, and the cookie that names it. `None` when the address - /// started too many lately. - fn start_sign_in(&self, peer: IpAddr, agent: &str) -> Option<(String, String)> { - let now = now_ms(); + /// Start a sign-in for a browser at `peer` (its `User-Agent` is `agent`) + /// holding `key`: a new code, and the cookie that names it. The key is + /// bound here, before any phone sees the code, so the code an identity + /// approves names exactly one key. `None` when the address started too + /// many lately. + fn start_sign_in(&self, peer: IpAddr, agent: &str, key: BrowserKey) -> Option<(String, String)> { + let now = self.now(); { let mut starts = self.starts.borrow_mut(); starts.retain(|_, (window, _)| now - *window < 60_000); @@ -332,11 +415,10 @@ impl Web { let code = new_code(); let expires_ms = now + PENDING_TTL_MS; let mut browsers = self.browsers.borrow_mut(); - browsers.retain(|_, b| match b.access { - Access::Pending { expires_ms, .. } | Access::SignedIn { expires_ms, .. } => expires_ms > now, - }); + browsers.retain(|_, b| b.lapses_ms() > now); let browser = Browser { access: Access::Pending { code: code.clone(), expires_ms }, + key, peer, order: self.next_order(), agent: agent.to_string(), @@ -349,15 +431,28 @@ impl Web { for dropped in evict_oldest(&mut browsers, MAX_PENDING, |b| matches!(b.access, Access::Pending { .. })) { self.withdraw(&dropped); } + drop(browsers); + // A lapsed signed-in browser reaped above may still hold a stream. + self.close_orphan_streams(); Some((token, code)) } fn sign_out(&self, key: &str) { + self.sign_out_for(key, protocol::web::closed::SIGNED_OUT); + } + + /// End the browser `key`: its record, its code if it was showing one, + /// and its streams, each closed with `reason`. + fn sign_out_for(&self, key: &str, reason: &'static str) { let removed = self.browsers.borrow_mut().remove(key); if let Some(browser) = removed { self.withdraw(&browser); self.persist(); } + let ended: Vec = self.streams.borrow().iter().filter(|(_, s)| s.key == key).map(|(n, _)| *n).collect(); + for n in ended { + self.end_stream(n, reason); + } } /// Sign out the browser whose id (the first `ID_LEN` hex characters of @@ -374,7 +469,7 @@ impl Web { .browsers .borrow() .iter() - .find(|(key, browser)| key.starts_with(id) && matches!(browser.access, Access::SignedIn { .. })) + .find(|(_, browser)| browser.key.id() == id && matches!(browser.access, Access::SignedIn { .. })) .map(|(key, _)| key.clone()); match key { Some(key) => { @@ -420,6 +515,7 @@ impl Web { .filter_map(|(key, browser)| match &browser.access { Access::SignedIn { by, since_ms, expires_ms } => Some(StoredSession { key: key.clone(), + public_key: browser.key.to_base64url(), by: by.clone(), since_ms: *since_ms, expires_ms: *expires_ms, @@ -450,86 +546,50 @@ impl Web { } } - fn status_json(&self, by: &str, since_ms: u64) -> String { - let heartbeat = self.heartbeat.borrow(); - serde_json::json!({ - "machine": self.machine_npub, - "signedInBy": by, - "signedInSince": since_ms, - "heartbeat": heartbeat.as_ref().map(|h| serde_json::to_value(h).unwrap_or(serde_json::Value::Null)), - }) - .to_string() - } - - /// The signed-in browsers, oldest signed in first, as `(key, info)`. The - /// page's own list: both `browsers_json` and `browsers` read it, so what - /// `GET /api/browsers` serves and what a phone's `web-browsers-request` - /// is answered with can never disagree. - /// A browser whose sign-in has lapsed is left out: it is only reaped when - /// it next asks for something, and until then it is not signed in. - fn browser_rows(&self) -> Vec<(String, WebBrowserInfo)> { - let now = now_ms(); - let mut rows: Vec<(u64, String, WebBrowserInfo)> = self + /// The signed-in browsers, oldest signed in first: what a + /// `web-browsers-request` is answered with, from a phone or a browser. + /// `expiresMs` is when each actually lapses — the sooner of its 30 days + /// and its idle limit. A browser whose sign-in has lapsed is left out: it + /// is only reaped when it next asks for something, and until then it is + /// not signed in. + pub fn browsers(&self) -> Vec { + let now = self.now(); + let mut rows: Vec<(u64, WebBrowserInfo)> = self .browsers .borrow() - .iter() - .filter_map(|(key, browser)| match &browser.access { - Access::SignedIn { by, since_ms, expires_ms } if *expires_ms > now => Some(( + .values() + .filter(|browser| browser.lapses_ms() > now) + .filter_map(|browser| match &browser.access { + Access::SignedIn { by, since_ms, .. } => Some(( browser.order, - key.clone(), WebBrowserInfo { - id: key[..ID_LEN].to_string(), + id: browser.key.id(), by: by.clone(), since_ms: *since_ms, last_seen_ms: browser.last_seen_ms, - expires_ms: *expires_ms, + expires_ms: browser.lapses_ms(), peer: browser.peer.to_string(), agent: browser.agent.clone(), }, )), - _ => None, - }) - .collect(); - rows.sort_by_key(|(order, _, _)| *order); - rows.into_iter().map(|(_, key, info)| (key, info)).collect() - } - - /// The signed-in browsers, oldest signed in first: what a paired phone's - /// `web-browsers-request` is answered with, from the same rows - /// `GET /api/browsers` serves. - pub fn browsers(&self) -> Vec { - self.browser_rows().into_iter().map(|(_, info)| info).collect() - } - - /// The signed-in browsers, oldest first, for `GET /api/browsers`. Each - /// row carries `current` — whether it is the browser asking — which only - /// the page's own request can know. - fn browsers_json(&self, current: Option<&str>) -> String { - let rows: Vec = self - .browser_rows() - .into_iter() - .map(|(key, info)| { - let mut row = serde_json::to_value(&info).unwrap_or(Value::Null); - if let Value::Object(map) = &mut row { - map.insert("current".to_string(), Value::Bool(current == Some(key.as_str()))); - } - row + Access::Pending { .. } => None, }) .collect(); - serde_json::json!({ "browsers": rows }).to_string() + rows.sort_by_key(|(order, _)| *order); + rows.into_iter().map(|(_, info)| info).collect() } - /// The paired identities, for `GET /api/devices`. + /// The paired identities, for the `devices` page request. fn devices_json(&self) -> String { serde_json::json!({ "devices": self.devices.borrow().clone() }).to_string() } - /// The config as it is in effect, for `GET /api/config`. + /// The config as it is in effect, for the `config` page request. fn config_json(&self) -> String { serde_json::json!({ "fields": self.config_fields.borrow().clone() }).to_string() } - /// Apply a `POST /api/config` body: only safe-set keys, each validated, + /// Apply a `config-set` page request's body: only safe-set keys, each validated, /// then written to the config file keeping every other key. `by` is the /// approver's npub, for the log line (key names only, never a value). fn apply_config(&self, body: &[u8], by: &str) -> Response { @@ -563,11 +623,195 @@ impl Web { } } +impl Web { + /// Whether a stream request may be upgraded: an allowed `Host`, an + /// `Origin` that is the page's own (a browser sends cookies on a + /// cross-site WebSocket handshake too), and a cookie naming a signed-in + /// browser. Checked before any signature work, so a stranger costs one + /// hash. The error is the HTTP status to refuse with. + pub(crate) fn stream_grant(&self, head: &[u8]) -> Result { + let request = parse_head(head).ok_or(400u16)?; + let host = request.host.as_deref().filter(|h| host_allowed(h, &self.hosts)).ok_or(403u16)?; + if request.origin.as_deref() != Some(&format!("https://{host}")) { + return Err(403); + } + match self.browser(request.cookie.as_deref()) { + Some((key, Browser { access: Access::SignedIn { by, .. }, key: browser_key, .. })) if self.is_paired(&by) => { + Ok(StreamGrant { id: browser_key.id(), key, by, browser_key }) + } + _ => Err(401), + } + } + + /// Whether the identity `by` (an npub) is paired now, as the heartbeat + /// last told the page. + fn is_paired(&self, by: &str) -> bool { + self.devices.borrow().iter().any(|d| d.npub == by) + } + + /// Close every stream whose browser is no longer signed in: one dropped + /// to make room, or lapsed and reaped, would otherwise stay open. + fn close_orphan_streams(&self) { + let orphans: Vec = { + let browsers = self.browsers.borrow(); + self.streams + .borrow() + .iter() + .filter(|(_, s)| !matches!(browsers.get(&s.key), Some(Browser { access: Access::SignedIn { .. }, .. }))) + .map(|(n, _)| *n) + .collect() + }; + for n in orphans { + self.end_stream(n, protocol::web::closed::SIGNED_OUT); + } + } + + /// Open a stream for `grant`: its lane, and the cell its closing reason + /// is left in. `None` past the caps (per browser, and in all). The first + /// stream of a browser makes it a present client of its identity. + pub(crate) fn open_stream(&self, grant: &StreamGrant) -> Option { + let mut streams = self.streams.borrow_mut(); + let of_browser = streams.values().filter(|s| s.key == grant.key).count(); + if streams.len() >= MAX_STREAMS || of_browser >= MAX_STREAMS_PER_BROWSER { + return None; + } + let n = self.next_stream.get(); + self.next_stream.set(n + 1); + let lane = Rc::new(crate::direct::FrameLane::new()); + let reason = Rc::new(Cell::new(protocol::web::closed::SIGNED_OUT)); + streams.insert(n, WebStream { key: grant.key.clone(), id: grant.id.clone(), lane: Rc::clone(&lane), reason: Rc::clone(&reason) }); + if of_browser == 0 { + let _ = self.inputs.send(Input::WebBrowserOnline { id: grant.id.clone(), by: grant.by.clone() }); + } + Some((n, lane, reason)) + } + + /// The stream `n` ended (either side). A browser whose last stream it + /// was gets nothing more until it opens one. + pub(crate) fn close_stream(&self, n: u64) { + let Some(stream) = self.streams.borrow_mut().remove(&n) else { return }; + let others = self.streams.borrow().values().any(|s| s.key == stream.key); + if !others { + let _ = self.inputs.send(Input::WebBrowserOffline { id: stream.id }); + } + } + + /// Close stream `n` from the page's side, with `reason`. + fn end_stream(&self, n: u64, reason: &'static str) { + if let Some(stream) = self.streams.borrow().get(&n) { + stream.reason.set(reason); + stream.lane.close(); + } + self.close_stream(n); + } + + /// Queue `message` (a `BridgeToPhone`, encoded) on each stream of the + /// browser `id`. A browser whose sign-in lapsed is ended instead; one + /// that stopped reading is closed as busy, never waited on — the phones' + /// links share this thread. + pub fn deliver(&self, id: &str, message: &str) { + let targets: Vec<(u64, String, Rc)> = + self.streams.borrow().iter().filter(|(_, s)| s.id == id).map(|(n, s)| (*n, s.key.clone(), Rc::clone(&s.lane))).collect(); + let Some((_, key, _)) = targets.first() else { return }; + if self.by_key(key).is_none() { + self.close_orphan_streams(); + return; + } + let frame = protocol::web::encode_web_frame(&protocol::web::WebFrame::Msg(message.to_string())); + for (n, _, lane) in targets { + if !lane.push(frame.clone()) { + log::info!("[Web] A browser stopped reading its stream; closing it"); + self.end_stream(n, protocol::web::closed::BUSY); + } + } + } + + /// Whether the browser `key` is still signed in: what each frame on its + /// stream is checked against, so a lapse or a sign-out ends the stream + /// at its next frame even when nothing was sent to it. + pub(crate) fn still_signed_in(&self, key: &str) -> bool { + matches!(self.by_key(key), Some((_, Browser { access: Access::SignedIn { .. }, .. }))) + } + + /// Answer a page request (its `body`, already verified) from browser + /// `by`'s stream: `{status, body}`, and a config write to make first + /// when it changes the config. + pub(crate) fn page_request(&self, body: &str, by: &str) -> (u16, String, Option) { + // Only for a browser whose identity is still paired: one restored + // from disk after its phone was unpaired must not reach the config + // before the engine has ended it. + if !self.is_paired(by) { + return (403, error_body(403), None); + } + let Ok(doc) = serde_json::from_str::(body) else { return (400, error_body(400), None) }; + match doc.get("type").and_then(Value::as_str) { + Some("devices") => (200, self.devices_json(), None), + Some("config") => (200, self.config_json(), None), + Some("config-set") => { + let set = serde_json::json!({ "set": doc.get("set").cloned().unwrap_or(Value::Null) }); + let mut response = self.apply_config(set.to_string().as_bytes(), by); + let write = response.config_write.take(); + (response.status, String::from_utf8(response.body).unwrap_or_default(), write) + } + _ => (400, error_body(400), None), + } + } +} + +fn error_body(status: u16) -> String { + serde_json::json!({ "error": reason(status) }).to_string() +} + +/// The fields of a request head the stream's gate reads. +fn parse_head(buf: &[u8]) -> Option { + let mut headers = [httparse::EMPTY_HEADER; 64]; + let mut parsed = httparse::Request::new(&mut headers); + if !matches!(parsed.parse(buf), Ok(httparse::Status::Complete(_))) { + return None; + } + let header = |name: &str| { + parsed.headers.iter().find(|h| h.name.eq_ignore_ascii_case(name)).and_then(|h| std::str::from_utf8(h.value).ok()).map(str::to_string) + }; + Some(Request { + method: parsed.method.unwrap_or("").to_string(), + path: parsed.path.unwrap_or("").split('?').next().unwrap_or("").to_string(), + host: header("host"), + origin: header("origin"), + cookie: header("cookie").and_then(|all| cookie_value(&all)), + user_agent: header("user-agent"), + body: Vec::new(), + }) +} + +/// The session cookie's value in a `Cookie` header. +fn cookie_value(all: &str) -> Option { + all.split(';').find_map(|pair| pair.trim().strip_prefix(&format!("{COOKIE}=")).map(str::to_string)) +} + +/// Whether the request head in `buf` asks for the browser's stream rather +/// than the direct link: a WebSocket upgrade of [`STREAM_PATH`]. +pub fn is_stream_request(buf: &[u8]) -> bool { + parse_head(buf).is_some_and(|r| r.path == STREAM_PATH) +} + +/// Where a browser opens its stream. +pub const STREAM_PATH: &str = "/api/stream"; + +/// Refuse a request with `status` and close the connection. +pub(crate) async fn refuse(stream: &mut S, status: u16) { + write_response(stream, Response::error(status)).await; +} + +/// Make a validated config write, off the bridge's thread: `{status, body}`. +pub(crate) async fn write_config_now(write: ConfigWrite) -> (u16, String) { + let response = write_config(write).await; + (response.status, String::from_utf8(response.body).unwrap_or_default()) +} + /// The signed-in browsers a previous run left in `path`, expired ones /// dropped. A missing or unreadable file is an empty set, with a warning: a /// page that will not start is worse than one whose browsers sign in again. -fn load_sessions(path: &Path) -> HashMap { - let now = now_ms(); +fn load_sessions(path: &Path, now: u64) -> HashMap { let raw = match std::fs::read_to_string(path) { Ok(raw) => raw, Err(e) if e.kind() == std::io::ErrorKind::NotFound => return HashMap::new(), @@ -589,14 +833,13 @@ fn load_sessions(path: &Path) -> HashMap { // A key is always 64 hex characters; anything else is not one this // page wrote, so it is dropped rather than trusted. let Ok(peer) = session.peer.parse::() else { continue }; - if session.expires_ms <= now || session.key.len() != 64 { + let Some(key) = BrowserKey::parse(&session.public_key) else { continue }; + let access = Access::SignedIn { by: session.by, since_ms: session.since_ms, expires_ms: session.expires_ms }; + let browser = Browser { access, key, peer, order, agent: session.agent, last_seen_ms: session.last_seen_ms }; + if browser.lapses_ms() <= now || session.key.len() != 64 { continue; } - let access = Access::SignedIn { by: session.by, since_ms: session.since_ms, expires_ms: session.expires_ms }; - browsers.insert( - session.key, - Browser { access, peer, order, agent: session.agent, last_seen_ms: session.last_seen_ms }, - ); + browsers.insert(session.key, browser); order += 1; } browsers @@ -808,7 +1051,7 @@ struct Response { } /// Config-file changes the page validated, still to be written. -struct ConfigWrite { +pub(crate) struct ConfigWrite { path: PathBuf, changes: Vec<(String, Option)>, /// Who asked, for the log line (an npub prefix). @@ -971,19 +1214,23 @@ fn route(request: &Request, peer: IpAddr, web: &Web) -> Response { return Response::error(403); } let browser = web.browser(request.cookie.as_deref()); + let now = web.now(); match (request.method.as_str(), request.path.as_str()) { ("GET", "/") => Response::new(200, "text/html; charset=utf-8", INDEX_HTML), ("GET", "/app.js") => Response::new(200, "text/javascript; charset=utf-8", APP_JS), ("GET", "/app.css") => Response::new(200, "text/css; charset=utf-8", APP_CSS), - ("GET", "/api/me") => Response::json(200, me_json(browser.as_ref().map(|(_, b)| b))), - ("POST", "/api/sign-in") => match web.start_sign_in(peer, &clean_agent(request.user_agent.as_deref())) { - Some((token, code)) => { - let mut response = Response::json(200, serde_json::json!({ "state": "pending", "code": code, "expiresInMs": PENDING_TTL_MS }).to_string()); - response.set_cookie = Some(session_cookie(&token, SESSION_TTL_MS / 1000)); - response + ("GET", "/api/me") => Response::json(200, me_json(browser.as_ref().map(|(_, b)| b), &web.machine_npub, now)), + ("POST", "/api/sign-in") => { + let Some(key) = sign_in_key(&request.body) else { return Response::error(400) }; + match web.start_sign_in(peer, &clean_agent(request.user_agent.as_deref()), key) { + Some((token, code)) => { + let mut response = Response::json(200, serde_json::json!({ "state": "pending", "code": code, "expiresInMs": PENDING_TTL_MS }).to_string()); + response.set_cookie = Some(session_cookie(&token, SESSION_TTL_MS / 1000)); + response + } + None => Response::error(429), } - None => Response::error(429), - }, + } ("GET", "/api/sign-in/qr.svg") => match browser { Some((_, Browser { access: Access::Pending { code, .. }, .. })) => { let url = format!("codedeck://web-sign-in?machine={}&code={code}", web.machine_npub); @@ -994,64 +1241,25 @@ fn route(request: &Request, peer: IpAddr, web: &Web) -> Response { } _ => Response::error(404), }, + // Ending its own sign-in is the one thing a cookie alone may do. ("POST", "/api/sign-out") => { if let Some((key, _)) = browser { web.sign_out(&key); } - let mut response = Response::json(200, me_json(None)); + let mut response = Response::json(200, me_json(None, &web.machine_npub, now)); response.set_cookie = Some(session_cookie("", 0)); response } - ("GET", "/api/status") => match &browser { - Some((_, Browser { access: Access::SignedIn { by, since_ms, .. }, .. })) => Response::json(200, web.status_json(by, *since_ms)), - _ => Response::error(401), - }, - ("GET", "/api/browsers") => match signed_in(&browser) { - Some((key, _)) => Response::json(200, web.browsers_json(Some(key))), - None => Response::error(401), - }, - ("POST", "/api/browsers/sign-out") => match signed_in(&browser) { - Some(_) => match sign_out_id(&request.body) { - Some(id) if web.revoke(&id) => Response::json(200, serde_json::json!({ "ok": true }).to_string()), - Some(_) => Response::error(404), - None => Response::error(400), - }, - None => Response::error(401), - }, - ("GET", "/api/devices") => match signed_in(&browser) { - Some(_) => Response::json(200, web.devices_json()), - None => Response::error(401), - }, - ("GET", "/api/config") => match signed_in(&browser) { - Some(_) => Response::json(200, web.config_json()), - None => Response::error(401), - }, - ("POST", "/api/config") => match signed_in(&browser) { - Some((_, by)) => web.apply_config(&request.body, by), - None => Response::error(401), - }, - ( - _, - "/" | "/app.js" | "/app.css" | "/api/me" | "/api/sign-in" | "/api/sign-in/qr.svg" | "/api/sign-out" | "/api/status" - | "/api/browsers" | "/api/browsers/sign-out" | "/api/devices" | "/api/config", - ) => Response::error(405), + (_, "/" | "/app.js" | "/app.css" | "/api/me" | "/api/sign-in" | "/api/sign-in/qr.svg" | "/api/sign-out") => Response::error(405), _ => Response::error(404), } } -/// The signed-in browser's key and approver, if it is signed in. -fn signed_in(browser: &Option<(String, Browser)>) -> Option<(&str, &str)> { - match browser { - Some((key, Browser { access: Access::SignedIn { by, .. }, .. })) => Some((key.as_str(), by.as_str())), - _ => None, - } -} - -/// The browser id a sign-out POST names, or `None` when the body is not a -/// JSON object with a string `id`. -fn sign_out_id(body: &[u8]) -> Option { +/// The browser's public key a sign-in start carries (`{"key": …}`), or +/// `None` when it carries none a browser could sign with. +fn sign_in_key(body: &[u8]) -> Option { let doc: Value = serde_json::from_slice(body).ok()?; - doc.get("id")?.as_str().map(str::to_string) + BrowserKey::parse(doc.get("key")?.as_str()?) } /// A 400 naming the setting at fault, so the page can point at it. @@ -1059,52 +1267,108 @@ fn bad_request(key: &str, message: &str) -> Response { Response::json(400, serde_json::json!({ "error": message, "key": key }).to_string()) } -fn me_json(browser: Option<&Browser>) -> String { - let now = now_ms(); - match browser.map(|b| &b.access) { - Some(Access::Pending { code, expires_ms }) => { - serde_json::json!({ "state": "pending", "code": code, "expiresInMs": expires_ms.saturating_sub(now) }) - } - Some(Access::SignedIn { by, since_ms, .. }) => { - serde_json::json!({ "state": "signed-in", "by": by, "since": since_ms }) - } - None => serde_json::json!({ "state": "signed-out" }), +/// What `GET /api/me` answers: where the browser stands, and what it needs +/// to sign on its stream — the machine and its own id. +fn me_json(browser: Option<&Browser>, machine: &str, now: u64) -> String { + match browser { + Some(Browser { access: Access::Pending { code, expires_ms }, key, .. }) => serde_json::json!({ + "state": "pending", "code": code, "expiresInMs": expires_ms.saturating_sub(now), "machine": machine, "id": key.id(), + }), + Some(browser @ Browser { access: Access::SignedIn { by, since_ms, .. }, key, .. }) => serde_json::json!({ + "state": "signed-in", "by": by, "since": since_ms, "lapses": browser.lapses_ms(), "machine": machine, "id": key.id(), + }), + None => serde_json::json!({ "state": "signed-out", "machine": machine }), } .to_string() } #[cfg(test)] -mod tests { +pub(crate) mod tests { use super::*; + use p256::ecdsa::signature::Signer as _; + use p256::ecdsa::{Signature, SigningKey}; + + /// A browser's key pair, as WebCrypto makes one: the signing half stays + /// with the test (the browser), the public half is what the page sends. + pub(crate) struct TestKey { + signing: SigningKey, + pub public: BrowserKey, + } + + impl TestKey { + pub(crate) fn new(seed: u8) -> Self { + let signing = SigningKey::from_bytes(&[seed.max(1); 32].into()).expect("a scalar"); + let raw = signing.verifying_key().to_encoded_point(false); + let public = BrowserKey::parse(&base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(raw.as_bytes())).unwrap(); + Self { signing, public } + } + + pub(crate) fn base64url(&self) -> String { + self.public.to_base64url() + } - /// A page over `home`, with no config view. - fn web_in(home: &Path) -> (Rc, mpsc::UnboundedReceiver) { - web_with_config(home, Vec::new()) + /// Sign `input` as WebCrypto does: `r‖s`, base64url. + pub(crate) fn sign(&self, input: &[u8]) -> String { + let sig: Signature = self.signing.sign(input); + base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(sig.to_bytes()) + } + } + + /// A clock the test moves. + pub(crate) fn clock() -> (Rc>, Box u64>) { + let now = Rc::new(Cell::new(1_800_000_000_000u64)); + let read = Rc::clone(&now); + (now, Box::new(move || read.get())) } - /// A page over `home`, its config API showing `fields`. - fn web_with_config(home: &Path, fields: Vec) -> (Rc, mpsc::UnboundedReceiver) { + /// A page over `home` on the clock `now`, its config view showing `fields`. + pub(crate) fn page(home: &Path, fields: Vec, now: Box u64>) -> (Rc, mpsc::UnboundedReceiver) { let (tx, rx) = mpsc::unbounded_channel(); let config = ConfigView { path: home.join("config.json"), fields }; - (Web::new("npub1machine".into(), &["wss://box.tail1234.ts.net:7447".into()], tx, home, config), rx) + let web = Web::with_clock("npub1machine".into(), &["wss://box.tail1234.ts.net:7447".into()], tx, home, config, now); + // The identity the tests sign browsers in with is paired, as the + // heartbeat tells the page. + web.set_devices(&[phone("npub1owner")]); + (web, rx) + } + + /// A paired identity, as the heartbeat hands it to the page. + fn phone(npub: &str) -> bridge_core::PairedPhone { + bridge_core::PairedPhone { + npub: npub.into(), + pubkey_hex: "ab".repeat(32), + label: "Pixel".into(), + paired_at: "2026-01-02T03:04:05Z".into(), + clients: Vec::new(), + } } /// A page over a fresh temp dir, which the caller must keep alive. fn web() -> (Rc, mpsc::UnboundedReceiver, tempfile::TempDir) { let dir = tempfile::tempdir().unwrap(); - let (web, rx) = web_in(dir.path()); + let (web, rx) = page(dir.path(), Vec::new(), Box::new(now_ms)); (web, rx, dir) } - /// Start a sign-in at [`PEER`] and have the owner approve it, returning - /// the browser's cookie token. - fn sign_in(web: &Web, inputs: &mut mpsc::UnboundedReceiver) -> String { - let (token, _) = web.start_sign_in(PEER, "Mozilla/5.0").expect("a start"); - let Some(Input::WebSignInPending { code, .. }) = inputs.try_recv().ok() else { panic!("the engine is told the code") }; + /// Start a sign-in at [`PEER`] with `key` and have the owner approve it, + /// returning the browser's cookie token. + pub(crate) fn sign_in_with(web: &Web, inputs: &mut mpsc::UnboundedReceiver, key: &TestKey) -> String { + let (token, _) = web.start_sign_in(PEER, "Mozilla/5.0", key.public.clone()).expect("a start"); + let code = loop { + match inputs.try_recv() { + Ok(Input::WebSignInPending { code, .. }) => break code, + Ok(_) => continue, + Err(_) => panic!("the engine is told the code"), + } + }; web.signed_in(&code, "npub1owner"); token } + fn sign_in(web: &Web, inputs: &mut mpsc::UnboundedReceiver) -> String { + sign_in_with(web, inputs, &TestKey::new(7)) + } + fn request(method: &str, path: &str, host: &str) -> Request { Request { method: method.into(), @@ -1117,8 +1381,19 @@ mod tests { } } - const PEER: IpAddr = IpAddr::V4(std::net::Ipv4Addr::new(192, 168, 1, 20)); - const HOST: &str = "192.168.1.5:7447"; + /// The head of a stream request, as a browser on the page sends it. + pub(crate) fn stream_head(origin: &str, cookie: Option<&str>) -> Vec { + let cookie = cookie.map(|c| format!("Cookie: {COOKIE}={c}\r\n")).unwrap_or_default(); + format!( + "GET {STREAM_PATH} HTTP/1.1\r\nHost: {HOST}\r\nOrigin: {origin}\r\nUpgrade: websocket\r\nConnection: Upgrade\r\n\ + Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nSec-WebSocket-Version: 13\r\n{cookie}\r\n" + ) + .into_bytes() + } + + pub(crate) const PEER: IpAddr = IpAddr::V4(std::net::Ipv4Addr::new(192, 168, 1, 20)); + pub(crate) const HOST: &str = "192.168.1.5:7447"; + const DAY: u64 = 24 * 3600 * 1000; #[test] fn only_addresses_localhost_and_the_endpoints_hosts_are_served() { @@ -1134,7 +1409,8 @@ mod tests { #[test] fn a_post_from_another_origin_is_refused() { let (web, _, _dir) = web(); - let mut post = request("POST", "/api/sign-in", "192.168.1.5:7447"); + let mut post = request("POST", "/api/sign-in", HOST); + post.body = serde_json::json!({ "key": TestKey::new(1).base64url() }).to_string().into_bytes(); post.origin = Some("https://evil.example".into()); assert_eq!(route(&post, PEER, &web).status, 403); post.origin = None; @@ -1142,41 +1418,147 @@ mod tests { } #[test] - fn the_status_needs_a_signed_in_browser() { + fn a_sign_in_start_needs_a_key_a_browser_can_sign_with() { + let (web, _, _dir) = web(); + let mut post = request("POST", "/api/sign-in", HOST); + assert_eq!(route(&post, PEER, &web).status, 400, "no key"); + post.body = br#"{"key":"AAAA"}"#.to_vec(); + assert_eq!(route(&post, PEER, &web).status, 400, "not a point"); + post.body = serde_json::json!({ "key": TestKey::new(1).base64url() }).to_string().into_bytes(); + let started = route(&post, PEER, &web); + assert_eq!(started.status, 200); + let cookie = started.set_cookie.unwrap(); + assert!(cookie.contains("Secure") && cookie.contains("HttpOnly") && cookie.contains("SameSite=Strict")); + } + + #[test] + fn a_cookie_alone_reaches_nothing_but_its_own_sign_in() { + let (web, mut inputs, _dir) = web(); + let token = sign_in(&web, &mut inputs); + let mut me = request("GET", "/api/me", HOST); + me.cookie = Some(token.clone()); + let body: Value = serde_json::from_slice(&route(&me, PEER, &web).body).unwrap(); + assert_eq!(body["state"], "signed-in"); + assert_eq!(body["machine"], "npub1machine"); + assert_eq!(body["id"], TestKey::new(7).public.id()); + for (method, path) in [ + ("GET", "/api/status"), + ("GET", "/api/browsers"), + ("POST", "/api/browsers/sign-out"), + ("GET", "/api/devices"), + ("GET", "/api/config"), + ("POST", "/api/config"), + ] { + let mut req = request(method, path, HOST); + req.cookie = Some(token.clone()); + assert_eq!(route(&req, PEER, &web).status, 404, "{method} {path} answers only on the signed stream"); + } + } + + #[test] + fn only_a_signature_keeps_a_browser_signed_in_for_seven_idle_days() { + let dir = tempfile::tempdir().unwrap(); + let (now, clock) = clock(); + let (web, mut inputs) = page(dir.path(), Vec::new(), clock); + let token = sign_in(&web, &mut inputs); + let key = token_key(&token); + let mut me = request("GET", "/api/me", HOST); + me.cookie = Some(token); + + // Six days of a cookie being shown, and nothing signed. + for _ in 0..6 { + now.set(now.get() + DAY); + route(&me, PEER, &web); + } + now.set(now.get() + DAY - 1); + assert!(web.still_signed_in(&key), "one ms short of seven days"); + now.set(now.get() + 1); + assert!(!web.still_signed_in(&key), "the cookie did not keep it alive"); + } + + #[test] + fn a_browser_in_use_still_lapses_after_thirty_days() { + let dir = tempfile::tempdir().unwrap(); + let (now, clock) = clock(); + let (web, mut inputs) = page(dir.path(), Vec::new(), clock); + let key = token_key(&sign_in(&web, &mut inputs)); + for _ in 0..29 { + now.set(now.get() + DAY); + assert!(web.still_signed_in(&key)); + web.seen(&key); + } + let row = &web.browsers()[0]; + assert_eq!(row.expires_ms, row.since_ms + SESSION_TTL_MS, "the list shows when it actually lapses"); + now.set(now.get() + DAY); + assert!(!web.still_signed_in(&key)); + assert!(web.browsers().is_empty()); + } + + #[test] + fn the_list_shows_the_idle_lapse_when_it_comes_first() { let (web, mut inputs, _dir) = web(); - let host = "192.168.1.5:7447"; - assert_eq!(route(&request("GET", "/api/status", host), PEER, &web).status, 401); + sign_in(&web, &mut inputs); + let row = &web.browsers()[0]; + assert_eq!(row.expires_ms, row.last_seen_ms + IDLE_TTL_MS); + } - let started = route(&request("POST", "/api/sign-in", host), PEER, &web); - let cookie = started.set_cookie.clone().unwrap(); - assert!(cookie.contains("Secure") && cookie.contains("HttpOnly") && cookie.contains("SameSite=Strict")); - let token = cookie.split(';').next().unwrap().strip_prefix(&format!("{COOKIE}=")).unwrap().to_string(); - let Some(Input::WebSignInPending { code, .. }) = inputs.try_recv().ok() else { panic!("the engine is told the code") }; + #[test] + fn the_stream_is_let_through_only_from_the_page_with_a_signed_in_cookie() { + let (web, mut inputs, _dir) = web(); + let key = TestKey::new(7); + let token = sign_in_with(&web, &mut inputs, &key); + let origin = format!("https://{HOST}"); + let grant = web.stream_grant(&stream_head(&origin, Some(&token))).expect("let through"); + assert_eq!(grant.id, key.public.id()); + assert_eq!(grant.by, "npub1owner"); + assert_eq!(web.stream_grant(&stream_head("https://evil.example", Some(&token))).err(), Some(403), "another origin"); + assert_eq!(web.stream_grant(&stream_head(&origin, None)).err(), Some(401), "no cookie"); + assert_eq!(web.stream_grant(&stream_head(&origin, Some("forged"))).err(), Some(401), "a cookie the page never set"); - let mut status = request("GET", "/api/status", host); - status.cookie = Some(token.clone()); - assert_eq!(route(&status, PEER, &web).status, 401, "a pending browser sees no status"); + let (pending, _) = web.start_sign_in(PEER, "", TestKey::new(9).public).unwrap(); + assert_eq!(web.stream_grant(&stream_head(&origin, Some(&pending))).err(), Some(401), "a browser still waiting for its phone"); + } - web.signed_in(&code, "npub1owner"); - assert_eq!(route(&status, PEER, &web).status, 200); + #[test] + fn streams_are_capped_per_browser_and_the_first_and_last_say_so() { + let (web, mut inputs, _dir) = web(); + let token = sign_in(&web, &mut inputs); + while inputs.try_recv().is_ok() {} + let grant = web.stream_grant(&stream_head(&format!("https://{HOST}"), Some(&token))).expect("let through"); + let opened: Vec = (0..MAX_STREAMS_PER_BROWSER).map(|_| web.open_stream(&grant).expect("room").0).collect(); + assert!(web.open_stream(&grant).is_none(), "one tab too many"); + let online: Vec = std::iter::from_fn(|| inputs.try_recv().ok()).collect(); + assert!(matches!(online.as_slice(), [Input::WebBrowserOnline { .. }]), "online once: {online:?}"); + for n in &opened { + web.close_stream(*n); + } + let offline: Vec = std::iter::from_fn(|| inputs.try_recv().ok()).collect(); + assert!(matches!(offline.as_slice(), [Input::WebBrowserOffline { .. }]), "offline once: {offline:?}"); + } - let mut out = request("POST", "/api/sign-out", host); - out.cookie = Some(token); - route(&out, PEER, &web); - assert_eq!(route(&status, PEER, &web).status, 401, "signed out"); + #[test] + fn signing_out_closes_the_browsers_streams() { + let (web, mut inputs, _dir) = web(); + let token = sign_in(&web, &mut inputs); + let grant = web.stream_grant(&stream_head(&format!("https://{HOST}"), Some(&token))).expect("let through"); + let (_, lane, reason) = web.open_stream(&grant).unwrap(); + assert!(web.revoke(&grant.id)); + assert!(lane.is_closed()); + assert_eq!(reason.get(), protocol::web::closed::SIGNED_OUT); } #[test] fn an_ipv6_host_is_rate_limited_by_its_slash_64() { let (web, _, _dir) = web(); + let key = || TestKey::new(3).public; for i in 0..STARTS_PER_MINUTE { let peer = IpAddr::V6(std::net::Ipv6Addr::new(0x2001, 0xdb8, 1, 2, 0, 0, 0, i as u16 + 1)); - assert!(web.start_sign_in(peer, "").is_some()); + assert!(web.start_sign_in(peer, "", key()).is_some()); } let same_64 = IpAddr::V6(std::net::Ipv6Addr::new(0x2001, 0xdb8, 1, 2, 9, 9, 9, 9)); - assert!(web.start_sign_in(same_64, "").is_none(), "another address in the same /64 counts as the same host"); + assert!(web.start_sign_in(same_64, "", key()).is_none(), "another address in the same /64 counts as the same host"); let other_64 = IpAddr::V6(std::net::Ipv6Addr::new(0x2001, 0xdb8, 1, 3, 0, 0, 0, 1)); - assert!(web.start_sign_in(other_64, "").is_some()); + assert!(web.start_sign_in(other_64, "", key()).is_some()); } #[test] @@ -1186,7 +1568,7 @@ mod tests { for i in 0..=MAX_PENDING { // A peer of its own each, so the rate limit does not interfere. let peer = IpAddr::V4(std::net::Ipv4Addr::new(10, 0, (i / 250) as u8, (i % 250) as u8 + 1)); - let (token, code) = web.start_sign_in(peer, "").expect("a start"); + let (token, code) = web.start_sign_in(peer, "", TestKey::new(3).public).expect("a start"); first.get_or_insert((token, code)); } let (first_token, first_code) = first.unwrap(); @@ -1199,7 +1581,7 @@ mod tests { assert_eq!(withdrawn, vec![first_code], "the oldest pending browser made room, and its code went with it"); assert!(web.browser(Some(&first_token)).is_none()); - let (token, code) = web.start_sign_in(IpAddr::V4(std::net::Ipv4Addr::new(10, 9, 9, 9)), "").unwrap(); + let (token, code) = web.start_sign_in(IpAddr::V4(std::net::Ipv4Addr::new(10, 9, 9, 9)), "", TestKey::new(3).public).unwrap(); while inputs.try_recv().is_ok() {} web.sign_out(&token_key(&token)); assert!(matches!(inputs.try_recv(), Ok(Input::WebSignInWithdrawn { code: c }) if c == code)); @@ -1211,7 +1593,7 @@ mod tests { let mut tokens = Vec::new(); for i in 0..=MAX_SESSIONS { let peer = IpAddr::V4(std::net::Ipv4Addr::new(10, 1, (i / 250) as u8, (i % 250) as u8 + 1)); - let (token, code) = web.start_sign_in(peer, "").unwrap(); + let (token, code) = web.start_sign_in(peer, "", TestKey::new(3).public).unwrap(); web.signed_in(&code, "npub1owner"); tokens.push(token); } @@ -1225,17 +1607,17 @@ mod tests { fn sign_in_starts_are_rate_limited_per_address() { let (web, _, _dir) = web(); for _ in 0..STARTS_PER_MINUTE { - assert!(web.start_sign_in(PEER, "").is_some()); + assert!(web.start_sign_in(PEER, "", TestKey::new(3).public).is_some()); } - assert!(web.start_sign_in(PEER, "").is_none()); - assert!(web.start_sign_in(IpAddr::V4(std::net::Ipv4Addr::new(192, 168, 1, 21)), "").is_some()); + assert!(web.start_sign_in(PEER, "", TestKey::new(3).public).is_none()); + assert!(web.start_sign_in(IpAddr::V4(std::net::Ipv4Addr::new(192, 168, 1, 21)), "", TestKey::new(3).public).is_some()); } #[test] fn pending_sign_ins_are_capped() { let (web, _, _dir) = web(); for i in 0..(MAX_PENDING as u8 + 10) { - web.start_sign_in(IpAddr::V4(std::net::Ipv4Addr::new(10, 0, 0, i)), "").unwrap(); + web.start_sign_in(IpAddr::V4(std::net::Ipv4Addr::new(10, 0, 0, i)), "", TestKey::new(3).public).unwrap(); } assert!(web.browsers.borrow().len() <= MAX_PENDING); } @@ -1252,22 +1634,24 @@ mod tests { assert!(is_websocket(b"GET / HTTP/1.1\r\nHost: x\r\nUpgrade: websocket\r\nConnection: Upgrade\r\n\r\n")); assert!(!is_websocket(b"GET / HTTP/1.1\r\nHost: x\r\n\r\n")); assert_eq!(head_len(b"GET / HTTP/1.1\r\n\r\nbody"), Some(18)); + assert!(is_stream_request(&stream_head("https://x", None)), "the browser's stream"); + assert!(!is_stream_request(b"GET / HTTP/1.1\r\nHost: x\r\nUpgrade: websocket\r\n\r\n"), "a phone's direct link"); } #[test] fn signed_in_browsers_survive_a_restart() { let dir = tempfile::tempdir().unwrap(); - let (web, mut inputs) = web_in(dir.path()); - let token = sign_in(&web, &mut inputs); + let (web, mut inputs) = page(dir.path(), Vec::new(), Box::new(now_ms)); + let key = TestKey::new(7); + let token = sign_in_with(&web, &mut inputs, &key); web.writer.flush(); // A new page over the same home, as after a restart. - let (again, _rx) = web_in(dir.path()); - let mut status = request("GET", "/api/status", HOST); - status.cookie = Some(token.clone()); - assert_eq!(route(&status, PEER, &again).status, 200, "the cookie still works"); + let (again, _rx) = page(dir.path(), Vec::new(), Box::new(now_ms)); + let grant = again.stream_grant(&stream_head(&format!("https://{HOST}"), Some(&token))).expect("the cookie still works"); + assert_eq!(grant.browser_key, key.public, "and so does the key it signed in with"); - // The file holds the key's SHA-256, never the token itself. + // The file holds the cookie's SHA-256, never the token itself. let raw = std::fs::read_to_string(dir.path().join("web-sessions.json")).unwrap(); assert!(!raw.contains(&token), "no token is written"); assert!(raw.contains(&token_key(&token)), "the key's hash is"); @@ -1275,70 +1659,45 @@ mod tests { } #[test] - fn an_expired_or_corrupt_sessions_file_starts_empty() { + fn an_expired_keyless_or_corrupt_sessions_file_starts_empty() { let dir = tempfile::tempdir().unwrap(); let path = dir.path().join("web-sessions.json"); - let expired = serde_json::json!([{ - "key": "a".repeat(64), "by": "npub1x", "sinceMs": 1, "expiresMs": 2, "lastSeenMs": 1, - "peer": "192.168.1.5", "agent": "x", - }]); - std::fs::write(&path, expired.to_string()).unwrap(); - assert!(web_in(dir.path()).0.browsers.borrow().is_empty(), "an expired one is dropped"); - - std::fs::write(&path, "{not json").unwrap(); - assert!(web_in(dir.path()).0.browsers.borrow().is_empty(), "a corrupt file is empty, not fatal"); - } - - #[test] - fn the_browsers_api_lists_browsers_and_marks_the_current_one() { - let (web, mut inputs, _dir) = web(); - let first = sign_in(&web, &mut inputs); - let (second, _) = web.start_sign_in(PEER, "curl/8").unwrap(); - let Some(Input::WebSignInPending { code, .. }) = inputs.try_recv().ok() else { panic!("the engine is told the code") }; - web.signed_in(&code, "npub1owner"); - - let mut get = request("GET", "/api/browsers", HOST); - get.cookie = Some(first.clone()); - let response = route(&get, PEER, &web); - assert_eq!(response.status, 200); - let body: Value = serde_json::from_slice(&response.body).unwrap(); - let rows = body["browsers"].as_array().unwrap(); - assert_eq!(rows.len(), 2); - assert_eq!(rows[0]["id"], &token_key(&first)[..ID_LEN]); - assert_eq!(rows[0]["current"], true); - assert_eq!(rows[1]["current"], false); - assert_eq!(rows[1]["agent"], "curl/8"); - assert_eq!(rows[0]["peer"], "192.168.1.20"); - for field in ["sinceMs", "lastSeenMs", "expiresMs"] { - assert!(rows[0][field].is_number(), "{field}"); - } - assert_eq!(rows[0]["by"], "npub1owner"); - assert!(serde_json::from_slice::(&response.body).unwrap().get("token").is_none()); - assert!(second.len() > ID_LEN, "the full token is not what the page sees"); + let record = |public_key: Option, expires: u64| { + let mut r = serde_json::json!({ + "key": "a".repeat(64), "by": "npub1x", "sinceMs": 1, "expiresMs": expires, "lastSeenMs": now_ms(), + "peer": "192.168.1.5", "agent": "x", + }); + if let Some(k) = public_key { + r["publicKey"] = Value::String(k); + } + serde_json::json!([r]) + }; + let empty = |raw: String| { + std::fs::write(&path, raw).unwrap(); + page(dir.path(), Vec::new(), Box::new(now_ms)).0.browsers.borrow().is_empty() + }; + assert!(empty(record(Some(TestKey::new(1).base64url()), 2).to_string()), "an expired one is dropped"); + assert!(empty(record(None, u64::MAX).to_string()), "one from before browser keys signs in again"); + assert!(!empty(record(Some(TestKey::new(1).base64url()), u64::MAX).to_string()), "a good one is kept"); + assert!(empty("{not json".into()), "a corrupt file is empty, not fatal"); } #[test] - fn the_phone_list_is_the_page_list_without_the_current_mark() { + fn the_phone_list_names_each_browser_by_its_keys_id() { let (web, mut inputs, _dir) = web(); - let first = sign_in(&web, &mut inputs); - let (_second, _) = web.start_sign_in(PEER, "curl/8").unwrap(); - let Some(Input::WebSignInPending { code, .. }) = inputs.try_recv().ok() else { panic!("the engine is told the code") }; + let first = TestKey::new(7); + sign_in_with(&web, &mut inputs, &first); + let (_second, _) = web.start_sign_in(PEER, "curl/8", TestKey::new(8).public).unwrap(); + let code = loop { + if let Ok(Input::WebSignInPending { code, .. }) = inputs.try_recv() { + break code; + } + }; web.signed_in(&code, "npub1owner"); - let mut get = request("GET", "/api/browsers", HOST); - get.cookie = Some(first.clone()); - let body: Value = serde_json::from_slice(&route(&get, PEER, &web).body).unwrap(); - let json_ids: Vec = body["browsers"] - .as_array() - .unwrap() - .iter() - .map(|row| row["id"].as_str().unwrap().to_string()) - .collect(); - - // The phone's list and the page's are one list: same rows, same order. let phone = web.browsers(); - assert_eq!(phone.iter().map(|b| b.id.clone()).collect::>(), json_ids); - assert_eq!(phone[0].id, &token_key(&first)[..ID_LEN], "the id is the key's short public form, never the token"); + assert_eq!(phone.len(), 2); + assert_eq!(phone[0].id, first.public.id(), "the id is the key's, never the token's"); assert_eq!(phone[0].by, "npub1owner"); assert_eq!(phone[0].peer, "192.168.1.20"); assert_eq!(phone[1].agent, "curl/8"); @@ -1348,29 +1707,54 @@ mod tests { } #[test] - fn revoking_another_browser_ends_its_cookie() { + fn revoking_a_browser_ends_its_cookie() { let (web, mut inputs, _dir) = web(); - let victim = sign_in(&web, &mut inputs); - let owner = sign_in(&web, &mut inputs); - - let mut status = request("GET", "/api/status", HOST); - status.cookie = Some(victim.clone()); - assert_eq!(route(&status, PEER, &web).status, 200); + let victim = TestKey::new(7); + let token = sign_in_with(&web, &mut inputs, &victim); + assert!(web.still_signed_in(&token_key(&token))); + assert!(web.revoke(&victim.public.id())); + assert!(!web.still_signed_in(&token_key(&token)), "the revoked browser's cookie no longer works"); + assert!(!web.revoke("0123456789abcdef"), "an unknown id"); + } - let mut post = request("POST", "/api/browsers/sign-out", HOST); - post.cookie = Some(owner); - post.body = serde_json::json!({ "id": &token_key(&victim)[..ID_LEN] }).to_string().into_bytes(); - assert_eq!(route(&post, PEER, &web).status, 200); - assert_eq!(route(&status, PEER, &web).status, 401, "the revoked browser's cookie no longer works"); + #[test] + fn a_browser_whose_identity_is_no_longer_paired_reaches_nothing() { + let (web, mut inputs, _dir) = web(); + let token = sign_in(&web, &mut inputs); + // Unpaired while the bridge was down: the record survived on disk, + // the heartbeat no longer lists its identity. + web.set_devices(&[phone("npub1someoneelse")]); + assert_eq!(web.page_request(r#"{"type":"config"}"#, "npub1owner").0, 403); + assert_eq!(web.stream_grant(&stream_head(&format!("https://{HOST}"), Some(&token))).err(), Some(401)); + } - post.body = serde_json::json!({ "id": "0123456789abcdef" }).to_string().into_bytes(); - assert_eq!(route(&post, PEER, &web).status, 404, "an unknown id"); + #[test] + fn a_browser_dropped_to_make_room_loses_its_streams() { + let (web, mut inputs, _dir) = web(); + let token = sign_in(&web, &mut inputs); + let grant = web.stream_grant(&stream_head(&format!("https://{HOST}"), Some(&token))).expect("let through"); + let (_, lane, _) = web.open_stream(&grant).unwrap(); + for i in 0..MAX_SESSIONS { + let peer = IpAddr::V4(std::net::Ipv4Addr::new(10, 2, (i / 250) as u8, (i % 250) as u8 + 1)); + let (_, code) = web.start_sign_in(peer, "", TestKey::new(3).public).unwrap(); + web.signed_in(&code, "npub1owner"); + } + assert!(lane.is_closed(), "the oldest browser went, and its stream with it"); } #[test] - fn the_devices_api_shows_paired_phones_without_any_secret() { + fn unpairing_its_identity_ends_a_browser() { let (web, mut inputs, _dir) = web(); let token = sign_in(&web, &mut inputs); + web.end_by("npub1someoneelse"); + assert!(web.still_signed_in(&token_key(&token))); + web.end_by("npub1owner"); + assert!(!web.still_signed_in(&token_key(&token))); + } + + #[test] + fn the_devices_request_shows_paired_phones_without_any_secret() { + let (web, _, _dir) = web(); let phone = bridge_core::PairedPhone { npub: "npub1phone".into(), pubkey_hex: "ab".repeat(32), @@ -1395,11 +1779,9 @@ mod tests { }; web.set_devices(&[phone]); - let mut get = request("GET", "/api/devices", HOST); - get.cookie = Some(token); - let response = route(&get, PEER, &web); - assert_eq!(response.status, 200); - let body = String::from_utf8(response.body).unwrap(); + let (status, body, write) = web.page_request(r#"{"type":"devices"}"#, "npub1phone"); + assert_eq!(status, 200); + assert!(write.is_none()); let json: Value = serde_json::from_str(&body).unwrap(); assert_eq!(json["devices"][0]["npub"], "npub1phone"); assert_eq!(json["devices"][0]["label"], "Pixel"); @@ -1411,80 +1793,59 @@ mod tests { } #[test] - fn the_config_api_serves_every_field_with_its_value() { + fn the_config_request_serves_every_field_with_its_value() { let dir = tempfile::tempdir().unwrap(); - let fields = vec![ - serde_json::json!({ "key": "machineName", "value": "desktop", "editable": true, "overridden": false }), - ]; - let (web, mut inputs) = web_with_config(dir.path(), fields); - let token = sign_in(&web, &mut inputs); - - let mut get = request("GET", "/api/config", HOST); - get.cookie = Some(token); - let response = route(&get, PEER, &web); - assert_eq!(response.status, 200); - let json: Value = serde_json::from_slice(&response.body).unwrap(); - let fields = json["fields"].as_array().unwrap(); - assert!(fields.iter().any(|f| f["key"] == "machineName" && f["value"] == "desktop")); + let fields = vec![serde_json::json!({ "key": "machineName", "value": "desktop", "editable": true, "overridden": false })]; + let (web, _) = page(dir.path(), fields, Box::new(now_ms)); + let (status, body, _) = web.page_request(r#"{"type":"config"}"#, "npub1owner"); + assert_eq!(status, 200); + let json: Value = serde_json::from_str(&body).unwrap(); + assert!(json["fields"].as_array().unwrap().iter().any(|f| f["key"] == "machineName" && f["value"] == "desktop")); } #[test] - fn a_config_post_outside_the_safe_set_is_refused_and_leaves_the_file() { + fn a_config_set_outside_the_safe_set_is_refused_and_leaves_the_file() { let dir = tempfile::tempdir().unwrap(); let path = dir.path().join("config.json"); let before = r#"{"machineName":"desktop","workspaceRoots":["/srv/w"],"keepMe":42}"#; std::fs::write(&path, before).unwrap(); - let (web, mut inputs) = web_with_config(dir.path(), Vec::new()); - let token = sign_in(&web, &mut inputs); - - let mut post = request("POST", "/api/config", HOST); - post.cookie = Some(token); - post.body = serde_json::json!({ "set": { "nodePath": "/evil" } }).to_string().into_bytes(); - let response = route(&post, PEER, &web); - assert_eq!(response.status, 400); - assert_eq!(serde_json::from_slice::(&response.body).unwrap()["key"], "nodePath"); + let (web, _) = page(dir.path(), Vec::new(), Box::new(now_ms)); + let (status, body, write) = web.page_request(r#"{"type":"config-set","set":{"nodePath":"/evil"}}"#, "npub1owner"); + assert_eq!(status, 400); + assert!(write.is_none()); + assert_eq!(serde_json::from_str::(&body).unwrap()["key"], "nodePath"); assert_eq!(std::fs::read_to_string(&path).unwrap(), before, "the file is untouched"); } #[test] fn an_endpoint_the_bridge_has_no_listener_for_is_refused() { let dir = tempfile::tempdir().unwrap(); - let path = dir.path().join("config.json"); - std::fs::write(&path, "{}").unwrap(); - let (web, mut inputs) = web_with_config(dir.path(), Vec::new()); - let mut post = request("POST", "/api/config", HOST); - post.cookie = Some(sign_in(&web, &mut inputs)); - post.body = serde_json::json!({ "set": { "direct.endpoints": ["ws://abc.onion:7448"] } }).to_string().into_bytes(); - let response = route(&post, PEER, &web); - assert_eq!(response.status, 400, "the bridge would refuse to start from it"); - assert_eq!(std::fs::read_to_string(&path).unwrap(), "{}"); + std::fs::write(dir.path().join("config.json"), "{}").unwrap(); + let (web, _) = page(dir.path(), Vec::new(), Box::new(now_ms)); + let (status, _, write) = web.page_request(r#"{"type":"config-set","set":{"direct.endpoints":["ws://abc.onion:7448"]}}"#, "npub1owner"); + assert_eq!(status, 400, "the bridge would refuse to start from it"); + assert!(write.is_none()); } #[test] - fn a_config_post_writes_the_file_keeping_every_other_key() { + fn a_config_set_writes_the_file_keeping_every_other_key() { let dir = tempfile::tempdir().unwrap(); let path = dir.path().join("config.json"); std::fs::write(&path, r#"{"machineName":"desktop","direct":{"listen":"0.0.0.0:7447"},"keepMe":{"x":1}}"#).unwrap(); // The bridge runs the direct listener, so a wss:// endpoint is one it can serve. let listening = serde_json::json!({ "key": "direct.listen", "value": "0.0.0.0:7447", "editable": false, "overridden": false }); - let (web, mut inputs) = web_with_config(dir.path(), vec![listening]); - let token = sign_in(&web, &mut inputs); - - let mut post = request("POST", "/api/config", HOST); - post.cookie = Some(token); - post.body = serde_json::json!({ + let (web, _) = page(dir.path(), vec![listening], Box::new(now_ms)); + let request = serde_json::json!({ + "type": "config-set", "set": { "machineName": "laptop", "relays": ["wss://relay.example"], "direct.endpoints": ["wss://192.168.1.9:7447"] }, - }) - .to_string() - .into_bytes(); - let mut response = route(&post, PEER, &web); - assert_eq!(response.status, 200); - // The write runs on the blocking pool in `serve`; here, in place. - let write = response.config_write.take().expect("a write to do"); - crate::config::write_web_settings(&write.path, &write.changes).unwrap(); - let json: Value = serde_json::from_slice(&response.body).unwrap(); - assert_eq!(json["ok"], true); + }); + let (status, body, write) = web.page_request(&request.to_string(), "npub1owner"); + assert_eq!(status, 200); + let json: Value = serde_json::from_str(&body).unwrap(); assert_eq!(json["restartNeeded"], true); + // The stream makes the write on the blocking pool; here, in place. + let write = write.expect("a write to do"); + crate::config::write_web_settings(&write.path, &write.changes).unwrap(); let written: Value = serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap(); assert_eq!(written["machineName"], "laptop"); @@ -1495,36 +1856,18 @@ mod tests { } #[test] - fn a_config_post_with_a_bad_value_is_refused() { + fn a_config_set_with_a_bad_value_is_refused() { let dir = tempfile::tempdir().unwrap(); std::fs::write(dir.path().join("config.json"), "{}").unwrap(); - let (web, mut inputs) = web_with_config(dir.path(), Vec::new()); - let token = sign_in(&web, &mut inputs); - + let (web, _) = page(dir.path(), Vec::new(), Box::new(now_ms)); for (key, value) in [ ("machineName", serde_json::json!("")), ("relays", serde_json::json!(["ws://192.168.1.9:7447"])), ("direct.endpoints", serde_json::json!(["https://x"])), ("transcriptKeepLast", serde_json::json!(-1)), ] { - let mut post = request("POST", "/api/config", HOST); - post.cookie = Some(token.clone()); - post.body = serde_json::json!({ "set": { key: value } }).to_string().into_bytes(); - assert_eq!(route(&post, PEER, &web).status, 400, "{key}"); - } - } - - #[test] - fn every_new_api_needs_a_signed_in_browser() { - let (web, _rx, _dir) = web(); - for (method, path) in [ - ("GET", "/api/browsers"), - ("POST", "/api/browsers/sign-out"), - ("GET", "/api/devices"), - ("GET", "/api/config"), - ("POST", "/api/config"), - ] { - assert_eq!(route(&request(method, path, HOST), PEER, &web).status, 401, "{method} {path}"); + let request = serde_json::json!({ "type": "config-set", "set": { key: value } }); + assert_eq!(web.page_request(&request.to_string(), "npub1owner").0, 400, "{key}"); } } } diff --git a/crates/bridge-runtime/src/web_stream.rs b/crates/bridge-runtime/src/web_stream.rs new file mode 100644 index 00000000..f9f28c22 --- /dev/null +++ b/crates/bridge-runtime/src/web_stream.rs @@ -0,0 +1,387 @@ +//! A browser's stream on the web page: the one WebSocket a signed-in browser +//! drives sessions over (`protocol::web` is the spec). +//! +//! The upgrade is let through only for an allowed `Host`, the page's own +//! `Origin` and a cookie naming a signed-in browser (`Web::stream_grant`). +//! Then the browser must prove it holds the key it signed in with: it signs +//! the connection's challenge (`HELLO`), and every frame after that, each +//! with a `seq` above the last. A frame that does not verify closes the +//! stream. A verified command is checked against what a browser may send +//! (`bridge_core::browser_may_send`) and handed to the engine as the +//! identity's that let the browser in; a page request is answered here. +//! +//! What the bridge sends a browser goes through the same lane as a phone's +//! direct link: queued, never waited on, and a browser that stops reading is +//! closed rather than allowed to hold the bridge's one thread. + +use std::time::Duration; + +use bridge_core::Input; +use futures_util::{SinkExt, StreamExt}; +use protocol::web::{closed, decode_web_frame, encode_web_frame, signed_input, WebFrame}; +use tokio::io::{AsyncRead, AsyncWrite}; +use tokio_tungstenite::tungstenite::protocol::WebSocketConfig; +use tokio_tungstenite::tungstenite::Message; + +use crate::web::{StreamGrant, Web}; + +/// How long a browser has to say `HELLO` once it has its challenge: it +/// signs with a key it already holds, so no prompt stands in the way. +const HELLO_TIMEOUT: Duration = Duration::from_secs(10); +/// A stream silent this long is dropped; the page renews its presence well +/// within it. +const IDLE_TIMEOUT: Duration = Duration::from_secs(400); +/// How long the WebSocket handshake may take. +const HANDSHAKE_TIMEOUT: Duration = Duration::from_secs(10); +/// Largest frame accepted from a browser: a command and its signature. +const MAX_FRAME_BYTES: usize = 256 * 1024; + +/// Serve a request for the stream whose head is `head` (still unread from +/// `stream`'s point of view: it is replayed to the WebSocket handshake). +/// `slot`: the direct link's hub and the peer, whose per-host connection +/// slot an open stream gives back (see `Hub::release_host_slot`). +pub async fn serve(head: Vec, mut stream: S, web: &Web, slot: Option<(&crate::direct::Hub, std::net::IpAddr)>) { + let grant = match web.stream_grant(&head) { + Ok(grant) => grant, + Err(status) => { + crate::web::refuse(&mut stream, status).await; + return; + } + }; + let config = WebSocketConfig { max_message_size: Some(MAX_FRAME_BYTES), max_frame_size: Some(MAX_FRAME_BYTES), ..Default::default() }; + let replay = crate::direct::Replay::new(head, stream); + let Ok(Ok(ws)) = tokio::time::timeout(HANDSHAKE_TIMEOUT, tokio_tungstenite::accept_async_with_config(replay, Some(config))).await + else { + return; + }; + run(ws, grant, web, slot).await; +} + +/// The stream once upgraded: the handshake, then frames both ways. +async fn run(ws: W, grant: StreamGrant, web: &Web, slot: Option<(&crate::direct::Hub, std::net::IpAddr)>) +where + W: futures_util::Stream> + + futures_util::Sink + + Unpin, +{ + let (mut sink, mut source) = ws.split(); + let send = |frame: &WebFrame| Message::Text(encode_web_frame(frame)); + let challenge = base64::Engine::encode(&base64::engine::general_purpose::URL_SAFE_NO_PAD, rand::random::<[u8; 32]>()); + if sink.send(send(&WebFrame::Challenge(challenge.clone()))).await.is_err() { + return; + } + let verifies = |seq: u64, body: &str, sig: &str| { + grant.browser_key.verifies(&signed_input(web.machine(), &grant.id, &challenge, seq, body), sig) + }; + let hello = tokio::time::timeout(HELLO_TIMEOUT, next_text(&mut source)).await.ok().flatten(); + match hello.as_deref().map(decode_web_frame) { + Some(Ok(WebFrame::Hello { sig })) if verifies(0, "", &sig) => {} + _ => { + let _ = sink.send(send(&WebFrame::Closed(closed::BAD_SIGNATURE.into()))).await; + return; + } + } + if !web.still_signed_in(&grant.key) { + let _ = sink.send(send(&WebFrame::Closed(closed::EXPIRED.into()))).await; + return; + } + web.seen(&grant.key); + let Some((n, lane, reason)) = web.open_stream(&grant) else { + let _ = sink.send(send(&WebFrame::Closed(closed::BUSY.into()))).await; + return; + }; + log::info!("[Web] A browser opened its stream"); + // Open and signed: from here the page's own caps bound it. + if let Some((hub, peer)) = slot { + hub.release_host_slot(peer); + } + let mut last_seq = 0u64; + let mut ok = sink.send(send(&WebFrame::Ready)).await.is_ok(); + while ok { + if let Some(text) = lane.pop() { + ok = sink.send(Message::Text(text)).await.is_ok(); + continue; + } + if lane.is_closed() { + let _ = sink.send(send(&WebFrame::Closed(reason.get().into()))).await; + break; + } + tokio::select! { + biased; + () = lane.ready() => { + if let Some(text) = lane.pop() { + ok = sink.send(Message::Text(text)).await.is_ok(); + } + }, + incoming = tokio::time::timeout(IDLE_TIMEOUT, source.next()) => match incoming { + Ok(Some(Ok(Message::Text(text)))) => { + match handle(&text, &grant, web, &mut last_seq, &verifies).await { + Ok(Some(answer)) => ok = sink.send(send(&answer)).await.is_ok(), + Ok(None) => {} + Err(why) => { + let _ = sink.send(send(&WebFrame::Closed(why.into()))).await; + ok = false; + } + } + } + Ok(Some(Ok(Message::Ping(_) | Message::Pong(_)))) => ok = sink.flush().await.is_ok(), + Ok(Some(Ok(Message::Binary(_) | Message::Frame(_)))) => {} + _ => ok = false, + }, + } + } + web.close_stream(n); + if let Some((hub, peer)) = slot { + hub.retake_host_slot(peer); + } + log::info!("[Web] A browser closed its stream"); +} + +/// One frame from the browser: its answer, nothing, or why the stream ends. +async fn handle( + text: &str, + grant: &StreamGrant, + web: &Web, + last_seq: &mut u64, + verifies: &impl Fn(u64, &str, &str) -> bool, +) -> Result, &'static str> { + let (seq, body, sig, page) = match decode_web_frame(text) { + Ok(WebFrame::Cmd { seq, body, sig }) => (seq, body, sig, false), + Ok(WebFrame::Page { seq, body, sig }) => (seq, body, sig, true), + _ => return Err(closed::BAD_FRAME), + }; + // A `seq` that does not grow is a replay, however good its signature. + if seq <= *last_seq || !verifies(seq, &body, &sig) { + return Err(closed::BAD_SIGNATURE); + } + *last_seq = seq; + if !web.still_signed_in(&grant.key) { + return Err(closed::EXPIRED); + } + web.seen(&grant.key); + if page { + let (status, reply, write) = web.page_request(&body, &grant.by); + let (status, reply) = match write { + Some(write) => crate::web::write_config_now(write).await, + None => (status, reply), + }; + let reply = serde_json::json!({ "status": status, "body": serde_json::from_str::(&reply).unwrap_or_default() }); + return Ok(Some(WebFrame::Reply { seq, reply: reply.to_string() })); + } + let msg = match protocol::decode_phone_to_bridge(&body) { + Ok(msg) => msg, + Err(err) => return Ok(Some(WebFrame::Ok { seq, accepted: false, message: format!("invalid: {err}") })), + }; + if !bridge_core::browser_may_send(&msg) { + return Ok(Some(WebFrame::Ok { seq, accepted: false, message: "not from a browser".into() })); + } + let _ = web.inputs().send(Input::WebCommand { id: grant.id.clone(), by: grant.by.clone(), msg: Box::new(msg) }); + Ok(Some(WebFrame::Ok { seq, accepted: true, message: String::new() })) +} + +async fn next_text(source: &mut S) -> Option +where + S: futures_util::Stream> + Unpin, +{ + loop { + match source.next().await? { + Ok(Message::Text(text)) => return Some(text), + Ok(Message::Ping(_) | Message::Pong(_)) => continue, + _ => return None, + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::web::tests::{clock, page, sign_in_with, TestKey, HOST}; + use crate::web::STREAM_PATH; + use tokio::io::DuplexStream; + use tokio_tungstenite::tungstenite::client::IntoClientRequest; + use tokio_tungstenite::WebSocketStream; + + type Ws = WebSocketStream; + + /// Serve one stream request from a browser holding `cookie` at `origin`, + /// while `client` plays the browser's side; both run to their end. + async fn with_stream(web: &Web, cookie: &str, origin: &str, client: F) + where + F: FnOnce(Ws) -> Fut, + Fut: std::future::Future, + { + let (client_io, mut server_io) = tokio::io::duplex(1 << 20); + let server = async { + if let Some(head) = crate::web::read_head(&mut server_io).await { + serve(head, server_io, web, None).await; + } + }; + let browser = async { + let mut request = format!("ws://{HOST}{STREAM_PATH}").into_client_request().unwrap(); + request.headers_mut().insert("Origin", origin.parse().unwrap()); + request.headers_mut().insert("Cookie", format!("__Host-codedeck={cookie}").parse().unwrap()); + if let Ok((ws, _)) = tokio_tungstenite::client_async(request, client_io).await { + client(ws).await; + } + }; + tokio::join!(server, browser); + } + + async fn recv(ws: &mut Ws) -> WebFrame { + let text = next_text(ws).await.expect("a frame"); + decode_web_frame(&text).expect("a web frame") + } + + async fn send(ws: &mut Ws, frame: WebFrame) { + ws.send(Message::Text(encode_web_frame(&frame))).await.unwrap(); + } + + /// What `key` signs for frame `seq` with `body`, on a connection whose + /// challenge is `challenge`. + fn sign(key: &TestKey, challenge: &str, seq: u64, body: &str) -> String { + key.sign(&signed_input("npub1machine", &key.public.id(), challenge, seq, body)) + } + + /// Read the challenge and say a good `HELLO`; returns the challenge once + /// the bridge said `READY`. + async fn hello(ws: &mut Ws, key: &TestKey) -> String { + let WebFrame::Challenge(challenge) = recv(ws).await else { panic!("a challenge first") }; + send(ws, WebFrame::Hello { sig: sign(key, &challenge, 0, "") }).await; + assert_eq!(recv(ws).await, WebFrame::Ready); + challenge + } + + fn commands(inputs: &mut tokio::sync::mpsc::UnboundedReceiver) -> Vec { + std::iter::from_fn(|| inputs.try_recv().ok()) + .filter_map(|input| match input { + Input::WebCommand { msg, .. } => Some(protocol::encode_phone_to_bridge(&msg).unwrap()), + _ => None, + }) + .collect() + } + + const REFRESH: &str = r#"{"v":12,"type":"refresh-sessions"}"#; + + #[tokio::test(flavor = "current_thread")] + async fn a_signed_command_reaches_the_engine_and_the_bridge_answers_down_the_stream() { + let dir = tempfile::tempdir().unwrap(); + let (_, now) = clock(); + let (web, mut inputs) = page(dir.path(), Vec::new(), now); + let key = TestKey::new(7); + let cookie = sign_in_with(&web, &mut inputs, &key); + while inputs.try_recv().is_ok() {} + let (page_ref, key_ref) = (&web, &key); + with_stream(&web, &cookie, &format!("https://{HOST}"), |mut ws| async move { + let (web, key) = (page_ref, key_ref); + let challenge = hello(&mut ws, key).await; + send(&mut ws, WebFrame::Cmd { seq: 1, body: REFRESH.into(), sig: sign(key, &challenge, 1, REFRESH) }).await; + assert_eq!(recv(&mut ws).await, WebFrame::Ok { seq: 1, accepted: true, message: String::new() }); + web.deliver(&key.public.id(), r#"{"v":12,"type":"input-ack","sessionId":"s","inputId":"i"}"#); + let WebFrame::Msg(message) = recv(&mut ws).await else { panic!("the bridge's message") }; + assert!(message.contains("input-ack")); + }) + .await; + let got: Vec = std::iter::from_fn(|| inputs.try_recv().ok()).collect(); + assert!(matches!(&got[0], Input::WebBrowserOnline { id, by } if *id == key.public.id() && by == "npub1owner"), "{got:?}"); + assert!(matches!(&got[1], Input::WebCommand { id, .. } if *id == key.public.id()), "{got:?}"); + assert!(matches!(&got[2], Input::WebBrowserOffline { .. }), "{got:?}"); + } + + #[tokio::test(flavor = "current_thread")] + async fn a_hello_by_another_key_is_closed() { + let dir = tempfile::tempdir().unwrap(); + let (web, mut inputs) = page(dir.path(), Vec::new(), clock().1); + let cookie = sign_in_with(&web, &mut inputs, &TestKey::new(7)); + while inputs.try_recv().is_ok() {} + let thief = TestKey::new(8); + with_stream(&web, &cookie, &format!("https://{HOST}"), |mut ws| async move { + let WebFrame::Challenge(challenge) = recv(&mut ws).await else { panic!() }; + // The cookie alone, with a key of the thief's own. + let sig = thief.sign(&signed_input("npub1machine", &TestKey::new(7).public.id(), &challenge, 0, "")); + send(&mut ws, WebFrame::Hello { sig }).await; + assert_eq!(recv(&mut ws).await, WebFrame::Closed(closed::BAD_SIGNATURE.into())); + }) + .await; + assert!(commands(&mut inputs).is_empty()); + } + + #[tokio::test(flavor = "current_thread")] + async fn a_replayed_frame_closes_the_stream() { + let dir = tempfile::tempdir().unwrap(); + let (web, mut inputs) = page(dir.path(), Vec::new(), clock().1); + let key = TestKey::new(7); + let cookie = sign_in_with(&web, &mut inputs, &key); + let origin = format!("https://{HOST}"); + + // The same seq twice on one connection. + let replay_key = TestKey::new(7); + with_stream(&web, &cookie, &origin, |mut ws| async move { + let challenge = hello(&mut ws, &replay_key).await; + let frame = WebFrame::Cmd { seq: 1, body: REFRESH.into(), sig: sign(&replay_key, &challenge, 1, REFRESH) }; + send(&mut ws, frame.clone()).await; + assert!(matches!(recv(&mut ws).await, WebFrame::Ok { accepted: true, .. })); + send(&mut ws, frame).await; + assert_eq!(recv(&mut ws).await, WebFrame::Closed(closed::BAD_SIGNATURE.into())); + }) + .await; + assert_eq!(commands(&mut inputs).len(), 1, "the replay ran nothing"); + + // A frame signed for an earlier connection's challenge. + let first = TestKey::new(7); + let old_challenge = std::cell::RefCell::new(String::new()); + let (slot, first) = (&old_challenge, &first); + with_stream(&web, &cookie, &origin, |mut ws| async move { + *slot.borrow_mut() = hello(&mut ws, first).await; + }) + .await; + let second = TestKey::new(7); + let old = old_challenge.borrow().clone(); + with_stream(&web, &cookie, &origin, |mut ws| async move { + hello(&mut ws, &second).await; + send(&mut ws, WebFrame::Cmd { seq: 1, body: REFRESH.into(), sig: sign(&second, &old, 1, REFRESH) }).await; + assert_eq!(recv(&mut ws).await, WebFrame::Closed(closed::BAD_SIGNATURE.into())); + }) + .await; + assert!(commands(&mut inputs).is_empty(), "nothing from another connection runs"); + } + + #[tokio::test(flavor = "current_thread")] + async fn a_command_a_browser_may_not_send_is_refused_and_a_page_request_answered() { + let dir = tempfile::tempdir().unwrap(); + let (web, mut inputs) = page(dir.path(), Vec::new(), clock().1); + let key = TestKey::new(7); + let cookie = sign_in_with(&web, &mut inputs, &key); + with_stream(&web, &cookie, &format!("https://{HOST}"), |mut ws| async move { + let challenge = hello(&mut ws, &key).await; + let sign_in = r#"{"v":12,"type":"web-sign-in","code":"K7QM-4XPA"}"#; + send(&mut ws, WebFrame::Cmd { seq: 1, body: sign_in.into(), sig: sign(&key, &challenge, 1, sign_in) }).await; + assert_eq!(recv(&mut ws).await, WebFrame::Ok { seq: 1, accepted: false, message: "not from a browser".into() }); + let devices = r#"{"type":"devices"}"#; + send(&mut ws, WebFrame::Page { seq: 2, body: devices.into(), sig: sign(&key, &challenge, 2, devices) }).await; + let WebFrame::Reply { seq: 2, reply } = recv(&mut ws).await else { panic!("a reply") }; + let reply: serde_json::Value = serde_json::from_str(&reply).unwrap(); + assert_eq!(reply["status"], 200); + assert!(reply["body"]["devices"].is_array()); + }) + .await; + assert!(commands(&mut inputs).is_empty(), "the engine never saw the sign-in"); + } + + #[tokio::test(flavor = "current_thread")] + async fn a_lapsed_browser_is_closed_at_its_next_frame() { + let dir = tempfile::tempdir().unwrap(); + let (now, clock) = clock(); + let (web, mut inputs) = page(dir.path(), Vec::new(), clock); + let key = TestKey::new(7); + let cookie = sign_in_with(&web, &mut inputs, &key); + while inputs.try_recv().is_ok() {} + with_stream(&web, &cookie, &format!("https://{HOST}"), |mut ws| async move { + let challenge = hello(&mut ws, &key).await; + now.set(now.get() + crate::web::IDLE_TTL_MS + 1); + send(&mut ws, WebFrame::Cmd { seq: 1, body: REFRESH.into(), sig: sign(&key, &challenge, 1, REFRESH) }).await; + assert_eq!(recv(&mut ws).await, WebFrame::Closed(closed::EXPIRED.into())); + }) + .await; + assert!(commands(&mut inputs).is_empty()); + } +} From d6645cb8455eada0c2c7af091c72a0a49135efb3 Mon Sep 17 00:00:00 2001 From: deymosh <232244450+deymosh@users.noreply.github.com> Date: Tue, 17 Nov 2026 23:31:25 +0100 Subject: [PATCH 4/6] feat(bridge-runtime): drive sessions from the web page The page becomes a client. At sign-in it makes a WebCrypto ECDSA P-256 key whose private half cannot be exported, keeps it in IndexedDB and sends the public half with the start; once the phone has let it in (and the key it holds is the one /api/me names), it opens the signed stream and signs every frame with it. A Sessions tab, first: the sessions beside the one open, its transcript (text, light markdown built as elements, thinking, tool calls with their input, result and diff, plans, to-dos, background tasks, notices), live text for the session on screen only, permission, question and plan cards answered in place, input (Enter sends), Stop, End, the mode picker and a new session on any agent and folder. A transcript is synced like the phone's (sync-request with the ranges held, acks batched) and survives a reload. Presence says which session is on screen and renews every five minutes, which also keeps an open tab's sign-in from idling out. Every string from the bridge is set as text: a transcript holds whatever a tool read. The Browsers, Devices and Settings tabs read through the stream. tests/web_page.rs drives the real runtime and agent host with a paired phone core and a browser played over pinned TLS: the key at sign-in, the phone's approval, a session created and answered over the stream, the phone seeing it, and the phone's sign-out closing the stream. It runs with the other end-to-end tests (codedeck e2e, CI). Its second test is a tool that holds such a bridge for a real browser; the page was driven through it in headless Chrome (sign-in, a session, input, a permission card, a reload, every tab, phone width) with no script or CSP error. Co-Authored-By: Claude Code --- .github/workflows/ci.yml | 4 +- codedeck | 2 +- crates/bridge-runtime/tests/web_page.rs | 332 +++++++++ crates/bridge-runtime/web/app.css | 89 ++- crates/bridge-runtime/web/app.js | 855 +++++++++++++++++++++--- crates/bridge-runtime/web/index.html | 61 +- 6 files changed, 1232 insertions(+), 111 deletions(-) create mode 100644 crates/bridge-runtime/tests/web_page.rs diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 008b25f6..26d4e795 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -207,7 +207,7 @@ jobs: pnpm install --frozen-lockfile pnpm --filter @codedeck/agent-host run build cargo test --locked -p agent-protocol --test agent_host -- --ignored - cargo test --locked -p bridge-runtime --test e2e -- --ignored + cargo test --locked -p bridge-runtime --test e2e --test web_page -- --ignored # The bridge on Windows — what the Windows release archive ships: the crates # the binary is built from, the agent host's tests and bundle, and the same @@ -257,7 +257,7 @@ jobs: run: | cargo test --locked -p protocol -p agent-protocol -p nostr-transport -p bridge-core -p bridge-runtime cargo test --locked -p agent-protocol --test agent_host -- --ignored - cargo test --locked -p bridge-runtime --test e2e -- --ignored + cargo test --locked -p bridge-runtime --test e2e --test web_page -- --ignored # apps/android: Gradle unit tests + Paparazzi screenshot verification # + the UniFFI Kotlin bindings drift check. The crates it watches are diff --git a/codedeck b/codedeck index bfcfb1a2..9652a0b4 100755 --- a/codedeck +++ b/codedeck @@ -913,7 +913,7 @@ cmd_e2e() { step "driver protocol" ${run[@]+"${run[@]}"} \ cargo test --locked -p agent-protocol --test agent_host -- --ignored || true step "bridge end to end" ${run[@]+"${run[@]}"} \ - cargo test --locked -p bridge-runtime --test e2e -- --ignored || true + cargo test --locked -p bridge-runtime --test e2e --test web_page -- --ignored || true fi check_summary } diff --git a/crates/bridge-runtime/tests/web_page.rs b/crates/bridge-runtime/tests/web_page.rs new file mode 100644 index 00000000..95d56851 --- /dev/null +++ b/crates/bridge-runtime/tests/web_page.rs @@ -0,0 +1,332 @@ +//! The bridge's web page as a client, end to end: the real runtime and agent +//! host (its scripted `fake` agent), a real phone core paired through a relay +//! on loopback, and a browser played by this test over real TLS — its own +//! P-256 key, the sign-in the phone approves, then a session driven over the +//! signed stream. +//! +//! Needs `node` and a built agent host, like `e2e.rs`: +//! `cargo test -p bridge-runtime --test web_page -- --ignored`. +//! +//! `hold_a_bridge_for_a_real_browser` is a tool rather than a test: with +//! `CODEDECK_WEB_HOLD=` it runs the same bridge and phone, prints the +//! page's address, and has the phone approve every code written to `` +//! for `CODEDECK_WEB_HOLD_SECS` (default 300), so a real browser can be +//! pointed at the page. + +mod support; + +use std::path::{Path, PathBuf}; +use std::rc::Rc; +use std::sync::Arc; +use std::time::Duration; + +use base64::Engine as _; +use bridge_runtime::config::{self, Flags}; +use bridge_runtime::runtime::{self, Mode, Options}; +use bridge_runtime::state::StateFile; +use client_runtime::client_core::connection::ConnectionStatus; +use client_runtime::protocol::crypto::generate_keypair; +use client_runtime::protocol::events::BridgeToPhone; +use client_runtime::{Core, CoreConfig, CoreObserver, CorePorts, Intent, LocalSigner, MemoryTranscriptStore, SystemClock, TimeEntropy}; +use futures_util::{SinkExt, StreamExt}; +use p256::ecdsa::signature::Signer as _; +use p256::ecdsa::{Signature, SigningKey}; +use protocol::web::{decode_web_frame, encode_web_frame, signed_input, WebFrame}; +use rustls::pki_types::ServerName; +use serde_json::{json, Value}; +use sha2::{Digest, Sha256}; +use tokio::io::{AsyncReadExt, AsyncWriteExt}; +use tokio::sync::oneshot; +use tokio::task::LocalSet; +use tokio_tungstenite::tungstenite::client::IntoClientRequest; +use tokio_tungstenite::tungstenite::Message; + +const TIMEOUT: Duration = Duration::from_secs(20); + +fn bundle() -> PathBuf { + std::env::var("AGENT_HOST_BUNDLE") + .map(PathBuf::from) + .unwrap_or_else(|_| PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../packages/agent-host/dist/main.js")) +} + +struct Observer; +impl CoreObserver for Observer { + fn connection_changed(&self, _: ConnectionStatus, _: bool, _: &[String]) {} + fn bridge_message(&self, _: String, _: BridgeToPhone) {} +} + +/// Poll `check` until it gives a value (or fail after [`TIMEOUT`]). +async fn until(what: &str, mut check: F) -> T +where + F: FnMut() -> Fut, + Fut: std::future::Future>, +{ + let deadline = tokio::time::Instant::now() + TIMEOUT; + loop { + if let Some(v) = check().await { + return v; + } + assert!(tokio::time::Instant::now() < deadline, "timed out waiting for {what}"); + tokio::time::sleep(Duration::from_millis(50)).await; + } +} + +/// A free loopback port for the page's listener. +fn free_port() -> u16 { + std::net::TcpListener::bind("127.0.0.1:0").unwrap().local_addr().unwrap().port() +} + +/// The bridge with its direct link (and so its page) on `port`, and a phone +/// paired with it. Returns the phone and the machine it knows. +async fn bridge_and_phone(home: &Path, workspace: &Path, port: u16) -> (Core, String, oneshot::Sender<()>) { + let relay = support::relay::start().await; + let flags = Flags { + home: Some(home.into()), + machine_name: Some("web".into()), + relays: vec![relay], + workspaces: vec![workspace.into()], + agent_host: Some(bundle()), + ..Default::default() + }; + let mut config = config::load(&flags).expect("config"); + config.host_env.insert("CODEDECK_AGENT_HOST_DRIVERS".into(), "fake".into()); + config.direct.listen = Some(format!("127.0.0.1:{port}").parse().unwrap()); + config.direct.endpoints = vec![format!("wss://127.0.0.1:{port}")]; + let state = StateFile::open(home).unwrap(); + let keys = state.identity().unwrap(); + let (stop, stop_rx) = oneshot::channel(); + let (urls_tx, mut urls) = tokio::sync::mpsc::unbounded_channel(); + let mut options = Options::new(Mode::Run); + options.signals = false; + options.stop = Some(stop_rx); + options.pairing_urls = Some(urls_tx); + tokio::task::spawn_local(runtime::run(config, state, keys, options)); + let pairing_url = tokio::time::timeout(TIMEOUT, urls.recv()).await.expect("a pairing window opens").unwrap(); + + let core = Core::spawn( + CoreConfig::new(Rc::new(LocalSigner(generate_keypair())), None, false, None), + CorePorts { transcript_store: Rc::new(MemoryTranscriptStore::new()), ..CorePorts::default() }, + Rc::new(Observer), + Rc::new(SystemClock), + Rc::new(TimeEntropy), + ) + .await; + core.start(); + core.dispatch(Intent::BeginPairing { url: pairing_url, label: "web-phone".into() }).await; + until("pairing", || async { + let view = core.pairing_view().await?; + assert_ne!(view.phase, "failed", "pairing failed: {:?}", view.error); + (view.phase == "paired").then_some(()) + }) + .await; + let machine = until("the machine", || async { core.machines_view().await.machines.keys().next().cloned() }).await; + // A session can start only once the agent host has reported its + // catalog; before that a create-session is refused. + until("the agent catalog", || async { + core.machines_view().await.machines.get(&machine)?.agents.iter().any(|a| a.id == "fake").then_some(()) + }) + .await; + (core, machine, stop) +} + +/// The browser: a key, a cookie, and TLS pinned to the certificate the +/// bridge made in `home` — what a user checks against the phone's pin. +struct Browser { + port: u16, + tls: tokio_rustls::TlsConnector, + key: SigningKey, + cookie: Option, +} + +impl Browser { + fn new(home: &Path, port: u16) -> Self { + let cert = std::fs::read(home.join("direct/cert.der")).expect("the page's certificate"); + let pin = hex::encode(Sha256::digest(&cert)); + let tls = tokio_rustls::TlsConnector::from(Arc::new(nostr_transport::direct::pinned_client_config(&pin))); + Self { port, tls, key: SigningKey::from_bytes(&[42u8; 32].into()).unwrap(), cookie: None } + } + + fn public_key(&self) -> String { + base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(self.key.verifying_key().to_encoded_point(false).as_bytes()) + } + + fn id(&self) -> String { + hex::encode(Sha256::digest(self.key.verifying_key().to_encoded_point(false).as_bytes()))[..16].to_string() + } + + async fn tls(&self) -> tokio_rustls::client::TlsStream { + let tcp = tokio::net::TcpStream::connect(("127.0.0.1", self.port)).await.unwrap(); + self.tls.connect(ServerName::try_from("codedeck-bridge").unwrap(), tcp).await.unwrap() + } + + /// One HTTPS request as a browser on the page makes it: (status, JSON). + async fn request(&mut self, method: &str, path: &str, body: Option) -> (u16, Value) { + let mut stream = self.tls().await; + let body = body.map(|b| b.to_string()).unwrap_or_default(); + let cookie = self.cookie.as_ref().map(|c| format!("Cookie: __Host-codedeck={c}\r\n")).unwrap_or_default(); + let head = format!( + "{method} {path} HTTP/1.1\r\nHost: 127.0.0.1:{port}\r\nOrigin: https://127.0.0.1:{port}\r\n{cookie}\ + Content-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}", + body.len(), + port = self.port, + ); + stream.write_all(head.as_bytes()).await.unwrap(); + let mut raw = Vec::new(); + let _ = stream.read_to_end(&mut raw).await; + let text = String::from_utf8_lossy(&raw).to_string(); + let (head, body) = text.split_once("\r\n\r\n").unwrap_or((&text, "")); + let status = head.split(' ').nth(1).and_then(|s| s.parse().ok()).unwrap_or(0); + if let Some(value) = head.lines().find_map(|l| l.strip_prefix("Set-Cookie: __Host-codedeck=")) { + self.cookie = Some(value.split(';').next().unwrap().to_string()); + } + (status, serde_json::from_str(body).unwrap_or(Value::Null)) + } + + fn sign(&self, challenge: &str, seq: u64, body: &str) -> String { + let sig: Signature = self.key.sign(&signed_input(&machine_npub(), &self.id(), challenge, seq, body)); + base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(sig.to_bytes()) + } +} + +/// The page's machine, as `/api/me` names it (set once the browser asked). +static MACHINE: std::sync::OnceLock = std::sync::OnceLock::new(); +fn machine_npub() -> String { + MACHINE.get().cloned().unwrap_or_default() +} + +type Stream = tokio_tungstenite::WebSocketStream>; + +async fn next(ws: &mut Stream) -> WebFrame { + loop { + let msg = tokio::time::timeout(TIMEOUT, ws.next()).await.expect("a frame in time").expect("open").unwrap(); + if let Message::Text(text) = msg { + return decode_web_frame(&text).unwrap(); + } + } +} + +#[tokio::test(flavor = "current_thread")] +#[ignore = "needs node and a built packages/agent-host bundle"] +async fn a_browser_signed_in_by_the_phone_drives_a_session_over_its_signed_stream() { + assert!(bundle().exists(), "agent host bundle missing at {} — build packages/agent-host first", bundle().display()); + LocalSet::new() + .run_until(async { + let home = tempfile::tempdir().unwrap(); + let workspace = tempfile::tempdir().unwrap(); + let port = free_port(); + let (core, machine, stop) = bridge_and_phone(home.path(), workspace.path(), port).await; + let mut browser = Browser::new(home.path(), port); + + // --- sign-in: the key goes with the start, the phone approves --- + let (status, started) = browser.request("POST", "/api/sign-in", Some(json!({ "key": browser.public_key() }))).await; + assert_eq!(status, 200, "{started}"); + let code = started["code"].as_str().unwrap().to_string(); + core.dispatch(Intent::WebSignIn { machine: machine.clone(), code }).await; + let me = until("the phone to let the browser in", || { + let mut b = Browser { cookie: browser.cookie.clone(), ..Browser::new(home.path(), port) }; + async move { + let (_, me) = b.request("GET", "/api/me", None).await; + (me["state"] == "signed-in").then_some(me) + } + }) + .await; + assert_eq!(me["id"], browser.id(), "the browser let in is the key's"); + MACHINE.set(me["machine"].as_str().unwrap().to_string()).unwrap(); + + // --- the cookie alone gets nothing beyond its own state --- + let (status, _) = browser.request("GET", "/api/config", None).await; + assert_eq!(status, 404); + + // --- the stream --- + let tls = browser.tls().await; + let mut request = format!("wss://127.0.0.1:{port}/api/stream").into_client_request().unwrap(); + request.headers_mut().insert("Origin", format!("https://127.0.0.1:{port}").parse().unwrap()); + request.headers_mut().insert("Cookie", format!("__Host-codedeck={}", browser.cookie.clone().unwrap()).parse().unwrap()); + let (mut ws, _) = tokio_tungstenite::client_async(request, tls).await.expect("the stream opens"); + let WebFrame::Challenge(challenge) = next(&mut ws).await else { panic!("a challenge") }; + ws.send(Message::Text(encode_web_frame(&WebFrame::Hello { sig: browser.sign(&challenge, 0, "") }))).await.unwrap(); + assert_eq!(next(&mut ws).await, WebFrame::Ready); + + let mut seq = 0; + let mut command = async |ws: &mut Stream, msg: Value| { + seq += 1; + let body = msg.to_string(); + let frame = WebFrame::Cmd { seq, body: body.clone(), sig: browser.sign(&challenge, seq, &body) }; + ws.send(Message::Text(encode_web_frame(&frame))).await.unwrap(); + }; + command(&mut ws, json!({"v":12,"type":"create-session","agent":"fake"})).await; + + // The browser hears the session become ready, then drives it. + let mut session = None; + let mut echoed = false; + let deadline = tokio::time::Instant::now() + TIMEOUT; + while !echoed { + assert!(tokio::time::Instant::now() < deadline, "the session and its echo, in time"); + match next(&mut ws).await { + WebFrame::Ok { accepted, message, .. } => assert!(accepted, "{message}"), + WebFrame::Msg(text) => { + let msg: Value = serde_json::from_str(&text).unwrap(); + assert_ne!(msg["type"], "session-failed", "the session did not start: {msg}"); + if msg["type"] == "session-ready" && session.is_none() { + let id = msg["session"]["id"].as_str().unwrap().to_string(); + command(&mut ws, json!({"v":12,"type":"presence","watching":id})).await; + command(&mut ws, json!({"v":12,"type":"input","sessionId":id,"text":"hello","inputId":"w1"})).await; + session = Some(id); + } + let text = msg["entries"].as_array().into_iter().flatten().filter_map(|e| e["text"].as_str()).collect::(); + echoed |= msg["type"] == "output" && text.contains("echo: hello"); + } + other => panic!("unexpected {other:?}"), + } + } + + // The phone sees the session the browser made: one engine, two clients. + let session = session.unwrap(); + until("the phone to list the browser's session", || async { + core.machines_view().await.machines.get(&machine)?.sessions.contains_key(&session).then_some(()) + }) + .await; + + // Signing out from the phone closes the stream at once. + core.dispatch(Intent::SignOutWebBrowser { machine: machine.clone(), id: browser.id() }).await; + loop { + match next(&mut ws).await { + WebFrame::Closed(reason) => { + assert_eq!(reason, "signed-out"); + break; + } + _ => continue, + } + } + let _ = stop.send(()); + }) + .await; +} + +#[tokio::test(flavor = "current_thread")] +#[ignore = "a tool: holds a bridge for a real browser when CODEDECK_WEB_HOLD names a code file"] +async fn hold_a_bridge_for_a_real_browser() { + let Ok(code_file) = std::env::var("CODEDECK_WEB_HOLD") else { return }; + let secs: u64 = std::env::var("CODEDECK_WEB_HOLD_SECS").ok().and_then(|s| s.parse().ok()).unwrap_or(300); + LocalSet::new() + .run_until(async { + let home = tempfile::tempdir().unwrap(); + let workspace = tempfile::tempdir().unwrap(); + let port: u16 = std::env::var("CODEDECK_WEB_HOLD_PORT").ok().and_then(|p| p.parse().ok()).unwrap_or_else(free_port); + let (core, machine, stop) = bridge_and_phone(home.path(), workspace.path(), port).await; + println!("PAGE https://127.0.0.1:{port}/"); + let deadline = tokio::time::Instant::now() + Duration::from_secs(secs); + let mut approved = String::new(); + while tokio::time::Instant::now() < deadline { + let code = std::fs::read_to_string(&code_file).unwrap_or_default().trim().to_string(); + if !code.is_empty() && code != approved { + println!("APPROVING {code}"); + core.dispatch(Intent::WebSignIn { machine: machine.clone(), code: code.clone() }).await; + approved = code; + } + tokio::time::sleep(Duration::from_millis(200)).await; + } + let _ = stop.send(()); + }) + .await; +} diff --git a/crates/bridge-runtime/web/app.css b/crates/bridge-runtime/web/app.css index 2ff4ed5d..92fa8f2f 100644 --- a/crates/bridge-runtime/web/app.css +++ b/crates/bridge-runtime/web/app.css @@ -78,16 +78,8 @@ button.quiet:hover { color: var(--text); border-color: var(--muted); } .state.busy::before { background: var(--busy); } .state.bad::before { background: var(--bad); } -.table-wrap { overflow-x: auto; } -table.sessions { width: 100%; border-collapse: collapse; } -.sessions th { text-align: left; font-weight: 500; color: var(--muted); font-size: 13px; padding: 0 12px 10px 0; border-bottom: 1px solid var(--line); } -.sessions td { padding: 11px 12px 11px 0; border-bottom: 1px solid var(--line); vertical-align: top; } -.sessions tr:last-child td { border-bottom: none; } -.sessions .title { max-width: 360px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; } -.sessions .folder { color: var(--dim); max-width: 220px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; } -.sessions .when { color: var(--dim); white-space: nowrap; } - -.tabs { display: flex; gap: 4px; margin: -4px 0 20px; border-bottom: 1px solid var(--line); overflow-x: auto; } + +.tabs { display: flex; gap: 4px; margin: -4px 0 20px; border-bottom: 1px solid var(--line); overflow-x: auto; overflow-y: hidden; } .tabs a { color: var(--dim); text-decoration: none; padding: 10px 14px; border-bottom: 2px solid transparent; margin-bottom: -1px; white-space: nowrap; } .tabs a:hover { color: var(--text); } .tabs a.on { color: var(--text); border-bottom-color: var(--text); } @@ -121,9 +113,84 @@ button.danger:hover { color: var(--bad); border-color: var(--bad); } .actions .primary { margin-top: 0; } .ok { color: var(--ok); } +.bar-end { display: flex; align-items: center; gap: 14px; } +.field select, .session-tools select { font: inherit; color: var(--text); background: var(--raised); border: 1px solid var(--line); border-radius: 10px; padding: 9px 12px; } + +/* Sessions: the list beside the open one, which fills the window. */ +main.wide { max-width: 1400px; } +.split { display: grid; grid-template-columns: 280px 1fr; gap: 18px; align-items: start; } +.session-list { display: flex; flex-direction: column; gap: 4px; position: sticky; top: 80px; max-height: calc(100vh - 170px); overflow-y: auto; } +.new-link { color: var(--text); text-decoration: none; border: 1px dashed var(--line); border-radius: 12px; padding: 10px 14px; margin-bottom: 6px; } +.new-link:hover { border-color: var(--muted); } +.session-item { display: flex; flex-direction: column; gap: 4px; padding: 10px 14px; border-radius: 12px; color: var(--text); text-decoration: none; border: 1px solid transparent; } +.session-item:hover { background: var(--surface); } +.session-item.on { background: var(--surface); border-color: var(--line); } +.session-title { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; } +.session-meta { display: flex; gap: 10px; align-items: center; min-width: 0; flex-wrap: wrap; } +.session-main { min-width: 0; } +.session-view { display: flex; flex-direction: column; height: calc(100vh - 150px); background: var(--surface); border: 1px solid var(--line); border-radius: var(--radius); overflow: hidden; } +.session-head { display: flex; justify-content: space-between; align-items: center; gap: 12px; padding: 14px 18px; border-bottom: 1px solid var(--line); } +.session-head-main { min-width: 0; display: flex; flex-direction: column; gap: 4px; } +.session-name { font-weight: 600; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; } +.session-tools { display: flex; gap: 8px; align-items: center; flex-shrink: 0; } +.session-tools button { padding: 7px 14px; } +.transcript { flex: 1; overflow-y: auto; padding: 18px; display: flex; flex-direction: column; } +#entries, #live { display: flex; flex-direction: column; gap: 10px; } +#live { margin-top: 10px; } +#live:empty { display: none; } + +.msg { line-height: 1.55; overflow-wrap: anywhere; } +.msg p { margin: 0 0 8px; white-space: pre-wrap; } +.msg p:last-child { margin-bottom: 0; } +.msg.from-user { align-self: flex-end; max-width: 80%; background: var(--raised); border: 1px solid var(--line); border-radius: 14px 14px 4px 14px; padding: 9px 14px; white-space: pre-wrap; } +.msg.live { opacity: 0.85; } +.msg code, .block code { font-family: ui-monospace, "JetBrains Mono", Menlo, Consolas, monospace; font-size: 13px; background: var(--raised); border-radius: 5px; padding: 1px 5px; } +.code-block { background: var(--bg); border: 1px solid var(--line); border-radius: 10px; padding: 10px 12px; overflow-x: auto; margin: 0 0 8px; } +.code-block code { background: none; padding: 0; } +.thinking { color: var(--muted); font-size: 14px; white-space: pre-wrap; } +.thinking summary { cursor: pointer; color: var(--dim); } +.tool { border: 1px solid var(--line); border-radius: 10px; padding: 7px 12px; } +.tool summary { cursor: pointer; display: flex; gap: 8px; align-items: center; min-width: 0; } +.tool-title { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; color: var(--dim); } +.tool-io, .diff { font-family: ui-monospace, "JetBrains Mono", Menlo, Consolas, monospace; font-size: 12.5px; background: var(--bg); border-radius: 8px; padding: 8px 10px; margin: 8px 0 2px; max-height: 320px; overflow: auto; white-space: pre-wrap; overflow-wrap: anywhere; } +.tool-io.error { color: var(--bad); } +.diff-path { color: var(--dim); margin-bottom: 4px; } +.diff-add { color: var(--ok); } +.diff-del { color: var(--bad); } +.diff-context { color: var(--dim); } +.block { border-left: 2px solid var(--line); padding: 2px 0 2px 12px; } +.block-head { font-size: 12px; text-transform: uppercase; letter-spacing: 0.06em; color: var(--dim); margin-bottom: 6px; } +.block p { margin: 0 0 6px; white-space: pre-wrap; } +.todos { margin: 0; padding-left: 18px; line-height: 1.6; } +.todo.completed, .todo.cancelled { color: var(--muted); text-decoration: line-through; } +.todo.in_progress { color: var(--busy); } +.line { font-size: 14px; } +.sub { border-left: 2px solid var(--raised); padding-left: 10px; display: flex; flex-direction: column; gap: 4px; } +.sub-label { font-size: 12px; color: var(--muted); } + +.card-entry { border: 1px solid var(--dim); border-radius: 12px; padding: 12px 14px; display: flex; flex-direction: column; gap: 8px; } +.card-entry.done { border-color: var(--line); } +.card-entry textarea, .card-entry .other, .composer textarea { font: inherit; color: var(--text); background: var(--raised); border: 1px solid var(--line); border-radius: 10px; padding: 8px 12px; width: 100%; resize: vertical; } +.card-actions { display: flex; flex-wrap: wrap; gap: 8px; } +button.small-btn { padding: 6px 14px; margin-top: 0; font-size: 14px; } +.choices { display: flex; flex-direction: column; gap: 6px; } +.choice { display: flex; gap: 8px; align-items: baseline; } + +.composer { display: flex; gap: 10px; align-items: flex-end; padding: 12px 14px; border-top: 1px solid var(--line); } +.composer textarea { min-height: 44px; max-height: 40vh; } +.composer .primary { margin-top: 0; } + +.toast { position: fixed; bottom: 22px; left: 50%; transform: translateX(-50%); background: var(--raised); border: 1px solid var(--line); border-radius: 12px; padding: 10px 16px; max-width: min(560px, calc(100vw - 32px)); } + +@media (max-width: 800px) { + .split { grid-template-columns: 1fr; } + .session-list { position: static; max-height: 220px; } +} + @media (max-width: 600px) { main { padding: 16px; } .bar { padding: 12px 16px; } - .sessions .folder, .sessions th:nth-child(4) { display: none; } + .session-view { height: calc(100vh - 120px); } + .msg.from-user { max-width: 92%; } } diff --git a/crates/bridge-runtime/web/app.js b/crates/bridge-runtime/web/app.js index 158604b6..0de84f32 100644 --- a/crates/bridge-runtime/web/app.js +++ b/crates/bridge-runtime/web/app.js @@ -1,21 +1,33 @@ -// The bridge's web page. Plain DOM, no dependencies: everything it loads is +// The bridge's web page: a client that drives the bridge's sessions, signed +// in by a paired phone. Plain DOM, no dependencies: everything it loads is // served by the bridge itself (its CSP allows nothing else). Text from the -// bridge is always set as text, never as HTML. +// bridge — transcripts above all, which hold whatever a tool read — is always +// set as text, never as HTML. +// +// The browser holds a key of its own: a WebCrypto ECDSA P-256 key made at +// sign-in, whose private half cannot be exported. Every frame it sends on +// its stream is signed with it (protocol::web is the spec), so the cookie +// alone is worth nothing to whoever copies it. "use strict"; +const PROTOCOL_VERSION = 12; +const SIGNING_CONTEXT = "codedeck-web-v1"; +// The page renews its presence (a signed frame) this often: it keeps the +// stream from going idle and the browser's sign-in from lapsing while open. +const PRESENCE_MS = 5 * 60 * 1000; + const views = ["loading", "signed-out", "pending", "dashboard"]; -const tabs = ["overview", "usage", "browsers", "devices", "settings"]; +const tabs = ["sessions", "overview", "usage", "browsers", "devices", "settings"]; let pollTimer = null; let expiresAt = 0; -// The latest status, so switching tabs renders at once instead of waiting -// for the next poll. -let lastStatus = null; +let me = null; const $ = (id) => document.getElementById(id); function show(view) { for (const v of views) $(v).hidden = v !== view; $("sign-out").hidden = view !== "dashboard"; + $("link").hidden = view !== "dashboard"; } async function api(path, method = "GET", payload = {}) { @@ -32,37 +44,90 @@ async function api(path, method = "GET", payload = {}) { function el(tag, attrs = {}, ...children) { const node = document.createElement(tag); for (const [k, v] of Object.entries(attrs)) { + if (v == null || v === false) continue; if (k === "class") node.className = v; - else node.setAttribute(k, v); + else node.setAttribute(k, v === true ? "" : v); } - for (const child of children) { - if (child == null) continue; + for (const child of children.flat()) { + if (child == null || child === false) continue; node.append(child instanceof Node ? child : document.createTextNode(String(child))); } return node; } +function button(label, onClick, cls = "quiet") { + const b = el("button", { class: cls, type: "button" }, label); + b.addEventListener("click", onClick); + return b; +} + function schedule(fn, ms) { clearTimeout(pollTimer); pollTimer = setTimeout(fn, ms); } +// --- the browser's key --------------------------------------------------- + +const b64url = (bytes) => btoa(String.fromCharCode(...new Uint8Array(bytes))).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, ""); +const hex = (bytes) => [...new Uint8Array(bytes)].map((b) => b.toString(16).padStart(2, "0")).join(""); + +function keyStore(mode, fn) { + return new Promise((resolve, reject) => { + const open = indexedDB.open("codedeck", 1); + open.onupgradeneeded = () => open.result.createObjectStore("keys"); + open.onerror = () => reject(open.error); + open.onsuccess = () => { + const tx = open.result.transaction("keys", mode); + const request = fn(tx.objectStore("keys")); + tx.oncomplete = () => resolve(request && request.result); + tx.onerror = () => reject(tx.error); + }; + }); +} + +/** The key pair this browser signed in with, or null. */ +const loadKey = () => keyStore("readonly", (s) => s.get("pair")).catch(() => null); +const dropKey = () => keyStore("readwrite", (s) => s.delete("pair")).catch(() => {}); + +/** A fresh key for a new sign-in: its private half can sign, never leave. */ +async function newKey() { + const pair = await crypto.subtle.generateKey({ name: "ECDSA", namedCurve: "P-256" }, false, ["sign", "verify"]); + await keyStore("readwrite", (s) => s.put(pair, "pair")); + return pair; +} + +async function keyId(pair) { + const raw = await crypto.subtle.exportKey("raw", pair.publicKey); + return hex(await crypto.subtle.digest("SHA-256", raw)).slice(0, 16); +} + +// --- sign-in ------------------------------------------------------------- + async function refresh() { - let me; try { me = (await api("/api/me")).body; } catch { schedule(refresh, 3000); return; } - if (me.state === "signed-in") return dashboard(); + if (me.state === "signed-in") return signedIn(); if (me.state === "pending") return pending(me); + link.stop(); show("signed-out"); } async function start() { $("start-error").hidden = true; - const { status, body } = await api("/api/sign-in", "POST"); + let raw; + try { + const pair = await newKey(); + raw = b64url(await crypto.subtle.exportKey("raw", pair.publicKey)); + } catch { + $("start-error").textContent = "This browser cannot make a signing key here (it needs WebCrypto and IndexedDB on this page)."; + $("start-error").hidden = false; + return; + } + const { status, body } = await api("/api/sign-in", "POST", { key: raw }); if (status === 429) { $("start-error").textContent = "Too many sign-in attempts from here. Wait a minute and try again."; $("start-error").hidden = false; @@ -76,13 +141,13 @@ async function start() { pending(body); } -function pending(me) { +function pending(state) { show("pending"); - if ($("code").textContent !== me.code) { - $("code").textContent = me.code; - $("qr").src = "/api/sign-in/qr.svg?code=" + encodeURIComponent(me.code); + if ($("code").textContent !== state.code) { + $("code").textContent = state.code; + $("qr").src = "/api/sign-in/qr.svg?code=" + encodeURIComponent(state.code); } - expiresAt = Date.now() + me.expiresInMs; + expiresAt = Date.now() + state.expiresInMs; tickExpiry(); // Waiting for the phone: ask again until the browser is in or the code lapses. schedule(refresh, 2000); @@ -95,6 +160,303 @@ function tickExpiry() { } setInterval(() => { if (!$("pending").hidden) tickExpiry(); }, 1000); +/** Signed in: the key this browser holds must be the one the bridge let in. */ +async function signedIn() { + const pair = await loadKey(); + if (!pair || (await keyId(pair)) !== me.id) { + // The key is gone (site data cleared) or another: this sign-in can sign + // nothing, so it ends here and a new one starts. + await signOut(); + return; + } + show("dashboard"); + render(); + link.start(pair); +} + +async function signOut() { + link.stop(); + await api("/api/sign-out", "POST").catch(() => {}); + await dropKey(); + me = null; + show("signed-out"); +} + +// --- the stream ---------------------------------------------------------- + +/** The signed stream: one WebSocket, every frame signed by the browser's key. */ +const link = { + ws: null, + pair: null, + id: null, + challenge: null, + seq: 0, + ready: false, + stopped: true, + retry: 1000, + waiting: new Map(), + presenceTimer: null, + // The frames being signed and sent, one after another. + queue: Promise.resolve(), + + async start(pair) { + this.pair = pair; + this.id = await keyId(pair); + this.stopped = false; + if (!this.ws) this.connect(); + }, + + stop() { + this.stopped = true; + clearInterval(this.presenceTimer); + if (this.ws) this.ws.close(); + this.ws = null; + this.ready = false; + status(); + }, + + connect() { + const ws = new WebSocket(`wss://${location.host}/api/stream`); + this.ws = ws; + this.ready = false; + this.seq = 0; + status(); + ws.onmessage = (event) => this.receive(event.data); + ws.onclose = () => { + if (this.ws !== ws) return; + this.ws = null; + this.ready = false; + clearInterval(this.presenceTimer); + for (const [, w] of this.waiting) w.resolve({ accepted: false, message: "The connection dropped: it may not have arrived." }); + this.waiting.clear(); + status(); + if (this.stopped) return; + // A closed stream may be a lapsed sign-in: ask before dialling again. + setTimeout(() => refresh(), this.retry); + this.retry = Math.min(this.retry * 2, 30000); + }; + }, + + async sign(seq, body) { + const input = `${SIGNING_CONTEXT}\n${me.machine}\n${this.id}\n${this.challenge}\n${seq}\n${body}`; + const sig = await crypto.subtle.sign({ name: "ECDSA", hash: "SHA-256" }, this.pair.privateKey, new TextEncoder().encode(input)); + return b64url(sig); + }, + + async receive(text) { + let frame; + try { frame = JSON.parse(text); } catch { return; } + const [label, ...rest] = frame; + if (label === "CHALLENGE") { + this.challenge = rest[0]; + this.ws.send(JSON.stringify(["HELLO", await this.sign(0, "")])); + } else if (label === "READY") { + this.ready = true; + this.retry = 1000; + status(); + onConnected(); + clearInterval(this.presenceTimer); + this.presenceTimer = setInterval(() => sendPresence(), PRESENCE_MS); + } else if (label === "CLOSED") { + const reason = rest[0]; + if (reason === "expired" || reason === "signed-out" || reason === "bad-signature") { + this.stop(); + await dropKey(); + refresh(); + } + } else if (label === "OK" || label === "REPLY") { + const w = this.waiting.get(rest[0]); + if (!w) return; + this.waiting.delete(rest[0]); + w.resolve(label === "OK" ? { accepted: rest[1], message: rest[2] } : rest[1]); + } else if (label === "MSG") { + onMessage(rest[0]); + } + }, + + /** + * Send a signed frame; resolves with its answer (`OK` or `REPLY`). Frames + * are signed and sent one at a time, in `seq` order: signing is async, and + * a frame whose `seq` does not grow closes the stream. + */ + send(label, body) { + const ws = this.ws; + const turn = this.queue.then(async () => { + if (!this.ready || this.ws !== ws) return label === "CMD" ? { accepted: false, message: "Not connected." } : { status: 0, body: {} }; + const seq = ++this.seq; + const sig = await this.sign(seq, body); + if (this.ws !== ws) return label === "CMD" ? { accepted: false, message: "Not connected." } : { status: 0, body: {} }; + const answer = new Promise((resolve) => this.waiting.set(seq, { resolve })); + ws.send(JSON.stringify([label, seq, body, sig])); + return { answer }; + }); + this.queue = turn.catch(() => {}); + return turn.then((r) => (r && r.answer ? r.answer : r)); + }, + + /** A command, as the phone would send it. */ + command(msg) { + return this.send("CMD", JSON.stringify({ v: PROTOCOL_VERSION, ...msg })); + }, + + /** A page request: `{status, body}`. */ + page(request) { + return this.send("PAGE", JSON.stringify(request)); + }, +}; + +function status() { + const live = link.ready; + $("link").className = `state ${live ? "ok" : "busy"}`; + $("link").textContent = live ? "live" : "connecting"; +} + +// --- what the bridge sends ---------------------------------------------- + +let heartbeat = null; +let heartbeatRev = 0; +const transcripts = new Map(); +let selected = null; +let browserList = null; + +function transcript(sessionId) { + let t = transcripts.get(sessionId); + if (!t) { + t = { entries: new Map(), live: new Map(), syncId: null, acks: [], ackTimer: null, sent: [] }; + transcripts.set(sessionId, t); + } + return t; +} + +function onConnected() { + // A creation whose answer the dropped connection lost is not waited for. + if (pendingCreate) { + pendingCreate = null; + renderNewSession(); + } + sendPresence(); + if (selected) syncSession(selected); + if (currentTab() === "browsers") link.command({ type: "web-browsers-request" }); +} + +function onMessage(msg) { + switch (msg.type) { + case "sessions": + if (msg.rev != null && msg.rev <= heartbeatRev) return; + if (msg.rev != null) heartbeatRev = msg.rev; + heartbeat = msg; + for (const id of msg.removedSessions || []) transcripts.delete(id); + render(); + return; + case "output": { + if (!transcripts.has(msg.sessionId)) return; + const t = transcript(msg.sessionId); + msg.entries.forEach((entry, i) => t.entries.set(msg.seq + i, entry)); + for (const entry of msg.entries) { + if (entry.part) t.live.delete(entry.part); + if (entry.entryType === "turn_complete") t.live.clear(); + } + if (msg.sessionId === selected) redrawTranscript(); + return; + } + case "partial": { + if (msg.sessionId !== selected) return; + const t = transcript(msg.sessionId); + const row = t.live.get(msg.key); + if (msg.offset === 0) t.live.set(msg.key, { entryType: msg.entryType, text: msg.text, subagent: msg.subagent }); + else if (row && !row.broken && row.text.length === msg.offset) row.text += msg.text; + else if (row) row.broken = true; + drawLive(); + return; + } + case "sync-begin": + transcript(msg.sessionId).syncId = msg.syncId; + return; + case "sync-chunk": { + const t = transcript(msg.sessionId); + for (const { seq, entry } of msg.entries) t.entries.set(seq, entry); + // Acks for chunks that arrive together go out as one command — each + // under the sync its chunks came in. + if (t.ackSync !== msg.syncId) flushAcks(t); + t.ackSync = msg.syncId; + t.acks.push(msg.range); + clearTimeout(t.ackTimer); + t.ackTimer = setTimeout(() => flushAcks(t), 50); + if (msg.sessionId === selected) redrawTranscript(); + return; + } + case "session-pending": + // The answer to this page's own create-session (replies go to the + // asking browser alone): the id the session will have. + if (pendingCreate === "?") pendingCreate = msg.pendingId; + return; + case "session-ready": + if (pendingCreate === msg.pendingId) { + pendingCreate = null; + location.hash = `#sessions/${msg.session.id}`; + } + return; + case "session-failed": + if (pendingCreate === msg.pendingId) { + pendingCreate = null; + notify(`The session did not start: ${msg.reason || "the agent failed"}.`); + renderNewSession(); + } + return; + case "input-failed": + notify(msg.reason === "no-session" ? "The bridge knows no such session." : "The session is not running."); + return; + case "option-confirmed": { + const s = (heartbeat?.sessions || []).find((x) => x.id === msg.sessionId); + if (s) s[msg.option] = msg.value; + if (msg.sessionId === selected) renderSessionHead(); + return; + } + case "web-browsers": + browserList = msg.browsers; + if (currentTab() === "browsers") renderBrowsers(); + return; + default: + } +} + +function flushAcks(t) { + clearTimeout(t.ackTimer); + const ranges = t.acks.splice(0); + if (ranges.length) link.command({ type: "sync-ack", syncId: t.ackSync, ranges }); +} + +let toastTimer = null; +function notify(text) { + $("toast").textContent = text; + $("toast").hidden = false; + clearTimeout(toastTimer); + toastTimer = setTimeout(() => { $("toast").hidden = true; }, 6000); +} + +function sendPresence() { + link.command({ type: "presence", away: document.hidden, watching: document.hidden ? null : selected }); +} +document.addEventListener("visibilitychange", () => { if (link.ready) sendPresence(); }); + +/** The seqs a transcript holds, as `[first, last]` runs. */ +function haveRanges(t) { + const seqs = [...t.entries.keys()].sort((a, b) => a - b); + const ranges = []; + for (const s of seqs) { + const last = ranges[ranges.length - 1]; + if (last && s === last[1] + 1) last[1] = s; + else ranges.push([s, s]); + } + return ranges; +} + +function syncSession(sessionId) { + link.command({ type: "sync-request", sessionId, haveRanges: haveRanges(transcript(sessionId)) }); +} + +// --- the frame ----------------------------------------------------------- + function relative(iso) { const at = typeof iso === "number" ? iso : Date.parse(iso); if (!Number.isFinite(at)) return ""; @@ -140,45 +502,371 @@ function facts(target, rows) { target.replaceChildren(...rows.flatMap(([k, v]) => [el("dt", {}, k), el("dd", {}, v)])); } -function currentTab() { - const tab = location.hash.slice(1); - return tabs.includes(tab) ? tab : "overview"; -} - -async function dashboard() { - const { status, body } = await api("/api/status"); - if (status === 401) return refresh(); - if (status !== 200) return schedule(dashboard, 5000); - lastStatus = body; - show("dashboard"); - render(); - schedule(dashboard, 5000); +/** The open tab, and for `sessions` the session in it. */ +function route() { + const [tab, id] = location.hash.slice(1).split("/"); + let session = null; + try { session = id ? decodeURIComponent(id) : null; } catch { session = null; } + return { tab: tabs.includes(tab) ? tab : "sessions", id: session }; } +const currentTab = () => route().tab; +const agentName = (id) => (heartbeat?.agents || []).find((a) => a.id === id)?.displayName || id; -/** The dashboard's frame and the open tab, from the latest status. */ +/** The frame and the open tab, from the latest heartbeat. */ function render() { - const body = lastStatus; - if (!body) return; - const hb = body.heartbeat || {}; + if ($("dashboard").hidden) return; + const hb = heartbeat || {}; $("machine").textContent = hb.machine || ""; document.title = `${hb.machine || "Bridge"} · CodeDeck+`; - const tab = currentTab(); - for (const link of document.querySelectorAll("[data-tab]")) link.classList.toggle("on", link.dataset.tab === tab); + const { tab, id } = route(); + for (const tabLink of document.querySelectorAll("[data-tab]")) tabLink.classList.toggle("on", tabLink.dataset.tab === tab); for (const pane of document.querySelectorAll("[data-pane]")) pane.hidden = pane.dataset.pane !== tab; - $("signed-in-as").textContent = `Signed in by ${body.signedInBy.slice(0, 16)}… ${relative(body.signedInSince)}.`; - if (tab === "usage") usage(hb); - else if (tab === "browsers") browsers(); + $("dashboard").classList.toggle("wide", tab === "sessions"); + if (me?.by) { + const lapse = me.lapses ? ` Stays signed in until ${new Date(me.lapses).toLocaleDateString()} while used.` : ""; + $("signed-in-as").textContent = `Signed in by ${me.by.slice(0, 16)}… ${relative(me.since)}.${lapse}`; + } + const watching = tab === "sessions" ? id : null; + if (watching !== selected) { + selected = watching; + if (link.ready) sendPresence(); + if (selected) { + transcript(selected); + if (link.ready) syncSession(selected); + } + transcriptKey = null; + } + if (!heartbeat) return; + if (tab === "sessions") sessionsPane(); + else if (tab === "usage") usage(hb); + else if (tab === "browsers") renderBrowsers(); else if (tab === "devices") devices(); else if (tab === "settings") settings(); - else overview(body, hb); + else overview(hb); +} + +// --- sessions ------------------------------------------------------------ + +let pendingCreate = null; + +function sortedSessions() { + return [...(heartbeat?.sessions || [])].sort((a, b) => Date.parse(b.lastActivity) - Date.parse(a.lastActivity)); } -function overview(body, hb) { +function sessionsPane() { + const sessions = sortedSessions(); + $("session-list").replaceChildren(...sessions.map((s) => el("a", { class: `session-item${s.id === selected ? " on" : ""}`, href: `#sessions/${encodeURIComponent(s.id)}` }, + el("span", { class: "session-title" }, s.title || s.slug), + el("span", { class: "session-meta" }, stateOf(s), el("span", { class: "dim small" }, `${agentName(s.agent)} · ${s.project || s.cwd}`)), + ))); + $("no-sessions").hidden = sessions.length > 0; + const session = sessions.find((s) => s.id === selected); + $("session-view").hidden = !session; + $("new-session").hidden = !!session; + if (session) { + renderSessionHead(); + redrawTranscript(); + } else { + renderNewSession(); + } +} + +function renderNewSession() { + const agents = (heartbeat?.agents || []).filter((a) => (a.install?.state || "ready") !== "failed"); + const agentSelect = $("new-agent"); + if (agentSelect.options.length !== agents.length) { + agentSelect.replaceChildren(...agents.map((a) => el("option", { value: a.id }, a.displayName))); + } + const folders = heartbeat?.folders || []; + const folderSelect = $("new-folder"); + const wanted = ["", ...folders]; + if (JSON.stringify([...folderSelect.options].map((o) => o.value)) !== JSON.stringify(wanted)) { + folderSelect.replaceChildren(el("option", { value: "" }, "The workspace itself"), ...folders.map((f) => el("option", { value: f }, f))); + } + $("new-start").disabled = !!pendingCreate || !agents.length; + $("new-start").textContent = pendingCreate ? "Starting…" : "Start"; +} + +$("new-session").addEventListener("submit", async (event) => { + event.preventDefault(); + const msg = { type: "create-session", agent: $("new-agent").value }; + if ($("new-folder").value) msg.cwd = $("new-folder").value; + const answer = await link.command(msg); + if (!answer.accepted) return notify(answer.message || "The bridge did not take it."); + // The bridge names the session after the pending id it answers with. + pendingCreate = "?"; + renderNewSession(); +}); + +/** The session's header: its name, state and options. */ +function renderSessionHead() { + const session = (heartbeat?.sessions || []).find((s) => s.id === selected); + if (!session) return; + const agent = (heartbeat.agents || []).find((a) => a.id === session.agent); + $("session-name").textContent = session.title || session.slug; + const meta = [agentName(session.agent), session.model, session.project || session.cwd].filter(Boolean).join(" · "); + $("session-meta").replaceChildren(stateOf(session), el("span", { class: "dim small" }, meta)); + const modes = agent?.modes || []; + const mode = $("session-mode"); + mode.hidden = modes.length === 0; + mode.replaceChildren(...modes.map((m) => el("option", { value: m.id, selected: m.id === (session.mode || agent.defaultMode) }, m.label))); + const busy = session.state && session.state !== "idle" && session.state !== "offline"; + $("interrupt").hidden = !busy || agent?.supports?.interrupt === false; +} + +$("session-mode").addEventListener("change", async () => { + const answer = await link.command({ type: "set-option", sessionId: selected, option: "mode", value: $("session-mode").value }); + if (!answer.accepted) notify(answer.message || "The bridge did not take it."); +}); +$("interrupt").addEventListener("click", () => link.command({ type: "interrupt", sessionId: selected })); +$("close-session").addEventListener("click", async () => { + if (!confirm("End this session? Its agent stops; the transcript stays on the bridge until it is pruned.")) return; + await link.command({ type: "close-session", sessionId: selected }); + location.hash = "#sessions"; +}); + +$("composer").addEventListener("submit", async (event) => { + event.preventDefault(); + const text = $("input").value; + if (!text.trim() || !selected) return; + const inputId = crypto.randomUUID(); + $("input").value = ""; + const answer = await link.command({ type: "input", sessionId: selected, text, inputId }); + if (!answer.accepted) { + $("input").value = text; + notify(answer.message || "It did not reach the bridge."); + } +}); +$("input").addEventListener("keydown", (event) => { + if (event.key === "Enter" && !event.shiftKey && !event.isComposing) { + event.preventDefault(); + $("composer").requestSubmit(); + } +}); + +// --- the transcript ------------------------------------------------------ + +let transcriptKey = null; +let redrawQueued = false; + +function redrawTranscript() { + if (redrawQueued) return; + redrawQueued = true; + requestAnimationFrame(() => { + redrawQueued = false; + drawTranscript(); + }); +} + +function atBottom(node) { + return node.scrollHeight - node.scrollTop - node.clientHeight < 80; +} + +function drawTranscript() { + if (!selected) return; + const t = transcript(selected); + const scroller = $("transcript"); + const stick = transcriptKey !== selected || atBottom(scroller); + const seqs = [...t.entries.keys()].sort((a, b) => a - b); + const entries = seqs.map((s) => t.entries.get(s)); + // What a card became, and each call's result and diff, by id. + const resolved = new Map(); + const results = new Map(); + const diffs = new Map(); + for (const e of entries) { + if (e.entryType === "resolved") resolved.set(e.requestId, e.summary); + if (e.entryType === "tool_result") results.set(e.callId, e); + if (e.entryType === "diff" && e.callId) diffs.set(e.callId, e); + } + const rows = []; + for (const e of entries) { + const row = entryRow(e, { resolved, results, diffs, session: selected }); + if (row) rows.push(e.subagent ? el("div", { class: "sub" }, el("span", { class: "sub-label" }, e.subagent.label || "sub-agent"), row) : row); + } + $("entries").replaceChildren(...rows); + $("transcript-empty").hidden = rows.length > 0; + drawLive(); + if (stick) scroller.scrollTop = scroller.scrollHeight; + transcriptKey = selected; +} + +function drawLive() { + const t = selected && transcripts.get(selected); + const scroller = $("transcript"); + const stick = atBottom(scroller); + $("live").replaceChildren(...(t ? [...t.live.values()] : []).map((row) => + row.entryType === "thinking" + ? el("div", { class: "thinking live" }, row.text) + : el("div", { class: "msg from-agent live" }, markdown(row.text)))); + if (stick) scroller.scrollTop = scroller.scrollHeight; +} + +/** Light markdown, built as elements: fences, paragraphs, `code`, **bold**. */ +function markdown(text) { + const out = document.createDocumentFragment(); + const parts = String(text).split(/^```[^\n]*\n?/m); + parts.forEach((part, i) => { + if (i % 2 === 1) { + out.append(el("pre", { class: "code-block" }, el("code", {}, part.replace(/\n$/, "")))); + return; + } + for (const para of part.split(/\n{2,}/)) { + if (!para.trim()) continue; + const p = el("p", {}); + for (const piece of para.split(/(`[^`\n]+`|\*\*[^*\n]+\*\*)/)) { + if (/^`[^`]+`$/.test(piece)) p.append(el("code", {}, piece.slice(1, -1))); + else if (/^\*\*[^*]+\*\*$/.test(piece)) p.append(el("strong", {}, piece.slice(2, -2))); + else if (piece) p.append(piece); + } + out.append(p); + } + }); + return out; +} +const KIND_WORDS = { + read: "Read", edit: "Edit", delete: "Delete", move: "Move", search: "Search", execute: "Run", + think: "Think", fetch: "Fetch", switch_mode: "Mode", agent: "Agent", other: "Tool", +}; + +function diffView(d) { + return el("pre", { class: "diff" }, + el("div", { class: "diff-path" }, d.path), + ...(d.lines || []).map((l) => el("div", { class: `diff-${l.type}` }, (l.type === "add" ? "+" : l.type === "del" ? "-" : " ") + l.text)), + d.truncated ? el("div", { class: "dim" }, "…") : null); +} + +function entryRow(e, ctx) { + switch (e.entryType) { + case "text": + return el("div", { class: `msg from-${e.role}` }, e.role === "user" ? e.text : markdown(e.text)); + case "thinking": + return e.redacted ? el("div", { class: "thinking" }, "Reasoning withheld by the provider.") + : el("details", { class: "thinking" }, el("summary", {}, "Thinking"), el("div", {}, e.text)); + case "plan": + return el("div", { class: "block" }, el("div", { class: "block-head" }, "Plan"), markdown(e.text)); + case "tool_call": { + const result = ctx.results.get(e.callId); + const diff = ctx.diffs.get(e.callId); + const tone = result ? (result.isError ? "bad" : "ok") : "busy"; + return el("details", { class: "tool" }, + el("summary", {}, el("span", { class: `state ${tone}` }, KIND_WORDS[e.kind] || e.toolName), " ", el("span", { class: "tool-title" }, e.title || e.toolName)), + e.input ? el("pre", { class: "tool-io" }, e.input) : null, + diff ? diffView(diff) : null, + result?.text ? el("pre", { class: `tool-io${result.isError ? " error" : ""}` }, result.text) : null); + } + case "tool_result": + return null; + case "diff": + return e.callId ? null : diffView(e); + case "todos": + return el("div", { class: "block" }, el("div", { class: "block-head" }, "To do"), + el("ul", { class: "todos" }, ...e.items.map((i) => el("li", { class: `todo ${i.status}` }, i.status === "in_progress" && i.activeText ? i.activeText : i.text)))); + case "background_task": + return el("div", { class: "line" }, el("span", { class: `state ${e.status === "running" ? "busy" : e.status === "failed" ? "bad" : "ok"}` }, e.status), ` ${e.title}`, e.summary ? el("span", { class: "dim" }, ` — ${e.summary}`) : null); + case "permission_request": + return permissionCard(e, ctx); + case "question": + return questionCard(e, ctx); + case "plan_approval": + return planCard(e, ctx); + case "resolved": + case "turn_complete": + return null; + case "notice": + return el("div", { class: "line dim" }, e.text || e.kind); + case "status": + return el("div", { class: "line dim" }, e.text); + case "error": + return el("div", { class: "line error" }, e.text); + default: + return null; + } +} + +/** A card's answer, sent; the card waits for its `resolved` entry. */ +const answered = new Set(); + +async function answer(ctx, requestId, msg) { + answered.add(requestId); + redrawTranscript(); + const result = await link.command({ sessionId: ctx.session, requestId, ...msg }); + if (!result.accepted) { + answered.delete(requestId); + redrawTranscript(); + notify(result.message || "The answer did not reach the bridge."); + } +} + +function cardFrame(title, ctx, requestId, ...body) { + const summary = ctx.resolved.get(requestId); + return el("div", { class: `card-entry${summary != null ? " done" : ""}` }, + el("div", { class: "block-head" }, title), + ...body.filter(() => summary == null), + summary != null ? el("div", { class: "dim" }, summary) : answered.has(requestId) ? el("div", { class: "dim" }, "Sent…") : null); +} + +function permissionCard(e, ctx) { + const open = !ctx.resolved.has(e.requestId) && !answered.has(e.requestId); + return cardFrame("Permission", ctx, e.requestId, + el("div", {}, el("strong", {}, e.title || e.toolName)), + e.description ? el("div", { class: "dim" }, e.description) : null, + e.reason ? el("div", { class: "dim small" }, e.reason) : null, + (e.locations || []).length ? el("div", { class: "mono small" }, e.locations.join("\n")) : null, + open ? el("div", { class: "card-actions" }, ...(e.options || []).map((o) => + button(o.label, () => answer(ctx, e.requestId, { type: "permission-response", optionId: o.id }), o.kind.startsWith("allow") ? "primary small-btn" : "quiet small-btn"))) : null); +} + +function questionCard(e, ctx) { + const key = `${e.requestId}#${e.index}`; + const open = !ctx.resolved.has(e.requestId) && !answered.has(key); + const choices = (e.options || []).map((o, i) => el("label", { class: "choice" }, + el("input", { type: e.multiSelect ? "checkbox" : "radio", name: key, value: String(i) }), + el("span", {}, o.label, o.description ? el("span", { class: "dim small" }, ` — ${o.description}`) : null))); + const other = el("input", { type: "text", class: "other", placeholder: "Or answer in your own words" }); + const send = button("Answer", () => { + if (other.value.trim()) return answerQuestion(ctx, e, key, { kind: "text", text: other.value.trim() }); + const selectedOptions = choices.map((c, i) => (c.querySelector("input").checked ? i : -1)).filter((i) => i >= 0); + if (selectedOptions.length) answerQuestion(ctx, e, key, { kind: "options", selected: selectedOptions }); + }, "primary small-btn"); + const count = e.count > 1 ? ` ${e.index + 1} of ${e.count}` : ""; + return cardFrame(`Question${count}`, ctx, e.requestId, + e.header ? el("div", { class: "dim small" }, e.header) : null, + el("div", {}, el("strong", {}, e.question)), + open ? el("div", { class: "choices" }, ...choices, other, el("div", { class: "card-actions" }, send)) : answered.has(key) ? el("div", { class: "dim" }, "Sent…") : null); +} + +function answerQuestion(ctx, e, key, value) { + answered.add(key); + redrawTranscript(); + link.command({ type: "question-response", sessionId: ctx.session, requestId: e.requestId, index: e.index, answer: value }).then((r) => { + if (!r.accepted) { + answered.delete(key); + redrawTranscript(); + notify(r.message || "The answer did not reach the bridge."); + } + }); +} + +function planCard(e, ctx) { + const open = !ctx.resolved.has(e.requestId) && !answered.has(e.requestId); + const feedback = e.revise ? el("textarea", { rows: "2", placeholder: "What to change (optional)" }) : null; + return cardFrame("Plan approval", ctx, e.requestId, + open ? feedback : null, + open ? el("div", { class: "card-actions" }, ...(e.options || []).map((o) => button(o.label, () => { + const msg = { type: "plan-response", optionId: o.id }; + if (o.id === e.revise && feedback.value.trim()) msg.feedback = feedback.value.trim(); + answer(ctx, e.requestId, msg); + }, o.id === e.revise ? "quiet small-btn" : "primary small-btn"))) : null); +} + +// --- the other tabs ------------------------------------------------------ + +function overview(hb) { facts($("bridge-facts"), [ ["Machine", hb.machine || "—"], ["Runs as", hb.host || "—"], - ["Identity", el("span", { class: "mono" }, body.machine)], + ["Identity", el("span", { class: "mono" }, me?.machine || "—")], ["Capabilities", el("span", { class: "chips" }, ...(hb.capabilities || []).map((c) => el("span", { class: "chip" }, c)))], ["Workspace", (hb.roots || []).join(", ") || "—"], ...((hb.credentials || []).length ? [["Credentials", el("span", { class: "chips" }, ...hb.credentials.map(credentialOf))]] : []), @@ -194,18 +882,6 @@ function overview(body, hb) { el("div", { class: "agent-head" }, el("span", { class: "agent-name" }, agent.displayName), installOf(agent)), el("div", { class: "creds" }, ...(agent.credentials || []).map(credentialOf)), ))); - - const sessions = [...(hb.sessions || [])].sort((a, b) => Date.parse(b.lastActivity) - Date.parse(a.lastActivity)); - const agentName = Object.fromEntries((hb.agents || []).map((a) => [a.id, a.displayName])); - $("session-count").textContent = sessions.length ? String(sessions.length) : ""; - $("no-sessions").hidden = sessions.length > 0; - $("sessions").replaceChildren(...sessions.map((s) => el("tr", {}, - el("td", { class: "title", title: s.title || s.slug }, s.title || s.slug), - el("td", {}, agentName[s.agent] || s.agent), - el("td", {}, stateOf(s)), - el("td", { class: "folder", title: s.cwd }, s.project || s.cwd), - el("td", { class: "when" }, relative(s.lastActivity)), - ))); } /** How many of `values` there are of each, most first. */ @@ -217,7 +893,6 @@ function tally(values) { function usage(hb) { const sessions = hb.sessions || []; - const agentName = Object.fromEntries((hb.agents || []).map((a) => [a.id, a.displayName])); const byAgent = tally(sessions.map((s) => s.agent)); $("usage-empty").hidden = byAgent.length > 0; $("usage-agents").replaceChildren(...byAgent.map(([agent, count]) => { @@ -227,7 +902,7 @@ function usage(hb) { const lines = own.reduce((sum, s) => sum + (s.lineCount || 0), 0); const models = tally(own.map((s) => s.model)); return el("div", { class: "agent" }, - el("div", { class: "agent-head" }, el("span", { class: "agent-name" }, agentName[agent] || agent), el("span", { class: "dim small" }, `${count} session${count === 1 ? "" : "s"}`)), + el("div", { class: "agent-head" }, el("span", { class: "agent-name" }, agentName(agent)), el("span", { class: "dim small" }, `${count} session${count === 1 ? "" : "s"}`)), el("dl", { class: "facts small" }, el("dt", {}, "Now"), el("dd", {}, running || waiting ? [running && `${running} running`, waiting && `${waiting} waiting`].filter(Boolean).join(" · ") : "idle"), el("dt", {}, "Transcripts"), el("dd", {}, `${lines.toLocaleString()} lines`), @@ -249,7 +924,7 @@ function usage(hb) { return el("div", { class: "meter" }, el("div", { class: "meter-head" }, el("span", { class: "meter-title", title: s.title || s.slug }, s.title || s.slug), - el("span", { class: "dim small" }, `${agentName[s.agent] || s.agent} · ${Math.round(pct)}%${size}`)), + el("span", { class: "dim small" }, `${agentName(s.agent)} · ${Math.round(pct)}%${size}`)), el("div", { class: "meter-track" }, fill), ); })); @@ -265,30 +940,41 @@ function browserName(agent) { return name ? (os ? `${name} on ${os}` : name) : agent; } -async function browsers() { - const { status, body } = await api("/api/browsers"); - if (status !== 200) return; - $("browsers").replaceChildren(...(body.browsers || []).map((b) => { - const out = el("button", { class: "quiet danger", type: "button" }, "Sign out"); - out.addEventListener("click", async () => { - if (!confirm(b.current ? "Sign this browser out?" : `Sign out ${browserName(b.agent)} at ${b.peer}?`)) return; - const answer = await api("/api/browsers/sign-out", "POST", { id: b.id }); - $("browsers-error").hidden = answer.status === 200; +let browsersAsked = false; + +function renderBrowsers() { + if (browserList === null || !browsersAsked) { + browsersAsked = true; + if (link.ready) link.command({ type: "web-browsers-request" }); + if (browserList === null) return; + } + $("browsers").replaceChildren(...browserList.map((b) => { + const current = b.id === me?.id; + const out = button("Sign out", async () => { + if (!confirm(current ? "Sign this browser out?" : `Sign out ${browserName(b.agent)} at ${b.peer}?`)) return; + if (current) return signOut(); + const answer = await link.command({ type: "web-browser-sign-out", id: b.id }); + $("browsers-error").hidden = answer.accepted; $("browsers-error").textContent = "The bridge did not sign it out."; - if (b.current && answer.status === 200) return refresh(); - browsers(); - }); + }, "quiet danger"); return el("div", { class: "row" }, el("div", { class: "row-main" }, - el("div", { class: "row-title" }, browserName(b.agent), b.current ? el("span", { class: "chip" }, "this browser") : null), - el("div", { class: "dim small" }, `${b.peer} · signed in ${relative(b.sinceMs)} · seen ${relative(b.lastSeenMs)} · by ${b.by.slice(0, 16)}…`)), + el("div", { class: "row-title" }, browserName(b.agent), current ? el("span", { class: "chip" }, "this browser") : null), + el("div", { class: "dim small" }, `${b.peer} · signed in ${relative(b.sinceMs)} · seen ${relative(b.lastSeenMs)} · until ${new Date(b.expiresMs).toLocaleDateString()} · by ${b.by.slice(0, 16)}…`)), out); })); } +let devicesShown = false; + async function devices() { - const { status, body } = await api("/api/devices"); - if (status !== 200) return; + if (devicesShown) return; + devicesShown = true; + const { status, body } = await link.page({ type: "devices" }); + if (status !== 200) { + devicesShown = false; + return; + } const list = body.devices || []; $("no-devices").hidden = list.length > 0; const now = Date.now(); @@ -317,8 +1003,8 @@ const FIXED_LABELS = { workspaceRoots: "Workspace", torProxyUrl: "Tor proxy", nodePath: "Node", agentHostPath: "Agent host", testMode: "Test mode", "direct.listen": "Direct link listens on", "direct.onionListen": "Onion listener", }; -// The form is built once per visit to the tab, so a poll does not wipe what -// is being typed. +// The form is built once per visit to the tab, so a heartbeat does not wipe +// what is being typed. let settingsShown = false; function shownValue(v) { @@ -329,9 +1015,12 @@ function shownValue(v) { async function settings() { if (settingsShown) return; - const { status, body } = await api("/api/config"); - if (status !== 200) return; settingsShown = true; + const { status, body } = await link.page({ type: "config" }); + if (status !== 200) { + settingsShown = false; + return; + } const fields = body.fields || []; const editable = fields.filter((f) => f.editable && SETTINGS[f.key]); $("settings-fields").replaceChildren(...editable.map((f) => { @@ -371,24 +1060,24 @@ $("settings-form").addEventListener("submit", async (event) => { } } const result = $("settings-result"); - const answer = await api("/api/config", "POST", { set }); + const answer = await link.page({ type: "config-set", set }); if (answer.status === 200) { result.className = "small ok"; result.textContent = "Saved. Restart the bridge to apply it."; } else { result.className = "small error"; - result.textContent = answer.body.error ? `${SETTINGS[answer.body.key]?.label || answer.body.key}: ${answer.body.error}` : "The bridge did not save it."; + const body = answer.body || {}; + result.textContent = body.error ? `${SETTINGS[body.key]?.label || body.key}: ${body.error}` : "The bridge did not save it."; } }); window.addEventListener("hashchange", () => { settingsShown = false; + devicesShown = false; + browsersAsked = false; render(); }); $("start").addEventListener("click", start); -$("sign-out").addEventListener("click", async () => { - await api("/api/sign-out", "POST"); - show("signed-out"); -}); +$("sign-out").addEventListener("click", () => signOut()); refresh(); diff --git a/crates/bridge-runtime/web/index.html b/crates/bridge-runtime/web/index.html index bd7d1341..a8ab5f6a 100644 --- a/crates/bridge-runtime/web/index.html +++ b/crates/bridge-runtime/web/index.html @@ -11,7 +11,7 @@
CodeDeck+
- +
@@ -20,7 +20,7 @@

Sign in with your phone

-

This page shows what your bridge is doing. Only a phone paired with it can let a browser in — there is no password.

+

Drive your bridge's sessions from this browser. Only a phone paired with it can let a browser in — there is no password.

@@ -35,6 +35,7 @@

Sign in with your phone

  • Open CodeDeck+ on a phone paired with this bridge.
  • On the machine's page, under Web page, choose Browsers.
  • Scan this code, or type it.
  • +
  • The phone shows this page's certificate fingerprint. Check that the certificate your browser accepted for this page shows the same SHA-256 before you sign in.
  • @@ -42,6 +43,7 @@

    Sign in with your phone

    -
    + + +
    + From 3246a6262bc06f863bbc346b8bf902b6e1ca3f40 Mon Sep 17 00:00:00 2001 From: deymosh <232244450+deymosh@users.noreply.github.com> Date: Tue, 17 Nov 2026 23:44:02 +0100 Subject: [PATCH 5/6] feat(android): check the page's certificate before signing a browser in A browser opening the bridge's web page meets a certificate warning, since the certificate is the bridge's own; whoever sits between the browser and the bridge can only be caught there. The phone already pins that certificate from the bridge's signed heartbeat, so the Browsers page now shows it before a code goes out: a scanned or typed code lands on "Check the page", with the SHA-256 written as browsers' certificate viewers write it (uppercase pairs, colon-separated, eight to a line) and the code, and only "They match: sign in" sends it. The machine summary carries the pin itself (directCertSha256) besides directPinned. The lifetime the page states follows the bridge's: signed in while used, ended by 7 idle days or 30 in all. Co-Authored-By: Claude Code --- .../plus/ui/screens/MachineWebPage.kt | 76 +++++++++++++++++- .../main/java/uniffi/client_ffi/client_ffi.kt | 10 +++ .../com/codedeck/plus/ui/DesignFixtures.kt | 1 + .../codedeck/plus/ui/DesignSnapshotTest.kt | 5 +- .../codedeck/plus/ui/screens/WebSignInTest.kt | 9 +++ ...DesignFullPageSnapshotTest_web_sign_in.png | Bin 17773 -> 18644 bytes ...plus.ui_DesignSnapshotTest_web_sign_in.png | Bin 60809 -> 64157 bytes ..._DesignSnapshotTest_web_sign_in_asking.png | Bin 47010 -> 50545 bytes ...shotTest_web_sign_in_check_certificate.png | Bin 0 -> 73742 bytes ...ui_DesignSnapshotTest_web_sign_in_none.png | Bin 47421 -> 50939 bytes ...DesignSnapshotTest_web_sign_in_sending.png | Bin 59314 -> 62685 bytes ...signSnapshotTest_web_sign_in_signed_in.png | Bin 31992 -> 37851 bytes crates/client-ffi/src/views.rs | 5 ++ 13 files changed, 101 insertions(+), 5 deletions(-) create mode 100644 apps/android/app/src/test/snapshots/images/com.codedeck.plus.ui_DesignSnapshotTest_web_sign_in_check_certificate.png diff --git a/apps/android/app/src/main/java/com/codedeck/plus/ui/screens/MachineWebPage.kt b/apps/android/app/src/main/java/com/codedeck/plus/ui/screens/MachineWebPage.kt index 29fc51d8..e8de181b 100644 --- a/apps/android/app/src/main/java/com/codedeck/plus/ui/screens/MachineWebPage.kt +++ b/apps/android/app/src/main/java/com/codedeck/plus/ui/screens/MachineWebPage.kt @@ -5,8 +5,10 @@ import android.content.ClipData import android.content.pm.PackageManager import androidx.activity.compose.rememberLauncherForActivityResult import androidx.activity.result.contract.ActivityResultContracts +import androidx.activity.compose.BackHandler import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.Row import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.foundation.layout.fillMaxWidth @@ -158,6 +160,12 @@ internal fun MachineWebPageGroup(machine: UniffiMachineSummary, onOpenWebSignIn: * Under that, the browsers signed in now ([browsers], null until the bridge * answers), each signed out with [onSignOut] after a confirmation; * [ownNpub] is this phone's identity, which a row does not repeat. + * + * [checking] is a code scanned or typed but not sent yet: the page asks the + * user to compare the certificate fingerprint the bridge pins + * ([fingerprint], lowercase hex) with the one the browser shows, since the + * browser's own warning is the only place a man in the middle shows up. + * [onConfirm] sends it, [onCancel] drops it. */ @Composable fun WebSignInContent( @@ -173,14 +181,22 @@ fun WebSignInContent( now: Long, onSignOut: (UniffiWebBrowser) -> Unit, onBack: () -> Unit, + checking: String?, + fingerprint: String?, + onConfirm: () -> Unit, + onCancel: () -> Unit, ) { var confirming by remember { mutableStateOf(null) } + if (checking != null) { + CertificateCheck(checking, fingerprint, onConfirm, onCancel) + return + } Page(title = "Browsers", onBack = onBack) { if (signIn?.state == UniffiWebSignInState.SIGNED_IN) { EmptyState( icon = Icons.Outlined.Check, title = "Browser signed in", - body = "It opens the dashboard now, and stays signed in for 30 days or until it is signed out.", + body = "It opens the dashboard now. It stays signed in while it is used — 7 days without it, or 30 days in all, end it — or until it is signed out.", action = "Done", onAction = onBack, modifier = Modifier.fillMaxWidth().padding(top = Tokens.Space7), @@ -236,6 +252,48 @@ fun WebSignInContent( } } +/** + * A certificate fingerprint as browsers' certificate viewers write it: + * uppercase hex pairs joined by colons, eight pairs to a line. + */ +internal fun fingerprintLines(hex: String): String = + hex.uppercase().chunked(2).chunked(8).joinToString("\n") { it.joinToString(":") } + +/** + * The step before a code is sent: the certificate the bridge pins, to compare + * with what the browser accepted for the page. A page whose certificate + * differs is served by something else, and signing it in would hand it this + * machine. + */ +@Composable +private fun CertificateCheck(code: String, fingerprint: String?, onConfirm: () -> Unit, onCancel: () -> Unit) { + BackHandler(onBack = onCancel) + Page(title = "Check the page", onBack = onCancel) { + Group( + title = "Certificate SHA-256", + footer = "Your browser warned about this page because the bridge's certificate is its own. " + + "Open the warning's details, or the site information beside the address, and compare its SHA-256 " + + "fingerprint with this one. If they differ, something between you and the bridge serves the page: do not sign it in.", + ) { + GroupBody { + Text( + fingerprint?.let(::fingerprintLines) ?: "The bridge advertised no certificate.", + color = Tokens.Text, + fontFamily = Tokens.FontMono, + fontSize = Tokens.TextMd, + ) + } + } + Group(title = "Code") { + ValueRow(code, mono = true) {} + } + Column(Modifier.fillMaxWidth(), verticalArrangement = Arrangement.spacedBy(Tokens.Space1)) { + PrimaryButton("They match: sign in", onClick = onConfirm, modifier = Modifier.fillMaxWidth()) + SecondaryButton("Cancel", onClick = onCancel, modifier = Modifier.fillMaxWidth()) + } + } +} + /** "Firefox on Windows" from a User-Agent, as the web page names it, or the string itself. */ internal fun browserName(agent: String): String { if (agent.isBlank()) return "A browser" @@ -271,7 +329,7 @@ private fun ago(ms: Long, now: Long): String { /** The browsers signed in to the page now, each with where it is, when it was last seen, and Sign out. */ @Composable private fun SignedInBrowsers(browsers: List?, ownNpub: String, now: Long, onSignOut: (UniffiWebBrowser) -> Unit) { - Group(title = "Signed in", footer = "A browser stays signed in for 30 days after its sign-in.") { + Group(title = "Signed in", footer = "A browser stays signed in while it is used: 7 days without it, or 30 days after its sign-in, end it.") { when { browsers == null -> ValueRow("Asking the bridge") { RowSpinner() } browsers.isEmpty() -> ValueRow("No browser is signed in") {} @@ -311,6 +369,9 @@ fun WebSignInScreen(core: CoreHost, pubkey: String, onBack: () -> Unit) { var scanOpen by remember { mutableStateOf(false) } // Each send waits for its own answer, a resend of the same code too. var attempt by remember { mutableIntStateOf(0) } + // A code scanned or typed waits here until the user has compared the + // certificate the browser accepted with the one this machine pins. + var checking by rememberSaveable { mutableStateOf(null) } fun send(sent: String) { notice = null @@ -344,7 +405,7 @@ fun WebSignInScreen(core: CoreHost, pubkey: String, onBack: () -> Unit) { notice = notice, code = code, onCodeChange = { code = it }, - onSend = ::send, + onSend = { checking = it }, onScan = { if (ContextCompat.checkSelfPermission(context, Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED) { scanOpen = true @@ -357,6 +418,13 @@ fun WebSignInScreen(core: CoreHost, pubkey: String, onBack: () -> Unit) { now = System.currentTimeMillis(), onSignOut = { b -> scope.launch { core.dispatch(UniffiIntent.SignOutWebBrowser(pubkey, b.id)) } }, onBack = onBack, + checking = checking, + fingerprint = machine.directCertSha256, + onConfirm = { + checking?.let(::send) + checking = null + }, + onCancel = { checking = null }, ) if (scanOpen) { PairingScanView( @@ -366,7 +434,7 @@ fun WebSignInScreen(core: CoreHost, pubkey: String, onBack: () -> Unit) { when (val scanned = readSignInQr(text, machine.npub)) { is ScannedSignIn.Code -> { code = scanned.code - send(scanned.code) + checking = scanned.code } ScannedSignIn.OtherMachine -> notice = "That QR is another machine's web page, not this one's." ScannedSignIn.NotSignIn -> notice = "That is not a web page's sign-in QR." diff --git a/apps/android/app/src/main/java/uniffi/client_ffi/client_ffi.kt b/apps/android/app/src/main/java/uniffi/client_ffi/client_ffi.kt index 7b5b982b..8658f662 100644 --- a/apps/android/app/src/main/java/uniffi/client_ffi/client_ffi.kt +++ b/apps/android/app/src/main/java/uniffi/client_ffi/client_ffi.kt @@ -6333,6 +6333,13 @@ data class UniffiMachineSummary ( */ var `directPinned`: kotlin.Boolean , + /** + * The SHA-256 of the certificate the bridge's `wss://` listener serves + * (lowercase hex), as its signed heartbeat pins it: what a browser + * opening the web page must be shown, checked before a sign-in. + */ + var `directCertSha256`: kotlin.String? + , /** * The direct endpoints the user added, tried after the advertised ones. */ @@ -6414,6 +6421,7 @@ public object FfiConverterTypeUniffiMachineSummary: FfiConverterRustBuffer Unit> = linkedMapOf( "web_sign_in_sending" to { WebSignIn(UniffiWebSignIn("K7QM-4XTR", UniffiWebSignInState.SENDING), code = "K7QM-4XTR") }, "web_sign_in_not_matched" to { WebSignIn(UniffiWebSignIn("K7QM-4XTR", UniffiWebSignInState.NOT_MATCHED), code = "K7QM-4XTR") }, "web_sign_in_signed_in" to { WebSignIn(UniffiWebSignIn("K7QM-4XTR", UniffiWebSignInState.SIGNED_IN), code = "K7QM-4XTR") }, + "web_sign_in_check_certificate" to { WebSignIn(signIn = null, code = "K7QM-4XTR", checking = "K7QM-4XTR") }, "settings_agent_opencode" to { AgentPage("opencode") }, "settings_agent_claude" to { AgentPage("claude-code") }, "settings_agent_not_installed" to { AgentPage("deepseek-harness") }, @@ -482,9 +483,10 @@ private fun AgentPage(agent: String) = AgentSettingsContent( /** Signing a browser in to the workstation's web page. */ @Composable -private fun WebSignIn(signIn: UniffiWebSignIn?, code: String, browsers: List? = signedInBrowsers) = WebSignInContent( +private fun WebSignIn(signIn: UniffiWebSignIn?, code: String, browsers: List? = signedInBrowsers, checking: String? = null) = WebSignInContent( signIn = signIn, noAnswer = false, notice = null, code = code, onCodeChange = {}, onSend = {}, onScan = {}, browsers = browsers, ownNpub = workstation.npub, now = NOW, onSignOut = {}, onBack = {}, + checking = checking, fingerprint = workstation.directCertSha256, onConfirm = {}, onCancel = {}, ) /** Two browsers on the workstation's page: one this identity signed in, one another identity did. */ @@ -575,6 +577,7 @@ class DesignSnapshotTest { @Test fun web_sign_in_sending() = paparazzi.page("web_sign_in_sending") @Test fun web_sign_in_not_matched() = paparazzi.page("web_sign_in_not_matched") @Test fun web_sign_in_signed_in() = paparazzi.page("web_sign_in_signed_in") + @Test fun web_sign_in_check_certificate() = paparazzi.page("web_sign_in_check_certificate") @Test fun settings_agent_opencode() = paparazzi.page("settings_agent_opencode") @Test fun settings_agent_claude() = paparazzi.page("settings_agent_claude") @Test fun settings_agent_not_installed() = paparazzi.page("settings_agent_not_installed") diff --git a/apps/android/app/src/test/java/com/codedeck/plus/ui/screens/WebSignInTest.kt b/apps/android/app/src/test/java/com/codedeck/plus/ui/screens/WebSignInTest.kt index 5a37ace7..fa3e597a 100644 --- a/apps/android/app/src/test/java/com/codedeck/plus/ui/screens/WebSignInTest.kt +++ b/apps/android/app/src/test/java/com/codedeck/plus/ui/screens/WebSignInTest.kt @@ -26,4 +26,13 @@ class WebSignInTest { assertEquals(ScannedSignIn.NotSignIn, readSignInQr("codedeck://pair?npub=$npub&token=x", npub)) assertEquals(ScannedSignIn.NotSignIn, readSignInQr("codedeck://web-sign-in?machine=$npub&code=", npub)) } + + @Test + fun the_fingerprint_reads_as_a_browsers_certificate_viewer_writes_it() { + val pin = "3f9a1c0e7b2d4a58c6e1f0b9d8a7c6e5f4d3c2b1a09f8e7d6c5b4a3928170615" + assertEquals( + "3F:9A:1C:0E:7B:2D:4A:58\nC6:E1:F0:B9:D8:A7:C6:E5\nF4:D3:C2:B1:A0:9F:8E:7D\n6C:5B:4A:39:28:17:06:15", + fingerprintLines(pin), + ) + } } diff --git a/apps/android/app/src/test/snapshots/images/com.codedeck.plus.ui_DesignFullPageSnapshotTest_web_sign_in.png b/apps/android/app/src/test/snapshots/images/com.codedeck.plus.ui_DesignFullPageSnapshotTest_web_sign_in.png index 689786643bce4bb6ffdc7843e803d1f41dd13c71..2e9d1ae555c297759e2dbe90bcac7289c5736e16 100644 GIT binary patch literal 18644 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 E0zdbwqW}N^ literal 17773 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 diff --git a/apps/android/app/src/test/snapshots/images/com.codedeck.plus.ui_DesignSnapshotTest_web_sign_in.png b/apps/android/app/src/test/snapshots/images/com.codedeck.plus.ui_DesignSnapshotTest_web_sign_in.png index 30b4fc82d4cd021d90812168822e892b781bb0c2..45ffcad7dd8dd1d6116bf45a9366448be6a30062 100644 GIT binary patch delta 11564 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 a@=905ZOL7Y<^DfNAJiiaWRZf2-~RzZ?1Ga3 delta 7996 zcmZ9QWmHt%`}Y+QMnT{J0!j=FDP7Wnz|bY4f^?{Km*k-t7#aknL&_Tvq`O-gN@|cC zKw{|5XZ-)(J?G_K=lWi~_S&C}qdO7kJ8{f-*cTP7HNQZ~%EE6yxJlWA@dOcwfS*N( zTn^1AoSFd~L-&{PKcs$m^G@lV(kmIaBQ!iG=+f7#C*@TD5@$|`T z;9|#JkkkZmlIb(VFnNxx4)3)3QcMC@s?!iO<{x;9$Q+KSqzayY9|75j%z%AODGr^# zxrWw``}cu-F;r$`tDy(9Vx&RGqiA%BkI4JMqpc>y*x;)dbGy~;=f&!kOn)rcnV)4;V z802m{lWWXv?PRjdPO7mZi!9Vkb?AiEM;fz6>+ng1&DbZ8%PiQtE-xuubM0DJuHV8s zG{7D8wILIybpz_x=>|aNBU#~)zk#uz8Hug$RE6%A0He>1oH?khcaJVt2IuoLHGFdH zya;r-Dk~4Dn6e#;4(duNo|-)%JffZe%umO4b|p;!0|_fHik9qOFz^w zkCH2beTDN+tEOFrL&$tcJ#Q^rA9VV>frG-LwR*S`3Hstnq`kW`_+3OHAnz1Ce?6J5 z_^}`)+|$4bEDLVEK5DhImuCXnWmOz3yKa1&Pj05opRZQcx=c|{F4!RyPpdB1wQd~N zV-)boj@netYy(GJ#DYAS=R?ywhk`D8V*qy4)epKRndgz(Qp~HThg~Jgw}uiyY>{+E z$h>%ZW%-f1_|P95R%3!^|)pDkSaCw2}@`w>&!)+1vaM zW_iwVyl)>ulrxY$L_~APpDuML7|9zi72Pu@&FS?t>}+^68aO;i4zw}7GE8HIkjaz{ zT|aqk>Awcx$&Wpj^QAQ<-D?H^Z%#-U?8?<&Ar~Vj;rtqHO)kZr;tR@RZr04q;{Kh@ z%L-r6Bm4-Kg*Io(x3)03&!Y>HHM|bGkEfc+${tRUkg3?^9Gb^j-`W4#5}=VyjZpoS@HD-;TCRg~TSv#@%hZ761I{O~V|n=}tgsr|%ueMj;Mij}_6c(VOA}-JbR|&` zzf62$$vl6n)?;5cSqKySI^g~d5;|82!y_Qnde;)53Nv?%fJ`v)YsjBw2y(A!P{fiJakyj$dsOcyn5NYcebfkL2cmj&7_lGFqs^p zLsCfJ0DatoDEjX|HAO{5A_qrGoO#!AU~Biz(m#b;Z!&~L^9CN`PC1FLsahK;uKkqY za5c5GVpy}vzvzn&&&cvtJx`($MWv;s-;5sr6Y!t=6gdA!6oxm0mZXd(`)5rP3bvt^ z96bkWcRnLb0|_?}%*fZ%|K}|T>_%-52MuIA1Qur?#?>YFsd48ugqNJx?%_4=+cAiR zQ;nKTr_-e4b0Ve?GPEl%ez@AAiRZ%S%|8^tb-p12(!opqFY~SmeEjPq(Z^7+;qoy& z^EHJK$?j1NTT01{7Z4C<+T9+zq~+h*Bc%(e?0x$eO7bwB^+lJ!eM#eqV1CHy0WIm zLG*6db|eHEpZ(&+tMsb;?&N>6$FPCx>&5Q?q73{K^ZZpfV%L^M%*^)VX;LYFDQ2@E z6xWAl0)OBJk=13gz4REdK>-*m3qO6z9vsYEe>Wvk73bx2B9HV`{&K0UtuHl8>XioG zzd#CGTBJpr+r7vgM)JEta59b&+p~*N{^xi%diK&6jhyOn#U(vGY+P*=?3xCr1R!fc ziswCCKB$GYT~B%W!k;&bgnQwysr-r@000@Wy=}~;ZmNmETNQdLhO57eSTi=tqsm1SFRGGTb2}2NFko89*ig7nd9)0#_0;Ic4}384pis|L$)8 z*NO_2hup_3gd}vz1cXWn%t|ra`j2B6uzHL> z;SM`0lZTBIDlJ4fH9Q>Wg>7ql;j%Vlw|}_4iMhTC@1L5gi}?Oa`sVViAA?0}v9TR{ zODg%ccpnXI?5>X~{D=CZ9PXGk^==x3Mj+@5^OpbW7hW@+o$ev8cz_C@n3K8Yv!}g2 z9;mgud11i~PK*03WWcXqJgeM8>Ef-WC~$W{OsTH0=xum!!3yK-?MCX_v4ohl z7bV&DvA}BP$xMG12VccOJAS*nyI;t`PcQ8zoT<#6_m)$ge9JA)@}-TNK3a?r%49qT zmGnwVF4H5c#wR9N4-T|=f;=E*HF%qcsJ}#2!>AMtqd*kZ1w&+y*OS|{giB~)h zS$=+Z`ZqRER2m7Zqv_(M?tDj@1tB;P3 zip#ktVV?t9E9HI|uKCNDO~&{3^z<|#ZZjE0F&?actsgh!K*4Sdk!DQ4a)MW+rARx4 zWNx}f!M`umHW;EDI3%|NnYMSJ>Ytd_7d?~SZ*iQZgOhjFDx<&g88v)xpP2TtyJKI_ zzPf8<%$B&^d$At{Qoq-FG(xqs|IEK>espIbXMSSBsnqk8KYq7RYHDhUot1&12}j0k zFoeW9mp;@hdeGc%%dpJBOH&*cbe>0SO}p+B{r$IE=zzKh{0}uYP~Ei+f{A zK6zI>Q)qyP%-4)^z0_Vty{%M1EU(wr9=Xqt9sHYXjwEb19vnojbQ?{D&1HK`X4Kl&1C-r%g5_+zP>R|~wXG<3 zlltS7WNE##5V`w=i)+Sft5n>6G{wcmXz}os(IfGCUvc_=#vknmO~YmkDd#Xp8u0@9 zzTQwGP*-(AT<(L}V(6b(sXfs%*iZUMk*JbbyU-P6B5N!r*gNl89Q7!@#O)}y_2tx+ z6)lmOyy#&Ma|_kReCa1y7bj~xj+bmLF&E4<9HRS|OWi-Jvtps(fNRoQ?Od%af6E?` zbgJyxBCdV;i?!<{rDA@OG5pJzAB?4!8JXwBpo*fRrhbd^+RvZzgV6YIb)a#x#HUS} zByp^5o-Gvz*8r>fNri>c7q50eTXgcfRthEA*Iz3mrDxgSw04M8f^Q+93)j=xRT3$R!^(`G4 zu!Ras7yw8)=Iw`pLMgyKr_ce$y0r3Wgp)Q4E2cnC=T_~Sqq!8eK zG<1-T>rn~*x)&Zp4YXH_0TS`8GMb>9wRN{dP8LN$-h6{QintOQ?R2%Z#k}csU3+yU z{~>!;KV~Q$&&1HzkzmMESuu9*_AWX#RbMFe(!ph4b--%0nAhZbZo6~mjJPv2QA=_& zt0Y)Z|6r1ei#_wH)RrP=TTwvOGNNhE#@c#N!?I4QY(7zNRdOK3){AYOr5W^hQ?EBG z=lA#TYPUqtM=zGnFBaZ7hP3Fh*>S)&o$kD>TVcgE9!YzhH#xB=N2F9Pd5 zY&7uLdWakte-t(yZY|I?-hFteUe?slPC_UvZ+w>SV=inRel5|`$uvAsq_eH$HOwGz zyiyX;M-KRgRjhuQrHEH(1hX@!gnC+L0eXbWB(LpD?OPj&9p4rXp%9)S))Mw~hILbX zEhwj_@brxL)Bs(DT&lBG&Z()X>~wh|ER$UJbXW;l?c3D~r*g;es(IB4{&r3+ys&lPE8-@~_IU+>h540LGk%Z-(vDR*yR=hkCY%lucq;ijy9(&mFzBVAo9--GMtk`Sg1$W7Jh&wB9F zAF_J!S?%p+TtqkYE3)TB7AA^S_5($Yjk+WTu%$-9Xl3-|$W_Dbd|>qR@~%EmfimYP9^IlH7mn7`e zF|WK7i!kfLQbOrrZSkYdULK#RD1F6t))nw`mR$zENO||thFu6O}mZPl%NUcD_LBHS^0&W_j6lN=fXv9GMYY+1mc zz>?4kxWrNwwLXPxtEb$lzwreOikNu;XUrWm(t3zQnA^fWl3=;ETo3&QlnstqVFLuc zL9*s7NP$}tBJ^=y4ZnCxSPV7q&_lBj@UGq_f=H0ew2GXTS%NmNzI@rmM4|v~F=x6I zD9jJDOl?DTTGVyCUUlf&or)sO(~kO#ay^w&>~eEb)QkEkB^4f@Ao|=Gp45m88hMh( zH}F_?Y0{(1i?_NwVSd3-;Ca-lb5WM`l{pY|WF6}vwCk_h`DhFJa+AgB6hlE{wAeNH zln$IFBvg5}a7p%3Iu}4@>cMxp{i$PF z=^1DcNm|@*MdZDR_;{TUl?cI+^?AP*8ULyJYU(AMaV_6u>0y?~ed=aa*N+)j(h zO%!<>UNc+r0NU4__E7?gWOq9L4h8G5vl!brl*A!Se~T!x3DqY363Gr zR|9U++X{UTm^+opnYZal=!0UQlAOel^^7!Efq?=)AN_${IzKO;gv48R0f8H$bx3wEJdv_Lm=O4#} zDR8(@*y z?kuLYeIu$GYVZ))>lptC-zmJbvfYD8Z-hzk)i4A}E&No&4l$Aka^yDiv!gon29j$S zkdWFQ%K z_lK*6(ot9kTBnS35Tb2t^9K=!=nGX?uM#$VYy%;6jqp%N0LF)g(Vj(=wi(O2Z?GVnq{&ZiT|HA{6#OqwgpM8ytDiE?S|2>o!^z=8GvmJCp*7>iNO$a-lF#J^UAyBT5DL+EPYaBF_4 zA>~?225*eqA5T?Yny({^kSljF_FCG7-f^l@IUGLRrV`XBpkfn1L5KXpGJ<^M{{{$% z%|d&@hp6@+(UD|Ub+5;GX7#H=Z8nk7Y%YyD9lnXN<>?|Y7zb&{eIRpqc%ezz(R!eRyznSPLs{iLwZX{OMQC4sLm&j#`9LU$C za3lDHkk9!vD@IgXlbwUvCKlEIBHY=_OAs~wE6wxe2`>xmvWO@zMCVfdy0CtkspF%_|MU-f|&*3+ydLT8r)@X&KsR z_(x0mS9d?fDz|?zd)Hy%BH)dQezU3YT#q$1-+9}zbAyl2-!xnGR~57&fs#?+1-z~gcb%YW8n4FZdvG$Z~9 z8-bvARVtE<-zX)>Hy#(lzr1J}hYtC3H41UE!up_Bi5@Y3b4^TV0o1HaRI)uBJ}g2O zS4P5%_5dZHB~RoxSZA?1Tf~pI)lArIo*T$+>CERK+7_4i{e*#$ z#X>=jgA(kwS(Fx0*LpU%lOQv5*Y8*LNZ}igJ-k^t10z5)FV9k=Ymayaf_=j9>LEGc zFktz6h6_cC#>0kIadS)6UiZ#WcqD3TN}HD(!SDii2pLPDdw@ynU}Ozu;BQDNS6*{B zQC27%zUp;F6J?&K=|Mh>KpJ&=+CAv37=HU#n5KJu-N%biSO5fL6Jle39}Uo02KDWp zJlA{2bL>j8-x3`ruOugyd_g_4qos6YjqeHH3ej-yf`wXIB;i)8@P)eBr4#uIgEjJ? zs{%ONMXfoezpzW|^LB4&gpg+s8 ztK(YH z9gH;8Skbs*A|TUPK~RCiz{=?w1oX9u^Wv)cK(-CFzndwzZFFwc$F@BPth8)w#ep{w4buO};mp2^1hQCEn~ zq-r|napqYj3|4un=F7`>oPt$KRqewJ!*i!|I};phpS=cnq}75%wBAajRVHm}ZS#L~ z-pn(51lE_L^$ni@6+~plN@5FkqG-rE!fjNw`41|K>DEeAZk>Z9^&_*{*#lbS_DZjp zlg1nI1cwm4V!@uz@9cGdaqhg_ymw#2zHVN`p{V7`-_w5$MCNoM?2lG-#$StL!?n%D z?X&fF*Q1ph4NMHNga76HJa?FVHScy+CWU^^01o!E>pX#=%sV_Q?Z*qhxJ=vJ@J*yl z4(1EEhsm>UF`)Xst(7Ll$05ir$fEFuK5Hu#Kjo2p&=J9rkaqFRlpuBZ$p}NooKJT# z@{j#|RKwdrN(L$R5O@fgfj_BgaOmE>+smKDQ)_4FZgqrt>C)YDEf0zMLOy0dpdij{ zQy>&6Rv2=0r}1dUo{0t4)e|mMuL&-$9_I9XxaI)rV?ihX!JEXZ1d$}(A^ zML)6BR}>Vv<>-!iFUPJGgB>{V3gtt|_!}0E;aFrGVoGOMM0{?+b9;8X$s%*o`M}q> z@IOTs9N&YP$F`?kcx)<&Zrghka-Anj{-b^{^Wfd{$&nGEW0K&5HFoS#LxtXg`-tUG zx>gMRrmEkNdvo)h{;saCS2cx&qSp5IYMNP~becD{oUX2x%Ra{X!p`b%Nb|9m`BH+0 zP7>`sai3$~(FqT+lSkigp1IrnoLdzY6SLbfTgc4FF!IhQ{l^;-s$-+02~uAB5?(jg zy_oi3b{ym5OZDrWWVFc z#tz3xSzw%ynA58Z6qTRpw}3vpJTLq^Bf;jd+~zC9J%rB*1ExTtj-)V?6-IWu>1{%- zx(iS1+H@0D!z)a79Acre7%aB-xq5oS@-k4l-qrGr4)lMb_i`8hG(zoc7!5B10w9IV zKj2-VL@Da{bmF7&4Qo?V^+EB7)z#$jYCdCb_R2~kwp#(k5$>rjOSyV1cmm{eu4aq* zSPYJr>IPHb6anogBv1z}<7RJLom*pLLjCJw%PMMWwyUXN$P4(w>^~BUgQu&dS*BQc zGUDUG2Uab(luymOF^<{bYD%fj;JQ7zf^x*^J1@x2+3w;21_xMF{F-so`L6}{cN(n9 z6(VAxtv`;)pfdg{Wk!u(9{1z!^hVD$y9aRJ)?bm33DaF#R6MhiE1m)j7g9*k5B$Zt zPVjD0)aBdS08`Umc>zG+sXLlVSn#TX9%k-J#Kj8xA4`r5sPlA`uJ<{S9a#J!9kl+S z<`tCzg@Bk?LP?2lg?+L=7SH^av$j1f=uqVqP8v75ibI(hy7{JP+Yf zb%QNfX#;^e$CFFL;u`xKzl*CcK)*5xpk16seKG{8fCK)xY976QoWo*kdn!cc17y`HpR8S!?udc#j$!n z_H%EHJNg`XeVsGT8)u24vX}kvkthBkj5`Oh;PhX9{-Ozr2d@Xx4FjgKvF(z4Ff2QyCz* zyPLFsmd;XUytw0k;d2AdZ9|c!8$nMYC9%6o2I1klxNXL5C(KnM*!_OGkn`TsYlG9i u@i0z(2vcIBFYW(_@}d7j`3U-jo7+HNrD)5?=l-{FpNfJeyiCqC=>GvOEwu0e diff --git a/apps/android/app/src/test/snapshots/images/com.codedeck.plus.ui_DesignSnapshotTest_web_sign_in_asking.png b/apps/android/app/src/test/snapshots/images/com.codedeck.plus.ui_DesignSnapshotTest_web_sign_in_asking.png index f1122d3f1f19e0c37d8902497c9b20556c1c827a..d09bb401fb18642f7d359c6d9f8363c1ae3abc4e 100644 GIT binary patch delta 22937 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 N002ovPDHLkV1m?3{2KrO delta 20722 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 literal 0 HcmV?d00001 diff --git a/apps/android/app/src/test/snapshots/images/com.codedeck.plus.ui_DesignSnapshotTest_web_sign_in_none.png b/apps/android/app/src/test/snapshots/images/com.codedeck.plus.ui_DesignSnapshotTest_web_sign_in_none.png index 9f5501b3c568595c0a99cf8fcaa55ac9eead9431..9c1245a5635378319a95c251b56ecd13da2de104 100644 GIT binary patch delta 23321 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 JO4%~>{{YnR2;~3( delta 19772 zcmaI7byQUE_XethGBgK}lp0zjMx;w%=oST$ZWZayBOwehGzv%w7+?Sb(lvC4AUV=V z4c&bYpYQLVyVhOzzgcJA^XA_BefG1Ta~gwJw{s(&{YDl3Pfj^|P$PE7DZN)BLQP6o zs-{$8DZf`QJyg`;SJ!J~e1{$@Mfo@p3y1T0bm)wiJL*WO zK3=51O$GFP=Y3)aqE30?NF9bKYGNbUIx>pos0L-jM2!wBWiPt%^u& zAL!3+$Zwokp9(Bq{vMM>1JGH9T_Z*)#StyuwZj@edo~#fqZCe4dxS2~cbMpWWzy;z&iP8+0?Y1$L%@VTyg@ukN`tUeqR zf<`dDJuR!nGTrv!ecZUaa8~a7cpSrcrK|B5cvFiypoipv`xn?e+?irUW18ndp zm=bb28aATcLEoj=S?fz2-BgWVIp98x%3mu%eTbdg8GHc*+lTHZ#tn{*nUtWTX^UVA z!D;N{^vs!&u=-5kOKQp1V-Z2o+cKgNWSPq@;N7qPw{TfnAX%LFf5Eos0gyBQ6hRq0VhdoJbeUi(Y`g8V5_HF3+Q^ z6yBUPZy}gGy5D8aR+==;?R~7T=e_3{qiXS_8&|>c8-Bx;swg@F505z|qAm2dUS*yz z5PU82@CnK1__mKj-vHoF_xBhqt&}sNS?<(Gq8LV3YE9_ z$b3vQ)Ya}ihw|NXy+R%k?#41$ojmt1pz!8YERMRrY}T4n9jVZhJ~RIaMcG0+`4kMf znWxTa&{mMJJ>hzAqseBp5D(MgEjU~%afv8t^5?@>yi?>V0*CuWY$+fSjT1D(H(fG$ zgtj(p6gB>DBkscCa|{#<3e>07cK-9CB0WSFjuBPvv>!o+PHZthF){!45A;pqcVV?* zeSQ7I8ffmE(8}kxml`RAZwUTUH8`lg(?6_U&&-grS^vJEsC9#%IQxdqwDosxX~f@5 z&nDr>Y(iKeMY)WxeZ7v?m8`7X zZkncs(8V-TE{%BQ4~|8n;0llrQUHKbSW>(bH3(T+7-Se%E&=^Qp?Kg|zksX%uO44H zEY$eQtS6rSdZ~ES79698M4m8?3F1=Wxp7GR?0}7Bs=shJ{14HALu-_06sn#Q&`2pH z%dRX(M4?ncywhJED|eNU=8-69;auJCe*E{m!TNYd1OvwM!cSC@6gtmJ?evdGDo7te zofD7o<7mA!fk73xRU7(W{P;8T>F0UWKtd3n7xC$zfq{>xWj+Am_)M$BZ~s;jpAzz8 zHs=!oq61>7&!}Z~AfY?@Y2x>1zhu+IU86|#k;t#ixZ7S17iXHhaB^v_dG4K4GK-B?TX$VzEt=G&t)9` z(+hKmFLfap{e^)xWdA!cg43wd#i&?+>>H>)rUZ5W;>8QCk?-Sl^=P{w=nx)jFe4q- zYAM=MB}#u;iRuA^F~zqWlvz1^bVbboV8x+W1%{Gvr!n9_U&T{4J;ssPr*)Ft9DAxL zl&ZNeYq8=OJC5?8An`yK7}WZ#Q$%d85}iZp&VfXJ{4GH-#v)Czuxgod*AXPX4H$BA zyiD@lrFlbu`j9I5t1X-#4zD9S2VFBJv!-KYv^XM7Fn(EBkrzJMFPw!5e5JHnJz!Kny4sQO}ZtvH+ zK61~ciBtb!il8|a^LcyN``xQ< z-`Y=`_4b9R7%Si1m!V=eHc9rwDijcG(7sgKDdDp_ zqAf`bXFQ8Bo*Oy&-yC}U9blj)nE7>v5*o`y5q?7~@Il!AzVM#3hoa_#2M;2aqP#=y z0Bg|60EiDt$i5?yMMYXJVzWTXml_%Z*WU`odtPliT|E58b)cCRMp#EKlOmWA?YFI;fPYvr!9OHv0?fzlprfQe~6@Lo56cTC-lYDpjnbKN&h@d@AFdubE8!m_5EYQcLoB?drm zh-%wWX9Xz*^OQT%-vMu ziVgKxW|>T^OLI&xyNWia!^o?9m7-0S)Ah}rRqkTk#^oRmH#81g8*wCC6!*euJ`JyC zV0hrm*Z2Fs#k@f^iu4`(3-`&|_nj^5t)wSL({92tq`WoUF3x_;UW!fm_`7Y*Y}az* zlec0*xtpA&yl`v!)>SWt%5`Ihz6csa#2dPfI@5$xnw)FA&9iAq&f0?N)|q&@ard34azFn3={M5HD%iyF z^uNPE!9J5vzFh7VQr;84XIg!C*Ix@pzja!mFIN86)-I?lCZ6XP*NwKoe?3OW*lR5W zr;5~Y^zgA%P*=vfj}(tiRkm2W?w5X`8I&{hpZZ2Bx0uLxj;y)b!8j$PbCJyJ6!vh$ zJAUIQ9(EmFZ`VQ$Z?K~iq+Mp7!n|LNmwd}Kv|gXkVykW3d>GrB$jR4q*`HCxOXqW7 zTI=IG7EWt}3E}L_QRHr(rWL?4?A)Oc%zUFR`f7|a786QY;VMv`DecRaCI{+)u)2@^ zHLmj`X1&=RfwsRy!0aoZT82=U{AzC+J?cg+$>3zM$4V60F7eU&)@+jHrQ_rQ^_emy z7c*&)l>fm$RuXZ0Y&asW?Y1Q#!}?0a=Z4ucy@RQfo2$;d*!GtMusc5b%1B+-7W9m zQ%j^lfVKCQTfUTKhz>MZvMHsUC5&XtH(=PA79^Q;6m=mhe zSX91e)R!y!l0@P=xrQN~xt!Y4=;^>wqta)gsjM6r=KwkOaNapdpcRQf6+w40tqt6QzbSvGWMegtYGBdZBpUYw~A5n?MfbG?Cj|vO>N0 znX(#9`ycDpk}-3 zrAwOiTkfxtS~lPj#L|BE#fZ|Rs&k9EO|4HJhEJF9IUeA4ckoQEw*4*u(5+*?H1f?e z$4$SV$uszi2nztk*!^@<1-dSc9uNVTuL*ePRO5)Vg)fa)VLMO&Uf45`f597ik6Q~C z5&)CtM#Ybe_#WH-^4`FTePG;un?|p_NqrS}BTQ4^h{TmY&L$N3aHaXVt`z8etOa}Cz>rZ>%BiT5!#fbjT2LFHe zXed0yh@mRZwJO6+#E%UEYH#9WO7CAmnJ3(EH^iY`9q=TL_z~#KP-q5OG^m7p8-=R; zSi<7{wcG?&NAcfI(E?Q;Tidp@qH#;*pNbMy8AFTR(;Tjj|4%eZocMJbd2GNpYf~6) z%GH>A!~kHu6)tijiw=&*bANm_*ts&aig&oa-luR@q?ynfYPPg$7ly@rTVjJQbvF1T z84K@~l%LJ#21pVX*|{BB(X~^P1QAiN+{EjbnACY``|7WQl83@!P*bgzKOz5X$?$*& zixly>MnQ(Ki<@;{wd~jYB(ely=#$0`tIgu8-mcxMd5^^gGzaUrF3FDl$v4bp6u3_l zpX*vuoMNSk{3y9QT-;FSIPVXU0y}MEkJA}t+qQWb*#g}a7GnginCG<(%@FG3m|2*!=TDI# zlbEHb6NWJ8u~igmkE*z0?63ORVH67W)4H7?Zy3bRNQlYi26HrFQ{;_zo2)DncI#b0 zA7%=wFkccQ=nO~q+5X|zNLe6TW-y`OoZcyW@8YFSfT?+GDD(x<;*#tZazUDuODzgT zl59jj_V+qF++wb!^Sp-rDwgPRo$7qqH*TEAH`}jzk^l2|$q$ zq`g9a9e)U6INs8=a8gFS7uWTCfdu1Lw}6)`HjKegTH@XDgU4i$H#1NW?oy$dB`ty# zkES1|fIw#TE#jM2DnGvjQnW2g0l;Xig=5G|GfHE~LKq@7jICApD!GvRD3thm(wo?) zrW$e3SgI0i=r#+npV^@VW*SN$&|dhC&%nXRv9DtQGgql)zLxy+AmeC{i!4&Ez7{MxZvw5XxE#JvZ?V zC~7)rKdHnpm}=d~^+O_UmIrc!W`1O*^GZ5i|U~$|ZyV7ifH#dpy zIxKYP<=i+n5!ql&PG#Ao1QLQtyvY1Vu~-Hiix-9eQ`@PCRT{tufm!-mpvlUGyjj|N ziyIEdW1G%_Se&tn=WE5TPXw61nj>w#gvPSSAz-MdotmzgKZ?vZg{2r6-Z!tBUJ(Uq z?!|^<{Po_!Owo#>q^IGT-?j|Ji%5ZlOd3hZgNxN^cWr!yq~qzNs^L)RLVgWRU5lt| za_!)}2MZBm!n1>z$){ z7WJ%vozbK(StqJHVEtiWW$%n^8U%gEMe`&dh~%CrHwj0jMKz2tw5gT|| z=bPt0(>O~(hHC$AT!HYN+BHkOXIAU+Fbb8U7{PUV$f6Er?SEf_I1Vk*XIJD6^?Xa@ zko?2i4NqrnF71q`@ro`NXP>qvji*lvy?pUs=phD>NU%=js_o5*qfBvg?fwU zrDjo+PX5XrARWTWW~w+#Hc;00xO zBC~W*dPzbMmKE(0+X~_QH}0>-iX|j`ww~{tj5cuk_WR4mW5LU{r2RE9nqGZY^Z7qT zL8g;Io6a?D)}2Gy7vFOwh{Mba8!mKr1{9q&rcS5GIg0%LI4E{}HUSVXhw~Q>CbQ|g zD%=*|-@vq%J5G9W`X88NOCQaoE2Odb%;bPJ-R~Tu$e;wP9El&Ec1EznCWK~JMlTQ0 z?M%97pEj{dQ?R<8b|mB_`fmp6$!3R85Zfb?LOTh3 z-*$oW8m-QzH_?;6T#}T)+Nd+pq|g{F2@^`dJ>RYa%R)c*iH<}?F#B<&Nw^z`3$`)p zHF_zZyPDg@uqvzWaj=BC$1%%rfxZW&*|Z0B`y*1jP4;c*HW&W#Y-wMvFw3o67g>@( z9Tcof+%PVol&_VLUCMf(P%bWyU_SOI?J!TVD9VUrlalo z<_o%W9_=$L;kAJMrz8M)CWB2AYfg()_gQ| z7$mg7kF?a)L{i-F9q%?{Do2#E2ln+L@pB^fE=P9n^0F;~hca~K>l43@P(DsHQSjvW zo1t=!6MMy%ts44ZYHeK*rTZJ`Q zjJ1?2SOS`~rsey_Rz0Z*CN2YJ89&7_ugi01)wUSM>}l`b_nsIZZ$qRD+2_|K>!i*; z4);A*!LqaZFutcv@A3O8NrNB4!i}g_-sGlY0Q*<}QBc4jp2Y$om4yWY7eU6PA?iH! zK10SI@v5IwVu~q|TZ$6!^xW@ckE`XTdqK%+v^Lw3K-Jky-jLTkP7l==8i|{}1Laf` zV-1%UN9C=M$Ks0ZT4Kbe5(QbBmfscyfHNf@d;?Q?OYHkE&Pa&hh`h zYzh*ewKLyO%evcXjDhdYvu@>3miK4<{hzV9N7?K6Jow#~ZPRA#R3(i5ofezcR|PTa z5T>^1N-kha#w2TC&wYep{uFMk--ErIA_T8)nCAoz_gSf*?kC2X%?A45ejaic1uTYM z-9(dtHzA}AVd|R_K!A1z_WBN6hqDD6A4@evPbPV&G9~G@Dubw?)_69>M9b!I?mXof zZ3tl}Yo^`jPZRyYl_py!P*4EPpg^ElXN(tO$caziFg0iK!u`_ZLvL|H;SzS+TwgyM zvOD1yFVd(WGJ5}hDFnK{W@Pk6iIVt-n>N>5E){!2`@ScRW)y=MOUDkw0DXOp-%!$C zzBp_OI_i4se`)dnfP}lB{*{c@ib8dRr;3XDzsJTBD_mbSZ|qZ%EA2-SJRV2W_sSQD zi1ezjuG*D73HlKOF_*XQjEUjy90)AsJSX!i?rKHuzu||1NjfcgOpJtB94SV%Tp3MAZ?JAP$aC`w5FUo%dr|vGnbvV3@uTgon9p>(>L^lq z=mr0UcS@;DxYZeq;;nKN>-8{BIV0(2BRU90$p|~()kFoZha$VXOkY9JZB{vLb2XF} z0=o2WYpOkjUS1EQK-e(ALT@PplS}4=P;}C8*gku4>FopM$Nvs!aJ_x+l;5M)Mv zyx)T}nS|}Ijg)|4Ek$X-05n7$KHoEgF-E<}O)E6fD$4oeY5W!BCcxc0pt(Zw_&*sw ze>i%5^^BJ0L(>Ks#H(t&VQi|KYrYLlV?B)l)WU2S@O&Jsp{0}Y!!3rXkG_Fye&rm$ zyV}BAC60OMQmJL3b4Z}ZAfOl;@a=17eM|7P4rRfsElWA42=!7xGWHi@vrlSJbPGgK z4h_HEAKmf8V!TMHWgw?HV}ci2mWsX%6vZY$C44m|Y|GvX*Apl&c}#?Jasum6h;u_E zWSeYQ{AuaKoU1=>;RFu6v6b6be?TA=+w$uO^W)vS@y@Bb(Jq_$Lsu^RaZ;2ktYU7i-^-7s8n&+9a~_qX4euzaqsU)dT}kS7`AFRDW!hT z7NX0<$SU{s%blmw&Q2RHRd)I>&jdT)i>!6gFbnz(Y9vlNH#G0tApIzCf?k!=Q7E;f z&wJG{{|+WwK)eoD4T{ldxfo(IL?zhnP2b* z!9(HB3<-C~1}HYy1HhIyc-WknnF61ixL$DtMcl;d>eX~JO`kVjQWWmDs@dUl{@CH+ zSCh9P9BP2<$&lcK;bC(wPl_&?FV25VpZE+8+E>9trd6Y)-4>oNQ`ZP5_C~?FI;%Q5 z$9`HHqVQ5yH6g+*ttY*Lm9EKi4HONt9w{_6AEx_ZR4NJ~P#3qE#vGf)t|vV= zUnzYUtLsSOwJO!Xzu#NF(HGIlE`{WtKjW3u!^Ot?fh-m zD675w`ALkUr-%4>g)>;~|nL z(V0zcXZCl-1bKX@Y?hE4JzmiPX<|=j2;_#jxD04<-OtbBK&V+_!*P0pRxFd$U?JY+ zSbLE0@hmw=O?h6jc-%-JOWk)GLR*_}ahfK)lvotF-k%5_r(`b_^-C~=XOW5FjCp${ zDRt7v-3@2o7N#%Or<()M7r3jcD|h?s%QU{8?xZwO?%Xmvn@b6|Z$u0;-TGL1!d;N) z*033_SfvcLUFvrn5uUSQ;x!vh6Ot2w3nq1GVDAyVq%;t-67(z$OMQ6cZ% z8O{DZo;s{&Ik+6}4+2)-i2AP%r{(4*m!Ix~MVG$yT9*slmke2hd}iBS$tWJdX}p|f znL&Y)+!>J~U!k*u@`^f{+H~-Ibh^%@Et~stPve%l16? zRXX~2c5^dulVBbF0wSGv16K7LlFoKgE~zAWYw6=;Px=;!&5x{hRIu9$hA1{CBC17$9O~64o?a2{ovwUoO9C${aBMiF1Y zgFI^E9QO_or zh?AW6MnFFM>KT+_oiAi=1{i|Ifr0R3dYu7ox#I#>?GmfS1Qlk|b{Cn0rAon|ZStmL zi312Y-)s*!teNf}rD|u}pio>XNuJYk_7lHzx*Z4RW}m>GUPW>btP2G#nVw{kE2 z+gXT@sZ64$DJU0ZLBT5>MecKL{96!&w#IOt{%{VI@^JA$LHOD>5~i$6C#-x>8E?H5 zyOy?MKREE#y74zWWNmPEHnBAo5oKI#p||r%Fi_$w9CMcoUO5G2?B&JI0%p>}&Ng#D zSuT&bcLlarhTPerpTDl(`y_XdZgI+Ma^3ROuzu%H$Qt<9bF_5#n1k-u-h=V;(<0}Z zrEE@c-*B2RWG*U#)%(1n;hgDskbmEEZ+ZJn^=x_2IxXRHd|*YmNyc?9JmB2T9441V zn-$@c{Q|)7q}X>0=LvMVT6%N9x2|nX=EZqEzL>Y=QrjS357CojUwyiS`Yo=wz&L#r zU82%8sJ=4XkzUa{;M zd4m*C{rDH^gJScO-f6l}W9Pab`atmP$w9>>c>nAGx(_Q&$3kM)p)^Hq)*E|j3IHB1 z3nDh4obS$Kx}TO$hY)K#aF^S(-Ra_@U0GW4-m6(MM6Y`F6vT ziV4|n)-nyIQ^omqYM3!}g%Ha)qFmEU&;O-6JJPn>pW`Vv(uI2@vX9QDde_dIuA@Q8 zsypZhh^!a=n$$q$cFlwUl+_PLyLa<{>ek6<$XH{I6|(UGOPZ)>JE|&|_Ef8qQ4a@@ z>}MktvcC(NN;XFuE@H@JfWxWNGcVf!D5>|a(hAID%?_KV8{cKL{EXWdb*vUBW1r|f zJC5F2CoZ~`Tk!O0B$o1E^98V71@@m`t~Vik24UXYQXv|7Y!J=<5&)#yxwCxkPwNSq z*XJq%@=eSe>)983OOChdjzXSzW4HHQ?rluExv@*8XUfyBJXrZSZjKy0nxDz6TrZaj0h(r7t!4MYf@y)5uMj=1 zVOrx-8jbUkup5O;*?Q$Yn%nakD|bS8;5^1UQ81J9pJ!imvg^JYQ9^ea*$ti%CU}17 zfu1_@`_rFy!|L+ClwH%LS}RCJ&4{~sm$bXY-3e78>_?x{W(G92i{94IEl4*%54Rchxb({ zqr?MGG?!KBwcd4|*()n~482S8G3=w(*`Y59FBJylQQ_0mXa6daYY+UVPmyCw1z%+2 z3CFRt<-1bgw8v2I?50@lY>v>&wq}a8Th_aOH-qHp(s18z+JTlWz$=e85P$(Ws?HCj zlHL&0-qxaS!E3reTd2kNgwTdeo9`s1>{p{coS9#^m7g^LZnvV|Hk7Ws*8xw2Cnj2T zLRec)l`fhT$?JH_+O2X@pweERw#;>5VLx>w>)zb{Z#cYsuyR2E=TgY)nZspIzvFIm z`o4V#K^`-M>2u>$@VT>NMiB-Gf@M(w670Ub9^XB1w1Q@LdEv{i$Kn#66|97#g{%XZ zLnooO>Cc@8 zeOZ2r4&&IOzD5>efMR z4T&JqKej4B#F0!ZZ_PM8P`4QQ5X4$;0rHE|v~B|8w54MIP5wGR{54tTJ}_57-&sm0^f*C3Q?uYRM1GXowwexmIMZ_4 ztGzNWo66iSl9t$hUVr*`lb44|g0jc#2!eEU%K1KmCHrd1auRT(c{F$(m3F#LvQb5n?c>7`$Dd#9A z0YnrLu}DQ#UF#uH>u+P#+fB+oTQAN$Y58Eg7Wo3beTc(RkX#*Qdde42_L*)W#HRX> zX~Verz8+dy?6zlS5mJi z)OA)kU1mFP_$Oq`$v)$b`#K_w&hT@*C3db%^7HhkQ3Q`6a-d3XyX7>o)V}{Fd+cOJ zEDZ=_gCqfs-DU?-E)B4oR>MBTsq_6-Pg@QF09_s(vthK!CLo|B9@_ut3)pbFVIOgS zNqK%#K=S^16Ya%J3G0y;-Cz=arT1oi`C5Yj-LlotC54siEPD$fpMaH3Dt$Bj@t{Le zpV$giJ>k2g-Cb^9();1Czr*U19CNq`*@_<^^_qCo163(3#sG5|X^KuTn6rfq?3(ecLh?X^@o+F7g*Pj$&1H)=qW@Vp1K4-(8^ z57d@4MjISdLQc-aFU(H?49QQHfmbI*%Q^ltP&_JjE`p$nSt7P*Fa5oB7XaRpulSU6J)p6ck~^( zAo#G#$+(+St+?C~X8Ir>1)|u9`Z5njT3aApK^RZT`erbJS-QC<|9MutODCEcA|~Ov z<|vpXljLLNDM%2qURG*lF1h`vd*L?%L7Qcp>#DcgOZ53Qjd4;A`_touf%Z=tVi9_G zm|=abL~qYDjG}yrws>^g9^I0bvJP`579z&eA#NiF2F4|CqBz|^z7h>5l@!_T2Xbph z{k-qp6KL4cc;hMuY^Gp*dj7a!u1of49?G5X1 z(OZTS?yEN0{5)B9I@XXkBb`37_{zg4y`%X&DeOViVzaL3Mp5!uGcm*nlZT1$%kJfn zNBBK#*{LH(+xgLe#7nF;D&nYLTv3tr*!>OIzPUPj-m^JfK{Z;am%jpQ;8spK+G4C2 z+siGxT@bIR5CqE-sO9PrU(G+a83l3z`u#>qC;t#+F$ZZx{Qcb@U&|8IFW@Q&$9ss> z%n+{{RSN5Ph}UeYX~ODa4Y%<-h(@XM0>Mlh6>x|tQ-kEi2?DQELNcgoudNic_)x$G zDMna5^j_XAL8(6bADaS|uoWsJ3j-947oLTiFw~MR^guwTfmXJk{8wT(uzsOqTx*LTW9udVqjs9=O10UpPxgZWW z5Yq9&Z{MhiK5xB}6dgFfRSo}EdjDBS-H*oM zzOG0VmU3)<9}@bZ_Ht=&NJZEENOmkrMX_S=Jcoxt8>cIVQ71I8wa9bwEK~ylR@jQaX|8>@5I`;};UgICE2sI*RbS~^Wl9B*8X68z6}{(8el6-Xn__r) z3;E}O6A5c*7dAqfTC?uET0%9^w=@)Qq0K06TaG`QeMNfpr?7QfkA=?9Z-JKm+2Du@ ztyWu1I)zgP2L)pYG!?^}NcVK6Oh()b^YI;7Dxk#?DoEa;lxJX|ri2DwgqUM$9Jf~) z`3~!e84}5c@ZA{}vc^-gjlEh(y97m;P;vTLzbp+!ARjz8K2^x_5zJAj{f`kN^mePg z+e+|TtC!r5D56A2 z45((P>l~Y36KxO6}__2Vb)eTMqeSPO0sFF`I27Xk-ne^=rKn3*42vWwZ z$KQSgJ-bbdD@mnezOQSvNU5Z(iBkIdl>5#n<&MxOLlbC?AV4hfG87`>Ek}!;tKQHV zhy4BKwml$+L`wD`{Pt4Mh)f@gy4$!%a+Nmskd+ufM))<|2;=l=oz9E&w2h$b>w{N= z4N6F_XUiylfL$?sHHw8+e&zO<1{R@$;`5%*nA9uGkU8DQS->8 z;DE>Aiu)}i0$I6)3tspwQU>bfE<_Tyjv6FIe2Zq1>La+fPIuo%HD&VgCwizNTmsdu zKNdPEXJg5i(h+$QMs)2Ha)3bbsCVuf$Z>skIT}br|mSx(3Aj@kUDzS!|5g5 zhF?>VL4_DDNKLLL>V$o-nJM}AP^(Y|0Oh%xh>Icp=GBJUvWPj1WGrB-j1|7j;BC-{ z-nZ!(7|=UB^rx5c({#g)rP&MbTb;gZtTQrkRU%5%^*@eIcg56D&0=@T5aZ9)XwWOM@L2~{>*+_INC1ljAimqdNK5JXLDyD z=dFK=uUG4Y{k@1e1z_;ohmR|o%RP`-;5HEW+=u**IJ4yVMUWs=S5fuaz-ISk)>u45 z!IXRb51G}UJ$vTAcLJ5}K{ZG*%cPv}mO(=BX)#CbnsGT!{h9F+XEY5zaR@n^FeH#b zcci6c$bk+N;;!ba#G&JV?~`)?!AH5Wkf-SuXZn4Vg^0Vy32qA$OBk>9r1~^_W5ZDk zmT#zK8E8!u3=D$JC;Ovse>^LN=VIekoff;1&hBj<=FG?K$>lnMW|HymAv*E-ENkHHB*JNw5f^v=|SC1 z+tv<?m*)E3!xK)O$s?>ly2F_~m;~9%dzeoOJ z^Qg1LKu)kYHAUj#G55y86UseIh1D zQK{pBSpVH+O_$N1GS$TMt{$pruOUGUnqF&`K@p4~)l&4e*FwpeIZ2q(n_j_lhX6gyBX;_G`*SwizEau>s(^83 z+$M(PFw~e{Ov+PHYHr*{O8KI&=*zhyQGf7(s;mOUn)rQoT1g)24|Pand;ng|xyY5# zud+{GMEhRmU+ykB6K=9BX)|u|++hG2?ZfT0P4zcUPTIT<`)d@Wdh3kSo6gy3)LVOf z%}X4^s<};mz8dd36P;km64Q|$L{s{!AS4b=IZaxhmCR7F{()Mi^yq?Jm)zmi{~Uf~2FZO& zl<-OS7CPNAe>4=^-?Vpwp{!~R9v)6rM{92^IDCKR4Jvq8NPBO}(lJQpaXbzN?Gd~VF zhqOx!tGJd(cQ%@8`+kf?i~1jZ562R@OjD2GM_iIgR&c0|CYbuz!eiN|%21M^tGzV0 za4zt-YYBO#@ySWX+HgVi@kbfuOf0*r(?*ImzO^#<^f)TaLDv~8))sTJfJGY&^}k+f z-PQJgA})5QozC`3kBT>f9 z=SAk`Jn-CypKBr6J@LLOlRh`BXwQ9)z6~3$7@>WuIhkf)5$%@#-Y#5HgYoOikb^=^ zM|B4fBE8#J`wo`&T=Q^Kj$t*zK5|ei8rCNtB6|25{Mmf8OCmuwpB*IUYgQ|^vi682 zS*AX;R&4wH^K?#(n@r!|wD=hYRH_L}JQc<8%F2+~?b`W0nX*eBxR3X5_zeWT68?TN z4N%LNk>ri4hXLTf9s!Wvp4XE6tE5}%?Tyn=geJ>;B9ZrqL4-7U@aY}I2OGqzT9cIoPC?%^(+)pZMDwRJ-hIObr+{8xf)LPKCj!+WWtq$QCsjt7Dt!O|oOfW2t$FGij8$ zrlk5wLPKX`%*YOwoF((0HqdQmw68>QhiOaGPBKl;*0Fl!=lS$5+s=*cokO49!VnXU zZ863WDQMm9&d&uOqg7<+*799>JaiZWYkp|)VQx2v)FMm>w=IblfDYnLd8@w-2xgIn z*9z+(c>#8gupV{;Y%i?+bXGI`rj<7Juw1y8q-xe+llLr9Q+WMIDGq71z*m! zruYSkd*=0Dds8#W4ikblf%FWqH7zR^Bz{{JI{+whlm&ZSzLwXBhDnozY5hKRB|YJs za5~8nLf2~4rmTp@>Ba8X`D~YftmVJgBkQB8H|~j9tPa1xR3;K99@GvH478P;4iRjb zy<_a_AY55%5=LjWc}RUUSB-{k@J%^LtPA_sJ(?vs$eUga8d9qt*3;6eyE;YYd_Bp~ zy?nwaI@bRxHn@DdiR2k38_pE$52{PK(}B=5<{KFH7->G_9bP28erNmDD^O<-3EAC$=gP&EJ7RMj5Eo;YL=$x}|9s7=wiMK| zrpI#DttzTe#kRqsgsc)KUq)4Ojm9A!&5aq2zJyMKjI`(`Gh-JrqAmXf`c#3qmfm%k z+O)UjNkN>4inffKbU%G48fc<;Hy@ZALm@EtR1(xFR7_=^+=e~~@yHmKKQP+87ZnL3 zdE!N_T($j9>1U`$TA%P~Pd?+slLuR*q{1QFY@@kSrNY&4I9<+=Xm=++RHqTL@Y$s( z8?T-_pPky8`ly7@{Js!{TE00KP`0F%ULJm;9XBksi~LyU-byK7;W(+k#~j6J@W>0F znGNL1;_OeWW;024N;$in!OS1W-%^hEdgmlHe0s3%FHkYa&Q==%^fH|MW~))d>}ONK zR1~J0M1BYAc`M;>GOxpe)JSz^h1<)9#)c43Awx%sdNA3 zr)KK~>YTyt9q)2G$k*kU9&#saxM)P9K>k@jliF4*#DNVzl>)u=o8^Y9}IB|+1gMej?t?IWprpuw$dP>N#h@!4B0$c?sU3nN@H z`GMl8Z9rh2vyuEJta3$WJ4)3~*A6lDa&`V~UeW&I<0gwnjJ6Lc1@36GCzrtC^~7cT zwVDgyz^&5L0a>ESMT>#+G`4iCgP761EhyKlvD{lvJTVEQecn_YEkkUHYh|jmSVP7`o1Ki8W|Pl`@LSH zfBQz}-jB1O6S|;NmV5*$QDaiBZ4%}=p&yA-NiqrKG_&D?4cW8gMpwXf;=J0v`^hzM zxKJv`gU{}ybk~2&yT+F3-Q|Rft7z7$Gg?Saen)k1Qiu|a%7mxRZ;gDE@>alqf!BWi z$h*o@VO6r0R&u;-OFp30$EjKtvR;$EvMO9@Jp&MIoPChwnMT`<=-^!C&-a74>Li@9 zafjD(a?1LP!$3nMKB!F1md-D{$;c*Et2th+7NI@I8f?#~Nc3rf=vKyj>0zT(HVv?+ zB%S{JA^WgA0+6qI?z|nSvm~-Ov3%s^n7q`77^fF%#V2!oz|{BY$1MLcAt0ZQ@`Y#q zs+fX4e@RaN!H$2&wt48=)%Lv{)6M4Du**klA&p3WTH959C4p59+bM;NZulO^h{NkO!CCzOImdA zH06%MZ?&xC;8=n5r$&XS55l&49nS@sCi@uh(AOqQm6gb`hG?h&EMpdI z70;Qpu-hX7?8uMOGplxQW2Ip%uvbYziAfIap~&X@dAKs2AxWxG^~a>9CwJCTc3k>4 zqF|E#tKophNl^Z@M=qNJVG&KcinWF*+@g@{XNef3&O?=L+jbk!axnh0vog7>`f42# zAerGSkgl9`)fuLQ1nWdQ*4p~q8>&)-9b+W{eJQY(CX{0J9kQLT-_mCb_E8DBNBN0V zdQ&L$W?|B8V2_HaqZS{*_+S3tr{&>#wr$}Uqsmk~tw81i~ z)GC+?6(!1D1j6tHS;J#f;xFyL_&{4U*fC_J%Pi^n*=I1dbbRjr3Ev1H_h|!}&Tft` z0EUPWLpC{(kqKoa1D$hY?Dp(A6gr@^Na01spwZbd3c?5>wlHSt>84!`XT(m3&;sYd zK;k)}<4C8A^cSS_pH?FFPAwtw1 zKYlJ4t91LpBf~RCOduL~#>bAGy*$OUx1I{pQSB5PqXQWXnOBV;iMya9#QgjB+-qw|%ntq##bH59*!wj<&=-@NQQl!)NEv>EzEo^$Mf5f$7gLL$}?W#yXL z)i*^EQDlyKO>o_(M>FlGI!zCXxuYpjbe?p8>_ev#liTQMvxXdlO9xS`Lx>B_#6%_x zJRM!JDROjzG@_H3CkkZ~OW>WNq`+p^c^oLrlI$a_e;8<}xHC(Li$KhKZ*C?+Bp-C?YYm67_! zdqG?_mWK|rvyeb~VW&9Si#aL?tMt7v^2d{vEgPLJB8cPSeZ(~((jPCvwM~6x4I}&G z$w-R>?uXbehA!8B4z_ieOWRGqWfVw%=gE2!?8iOO2Jm8ZGzUK#Iz$)ONefrnL3+An zZg#+u(ALUXxCimgNWGL1#&ENK3gxBT)Mr*$$J~~3rW>ahv7!%%^@T7gHoZ5uK-Y}m zx!}Et#;Du`Jj#^IL(26HOeaNr@odxWjSw5pma@RO;I5H4I{1y9umPuT^ z4sTn!jgpVhS+aO8cd90|3Cc?!$Up<*%sH}kOk3vuip^@GjyVU{&$bcnDfXFwK&1W0 z^3mQXL#h6(efu04+Go})8NYqPHRvm@c;NC_tc#%r2lvi%& zh8Vb-b97$DVS&zG6gq15>**zbcyreu+Q}k4LrU(GtE0~A2g6LlWJl8sV||x%zK)LV zN~aTNq{OLhxv7Th%UYwN{Pr`X;?K4>iRJC-?`w4BeJi(aJL((CX=j|joNM4!!eiKx zXQ8`oG@U?vwQYoRl)CS9z4WHx?x=6R+By&{e&0FnWkHRS!0-+UBgJ7 z5fK81kv(o~MtlR|>!s4W-~l1uh0qIL3JsqqB1C%ZJ18TAJ2=k$PA76!i^#$KOe~i8 zFG7dWBm&}Uy%2J3h-AX2;~yWxVa9(y&{s^mFE zL_`!3B^i`VoH!|2y?R5kb?dHV)28jooH_H8;lqa)?8jFj`R;vVV{^NI?epg^PBw4e z-gfM^WbWJrNli^{vS!W35CVz&H8r&)D^{!t9tA#6ecg3C!ZBx>+-qX zxF4TvzVXJ}ljX}-=eG@i9y}x%?F$!fORm5EXgK!3fn&+><7dNH87EJkn%{Tj%5`De z(W9rrz8rV>@D0iN^S37T^)t%IiKtI5Uc93qCj#Mc_Uz5ckt3(VCxJQVp+hIaIcLtC zWn&W&5k*9AvTWI^VBDunxnl5JTjzx&#_7{*I}{Pqrq#4#Y_vqCx+5f|G;#KeMg z?%jJh*|+bAB0@w&6cN1*# z5k*8Fz%tU?x9c~-R^~+jB7~&IY7-Gdh71kf4I7|{ zh$td@2&O`R;!QwEuzthxrg}>LRcGuDV0p`1m?~jhHAIVQmVI>1>K8<=MG&Us%Y0DsCf>gXGRJW5yKhOLh0%LgmX1b5us_GeV_Dgf1*fuJhrZ7LAf#af z6cG_cL>0i2*LWaU7lLpH3q6sHi5CJ7f#0zZ5fM>Dl<-~*3AqM{2BvzFbHECee1pT> z0}&Aw5k*9&VFFgSY;2sFG&i?|Z*dql5R3Y?F|DHzA3Q7@BE#!{1B#Zr@7 fQC%5GpY#6!(rgtVYi#@200000NkvXXu0mjf@Fn3) diff --git a/apps/android/app/src/test/snapshots/images/com.codedeck.plus.ui_DesignSnapshotTest_web_sign_in_sending.png b/apps/android/app/src/test/snapshots/images/com.codedeck.plus.ui_DesignSnapshotTest_web_sign_in_sending.png index a44778be1e6b0c6b633dc42a979328e89902fb02..20a43f7d72cb1ac607bf46f1e410af24987b1e44 100644 GIT binary patch delta 10219 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 delta 6483 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 diff --git a/apps/android/app/src/test/snapshots/images/com.codedeck.plus.ui_DesignSnapshotTest_web_sign_in_signed_in.png b/apps/android/app/src/test/snapshots/images/com.codedeck.plus.ui_DesignSnapshotTest_web_sign_in_signed_in.png index 0316fa814babfda4120f1415eaf02f7f849e4082..ad6eab9017563c8bd28541280e76c55c1eca9e1d 100644 GIT binary patch literal 37851 zcmdSAcT`kQyESM+0ZC2HND~DFT96zBnw&*IBuNIzlC$I{CrL_>AfS>#g5(?}3zBor zvB^xezxUqn{l59`teLg$nl;06`N!#V>eQ)v>Z$$gy(>gTNg5lI9P`$#TiCKP@E5mk z-GSV?b$1Q@KDhG6G2i9Zt+-5CxY$eAiLF$V6v~btl|@NSrAf)jWKT*5VxLTwhL=9! zD(l61+SyB}mK28+2pG` z4od1*V?N*?8UzA~5qQIZ0Dn+%I2=w0fkL5~2t06IGT^_w$_xd!{-5ss=PHEue{SL5 zu7;w6X8&pTf4!;-N4@NSfAw$2;D6iw+rmHh{*UfLFOm^S{0^pns`dv4^0l~V5>Q{0 z>3Ms}Cw-|1ru&vc%c$DU`Q$6s*Qj;d~Z)dpGa+Mz1)}Pg}+}`iy>JPY!D>U$c4mH%w zzdk%xYeCi{HR9j9ZWinY8$}7T=WCT!D6#3+H$Py3LQ5OM5M6Oh(u2|H=%-^1*HqX0 zQ9h%|=~r8;A}V11u5{tOse-(h8=4I)c#z{|a7zU4OE}!vhXkVdksBk7grg7-zo8KS zb^uQw-(s)bLI~4n$P?|z6W>q-f;*wLyFB_7*>FR!Q-85D@YBhXCj4)oO%vF(Ud+Y( zsXp8p$Wf&D*O!YFSrVS z2bhahQv)-k;riHi9^8uk>k}{1_iq#3B=}}2_EP49nSuXI6)NcdEja!k2h#slc>PFCoS1e7s8j?wk;rKiZlJRFf!gnb!6|`T&6*yH)q>>={J}95fp%qV0~xQ4&gr_cj|M%x$o0N* z0Hfl^)6ak3{l&*+RLhJg1hMP2TL2cvnBU^ZXO_gT%gt4vL%B~YttTroB!Y1=ye>}m zYhH{kzG`Lwq4Zs#Uhxx8hTGxF?}WJBvazBa^7Tb#59>bd)b|S)*;|b_vNF~a4$?1ao37xkCr7kYzkKp@G_EHz>fje;=8wE@4y z3Tr_IcjlpRQW%tc0IX#u&zlQTbRY0vGtKp0huwY~$twA##c)pWW?>Dx=eoRp z=6ys0vTpZkzI<5ep|JZ==QCG9=P5lq>vz1R;!FlBy~$`DY2N4S47)ddg1c;dCv-Gt z=7VfR-42bn9|RO=D~ESnE-{Hll)Xm3x;#j1z?!{2scfl3&QNINzk*=f@%M)&n0o0;UAQ=Oe;S3G5gAt0@F+9pPkL&AB4S z>#l_jSKGVuUlR2~@6cX(z}r*!9a=!nA=UFbuG#0m1ljM~DH3;I%X^8A1|v7+-P^U{ z+#G(ZmadZ%~VxMrz?ns4ud_;2{*cSgYh`l<5~!tD)hp zX^6%-Q?z?JK3B);4K3PxB~f0r8eDMF<#e|dEi~H5XO^Q<^U)$Z%?~+Pe&$9}2?iE< zF0)D=Kfjhf`BUw%N{sQT{8py7Mxl4GMpaOkV8Nhz2PRtu}r4 zM}FqSIzKzO(-{H@ZJJT&;9QCihU!0**D|^*kvp}#FNXnuF5YmAC#g5?0nRD+! zbkY8+bS9{reH)Qx>+G8H5mfEqfrRn9Gv?$BdjgfJ#ejzo3sok*e@9{%B^`hd%$}%Fr z)N=;0ADFgYZkdTjQGeFIIp>u$X*RMu=wc!v-4{}ZKi;d@(}t5lA72RfFAS$&J60iQ zE*8A%_S-*6E<_IyP!sEWLt><$P|~llG@PEN2o|ueDO=D4U3S84cJjq&6O>LfbRfP> zi$bWm2E$p)dx`XEAXO6D&p!Qhyg5eVhRZ31oN}<`mPr+G3Jr2U-gq_-vWa`lK7BxR zpGRlVEijWbBn-xB&J*j^%bsBC6)!Ul><~HmvnZ)%h+$7Zo9;N&CAoSw_dt~NkY{L> zc1p|!KDx*8s#Jo+9&U|9)Sn3FZrs|a+rbZRmGf9 zDgg0)?z)x{%z`z$mPvUl++)$y-+1S$ z_Y-eXp76ZyR}10@u%ADL_}Zh=m&%LhAMhdJj`F{x=5(|;T5qm*qgbV;yyW%#V|-3{ zU8Q2j@c}eow<~kl%2E7;*^JwpA~UOb{%5%-QIks0b#HF(yZ+VBxz}vX@i<7KgU&2T zy$?cJxDG45Ay6jlWyN~4`|_j1%~)|SoM7%pYnhx~hy9}Z4DSx$_c8eti4STrI+EBCW~BqE>V4?Qowyhi#kpQe3{?%IW5SV(|Gc+=oVhF&>ck=6a(_n~Nw zq1nV5Q;?_!u0pV}q%uCC<)LSiUvh!1v+5Hkq1AqO(^J7}n>2*$)iLk4W5T2L;au^g z%ZfSP^5jX|20C{~9SVSdA*y(b4VMS3nI+2ppHd4NZ&rQuSmZv_MHwEh{4xnaPZ(iW zrw;cxaW&O>>4HlN>;7;x4KUxg$R@6s)cWKA8axb(#ZE_QEXxD3ns~-DY7$*X)h0L6 zW0$R0eDSe(_qZqyn)whROlhvr6#I5EqWfM_5o#8)&|mI8ov^B%pPLTV%L&>KYgxL^ zsbuxwX^7Ju7ya)V@aVPk0SVmIP??=LEpCO!CQ_Jb*&D>`_+Uwjv=R8rRe0-((}j3D z5kW{DN25B)6~o;Xk^5cB-lb~-q(7D}0MO!H{Ceu75Cp%K?LaBRX3PT@aEo1!3aLro zQ#=>a;kA5U9VLM)oZop7gI02K&@&r4A8pVQM6?|ICj8LUZiKk6>1>k)`dPohd)^`a z!ZTw2$-SOoWl^d+!9sw|GZCGEe|X!O1cyWbs@`CLitPE~5-J)QS4b%$o3?@%Bnx;n zyhNQgMlyxaVsF`ZU$W@)yKwJi%8k}h~wnzQ2fHg3l4|UyQYn&M8CMRK5mxIDkDdP3aI!dvpWC$eb=QJ zY0v{|ucMO8L2Chw(sHH+HOa9iM6Q`vwgi@|YK8SAu>^ygUto-f`)j&|pgoxhu15a6 zhK=sPT%)UViOgWMjK*hjWO}W=42e3gO$KDKez`-d7{inxE6gPCp!ad9U)VxoM(7^u z>-t<_!vbCoes3ttSN$u&orB1sMRqX{mayH>KZ2P7kV|uG1TZJ?HV0Z;K)qz#=G{HC{Rkf>nK1-+ldyqzMCAS&pu#)^CT-=!|1x zi0f-qSP@U*4lBuT2gsc=PO^7mG?f`Wcmx6vadyY8hoa%?WYSzrc+zq*TD>VDbxR^b7#Ntxc=lv(K5C2D_YyKd?CnDe39p~a?3Fh zq&Kec(Et<@qt{~CiinYvN?!!9Yb7?zqnUAp5Q9y5t3#>n#^+F0uc5wb=O80Lo3c{fx*8FB%(M6=GLl)t>@J#Gcwq{noJfFX? zTB#nXcbVOMCiJ#gv&qT0*9up<{WdxzrX331xFZ`xns?656W@EQQ`?axxv8-;;RnS* z1p(6~r_c3eY=|ctBHl%h_-(hKcUP=`s779XO5lOHYzv=@&Hgo{D<6}%4*E6rYkI@k zFWa#2LwOFbESXy+>>Z#K6|G**v2u;fBgj!V?GF|cUC)jKYZFg?Yc#ozXVu^Y4Jm=Y z@yWJci~dn8Tm^s(u#UT);ou0ETNKV0h9PblUWYfzFLN&W1_wO;_#oOY1my_2_DaAh~=p~vTqo+=c&~d?rzFXxOB(x zV1eE<;%plaYSEfAz!E?+`5=&eyJ1CMX$kGOOZu9S+w@XtcFh=)lPat6fvKWQ%4s@_ zFU7@)$H^c|veAfFZ?{8p)7-yx@@ZDCzk<>yd5Pg0D>{Yb8E`ARX8k-MV1GjuvQ?Po zcDx^9>q%GmC;2#G#LW3Vt6QnOxpU3F&>wDWS`+pFM5i|!RHoS|9c$%a>|U0fDLq~p z4VS3`_rbI6zN)vszhxd4JD5~2x8$AdObf1vdTywthkCrmBYrb--OXCmTHL(x`@3aI zL9_@Bt5!~r+H{Zxr{!qA-{QD*HYk=%bfXschBy}&9_pVOs-MB80&cy!Yt$SNViGm_ zSaee)#d*R4#@&qhQP!(iv|Y7jsFzS&tD$) zM^)1x=nr1t87{?hw#BvmsH(S=Kp?hOp_#P487+t}7R*7R?@W92XSYiZ`zo0>{WqUk z|3nsYfK`d2lKxxEChVtk3^TF7SV46aS5t`8THI z->w3xW!#e6Vu+sGdV-tVc1Eb&W?H~;eTV_zHC`-oZoY6zeinr!PMAWP5dTw)7mpc1 z5iAdbrDYK=b|^DGrxIN5R|GBhz<1EqrbWQA@%iDV#(dwu%mQH|3kH9+Ee2GL`I zfSwESyA3P08b1IlJB9C@=Be>3P^9ax{r;}JHkhT^X6qhMs9VGPidhsnSZ206P~$So zY4?aaVbEYG`!OgMK7*Q-s;$irEvz{Sw%C08fg{GRkI%}cQ7kJtZvb-;HU+ix4Eh5h zEX4hAW}EAsX%8Or7#01ho7;Eq2M%U+NYSc4X3v8hvyCnm8_*fP$k|o^tD#h149lnSy|2Oa z&*S+{x+u)URStxdikOPe-i*RW?jPa`Y`6}qeYk+edTJ()dcbD@lwF}Q2MbAu&;J;% z4a}3@OyA11TIn4(SRW#S`ieVR_LJlj>3A{@fvO+52X^dst zo8G{Av^F@bgMqrSB~vnt*r5BvSA(8}tSn^HKwDa%MKPCYZ|E8Rk{oB?sPkhG#uj*8 zaiES036uDh1mi07|7%AU#JSIC6f@U$bpVHsSqf(ymvh zm{$4PXHKtkg+qE2nSQ~TpY7U7OR+FC+`9a1?gHoT1Dp^`x#D_wFb6WQm23I&aUa{s~6Vw%!sD4so7y;gzgYg9pCEqLm zsYc#i!}j((RU<4*RO8N~bsoqNgYd4n+_wni-5^{VA~P$;^>?4QwNbNu@kSX-BU`7; zRCjH>tWwIg0mHI4G;=_h2Q`v45r9W*ds1ibWBDFQb07Pg&S0r#(M*K{>a{!j;$USm zvT0W|KdD2ujFZPPDq^eUD2!3iqWXP|MajqMPAe5jSuj7%L6SjE=|K0>W!J!i1ne$b z0;H+z`t?wybw|tHE0@i^uWGr$7zB*LroTRp@1RDlCWu}o4)-G7cs1`XYm;{EwC>2`_LqLdIkdI0INN?{< zdNcm>M~w$6MmA&s{nxzmOF9sgftETHkgE$^EKvM&aiEsl3l~&!<*^a!{hAu_l*3TN zbEh7aP-6sOW_?q|&fDizm459%?6gGAtqK<+zN&*(S&` z?ap%-k5FGn1VR#vRkIKiEbHMs9&xECY7#Sxs_(gA^<*otsuyZkiYTOusAWwso0*4) zmc7%deu3(U9Y9Y2l zoe=46q!{W!RsrWNQXbnG{Pu9NTvh829_CmWWv0KdttYDHKA>KT16|0=ii{*XC;#1E z4bl99FyH*At6_*gnFtm5sR$}iH;DUG;LOl}UKfh~)gQshgc_ktMD*)WbmxPY@V|F4 zLnB}O=WRboAkx%dK@;G4(8*9lU3<2y8VlCJ)_wJr+jmiy&>@nodVyC=dTz^t^SPo| zZhUK>O|VV1o#6LaHCX;W=0phjLb59f>i;wrd_>r{XED6NF`Dh*W-T;|Y$<`Qy zkvtft|Lf;>mU}pSST&zNV(W}CC!NQFx3c}yxD9k+uZ0Nm1MFzk3~2Y#l~V=kZvO&< zf%;xTh=lLdDz1C;$j9X>W|V zIWqfi&qn0oRuhf^&`jz(3ttk+bKbjZ!h8Q2L_$c7Kfl9Dd`jT{ko>H<-S?L{>$CcQ zn^T2v@!-N|1n@5W-^;*TN52035CqhaY=!&O<3F1ry?4jMV5|Smf-VFm z@lSs~A^5h6!S^KNwSO=2t~AD9zJ@;fkC|XUdG3jZ$6b(!I)ttGe#a8$g8RB}ONS zcuAq;!o(?s?-@@_3jPk=mMR4HZfWhl!4b$JG}quxLNbql)(Y#~(XPAuSGzZ#mz-xj z8$?&%KY}tUOTo)eyil>QH4DwOoxPrKdO*|t>^wv|Q@fJd#Ql+J0wLb)S>Jc;x4cS! zXB^ODIngK*)FI-A=H@iFGyv{&XW_S|{zH&HEeXq1StMJz|06aG7u#FNKOpjCWiC;o z#bib5ix)D{^k*$J*UZRDFh1@{+!k_K$wL!G=>YyfXoouCtu^8cF*>llRnZ2jTp!cG zR-k9dW1^dy0m%1NwIIwFk;Ep->2Zl*sw3LT1;C?S_CjW$!UM-vn4C^^;!m{rS)N3U!IRObP?edHC#(&5#jwSw4l$1KYxg3j)(KxFDyybX`(|7 z7vTSVeoPoTDd#QPedE(r(Hr%G_iqyWz&^%vj@_|0_a951g%-vvv=6tS9ehO`%c2ig z_`53M8;npKeq$rBE01`aP|9P3*!o-uUL5O@{%1gAggBb}|0+Kjo95f3gEA`ov*0$K zUz}VNA!I!0_1xD#0R?It^TFTF7;A|p&TE1`dlLnQrcQ7Xa#xCJQ%GXFOPs={Tq;jLBn|G5Y}Bm=;Ye;2ke z5bYj**C@cql8PA2;~B!PYL86CdtG6*{7?3z0%{#bPhycHRiG56V0t9AFnc-JU`~dw+vpumSD!Lo5V<}WE|0ZPIE8w?go z9sbuHs7*$z%(SKmPG`~?J#R4ZIirN?pKSdWCAVksif2un0?6m6PLVRqR=4nIcmG$1%d^YMm`^(=?2&hQNS~Vi%Y;spz&Wn3plQk z0)GC-L#1cUfjM}P0_~cCzuQP8C}g0$00ticr1J@>geEJ6tdeA!ffIZG&rWS1wyO7qVQ`;LEN{xO%3j}7H3u07{ zy-9zRhAx9`RMKFW$8wl5ZxX*TSI@d66~ssD<>(=qW?> zlR_mF$RE!_Rio^|zsmc)ukM>CQH*@VtIK-ew_Gs2^B0efjYa|>>>a=m_iW%oMA-f1 zidgZ}FJ&;)_U;jX7iSHhnC%rIKzmfuRpc99{4u3wq)(0EIxoNJ)|^!6qk!p5u6E@P zpf3HJN4|0`$Y}c4?G`?O8MY=3WJoYg7JyJOp3QLC6*1Uf_+l_op6pJ4B8%I)$NWgZ zWyjEi2=$E~Ts$Cti3pyU^`$J5<6lI-e{^&E_Tbmy+kLHn$FYXe_03q7^=S(Kp*Rr9 zo-KK}5#K+GlN);4sU(sdsaB-(O?~u&i zd!F?C?|5>U|NiE5Bp2=2#j}wAA#ZTjDY{kekKst3{oq9-qeX=vYDByx6WJdGSqz)P z`&*Z~h8HRp+!;6IqN?PWXQ;$U6y~|zPzbP8e;8;md_<1jAJ#zt1P*e6U`O!9Jr`5e z>${tl0#>$Uf6H7`i_uyp$QczJs2(nMCBBj0-(O_X*lvK?FMOyH%=62%`yv}~*8npi zUy3jKkn>IB9N)usr@t^V;^Sz+WPpg*xg-SUaZ-z(7785REYzo z$35^@y-BbdaUF#)L!--6S(uhXZ<0OQ8#@BhA8{Niok{3fXP#2hNz2heXrEZf;th-g zQek0a5L#PWY-+T*8_Ev1SE{iGK)a?5WxDQnx>@rqF@Y#bD_&az)n;(N&o## zDR0MTF$oqdR=UFygQ+SE6jNYuu=Eu&nwe)TcP|4B#1adm0<-buX_qR39@HNtx5C|M z7iS?)EHEYI83HrWaK#w{4Zpld3J=AInIbXFcqe#llL0Dtdtc_AS!WcGN7;G)e`6g3 z``5qGli8|&OQN^GH;U~S+dCK9Lz*F!#)o7~9 zetwbW27a1;Ak}u-)Plt%!$urU)z&*kZ2*b*WMa~xzL0BRCCo8``?W!FITvQ)WpN~|x>;ipJ zNV?Ky+Awu=nUa(WUzcCg%Zx-NL9fnzo4DvsroT?;Or6JW>0wNi+L%uGT^zo-)StW5 z{pypJz}UfrxshGy9EixX^;pu)5dISdKIX&%avShq2>Z#UKSkchmXcI|`chpw?g^dt zx#&ggj9V7f@t}-8p&=hd&j)XaQxmmlv@6p{`;jM;K40ZF=Wne@6XMto&kKt#(C2o4`fm0}(v4 zqLG&kfCj=w8G24vc=i9fz`o;a`0V-91PSievhr5G&#qDSIlobl-}a}uQ~}(Hnd{{~ zlOZC+0p%|H;XOKC2gFxq zrrN>mcU}GY#&@v&t)q2Jxo=vl&pLPqU=7QO0)?_Iz^uE)OSK+2V1}<12qC4rp$L?% z!xbuWJ{Uz5k(2JRbLIz!h3g6A`r+_-3Ee*eMksNc8Ob}T%WkWwn%w8=!1kI6r6;49vsJaF1J)nAr6iKChl>yMV- z?&2DSJ@1Kp+Hf(wt3h=LR(STKIGVi82_Z8q?)J)`7fp?Np8E`v{X|WBU}80>r1kF6 zT?l1#arFuEZqK8vM5kg6(=8Ts^ zT!vF3iePB^L(sz~fJvwFbBn-cepzUwd>BG#C=FfboIc(J8+*Aa$waWzp^rb8xz%r8 z*+U9bvb{C@{h6#|5!0+gdM~$Zz0XRr**C*0*H?PpXWD3EX52F9tMQukYIb@XRzT8~ zbZR==f0Mnt2<$+bgxH9vqgB%G^4s4CAw}xiiMww7TqdGM_lU&lb^8%_b{=HJ*V6=O zIiD!J#j@+Faq>m5f zPv>n7<2eYYn>gZdX}V{J7}E9Ztnwv)m1rE7B!t#O5k3IZbze7`KN?mpS{Rb&z@9yA z=fxD@k}@aFc?Z9DAAgK1%};Qrs*Gjw=45i0nGYwc+I4?{C94Bn^a&&Bv55qQaXHg0 z7F_VX?3y6gd{naL+pPnRF-N^y!jT~tOm#e4Qc z71jp@Z+zx_A3Q9)iHY(o@Aiu9xmnLmXXm^#;@|}J+pIh2W+g&izQUqN1-hJx=px|$ z*IAGpF!WMTG^BBEEmk|gmK^qQcj>2o;yksPI6naYP5w2q`d9PzHpEGhe zw;y56;f2%8re!aCl^unW+#!JE*CQIrn9klshO!p2@u3`on63A>_dZ${hVTz`|q$dvg)xi0Xf{uO$!H!4(J9k70Plqc*y_Gv8)Wsw$e4 z;pOSR`YbK;P=j`jv$bk|YW#h&ww6^9~1hNg$5@}N0`_PJ)ZveLg9{l46rFJ zNR#l4eFv43(pv5Lh9zd}NONEqX8rEO4@>U$uB$hB!}m)VA-=_O!E$;1z`8^dzqk}v z`CAT-x6wVr<%VaGC<2W?mkaJ3q9v;DUlEzJkn?DA6$v2;HM2YX6}TPwvwx;1l!z6x z*}_8{zO;I5RdhlH6w6K#Iw&djuvTfQo*wmc4LIBDaz5n82ULzKP4?m4hmkGC1eHn@ z@s3ZK?k{rqxK+~4R&0M@854jl(eL~c^1SZ<_KDOsl9oFCaz}9XOo=e&AQZs8#pO;}))GsP=h)1Ff zUJbypH|EeU(I;UIhfm!70BqWuq{Q-x45>YSB#(88V@VFX#l6LTvdLaSUw0bGu0jD- z>XoRxpC5(*b&1lT8;y(@3ZkWcfl-}%K6oAGhmXiQ-865 zGRm6c?a|};$wUI1iS)xMWH0oQMjAUEo%O;}@6*p*9dAB7ZAJtg*@^=HMmxlaSm>Es zCMzq{`+PV(u-A?|O1aR?Z%#njPOTXK^j!VCM*<|0PK+%`3v_hXq&k^FN4}kO+H(D(S&XqZ%)(R zB){4DaTywkA*P0+kl)|Ows;^hy|3R);~Y>|?bcqL0oTdv4-zWc5MPx^Z77rqDrfrX zgBmg<`d27oOivAts{Ur6chcN9*8P;Me|`J`hR`g{O{2-)ZTJX(F&@WkPFSX+A@1xl zWIlt7VOWIBx&gQ#3j~6;69^3U0rGp98rOd~^?MvG%kFG3qN&)#jI5aSrGWlI#iTQ# zXB6H%@^_QCL>J448hLo_r;%}3ZwfybrPtA*{Wo(Sjvzdh3D+@tD5vrIEO5R|gWL|_ zVg%Y))yB8)Z}UB5Hqs7rCA7*DYnR?gqG+wRv{26M^s`*{Sm7g8@jq(`9m|`$?m6Vfg^0>!rJk-x&(L#17*fVMiNouP>q^MkJLKXE+vK1U? zc({}JOz>dGMHzt}p!bsvEE$!8jkL!_y%n+^4X!hx=%8>PQH6twp*GV&r1Xs(MUe5@ zfB_iU-eMUJ!nV$|82fY5(j{2^`e8|$*v#205&q2tK#{0D8D_OHoko&=+B)eWO*tBo zZzftlX2O^F>skGLxgOoVH&2I|Q+yz-MqPG4%yM2z^lT~4>T#V|k zpl?Z6(RxYW86iz)LtKpLR0Vo-No@4-@V3y$rZ*Xv+{TU(4I5{?Ns@4RadSTLOTBc%Y zHxa~fSqZkkHXKCOXZK=zv>AHEOXUZ zCwfi<0VS^_{K=c_zWZ>e)P-a=yH-<$adie*g_e$8g(8uV+Zn_C&J+34 zF(MqpLWj;`t!rNrTXW(}15s62*u3`axki(tW_K^6;<&>jSG!HKO`O5^^F8d_iuGMP z_z?PpoED;+%T>`VCd7pSkwUofL|C-$NFF6bOi66!>55Jwk4B*1dqNeb~w<|2&@eVZ7AYx27&1>e{g;z;fJA#6ZDQ< zav6q(JH~n~_BYbD(el@eVI1B$Z&qYxenj!-*b(2R8-20bqV{~q#EF6r_RS2IRVx%B z2Ybp=s1`k4L|d~?w5gn3c``#462C-e9N|ga+6wH5BxcMb8gP2UO9@_rpxX*3*68>3GMvd^{GkR!wcnJjy?iH6{tMr{=5pSLpyk5VODQO zB&6X_$!p^&$uyI*RQ>0M_Ub}4OKQyZsxK865vEvox)3&q7WoNK#-xxF7_-?I8N-n- zCyXCUAvm>ncY!JTd!%;p8?hg&#*FCml=$16nIEExG4EdolIS5W2#v9AX8g3O8pZ|v zCBv(Db3Q{=(p(q1lD@}0VGTL};z&LV6ZHon2~BNugT3%SidbVP;N#U}CBB#d2de%Q8yNYj8e<&iqZ=5MEeW`~mO}l08s0>^ z^c*O3DdwVg74wseM;465{q$M?lGq%lEJ6g%fh2o0tS5`+!HK`*iaGbq%rc|HU~UJ5n~JD5UL-TiEEv0M$j-EzL% zEStQDNTzg8S~h)eJAd1|6udT}$fve5%~E66xytEeHg!&Bd`rE1Nk^%}nW2P`UBD|ZxbBu$Z@EZQ zyD4~@O;qj{YZnR|cNW|2RFeb(1;&Qv3nE&W7P``}PpW^4O+oo=WJZOOdJ_kh@mDZ^ z3v9p=XFKoj;{16smL}x()^)4Itfi#G1{)l9EJ=R>?*!QrB{6|xSy({E2;(?Tc+%0) zU@0iRHniNx3Akb4l}aalz(J(cloZR_820PtOc6*Q-9OuXA2>&J9NOx2Gz#1I0T)Jl z11{fZd6YK@*tL9WO}`$#D+IYFj}N&QYILFQVfE2@d!pl~!1)@1;dFscHRJVkj^d;a z1jsMLuS7q5J=kS@mgWPzNJI_m6cP5iX>NekdAL!<2oduj<$R;kn+z;q))A|=fD9K( zi=kOAkcHdze+Uskxx99~OeEn4lx{oE!V*^Y$=>xZuVkq3jyT+0-+hfwsY;_@R!w_)@zjrLo59HXDQ>tA`pRpXT!?fX4JAZu3BSl$fDP{L8(r z*Dt)VI*^;Zk3{-wMWXsy(q%8EX5T$Ik6b|JSp!u|Ccs7RA`9`yRLz z#vM#k|HZ0u9)uuae@sg7;jo2i+r2x>`yJ^K9DME1_^Gp;H@=#YxJl!4VkYW3J2gEk ztUF2Iw40mrTZ|Og_~Tj#Vl4O}dsY70sSq9ayQMt4X{SnJ%8SOkQPN^6Y8@5cR~eGW z_aBl_zobV+4W&)}S)boek+Y>?hX{?yitT1urc`3Vrlr%G9d}MZ-4<>2r9^V*n%SMN zuf7~P)T)O1DJ9$+0H-Q*Hcqn%*nd~sOgc-o!TJex7HbdLA9K!FKuV0eN<$%Q$7oJ= zgOZbBX&z8$q|m|I+JTbjCwY!K79{_RD4=O#f>TrGLhNVQ9mw@zj>^dUSfr#CwhcLR zmjL$}zp8PT5EFL5HA{8!wjy!ea7_!DQwn>qBdkpVEX)N~5EwXE<+?RmkQ*R@GfqhD zefss~C(lenN8y6jJdf8^S0^6dcRu;pRxkIFX0lfjAh*W9KZg(S3t#RHmqfy5fXNUl^1z$RVP&h=yj+soiqvf5;a%VTFA6FCPe+e* zNYNOY*T7+uFr=8Uj^p66dghZSP}0Y`@4D3YKRP-)ri|#my99BobELx;xeJa`Px0L~ zXb&GBG(RAtve$sCB!HYI;M@+Fn9%zxK@=?M7eAdS93LN(nNb3dn~o#7EGu1AAN z_1OP{R^&sg^AsKm$d!E5?qCQchlk~Z6?Vklpm10ESmjKkOSo4vr14 zR0O)z>ALD&8;8CKU_Mt?Zdi1^r*b|;z@!w?ys#A4&rJ65tD@4qW&PqevQ0AP*O!td z1QM^ZMRU~(C<93nLfpmRk0Re5M6>DDvN;>)raC(}l>mtvlXu3|1Dp$94uwhDW$z~9 zd|34pTO_O73^b=fqs*FhT%E0T3tO{p`pnSI{sf96xYg-*7>5Xr$<0!(`9lCvJ#*{v zThH{AI_tVr7BM6AnDvTkFU^r;IR5$e_k`;}%iGy_2EZF5@}@0HG}&es5=9#KmAsw~w3*6^x0r%DcM zQEf)|WE(SCjN`9oyy}6s(KR2be0?~f=}yibMBJ3VS~xq*4?$$W%T0wd$|Z%O)(51V z_#xJ^JTh}^4QDCqpu5kPHWgk@at9_J97pwau25OPuT=#U zApN3ri|)4igRog@!Jcy15?`b!z$}>_BI_!o%ZA~=hW#>uqLMu%zV*#|IawXk^6G2H z=bmX!<7yovEugH_f4Y+T9`>D^uf;O;l`I*j06I=#2t-_kVJ4n_N}Qi_sw!!imTV&* zKyP*AOI<^T{=Ggyn!GiHE&G}d0VF1zeR#n66lXu)v%;`#BeUYr#!a9@mBWvzOO3gH zHAlS~2azr(VW$mdyCt5uTB`^v=(|Wrdf77&dJ7$_XDzH zV$~t>>nBPy4glD6xX-!ojvfZAZ8wD_jG$4!JO?L_abyGU3AS4f_3vHh%vyF!&q}!c zkPJnaY!#%tD^=t8*==_5#nKniqXD{ZaF}VkT7<5BsSJR{VPp-5*9P< z=7g8e7Ii-t50Nj$OZ7mj*~;d(&LC+h$8$PL3`kQnkdKr-*{dCE^r81M>KLID*W zA}J+`Efty=&iCd3Uy}*yn!&IC`a`r)485{})j=b{3r$E2DZZZL)L50|`mMb5<4s&v z!SC*xA?SsPt<&<;98}khzW(2IY4JRG4_im7}NZO zATbD`0FtpqvVD(*P1k7WM4)?ixP(W?T`*{U_({qC&e0~d*pR+Kw&s%T7e2W`K!_OK ze&hwiSuqdPufl6Neyl^F8E;n>A|?~mkFLL*${~A6CrwZFwpHaI4JN?YZ@4+y9Zimm z91C%w?}Eujbs|p)mBqEuA4~ud61P?CUi-(2kH3h%D!~U#WzxRXJ#~GwC4F^p`86sZ zajQP7Hh}gqmlv9B=DMBs5Ot?~h9aYzLcj~i^Ji{&l90hX_`TG}?Fdqnv>~Pk@0HN+ zYDY5p!OOeDk&B^1knn_V4Av1za1?Pm!oENu(p|(|)mf8|ZkAwhD>Y`+>-ghjA0ifq z$2Qa`4e`8D-84s^P=aW^4;(QqVtou9swOTER{RthO2svkK`&;j8HT=mopMO5``1Kztwc(qaB6;~a8Z-F!b z8S0wyJfxBg(X0)ZeM-gQ4i4#Jq;9X-j~`M|86CLwr_~v0tq(l*m?1}7$H}Y!7!&7q z^mZpF4{4v{o!9&iF@I~q?KlD;q*S=nLiA?jMq#B>nWP!{O|ncOCX%fmpKUJg1NXtN zCq5eRV)lDBlUAqi4~(YPISHCnXdq2i{x2+LIG-wrw5+K!c2a8_b29T&;*kS6N9 zle|&=FbOObC}f)Sr1KFC$HT`6lXjDIo1rN0x(Nf?x(19|rf zKP#9C6DhJw6;#b*P&W~Ru(V`=cIszNX~E>vZqM8kLSGlT!(sXu;>$~`?8)Fp4~}d{ z-8~aqx~)1}TQlzRQ4Dui@}v?SR;%v%psZh<5ONWL`0VfvOWEqlrcP~A6$B=u5T#H$ zwCFLHo8j5u75pO}P;HX_@b8FxE*D%J50<(y67k#l}%f7+_TWaE!t ztHwi#tl(_$Yzfa@OJ(|FMK_nNDvwH#Bg80{-D3Sel+*2ec^A}oSTdzWC+7w$j^AD2 zN885mPtRA5P4y0kEsZA%YG(;R?DyN^hl8~^zoj@Z3@bvc)HaK3!26sRw#1!e;m`amO@C*s;HEWSfgzS!2;wSti{o*HXW4 z`CwTvLr>HozA=q^cm!>B1d(~`o>e!h%a@UTTflD+weKh;N*ZhxE&zcjFty}y4b8v) z5DXz|7n+Eo8@)A*p>JzVerp5iYvPBXSHkyU5nXMwz%-2c?bV)pR0=khIi{ zXP*K_D;eF8alvh!WAx~9Rfgmk4=HA9m#GjK5)H|@`bO7(DH$AH=4_^4`E`z0&f497 zw*T5>5~CRdBBtxm@ZkZSSSm!KpE3FA|IyrgM>X|sYol0x0)kXgkR}1?MY?o_NRg)W z4hk5M-aDwYNbg8Tq)6`|T~H~B5Tu9R0#XB^_xtiY=iG0fy}xnyxM$q)jq5)#S!AuO zwca(~`9AZR&r|)bF6t8#-Mbgr_J>lVW=`cS@vQ*RKH%ykhgvp#5pu6hSyShdjIwlE(JdX&JNRkvNwk@%gt>k`*uCT=7$tp?Uv@zDjz5 zCr`9yA-!sREEex$zkiRT=ir~0d;Yr}a+SJwzzOGzh%6jWvP9=epeOjQVUzl# ztNw*SQzox!o;uA+PzlkQ>ozOCdYE0b zi_1(x;9ozsy6;C(e(#iu!M4MChPvmQW0JOy0INuQ+czPlk(oTEPP?ye$tdlluZ%9G z#;%oC@U`#ez!DsPe1_g*lF`1|NkJu{H|(ve@tnKDA?zp5d)ipX)9s0{xEt1j&C6bz z);nf(q?Xc$v%(E$H#Q>OzwbO#XDYMr@2K5=yREh*0e$3_CMp-$SkNp<+U&Vbxf5BGBv@k;-JhoA$Yf99$}FVr=D^4JUW!v5k<_Z< zb@+9KKV5!~ILxQy61(w2PC<9G@u)dl*!XkV)_a$kUwf~o-j1J3JADv<`RS@I&(l0- z?b9D^5hVDl|K;n0r|iPj*L3&Z;U`_Fe02z-K{4sG8wGD%?>HwK6XTK526Yxn*0AB1RqmQGZn`(}*BW_WS z41zQa0H0Rjn?0lAS9~p_#|Rl9!*$2~uy=k?WccTjE|A7l@Q(TuQ5jrO?(O6aoXW?r z)QsPN+V+o3yGwbmf70yw8-V?|?gXW`*8Rob z41N6CA7y7T6Ri4WtU<&f4R>}+l{~nkBVqwA2~3x<@f(VZura|HAzjp2KwocbfEgyTTrwB*^8h5V2 z7=?s`La*}^ZlKdcG?yE%RzCwWhx6<71Zg(LzS~qyu1&Lk+EBBaKfj_L&HuT<2hkfz zo+1>>+z9umhd=(3?z8!`@|=t}_*ISh$A>R9{(x>p^s@N*Vf;eFNZHgE_?WWgW$P#? zdeXiU!)5zzN4RhLR%A#1T|U;PN6-I6-YZeAt%F?s-UOKA+cP294_4#~aDw*T<)%SO zK>O}@?0&x&U;+ zIX)1--9X_F&~ivlEQZL;DqE|oZy8|6d^CZ}K9fu7%=E}!cXql^8zC`uOs%2(n=mZf zsMU1y)5sfNaAO|WLXZPhJy#P)X;>~dIU`Mcr&-1JCb$nI(cZr($tT%pvoIdBs?J$Y z#USrtCdbW~8Q6e7t6DnU(;t@r9@0pyC9$a5qs`$CQctbvOBv6|?&;2iF0u;ysVbru z$*J48u}K8U$;W{iL}|MLumGD!Hdu`Lgg?L+Qxf0A_Z;N4B7H~)u=*NF<2B5nN< z1f_i@&`@VKR<{uW8t9gCcFbxVT}Y`Pewp`X>zr{q0}LLN@K$p_bu*>fBQYcYquT9z zKPCVmpX6goFX2uCP%L;C;3R3!fd;e4(Hu%%T`1@b6igCqDfI%xjRhD$GjC&=8(;|k zU;J!Z5kqg>7u2$(xd24>)Crn-p8k6h4KpRX!)KD(kR0`LZA5ckisd~M59CXr9ElkB z^cqlrFx`&m<67-TZypY5qQWe>McLke-OqW7ubr^h5w>G;S54+@@*yBITYW)V8*=HC zge?PI1k)!cFPkhoUU^J9nVz1{296Gmy+ncD1qKNKysEsinxGDq*{G?WvA#QDe)z#R z$vFbggtbrEr`Nx$1vfQTN$DJK;I$vL?|ELcQ>Y1ByvHVe8JvB)*cZH(jVW}>rE@K4 zbLj!?=tboe;KC)&fhiV#P|X)kfKZ^mgj;!i@J%yO*-x4WCpcFts!RaupByj%Q@J3I zGV5Aje$V%$A7|P4aFC~6?9t+6+~gjKz3cZ>2af?T+Yi%v)1rB-x`N(pRRI+#F)Gxb zM#s6}39iicr2c9c-%rq_Qbc>D|HkIzpS!}p#?!Oa$tu%Yd}(V06J zZRTAqmA>#+XZdMr)u^snoal{f-#rIa>$?P|T>#`rW_J6{>K9T8TNlaEUnwp(p(GuD z0N5E0W=E%u+WH>?E*Bp>3#DJWJeTB?XFH)+`r%s-iaGC5px1zYZN2q`p_F1;5ya@jkEe`cx5vtNy1#Bpl|;vd3*I|#!tWE z+0?mCJXow`w!SS?+LyH+=N~dKaXU2G!OGy&BDNMKa;uphL5+)^QBs%$!Q$(57aFi= zNt~;1>x#?$M~@huWRkexrZxOmlXnK#wj(ybE}XNo)Z7gt=y~@-kYB~jXVvDV2%75f4jQ`Xyw^1(f030Amn46u`~EmT12hlRA>KZJjer+q zvsPXv<$v~4ZS2Fas^b&i*U2+!H-w}(%bG`FIbBzyHE^di7+eI2jIYbPFUwQ&E~_#r zbKkZJ)DRkF@NW+x*KOp)8ic(bHY)t!$Fl|+Ao^`{(^lcs-m9WsYBhtPw9%*t?Jrw_ zc}{y0#4lLK18%U3WM*ADUDocEwGlf&DZGULPwwUm!?MV+c$%56&Ldq2HWY6pXl)WvL+M z3XO;ZB-l@!`AAY_XA*Al6FOYqqo7B9<23gwDz{%12z?e5|7 z=Kwnmzj0?ShAy0a)_T&&?s=ys7$`M#I{qlTLr!o-{(EAzk@($Uqml9%z57Nq#+q$t3yaJHkXzEWP<$OY ziXi7h?JT8XODKY^vX7Xo%t-&03b_>&e^M<^bYc{o{(Ga00`=6kJ z3?UP|b5^yCmgsR-9UV4^W7g~FnJUcJLwYe%;S8V6$>7Rq_%hqvJ%p4cqUO4UW2@UB$-+4gY{!s znsTI%aIho31gq^h2|wLuA-4qq8Ks)^{!{TS&?Zq{3xBM|^cYATm5p^G&ge~)SCh~ZwJ90z-p`eznoIZqmjtp^E7kxEZpBE`XV4Lq+tXc*P8!w&2E0Iq!Ob> z>|r`m9m58p_S<^3^uTaL0cxfaPfkG3pOyGt;DJ(@D}k^4`&WJio||gqPeQ|Ae0#2m z@-*wF%8p<(t%q0TDfAG0OI?k1-XU>51vKpi*jLoSPmWBl7&=w@=eo80 zjnvNm$^MxD!345j9zhh?mV@78`-P-X3mquloSJl(=DWksEg+P}Z)YIFc*j|ec!Km8 zeM$sK|A364nC$np+mzsJ+1lgKR1qOwN=np=PoGlfnr4F_@y-vF^L*h`Oc3h1-@hqr zIum<#zi|UWf}$`{LBwa54!KG&+ir%(QiQ-`xkCsRbW=RV1nxxuX57z;8%_&Mav_`i z(yMDT2~8K zfd)xrNYa?CH>N?7{K?qdWhGf&*oF*rWZ)4q(z_<}3O6aIFoa&26GgL>`zb+LDve~7 zJQ*GqDZzrd62J0nI*SVm{EUBel1WDXHH?GQi*`?6$jT#}AX7Mp-|qIq*%~DZMx`Ic z){QUY>f_nOL5&=H^Yh?(SOi?J<2hZ{x?G1~2f^>@Dlaat{yNV)i$8PabWe)lv-Ei? zEc+ww7fFcrE~3hfWM+tGU-PKs;CkG+(mW^-_PcupSP?ZN;diDRnyp*YWsH|6NwNHA z^wlHxj!h)O2+%yU*5CXTC@e*;#2OLG_pG$s1Zs-RSLFTELuqbW^9%UwPa1;)i^R^d z`Mhpp_53~1-@-M9421S07JtBA%^Q!HX^i+ig+6x|7is2J$pWoKe#3tJ_wv*TF%@w2 zkufmV+jkUfoz84!?`Lp$(JAQz#@I*n6NzWh#3=VvLpX1~56A9(4 zG#{0Y$P?L_CujGY2}muF1|)!u5w@q6*fi&sEzS{i0WF1r%?@N$WeQ-yDepdta$ZiJI7gYzNNyx7o;Aq z{=|qVw^CHAZJB($`w1RHp+BjDmYZTG`4i)n0++yDwe(Qo2IU~Q(hYO1ZlYd(YHs&$ zix|w)@@TjsF$y#yQAS>~{6Vh<^EtwdYFU~VOnp>27_VH|)MJRkh`Jg??Cw*M$FlhR z=FcB}s~C3xub%N*zSiL5v2IWP?j`e1Mq^H&SV-fK_-d~me#?yky=Tz=SaSlhU`bjW z^_!b%i!c-I0en*)5o zDOppYdsWLdsboa z04r}P;f>3XUf=%8u06iP1hUMGRW$FtR}`z%Zu2-~_yhB=AB&RehlKdJG|Lqe=IJ87 z#idZ_U;F8$7=)A{?RoB-{3`>+>dcQbzfBy0r_5t7x2!r(HAqF%^SdGb(bED|y5@8} znUM6V+~sxi3gyI%wQb`DqD_`f*XtVI?{aca6R48kRK3-$YmHw?M*kLJp0lOlpNu%H zCUk^fDa&HhV!tL!A@`)4$O+nAG$~0~rY?q)y*bJEDwOKFSCnw%F4>brw+U&Fnv@zM zsC)xT^n^}v@+alvv^noZF~?q8>1XqO1(7aNk~boL?Tp)sLxVof`YV}rN||yFb?hv9 zJ)imIKPxpaxXINdzBaA&!~V_$`9|U7gR){umYSEVL5;b7PHN*8(-NJ6b4Oe0Rx-^t zN^J@CRTfpR<-PBy6rR85StCy%zDKslk~Yf5rg)oN!ySLJq5ILcMx4tFv7c`~@3BC9 z=zh>P7^_?>v%?jDjs?G08#BZwiM8^A>F)c<56*FKLG#dm$;$snODiDF{%?S*|N8VoyJ3YSyl&Ah zkE?_8T}^bOEfG)RbC02y?t%g$Q8sWQ*2-tOTu;LwuVjMkGSLr<0B-L~7kQR%dz43+AUlbpzj9NW)MU>zF*NQ&b2 zeVXhgsS4MW>4kz|aL2zHe$3I$Y@4Ltb}Y){fH>Haw9IN4*1iE#<|$dx)l+8&3j!UC z!%dRwS+XaOPS%O;{qp&?Gu^P$?zmPe;ZlDxJ!s}w_qkGx80ap69}iVb ztEc=$TZ_cIx+3v){N{+x?0EvU57%Cj{kW2l4S5s699Dfln?3B&m7Lkz%lb|tU#NdJ zu%3zP*A*8l=`_AdO&w;j8@C#C7v|CjWKE^C)cn$v&vvMbvwfu3w8u>F0mIg;)M1~& zjK*dQ7W9uy9jwoweL%aa)ZQ=NxfPJh@wCsCH8HR=37qgI>X1wl>NFhmbl!nDhol=q z>jTc8$o}vqCMP5XyfR0(*>{v_24AJ0PdOuvG4|>9m`JkUsNRoGYGQiyKq&qi1e)&H zp=6mBCFPE|S8jt_{EkGQ?ygiHpB(@}yg8`)%>CGM6?TvR0jyY>#-Qyl^{4SbwF1)(0V9D8O_k*u{TG`s7>$vXU=Y-8n$v_>u-F+ zc8NFpWK*IH*)HIBa5M?jG5*w??JODV)N#NTjy(GMn4~++*h@wI12hc9 z!2~%&dHEkq9q4UfIbgMgCDjfC0WtHnNB_(HGqLt>b=>Zo^Up)cLRsM!`E7eTq6~?((u|$cUjtf^KBAN{u$ws+JuAsH)!(OV^bg>z|npai22{cOra|0 zc1NrF$wT>R_6Cu(9*=8h{1+M%>YH`_?{cuM9E;Dx!QN9)8EtF5U&DPfYc?^q5+2Da zidMBzt;FO<6QEnR`ZQ|d;9@JuoJwPJ$ERC*4D`byT9vqT_BRmzrbpap-6KEP)Da2p zpoNfpkDtA*>sT*&=Ba_g;JkYm{ed>)asLy{K~w8@=(NlUgr^ZLO2a2&(H+Cv^{tt= ztMzQ3*0l3g9$g->(76aXWTcSpA*0t~&nhr9SaZdjcAv0QK7jTKrEw(zXM_eJeNl#w zgQA&%8vfZw2i66u#h^>*C$3TQ{Fh*x=6Ob-tPA|>dezfmKm_e~ci)l~TT}fj;Q~ck zw6kwNupc;6OiZ9Gc#OlK65Y!5wl#zU&Z#ift_)jWwI^Vnx!!+1bxla4+%qyKz{(R@ z$D>#A^;Dw%ptsTa##CzyUvdCr!0C|v!5nz*HO}*=)veunQq)??n$<@Vby9|pqTDB) z3Zkk{_WgE!k4~-Q>_}L}x{Z9d-wTv6y<QM?h34) z+VHo3e!WGHf{&}C8nr>iETSq4Cyh*&F_b#~6K~hPl#|2+nGkYc_a82;pEf>c&Dvfm zm_QoHsxEl=Avg+>-2h~JWX$=kSp=)=QES;!I5tok-=DD2y%T$u9O$kt>t$evOM6p- zM=@VTf0WKqjFv%fChTcht&pttv_8v5Ic&r#BqgIxeo&&4oMYWGyp|$(KV_H8La(m= zb=PP}r_7W+D~}gTbeEU6R5!9*_2aK)$-N=LXZp`*qM8FbCxxOPAVe^Sv1c>qG+7*3 z4x5w82y>}hokda@wfv!kc#$w& zLPD``Y*y*MxD`x<&##Y_n689C)egl48gmC(D2Xq+HR3f&1QYi5v`OsaE(>(gmMb6) z6&ncS+&h(cY362dUxQ}3Ns-ZhBtFo-kSs&q-mIWB|jqfug`3-EgH=@H)Ed-)jSM46H6%(Aw{Vyl=Fvgff!e> zz8>O<0gJ|y`uex&GfuO;Xyex9=GMyQrF9{yt${q!?i?_P-B3Hw=d5amxzN}>U}DQ+yCPt2Kk&-q+Z9I6QpF>BOhj9` z9Q2$O!-*BO8S%=q&HD+PZdO*-SDJluI>idDN$y&n@HcfSj%8LzjDHu-`^I5U*~ZdE z6o&9YxJx@on@iisnwzvW0@)9-iPWmZ{**mT$@w+Lv6cyJEnnW65N0jOaFaJnu+%q{ z!5d1Go>t-Z?FwaM5Zt#c;R0Qaav<7`N5GzE5t6T|_H}5o4<;DNi1_UPg}I+5D;aQ} zNRJ=vw~ubC;mjq<*$y40gLn(F&V%0K6(IsX{FCGRx}r~)T3+{x*VE;ua+RIhagNgs z-3xF85y(b>6^w+EUViezUjWa+)ID_fD!Asq4*_mF4a43Ae0FcJ>Hr!eq@>Sm= z#O<56qcm19VUbJKNa8!aK3R?(Jv_X1P7$!?CWD%=aEeO zx)Pu$(1K~`)Io?tf2Dib7gVp-*jk$ARh2X?32ZW*u=CInI`$fC5<-e;AtM$lKR)uG zBv2+#D;{m|LJPQaF)z_o1>#X|wb#?H{|d@D_RtE22bCm@?$P)M5!^ctIbaVKrqVV( z%18729f>ue(CGb%dR>SZ921&yb-F=A|BNj5_1MyK5_dzHq%P?=vRy(o>!>}CulZ0;y_2ja;hP@_kc!1QkCz%INpP;12;HG6ut6{gl_DQ>%%gPN76Q| zH~YHvl9!IOHTs-=3*{6#3v;!Fs4RC5!=_0}jMA7O$z^QW`|=$&#pc>B$N@wrDW*y3 zE$YK0&?`x66wKsk6WmKC`|ThvRp2FrpG0h+GUzD#H1$ltiYw91@2&D*@r-^u(Vo4s z(9vSSvSwT=&S=Us^_sVz*c{@<3(K^@T_eV3d~bO76<(M-p<3yU8}cMYgcN)2j&?zC zA?z|S2Y#Wg&;H3R(aGt;4zc|)N`G32nzfkH5FqdxPkAnEOsU;W(8()dn_>oo+L}h` zLF`Cejilu17EXh=y0n)GVkvIP%p~-Q8GpZdKhuX{UFg0jERv(#%g$hq;{CvbM7+_# zcZtQ6kk!rf&M*({QgXtPyQa+*36bePm#bN7YNH$UCJUG#*sP@Zgf*4xNzT97ry}(o zIz3$(A$6R|j|-@Z7#!k9J}zfnScrM)4;BlKyoOs{NUe`>Nu|8qT#Q#=8@M?+$@$Sw zH~AKmEc{RXz|cq5AGr-Xea|N{wg`S?ouWClEZ(Xy3F--|bJLxP2v=a~wm0k_fO%9nx zC4NHZnRyg_)S;WH7lLDDXZO8bqvfCmKg&P?%{e3q!CJ}$TE?Lq>RvNTWH0LfES{(# z<;qC9y)}Dk#+M7bo#ivC5~}B$Q8`a_Ynz=djYHuzNx2YJM@5Y9FMiEuHfmF{W1~!v zDZag7@goue_R7T01{!Zli1XF>jc1Ch>P$K1z)>TjDw3nAG_%~$eHC>dN31dE7X$b{D#h|p-dL)FG(mCE#25``7@#Vr)@ylD=WIa ztPO_lDH<`ef;=XeNNN6FFJ5JhR*AKT{8d?AE*tGa(51D@3sYXXi!!$!x8F0iNaJf- z4|9I1s@}OEr2e|Lh%B}&VSO~>FKce1!dVTk`kUl#E&(_8Et}O1Xd7t*V=6_g=bniw zBA&gTHyY$8x1oUGjs}{6)l(&HzMpBN5gSv^Sv}f6@3}hu+CD2ZH}Qd`Xjj&;g_#@) zxm&nNR8#3yUxX3D#P6?IGA8KmnzGd3ZGF=-z;a;|A(oXWp%Vg;p%s~3xG4+G$Q>1e zF5)K&rqh|FE=zW|i&MFgXrZGzrGL5xnAo;kgCWHl$0^AaUb24UQvJKJ4q^w9mNAJN1)!gJ#hB>jeV3G z6+|O*&FM+uTiPt-VGwv*m9?6bzVz%X!{;h6l}%|K`B$~2)r)m~@eQ?MfQ0O&k;N+4 zxX?Wt)!(`QXFc3^MvSm1+Eg|O1O|{YC@)>xlA4AxiDbx<_lb6?gz+;mtNbHzsuwMpTKk0r&KUUxnz_{w z__6cQ`a!4NvufA(=A1K~K2H|SlD6Wo%nSEc1$S+g-&?&mROgi_?()mE&2Z}6)eu`0 zTyiNWsl7?wu*wp>+@v}xk1$6lU41MqH{H|_*CW1mC1S(nj;q~~BD&Y*u8F60*W0h& zoAC6r0;=q$qwB|w4{|a;V}4Mo^YXk{SxS32m#wis!Ix}QWdJhNRJ@F&yd^HDMzz>h zm!l|`bj4zevne*o#hXRGS&>h2M8R<5EZOltIpbY9lqy)qoFKhNgrGyo_hGFmn>VEQ zYkj9rmjp;yx`K{R6!l7F9LhRY#npo@$DW*ZnSC4aMwFUpfi>Ts(WGS!bj|TZVldq3 zXY4cfQd+UEHL12mAfmyF2p{O1%Bpgv5EH0oxea(1pSXZ$T*m91b%DcqDLr7+oG?`m zD)m^<**$%!bNCjy81-@qKkQIncgg)r6O+K7hwTMyXX`YRsnu)i--ELD+l*h-@$;}o zCJuuuPPe;5Um&3V*9+{#zTdWN^3Cklo6LzXc#nGhd+&Go=C7|Mgl1-99#rJNQk3zT zmN?vkKX7SqI&YoE zZ_r?dm7-gJ*;TZ5L31OPtMgUzh}n!-XKU~g>IruC>7PG=^PJJ%j7f2G(-p(GV5T`a z0yhL@czG=I7{*e$a_`}nfX8{LEzMT>>?~h$vHCUM#`xDCf>T;Fs93w+VWt%Uy{!7D zs6=&iz|r}DbE=&(dr6aF+V`f*OKo_>1iIlTotK7-1k?nbdGYP`>Q_GZ?(|aWa-OS% z#7Xzj%?k9Wof)xa^vnp&+%MSVLb=F=ZVq8=xdY3W`dVtVz8tkb2+9?(A9jujG(Y~M zSvl>yV{BPr+DM?`gh@SKk~p=bM|T>%N<}mdxBl_I;iG{b>0G;*x%I;Q*@KTZGdn4( z`FlbI%h?n0f}dyezYfov3uiJ+6SaZY|lwNk{ zXaNPv9TQft)TZR|GSi02)*vzX`kKmq0+v0{M6lFrUwc|`M%P?dLDq3(N|Kd*!3gJh zCS@70c%p3fW;03;?QT(oxgO*TLnrwj9F>adcCR38`O3dHMXV^Hd)!55wuRclPfaLn z!B`vSoq1xCh5gJXsIuhq3uc>1UVSdj+q@NrOA&lZaT$3hRU5kqZ8~M^8#hdtNyABilJu(Ng-bv*Sz#ZhWR#V;qK+` z*1o#kE<(TYw$D#&N^#0tis2@l>(j|Sy(c9qOZC+v(X_o(&UH=o@9N8=}_d2=IG4F&~TSqG;k7zxPxqibj0ZR2TogehX#Dl%!c`N^_m=F+uIK6F8;9b^8$kqk zkKuTD|LX;h=_(!>1n)my%&t`{CDR_+R`-fv?B9Vx{rYcl=j8rcx4;~g{UK9(ccB;u z$C_cCz+#|}Q>jo-f*(Yn#{(*xUjRH)c8~v+R+o9h)UKv_%X9nQ>G)>>OTS!-0jbNk zbdpD){vcE40+Cd&Vw${5j z#HzfW7xzTgo#@1td^Q|I!?1U!e~B&q9!w7{LV8c=OUdVRe_V^j#40w=>tf`SRev@Q zV&9=@!yOZ1T0GsyI-sstY~9jV$d0K5f!QQiDN<0SdM z_Tp-c9ILMAq@$s=HK21vYXg>w`9#X8J$<=x)nX%V94G`f&@}@os`k~oiOm(E>HC3L zTq;=4nbpccIg3DJaQ5ecN5JC_DW1&Z)7Xp!<3RsBV`IbKIN8M8%WGrA(8K-;5M{Qg zb)1WmfzeJ zD(&i++%Ia0Q2HAt8gT-Bvbut=(=}B;IzD$h*-$RNY}V^?#+mppEo)@n@`WQdfyZq&4OT^k12kI_br=9=K)HPX}P9Bdr;`dG_ko;N!J?WrT>}k-A_wiV78-C~z$u}L_y&L+ z)N8a|NfQOPHb^u?kSz1XN0Pf?o`x%}Hu7zqY<}(g!PtkpRMoM8z(smh7O`W`CfYZG81d zqOOT%oy+#Tjj~N2SdeI=BzGk82Gqhem+|;3j}N;{t#*8ACcQ`WtAV{+V{1a%bPybn zg9_~~CUrYMFJh~w2<_Bm&NL=qC!PfrNoPRyAQ965BxBtTP%%srNvM=6Lyy1ceby6j zXEL~MT$L)J*pbH$>kr!~qpBW?Jjq`mpW_?>4?ZO9QLU8;YH7F(YkYDCxG(gwhjf&t%r@%YGRK!vRYC*?ay23~>&M z4=?E_;*xTJwpB~Bza!sBUQIV68+Ub=iTO~G^i4B2s36Y!nOy@v`x`p$87x(KUYvNWxwov;^@wW#pAcB1 z>HvNJB=-y_H21w7)$L2)1!GJ2qj`9=P$b7#j%&f<3B7=Yq5^e~`B5tlor?bqxPpca z6vaE;@v_CXbS2%CE>-WfWa7aG$R;{q#rv7E!qi{CACX|jZ5+5~9HcyT;E&;NuP{Ic zgnu^!MFBnzR3u}-Ecji($HKU78CWv%z=) zdec4a%q&?K7@8(7Q900*9`#!8wL3Z`WJ@<1aa*rsBOoUrzYirYA&U)@hP7XoNNCz( zskGp`=1xL2Za5=7gDuG7RF<yi{Oc)hpa1G-`Hfl~IjC_V zD>tULI1Xh@8lifi#vrluabc7l%96WSyCPzsulsyqNA|kxbprBhtWY77&X1LhEB@Wt zoi!?p>%PA}W}-M#Zaz$Q2V~OoVZaSg&hEb78Ay^kWC!og?z{f+va+Kt`vaKs05Y<_ zx`#X$O@tnHSp|~hrk>%AxEBm}CB)Ryu#B%B5rcYhN`=bhrS@mJcI<2h7))}(@Wdc^ zP{0X6Zki{HBGxdp>zBeq_*=YH<&rPKs%?Q%8m+h58reDDSXVjAOoq*-jG{8 zoR`&GrCzmR{YgKbEOz@oK;3oyc0bpl@t^fAw*+bxVk;NJIN^?e*=fm&3&KXz2$#;1I zzl{DWjHr$>+K7D;f!<$A%GP0m@Q9_96lH$pqV%_vl;xatbt$oif8pA2t<06QxDVs4 z`~^Gzqu{_h2iegQ+FUlGirYZt6?pMZ_{;?-C*qB#c|j=Ds(AF(5ij@E4U8B-F$jlt z29Bp|f=_ho*aG4S2L~wP1@uu$1Dw!B+_+?NS{k(~#<>zON6R?{*^ zWt3+34&=^dPFQ(NOJ#q6Nz|bA`|+Mz@w1VPp05-*fr}9HtFqU30fMRNwfHU7X3xc} z_g!Pdt1|3h|7z%y@1l$TC!n=LV@Gz5>Xk42NnlxuaOP7&8cvKM#t`+OwFmHQJ;^B)RM>(-VI z83Nc!TW2~qCc#iaz*N_MyiRNJNPNk$)}s&1k4aV_e>S8MCnWTZn$}Z2=PR37%G)ko z!`+j2xwz`F?#Sl)8b!>rluoQzwCMD8k{|-Jz<4gfdxp;A*TzqZK;BgvIbt{p9sIsGnE0{RgQdNZY(KzEEr?ROFhcKrKLJgM!>gXV&J z(!QR;e#g73zZDpHp3DI+bEmzunbZ97k4YD2GZ&?oYL_~|Z{*-vg!`j0htvea38}&0ucf6_Dr@hxofg1R+mfP4%;8JxT`mNJ4 z%?{MehkzFNf%0IBC6htuQn3p4g>t-%)1D(Tn7)Ivf z%A!uNZEZn<7-Fz>7Knv^0TtO$k;W%+YgK8?x;`rDk6w6PW4bCr2ddue$(9Dk{zpIg z{9k}3mpsg~yOyLu1l0Wkhgh&A(P}DRzyL4kVv!kN7fUj*;iHT6uT<#@kY)mx`4;C=Mn8!`nWl04?1(FyUXZN%w`+JJ$i)0mHY4>$K%pLG4Be>R& zlATGiF(66g4+WEI#rZ7;$*;!<-PWAf3}#c8)?3g0ftTx^4X~jd2HE9j@G(-f?MRjK z1qgs^AOn;u`uqMelYV=!=5?2WdCAE>CGMkI%0#K3yMnezTqh zi;nZjy!5q3h=L_sJ#g?cKAUJeGi)owb6MNwsT<3Q=c%8pn$!kt#}~sOuP{6t4LD2A z?eE2be2Qb{KJ@X7I2d-w)2nA3(4mR_^MkfFAg=Yf7(8bszw%SMoI`(u{+H%sV4lRq zQS$2Y?w0!ol3nq$=}Q+oE5g|jlLL8if5Jy8ZII|0j~TyV9YZ^9UZvjVJ2F7OIWIVo z+o5?|zIJcKkZa-ca9|wz9NWP^N_f~Ox1Iyi$0y0;V$$jg z#2cH`52{IMgG#eOTe>S}mh#_6QsL}+cN;=+V}B;#0(Z(3N~cjarbzVE4jq$mjxcXf zLW{O;M@EhM1G_R#b0OU1rNDdnzPa?mVo!Xc6L_|KcKgzF_Z(d5=E1eL zvkiyjhKD#`UQ#;}a<+6w*@Dpm%Y6R}l>dG;rWWW0abNVM_+3R_22IGCnumO5)1RF1 z<0&KZ2Aurg*X|dPrf#@0k>Rw}j<4Hxis3`f_MiHI7`oz28k2RtTR>m>*9z_rFZA>r zd*R=85&&G4IVR#8gc>KJK^W+#xFUPq)<_z-)suc9i%ohP6fBv=#Zi?T%yglqcNiLQ z7^+r&fd#7i0{WK#w&;v+^*C?}K(ql7cho9STjahbo|Z?O+ZOrZi{W$dgo_*(3ktw~ z0NFQ$3(dn6q*!$`h=Z1IEf`QN%8^LZ)1RiU#AUwV=lak?1_oZViSRHIJ}7M@Ii85S zlLi!Xb^l}Z0g)ZFgWL}=`VAYIHJmPxZKuk$z-To}CpcbByf7lVJFb|0;MsGT%#pxG zE^}ZnLBI3NVl!wu1kPPQ>8woS5X&VakOh?@6a2IUgk+slbRjP4y9F4ZnG=&P=_?>q zP%fvtsI}c9Pf2EiT{OIZ1?r9~)RHMz5*q|^Oq^Gij6J5bIgc8D-q+QlbNWG^7YqTm zPXo@G@XR1MAW-4w+1$rw_;|5=0sOtaVIY`p(x`(QGd&wN-77vjJYFmJi1_R8;}lw@ z!Ccq*m~xUFV~|{eB23ASBRir(ylsa+`4E`&l!`HAH;`Il*RYNZX@%<#ri z+(dR-9tD_N_ymGoST(DNn;*SlAg&3I91(8$P_GP-aXOHIJ!bPfa3sl%5^NKxs@T--#;3}Bt* z4J+#Z1wv>ZbJU}pV>HS?e`FJe1Qv-at1Vc+a)Fy*_Hr03Q1?K?WDHutAV}4^36hLQ zzyyR%aW@cSV|rpBY|%|-2~L$-&)M{bG3^?xho@C$Ck3Si;K|Y|0@>@tDnJgfrafuR z6Bt8y6af&h@Sc!WjKJk4TOeo2n;ekuT)n%2TS{}#A-cou=;Hv+?|bFXJBC_7o!D*< zST5+P&M1_U2H@BNG$Lt5`z+JJeF|YqG~{g1HSx+*@wL#GFlQ7X!kixM6oYwDL+mnt zvIRJpm)r45f$n8$R(zR|#(jGOIJoCqp~E0Pn%%pc%@^Vuhy)6LfLNh(28>#gh`p&9 z{DBT^!d3-1`by(vsIUim^1KJGdab@*d%z>6$s2e=#I3^4kOfSIWd2t4YALYMv(NfQyv#J=YG0!pLN{=1)7fkz>G{l=x~NYVB}S8`f9 z2is-h8-u*NnafP`s<*0*`ipJ78(+ZXVw)y@u3zm#h<` zJsgrx7if|e1IQ?U6+rA|m-Zf!G=iPb7hr#2l;VM(ghxRBk1zkZ;U8Z9`*!f|@{9kl z9lZPZyBQ<=r$73i>;&(he(V3}x4fnQ=iU7GbGdx?|H&!;``!E>I?TV^AUt=x|JOJ0 z-=EFD9OiOV{JU%W@3#MsZt>+#|J}9y|IvW_KlKd$>qT+D`cF6L-#^Izx|9D=Jox9` knBo8PZvOiXwEcQ6!=>nrTO^+L!UO-5o~l91WX<0HUqks4IsgCw literal 31992 zcmdSBbySsI_b#kr(6DKwH%Lne(jl-ZK@e$akdp2O31QP+QUXdycQ;ZZ2q@j%o05*R zwm$C}@A-Z2`Tg~M<2%RkjAsnjzVCIfm}|~!Uh`T8zf_RMLVt*U>((tSSsB=?Tet2& zZrwszN4*bP^c@RbZr$>1k%ft=xK3`T8K;tWSJjjxwHcb2+z-_(XDw&#O)$QnY?W;F zwZC7!%t#R1;XpTNf6~rSFp$r-Lmr#qM62oIXO6nCuy8{~L)I@5s`QLXF5#J9zkWGg zI}PN2xj8QZ|4~Ds&{q!%??NCDB^Vt1fr`UmFaii@&Vu9qZ(Ah;{?oI6S{b3BgMaVg z-&!Fw|Fhr!+8TliJ_h-Zt$zphx8FZK{CW1@hP!+VA5vlR9i5DqlJdh-i`5Q1*4pBFLyf~28D_1owimx{w!jg$zvO6+IK0P~4VojLj3+4prJm2Yxl}&|Q&KYZ zJ|D?AdnO5kVLL)NU3RDUzUf_;KZE^D)Vtao6L|@NM5E}yxXp*@Salm~#bqwPJim)O z$#>Xa(Jsr7rovEdB{=zj844ZNz+)K^U(~xfcd1=V_YmJ2E%M^{Gn)^Z7qFb%!ErKl<2Xi26C`S>-jf}fc-~1`D51q zk7xgz*8ks*05=ny-J`1Qsp#{<{RIZmGxO-E(@q8v(huC`i~dA^ zPUQ6rn1K!*wE1GDMxw@g20g-Jv{2J*C`RJlTgSsvC7M~)sx2yPVobH4mV#`r(7-*`@M{=CptuG@kaw&&@ zD~+6$pCmO6COpuV?U%Z4wzQuRkY5TI!qQ?FmWf9YklTK?i!oRP)u(^-LKq z`{f?9XM_A}(|b(_FVV{#8y_6tBdFTH66>W}6y_>sK#H4=C-+v^eIDuh+oE^VzMj3g z#t9fv6cs+&p5PjrpK+erxi?1dLd)WaXY&1ns_izZX{yq}HKOrwz|TnZd?=Fe`>RZ$ z2NaGk`Sv?w7db_*_Z1fliNr-)PQS9Z*MJqYo%1?*AJ3vLg`z!hxL8|dG4?))(w(pI zeA8lqx8=-AXpZXUGOt5Pp#z*oU16tQ=cgx4h%1AUoEJ($ zpG0rIvU_XV-ZXifpeYLfb|mn68ovPMV8^!*fd8VJ5R9LIOgrXrMc@)R0G`p1L3{|w zbm6;qTg45t?%uBw@2Wh? zo|_&@Fu`f4K`ha;pMzgi3qr!2UR=&U5bbHwg;I0$S0%f9++5*wmdc(BxjOAp5(H*8 zYtd29uZiAB#-pweWlOs*yeEF^Bzki`*3xm0SX*N)DjW_c*N5Km=P+mw*gKw@V|lo+ zR(Ep4}x|1QuYjz^1ZW6Di^rQdld1o_-L)oueZhJV^V5egmjT;*D5zSxaC z`MsKALl`U}uIQ@ac_s;a7!23{^xV4@4xueb5^{TvNj&X!GBfl&?I~mDFq&u_3zWk( zbqz!B)X??%?BxB;HG&u!ZODBpysyroh}&K3z~hJB&j%rI=p~i=`iH%68_(<>S3Gf< zHQ_fBw~(hK1n-HW=vCOXy~xewVWwt9yAhSoWpEZ#SpZ)QLQ&)_F6+>9U4kmajcnr( zcbA$MYH>=;s-a;!t>ZGI>L{|g+ljA;d3F9f5-kG$amuDec=gE}33>nfSj=)T>Q-I1 zm0x=cI6i!y%d}L%Gzl;QW7DO}ZBtQJ$UJHC5+9XRSF&76|_w@6M3r&5O=ubEGj^ED4R9ZGFX<|RQ=4eN`kI9%6zc(y5$I7=Vr+03zN)lutaysuXIi>|-to4=9(GLm9vBvc* z9kd*YAnb73>+Q4Q^vJt-f{41cbZD6~IH9AAP+Z+0^74A|C;|pog*1Vx^;3onPnX@R z{uJJlJmCf3d~+gTVBAk2zIHdQ4@5LxJ&VJGggMH6mzvksWbXvK5y>nyef3<|KicP* z*HtQJ0xy)9oz1qwVHx{;)A zoKQB7!)kvplmTnyMYHLBxzUk!%-B~>oF@HASsc9{a~HGB(Xk9r+(!X<&(rWrRE|kS zPNp5|M)(^XH}IUd`AX)!2Lus9!T@20z%NVhmhHVr;aPhaF9h+8W>QTziWIJ1cXh@o z+NG2VBY`-e47booQ=^$vYj~eD%n^GIs`MmlE zC)XJQMLlrjgWgCg;t^OJdM5cL7uh%~J$4dW8+1206|A#Pha=Hn!Eb`2ov9k}q|2On z-pXWPB((01+GGIcL6mTpe8w8sBD+Metevax++^Iil`;B82!#}B)g(NEYP@PtapTyX zSW322ni1CTWK=$O8Oc>F5x74Hb3Ql0^L|G6DV%nMg0ryKbX)DivWK?gkmS8JgP(I{ zMhhy>#c}&BdoY%$>C-(AdTqf$RU#L3_P)?m z+@Onsb8bzqA!1ou9XO&fEYLbdlOc}JaimPHF<-Pk$$@x%MxcnvJaO)Z7EX8mOBJU7 zLsJxL!Ogk(bf!C3W*6HqrARFcb?>AzFO_v8XhJ0^M_ZB42Xh@bCNy)3;JJ?>=hoG*{wfLM~uC=^0 za>ZynI2uuuMnqVE)PWIdPjei;-y2aGDRQ3V9t_9v-t(6nAxSP$8u8+|$aGaI2v?m` zOyMbFRP?2LHod<=ibW@2f0^)Dn!r_SKwztogs7K|@~Z&q=bUynt!h@!spUMNB07!~VXp3@(gL0Dh>b6fcQ{pI7&J)ga&wf3{wu+=ROGy5wTnvLSOJ=Js!;gGJ2!smR`^TRz9{)tla zbhCb|IFjbmhtbs2$+2cN?kZKVBX#gwL_vL8>X{<^5OrNQ)hcDm!`AWU%Y$!{T|C0! z_~j#f;GnE6$p;<1`YyYBYeZy(#U#e`9WV6pom19^8W={aS(E*N&DK- zwLM`G->kpB-5!)5%X&M#Y3>`_l%~`4n#f5V)J|olOaEz^pd_qXxYPz6!^pVlapCL+ zCN>gP5t3j!TlGJDHhM2F5>6uIY8wrK7Pf{3y=qzToS1-STrTH^;9Vr4f8c#JOE}9{ zWfuLpvWEI%O2|mWX738OvaEmzx-X|lV+iz=ekg#S^yhWg{iQuS7!C#8u9J3m9j8& zd2IePU#J{W_(q5ufSM#6lUS?yw#mQ5YiFx2a5q8A`f=TFS7$FcEbk35T-;XZc-%-b z+r^%zoCc5jQ!Lw|@X556BWAY80l&uO+wsx`yU))}QnbC#2#4Sdy7+g+-JkZ=2XKvZ zJ=%J|z>7i5#*Bwcr)`okV+yjeu?SpN^#>A*0}EH54-9dLQf)POjJwP31#EuuaI+9 zev_)_x&Ik@yR)8r?zHP>IU%Kdfj>(jNiA8J>i*SotYUE@{26PRmg(_iYS0AnG>&YZ zP1A3+=yx)BVqO4b5I`P{@oCgMY8EdPhr(|eUWc{Ht#B;+1_dyE__Z_AiZ?Lf#lz7& z!6AR=;%#Z6%kgW5R9nL;*}wp0T!E^5X%oXw>J#!Etf3{ID+N^oRDPkP+~$avI`}MT zBe)6qJG0CH*Et?OMp~^M6uP+3MP?HcSpBo7r5JigCQJw*$&l*I0Tv8FABE&6pS$t{ z0$9trpgpnFkg}hXgaCG`MB5cxkCee=I4=C?dOmF8DRr2o?@2kWFle_5;7#ZVA8sxI z^9^BfHfehFJ2|cGdHOcqhZ$=j9G({vGRYV;Q2Se$+$ksT}mekxJOdea?r=ZS!lbS88phLMdKx+ zRxY2ITaQ(w53-tj-4&5CDLhtv^_1NUpAEXc61SXw{&HYci*~#8ephF3Y#(KjviGPL z-__BGky!vCckH=-5oY!JY@?eTNZNIF5oeFN%!W@K0HqPv^o>3X1OUjw<>6pt9TlAJ z;1#anay-Y^*soQ!%@z^>%FaWxXnZp};GfMI14HahzUj^FlpPM#@NW5UJ+-Pw6tn+- zK_V62`d@SX|I5g#|4dE%=hpudsfqu}!$DY{0TSWgHsRkmy#L(#-?M-drby0;+iH@V z+h$e>5ElZD8^ezPTw}+i6ruycPC!1Dk4ZlH$)hK3_Du9ava!!OnbNZf@ag4Qdr$W{ zGU0YhcwNMt&fB$jq#`Nt0i!^4enN%o{(F;9z-g2Gb=6x!MB>HjwbcV86~v^>t^aJQ z#)c{olN6b@QzWqKk@DDxKtV_yGT0i;Zih&dlU7^$(k`y0@Y)1hPR5n;+n+9=rL=d2 zzbAJdU$|#EURw6<_ZAL|;Y>Z&y+WOa=66pmMhU?YwZPD5a({6+vRBK_h*O1Fxouo zJW*F0dc|}#8hW*WI)}9&-6r=GE*j(u9P5B1{3_#S*Y8Gc$!R%`8h%50ONqx~w9R0m zJf1T*fRv(I6bwbi|GO6nhrWKQVK0Gv4hzpQthWiWO2TQVf@#yA(ZT`PoNwA_$Ok*J zBtwY|KzKHos?N?nY5VbY_Pu#2V1Xmf@Rpx*ydQOD0v|TV?TrO#RB))ocR<4x`+qc; z;~kOcj!45zVAZ5l-*pto1N-}?1tfM63sDkk-OI8G??#gl9z9~3m1gEioJI+5c*u3V z!dH7WUAjuLN`%tFDgQ)^!Cq4(y98tH%Y~UBKFiD@tcQjG8 zqbDA&K8CaC0rG6rnFWkz;zU1cTqXpoOoQ*af0HOiu$aO1rKG|6QF5kg!DzJ}ayOc@ zjlU(>-EWPSw#K5Bju?H(oAje=k;8mA?nk2=##9;dTXTgdoKBlZd>BU4wPCp{({|Oftq=Tx@xLYOjldfgUA8D0NrAvZy@8QI}))gKU^s8Vj zV7BSvZ4w!E;app#BHm-osSfAI$Z@h5gn=FW3hNW|4>XG+J6+Z3A14uZFEqeHcAgF> zw`R^TPUAjqto_@7amZc@3un`*pKSiqJ@#>@zGNRbXYX~J&dmaFl1jU_8PR8qB!DL^ z?7KOx5N@hIRuJrb=Pw5Nc+!x zt|KXs!@!(H0aFm73s=hSGIPc0k<1J1oQ6{hyHCy{KihyKl?xc{FlB+6$&1z*0nf=w zQiH`#CO}h|RC^$Yy_;z|m~JQ46@V7YUHjnld4j_l8)}-MOZ7}BvUi-3+(CG#-0z(! zJtL1>9bqY&6{|2#g9hZtex{5TX$2ukKVWtiW@NXQx)sCF5+1*k+~xG27lm1jCdvsP zj!SiZl2tauE2`i|I&3E-)nIVAN(*K`^0YYot!TIsXIr_Gh06&6ayZemO&&o-T9N1- zL6JXdd7$?(NeEW^lTCF4fO&k{4WksMx16r+%})z|!fxp7x!a6%sL=wPrUTQZ&O7I| zHGW-Hb~~TjHse7DN5Z(sKGVTr50nf|NK%=QF*w@-4BuDh`3q`b4*7(SwW=`-)QYej z)&@rMc*MKHNU2QCYYTFbUsGUFE!L_L=}+R6%bsL3H4BTVu-C48g`B&^WVIF9$+x5@ z#vi1rAmSpOM;ly7XXQzSoMctD*Tu12II7F8Whyu_LdDv_(tRgl$QM}zoVQ7;t!Ie3 zA}C6ftl~V(FtI932eGUsYv<#TAH{|)=4D4jke)yM)l~;k{|qAaDWyL?PL!CJ7VP zM+DpWT*U7od~WoXb49PfQ?GT9-^a~Qg!3(;O2TxK`5l~n-^pME^E<5m(>ZD{G49;? zXiezdyVR^b(c?Fgo%0+kyBEuGOwU)izwl9?lzAyI4$w6?V zcwM9RXF=Y|24RQ5XBK>2H$K~Rkp~AlEB>8T6RdOfyEG$olZIN?v&;Y;t^+kp_%p05 z_&7cwvP+g(!-(}f^V^DEC7ZO~0(b-YYgxAtuG`i#a@0Fe2xKIO>7ON>VWnPGVWBn| zOdpv?DE%3@5^UQ97j^r+9W@5B@0`C==7p4*j}S@1=mYjAE#{b#VQwE$QUBFemsXEUC8Ip)i#2ZoF*y>o3sa3&~gO-aK#MUD^K(~?3dS7@v;vIQwCa1~rXSN=yFo2J8#7LTe6A40o zL9&aIrp)WY-09$%C&FWny)KP+j;e>B8V+Yt#)TAl{W&5Js^RNnHqTr^O5qUhy%@bd z+hm$d3D7O5AuovQskv^Bo|T4pBdq%=;u#bv1~w);@SgExP6xaP zvE)2FJpYbZ#RMX}aATVM1IbR6zcaIj8g>MR8!Yz>J&3boeMHxMwWE%+-o){*Q)P{Z zxAEhCiaAAIgB_s3GsU@pO^5qfqk!3;CZ{qGy<(qa~u-?+76r zWwVIo^(APPyHkgv48$9lLqVjXT8Cw0JaSQ=K9%P3Qg8UKbG><{aj;&C)i5|oUwd_e5-uZ{T)`n&Pg8g~*lXIo{ z2z{YOS)UWZL#Ay{0h9jIA6b%ea}SUnZO81_7gde&H=0Qt1~I^!Ke3&U;;>&HM~4ix z|8?4epgK%S#HLLSK;Rc8s{qW0+}r@kGJ|Ac`kyC0@K`-G859}!di0P9U@lbu2RNZS zt$%;C$WcfmYJvcV-VKKs8QOnF_#y|b5Jtku%&Jo_bhPU!syFH+Pv2Sspq=>l z32RUbV<-gpz5nM}Ee|EgCdf=p95)@K{`uK){RbzxeNQGE-!D|+58|*&>m70BKk;z5 z(Jhq2W!I0xY7#Ttg4S?veu1;B8~}#D@v@%F?I5nyb|Hp@VXT$%)Dbbu1qLH&kjaX4t`99qtPQM6{D~^EQ`J^Fb>-1TD!oSvL}V3zfr4Z# z{fqWErjho`GYl+qZoijZdkfi1=eR;HQ!QY+Z+HW^-Mgc@qG&p}s~>OxiUA{AIue6I z(D`2|rRa4P_Td^kI+sa*NVY20u5T}RwxiU5cE(W-m`k|_DUT&gquTN_h9X5PT70%t zcqnw}m<@^QzN01VEUG9v|Ncp4_i=ZUU!c-*qVMldSHL^b?|#nYU2M&AK{Ve?uw+N> zXe0YGMJ5!}zhb9RP2ZC9aXsmIPa@)}V)pAfJJP1!;5-4QTWUEG!r{1X8@_k@*2+@}v(;r6z*71dLS#5Tl{|vyZ+PO28|B#k7xzKm^W@Dn_365VpQ(8DO2v6ja zJHAXT)o;t<0J(@=Ktbkg20oL=`%DSxF3Hc6RTefEga8_Cd(?yU52Qv9k@=8x{lo1m z7h!lbZ8x$cK4FbSpBFe_tFS<>fdNqDFm0KhJGB(-_E4Pz@!#y=CZ!Byf`}wDev47^ zv8eILyLZoUP~i$`*!J{+$VIsMY%ykSH?;>)zdD;R8nEKkN*G)luV;; z1%u=5I)gU9uf?=wksvPUYdehNZ z^+t?UrzVq9cFP5IaD3@kVA|OyzAuI?U69?NgaEi7xG`cXHP{J^d8vBQoqqHAVC{3p zSqgDt`2}vbzkQ7WkHSajxcQURV7Br75ErNCX%AoQGchII0hIJq2(6U#U`G@Ut>JnW z@YL1p$T=+aChE)Wqv6x5?zC{45C5zc%=62#{VW@RVt}4dD8(0b$N@YLA4Zqcp9mTL zVYFx}0944OA$EIhhfr7ME|A`tKGc5(A?n|2{b;CxLl7N3Ee9n6q74f7lU-tjTThh1 z&=Q9UX1jrQAx41uw*>3dN5C4Qp$Hf_v)TH20B7w z;#{U{gO!B#eToJ3TR$er4c9waG+~2PgfJxnR^#goz2?2xCjR?4l&=jmNRuNmKyHB< z%b|_V915AnJfWfBOBet$&B`pIiSE3H9(Pg@7Y!fjZSgfL=&68(n3AH08Y$Z3wEl zHmhbi9f(>_5<%kp-XBMV4>)NkQag73wzE*Lg~oF~R1aP6tWUiIs7}Oz8ttKz7jQ67 zkfmjuo9mMs$>#m=8#Is!7XRY!ilm|v*$-9>ygADt?iffDlmO(2r3J_s0`E~Q04Y|D z_VqzxOCVAqvXIzvsp@*RlGw45s7HBzg0N|N`s6;=Ljq7-MyQka&t0z8WZKL%hrr$8 zsCPR6{!jigcUWAc+cbGh4@Rz`j~f$FNPi9BV^GbUw_xGxs=j&)Bv2H%1ZBLuw-0B|yN#^EN-sna;)`A` z;B)})qOe8kPG%^D-~a}4u`F z(=a&;>;g+2#?ekL>@L5JiGLrPoFqc@`qU2_zqsYveX9gA1kUsiKwJF)QUR$9oU#Uc zC@vl-*+#ZlOq74#ktcu*?@7X1yszv98yp7sYo5V80n}o=co_CN2#bv9{CG!w$BraF zQzEF#)#GsW`$>U&`<1pEj@Q=of(zgi)3X5~P^PeDj~#{`T%20aT!FzThnQ_Tfvevh z5@VCh5b<)JI_v4qw_xiMdq8oNQICKOs!my)Y>e=tZ+|cr5E=3XewyL&c9R zAh+=u6vFJLmdBBm8%c`s8J9VH{Jr^K>UyEO6BfmF^p}goEn&eQz{1@Sr6p=oF{Hb` z5}Ff4T-Gt?$C6xv$~Ps~xZHQ5(_NRj;`&*j9Sjk;CbO5ck*I<8D9u<1uT!^B& z%(|&tTi=#-$vEr3DPW!o5;xcF;8#b|1ARp@cF4k>Ov|F8#YB5E@@ z#x#z8ot9{@x?4ytQ) z$CDNq-rwXuB0SfAe?de7J>xhfmFs-lm%H8y3oBN;;gw5W3`l{{f8i;Bz zfl9!JyZzTydbKRc8qh(i|6)Vi*q%Ns<}mJya}P#^9e@?paVjZkI)0r5WR`85K!jxR z>m-$mrlWFr&};XQb0PV_Rxb`wSTRs8iZ2r(~RiKsfUdq)nN;uR?o&?{?!Pn3;R5I(J>DFQJ&ooCN8MjeYq|z%GR^| zV6&cQkQ60+zi8K+qZA~rvO^A%9F1qITB_aA#BDtyie?94hXXG>PKOhlwSUa+w%qvo z%~g!v5obBOj+Uk@IwsYZ2m6}n(SjPl?zw>RYxD}_Fev~}9>t_%OuEh@&bGDY&YcMy zK}~W{_(b~`V$N+Xjl*WP(a*@$CkAn|7bGe*6l}{Fe-uViqljD@7wDbr z$vn^Ep^LxYZXF0C+;X-}!#;|`KW&jJwO&zI4xjjQd>d$Hl7`JYEgo(=ETz}!rgM7F z`#uO6Wt9zuFY{iC@GDk})Y#1FI<^FuaU87tyh18k!~qHn#T2?juZU`w-smwg0)^Jm z-y|?UI5D-)VT8WP2u2mikz;RSO||PHRn>Oi_`Cp0bIj}gB$)5*`6imHX!1HC0Wavv+CTuv7iz0B@;#B$nq#z}w*y zr?a|9uT25v!zIc1IqcISW1OvdO;uZ8!=EfR?8ObtdwTEvA za6pbtoMrdCnM%adwJndF{l2W*gb>OB$M8a2r>&{v-4j=!toq5HdHAKEm6aDWYDep`;R_tT3U=0ujq&@fchd`=oOYSJ`BtfXW4_ zoQkAeyvt?Uxwmvir^}e$_JWtNT5waugPldam=!g52MZFNF;-DA>4JnU7vXSyZh6z* zK6f{_TbhtEv!TUl3xG!}=lP^o+`0|MgSB$Qp9>`8`|q!bA~t(!Y(%U2suVE!gFU#w zlqxpqyHbqc-3%=rzkjJ`)4Uk)_^C7%BDETp_bqL*M;G0kU4loCmPY4(gkpe{8jRx$ z)sr_eX&IcExkpZbrU*{DQQBpF52kj;v~h9O#oHY1L1|CO=<^!^X0k#6#kgastE#fIMyR3Nh7zfwaUSWWeEcAq9Ps87=!52{OEh z2B^!h#~kh?uOmf+1!4BXWhT;VZcsx|L#`VW0=hel2*I;u<>y@oy<##RKn(LK^6a=q zFaP`+P*x!s!0_`oD*zSriJ561a4r(usIGXZVsza|k=VUm4-*J3i(+DQG>@IV3F(hy zBaY{!1~7^98YKI(2oG_d}-m2aQd8lhT%jYh2NYVeCw(0LoayHok?A^=~3wSKqU z_*?e31{G(Kg&>QPCN>v#VEAsIED;L2<8NF-Q8j9;y||m*PW&N@?#mr-BwzDG7srhv zAM;T`?ev0C@5<|JdUphNd=XdOa9IRG*>T#?7l1p0(1gDYVF(Ooa_TK}Jf>^>B?&8y zR(}oq0ZCwNqVB-n6B`cr=L%HMYcG$}p!*P%6X$;+q#Vc?!3ZJKT6uf$i zW>bEwDd)$3sVyid`0)wB!D|vhXUjIkp5>=VnvK}GF=Pc~!UzgYu4=8PSQfUOb2~Y# zD)A~}4Ek6Ny^~p80)q*_;`(`*a(D4*QV1a>EyZwLkT*3+-WB@&bL3vyBq$|r(LsT1 zYuj(>AZO!I7YoHet4CCX55wUZeusqV^Bk`ylion(r0#?{^_Zc3vF!m>p#Ve1T3tZ} zhSb7AH<`b|w}B`6oOzDTokcaXYJ0-s0dwjPFt8pKyxe7il(FPj7$rTmP(y0nmsEx< zbuno^R_+(e!t{HFTUtOUKTd|%0vR!Su^sTBqZ%hsKZVy6gUZd=-Fn+XP?5z3ahSf0 z=*7e!kt=S@1a1`}1cQi`m2cMz;o)N~ls<6f(sH5m%T8M~EjZ(u*`vqYF$bJqIrvvW zOwT_TnmNlgwWP}=!@N6tkJ^n((97ZcXye`j?sY~nZ*dAXnQi!H%#(_fWQ0869~@PLgo+Y*53puS3*D?x{Gj{-NJc!1~H2ZL2Yu>r1U;rc>POQSvT1#_Sk#B zkq`nhoBV9J*=V7g! z_Hge$rrd2#h;P|*liXJI=7V3*>TmeNW{FoJ24u0R_iChavONlZxojTJ+{2~$*Au(w<>lt{aOqKe4*kr*2b z9z=fRTQNIQeP3esUKG>&*mGkb1^XNTGn}gn9QZ6rPGmWw+G{$X9pAbqRb{Ui;DIjH z8Fn<$8Kxu{O0@8`4rsiWpsz_3hyo_@p?5TrpYRh0;&cRSEPL9R8;Y?`O6niRilmm=6} zyK3#0F#5z4Fz&#s)D`L_PzVpgwTU;kG4d-u=EehDtY~?+rOl5JUR5)MG=c(<=3g@0Yx4HV0n2& z0tTZ(N&F6Knk;H+4A5JN{3-gM6Qc&EK87e+z9@Lwyw`4uVG^;dbCG0(ZVKTreC#A5 zbdOF)t;QEW+ntE3@7qWo0d4k@z`cp9hvg}{W!Erw3xsgAhOCJAXpgCwytc#lD!V{& zD@hnsZPtCOD8?y%7S~EK1l|`l3?Ek;`Ifl$OIS`n_fT{=3$C5kNXl9{hT}Q!e^0gr zxv(@j={F@5&2cKjy>dn2yS zd~NV;e}9MpmA}1O2%S`#cH&F9^z~N3JzpHpkDIkX3!&nnVB&{6Kr@6*`}_>GKz}~N z=lZNxQEYU6^>Nbsim;6?%8qgH)Z=*2#L~%ktg>vB?*KpUFpVo3W^tTWn?+tz6xgQ1_D=q{C!Xe!{y?_T5ukt*I9&{MJ zw4QMw&#YOlaU&ZHMv^U?Xv(r^IG-fA&`{Zrf64@s0%PT+^^u@b7M&$m~?NSJmnL_f3F?Jq@45G21y}B z_rb*Q7)C0dAMmglIRVylZMVV`7pZ3H@kZx*l*H6Ai6QTMm*=;kz!DHc7{+A%rb7}( zOlaR=T(P&4W@2=CUL)(O|GL`v-!Mo2@9;_gPJbb1hZITwrN3UGy!gP425zrmn5NoU z1GVhBw^9zEPy;{_QM5l@*ri0rVe{w4{s%zCF>jp$kxTcIdeQ5V`6*CX@?UHMY}B-i zA^VRek4TNVAj_{iG$`aC?QesE%CNfp{c-F1&bXc3keM2(tTzd?~T?##UX8`-&1&zmomcw_ZEUO&=YmtjgOv_JN^*6cfX7t@aI&3 zA*Tcs5;-UhC40zkjarEhrZ2bmqRlXS`zwIljW?%i^jK*Jb8`+Iga-ZH zS7#5>jnrT-=?4_GGGC0+LBZIGr_>O$Uf=L)h5VywrMo@Yaw8@y&B?Zs>J=tUbT3vL zD>?gG_m>5iDWuOlesAJ$W${4$mY5F39ykU2@LG(r>iWBUl1pTJdY$f)VC3d~SzT+n zgFf4G%59)rtfbFr3Q1Yu^98)|OxdAG)$ThttcPlZy*g%i@27oELJo*wcT#^w$B>nnG zYuDE_T74}wS2=f}%+skrr*_nK-ZQEwNU%RZ~EuA}8ZPoA= zL1EBZHc>CQ->Do5>nt}eK;Grs&#<67@zmKq4aIT@1u_+bg|-J7h0Mf*mK}lLja^pb zu0F*ogpRGcr!F0QE5QQ!aXbrjJqqyu8vEPnVRH;lZ8it#V6~P2qZRD8RMLE&gU-pr ztq!vllFd;RsVgX&_P)51TvLSI9WO zlg!xa2Cs``LZ>77Uk(dyuWTkv2M^~x$#|{Nc;`G#FK<-UXEgLlI5=cI<~_%BT;w!b zuJ_6%?;75x@%g37+v&2>d_h@Ik2A|Y5TDV=&)2x6Ge%Uo;DPX>3mhBXd4J-6XgOI~ zHGcxf_IBC-nrI4>O|;!AItc(N%cC)k(KsJTt?U{49h`M_j+hCfx!=VW?G!H4R2}zt zr)@ocd9|A7rs>dSxz(6;REB?Qb{nNz8kK@kW4q4E>P0`Bk_%n0vfw3ZT5G)peM|{z zvUt1oTWx+kJy+E5m?d0`xD;<*L47gqgRph7;X!OjS3|sa*Ab4zsO3v}M(A-7T;EYV zNb-SXM@~l)uZ;mnQN+WuMWp&1UAf)EIx5Y%SiBn;(eFGI*u6U9$Ah%(gS(^r68fWs z{w#ee=AAb68v|L1=rrOFBqkyRHpc-^cvR}R(Z>i~w`F+o;T0W}(rr2abn(DXF++qU z)%%=(|8h**LAed1TP|eno`lEcer~7H+JFu&76Zi`MB1|8_?pyhWP`%#r`>)!Tm8Du z{z>DWIYca(QPe4NZy|}Lq*25>VxczzcFLNcoy=vberaM|xYmg~wp_J9xj}-T*?ySH zY2+;brHFv=D>C6z3~^F%!#T`0Mepb~tqiu5t}+`MKBZXGE7iC2JdXFuK16Gu^CC5wJLlIIRG}1Gox#dq zVAwl!WX&C}`mR(S+rs-Iru|8T87qL@A}o2KC08>8gHgXT%N088d}liiRIC&&4CbT~ z;$GBm@M+b_AZ=cI?1QKVomFRKBuu7FY^V&ALWn6)Xv@<7`tg-d9H%*Znt)SCV5n)7 zwFHPUA_>v;5-PbFC_7PWucw+J#Wu#G%MtNqcsCQj$x5HZ(zD$1?`)yQSvZ;UE;GMh#s}d6zS&QMSespka?BPUN+G#0V%mjD&b9O0RC}pt_`KT?4QHRCDDmX&mDV3QQy6I?zXxO(g}((Y zaS~LPI4)`qD}bwVF@7GOtvL^(iq~MUmpP6ye&?Sk_H^onUs48OuPoPW)PI~7B9pQ+ zrwQQoKTxLHI95oRpD+sGtOxf|)*^Em1&g9QR$VqqQPzYHdW_yahT>`kL+N$n zP-z&LV-1nS^x~PjYbWLg!bJ2PgLh`Du8khO4MDfNQNFGL!cZ|d)M=k9Ol?QpjKWB8 z{v z@w`}2gl1-8@bk#FwrRO)CUKVY0T#t^QoUoM zy^)rk`Gs38O_?@Z*^s}Y8^r*xnPp{Q?&$~q!k+n`^kp&b&s>K%?G+st!{|oRShJtP z$Oq$`*eu8^;5F$$G!%M_^A!ZwQ=gfKj2497v2E50@lm8r4wQVffvq8N?^; z{iMyN;bE_=l0CBUyQB16W{Nm3HVYn8Ut3H zo)^luNC0tbM2l>RN4qfXtvxonL2SbXErqdI4Yb-=tX`Zl(O zJ_LRx4*T(L!*hM_pqXLdyAxZ}QAj!LE`_SG&}r9~twTJudcHXd@Gk`f+yVcvMJFTm z`YjIDr@^QMqI1U5u39ye_|o2hA~t*fj-MTStAe>kjh*jjPp4Sd(>fc^iW^65)yH|v#p;L~8EjJVhNm_8JVcq;Mx4goH+XSTUZx{5*l zGN_-eex#pz>@TkDdxLvwL>-{ocBWrw1mj-$sB1=6wPWF04W9u@+Hk+aJ{B9elU$P_ zqq*n`9Q8n$1crNOq4qgqIkSunq-2_i3DQ)QXz{rq7pt=aiL8$=id9o4NQJm!!f*sF z9V{DMjq29u=sG-Jl04^sRQ-*vCiKL=C6QfEm0N!?ZCP_EO>pDWNOoTCm0+v_WJq7~ zE(Im~ee2~$1gPv0&e%Ir_M*0c)#ypxT9T62{zyk{CzPhU=-h9=6kgNqYODi;4NtsC z7ka$KNW!X*R_!GSKg+i``wEf8pPJH8-cLIcmJ$`7m2) z6W!=*&xf@{253w`7N7D=x42zFu0-bZ=A7>!W3!0B)^Lu632lGCKW8a7F zc#E8`_W>c_+n=Oo7D^(AYDpf^DHTUPW_9Y!~3*yi`B!8nA$@PWTV z6T**Y1#@AO0VZ0QiEi~xf?MNE7vq7nt3wa?mn%urp_icbJDe7hL>EJOZo%d=m>TC*Ks`yQ} zhr^JhpvCsq9v;n6jHYow?U4+?Za@V5X_O!Gru?w{bL^)WM9dJ)bAA?R&zr&YNbDqq zG>Di0L)LK9rHW(6>I+)AAd0svP+UyMj}uJ6a5RCt0zVs-+S2hLt?Q41n@k1q)8zy> z%LqDKSxiaD)g7@10OL#|aF=G0spL`<;u{2y;2Hc#ul#T%8+id)%4DJ%zMpyZB%2}m zSo)$PRNPRD2UC)ahTGqTDXmbdVfo<(ti4l0j8ef01~Z(OW&S?On|1|0M`AXK%eGrM z7B;88`h#Hbmi~R|C*jf6$w&7ZZKhGi7|ux9jb6w$o*6cm7rHu^OW~Kmyd>}PbM(q* zSqksG6?__sI{JG4%9LKw4*Qqn{zFY0T_(s-$=thfk2580^Mlz!OiN* zGzUh&@dvLiVUObo0}Z@9xgx-0z?kwNzoFg?C1^$WKU(wo80oO4y)&3Q+@a3;bM#O;i{9UH5jjr*6_c{oNJsP#+39Px}z<&jbcAH&cUVfI{bIaKyJ>HuS421CCoJrdfY_I}PM&L`<{QwtCQQ44O!;eY z&!cAnMjvInmR<{u9S$_OMh2rsv|+S+aXoxtGHT0CV!nwZ7T1`vaqmN|!ioUJ2_Y)` ztkPyEPfD71SdIPH5Q)Whgc}oAIxHAuj@_+ljq9}?%vda*%hU{C*AbXUMeUPQ> zOGuVV#=b|^vdg}NB1;BYGDL`?Y-0;!-#w?_ec#Xh`+kr6S?=ff9mn$*2iMG8*EOHd z=lY!I`F_7ni-H{d_|MlVamSioB;G(}t-8aQBHPtgR$*1u@x=<5=esD9^jTe^9L254 z+?3Ptn7hzk-NBW^>hd`$gF)I;(1x^5OO|+80QtQ97q+=_I3Jx{`k)oIboCM?{q))l=j$~ z{YE*@3y~|0d8eor9XpyN)mWFRS!wszj_iYu=7vfHh3!Bl%35Q8b>Y2Um>fGb_6GHN zEv8DSNv~fUncnWpw`k0xQNr{~SdG#kk*BUvbvJU{{OCH?f9_=Pme1Wd?qBWg-D#== z^5$-8hBv6P8`N^NrUUKE=i`=*Vq2OLr>>2C`q<0*$~KBF8)`2q2ggL2JV(hs1K~vA ztY*xPpfajwk-+LwBFi`Tv_YtLVa_wcO;BZ+=H;Xfdtz)9yZx(D#Ghbq{1fy^#Gimi zd3PF6#up#7E+^~!X5Y~pRZbJL${N$yF~HVuXdue;UN?z+xcYv@<$eSH#GB?EXS7>~ zfgOYSb)C`f)Isc6?=g|N2_pkNHzd;Y*kv>}ZTk$zG3h)VK`CjydaWEcuEo2>$$}i@ zmStOr@ofDsj^Se$RT5|4k27m=yLSp~V)w}BtTz^cErs`xPpRen?mZ^F^IEfy zZ{Xsf)iqWSAqeiKV5}z?r%a@{t;R}!FaNmcrKVB9K@w2*i<#bxf-2NiJ8ez%aWKa6 z{>fB%7ETtXOi!aeqvRc&M`IWl!?v?S2j-1gf1Gh3O$iCUaW(cF;(1Bl(i$1X(z&)+ zs$lDYLsws=pp=Gwmme6Z>ymM#7M~g>-QrZEtm1;B6eZd15Y&~1#Z6+)$=q#RQx{~l zRcp+LBuUr9uf9ojJ^RU*>}yhjiGwkrt0c@G`JhgcauAnXrIwuMqu>yRi}*qJoP@nm z2bs7>HCnr%q*Ez3N9CNl{;5ogZOKt;UWux@ZK&+>d8>>sy=QH1|4{z0@2oL=Z2a<{ z{rt7l8^KFl#BmEm&jP5PCg9uTR{0q?mq+_6Zy8DZw4n9L%(}11yiR9dLgF~o(gAR` zvz4}-(kJRW)8IMgMH%CMe=FIEeO}>KiPyZ;WwXxW-sr$hVj%`xme zJy&U+yRFJ+Msm&H&^87PjtK#FkZp;@j zrgL}LK*MTEKTXJ<%aK=dUMuRgktUn!M zc#xc=F;N(fm-h^Ap|XUpQggQ_bDGDH|1SR)LUu{CN~2ElV@)I=xt>j$T}OG{mR9_` z1oJ;~(Eo+l@<{g}{P5Qm@3o<)e_A(#M9OL})hd+h?ko;77qT~_trtwbHyjd;*c1DI z$r&mt*DDzv2;xCzU0DdJcApn^CZBkr@9R`_)+mVxTD%LNP=GQN+8C6qR zeLT!!__db*9n?UGIuqEaWi~-{gZDp=a8sohUIYnX{NpUy2ZOA1I7sTYnD^%igK^K~ zz2W&Kl_Bw+7fcSJ$mushqb!T{yKg|Zh*O$bSe3SZdAxo)Dfw_UnY(#^Q^CX>l}1h} zzlB-@p%J4X{kHQ2*K^3?)5<+Qs9z{A7_Yc?bwCl-<6&b+c3=FAnxBNzuU|(d%i{q$ zw+(=5^a_ANOA&^hyL+^V^7Ll!75bMT%f512izIcp+=}l;u4d}yRr*Y?wd*~{77JL8 zpUMXPQoJ?=B*@>};o`tIiIu)if5G8v!?np$0g*8lXKYmu2nV+ql4(ILXW>jNA$vCj z^I|80jdtJ@AH#m%AMuuXVx{}zvb(T zV!tsV-j-nGq9`lA&%z?gvQyTUroZepSp4%7Bu@~ zqW$Aavh0lnpY%;*9f|lcvGz-96^vugT!xL^r}zZhiluqh9jyFf@fUBVm)v10F8;V; zm?ngLDo}dL;9Po%fwo~$IOg-{qYq)8l3t5oU?|>rlDBB&?sXOfGTyDtc$_J%@-g~% zp@QCeU5}5<+P!M(I^*y0Ci+=>QW3pt!Q5$#IOkEX1T4Y_>E)wcx@{B_^wW8@={F3 z_uh0EcC+NyvPWTKF7lzJ7+&Sh`{U?Ugn5r*I^K@k1{+|J)TJK~7fS;$*@<&g4V*vx z4lRDe-3p$XNa3Wpe}-t?yGxk6b#)11c10G)$n_{O@kx892={sM)|zz#>r}S%i|jEv zQ;lZ)_bRW9-rkUrFQ70^HC)~X!|FKxVSLK|nW;8ijnuf2gP}_V5bOqTwu)vK-8zs( zT$9P{njd6iU5Xb!0z?F5tLf49%Rp)%yU21rc*AAD0N*0r5|tAxbsloTBM+t?mx@k5 zrdqtDr|x7_?I4HlZUpfhU1!_2r)jx;(t~uTPnQUzM*(yCe7v3s+tNqrXYH$U6Jf45 zpe7O`OID{$zXDW3y(jWsE0u4nPIyK`ZQ#SuG!OTuE3>3C#DaBB)(>MnKa*8xYt5F^ zJe}~F{VDK(133(K{*q>|SnsJ{pC_6!h1-#mqm~V`o@Or%rfm# z57Xj)cZuRcw`mq{6=I@(lATUH%Qm4%*j#J_i@aQA{lv!bwmLY4Dp_6HN&XQeDPn(*}Z z*(y(YhQN?ziOl^-klkj%CE$VL1xy6Gh8tuiPu9cBSe#_-SHeU+?gSs7JB0Nyavkef zemug}qOMORBR9?4LpIH+3%*}QSNY31kf$~K?mpCT*to??knz>p27P6KrwN7Zn{?yB zhb$$5+!$*m`SzpA4wT~zGi?s^x>{*6&>OlO8th>PnjDRs-`Ol+WjIE2Y1$^j<}T zMu>~UM_OK%d^SN;3)R!q!`@TIaW-aRmOqBGPzQNj?;wn!qQLh?Zc`|ZhsXXo{WWu& zW!}rFg)W?fA`w@3aG(VN$w>>XxLYUd7UIs;y0nQpJT?ZWso|6G938EUY z-WFJQoE#;-`}tMc9zrieOhS}fjoTe94&Jbc zh1o=qK)@5lMf};3$Z{38*7a0 zT>6gMu#kJm?N;5*f4k4Bz4Smc|r>#z(1m+I$rm^fUq;u#w=gJ{U(+#*IQ5 zyCR`}ak!G^>In7if)7gI?8;o8l(L@Jq($f`ga3}z^qx`vtY$et0G&xX@&tZHPX>cn zitE7oMU$dp>L>817o0=X99A@#uQfkvPjM}dB)oQIm2$b$8`n4DP%G4mr?CjyP3vBp zPF@PxjFwA73@lP1lv&)3w7=8zqK2~Sfz=n+MbU0z-5O?~SYZh{Vm|qHvHUY&5DPi( zuYCpI)QFGgBiu4e2~k8HdY)b6`=f)~ydD;UZ(6>;6zQaQ7iD&p8?Y9@-8JF-3X9O~ zE1@S5f#%J`@s;Kzr|qGj861GQ<_k*zH*Fm$eLrvx4wNge6gbaW=u8*>dM&q{0yM?6 zO3dr}8ciu&o;>pD<(pM$3%N}#bb8BQZW&tQ6pt^p%~%;lOI zQ?GoL5RS8&%7z^*>DcRb`%&Oq{Z^4*{H%T$gtHwY`IFD$0PsxLIfnfZD+b6$t7f@a~pk;H5>Q}s7wucQr2ioUWW}M zPgGv6dGm`y?gjDpszmp5-&6Z$E?^{v1zPLHgX28~JSA4{pT2N)x%gK$ax$6@A=`}7 zUr<3b6~0~A_SEdxf@dWqJ)%j%lR{C9#eO}dMA2gPSmN-@tBkp^jRhM17ZSu>Tmf=EoGeoyeKasF&J zJ%!P3@NR8A63H}dcE`jkU75}&s8`S`F45|`;7Q?4x36ecCh>@vx0QaxeGx- zr3jULl><~vqzg`Y47vE5R+Vk;j}gnOxo83ff?H}jktU<&t%~}xoc)PsDGq$L zo}@hFOV|T0_U?VZpRX%97xUMcisg$iUAeO1o5u2Jc6a^`Cq!Psq1G{(X zN?(4cef3(@L`2sd@WuXc=zQXV@vmcMqF`oymE=Okdw$s4G4PG)y_c9q|1|G8gI<{% zX~arl&+m1pe6>%*G)ju@aQgs5B#3@|+*ft#!37_xGoIi6QA2B^@3-x{->+{4dN66m*omm0z+mj3B{HbrA#51Jc@85BQv-1f&+r_aO0pNimD#X zbsWcmGn=~jMx-bnH@jTX(BwZJ-_c!sN$krz5z60NP(avhvrFRC&Ka>3IVYiox>GFe zZ9>aBsd39e*4k@5m|dg#d>HlidCu*-Tp@SUdmCJ)=3*-Der_<^IF-S9suqN^W>;|X zyHE9V3g76Wt`yl-KMyN6znW7z-ZH+&|K9$v1fKOof_^453v$E(0T#=7 z^(&&6J?EUfkQj>{WdHEyFUeYidmngXn+{bzso^j51eieC#+f9^*gjhORA$SI3&^|& z9UUKYMK@+WRc?M^EQA~->Rc|=~< zCCHwwolcOwO<@8#zv?zJQ`avVC%hQdHL#^GJ4$XY65|-{pBkLl*hND@Am_;qpqe@d+NAqyi)R|nAyTL z_*O%^GNgREjogeH=p9Lpv$#G1`890^S=a+nofaZ$)uz(Y3pyW~n`N%!G5QzELLQ^n zqSf;skRgvx=)YgaJw}&vWQwLynv+l*g236tOnn}STwXD9X`j+v#piRAFl^p@f7$1I zOXN)9Y?v)uSA#N^Aba!Xr04x0%W#`Z%lfzOOZ#k~8(jl0tGY0M1!%5+Z?nJ7T{_-o z;(*6V<(#5aD|JMbsg|uOqqM5m(Uk(SG7nKN>qsjNyEV45a+WEUPHl70-yXR5`)3AA z&mxtvy0zvCJKQQFLgOl0iMk@4hx<6Y?a2B$L@-&~b7eYJI(*P_EI>szLU*3p&3Si5rZ&NMp2b9VZkWur@jpct5oqX|%s3pisRyz%Ns zr-sB&1Wn@u>gTXx+`G=*YD1mbbTjPLSuYN87iwUq{@jc~5Tzo%Z-l*cS`xX}75bP% z`leZ@n$sM(?)L|yK^B8ZW5o%p>VzuR;6Dd`HctxR7&ZZQxd;bI4?dyw%#Wm&^J4wS*K+?p<5qi&kEk~gev7!C!xxwwVe~Q;{JGl7j&W*EB)Oxq1y_p z8*ygBA{6!__BC!Iwrw*6_V2MDetqxvz@13r+dlP!+zJ~Ti+}Z7a+qC8<=w}V>&-Js z;@3v*zZG@AD!0Pirxf!z!#FGOs}YbM78@kxTskjImMYRE2Gpya3OJxE%)T&)1%4`es0+xFFH5w$^(>*00~ft{z!NaB%}lNK@M z3IRo{i2F=Wll74-)K>opF}F6;D+)L{DSneWesxd@0sf(OeD%I!+s6E$f_kd7+>y*s zaSUE190p}&ext3!ky;uvzRsP1iQCA~4!R7?!Lbu4b*F2`u6^fJyhEa>?xFreI~Gg3 z?kJc@&V#{(oZeG;7-GjY;>7!)(!S?%MUQP+yLu=!A`t6+u(>IT@A^pn^?WIdgShFEzPGSfPH<b#q8jpO(Vfx~KVl$KA%7dkCstiT75Dkgz8GRAvTUi_VXt=8PI`z{C4 zqyaKN+xur3T+q^Uc@`@VbPqogq?EF-yCHov-?R*{yYiD!H~JiEpDe%knD?+b;9sh- zaPZXvA^vAShaWX%`_w3sxO)1Yak}|cyh0pa`p2WOjJ*c(^YTebkq2(hjeL^$lv7@f zGCMQ!x~vK_uLaMIqx+FujpOM7JP zdq7Od-(AA;%q~}x^c(%_Na?wmD-Q-1Ds6hp$9GfY9{VbKu9XPCZYvrW`ncAymlDK! z?;c?k@cWiv`TWHz@PBS9RyxYTol zvh&#>EO2R&tU&y@#Nv!9k&RN=TQ1)l8bBh?Hn;tvf3~|txV=(M=uWN8(a!AdC}F{s z2q4D^C&*b@&)VP}IxL=T)!+4$IK?Ktky zRHEc!O#mBsj%?KTk{xU9HGQ=R25sp~VlLa4Fl0Q$)+xeVlxEJSGgc;qZ*?cR>q$?= z^;I(>gnL?hU(hG=v4uoB&Ym}sv=2ofp6$)_;wLjH0^268s4`n&0^VI7YPAi<1O$?w z&t3efU@+xA&KphN1;D#IvW#V$qxP;nSnZIGRf=&ucZ$=vxH2jwW^4RB{?7C6=Itw* z-*{}&C#E2!Cy@4GXcSmk$6+MBqrYQuIr7@OC%gNh^9m>;tWO}9Mv{XVQhxOn`KpDm z_3NGawtRm9MbvZU5|fV)x(YD<7$TdWJ2WltSdjekhuchcUFR`34uwCP`t1v}Y_cko zjz5A9DKs87XsfOzOeU4HTb9cV?Nd(HNdHSl`AFndRHNWULB6nKVkes=`~B9x4dPw* zormgo8sBGQFae^PhS;(11dL5uq<>f16H~js`%B}O639{|Q=R|3GtC?SFz?W@v=8Z} zB6_R>Sr{l|b@#fbYyd(&Ew|58HA)*xz3M&9Q>xz@kVnWJ4EQc;n=}nbWv5 z_tZ_k2tU2Rh15**F$sT1ZWoGS5H0SEMNVL@fsnwbFLDsmCcpc=;DMO?TuTcFLijvK zMrPHCvMO%m>0Ei_Tf1Gaz2tE`!I2hm0ofQGEVrr3BEy;}Si9irb%9lQJgi6wWpn~@ zt*6LvQ#u#}$O29_` zxIVcyn|>bN*ldt$l|iufp|?rf>y-&oR?l0kL*vQoFxI(DTP;A4SRgzE{cOI=Fe3;J z!U4k5DhsuawTy=^^g}aN@)NG}KuYY3m}Wcn-kA|b1fh2P>tKyYCd3@NzI4hg=tU*< zVpuu$LlWM!&bLOV)FfrCtWMm~>YC4!L*5T2qe9&B?N&I9k@Z(3qg{N+0O?u|D#F$l zAr?mK?$V)xm%JiH4K#z$sQoj*Lz$PpXBp`R7U(4>6e7 zs!&weZAPWVKUlGRyi&c+x9|qy7?nb3<}u+Qv>^xbpgZmo9zVt;vB0Y?65gI_o$9XX zE327#=WMQarV@TI{mN|JIA@Q3BJazp2>c)&LYVU6fhH(O?Fz#YvAPxrUh-Q382=cW zu`0*Q$1Dz zje_n~+C)Pmh_`!>(Ds;Dq76}Fjz${{Z>Z<_?)awa7xL02g!Ek~n^sH_!StOXI0_g= zd=N<2DvV-CNNAm>l~4EdBQOe|=kzt%|BCxwvGfHOiDQot!7hb=4hhVH5hnSEIsmaG zF`iqBwq|AtX`o4;Z6bYC(eM=G|CJ`ebjh#W>>2 zJa4Z%ei4q+O7V0!sA41bEo9S{%s{B!)ARK$6k#Y(Zruy*h-_&$sE;-s#r5)+IV9V7|5k>6;lR1Uq&kGWR1%!p5Yqz(4zor#8Z`3X0bI^3t( zgreYUj}6mz&Bw=Rf0x2t^m$o!^X}fF{VNJaTrghGFP-3NpD=tJd7SY%#Ozan31EZJ zvGNZu5F0n4ah>L0)?lPUT>X;}*s9AcOnKpDa71?T1nu<{9Ob(r%TpJS{^Le3YUDN{ zL7T`e-^z)VltxGl48LsNCPE(fa1M0cx+V+15m6zC{4vYyME~=5A|ezC{OKP*E+C1B z5XXoxWdHHwD(XKD{Oj>Y2g1w#^Z26!;bs4M{Lwr9~;Wup8J}uHutSS z4-5;A(vYf!UBt7_(Z&Gc+d$a(D%{2#3tXFMuqz~ZjMz&Yra!|F$%lX)ZDQ7+`0ULa zFDO)izN8M?!J9|;0dH_T_wB6D_qB#I^+98a+c$;|pczY+-~PO*ZS#vWv(Usw8GQH& zUvF#4#Y1);J-SiVAY zka$Qezlt0h3OZW)p>!y2JJ+9Y3&62$r+WL{Dv41~4!Pwsn&IFMd3RJg%zg(`j7okQ)5~D|G0y^*c!5<_Y+#a_38d zRk_O#vm08Tr~=ByvEc;bn2c$m5@4me)__7eLT1c0(kaxiV8R4X5WEa*C07LM?5EuC zS%ATO@!%B9fW>e0YA^YPc@t*8F&bx~8id(!yU3D3HhJ1_2yn6x~Zy1za47 zeE5<#Y~c+QfI*kyyVcCb7{Jt61y&_DFvAX&z@6AX@)!3dJJ#EhI9xC+MB6^S2=85e zn?XGH3K1L8!%bZV=n0?~UU$aE5RB+^eYuhQOem86B4|<|Q)Ez)V|lU>dNJ{VX7YUq zz-n^9ohSI@&jZuWP~PuV^~TVFX~PlDpc*U+c`-?pM|Sxqp-b+YKOfEG>|jC?EFtt=LrM7FQICv0+H#^c&x-nH%BGd!K; zK0h#pw;w8HKir1PQ1gT7SrHDl6T*H=Q8hU(^ic2{5Lou@?MAAKo-o7JrUL#f9-_vo zHa0(5t&?ZKL{_v?!L~o6Y&%qHZriZG(djC;0VQXjD;6-?bkWF@hoJKj1`eg5Fl8Zj=$^jY9eC9KOe40qA)77n`aLIk(nEc6$0Q6bOIQA>h)27vs zhVSfj_kO|*6=2QAoJfKB5XUHH7w0zsO9cOc3~RFd6Yusfy%-LG#W@&`bNz6(+IL~M zYr!9(tIs(P59IEID;rB=3JM-Q*GRLE0Q}ot@Cn_@XUAb{FOv&Eom?fCv<-mxTwQGd=29+vGVNeL#&MevbRj4H$WG}$#h(zaHbLp_@zg|*c zM>(~W1b9*gfXaAX z+p^RI@WBq$sJ?OHL>6NqNWk=61Op$=PyS$Qq7TSat7`xy8d$C!+b_3;GGta>Kcb996)cwQ9jr6x|?(s#QgIQ0YGw?Ocy z!`=97n7&`ej_ou0QZ@Tf9IxQDcahI9{?fO%JWN6mfRkJHnZ2*>6eh-gI)Pt_wkt`j zK$2agxCc}LrUwRvz&1nV3LkZKg!W-=d!C@$2noGuuZ6;H#FzMF(_bR&!OD86!Iwm_ zFpDAg%s{cRp-#F*UE8ONCI0X+&cn93@eAdH-&%Gk!Rm;k;VdZOWgyp3yh=-#VF#mx zP^sJ%kKvQFGvr1aB9YU^*rkWiH%}OiKDGEsmkq(2?M72Eo?YefnJK(N_4rm{(_<+Bos;0CLoYGOSY^OH_C`)3G>wp7QDf}BZUx~hy$HEY= z!tOwIz3$#e=(J@S-$#d_huW@PM7-zz{^pp1X_5BG%81P4P(|#**wH7o`0uWC3Q6Q8 zYqeN@9s|x9oA*)}%lGj$m6Q&iLK}mSk#l-R=7%Sb2Fuy~wx{Y{@xUw|t-f>Er) z_h_ZmGWw*in&3SwKTH>ESwsnst2tf%KYPHfq7Ur!sRcm90uIj5x8;*MBuhk2ClKfo zDvtmR8`dx-4#(+6V2_^DTccjx5_kg8+o#TxQ|`}-Z|iML0O3?;nC z(D>O*a81A2r-K+b0_H~!th@}_YI|3dy3B3AW(7Yv`p1B6ctP<8-m&8&caug!h3XR> z)g1ibk$RE4{x?XPKB>OESkt1N0ZFh?-_!8?)dNWOS6Ke-`vu?FgED6pCWA+;09@4$ zC?C=(Q%5`w==8oA!K3H+QE(jz0Ld)a#xS)!a=EIWEdJ$f9NZXLE&IK#HU;sdrL5cZ zumj2Apn|{p{DG!PwzFTexeNy;fa6t?O`|EWfSpBsLl2T% zpw}6)_L}4)@->Slz3*ufeL$At?TED2m%!{CTGmM;ssk z6ScIC`ar6c)UBvO+X&rz^*&zpZ@zA!z>|NXD diff --git a/crates/client-ffi/src/views.rs b/crates/client-ffi/src/views.rs index 842043cc..37ef5754 100644 --- a/crates/client-ffi/src/views.rs +++ b/crates/client-ffi/src/views.rs @@ -640,6 +640,10 @@ pub struct UniffiMachineSummary { /// Whether the bridge advertised a certificate pin (without one no /// `wss://` endpoint is dialled). pub direct_pinned: bool, + /// The SHA-256 of the certificate the bridge's `wss://` listener serves + /// (lowercase hex), as its signed heartbeat pins it: what a browser + /// opening the web page must be shown, checked before a sign-in. + pub direct_cert_sha256: Option, /// The direct endpoints the user added, tried after the advertised ones. pub direct_endpoints: Vec, /// The endpoint the direct link is up on; `None` means the relays. @@ -1164,6 +1168,7 @@ pub fn build_uniffi_machines_view(v: &MachinesView) -> UniffiMachinesView { accounts: m.accounts.iter().map(|(agent, a)| to_uniffi_agent_accounts(agent, a)).collect(), direct_advertised: m.direct.as_ref().map(|d| d.endpoints.clone()).unwrap_or_default(), direct_pinned: m.direct.as_ref().is_some_and(|d| d.cert_sha256.is_some()), + direct_cert_sha256: m.direct.as_ref().and_then(|d| d.cert_sha256.clone()), direct_endpoints: m.direct_endpoints.clone(), direct_up: v.direct_up.get(&m.pubkey_hex).cloned(), npub: protocol::crypto::npub_from_hex(&m.pubkey_hex).unwrap_or_else(|_| m.pubkey_hex.clone()), From ed5538d1d88804aadcc1257c1d26409ff0a0f529 Mon Sep 17 00:00:00 2001 From: deymosh <232244450+deymosh@users.noreply.github.com> Date: Tue, 17 Nov 2026 19:46:12 +0100 Subject: [PATCH 6/6] docs: the web page as a client docs/WEB-CLIENT.md is the design of the web page as a client: why the browser speaks the protocol's own JSON over TLS rather than Nostr, the threat model, the sign-in with a key of the browser's own bound before the phone approves, the stream and its signed input, what a browser may send, the lifetimes (7 idle days, 30 in all), why the page renders the wire itself rather than client-core in wasm, the cost, and the tests (with the tool that holds a bridge for a real browser). BRIDGE.md's web page section describes the page as it is now (sessions driven from the browser, the HTTPS routes a cookie still reaches, the stream caps); PROTOCOL.md gains the browser's stream and the new meaning of a browser's id and expiresMs; CLIENT.md the phone's certificate check; the README its line. CLAUDE.md: the signing rule names the browser as the one other signer, and the e2e runs include the web page's. Co-Authored-By: Claude Code --- .claude/CLAUDE.md | 12 ++- README.md | 6 +- docs/BRIDGE.md | 67 +++++++------ docs/CLIENT.md | 7 ++ docs/PROTOCOL.md | 31 ++++-- docs/WEB-CLIENT.md | 231 +++++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 312 insertions(+), 42 deletions(-) create mode 100644 docs/WEB-CLIENT.md diff --git a/.claude/CLAUDE.md b/.claude/CLAUDE.md index 8b1016fb..ac647775 100644 --- a/.claude/CLAUDE.md +++ b/.claude/CLAUDE.md @@ -45,7 +45,10 @@ the upstream did not design for: bridge output coalescing, GSD. OpenCode is the default agent. - **Every phone event is signed by the identity key** (commands, grants, NIP-42 AUTH, Blossom auth). Session keys only key NIP-44 payloads; they - never sign. + never sign. The one other signer is a browser on the web page: its + commands are signed by a key of its own, which an identity-signed + `web-sign-in` let in, and it may send only what + `bridge_core::browser_may_send` names (`docs/WEB-CLIENT.md`). - **No migrations.** A breaking change to persisted or wire data is reshaped directly, old data skipped tolerantly on load, and the PR says so. @@ -111,7 +114,8 @@ crates kept apart). ./codedeck typecheck # typecheck / clippy only ./codedeck test # tests only ./codedeck e2e # the ignored tests that drive a built agent host - # from Rust: driver protocol, bridge end to end + # from Rust: driver protocol, bridge end to end, + # a browser on the web page ./codedeck ci [PR] # the pull request's checks, and the end of the log # of each failed one (--watch waits for them) @@ -150,8 +154,8 @@ Narrower loops run in the dev container, which keeps its node_modules and the caches between commands: `./codedeck dev cargo test -p `, `./codedeck dev vitest run ` (the agent host's own tests). Tests marked `#[ignore]` need Node and a built agent host; `./codedeck e2e` builds the -bundle and runs the two CI runs (the driver-protocol spawn test and the -bridge end-to-end test). Before a release, the acceptance test runs the real +bundle and runs the two CI runs (the driver-protocol spawn test, and the +bridge end-to-end tests: a phone, and a browser on the web page). Before a release, the acceptance test runs the real phone core against a throwaway bridge with the real OpenCode (MCP changes across restarts, a free model's session resumed across a restart): `./codedeck dev sh -c 'CODEDECK_AGENT_CACHE=/agents cargo test -p bridge-runtime --test acceptance -- --ignored --test-threads 1'`. diff --git a/README.md b/README.md index 5590468a..174ef492 100644 --- a/README.md +++ b/README.md @@ -54,8 +54,9 @@ Pairing is a one-time QR scan; it survives restarts on both ends. - NIP-42 `AUTH` relays, and Tor on both ends (see below) - A direct link on your LAN or VPN: the phone talks to the bridge over its own WebSocket, with the relays as the fallback -- A web page on the same port: the bridge's dashboard in a browser, signed in - from a paired phone instead of a password +- A web page on the same port: drive the sessions from a browser, signed in + from a paired phone instead of a password, every command signed by a key + the browser cannot hand out ([`docs/BRIDGE.md`](docs/BRIDGE.md#web-page)) ## About this fork @@ -249,6 +250,7 @@ the full runbook. - [`docs/DEEPSEEK.md`](docs/DEEPSEEK.md) — the DeepSeek Harness: API key, models and reasoning, gateways, MCP servers and plugins - [`docs/QWEN.md`](docs/QWEN.md) — Qwen Code: install, OpenAI-compatible providers, its home, modes, MCP servers and extensions - [`docs/PI.md`](docs/PI.md) — Pi: install, accounts and providers, its home, the permission gate and its tiers, MCP servers and packages +- [`docs/WEB-CLIENT.md`](docs/WEB-CLIENT.md) — the bridge's web page as a client: the browser's signing key, its stream, what it may send, the threat model - [`docs/AGENT-CANDIDATES.md`](docs/AGENT-CANDIDATES.md) — which agents to add next and how - [`.claude/skills/cut-release/SKILL.md`](.claude/skills/cut-release/SKILL.md) — the release runbook diff --git a/docs/BRIDGE.md b/docs/BRIDGE.md index 832a8521..d41f6dd7 100644 --- a/docs/BRIDGE.md +++ b/docs/BRIDGE.md @@ -268,43 +268,50 @@ phone, in the machine's settings. To turn the link off, remove `direct` from With the direct link listening on `wss://`, the same port serves a web page for a browser: open `https://

    :7447/` (the bridge logs it at start, -`[Web] The bridge's web page: …`). The browser gets the same self-signed -certificate as the phone, so it shows a certificate warning; compare the -SHA-256 it shows with the one `[Direct] Listening on …` logs before -accepting it. Plain `http://` on the port redirects to -`https://`; the onion listener serves no page. +`[Web] The bridge's web page: …`). From it a browser drives the bridge's +sessions as the phone does — the list, a transcript with live text, input, +permission, question and plan cards, Stop, the mode, a new session — and +sees the bridge, its agents, usage, the signed-in browsers, the paired phones +and the settings. The browser gets the same self-signed certificate as the +phone, so it shows a certificate warning: the phone shows the fingerprint to +compare it with while it signs the browser in (and `[Direct] Listening on …` +logs it). Plain `http://` on the port redirects to `https://`; the onion +listener serves no page. A browser signs in with a paired phone: the page shows a code and a QR, and -on the phone the machine's page, "Browsers", scans or types it (the same -page lists the signed-in browsers and signs one out). The -browser then stays signed in for 30 days (a cookie only the bridge can read, -sent only over HTTPS), and it survives a restart: signed-in browsers are kept -in `/web-sessions.json`, keyed by the cookie's SHA-256 so the file -holds no token a copy could be replayed from. Signing out, or revoking one -from the page, ends it; a pending sign-in is never written. Until signed in -it sees only the sign-in page. The page shows what the heartbeat carries — -the bridge, the direct link, the agents and their credential status, the -sessions — and never a secret. - -Signed in, the page also has a few JSON APIs: `GET /api/browsers` lists the -signed-in browsers (each with its id, approver, sign-in and last-seen times, -expiry, address and User-Agent, and which is the caller) and -`POST /api/browsers/sign-out` ends one — the same list a paired phone reads -with `web-browsers-request` and ends one of with `web-browser-sign-out`, both -served from one place so the two paths never disagree; `GET /api/devices` -shows the paired identities and their clients (labels and key expiries, never -a key); -`GET /api/config` shows the config as it is in effect (and each field whether -a flag or environment variable overrides the file) and `POST /api/config` +on the phone the machine's page, "Browsers", scans or types it, shows the +certificate fingerprint to check, and sends it (the same page lists the +signed-in browsers and signs one out). When it starts, the browser makes a +signing key of its own that its page can use but never read, and sends the +public half with the request; every command it sends afterwards, over one +WebSocket, is signed with it, so the cookie the bridge also sets (readable +only by the bridge, sent only over HTTPS) is worth nothing to whoever copies +it. A browser stays signed in while it is used: 7 days without signing +anything, or 30 days after its sign-in, end it. Signed-in browsers survive a +restart: they are kept in `/web-sessions.json` with their public key, +keyed by the cookie's SHA-256, so the file holds no token a copy could be +replayed from. Signing out, revoking one from the page or the phone, or +unpairing the phone that let it in, ends it at once. A pending sign-in is +never written. [`WEB-CLIENT.md`](WEB-CLIENT.md) is the whole design: the +threat model, the stream, what a browser may send. + +Over plain HTTPS the page answers only its own files, the sign-in (`GET +/api/me`, `POST /api/sign-in`, the QR) and `POST /api/sign-out`; everything +else goes through the signed stream (`/api/stream`). There the config editor changes the safe set — the machine name, the relays, the direct endpoints and the transcript retention — validating each and rewriting `config.json` -keeping every other key. +keeping every other key, and the paired phones are shown with their labels +and key expiries, never a key. What the page shows is what the bridge sends +a phone, which by protocol never holds a secret. Because a LAN or VPN is not a trusted place, the page refuses a `Host` that is not an IP address, `localhost` or a host the direct endpoints name, -requires an `Origin` equal to its own on every `POST`, forbids framing, -caching and any script or connection not its own, rate-limits sign-in starts -to 10 a minute per address, and caps pending codes and signed-in browsers. +requires an `Origin` equal to its own on every `POST` and on its stream, +forbids framing, caching and any script or connection not its own, +rate-limits sign-in starts to 10 a minute per address, and caps pending +codes, signed-in browsers and open streams (4 per browser, 16 in all). A +browser that stops reading its stream is closed rather than waited on, so the +page never slows a phone's link. ## Terminal diff --git a/docs/CLIENT.md b/docs/CLIENT.md index fe79908e..c4396732 100644 --- a/docs/CLIENT.md +++ b/docs/CLIENT.md @@ -433,6 +433,13 @@ the UI view's `webBrowsers` (by machine). Ending one dispatches `SignOutWebBrowser`, which drops the row at once and lets the bridge's fresh list — the same message a request is answered with — confirm it. +A scanned or typed code is not sent at once: "Check the page" shows the +certificate fingerprint the machine's heartbeat pins (the summary's +`directCertSha256`, written as browsers' certificate viewers write it) beside +the code, and only "They match: sign in" sends it. The browser's warning is +the one place a page served by someone else shows itself +([`WEB-CLIENT.md`](WEB-CLIENT.md#sign-in)). + ## Conventions - A UniFFI error variant must not have a field named `message` (it collides diff --git a/docs/PROTOCOL.md b/docs/PROTOCOL.md index 3bd0ba26..45841ac1 100644 --- a/docs/PROTOCOL.md +++ b/docs/PROTOCOL.md @@ -806,12 +806,14 @@ the page's own `GET /api/browsers` and `POST /api/browsers/sign-out` do: never on a timer: the list changes only when a browser signs in or out, so nothing else would make it stale. - `web-browsers {browsers}` to the asking client. Each entry is `{id, by, - sinceMs, lastSeenMs, expiresMs, peer, agent}`: `id` is the page's short - public id — the first 16 hex characters of the stored key's SHA-256, never - the key and never the session token — `by` is the npub that signed it in, - the three times are ms since the Unix epoch, `peer` the address it came - from and `agent` its `User-Agent` (cleaned and bounded). Oldest signed in - first; empty when the bridge runs no web page. + sinceMs, lastSeenMs, expiresMs, peer, agent}`: `id` is the browser's short + public id — the first 16 hex characters of the SHA-256 of its signing key, + never the session token — `by` is the npub that signed it in, the three + times are ms since the Unix epoch (`expiresMs` the moment it lapses: the + sooner of 30 days after its sign-in and 7 days after it last signed + anything), `peer` the address it came from and `agent` its `User-Agent` + (cleaned and bounded). Oldest signed in first; empty when the bridge runs + no web page. - `web-browser-sign-out {id}` (phone → bridge). Ends the browser whose page id is `id`; any paired client may end any of the owner's browsers. Answered with `web-browsers`, the fresh list — a sign-out is confirmed by the list it @@ -822,6 +824,23 @@ Cost: two small command-class events per sign-in, one request and one response per screen opening, and the same again per sign-out; nothing while the screen is closed. +### The browser's stream + +A signed-in browser drives sessions over a wire of its own, not Nostr: the +page is reached only over TLS on the direct listener, so the browser sends +the same `PhoneToBridge` messages as JSON and gets the same `BridgeToPhone` +ones, unencrypted, on one WebSocket (`/api/stream`). Each frame it sends is +signed by a WebCrypto P-256 key the browser made at sign-in, whose public +half `POST /api/sign-in` bound to the code before the phone approved it. +`crates/protocol/src/web.rs` is the spec (frames, the signed input, the key +and signature checks), its frames are in the corpus (`webFrames`), and +[`WEB-CLIENT.md`](WEB-CLIENT.md) is the design: the threat model, what a +browser may send (`bridge_core::browser_may_send`), the lifetimes. + +Cost: none on the relays and none for a phone. A browser's copies are neither +encrypted nor signed, live text goes only to the session on its screen, and a +browser that stops reading is closed, never waited on. + ### Version and capabilities Every message, both ways, carries `v`: its sender's protocol version (12), diff --git a/docs/WEB-CLIENT.md b/docs/WEB-CLIENT.md new file mode 100644 index 00000000..91493bdd --- /dev/null +++ b/docs/WEB-CLIENT.md @@ -0,0 +1,231 @@ +# The web client + +The bridge's web page is a client: a browser drives the bridge's sessions +from it, as the phone does. This page is its design: why it is built the way +it is, what it defends against, and what a browser may do. +[`BRIDGE.md`](BRIDGE.md#web-page) has how to open it; +`crates/protocol/src/web.rs` is the spec of its stream. + +## In one paragraph + +A browser makes a key of its own when it signs in: a WebCrypto ECDSA P-256 +key whose private half the page can use but never read. It sends the public +half with its sign-in request, so the code the phone approves names exactly +one key. After that, every frame the browser sends, on one WebSocket stream, +carries a signature by that key. The 30-day cookie stays, but by itself it +opens nothing beyond the sign-in state. A browser that has signed nothing for +7 days is signed out. While the phone approves, it shows the SHA-256 +fingerprint of the bridge's certificate, so the user can check the +browser's certificate warning against it. + +## Why not Nostr in the browser + +The page is served only on the direct link's `wss://` listener, so a browser +reaches the bridge over TLS and never through a relay. The phone's commands +are Nostr events with NIP-44 payloads because the same events also travel +through relays, and one format means one ingest path. A browser has no +relays, and TLS already encrypts its one hop once the certificate checks +out. So the browser sends the protocol's own JSON messages (`PhoneToBridge` +up, `BridgeToPhone` down) as they are, with no event wrapper and no +encryption of its own. + +TLS does not tell the bridge **who** sent a command. A phone command is +signed by the identity key; a cookie is a bearer token, and whoever holds a +copy holds the browser. Prompting an agent is running commands on the +machine, so the browser signs with a key of its own. + +## Threat model + +What is at stake: commands to agents (code execution on the machine) and +transcripts (code, tool output). + +| Threat | What stops it | +| --- | --- | +| Someone on the LAN or VPN | TLS, the `Host` allowlist, the `Origin` check, and the sign-in itself (only a paired phone approves a code) | +| A copied cookie (profile backup, proxy log, devtools export) | Every frame on the stream needs a signature by the browser's key, which cannot be exported. The cookie alone reads only `/api/me` and cannot keep the session alive. | +| Script injected into the page | The strict CSP (no inline script, nothing from another origin, no `eval`): the key can be *used* by any script on the page, so keeping foreign script out is what protects it. Transcripts are rendered as text only (below). | +| An active MITM whose certificate the user accepts | The fingerprint on the phone. A MITM serves its own page and its own key, and the code it shows is bound to that key; only the user comparing the browser's certificate with the phone's pin catches it. | +| A forgotten signed-in browser | The 7-day idle limit, the 30-day limit, and sign-out from the phone or another browser | +| A browser approved by an identity that is later unpaired | Unpairing ends that identity's browsers | +| A pending sign-in code read off the screen | It is useless without a paired phone, works once, for 5 minutes | + +Out of reach by design: malware running as the user inside that browser +profile (it can drive the page, and so the key); a user who approves a code +they did not start themselves. + +**Transcripts are attacker-controlled text.** An agent's output can contain +anything a tool read, such as a fetched web page. The page builds every +transcript element from text nodes and never assigns `innerHTML`; its light +markdown (fences, paragraphs, inline code, bold) is built as elements. The +CSP is the second line of defence, never the first. + +## Sign-in + +1. **The key.** On "Show a sign-in code" the page makes a fresh pair with + `crypto.subtle.generateKey({name: "ECDSA", namedCurve: "P-256"}, false, + ["sign", "verify"])` and stores the `CryptoKey` objects in IndexedDB, + where they stay non-extractable. P-256 rather than Ed25519, because every + browser has had it for years. A page whose certificate the user accepted + is a secure context (its scheme is `https`), so WebCrypto works there — + checked in Chrome over a LAN address. +2. **Start.** `POST /api/sign-in {key}`: the public key's raw uncompressed + point (65 bytes, base64url). The bridge refuses a point off the curve. + The browser's **id** is the first 16 hex characters of the point's + SHA-256: what `web-browsers` lists and `web-browser-sign-out` names. The + key is bound to the pending sign-in **here, before any phone sees the + code**, so the code an identity approves names exactly one key. The answer + is the code, its lifetime, and the `__Host-` cookie. +3. **The page** shows the code and its QR, and tells the user that the phone + will show the certificate fingerprint to compare. It never shows a + fingerprint itself: a MITM's page would show whatever matches. +4. **The phone** (Browsers) scans the QR or takes the typed code, then shows + "Check the page": the certificate fingerprint it pins from the heartbeat + (`direct.certSha256`), written as browsers' certificate viewers write it + (uppercase pairs, colon-separated, eight to a line), and the code. Only + "They match: sign in" sends `web-sign-in {code}`. The wire is the one it + was: the identity's signature covers the code, and the code names one key. +5. **The bridge** matches the code and signs the browser in with that key. + The page, polling `/api/me`, sees `signed-in` with its own `id` and the + machine's npub — and opens the stream only if the key it holds has that + id (site data cleared means a new sign-in). + +The key lives as long as the sign-in: signing out, a revocation or a lapse +deletes it, and the next sign-in makes a fresh one, so a revoked key is +never used again. + +## The stream + +`GET /api/stream` with `Upgrade: websocket`; every other upgrade on the port +is a phone's direct link. The upgrade is refused unless the `Host` is +allowed, the `Origin` is the page's own (browsers send cookies on +cross-site WebSocket handshakes, and `SameSite` alone is not relied on), and +the cookie names a signed-in browser — a check that costs one hash, before +any signature work. + +Frames are JSON arrays, one per text message, like the direct link's: + +``` +bridge ["CHALLENGE", c] 32 random bytes, base64url, new per connection +browser ["HELLO", sig] within 10 s; signs seq 0 with an empty body +bridge ["READY"] | ["CLOSED", reason] bad-signature | expired | signed-out | busy | bad-frame +browser ["CMD", seq, body, sig] body: one PhoneToBridge, as JSON text +bridge ["OK", seq, accepted, message] per CMD +bridge ["MSG", message] one BridgeToPhone, as a JSON object +browser ["PAGE", seq, body, sig] a page request, as JSON text +bridge ["REPLY", seq, {status, body}] its answer +``` + +**The signed input** is the UTF-8 of +`codedeck-web-v1\n\n\n\n\n` +with `seq` in decimal; `sig` is WebCrypto's ECDSA signature over it with +SHA-256 (64 bytes, `r‖s`, base64url). It is over the exact text sent, so +neither side canonicalizes JSON, and binding the machine, the browser and the +connection's challenge makes a signature good once, on one connection to one +bridge. `seq` grows on every signed frame (gaps allowed); a frame that does +not verify, or whose `seq` does not grow, closes the stream. Several tabs are +several connections, each with its own challenge. + +**Page requests** are what only the page asks: `{type: "devices"}`, +`{type: "config"}` and `{type: "config-set", set}`. The heartbeat +(`sessions`) arrives as a `MSG`, and the browser list through the phone's own +`web-browsers-request` and `web-browser-sign-out`. Over plain HTTPS a cookie +reaches only the page's files, `GET /api/me`, `POST /api/sign-in`, the QR and +`POST /api/sign-out` (ending its own sign-in, which a cookie may always do). + +**No automatic resend.** A `CMD` whose `OK` never came before the connection +dropped is reported as "may not have arrived" and not sent again: a browser's +command has no event id for the engine to drop a duplicate by, and the +transcript shows whether an input landed. + +## The browser in the engine + +A browser is a principal of `bridge-core`: **a client of the identity that +let it in**, addressed as `Addressee::browser(identity, id)`. The runtime +verifies each frame and hands the engine `Input::WebCommand`; the engine +runs it as that identity's, with the reply going to the browser alone. Its +copies are neither encrypted nor signed: the runtime writes them down its +streams. It has presence and watch state like a phone's client, so it gets +live text only for the session on screen; it is present while a stream is +open. Unpairing an identity ends the browsers it let in. + +**What a browser may send** (`bridge_core::browser_may_send`, which names +every command so a new one is decided rather than let through): `input`, the +three card responses, `set-option`, `sync-request`/`sync-ack`, +`create-session`, `refresh-sessions`, `close-session`, `interrupt`, +`stop-task`, `create-folder`, `presence`, the read-only requests (usage, +models, agent style, commands, personas, plugins, MCP, session MCP, +permission rules, accounts, provider profiles), `web-browsers-request` and +`web-browser-sign-out`. Refused, with `OK false`: + +- `session-key`, `pair-request` and `web-sign-in` belong to an identity: a + browser never lets in another browser. +- `set-credentials`, `set-provider-profile` and `account-action` move + secrets and sign-ins. +- `terminal-*`: the terminal allowlist names devices, and a browser is none. +- `upload-file`, and the agent-configuration writes: `plugin-action`, + `mcp-action`, `agent-action`, `session-mcp-toggle`, + `permission-rules-remove`. + +These can be opened one at a time later, each with its own reasoning. + +## Lifetimes + +- **30 days** from sign-in at most (the cookie's `Max-Age` is set at the + start; the bridge's record, which decides, counts from the approval). +- **7 idle days:** only a verified signature (`HELLO`, `CMD`, `PAGE`) moves + `lastSeenMs` — a request carrying the cookie does not, so a copied cookie + cannot keep a session alive. It is written to disk at most once a minute, + so the limit holds to a minute and survives a restart. An open tab renews + its presence every 5 minutes, which keeps it signed in while open. +- `expiresMs` in `web-browsers` is when it actually lapses: + `min(sinceMs + 30 d, lastSeenMs + 7 d)`. +- A lapse, sign-out or revocation closes the browser's streams at once with + `["CLOSED", reason]`; the page returns to sign-in and deletes its key. + +## Rendering + +The page renders the protocol's messages itself, in plain JavaScript with no +build step, about 60 KB in all. Reusing the phone's core instead +(`crates/client-core` in wasm) was considered: it is pure, but it and +`crates/protocol` depend on `nostr`, which pulls `secp256k1-sys`, a C +library — a wasm build needs the Nostr parts behind a feature or a C +compiler for wasm, a wasm build in every release, and `'wasm-unsafe-eval'` +in the CSP. The browser needs none of the Nostr parts, and a renderer of the +wire's entry types is small, so the page keeps its own; the corpora and +`PROTOCOL.md` are what it follows. + +## Cost + +- No relay traffic, no NIP-44 and no event signing for a browser's copies: a + copy for a browser costs the bridge less than one for a phone. +- Live text only for the session on screen, nothing for a closed tab. +- **The phones' links never wait for a browser.** A stream goes through the + direct link's lane: queued, never waited on, and a browser that stops + reading is closed (`busy`) and reconnects with a sync. Caps: 4 streams per + browser, 16 in all, 64 signed-in browsers. An open stream does not count + against its host's direct-link connections (8 per address, or per /64 on + IPv6, where a whole LAN shares one), so tabs never lock a phone out. +- One ECDSA P-256 verify per browser frame, at human rates. + +## Tests + +- `crates/protocol/src/web.rs`: the frames, and the key and signature checks + against a vector made by WebCrypto. +- `crates/bridge-core/tests/web_client.rs`: the engine's side — copies, + replies, live text, the allowlist, unpairing. +- `crates/bridge-runtime/src/web.rs`, `web_stream.rs`: the page and the + stream over a real WebSocket — the cookie alone, the limits on an injected + clock, the gate, a replayed `seq`, another key, another connection's + challenge. +- `crates/bridge-runtime/tests/web_page.rs` (ignored; `./codedeck e2e` and + CI run it): the real runtime and agent host, a paired phone core, and a + browser over pinned TLS, from sign-in to a session answered and the phone's + sign-out closing the stream. Its `hold_a_bridge_for_a_real_browser` holds + such a bridge for a real browser: with `CODEDECK_WEB_HOLD=` (and + `CODEDECK_WEB_HOLD_PORT`, `CODEDECK_WEB_HOLD_SECS`) the phone approves + every code written to ``, so headless Chrome — or a person — can + drive the page. + +Later, optionally: signing as the real identity through a NIP-07 browser +extension, for users who have one; a real certificate through Tailscale, +which removes the warning.