@agentshouse/kit 0.2.1-cd9cbd8b6428c → 0.2.1-cfe80fd914176

package/dist/copies.js

@@ -2,7 +2,7 @@ import { parse } from '@agentshouse/mdmodel';
 import { randomUUID } from 'node:crypto';
 import { mkdir, readFile, readdir, realpath, rename, rm, rmdir, stat, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
-import { HouseRefusal } from './api.js';
+import { finalRefusal, HouseRefusal, retrying } from './api.js';
 import { blobId, blobText, git, HOUSE_REF, importCommits, localCopies, revision, run, succeeded, tree, } from './git.js';
 import { kitHome } from './home.js';
 import { operationId } from './operation.js';
@@ -11,7 +11,6 @@ import { changed } from './translate.js';
 import { relayed } from './relay.js';
 const BRANCH = 'main';
 const PROVENANCE = '_provenance';
-const REPLICA_RETRY_MS = 30_000;
 const IDENTITY = { GIT_COMMITTER_NAME: 'House Kit', GIT_COMMITTER_EMAIL: 'house-kit@localhost' };
 function causeOf(error) {
     return error instanceof Error ? error.message : String(error);
@@ -41,11 +40,11 @@ function sidecar(path) {
     segments.splice(-1, 0, PROVENANCE);
     return segments.join('/');
 }
-function rootOf(copy) {
-    return copy.private ? '/private' : `/rooms/${copy.room_handle}`;
+function rootOf(handle) {
+    return `/rooms/${handle}`;
 }
 function relative(path) {
-    return path.replace(/^\/private\//, '').replace(/^\/rooms\/[^/]+\//, '');
+    return path.replace(/^\/rooms\/[^/]+\//, '');
 }
 function declaredWritable(path, copy) {
     const deepest = (scopes) => Math.max(-1, ...scopes.filter((scope) => covers(path, scope)).map((scope) => scope.length));
@@ -161,11 +160,11 @@ export class LocalCopies {
             key: 'owner',
             submit: async (operation, changes) => {
                 try {
-                    const outcome = await house.post('/kit/door/batch', { operation_id: operation, changes });
+                    const outcome = await retrying(() => house.post('/kit/door/batch', { operation_id: operation, changes }));
                     return { accepted: outcome.contents };
                 }
                 catch (error) {
-                    if (!(error instanceof HouseRefusal) || error.status >= 500)
+                    if (!finalRefusal(error))
                         throw error;
                     return {
                         refused: refusalOf(error.text) ?? { code: '', text: `House refused it with ${error.status}`, conflicts: [] },
@@ -177,7 +176,7 @@ export class LocalCopies {
     async load() {
         const home = join(kitHome(), 'local-copies');
         const names = (await readdir(join(home, 'rooms')).catch(() => [])).filter((name) => name.endsWith('.json'));
-        for (const path of [...names.map((name) => join(home, 'rooms', name)), join(home, 'private.json')]) {
+        for (const path of names.map((name) => join(home, 'rooms', name))) {
             const text = await readFile(path, 'utf8').catch(() => null);
             if (text === null)
                 continue;
@@ -189,7 +188,7 @@ export class LocalCopies {
         await this.selecting;
         return [...this.copies.values()]
             .filter((copy) => copy.active)
-            .map((copy) => `${rootOf(copy)}: ${copy.repository}`)
+            .map((copy) => `${rootOf(copy.room_handle)}: ${copy.repository}`)
             .sort();
     }
     select() {
@@ -199,12 +198,7 @@ export class LocalCopies {
     }
     async reselect() {
         const { local_copy: chosen } = await this.house.post('/kit/local-copy/selection', {});
-        const selected = [
-            ...(chosen?.rooms ?? [])
-                .filter((room) => room.room_handle !== null)
-                .map((room) => ({ key: `rooms/${room.room_ref}`, private: false, handle: room.room_handle })),
-            ...(chosen?.private === true ? [{ key: 'private', private: true, handle: null }] : []),
-        ];
+        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()) {
@@ -288,7 +282,7 @@ export class LocalCopies {
         }).catch(logged);
     }
     async save(copy) {
-        const path = join(kitHome(), 'local-copies', copy.private ? 'private.json' : `${copy.key}.json`);
+        const path = join(kitHome(), 'local-copies', `${copy.key}.json`);
         await mkdir(dirname(path), { recursive: true, mode: 0o700 });
         const temporary = `${path}.${process.pid}`;
         await writeFile(temporary, JSON.stringify(copy), { mode: 0o600 });
@@ -296,8 +290,8 @@ export class LocalCopies {
         this.copies.set(copy.key, copy);
         return copy;
     }
-    async read(selected) {
-        const prefixes = [rootOf(selected)];
+    async read(handle) {
+        const prefixes = [rootOf(handle)];
         const discovery = await this.house.post('/kit/door/discover', { prefixes });
         let bundle = await this.house.post('/kit/door/bootstrap', { prefixes });
         if ('transfer' in bundle)
@@ -344,13 +338,13 @@ export class LocalCopies {
             return;
         }
         const discovery = await this.house.post('/kit/door/discover', {
-            prefixes: [rootOf(copy)],
+            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)} is not synchronized to this Environment`);
+            logged(`operation_denied: ${rootOf(copy.room_handle)} is not synchronized to this Environment`);
             return;
         }
         if (JSON.stringify([authority.operations.write, authority.protected_paths]) !==
@@ -361,12 +355,12 @@ export class LocalCopies {
         await this.save(await this.caughtUp(copy));
     }
     async materialize(scope) {
-        const read = await this.read({ private: scope.private, room_handle: scope.handle });
+        const read = await this.read(scope.handle);
         if (read === null) {
-            logged(`House serves nothing of ${rootOf({ private: scope.private, room_handle: scope.handle })} to copy`);
+            logged(`House serves nothing of ${rootOf(scope.handle)} to copy`);
             return;
         }
-        const repository = scope.private ? join(localCopies(), 'private') : join(localCopies(), 'rooms', read.anchor);
+        const repository = join(localCopies(), 'rooms', read.anchor);
         if (await exists(repository)) {
             logged(`${repository} already exists and House Kit leaves it as it is`);
             return;
@@ -378,7 +372,7 @@ export class LocalCopies {
         try {
             await git(staging, ['init', '-q', '-b', BRANCH]);
             house = await importCommits(staging, [
-                { message: `House ${rootOf({ private: scope.private, room_handle: scope.handle })}`, from: null, files: read.writable },
+                { message: `House ${rootOf(scope.handle)}`, from: null, files: read.writable },
             ]);
             await git(staging, ['update-ref', `refs/heads/${BRANCH}`, house]);
             await git(staging, ['reset', '-q', '--hard']);
@@ -392,7 +386,6 @@ export class LocalCopies {
         }
         await this.save({
             key: scope.key,
-            private: scope.private,
             room_ref: read.anchor,
             room_handle: scope.handle,
             repository,
@@ -408,11 +401,11 @@ export class LocalCopies {
         });
     }
     async received(copy) {
-        const read = await this.read(copy);
+        const read = await this.read(copy.room_handle);
         if (read === null)
             return copy;
         const house = await importCommits(copy.repository, [
-            { message: `House ${rootOf(copy)} at position ${read.position}`, from: copy.house, replaces: true, files: read.writable },
+            { message: `House ${rootOf(copy.room_handle)} at position ${read.position}`, from: copy.house, replaces: true, files: read.writable },
         ]);
         const removed = copy.read_only.filter((path) => !read.readOnly.has(path));
         const readOnly = await readOnlyPlaced(copy.repository, copy.read_only, read.readOnly, removed);
@@ -435,7 +428,7 @@ export class LocalCopies {
             let answer;
             try {
                 answer = await this.house.post('/kit/door/enumerate', {
-                    prefixes: [rootOf(copy)],
+                    prefixes: [rootOf(copy.room_handle)],
                     positions: [{ authority: copy.room_ref, position: copy.position, log_epoch: copy.log_epoch }],
                 });
             }
@@ -445,7 +438,6 @@ export class LocalCopies {
                     return this.received(copy);
                 if (code !== 'replica_behind')
                     throw error;
-                setTimeout(() => this.deliver(copy.key), REPLICA_RETRY_MS).unref();
                 return copy;
             }
             const view = answer.authorities.find((entry) => entry.authority === copy.room_ref);
@@ -485,7 +477,7 @@ export class LocalCopies {
         let { house, manifests } = copy;
         if (files.size > 0) {
             house = await importCommits(copy.repository, [
-                { message: `House ${rootOf(copy)} at position ${position}`, from: copy.house, files },
+                { message: `House ${rootOf(copy.room_handle)} at position ${position}`, from: copy.house, files },
             ]);
             manifests = { ...manifests, [house]: { parent: copy.house, files: revisions } };
         }
@@ -516,7 +508,7 @@ export class LocalCopies {
             copy = await this.save(without(copy));
         }
         if (!copy.active) {
-            return { refused: true, text: `${rootOf(copy)} is no longer synced to this Environment, so House takes no push from it` };
+            return { refused: true, text: `${rootOf(copy.room_handle)} is no longer synced to this Environment, so House takes no push from it` };
         }
         const listed = (await git(copy.repository, ['rev-list', '--topo-order', commit])).split('\n');
         const base = listed.find((ancestor) => ancestor in copy.manifests);
@@ -550,7 +542,7 @@ export class LocalCopies {
         return this.settle(submitted, caller);
     }
     async derived(copy, base, commit) {
-        const root = rootOf(copy);
+        const root = rootOf(copy.room_handle);
         const before = await tree(copy.repository, base);
         const after = await tree(copy.repository, commit);
         const moved = movedPaths(copy.moves, before, after);
@@ -632,7 +624,7 @@ export class LocalCopies {
         const push = copy.push;
         const current = await this.save(await this.caughtUp(copy));
         const house = await tree(copy.repository, current.house);
-        const root = rootOf(current);
+        const root = rootOf(current.room_handle);
         if (!(await this.landed(copy.repository, push.changes, house, await tree(copy.repository, push.commit)))) {
             await this.save(without(current));
             return {
@@ -688,7 +680,7 @@ export class LocalCopies {
                 written = [
                     ...written,
                     {
-                        path: `${rootOf(copy)}/${path}`,
+                        path: `${rootOf(copy.room_handle)}/${path}`,
                         revision: entry === undefined ? null : (revisionAt(copy, copy.house, path) ?? null),
                         content: entry === undefined ? null : await blobText(copy.repository, entry, path),
                     },
@@ -708,7 +700,7 @@ export class LocalCopies {
         }
         const edits = new Map([...files].filter(([path, content]) => (content === null ? selected.has(path) : selected.get(path) !== blobId(content))));
         const received = [...files.keys()].filter((path) => revisionAt(copy, copy.house, path) === revisionAt(copy, push.house, path));
-        const accepted = `House ${rootOf(copy)} with ${push.commit} accepted`;
+        const accepted = `House ${rootOf(copy.room_handle)} with ${push.commit} accepted`;
         const house = await importCommits(copy.repository, [
             ...(edits.size === 0 ? [] : [{ message: accepted, from: push.commit, files: edits }]),
             {

package/dist/end.js

@@ -0,0 +1,8 @@
+import { killDescendants } from './acp.js';
+export const REPLACED = 'another Kit started for this Environment';
+export const SIGN_IN_AGAIN = 'sign in again';
+export function end(reason) {
+    process.stderr.write(`kit: ${reason}\n`);
+    killDescendants();
+    process.exit(0);
+}