@agentshouse/kit 0.2.1-c4ea88ba9424e → 0.2.1-c5d36e97b0fea

package/dist/copies.js

@@ -32,6 +32,22 @@ function rebaseFixes(refusal) {
 function short(commit) {
     return commit.slice(0, 12);
 }
+function moved(before, after) {
+    if (before.house !== after.house)
+        return [`${rootOf(after.room_handle)}: ${HOUSE_REF} is at ${short(after.house)}`];
+    return before.position === after.position ? [] : [`${rootOf(after.room_handle)}: read-only files refreshed`];
+}
+function expiredAuthority(error) {
+    if (!(error instanceof HouseRefusal))
+        return undefined;
+    try {
+        const { error: refused } = JSON.parse(error.text);
+        return refused?.code === 'position_expired' && typeof refused.authority === 'string' ? refused.authority : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 function covers(path, prefix) {
     return prefix === '' || path === prefix || path.startsWith(`${prefix}/`);
 }
@@ -152,7 +168,6 @@ export class LocalCopies {
     house;
     copies = new Map();
     queues = new Map();
-    delivering = new Set();
     selecting = Promise.resolve();
     constructor(house) {
         this.house = house;
@@ -191,36 +206,62 @@ export class LocalCopies {
             .map((copy) => `${rootOf(copy.room_handle)}: ${copy.repository}`)
             .sort();
     }
-    select() {
-        const selected = this.selecting.then(() => this.reselect());
+    async select() {
+        const selected = await this.selected(() => this.fetched(false));
+        if (selected.refused)
+            logged(selected.text);
+    }
+    fetch() {
+        return this.selected(() => this.fetched(true));
+    }
+    selected(work) {
+        const selected = this.selecting.then(work);
         this.selecting = selected.catch(() => undefined);
         return selected;
     }
-    async reselect() {
+    async fetched(refreshing) {
         const { local_copy: chosen } = await this.house.post('/kit/local-copy/selection', {});
-        const selected = (chosen?.rooms ?? []).flatMap((room) => room.room_handle === null ? [] : [{ key: `rooms/${room.room_ref}`, handle: room.room_handle }]);
-        const keys = new Set(selected.map((scope) => scope.key));
-        const work = [];
-        for (const key of this.copies.keys()) {
-            if (keys.has(key))
-                continue;
-            work.push(this.exclusive(key, async () => {
-                const copy = this.copies.get(key);
-                if (copy.active)
-                    await this.save({ ...copy, active: false });
-            }));
-        }
-        for (const scope of selected)
-            work.push(this.exclusive(scope.key, () => this.apply(scope)).catch(logged));
-        await Promise.all(work);
-    }
-    entries(frame) {
-        const copy = [...this.copies.values()].find((held) => held.active && held.room_ref === frame.authority);
-        if (copy === undefined)
-            return;
-        if (copy.log_epoch === frame.log_epoch && BigInt(frame.position) <= BigInt(copy.position))
-            return;
-        this.deliver(copy.key);
+        const selected = new Map(chosen.rooms.map((room) => [`rooms/${room.room_ref}`, room.room_handle]));
+        return this.holding([...new Set([...this.copies.keys(), ...selected.keys()])].sort(), async () => {
+            const said = [];
+            let refused = false;
+            for (const copy of this.copies.values()) {
+                if (selected.has(copy.key) || !copy.active)
+                    continue;
+                await this.save({ ...copy, active: false });
+                said.push(`${rootOf(copy.room_handle)}: no longer synced to this Environment; its files stay`);
+            }
+            const current = [];
+            for (const [key, handle] of selected) {
+                try {
+                    const held = this.copies.get(key);
+                    if (held === undefined || !(await exists(held.repository))) {
+                        said.push(await this.materialize(key, handle));
+                        continue;
+                    }
+                    const copy = held.room_handle === handle ? held : await this.save({ ...held, room_handle: handle });
+                    if (copy.active)
+                        current.push(copy);
+                    else
+                        said.push(...moved(copy, await this.save(await this.received({ ...copy, active: true }))));
+                }
+                catch (error) {
+                    refused = true;
+                    said.push(`${rootOf(handle)}: ${causeOf(error)}`);
+                }
+            }
+            if (refreshing && current.length > 0) {
+                try {
+                    const refreshed = await this.refreshed(current);
+                    current.forEach((copy, index) => said.push(...moved(copy, refreshed[index])));
+                }
+                catch (error) {
+                    refused = true;
+                    said.push(error instanceof HouseRefusal ? (refusalOf(error.text)?.text ?? causeOf(error)) : causeOf(error));
+                }
+            }
+            return { refused, text: said.length === 0 ? 'Nothing new from House.' : said.join('\n') };
+        });
     }
     async observed(report) {
         const key = await this.keyAt(dirname(report.common));
@@ -270,16 +311,9 @@ export class LocalCopies {
         this.queues.set(key, queued.catch(() => undefined));
         return queued;
     }
-    deliver(key) {
-        if (this.delivering.has(key))
-            return;
-        this.delivering.add(key);
-        void this.exclusive(key, async () => {
-            this.delivering.delete(key);
-            const copy = this.copies.get(key);
-            if (copy.active)
-                await this.save(await this.caughtUp(copy));
-        }).catch(logged);
+    holding(keys, work) {
+        const [key, ...rest] = keys;
+        return key === undefined ? work() : this.exclusive(key, () => this.holding(rest, work));
     }
     async save(copy) {
         const path = join(kitHome(), 'local-copies', `${copy.key}.json`);
@@ -325,46 +359,13 @@ export class LocalCopies {
         }
         return read;
     }
-    async apply(scope) {
-        let copy = this.copies.get(scope.key);
-        if (copy === undefined || !(await exists(copy.repository))) {
-            await this.materialize(scope);
-            return;
-        }
-        if (copy.room_handle !== scope.handle)
-            copy = await this.save({ ...copy, room_handle: scope.handle });
-        if (!copy.active) {
-            await this.save(await this.received({ ...copy, active: true }));
-            return;
-        }
-        const discovery = await this.house.post('/kit/door/discover', {
-            prefixes: [rootOf(copy.room_handle)],
-        });
-        const authority = discovery.authorities.find((entry) => entry.room_ref === copy.room_ref);
-        if (authority === undefined)
-            return;
-        if (authority.managed_replication !== 'admitted') {
-            logged(`operation_denied: ${rootOf(copy.room_handle)} is not synchronized to this Environment`);
-            return;
-        }
-        if (JSON.stringify([authority.operations.write, authority.protected_paths]) !==
-            JSON.stringify([copy.write, copy.protected])) {
-            await this.save(await this.received(copy));
-            return;
-        }
-        await this.save(await this.caughtUp(copy));
-    }
-    async materialize(scope) {
-        const read = await this.read(scope.handle);
-        if (read === null) {
-            logged(`House serves nothing of ${rootOf(scope.handle)} to copy`);
-            return;
-        }
+    async materialize(key, handle) {
+        const read = await this.read(handle);
+        if (read === null)
+            throw new Error('House serves nothing of it to copy');
         const repository = join(localCopies(), 'rooms', read.anchor);
-        if (await exists(repository)) {
-            logged(`${repository} already exists and House Kit leaves it as it is`);
-            return;
-        }
+        if (await exists(repository))
+            throw new Error(`${repository} already exists and House Kit leaves it as it is`);
         const staging = join(dirname(repository), `.${randomUUID()}`);
         await mkdir(staging, { recursive: true });
         let house;
@@ -372,7 +373,7 @@ export class LocalCopies {
         try {
             await git(staging, ['init', '-q', '-b', BRANCH]);
             house = await importCommits(staging, [
-                { message: `House ${rootOf(scope.handle)}`, from: null, files: read.writable },
+                { message: `House ${rootOf(handle)}`, from: null, files: read.writable },
             ]);
             await git(staging, ['update-ref', `refs/heads/${BRANCH}`, house]);
             await git(staging, ['reset', '-q', '--hard']);
@@ -385,9 +386,9 @@ export class LocalCopies {
             throw error;
         }
         await this.save({
-            key: scope.key,
+            key,
             room_ref: read.anchor,
-            room_handle: scope.handle,
+            room_handle: handle,
             repository,
             active: true,
             house,
@@ -399,6 +400,7 @@ export class LocalCopies {
             manifests: { [house]: { parent: null, files: read.revisions } },
             moves: [],
         });
+        return `${rootOf(handle)}: copied to ${repository}`;
     }
     async received(copy) {
         const read = await this.read(copy.room_handle);
@@ -422,29 +424,52 @@ export class LocalCopies {
         await ignoreRules(copy.repository, [...read.writable.keys()], next);
         return next;
     }
-    async caughtUp(start) {
-        let copy = start;
-        for (;;) {
+    async refreshed(copies) {
+        const discovery = await this.house.post('/kit/door/discover', {
+            prefixes: copies.map((copy) => rootOf(copy.room_handle)),
+        });
+        const regranted = new Map();
+        for (const copy of copies) {
+            const authority = discovery.authorities.find((entry) => entry.room_ref === copy.room_ref);
+            if (authority !== undefined &&
+                JSON.stringify([authority.operations.write, authority.protected_paths]) !== JSON.stringify([copy.write, copy.protected])) {
+                regranted.set(copy.key, await this.save(await this.received(copy)));
+            }
+        }
+        const caught = await this.caughtUp(copies.filter((copy) => !regranted.has(copy.key)), false);
+        return copies.map((copy) => regranted.get(copy.key) ?? caught.find((held) => held.key === copy.key));
+    }
+    async caughtUp(copies, whole) {
+        const caught = new Map(copies.map((copy) => [copy.key, copy]));
+        let asking = [...copies];
+        while (asking.length > 0) {
             let answer;
             try {
                 answer = await this.house.post('/kit/door/enumerate', {
-                    prefixes: [rootOf(copy.room_handle)],
-                    positions: [{ authority: copy.room_ref, position: copy.position, log_epoch: copy.log_epoch }],
+                    prefixes: asking.map((copy) => rootOf(copy.room_handle)),
+                    positions: asking.map((copy) => ({ authority: copy.room_ref, position: copy.position, log_epoch: copy.log_epoch })),
                 });
             }
             catch (error) {
-                const code = error instanceof HouseRefusal ? (refusalOf(error.text)?.code ?? null) : null;
-                if (code === 'position_expired')
-                    return this.received(copy);
-                if (code !== 'replica_behind')
+                const expired = asking.find((copy) => copy.room_ref === expiredAuthority(error));
+                if (expired === undefined)
                     throw error;
-                return copy;
+                caught.set(expired.key, await this.save(await this.received(expired)));
+                asking = asking.filter((copy) => copy !== expired);
+                continue;
+            }
+            const advanced = [];
+            for (const copy of asking) {
+                const view = answer.authorities.find((entry) => entry.authority === copy.room_ref);
+                if (view === undefined || (view.position === copy.position && view.log_epoch === copy.log_epoch))
+                    continue;
+                const next = await this.save(await this.incorporated(copy, view.changes, view.position, view.log_epoch));
+                caught.set(copy.key, next);
+                advanced.push(next);
             }
-            const view = answer.authorities.find((entry) => entry.authority === copy.room_ref);
-            if (view === undefined || (view.position === copy.position && view.log_epoch === copy.log_epoch))
-                return copy;
-            copy = await this.save(await this.incorporated(copy, view.changes, view.position, view.log_epoch));
+            asking = whole ? advanced : [];
         }
+        return copies.map((copy) => caught.get(copy.key));
     }
     async incorporated(copy, changes, position, logEpoch) {
         const houseTree = await tree(copy.repository, copy.house);
@@ -603,7 +628,7 @@ export class LocalCopies {
             const rebased = rebaseFixes(outcome.refused);
             let settled = await this.save(without(copy));
             try {
-                settled = await this.save(await this.caughtUp(settled));
+                settled = (await this.caughtUp([settled], true))[0];
             }
             catch {
                 return {
@@ -622,7 +647,7 @@ export class LocalCopies {
     }
     async recovered(copy) {
         const push = copy.push;
-        const current = await this.save(await this.caughtUp(copy));
+        const current = (await this.caughtUp([copy], true))[0];
         const house = await tree(copy.repository, current.house);
         const root = rootOf(current.room_handle);
         if (!(await this.landed(copy.repository, push.changes, house, await tree(copy.repository, push.commit)))) {
@@ -666,7 +691,7 @@ export class LocalCopies {
         const push = copy.push;
         let written = push.written;
         if (push.changes.some((change) => change.op === 'rename')) {
-            copy = await this.save(await this.caughtUp(copy));
+            copy = (await this.caughtUp([copy], true))[0];
             const house = await tree(copy.repository, copy.house);
             const sent = await tree(copy.repository, push.house);
             if (push.changes.some((change) => change.op === 'rename' && !house.has(relative(change.to)))) {

package/dist/end.js

@@ -1,4 +1,4 @@
-import { killDescendants } from './acp.js';
+import { killDescendants } from './scope.js';
 export const REPLACED = 'another Kit started for this Environment';
 export const SIGN_IN_AGAIN = 'sign in again';
 export function end(reason) {