@agentshouse/kit 0.2.0 → 0.2.1-alpha.1

package/dist/resident.js

@@ -1,10 +1,66 @@
+import { killDescendants } from './acp.js';
+import { Agents } from './agents.js';
+import { house } from './api.js';
+import { Conversations } from './conversations.js';
 import { readEnrolment } from './home.js';
+import { SignIns } from './sign-in.js';
 import { holdStream } from './stream.js';
+function report(error) {
+    process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
+}
+function logged(work) {
+    work.catch(report);
+}
 export async function resident() {
     if ((await readEnrolment()) === null) {
         process.stderr.write('kit: this Environment is not enrolled; run kit login\n');
         process.exitCode = 1;
         return;
     }
-    holdStream();
+    process.env.HOUSE_KIT_RESIDENT = String(process.pid);
+    const agents = new Agents(house);
+    let stream = null;
+    let reported = false;
+    const idle = () => conversations.idle() && signIns.idle();
+    const changed = () => {
+        if (!idle()) {
+            reported = false;
+        }
+        else if (!reported) {
+            reported = true;
+            logged(house.deliver('/kit/idle', {}, idle));
+        }
+    };
+    const conversations = new Conversations({
+        house,
+        agents,
+        send: (frame) => stream?.send(frame) ?? false,
+        changed,
+    });
+    const signIns = new SignIns(house, agents, changed);
+    for (const signal of ['SIGTERM', 'SIGINT']) {
+        process.once(signal, () => {
+            killDescendants();
+            process.kill(process.pid, signal);
+        });
+    }
+    await house.deliver('/kit/restarted', {}).catch(report);
+    logged(agents.refresh());
+    stream = holdStream({
+        opened: () => {
+            conversations.opened();
+            changed();
+        },
+        frame: (received) => {
+            if (received.type === 'work_available' && received.subject === 'agents')
+                logged(agents.refresh());
+            if (received.type === 'input') {
+                reported = false;
+                if (received.kind === 'sign_in')
+                    signIns.start(received);
+                else
+                    conversations.input(received);
+            }
+        },
+    });
 }

package/dist/secret-input.js

@@ -0,0 +1,16 @@
+export async function holdSecretInput(house, subject, steps, waiting) {
+    while (waiting()) {
+        try {
+            const held = await house.post(`/kit/secret-input/${subject}`, { steps });
+            if (held.outcome === 'collected')
+                return held.content;
+            if (held.release !== 'held')
+                return null;
+        }
+        catch (error) {
+            process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+        }
+    }
+    return null;
+}

package/dist/sign-in.js

@@ -0,0 +1,83 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { killTree } from './acp.js';
+import { CLIS, cliCommand } from './clis.js';
+import { holdSecretInput } from './secret-input.js';
+const ESCAPE = /\u001b\[[\d;]*m/g;
+const LINK = /https:\/\/\S+/;
+const CODE = /^[A-Z0-9]+-[A-Z0-9]+$/;
+function logged(error) {
+    process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
+}
+export class SignIns {
+    house;
+    agents;
+    changed;
+    running = new Set();
+    constructor(house, agents, changed) {
+        this.house = house;
+        this.agents = agents;
+        this.changed = changed;
+    }
+    idle() {
+        return this.running.size === 0;
+    }
+    start(input) {
+        if (this.running.has(input.input_id))
+            return;
+        this.running.add(input.input_id);
+        this.changed();
+        this.login(input)
+            .then(() => this.agents.report())
+            .then(() => this.house.deliver(`/kit/inputs/${input.input_id}/ack`, {}))
+            .catch(logged)
+            .finally(() => {
+            this.running.delete(input.input_id);
+            this.changed();
+        });
+    }
+    async login(input) {
+        await this.agents.installed();
+        const login = CLIS[input.cli].login;
+        const child = spawn(cliCommand(input.cli), login.args, { stdio: ['pipe', 'pipe', 'pipe'], detached: true });
+        const running = () => child.exitCode === null && child.signalCode === null;
+        let link;
+        let code;
+        let last = '';
+        let held = false;
+        const read = (line) => {
+            const plain = line.replace(ESCAPE, '').trim();
+            if (plain === '')
+                return;
+            last = plain;
+            link ??= LINK.exec(plain)?.[0];
+            if (CODE.test(plain))
+                code ??= plain;
+            const step = login.code === 'collect'
+                ? { kind: 'collect', label: 'Code shown after you sign in', name: 'code' }
+                : code === undefined
+                    ? undefined
+                    : { kind: 'show', label: 'One-time code', text: code };
+            if (held || link === undefined || step === undefined)
+                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) => {
+                if (!running())
+                    return;
+                if (content === null)
+                    killTree(child);
+                else
+                    child.stdin.end(`${content.code}\n`);
+            });
+        };
+        for (const output of [child.stdout, child.stderr])
+            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}` : ''}`));
+        });
+        if (failed !== null)
+            process.stderr.write(`kit: the ${input.cli} sign-in failed: ${failed}\n`);
+    }
+}

package/dist/stream.js

@@ -5,7 +5,8 @@ function streamUrl(house) {
     url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
     return url;
 }
-export function holdStream() {
+export function holdStream(handlers) {
+    let socket = null;
     let failures = 0;
     const connect = async () => {
         const { house, credential } = (await readEnrolment());
@@ -17,9 +18,16 @@ export function holdStream() {
         opening.onopen = () => {
             opened = true;
             failures = 0;
+            socket = opening;
+            handlers.opened();
+        };
+        opening.onmessage = (event) => {
+            handlers.frame(JSON.parse(String(event.data)));
         };
         opening.onerror = () => undefined;
         opening.onclose = (event) => {
+            if (socket === opening)
+                socket = null;
             process.stderr.write(`kit: control stream closed ${event.code} ${event.reason}\n`);
             const delay = opened
                 ? 1000 + Math.random() * 2000
@@ -28,4 +36,12 @@ export function holdStream() {
         };
     };
     void connect();
+    return {
+        send(frame) {
+            if (socket === null || socket.readyState !== WebSocket.OPEN)
+                return false;
+            socket.send(JSON.stringify(frame));
+            return true;
+        },
+    };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentshouse/kit",
-  "version": "0.2.0",
+  "version": "0.2.1-alpha.1",
   "description": "House Kit connects an Environment to agents.house.",
   "license": "MIT",
   "repository": {
@@ -19,6 +19,25 @@
     "build": "tsc -p tsconfig.build.json",
     "test": "tsc -p tsconfig.json && vitest run"
   },
+  "dependencies": {
+    "@agentclientprotocol/sdk": "1.7.0"
+  },
+  "peerDependencies": {
+    "@agentclientprotocol/claude-agent-acp": "0.85.1",
+    "@agentclientprotocol/codex-acp": "2.1.1",
+    "@xai-official/grok": "1.0.46"
+  },
+  "peerDependenciesMeta": {
+    "@agentclientprotocol/claude-agent-acp": {
+      "optional": true
+    },
+    "@agentclientprotocol/codex-acp": {
+      "optional": true
+    },
+    "@xai-official/grok": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@types/node": "24.13.6",
     "@types/ws": "8.18.2",