tryharness 0.7.83 → 0.7.86
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 +21 -19
- package/assets/dsh-plugin.mjs +75 -4
- package/assets/herdr-mod/harness/main.js +367 -0
- package/assets/herdr-mod/harness/mod.json +6 -0
- package/assets/opencode-plugin.js +87 -22
- package/assets/pi-extension.ts +81 -2
- package/cli.mjs +544 -208
- package/lib/adapters.mjs +62 -27
- package/lib/agentBinaries.mjs +6 -8
- package/lib/agentClaims.mjs +168 -0
- package/lib/agentReadTools.json +415 -0
- package/lib/agentSignIn.mjs +17 -18
- package/lib/agentWiring.mjs +114 -0
- package/lib/archetypes.js +10 -11
- package/lib/attention.mjs +100 -0
- package/lib/audit.mjs +1 -1
- package/lib/backupSetup.mjs +6 -28
- package/lib/bankrApprovals.mjs +86 -0
- package/lib/boardAccess.mjs +40 -66
- package/lib/boardBackup.mjs +86 -85
- package/lib/boardCommands.mjs +28 -0
- package/lib/boardFileCommands.mjs +29 -36
- package/lib/boardFiles.mjs +83 -15
- package/lib/boardMirror.mjs +78 -11
- package/lib/boardProtocol.json +191 -123
- package/lib/boardThreads.mjs +19 -37
- package/lib/boardTools.mjs +22 -15
- package/lib/boardWatches.mjs +43 -15
- package/lib/bridge.mjs +7 -3
- package/lib/browserAgentTools.mjs +59 -0
- package/lib/browserWake.mjs +0 -6
- package/lib/cards.mjs +52 -0
- package/lib/circling.mjs +189 -0
- package/lib/cleanup.mjs +234 -0
- package/lib/cloudBoot.mjs +21 -4
- package/lib/cloudSave.mjs +46 -5
- package/lib/compaction.mjs +8 -1
- package/lib/completion.mjs +358 -0
- package/lib/computerDevices.mjs +853 -0
- package/lib/connectionStatus.mjs +34 -0
- package/lib/connectors.mjs +139 -1
- package/lib/coordinator.mjs +108 -14
- package/lib/coreModels.mjs +36 -12
- package/lib/daemon.mjs +2426 -338
- package/lib/daemonLock.mjs +103 -0
- package/lib/deviceDoor.mjs +308 -0
- package/lib/deviceIdentity.mjs +114 -0
- package/lib/deviceList.mjs +172 -0
- package/lib/deviceSeal.mjs +74 -0
- package/lib/dispatcher.mjs +497 -26
- package/lib/dispatches.mjs +3 -3
- package/lib/environment.mjs +2 -1
- package/lib/environments.mjs +67 -41
- package/lib/events.mjs +318 -0
- package/lib/facts.mjs +170 -0
- package/lib/fileSource.mjs +540 -0
- package/lib/files.mjs +47 -2
- package/lib/gitHost.mjs +39 -1
- package/lib/goalCommands.mjs +12 -80
- package/lib/handover.mjs +21 -16
- package/lib/harnessOffers.mjs +140 -15
- package/lib/herdr.mjs +100 -15
- package/lib/herdrAppCall.mjs +19 -0
- package/lib/herdrCore.mjs +59 -0
- package/lib/herdrRuns.mjs +1126 -0
- package/lib/hookDialects.mjs +235 -50
- package/lib/identityLink.mjs +81 -0
- package/lib/inference.mjs +31 -2
- package/lib/jamAccess.mjs +82 -0
- package/lib/{projectBoard.mjs → jamBoard.mjs} +5 -4
- package/lib/{projectGit.mjs → jamGit.mjs} +53 -15
- package/lib/jamKey.mjs +274 -0
- package/lib/{projectPieces.mjs → jamPieces.mjs} +35 -29
- package/lib/{projectSettings.mjs → jamSettings.mjs} +12 -22
- package/lib/jamStore.mjs +973 -0
- package/lib/jamUpgrade.mjs +112 -0
- package/lib/jams.mjs +3079 -0
- package/lib/kanban.mjs +13 -7
- package/lib/landed.mjs +5 -1
- package/lib/library.mjs +41 -22
- package/lib/limits.mjs +91 -0
- package/lib/lineDiff.mjs +97 -0
- package/lib/lineup.mjs +18 -13
- package/lib/link.mjs +584 -0
- package/lib/localStack.mjs +75 -16
- package/lib/localmodels.mjs +58 -78
- package/lib/loopBackstop.mjs +2 -1
- package/lib/machine.mjs +544 -0
- package/lib/machineLink.mjs +446 -0
- package/lib/machineRoutes.mjs +68 -19
- package/lib/machineRuns.mjs +85 -4
- package/lib/machineSeal.mjs +6 -31
- package/lib/manager.mjs +134 -12
- package/lib/mcp-stdio.mjs +492 -215
- package/lib/mcpRelay.mjs +34 -35
- package/lib/members.json +1 -1
- package/lib/modelRoute.mjs +162 -0
- package/lib/nativeHost.mjs +81 -90
- package/lib/nativeSenses.mjs +258 -0
- package/lib/nerves.mjs +523 -0
- package/lib/network.mjs +117 -278
- package/lib/networkPlaces.mjs +578 -0
- package/lib/nextStep.mjs +95 -0
- package/lib/notify.mjs +2 -2
- package/lib/nudge.mjs +116 -10
- package/lib/originals.mjs +216 -0
- package/lib/outsideEvents.mjs +383 -0
- package/lib/outsideRuns.mjs +230 -0
- package/lib/ownMachines.mjs +674 -256
- package/lib/pain.mjs +215 -0
- package/lib/pairing.mjs +91 -11
- package/lib/paths.mjs +42 -3
- package/lib/peerProcess.mjs +21 -7
- package/lib/peopleLink.mjs +268 -0
- package/lib/personNotices.mjs +3 -2
- package/lib/phones.mjs +252 -542
- package/lib/placeCards.mjs +282 -0
- package/lib/placeChecks.mjs +95 -0
- package/lib/placeCommands.mjs +8 -17
- package/lib/placeRequests.mjs +152 -0
- package/lib/placeStore.mjs +295 -0
- package/lib/placeTool.d.ts +12 -0
- package/lib/placeTool.js +40 -0
- package/lib/places.mjs +63 -14
- package/lib/plans.mjs +53 -8
- package/lib/presence.mjs +270 -0
- package/lib/privateNetwork.d.ts +2 -0
- package/lib/privateNetwork.js +93 -0
- package/lib/proposals.mjs +300 -0
- package/lib/publicFetch.d.ts +32 -0
- package/lib/publicFetch.js +248 -0
- package/lib/reach.mjs +128 -0
- package/lib/rebuildable.mjs +72 -0
- package/lib/recall.mjs +216 -0
- package/lib/record.mjs +13 -0
- package/lib/reflexes.mjs +392 -0
- package/lib/relayLimits.mjs +31 -2
- package/lib/releaseNotice.mjs +198 -0
- package/lib/removeHarness.mjs +15 -4
- package/lib/repoLinks.mjs +204 -35
- package/lib/runAuthority.mjs +102 -39
- package/lib/runBrief.mjs +93 -40
- package/lib/runRequests.mjs +52 -14
- package/lib/runUsage.mjs +31 -0
- package/lib/runWorker.mjs +74 -25
- package/lib/runner.mjs +289 -45
- package/lib/runtime-install.mjs +37 -8
- package/lib/schedules.mjs +171 -47
- package/lib/screenWatches.mjs +221 -0
- package/lib/sealed.mjs +12 -30
- package/lib/sealedThreads.mjs +198 -392
- package/lib/secretStore.mjs +178 -0
- package/lib/secrets.mjs +11 -0
- package/lib/seen.mjs +3 -9
- package/lib/selfUpdate.mjs +51 -15
- package/lib/senseCall.mjs +1514 -0
- package/lib/senseHook.mjs +114 -0
- package/lib/senseTools.mjs +1298 -0
- package/lib/sessionBriefs.mjs +87 -0
- package/lib/sessionControl.mjs +63 -13
- package/lib/sessionFiles.mjs +85 -0
- package/lib/setupChoices.mjs +12 -3
- package/lib/setupMode.mjs +70 -25
- package/lib/sharedKeys.mjs +166 -0
- package/lib/sleep.mjs +396 -0
- package/lib/sources.mjs +306 -0
- package/lib/speech.mjs +166 -411
- package/lib/spoken.mjs +210 -0
- package/lib/steerHook.mjs +3 -1
- package/lib/steerQueue.mjs +40 -11
- package/lib/store.mjs +323 -130
- package/lib/stuck.mjs +85 -7
- package/lib/swarm.mjs +157 -49
- package/lib/swarmDevices.mjs +25 -85
- package/lib/swarmMemory.mjs +93 -9
- package/lib/t3.mjs +73 -3
- package/lib/taskCommands.mjs +51 -60
- package/lib/taskRooms.mjs +30 -4
- package/lib/taskRules.json +29 -0
- package/lib/taskRules.mjs +21 -0
- package/lib/taskRuns.mjs +74 -11
- package/lib/team.mjs +2 -1
- package/lib/threadActions.mjs +37 -9
- package/lib/threadAuthority.mjs +4 -4
- package/lib/threadBriefs.mjs +173 -43
- package/lib/threadNotes.mjs +320 -0
- package/lib/threadRecord.mjs +491 -0
- package/lib/threadRuns.mjs +216 -108
- package/lib/threadView.mjs +27 -30
- package/lib/threadWatches.mjs +1962 -0
- package/lib/timeSense.mjs +839 -0
- package/lib/tripwires.mjs +454 -0
- package/lib/ui.mjs +1 -1
- package/lib/vault.mjs +560 -45
- package/lib/vaultCommands.mjs +5 -3
- package/lib/vaultPeers.mjs +165 -0
- package/lib/vaultTools.d.ts +4 -1
- package/lib/vaultTools.js +22 -1
- package/lib/verdicts.mjs +12 -26
- package/lib/versions.mjs +117 -0
- package/lib/waitTool.mjs +278 -0
- package/lib/wakePicture.mjs +268 -0
- package/lib/wakeQueue.mjs +108 -0
- package/lib/watchResponses.mjs +533 -0
- package/lib/watches.mjs +290 -145
- package/lib/windowAsks.mjs +80 -17
- package/lib/worktrees.mjs +159 -9
- package/npm-shrinkwrap.json +138 -631
- package/package.json +7 -6
- package/release.json +211 -129
- package/lib/callSessions.mjs +0 -51
- package/lib/directLink.mjs +0 -349
- package/lib/peopleBoard.mjs +0 -131
- package/lib/projects.mjs +0 -2917
- package/lib/roomChannels.mjs +0 -667
package/lib/jamStore.mjs
ADDED
|
@@ -0,0 +1,973 @@
|
|
|
1
|
+
import { aboutOf, claimHolds } from "./agentClaims.mjs";
|
|
2
|
+
import { createHash, randomUUID } from "node:crypto";
|
|
3
|
+
import {
|
|
4
|
+
cardHolds,
|
|
5
|
+
newJamKey,
|
|
6
|
+
openEvent,
|
|
7
|
+
openFile,
|
|
8
|
+
openOffer,
|
|
9
|
+
sealEvent,
|
|
10
|
+
sealFile,
|
|
11
|
+
sealOffer,
|
|
12
|
+
signCard,
|
|
13
|
+
unwrapKey,
|
|
14
|
+
wrapKey,
|
|
15
|
+
} from "./jamKey.mjs";
|
|
16
|
+
|
|
17
|
+
// The jam's sealed store on the person's home computer (docs/jam-plan.md J3). Harness keeps every jam's events in order
|
|
18
|
+
// and cannot read them (src/server/jams/jams.ts); this computer makes and wraps the keys, seals and signs what the
|
|
19
|
+
// person appends, and opens and checks what everyone else appended, keeping its own copy. A removed member's computer
|
|
20
|
+
// keeps what it had and reads nothing after; a computer that was off reads on from its last place.
|
|
21
|
+
//
|
|
22
|
+
// Who wrote what is checked by signature, never taken from Harness: each member's keys come on a card the jam's owner
|
|
23
|
+
// signed, and the owner's own key is the one this computer pinned when the two became friends. An event that is
|
|
24
|
+
// unsigned, signed by anyone but its author, changed, moved, or under an older epoch after a newer one is kept as
|
|
25
|
+
// refused, with why, and never read as anyone's words.
|
|
26
|
+
//
|
|
27
|
+
// Removing a member, or a member leaving, stops the jam until a new key is in: the owner's computer makes it, or any
|
|
28
|
+
// joined member's when the owner's is off; Harness takes the first. An invitation carries an offer, what the invited
|
|
29
|
+
// friend is shown before joining, sealed and signed by the owner's computer; nothing else is read before joining.
|
|
30
|
+
//
|
|
31
|
+
// What the jam's events mean (its record, room and members' agents) is jams.mjs's: this module only keeps them.
|
|
32
|
+
|
|
33
|
+
const TABLES = `
|
|
34
|
+
create table if not exists jam_store (
|
|
35
|
+
jam_id text primary key,
|
|
36
|
+
owner text,
|
|
37
|
+
role text,
|
|
38
|
+
state text not null,
|
|
39
|
+
epoch integer not null default 0,
|
|
40
|
+
rotate_due integer not null default 0,
|
|
41
|
+
last_seq integer not null default 0,
|
|
42
|
+
top_epoch integer not null default 0,
|
|
43
|
+
members text not null default '[]',
|
|
44
|
+
refusal text,
|
|
45
|
+
updated_at text not null
|
|
46
|
+
);
|
|
47
|
+
create table if not exists jam_store_keys (
|
|
48
|
+
jam_id text not null,
|
|
49
|
+
epoch integer not null,
|
|
50
|
+
wrapped text not null,
|
|
51
|
+
primary key (jam_id, epoch)
|
|
52
|
+
);
|
|
53
|
+
create table if not exists jam_store_events (
|
|
54
|
+
jam_id text not null,
|
|
55
|
+
seq integer not null,
|
|
56
|
+
epoch integer not null,
|
|
57
|
+
author text,
|
|
58
|
+
body text,
|
|
59
|
+
refused text,
|
|
60
|
+
created_at text,
|
|
61
|
+
primary key (jam_id, seq)
|
|
62
|
+
);
|
|
63
|
+
`;
|
|
64
|
+
const IN = new Set(["invited", "joined"]);
|
|
65
|
+
// Computers that kept jams before invitations carried an offer have no column for it.
|
|
66
|
+
const OFFER_COLUMN = "alter table jam_store add column offer text";
|
|
67
|
+
// Computers that kept jams before a jam could end (its owner left) have no column for that.
|
|
68
|
+
const ENDED_COLUMN =
|
|
69
|
+
"alter table jam_store add column ended integer not null default 0";
|
|
70
|
+
const MAX_BODY_BYTES = 256 * 1024;
|
|
71
|
+
// A file in a jam: as large as a board file may be (boardFiles.mjs MAX_FILE_BYTES, a 32 MB PDF).
|
|
72
|
+
const MAX_FILE_BYTES = 32 * 1024 * 1024;
|
|
73
|
+
// A file's bytes go and come in one call that waits for its answer, or for the connection to drop (bridge.mjs): how long
|
|
74
|
+
// a 32 MB upload takes depends on the person's link, which no measured deadline covers yet.
|
|
75
|
+
const FILE_WAIT = null;
|
|
76
|
+
const APPEND_TRIES = 6;
|
|
77
|
+
const READ_LIMIT = 500;
|
|
78
|
+
|
|
79
|
+
const now = () => new Date().toISOString();
|
|
80
|
+
|
|
81
|
+
/**
|
|
82
|
+
* `ask(type, input)`: a call to Harness. `can()`: whether the Harness connected to keeps jams. `identity()`: this
|
|
83
|
+
* computer's keys ({ sealingKey (base64url), sealingPrivateKey, signingKey, signingPrivateKey }). `myHandle()`: the
|
|
84
|
+
* person's name on Harness. `changed(jamId)`: a jam moved here.
|
|
85
|
+
*/
|
|
86
|
+
export function createJamStore({
|
|
87
|
+
store,
|
|
88
|
+
ask,
|
|
89
|
+
can = () => true,
|
|
90
|
+
identity,
|
|
91
|
+
myHandle,
|
|
92
|
+
changed = () => {},
|
|
93
|
+
log = () => {},
|
|
94
|
+
}) {
|
|
95
|
+
const db = store.db;
|
|
96
|
+
// One transaction: each statement on its own synced a journal to disk on every start.
|
|
97
|
+
db.exec(`begin; ${TABLES}; commit;`);
|
|
98
|
+
if (
|
|
99
|
+
!db
|
|
100
|
+
.all("pragma table_info(jam_store)")
|
|
101
|
+
.some((column) => column.name === "offer")
|
|
102
|
+
)
|
|
103
|
+
db.exec(OFFER_COLUMN);
|
|
104
|
+
if (
|
|
105
|
+
!db
|
|
106
|
+
.all("pragma table_info(jam_store)")
|
|
107
|
+
.some((column) => column.name === "ended")
|
|
108
|
+
)
|
|
109
|
+
db.exec(ENDED_COLUMN);
|
|
110
|
+
|
|
111
|
+
// ---- this computer's copy ----
|
|
112
|
+
|
|
113
|
+
const rowOf = (jamId) => {
|
|
114
|
+
const row = db.get("select * from jam_store where jam_id = ?", [jamId]);
|
|
115
|
+
return row
|
|
116
|
+
? {
|
|
117
|
+
...row,
|
|
118
|
+
members: JSON.parse(row.members),
|
|
119
|
+
offer: row.offer ? JSON.parse(row.offer) : null,
|
|
120
|
+
}
|
|
121
|
+
: null;
|
|
122
|
+
};
|
|
123
|
+
const save = (jamId, fields) => {
|
|
124
|
+
const before = rowOf(jamId);
|
|
125
|
+
const next = {
|
|
126
|
+
owner: null,
|
|
127
|
+
role: null,
|
|
128
|
+
state: "invited",
|
|
129
|
+
epoch: 0,
|
|
130
|
+
rotate_due: 0,
|
|
131
|
+
last_seq: 0,
|
|
132
|
+
top_epoch: 0,
|
|
133
|
+
members: [],
|
|
134
|
+
refusal: null,
|
|
135
|
+
offer: null,
|
|
136
|
+
ended: 0,
|
|
137
|
+
...before,
|
|
138
|
+
...fields,
|
|
139
|
+
};
|
|
140
|
+
db.run(
|
|
141
|
+
`insert into jam_store (jam_id, owner, role, state, epoch, rotate_due, last_seq, top_epoch, members, refusal, offer, ended, updated_at)
|
|
142
|
+
values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
143
|
+
on conflict(jam_id) do update set owner = excluded.owner, role = excluded.role, state = excluded.state,
|
|
144
|
+
epoch = excluded.epoch, rotate_due = excluded.rotate_due, last_seq = excluded.last_seq,
|
|
145
|
+
top_epoch = excluded.top_epoch, members = excluded.members, refusal = excluded.refusal,
|
|
146
|
+
offer = excluded.offer, ended = excluded.ended, updated_at = excluded.updated_at`,
|
|
147
|
+
[
|
|
148
|
+
jamId,
|
|
149
|
+
next.owner,
|
|
150
|
+
next.role,
|
|
151
|
+
next.state,
|
|
152
|
+
next.epoch,
|
|
153
|
+
next.rotate_due ? 1 : 0,
|
|
154
|
+
next.last_seq,
|
|
155
|
+
next.top_epoch,
|
|
156
|
+
JSON.stringify(next.members),
|
|
157
|
+
next.refusal,
|
|
158
|
+
next.offer == null ? null : JSON.stringify(next.offer),
|
|
159
|
+
next.ended ? 1 : 0,
|
|
160
|
+
now(),
|
|
161
|
+
]
|
|
162
|
+
);
|
|
163
|
+
};
|
|
164
|
+
const keep = (jamId, event) =>
|
|
165
|
+
db.run(
|
|
166
|
+
`insert or ignore into jam_store_events (jam_id, seq, epoch, author, body, refused, created_at) values (?, ?, ?, ?, ?, ?, ?)`,
|
|
167
|
+
[
|
|
168
|
+
jamId,
|
|
169
|
+
event.seq,
|
|
170
|
+
event.epoch,
|
|
171
|
+
event.author ?? null,
|
|
172
|
+
event.body === undefined ? null : JSON.stringify(event.body),
|
|
173
|
+
event.refused ?? null,
|
|
174
|
+
event.createdAt ?? now(),
|
|
175
|
+
]
|
|
176
|
+
);
|
|
177
|
+
|
|
178
|
+
// ---- keys ----
|
|
179
|
+
|
|
180
|
+
// The person's identity (daemon.mjs personKeys), read each time: it changes when a device leaves their list.
|
|
181
|
+
let handle = null;
|
|
182
|
+
const me = async () => {
|
|
183
|
+
handle ??= await myHandle();
|
|
184
|
+
if (!handle) throw new Error("claim a name on Harness before you use jams");
|
|
185
|
+
return { ...(await identity()), handle };
|
|
186
|
+
};
|
|
187
|
+
|
|
188
|
+
// A friend's identity as this computer pinned it with the friendship, and the signing keys they had before it moved
|
|
189
|
+
// on along its links; keys waiting for the person's trust give none.
|
|
190
|
+
const friendKeys = async (handle) => {
|
|
191
|
+
const pinned = store.relayPeer(handle);
|
|
192
|
+
if (!pinned?.signing_key || store.meta(`relay-key-waiting:${handle}`))
|
|
193
|
+
return null;
|
|
194
|
+
return {
|
|
195
|
+
sealingKey: pinned.public_key,
|
|
196
|
+
signingKey: pinned.signing_key,
|
|
197
|
+
pastSigningKeys: pinned.past_signing_keys ?? [],
|
|
198
|
+
};
|
|
199
|
+
};
|
|
200
|
+
|
|
201
|
+
// Whether a card holds under any of the owner's signing keys: theirs now, or one before their keys changed.
|
|
202
|
+
const cardHoldsUnder = async (card, jamId, ownerKeys) => {
|
|
203
|
+
for (const ownerKey of ownerKeys)
|
|
204
|
+
if (await cardHolds(card, jamId, ownerKey)) return true;
|
|
205
|
+
return false;
|
|
206
|
+
};
|
|
207
|
+
|
|
208
|
+
// The members whose cards the owner signed for this jam; the owner's own card must carry a key pinned for them.
|
|
209
|
+
const checkedMembers = async (jamId, owner, members) => {
|
|
210
|
+
const self = await me();
|
|
211
|
+
const ownerKeys =
|
|
212
|
+
owner === self.handle
|
|
213
|
+
? [self.signingKey, ...(self.pastSigningKeys ?? [])]
|
|
214
|
+
: await friendKeys(owner).then((friend) =>
|
|
215
|
+
friend ? [friend.signingKey, ...friend.pastSigningKeys] : []
|
|
216
|
+
);
|
|
217
|
+
if (!ownerKeys.length) return null;
|
|
218
|
+
const checked = [];
|
|
219
|
+
for (const member of members) {
|
|
220
|
+
const card = member.card;
|
|
221
|
+
if (!card || card.handle !== member.handle) continue;
|
|
222
|
+
if (member.role === "owner" && !ownerKeys.includes(card.signingKey))
|
|
223
|
+
continue;
|
|
224
|
+
if (!(await cardHoldsUnder(card, jamId, ownerKeys))) continue;
|
|
225
|
+
// The cards the owner gave them before their keys changed, so what they wrote then still checks out.
|
|
226
|
+
const past = [];
|
|
227
|
+
for (const old of Array.isArray(member.pastCards) ? member.pastCards : [])
|
|
228
|
+
if (
|
|
229
|
+
old?.handle === member.handle &&
|
|
230
|
+
(await cardHoldsUnder(old, jamId, ownerKeys))
|
|
231
|
+
)
|
|
232
|
+
past.push(old.signingKey);
|
|
233
|
+
checked.push({
|
|
234
|
+
handle: member.handle,
|
|
235
|
+
role: member.role,
|
|
236
|
+
state: member.state,
|
|
237
|
+
sealingKey: card.sealingKey,
|
|
238
|
+
signingKey: card.signingKey,
|
|
239
|
+
signingKeys: [card.signingKey, ...past],
|
|
240
|
+
});
|
|
241
|
+
}
|
|
242
|
+
return checked;
|
|
243
|
+
};
|
|
244
|
+
// What a member signed is theirs under any key the owner gave them: their computer's now, or one it had before.
|
|
245
|
+
const byAnyKey = async (member, open) => {
|
|
246
|
+
let failure = new Error("no key of theirs");
|
|
247
|
+
for (const signingKey of member.signingKeys ?? [member.signingKey])
|
|
248
|
+
try {
|
|
249
|
+
return await open(signingKey);
|
|
250
|
+
} catch (error) {
|
|
251
|
+
failure = error;
|
|
252
|
+
}
|
|
253
|
+
throw failure;
|
|
254
|
+
};
|
|
255
|
+
|
|
256
|
+
const opened = new Map();
|
|
257
|
+
const keyFor = async (jamId, epoch, members) => {
|
|
258
|
+
const cached = opened.get(`${jamId}:${epoch}`);
|
|
259
|
+
if (cached) return cached;
|
|
260
|
+
const row = db.get(
|
|
261
|
+
"select wrapped from jam_store_keys where jam_id = ? and epoch = ?",
|
|
262
|
+
[jamId, epoch]
|
|
263
|
+
);
|
|
264
|
+
if (!row) return null;
|
|
265
|
+
const wrapped = JSON.parse(row.wrapped);
|
|
266
|
+
const wrapper = members.find((member) => member.handle === wrapped.by);
|
|
267
|
+
if (!wrapper) return null;
|
|
268
|
+
const self = await me();
|
|
269
|
+
// Wrapped to the person's keys now, or to keys they had before a device left their list.
|
|
270
|
+
const sealingKeys = [
|
|
271
|
+
self.sealingPrivateKey,
|
|
272
|
+
...(self.earlierSealingPrivateKeys ?? []),
|
|
273
|
+
];
|
|
274
|
+
const key = await byAnyKey(wrapper, async (wrapperSigningKey) => {
|
|
275
|
+
let failure = new Error("no key of yours opens it");
|
|
276
|
+
for (const sealingPrivateKey of sealingKeys)
|
|
277
|
+
try {
|
|
278
|
+
return await unwrapKey({
|
|
279
|
+
jamId,
|
|
280
|
+
epoch,
|
|
281
|
+
wrapped,
|
|
282
|
+
me: self.handle,
|
|
283
|
+
sealingPrivateKey,
|
|
284
|
+
wrapperSigningKey,
|
|
285
|
+
});
|
|
286
|
+
} catch (error) {
|
|
287
|
+
failure = error;
|
|
288
|
+
}
|
|
289
|
+
throw failure;
|
|
290
|
+
});
|
|
291
|
+
opened.set(`${jamId}:${epoch}`, key);
|
|
292
|
+
return key;
|
|
293
|
+
};
|
|
294
|
+
|
|
295
|
+
// An agent's words in a jam carry the claim of the computer it runs on (agentClaims.mjs): that computer's key,
|
|
296
|
+
// certified by its person's identity, signed this agent's name over exactly these words, or a file's hash and name. A
|
|
297
|
+
// post or file naming an agent without one that holds is refused; the person's own are signed by their identity.
|
|
298
|
+
const agentRefusal = async (event, body, author) => {
|
|
299
|
+
if (body.type !== "post" && body.type !== "file") return null;
|
|
300
|
+
const [handle, who] = String(body.author || "").split("/");
|
|
301
|
+
if (handle !== event.author || !who || who === "person") return null;
|
|
302
|
+
const holds =
|
|
303
|
+
body.claim?.agent === who &&
|
|
304
|
+
(await claimHolds(body.claim, {
|
|
305
|
+
identitySigningKeys: author.signingKeys ?? [author.signingKey],
|
|
306
|
+
about: aboutOf(
|
|
307
|
+
body.type === "file"
|
|
308
|
+
? fileClaimed(body.file?.sha256, body.name)
|
|
309
|
+
: String(body.text ?? "")
|
|
310
|
+
),
|
|
311
|
+
}));
|
|
312
|
+
return holds
|
|
313
|
+
? null
|
|
314
|
+
: `${body.author}'s words come without its computer's claim`;
|
|
315
|
+
};
|
|
316
|
+
|
|
317
|
+
// ---- reading on from the last place ----
|
|
318
|
+
|
|
319
|
+
// One jam's calls run one after another on this computer.
|
|
320
|
+
const queues = new Map();
|
|
321
|
+
const queued = (jamId, run) => {
|
|
322
|
+
const next = (queues.get(jamId) ?? Promise.resolve())
|
|
323
|
+
.catch(() => {})
|
|
324
|
+
.then(run);
|
|
325
|
+
queues.set(jamId, next);
|
|
326
|
+
return next;
|
|
327
|
+
};
|
|
328
|
+
|
|
329
|
+
const readOnce = async (jamId) => {
|
|
330
|
+
const before = rowOf(jamId);
|
|
331
|
+
const answer = await ask("jam_since", {
|
|
332
|
+
jamId,
|
|
333
|
+
seq: before?.last_seq ?? 0,
|
|
334
|
+
});
|
|
335
|
+
if (!answer.ok) return answer;
|
|
336
|
+
const { jam } = answer;
|
|
337
|
+
const fields = {
|
|
338
|
+
owner: jam.owner,
|
|
339
|
+
role: jam.role,
|
|
340
|
+
state: jam.state,
|
|
341
|
+
epoch: jam.epoch,
|
|
342
|
+
rotate_due: jam.rotateDue,
|
|
343
|
+
// Its owner left: the jam is over for everyone, and those in it keep what it holds.
|
|
344
|
+
ended: Boolean(jam.ended),
|
|
345
|
+
};
|
|
346
|
+
if (!IN.has(jam.state)) {
|
|
347
|
+
// Removed or gone: what this computer had stays; nothing more comes.
|
|
348
|
+
save(jamId, { ...fields, offer: null });
|
|
349
|
+
if (before?.state !== jam.state) changed(jamId);
|
|
350
|
+
return { ok: true, more: false };
|
|
351
|
+
}
|
|
352
|
+
const members = await checkedMembers(jamId, jam.owner, answer.members);
|
|
353
|
+
if (!members) {
|
|
354
|
+
save(jamId, {
|
|
355
|
+
...fields,
|
|
356
|
+
refusal: `its owner ${jam.owner} is not your friend on this computer`,
|
|
357
|
+
});
|
|
358
|
+
return { ok: false, error: `${jam.owner} is not your friend here` };
|
|
359
|
+
}
|
|
360
|
+
for (const { epoch, wrapped } of answer.keys)
|
|
361
|
+
db.run(
|
|
362
|
+
"insert or replace into jam_store_keys (jam_id, epoch, wrapped) values (?, ?, ?)",
|
|
363
|
+
[jamId, epoch, JSON.stringify(wrapped)]
|
|
364
|
+
);
|
|
365
|
+
const offer =
|
|
366
|
+
jam.state === "invited" && jam.offer
|
|
367
|
+
? await offerOf(jamId, jam, members)
|
|
368
|
+
: null;
|
|
369
|
+
let lastSeq = before?.last_seq ?? 0;
|
|
370
|
+
let topEpoch = before?.top_epoch ?? 0;
|
|
371
|
+
let moved = false;
|
|
372
|
+
for (const event of answer.events) {
|
|
373
|
+
const key = await keyFor(jamId, event.epoch, members).catch((error) => {
|
|
374
|
+
log(
|
|
375
|
+
`jam ${jamId}: epoch ${event.epoch}'s key refused: ${error.message}`
|
|
376
|
+
);
|
|
377
|
+
return null;
|
|
378
|
+
});
|
|
379
|
+
// A key not in yet: what follows waits for it.
|
|
380
|
+
if (!key) break;
|
|
381
|
+
const author = members.find((member) => member.handle === event.author);
|
|
382
|
+
let body, refusal;
|
|
383
|
+
if (!author) refusal = "its author is not a member of the jam";
|
|
384
|
+
else if (event.epoch < topEpoch)
|
|
385
|
+
refusal = "it came under an older key after a newer one";
|
|
386
|
+
else
|
|
387
|
+
try {
|
|
388
|
+
body = await byAnyKey(author, (authorSigningKey) =>
|
|
389
|
+
openEvent({
|
|
390
|
+
jamId,
|
|
391
|
+
epoch: event.epoch,
|
|
392
|
+
seq: event.seq,
|
|
393
|
+
author: event.author,
|
|
394
|
+
key,
|
|
395
|
+
sealed: event.sealed,
|
|
396
|
+
authorSigningKey,
|
|
397
|
+
})
|
|
398
|
+
);
|
|
399
|
+
} catch (error) {
|
|
400
|
+
refusal = error.message;
|
|
401
|
+
}
|
|
402
|
+
if (!refusal && body) refusal = await agentRefusal(event, body, author);
|
|
403
|
+
if (refusal) log(`jam ${jamId}: refused event ${event.seq}: ${refusal}`);
|
|
404
|
+
keep(jamId, { ...event, body, refused: refusal });
|
|
405
|
+
lastSeq = event.seq;
|
|
406
|
+
if (!refusal) topEpoch = Math.max(topEpoch, event.epoch);
|
|
407
|
+
moved = true;
|
|
408
|
+
}
|
|
409
|
+
save(jamId, {
|
|
410
|
+
...fields,
|
|
411
|
+
members,
|
|
412
|
+
refusal: null,
|
|
413
|
+
offer,
|
|
414
|
+
last_seq: lastSeq,
|
|
415
|
+
top_epoch: topEpoch,
|
|
416
|
+
});
|
|
417
|
+
const who = (list) =>
|
|
418
|
+
JSON.stringify(
|
|
419
|
+
(list ?? []).map((member) => [member.handle, member.state])
|
|
420
|
+
);
|
|
421
|
+
if (
|
|
422
|
+
moved ||
|
|
423
|
+
offer ||
|
|
424
|
+
before?.state !== jam.state ||
|
|
425
|
+
Boolean(before?.ended) !== Boolean(jam.ended) ||
|
|
426
|
+
who(before?.members) !== who(members)
|
|
427
|
+
)
|
|
428
|
+
changed(jamId);
|
|
429
|
+
return { ok: true, more: Boolean(answer.more) && moved };
|
|
430
|
+
};
|
|
431
|
+
|
|
432
|
+
// The offer an invitation carried, opened under the newest key that opens it (a key may have changed since the owner
|
|
433
|
+
// sealed it) and checked against the owner's card; null with a log line when it does not open.
|
|
434
|
+
const offerOf = async (jamId, jam, members) => {
|
|
435
|
+
const owner = members.find((member) => member.role === "owner");
|
|
436
|
+
if (!owner) return null;
|
|
437
|
+
for (let epoch = jam.epoch; epoch >= 1; epoch -= 1) {
|
|
438
|
+
const key = await keyFor(jamId, epoch, members).catch(() => null);
|
|
439
|
+
if (!key) continue;
|
|
440
|
+
try {
|
|
441
|
+
return await openOffer({
|
|
442
|
+
jamId,
|
|
443
|
+
epoch,
|
|
444
|
+
to: (await me()).handle,
|
|
445
|
+
key,
|
|
446
|
+
sealed: jam.offer,
|
|
447
|
+
ownerSigningKey: owner.signingKey,
|
|
448
|
+
});
|
|
449
|
+
} catch {}
|
|
450
|
+
}
|
|
451
|
+
log(`jam ${jamId}: the invitation's offer does not open here`);
|
|
452
|
+
return null;
|
|
453
|
+
};
|
|
454
|
+
|
|
455
|
+
// A new key for everyone still in the jam, after a removal or a leaving. Harness takes the first computer's; another's comes back
|
|
456
|
+
// refused and reads the one that won.
|
|
457
|
+
const rotateOnce = async (jamId) => {
|
|
458
|
+
const row = rowOf(jamId);
|
|
459
|
+
const self = await me();
|
|
460
|
+
const epoch = row.epoch + 1;
|
|
461
|
+
const key = newJamKey();
|
|
462
|
+
const keys = [];
|
|
463
|
+
for (const member of row.members.filter((m) => IN.has(m.state)))
|
|
464
|
+
keys.push({
|
|
465
|
+
handle: member.handle,
|
|
466
|
+
wrapped: await wrapKey({
|
|
467
|
+
jamId,
|
|
468
|
+
epoch,
|
|
469
|
+
key,
|
|
470
|
+
to: member,
|
|
471
|
+
by: {
|
|
472
|
+
handle: self.handle,
|
|
473
|
+
signingPrivateKey: self.signingPrivateKey,
|
|
474
|
+
},
|
|
475
|
+
}),
|
|
476
|
+
});
|
|
477
|
+
const answer = await ask("jam_rotate", { jamId, epoch, keys });
|
|
478
|
+
if (answer.ok) log(`jam ${jamId}: new key for epoch ${epoch}`);
|
|
479
|
+
return answer;
|
|
480
|
+
};
|
|
481
|
+
|
|
482
|
+
const readNow = async (jamId) => {
|
|
483
|
+
for (let round = 0; round < 50; round += 1) {
|
|
484
|
+
const answer = await readOnce(jamId);
|
|
485
|
+
if (!answer.ok) return answer;
|
|
486
|
+
const row = rowOf(jamId);
|
|
487
|
+
if (row.rotate_due && row.state === "joined") {
|
|
488
|
+
const rotated = await rotateOnce(jamId);
|
|
489
|
+
// Refused for anything but another computer's key winning: said, not tried again and again.
|
|
490
|
+
if (!rotated.ok && rotated.epoch === undefined) return rotated;
|
|
491
|
+
continue;
|
|
492
|
+
}
|
|
493
|
+
if (!answer.more) return { ok: true };
|
|
494
|
+
}
|
|
495
|
+
return { ok: true };
|
|
496
|
+
};
|
|
497
|
+
|
|
498
|
+
// ---- what the person does ----
|
|
499
|
+
|
|
500
|
+
const view = (jamId) => {
|
|
501
|
+
const row = rowOf(jamId);
|
|
502
|
+
if (!row) return null;
|
|
503
|
+
return {
|
|
504
|
+
id: row.jam_id,
|
|
505
|
+
owner: row.owner,
|
|
506
|
+
role: row.role,
|
|
507
|
+
state: row.state,
|
|
508
|
+
epoch: row.epoch,
|
|
509
|
+
lastSeq: row.last_seq,
|
|
510
|
+
ended: Boolean(row.ended),
|
|
511
|
+
members: row.members.map(({ handle, role, state }) => ({
|
|
512
|
+
handle,
|
|
513
|
+
role,
|
|
514
|
+
state,
|
|
515
|
+
})),
|
|
516
|
+
...(row.state === "invited" && row.offer ? { offer: row.offer } : {}),
|
|
517
|
+
...(row.refusal ? { refusal: row.refusal } : {}),
|
|
518
|
+
};
|
|
519
|
+
};
|
|
520
|
+
const ready = () => {
|
|
521
|
+
if (!can()) throw new Error("this Harness does not keep jams yet");
|
|
522
|
+
};
|
|
523
|
+
|
|
524
|
+
/** A new jam, owned by the person, with its first key. Only jams.mjs starts one, from a repository. */
|
|
525
|
+
const create = async () => {
|
|
526
|
+
ready();
|
|
527
|
+
const self = await me();
|
|
528
|
+
const jamId = randomUUID();
|
|
529
|
+
const key = newJamKey();
|
|
530
|
+
const card = await signCard(
|
|
531
|
+
{
|
|
532
|
+
jamId,
|
|
533
|
+
handle: self.handle,
|
|
534
|
+
sealingKey: self.sealingKey,
|
|
535
|
+
signingKey: self.signingKey,
|
|
536
|
+
},
|
|
537
|
+
self.signingPrivateKey
|
|
538
|
+
);
|
|
539
|
+
const wrapped = await wrapKey({
|
|
540
|
+
jamId,
|
|
541
|
+
epoch: 1,
|
|
542
|
+
key,
|
|
543
|
+
to: self,
|
|
544
|
+
by: self,
|
|
545
|
+
});
|
|
546
|
+
const answer = await ask("jam_create", { jamId, card, key: wrapped });
|
|
547
|
+
if (!answer.ok) return answer;
|
|
548
|
+
await queued(jamId, () => readNow(jamId));
|
|
549
|
+
return { ok: true, jam: view(jamId) };
|
|
550
|
+
};
|
|
551
|
+
|
|
552
|
+
// The owner's card for a friend's computer in this jam, and every epoch's key wrapped to it.
|
|
553
|
+
const cardAndKeys = async (jamId, row, handle, friend, self) => {
|
|
554
|
+
const card = await signCard(
|
|
555
|
+
{ jamId, handle, ...friend },
|
|
556
|
+
self.signingPrivateKey
|
|
557
|
+
);
|
|
558
|
+
const keys = [];
|
|
559
|
+
for (let epoch = 1; epoch <= row.epoch; epoch += 1) {
|
|
560
|
+
const key = await keyFor(jamId, epoch, row.members);
|
|
561
|
+
if (!key)
|
|
562
|
+
return { ok: false, error: `this computer lacks epoch ${epoch}'s key` };
|
|
563
|
+
keys.push({
|
|
564
|
+
epoch,
|
|
565
|
+
wrapped: await wrapKey({
|
|
566
|
+
jamId,
|
|
567
|
+
epoch,
|
|
568
|
+
key,
|
|
569
|
+
to: { handle, sealingKey: friend.sealingKey },
|
|
570
|
+
by: self,
|
|
571
|
+
}),
|
|
572
|
+
});
|
|
573
|
+
}
|
|
574
|
+
return { ok: true, card, keys };
|
|
575
|
+
};
|
|
576
|
+
|
|
577
|
+
// In one jam the person owns: a new card for `handle` under `keys` and every epoch's key wrapped to them, unless
|
|
578
|
+
// their card already carries those keys (`resign`: signed again all the same, after the owner's own keys changed).
|
|
579
|
+
const rekeyIn = async (jamId, handle, keys, { resign = false } = {}) => {
|
|
580
|
+
const read = await readNow(jamId);
|
|
581
|
+
if (!read.ok) return read;
|
|
582
|
+
const row = rowOf(jamId);
|
|
583
|
+
if (row.role !== "owner" || row.ended) return { ok: true };
|
|
584
|
+
const member = row.members.find(
|
|
585
|
+
(each) => each.handle === handle && each.state === "joined"
|
|
586
|
+
);
|
|
587
|
+
if (!member) return { ok: true };
|
|
588
|
+
const self = await me();
|
|
589
|
+
if (
|
|
590
|
+
!resign &&
|
|
591
|
+
member.sealingKey === keys.sealingKey &&
|
|
592
|
+
member.signingKey === keys.signingKey
|
|
593
|
+
)
|
|
594
|
+
return { ok: true, same: true };
|
|
595
|
+
const given = await cardAndKeys(jamId, row, handle, keys, self);
|
|
596
|
+
if (!given.ok) return given;
|
|
597
|
+
const rekeyed = await ask("jam_rekey", {
|
|
598
|
+
jamId,
|
|
599
|
+
handle,
|
|
600
|
+
card: given.card,
|
|
601
|
+
keys: given.keys,
|
|
602
|
+
});
|
|
603
|
+
if (!rekeyed.ok) return rekeyed;
|
|
604
|
+
await readNow(jamId);
|
|
605
|
+
return { ok: true };
|
|
606
|
+
};
|
|
607
|
+
|
|
608
|
+
const ownedJams = () =>
|
|
609
|
+
db
|
|
610
|
+
.all("select jam_id from jam_store where role = 'owner'")
|
|
611
|
+
.map((row) => row.jam_id);
|
|
612
|
+
|
|
613
|
+
/**
|
|
614
|
+
* The owner, once a member's keys changed (followed along their links, or trusted after they started fresh;
|
|
615
|
+
* daemon.mjs), gives that member a new card and every epoch's key under it in each jam they own, so the member reads
|
|
616
|
+
* on without being invited again. A jam whose card for them already carries the keys is left as it is.
|
|
617
|
+
*/
|
|
618
|
+
const rekey = async (handle) => {
|
|
619
|
+
if (!can()) return { ok: true, jams: [] };
|
|
620
|
+
const friend = await friendKeys(handle);
|
|
621
|
+
if (!friend)
|
|
622
|
+
return { ok: false, error: `${handle}'s keys are not trusted here` };
|
|
623
|
+
const done = [];
|
|
624
|
+
for (const jamId of ownedJams()) {
|
|
625
|
+
const answer = await queued(jamId, () =>
|
|
626
|
+
rekeyIn(jamId, handle, friend)
|
|
627
|
+
).catch((error) => ({ ok: false, error: error.message }));
|
|
628
|
+
if (!answer.ok)
|
|
629
|
+
log(`jam ${jamId}: ${handle} not re-keyed: ${answer.error}`);
|
|
630
|
+
else if (!answer.same) done.push(jamId);
|
|
631
|
+
}
|
|
632
|
+
return { ok: true, jams: done };
|
|
633
|
+
};
|
|
634
|
+
|
|
635
|
+
/**
|
|
636
|
+
* The person's own keys changed (a device left their list): in each jam they own, their own card and every member's
|
|
637
|
+
* are signed again with the new keys, and every epoch's key is wrapped to their new keys, so everyone reads on.
|
|
638
|
+
*/
|
|
639
|
+
const rekeyOwned = async () => {
|
|
640
|
+
if (!can()) return { ok: true, jams: [] };
|
|
641
|
+
const done = [];
|
|
642
|
+
for (const jamId of ownedJams()) {
|
|
643
|
+
const answer = await queued(jamId, async () => {
|
|
644
|
+
const self = await me();
|
|
645
|
+
const own = await rekeyIn(
|
|
646
|
+
jamId,
|
|
647
|
+
self.handle,
|
|
648
|
+
{ sealingKey: self.sealingKey, signingKey: self.signingKey },
|
|
649
|
+
{ resign: true }
|
|
650
|
+
);
|
|
651
|
+
if (!own.ok) return own;
|
|
652
|
+
for (const member of rowOf(jamId)?.members ?? []) {
|
|
653
|
+
if (member.handle === self.handle || member.state !== "joined")
|
|
654
|
+
continue;
|
|
655
|
+
const friend = await friendKeys(member.handle);
|
|
656
|
+
if (!friend) continue;
|
|
657
|
+
const given = await rekeyIn(jamId, member.handle, friend, {
|
|
658
|
+
resign: true,
|
|
659
|
+
});
|
|
660
|
+
if (!given.ok) return given;
|
|
661
|
+
}
|
|
662
|
+
return { ok: true };
|
|
663
|
+
}).catch((error) => ({ ok: false, error: error.message }));
|
|
664
|
+
if (!answer.ok) log(`jam ${jamId}: not re-keyed: ${answer.error}`);
|
|
665
|
+
else done.push(jamId);
|
|
666
|
+
}
|
|
667
|
+
return { ok: true, jams: done };
|
|
668
|
+
};
|
|
669
|
+
|
|
670
|
+
/**
|
|
671
|
+
* The owner invites a friend: their card, every epoch's key wrapped to their computer, and `offer`, what they are
|
|
672
|
+
* shown before they join, sealed to them under the current key.
|
|
673
|
+
*/
|
|
674
|
+
const invite = (jamId, handle, offer = {}) =>
|
|
675
|
+
queued(jamId, async () => {
|
|
676
|
+
ready();
|
|
677
|
+
const read = await readNow(jamId);
|
|
678
|
+
if (!read.ok) return read;
|
|
679
|
+
const row = rowOf(jamId);
|
|
680
|
+
if (row.role !== "owner")
|
|
681
|
+
return { ok: false, error: "only the jam's owner invites" };
|
|
682
|
+
const friend = await friendKeys(handle);
|
|
683
|
+
if (!friend)
|
|
684
|
+
return {
|
|
685
|
+
ok: false,
|
|
686
|
+
error: `you can invite only your friends, once their computer's key is pinned here (${handle})`,
|
|
687
|
+
};
|
|
688
|
+
const self = await me();
|
|
689
|
+
const given = await cardAndKeys(jamId, row, handle, friend, self);
|
|
690
|
+
if (!given.ok) return given;
|
|
691
|
+
const { card, keys } = given;
|
|
692
|
+
const sealedOffer = await sealOffer({
|
|
693
|
+
jamId,
|
|
694
|
+
epoch: row.epoch,
|
|
695
|
+
to: handle,
|
|
696
|
+
key: await keyFor(jamId, row.epoch, row.members),
|
|
697
|
+
body: offer,
|
|
698
|
+
signingPrivateKey: self.signingPrivateKey,
|
|
699
|
+
});
|
|
700
|
+
const answer = await ask("jam_invite", {
|
|
701
|
+
jamId,
|
|
702
|
+
handle,
|
|
703
|
+
card,
|
|
704
|
+
keys,
|
|
705
|
+
offer: sealedOffer,
|
|
706
|
+
});
|
|
707
|
+
if (!answer.ok) return answer;
|
|
708
|
+
await readNow(jamId);
|
|
709
|
+
return { ok: true, jam: view(jamId) };
|
|
710
|
+
});
|
|
711
|
+
|
|
712
|
+
// A step the person takes in a jam (join, leave) or on a member (remove), then the jam read again: after a removal
|
|
713
|
+
// that is where the owner's computer makes the new key.
|
|
714
|
+
const step = (jamId, type, input = {}) =>
|
|
715
|
+
queued(jamId, async () => {
|
|
716
|
+
ready();
|
|
717
|
+
const answer = await ask(type, { jamId, ...input });
|
|
718
|
+
if (!answer.ok) return answer;
|
|
719
|
+
const read = await readNow(jamId);
|
|
720
|
+
return read.ok ? { ok: true, jam: view(jamId) } : read;
|
|
721
|
+
});
|
|
722
|
+
const join = (jamId) => step(jamId, "jam_join");
|
|
723
|
+
const leave = (jamId) => step(jamId, "jam_leave");
|
|
724
|
+
const remove = (jamId, handle) => step(jamId, "jam_remove", { handle });
|
|
725
|
+
|
|
726
|
+
// One try at adding an event at the next place in the current epoch; an answer with `retry` is tried again.
|
|
727
|
+
const appendOnce = async (jamId, row, key, body) => {
|
|
728
|
+
const self = await me();
|
|
729
|
+
const event = {
|
|
730
|
+
jamId,
|
|
731
|
+
epoch: row.epoch,
|
|
732
|
+
seq: row.last_seq + 1,
|
|
733
|
+
author: self.handle,
|
|
734
|
+
};
|
|
735
|
+
const sealed = await sealEvent({
|
|
736
|
+
...event,
|
|
737
|
+
key,
|
|
738
|
+
body,
|
|
739
|
+
signingPrivateKey: self.signingPrivateKey,
|
|
740
|
+
});
|
|
741
|
+
const answer = await ask("jam_append", {
|
|
742
|
+
jamId,
|
|
743
|
+
seq: event.seq,
|
|
744
|
+
epoch: event.epoch,
|
|
745
|
+
sealed,
|
|
746
|
+
});
|
|
747
|
+
if (!answer.ok) return answer;
|
|
748
|
+
keep(jamId, { ...event, body });
|
|
749
|
+
save(jamId, {
|
|
750
|
+
last_seq: event.seq,
|
|
751
|
+
top_epoch: Math.max(row.top_epoch, event.epoch),
|
|
752
|
+
});
|
|
753
|
+
changed(jamId);
|
|
754
|
+
return {
|
|
755
|
+
ok: true,
|
|
756
|
+
seq: event.seq,
|
|
757
|
+
online: Array.isArray(answer.online) ? answer.online : [],
|
|
758
|
+
};
|
|
759
|
+
};
|
|
760
|
+
// The jam read on, with this computer in it and holding its current key.
|
|
761
|
+
const current = async (jamId) => {
|
|
762
|
+
const read = await readNow(jamId);
|
|
763
|
+
if (!read.ok) return { refusal: read };
|
|
764
|
+
const row = rowOf(jamId);
|
|
765
|
+
if (row.state !== "joined")
|
|
766
|
+
return { refusal: { ok: false, error: "you are not in this jam" } };
|
|
767
|
+
const key = await keyFor(jamId, row.epoch, row.members);
|
|
768
|
+
if (!key)
|
|
769
|
+
return {
|
|
770
|
+
refusal: { ok: false, error: "this computer lacks the jam's key" },
|
|
771
|
+
};
|
|
772
|
+
return { row, key };
|
|
773
|
+
};
|
|
774
|
+
const tooLarge = (body) =>
|
|
775
|
+
Buffer.byteLength(JSON.stringify(body ?? null)) > MAX_BODY_BYTES;
|
|
776
|
+
|
|
777
|
+
/** Something the person adds to the jam, sealed and signed here, at the next place in the current epoch. */
|
|
778
|
+
const append = (jamId, body) =>
|
|
779
|
+
queued(jamId, async () => {
|
|
780
|
+
ready();
|
|
781
|
+
if (tooLarge(body))
|
|
782
|
+
return { ok: false, error: "that is too large for one jam entry" };
|
|
783
|
+
for (let attempt = 0; attempt < APPEND_TRIES; attempt += 1) {
|
|
784
|
+
const { row, key, refusal } = await current(jamId);
|
|
785
|
+
if (refusal) return refusal;
|
|
786
|
+
const answer = await appendOnce(jamId, row, key, body);
|
|
787
|
+
if (answer.ok || !answer.retry) return answer;
|
|
788
|
+
}
|
|
789
|
+
return { ok: false, error: "the jam kept moving; try again" };
|
|
790
|
+
});
|
|
791
|
+
|
|
792
|
+
/**
|
|
793
|
+
* A file added to the jam with the event that names it (docs/jam-plan.md J4.9). The bytes are sealed and signed here
|
|
794
|
+
* under the current epoch's key and put at Harness first; then `bodyOf(file)` is appended, `file` being { id, epoch,
|
|
795
|
+
* bytes, sha256 }, which every member's computer fetches it by. A key that changes in between seals the file again
|
|
796
|
+
* under the new one, so a file is never named under a later key than its own.
|
|
797
|
+
*/
|
|
798
|
+
const attach = (jamId, bytes, bodyOf) =>
|
|
799
|
+
queued(jamId, async () => {
|
|
800
|
+
ready();
|
|
801
|
+
if (!bytes?.length || bytes.length > MAX_FILE_BYTES)
|
|
802
|
+
return {
|
|
803
|
+
ok: false,
|
|
804
|
+
error: `a file in a jam is 1 byte to ${MAX_FILE_BYTES / 1024 / 1024} MB`,
|
|
805
|
+
};
|
|
806
|
+
const self = await me();
|
|
807
|
+
const sha256 = createHash("sha256").update(bytes).digest("hex");
|
|
808
|
+
let added = null;
|
|
809
|
+
for (let attempt = 0; attempt < APPEND_TRIES; attempt += 1) {
|
|
810
|
+
const { row, key, refusal } = await current(jamId);
|
|
811
|
+
if (refusal) return refusal;
|
|
812
|
+
if (added?.epoch !== row.epoch) {
|
|
813
|
+
const id = randomUUID();
|
|
814
|
+
const sealed = await sealFile({
|
|
815
|
+
jamId,
|
|
816
|
+
epoch: row.epoch,
|
|
817
|
+
author: self.handle,
|
|
818
|
+
fileId: id,
|
|
819
|
+
key,
|
|
820
|
+
bytes,
|
|
821
|
+
signingPrivateKey: self.signingPrivateKey,
|
|
822
|
+
});
|
|
823
|
+
const put = await ask(
|
|
824
|
+
"jam_file_put",
|
|
825
|
+
{ jamId, fileId: id, epoch: row.epoch, sealed },
|
|
826
|
+
FILE_WAIT
|
|
827
|
+
);
|
|
828
|
+
if (!put.ok && put.retry) continue;
|
|
829
|
+
if (!put.ok) return put;
|
|
830
|
+
added = { id, epoch: row.epoch, bytes: bytes.length, sha256 };
|
|
831
|
+
}
|
|
832
|
+
const body = bodyOf(added);
|
|
833
|
+
if (tooLarge(body))
|
|
834
|
+
return { ok: false, error: "that is too large for one jam entry" };
|
|
835
|
+
const answer = await appendOnce(jamId, row, key, body);
|
|
836
|
+
if (answer.ok) return { ...answer, file: added };
|
|
837
|
+
if (!answer.retry) return answer;
|
|
838
|
+
}
|
|
839
|
+
return { ok: false, error: "the jam kept moving; try again" };
|
|
840
|
+
});
|
|
841
|
+
|
|
842
|
+
/**
|
|
843
|
+
* A file someone added to the jam, by what their event named (`file`: { id, epoch, bytes, sha256 }) and its author:
|
|
844
|
+
* fetched from Harness, checked against the author's card and signature, opened under its epoch's key, and held to
|
|
845
|
+
* the size and hash the author's signed event gave. `{ ok, bytes }`, or why not; `gone` when it will never come
|
|
846
|
+
* (this person is out of the jam, or Harness has no such file for them).
|
|
847
|
+
*/
|
|
848
|
+
const file = async (jamId, named, author) => {
|
|
849
|
+
ready();
|
|
850
|
+
const row = rowOf(jamId);
|
|
851
|
+
if (row?.state !== "joined")
|
|
852
|
+
return { ok: false, gone: true, error: "you are not in this jam" };
|
|
853
|
+
const answer = await ask(
|
|
854
|
+
"jam_file_get",
|
|
855
|
+
{ jamId, fileId: String(named.id) },
|
|
856
|
+
FILE_WAIT
|
|
857
|
+
);
|
|
858
|
+
if (!answer.ok)
|
|
859
|
+
return {
|
|
860
|
+
...answer,
|
|
861
|
+
gone: /not in this jam|no such file/.test(String(answer.error)),
|
|
862
|
+
};
|
|
863
|
+
const kept = answer.file;
|
|
864
|
+
if (kept?.author !== author || kept?.epoch !== named.epoch)
|
|
865
|
+
return {
|
|
866
|
+
ok: false,
|
|
867
|
+
gone: true,
|
|
868
|
+
error: "Harness handed over a file other than the one the post named",
|
|
869
|
+
};
|
|
870
|
+
const writer = row.members.find((member) => member.handle === author);
|
|
871
|
+
if (!writer)
|
|
872
|
+
return {
|
|
873
|
+
ok: false,
|
|
874
|
+
gone: true,
|
|
875
|
+
error: "its author is not a member of the jam",
|
|
876
|
+
};
|
|
877
|
+
const key = await keyFor(jamId, named.epoch, row.members);
|
|
878
|
+
if (!key) return { ok: false, error: "this computer lacks that key" };
|
|
879
|
+
let bytes;
|
|
880
|
+
try {
|
|
881
|
+
bytes = await byAnyKey(writer, (authorSigningKey) =>
|
|
882
|
+
openFile({
|
|
883
|
+
jamId,
|
|
884
|
+
epoch: named.epoch,
|
|
885
|
+
author,
|
|
886
|
+
fileId: String(named.id),
|
|
887
|
+
key,
|
|
888
|
+
sealed: kept.sealed,
|
|
889
|
+
authorSigningKey,
|
|
890
|
+
})
|
|
891
|
+
);
|
|
892
|
+
} catch (error) {
|
|
893
|
+
return { ok: false, gone: true, error: error.message };
|
|
894
|
+
}
|
|
895
|
+
const sha256 = createHash("sha256").update(bytes).digest("hex");
|
|
896
|
+
if (bytes.length !== named.bytes || sha256 !== named.sha256)
|
|
897
|
+
return {
|
|
898
|
+
ok: false,
|
|
899
|
+
gone: true,
|
|
900
|
+
error: "the file is not the one its author's post named",
|
|
901
|
+
};
|
|
902
|
+
return { ok: true, bytes };
|
|
903
|
+
};
|
|
904
|
+
|
|
905
|
+
/** The jam as this computer has it: who is in it and its events after `after`, each opened or refused with why. */
|
|
906
|
+
const read = (jamId, { after = 0, limit = 200 } = {}) => {
|
|
907
|
+
const jam = view(jamId);
|
|
908
|
+
if (!jam) return { ok: false, error: "no such jam here" };
|
|
909
|
+
const events = db
|
|
910
|
+
.all(
|
|
911
|
+
"select * from jam_store_events where jam_id = ? and seq > ? order by seq limit ?",
|
|
912
|
+
[jamId, Number(after) || 0, Math.min(Number(limit) || 200, READ_LIMIT)]
|
|
913
|
+
)
|
|
914
|
+
.map((row) => ({
|
|
915
|
+
seq: row.seq,
|
|
916
|
+
epoch: row.epoch,
|
|
917
|
+
author: row.author,
|
|
918
|
+
createdAt: row.created_at,
|
|
919
|
+
...(row.refused
|
|
920
|
+
? { refused: row.refused }
|
|
921
|
+
: { body: JSON.parse(row.body) }),
|
|
922
|
+
}));
|
|
923
|
+
return { ok: true, jam, events };
|
|
924
|
+
};
|
|
925
|
+
|
|
926
|
+
/** Every jam the person is in or invited to, read on from where this computer was. */
|
|
927
|
+
const sync = async () => {
|
|
928
|
+
if (!can()) return { ok: true, jams: [] };
|
|
929
|
+
const listed = await ask("jam_list", {});
|
|
930
|
+
if (!listed.ok) return listed;
|
|
931
|
+
for (const jam of listed.jams) {
|
|
932
|
+
const here = rowOf(jam.id);
|
|
933
|
+
if (!IN.has(jam.state) && here?.state === jam.state) continue;
|
|
934
|
+
await queued(jam.id, () => readNow(jam.id)).catch((error) =>
|
|
935
|
+
log(`jam ${jam.id}: ${error.message}`)
|
|
936
|
+
);
|
|
937
|
+
}
|
|
938
|
+
return {
|
|
939
|
+
ok: true,
|
|
940
|
+
jams: listed.jams.map((jam) => view(jam.id)).filter(Boolean),
|
|
941
|
+
};
|
|
942
|
+
};
|
|
943
|
+
|
|
944
|
+
/** Harness told this computer a jam moved (jam_event, jam_changed): it reads on. */
|
|
945
|
+
const heard = (message) => {
|
|
946
|
+
const jamId = String(message.input?.jamId || "");
|
|
947
|
+
if (!/^[0-9a-f-]{36}$/.test(jamId) || !can()) return;
|
|
948
|
+
void queued(jamId, () => readNow(jamId)).catch((error) =>
|
|
949
|
+
log(`jam ${jamId}: ${error.message}`)
|
|
950
|
+
);
|
|
951
|
+
};
|
|
952
|
+
|
|
953
|
+
return {
|
|
954
|
+
create,
|
|
955
|
+
invite,
|
|
956
|
+
rekey,
|
|
957
|
+
rekeyOwned,
|
|
958
|
+
join,
|
|
959
|
+
leave,
|
|
960
|
+
remove,
|
|
961
|
+
append,
|
|
962
|
+
attach,
|
|
963
|
+
file,
|
|
964
|
+
read,
|
|
965
|
+
sync,
|
|
966
|
+
heard,
|
|
967
|
+
view,
|
|
968
|
+
};
|
|
969
|
+
}
|
|
970
|
+
|
|
971
|
+
/** What an agent's claim on a jam file is about: the file's SHA-256 (hex) and its name. */
|
|
972
|
+
export const fileClaimed = (sha256, name) =>
|
|
973
|
+
`${String(sha256 ?? "")}\n${String(name ?? "")}`;
|