@openchamber/web 1.14.0 → 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.
- package/bin/cli.test.js +8 -0
- package/bin/lib/DOCUMENTATION.md +3 -0
- package/bin/lib/cli-args.js +10 -0
- package/bin/lib/commands-connect-url.js +169 -22
- package/dist/assets/{DiagramView-CIaZCGUT.js → DiagramView-HR2xZxJ8.js} +1 -1
- package/dist/assets/MarkdownRendererImpl-sm01Q7R7.js +11 -0
- package/dist/assets/{MultiRunWindow-Bsbr3i8y.js → MultiRunWindow-DlFUaNQK.js} +1 -1
- package/dist/assets/OnboardingScreen-DVRz82mJ.js +1 -0
- package/dist/assets/{SessionSwitcherDropdown-CLm6tF5n.js → SessionSwitcherDropdown-DvoOalMY.js} +1 -1
- package/dist/assets/SettingsWindow-CkInZcj7.js +1 -0
- package/dist/assets/{TerminalView-DF7-jlam.js → TerminalView-D_9BAjtv.js} +3 -3
- package/dist/assets/es-cjUissX4.js +15 -0
- package/dist/assets/fr-DqbXnTdK.js +13 -0
- package/dist/assets/index-Dg0nmvQU.css +1 -0
- package/dist/assets/index-ltrmNGAf.js +2 -0
- package/dist/assets/ja-Cetyq6Eg.js +15 -0
- package/dist/assets/ko-DtunWisP.js +15 -0
- package/dist/assets/main-BC0m8s1v.js +236 -0
- package/dist/assets/main-DzNa8r0N.js +2 -0
- package/dist/assets/miniChat-BRYDE-Se.js +2 -0
- package/dist/assets/mobile-C3QJVA97.js +2 -0
- package/dist/assets/pl-DctGLgve.js +15 -0
- package/dist/assets/pt-BR-CXPhf78S.js +15 -0
- package/dist/assets/renderElectronMiniChatApp-CVFbDC5A.js +2 -0
- package/dist/assets/renderMobileApp-wkBjh5WR.js +16 -0
- package/dist/assets/runtimeEndpointReset-C42u8PvG.js +167 -0
- package/dist/assets/uk-Bdrc-kqF.js +15 -0
- package/dist/assets/{useAppFontEffects-DTO332li.js → useAppFontEffects-DzBg8hrC.js} +132 -116
- package/dist/assets/{vendor-.bun-C6iL44L9.js → vendor-.bun-BE757pvp.js} +1 -1
- package/dist/assets/zh-CN-CeCVKrHP.js +15 -0
- package/dist/assets/zh-TW-CoqiQING.js +15 -0
- package/dist/index.html +4 -4
- package/dist/mini-chat.html +4 -4
- package/dist/mobile.html +4 -4
- package/package.json +2 -2
- package/server/index.js +157 -6
- package/server/lib/client-auth/pairing.js +308 -0
- package/server/lib/client-auth/pairing.test.js +142 -0
- package/server/lib/client-auth/remote-clients.js +65 -3
- package/server/lib/notifications/apns-runtime.js +9 -16
- package/server/lib/opencode/bootstrap-runtime.js +10 -0
- package/server/lib/opencode/core-routes.js +247 -6
- package/server/lib/opencode/core-routes.test.js +248 -9
- package/server/lib/opencode/feature-routes-runtime.js +10 -0
- package/server/lib/opencode/models-metadata.js +61 -0
- package/server/lib/opencode/network-runtime.js +14 -1
- package/server/lib/opencode/network-runtime.test.js +29 -9
- package/server/lib/opencode/openchamber-routes.js +7 -40
- package/server/lib/opencode/proxy.js +47 -6
- package/server/lib/opencode/settings-helpers.js +16 -0
- package/server/lib/opencode/settings-helpers.test.js +11 -0
- package/server/lib/opencode/settings-normalization-runtime.js +2 -0
- package/server/lib/opencode/shutdown-runtime.js +2 -0
- package/server/lib/package-manager.js +18 -5
- package/server/lib/relay/DOCUMENTATION.md +78 -0
- package/server/lib/relay/cross-compat.test.js +135 -0
- package/server/lib/relay/e2ee.js +341 -0
- package/server/lib/relay/e2ee.test.js +124 -0
- package/server/lib/relay/host-client.js +389 -0
- package/server/lib/relay/host-client.test.js +280 -0
- package/server/lib/relay/identity.js +73 -0
- package/server/lib/relay/identity.test.js +78 -0
- package/server/lib/relay/service.js +247 -0
- package/server/lib/relay/signing-key.js +50 -0
- package/server/lib/relay/tunnel-codec.js +373 -0
- package/server/lib/relay/tunnel-codec.test.js +58 -0
- package/server/lib/relay/tunnel-host.js +462 -0
- package/server/lib/session-assist/DOCUMENTATION.md +66 -0
- package/server/lib/session-assist/runtime.js +394 -0
- package/server/lib/small-model/DOCUMENTATION.md +78 -0
- package/server/lib/small-model/call.js +380 -0
- package/server/lib/small-model/catalog.js +13 -0
- package/server/lib/small-model/index.js +167 -0
- package/server/lib/small-model/resolve.js +131 -0
- package/server/lib/small-model/resolve.test.js +197 -0
- package/server/lib/small-model/routes.js +44 -0
- package/server/lib/ui-auth/DOCUMENTATION.md +6 -0
- package/server/lib/ui-auth/ui-auth.js +10 -0
- package/server/opencode-proxy.test.js +38 -0
- package/dist/assets/MarkdownRendererImpl-DWgOeIpO.js +0 -7
- package/dist/assets/OnboardingScreen-3IAKkM5k.js +0 -1
- package/dist/assets/SettingsWindow-K-ErjehP.js +0 -1
- package/dist/assets/es-DQIFCjC2.js +0 -15
- package/dist/assets/fr-CJRav0LS.js +0 -13
- package/dist/assets/index-5eUDDB6w.js +0 -2
- package/dist/assets/index-CgpE7F8T.css +0 -1
- package/dist/assets/ja-CjAaqvHO.js +0 -15
- package/dist/assets/ko-BEbFxvrd.js +0 -15
- package/dist/assets/main-C2put7uQ.js +0 -2
- package/dist/assets/main-DuQEoz31.js +0 -214
- package/dist/assets/miniChat-o3AAQ-8r.js +0 -2
- package/dist/assets/mobile-X0421aWz.js +0 -2
- package/dist/assets/pl-D4kzai5T.js +0 -15
- package/dist/assets/pt-BR-9Sk3esQZ.js +0 -15
- package/dist/assets/renderElectronMiniChatApp-CdDj0ms1.js +0 -2
- package/dist/assets/renderMobileApp-cZ_HZKSe.js +0 -16
- package/dist/assets/runtimeEndpointReset-BYLVW9e7.js +0 -167
- package/dist/assets/uk-DW_dTfoO.js +0 -15
- package/dist/assets/zh-CN-r2_euV7U.js +0 -15
- package/dist/assets/zh-TW-BdPx3NWh.js +0 -15
|
@@ -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
|
+
};
|
|
@@ -0,0 +1,50 @@
|
|
|
1
|
+
// Per-server relay signing identity (ECDSA P-256), extracted from
|
|
2
|
+
// lib/notifications/apns-runtime.js so both the push relay and the private
|
|
3
|
+
// relay share the SAME keypair and thus the SAME serverId
|
|
4
|
+
// (base64url(SHA-256(canonical public JWK))). Storage format is unchanged:
|
|
5
|
+
// `settings.relaySigningKey = { privateJwk, publicJwk }` — existing installs'
|
|
6
|
+
// serverId must stay stable because push token binding depends on it.
|
|
7
|
+
|
|
8
|
+
/**
|
|
9
|
+
* @param {{ crypto: typeof import('node:crypto'), readSettingsFromDiskMigrated: () => Promise<object>, writeSettingsToDisk: (settings: object) => Promise<void> }} deps
|
|
10
|
+
* @returns {Promise<{ privateKey: import('node:crypto').KeyObject, publicJwk: JsonWebKey }>}
|
|
11
|
+
*/
|
|
12
|
+
export const getOrCreateRelaySigningKeypair = async ({ crypto, readSettingsFromDiskMigrated, writeSettingsToDisk }) => {
|
|
13
|
+
const settings = await readSettingsFromDiskMigrated();
|
|
14
|
+
const existing = settings?.relaySigningKey;
|
|
15
|
+
if (existing && existing.privateJwk && existing.publicJwk) {
|
|
16
|
+
return {
|
|
17
|
+
privateKey: crypto.createPrivateKey({ key: existing.privateJwk, format: 'jwk' }),
|
|
18
|
+
publicJwk: existing.publicJwk,
|
|
19
|
+
};
|
|
20
|
+
}
|
|
21
|
+
const { privateKey, publicKey } = crypto.generateKeyPairSync('ec', { namedCurve: 'P-256' });
|
|
22
|
+
const privateJwk = privateKey.export({ format: 'jwk' });
|
|
23
|
+
const publicJwk = publicKey.export({ format: 'jwk' });
|
|
24
|
+
await writeSettingsToDisk({ ...settings, relaySigningKey: { privateJwk, publicJwk } });
|
|
25
|
+
return { privateKey, publicJwk };
|
|
26
|
+
};
|
|
27
|
+
|
|
28
|
+
// Fixed key order so the hash is stable regardless of stored JSON field order.
|
|
29
|
+
// Byte-for-byte mirror of canonicalJwk in openchamber-website apps/api relay-auth.ts.
|
|
30
|
+
/** @param {JsonWebKey} jwk */
|
|
31
|
+
export const canonicalPublicJwkString = (jwk) =>
|
|
32
|
+
JSON.stringify({ crv: jwk.crv, kty: jwk.kty, x: jwk.x, y: jwk.y });
|
|
33
|
+
|
|
34
|
+
/**
|
|
35
|
+
* serverId = base64url(SHA-256(canonical public JWK)). Must match the push
|
|
36
|
+
* relay's deriveServerId — this id is the routing key for both relays.
|
|
37
|
+
* @param {{ crypto: typeof import('node:crypto') }} deps
|
|
38
|
+
* @param {JsonWebKey} publicJwk
|
|
39
|
+
*/
|
|
40
|
+
export const deriveServerId = ({ crypto }, publicJwk) =>
|
|
41
|
+
crypto.createHash('sha256').update(canonicalPublicJwkString(publicJwk)).digest('base64url');
|
|
42
|
+
|
|
43
|
+
/**
|
|
44
|
+
* ECDSA-SHA256, IEEE P1363 (raw r||s) signature — the form WebCrypto verifies.
|
|
45
|
+
* @param {{ crypto: typeof import('node:crypto') }} deps
|
|
46
|
+
* @param {import('node:crypto').KeyObject} privateKey
|
|
47
|
+
* @param {string} message
|
|
48
|
+
*/
|
|
49
|
+
export const signRelayMessage = ({ crypto }, privateKey, message) =>
|
|
50
|
+
crypto.sign('SHA256', Buffer.from(message), { key: privateKey, dsaEncoding: 'ieee-p1363' }).toString('base64url');
|