tryharness 0.7.45 → 0.7.53
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.md +232 -12
- package/cli.mjs +406 -184
- package/lib/actorRoster.mjs +28 -5
- package/lib/adapters.mjs +9 -1
- package/lib/agentRuntimeConfig.mjs +36 -0
- package/lib/agentRuntimes.mjs +560 -0
- package/lib/atlas.mjs +7 -2
- package/lib/boardCommands.mjs +5 -10
- package/lib/boardFileCommands.mjs +2 -1
- package/lib/boardMirror.mjs +459 -0
- package/lib/boardProtocol.json +206 -6
- package/lib/boardTools.mjs +2 -6
- package/lib/bridge.mjs +25 -3
- package/lib/browserWake.mjs +60 -0
- package/lib/cards.mjs +35 -2
- package/lib/commands.mjs +20 -5
- package/lib/connectionTools.d.ts +13 -0
- package/lib/connectionTools.js +45 -0
- package/lib/connectorAuth.mjs +309 -0
- package/lib/connectorCatalog.json +41 -0
- package/lib/connectorCommands.mjs +121 -0
- package/lib/connectorGoogle.mjs +513 -0
- package/lib/connectors.mjs +805 -0
- package/lib/coordinator.mjs +8 -1
- package/lib/coreModels.mjs +78 -0
- package/lib/daemon.mjs +643 -45
- package/lib/desktop.mjs +7 -2
- package/lib/digest.mjs +32 -0
- package/lib/directLink.mjs +283 -0
- package/lib/environments.mjs +595 -0
- package/lib/folders.mjs +2 -2
- package/lib/goalCommands.mjs +58 -14
- package/lib/inference.mjs +263 -152
- package/lib/lessons.mjs +6 -0
- package/lib/lineup.mjs +324 -0
- package/lib/localmodels.mjs +10 -0
- package/lib/machineIdentity.mjs +3 -0
- package/lib/machineRoutes.mjs +40 -2
- package/lib/machineRuns.mjs +30 -3
- package/lib/machineSeal.mjs +69 -10
- package/lib/mcp-stdio.mjs +121 -118
- package/lib/mcpRelay.mjs +119 -0
- package/lib/members.json +12 -0
- package/lib/members.mjs +33 -0
- package/lib/modelMemory.mjs +100 -0
- package/lib/modelTiers.json +1183 -0
- package/lib/modelTiers.mjs +133 -0
- package/lib/models.mjs +41 -8
- package/lib/museSession.mjs +119 -0
- package/lib/nativeHost.mjs +203 -0
- package/lib/network.mjs +7 -2
- package/lib/nudge.mjs +10 -2
- package/lib/onboard.mjs +430 -1
- package/lib/oneclawLocal.mjs +150 -0
- package/lib/ownMachines.mjs +521 -36
- package/lib/pairing.mjs +165 -0
- package/lib/paths.mjs +4 -0
- package/lib/phones.mjs +61 -0
- package/lib/placeCommands.mjs +27 -0
- package/lib/places.mjs +10 -2
- package/lib/plans.mjs +151 -27
- package/lib/profile.mjs +152 -0
- package/lib/projects.mjs +624 -137
- package/lib/readiness.mjs +283 -0
- package/lib/repoLinks.mjs +354 -0
- package/lib/roomChannels.mjs +641 -0
- package/lib/runBrief.mjs +32 -2
- package/lib/runRequests.mjs +157 -0
- package/lib/runWorker.mjs +20 -7
- package/lib/runner.mjs +67 -8
- package/lib/secretPatterns.json +55 -0
- package/lib/secrets.mjs +10 -27
- package/lib/seen.mjs +102 -0
- package/lib/service.mjs +11 -6
- package/lib/sessionControl.mjs +10 -8
- package/lib/sessionIndex.mjs +5 -3
- package/lib/store.mjs +546 -29
- package/lib/subagents.mjs +8 -4
- package/lib/swarm.mjs +367 -37
- package/lib/swarmMemory.mjs +947 -0
- package/lib/t3.mjs +43 -13
- package/lib/taskCommands.mjs +56 -5
- package/lib/taskRuns.mjs +61 -11
- package/lib/team.json +17 -15
- package/lib/team.mjs +68 -18
- package/lib/threadRuns.mjs +3 -1
- package/lib/threadView.mjs +51 -14
- package/lib/tokenizer.mjs +405 -0
- package/lib/ui.mjs +16 -2
- package/lib/usageTotals.mjs +148 -0
- package/lib/vault.mjs +1144 -0
- package/lib/vaultCloud.mjs +117 -0
- package/lib/vaultCommands.mjs +201 -0
- package/lib/vaultTools.d.ts +12 -0
- package/lib/vaultTools.js +42 -0
- package/lib/windowAsks.mjs +42 -0
- package/lib/workFocus.mjs +59 -0
- package/lib/workLinks.mjs +90 -0
- package/package.json +9 -4
|
@@ -0,0 +1,641 @@
|
|
|
1
|
+
import { createHash, randomUUID } from "node:crypto";
|
|
2
|
+
|
|
3
|
+
// Membership and authenticated delivery for a shared room. Each pair uses the
|
|
4
|
+
// existing sealed relay; a participant's computer receives their words directly
|
|
5
|
+
// from them. The creator administers membership, but is not a message router.
|
|
6
|
+
// Projects supply the shared record and repository behaviour over this seam.
|
|
7
|
+
const HANDLE = /^[a-z0-9][a-z0-9-]{2,19}$/;
|
|
8
|
+
const UUID = /^[0-9a-f-]{36}$/;
|
|
9
|
+
const STATES = new Set(["invited", "joined", "left", "removed"]);
|
|
10
|
+
const AGENT = /^[a-z0-9][a-z0-9._-]{0,63}$/;
|
|
11
|
+
const parse = (text) => JSON.parse(text);
|
|
12
|
+
export const agreementHash = (body) =>
|
|
13
|
+
createHash("sha256").update(JSON.stringify(body)).digest("hex");
|
|
14
|
+
const consentHashes = (value) =>
|
|
15
|
+
Object.fromEntries(
|
|
16
|
+
Object.entries(value && typeof value === "object" ? value : {}).filter(
|
|
17
|
+
([id, hash]) =>
|
|
18
|
+
UUID.test(id) && typeof hash === "string" && /^[0-9a-f]{64}$/.test(hash)
|
|
19
|
+
)
|
|
20
|
+
);
|
|
21
|
+
|
|
22
|
+
export function createRoomChannels({
|
|
23
|
+
store,
|
|
24
|
+
request,
|
|
25
|
+
decide,
|
|
26
|
+
invites,
|
|
27
|
+
sentInvites = async () => [],
|
|
28
|
+
send,
|
|
29
|
+
end,
|
|
30
|
+
ownAgents,
|
|
31
|
+
details = () => ({}),
|
|
32
|
+
onOpen,
|
|
33
|
+
onChange,
|
|
34
|
+
onEvent,
|
|
35
|
+
log = () => {},
|
|
36
|
+
}) {
|
|
37
|
+
const db = store.db;
|
|
38
|
+
db.exec(`
|
|
39
|
+
create table if not exists shared_rooms (
|
|
40
|
+
id text primary key, record text not null
|
|
41
|
+
);
|
|
42
|
+
create table if not exists shared_room_channels (
|
|
43
|
+
id text primary key, room_id text not null, peer text not null,
|
|
44
|
+
state text not null, unique(room_id, peer)
|
|
45
|
+
);
|
|
46
|
+
`);
|
|
47
|
+
const all = (sql, ...values) =>
|
|
48
|
+
db.all(sql, values.length ? values : undefined);
|
|
49
|
+
const run = (sql, ...values) =>
|
|
50
|
+
db.run(sql, values.length ? values : undefined);
|
|
51
|
+
const read = (id) => {
|
|
52
|
+
const row = all(
|
|
53
|
+
"select record from shared_rooms where id = ?",
|
|
54
|
+
String(id)
|
|
55
|
+
)[0];
|
|
56
|
+
return row ? parse(row.record) : null;
|
|
57
|
+
};
|
|
58
|
+
const rooms = () =>
|
|
59
|
+
all("select record from shared_rooms").map((row) => parse(row.record));
|
|
60
|
+
const channel = (id) =>
|
|
61
|
+
all("select * from shared_room_channels where id = ?", String(id))[0] ??
|
|
62
|
+
null;
|
|
63
|
+
const routes = (id) =>
|
|
64
|
+
all("select * from shared_room_channels where room_id = ?", String(id));
|
|
65
|
+
const active = (room) =>
|
|
66
|
+
room.members.filter((member) => member.status === "joined");
|
|
67
|
+
const own = (room) =>
|
|
68
|
+
room.members.find((member) => member.handle === room.me);
|
|
69
|
+
const joined = (room) => own(room)?.status === "joined";
|
|
70
|
+
const write = (room) => {
|
|
71
|
+
run(
|
|
72
|
+
"insert into shared_rooms(id, record) values(?, ?) on conflict(id) do update set record = excluded.record",
|
|
73
|
+
room.id,
|
|
74
|
+
JSON.stringify(room)
|
|
75
|
+
);
|
|
76
|
+
return room;
|
|
77
|
+
};
|
|
78
|
+
const forget = (route) => {
|
|
79
|
+
store.meta(`shared-room-channel:${route.id}`, route.room_id);
|
|
80
|
+
run("delete from shared_room_channels where id = ?", route.id);
|
|
81
|
+
};
|
|
82
|
+
const save = (room, update) => write({ ...read(room.id), ...update });
|
|
83
|
+
const bind = (id, roomId, peer, state = "joining") =>
|
|
84
|
+
run(
|
|
85
|
+
"insert into shared_room_channels(id, room_id, peer, state) values(?, ?, ?, ?) on conflict(room_id, peer) do update set id = excluded.id, state = excluded.state",
|
|
86
|
+
id,
|
|
87
|
+
roomId,
|
|
88
|
+
peer,
|
|
89
|
+
state
|
|
90
|
+
);
|
|
91
|
+
const members = (id) => read(id)?.members ?? [];
|
|
92
|
+
const recipients = (id) => {
|
|
93
|
+
const room = read(id);
|
|
94
|
+
if (!room || !joined(room)) return [];
|
|
95
|
+
const permitted = new Set(active(room).map((member) => member.handle));
|
|
96
|
+
return routes(id).filter(
|
|
97
|
+
(route) => route.state === "open" && permitted.has(route.peer)
|
|
98
|
+
);
|
|
99
|
+
};
|
|
100
|
+
const snapshot = (room) => ({
|
|
101
|
+
type: "membership",
|
|
102
|
+
owner: room.owner,
|
|
103
|
+
revision: room.revision,
|
|
104
|
+
members: room.members,
|
|
105
|
+
});
|
|
106
|
+
const publish = (room, peers = null) => send(room.id, snapshot(room), peers);
|
|
107
|
+
const notify = (before, after) => onChange?.(after.id, before, after);
|
|
108
|
+
const checkedMembers = (value) => {
|
|
109
|
+
if (!Array.isArray(value) || !value.length)
|
|
110
|
+
throw new Error("The room has no membership list.");
|
|
111
|
+
const seen = new Set();
|
|
112
|
+
return value.map((member) => {
|
|
113
|
+
if (
|
|
114
|
+
!member ||
|
|
115
|
+
!HANDLE.test(member.handle) ||
|
|
116
|
+
!STATES.has(member.status) ||
|
|
117
|
+
seen.has(member.handle)
|
|
118
|
+
)
|
|
119
|
+
throw new Error("The room's membership list is invalid.");
|
|
120
|
+
seen.add(member.handle);
|
|
121
|
+
return {
|
|
122
|
+
handle: member.handle,
|
|
123
|
+
status: member.status,
|
|
124
|
+
generation:
|
|
125
|
+
Number.isSafeInteger(member.generation) && member.generation > 0
|
|
126
|
+
? member.generation
|
|
127
|
+
: 1,
|
|
128
|
+
};
|
|
129
|
+
});
|
|
130
|
+
};
|
|
131
|
+
const knownAgents = (agents) => [
|
|
132
|
+
...new Set(
|
|
133
|
+
(Array.isArray(agents) ? agents : []).filter(
|
|
134
|
+
(id) => typeof id === "string" && AGENT.test(id)
|
|
135
|
+
)
|
|
136
|
+
),
|
|
137
|
+
];
|
|
138
|
+
const peersFor = (id) => {
|
|
139
|
+
const room = read(id);
|
|
140
|
+
return room
|
|
141
|
+
? active(room)
|
|
142
|
+
.filter((member) => member.handle !== room.me)
|
|
143
|
+
.map((member) => member.handle)
|
|
144
|
+
: [];
|
|
145
|
+
};
|
|
146
|
+
|
|
147
|
+
const init = ({ id = randomUUID(), me, title, repo, settings, agents }) => {
|
|
148
|
+
if (
|
|
149
|
+
agents &&
|
|
150
|
+
(!Array.isArray(agents) ||
|
|
151
|
+
agents.some((agent) => !ownAgents().includes(agent)))
|
|
152
|
+
)
|
|
153
|
+
throw new Error("Choose agents available on this computer.");
|
|
154
|
+
const room = {
|
|
155
|
+
id,
|
|
156
|
+
me,
|
|
157
|
+
owner: me,
|
|
158
|
+
title,
|
|
159
|
+
repo,
|
|
160
|
+
settings,
|
|
161
|
+
revision: 1,
|
|
162
|
+
history: "shared",
|
|
163
|
+
agents: knownAgents(agents ?? ownAgents()),
|
|
164
|
+
members: [{ handle: me, status: "joined", generation: 1 }],
|
|
165
|
+
rosters: {},
|
|
166
|
+
consents: {},
|
|
167
|
+
errors: {},
|
|
168
|
+
};
|
|
169
|
+
return write(room);
|
|
170
|
+
};
|
|
171
|
+
const offer = (room, to, purpose = "invite") => ({
|
|
172
|
+
v: 2,
|
|
173
|
+
id: room.id,
|
|
174
|
+
owner: room.owner,
|
|
175
|
+
revision: room.revision,
|
|
176
|
+
title: room.title,
|
|
177
|
+
from: room.me,
|
|
178
|
+
to,
|
|
179
|
+
purpose,
|
|
180
|
+
repo: room.repo,
|
|
181
|
+
settings: room.settings,
|
|
182
|
+
history: room.history,
|
|
183
|
+
members: room.members,
|
|
184
|
+
...details(room.id),
|
|
185
|
+
});
|
|
186
|
+
const sending = new Set();
|
|
187
|
+
const connect = async (id, peer, purpose) => {
|
|
188
|
+
const key = `${id}:${peer}`;
|
|
189
|
+
if (sending.has(key)) return;
|
|
190
|
+
sending.add(key);
|
|
191
|
+
try {
|
|
192
|
+
const room = read(id);
|
|
193
|
+
const sent = await request({
|
|
194
|
+
to: `${peer}/person`,
|
|
195
|
+
fromAgent: "person",
|
|
196
|
+
about: `Room: ${room.title}`,
|
|
197
|
+
brief: `${room.me} invited you to a shared room in Harness.`,
|
|
198
|
+
refs: [],
|
|
199
|
+
project: offer(room, peer, purpose),
|
|
200
|
+
});
|
|
201
|
+
if (!sent.sealed)
|
|
202
|
+
throw new Error("Shared rooms need an encrypted connection.");
|
|
203
|
+
bind(String(sent.threadId), id, peer, "invited");
|
|
204
|
+
// Acceptance can reach the daemon before the request call returns. The
|
|
205
|
+
// existing local thread proves it opened even if its callback ran early.
|
|
206
|
+
if (store.getThread(String(sent.threadId))) opened(String(sent.threadId));
|
|
207
|
+
const fresh = read(id);
|
|
208
|
+
save(fresh, { errors: { ...fresh.errors, [peer]: null } });
|
|
209
|
+
} catch (error) {
|
|
210
|
+
const room = read(id);
|
|
211
|
+
save(room, { errors: { ...room.errors, [peer]: error.message } });
|
|
212
|
+
log(`room ${id}, ${peer}: ${error.message}`);
|
|
213
|
+
throw error;
|
|
214
|
+
} finally {
|
|
215
|
+
sending.delete(key);
|
|
216
|
+
}
|
|
217
|
+
};
|
|
218
|
+
const invite = async (id, handles) => {
|
|
219
|
+
let room = read(id);
|
|
220
|
+
if (!room || !joined(room) || room.owner !== room.me)
|
|
221
|
+
throw new Error("Only the room's creator can invite people.");
|
|
222
|
+
const chosen = [
|
|
223
|
+
...new Set(
|
|
224
|
+
handles.map((handle) =>
|
|
225
|
+
String(handle).trim().toLowerCase().replace(/^@/, "")
|
|
226
|
+
)
|
|
227
|
+
),
|
|
228
|
+
];
|
|
229
|
+
if (!chosen.length || chosen.some((handle) => !HANDLE.test(handle)))
|
|
230
|
+
throw new Error("Write each person's swarm name, separated by commas.");
|
|
231
|
+
if (chosen.includes(room.me))
|
|
232
|
+
throw new Error("That's your own swarm's name.");
|
|
233
|
+
if (
|
|
234
|
+
chosen.some((handle) =>
|
|
235
|
+
room.members.some(
|
|
236
|
+
(member) =>
|
|
237
|
+
member.handle === handle &&
|
|
238
|
+
["invited", "joined"].includes(member.status)
|
|
239
|
+
)
|
|
240
|
+
)
|
|
241
|
+
)
|
|
242
|
+
throw new Error("That person is already in this room or invited.");
|
|
243
|
+
const before = room;
|
|
244
|
+
const nextMembers = room.members.filter(
|
|
245
|
+
(member) => !chosen.includes(member.handle)
|
|
246
|
+
);
|
|
247
|
+
for (const handle of chosen) {
|
|
248
|
+
const previous = room.members.find((member) => member.handle === handle);
|
|
249
|
+
nextMembers.push({
|
|
250
|
+
handle,
|
|
251
|
+
status: "invited",
|
|
252
|
+
generation: (previous?.generation ?? 0) + 1,
|
|
253
|
+
});
|
|
254
|
+
for (const route of routes(id).filter((entry) => entry.peer === handle)) {
|
|
255
|
+
end(route.id, "A new room invitation replaces this participation.");
|
|
256
|
+
forget(route);
|
|
257
|
+
}
|
|
258
|
+
}
|
|
259
|
+
room = save(room, {
|
|
260
|
+
revision: room.revision + 1,
|
|
261
|
+
members: nextMembers,
|
|
262
|
+
});
|
|
263
|
+
publish(room);
|
|
264
|
+
notify(before, room);
|
|
265
|
+
// Each result is retained. A failed invitation never repeats automatically.
|
|
266
|
+
for (const handle of chosen)
|
|
267
|
+
await connect(id, handle, "invite").catch(() => undefined);
|
|
268
|
+
return read(id);
|
|
269
|
+
};
|
|
270
|
+
const validateInvite = (invitation, me) => {
|
|
271
|
+
const incoming = invitation.project;
|
|
272
|
+
if (
|
|
273
|
+
incoming?.v !== 2 ||
|
|
274
|
+
!UUID.test(incoming.id) ||
|
|
275
|
+
incoming.to !== me ||
|
|
276
|
+
incoming.from !== invitation.sender ||
|
|
277
|
+
!HANDLE.test(incoming.owner) ||
|
|
278
|
+
!Number.isSafeInteger(incoming.revision) ||
|
|
279
|
+
incoming.revision < 1 ||
|
|
280
|
+
incoming.history !== "shared"
|
|
281
|
+
)
|
|
282
|
+
throw new Error(
|
|
283
|
+
"The room invitation does not match its sender or recipient."
|
|
284
|
+
);
|
|
285
|
+
const listed = checkedMembers(incoming.members);
|
|
286
|
+
if (
|
|
287
|
+
!listed.some((member) => member.handle === me) ||
|
|
288
|
+
!listed.some(
|
|
289
|
+
(member) =>
|
|
290
|
+
member.handle === incoming.owner && member.status === "joined"
|
|
291
|
+
)
|
|
292
|
+
)
|
|
293
|
+
throw new Error("The invitation has no active room owner or recipient.");
|
|
294
|
+
return { ...incoming, members: listed };
|
|
295
|
+
};
|
|
296
|
+
const join = (invitation, me, agents) => {
|
|
297
|
+
const incoming = validateInvite(invitation, me);
|
|
298
|
+
if (incoming.purpose !== "invite" || incoming.from !== incoming.owner)
|
|
299
|
+
throw new Error("Join a room through its creator's invitation.");
|
|
300
|
+
if (read(incoming.id) && joined(read(incoming.id)))
|
|
301
|
+
throw new Error("This computer already has that room.");
|
|
302
|
+
if (
|
|
303
|
+
agents &&
|
|
304
|
+
(!Array.isArray(agents) ||
|
|
305
|
+
agents.some((agent) => !ownAgents().includes(agent)))
|
|
306
|
+
)
|
|
307
|
+
throw new Error("Choose agents available on this computer.");
|
|
308
|
+
for (const route of routes(incoming.id)) forget(route);
|
|
309
|
+
const room = write({
|
|
310
|
+
...incoming,
|
|
311
|
+
me,
|
|
312
|
+
agents: knownAgents(agents ?? ownAgents()),
|
|
313
|
+
rosters: {},
|
|
314
|
+
consents: {
|
|
315
|
+
[me]: Object.fromEntries(
|
|
316
|
+
(incoming.agreements ?? []).map((entry) => [
|
|
317
|
+
entry.id,
|
|
318
|
+
agreementHash(entry.body),
|
|
319
|
+
])
|
|
320
|
+
),
|
|
321
|
+
},
|
|
322
|
+
errors: {},
|
|
323
|
+
members: incoming.members.map((member) =>
|
|
324
|
+
member.handle === me ? { ...member, status: "joined" } : member
|
|
325
|
+
),
|
|
326
|
+
});
|
|
327
|
+
bind(invitation.id, room.id, incoming.from);
|
|
328
|
+
return room;
|
|
329
|
+
};
|
|
330
|
+
const setAgents = (id, agents) => {
|
|
331
|
+
const room = read(id);
|
|
332
|
+
if (!room || !joined(room)) throw new Error("You are not in this room.");
|
|
333
|
+
const chosen = knownAgents(agents);
|
|
334
|
+
if (chosen.some((agent) => !ownAgents().includes(agent)))
|
|
335
|
+
throw new Error("Choose agents available on this computer.");
|
|
336
|
+
return save(room, { agents: chosen });
|
|
337
|
+
};
|
|
338
|
+
const opened = (channelId) => {
|
|
339
|
+
const route = channel(channelId);
|
|
340
|
+
if (!route) return false;
|
|
341
|
+
if (route.state === "open") return true;
|
|
342
|
+
run(
|
|
343
|
+
"update shared_room_channels set state = 'open' where id = ?",
|
|
344
|
+
channelId
|
|
345
|
+
);
|
|
346
|
+
let room = read(route.room_id);
|
|
347
|
+
if (!joined(room)) {
|
|
348
|
+
end(channelId, "You no longer participate in this room.");
|
|
349
|
+
return true;
|
|
350
|
+
}
|
|
351
|
+
const peer = room.members.find((member) => member.handle === route.peer);
|
|
352
|
+
if (!peer || !["invited", "joined"].includes(peer.status)) {
|
|
353
|
+
publish(room, [route.peer]);
|
|
354
|
+
end(channelId, "This invitation is no longer active.");
|
|
355
|
+
return true;
|
|
356
|
+
}
|
|
357
|
+
if (room.owner === room.me) {
|
|
358
|
+
const member = room.members.find((entry) => entry.handle === route.peer);
|
|
359
|
+
if (member?.status === "invited") {
|
|
360
|
+
const before = room;
|
|
361
|
+
room = save(room, {
|
|
362
|
+
revision: room.revision + 1,
|
|
363
|
+
members: room.members.map((entry) =>
|
|
364
|
+
entry.handle === route.peer ? { ...entry, status: "joined" } : entry
|
|
365
|
+
),
|
|
366
|
+
});
|
|
367
|
+
publish(room);
|
|
368
|
+
notify(before, room);
|
|
369
|
+
}
|
|
370
|
+
}
|
|
371
|
+
onOpen(room.id, route.peer);
|
|
372
|
+
void sync().catch((error) => log(error.message));
|
|
373
|
+
return true;
|
|
374
|
+
};
|
|
375
|
+
const receive = (channelId, event) => {
|
|
376
|
+
const route = channel(channelId);
|
|
377
|
+
// A rejoin replaces the old pair channel. Acknowledge its queued frames
|
|
378
|
+
// without applying them so they cannot block delivery on the new channel.
|
|
379
|
+
if (!route)
|
|
380
|
+
return store.meta(`shared-room-channel:${channelId}`)
|
|
381
|
+
? { ok: true, ignored: true }
|
|
382
|
+
: null;
|
|
383
|
+
let room = read(route.room_id);
|
|
384
|
+
if (!event || typeof event !== "object")
|
|
385
|
+
return { ok: false, error: "An empty room event." };
|
|
386
|
+
if (!joined(room)) return { ok: true, ignored: true };
|
|
387
|
+
if (event.type === "membership") {
|
|
388
|
+
if (route.peer !== room.owner)
|
|
389
|
+
return { ok: false, error: "Only the room owner changes membership." };
|
|
390
|
+
if (
|
|
391
|
+
!Number.isSafeInteger(event.revision) ||
|
|
392
|
+
event.revision <= room.revision
|
|
393
|
+
)
|
|
394
|
+
return { ok: true, duplicate: true };
|
|
395
|
+
let listed;
|
|
396
|
+
try {
|
|
397
|
+
listed = checkedMembers(event.members);
|
|
398
|
+
} catch (error) {
|
|
399
|
+
return { ok: false, error: error.message };
|
|
400
|
+
}
|
|
401
|
+
if (
|
|
402
|
+
event.owner !== room.owner ||
|
|
403
|
+
!listed.some(
|
|
404
|
+
(member) => member.handle === room.owner && member.status === "joined"
|
|
405
|
+
) ||
|
|
406
|
+
room.members.some(
|
|
407
|
+
(member) =>
|
|
408
|
+
["left", "removed"].includes(member.status) &&
|
|
409
|
+
listed.some(
|
|
410
|
+
(next) =>
|
|
411
|
+
next.handle === member.handle &&
|
|
412
|
+
next.status === "joined" &&
|
|
413
|
+
next.generation <= member.generation
|
|
414
|
+
)
|
|
415
|
+
)
|
|
416
|
+
)
|
|
417
|
+
return {
|
|
418
|
+
ok: false,
|
|
419
|
+
error: "A membership update cannot revive a departed person.",
|
|
420
|
+
};
|
|
421
|
+
const before = room;
|
|
422
|
+
for (const member of listed) {
|
|
423
|
+
const previous = room.members.find(
|
|
424
|
+
(entry) => entry.handle === member.handle
|
|
425
|
+
);
|
|
426
|
+
if (previous && member.generation > previous.generation)
|
|
427
|
+
for (const route of routes(room.id).filter(
|
|
428
|
+
(entry) => entry.peer === member.handle
|
|
429
|
+
))
|
|
430
|
+
forget(route);
|
|
431
|
+
}
|
|
432
|
+
room = save(room, { revision: event.revision, members: listed });
|
|
433
|
+
notify(before, room);
|
|
434
|
+
if (!joined(room)) closeRoutes(room, "Your room membership ended.");
|
|
435
|
+
else void sync().catch((error) => log(error.message));
|
|
436
|
+
return { ok: true };
|
|
437
|
+
}
|
|
438
|
+
const sender = room.members.find((member) => member.handle === route.peer);
|
|
439
|
+
if (sender?.status !== "joined") return { ok: true, ignored: true };
|
|
440
|
+
if (event.type === "room_left") {
|
|
441
|
+
if (event.generation !== sender.generation)
|
|
442
|
+
return { ok: true, ignored: true };
|
|
443
|
+
const before = room;
|
|
444
|
+
room = save(room, {
|
|
445
|
+
revision: room.revision + (room.owner === room.me ? 1 : 0),
|
|
446
|
+
members: room.members.map((member) =>
|
|
447
|
+
member.handle === route.peer ? { ...member, status: "left" } : member
|
|
448
|
+
),
|
|
449
|
+
});
|
|
450
|
+
notify(before, room);
|
|
451
|
+
if (room.owner === room.me) publish(room);
|
|
452
|
+
return { ok: true };
|
|
453
|
+
}
|
|
454
|
+
if (event.type === "hello" || event.type === "roster") {
|
|
455
|
+
const rosters = {
|
|
456
|
+
...room.rosters,
|
|
457
|
+
[route.peer]: knownAgents(
|
|
458
|
+
(event.agents ?? []).map((agent) => agent.id)
|
|
459
|
+
),
|
|
460
|
+
};
|
|
461
|
+
room = save(room, {
|
|
462
|
+
rosters,
|
|
463
|
+
...(event.agreements
|
|
464
|
+
? {
|
|
465
|
+
consents: {
|
|
466
|
+
...room.consents,
|
|
467
|
+
[route.peer]: consentHashes(event.agreements),
|
|
468
|
+
},
|
|
469
|
+
}
|
|
470
|
+
: {}),
|
|
471
|
+
});
|
|
472
|
+
}
|
|
473
|
+
return onEvent(room.id, event, route.peer);
|
|
474
|
+
};
|
|
475
|
+
const closeRoutes = (room, reason) => {
|
|
476
|
+
for (const route of routes(room.id)) end(route.id, reason);
|
|
477
|
+
};
|
|
478
|
+
const leave = (id) => {
|
|
479
|
+
let room = read(id);
|
|
480
|
+
if (!room || !joined(room)) return;
|
|
481
|
+
send(id, { type: "room_left", generation: own(room).generation });
|
|
482
|
+
const before = room;
|
|
483
|
+
room = save(room, {
|
|
484
|
+
members: room.members.map((member) =>
|
|
485
|
+
member.handle === room.me ? { ...member, status: "left" } : member
|
|
486
|
+
),
|
|
487
|
+
});
|
|
488
|
+
notify(before, room);
|
|
489
|
+
closeRoutes(room, "Left the shared room.");
|
|
490
|
+
};
|
|
491
|
+
const remove = (id, peer) => {
|
|
492
|
+
const room = read(id);
|
|
493
|
+
if (!room || !joined(room) || room.owner !== room.me)
|
|
494
|
+
throw new Error("Only the room owner can remove someone.");
|
|
495
|
+
if (peer === room.me)
|
|
496
|
+
throw new Error("Use Leave to end your own participation.");
|
|
497
|
+
if (!room.members.some((member) => member.handle === peer))
|
|
498
|
+
throw new Error("That person is not in this room.");
|
|
499
|
+
const updated = save(room, {
|
|
500
|
+
revision: room.revision + 1,
|
|
501
|
+
members: room.members.map((member) =>
|
|
502
|
+
member.handle === peer ? { ...member, status: "removed" } : member
|
|
503
|
+
),
|
|
504
|
+
});
|
|
505
|
+
publish(updated, [...peersFor(id), peer]);
|
|
506
|
+
notify(room, updated);
|
|
507
|
+
};
|
|
508
|
+
const closed = (channelId) => {
|
|
509
|
+
const route = channel(channelId);
|
|
510
|
+
if (!route) return false;
|
|
511
|
+
run(
|
|
512
|
+
"update shared_room_channels set state = 'closed' where id = ?",
|
|
513
|
+
channelId
|
|
514
|
+
);
|
|
515
|
+
const room = read(route.room_id);
|
|
516
|
+
if (
|
|
517
|
+
joined(room) &&
|
|
518
|
+
active(room).some((member) => member.handle === route.peer)
|
|
519
|
+
) {
|
|
520
|
+
const next = save(room, {
|
|
521
|
+
revision: room.revision + (room.owner === room.me ? 1 : 0),
|
|
522
|
+
members: room.members.map((member) =>
|
|
523
|
+
member.handle === route.peer ? { ...member, status: "left" } : member
|
|
524
|
+
),
|
|
525
|
+
});
|
|
526
|
+
notify(room, next);
|
|
527
|
+
if (next.owner === next.me) publish(next);
|
|
528
|
+
}
|
|
529
|
+
return true;
|
|
530
|
+
};
|
|
531
|
+
let syncing = null;
|
|
532
|
+
const retry = async (id, peer) => {
|
|
533
|
+
const room = read(id);
|
|
534
|
+
if (
|
|
535
|
+
!room ||
|
|
536
|
+
!joined(room) ||
|
|
537
|
+
!room.members.some(
|
|
538
|
+
(member) =>
|
|
539
|
+
member.handle === peer &&
|
|
540
|
+
["invited", "joined"].includes(member.status)
|
|
541
|
+
)
|
|
542
|
+
)
|
|
543
|
+
throw new Error(
|
|
544
|
+
"That person has no active room invitation or membership."
|
|
545
|
+
);
|
|
546
|
+
const pending = (await sentInvites()).find(
|
|
547
|
+
(entry) =>
|
|
548
|
+
entry.project?.id === id &&
|
|
549
|
+
entry.project.to === peer &&
|
|
550
|
+
["requested", "accepted", "accepted_pending"].includes(entry.status)
|
|
551
|
+
);
|
|
552
|
+
if (pending) {
|
|
553
|
+
bind(pending.id, id, peer, "invited");
|
|
554
|
+
if (store.getThread(pending.id)) opened(pending.id);
|
|
555
|
+
return;
|
|
556
|
+
}
|
|
557
|
+
if (
|
|
558
|
+
routes(id).some((entry) => entry.peer === peer && entry.state === "open")
|
|
559
|
+
)
|
|
560
|
+
return;
|
|
561
|
+
await connect(id, peer, room.owner === room.me ? "invite" : "link");
|
|
562
|
+
};
|
|
563
|
+
const sync = () => {
|
|
564
|
+
if (syncing) return syncing;
|
|
565
|
+
syncing = (async () => {
|
|
566
|
+
const current = rooms().filter(joined);
|
|
567
|
+
if (!current.length) return;
|
|
568
|
+
const waiting = await invites();
|
|
569
|
+
for (const invitation of waiting) {
|
|
570
|
+
if (
|
|
571
|
+
invitation.project?.v !== 2 ||
|
|
572
|
+
invitation.project.purpose !== "link"
|
|
573
|
+
)
|
|
574
|
+
continue;
|
|
575
|
+
const room = read(invitation.project.id);
|
|
576
|
+
if (!room || !joined(room)) continue;
|
|
577
|
+
let incoming;
|
|
578
|
+
try {
|
|
579
|
+
incoming = validateInvite(invitation, room.me);
|
|
580
|
+
} catch {
|
|
581
|
+
continue;
|
|
582
|
+
}
|
|
583
|
+
if (
|
|
584
|
+
incoming.owner !== room.owner ||
|
|
585
|
+
incoming.revision > room.revision ||
|
|
586
|
+
!active(room).some((member) => member.handle === incoming.from) ||
|
|
587
|
+
routes(room.id).some((route) => route.peer === incoming.from)
|
|
588
|
+
)
|
|
589
|
+
continue;
|
|
590
|
+
bind(invitation.id, room.id, incoming.from);
|
|
591
|
+
await decide(invitation.id, "accept");
|
|
592
|
+
}
|
|
593
|
+
for (const room of rooms().filter(joined))
|
|
594
|
+
for (const peer of peersFor(room.id)) {
|
|
595
|
+
if (
|
|
596
|
+
room.me > peer ||
|
|
597
|
+
routes(room.id).some((route) => route.peer === peer) ||
|
|
598
|
+
room.errors[peer]
|
|
599
|
+
)
|
|
600
|
+
continue;
|
|
601
|
+
await connect(room.id, peer, "link").catch(() => undefined);
|
|
602
|
+
}
|
|
603
|
+
})().finally(() => {
|
|
604
|
+
syncing = null;
|
|
605
|
+
});
|
|
606
|
+
return syncing;
|
|
607
|
+
};
|
|
608
|
+
const timer = setInterval(
|
|
609
|
+
() => void sync().catch((error) => log(error.message)),
|
|
610
|
+
2_000
|
|
611
|
+
);
|
|
612
|
+
timer.unref?.();
|
|
613
|
+
return {
|
|
614
|
+
init,
|
|
615
|
+
read,
|
|
616
|
+
members,
|
|
617
|
+
recipients,
|
|
618
|
+
routes,
|
|
619
|
+
channel,
|
|
620
|
+
knowsChannel: (id) =>
|
|
621
|
+
Boolean(channel(id) || store.meta(`shared-room-channel:${id}`)),
|
|
622
|
+
invite,
|
|
623
|
+
join,
|
|
624
|
+
setAgents,
|
|
625
|
+
opened,
|
|
626
|
+
receive,
|
|
627
|
+
leave,
|
|
628
|
+
remove,
|
|
629
|
+
closed,
|
|
630
|
+
sync,
|
|
631
|
+
retry,
|
|
632
|
+
agents: (id) => {
|
|
633
|
+
const available = ownAgents();
|
|
634
|
+
return (read(id)?.agents ?? available).filter((agent) =>
|
|
635
|
+
available.includes(agent)
|
|
636
|
+
);
|
|
637
|
+
},
|
|
638
|
+
peers: peersFor,
|
|
639
|
+
stop: () => clearInterval(timer),
|
|
640
|
+
};
|
|
641
|
+
}
|