@agentshouse/kit 0.2.1-cbdf76b9a90a3 → 0.2.1-cbff58027f078

package/dist/resident.js

@@ -8,17 +8,19 @@ import { fileURLToPath } from 'node:url';
 import { Agents } from './agents.js';
 import { house } from './api.js';
 import { received } from './bridge.js';
-import { CONVERSATION_INPUTS, Conversations } from './conversations.js';
+import { CONVERSATION_METHODS, 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 { restart, unknownMethod } from './end.js';
+import { agentBase, enrolled, kitHome, ownerLock, ownerSocket, readEnrolment } from './home.js';
+import { Calls } from './calls.js';
 import { killDescendants } from './scope.js';
+import { removeInputs, Scripts } from './scripts.js';
 import { quoted } from './shell.js';
 import { SignIns } from './sign-in.js';
 import { placeSkillSet } from './skills.js';
-import { holdStream } from './stream.js';
-import { Updates } from './update.js';
+import { holdConnection } from './connection.js';
+import { KitUpdate } from './update.js';
+import { takeUnservedRelease } from './wire.js';
 import { codexLauncher } from './work.js';
 function report(error) {
     process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
@@ -47,7 +49,7 @@ async function serveOwner(copies) {
     if (!claimed(lock)) {
         lock.close();
         const running = await runningResident();
-        throw new Error(`${running === null ? 'another Kit' : `Kit ${running}`} already runs this Environment from Kit home ${kitHome()}; stop it first to run another here`);
+        throw new Error(`${running === null ? 'another Kit process' : `Kit process ${running}`} already runs this Environment from Kit home ${kitHome()}; stop it first to run another Kit process here`);
     }
     const server = createServer(async (request, response) => {
         try {
@@ -109,14 +111,13 @@ function connected() {
 }
 async function started() {
     await connected();
-    await forgetRestart();
     watch(kitHome(), () => {
         if (enrolled())
             return;
         killDescendants();
         process.exit(1);
     });
-    await placeSkillSet();
+    await placeSkillSet((await readEnrolment()).house);
     await mkdir(agentBase(), { recursive: true });
     await installShim(join(kitHome(), 'shim', 'git'), 'git-main');
     await installShim(codexLauncher(), 'codex-main');
@@ -126,72 +127,82 @@ export async function resident() {
     const copies = new LocalCopies(house);
     await copies.load();
     await serveOwner(copies);
+    await copies.swept();
     await started().catch((error) => {
         report(error);
         process.exit(1);
     });
     process.env.HOUSE_KIT_RESIDENT = String(process.pid);
     const agents = new Agents(house, () => changed());
-    let stream = null;
+    let connection = null;
     let reported = false;
-    const idle = () => inputs.idle() && conversations.idle() && agents.idle();
+    const idle = () => calls.idle() && conversations.idle() && agents.idle();
     const changed = () => {
         if (!idle()) {
             reported = false;
         }
-        else if (restartAsked() && conversations.quiet()) {
-            restart('restarting for an updated CLI');
+        else if (update.placedRelease() !== null && conversations.quiet()) {
+            restart(`Kit ${update.placedRelease()} is placed; its supervisor starts it`);
         }
         else if (!reported) {
             reported = true;
             logged(house.deliver('/kit/idle', {}, idle));
         }
     };
-    const inputs = new Inputs(house, changed);
+    const calls = new Calls(house, changed);
     const conversations = new Conversations({
         house,
         agents,
         copies,
-        inputs,
-        send: (frame) => stream?.send(frame) ?? false,
+        calls,
+        send: (notification) => connection?.send(notification) ?? false,
         changed,
     });
-    const signIns = new SignIns(house, agents, inputs);
-    const updates = new Updates(inputs);
+    const signIns = new SignIns(house, agents, calls);
+    const update = new KitUpdate(calls);
+    if (process.env.HOUSE_KIT_SANDBOX !== '1')
+        takeUnservedRelease((release) => logged(update.takeRefused(release)));
+    removeInputs();
+    const scripts = new Scripts(calls, (notification) => connection?.send(notification) ?? false);
     for (const signal of ['SIGTERM', 'SIGINT']) {
         process.once(signal, () => {
             killDescendants();
+            removeInputs();
             process.kill(process.pid, signal);
         });
     }
     await house.deliver('/kit/restarted', {}).catch(report);
-    await updates.resumed().catch(report);
     logged(agents.refresh());
-    stream = holdStream({
+    agents.keepCurrent();
+    connection = holdConnection({
         opened: () => {
             conversations.opened();
             changed();
             logged(copies.connected());
         },
-        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') {
-                if (arrived.kind === 'sign_in')
-                    signIns.start(arrived);
-                else if (arrived.kind === 'update')
-                    updates.start(arrived);
-                else if (CONVERSATION_INPUTS.has(arrived.kind))
-                    conversations.input(arrived);
-                else {
-                    const refused = { refused: `This Kit does not know ${arrived.kind}; update the Kit` };
-                    void inputs.carry(String(arrived.input_id), async () => ({ ack: refused }));
-                }
+        closed: () => scripts.disconnected(),
+        call: (call) => {
+            if (call.kind === 'sign_in')
+                signIns.start(call);
+            else if (call.kind === 'update')
+                update.take(call);
+            else if (call.kind === 'run_wizard' || call.kind === 'run_function')
+                scripts.start(call);
+            else if (CONVERSATION_METHODS.has(call.kind))
+                conversations.call(call);
+            else {
+                const refused = { refused: unknownMethod(call.kind) };
+                void calls.carry(call.input_id, async () => ({ result: refused }));
             }
         },
+        notification: (notification) => {
+            if (notification.type === 'watching')
+                conversations.watching(notification.watching === true);
+            if (notification.type === 'authority_changed')
+                logged(copies.changed(notification.rooms));
+            if (notification.type === 'work_available' && notification.subject === 'agents')
+                logged(agents.refresh());
+            scripts.notified(notification);
+        },
     });
 }

package/dist/scope.js

@@ -1,5 +1,5 @@
 import { execFileSync } from 'node:child_process';
-import { mkdirSync, readdirSync, readFileSync, rmdirSync, statSync, writeFileSync } from 'node:fs';
+import { mkdirSync, readdirSync, readFileSync, realpathSync, rmdirSync, statSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 const LISTING_BYTES = 1 << 28;
 const CGROUPS = '/sys/fs/cgroup';
@@ -122,15 +122,23 @@ function members(group) {
     }
     return pids;
 }
+function besideCli(cli) {
+    try {
+        return `${realpathSync(cli)}-`;
+    }
+    catch {
+        return null;
+    }
+}
 export class Scope {
     marker;
-    cli;
+    helpers;
     group;
     session = null;
     recorded = null;
     constructor(marker, name, cli) {
         this.marker = marker;
-        this.cli = cli;
+        this.helpers = besideCli(cli);
         const own = ownGroup();
         this.group = own === null ? null : join(own, name);
         try {
@@ -168,7 +176,7 @@ export class Scope {
             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}-`)));
+        return [...found].some(([pid, { session, command }]) => session !== this.session || !(this.recorded.has(pid) || (this.helpers !== null && command.startsWith(this.helpers))));
     }
     empty() {
         return this.found()?.size === 0;

package/dist/scripts.js

@@ -0,0 +1,255 @@
+import { spawn as spawnPiped } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { once } from 'node:events';
+import { rmSync } from 'node:fs';
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { constants } from 'node:os';
+import { join } from 'node:path';
+import { loginPath, onLoginPath } from './clis.js';
+import { kitHome } from './home.js';
+import { childEnvironment } from './relay.js';
+import { killTree } from './scope.js';
+const TERMINAL = 'xterm-256color';
+const FIRST_SIZE = { cols: 80, rows: 24 };
+const SIGNALLED = 128;
+const NEWLINE = 0x0a;
+const NO_BASH = "bash is not on the login shell's PATH";
+const LOST = { refused: 'the Kit lost its connection to House' };
+function causeOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function failed(plan, cause) {
+    process.stderr.write(`kit: ${plan.named} could not start: ${cause}\n`);
+    return { refused: `the script could not start: ${cause}` };
+}
+function planned(call) {
+    if (call.kind === 'run_wizard')
+        return { named: 'a Web Wizard', script: call.script, terminal: 'page', function: null };
+    return {
+        named: 'an Environment function',
+        script: call.script,
+        terminal: call.terminal ? 'at once' : null,
+        function: { input: call.input, timeCap: call.time_cap, outputCap: call.output_cap },
+    };
+}
+function inputs() {
+    return join(kitHome(), 'inputs');
+}
+async function inputFile(value) {
+    await mkdir(inputs(), { recursive: true, mode: 0o700 });
+    const path = join(inputs(), `${randomUUID()}.json`);
+    await writeFile(path, JSON.stringify(value), { mode: 0o600, flag: 'wx' });
+    return path;
+}
+export function removeInputs() {
+    rmSync(inputs(), { recursive: true, force: true });
+}
+function struck(line, typed) {
+    return typed.some((typedLine) => line.includes(typedLine));
+}
+class KeptOutput {
+    cap;
+    typedText = '';
+    text = '';
+    bytes = 0;
+    line = '';
+    lineBytes = 0;
+    dropping = false;
+    cut = false;
+    constructor(cap) {
+        this.cap = cap;
+    }
+    typed(data) {
+        this.typedText += data;
+    }
+    add(data) {
+        const pieces = data.split('\n');
+        const rest = pieces.pop();
+        for (const piece of pieces)
+            this.ended(piece);
+        this.extend(rest);
+    }
+    kept() {
+        const typed = this.typedLines(true);
+        this.text = [...this.text.split(/(?<=\n)/), this.line].filter((line) => line !== '' && !struck(line, typed)).join('');
+        this.bytes = Buffer.byteLength(this.text);
+        this.trim();
+        return { output: this.text, cut: this.cut };
+    }
+    typedLines(all) {
+        const lines = this.typedText.split(/\r\n|\r|\n/);
+        if (!all)
+            lines.pop();
+        return lines.filter((line) => line !== '');
+    }
+    ended(piece) {
+        const line = `${this.line}${piece}\n`;
+        const dropped = this.dropping;
+        this.line = '';
+        this.lineBytes = 0;
+        this.dropping = false;
+        if (dropped || struck(line, this.typedLines(false)))
+            return;
+        this.text += line;
+        this.bytes += Buffer.byteLength(line);
+        if (this.bytes > 2 * this.cap)
+            this.trim();
+    }
+    extend(piece) {
+        if (this.dropping)
+            return;
+        this.line += piece;
+        this.lineBytes += Buffer.byteLength(piece);
+        if (this.lineBytes <= this.cap)
+            return;
+        this.text = '';
+        this.bytes = 0;
+        this.line = '';
+        this.lineBytes = 0;
+        this.dropping = true;
+        this.cut = true;
+    }
+    trim() {
+        if (this.bytes <= this.cap)
+            return;
+        const bytes = Buffer.from(this.text);
+        const start = bytes.indexOf(NEWLINE, bytes.length - this.cap - 1) + 1;
+        this.text = bytes.subarray(start).toString('utf8');
+        this.bytes = bytes.length - start;
+        this.cut = true;
+    }
+}
+export class Scripts {
+    calls;
+    send;
+    runs = new Map();
+    constructor(calls, send) {
+        this.calls = calls;
+        this.send = send;
+    }
+    start(call) {
+        void this.calls.carry(call.input_id, () => this.run(call.input_id, planned(call)));
+    }
+    notified(notification) {
+        const run = this.runs.get(String(notification.wizard));
+        if (run === undefined)
+            return;
+        if (notification.type === 'wizard_input')
+            this.typed(run, String(notification.data));
+        if (notification.type === 'wizard_size')
+            this.resized(run, { cols: Number(notification.cols), rows: Number(notification.rows) });
+        if (notification.type === 'wizard_end' && run.plan.terminal === 'page')
+            this.end(run, {});
+    }
+    disconnected() {
+        for (const run of this.runs.values())
+            this.end(run, LOST);
+    }
+    async run(id, plan) {
+        const size = plan.terminal === 'page' ? null : FIRST_SIZE;
+        const output = plan.function === null ? null : new KeptOutput(plan.function.outputCap);
+        const run = { plan, input: null, output, process: null, pipes: [], terminal: null, size, typed: [], ended: null, sized: Promise.withResolvers() };
+        if (size !== null)
+            run.sized.resolve();
+        this.runs.set(id, run);
+        try {
+            return { result: await this.ran(id, run), release: plan.function !== null };
+        }
+        finally {
+            this.runs.delete(id);
+            if (run.input !== null)
+                await rm(run.input, { force: true });
+        }
+    }
+    async ran(id, run) {
+        const { plan, output } = run;
+        let exited;
+        try {
+            const { spawn } = await import('@lydell/node-pty');
+            const shell = await onLoginPath('bash');
+            if (shell === null)
+                return failed(plan, NO_BASH);
+            const path = await loginPath();
+            await run.sized.promise;
+            if (plan.function !== null)
+                run.input = await inputFile(plan.function.input);
+            if (run.ended !== null)
+                return run.ended;
+            const environment = { ...childEnvironment(), PATH: path, ...(run.input === null ? {} : { HOUSE_INPUT: run.input }) };
+            if (plan.terminal === null) {
+                ({ exited } = await this.piped(plan.script, shell, environment, run));
+            }
+            else {
+                const terminal = spawn(shell, ['-c', plan.script], { name: TERMINAL, ...run.size, cwd: process.cwd(), env: environment });
+                run.process = terminal;
+                run.terminal = terminal;
+                terminal.onData((data) => {
+                    this.send({ type: 'wizard_output', wizard: id, data });
+                    output?.add(data);
+                });
+                for (const data of run.typed.splice(0))
+                    terminal.write(data);
+                exited = new Promise((resolve) => terminal.onExit(({ exitCode, signal }) => resolve(signal ? SIGNALLED + signal : exitCode)));
+            }
+        }
+        catch (error) {
+            return failed(plan, causeOf(error));
+        }
+        let timedOut = false;
+        // House sends a function run's time cap in seconds, and a run still going at its cap ends with its process group and the output pipes it holds.
+        const capped = plan.function === null ? undefined : setTimeout(() => {
+            timedOut = true;
+            this.stop(run);
+        }, plan.function.timeCap * 1000);
+        const code = await exited;
+        clearTimeout(capped);
+        if (run.ended !== null)
+            return run.ended;
+        if (output === null)
+            return { exit_code: code };
+        const kept = output.kept();
+        return timedOut ? { timed_out: true, ...kept } : { exit_code: code, ...kept };
+    }
+    async piped(script, shell, environment, run) {
+        const child = spawnPiped(shell, ['-c', script], { cwd: process.cwd(), env: environment, detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
+        const exited = new Promise((resolve) => child.once('close', (code, signal) => resolve(signal === null ? code : SIGNALLED + constants.signals[signal])));
+        await once(child, 'spawn');
+        run.process = { pid: child.pid };
+        run.pipes = [child.stdout, child.stderr];
+        for (const pipe of run.pipes) {
+            pipe.setEncoding('utf8');
+            pipe.on('data', (data) => run.output.add(data));
+        }
+        if (run.ended !== null)
+            this.stop(run);
+        return { exited };
+    }
+    typed(run, data) {
+        run.output?.typed(data);
+        if (run.terminal === null)
+            run.typed.push(data);
+        else
+            run.terminal.write(data);
+    }
+    resized(run, size) {
+        run.size = size;
+        run.sized.resolve();
+        try {
+            run.terminal?.resize(size.cols, size.rows);
+        }
+        catch { }
+    }
+    end(run, result) {
+        if (run.ended !== null)
+            return;
+        run.ended = result;
+        run.sized.resolve();
+        this.stop(run);
+    }
+    stop(run) {
+        if (run.process !== null)
+            killTree(run.process);
+        for (const pipe of run.pipes)
+            pipe.destroy();
+    }
+}

package/dist/service.js

@@ -13,7 +13,7 @@ function start(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}`);
+    throw new Error(`the Kit service could not be started: ${cause}`);
 }
 function physical(path) {
     return existsSync(path) ? realpathSync(path) : resolve(path);

package/dist/sign-in.js

@@ -1,6 +1,7 @@
 import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
-import { CLIS, withoutProxy } from './clis.js';
+import { CLIS } from './clis.js';
+import { childEnvironment } from './relay.js';
 import { killTree } from './scope.js';
 import { holdSecretInput } from './secret-input.js';
 const ESCAPE = /\u001b\[[\d;]*m/g;
@@ -15,48 +16,48 @@ function endOf(signal) {
 export class SignIns {
     house;
     agents;
-    inputs;
-    constructor(house, agents, inputs) {
+    calls;
+    constructor(house, agents, calls) {
         this.house = house;
         this.agents = agents;
-        this.inputs = inputs;
+        this.calls = calls;
     }
-    start(input) {
-        void this.inputs.carry(input.input_id, () => this.signIn(input));
+    start(call) {
+        void this.calls.carry(call.input_id, () => this.signIn(call));
     }
-    async signIn(input) {
+    async signIn(call) {
         const ending = new AbortController();
         // House stops waiting for a sign-in ten minutes after it wrote it and sends the seconds left, so its install and login end with the page.
-        const timer = setTimeout(() => ending.abort(), input.ends_in * 1000);
-        const ended = await Promise.race([this.signedIn(input, ending.signal), endOf(ending.signal)]);
+        const timer = setTimeout(() => ending.abort(), call.ends_in * 1000);
+        const ended = await Promise.race([this.signedIn(call, ending.signal), endOf(ending.signal)]);
         clearTimeout(timer);
         if (ended)
-            process.stderr.write(`kit: the ${input.cli} sign-in reached the end House set for it\n`);
-        return ended ? { ack: {} } : { ack: {}, acknowledged: () => this.agents.reread(input.cli) };
+            process.stderr.write(`kit: the ${call.cli} sign-in reached the end House set for it\n`);
+        return ended ? { result: {} } : { result: {}, returned: () => this.agents.reread(call.cli) };
     }
-    async signedIn(input, signal) {
-        await this.login(input, signal);
+    async signedIn(call, signal) {
+        await this.login(call, signal);
         if (!signal.aborted)
-            await this.agents.recheck(input.cli, signal);
+            await this.agents.recheck(call.cli, signal);
         return false;
     }
-    async login(input, signal) {
+    async login(call, signal) {
         let cli;
         try {
-            cli = await this.agents.located(input.cli, signal);
+            cli = await this.agents.located(call.cli, signal);
         }
         catch (error) {
             if (!signal.aborted)
-                process.stderr.write(`kit: the ${input.cli} sign-in failed: ${causeOf(error)}\n`);
+                process.stderr.write(`kit: the ${call.cli} sign-in failed: ${causeOf(error)}\n`);
             return;
         }
         if (signal.aborted)
             return;
-        const login = CLIS[input.cli].login;
+        const login = CLIS[call.cli].login;
         const child = spawn(cli, login.args, {
             stdio: ['pipe', 'pipe', 'pipe'],
             detached: true,
-            env: withoutProxy(),
+            env: childEnvironment(),
         });
         const running = () => child.exitCode === null && child.signalCode === null;
         const stop = () => killTree(child);
@@ -84,7 +85,7 @@ export class SignIns {
                 return;
             held = true;
             const steps = [{ kind: 'visit', label: 'Open this link and sign in', url: link }, step];
-            void holdSecretInput(this.house, input.input_id, steps, running).then((content) => {
+            void holdSecretInput(this.house, call.input_id, steps, running).then((content) => {
                 if (!running())
                     return;
                 if (content === null)
@@ -101,6 +102,6 @@ export class SignIns {
         });
         signal.removeEventListener('abort', stop);
         if (failed !== null && !signal.aborted)
-            process.stderr.write(`kit: the ${input.cli} sign-in failed: ${failed}\n`);
+            process.stderr.write(`kit: the ${call.cli} sign-in failed: ${failed}\n`);
     }
 }

package/dist/silence.js

@@ -0,0 +1,28 @@
+const SYSTEM_CLOCK = {
+    later: (delay, callback) => setTimeout(callback, delay),
+    clear: (timer) => clearTimeout(timer),
+};
+export class Silence {
+    timer = null;
+    interval;
+    silent;
+    clock;
+    constructor(interval, silent, clock = SYSTEM_CLOCK) {
+        this.interval = interval;
+        this.silent = silent;
+        this.clock = clock;
+    }
+    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;
+    }
+}