@agentshouse/kit 0.2.1-cb6679d048e60 → 0.2.1-cb997daca91ed

package/dist/web-wizard.js

@@ -0,0 +1,101 @@
+import { loginPath, onLoginPath } from './clis.js';
+import { childEnvironment } from './relay.js';
+import { killTree } from './scope.js';
+const TERMINAL = 'xterm-256color';
+const SIGNALLED = 128;
+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(cause) {
+    process.stderr.write(`kit: a Web Wizard could not start: ${cause}\n`);
+    return { refused: `the script could not start: ${cause}` };
+}
+export class WebWizards {
+    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));
+    }
+    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')
+            this.end(run, {});
+    }
+    disconnected() {
+        for (const run of this.runs.values())
+            this.end(run, LOST);
+    }
+    async run(call) {
+        const run = { terminal: null, size: null, typed: [], ended: null, sized: Promise.withResolvers() };
+        this.runs.set(call.input_id, run);
+        try {
+            return { result: await this.ran(call.input_id, call.script, run) };
+        }
+        finally {
+            this.runs.delete(call.input_id);
+        }
+    }
+    async ran(wizard, script, run) {
+        let terminal;
+        try {
+            const { spawn } = await import('@lydell/node-pty');
+            const shell = await onLoginPath('bash');
+            if (shell === null)
+                return failed(NO_BASH);
+            const path = await loginPath();
+            await run.sized.promise;
+            if (run.ended !== null)
+                return run.ended;
+            terminal = spawn(shell, ['-c', script], {
+                name: TERMINAL,
+                ...run.size,
+                cwd: process.cwd(),
+                env: { ...childEnvironment(), PATH: path },
+            });
+        }
+        catch (error) {
+            return failed(causeOf(error));
+        }
+        run.terminal = terminal;
+        terminal.onData((data) => this.send({ type: 'wizard_output', wizard, data }));
+        for (const data of run.typed.splice(0))
+            terminal.write(data);
+        const exited = await new Promise((resolve) => terminal.onExit(resolve));
+        return run.ended ?? { exit_code: exited.signal ? SIGNALLED + exited.signal : exited.exitCode };
+    }
+    typed(run, 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();
+        if (run.terminal !== null)
+            killTree(run.terminal);
+    }
+}

package/dist/wire.js

@@ -0,0 +1,22 @@
+import { newerThanHouse, updateRequired } from './end.js';
+import { machine } from './placement.js';
+import { refusalOf } from './refusals.js';
+export const KIT_WIRE = 3;
+export const KIT_WIRE_HEADER = 'x-house-kit-wire';
+function newer(text) {
+    let body;
+    try {
+        body = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    return body?.error?.code === 'kit_newer_than_house' ? body.error : null;
+}
+export function endUnserved(text) {
+    if (refusalOf(text)?.code === 'kit_update_required')
+        updateRequired();
+    const refused = newer(text);
+    if (refused !== null)
+        newerThanHouse(refused.release, refused.commands[machine()]);
+}

package/dist/work.js

@@ -0,0 +1,346 @@
+import { randomUUID } from 'node:crypto';
+import { once } from 'node:events';
+import { readFileSync } from 'node:fs';
+import { rm } from 'node:fs/promises';
+import { createServer } from 'node:net';
+import { join } from 'node:path';
+import { RUNNING_JOB } from './events.js';
+import { kitHome, socketDirectory } from './home.js';
+const ENDED_TASK = new Set(['completed', 'failed', 'killed']);
+const SCHEDULING = new Set(['CronCreate', 'CronDelete', 'ScheduleWakeup']);
+const QUEUE_LIST = 'house-kit-queue-';
+const SYNC = 'house-kit-sync-';
+const WAKEUP = /Next wakeup scheduled for (\d\d):(\d\d):(\d\d) \(in (\d+)s\)/;
+const HALF_DAY = 12 * 60 * 60 * 1000;
+export function codexLauncher() {
+    return join(kitHome(), 'launchers', 'codex');
+}
+export class Work {
+    changed;
+    jobs = new Set();
+    constructor(changed) {
+        this.changed = changed;
+    }
+    async open(_cli) {
+        return {};
+    }
+    async settled() { }
+    read(message) {
+        this.take(message);
+        this.changed();
+    }
+    take(message) {
+        const update = message.params?.update;
+        if (message.method !== 'session/update' || update?.asyncTaskId === undefined)
+            return;
+        if (update.sessionUpdate === 'async_task_spawned')
+            this.jobs.add(update.asyncTaskId);
+        if (update.sessionUpdate === 'async_task_state_update' && !RUNNING_JOB.has(update.state))
+            this.jobs.delete(update.asyncTaskId);
+    }
+    busy() {
+        return this.jobs.size > 0;
+    }
+    close() { }
+}
+class ClaudeWork extends Work {
+    cwd;
+    level = new Set();
+    listed = new Set();
+    started = new Set();
+    running = false;
+    hooks = new Set();
+    calls = new Map();
+    crons = new Map();
+    wakeups = [];
+    goal = false;
+    constructor(cwd, changed) {
+        super(changed);
+        this.cwd = cwd;
+    }
+    take(message) {
+        super.take(message);
+        if (message.method === '_claude/sdkMessage')
+            this.sdk(message.params.message);
+        if (message.method === 'session/update')
+            this.update(message.params.update);
+    }
+    busy() {
+        return (super.busy() ||
+            this.level.size > 0 ||
+            this.started.size > 0 ||
+            this.running ||
+            this.hooks.size > 0 ||
+            this.crons.size > 0 ||
+            this.wakeups.length > 0 ||
+            this.goal ||
+            this.durable());
+    }
+    sdk(message) {
+        switch (message.subtype) {
+            case 'background_tasks_changed':
+                this.level = new Set(message.tasks.map((task) => task.task_id));
+                for (const id of this.level) {
+                    this.listed.add(id);
+                    this.started.delete(id);
+                }
+                break;
+            case 'task_started':
+                if (!this.listed.has(message.task_id))
+                    this.started.add(message.task_id);
+                break;
+            case 'task_updated':
+                if (ENDED_TASK.has(message.patch.status))
+                    this.started.delete(message.task_id);
+                break;
+            case 'task_notification':
+                this.started.delete(message.task_id);
+                break;
+            case 'session_state_changed':
+                if (message.state === 'running' && !this.running)
+                    this.wakeups = this.wakeups.filter((due) => due > Date.now());
+                this.running = message.state === 'running';
+                break;
+            case 'hook_started':
+                this.hooks.add(message.hook_id);
+                break;
+            case 'hook_response':
+                this.hooks.delete(message.hook_id);
+                break;
+        }
+    }
+    update(update) {
+        const air = update._meta?.jetbrains?.air;
+        if (update.sessionUpdate === 'session_info_update' && air !== undefined && 'goal' in air) {
+            this.goal = air.goal?.status === 'active';
+        }
+        if (update.sessionUpdate !== 'tool_call' && update.sessionUpdate !== 'tool_call_update')
+            return;
+        const tool = update._meta?.claudeCode?.toolName;
+        if (update.sessionUpdate === 'tool_call' && SCHEDULING.has(tool ?? ''))
+            this.calls.set(update.toolCallId, { tool });
+        const call = this.calls.get(update.toolCallId);
+        if (call === undefined)
+            return;
+        if (update.rawInput !== undefined)
+            call.input = update.rawInput;
+        if (update.content !== undefined)
+            call.content = update.content;
+        if (update.status === 'failed')
+            this.calls.delete(update.toolCallId);
+        if (update.status !== 'completed')
+            return;
+        this.calls.delete(update.toolCallId);
+        if (call.tool === 'CronCreate')
+            this.crons.set(update.toolCallId, JSON.stringify(call.content ?? []));
+        if (call.tool === 'ScheduleWakeup')
+            this.wakeup(call);
+        if (call.tool !== 'CronDelete')
+            return;
+        for (const [id, text] of this.crons)
+            if (text.includes(String(call.input?.id)))
+                this.crons.delete(id);
+    }
+    wakeup(call) {
+        if (call.input?.stop === true) {
+            this.wakeups = [];
+            return;
+        }
+        const time = WAKEUP.exec(JSON.stringify(call.content ?? []));
+        if (time === null) {
+            this.wakeups.push(Infinity);
+            return;
+        }
+        const fires = Date.now() + Number(time[4]) * 1000;
+        const due = new Date(fires);
+        due.setHours(Number(time[1]), Number(time[2]), Number(time[3]), 0);
+        if (due.getTime() - fires > HALF_DAY)
+            due.setDate(due.getDate() - 1);
+        if (fires - due.getTime() > HALF_DAY)
+            due.setDate(due.getDate() + 1);
+        this.wakeups.push(due.getTime());
+    }
+    durable() {
+        let text;
+        try {
+            text = readFileSync(join(this.cwd, '.claude', 'scheduled_tasks.json'), 'utf8');
+        }
+        catch (error) {
+            return error.code !== 'ENOENT';
+        }
+        try {
+            return JSON.parse(text).tasks?.length !== 0;
+        }
+        catch {
+            return true;
+        }
+    }
+}
+class CodexWork extends Work {
+    threads = new Map();
+    queues = new Map();
+    goals = new Set();
+    items = new Set();
+    hooks = new Set();
+    starting = new Set();
+    settling = [];
+    memories = null;
+    lost = false;
+    server = null;
+    path = null;
+    socket = null;
+    asked = 0;
+    heard = 0;
+    proving = -1;
+    proven = -1;
+    async open(cli) {
+        this.path = join(socketDirectory(), `${randomUUID()}.sock`);
+        this.server = createServer((socket) => this.connected(socket));
+        this.server.listen(this.path);
+        await once(this.server, 'listening');
+        return { CODEX_PATH: codexLauncher(), HOUSE_KIT_CODEX: cli, HOUSE_KIT_CODEX_STREAM: this.path };
+    }
+    settled() {
+        return new Promise((resolve) => {
+            this.settling.push(resolve);
+            this.settle();
+        });
+    }
+    take(message) {
+        super.take(message);
+        this.heard++;
+    }
+    busy() {
+        if (super.busy() ||
+            this.lost ||
+            this.memories !== false ||
+            [...this.threads.values()].some(Boolean) ||
+            this.queues.size > 0 ||
+            this.goals.size > 0 ||
+            this.items.size > 0 ||
+            this.hooks.size > 0) {
+            return true;
+        }
+        if (this.proven === this.heard)
+            return false;
+        this.prove();
+        return true;
+    }
+    close() {
+        this.server?.close();
+        if (this.path !== null)
+            void rm(this.path, { force: true });
+    }
+    connected(socket) {
+        this.socket = socket;
+        let buffer = '';
+        socket.on('error', () => this.lose());
+        socket.on('close', () => this.lose());
+        socket.setEncoding('utf8').on('data', (chunk) => {
+            buffer += chunk;
+            for (let index = buffer.indexOf('\n'); index >= 0; index = buffer.indexOf('\n')) {
+                const message = this.parsed(buffer.slice(0, index));
+                buffer = buffer.slice(index + 1);
+                if (message !== null)
+                    this.stream(message, socket);
+            }
+            this.settle();
+            this.changed();
+        });
+    }
+    parsed(line) {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            this.lost = true;
+            return null;
+        }
+    }
+    lose() {
+        this.lost = true;
+        this.changed();
+    }
+    prove() {
+        if (this.proving === this.heard)
+            return;
+        this.proving = this.heard;
+        this.socket.write(`${JSON.stringify({ jsonrpc: '2.0', id: `${SYNC}${this.heard}`, method: 'house-kit/sync' })}\n`);
+    }
+    settle() {
+        if (this.starting.size === 0)
+            for (const resolve of this.settling.splice(0))
+                resolve();
+    }
+    stream(message, socket) {
+        const params = message.params;
+        switch (message.method) {
+            case 'thread/status/changed':
+                this.threads.set(params.threadId, params.status.type === 'active' && params.status.activeFlags.length === 0);
+                break;
+            case 'thread/closed':
+                this.threads.delete(params.threadId);
+                break;
+            case 'thread/queue/changed':
+                this.queues.set(params.threadId, ++this.asked);
+                socket.write(`${JSON.stringify({ jsonrpc: '2.0', id: `${QUEUE_LIST}${this.asked}`, method: 'thread/queue/list', params: { threadId: params.threadId } })}\n`);
+                break;
+            case 'thread/goal/updated':
+                if (params.goal.status === 'active')
+                    this.goals.add(params.threadId);
+                else
+                    this.goals.delete(params.threadId);
+                break;
+            case 'thread/goal/cleared':
+                this.goals.delete(params.threadId);
+                break;
+            case 'item/started':
+                this.items.add(`${params.threadId} ${params.item.id}`);
+                break;
+            case 'item/completed':
+                this.items.delete(`${params.threadId} ${params.item.id}`);
+                break;
+            case 'hook/started':
+                this.hooks.add(params.run.id);
+                break;
+            case 'hook/completed':
+                this.hooks.delete(params.run.id);
+                break;
+            case 'mcpServer/startupStatus/updated':
+                if (params.status === 'starting')
+                    this.starting.add(`${params.threadId} ${params.name}`);
+                else
+                    this.starting.delete(`${params.threadId} ${params.name}`);
+                break;
+            case undefined:
+                this.answered(message);
+        }
+    }
+    answered(message) {
+        if (typeof message.id === 'string' && message.id.startsWith(SYNC)) {
+            this.proven = Number(message.id.slice(SYNC.length));
+        }
+        else if (typeof message.id === 'string' && message.id.startsWith(QUEUE_LIST)) {
+            const asked = Number(message.id.slice(QUEUE_LIST.length));
+            for (const [thread, latest] of this.queues) {
+                if (latest === asked && message.result?.data?.length === 0)
+                    this.queues.delete(thread);
+            }
+        }
+        else if (message.result?.config?.features !== undefined) {
+            this.memories = message.result.config.features.memories !== false;
+        }
+    }
+}
+class GrokWork extends Work {
+    busy() {
+        return true;
+    }
+}
+export function workFor(kind, cwd, changed) {
+    if (kind === 'claude-agent-acp')
+        return new ClaudeWork(cwd, changed);
+    if (kind === 'codex-acp')
+        return new CodexWork(changed);
+    return new GrokWork(changed);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agentshouse/kit",
-  "version": "0.2.1-cb6679d048e60",
-  "description": "House Kit connects an Environment to agents.house.",
+  "version": "0.2.1-cb997daca91ed",
+  "description": "Kit connects an Environment to agents.house.",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -12,27 +12,27 @@
     "kit": "dist/kit-main.js",
     "house": "dist/house-main.js"
   },
-  "exports": {
-    "./bootstrap": "./dist/bootstrap.json"
-  },
   "files": [
-    "dist",
-    "how-we-work.md",
-    "skills"
+    "dist"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.build.json && node scripts/bootstrap-manifest.mjs",
+    "bootstrap-manifest": "node scripts/bootstrap-manifest.mjs",
+    "build": "tsc -p tsconfig.build.json",
     "engine": "mkdir -p tmp/engine && docker run --rm -v \"$PWD:/kit\" -w /kit alpine:3.24@sha256:294b683cb724975bec92580e1e685676bd4b50bda910ddb8c51d4cabeaec77e6 sh scripts/engine.sh tmp/engine",
+    "follow-skills": "node scripts/follow-skills.mjs",
+    "release-files": "node scripts/release-files.mjs",
     "test": "tsc -p tsconfig.json && vitest run"
   },
   "dependencies": {
-    "@agentclientprotocol/sdk": "1.7.0",
-    "@agentshouse/mdmodel": "0.1.0-alpha.19",
+    "@agentclientprotocol/sdk": "2.0.1",
+    "@agentshouse/mdmodel": "0.1.0-c4f4d37bc9d6a",
+    "@agentshouse/skills": "0.1.0-c08575ab21b57",
+    "@lydell/node-pty": "1.2.0-beta.15",
     "yaml": "2.9.1"
   },
   "peerDependencies": {
-    "@agentclientprotocol/claude-agent-acp": "0.85.1",
-    "@agentclientprotocol/codex-acp": "2.1.1"
+    "@agentclientprotocol/claude-agent-acp": "0.94.0",
+    "@agentclientprotocol/codex-acp": "2.2.2"
   },
   "peerDependenciesMeta": {
     "@agentclientprotocol/claude-agent-acp": {
@@ -43,26 +43,26 @@
     }
   },
   "devDependencies": {
-    "@types/node": "24.13.6",
+    "@types/node": "24.19.2",
     "@types/ws": "8.18.2",
     "typescript": "7.0.2",
-    "vitest": "5.0.1",
+    "vitest": "5.0.5",
     "ws": "8.22.0"
   },
-  "packageManager": "npm@11.19.0",
+  "packageManager": "npm@11.19.1",
   "engines": {
-    "node": "24.21.0",
-    "npm": "11.19.0"
+    "node": "24.22.1",
+    "npm": "11.19.1"
   },
   "devEngines": {
     "runtime": {
       "name": "node",
-      "version": "24.21.0",
+      "version": "24.22.1",
       "onFail": "error"
     },
     "packageManager": {
       "name": "npm",
-      "version": "11.19.0",
+      "version": "11.19.1",
       "onFail": "error"
     }
   }

package/dist/blocks.js

@@ -1,51 +0,0 @@
-const FENCE = /^\s*(`{3,}|~{3,})\s*(\S*)/;
-export function blocksOf(text) {
-    const blocks = [];
-    let paragraph = [];
-    let fence = null;
-    const closeParagraph = () => {
-        const joined = paragraph.join('\n').trim();
-        if (joined.length > 0)
-            blocks.push({ type: 'paragraph', text: joined });
-        paragraph = [];
-    };
-    const closeFence = () => {
-        const joined = fence.lines.join('\n');
-        if (joined.length > 0)
-            blocks.push({ type: 'code', language: fence.language, text: joined });
-        fence = null;
-    };
-    for (const line of text.split('\n')) {
-        if (fence !== null) {
-            if (line.trim().startsWith(fence.marker))
-                closeFence();
-            else
-                fence.lines.push(line);
-            continue;
-        }
-        const opening = FENCE.exec(line);
-        if (opening !== null) {
-            closeParagraph();
-            fence = { marker: opening[1], language: opening[2] || null, lines: [] };
-        }
-        else if (line.trim().length === 0) {
-            closeParagraph();
-        }
-        else {
-            paragraph.push(line);
-        }
-    }
-    if (fence !== null)
-        closeFence();
-    closeParagraph();
-    return blocks;
-}
-export function firstChange(before, after) {
-    let index = 0;
-    while (index < before.length &&
-        index < after.length &&
-        JSON.stringify(before[index]) === JSON.stringify(after[index])) {
-        index++;
-    }
-    return index;
-}

package/dist/bootstrap.json

@@ -1,24 +0,0 @@
-{
-  "schemaVersion": 2,
-  "version": "0.2.1-cb6679d048e60",
-  "hosts": {
-    "macos": {
-      "asset": {
-        "name": "connect-linux.sh",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-cb6679d048e60/connect-linux.sh"
-      }
-    },
-    "linux": {
-      "asset": {
-        "name": "connect-linux.sh",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-cb6679d048e60/connect-linux.sh"
-      }
-    },
-    "windows": {
-      "asset": {
-        "name": "connect-windows.ps1",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-cb6679d048e60/connect-windows.ps1"
-      }
-    }
-  }
-}

package/dist/stream.js

@@ -1,46 +0,0 @@
-import { retryDelay } from './api.js';
-import { readEnrolment } from './home.js';
-const SUBPROTOCOL = 'house.kit.stream.1';
-function streamUrl(house) {
-    const url = new URL('/kit/stream', house);
-    url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
-    return url;
-}
-export function holdStream(handlers) {
-    let socket = null;
-    let failures = 0;
-    const connect = async () => {
-        const { house, credential } = (await readEnrolment());
-        const opening = new WebSocket(streamUrl(house), {
-            protocols: [SUBPROTOCOL],
-            headers: { authorization: `Bearer ${credential}` },
-        });
-        let opened = false;
-        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 : retryDelay(failures++);
-            setTimeout(() => void connect(), delay);
-        };
-    };
-    void connect();
-    return {
-        send(frame) {
-            if (socket === null || socket.readyState !== WebSocket.OPEN)
-                return false;
-            socket.send(JSON.stringify(frame));
-            return true;
-        },
-    };
-}