@agentshouse/kit 0.2.1-cca9e1f43de44 → 0.2.1-ccf188e02985d

package/dist/scope.js

@@ -0,0 +1,203 @@
+import { execFileSync } from 'node:child_process';
+import { mkdirSync, readdirSync, readFileSync, rmdirSync, statSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+const LISTING_BYTES = 1 << 28;
+const CGROUPS = '/sys/fs/cgroup';
+const GONE = new Set(['ENOENT', 'ESRCH']);
+function failure(error) {
+    return error.code ?? '';
+}
+function listed(environment) {
+    const found = new Map();
+    const output = execFileSync('ps', [environment ? '-AEww' : '-Aww', '-o', 'pid=,ppid=,sess=,command='], {
+        encoding: 'utf8',
+        maxBuffer: LISTING_BYTES,
+    });
+    for (const line of output.split('\n')) {
+        const fields = /^\s*(\d+)\s+(\d+)\s+(\S+)\s?(.*)$/.exec(line);
+        if (fields !== null)
+            found.set(Number(fields[1]), { parent: Number(fields[2]), session: fields[3], command: fields[4] });
+    }
+    return found;
+}
+function read(pid) {
+    try {
+        const stat = readFileSync(`/proc/${pid}/stat`, 'utf8');
+        const fields = stat.slice(stat.lastIndexOf(')') + 2).split(' ');
+        const command = readFileSync(`/proc/${pid}/cmdline`, 'utf8').replaceAll('\0', ' ');
+        return { parent: Number(fields[1]), session: fields[3], command };
+    }
+    catch (error) {
+        if (GONE.has(failure(error)))
+            return null;
+        throw error;
+    }
+}
+function processes() {
+    if (process.platform === 'darwin')
+        return listed(false);
+    const found = new Map();
+    for (const entry of readdirSync('/proc')) {
+        const running = /^\d+$/.test(entry) ? read(entry) : null;
+        if (running !== null)
+            found.set(Number(entry), running);
+    }
+    return found;
+}
+function descendants(roots, table = processes()) {
+    const children = new Map();
+    for (const [pid, { parent }] of table)
+        children.set(parent, [...(children.get(parent) ?? []), pid]);
+    const tree = [];
+    const pending = roots.flatMap((root) => children.get(root) ?? []);
+    while (pending.length > 0) {
+        const pid = pending.pop();
+        tree.push(pid);
+        pending.push(...(children.get(pid) ?? []));
+    }
+    return tree;
+}
+function marked(marker, doubted) {
+    if (process.platform === 'darwin') {
+        return [...listed(true)].filter(([, { command }]) => ` ${command} `.includes(` ${marker} `)).map(([pid]) => pid);
+    }
+    return readdirSync('/proc')
+        .filter((entry) => /^\d+$/.test(entry) && carries(entry, marker, doubted))
+        .map(Number);
+}
+function carries(pid, marker, doubted) {
+    try {
+        return readFileSync(`/proc/${pid}/environ`, 'utf8').split('\0').includes(marker);
+    }
+    catch (error) {
+        if (GONE.has(failure(error)))
+            return false;
+        if (failure(error) !== 'EACCES')
+            throw error;
+        return doubted && statSync(`/proc/${pid}`, { throwIfNoEntry: false })?.uid === process.getuid();
+    }
+}
+function killAll(pids) {
+    for (const pid of pids) {
+        for (const target of [-pid, pid]) {
+            try {
+                process.kill(target, 'SIGKILL');
+            }
+            catch { }
+        }
+    }
+}
+export function killTree(child) {
+    killAll([child.pid, ...descendants([child.pid])]);
+}
+export function killMarked(marker) {
+    const pids = marked(marker, false);
+    killAll([...pids, ...descendants(pids)]);
+}
+export function killDescendants() {
+    const pids = marked(`HOUSE_KIT_RESIDENT=${process.pid}`, false);
+    killAll([...pids, ...descendants([process.pid, ...pids])]);
+}
+function ownGroup() {
+    if (process.platform !== 'linux')
+        return null;
+    try {
+        const line = readFileSync('/proc/self/cgroup', 'utf8')
+            .split('\n')
+            .find((entry) => entry.startsWith('0::'));
+        return line === undefined ? null : join(CGROUPS, line.slice(3));
+    }
+    catch {
+        return null;
+    }
+}
+function members(group) {
+    const pids = readFileSync(join(group, 'cgroup.procs'), 'utf8').split('\n').filter(Boolean).map(Number);
+    for (const entry of readdirSync(group, { withFileTypes: true })) {
+        if (entry.isDirectory())
+            pids.push(...members(join(group, entry.name)));
+    }
+    return pids;
+}
+export class Scope {
+    marker;
+    cli;
+    group;
+    session = null;
+    recorded = null;
+    constructor(marker, name, cli) {
+        this.marker = marker;
+        this.cli = cli;
+        const own = ownGroup();
+        this.group = own === null ? null : join(own, name);
+        try {
+            if (this.group !== null)
+                mkdirSync(this.group);
+        }
+        catch {
+            this.group = null;
+        }
+    }
+    command(command, args) {
+        if (this.group === null)
+            return [command, args];
+        return ['/bin/sh', ['-c', 'echo $$ > "$0/cgroup.procs" 2>/dev/null; exec "$@"', this.group, command, ...args]];
+    }
+    entered(pid) {
+        this.session = process.platform === 'darwin' ? (listed(false).get(pid)?.session ?? null) : String(pid);
+        if (this.group === null)
+            return;
+        const joined = readFileSync(`/proc/${pid}/cgroup`, 'utf8').split('\n').find((entry) => entry.startsWith('0::'));
+        if (joined !== undefined && join(CGROUPS, joined.slice(3)) === this.group)
+            return;
+        this.close();
+        this.group = null;
+    }
+    record() {
+        const found = this.found();
+        if (found === null)
+            return;
+        this.recorded = new Set([...found].filter(([, { session }]) => session === this.session).map(([pid]) => pid));
+    }
+    working() {
+        const found = this.found();
+        if (found === null)
+            return true;
+        if (this.recorded === null)
+            return found.size > 0;
+        return [...found].some(([pid, { session, command }]) => session !== this.session || !(this.recorded.has(pid) || command.startsWith(`${this.cli}-`)));
+    }
+    empty() {
+        return this.found()?.size === 0;
+    }
+    kill() {
+        killMarked(this.marker);
+        if (this.group === null)
+            return;
+        try {
+            writeFileSync(join(this.group, 'cgroup.kill'), '1');
+        }
+        catch {
+            killAll([...(this.found()?.keys() ?? [])]);
+        }
+    }
+    close() {
+        if (this.group === null)
+            return;
+        try {
+            rmdirSync(this.group);
+        }
+        catch { }
+    }
+    found() {
+        try {
+            const table = processes();
+            const roots = this.group === null ? marked(this.marker, true) : members(this.group);
+            const pids = this.group === null ? [...roots, ...descendants(roots, table)] : roots;
+            return new Map(pids.flatMap((pid) => (table.has(pid) ? [[pid, table.get(pid)]] : [])));
+        }
+        catch {
+            return null;
+        }
+    }
+}

package/dist/service-main.js

@@ -0,0 +1,9 @@
+import { startService } from './service.js';
+try {
+    if (startService())
+        process.stdout.write('started\n');
+}
+catch (error) {
+    process.stderr.write(`kit: ${error.message}\n`);
+    process.exitCode = 1;
+}

package/dist/service.js

@@ -0,0 +1,55 @@
+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;
+function manage(command, args) {
+    return spawnSync(command, args, { encoding: 'utf8', timeout: MANAGER_MS });
+}
+function start(command, args) {
+    const started = manage(command, args);
+    if (started.status === 0)
+        return;
+    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]);
+        return true;
+    }
+    return false;
+}

package/dist/sign-in.js

@@ -1,7 +1,7 @@
 import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
-import { killTree } from './acp.js';
 import { CLIS, withoutProxy } from './clis.js';
+import { killTree } from './scope.js';
 import { holdSecretInput } from './secret-input.js';
 const ESCAPE = /\u001b\[[\d;]*m/g;
 const LINK = /https:\/\/\S+/;
@@ -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/skills.js

@@ -1,17 +1,31 @@
+import { createHash } from 'node:crypto';
 import { readFileSync } from 'node:fs';
-import { cp, lstat, mkdir, readdir, realpath, rm, symlink, writeFile } from 'node:fs/promises';
+import { cp, lstat, mkdir, readdir, realpath, rm, symlink } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join, relative } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { parse } from 'yaml';
 import { KIT_VERSION } from './clis.js';
 import { kitHome, readConfiguration, readHome, writeHome } from './home.js';
 import { refusalOf } from './refusals.js';
-export const HOW_WE_WORK = '/rooms/private/how-we-work.md';
+const HOW_WE_WORK = '/rooms/private/how-we-work.md';
 const SKILL_SET = fileURLToPath(new URL('../skills/', import.meta.url));
 const HOW_WE_WORK_TEXT = readFileSync(new URL('../how-we-work.md', import.meta.url), 'utf8');
+const SHIPPED_HOW_WE_WORK = [
+    'ae4dda60da7b174f22dc5fa9bf07fc27c25864932a74230de4f9f509ddd91f41',
+    '0bdcd43e1603ba6673a3cae56d70bbf90657cbeefd124e91a47be2ca1cbd6c93',
+    '4106a87ec66da6f7b2a10e74d18e6559d68d5f4fe7415dae68f5c7bdb9081968',
+    'ac814a2197038f037b657bb719340395f89f319ac9fcdd386629c3fe2cec68f1',
+    '29951ee394aad9979eecfed3e5dc32c2c86e2226b6a380db5dbd4f305f4d1156',
+];
 const RECORD = 'skill-set.json';
-const CREATED = 'how-we-work-created';
+const WRITTEN = 'how-we-work.json';
 const UNWRITABLE = new Set(['room_not_found', 'operation_denied']);
+const PRESENT = new Set(['path_exists']);
+const CHANGED = new Set(['base_revision_stale', 'path_absent']);
+const UNREADABLE = /^(?:\S+: )?(?:path_not_found|room_not_found|operation_denied)\b/;
+const FAILED = /^exit: [1-9]\d*$/;
+const CUT = /^stderr: shell: output_cut (\d+) of \d+ bytes; continue with: (.+)$/;
 function skillsDirectory() {
     return join(homedir(), '.agents', 'skills');
 }
@@ -49,6 +63,14 @@ async function install() {
     await writeHome(RECORD, { version: KIT_VERSION, names });
 }
 export async function placeSkillSet() {
+    try {
+        await replaceSkillSet();
+    }
+    catch (error) {
+        process.stderr.write(`kit: the skills could not be placed: ${error.message}\n`);
+    }
+}
+async function replaceSkillSet() {
     const accepted = (await readConfiguration()).skills;
     const installed = await readHome(RECORD);
     if (accepted && installed?.version === KIT_VERSION)
@@ -62,17 +84,64 @@ export async function placeSkillSet() {
     else
         await rm(join(kitHome(), RECORD), { force: true });
 }
+function sha256(text) {
+    return createHash('sha256').update(text).digest('hex');
+}
+function cutOf(lines) {
+    const cut = CUT.exec(lines[0] ?? '');
+    return cut !== null && Buffer.byteLength(lines.slice(1).join('\n')) === Number(cut[1]) ? cut : null;
+}
+export async function readHowWeWork(bridge) {
+    let document = '';
+    for (let command = `cat ${HOW_WE_WORK}`; command !== undefined;) {
+        const read = await bridge.tool('shell', { command });
+        const text = read.content.map((content) => content.text).join('\n');
+        const lines = text.split('\n');
+        if (read.isError === true || (FAILED.test(lines[0] ?? '') && lines[1]?.startsWith('stderr: '))) {
+            const refusal = read.isError === true ? text : lines.slice(1).join('\n').replace(/^stderr: /gm, '');
+            if (UNREADABLE.test(refusal))
+                return '';
+            throw new Error(refusal);
+        }
+        const cut = cutOf(lines);
+        document += lines.slice(cut === null ? 0 : 1).join('\n');
+        command = cut?.[2];
+    }
+    return document;
+}
+async function currentRevision(bridge) {
+    const inspected = await bridge.tool('inspect', { path: HOW_WE_WORK });
+    const text = inspected.content.map((content) => content.text).join('\n');
+    if (inspected.isError === true)
+        throw new Error(text);
+    return parse(text).revisions[0].revision;
+}
+async function edit(bridge, change, kept) {
+    const edited = await bridge.tool('edit', { changes: [{ ...change, path: HOW_WE_WORK, content: HOW_WE_WORK_TEXT }] });
+    if (edited.isError !== true)
+        return 'written';
+    const text = edited.content.map((content) => content.text).join('\n');
+    const refusal = refusalOf(text);
+    if (UNWRITABLE.has(refusal?.code ?? ''))
+        return 'unwritable';
+    if (refusal?.code === 'edit_conflict' && refusal.conflicts.some((conflict) => kept.has(conflict)))
+        return 'kept';
+    throw new Error(text);
+}
 export async function createHowWeWork(bridge) {
-    if ((await readHome(RECORD)) === null || (await present(join(kitHome(), CREATED))))
+    if (!(await readConfiguration()).skills || (await readHome(RECORD))?.version === undefined)
+        return;
+    const current = sha256(HOW_WE_WORK_TEXT);
+    if ((await readHome(WRITTEN)) === current)
+        return;
+    const created = await edit(bridge, { op: 'create' }, PRESENT);
+    if (created === 'unwritable')
         return;
-    const created = await bridge.tool('edit', { changes: [{ op: 'create', path: HOW_WE_WORK, content: HOW_WE_WORK_TEXT }] });
-    if (created.isError === true) {
-        const text = created.content.map((content) => content.text).join('\n');
-        const refusal = refusalOf(text);
-        if (UNWRITABLE.has(refusal?.code ?? ''))
+    if (created === 'kept') {
+        const base = await currentRevision(bridge);
+        const held = sha256(await readHowWeWork(bridge));
+        if (held !== current && SHIPPED_HOW_WE_WORK.includes(held) && (await edit(bridge, { op: 'replace', base }, CHANGED)) === 'unwritable')
             return;
-        if (refusal?.code !== 'edit_conflict' || !refusal.conflicts.includes('path_exists'))
-            throw new Error(text);
     }
-    await writeFile(join(kitHome(), CREATED), '');
+    await writeHome(WRITTEN, current);
 }

package/dist/stream.js

@@ -1,11 +1,42 @@
 import { subscribe } from 'node:diagnostics_channel';
-import { finalRefusal, HouseRefusal, retryDelay } from './api.js';
-import { end, REPLACED, SIGN_IN_AGAIN } from './end.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';
+import { KIT_WIRE, tooOld } from './wire.js';
 const PATH = '/kit/stream';
-const SUBPROTOCOL = 'house.kit.stream.1';
+const SUBPROTOCOL = `house.kit.stream.${KIT_WIRE}`;
 const REFUSAL_HEADER = 'x-house-refusal';
+// House beats each stream every thirty seconds, so two silent beats mean this Kit cannot hear House.
+export const STREAM_SILENCE_MS = 60_000;
+const SYSTEM_STREAM_CLOCK = {
+    later: (delay, callback) => setTimeout(callback, delay),
+    clear: (timer) => clearTimeout(timer),
+};
+export class StreamSilence {
+    timer = null;
+    silent;
+    clock;
+    interval;
+    constructor(silent, clock = SYSTEM_STREAM_CLOCK, interval = STREAM_SILENCE_MS) {
+        this.silent = silent;
+        this.clock = clock;
+        this.interval = interval;
+    }
+    heard() {
+        this.stop();
+        this.timer = this.clock.later(this.interval, () => {
+            this.timer = null;
+            this.silent();
+        });
+    }
+    stop() {
+        if (this.timer === null)
+            return;
+        this.clock.clear(this.timer);
+        this.timer = null;
+    }
+}
 function streamUrl(house) {
     const url = new URL(PATH, house);
     url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
@@ -36,29 +67,49 @@ export function holdStream(handlers) {
             headers: { authorization: `Bearer ${credential}` },
         });
         let opened = false;
+        let silence = null;
+        const closed = (event) => {
+            silence?.stop();
+            silence = null;
+            if (socket === opening)
+                socket = null;
+            process.stderr.write(`kit: control stream closed ${event.code} ${event.reason}\n`);
+            if (event.reason === 'replaced')
+                end(REPLACED);
+            if (event.reason === 'credential_rejected' || refused?.status === 401) {
+                void signInAgain(credential);
+                return;
+            }
+            if (refused !== null && tooOld(refused.text))
+                updateRequired();
+            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 = () => {
             opened = true;
             failures = 0;
             socket = opening;
+            silence = new StreamSilence(() => {
+                if (socket !== opening)
+                    return;
+                socket = null;
+                opening.onclose = null;
+                opening.close();
+                closed(new CloseEvent('close', { code: 1006, reason: 'heartbeat_missed' }));
+            });
+            silence.heard();
             handlers.opened();
         };
         opening.onmessage = (event) => {
-            handlers.frame(JSON.parse(String(event.data)));
+            silence?.heard();
+            const frame = JSON.parse(String(event.data));
+            if (frame.type !== 'beat')
+                handlers.frame(frame);
         };
         opening.onerror = () => undefined;
-        opening.onclose = (event) => {
-            if (socket === opening)
-                socket = null;
-            process.stderr.write(`kit: control stream closed ${event.code} ${event.reason}\n`);
-            if (event.reason === 'replaced')
-                end(REPLACED);
-            if (event.reason === 'credential_rejected' || refused?.status === 401)
-                end(SIGN_IN_AGAIN);
-            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.
-            setTimeout(() => void connect(), opened ? 1000 + Math.random() * 2000 : retryDelay(failures++));
-        };
+        opening.onclose = closed;
     };
     void connect();
     return {

package/dist/transcription.js

@@ -49,10 +49,10 @@ async function executed(command, args, signal) {
 function present(path) {
     return stat(path).then(() => true, () => false);
 }
-async function cpus() {
+async function threads() {
     const [quota, period] = (await readFile('/sys/fs/cgroup/cpu.max', 'utf8').catch(() => 'max')).split(' ');
     const allowed = quota === 'max' ? Infinity : Math.ceil(Number(quota) / Number(period));
-    return Math.min(availableParallelism(), allowed);
+    return Math.max(1, Math.floor(Math.min(availableParallelism(), allowed) / 2));
 }
 async function sha256(path) {
     const hash = createHash('sha256');
@@ -140,7 +140,7 @@ async function transcribed(path, signal) {
         await executed(installed(pinned.decoder), ['-nostdin', '-hide_banner', '-loglevel', 'error', '-i', path, '-ar', '16000', '-ac', '1', '-c:a', 'pcm_s16le',
             '-f', 'segment', '-segment_time', String(CHUNK_SECONDS), join(work, '%05d.wav')], signal);
         const parts = (await readdir(work)).sort().flatMap((part) => ['-f', join(work, part)]);
-        const text = await executed(installed(pinned.engine), ['-t', String(await cpus()), '-np', '-m', installed(MODEL), ...parts], signal);
+        const text = await executed(installed(pinned.engine), ['-t', String(await threads()), '-np', '-m', installed(MODEL), ...parts], signal);
         return text
             .split('\n')
             .map((line) => line.trim())