@idleware/ringi 0.2.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idleware/ringi",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Distributed agent coordinator",
   "keywords": [
     "agents",

package/target/esm/app/rooms.js

@@ -91,6 +91,8 @@ export const archive = (H, R) => {
         setConfig({ room: null });
     return name;
 };
+// The room and everything kept for it: in the store (deleteRoom) and its readers' state. The sessions bound to it,
+// on this machine or another, leave it on their own when they find its branch gone (runtime/session.ts).
 export const erase = (H, R) => {
     notSigned(H, 'delete');
     locked(`hub-${H.name}`, () => H.store.deleteRoom(R.s));

package/target/esm/cli/index.js

@@ -25,7 +25,7 @@ export const TABLE = [
     ['room admit <agent> <public key|file>', 'operator', 'signed hubs: admit the key an agent made on its own machine'],
     ['room remove <agent>', 'operator', 'local hubs: take an agent out of the current room'],
     ['room archive <id>', 'operator', 'local hubs: read-only from now on; wakes nobody; its sessions end'],
-    ['room delete <id> --yes', 'operator', 'local hubs: remove a room\'s history for good'],
+    ['room delete <id> --yes', 'operator', 'local hubs: erase a room and everything kept for it; its sessions leave on their own'],
     ['room rebase-contract <id>', 'operator', 'move a room onto the hub\'s current contract'],
     ['where [-n n] [--short] [--follow]', 'operator', 'hub, room, sessions (active, stopped, gone), open work and proposals, latest messages'],
     ['send -m <subject> [-m <body>]... [--to <ids>] [--task] [--re <msg>] [--state <s>] [--assign <ids>] [--roles <id>=<label>,...] [--grant <decision>] [--attach <src>[:<dest>]]...', 'operator', 'a message as operator; without --to it goes to the room and wakes nobody; --task opens work of the room\'s profile'],

package/target/esm/cli/operator.js

@@ -139,7 +139,7 @@ export const roomCmd = (o) => {
         if (!flag(o, 'yes'))
             fail(`deleting ${R.name} removes its history from the hub for good. Run again with --yes, or archive it instead`);
         Rooms.erase(H, R);
-        return out(`deleted room ${R.name}; sessions bound to it will be told it no longer exists`);
+        return out(`deleted room ${R.name}: its branch, signals, pins, evidence and readers' state. Sessions bound to it leave it on their next turn`);
     }
     if (sub === 'rebase-contract') {
         const R = Rooms.roomIn(H, arg ?? fail('usage: ringi room rebase-contract <id>'));

package/target/esm/runtime/session.js

@@ -90,10 +90,14 @@ export const bound = () => {
     const H = openHub(s.hub);
     const R = openRoom(H, s.room, { quiet: true });
     if (!R || R.genesis !== s.genesis) {
+        // The room's branch is gone (deleted, archived, or deleted and made anew): the session leaves it on its own. A hub
+        // that cannot be reached fails above and leaves nothing.
+        locked('sessions', () => { if (readSession(me.handle)?.genesis === s.genesis)
+            dropSession(me.handle); });
         const gone = roomNames(H, true).find(a => a === `${s.room}@${s.genesis.slice(0, 8)}`);
-        if (gone)
-            fail(`room ${s.room} was archived as ${gone}; nothing more happens there. Tell the operator`);
-        fail(R ? `room ${s.room} was deleted and created again; this session's binding ended with the old room. The operator joins it anew` : `room ${s.room} no longer exists in hub ${s.hub}. Tell the operator`);
+        fail(gone ? `room ${s.room} was archived as ${gone}; this session left it`
+            : R ? `room ${s.room} was deleted and created again; this session left the old room. The operator joins it anew`
+                : `room ${s.room} is gone from hub ${s.hub}; this session left it`);
     }
     if (!R.members[s.agent])
         fail(`${s.agent} was removed from room ${s.room}; returning needs a fresh join by the operator`);

package/target/esm/runtime/watch.js

@@ -126,8 +126,15 @@ export const watch = async (w, log = note) => {
         }
         const H = openHub(H0.name, { refresh: true });
         const R = openRoom(H, R0.name, { quiet: true });
-        if (!R || R.genesis !== R0.genesis || !R.members[me]) {
-            log(`watch: ${R0.name} is gone, recreated or archived, or ${me} was removed; stopping`);
+        if (!R || R.genesis !== R0.genesis) {
+            // The room's branch is gone: the watcher leaves its seat (a hub it cannot reach fails above and leaves nothing).
+            locked('sessions', () => { if (readSession(handle)?.genesis === R0.genesis)
+                dropSession(handle); });
+            log(`watch: ${R0.name} is gone, recreated or archived; ${me} left it`);
+            return 0;
+        }
+        if (!R.members[me]) {
+            log(`watch: ${me} was removed from ${R0.name}; stopping`);
             return 0;
         }
         const P = R.profile;

package/target/esm/store/git/index.js

@@ -433,13 +433,20 @@ export class GitStore {
         this.git(['update-ref', `refs/archive/${as}`, tip, ZERO]);
         this.git(['update-ref', '-d', this.ref(room.name), tip]);
     }
+    // Every ref of the room in one transaction: its branch (or archive) and a pending migration, every tag on its
+    // commits (signals, ringi 0.1's, anyone's), what the store keeps under its genesis (pins, ringi 0.1's refs, evidence)
+    // and its unpublished commits; then the migration's backup of its readers. Objects are left to the repository.
     deleteRoom(room) {
-        const signals = this.signals(room);
-        this.gitOk(['update-ref', '-d', this.ref(room.name)]);
-        for (const [ref] of this.refsUnder(`refs/ringi/accepted/${room.genesis}/`))
-            this.git(['update-ref', '-d', ref]);
-        for (const s of signals)
-            this.gitOk(['update-ref', '-d', s.ref]);
+        const commits = this.commitsOf(room);
+        const tags = this.git(['for-each-ref', '--format=%(refname) %(objectname) %(*objectname)', 'refs/tags/']).split('\n').filter(Boolean)
+            .map(l => l.split(' ')).filter(([ref, object, target]) => commits.has(target || object) || ref.startsWith(`refs/tags/ringi/${room.genesis}/`)).map(([ref]) => ref);
+        const kept = this.refsUnder('refs/ringi/').map(([ref]) => ref).filter(ref => {
+            const [, , kind, key] = ref.split('/');
+            return key === room.genesis || (kind === 'unpublished' && commits.has(key));
+        });
+        const refs = [this.ref(room.name), this.transition(room.name)].filter(r => this.rev(r)).concat(tags, kept);
+        this.git(['update-ref', '--stdin'], { input: ['start', ...refs.map(r => `delete ${r}`), 'prepare', 'commit', ''].join('\n') });
+        fs.rmSync(path.join(this.home, 'migration', this.d.name, room.genesis), { recursive: true, force: true });
     }
     remote(room) {
         return { name: room.name, ref: this.ref(room.name), head: room.head, genesis: room.genesis, archived: room.archived };