@agentshouse/kit 0.2.1-ce145e9aadbf6 → 0.2.1-ce47f621f90e1

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/secret-input.js

@@ -1,4 +1,4 @@
-import { HouseRefusal, retryDelay } from './api.js';
+import { finalRefusal, retryDelay } from './api.js';
 export async function holdSecretInput(house, subject, steps, waiting) {
     for (let failures = 0; waiting();) {
         try {
@@ -10,9 +10,10 @@ export async function holdSecretInput(house, subject, steps, waiting) {
             failures = 0;
         }
         catch (error) {
-            if (error instanceof HouseRefusal && error.status < 500)
+            if (finalRefusal(error))
                 return null;
             process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
+            // A wait that did not reach House is held again on the jittered curve for as long as its asker still waits.
             await new Promise((resolve) => setTimeout(resolve, retryDelay(failures++)));
         }
     }

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 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/shell.js

@@ -0,0 +1,3 @@
+export function quoted(value) {
+    return `'${value.replaceAll("'", `'\\''`)}'`;
+}

package/dist/sign-in.js

@@ -1,7 +1,8 @@
 import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
-import { killTree } from './acp.js';
-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;
 const LINK = /https:\/\/\S+/;
@@ -9,53 +10,58 @@ 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) {
+    calls;
+    constructor(house, agents, calls) {
         this.house = house;
         this.agents = agents;
-        this.changed = changed;
+        this.calls = calls;
     }
-    idle() {
-        return this.running.size === 0;
+    start(call) {
+        void this.calls.carry(call.input_id, () => this.signIn(call));
     }
-    start(input) {
-        if (this.running.has(input.input_id))
-            return;
-        this.running.add(input.input_id);
-        this.changed();
-        this.login(input)
-            .then(() => this.agents.recheck(input.cli))
-            .then(() => this.house.deliver(`/kit/inputs/${input.input_id}/ack`, {}))
-            .then(() => this.agents.reread(input.cli))
-            .catch(logged)
-            .finally(() => {
-            this.running.delete(input.input_id);
-            this.changed();
-        });
+    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(), 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 ${call.cli} sign-in reached the end House set for it\n`);
+        return ended ? { result: {} } : { result: {}, returned: () => this.agents.reread(call.cli) };
     }
-    async login(input) {
+    async signedIn(call, signal) {
+        await this.login(call, signal);
+        if (!signal.aborted)
+            await this.agents.recheck(call.cli, signal);
+        return false;
+    }
+    async login(call, signal) {
         let cli;
         try {
-            cli = await this.agents.located(input.cli);
+            cli = await this.agents.located(call.cli, signal);
         }
         catch (error) {
-            process.stderr.write(`kit: the ${input.cli} sign-in failed: ${causeOf(error)}\n`);
+            if (!signal.aborted)
+                process.stderr.write(`kit: the ${call.cli} sign-in failed: ${causeOf(error)}\n`);
             return;
         }
-        const login = CLIS[input.cli].login;
+        if (signal.aborted)
+            return;
+        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);
+        signal.addEventListener('abort', stop, { once: true });
         let link;
         let code;
         let last = '';
@@ -79,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)
@@ -92,9 +98,10 @@ export class SignIns {
             createInterface({ input: output }).on('line', read);
         const failed = await new Promise((resolve) => {
             child.on('error', (error) => resolve(error.message));
-            child.on('close', (status, signal) => resolve(status === 0 ? null : `exited with ${status ?? signal}${last ? `: ${last}` : ''}`));
+            child.on('close', (status, killed) => resolve(status === 0 ? null : `exited with ${status ?? killed}${last ? `: ${last}` : ''}`));
         });
-        if (failed !== null)
-            process.stderr.write(`kit: the ${input.cli} sign-in failed: ${failed}\n`);
+        signal.removeEventListener('abort', stop);
+        if (failed !== null && !signal.aborted)
+            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;
+    }
+}

package/dist/skills.js

@@ -1,17 +1,14 @@
-import { readFileSync } from 'node:fs';
-import { cp, lstat, mkdir, readdir, realpath, rm, symlink, writeFile } from 'node:fs/promises';
+import { cp, lstat, mkdir, realpath, rm, symlink, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join, relative } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { KIT_VERSION } from './clis.js';
+import { GUIDE, listSkills } from '@agentshouse/skills';
+import { parse } from 'yaml';
+import { KIT_RELEASE } 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 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 RECORD = 'skill-set.json';
-const CREATED = 'how-we-work-created';
-const UNWRITABLE = new Set(['room_not_found', 'operation_denied']);
+const ENTRY = 'SKILL.md';
+const FRONTMATTER = /^---\n([\s\S]*?)\n---\n/u;
+const ORIGIN = '<origin>';
 function skillsDirectory() {
     return join(homedir(), '.agents', 'skills');
 }
@@ -29,50 +26,67 @@ async function present(path) {
         throw error;
     }
 }
-async function install() {
-    const names = [];
-    for (const name of (await readdir(SKILL_SET)).sort()) {
-        if (!(await present(join(skillsDirectory(), name))) && !(await present(join(claudeDirectory(), name)))) {
-            names.push(name);
+function skillName(text) {
+    const front = FRONTMATTER.exec(text);
+    const fields = (front === null ? null : parse(front[1]));
+    return typeof fields?.name === 'string' && typeof fields.description === 'string' ? fields.name : undefined;
+}
+function skillSet(origin) {
+    const upstream = listSkills().map(({ name, directory }) => ({
+        name,
+        place: (destination) => cp(directory, destination, { recursive: true }),
+    }));
+    const pages = GUIDE.flatMap(({ text }) => {
+        const name = skillName(text);
+        if (name === undefined)
+            return [];
+        const place = async (destination) => {
+            await mkdir(destination);
+            await writeFile(join(destination, ENTRY), text.replaceAll(ORIGIN, origin));
+        };
+        return [{ name, place }];
+    });
+    return [...upstream, ...pages].sort((left, right) => (left.name < right.name ? -1 : 1));
+}
+async function install(origin) {
+    const placed = [];
+    for (const skill of skillSet(origin)) {
+        if (!(await present(join(skillsDirectory(), skill.name))) && !(await present(join(claudeDirectory(), skill.name)))) {
+            placed.push(skill);
         }
     }
+    const names = placed.map((skill) => skill.name);
     await writeHome(RECORD, { names });
     await mkdir(skillsDirectory(), { recursive: true });
     await mkdir(claudeDirectory(), { recursive: true });
     const skills = await realpath(skillsDirectory());
     const claude = await realpath(claudeDirectory());
-    for (const name of names) {
-        await cp(join(SKILL_SET, name), join(skillsDirectory(), name), { recursive: true });
+    for (const { name, place } of placed) {
+        await place(join(skillsDirectory(), name));
         if (claude !== skills)
             await symlink(relative(claude, join(skills, name)), join(claudeDirectory(), name));
     }
-    await writeHome(RECORD, { version: KIT_VERSION, names });
+    await writeHome(RECORD, { version: KIT_RELEASE, origin, names });
+}
+export async function placeSkillSet(origin) {
+    try {
+        await replaceSkillSet(origin);
+    }
+    catch (error) {
+        process.stderr.write(`kit: the skills could not be placed: ${error.message}\n`);
+    }
 }
-export async function placeSkillSet() {
+async function replaceSkillSet(origin) {
     const accepted = (await readConfiguration()).skills;
     const installed = await readHome(RECORD);
-    if (accepted && installed?.version === KIT_VERSION)
+    if (accepted && installed?.version === KIT_RELEASE && installed.origin === origin)
         return;
     for (const name of installed?.names ?? []) {
         await rm(join(claudeDirectory(), name), { recursive: true, force: true });
         await rm(join(skillsDirectory(), name), { recursive: true, force: true });
     }
     if (accepted)
-        await install();
+        await install(origin);
     else
         await rm(join(kitHome(), RECORD), { force: true });
 }
-export async function createHowWeWork(bridge) {
-    if ((await readHome(RECORD)) === null || (await present(join(kitHome(), CREATED))))
-        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 ?? ''))
-            return;
-        if (refusal?.code !== 'edit_conflict' || !refusal.conflicts.includes('path_exists'))
-            throw new Error(text);
-    }
-    await writeFile(join(kitHome(), CREATED), '');
-}