@agentshouse/kit 0.2.1-c70284f7a7466 → 0.2.1-c7a397cb0cce7

package/dist/files.js

@@ -11,7 +11,7 @@ export function verified(bytes, sha256, name) {
 export async function placeFiles(house, directory, files, signal) {
     const paths = [];
     for (const file of files) {
-        const original = await house.post('/kit/conversation/originals/get', { version: file.version, download: true }, signal);
+        const original = await retrying(() => house.post('/kit/conversation/originals/get', { version: file.version, download: true }, signal), signal);
         const answer = await fetch(relayed(original.download.url), { signal });
         if (!answer.ok)
             throw new Error(`${file.name} did not download: ${answer.status}`);

package/dist/inputs.js

@@ -0,0 +1,63 @@
+import { existsSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { kitHome } from './home.js';
+function logged(error) {
+    process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
+}
+export class Inputs {
+    house;
+    changed;
+    carried = new Map();
+    path = join(kitHome(), 'handed-inputs.json');
+    handed;
+    answered = new Set();
+    open = 0;
+    constructor(house, changed) {
+        this.house = house;
+        this.changed = changed;
+        this.handed = new Map(existsSync(this.path) ? Object.entries(JSON.parse(readFileSync(this.path, 'utf8'))) : []);
+    }
+    hands(inputId, ack) {
+        if (this.answered.has(inputId))
+            return;
+        this.handed.set(inputId, ack);
+        this.save();
+    }
+    idle() {
+        return this.open === 0;
+    }
+    carry(inputId, work) {
+        const known = this.carried.get(inputId);
+        const handed = this.handed.get(inputId);
+        const carried = known ?? (handed === undefined ? work() : Promise.resolve({ ack: handed }));
+        if (known === undefined) {
+            this.carried.set(inputId, carried);
+            carried.catch(() => this.carried.delete(inputId));
+        }
+        this.open++;
+        this.changed();
+        return carried
+            .then(async ({ ack, acknowledged }) => {
+            try {
+                await this.house.deliver(`/kit/inputs/${inputId}/ack`, ack);
+            }
+            finally {
+                this.answered.add(inputId);
+                if (this.handed.delete(inputId))
+                    this.save();
+            }
+            if (known === undefined)
+                await acknowledged?.();
+        })
+            .catch(logged)
+            .finally(() => {
+            this.open--;
+            this.changed();
+        });
+    }
+    save() {
+        const temporary = `${this.path}.${process.pid}`;
+        writeFileSync(temporary, JSON.stringify(Object.fromEntries(this.handed)), { mode: 0o600 });
+        renameSync(temporary, this.path);
+    }
+}

package/dist/resident.js

@@ -12,6 +12,7 @@ import { CONVERSATION_INPUTS, Conversations } from './conversations.js';
 import { LocalCopies } from './copies.js';
 import { restart } from './end.js';
 import { agentBase, enrolled, forgetRestart, kitHome, ownerLock, ownerSocket, restartAsked } from './home.js';
+import { Inputs } from './inputs.js';
 import { killDescendants } from './scope.js';
 import { quoted } from './shell.js';
 import { SignIns } from './sign-in.js';
@@ -133,7 +134,7 @@ export async function resident() {
     const agents = new Agents(house, () => changed());
     let stream = null;
     let reported = false;
-    const idle = () => conversations.idle() && signIns.idle() && agents.idle();
+    const idle = () => inputs.idle() && conversations.idle() && agents.idle();
     const changed = () => {
         if (!idle()) {
             reported = false;
@@ -146,15 +147,17 @@ export async function resident() {
             logged(house.deliver('/kit/idle', {}, idle));
         }
     };
+    const inputs = new Inputs(house, changed);
     const conversations = new Conversations({
         house,
         agents,
         copies,
+        inputs,
         send: (frame) => stream?.send(frame) ?? false,
         changed,
     });
-    const signIns = new SignIns(house, agents, changed);
-    const updates = new Updates(house);
+    const signIns = new SignIns(house, agents, inputs);
+    const updates = new Updates(inputs);
     for (const signal of ['SIGTERM', 'SIGINT']) {
         process.once(signal, () => {
             killDescendants();
@@ -173,10 +176,11 @@ export async function resident() {
         frame: (arrived) => {
             if (arrived.type === 'watching')
                 conversations.watching(arrived.watching === true);
+            if (arrived.type === 'authority_changed')
+                logged(copies.changed(arrived.rooms));
             if (arrived.type === 'work_available' && arrived.subject === 'agents')
                 logged(agents.refresh());
             if (arrived.type === 'input') {
-                reported = false;
                 if (arrived.kind === 'sign_in')
                     signIns.start(arrived);
                 else if (arrived.kind === 'update')
@@ -185,7 +189,7 @@ export async function resident() {
                     conversations.input(arrived);
                 else {
                     const refused = { refused: `This Kit does not know ${arrived.kind}; update the Kit` };
-                    logged(house.deliver(`/kit/inputs/${arrived.input_id}/ack`, refused).finally(changed));
+                    void inputs.carry(String(arrived.input_id), async () => ({ ack: refused }));
                 }
             }
         },

package/dist/scope.js

@@ -4,6 +4,7 @@ import { join } from 'node:path';
 const LISTING_BYTES = 1 << 28;
 const CGROUPS = '/sys/fs/cgroup';
 const GONE = new Set(['ENOENT', 'ESRCH']);
+const EXITED = new Set(['Z', 'X']);
 function failure(error) {
     return error.code ?? '';
 }
@@ -24,6 +25,8 @@ function read(pid) {
     try {
         const stat = readFileSync(`/proc/${pid}/stat`, 'utf8');
         const fields = stat.slice(stat.lastIndexOf(')') + 2).split(' ');
+        if (EXITED.has(fields[0]))
+            return null;
         const command = readFileSync(`/proc/${pid}/cmdline`, 'utf8').replaceAll('\0', ' ');
         return { parent: Number(fields[1]), session: fields[3], command };
     }

package/dist/service.js

@@ -1,4 +1,7 @@
 import { spawnSync } from 'node:child_process';
+import { existsSync, realpathSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { kitHome } from './home.js';
 const UNIT = 'house-kit.service';
 // launchctl and systemctl answer at once, so ten seconds only bounds a stuck service manager.
 const MANAGER_MS = 10_000;
@@ -12,18 +15,37 @@ function start(command, args) {
     const cause = started.error?.message ?? (started.stderr.trim() || `${command} exited with ${started.status ?? 'a signal'}`);
     throw new Error(`the House Kit service could not be started: ${cause}`);
 }
+function physical(path) {
+    return existsSync(path) ? realpathSync(path) : resolve(path);
+}
+function systemdHome(environment) {
+    for (const [, quoted, bare] of environment.matchAll(/"((?:[^"\\]|\\.)*)"|(\S+)/g)) {
+        const assignment = bare ?? quoted.replace(/\\(.)/g, '$1');
+        if (assignment.startsWith('HOUSE_KIT_HOME='))
+            return assignment.slice('HOUSE_KIT_HOME='.length);
+    }
+    return undefined;
+}
+function runsThisHome(served) {
+    return served !== undefined && physical(served) === physical(kitHome());
+}
 export function startService() {
     if (process.platform === 'darwin') {
         const service = `gui/${process.getuid()}/house-kit`;
         const printed = manage('launchctl', ['print', service]);
         if (printed.status !== 0 || /^\tstate = running$/m.test(printed.stdout))
             return false;
+        if (!runsThisHome(/^\t+HOUSE_KIT_HOME => (.+)$/m.exec(printed.stdout)?.[1]))
+            return false;
         start('launchctl', ['kickstart', service]);
         return true;
     }
     for (const scope of [['--user'], []]) {
         if (manage('systemctl', [...scope, 'is-enabled', '--quiet', UNIT]).status !== 0)
             continue;
+        const environment = manage('systemctl', [...scope, 'show', '--property=Environment', '--value', UNIT]).stdout;
+        if (!runsThisHome(systemdHome(environment)))
+            continue;
         if (manage('systemctl', [...scope, 'is-active', '--quiet', UNIT]).status === 0)
             return false;
         start('systemctl', [...scope, 'start', UNIT]);

package/dist/sign-in.js

@@ -9,36 +9,20 @@ const CODE = /^[A-Z0-9]+-[A-Z0-9]+$/;
 function causeOf(error) {
     return error instanceof Error ? error.message : String(error);
 }
-function logged(error) {
-    process.stderr.write(`kit: ${causeOf(error)}\n`);
-}
 function endOf(signal) {
     return new Promise((resolve) => signal.addEventListener('abort', () => resolve(true), { once: true }));
 }
 export class SignIns {
     house;
     agents;
-    changed;
-    running = new Set();
-    constructor(house, agents, changed) {
+    inputs;
+    constructor(house, agents, inputs) {
         this.house = house;
         this.agents = agents;
-        this.changed = changed;
-    }
-    idle() {
-        return this.running.size === 0;
+        this.inputs = inputs;
     }
     start(input) {
-        if (this.running.has(input.input_id))
-            return;
-        this.running.add(input.input_id);
-        this.changed();
-        this.signIn(input)
-            .catch(logged)
-            .finally(() => {
-            this.running.delete(input.input_id);
-            this.changed();
-        });
+        void this.inputs.carry(input.input_id, () => this.signIn(input));
     }
     async signIn(input) {
         const ending = new AbortController();
@@ -48,9 +32,7 @@ export class SignIns {
         clearTimeout(timer);
         if (ended)
             process.stderr.write(`kit: the ${input.cli} sign-in reached the end House set for it\n`);
-        await this.house.deliver(`/kit/inputs/${input.input_id}/ack`, {});
-        if (!ended)
-            await this.agents.reread(input.cli);
+        return ended ? { ack: {} } : { ack: {}, acknowledged: () => this.agents.reread(input.cli) };
     }
     async signedIn(input, signal) {
         await this.login(input, signal);

package/dist/stream.js

@@ -1,5 +1,5 @@
 import { subscribe } from 'node:diagnostics_channel';
-import { finalRefusal, HouseRefusal, retryDelay } from './api.js';
+import { HouseRefusal, retryDelay } from './api.js';
 import { end, REPLACED, signInAgain, updateRequired } from './end.js';
 import { readEnrolment } from './home.js';
 import { relayed } from './relay.js';
@@ -82,9 +82,9 @@ export function holdStream(handlers) {
             }
             if (refused !== null && tooOld(refused.text))
                 updateRequired();
-            if (finalRefusal(refused))
-                end(refused.message);
-            // A closed socket reopens in one to three seconds, spread so Kits one restart closed return apart; an opening House refused as retryable or left unanswered backs off on the jittered curve.
+            if (!opened && refused !== null)
+                process.stderr.write(`kit: ${refused.message}\n`);
+            // A closed socket reopens in one to three seconds, spread so Kits one restart closed return apart; an opening House refused or left unanswered backs off on the jittered curve, retryable or not, since a resident outlives a House deploy.
             setTimeout(() => void connect(), opened ? 1000 + Math.random() * 2000 : retryDelay(failures++));
         };
         opening.onopen = () => {

package/dist/translate.js

@@ -3,14 +3,8 @@ function same(left, right) {
     return JSON.stringify(left) === JSON.stringify(right);
 }
 function applied(document, changes) {
-    let current = document;
-    for (const change of changes) {
-        const result = apply(current, change);
-        if (result.outcome !== 'applied')
-            return null;
-        current = result.document;
-    }
-    return serialize(current);
+    const result = apply(document, changes);
+    return result.outcome === 'applied' ? serialize(result.document) : null;
 }
 function components(path, before, after, text) {
     const edits = [];

package/dist/update.js

@@ -6,9 +6,6 @@ import { join } from 'node:path';
 import { run } from './clis.js';
 import { kitHome, workspaceRoot } from './home.js';
 import { service, throughSudo } from './placement.js';
-function logged(error) {
-    process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
-}
 function directory() {
     return join(kitHome(), 'update');
 }
@@ -50,6 +47,12 @@ async function recorded() {
         return null;
     return status.trim() === '0' ? {} : { refused: `the Kit bootstrap exited with ${status.trim()}` };
 }
+async function forget(inputId) {
+    if ((await pendingInput()) !== inputId)
+        return;
+    await rm(pending(), { force: true });
+    await rm(outcome(), { force: true });
+}
 async function finished(inputId) {
     for (;;) {
         const ack = await recorded();
@@ -90,27 +93,28 @@ function rerun(script, inputId, flags) {
     });
 }
 export class Updates {
-    house;
-    held = new Set();
+    inputs;
     queue = Promise.resolve();
-    constructor(house) {
-        this.house = house;
+    constructor(inputs) {
+        this.inputs = inputs;
     }
     async resumed() {
         const inputId = await pendingInput();
         if (inputId === null)
             return;
-        await this.acknowledge(inputId, await finished(inputId));
+        await this.enqueue(inputId, () => finished(inputId));
     }
     start(input) {
-        if (this.held.has(input.input_id))
-            return;
-        this.held.add(input.input_id);
-        this.queue = this.queue
-            .then(() => this.carry(input))
-            .then((ack) => this.acknowledge(input.input_id, ack))
-            .catch(logged)
-            .finally(() => this.held.delete(input.input_id));
+        void this.enqueue(input.input_id, () => this.carry(input));
+    }
+    enqueue(inputId, work) {
+        const before = this.queue;
+        const carried = this.inputs.carry(inputId, async () => {
+            await before;
+            return { ack: await work(), acknowledged: () => forget(inputId) };
+        });
+        this.queue = before.then(() => carried);
+        return carried;
     }
     async carry(input) {
         if ((await pendingInput()) === input.input_id)
@@ -131,11 +135,4 @@ export class Updates {
             refused: 'the Kit bootstrap did not finish',
         };
     }
-    async acknowledge(inputId, ack) {
-        await this.house.deliver(`/kit/inputs/${inputId}/ack`, ack);
-        if ((await pendingInput()) !== inputId)
-            return;
-        await rm(pending(), { force: true });
-        await rm(outcome(), { force: true });
-    }
 }

package/dist/wire.js

@@ -1,5 +1,5 @@
 import { refusalOf } from './refusals.js';
-export const KIT_WIRE = 1;
+export const KIT_WIRE = 2;
 export const KIT_WIRE_HEADER = 'x-house-kit-wire';
 export function tooOld(text) {
     return refusalOf(text)?.code === 'kit_update_required';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentshouse/kit",
-  "version": "0.2.1-c70284f7a7466",
+  "version": "0.2.1-c7a397cb0cce7",
   "description": "House Kit connects an Environment to agents.house.",
   "license": "MIT",
   "repository": {
@@ -28,7 +28,7 @@
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "1.7.0",
-    "@agentshouse/mdmodel": "0.1.0-c68e2039f1ca8",
+    "@agentshouse/mdmodel": "0.1.0-cabd61587647f",
     "yaml": "2.9.1"
   },
   "peerDependencies": {