@celljs/ta-relay 4.11.0 → 4.13.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/README.en.md +26 -1
- package/README.md +26 -1
- package/esm/common/index.d.ts +5 -0
- package/esm/common/index.js +5 -0
- package/esm/common/relay-faces.d.ts +32 -0
- package/esm/common/relay-faces.js +208 -0
- package/esm/common/relay-friends.d.ts +154 -0
- package/esm/common/relay-friends.js +482 -0
- package/esm/common/relay-hub-util.d.ts +9 -0
- package/esm/common/relay-hub-util.js +19 -2
- package/esm/common/relay-hubs-connection.d.ts +110 -0
- package/esm/common/relay-hubs-connection.js +508 -0
- package/esm/common/relay-hubs-protocol.d.ts +174 -0
- package/esm/common/relay-hubs-protocol.js +2 -0
- package/esm/common/relay-hubs.d.ts +68 -216
- package/esm/common/relay-hubs.js +303 -507
- package/esm/common/relay-identity.d.ts +2 -0
- package/esm/common/relay-info.d.ts +44 -0
- package/esm/common/relay-info.js +94 -0
- package/esm/common/relay-protocol.d.ts +7 -3
- package/esm/common/relay-protocol.js +7 -3
- package/esm/common/relay-room-chat.d.ts +36 -2
- package/esm/common/relay-room-chat.js +32 -7
- package/esm/common/relay-spot.d.ts +122 -0
- package/esm/common/relay-spot.js +179 -0
- package/esm/guest/guest-i18n.d.ts +5 -0
- package/esm/guest/guest-i18n.js +10 -0
- package/esm/guest/guest-style.d.ts +1 -1
- package/esm/guest/guest-style.js +11 -4
- package/esm/guest/guest.js +39 -18
- package/esm/node/index.d.ts +2 -0
- package/esm/node/index.js +2 -0
- package/esm/node/relay-file-storage.d.ts +32 -0
- package/esm/node/relay-file-storage.js +101 -0
- package/esm/node/relay-host.d.ts +63 -28
- package/esm/node/relay-host.js +145 -52
- package/esm/node/relay-hub-files.d.ts +1 -1
- package/esm/node/relay-server.d.ts +37 -3
- package/esm/node/relay-server.js +193 -37
- package/esm/node/relay-store.d.ts +34 -6
- package/esm/node/relay-store.js +54 -22
- package/esm/node/relays-file.d.ts +139 -0
- package/esm/node/relays-file.js +373 -0
- package/lib/common/index.d.ts +5 -0
- package/lib/common/index.js +5 -0
- package/lib/common/relay-faces.d.ts +33 -0
- package/lib/common/relay-faces.js +211 -0
- package/lib/common/relay-friends.d.ts +155 -0
- package/lib/common/relay-friends.js +486 -0
- package/lib/common/relay-hub-util.d.ts +9 -0
- package/lib/common/relay-hub-util.js +19 -2
- package/lib/common/relay-hubs-connection.d.ts +111 -0
- package/lib/common/relay-hubs-connection.js +513 -0
- package/lib/common/relay-hubs-protocol.d.ts +175 -0
- package/lib/common/relay-hubs-protocol.js +3 -0
- package/lib/common/relay-hubs.d.ts +68 -216
- package/lib/common/relay-hubs.js +311 -515
- package/lib/common/relay-identity.d.ts +2 -0
- package/lib/common/relay-info.d.ts +45 -0
- package/lib/common/relay-info.js +97 -0
- package/lib/common/relay-protocol.d.ts +7 -3
- package/lib/common/relay-protocol.js +8 -4
- package/lib/common/relay-room-chat.d.ts +36 -2
- package/lib/common/relay-room-chat.js +32 -7
- package/lib/common/relay-spot.d.ts +123 -0
- package/lib/common/relay-spot.js +183 -0
- package/lib/guest/guest-i18n.d.ts +5 -0
- package/lib/guest/guest-i18n.js +10 -0
- package/lib/guest/guest-style.d.ts +1 -1
- package/lib/guest/guest-style.js +11 -4
- package/lib/guest/guest.js +39 -18
- package/lib/node/index.d.ts +2 -0
- package/lib/node/index.js +2 -0
- package/lib/node/relay-file-storage.d.ts +33 -0
- package/lib/node/relay-file-storage.js +105 -0
- package/lib/node/relay-host.d.ts +63 -28
- package/lib/node/relay-host.js +146 -53
- package/lib/node/relay-hub-files.d.ts +1 -1
- package/lib/node/relay-server.d.ts +37 -3
- package/lib/node/relay-server.js +193 -37
- package/lib/node/relay-store.d.ts +34 -6
- package/lib/node/relay-store.js +54 -22
- package/lib/node/relays-file.d.ts +140 -0
- package/lib/node/relays-file.js +378 -0
- package/package.json +2 -2
- package/viewer/room.html +21 -14
|
@@ -0,0 +1,513 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
+
exports.RelayHubsConnection = exports.Live = exports.OPEN = exports.READY_MS = void 0;
|
|
4
|
+
const relay_friends_1 = require("./relay-friends");
|
|
5
|
+
const relay_hub_1 = require("./relay-hub");
|
|
6
|
+
const relay_hub_util_1 = require("./relay-hub-util");
|
|
7
|
+
const relay_identity_1 = require("./relay-identity");
|
|
8
|
+
const relay_pairing_1 = require("./relay-pairing");
|
|
9
|
+
const relay_protocol_1 = require("./relay-protocol");
|
|
10
|
+
const relay_room_chat_1 = require("./relay-room-chat");
|
|
11
|
+
const MAX_RECONNECT_MS = 30000;
|
|
12
|
+
const SKEW_MS = 5 * 60 * 1000;
|
|
13
|
+
/** How long a call waits for the room to be connected, or for the relay to answer. */
|
|
14
|
+
exports.READY_MS = 15000;
|
|
15
|
+
exports.OPEN = 1;
|
|
16
|
+
/** A room as this Ta holds it while it runs: its connection and what it knows of the room. */
|
|
17
|
+
class Live {
|
|
18
|
+
constructor(record) {
|
|
19
|
+
this.record = record;
|
|
20
|
+
this.synced = false;
|
|
21
|
+
this.online = new Set();
|
|
22
|
+
this.state = new Map();
|
|
23
|
+
/** Asks to join, with the invitation each came with. */
|
|
24
|
+
this.asks = new Map();
|
|
25
|
+
this.done = new Map();
|
|
26
|
+
this.ready = [];
|
|
27
|
+
this.attempts = 0;
|
|
28
|
+
/** Connect again at once, whatever the close said. */
|
|
29
|
+
this.retry = false;
|
|
30
|
+
this.awaitingPong = false;
|
|
31
|
+
/** Events are handled one after another: opening them is async. */
|
|
32
|
+
this.chain = Promise.resolve();
|
|
33
|
+
}
|
|
34
|
+
}
|
|
35
|
+
exports.Live = Live;
|
|
36
|
+
/**
|
|
37
|
+
* The half of {@link RelayHubs} that keeps a connection to the hub of each room and reads what comes over it:
|
|
38
|
+
* connecting again, the welcome, the roster, the state and the messages, each opened and checked against the
|
|
39
|
+
* signatures of the roster; what is kept of the rooms.
|
|
40
|
+
*/
|
|
41
|
+
class RelayHubsConnection {
|
|
42
|
+
constructor(options) {
|
|
43
|
+
this.options = options;
|
|
44
|
+
this.live = new Map();
|
|
45
|
+
this.listeners = new Set();
|
|
46
|
+
/** Asks the user was told of while this runs: those the owner finds waiting when it connects are told once. */
|
|
47
|
+
this.told = new Set();
|
|
48
|
+
this.stopped = true;
|
|
49
|
+
this.nextId = 1;
|
|
50
|
+
}
|
|
51
|
+
/** This Ta's identity, made the first time. */
|
|
52
|
+
async identity() {
|
|
53
|
+
var _a, _b;
|
|
54
|
+
if (this.own) {
|
|
55
|
+
return this.own;
|
|
56
|
+
}
|
|
57
|
+
const kept = this.options.store.read('identity');
|
|
58
|
+
if (kept && (await relay_identity_1.RelayIdentityUtil.check(kept))) {
|
|
59
|
+
this.own = kept;
|
|
60
|
+
return kept;
|
|
61
|
+
}
|
|
62
|
+
const made = await relay_identity_1.RelayIdentityUtil.create(((_b = (_a = this.options).name) === null || _b === void 0 ? void 0 : _b.call(_a)) || 'Ta');
|
|
63
|
+
this.options.store.write('identity', made);
|
|
64
|
+
this.own = made;
|
|
65
|
+
return made;
|
|
66
|
+
}
|
|
67
|
+
/** Who this Ta is in a room: the identity it joined with when it took on another since (RelayRoomRecord.identity). */
|
|
68
|
+
async identityOf(live) {
|
|
69
|
+
var _a;
|
|
70
|
+
return (_a = live.record.identity) !== null && _a !== void 0 ? _a : this.identity();
|
|
71
|
+
}
|
|
72
|
+
requestOf(live, ask, friends) {
|
|
73
|
+
return {
|
|
74
|
+
room: live.record.id,
|
|
75
|
+
title: live.record.title,
|
|
76
|
+
ask: ask.member,
|
|
77
|
+
id: ask.id,
|
|
78
|
+
name: ask.name,
|
|
79
|
+
friend: friends.has(ask.id),
|
|
80
|
+
...(ask.guest ? { guest: true } : {}),
|
|
81
|
+
at: ask.at,
|
|
82
|
+
};
|
|
83
|
+
}
|
|
84
|
+
/** Resolves once the room is connected and has its state; rejects after a while. */
|
|
85
|
+
ready(live) {
|
|
86
|
+
var _a;
|
|
87
|
+
if (((_a = live.socket) === null || _a === void 0 ? void 0 : _a.readyState) === exports.OPEN && live.synced) {
|
|
88
|
+
return Promise.resolve();
|
|
89
|
+
}
|
|
90
|
+
return new Promise((resolve, reject) => {
|
|
91
|
+
const timer = setTimeout(() => reject(new Error('The room cannot be reached now.')), exports.READY_MS);
|
|
92
|
+
live.ready.push(() => {
|
|
93
|
+
clearTimeout(timer);
|
|
94
|
+
resolve();
|
|
95
|
+
});
|
|
96
|
+
});
|
|
97
|
+
}
|
|
98
|
+
request(live, request) {
|
|
99
|
+
var _a;
|
|
100
|
+
if (((_a = live.socket) === null || _a === void 0 ? void 0 : _a.readyState) !== exports.OPEN) {
|
|
101
|
+
throw new Error('The room cannot be reached now.');
|
|
102
|
+
}
|
|
103
|
+
live.socket.send(JSON.stringify(request));
|
|
104
|
+
}
|
|
105
|
+
async sendBody(live, body, to) {
|
|
106
|
+
await this.ready(live);
|
|
107
|
+
const identity = await this.identityOf(live);
|
|
108
|
+
const d = await relay_hub_util_1.RelayHubUtil.seal(live.keys.seal, identity, live.record.member, body);
|
|
109
|
+
this.request(live, { t: 'send', d, ...(to ? { to } : {}) });
|
|
110
|
+
}
|
|
111
|
+
/** The roster with `change` made, its version one more, signed by the owner. */
|
|
112
|
+
async nextRoster(live, change) {
|
|
113
|
+
var _a, _b;
|
|
114
|
+
var _c, _d;
|
|
115
|
+
const identity = await this.identityOf(live);
|
|
116
|
+
const body = { v: ((_c = (_a = live.roster) === null || _a === void 0 ? void 0 : _a.v) !== null && _c !== void 0 ? _c : 0) + 1, members: change((_d = (_b = live.roster) === null || _b === void 0 ? void 0 : _b.members) !== null && _d !== void 0 ? _d : []) };
|
|
117
|
+
const d = await relay_hub_util_1.RelayHubUtil.seal(live.keys.seal, identity, live.record.member, body);
|
|
118
|
+
live.roster = body;
|
|
119
|
+
return { v: body.v, d };
|
|
120
|
+
}
|
|
121
|
+
async writeRoster(live, change) {
|
|
122
|
+
await this.ready(live);
|
|
123
|
+
this.request(live, { t: 'roster', roster: await this.nextRoster(live, change) });
|
|
124
|
+
}
|
|
125
|
+
connect(live) {
|
|
126
|
+
if (this.stopped) {
|
|
127
|
+
return;
|
|
128
|
+
}
|
|
129
|
+
const { record } = live;
|
|
130
|
+
const socket = new WebSocket(relay_pairing_1.RelayPairingUtil.websocketUrl(record.relay, relay_protocol_1.RELAY_HUB_PATH + record.id));
|
|
131
|
+
live.socket = socket;
|
|
132
|
+
live.synced = false;
|
|
133
|
+
socket.onopen = () => {
|
|
134
|
+
var _a;
|
|
135
|
+
live.attempts = 0;
|
|
136
|
+
void this.hello(live, socket);
|
|
137
|
+
live.pingTimer = setInterval(() => {
|
|
138
|
+
if (live.awaitingPong) {
|
|
139
|
+
socket.close(4408, 'The relay did not answer.');
|
|
140
|
+
return;
|
|
141
|
+
}
|
|
142
|
+
live.awaitingPong = true;
|
|
143
|
+
socket.send(relay_protocol_1.RELAY_PING);
|
|
144
|
+
}, (_a = this.options.pingMs) !== null && _a !== void 0 ? _a : relay_protocol_1.RELAY_PING_MS);
|
|
145
|
+
};
|
|
146
|
+
socket.onmessage = message => {
|
|
147
|
+
const text = String(message.data);
|
|
148
|
+
if (text === relay_protocol_1.RELAY_PONG) {
|
|
149
|
+
live.awaitingPong = false;
|
|
150
|
+
return;
|
|
151
|
+
}
|
|
152
|
+
live.chain = live.chain.then(() => this.receive(live, text)).catch(() => undefined);
|
|
153
|
+
};
|
|
154
|
+
socket.onerror = () => undefined;
|
|
155
|
+
socket.onclose = event => {
|
|
156
|
+
if (live.socket !== socket) {
|
|
157
|
+
return;
|
|
158
|
+
}
|
|
159
|
+
clearInterval(live.pingTimer);
|
|
160
|
+
live.socket = undefined;
|
|
161
|
+
live.synced = false;
|
|
162
|
+
live.awaitingPong = false;
|
|
163
|
+
live.online.clear();
|
|
164
|
+
void live.chain.then(() => this.closed(live, event.code));
|
|
165
|
+
};
|
|
166
|
+
}
|
|
167
|
+
async hello(live, socket) {
|
|
168
|
+
var _a;
|
|
169
|
+
const { record } = live;
|
|
170
|
+
let request;
|
|
171
|
+
if (record.status === 'waiting') {
|
|
172
|
+
request =
|
|
173
|
+
record.asked || !record.invite
|
|
174
|
+
? { t: 'wait', ask: record.member, token: record.token }
|
|
175
|
+
: {
|
|
176
|
+
t: 'ask',
|
|
177
|
+
ask: record.member,
|
|
178
|
+
token: record.token,
|
|
179
|
+
proof: await relay_hub_util_1.RelayHubUtil.inviteProof(record.invite),
|
|
180
|
+
d: await relay_hub_util_1.RelayHubUtil.sealAsk(record.invite, await this.identityOf(live), record.member, Date.now(), !!this.options.guest),
|
|
181
|
+
};
|
|
182
|
+
}
|
|
183
|
+
else {
|
|
184
|
+
(_a = live.keys) !== null && _a !== void 0 ? _a : (live.keys = await relay_hub_util_1.RelayHubUtil.keys(record.key));
|
|
185
|
+
request = { t: record.own && !record.made ? 'create' : 'auth', member: record.member, token: record.token };
|
|
186
|
+
}
|
|
187
|
+
if (socket.readyState === exports.OPEN) {
|
|
188
|
+
socket.send(JSON.stringify(request));
|
|
189
|
+
}
|
|
190
|
+
}
|
|
191
|
+
closed(live, code) {
|
|
192
|
+
var _a;
|
|
193
|
+
for (const resolve of live.done.values()) {
|
|
194
|
+
resolve({ ok: false, v: 0, error: 'gone' });
|
|
195
|
+
}
|
|
196
|
+
live.done.clear();
|
|
197
|
+
const { record } = live;
|
|
198
|
+
this.emit({ type: 'rooms' });
|
|
199
|
+
if (this.stopped || this.live.get(record.id) !== live) {
|
|
200
|
+
return;
|
|
201
|
+
}
|
|
202
|
+
if ((code === relay_hub_1.RelayHubCloseCode.ANSWERED || live.retry) && (record.status === 'member' || record.status === 'waiting')) {
|
|
203
|
+
live.retry = false;
|
|
204
|
+
this.connect(live);
|
|
205
|
+
return;
|
|
206
|
+
}
|
|
207
|
+
if (code === relay_hub_1.RelayHubCloseCode.REFUSED || code === relay_hub_1.RelayHubCloseCode.GONE || code === relay_hub_1.RelayHubCloseCode.REMOVED || code === relay_hub_1.RelayHubCloseCode.INVALID) {
|
|
208
|
+
return;
|
|
209
|
+
}
|
|
210
|
+
if (record.status !== 'member' && record.status !== 'waiting') {
|
|
211
|
+
return;
|
|
212
|
+
}
|
|
213
|
+
const delay = Math.min(((_a = this.options.reconnectDelayMs) !== null && _a !== void 0 ? _a : 1000) * 2 ** live.attempts, MAX_RECONNECT_MS);
|
|
214
|
+
live.attempts++;
|
|
215
|
+
clearTimeout(live.timer);
|
|
216
|
+
live.timer = setTimeout(() => this.connect(live), delay);
|
|
217
|
+
}
|
|
218
|
+
disconnect(live) {
|
|
219
|
+
clearTimeout(live.timer);
|
|
220
|
+
clearInterval(live.pingTimer);
|
|
221
|
+
const socket = live.socket;
|
|
222
|
+
live.socket = undefined;
|
|
223
|
+
socket === null || socket === void 0 ? void 0 : socket.close(1000, 'Bye.');
|
|
224
|
+
}
|
|
225
|
+
async receive(live, text) {
|
|
226
|
+
var _a;
|
|
227
|
+
var _b;
|
|
228
|
+
let event;
|
|
229
|
+
try {
|
|
230
|
+
event = JSON.parse(text);
|
|
231
|
+
}
|
|
232
|
+
catch (_c) {
|
|
233
|
+
return;
|
|
234
|
+
}
|
|
235
|
+
const { record } = live;
|
|
236
|
+
switch (event.t) {
|
|
237
|
+
case 'welcome': {
|
|
238
|
+
if (record.own && !record.made) {
|
|
239
|
+
record.made = true;
|
|
240
|
+
this.save();
|
|
241
|
+
}
|
|
242
|
+
live.online = new Set(event.online);
|
|
243
|
+
live.asks.clear();
|
|
244
|
+
if (event.roster) {
|
|
245
|
+
await this.readRoster(live, event.roster.d);
|
|
246
|
+
}
|
|
247
|
+
for (const ask of (_b = event.asks) !== null && _b !== void 0 ? _b : []) {
|
|
248
|
+
await this.asked(live, ask.d, false);
|
|
249
|
+
}
|
|
250
|
+
return;
|
|
251
|
+
}
|
|
252
|
+
case 'entries':
|
|
253
|
+
for (const entry of event.entries) {
|
|
254
|
+
await this.readEntry(live, entry, false);
|
|
255
|
+
}
|
|
256
|
+
return;
|
|
257
|
+
case 'synced':
|
|
258
|
+
live.synced = true;
|
|
259
|
+
for (const resolve of live.ready.splice(0)) {
|
|
260
|
+
resolve();
|
|
261
|
+
}
|
|
262
|
+
this.emit({ type: 'rooms' });
|
|
263
|
+
return;
|
|
264
|
+
case 'state':
|
|
265
|
+
await this.readEntry(live, event.entry, true);
|
|
266
|
+
return;
|
|
267
|
+
case 'msg':
|
|
268
|
+
await this.readMessage(live, event.from, event.d);
|
|
269
|
+
return;
|
|
270
|
+
case 'done':
|
|
271
|
+
(_a = live.done.get(event.id)) === null || _a === void 0 ? void 0 : _a({ ok: event.ok, v: event.v, error: event.error });
|
|
272
|
+
live.done.delete(event.id);
|
|
273
|
+
return;
|
|
274
|
+
case 'presence':
|
|
275
|
+
if (event.online) {
|
|
276
|
+
live.online.add(event.member);
|
|
277
|
+
}
|
|
278
|
+
else {
|
|
279
|
+
live.online.delete(event.member);
|
|
280
|
+
}
|
|
281
|
+
this.emit({ type: 'rooms' });
|
|
282
|
+
return;
|
|
283
|
+
case 'roster':
|
|
284
|
+
await this.readRoster(live, event.roster.d);
|
|
285
|
+
this.emit({ type: 'rooms' });
|
|
286
|
+
return;
|
|
287
|
+
case 'asked':
|
|
288
|
+
await this.asked(live, event.ask.d, true);
|
|
289
|
+
return;
|
|
290
|
+
case 'left':
|
|
291
|
+
live.online.delete(event.member);
|
|
292
|
+
if (record.own) {
|
|
293
|
+
await this.writeRoster(live, members => members.filter(member => member.member !== event.member)).catch(() => undefined);
|
|
294
|
+
}
|
|
295
|
+
this.emit({ type: 'rooms' });
|
|
296
|
+
return;
|
|
297
|
+
case 'waiting':
|
|
298
|
+
if (!record.asked) {
|
|
299
|
+
record.asked = true;
|
|
300
|
+
this.save();
|
|
301
|
+
}
|
|
302
|
+
this.emit({ type: 'rooms' });
|
|
303
|
+
return;
|
|
304
|
+
case 'admitted':
|
|
305
|
+
await this.admitted(live, event.answer);
|
|
306
|
+
return;
|
|
307
|
+
case 'refused':
|
|
308
|
+
this.setStatus(live, 'refused');
|
|
309
|
+
return;
|
|
310
|
+
case 'error':
|
|
311
|
+
this.failed(live, event.code);
|
|
312
|
+
return;
|
|
313
|
+
}
|
|
314
|
+
}
|
|
315
|
+
failed(live, code) {
|
|
316
|
+
const { record } = live;
|
|
317
|
+
if (code === 'gone') {
|
|
318
|
+
this.setStatus(live, 'gone', record.status === 'waiting' ? 'invite' : 'closed');
|
|
319
|
+
}
|
|
320
|
+
else if (code === 'auth' && record.status === 'member') {
|
|
321
|
+
this.setStatus(live, 'gone', 'removed');
|
|
322
|
+
}
|
|
323
|
+
else if (code === 'invite' || (code === 'exists' && record.status === 'waiting')) {
|
|
324
|
+
this.setStatus(live, 'gone', 'invite');
|
|
325
|
+
}
|
|
326
|
+
else if (code === 'exists' && record.own && !record.made) {
|
|
327
|
+
// Made before, its first answer not heard: it is this Ta's, to connect to as a member.
|
|
328
|
+
record.made = true;
|
|
329
|
+
live.retry = true;
|
|
330
|
+
this.save();
|
|
331
|
+
}
|
|
332
|
+
}
|
|
333
|
+
setStatus(live, status, reason) {
|
|
334
|
+
live.record = { ...live.record, status, ...(reason ? { reason } : {}) };
|
|
335
|
+
if (status !== 'member' && status !== 'waiting') {
|
|
336
|
+
delete live.record.key;
|
|
337
|
+
delete live.record.invite;
|
|
338
|
+
this.disconnect(live);
|
|
339
|
+
}
|
|
340
|
+
this.save();
|
|
341
|
+
this.emit({ type: 'rooms' });
|
|
342
|
+
}
|
|
343
|
+
async admitted(live, answer) {
|
|
344
|
+
const { record } = live;
|
|
345
|
+
const opened = record.invite
|
|
346
|
+
? await relay_hub_util_1.RelayHubUtil.openAnswer(await this.identityOf(live), record.id, record.member, record.owner.id, answer, record.invite)
|
|
347
|
+
: undefined;
|
|
348
|
+
if (!opened) {
|
|
349
|
+
// Not signed by the owner the link named: whoever answered, it is not that room.
|
|
350
|
+
this.setStatus(live, 'gone', 'invite');
|
|
351
|
+
return;
|
|
352
|
+
}
|
|
353
|
+
live.record = {
|
|
354
|
+
...record,
|
|
355
|
+
key: opened.body.key,
|
|
356
|
+
kind: relay_friends_1.RelayFriendsUtil.kindOf(String(opened.body.kind)),
|
|
357
|
+
title: String(opened.body.title).slice(0, 80),
|
|
358
|
+
...(opened.body.view ? { view: String(opened.body.view) } : {}),
|
|
359
|
+
...(opened.body.unlisted === true ? { unlisted: true } : {}),
|
|
360
|
+
owner: opened.owner,
|
|
361
|
+
status: 'member',
|
|
362
|
+
joinedAt: Date.now(),
|
|
363
|
+
};
|
|
364
|
+
delete live.record.invite;
|
|
365
|
+
delete live.record.asked;
|
|
366
|
+
live.keys = await relay_hub_util_1.RelayHubUtil.keys(opened.body.key);
|
|
367
|
+
this.save();
|
|
368
|
+
this.emit({ type: 'rooms' });
|
|
369
|
+
}
|
|
370
|
+
/** An ask to join: told as a request the first time this Ta hears it; `fresh` when it came now, not with the welcome. */
|
|
371
|
+
async asked(live, sealed, fresh) {
|
|
372
|
+
var _a;
|
|
373
|
+
for (const invite of [...((_a = live.record.invites) !== null && _a !== void 0 ? _a : [])].reverse()) {
|
|
374
|
+
const ask = await relay_hub_util_1.RelayHubUtil.openAsk(invite.secret, sealed);
|
|
375
|
+
if (ask) {
|
|
376
|
+
live.asks.set(ask.member, { body: ask, invite: invite.secret });
|
|
377
|
+
if (fresh || !this.told.has(ask.member)) {
|
|
378
|
+
this.told.add(ask.member);
|
|
379
|
+
this.heardAsk(live, ask);
|
|
380
|
+
}
|
|
381
|
+
return;
|
|
382
|
+
}
|
|
383
|
+
}
|
|
384
|
+
}
|
|
385
|
+
/** One asks to join a room of this Ta, heard the first time. */
|
|
386
|
+
heardAsk(live, ask) {
|
|
387
|
+
this.emit({ type: 'request', request: this.requestOf(live, ask, this.friendIds()) });
|
|
388
|
+
this.emit({ type: 'rooms' });
|
|
389
|
+
}
|
|
390
|
+
/** The members of a roster, read: those of them the user chose as friends are kept up to date. */
|
|
391
|
+
heardMembers(_members) { }
|
|
392
|
+
/** A member asks the user to be friends, by the link of its room of friends. */
|
|
393
|
+
offered(_live, _from, _link) { }
|
|
394
|
+
async readRoster(live, sealed) {
|
|
395
|
+
var _a;
|
|
396
|
+
const owner = live.record.owner;
|
|
397
|
+
const keys = (_a = live.keys) !== null && _a !== void 0 ? _a : (live.record.key ? await relay_hub_util_1.RelayHubUtil.keys(live.record.key) : undefined);
|
|
398
|
+
if (!keys || !owner.sign) {
|
|
399
|
+
return;
|
|
400
|
+
}
|
|
401
|
+
live.keys = keys;
|
|
402
|
+
// Signed by the owner alone: its member id is in the roster it signs.
|
|
403
|
+
let ownerMember;
|
|
404
|
+
const signed = await relay_hub_util_1.RelayHubUtil.open(keys.seal, sealed, member => {
|
|
405
|
+
ownerMember = member;
|
|
406
|
+
return owner.sign;
|
|
407
|
+
});
|
|
408
|
+
if (!signed || !Array.isArray(signed.b.members) || (live.roster && signed.b.v < live.roster.v)) {
|
|
409
|
+
return;
|
|
410
|
+
}
|
|
411
|
+
const members = signed.b.members.filter(member => member && typeof member.member === 'string');
|
|
412
|
+
if (!members.some(member => member.owner && member.member === ownerMember && member.id === owner.id)) {
|
|
413
|
+
return;
|
|
414
|
+
}
|
|
415
|
+
live.roster = { v: signed.b.v, members };
|
|
416
|
+
const own = (await this.identityOf(live)).id;
|
|
417
|
+
this.heardMembers(members.filter(member => member.id !== own && !member.guest));
|
|
418
|
+
if (!members.some(member => member.member === live.record.member) && !live.record.own && live.record.status === 'member') {
|
|
419
|
+
this.setStatus(live, 'gone', 'removed');
|
|
420
|
+
}
|
|
421
|
+
}
|
|
422
|
+
guestOf(live, member) {
|
|
423
|
+
var _a, _b;
|
|
424
|
+
return !!((_b = (_a = live.roster) === null || _a === void 0 ? void 0 : _a.members.find(other => other.member === member)) === null || _b === void 0 ? void 0 : _b.guest);
|
|
425
|
+
}
|
|
426
|
+
signOf(live) {
|
|
427
|
+
return member => { var _a, _b; return (_b = (_a = live.roster) === null || _a === void 0 ? void 0 : _a.members.find(other => other.member === member)) === null || _b === void 0 ? void 0 : _b.sign; };
|
|
428
|
+
}
|
|
429
|
+
async readEntry(live, entry, tell) {
|
|
430
|
+
var _a, _b;
|
|
431
|
+
if (!live.keys) {
|
|
432
|
+
return;
|
|
433
|
+
}
|
|
434
|
+
const signed = await relay_hub_util_1.RelayHubUtil.open(live.keys.seal, entry.d, this.signOf(live));
|
|
435
|
+
if (!signed || signed.m !== entry.by || typeof signed.b.key !== 'string' || (await relay_hub_util_1.RelayHubUtil.keyId(live.keys, signed.b.key)) !== entry.k) {
|
|
436
|
+
return;
|
|
437
|
+
}
|
|
438
|
+
const before = live.state.get(signed.b.key);
|
|
439
|
+
if (before && before.version >= entry.v) {
|
|
440
|
+
return;
|
|
441
|
+
}
|
|
442
|
+
if (this.guestOf(live, entry.by) && !signed.b.key.startsWith(relay_room_chat_1.RELAY_CHAT_KEY)) {
|
|
443
|
+
// A guest only chats: what else it set is not taken, its version kept, so that setting it again goes on that.
|
|
444
|
+
live.state.set(signed.b.key, { value: (_a = before === null || before === void 0 ? void 0 : before.value) !== null && _a !== void 0 ? _a : null, version: entry.v, by: (_b = before === null || before === void 0 ? void 0 : before.by) !== null && _b !== void 0 ? _b : entry.by });
|
|
445
|
+
return;
|
|
446
|
+
}
|
|
447
|
+
live.state.set(signed.b.key, { value: signed.b.value, version: entry.v, by: entry.by });
|
|
448
|
+
if (tell) {
|
|
449
|
+
this.emit({ type: 'state', room: live.record.id, key: signed.b.key, value: signed.b.value, version: entry.v, by: entry.by });
|
|
450
|
+
}
|
|
451
|
+
}
|
|
452
|
+
async readMessage(live, from, sealed) {
|
|
453
|
+
var _a;
|
|
454
|
+
var _b;
|
|
455
|
+
if (!live.keys) {
|
|
456
|
+
return;
|
|
457
|
+
}
|
|
458
|
+
const signed = await relay_hub_util_1.RelayHubUtil.open(live.keys.seal, sealed, this.signOf(live), { skewMs: SKEW_MS });
|
|
459
|
+
if (!signed || signed.m !== from) {
|
|
460
|
+
return;
|
|
461
|
+
}
|
|
462
|
+
const sender = (_a = live.roster) === null || _a === void 0 ? void 0 : _a.members.find(member => member.member === from);
|
|
463
|
+
if ((sender === null || sender === void 0 ? void 0 : sender.guest) && typeof signed.b.name !== 'string') {
|
|
464
|
+
// A guest only chats, in the state: the messages of games are not its.
|
|
465
|
+
return;
|
|
466
|
+
}
|
|
467
|
+
if (typeof signed.b.friend === 'string') {
|
|
468
|
+
if (sender && !sender.guest) {
|
|
469
|
+
this.offered(live, sender, signed.b.friend);
|
|
470
|
+
}
|
|
471
|
+
return;
|
|
472
|
+
}
|
|
473
|
+
if (typeof signed.b.name === 'string') {
|
|
474
|
+
if (live.record.own && sender) {
|
|
475
|
+
const name = signed.b.name.trim().slice(0, 40);
|
|
476
|
+
await this.writeRoster(live, members => members.map(member => (member.member === from ? { ...member, name } : member))).catch(() => undefined);
|
|
477
|
+
}
|
|
478
|
+
return;
|
|
479
|
+
}
|
|
480
|
+
this.emit({ type: 'message', room: live.record.id, from, name: (_b = sender === null || sender === void 0 ? void 0 : sender.name) !== null && _b !== void 0 ? _b : '', data: signed.b.d });
|
|
481
|
+
}
|
|
482
|
+
/** Ids of those the user chose as friends. */
|
|
483
|
+
friendIds() {
|
|
484
|
+
return new Set();
|
|
485
|
+
}
|
|
486
|
+
readRooms() {
|
|
487
|
+
var _a;
|
|
488
|
+
const rooms = (_a = this.options.store.read('rooms')) === null || _a === void 0 ? void 0 : _a.rooms;
|
|
489
|
+
return Array.isArray(rooms) ? rooms : [];
|
|
490
|
+
}
|
|
491
|
+
save() {
|
|
492
|
+
this.options.store.write('rooms', { rooms: [...this.live.values()].map(live => live.record) });
|
|
493
|
+
}
|
|
494
|
+
/** To the listeners, then what follows from it (RelayHubs: the friends settle). */
|
|
495
|
+
emit(event) {
|
|
496
|
+
this.notify(event);
|
|
497
|
+
this.after(event);
|
|
498
|
+
}
|
|
499
|
+
after(_event) { }
|
|
500
|
+
/** To the listeners alone. */
|
|
501
|
+
notify(event) {
|
|
502
|
+
for (const listener of this.listeners) {
|
|
503
|
+
try {
|
|
504
|
+
listener(event);
|
|
505
|
+
}
|
|
506
|
+
catch (_a) {
|
|
507
|
+
// A listener's failure is its own.
|
|
508
|
+
}
|
|
509
|
+
}
|
|
510
|
+
}
|
|
511
|
+
}
|
|
512
|
+
exports.RelayHubsConnection = RelayHubsConnection;
|
|
513
|
+
//# sourceMappingURL=relay-hubs-connection.js.map
|
|
@@ -0,0 +1,175 @@
|
|
|
1
|
+
import type { RelayIdentity, RelayPublicIdentity } from './relay-identity';
|
|
2
|
+
/** `member` in the room; `waiting` for the owner to answer; `refused` by the owner; `gone`: closed, removed, or the invitation no longer works. */
|
|
3
|
+
export type RelayRoomStatus = 'member' | 'waiting' | 'refused' | 'gone';
|
|
4
|
+
/** A room this Ta is in or asked to join, in `rooms.json` of the agent directory (docs/design/ta-link.md 3.5). */
|
|
5
|
+
export interface RelayRoomRecord {
|
|
6
|
+
id: string;
|
|
7
|
+
relay: string;
|
|
8
|
+
kind: string;
|
|
9
|
+
title: string;
|
|
10
|
+
view?: string;
|
|
11
|
+
unlisted?: true;
|
|
12
|
+
/** This Ta's id in the room, and what the relay knows it by. */
|
|
13
|
+
member: string;
|
|
14
|
+
token: string;
|
|
15
|
+
/** base64url, 32 bytes: the key of the room, once admitted. */
|
|
16
|
+
key?: string;
|
|
17
|
+
/** The owner: all of it once admitted (its keys check the roster), its id and name from the link before. */
|
|
18
|
+
owner: Pick<RelayPublicIdentity, 'id' | 'name'> & Partial<RelayPublicIdentity>;
|
|
19
|
+
/** This Ta made the room. */
|
|
20
|
+
own: boolean;
|
|
21
|
+
status: RelayRoomStatus;
|
|
22
|
+
/** Why it is `gone`: `closed` by the owner, `removed` by the owner, the `invite` no longer works. */
|
|
23
|
+
reason?: 'closed' | 'removed' | 'invite';
|
|
24
|
+
/** Of the owner: the invitations of late, the latest last; an ask is sealed with one of them. */
|
|
25
|
+
invites?: {
|
|
26
|
+
secret: string;
|
|
27
|
+
expiresAt: number;
|
|
28
|
+
}[];
|
|
29
|
+
/** Of the owner: the relay has the room. */
|
|
30
|
+
made?: boolean;
|
|
31
|
+
/** Of one asking: the invitation, till the relay has the ask. */
|
|
32
|
+
invite?: string;
|
|
33
|
+
asked?: boolean;
|
|
34
|
+
createdAt: number;
|
|
35
|
+
joinedAt?: number;
|
|
36
|
+
/**
|
|
37
|
+
* The identity this Ta is in the room when it is not the one of identity.json: the one it joined with, kept when
|
|
38
|
+
* this Ta took on the identity of the user's other computer (RelayHubs.importIdentity).
|
|
39
|
+
*/
|
|
40
|
+
identity?: RelayIdentity;
|
|
41
|
+
}
|
|
42
|
+
/** What makes a Ta who it is in rooms, private keys and all: for the user's own computers alone (a move, a shared identity). */
|
|
43
|
+
export interface RelayIdentityBundle {
|
|
44
|
+
identity: RelayIdentity;
|
|
45
|
+
rooms: RelayRoomRecord[];
|
|
46
|
+
friends: RelayFriend[];
|
|
47
|
+
}
|
|
48
|
+
/** What {@link RelayIdentityBundle} did here: whether this Ta took on another identity, the rooms and friends it got. */
|
|
49
|
+
export interface RelayIdentityImport {
|
|
50
|
+
switched: boolean;
|
|
51
|
+
rooms: number;
|
|
52
|
+
friends: number;
|
|
53
|
+
}
|
|
54
|
+
export interface RelayRoomMember {
|
|
55
|
+
member: string;
|
|
56
|
+
/** The identity of its Ta. */
|
|
57
|
+
id: string;
|
|
58
|
+
name: string;
|
|
59
|
+
owner: boolean;
|
|
60
|
+
online: boolean;
|
|
61
|
+
self: boolean;
|
|
62
|
+
/** In a browser, without Ta: it only chats (docs/design/ta-link.md 3.8). */
|
|
63
|
+
guest?: boolean;
|
|
64
|
+
}
|
|
65
|
+
export interface RelayRoomInfo {
|
|
66
|
+
id: string;
|
|
67
|
+
kind: string;
|
|
68
|
+
title: string;
|
|
69
|
+
view?: string;
|
|
70
|
+
unlisted?: true;
|
|
71
|
+
/** The relay it is on. */
|
|
72
|
+
relay: string;
|
|
73
|
+
owner: boolean;
|
|
74
|
+
ownerName: string;
|
|
75
|
+
status: RelayRoomStatus;
|
|
76
|
+
reason?: RelayRoomRecord['reason'];
|
|
77
|
+
/** This Ta is connected to the room now. */
|
|
78
|
+
connected: boolean;
|
|
79
|
+
members: RelayRoomMember[];
|
|
80
|
+
createdAt: number;
|
|
81
|
+
joinedAt?: number;
|
|
82
|
+
}
|
|
83
|
+
/** One asking to join a room this Ta owns, till the user answers. */
|
|
84
|
+
export interface RelayRoomRequest {
|
|
85
|
+
room: string;
|
|
86
|
+
title: string;
|
|
87
|
+
ask: string;
|
|
88
|
+
/** Its identity, and the name it gives. */
|
|
89
|
+
id: string;
|
|
90
|
+
name: string;
|
|
91
|
+
/** Met before, in another room. */
|
|
92
|
+
friend: boolean;
|
|
93
|
+
/** Asks from a browser, without Ta: admitted, it only chats. */
|
|
94
|
+
guest?: boolean;
|
|
95
|
+
at: number;
|
|
96
|
+
}
|
|
97
|
+
/**
|
|
98
|
+
* One the user chose as a friend (docs/design/ta-link.md 3.1), in `friends.json`: its keys once known (from its link
|
|
99
|
+
* only its id and name), when chosen and last heard of.
|
|
100
|
+
*/
|
|
101
|
+
export interface RelayFriend extends Pick<RelayPublicIdentity, 'id' | 'name'>, Partial<Pick<RelayPublicIdentity, 'sign' | 'box'>> {
|
|
102
|
+
metAt: number;
|
|
103
|
+
seenAt: number;
|
|
104
|
+
}
|
|
105
|
+
/** A friend as the pages show it: `friend` once each is in the room of the other, `adding` till then. */
|
|
106
|
+
export interface RelayFriendInfo {
|
|
107
|
+
id: string;
|
|
108
|
+
name: string;
|
|
109
|
+
status: 'friend' | 'adding';
|
|
110
|
+
online: boolean;
|
|
111
|
+
metAt: number;
|
|
112
|
+
seenAt: number;
|
|
113
|
+
}
|
|
114
|
+
/** One asking the user to be friends: by the link of the user's room of friends, or in a room the two share (its title). */
|
|
115
|
+
export interface RelayFriendRequest {
|
|
116
|
+
id: string;
|
|
117
|
+
name: string;
|
|
118
|
+
at: number;
|
|
119
|
+
via: 'link' | 'room';
|
|
120
|
+
room?: string;
|
|
121
|
+
}
|
|
122
|
+
export interface RelayRoomValue {
|
|
123
|
+
value: unknown;
|
|
124
|
+
version: number;
|
|
125
|
+
/** The member who wrote it last. */
|
|
126
|
+
by: string;
|
|
127
|
+
}
|
|
128
|
+
export type RelayRoomEvent = {
|
|
129
|
+
type: 'rooms';
|
|
130
|
+
} | {
|
|
131
|
+
type: 'request';
|
|
132
|
+
request: RelayRoomRequest;
|
|
133
|
+
}
|
|
134
|
+
/** One asks the user to be friends. */
|
|
135
|
+
| {
|
|
136
|
+
type: 'friend';
|
|
137
|
+
request: RelayFriendRequest;
|
|
138
|
+
} | {
|
|
139
|
+
type: 'message';
|
|
140
|
+
room: string;
|
|
141
|
+
from: string;
|
|
142
|
+
name: string;
|
|
143
|
+
data: unknown;
|
|
144
|
+
} | {
|
|
145
|
+
type: 'state';
|
|
146
|
+
room: string;
|
|
147
|
+
key: string;
|
|
148
|
+
value: unknown;
|
|
149
|
+
version: number;
|
|
150
|
+
by: string;
|
|
151
|
+
};
|
|
152
|
+
/** Where a {@link RelayHubs} keeps what it knows: files of the agent directory for Ta, the storage of a browser for a guest. */
|
|
153
|
+
export interface RelayHubsStore {
|
|
154
|
+
read<T>(name: RelayHubsStoreName): T | undefined;
|
|
155
|
+
/** Holds keys: kept where the user alone reads it. */
|
|
156
|
+
write(name: RelayHubsStoreName, value: unknown): void;
|
|
157
|
+
}
|
|
158
|
+
/** The identity, the rooms (with their keys) and the friends. */
|
|
159
|
+
export type RelayHubsStoreName = 'identity' | 'rooms' | 'friends';
|
|
160
|
+
export interface RelayHubsOptions {
|
|
161
|
+
store: RelayHubsStore;
|
|
162
|
+
/** The name of a new identity: that of the user on the system. */
|
|
163
|
+
name?(): string;
|
|
164
|
+
/**
|
|
165
|
+
* A guest of rooms in a browser (docs/design/ta-link.md 3.8): its asks say so, its owner admits it as one, and the
|
|
166
|
+
* others hear only what it says (`chat:` of the state), not its messages or the rest of the state.
|
|
167
|
+
*/
|
|
168
|
+
guest?: boolean;
|
|
169
|
+
/** The relay new rooms are made on; `use` the feature a room is for (relays.json), `rooms` when none is said. */
|
|
170
|
+
relay(use?: string): string;
|
|
171
|
+
/** First wait before connecting again; it doubles up to 30 seconds. */
|
|
172
|
+
reconnectDelayMs?: number;
|
|
173
|
+
pingMs?: number;
|
|
174
|
+
}
|
|
175
|
+
//# sourceMappingURL=relay-hubs-protocol.d.ts.map
|