@agentshouse/kit 0.2.1-c3cf4b145dcda → 0.2.1-c3db1f18aed8f

package/dist/codex-main.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import { connect } from 'node:net';
+const KIT_ANSWER = '"house-kit-';
+const SYNC = 'house-kit/sync';
+function lines(each) {
+    let buffer = '';
+    return (chunk) => {
+        buffer += chunk;
+        for (let index = buffer.indexOf('\n'); index >= 0; index = buffer.indexOf('\n')) {
+            each(buffer.slice(0, index + 1));
+            buffer = buffer.slice(index + 1);
+        }
+    };
+}
+function answersKit(line) {
+    if (!line.includes(KIT_ANSWER))
+        return false;
+    try {
+        const message = JSON.parse(line);
+        return message.method === undefined && typeof message.id === 'string' && message.id.startsWith(KIT_ANSWER.slice(1));
+    }
+    catch {
+        return false;
+    }
+}
+const args = process.argv.slice(2);
+const serving = args[0] === 'app-server';
+if (process.env.HOUSE_KIT_SANDBOX === '1' && serving)
+    args.push('--disable', 'memories');
+const codex = spawn(process.env.HOUSE_KIT_CODEX, args, { stdio: ['pipe', 'pipe', 'inherit'] });
+const stream = serving ? connect(process.env.HOUSE_KIT_CODEX_STREAM) : null;
+stream?.on('error', () => undefined);
+process.stdin.setEncoding('utf8').on('data', lines((line) => codex.stdin.write(line)));
+process.stdin.on('end', () => codex.stdin.end());
+stream?.setEncoding('utf8').on('data', lines((line) => {
+    const message = JSON.parse(line);
+    if (message.method === SYNC)
+        stream.write(`${JSON.stringify({ jsonrpc: '2.0', id: message.id, result: {} })}\n`);
+    else
+        codex.stdin.write(line);
+}));
+codex.stdout.setEncoding('utf8').on('data', lines((line) => {
+    stream?.write(line);
+    if (answersKit(line) || process.stdout.write(line))
+        return;
+    codex.stdout.pause();
+    process.stdout.once('drain', () => codex.stdout.resume());
+}));
+codex.stdin.on('error', () => undefined);
+for (const signal of ['SIGTERM', 'SIGINT', 'SIGHUP'])
+    process.on(signal, () => codex.kill(signal));
+codex.on('exit', (code, signal) => {
+    if (signal === null)
+        process.exit(code ?? 1);
+    process.removeAllListeners(signal);
+    process.kill(process.pid, signal);
+});

package/dist/conversations.js

@@ -3,7 +3,7 @@ import { createHash, randomUUID } from 'node:crypto';
 import { mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { unlessAborted } from './abort.js';
-import { killMarked, processes, startAdapter } from './acp.js';
+import { startAdapter } from './acp.js';
 import { openBridge } from './bridge.js';
 import { CLIS } from './clis.js';
 import { readerFor } from './events.js';
@@ -11,12 +11,13 @@ import { placeFiles, uploadBytes } from './files.js';
 import { agentBase } from './home.js';
 import { instructions } from './instructions.js';
 import { Parts } from './parts.js';
+import { killMarked, Scope } from './scope.js';
 import { holdSecretInput } from './secret-input.js';
 import { createHowWeWork } from './skills.js';
 import { transcribe } from './transcription.js';
+import { workFor } from './work.js';
 const KILLED = 'the conversation was killed';
-// A process a conversation left running reports nothing when it exits, so the Kit looks again every five seconds while one runs.
-const PROCESS_RECHECK_MS = 5000;
+export const CONVERSATION_INPUTS = new Set(['open', 'message', 'interrupt', 'kill', 'option', 'answer']);
 function causeOf(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -29,9 +30,6 @@ function logged(error) {
 function marker(bridge) {
     return `HOUSE_BRIDGE=${bridge.env.HOUSE_BRIDGE}`;
 }
-function stop(bridge) {
-    killMarked(marker(bridge));
-}
 class Turn {
     id = randomUUID();
     parts;
@@ -53,7 +51,7 @@ class Conversation {
     turn = null;
     commands = null;
     context = null;
-    busy = new Set();
+    leftovers = new Set();
     waiting = [];
     sending = null;
     subagents = new Map();
@@ -86,9 +84,10 @@ export class Conversations {
     carrying = 0;
     reporting = 0;
     watched = false;
-    recheck = null;
     constructor(kit) {
         this.kit = kit;
+        // A process or a durable schedule ends without a report, so the Kit looks at both again every two seconds.
+        setInterval(() => this.look(), 2_000);
     }
     input(input) {
         this.carrying++;
@@ -126,22 +125,27 @@ export class Conversations {
         for (const conversation of this.conversations.values()) {
             const turn = conversation.turn;
             const asking = turn !== null && turn.questions > 0 && turn.secrets === 0;
-            if (conversation.busy.size > 0 || conversation.open > (asking ? 1 : 0))
+            if (conversation.open > (asking ? 1 : 0))
                 return false;
         }
-        for (const conversation of this.conversations.values()) {
-            const running = conversation.running;
-            if (running === null || running.baseline === null)
-                continue;
-            if ([...processes(marker(running.bridge))].every((found) => running.baseline.has(found)))
-                continue;
-            this.recheck ??= setTimeout(() => {
-                this.recheck = null;
-                this.kit.changed();
-            }, PROCESS_RECHECK_MS);
+        const conversations = [...this.conversations.values()];
+        if (conversations.some((conversation) => conversation.running?.work.busy()))
             return false;
+        return !conversations.some((conversation) => conversation.running?.scope.working() || [...conversation.leftovers].some((scope) => scope.working()));
+    }
+    quiet() {
+        return this.idle() && [...this.conversations.values()].every((conversation) => conversation.open === 0);
+    }
+    look() {
+        for (const conversation of this.conversations.values()) {
+            for (const scope of conversation.leftovers) {
+                if (!scope.empty())
+                    continue;
+                scope.close();
+                conversation.leftovers.delete(scope);
+            }
         }
-        return true;
+        this.kit.changed();
     }
     opened() {
         this.watched = false;
@@ -295,11 +299,13 @@ export class Conversations {
     }
     halt(conversation) {
         if (conversation.opening !== null)
-            stop(conversation.opening);
+            killMarked(marker(conversation.opening));
+        for (const scope of conversation.leftovers)
+            scope.kill();
         if (conversation.running === null)
             return;
         conversation.running.killed = true;
-        stop(conversation.running.bridge);
+        conversation.running.scope.kill();
     }
     async kill(conversation) {
         const running = conversation.running;
@@ -350,22 +356,30 @@ export class Conversations {
             throw new Error(KILLED);
         }
         conversation.opening = bridge;
+        const work = workFor(route.kind, route.working_directory, () => this.kit.changed());
+        const scope = new Scope(marker(bridge), randomUUID(), cli);
         try {
             await unlessAborted(createHowWeWork(bridge), conversation.killed.signal);
-            await CLIS[route.kind].allowHouse();
-            conversation.busy.clear();
-            const adapter = await startAdapter(route.kind, cli, route.working_directory, app, (message) => this.read(conversation, reader, message), bridge.env);
+            await CLIS[route.kind].allowHouse(bridge.env.PATH);
+            const adapter = await startAdapter(route.kind, cli, route.working_directory, app, (message) => {
+                work.read(message);
+                this.read(conversation, reader, message);
+            }, { ...bridge.env, ...(await work.open(cli)) }, undefined, scope);
             void adapter.exited.then(() => bridge.close());
             const agent = adapter.connection.agent;
             const cwd = route.working_directory;
-            const _meta = CLIS[route.kind].sessionMeta;
+            const _meta = CLIS[route.kind].sessionMeta(bridge.env.HOUSE_BRIDGE, conversation.id);
             const opened = sessionId === null
                 ? await agent.request('session/new', { cwd, mcpServers: [], _meta })
                 : { ...(await agent.request('session/resume', { sessionId, cwd, mcpServers: [], _meta })), sessionId };
             reader.session = opened.sessionId;
-            const running = { adapter, bridge, sessionId: opened.sessionId, killed: false, reader, baseline: null };
+            if (sessionId === null && CLIS[route.kind].renames) {
+                const prompt = [{ type: 'text', text: `/rename ${conversation.id}` }];
+                await agent.request('session/prompt', { sessionId: opened.sessionId, prompt });
+            }
+            const running = { adapter, bridge, sessionId: opened.sessionId, killed: false, reader, work, scope };
             const options = await this.launchSettings(running, route, opened.configOptions ?? []);
-            running.baseline = processes(marker(bridge));
+            void work.settled().then(() => scope.record());
             conversation.running = running;
             conversation.session = running.sessionId;
             this.kit.send({ type: 'process', conversation_id: conversation.id, running: true });
@@ -376,7 +390,9 @@ export class Conversations {
             return running.sessionId;
         }
         catch (error) {
-            stop(bridge);
+            scope.kill();
+            work.close();
+            conversation.leftovers.add(scope);
             bridge.close();
             throw conversation.kills > 0 ? new Error(KILLED) : error;
         }
@@ -409,17 +425,18 @@ export class Conversations {
         const running = conversation.running;
         if (running?.adapter !== adapter)
             return;
-        this.detach(conversation);
+        this.detach(conversation, running);
         if (conversation.turn !== null) {
             this.end(conversation, conversation.turn, { failed: running.killed ? KILLED : cause });
         }
         this.next(conversation);
         this.kit.changed();
     }
-    detach(conversation) {
+    detach(conversation, running) {
+        running.work.close();
+        conversation.leftovers.add(running.scope);
         conversation.running = null;
         conversation.commands = null;
-        conversation.busy.clear();
         for (const [id, question] of this.questions) {
             if (question.conversation === conversation)
                 this.questions.delete(id);
@@ -471,8 +488,6 @@ export class Conversations {
             turn.parts.measure(conversation.context);
         for (const part of conversation.held.splice(0))
             turn.parts.start(part);
-        for (const event of conversation.running?.reader.turnStarted() ?? [])
-            this.event(conversation, event);
         this.kit.changed();
         return turn;
     }
@@ -488,7 +503,7 @@ export class Conversations {
         if (conversation.turn === turn)
             conversation.turn = null;
         const body = Promise.allSettled(turn.uploads).then(() => ({
-            parts: turn.parts.parts,
+            parts: turn.parts.saved(),
             context: turn.parts.context,
             ...failed,
         }));
@@ -506,8 +521,8 @@ export class Conversations {
             }
             else {
                 if (conversation.open === 1 && conversation.running === running) {
-                    stop(running.bridge);
-                    this.detach(conversation);
+                    running.scope.kill();
+                    this.detach(conversation, running);
                 }
                 this.end(conversation, turn, { failed: causeOf(error) });
             }
@@ -592,20 +607,6 @@ export class Conversations {
             case 'options':
                 this.options(conversation, event.options);
                 return;
-            case 'busy':
-                if (event.running)
-                    conversation.busy.add(event.key);
-                else
-                    conversation.busy.delete(event.key);
-                this.kit.changed();
-                return;
-            case 'servers': {
-                const running = conversation.running;
-                if (running?.baseline)
-                    for (const found of processes(marker(running.bridge)))
-                        running.baseline.add(found);
-                return;
-            }
             case 'context':
                 conversation.context = { used: event.used, window: event.window };
                 conversation.turn?.parts.measure(conversation.context);
@@ -647,7 +648,7 @@ export class Conversations {
                 turn.parts.plan(event.entries);
                 return;
             case 'image':
-                turn.uploads.push(this.image(conversation, turn, event.data, event.mediaType));
+                turn.uploads.push(this.image(conversation, turn, turn.parts.reserve(), event.data, event.mediaType));
                 this.kit.changed();
                 return;
         }
@@ -667,7 +668,7 @@ export class Conversations {
         else
             conversation.turn.parts.start(part);
     }
-    async image(conversation, turn, data, mediaType) {
+    async image(conversation, turn, reserved, data, mediaType) {
         const bytes = Buffer.from(data, 'base64');
         const name = `image-${++turn.images}.${mediaType.split('/')[1]}`;
         try {
@@ -680,10 +681,10 @@ export class Conversations {
             const saved = declared.upload === undefined ? declared : await uploadBytes(declared.upload, bytes);
             if (saved.save.status !== 'saved')
                 throw new Error(saved.save.failure ?? saved.save.status);
-            turn.parts.start({ type: 'image', file: saved.version, name, media_type: mediaType });
+            turn.parts.arrive({ type: 'image', file: saved.version, name, media_type: mediaType }, reserved);
         }
         catch (error) {
-            turn.parts.start({ type: 'marker', marker: 'retry', text: `${name} was not saved: ${causeOf(error)}` });
+            turn.parts.arrive({ type: 'marker', marker: 'retry', text: `${name} was not saved: ${causeOf(error)}` }, reserved);
         }
     }
 }