@openchamber/web 1.14.1 → 1.15.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (87) hide show
  1. package/bin/cli.test.js +8 -0
  2. package/bin/lib/DOCUMENTATION.md +3 -0
  3. package/bin/lib/cli-args.js +10 -0
  4. package/bin/lib/commands-connect-url.js +169 -22
  5. package/dist/assets/{DiagramView-Cb58svCq.js → DiagramView-HR2xZxJ8.js} +1 -1
  6. package/dist/assets/MarkdownRendererImpl-sm01Q7R7.js +11 -0
  7. package/dist/assets/{MultiRunWindow-BPSxV_B7.js → MultiRunWindow-DlFUaNQK.js} +1 -1
  8. package/dist/assets/OnboardingScreen-DVRz82mJ.js +1 -0
  9. package/dist/assets/{SessionSwitcherDropdown-4FWg9xMC.js → SessionSwitcherDropdown-DvoOalMY.js} +1 -1
  10. package/dist/assets/SettingsWindow-CkInZcj7.js +1 -0
  11. package/dist/assets/{TerminalView-fTYjnQkh.js → TerminalView-D_9BAjtv.js} +3 -3
  12. package/dist/assets/es-cjUissX4.js +15 -0
  13. package/dist/assets/fr-DqbXnTdK.js +13 -0
  14. package/dist/assets/index-Dg0nmvQU.css +1 -0
  15. package/dist/assets/index-ltrmNGAf.js +2 -0
  16. package/dist/assets/ja-Cetyq6Eg.js +15 -0
  17. package/dist/assets/ko-DtunWisP.js +15 -0
  18. package/dist/assets/main-BC0m8s1v.js +236 -0
  19. package/dist/assets/main-DzNa8r0N.js +2 -0
  20. package/dist/assets/miniChat-BRYDE-Se.js +2 -0
  21. package/dist/assets/mobile-C3QJVA97.js +2 -0
  22. package/dist/assets/pl-DctGLgve.js +15 -0
  23. package/dist/assets/pt-BR-CXPhf78S.js +15 -0
  24. package/dist/assets/renderElectronMiniChatApp-CVFbDC5A.js +2 -0
  25. package/dist/assets/renderMobileApp-wkBjh5WR.js +16 -0
  26. package/dist/assets/runtimeEndpointReset-C42u8PvG.js +167 -0
  27. package/dist/assets/uk-Bdrc-kqF.js +15 -0
  28. package/dist/assets/{useAppFontEffects-BUUJYbAZ.js → useAppFontEffects-DzBg8hrC.js} +123 -119
  29. package/dist/assets/{vendor-.bun-C6iL44L9.js → vendor-.bun-BE757pvp.js} +1 -1
  30. package/dist/assets/zh-CN-CeCVKrHP.js +15 -0
  31. package/dist/assets/zh-TW-CoqiQING.js +15 -0
  32. package/dist/index.html +4 -4
  33. package/dist/mini-chat.html +4 -4
  34. package/dist/mobile.html +4 -4
  35. package/package.json +2 -2
  36. package/server/index.js +130 -1
  37. package/server/lib/client-auth/pairing.js +308 -0
  38. package/server/lib/client-auth/pairing.test.js +142 -0
  39. package/server/lib/client-auth/remote-clients.js +65 -3
  40. package/server/lib/notifications/apns-runtime.js +9 -16
  41. package/server/lib/opencode/bootstrap-runtime.js +10 -0
  42. package/server/lib/opencode/core-routes.js +246 -6
  43. package/server/lib/opencode/core-routes.test.js +248 -9
  44. package/server/lib/opencode/network-runtime.js +14 -1
  45. package/server/lib/opencode/network-runtime.test.js +29 -9
  46. package/server/lib/opencode/proxy.js +47 -6
  47. package/server/lib/opencode/settings-helpers.js +3 -0
  48. package/server/lib/opencode/settings-helpers.test.js +11 -0
  49. package/server/lib/opencode/settings-normalization-runtime.js +2 -0
  50. package/server/lib/package-manager.js +18 -5
  51. package/server/lib/relay/DOCUMENTATION.md +78 -0
  52. package/server/lib/relay/cross-compat.test.js +135 -0
  53. package/server/lib/relay/e2ee.js +341 -0
  54. package/server/lib/relay/e2ee.test.js +124 -0
  55. package/server/lib/relay/host-client.js +389 -0
  56. package/server/lib/relay/host-client.test.js +280 -0
  57. package/server/lib/relay/identity.js +73 -0
  58. package/server/lib/relay/identity.test.js +78 -0
  59. package/server/lib/relay/service.js +247 -0
  60. package/server/lib/relay/signing-key.js +50 -0
  61. package/server/lib/relay/tunnel-codec.js +373 -0
  62. package/server/lib/relay/tunnel-codec.test.js +58 -0
  63. package/server/lib/relay/tunnel-host.js +462 -0
  64. package/server/lib/ui-auth/DOCUMENTATION.md +6 -0
  65. package/server/lib/ui-auth/ui-auth.js +10 -0
  66. package/server/opencode-proxy.test.js +38 -0
  67. package/dist/assets/MarkdownRendererImpl-D2yCDL5A.js +0 -7
  68. package/dist/assets/OnboardingScreen-Sl-6JgaP.js +0 -1
  69. package/dist/assets/SettingsWindow-CY8q4msv.js +0 -1
  70. package/dist/assets/es-bWcuDy_2.js +0 -15
  71. package/dist/assets/fr-DzRs3OzV.js +0 -13
  72. package/dist/assets/index-KnWk9fmM.css +0 -1
  73. package/dist/assets/index-ZJTzZ0_U.js +0 -2
  74. package/dist/assets/ja-BqUX_UD3.js +0 -15
  75. package/dist/assets/ko-BQo10SNx.js +0 -15
  76. package/dist/assets/main-BDoqLlQB.js +0 -236
  77. package/dist/assets/main-DUGyTrDt.js +0 -2
  78. package/dist/assets/miniChat-DNDiX8GA.js +0 -2
  79. package/dist/assets/mobile-DnghtOCb.js +0 -2
  80. package/dist/assets/pl-Bgx_ATJT.js +0 -15
  81. package/dist/assets/pt-BR-B1yXRvoX.js +0 -15
  82. package/dist/assets/renderElectronMiniChatApp-BB4C1K7t.js +0 -2
  83. package/dist/assets/renderMobileApp-CZgaXKi5.js +0 -16
  84. package/dist/assets/runtimeEndpointReset-By39StyB.js +0 -167
  85. package/dist/assets/uk-C9k8SP8q.js +0 -15
  86. package/dist/assets/zh-CN-Bri-Vo5y.js +0 -15
  87. package/dist/assets/zh-TW-DAUGzmYG.js +0 -15
@@ -0,0 +1,280 @@
1
+ // Integration test: fake relay (minimal Layer 1) + real host-client + a scripted
2
+ // client using the JS e2ee initiator. Verifies the full handshake and a tunneled
3
+ // HTTP GET /health, and asserts only binary frames cross the relay post-handshake.
4
+
5
+ import { afterAll, beforeAll, describe, expect, it } from 'bun:test';
6
+ import http from 'node:http';
7
+ import crypto from 'node:crypto';
8
+ import { WebSocket, WebSocketServer } from 'ws';
9
+
10
+ import { startRelayHost } from './host-client.js';
11
+ import {
12
+ bytesToBase64Url,
13
+ createFrameDecryptor,
14
+ createFrameEncryptor,
15
+ deriveSessionKeys,
16
+ exportPublicKeyJwk,
17
+ generateEcdhKeyPair,
18
+ generateHandshakeNonce,
19
+ importEcdhPrivateKey,
20
+ RELAY_PROTOCOL_VERSION,
21
+ } from './e2ee.js';
22
+ import {
23
+ TunnelFrameType,
24
+ decodeTunnelFrame,
25
+ encodeJsonPayload,
26
+ encodeTunnelFrame,
27
+ } from './tunnel-codec.js';
28
+
29
+ // ---------------------------------------------------------------------------
30
+ // Fake relay: routes host-control <-> host-data <-> client by (serverId, connectionId).
31
+ // Forwards frames verbatim, never inspects them.
32
+ // ---------------------------------------------------------------------------
33
+ const startFakeRelay = () => {
34
+ const server = http.createServer();
35
+ const wss = new WebSocketServer({ server });
36
+ const state = {
37
+ control: null,
38
+ hostData: new Map(), // connectionId -> ws
39
+ clients: new Map(), // connectionId -> ws
40
+ buffered: new Map(), // connectionId -> [[data, isBinary]] awaiting host-data
41
+ relayFrames: [], // observed forwarded frames (for plaintext assertions)
42
+ };
43
+
44
+ wss.on('connection', (ws, req) => {
45
+ const url = new URL(req.url, 'http://localhost');
46
+ const role = url.searchParams.get('role');
47
+ const connectionId = url.searchParams.get('connectionId');
48
+
49
+ if (role === 'host-control') {
50
+ state.control = ws;
51
+ // Announce any already-waiting clients.
52
+ ws.send(JSON.stringify({ type: 'sync', connectionIds: [...state.clients.keys()] }));
53
+ for (const id of state.clients.keys()) {
54
+ ws.send(JSON.stringify({ type: 'connected', connectionId: id }));
55
+ }
56
+ return;
57
+ }
58
+
59
+ if (role === 'host-data') {
60
+ state.hostData.set(connectionId, ws);
61
+ // Flush any client frames that arrived before this socket attached.
62
+ const buffered = state.buffered.get(connectionId) || [];
63
+ state.buffered.delete(connectionId);
64
+ for (const [data, isBinary] of buffered) ws.send(data, { binary: isBinary });
65
+ ws.on('message', (data, isBinary) => {
66
+ state.relayFrames.push({ from: 'host', isBinary });
67
+ const client = state.clients.get(connectionId);
68
+ if (client && client.readyState === WebSocket.OPEN) client.send(data, { binary: isBinary });
69
+ });
70
+ ws.on('close', () => state.hostData.delete(connectionId));
71
+ return;
72
+ }
73
+
74
+ if (role === 'client') {
75
+ state.clients.set(connectionId, ws);
76
+ ws.on('message', (data, isBinary) => {
77
+ state.relayFrames.push({ from: 'client', isBinary });
78
+ const host = state.hostData.get(connectionId);
79
+ if (host && host.readyState === WebSocket.OPEN) {
80
+ host.send(data, { binary: isBinary });
81
+ } else {
82
+ const queue = state.buffered.get(connectionId) || [];
83
+ queue.push([data, isBinary]);
84
+ state.buffered.set(connectionId, queue);
85
+ }
86
+ });
87
+ ws.on('close', () => state.clients.delete(connectionId));
88
+ if (state.control && state.control.readyState === WebSocket.OPEN) {
89
+ state.control.send(JSON.stringify({ type: 'connected', connectionId }));
90
+ }
91
+ }
92
+ });
93
+
94
+ return new Promise((resolve) => {
95
+ server.listen(0, '127.0.0.1', () => {
96
+ const port = server.address().port;
97
+ resolve({
98
+ wsUrl: `ws://127.0.0.1:${port}`,
99
+ state,
100
+ stop: () => new Promise((r) => {
101
+ wss.close();
102
+ server.close(() => r());
103
+ }),
104
+ });
105
+ });
106
+ });
107
+ };
108
+
109
+ // A stub loopback origin serving /health.
110
+ const startLoopbackOrigin = () =>
111
+ new Promise((resolve) => {
112
+ const server = http.createServer((req, res) => {
113
+ if (req.url === '/health') {
114
+ res.writeHead(200, { 'content-type': 'application/json' });
115
+ res.end(JSON.stringify({ ok: true, service: 'stub', relayConn: req.headers['x-openchamber-relay-connection'] || null }));
116
+ return;
117
+ }
118
+ res.writeHead(404);
119
+ res.end();
120
+ });
121
+ server.listen(0, '127.0.0.1', () => resolve({ port: server.address().port, stop: () => new Promise((r) => server.close(() => r())) }));
122
+ });
123
+
124
+ // Build the host identity around a fresh keypair (ECDH enc key + ECDSA sign key).
125
+ const buildIdentity = async () => {
126
+ const enc = await generateEcdhKeyPair();
127
+ const encPrivJwk = await globalThis.crypto.subtle.exportKey('jwk', enc.privateKey);
128
+ const { privateKey: signPriv, publicKey: signPub } = crypto.generateKeyPairSync('ec', { namedCurve: 'P-256' });
129
+ const signPubJwk = signPub.export({ format: 'jwk' });
130
+ const canonical = JSON.stringify({ crv: signPubJwk.crv, kty: signPubJwk.kty, x: signPubJwk.x, y: signPubJwk.y });
131
+ const serverId = crypto.createHash('sha256').update(canonical).digest('base64url');
132
+ return {
133
+ serverId,
134
+ hostEncPubJwk: await exportPublicKeyJwk(enc.publicKey),
135
+ hostEncPrivateKey: await importEcdhPrivateKey(encPrivJwk),
136
+ signRelayAuth: (role, connectionId) => {
137
+ const ts = Date.now();
138
+ const sig = crypto
139
+ .sign('SHA256', Buffer.from(`${ts}.${serverId}.${role}.${connectionId ?? ''}`), { key: signPriv, dsaEncoding: 'ieee-p1363' })
140
+ .toString('base64url');
141
+ return { ts, sig, pk: Buffer.from(canonical, 'utf8').toString('base64url') };
142
+ },
143
+ };
144
+ };
145
+
146
+ // Scripted client using the JS initiator: connects, handshakes, does a GET.
147
+ const runScriptedClient = async ({ relayUrl, serverId, hostEncPubJwk }) => {
148
+ const connectionId = 'conn-test-1';
149
+ const url = new URL(`${relayUrl}/`);
150
+ url.searchParams.set('v', String(RELAY_PROTOCOL_VERSION));
151
+ url.searchParams.set('role', 'client');
152
+ url.searchParams.set('serverId', serverId);
153
+ url.searchParams.set('connectionId', connectionId);
154
+ const ws = new WebSocket(url.toString());
155
+
156
+ const hostPub = await globalThis.crypto.subtle.importKey(
157
+ 'jwk',
158
+ { kty: hostEncPubJwk.kty, crv: hostEncPubJwk.crv, x: hostEncPubJwk.x, y: hostEncPubJwk.y, ext: true },
159
+ { name: 'ECDH', namedCurve: 'P-256' },
160
+ true,
161
+ [],
162
+ );
163
+ const ephemeral = await generateEcdhKeyPair();
164
+ const nonce = generateHandshakeNonce();
165
+
166
+ let channel = null;
167
+ const responseChunks = [];
168
+ let responseStatus = null;
169
+ let resolveDone;
170
+ const done = new Promise((resolve) => {
171
+ resolveDone = resolve;
172
+ });
173
+
174
+ ws.on('open', async () => {
175
+ ws.send(JSON.stringify({
176
+ t: 'hello',
177
+ v: RELAY_PROTOCOL_VERSION,
178
+ clientPubJwk: await exportPublicKeyJwk(ephemeral.publicKey),
179
+ nonce: bytesToBase64Url(nonce),
180
+ }));
181
+ });
182
+
183
+ // Serialize message handling: an async ws handler runs per-message tasks
184
+ // concurrently, letting StreamEnd overtake HttpBody and trip the decryptor's
185
+ // strict counter ordering (the production tunnel client chains decrypts).
186
+ let processing = Promise.resolve();
187
+ const handleMessage = async (data, isBinary) => {
188
+ if (!isBinary) {
189
+ const msg = JSON.parse(data.toString('utf8'));
190
+ if (msg.t === 'ready') {
191
+ const keys = await deriveSessionKeys(ephemeral.privateKey, hostPub, nonce);
192
+ channel = {
193
+ encryptor: createFrameEncryptor(keys.clientToHost),
194
+ decryptor: createFrameDecryptor(keys.hostToClient),
195
+ };
196
+ // Send an HTTP GET /health over stream 1.
197
+ const req = encodeTunnelFrame(TunnelFrameType.HttpRequest, 1, encodeJsonPayload({
198
+ method: 'GET',
199
+ path: '/health',
200
+ query: '',
201
+ headers: { accept: 'application/json' },
202
+ }));
203
+ ws.send(await channel.encryptor.encrypt(req), { binary: true });
204
+ ws.send(await channel.encryptor.encrypt(encodeTunnelFrame(TunnelFrameType.StreamEnd, 1, new Uint8Array(0))), { binary: true });
205
+ }
206
+ return;
207
+ }
208
+ if (!channel) return;
209
+ const plaintext = await channel.decryptor.decrypt(new Uint8Array(data));
210
+ const frame = decodeTunnelFrame(plaintext);
211
+ if (frame.frameType === TunnelFrameType.HttpResponse) {
212
+ responseStatus = JSON.parse(new TextDecoder().decode(frame.payload)).status;
213
+ } else if (frame.frameType === TunnelFrameType.HttpBody) {
214
+ responseChunks.push(frame.payload);
215
+ } else if (frame.frameType === TunnelFrameType.StreamEnd) {
216
+ const total = responseChunks.reduce((n, c) => n + c.length, 0);
217
+ const body = new Uint8Array(total);
218
+ let off = 0;
219
+ for (const c of responseChunks) {
220
+ body.set(c, off);
221
+ off += c.length;
222
+ }
223
+ resolveDone({ status: responseStatus, body: JSON.parse(new TextDecoder().decode(body)) });
224
+ ws.close();
225
+ }
226
+ };
227
+ ws.on('message', (data, isBinary) => {
228
+ processing = processing.then(() => handleMessage(data, isBinary));
229
+ });
230
+
231
+ return done;
232
+ };
233
+
234
+ describe('relay host-client integration', () => {
235
+ let relay;
236
+ let origin;
237
+ let host;
238
+
239
+ beforeAll(async () => {
240
+ relay = await startFakeRelay();
241
+ origin = await startLoopbackOrigin();
242
+ });
243
+
244
+ afterAll(async () => {
245
+ host?.stop();
246
+ await relay?.stop();
247
+ await origin?.stop();
248
+ });
249
+
250
+ it('tunnels an HTTP GET /health with only binary frames post-handshake', async () => {
251
+ const identity = await buildIdentity();
252
+ host = startRelayHost({
253
+ relayUrl: `${relay.wsUrl}/`,
254
+ identity,
255
+ getLocalPort: () => origin.port,
256
+ onStatus: () => {},
257
+ logger: { warn: () => {} },
258
+ });
259
+
260
+ // Give the control socket a moment to connect before the client arrives.
261
+ await new Promise((r) => setTimeout(r, 200));
262
+
263
+ const result = await runScriptedClient({
264
+ relayUrl: relay.wsUrl,
265
+ serverId: identity.serverId,
266
+ hostEncPubJwk: identity.hostEncPubJwk,
267
+ });
268
+
269
+ expect(result.status).toBe(200);
270
+ expect(result.body.ok).toBe(true);
271
+ expect(result.body.relayConn).toBe('conn-test-1');
272
+
273
+ // Every forwarded frame after the two plaintext handshake frames (client
274
+ // hello, host ready) must be binary.
275
+ const forwarded = relay.state.relayFrames;
276
+ const plaintextForwarded = forwarded.filter((f) => !f.isBinary);
277
+ expect(plaintextForwarded.length).toBe(2); // hello + ready only
278
+ expect(forwarded.filter((f) => f.isBinary).length).toBeGreaterThan(0);
279
+ });
280
+ });
@@ -0,0 +1,73 @@
1
+ // Host relay identity: the EXISTING ECDSA P-256 signing keypair (shared with
2
+ // the push relay via signing-key.js — same storage, same serverId) plus a NEW
3
+ // long-lived ECDH P-256 encryption keypair for the E2EE channel (WebCrypto
4
+ // keys are single-purpose, so signing and encryption keys must differ).
5
+ // The encryption keypair is persisted as `settings.relayEncryptionKey =
6
+ // { privateJwk, publicJwk }`, mirroring the relaySigningKey precedent.
7
+
8
+ import {
9
+ canonicalPublicJwkString,
10
+ deriveServerId,
11
+ getOrCreateRelaySigningKeypair,
12
+ signRelayMessage,
13
+ } from './signing-key.js';
14
+ import { exportPublicKeyJwk, generateEcdhKeyPair, importEcdhPrivateKey } from './e2ee.js';
15
+
16
+ const isJwkPair = (value) => Boolean(value && typeof value === 'object' && value.privateJwk && value.publicJwk);
17
+
18
+ /**
19
+ * @param {{ crypto: typeof import('node:crypto'), readSettingsFromDiskMigrated: () => Promise<object>, writeSettingsToDisk: (settings: object) => Promise<void> }} deps
20
+ */
21
+ export const createRelayIdentityRuntime = (deps) => {
22
+ const { crypto, readSettingsFromDiskMigrated, writeSettingsToDisk } = deps;
23
+
24
+ let cachedIdentity = null;
25
+
26
+ const getOrCreateEncryptionKeypair = async () => {
27
+ const settings = await readSettingsFromDiskMigrated();
28
+ const existing = settings?.relayEncryptionKey;
29
+ if (isJwkPair(existing)) {
30
+ return existing;
31
+ }
32
+ const keyPair = await generateEcdhKeyPair();
33
+ const privateJwk = await globalThis.crypto.subtle.exportKey('jwk', keyPair.privateKey);
34
+ const publicJwk = await exportPublicKeyJwk(keyPair.publicKey);
35
+ await writeSettingsToDisk({ ...settings, relayEncryptionKey: { privateJwk, publicJwk } });
36
+ return { privateJwk, publicJwk };
37
+ };
38
+
39
+ /**
40
+ * @returns {Promise<{
41
+ * serverId: string,
42
+ * hostEncPubJwk: JsonWebKey,
43
+ * hostEncPrivateKey: CryptoKey,
44
+ * signRelayAuth: (role: string, connectionId?: string | null) => { ts: number, sig: string, pk: string },
45
+ * }>}
46
+ */
47
+ const getRelayIdentity = async () => {
48
+ if (cachedIdentity) return cachedIdentity;
49
+ const signing = await getOrCreateRelaySigningKeypair({ crypto, readSettingsFromDiskMigrated, writeSettingsToDisk });
50
+ const serverId = deriveServerId({ crypto }, signing.publicJwk);
51
+ const encryption = await getOrCreateEncryptionKeypair();
52
+ const hostEncPrivateKey = await importEcdhPrivateKey(encryption.privateJwk);
53
+ const pk = Buffer.from(canonicalPublicJwkString(signing.publicJwk), 'utf8').toString('base64url');
54
+
55
+ // Relay-layer auth for host-control / host-data upgrades. Signature payload
56
+ // string is `${ts}.${serverId}.${role}.${connectionId ?? ""}` (spec Layer 1).
57
+ const signRelayAuth = (role, connectionId) => {
58
+ const ts = Date.now();
59
+ const sig = signRelayMessage({ crypto }, signing.privateKey, `${ts}.${serverId}.${role}.${connectionId ?? ''}`);
60
+ return { ts, sig, pk };
61
+ };
62
+
63
+ cachedIdentity = {
64
+ serverId,
65
+ hostEncPubJwk: encryption.publicJwk,
66
+ hostEncPrivateKey,
67
+ signRelayAuth,
68
+ };
69
+ return cachedIdentity;
70
+ };
71
+
72
+ return { getRelayIdentity };
73
+ };
@@ -0,0 +1,78 @@
1
+ import { describe, expect, it } from 'bun:test';
2
+ import crypto from 'node:crypto';
3
+
4
+ import { createRelayIdentityRuntime } from './identity.js';
5
+ import { canonicalPublicJwkString } from './signing-key.js';
6
+
7
+ // In-memory settings store standing in for the on-disk settings file.
8
+ const makeSettingsStore = (initial = {}) => {
9
+ let settings = { ...initial };
10
+ return {
11
+ readSettingsFromDiskMigrated: async () => ({ ...settings }),
12
+ writeSettingsToDisk: async (next) => {
13
+ settings = { ...next };
14
+ },
15
+ peek: () => settings,
16
+ };
17
+ };
18
+
19
+ describe('relay identity', () => {
20
+ it('derives a stable serverId from the signing key and persists both keypairs', async () => {
21
+ const store = makeSettingsStore();
22
+ const runtime = createRelayIdentityRuntime({ crypto, ...store });
23
+ const identity = await runtime.getRelayIdentity();
24
+
25
+ const stored = store.peek();
26
+ expect(stored.relaySigningKey).toBeDefined();
27
+ expect(stored.relayEncryptionKey).toBeDefined();
28
+
29
+ const expectedServerId = crypto
30
+ .createHash('sha256')
31
+ .update(canonicalPublicJwkString(stored.relaySigningKey.publicJwk))
32
+ .digest('base64url');
33
+ expect(identity.serverId).toBe(expectedServerId);
34
+ expect(identity.hostEncPubJwk.crv).toBe('P-256');
35
+ });
36
+
37
+ it('reuses an existing signing key (serverId stays stable across installs)', async () => {
38
+ const { privateKey, publicKey } = crypto.generateKeyPairSync('ec', { namedCurve: 'P-256' });
39
+ void privateKey;
40
+ const publicJwk = publicKey.export({ format: 'jwk' });
41
+ const store = makeSettingsStore({
42
+ relaySigningKey: {
43
+ privateJwk: crypto.generateKeyPairSync('ec', { namedCurve: 'P-256' }).privateKey.export({ format: 'jwk' }),
44
+ publicJwk,
45
+ },
46
+ });
47
+ // Match private to public so importing works.
48
+ const pair = crypto.generateKeyPairSync('ec', { namedCurve: 'P-256' });
49
+ store.peek().relaySigningKey.privateJwk = pair.privateKey.export({ format: 'jwk' });
50
+ store.peek().relaySigningKey.publicJwk = pair.publicKey.export({ format: 'jwk' });
51
+
52
+ const runtime = createRelayIdentityRuntime({ crypto, ...store });
53
+ const identity = await runtime.getRelayIdentity();
54
+ const expected = crypto
55
+ .createHash('sha256')
56
+ .update(canonicalPublicJwkString(pair.publicKey.export({ format: 'jwk' })))
57
+ .digest('base64url');
58
+ expect(identity.serverId).toBe(expected);
59
+ });
60
+
61
+ it('produces a verifiable relay auth signature', async () => {
62
+ const store = makeSettingsStore();
63
+ const runtime = createRelayIdentityRuntime({ crypto, ...store });
64
+ const identity = await runtime.getRelayIdentity();
65
+ const { ts, sig, pk } = identity.signRelayAuth('host-control', null);
66
+
67
+ const canonical = Buffer.from(pk, 'base64url').toString('utf8');
68
+ const publicJwk = JSON.parse(canonical);
69
+ const key = crypto.createPublicKey({ key: publicJwk, format: 'jwk' });
70
+ const ok = crypto.verify(
71
+ 'SHA256',
72
+ Buffer.from(`${ts}.${identity.serverId}.host-control.`),
73
+ { key, dsaEncoding: 'ieee-p1363' },
74
+ Buffer.from(sig, 'base64url'),
75
+ );
76
+ expect(ok).toBe(true);
77
+ });
78
+ });
@@ -0,0 +1,247 @@
1
+ // Private relay service: config persistence, lifecycle of the relay host
2
+ // client, and the /api/openchamber/relay/* management routes.
3
+ //
4
+ // Config lives in the server settings file as `settings.privateRelay =
5
+ // { enabled, relayUrl }` (same storage precedent as tunnels/notifications).
6
+ // Routes are registered with the other OpenChamber feature routes, before the
7
+ // generic OpenCode proxy, and are covered by the same global UI auth gate.
8
+ //
9
+ // Cross-runtime parity note: relay host mode intentionally targets the web
10
+ // server runtime only in v1 (Electron shares this server in-process). The VS
11
+ // Code runtime does not host a relay; shared UI must treat these routes as
12
+ // web-runtime capabilities.
13
+
14
+ import express from 'express';
15
+
16
+ import { createRelayIdentityRuntime } from './identity.js';
17
+ import { startRelayHost } from './host-client.js';
18
+
19
+ export const DEFAULT_RELAY_URL = 'wss://relay.openchamber.dev/ws';
20
+
21
+ const isValidRelayUrl = (value) => {
22
+ if (typeof value !== 'string') return false;
23
+ try {
24
+ const url = new URL(value.trim());
25
+ return url.protocol === 'ws:' || url.protocol === 'wss:';
26
+ } catch {
27
+ return false;
28
+ }
29
+ };
30
+
31
+ const normalizeRelayUrl = (value) => {
32
+ if (typeof value !== 'string') return DEFAULT_RELAY_URL;
33
+ const trimmed = value.trim();
34
+ if (!trimmed || !isValidRelayUrl(trimmed)) return DEFAULT_RELAY_URL;
35
+ return trimmed;
36
+ };
37
+
38
+ // A deployment can pin the relay endpoint via env (e.g. a self-hosted relay on
39
+ // your own Cloudflare account/domain). When set and valid it overrides the
40
+ // stored setting entirely, so the host connection, the pairing offer, and the
41
+ // status all point at it — clients then inherit it from the offer automatically.
42
+ const envRelayUrlOverride = () => {
43
+ const raw = process.env.OPENCHAMBER_RELAY_URL;
44
+ if (typeof raw !== 'string' || !raw.trim() || !isValidRelayUrl(raw)) return null;
45
+ return raw.trim();
46
+ };
47
+
48
+ /**
49
+ * @param {{
50
+ * crypto: typeof import('node:crypto'),
51
+ * readSettingsFromDiskMigrated: () => Promise<object>,
52
+ * writeSettingsToDisk: (settings: object) => Promise<void>,
53
+ * getLocalPort: () => number,
54
+ * logger?: Pick<Console, 'warn'>,
55
+ * }} deps
56
+ */
57
+ export const createRelayService = ({
58
+ crypto,
59
+ readSettingsFromDiskMigrated,
60
+ writeSettingsToDisk,
61
+ getLocalPort,
62
+ // Returns true when any paired device or pending pairing session uses the
63
+ // relay transport. The relay lifecycle is driven purely by this demand.
64
+ hasRelayDemand = async () => false,
65
+ logger = console,
66
+ }) => {
67
+ const identityRuntime = createRelayIdentityRuntime({ crypto, readSettingsFromDiskMigrated, writeSettingsToDisk });
68
+
69
+ let hostClient = null;
70
+ let status = { state: 'disabled', lastError: null, connectedClients: 0 };
71
+
72
+ const readConfig = async () => {
73
+ const settings = await readSettingsFromDiskMigrated();
74
+ const stored = settings?.privateRelay;
75
+ const override = envRelayUrlOverride();
76
+ return {
77
+ enabled: stored?.enabled === true,
78
+ relayUrl: override ?? normalizeRelayUrl(stored?.relayUrl),
79
+ // True when the endpoint is pinned by OPENCHAMBER_RELAY_URL (a self-hosted
80
+ // relay); the stored setting is ignored while it is set.
81
+ relayUrlLocked: override !== null,
82
+ };
83
+ };
84
+
85
+ const writeConfig = async (config) => {
86
+ const settings = await readSettingsFromDiskMigrated();
87
+ await writeSettingsToDisk({
88
+ ...settings,
89
+ privateRelay: { enabled: config.enabled === true, relayUrl: normalizeRelayUrl(config.relayUrl) },
90
+ });
91
+ };
92
+
93
+ const start = async (relayUrl) => {
94
+ if (hostClient) return;
95
+ const identity = await identityRuntime.getRelayIdentity();
96
+ hostClient = startRelayHost({
97
+ relayUrl,
98
+ identity,
99
+ getLocalPort,
100
+ logger,
101
+ onStatus: (next) => {
102
+ status = next;
103
+ },
104
+ });
105
+ status = hostClient.getStatus();
106
+ };
107
+
108
+ const stop = () => {
109
+ if (!hostClient) return;
110
+ hostClient.stop();
111
+ hostClient = null;
112
+ status = { state: 'disabled', lastError: null, connectedClients: 0 };
113
+ };
114
+
115
+ const startIfEnabled = async () => {
116
+ try {
117
+ const config = await readConfig();
118
+ if (config.enabled) {
119
+ await start(config.relayUrl);
120
+ }
121
+ } catch (error) {
122
+ logger.warn(`[Relay] startup failed: ${error?.message ?? error}`);
123
+ }
124
+ };
125
+
126
+ // Drive the relay lifecycle from demand: run it when a device or pending
127
+ // session uses the relay, stop it when none remain. Called on startup and after
128
+ // pairing/device changes, so the operator never toggles it manually.
129
+ const reconcile = async () => {
130
+ try {
131
+ const demand = await hasRelayDemand();
132
+ const config = await readConfig();
133
+ if (demand) {
134
+ if (!config.enabled) await writeConfig({ enabled: true, relayUrl: config.relayUrl });
135
+ if (!hostClient) {
136
+ const next = await readConfig();
137
+ await start(next.relayUrl);
138
+ }
139
+ } else {
140
+ if (config.enabled) await writeConfig({ enabled: false, relayUrl: config.relayUrl });
141
+ stop();
142
+ }
143
+ } catch (error) {
144
+ logger.warn(`[Relay] reconcile failed: ${error?.message ?? error}`);
145
+ }
146
+ };
147
+
148
+ const getStatus = async () => {
149
+ const config = await readConfig();
150
+ const identity = await identityRuntime.getRelayIdentity();
151
+ const live = hostClient ? hostClient.getStatus() : status;
152
+ return {
153
+ enabled: config.enabled,
154
+ state: hostClient ? live.state : 'disabled',
155
+ serverId: identity.serverId,
156
+ connectedClients: live.connectedClients,
157
+ relayUrl: config.relayUrl,
158
+ relayUrlLocked: config.relayUrlLocked,
159
+ ...(live.lastError ? { lastError: live.lastError } : {}),
160
+ };
161
+ };
162
+
163
+ // Pairing candidate for the unified connection payload (pairing v2). Relay is
164
+ // just another transport: it carries the relay route + E2EE trust anchor, no
165
+ // embedded token — the client redeems the one-time pairing secret over the
166
+ // tunnel like any other candidate. Returns null when the host relay is off, so
167
+ // callers only advertise relay when it is actually reachable. Priority is high
168
+ // (tried after LAN/tunnel) since the relay path is the last-resort transport.
169
+ const buildPairingCandidate = async () => {
170
+ const config = await readConfig();
171
+ const identity = await identityRuntime.getRelayIdentity();
172
+ return {
173
+ type: 'relay',
174
+ relayUrl: config.relayUrl,
175
+ serverId: identity.serverId,
176
+ hostEncPubJwk: identity.hostEncPubJwk,
177
+ priority: 30,
178
+ };
179
+ };
180
+
181
+ const getPairingCandidate = async () => {
182
+ const config = await readConfig();
183
+ if (!config.enabled) return null;
184
+ return buildPairingCandidate();
185
+ };
186
+
187
+ // Enable the relay host on demand and return its pairing candidate. Creating a
188
+ // relay pairing link IS the demand signal, so the relay turns itself on here
189
+ // rather than requiring a separate manual toggle. Idempotent: a no-op when the
190
+ // relay is already enabled and running.
191
+ const ensureEnabledForPairing = async () => {
192
+ const config = await readConfig();
193
+ if (!config.enabled) {
194
+ await writeConfig({ enabled: true, relayUrl: config.relayUrl });
195
+ }
196
+ if (!hostClient) {
197
+ const next = await readConfig();
198
+ await start(next.relayUrl);
199
+ }
200
+ return buildPairingCandidate();
201
+ };
202
+
203
+ const registerRoutes = (app) => {
204
+ app.get('/api/openchamber/relay/status', async (_req, res) => {
205
+ try {
206
+ res.json(await getStatus());
207
+ } catch (error) {
208
+ res.status(500).json({ error: error?.message ?? 'Failed to read relay status' });
209
+ }
210
+ });
211
+
212
+ app.post('/api/openchamber/relay/enable', express.json({ limit: '16kb' }), async (req, res) => {
213
+ try {
214
+ const current = await readConfig();
215
+ const relayUrl = typeof req.body?.relayUrl === 'string' ? normalizeRelayUrl(req.body.relayUrl) : current.relayUrl;
216
+ await writeConfig({ enabled: true, relayUrl });
217
+ if (hostClient) stop();
218
+ await start(relayUrl);
219
+ res.json(await getStatus());
220
+ } catch (error) {
221
+ res.status(500).json({ error: error?.message ?? 'Failed to enable relay' });
222
+ }
223
+ });
224
+
225
+ app.post('/api/openchamber/relay/disable', async (_req, res) => {
226
+ try {
227
+ const current = await readConfig();
228
+ await writeConfig({ enabled: false, relayUrl: current.relayUrl });
229
+ stop();
230
+ res.json(await getStatus());
231
+ } catch (error) {
232
+ res.status(500).json({ error: error?.message ?? 'Failed to disable relay' });
233
+ }
234
+ });
235
+
236
+ };
237
+
238
+ return {
239
+ registerRoutes,
240
+ startIfEnabled,
241
+ reconcile,
242
+ stop,
243
+ getStatus,
244
+ getPairingCandidate,
245
+ ensureEnabledForPairing,
246
+ };
247
+ };