@agentshouse/kit 0.2.1-cb997daca91ed → 0.2.1-cba216f2c559c
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 +14 -14
- package/dist/acp.js +54 -4
- package/dist/afk.js +17 -0
- package/dist/agents.js +58 -32
- package/dist/authority-main.js +1 -1
- package/dist/bridge.js +4 -4
- package/dist/building.js +7 -3
- package/dist/calls.js +12 -4
- package/dist/chunks.js +49 -0
- package/dist/clis.js +32 -50
- package/dist/connection.js +7 -45
- package/dist/conversations.js +193 -56
- package/dist/copies.js +275 -124
- package/dist/end.js +8 -2
- package/dist/events.js +66 -8
- package/dist/files.js +2 -2
- package/dist/git.js +44 -10
- package/dist/grok.js +39 -0
- package/dist/home.js +0 -7
- package/dist/login.js +2 -0
- package/dist/logout.js +1 -1
- package/dist/mcp.js +2 -0
- package/dist/parts.js +10 -0
- package/dist/placement.js +10 -18
- package/dist/resident.js +29 -27
- package/dist/scope.js +12 -4
- package/dist/scripts.js +255 -0
- package/dist/secret-input.js +1 -1
- package/dist/silence.js +28 -0
- package/dist/update.js +105 -154
- package/dist/wire.js +23 -5
- package/package.json +2 -2
- package/dist/clis-main.js +0 -23
- package/dist/web-wizard.js +0 -101
package/dist/copies.js
CHANGED
|
@@ -1,17 +1,31 @@
|
|
|
1
1
|
import { parse } from '@agentshouse/mdmodel';
|
|
2
|
-
import { randomUUID } from 'node:crypto';
|
|
2
|
+
import { createHash, randomUUID } from 'node:crypto';
|
|
3
3
|
import { mkdir, readFile, readdir, realpath, rename, rm, rmdir, stat, writeFile } from 'node:fs/promises';
|
|
4
4
|
import { dirname, join } from 'node:path';
|
|
5
5
|
import { finalRefusal, HouseRefusal, retrying } from './api.js';
|
|
6
|
+
import { chunkTexts, stagedChunks } from './chunks.js';
|
|
6
7
|
import { blobId, blobText, git, isText, HOUSE_REF, importCommits, localCopies, revision, run, succeeded, tree, } from './git.js';
|
|
8
|
+
import { paused } from './files.js';
|
|
7
9
|
import { kitHome } from './home.js';
|
|
8
10
|
import { operationId } from './operation.js';
|
|
9
11
|
import { refusalOf } from './refusals.js';
|
|
10
12
|
import { changed } from './translate.js';
|
|
11
|
-
import { relayed } from './relay.js';
|
|
12
13
|
const BRANCH = 'main';
|
|
13
14
|
const PROVENANCE = '_provenance';
|
|
14
15
|
const IDENTITY = { GIT_COMMITTER_NAME: 'Kit', GIT_COMMITTER_EMAIL: 'house-kit@localhost' };
|
|
16
|
+
const ROOMS = 'rooms/';
|
|
17
|
+
const ENUMERATE = '/kit/door/changes/enumerate';
|
|
18
|
+
const NOT_READY = 'not ready yet; Kit copies it once House has built it';
|
|
19
|
+
const STAGED_CHUNKS = 'house-chunks';
|
|
20
|
+
// A Room answered not ready is asked again on this schedule: its chunk build usually catches up within seconds, so the first asks come soon and the last repeats until it does.
|
|
21
|
+
const ASKED_AGAIN_MS = [1000, 2000, 3000, 5000, 8000, 11_000, 15_000];
|
|
22
|
+
class NotReady extends Error {
|
|
23
|
+
rooms;
|
|
24
|
+
constructor(rooms) {
|
|
25
|
+
super(NOT_READY);
|
|
26
|
+
this.rooms = rooms;
|
|
27
|
+
}
|
|
28
|
+
}
|
|
15
29
|
function causeOf(error) {
|
|
16
30
|
return error instanceof Error ? error.message : String(error);
|
|
17
31
|
}
|
|
@@ -72,6 +86,9 @@ function sidecar(path) {
|
|
|
72
86
|
function recordOf(key) {
|
|
73
87
|
return join(kitHome(), 'local-copies', `${key}.json`);
|
|
74
88
|
}
|
|
89
|
+
function stagingPrefix() {
|
|
90
|
+
return `.${createHash('sha256').update(kitHome()).digest('hex').slice(0, 16)}-`;
|
|
91
|
+
}
|
|
75
92
|
function rootOf(handle) {
|
|
76
93
|
return `/rooms/${handle}`;
|
|
77
94
|
}
|
|
@@ -99,32 +116,59 @@ async function removeFile(repository, path) {
|
|
|
99
116
|
return;
|
|
100
117
|
}
|
|
101
118
|
}
|
|
102
|
-
async function
|
|
119
|
+
async function readOnlyFiles(repository, held) {
|
|
103
120
|
const tracked = new Set((await git(repository, ['ls-files', '-z'])).split('\0'));
|
|
104
121
|
const holding = new Set(held);
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
|
|
109
|
-
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
|
|
122
|
+
return {
|
|
123
|
+
remove: async (path) => {
|
|
124
|
+
if (!holding.has(path))
|
|
125
|
+
return;
|
|
126
|
+
if (!tracked.has(path))
|
|
127
|
+
await removeFile(repository, path);
|
|
128
|
+
holding.delete(path);
|
|
129
|
+
},
|
|
130
|
+
place: async (path, content) => {
|
|
131
|
+
if (tracked.has(path))
|
|
132
|
+
return;
|
|
133
|
+
if (!holding.has(path) && (await exists(join(repository, path))))
|
|
134
|
+
return;
|
|
135
|
+
await writeText(join(repository, path), content);
|
|
136
|
+
holding.add(path);
|
|
137
|
+
},
|
|
138
|
+
held: () => [...holding].sort(),
|
|
139
|
+
};
|
|
140
|
+
}
|
|
141
|
+
async function readOnlyPlaced(repository, held, written, removed) {
|
|
142
|
+
const files = await readOnlyFiles(repository, held);
|
|
143
|
+
for (const path of removed)
|
|
144
|
+
await files.remove(path);
|
|
145
|
+
for (const [path, content] of written)
|
|
146
|
+
await files.place(path, content);
|
|
147
|
+
return files.held();
|
|
148
|
+
}
|
|
149
|
+
async function importedWhole(repository, scope, texts, commit, readOnly) {
|
|
150
|
+
const revisions = {};
|
|
151
|
+
async function* tracked() {
|
|
152
|
+
for await (const { path, content, revision: held, provenance } of texts) {
|
|
153
|
+
if (declaredWritable(path, scope)) {
|
|
154
|
+
revisions[path] = held;
|
|
155
|
+
yield [path, content];
|
|
156
|
+
}
|
|
157
|
+
else {
|
|
158
|
+
await readOnly.place(path, content);
|
|
159
|
+
}
|
|
160
|
+
if (provenance !== undefined)
|
|
161
|
+
await readOnly.place(sidecar(path), provenance);
|
|
162
|
+
}
|
|
163
|
+
}
|
|
164
|
+
return { house: await importCommits(repository, [{ ...commit, files: tracked() }]), revisions };
|
|
121
165
|
}
|
|
122
166
|
async function ruled(path, rules) {
|
|
123
167
|
if ((await readFile(path, 'utf8').catch(() => null)) !== rules)
|
|
124
168
|
await writeFile(path, rules);
|
|
125
169
|
}
|
|
126
170
|
async function ignoreRules(repository, writable, copy) {
|
|
127
|
-
const readOnly =
|
|
171
|
+
const readOnly = copy.read_only.filter((path) => !path.split('/').includes(PROVENANCE));
|
|
128
172
|
const protectedPath = (path) => copy.protected.some((prefix) => prefix !== '' && covers(path, prefix));
|
|
129
173
|
const whole = copy.protected.filter((prefix) => prefix !== '' && !writable.some((path) => covers(path, prefix)));
|
|
130
174
|
const house = [
|
|
@@ -184,6 +228,7 @@ export class LocalCopies {
|
|
|
184
228
|
house;
|
|
185
229
|
copies = new Map();
|
|
186
230
|
queues = new Map();
|
|
231
|
+
waiting = new Set();
|
|
187
232
|
answering = Promise.resolve();
|
|
188
233
|
constructor(house) {
|
|
189
234
|
this.house = house;
|
|
@@ -191,7 +236,7 @@ export class LocalCopies {
|
|
|
191
236
|
key: 'owner',
|
|
192
237
|
submit: async (operation, changes) => {
|
|
193
238
|
try {
|
|
194
|
-
const outcome = await retrying(() => house.post('/kit/door/batch', { operation_id: operation, changes }));
|
|
239
|
+
const outcome = await retrying(() => house.post('/kit/door/files/batch', { operation_id: operation, changes }));
|
|
195
240
|
return { accepted: outcome.contents };
|
|
196
241
|
}
|
|
197
242
|
catch (error) {
|
|
@@ -215,6 +260,13 @@ export class LocalCopies {
|
|
|
215
260
|
this.copies.set(copy.key, copy);
|
|
216
261
|
}
|
|
217
262
|
}
|
|
263
|
+
async swept() {
|
|
264
|
+
const rooms = join(localCopies(), 'rooms');
|
|
265
|
+
for (const name of await readdir(rooms).catch(() => [])) {
|
|
266
|
+
if (name.startsWith(stagingPrefix()))
|
|
267
|
+
await rm(join(rooms, name), { recursive: true, force: true });
|
|
268
|
+
}
|
|
269
|
+
}
|
|
218
270
|
async mapping() {
|
|
219
271
|
await this.answering;
|
|
220
272
|
return [...this.copies.values()]
|
|
@@ -243,9 +295,9 @@ export class LocalCopies {
|
|
|
243
295
|
return answered;
|
|
244
296
|
}
|
|
245
297
|
async fetched(refreshing, rooms) {
|
|
246
|
-
const { local_copy: answer } = await this.house.post('/kit/local-
|
|
247
|
-
const synced = new Map(answer.rooms.map((room) => [
|
|
248
|
-
const named = rooms === undefined ? null : new Set(rooms.map((room) =>
|
|
298
|
+
const { local_copy: answer } = await this.house.post('/kit/local-copies/selection/read', rooms === undefined ? {} : { rooms });
|
|
299
|
+
const synced = new Map(answer.rooms.map((room) => [`${ROOMS}${room.room_ref}`, room.room_handle]));
|
|
300
|
+
const named = rooms === undefined ? null : new Set(rooms.map((room) => `${ROOMS}${room}`));
|
|
249
301
|
const held = () => [...this.copies.values()].filter((copy) => named === null || named.has(copy.key));
|
|
250
302
|
return this.holding([...new Set([...held().map((copy) => copy.key), ...synced.keys()])].sort(), async () => {
|
|
251
303
|
const said = [];
|
|
@@ -259,11 +311,12 @@ export class LocalCopies {
|
|
|
259
311
|
said.push(`${rootOf(copy.room_handle)}: no longer followed; kept as it is`);
|
|
260
312
|
}
|
|
261
313
|
const current = [];
|
|
314
|
+
const wanted = new Map();
|
|
262
315
|
for (const [key, handle] of synced) {
|
|
263
316
|
try {
|
|
264
317
|
const held = this.copies.get(key);
|
|
265
318
|
if (held === undefined || !(await exists(held.repository))) {
|
|
266
|
-
|
|
319
|
+
wanted.set(key, handle);
|
|
267
320
|
continue;
|
|
268
321
|
}
|
|
269
322
|
const { unfollowed, ...followed } = held;
|
|
@@ -274,18 +327,62 @@ export class LocalCopies {
|
|
|
274
327
|
said.push(`${rootOf(handle)}: ${causeOf(error)}`);
|
|
275
328
|
}
|
|
276
329
|
}
|
|
277
|
-
|
|
278
|
-
|
|
279
|
-
|
|
280
|
-
|
|
330
|
+
const unready = [];
|
|
331
|
+
const unsettled = [];
|
|
332
|
+
if (wanted.size > 0) {
|
|
333
|
+
const { authorities } = await this.discovered([...wanted.values()]);
|
|
334
|
+
for (const [key, handle] of wanted) {
|
|
335
|
+
const authority = authorities.find((entry) => `${ROOMS}${entry.room_ref}` === key);
|
|
336
|
+
try {
|
|
337
|
+
if (authority === undefined)
|
|
338
|
+
throw new Error('House serves nothing of it to copy');
|
|
339
|
+
said.push(await this.copied({ key, handle, authority }));
|
|
340
|
+
}
|
|
341
|
+
catch (error) {
|
|
342
|
+
if (error instanceof NotReady) {
|
|
343
|
+
unready.push(...error.rooms);
|
|
344
|
+
said.push(`${rootOf(handle)}: ${NOT_READY}`);
|
|
345
|
+
}
|
|
346
|
+
else {
|
|
347
|
+
refused = true;
|
|
348
|
+
unsettled.push(key.slice(ROOMS.length));
|
|
349
|
+
said.push(`${rootOf(handle)}: ${causeOf(error)}`);
|
|
350
|
+
}
|
|
351
|
+
}
|
|
352
|
+
}
|
|
353
|
+
}
|
|
354
|
+
const reading = refreshing ? current : current.filter((copy) => this.waiting.has(copy.room_ref));
|
|
355
|
+
if (reading.length > 0) {
|
|
356
|
+
const failed = await this.refreshed(reading, unready).then(() => null, houseCause);
|
|
357
|
+
for (const copy of reading) {
|
|
358
|
+
said.push(...(unready.includes(copy.room_ref) ? [`${rootOf(copy.room_handle)}: ${NOT_READY}`] : moved(copy, this.copies.get(copy.key))));
|
|
359
|
+
}
|
|
281
360
|
if (failed !== null) {
|
|
282
361
|
refused = true;
|
|
362
|
+
unsettled.push(...reading.map((copy) => copy.room_ref));
|
|
283
363
|
said.push(failed);
|
|
284
364
|
}
|
|
285
365
|
}
|
|
366
|
+
for (const room of rooms ?? [...this.waiting]) {
|
|
367
|
+
if (!unready.includes(room) && !unsettled.includes(room))
|
|
368
|
+
this.waiting.delete(room);
|
|
369
|
+
}
|
|
370
|
+
const due = unready.filter((room) => !this.waiting.has(room));
|
|
371
|
+
for (const room of due)
|
|
372
|
+
this.waiting.add(room);
|
|
373
|
+
if (due.length > 0)
|
|
374
|
+
void this.askedAgain(due);
|
|
286
375
|
return { refused, text: said.length === 0 ? 'Nothing new from House.' : said.join('\n') };
|
|
287
376
|
});
|
|
288
377
|
}
|
|
378
|
+
async askedAgain(rooms) {
|
|
379
|
+
let asking = rooms;
|
|
380
|
+
for (let step = 0; asking.length > 0; step++) {
|
|
381
|
+
await paused(ASKED_AGAIN_MS[Math.min(step, ASKED_AGAIN_MS.length - 1)]);
|
|
382
|
+
await this.selected().catch(logged);
|
|
383
|
+
asking = asking.filter((room) => this.waiting.has(room));
|
|
384
|
+
}
|
|
385
|
+
}
|
|
289
386
|
async observed(report) {
|
|
290
387
|
const key = await this.keyAt(dirname(report.common));
|
|
291
388
|
if (key === undefined)
|
|
@@ -347,132 +444,170 @@ export class LocalCopies {
|
|
|
347
444
|
this.copies.set(copy.key, copy);
|
|
348
445
|
return copy;
|
|
349
446
|
}
|
|
350
|
-
async
|
|
351
|
-
const
|
|
352
|
-
const
|
|
353
|
-
|
|
354
|
-
|
|
355
|
-
|
|
356
|
-
|
|
357
|
-
|
|
358
|
-
|
|
359
|
-
|
|
360
|
-
|
|
361
|
-
|
|
362
|
-
|
|
363
|
-
|
|
364
|
-
|
|
365
|
-
|
|
366
|
-
|
|
367
|
-
|
|
368
|
-
|
|
369
|
-
|
|
370
|
-
|
|
371
|
-
for (const file of view.manifest.files) {
|
|
372
|
-
const content = contents.get(file.path);
|
|
373
|
-
if (file.writable) {
|
|
374
|
-
read.writable.set(file.path, content);
|
|
375
|
-
read.revisions[file.path] = file.revision;
|
|
376
|
-
}
|
|
377
|
-
else {
|
|
378
|
-
read.readOnly.set(file.path, content);
|
|
447
|
+
async discovered(handles) {
|
|
448
|
+
const discover = (group) => this.house.post('/kit/door/rooms/discover', { prefixes: group.map(rootOf) });
|
|
449
|
+
const [first, ...rest] = handles;
|
|
450
|
+
const { bounds, authorities } = await discover([first]);
|
|
451
|
+
for (const group of grouped(rest, bounds.max_prefixes))
|
|
452
|
+
authorities.push(...(await discover(group)).authorities);
|
|
453
|
+
return { bounds, authorities };
|
|
454
|
+
}
|
|
455
|
+
async chunked(root, room, directory) {
|
|
456
|
+
await mkdir(directory, { recursive: true });
|
|
457
|
+
for (let renewed = false;; renewed = true) {
|
|
458
|
+
const { rooms } = await this.house.post('/kit/door/room-chunks/list', { prefixes: [root] });
|
|
459
|
+
const list = rooms.find((entry) => entry.room_ref === room);
|
|
460
|
+
if (list === undefined)
|
|
461
|
+
throw new Error('House serves nothing of it to copy');
|
|
462
|
+
if (!list.ready)
|
|
463
|
+
throw new NotReady([room]);
|
|
464
|
+
const held = new Set(await readdir(directory));
|
|
465
|
+
const failure = await stagedChunks(directory, list.chunks.filter(({ hash }) => !held.has(hash)));
|
|
466
|
+
if (failure === undefined) {
|
|
467
|
+
return { position: list.position, log_epoch: list.log_epoch, texts: chunkTexts(directory, list.chunks, list.models) };
|
|
379
468
|
}
|
|
380
|
-
if (
|
|
381
|
-
|
|
469
|
+
if (renewed && (await readdir(directory)).length === held.size)
|
|
470
|
+
throw failure;
|
|
382
471
|
}
|
|
383
|
-
return read;
|
|
384
472
|
}
|
|
385
|
-
async
|
|
386
|
-
const
|
|
387
|
-
if (read === null)
|
|
388
|
-
throw new Error('House serves nothing of it to copy');
|
|
389
|
-
const repository = join(localCopies(), 'rooms', read.anchor);
|
|
473
|
+
async materialized({ key, handle, authority }, whole) {
|
|
474
|
+
const repository = join(localCopies(), 'rooms', authority.room_ref);
|
|
390
475
|
if (await exists(repository))
|
|
391
476
|
throw new Error(`${repository} already exists and Kit leaves it as it is`);
|
|
392
|
-
const staging = join(dirname(repository),
|
|
477
|
+
const staging = join(dirname(repository), `${stagingPrefix()}${randomUUID()}`);
|
|
478
|
+
const scope = { write: authority.operations.write, protected: authority.protected_paths };
|
|
393
479
|
await mkdir(staging, { recursive: true });
|
|
394
|
-
let
|
|
395
|
-
let readOnly;
|
|
480
|
+
let copy;
|
|
396
481
|
try {
|
|
397
482
|
await git(staging, ['init', '-q', '-b', BRANCH]);
|
|
398
|
-
|
|
399
|
-
|
|
400
|
-
|
|
483
|
+
const read = await whole(join(staging, '.git', STAGED_CHUNKS));
|
|
484
|
+
const readOnly = await readOnlyFiles(staging, []);
|
|
485
|
+
const { house, revisions } = await importedWhole(staging, scope, read.texts, { message: `House ${rootOf(handle)}`, from: null }, readOnly);
|
|
401
486
|
await git(staging, ['update-ref', `refs/heads/${BRANCH}`, house]);
|
|
402
487
|
await git(staging, ['reset', '-q', '--hard']);
|
|
403
|
-
|
|
404
|
-
|
|
488
|
+
copy = {
|
|
489
|
+
key,
|
|
490
|
+
room_ref: authority.room_ref,
|
|
491
|
+
room_handle: handle,
|
|
492
|
+
repository,
|
|
493
|
+
house,
|
|
494
|
+
position: read.position,
|
|
495
|
+
log_epoch: read.log_epoch,
|
|
496
|
+
...scope,
|
|
497
|
+
read_only: readOnly.held(),
|
|
498
|
+
manifests: { [house]: { parent: null, files: revisions } },
|
|
499
|
+
moves: [],
|
|
500
|
+
};
|
|
501
|
+
await ignoreRules(staging, Object.keys(revisions), copy);
|
|
502
|
+
await rm(join(staging, '.git', STAGED_CHUNKS), { recursive: true, force: true });
|
|
405
503
|
await rename(staging, repository);
|
|
406
504
|
}
|
|
407
505
|
catch (error) {
|
|
408
506
|
await rm(staging, { recursive: true, force: true });
|
|
409
507
|
throw error;
|
|
410
508
|
}
|
|
411
|
-
|
|
412
|
-
key,
|
|
413
|
-
room_ref: read.anchor,
|
|
414
|
-
room_handle: handle,
|
|
415
|
-
repository,
|
|
416
|
-
house,
|
|
417
|
-
position: read.position,
|
|
418
|
-
log_epoch: read.log_epoch,
|
|
419
|
-
write: read.write,
|
|
420
|
-
protected: read.protected,
|
|
421
|
-
read_only: readOnly,
|
|
422
|
-
manifests: { [house]: { parent: null, files: read.revisions } },
|
|
423
|
-
moves: [],
|
|
424
|
-
});
|
|
425
|
-
return `${rootOf(handle)}: copied to ${repository}`;
|
|
509
|
+
return this.save(copy);
|
|
426
510
|
}
|
|
427
|
-
async
|
|
428
|
-
const
|
|
429
|
-
|
|
430
|
-
|
|
431
|
-
|
|
432
|
-
|
|
433
|
-
|
|
434
|
-
|
|
435
|
-
|
|
436
|
-
|
|
437
|
-
|
|
438
|
-
|
|
439
|
-
|
|
440
|
-
|
|
441
|
-
|
|
442
|
-
|
|
443
|
-
|
|
444
|
-
|
|
445
|
-
|
|
446
|
-
|
|
447
|
-
|
|
511
|
+
async copied(wanted) {
|
|
512
|
+
const { handle, authority } = wanted;
|
|
513
|
+
const root = rootOf(handle);
|
|
514
|
+
let answer = null;
|
|
515
|
+
try {
|
|
516
|
+
if (!this.waiting.has(authority.room_ref)) {
|
|
517
|
+
answer = await this.house.post(ENUMERATE, {
|
|
518
|
+
prefixes: [root],
|
|
519
|
+
positions: [
|
|
520
|
+
{ authority: authority.room_ref, position: '0', log_epoch: authority.log_epoch, page: { through: authority.position, read: 0 } },
|
|
521
|
+
],
|
|
522
|
+
});
|
|
523
|
+
}
|
|
524
|
+
}
|
|
525
|
+
catch (error) {
|
|
526
|
+
if (expiredAuthority(error) !== authority.room_ref)
|
|
527
|
+
throw error;
|
|
528
|
+
}
|
|
529
|
+
const view = answer?.authorities.find((entry) => entry.authority === authority.room_ref);
|
|
530
|
+
if (answer !== null && view === undefined)
|
|
531
|
+
throw new Error('House serves nothing of it to copy');
|
|
532
|
+
if (view !== undefined && view.next === undefined) {
|
|
533
|
+
const texts = view.changes.filter((change) => !('removed' in change));
|
|
534
|
+
const copy = await this.materialized(wanted, async () => ({ position: view.position, log_epoch: view.log_epoch, texts }));
|
|
535
|
+
return `${root}: copied to ${copy.repository}`;
|
|
536
|
+
}
|
|
537
|
+
const copy = await this.materialized(wanted, (directory) => this.chunked(root, authority.room_ref, directory));
|
|
538
|
+
const [caught] = await this.caughtUp([copy], true);
|
|
539
|
+
await succeeded(copy.repository, ['merge', '--ff-only', '-q', caught.house]);
|
|
540
|
+
return `${root}: copied to ${copy.repository}`;
|
|
448
541
|
}
|
|
449
|
-
async
|
|
450
|
-
const
|
|
451
|
-
const
|
|
452
|
-
const {
|
|
453
|
-
|
|
454
|
-
|
|
542
|
+
async received(copy, authority) {
|
|
543
|
+
const root = rootOf(copy.room_handle);
|
|
544
|
+
const directory = join(copy.repository, '.git', STAGED_CHUNKS);
|
|
545
|
+
const scope = { write: authority.operations.write, protected: authority.protected_paths };
|
|
546
|
+
try {
|
|
547
|
+
const read = await this.chunked(root, copy.room_ref, directory);
|
|
548
|
+
const readOnly = await readOnlyFiles(copy.repository, copy.read_only);
|
|
549
|
+
for (const path of copy.read_only)
|
|
550
|
+
await readOnly.remove(path);
|
|
551
|
+
const commit = { message: `House ${root} at position ${read.position}`, from: copy.house, replaces: true };
|
|
552
|
+
const { house, revisions } = await importedWhole(copy.repository, scope, read.texts, commit, readOnly);
|
|
553
|
+
const next = {
|
|
554
|
+
...copy,
|
|
555
|
+
...scope,
|
|
556
|
+
house,
|
|
557
|
+
position: read.position,
|
|
558
|
+
log_epoch: read.log_epoch,
|
|
559
|
+
read_only: readOnly.held(),
|
|
560
|
+
manifests: { ...copy.manifests, [house]: { parent: null, files: revisions } },
|
|
561
|
+
};
|
|
562
|
+
await ignoreRules(copy.repository, Object.keys(revisions), next);
|
|
563
|
+
return next;
|
|
564
|
+
}
|
|
565
|
+
finally {
|
|
566
|
+
await rm(directory, { recursive: true, force: true });
|
|
567
|
+
}
|
|
568
|
+
}
|
|
569
|
+
async reread(copy) {
|
|
570
|
+
const { authorities } = await this.discovered([copy.room_handle]);
|
|
571
|
+
const authority = authorities.find((entry) => entry.room_ref === copy.room_ref);
|
|
572
|
+
if (authority === undefined)
|
|
573
|
+
throw new NotReady([copy.room_ref]);
|
|
574
|
+
return this.received(copy, authority);
|
|
575
|
+
}
|
|
576
|
+
async refreshed(copies, unready) {
|
|
577
|
+
const { bounds, authorities } = await this.discovered(copies.map((copy) => copy.room_handle));
|
|
578
|
+
const read = [];
|
|
455
579
|
const unchanged = [];
|
|
456
580
|
for (const copy of copies) {
|
|
457
581
|
const authority = authorities.find((entry) => entry.room_ref === copy.room_ref);
|
|
458
582
|
if (authority !== undefined &&
|
|
459
583
|
JSON.stringify([authority.operations.write, authority.protected_paths]) !== JSON.stringify([copy.write, copy.protected])) {
|
|
460
|
-
|
|
584
|
+
try {
|
|
585
|
+
read.push(await this.save(await this.received(copy, authority)));
|
|
586
|
+
}
|
|
587
|
+
catch (error) {
|
|
588
|
+
if (!(error instanceof NotReady))
|
|
589
|
+
throw error;
|
|
590
|
+
unready.push(...error.rooms);
|
|
591
|
+
}
|
|
461
592
|
}
|
|
462
593
|
else {
|
|
463
594
|
unchanged.push(copy);
|
|
464
595
|
}
|
|
465
596
|
}
|
|
466
597
|
for (const group of grouped(unchanged, bounds.max_prefixes))
|
|
467
|
-
await this.caughtUp(group, false);
|
|
598
|
+
await this.caughtUp(group, false, unready);
|
|
599
|
+
for (const group of grouped(read, bounds.max_prefixes))
|
|
600
|
+
await this.caughtUp(group, true, unready);
|
|
468
601
|
}
|
|
469
|
-
async caughtUp(copies, whole) {
|
|
602
|
+
async caughtUp(copies, whole, unready) {
|
|
470
603
|
const caught = new Map(copies.map((copy) => [copy.key, copy]));
|
|
604
|
+
const read = new Set();
|
|
605
|
+
const waiting = unready ?? [];
|
|
471
606
|
let asking = [...copies];
|
|
472
607
|
while (asking.length > 0) {
|
|
473
608
|
let answer;
|
|
474
609
|
try {
|
|
475
|
-
answer = await this.house.post(
|
|
610
|
+
answer = await this.house.post(ENUMERATE, {
|
|
476
611
|
prefixes: asking.map((copy) => rootOf(copy.room_handle)),
|
|
477
612
|
positions: asking.map((copy) => ({ authority: copy.room_ref, position: copy.position, log_epoch: copy.log_epoch })),
|
|
478
613
|
});
|
|
@@ -481,8 +616,22 @@ export class LocalCopies {
|
|
|
481
616
|
const expired = asking.find((copy) => copy.room_ref === expiredAuthority(error));
|
|
482
617
|
if (expired === undefined)
|
|
483
618
|
throw error;
|
|
484
|
-
caught.set(expired.key, await this.save(await this.received(expired)));
|
|
485
619
|
asking = asking.filter((copy) => copy !== expired);
|
|
620
|
+
if (read.has(expired.key)) {
|
|
621
|
+
waiting.push(expired.room_ref);
|
|
622
|
+
continue;
|
|
623
|
+
}
|
|
624
|
+
read.add(expired.key);
|
|
625
|
+
try {
|
|
626
|
+
const next = await this.save(await this.reread(expired));
|
|
627
|
+
caught.set(expired.key, next);
|
|
628
|
+
asking.push(next);
|
|
629
|
+
}
|
|
630
|
+
catch (refused) {
|
|
631
|
+
if (!(refused instanceof NotReady))
|
|
632
|
+
throw refused;
|
|
633
|
+
waiting.push(expired.room_ref);
|
|
634
|
+
}
|
|
486
635
|
continue;
|
|
487
636
|
}
|
|
488
637
|
const advanced = [];
|
|
@@ -494,8 +643,10 @@ export class LocalCopies {
|
|
|
494
643
|
caught.set(copy.key, next);
|
|
495
644
|
advanced.push(next);
|
|
496
645
|
}
|
|
497
|
-
asking =
|
|
646
|
+
asking = advanced.filter((copy) => whole || read.has(copy.key));
|
|
498
647
|
}
|
|
648
|
+
if (unready === undefined && waiting.length > 0)
|
|
649
|
+
throw new NotReady(waiting);
|
|
499
650
|
return copies.map((copy) => caught.get(copy.key));
|
|
500
651
|
}
|
|
501
652
|
async incorporated(copy, changes, position, logEpoch) {
|
|
@@ -598,7 +749,7 @@ export class LocalCopies {
|
|
|
598
749
|
const arrived = new Set(moved.values());
|
|
599
750
|
const arriving = [...after].filter(([path, entry]) => before.get(path) !== entry);
|
|
600
751
|
if (arriving.length > 0) {
|
|
601
|
-
const { bounds } = await this.house.post('/kit/door/discover', { prefixes: [root] });
|
|
752
|
+
const { bounds } = await this.house.post('/kit/door/rooms/discover', { prefixes: [root] });
|
|
602
753
|
const binary = [];
|
|
603
754
|
for (const [path, entry] of arriving) {
|
|
604
755
|
if (!(await isText(copy.repository, entry, bounds.max_authored_file_bytes)))
|
|
@@ -815,7 +966,7 @@ export class LocalCopies {
|
|
|
815
966
|
return true;
|
|
816
967
|
}
|
|
817
968
|
async revisionText(path, wanted) {
|
|
818
|
-
const page = await this.house.post('/kit/door/revisions', {
|
|
969
|
+
const page = await this.house.post('/kit/door/files/revisions/list', {
|
|
819
970
|
path,
|
|
820
971
|
revision: wanted,
|
|
821
972
|
});
|
package/dist/end.js
CHANGED
|
@@ -14,9 +14,15 @@ export function end(reason) {
|
|
|
14
14
|
export function restart(reason) {
|
|
15
15
|
exit(reason, 1);
|
|
16
16
|
}
|
|
17
|
-
export function
|
|
17
|
+
export function updateLine(lead) {
|
|
18
18
|
const command = installCommand();
|
|
19
|
-
|
|
19
|
+
return command === null ? `${lead}; install it again.` : `${lead}. Update it: ${command}`;
|
|
20
|
+
}
|
|
21
|
+
export function updateRequired() {
|
|
22
|
+
end(updateLine('This Kit is too old for House'));
|
|
23
|
+
}
|
|
24
|
+
export function unknownMethod(kind) {
|
|
25
|
+
return updateLine(`This Kit does not know ${kind}`);
|
|
20
26
|
}
|
|
21
27
|
export function newerThanHouse(release, command) {
|
|
22
28
|
end(`Kit ${KIT_RELEASE} is newer than this Building supports (Kit ${release}). Install Kit ${release}: ${command}`);
|