@agentshouse/mdruntime-adapter 0.1.0-cb5eef5f389d7 → 0.1.0-cb5f9883339ed
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 +2 -2
- package/dist/actions.d.ts +3 -65
- package/dist/actions.d.ts.map +1 -1
- package/dist/actions.js +3 -336
- package/dist/adapter.d.ts.map +1 -1
- package/dist/adapter.js +232 -345
- package/dist/app-reference.d.ts +2 -0
- package/dist/app-reference.d.ts.map +1 -0
- package/dist/app-reference.js +2 -0
- package/dist/crockford.d.ts +4 -0
- package/dist/crockford.d.ts.map +1 -0
- package/dist/crockford.js +3 -0
- package/dist/discovery.d.ts +13 -12
- package/dist/discovery.d.ts.map +1 -1
- package/dist/discovery.js +62 -51
- package/dist/history.d.ts +12 -0
- package/dist/history.d.ts.map +1 -0
- package/dist/history.js +91 -0
- package/dist/house-model.d.ts +2398 -0
- package/dist/house-model.d.ts.map +1 -0
- package/dist/house-model.js +1321 -0
- package/dist/index.d.ts +10 -2
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +9 -1
- package/dist/model.d.ts +5 -2
- package/dist/model.d.ts.map +1 -1
- package/dist/model.js +10 -29
- package/dist/part.d.ts +14 -0
- package/dist/part.d.ts.map +1 -0
- package/dist/part.js +90 -0
- package/dist/read.d.ts +47 -61
- package/dist/read.d.ts.map +1 -1
- package/dist/read.js +218 -275
- package/dist/refusal.d.ts +0 -3
- package/dist/refusal.d.ts.map +1 -1
- package/dist/refusal.js +0 -5
- package/dist/room-stream.d.ts +19 -0
- package/dist/room-stream.d.ts.map +1 -0
- package/dist/room-stream.js +57 -0
- package/dist/room-types.d.ts +7 -0
- package/dist/room-types.d.ts.map +1 -0
- package/dist/room-types.js +126 -0
- package/dist/site.d.ts.map +1 -1
- package/dist/site.js +103 -197
- package/dist/stream.d.ts +13 -14
- package/dist/stream.d.ts.map +1 -1
- package/dist/stream.js +186 -422
- package/dist/transport.d.ts +69 -39
- package/dist/transport.d.ts.map +1 -1
- package/dist/transport.js +53 -11
- package/dist/upload.d.ts +12 -0
- package/dist/upload.d.ts.map +1 -0
- package/dist/upload.js +63 -0
- package/dist/write.d.ts +16 -1
- package/dist/write.d.ts.map +1 -1
- package/dist/write.js +101 -55
- package/package.json +8 -4
- package/AGENTS.md +0 -309
- package/dist/gather.d.ts +0 -4
- package/dist/gather.d.ts.map +0 -1
- package/dist/gather.js +0 -45
- package/dist/handed.d.ts +0 -15
- package/dist/handed.d.ts.map +0 -1
- package/dist/handed.js +0 -38
- package/dist/referrer.d.ts +0 -7
- package/dist/referrer.d.ts.map +0 -1
- package/dist/referrer.js +0 -35
package/dist/adapter.js
CHANGED
|
@@ -1,46 +1,47 @@
|
|
|
1
|
-
import {
|
|
2
|
-
import {
|
|
3
|
-
import { gathered, gatheredEach, selections } from './gather.js';
|
|
1
|
+
import { stepped } from '@agentshouse/mdruntime';
|
|
2
|
+
import { capabilities, discoveredRoom, mapDiscovery, parseAuthorityChange, parseDiscovery, trackedFrom, } from './discovery.js';
|
|
4
3
|
import { createSiteAdapter } from './site.js';
|
|
5
|
-
import {
|
|
4
|
+
import { authorityRoot, bootstrapping, parseFileAddress, parseGrant, } from './read.js';
|
|
5
|
+
import { roomStreams } from './room-stream.js';
|
|
6
6
|
import { sha256Hex } from './digest.js';
|
|
7
|
-
import {
|
|
7
|
+
import { finishedUpload, houseUpload } from './upload.js';
|
|
8
8
|
import { houseAction } from './actions.js';
|
|
9
|
-
import { classifyDoor,
|
|
10
|
-
import { houseNotifications } from './stream.js';
|
|
11
|
-
import {
|
|
12
|
-
import { batchPaths, deltaBody, deltaBytes, deltaDigest, historyOutcome, houseChanges, mutationOutcome, operationHead, rejectedMapping, revisionBody, uploadable, } from './write.js';
|
|
13
|
-
import {
|
|
14
|
-
import { followsVersion, logPosition, presented, reachedVersion, roomVersion
|
|
9
|
+
import { classifyDoor, doorRefusal } from './refusal.js';
|
|
10
|
+
import { houseNotifications, } from './stream.js';
|
|
11
|
+
import { houseDoorRoute, } from './transport.js';
|
|
12
|
+
import { batchPaths, deltaBody, deltaBytes, deltaDigest, historyOutcome, houseChanges, houseMove, mutationOutcome, operationHead, rejectedMapping, revisionBody, uploadable, } from './write.js';
|
|
13
|
+
import { HOUSE_NAMEABLE_ROOM_TYPES, HOUSE_ROOM_TYPES } from './room-types.js';
|
|
14
|
+
import { followsVersion, logPosition, presented, reachedVersion, roomVersion } from './version.js';
|
|
15
15
|
const UNCERTAIN = { kind: 'transport-uncertainty' };
|
|
16
16
|
const UNCERTAIN_READ = { kind: 'transport-uncertainty' };
|
|
17
|
+
const OCTET_STREAM = 'application/octet-stream';
|
|
18
|
+
const EXPIRED_ADDRESS = 403;
|
|
17
19
|
function lapsedGrant(outcome) {
|
|
18
20
|
return outcome.kind === 'rejected' && outcome.code === 'upload_unavailable';
|
|
19
21
|
}
|
|
20
|
-
function heldFiles(authority, held,
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
const
|
|
24
|
-
|
|
25
|
-
.sort();
|
|
26
|
-
if (paths.length === 0)
|
|
27
|
-
return null;
|
|
28
|
-
const files = paths.slice(0, budget).map((path) => ({ path, revision: held.revisions[path] }));
|
|
29
|
-
return { room: authority, through: paths.length > budget ? files.at(-1).path : null, files };
|
|
22
|
+
async function heldFiles(authority, held, bound) {
|
|
23
|
+
const listed = await held.files(null, bound + 1);
|
|
24
|
+
const files = listed.slice(0, bound);
|
|
25
|
+
const through = listed.length > bound ? (files.at(-1)?.path ?? null) : null;
|
|
26
|
+
return files.length === 0 ? null : { room: authority, through, files };
|
|
30
27
|
}
|
|
31
28
|
async function reused(scope, held) {
|
|
32
29
|
const sent = new Set(scope.contents.map((entry) => entry.path));
|
|
33
30
|
const contents = [...scope.contents];
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
31
|
+
const asked = scope.files.filter((file) => file.binary === undefined && !sent.has(file.path));
|
|
32
|
+
if (asked.length === 0)
|
|
33
|
+
return scope;
|
|
34
|
+
if (held === undefined)
|
|
35
|
+
return null;
|
|
36
|
+
const kept = await held.contents(asked.map(({ path }) => path));
|
|
37
|
+
for (const file of asked) {
|
|
38
|
+
const found = kept.get(file.path);
|
|
39
|
+
if (found === undefined ||
|
|
40
|
+
found.revision !== file.revision ||
|
|
41
|
+
(await sha256Hex(found.content)) !== file.sha256) {
|
|
41
42
|
return null;
|
|
42
43
|
}
|
|
43
|
-
contents.push({ path: file.path, content });
|
|
44
|
+
contents.push({ path: file.path, content: found.content });
|
|
44
45
|
}
|
|
45
46
|
return { ...scope, contents };
|
|
46
47
|
}
|
|
@@ -48,116 +49,84 @@ export function createAgentsHouseAdapter(options) {
|
|
|
48
49
|
if ('site' in options)
|
|
49
50
|
return createSiteAdapter(options.site, options.snapshot === true);
|
|
50
51
|
const transport = options.transport;
|
|
51
|
-
const notifications = houseNotifications(transport, 'credential'
|
|
52
|
+
const notifications = houseNotifications(transport, 'credential', {
|
|
53
|
+
opened: async (frame) => (frame === null ? null : opened(frame)),
|
|
54
|
+
changed,
|
|
55
|
+
});
|
|
52
56
|
const tracked = new Map();
|
|
53
|
-
const
|
|
57
|
+
const rooms = roomStreams('credential');
|
|
58
|
+
const unreused = new Set();
|
|
54
59
|
let bounds;
|
|
55
60
|
function declared() {
|
|
56
61
|
if (bounds === undefined)
|
|
57
62
|
throw new Error('no Discovery declared the bounds');
|
|
58
63
|
return bounds;
|
|
59
64
|
}
|
|
60
|
-
|
|
61
|
-
const
|
|
62
|
-
if (
|
|
63
|
-
return
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
? bootstrapTogether({ entry, held: undefined })
|
|
70
|
-
: continuedBootstrap({ entry, held: undefined }, continued);
|
|
71
|
-
}
|
|
72
|
-
const cursor = envelope.next?.room === entry.authority ? envelope.next : undefined;
|
|
73
|
-
const next = cursor?.path ?? null;
|
|
74
|
-
if (continued === null && next === null)
|
|
75
|
-
handed.set(entry.locator, scopeHanded(scope));
|
|
76
|
-
else
|
|
77
|
-
handed.delete(entry.locator);
|
|
78
|
-
notifications.reach(entry.authority, scope);
|
|
79
|
-
const seen = [
|
|
80
|
-
...(continued?.seen ?? []),
|
|
81
|
-
...entry.schemas.filter((schema) => scope.files.some((file) => file.path === schema)),
|
|
82
|
-
];
|
|
83
|
-
const models = await partModels(scope, entry, new Set(seen), next === null);
|
|
84
|
-
const continuation = next === null
|
|
85
|
-
? null
|
|
86
|
-
: { after: next, seen, ...(cursor?.cut === undefined ? {} : { cut: cursor.cut }) };
|
|
65
|
+
function opened(frame) {
|
|
66
|
+
const document = parseDiscovery(frame);
|
|
67
|
+
if (document === null)
|
|
68
|
+
return null;
|
|
69
|
+
bounds = document.bounds;
|
|
70
|
+
tracked.clear();
|
|
71
|
+
for (const entry of trackedFrom(document))
|
|
72
|
+
tracked.set(entry.locator, entry);
|
|
73
|
+
notifications.track([...tracked.values()]);
|
|
87
74
|
return {
|
|
88
|
-
...
|
|
89
|
-
|
|
90
|
-
...(continuation === null ? {} : { pageToken: JSON.stringify(continuation) }),
|
|
75
|
+
...mapDiscovery(document, document.authorities.map((authority) => discoveredRoom(authority)), capabilities(document.actions)),
|
|
76
|
+
member: document.member,
|
|
91
77
|
};
|
|
92
78
|
}
|
|
93
|
-
|
|
94
|
-
const
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
return UNCERTAIN_READ;
|
|
109
|
-
return (viewOf(enumeration, ask.entry) ?? { kind: 'room-not-readable', locator: ask.entry.locator });
|
|
79
|
+
function changed(frame) {
|
|
80
|
+
const change = parseAuthorityChange(frame);
|
|
81
|
+
if (change === null)
|
|
82
|
+
return null;
|
|
83
|
+
for (const locator of change.left)
|
|
84
|
+
tracked.delete(locator);
|
|
85
|
+
for (const entry of trackedFrom(change))
|
|
86
|
+
tracked.set(entry.locator, entry);
|
|
87
|
+
notifications.track([...tracked.values()]);
|
|
88
|
+
return {
|
|
89
|
+
kind: 'authority-changed',
|
|
90
|
+
rooms: change.authorities.map((authority) => discoveredRoom(authority)),
|
|
91
|
+
left: change.left,
|
|
92
|
+
member: change.member,
|
|
93
|
+
};
|
|
110
94
|
}
|
|
111
|
-
async function
|
|
112
|
-
const
|
|
113
|
-
if (
|
|
114
|
-
return
|
|
115
|
-
const
|
|
116
|
-
if (
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
95
|
+
async function streamedPage(entry, token, held) {
|
|
96
|
+
const part = await rooms.part(entry, token);
|
|
97
|
+
if ('kind' in part)
|
|
98
|
+
return part;
|
|
99
|
+
const scope = await reused(part.scope, held);
|
|
100
|
+
if (scope === null) {
|
|
101
|
+
unreused.add(entry.locator);
|
|
102
|
+
return UNCERTAIN_READ;
|
|
103
|
+
}
|
|
104
|
+
return {
|
|
105
|
+
...(await stepped(bootstrapping(scope))),
|
|
106
|
+
...(part.models === undefined ? {} : { models: part.models }),
|
|
107
|
+
...(part.pageToken === undefined ? {} : { pageToken: part.pageToken }),
|
|
108
|
+
bytes: part.bytes,
|
|
109
|
+
};
|
|
125
110
|
}
|
|
126
|
-
async function
|
|
127
|
-
const
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
|
|
111
|
+
async function openedRoom(entry, request) {
|
|
112
|
+
const reusing = unreused.delete(entry.locator) ? undefined : request.held;
|
|
113
|
+
const files = reusing === undefined
|
|
114
|
+
? null
|
|
115
|
+
: await heldFiles(entry.authority, reusing, declared().max_held_files);
|
|
116
|
+
const answered = await transport.streamed(houseDoorRoute('bootstrap'), {
|
|
117
|
+
prefixes: [authorityRoot(entry.handle)],
|
|
118
|
+
...(files === null ? {} : { held: [files] }),
|
|
119
|
+
}, request.signal ?? new AbortController().signal);
|
|
120
|
+
if (answered.room === null)
|
|
121
|
+
return classifyDoor(answered.status, answered.body, entry.locator) ?? UNCERTAIN_READ;
|
|
122
|
+
return rooms.head(entry, answered.room, request.arriving, request.signal);
|
|
136
123
|
}
|
|
137
124
|
function held(rooms) {
|
|
138
|
-
|
|
125
|
+
notifications.send(rooms.flatMap((room) => {
|
|
139
126
|
const entry = tracked.get(room.locator);
|
|
140
127
|
const at = logPosition(room.roomVersion);
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
handed.set(room.locator, heldHanded(room));
|
|
144
|
-
notifications.reach(entry.authority, at);
|
|
145
|
-
return [presented(entry.authority, at)];
|
|
146
|
-
});
|
|
147
|
-
notifications.send(kept);
|
|
148
|
-
}
|
|
149
|
-
function adopted(entry, outcome) {
|
|
150
|
-
if (outcome.kind !== 'accepted')
|
|
151
|
-
return outcome;
|
|
152
|
-
const held = handed.get(entry.locator);
|
|
153
|
-
if (held === undefined)
|
|
154
|
-
return outcome;
|
|
155
|
-
const follows = followsVersion(held.roomVersion, outcome.roomVersion);
|
|
156
|
-
handed.set(entry.locator, acceptedHanded(held, outcome, follows ? outcome.roomVersion : held.roomVersion));
|
|
157
|
-
const at = logPosition(outcome.roomVersion);
|
|
158
|
-
if (follows && at !== null)
|
|
159
|
-
notifications.reach(entry.authority, at);
|
|
160
|
-
return outcome;
|
|
128
|
+
return entry === undefined || at === null ? [] : [presented(entry.authority, at)];
|
|
129
|
+
}));
|
|
161
130
|
}
|
|
162
131
|
function authorityFor(locator) {
|
|
163
132
|
return tracked.get(locator);
|
|
@@ -176,127 +145,25 @@ export function createAgentsHouseAdapter(options) {
|
|
|
176
145
|
return result;
|
|
177
146
|
return { ...result, at: { locator, roomVersion: roomVersion({ position, logEpoch }) } };
|
|
178
147
|
}
|
|
179
|
-
function weight(entry) {
|
|
180
|
-
return contentPrefixes(entry).length;
|
|
181
|
-
}
|
|
182
|
-
function holding(asks, after) {
|
|
183
|
-
const budget = Math.floor(declared().max_held_files / Math.max(1, asks.filter((ask) => ask.held !== undefined).length));
|
|
184
|
-
return asks.flatMap((ask) => heldFiles(ask.entry.authority, ask.held, after, budget) ?? []);
|
|
185
|
-
}
|
|
186
|
-
async function bootstrapped(asks, answer) {
|
|
187
|
-
let open = asks.map((asked, ask) => ({ entry: asked.entry, asked, ask }));
|
|
188
|
-
while (open.length > 0) {
|
|
189
|
-
const unreached = [];
|
|
190
|
-
for (const part of selections(open, ({ entry }) => weight(entry), declared().max_prefixes)) {
|
|
191
|
-
const held = holding(part.map(({ asked }) => asked), null);
|
|
192
|
-
const answered = await transport.door(DOOR_BOOTSTRAP, {
|
|
193
|
-
prefixes: part.flatMap(({ entry }) => contentPrefixes(entry)),
|
|
194
|
-
...(held.length === 0 ? {} : { held }),
|
|
195
|
-
});
|
|
196
|
-
const classified = part.map(({ entry }) => classifyDoor(answered.status, answered.body, entry.locator));
|
|
197
|
-
const envelope = classified[0] === null ? parseEnvelope(answered.body) : null;
|
|
198
|
-
for (const [index, asked] of part.entries()) {
|
|
199
|
-
const failure = classified[index];
|
|
200
|
-
if (failure !== null && failure !== undefined) {
|
|
201
|
-
answer(asked.ask, failure);
|
|
202
|
-
continue;
|
|
203
|
-
}
|
|
204
|
-
if (envelope === null) {
|
|
205
|
-
answer(asked.ask, UNCERTAIN_READ);
|
|
206
|
-
continue;
|
|
207
|
-
}
|
|
208
|
-
const scope = envelope.scopes.find((candidate) => matchesScope(candidate, asked.entry));
|
|
209
|
-
if (scope === undefined && envelope.next !== undefined) {
|
|
210
|
-
unreached.push(asked);
|
|
211
|
-
continue;
|
|
212
|
-
}
|
|
213
|
-
answer(asked.ask, await bootstrappedRoom(envelope, scope, asked.asked, null));
|
|
214
|
-
}
|
|
215
|
-
}
|
|
216
|
-
open = unreached;
|
|
217
|
-
}
|
|
218
|
-
}
|
|
219
|
-
async function continuedBootstrap(asked, continued) {
|
|
220
|
-
const { entry } = asked;
|
|
221
|
-
const after = {
|
|
222
|
-
room: entry.authority,
|
|
223
|
-
path: continued.after,
|
|
224
|
-
...(continued.cut === undefined ? {} : { cut: continued.cut }),
|
|
225
|
-
};
|
|
226
|
-
const held = holding([asked], continued.after);
|
|
227
|
-
const answered = await transport.door(DOOR_BOOTSTRAP, {
|
|
228
|
-
prefixes: contentPrefixes(entry),
|
|
229
|
-
after,
|
|
230
|
-
...(held.length === 0 ? {} : { held }),
|
|
231
|
-
});
|
|
232
|
-
const failure = classifyRead(answered.status, answered.body, entry.locator);
|
|
233
|
-
if (failure !== null)
|
|
234
|
-
return failure;
|
|
235
|
-
const envelope = parseEnvelope(answered.body);
|
|
236
|
-
if (envelope === null)
|
|
237
|
-
return UNCERTAIN_READ;
|
|
238
|
-
const scope = envelope.scopes.find((candidate) => matchesScope(candidate, entry));
|
|
239
|
-
return bootstrappedRoom(envelope, scope, asked, continued);
|
|
240
|
-
}
|
|
241
|
-
function layered(asks) {
|
|
242
|
-
const depths = new Map();
|
|
243
|
-
const layers = [];
|
|
244
|
-
for (const ask of asks) {
|
|
245
|
-
const depth = depths.get(ask.entry.authority) ?? 0;
|
|
246
|
-
depths.set(ask.entry.authority, depth + 1);
|
|
247
|
-
(layers[depth] ??= []).push(ask);
|
|
248
|
-
}
|
|
249
|
-
return layers;
|
|
250
|
-
}
|
|
251
|
-
async function enumerated(asks) {
|
|
252
|
-
const answers = new Map();
|
|
253
|
-
const parts = layered(asks).flatMap((layer) => selections(layer, (ask) => weight(ask.entry), declared().max_prefixes));
|
|
254
|
-
for (const part of parts) {
|
|
255
|
-
let open = [...part];
|
|
256
|
-
while (open.length > 0) {
|
|
257
|
-
const answer = await transport.door(DOOR_ENUMERATE, {
|
|
258
|
-
prefixes: open.flatMap((ask) => contentPrefixes(ask.entry)),
|
|
259
|
-
positions: open.map((ask) => presented(ask.entry.authority, ask.from)),
|
|
260
|
-
});
|
|
261
|
-
const classified = open.map((ask) => classifyRead(answer.status, answer.body, ask.entry.locator));
|
|
262
|
-
if (classified[0]?.kind === 'beyond-horizon') {
|
|
263
|
-
const named = doorRefusal(answer.body)?.fields.authority;
|
|
264
|
-
const expired = open.filter((ask) => ask.entry.authority === named);
|
|
265
|
-
const answered = expired.length === 0 ? UNCERTAIN_READ : { kind: 'beyond-horizon' };
|
|
266
|
-
const gone = expired.length === 0 ? open : expired;
|
|
267
|
-
for (const ask of gone)
|
|
268
|
-
answers.set(ask, answered);
|
|
269
|
-
open = open.filter((ask) => !gone.includes(ask));
|
|
270
|
-
continue;
|
|
271
|
-
}
|
|
272
|
-
const enumeration = classified[0] === null ? parseEnumeration(answer.body, 'credential') : null;
|
|
273
|
-
for (const [index, ask] of open.entries()) {
|
|
274
|
-
const failure = classified[index];
|
|
275
|
-
if (failure !== null && failure !== undefined) {
|
|
276
|
-
answers.set(ask, failure);
|
|
277
|
-
continue;
|
|
278
|
-
}
|
|
279
|
-
answers.set(ask, enumeration === null ? UNCERTAIN_READ : await enumeratedRoom(enumeration, ask));
|
|
280
|
-
}
|
|
281
|
-
open = [];
|
|
282
|
-
}
|
|
283
|
-
}
|
|
284
|
-
return asks.map((ask) => answers.get(ask) ?? UNCERTAIN_READ);
|
|
285
|
-
}
|
|
286
|
-
const bootstrapTogether = gatheredEach(bootstrapped);
|
|
287
|
-
const enumerateTogether = gathered(enumerated);
|
|
288
148
|
async function uploaded(head, changes, delta, bytes, entry, handed, keep) {
|
|
289
149
|
const paths = batchPaths(changes);
|
|
290
150
|
const sha256 = await deltaDigest(delta);
|
|
291
151
|
if (handed !== undefined && handed.sha256 === sha256) {
|
|
292
152
|
return { body: { ...head, paths, upload: handed, runtime: notifications.runtime } };
|
|
293
153
|
}
|
|
294
|
-
const minted = await transport.door(
|
|
154
|
+
const minted = await transport.door(houseDoorRoute('batch-upload'), {
|
|
155
|
+
...head,
|
|
156
|
+
paths,
|
|
157
|
+
bytes,
|
|
158
|
+
sha256,
|
|
159
|
+
});
|
|
295
160
|
if (minted.status !== 200) {
|
|
296
|
-
return {
|
|
161
|
+
return {
|
|
162
|
+
outcome: await stepped(mutationOutcome(minted.status, minted.body, entry.locator, entry.handle)),
|
|
163
|
+
};
|
|
297
164
|
}
|
|
298
165
|
const grant = parseGrant(minted.body);
|
|
299
|
-
if (grant === null
|
|
166
|
+
if (grant === null)
|
|
300
167
|
return { outcome: UNCERTAIN };
|
|
301
168
|
const delivered = await transport.transfer({
|
|
302
169
|
act: 'authored_batch_upload',
|
|
@@ -306,52 +173,52 @@ export function createAgentsHouseAdapter(options) {
|
|
|
306
173
|
if (delivered.status !== 200)
|
|
307
174
|
return { outcome: UNCERTAIN };
|
|
308
175
|
const holding = parseGrant(delivered.body);
|
|
309
|
-
if (holding === null
|
|
176
|
+
if (holding === null)
|
|
310
177
|
return { outcome: UNCERTAIN };
|
|
311
178
|
const upload = { url: holding.url, operation: holding.operation, bytes, sha256 };
|
|
312
179
|
await keep(upload);
|
|
313
180
|
return { body: { ...head, paths, upload, runtime: notifications.runtime } };
|
|
314
181
|
}
|
|
315
|
-
async function staged(answer, batch) {
|
|
182
|
+
async function staged(answer, { changeBatch: batch, file }) {
|
|
316
183
|
const refusal = doorRefusal(answer.body);
|
|
317
184
|
if (refusal?.code !== 'files_unstaged')
|
|
318
185
|
return null;
|
|
319
|
-
const
|
|
320
|
-
if (!Array.isArray(
|
|
186
|
+
const uploads = refusal.fields.upload;
|
|
187
|
+
if (!Array.isArray(uploads))
|
|
321
188
|
return false;
|
|
322
|
-
for (const
|
|
323
|
-
const
|
|
324
|
-
const change = batch.changes.find((held) => held.kind === 'binary' && held.sha256 === sha256);
|
|
325
|
-
if (
|
|
189
|
+
for (const named of uploads) {
|
|
190
|
+
const upload = houseUpload(named);
|
|
191
|
+
const change = batch.changes.find((held) => held.kind === 'binary' && held.sha256 === named.sha256);
|
|
192
|
+
if (upload === null || change === undefined)
|
|
326
193
|
return false;
|
|
327
|
-
const
|
|
328
|
-
|
|
329
|
-
url,
|
|
330
|
-
body: change.blob,
|
|
331
|
-
operation,
|
|
332
|
-
});
|
|
333
|
-
if (delivered.status !== 200)
|
|
194
|
+
const finished = await finishedUpload(transport, upload, await file(change.localId));
|
|
195
|
+
if (finished?.body?.staged !== true)
|
|
334
196
|
return false;
|
|
335
197
|
}
|
|
336
198
|
return true;
|
|
337
199
|
}
|
|
338
|
-
async function submit(
|
|
200
|
+
async function submit(request, head, changes, delta, bytes, entry, handed, keep, into) {
|
|
339
201
|
const inline = { ...head, changes, runtime: notifications.runtime };
|
|
340
202
|
const prepared = uploadable(inline, bytes, declared())
|
|
341
203
|
? await uploaded(head, changes, delta, bytes, entry, handed, keep)
|
|
342
204
|
: { body: inline };
|
|
343
205
|
if ('outcome' in prepared)
|
|
344
206
|
return prepared.outcome;
|
|
345
|
-
const answer = await transport.door(
|
|
346
|
-
const stagedFiles = await staged(answer,
|
|
207
|
+
const answer = await transport.door(houseDoorRoute('batch'), prepared.body);
|
|
208
|
+
const stagedFiles = await staged(answer, request);
|
|
347
209
|
if (stagedFiles === false)
|
|
348
210
|
return UNCERTAIN;
|
|
349
|
-
const settled = stagedFiles === null ? answer : await transport.door(
|
|
350
|
-
if (stagedFiles === true && (await staged(settled,
|
|
211
|
+
const settled = stagedFiles === null ? answer : await transport.door(houseDoorRoute('batch'), prepared.body);
|
|
212
|
+
if (stagedFiles === true && (await staged(settled, request)) !== null)
|
|
351
213
|
return UNCERTAIN;
|
|
352
|
-
return mutationOutcome(settled.status, settled.body, entry.locator, entry.handle
|
|
214
|
+
return stepped(mutationOutcome(settled.status, settled.body, entry.locator, entry.handle, into === undefined
|
|
215
|
+
? undefined
|
|
216
|
+
: {
|
|
217
|
+
source: { authority: entry.authority, handle: entry.handle },
|
|
218
|
+
destination: { authority: into.authority, handle: into.handle },
|
|
219
|
+
}));
|
|
353
220
|
}
|
|
354
|
-
|
|
221
|
+
function addressed(answer, locator) {
|
|
355
222
|
const failure = classifyDoor(answer.status, answer.body, locator);
|
|
356
223
|
if (failure !== null) {
|
|
357
224
|
return failure.kind === 'scoped-refusal'
|
|
@@ -363,86 +230,102 @@ export function createAgentsHouseAdapter(options) {
|
|
|
363
230
|
}
|
|
364
231
|
: failure;
|
|
365
232
|
}
|
|
366
|
-
const
|
|
367
|
-
|
|
368
|
-
|
|
369
|
-
|
|
370
|
-
|
|
233
|
+
const address = parseFileAddress(answer.body);
|
|
234
|
+
return address === null ? UNCERTAIN_READ : { kind: 'address', ...address };
|
|
235
|
+
}
|
|
236
|
+
function linked(answer, locator) {
|
|
237
|
+
const address = addressed(answer, locator);
|
|
238
|
+
return address.kind === 'address'
|
|
239
|
+
? { kind: 'link', url: address.url, name: address.name, mediaType: address.mediaType }
|
|
240
|
+
: address;
|
|
241
|
+
}
|
|
242
|
+
function refusedAttach(answer, locator) {
|
|
243
|
+
const failure = classifyDoor(answer.status, answer.body, locator);
|
|
244
|
+
if (failure === null)
|
|
245
|
+
return null;
|
|
246
|
+
return failure.kind === 'scoped-refusal'
|
|
247
|
+
? {
|
|
248
|
+
kind: 'rejected',
|
|
249
|
+
code: failure.code,
|
|
250
|
+
fields: failure.fields,
|
|
251
|
+
retryable: failure.retryable,
|
|
252
|
+
}
|
|
253
|
+
: failure;
|
|
254
|
+
}
|
|
255
|
+
async function downloaded(ask, locator) {
|
|
256
|
+
let address = addressed(await ask(), locator);
|
|
257
|
+
if (address.kind !== 'address')
|
|
258
|
+
return address;
|
|
259
|
+
let read = await transport.download(address.url);
|
|
260
|
+
if (read.status === EXPIRED_ADDRESS) {
|
|
261
|
+
address = addressed(await ask(), locator);
|
|
262
|
+
if (address.kind !== 'address')
|
|
263
|
+
return address;
|
|
264
|
+
read = await transport.download(address.url);
|
|
265
|
+
}
|
|
266
|
+
if (read.status !== 200 || read.body === null)
|
|
371
267
|
return UNCERTAIN_READ;
|
|
372
|
-
return {
|
|
268
|
+
return {
|
|
269
|
+
kind: 'binary',
|
|
270
|
+
body: read.body,
|
|
271
|
+
mediaType: address.mediaType,
|
|
272
|
+
sha256: address.sha256,
|
|
273
|
+
};
|
|
274
|
+
}
|
|
275
|
+
function pathAddress(request) {
|
|
276
|
+
const entry = authorityFor(request.locator);
|
|
277
|
+
if (entry === undefined)
|
|
278
|
+
return null;
|
|
279
|
+
return () => transport.door(houseDoorRoute('files/get'), {
|
|
280
|
+
room_ref: entry.authority,
|
|
281
|
+
path: request.path,
|
|
282
|
+
revision: request.revision,
|
|
283
|
+
});
|
|
373
284
|
}
|
|
374
285
|
return {
|
|
286
|
+
roomTypes: HOUSE_ROOM_TYPES,
|
|
287
|
+
nameableRoomTypes: HOUSE_NAMEABLE_ROOM_TYPES,
|
|
375
288
|
async authorize() {
|
|
376
289
|
return options.authorize();
|
|
377
290
|
},
|
|
378
|
-
async discover(_authorization) {
|
|
379
|
-
const answer = await transport.door(DOOR_DISCOVER, { prefixes: [...DISCOVER_PREFIXES] });
|
|
380
|
-
const failed = discoveryFailure(answer.status, answer.body);
|
|
381
|
-
if (failed !== null)
|
|
382
|
-
return failed;
|
|
383
|
-
const document = parseDiscovery(answer.body);
|
|
384
|
-
if (document === null)
|
|
385
|
-
return { kind: 'transport-uncertainty' };
|
|
386
|
-
bounds = document.bounds;
|
|
387
|
-
const entries = trackedFrom(document);
|
|
388
|
-
tracked.clear();
|
|
389
|
-
for (const entry of entries)
|
|
390
|
-
tracked.set(entry.locator, entry);
|
|
391
|
-
for (const locator of handed.keys())
|
|
392
|
-
if (!tracked.has(locator))
|
|
393
|
-
handed.delete(locator);
|
|
394
|
-
notifications.track(entries);
|
|
395
|
-
return {
|
|
396
|
-
...mapDiscovery(document, document.authorities.map((authority) => discoveredRoom(authority)), capabilities(document)),
|
|
397
|
-
member: document.member,
|
|
398
|
-
};
|
|
399
|
-
},
|
|
400
291
|
async bootstrap(_authorization, request) {
|
|
401
292
|
const entry = authorityFor(request.locator);
|
|
402
293
|
if (entry === undefined)
|
|
403
294
|
return { kind: 'room-not-readable', locator: request.locator };
|
|
404
|
-
|
|
405
|
-
|
|
406
|
-
|
|
407
|
-
}
|
|
408
|
-
return bootstrapTogether(asked);
|
|
409
|
-
},
|
|
410
|
-
async refresh(_authorization, request) {
|
|
411
|
-
const entry = authorityFor(request.locator);
|
|
412
|
-
if (entry === undefined)
|
|
413
|
-
return { kind: 'room-not-readable', locator: request.locator };
|
|
414
|
-
if (request.pageToken !== undefined)
|
|
415
|
-
return { kind: 'transport-uncertainty' };
|
|
416
|
-
const from = logPosition(request.fromRoomVersion);
|
|
417
|
-
if (from === null)
|
|
418
|
-
return { kind: 'beyond-horizon' };
|
|
419
|
-
const answered = await streamed(entry, request, from);
|
|
420
|
-
if (answered !== null)
|
|
421
|
-
return answered;
|
|
422
|
-
return enumerateTogether({ entry, from, fromRoomVersion: request.fromRoomVersion });
|
|
295
|
+
return request.pageToken === undefined
|
|
296
|
+
? openedRoom(entry, request)
|
|
297
|
+
: streamedPage(entry, request.pageToken, request.held);
|
|
423
298
|
},
|
|
424
299
|
async mutate(_authorization, request, keep) {
|
|
425
300
|
const entry = authorityFor(request.locator);
|
|
426
301
|
if (entry === undefined)
|
|
427
302
|
return { kind: 'room-not-readable', locator: request.locator };
|
|
428
|
-
const
|
|
303
|
+
const batch = request.changeBatch;
|
|
304
|
+
const destination = batch.between?.destination.room;
|
|
305
|
+
const into = destination === undefined ? undefined : authorityFor(destination);
|
|
306
|
+
if (destination !== undefined && into === undefined) {
|
|
307
|
+
return { kind: 'room-not-readable', locator: destination };
|
|
308
|
+
}
|
|
309
|
+
const mapped = into === undefined
|
|
310
|
+
? houseChanges(batch, entry.handle)
|
|
311
|
+
: houseMove(batch, entry.handle, into.handle);
|
|
429
312
|
if (mapped.kind === 'unmapped')
|
|
430
313
|
return rejectedMapping(mapped);
|
|
431
|
-
const head = operationHead(
|
|
314
|
+
const head = operationHead(batch);
|
|
432
315
|
const delta = deltaBody(mapped.changes);
|
|
433
316
|
const bytes = deltaBytes(delta);
|
|
434
317
|
const handed = request.upload;
|
|
435
|
-
const
|
|
436
|
-
const outcome = await
|
|
318
|
+
const answer = (upload) => submit(request, head, mapped.changes, delta, bytes, entry, upload, keep, into);
|
|
319
|
+
const outcome = await answer(handed);
|
|
437
320
|
if (handed === undefined || !lapsedGrant(outcome))
|
|
438
|
-
return
|
|
439
|
-
return
|
|
321
|
+
return outcome;
|
|
322
|
+
return answer(undefined);
|
|
440
323
|
},
|
|
441
324
|
async history(_authorization, request) {
|
|
442
325
|
const entry = authorityFor(request.locator);
|
|
443
326
|
if (entry === undefined)
|
|
444
327
|
return { kind: 'room-not-readable', locator: request.locator };
|
|
445
|
-
const answer = await transport.door(
|
|
328
|
+
const answer = await transport.door(houseDoorRoute('revisions'), revisionBody({
|
|
446
329
|
path: request.path,
|
|
447
330
|
handle: entry.handle,
|
|
448
331
|
...(request.revision === undefined ? {} : { revision: request.revision }),
|
|
@@ -454,35 +337,45 @@ export function createAgentsHouseAdapter(options) {
|
|
|
454
337
|
});
|
|
455
338
|
},
|
|
456
339
|
async binary(_authorization, request) {
|
|
457
|
-
|
|
458
|
-
|
|
459
|
-
|
|
460
|
-
|
|
461
|
-
|
|
462
|
-
|
|
463
|
-
|
|
464
|
-
|
|
465
|
-
}
|
|
466
|
-
|
|
467
|
-
}
|
|
468
|
-
const referrer = houseReferrer(request.referrer, tracked);
|
|
469
|
-
if (referrer === null) {
|
|
470
|
-
return { kind: 'rejected', code: 'referrer_unknown', fields: {}, retryable: false };
|
|
471
|
-
}
|
|
472
|
-
const answer = await transport.door(DOOR_FILES_GET, {
|
|
473
|
-
file: request.fileRef,
|
|
474
|
-
referrer: referrer.referrer,
|
|
475
|
-
});
|
|
476
|
-
return downloaded(answer, referrer.locator);
|
|
340
|
+
const ask = pathAddress(request);
|
|
341
|
+
if (ask === null)
|
|
342
|
+
return { kind: 'room-not-readable', locator: request.locator };
|
|
343
|
+
return downloaded(ask, request.locator);
|
|
344
|
+
},
|
|
345
|
+
async link(_authorization, request) {
|
|
346
|
+
const ask = pathAddress(request);
|
|
347
|
+
if (ask === null)
|
|
348
|
+
return { kind: 'room-not-readable', locator: request.locator };
|
|
349
|
+
return linked(await ask(), request.locator);
|
|
477
350
|
},
|
|
478
|
-
|
|
479
|
-
const
|
|
480
|
-
if (
|
|
481
|
-
return
|
|
482
|
-
|
|
483
|
-
|
|
484
|
-
|
|
485
|
-
|
|
351
|
+
async attach(_authorization, request) {
|
|
352
|
+
const entry = authorityFor(request.locator);
|
|
353
|
+
if (entry === undefined)
|
|
354
|
+
return { kind: 'room-not-readable', locator: request.locator };
|
|
355
|
+
const declared = await transport.door(houseDoorRoute('files/attach'), {
|
|
356
|
+
room_ref: entry.authority,
|
|
357
|
+
name: request.name,
|
|
358
|
+
bytes: request.byteLength,
|
|
359
|
+
sha256: request.sha256,
|
|
360
|
+
media_type: request.mediaType.length > 0 ? request.mediaType : OCTET_STREAM,
|
|
361
|
+
});
|
|
362
|
+
const refused = refusedAttach(declared, request.locator);
|
|
363
|
+
if (refused !== null)
|
|
364
|
+
return refused;
|
|
365
|
+
const upload = houseUpload(declared.body?.upload);
|
|
366
|
+
if (upload === null)
|
|
367
|
+
return UNCERTAIN_READ;
|
|
368
|
+
const finished = await finishedUpload(transport, upload, request.blob);
|
|
369
|
+
if (finished === null)
|
|
370
|
+
return UNCERTAIN_READ;
|
|
371
|
+
const unfinished = refusedAttach(finished, request.locator);
|
|
372
|
+
if (unfinished !== null)
|
|
373
|
+
return unfinished;
|
|
374
|
+
const { path, revision } = (finished.body ?? {});
|
|
375
|
+
const root = `/rooms/${entry.handle}/`;
|
|
376
|
+
return typeof path === 'string' && path.startsWith(root) && typeof revision === 'string'
|
|
377
|
+
? { kind: 'attached', path: path.slice(root.length), revision }
|
|
378
|
+
: UNCERTAIN_READ;
|
|
486
379
|
},
|
|
487
380
|
reached(locator, version, target) {
|
|
488
381
|
return reachedVersion(version, target, authorityFor(locator)?.logEpoch);
|
|
@@ -495,13 +388,7 @@ export function createAgentsHouseAdapter(options) {
|
|
|
495
388
|
},
|
|
496
389
|
roomStream: {
|
|
497
390
|
hold: held,
|
|
498
|
-
reopen: notifications.reopen,
|
|
499
391
|
observe: notifications.observe,
|
|
500
|
-
published(locator, roomVersion) {
|
|
501
|
-
const at = logPosition(roomVersion);
|
|
502
|
-
if (at !== null)
|
|
503
|
-
notifications.published(locator, at);
|
|
504
|
-
},
|
|
505
392
|
},
|
|
506
393
|
conversations: notifications.conversations,
|
|
507
394
|
serviceMode: notifications.serviceMode,
|