From 7e61d16f0ca6aeca6adb1dd909a7e7b0376719f9 Mon Sep 17 00:00:00 2001 From: Christophe Besson Date: Sat, 17 Oct 2026 10:11:07 +0200 Subject: fix(spa): follow the device to another network Moving between mobile data and the node's Wi-Fi left the connection on the network it had left until ICE gave up, and a group that had failed was never tried again: the Android application had to be killed. A change of network or an ICE disconnection now pings the session and reconnects one that does not answer, wakes a reconnect backing off, and retries a group page left on an error. Co-Authored-By: Claude Opus 5.5 --- .../tests/harness/network_change_harness.mjs | 267 +++++++++++++++++++++ 1 file changed, 267 insertions(+) create mode 100644 packages/meshbay-hub/tests/harness/network_change_harness.mjs (limited to 'packages/meshbay-hub/tests/harness') diff --git a/packages/meshbay-hub/tests/harness/network_change_harness.mjs b/packages/meshbay-hub/tests/harness/network_change_harness.mjs new file mode 100644 index 00000000..e0201125 --- /dev/null +++ b/packages/meshbay-hub/tests/harness/network_change_harness.mjs @@ -0,0 +1,267 @@ +// Run the SHIPPED transport through a change of network, and see whether the +// connection follows. +// +// A phone moving between mobile data and the Wi-Fi the node is on keeps a +// connection whose candidate pair runs over the network it left. Reported on +// the Android application: the group stopped answering and the application had +// to be killed. transport.js is executed whole; what is modelled is the +// environment: a clock, the window's events, `navigator.connection`, a peer +// connection that opens its channel after the answer, a hub that answers the +// offer and the token (or does not, while the device is offline), and a node +// that answers the handshake and pings until it is cut off. +// +// Usage: node network_change_harness.mjs +// {"scenario": "change-dead" | "change-alive" | "backoff" | "ice-dead" | "ice-alive" +// | "events" | "closed"} +import { readFileSync } from 'fs'; +import { delimiter } from 'path'; + +const transportSrc = process.argv[2].split(delimiter) + .map((p) => readFileSync(p, 'utf8')).join('\n'); +const { scenario } = JSON.parse(process.argv[3] || '{}'); + +for (const level of ['log', 'warn', 'error', 'info', 'debug']) { + console[level] = (...args) => process.stderr.write(args.join(' ') + '\n'); +} +process.on('unhandledRejection', () => {}); + +// ── The clock ──────────────────────────────────────────────────────────────── + +let now = 0; +let nextId = 1; +let timers = []; +globalThis.setTimeout = (fn, ms) => { + const t = { at: now + (ms || 0), fn, id: nextId++ }; + timers.push(t); + return t.id; +}; +globalThis.setInterval = (fn, ms) => { + const t = { at: now + ms, fn, id: nextId++, every: ms }; + timers.push(t); + return t.id; +}; +globalThis.clearTimeout = (id) => { timers = timers.filter((t) => t.id !== id); }; +globalThis.clearInterval = globalThis.clearTimeout; +Date.now = () => now; +globalThis.performance = { now: () => now }; +const flush = async () => { for (let i = 0; i < 50; i++) await Promise.resolve(); }; +async function run(until) { + await flush(); + while (timers.length) { + const due = timers.reduce((a, b) => (b.at < a.at ? b : a)); + if (due.at > until) break; + if (due.every) due.at += due.every; + else timers = timers.filter((t) => t !== due); + now = Math.max(now, due.every ? due.at - due.every : due.at); + due.fn(); + await flush(); + } + now = until; +} + +// ── The page around the transport ──────────────────────────────────────────── + +function eventTarget(obj) { + const listeners = new Map(); + obj.addEventListener = (type, fn) => { + if (!listeners.has(type)) listeners.set(type, new Set()); + listeners.get(type).add(fn); + }; + obj.removeEventListener = (type, fn) => { listeners.get(type)?.delete(fn); }; + obj.dispatch = (type) => { for (const fn of [...(listeners.get(type) || [])]) fn({ type }); }; + obj.listening = () => [...listeners.values()].reduce((n, s) => n + s.size, 0); + return obj; +} + +globalThis.window = globalThis; +eventTarget(globalThis); +const connection = eventTarget({ type: 'cellular', effectiveType: '4g' }); +Object.defineProperty(globalThis, 'navigator', + { value: { userAgent: 'harness', connection }, configurable: true }); +globalThis.location = { hash: '' }; +globalThis.document = { + addEventListener() {}, removeEventListener() {}, visibilityState: 'visible', +}; +globalThis.localStorage = { getItem: () => null, setItem() {}, removeItem() {} }; + +const b64 = (u8) => Buffer.from(u8).toString('base64'); +window.MeshBayCrypto = { + b64encode: (u8) => b64(u8), + b64decode: (s) => new Uint8Array(Buffer.from(String(s), 'base64')), + verifyNodeSignature: async () => true, + challengeTranscript: () => new Uint8Array(1), + webrtcBinding: () => new Uint8Array(1), + handshakeProof: async () => new Uint8Array([7]), + handshakeTranscript: () => new Uint8Array(1), + constantTimeEqual: () => true, + openGroup: async () => window.__codec.msgpack_encode({ chat_epoch: 1 }), +}; + +const SDP = 'v=0\r\na=fingerprint:sha-256 AA:BB\r\n'; +let offline = false; +globalThis.fetch = async (url) => { + if (offline) throw new TypeError('Failed to fetch'); + return { + ok: true, status: 200, headers: { get: () => null }, + json: async () => (url.endsWith('/mnp-token') ? { mnp_token: 't' } : { sdp: SDP }), + }; +}; + +// ── The node ───────────────────────────────────────────────────────────────── + +let pings = 0; +const pcs = []; + +class NodeSession { + constructor(channel) { this.channel = channel; this.cut = false; } + reply(obj, ms) { + setTimeout(() => { + if (this.cut || this.channel.readyState !== 'open') return; + const body = window.__codec.msgpack_encode(obj); + const frame = new Uint8Array(4 + body.byteLength); + new DataView(frame.buffer).setUint32(0, body.byteLength, false); + frame.set(body, 4); + this.channel.onmessage({ data: frame.buffer }); + }, ms); + } + receive(frame) { + if (this.cut) return; + const msg = window.__codec.msgpack_decode(frame.slice(4)); + const req_id = msg.req_id; + switch (msg.type) { + case 'handshake': + return this.reply({ type: 'handshake_challenge', v: '99.0', v_min: '0.0', + nonce: b64(new Uint8Array(32)), node_pk: 'pk', sig: 's', req_id }, 50); + case 'handshake_response': + return this.reply({ type: 'handshake_ack', proof: 'AA==', node_pk: 'pk', sig: 's', + nonce: 'n', ct: 'c', req_id }, 50); + case 'device_hello': + return this.reply({ type: 'device_hello_ack', req_id }, 50); + case 'ping': + pings += 1; + return this.reply({ type: 'pong', token: msg.token, req_id }, 30); + default: + return undefined; + } + } +} + +class FakeChannel { + constructor() { this.readyState = 'connecting'; this.binaryType = 'arraybuffer'; } + send(frame) { + if (this.readyState !== 'open') throw new Error('InvalidStateError'); + this.session.receive(frame); + } + close() { + if (this.readyState === 'closed') return; + this.readyState = 'closed'; + if (this.onclose) this.onclose({}); + } +} + +class FakePC { + constructor() { + this.connectionState = 'new'; + this.iceConnectionState = 'new'; + this.iceGatheringState = 'complete'; + pcs.push(this); + } + createDataChannel() { this.channel = new FakeChannel(); return this.channel; } + async createOffer() { return { type: 'offer', sdp: SDP }; } + async setLocalDescription(d) { this.localDescription = d; } + async getStats() { return new Map(); } + async setRemoteDescription() { + setTimeout(() => { + if (this.connectionState === 'closed') return; + this.channel.session = new NodeSession(this.channel); + this.channel.readyState = 'open'; + this.connectionState = 'connected'; + this.iceConnectionState = 'connected'; + if (this.channel.onopen) this.channel.onopen(); + }, 100); + } + close() { + this.connectionState = 'closed'; + if (this.channel) this.channel.close(); + } +} +globalThis.RTCPeerConnection = FakePC; + +// ── The shipped transport ──────────────────────────────────────────────────── + +new Function(`${transportSrc}\nwindow.__codec = { msgpack_encode, msgpack_decode };`)(); +const Transport = window.MeshBayTransport; +// What the transport's own module listens to, before any connection exists. +const moduleListeners = window.listening() + connection.listening(); +const out = {}; + +if (scenario === 'events') { + // The helper alone: which events count as another network, and how many. + let calls = 0; + const off = Transport.onNetworkChange(() => { calls += 1; }); + const at = []; + const step = async (fire) => { fire(); await run(now + 5000); at.push(calls); }; + await step(() => connection.dispatch('change')); // a bandwidth estimate + await step(() => { connection.type = 'wifi'; connection.dispatch('change'); }); + await step(() => window.dispatch('online')); + await step(() => window.dispatch('meshbay-default-network')); + await step(() => { // one change, three events + connection.type = 'cellular'; connection.dispatch('change'); + window.dispatch('online'); + window.dispatch('meshbay-default-network'); + }); + off(); + await step(() => window.dispatch('online')); + out.calls = at; + out.leftListening = window.listening() + connection.listening() - moduleListeners; +} else { + const main = new Transport('https://hub.invalid', 'token'); + let reconnectedAt = null; + main.addReconnectListener(() => { if (reconnectedAt === null) reconnectedAt = now; }); + let connected = false; + const identity = { pkEdB64: 'ed', signAs: async () => 'sig', native: false }; + main.connect('node', 'token', 'group', new Uint8Array(32), identity, null, 'u', 'uid', + undefined, undefined, '', 'pk') + .then(() => { connected = true; }, (err) => { out.connectError = err.message; }); + await run(5000); + out.connected = connected; + + const first = pcs[0]; + if (scenario === 'change-dead' || scenario === 'change-alive') { + // Mobile data to Wi-Fi. The pair in use ran over mobile data; when it is + // gone, the node hears nothing more on it. + if (scenario === 'change-dead') first.channel.session.cut = true; + connection.type = 'wifi'; + connection.dispatch('change'); + await run(25000); + } else if (scenario === 'ice-dead' || scenario === 'ice-alive') { + if (scenario === 'ice-dead') first.channel.session.cut = true; + first.iceConnectionState = 'disconnected'; + first.oniceconnectionstatechange(); + await run(25000); + } else if (scenario === 'backoff') { + // The connection fails while the device has no network, and every attempt + // fails with it until the backoff has grown long. Then Wi-Fi comes back. + offline = true; + first.channel.session.cut = true; + first.connectionState = 'failed'; + first.onconnectionstatechange(); + await run(40000); + offline = false; + connection.type = 'wifi'; + connection.dispatch('change'); + out.backAt = now; + await run(80000); + } else if (scenario === 'closed') { + main.close(); + connection.type = 'wifi'; + connection.dispatch('change'); + await run(25000); + out.leftListening = window.listening() + connection.listening() - moduleListeners; + } + out.reconnectedAt = reconnectedAt; + out.connections = pcs.length; + out.pings = pings; +} + +process.stdout.write(JSON.stringify(out)); -- cgit v1.2.3