@agentshouse/kit 0.2.1-c3cf4b145dcda → 0.2.1-c4beedfd8b549

package/dist/events.js

@@ -1,7 +1,7 @@
 const COMMAND = { shown: 'command' };
 const HIDDEN = { shown: 'hidden' };
 const FINISHED = new Set(['completed', 'failed']);
-const RUNNING_JOB = new Set(['running', 'paused']);
+export const RUNNING_JOB = new Set(['running', 'paused']);
 const ROUTINE_TARGETS = { send_routine_request: 'access', cancel_routine_request: 'request' };
 function words(line) {
     const found = [];
@@ -113,9 +113,6 @@ class Reader {
     refused(option) {
         this.requestedOptions.delete(option);
     }
-    turnStarted() {
-        return [];
-    }
     closeTurn() {
         const events = [];
         for (const [id, call] of this.calls) {
@@ -187,10 +184,7 @@ class Reader {
         const label = this.jobs.get(id) ?? '';
         if (state !== 'running')
             this.jobs.delete(id);
-        return [
-            { kind: 'busy', key: `job:${id}`, running: state === 'running' },
-            { kind: 'marker', marker: 'job', text: `${label}: ${state}` },
-        ];
+        return [{ kind: 'marker', marker: 'job', text: `${label}: ${state}` }];
     }
     optionsChanged(options) {
         const events = [];
@@ -275,7 +269,6 @@ class Reader {
 class ClaudeReader extends Reader {
     watchedOptions = { model: 'model' };
     tasks = new Map();
-    scheduled = new Map();
     own(message) {
         if (message.params?.update?._meta?.claudeCode?.parentToolUseId !== undefined)
             return [];
@@ -295,10 +288,6 @@ class ClaudeReader extends Reader {
             return [];
         const sdk = message.params.message;
         switch (sdk.subtype) {
-            case 'background_tasks_changed':
-                return [{ kind: 'busy', key: 'tasks', running: sdk.tasks.length > 0 }];
-            case 'session_state_changed':
-                return [{ kind: 'busy', key: 'state', running: sdk.state === 'running' }];
             case 'task_started':
                 if (sdk.tool_use_id !== undefined)
                     this.tasks.set(sdk.task_id, sdk.tool_use_id);
@@ -309,16 +298,6 @@ class ClaudeReader extends Reader {
                 return [];
         }
     }
-    turnStarted() {
-        const events = [];
-        for (const [id, entry] of this.scheduled) {
-            if (entry.recurring)
-                continue;
-            this.scheduled.delete(id);
-            events.push({ kind: 'busy', key: `scheduled:${id}`, running: false });
-        }
-        return events;
-    }
     decide(call, final) {
         const tool = call.meta.claudeCode?.toolName;
         if (tool === 'Agent' || tool === 'Task' || call.meta.jetbrains?.air?.subagent === true) {
@@ -350,22 +329,7 @@ class ClaudeReader extends Reader {
         if (call.status !== 'completed')
             return [];
         if (tool === 'CronCreate' || (tool === 'ScheduleWakeup' && call.rawInput?.stop !== true)) {
-            this.scheduled.set(call.id, {
-                recurring: tool === 'CronCreate' && call.rawInput?.recurring !== false,
-                text: contentText(call.content) ?? '',
-            });
-            return [
-                { kind: 'busy', key: `scheduled:${call.id}`, running: true },
-                { kind: 'marker', marker: 'job', text: `${call.rawInput?.prompt ?? call.title ?? ''}: scheduled` },
-            ];
-        }
-        if (tool === 'CronDelete') {
-            for (const [id, entry] of this.scheduled) {
-                if (!entry.text.includes(String(call.rawInput?.id)))
-                    continue;
-                this.scheduled.delete(id);
-                return [{ kind: 'busy', key: `scheduled:${id}`, running: false }];
-            }
+            return [{ kind: 'marker', marker: 'job', text: `${call.rawInput?.prompt ?? call.title ?? ''}: scheduled` }];
         }
         return [];
     }
@@ -402,15 +366,9 @@ class CodexReader extends Reader {
             case 'subagent_spawned':
                 this.children.set(update.subagentSessionId, { id: null, text: '' });
                 this.subagents.add(update.subagentSessionId);
-                return [
-                    { kind: 'busy', key: `subagent:${update.subagentSessionId}`, running: true },
-                    { kind: 'subagent', id: update.subagentSessionId, description: update.name },
-                ];
+                return [{ kind: 'subagent', id: update.subagentSessionId, description: update.name }];
             case 'subagent_state_update':
-                return [
-                    { kind: 'busy', key: `subagent:${update.subagentSessionId}`, running: false },
-                    ...this.finish(update.subagentSessionId, this.children.get(update.subagentSessionId)?.text || null),
-                ];
+                return this.finish(update.subagentSessionId, this.children.get(update.subagentSessionId)?.text || null);
             default:
                 return super.update(update);
         }
@@ -427,10 +385,6 @@ class CodexReader extends Reader {
             child.id = id;
             child.text += update.content.text;
         }
-        const status = update._meta?.codex?.threadStatus?.type;
-        if (update.sessionUpdate === 'session_info_update' && status !== undefined) {
-            return [{ kind: 'busy', key: `thread:${session}`, running: status === 'active' }];
-        }
         return [];
     }
     decide(call) {
@@ -460,7 +414,6 @@ class CodexReader extends Reader {
 class GrokReader extends Reader {
     watchedOptions = {};
     children = new Map();
-    queues = new Map();
     models = [];
     model = null;
     answered(result) {
@@ -473,15 +426,10 @@ class GrokReader extends Reader {
         if (this.session !== null && session !== undefined && session !== this.session && !this.children.has(session))
             return [];
         if (message.method === '_x.ai/queue/changed') {
-            const running = message.params.runningPromptId ?? null;
-            this.queues.set(session, { running, entries: message.params.entries.length });
-            return [this.queued(session), ...(running !== null && session === this.session ? [{ kind: 'started' }] : [])];
+            return (message.params.runningPromptId ?? null) !== null && session === this.session ? [{ kind: 'started' }] : [];
         }
         if (message.params?.update?.sessionUpdate === 'turn_completed') {
-            const queue = this.queues.get(session);
-            if (queue !== undefined && queue.running === message.params.update.prompt_id)
-                queue.running = null;
-            return [this.queued(session), ...(session === this.session ? [{ kind: 'ended' }] : [])];
+            return session === this.session ? [{ kind: 'ended' }] : [];
         }
         if (message.method === '_x.ai/models/update') {
             this.offered(message.params);
@@ -489,10 +437,6 @@ class GrokReader extends Reader {
         }
         return super.read(message);
     }
-    queued(session) {
-        const queue = this.queues.get(session);
-        return { kind: 'busy', key: `queue:${session}`, running: queue !== undefined && (queue.running !== null || queue.entries > 0) };
-    }
     offered(models) {
         this.models = models.availableModels ?? this.models;
         this.model = models.currentModelId ?? this.model;
@@ -508,16 +452,9 @@ class GrokReader extends Reader {
             case '_x.ai/task_completed':
                 return this.job(update.task_snapshot.task_id, null, update.task_snapshot.exit_code === 0 ? 'completed' : 'failed');
             case '_x.ai/scheduled_task_created':
-                return [
-                    { kind: 'busy', key: `scheduled:${update.task_id}`, running: true },
-                    { kind: 'marker', marker: 'job', text: `${update.prompt}: next run ${update.next_fire_at}` },
-                ];
-            case '_x.ai/scheduled_task_deleted':
-                return [{ kind: 'busy', key: `scheduled:${update.task_id}`, running: false }];
+                return [{ kind: 'marker', marker: 'job', text: `${update.prompt}: next run ${update.next_fire_at}` }];
             case '_x.ai/session_notification':
                 return this.notification(update);
-            case '_x.ai/mcp_initialized':
-                return [{ kind: 'servers' }];
             default:
                 return [];
         }
@@ -538,14 +475,11 @@ class GrokReader extends Reader {
                     candidate.decided.description === update.description) ??
                     [...this.calls.values()].find((candidate) => candidate.decided?.shown === 'subagent' && ![...this.children.values()].includes(candidate.id));
                 this.children.set(update.child_session_id, call?.id ?? null);
-                return [{ kind: 'busy', key: `subagent:${update.child_session_id}`, running: true }];
+                return [];
             }
             case 'subagent_finished': {
                 const call = this.children.get(update.child_session_id);
-                return [
-                    { kind: 'busy', key: `subagent:${update.child_session_id}`, running: false },
-                    ...(typeof call === 'string' ? this.finish(call, update.output ?? null) : []),
-                ];
+                return typeof call === 'string' ? this.finish(call, update.output ?? null) : [];
             }
             case 'auto_compact_completed':
                 return [{ kind: 'marker', marker: 'compaction', text: '' }];

package/dist/house-main.js

@@ -6,12 +6,14 @@ import { basename, join } from 'node:path';
 import { kitHome, readOwnAgent } from './home.js';
 import { callHouse, rpc, UNREACHABLE } from './mcp.js';
 import { refusalOf } from './refusals.js';
+import { relayed } from './relay.js';
+import { parse } from 'yaml';
 const USAGE = "usage: house <tool> ['<arguments as JSON>']";
 const PUSH_USAGE = 'usage: house push [commit] [--owner]';
 const PUSH = "push [commit]: sends the Local copy's committed changes to House";
 const ARGUMENTS = `the arguments are one JSON object in single quotes, like house search '{"query":"invoice"}'`;
 const CLOSED = "this conversation's House connection is closed; nothing to do from here";
-const SANDBOXED = "your CLI's sandbox kept house from House; run house as a command of its own, with no pipe, chain or redirect";
+const SANDBOXED = "your CLI's sandbox kept house from House; run house directly, not through another program";
 const REVOKED = 'this conversation no longer has House access; nothing to do from here';
 const UNCONNECTED = "this computer's own agent has no House connection; run kit login";
 const DISCONNECTED = "House no longer accepts this computer's own agent; run kit login";
@@ -79,11 +81,24 @@ async function localFile(path) {
             : `${path} is not a readable file`);
     }
 }
+async function sent(url, bytes, operation) {
+    const headers = { 'content-type': 'application/octet-stream', 'x-house-byte-operation': operation };
+    if (socketPath !== undefined)
+        return bridged(url, bytes, headers);
+    setGlobalProxyFromEnv();
+    const answer = await fetch(relayed(url), { method: 'POST', headers, body: bytes }).catch(() => {
+        throw new Error(UNREACHABLE);
+    });
+    const text = await answer.text();
+    if (answer.status === 200)
+        return text;
+    throw new Error(refused(url, answer.status, text));
+}
 async function upload(path, roomRef, missing) {
     if (typeof path !== 'string' || path === '')
         throw new Error(missing);
     const bytes = await localFile(path);
-    const declared = JSON.parse(await bridged('/kit/attachments/upload', {
+    const declared = parse(await called('upload', {
         ...(roomRef === undefined ? {} : { room_ref: roomRef }),
         name: basename(path),
         bytes: bytes.length,
@@ -91,10 +106,7 @@ async function upload(path, roomRef, missing) {
     }));
     if (declared.upload === undefined)
         return declared.attachment;
-    const saved = JSON.parse(await bridged(declared.upload.url, bytes, {
-        'content-type': 'application/octet-stream',
-        'x-house-byte-operation': declared.upload.operation,
-    }));
+    const saved = JSON.parse(await sent(declared.upload.url, bytes, declared.upload.operation));
     if (saved.upload_failure !== undefined)
         throw new Error(`${path} was not saved: ${saved.upload_failure}; call again later`);
     return saved.attachment;
@@ -138,17 +150,20 @@ async function house([verb, argument]) {
         return [...(tool.description === undefined ? [] : [tool.description]), JSON.stringify(tool.inputSchema)].join('\n');
     }
     const args = argumentsOf(argument);
-    if (socketPath !== undefined && verb === 'upload_attachment') {
-        return JSON.stringify({ attachment: await upload(args.path, args.room_ref, 'upload_attachment needs "path", a local file') });
+    if (verb === 'upload') {
+        return JSON.stringify({ attachment: await upload(args.path, args.room_ref, 'upload needs "path", a local file') });
     }
-    if (socketPath !== undefined && verb === 'append_record' && Array.isArray(args.attachments)) {
+    if (verb === 'append_record' && Array.isArray(args.attachments)) {
         const attachments = [];
         for (const path of args.attachments) {
             attachments.push(await upload(path, args.room_ref, 'each attachments entry is the path of a local file'));
         }
         args.attachments = attachments;
     }
-    const result = await mcp('tools/call', { name: verb, arguments: args });
+    return called(verb, args);
+}
+async function called(name, args) {
+    const result = await mcp('tools/call', { name, arguments: args });
     const text = result.content.map((content) => content.text).join('\n');
     if (result.isError === true)
         throw new Error(text.replace(/\n+$/, ''));

package/dist/instructions.js

@@ -1,6 +1,6 @@
 import { HOW_WE_WORK } from './skills.js';
 const HOUSE_LINE = 'Work with House through the `house` CLI: run `house --help`.';
-const FILE_LINE = 'To give the User a file or a page, upload it with `house upload_attachment` and link it; never start a server.';
+const FILE_LINE = 'To give the User a file or a page, upload it with `house upload` and link it; never start a server.';
 const READ_LINE = 'Before working in a Room, read `/rooms/private/rooms/<handle>/AGENTS.md`.';
 const COPIES_LINE = 'House Local copies; commit, then `house push`:';
 const UNREADABLE = /^(?:\S+: )?(?:path_not_found|room_not_found|operation_denied)\b/;

package/dist/resident.js

@@ -2,32 +2,31 @@ import { once } from 'node:events';
 import { watch } from 'node:fs';
 import { mkdir, rm, writeFile } from 'node:fs/promises';
 import { createServer } from 'node:http';
-import { extname, join } from 'node:path';
+import { dirname, extname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { killDescendants } from './acp.js';
 import { Agents } from './agents.js';
 import { house } from './api.js';
 import { received } from './bridge.js';
 import { Conversations } from './conversations.js';
 import { LocalCopies } from './copies.js';
 import { agentBase, enrolled, kitHome } from './home.js';
+import { killDescendants } from './scope.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 { codexLauncher } from './work.js';
 function report(error) {
     process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
 }
 function logged(work) {
     work.catch(report);
 }
-async function installShim() {
-    const main = fileURLToPath(new URL(`./git-main${extname(fileURLToPath(import.meta.url))}`, import.meta.url));
-    await mkdir(join(kitHome(), 'shim'), { recursive: true });
-    await writeFile(join(kitHome(), 'shim', 'git'), `#!/bin/sh\nexec ${quoted(process.execPath)} ${quoted(main)} "$@"\n`, {
-        mode: 0o755,
-    });
+async function installShim(path, module) {
+    const main = fileURLToPath(new URL(`./${module}${extname(fileURLToPath(import.meta.url))}`, import.meta.url));
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `#!/bin/sh\nexec ${quoted(process.execPath)} ${quoted(main)} "$@"\n`, { mode: 0o755 });
 }
 async function serveOwner(copies) {
     const socketPath = join(kitHome(), 'owner.sock');
@@ -79,7 +78,8 @@ export async function resident() {
     const agents = new Agents(house);
     const copies = new LocalCopies(house);
     await copies.load();
-    await installShim();
+    await installShim(join(kitHome(), 'shim', 'git'), 'git-main');
+    await installShim(codexLauncher(), 'codex-main');
     await serveOwner(copies);
     let stream = null;
     let reported = false;

package/dist/scope.js

@@ -0,0 +1,203 @@
+import { execFileSync } from 'node:child_process';
+import { mkdirSync, readdirSync, readFileSync, rmdirSync, statSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+const LISTING_BYTES = 1 << 28;
+const CGROUPS = '/sys/fs/cgroup';
+const GONE = new Set(['ENOENT', 'ESRCH']);
+function failure(error) {
+    return error.code ?? '';
+}
+function listed(environment) {
+    const found = new Map();
+    const output = execFileSync('ps', [environment ? '-AEww' : '-Aww', '-o', 'pid=,ppid=,sess=,command='], {
+        encoding: 'utf8',
+        maxBuffer: LISTING_BYTES,
+    });
+    for (const line of output.split('\n')) {
+        const fields = /^\s*(\d+)\s+(\d+)\s+(\S+)\s?(.*)$/.exec(line);
+        if (fields !== null)
+            found.set(Number(fields[1]), { parent: Number(fields[2]), session: fields[3], command: fields[4] });
+    }
+    return found;
+}
+function read(pid) {
+    try {
+        const stat = readFileSync(`/proc/${pid}/stat`, 'utf8');
+        const fields = stat.slice(stat.lastIndexOf(')') + 2).split(' ');
+        const command = readFileSync(`/proc/${pid}/cmdline`, 'utf8').replaceAll('\0', ' ');
+        return { parent: Number(fields[1]), session: fields[3], command };
+    }
+    catch (error) {
+        if (GONE.has(failure(error)))
+            return null;
+        throw error;
+    }
+}
+function processes() {
+    if (process.platform === 'darwin')
+        return listed(false);
+    const found = new Map();
+    for (const entry of readdirSync('/proc')) {
+        const running = /^\d+$/.test(entry) ? read(entry) : null;
+        if (running !== null)
+            found.set(Number(entry), running);
+    }
+    return found;
+}
+function descendants(roots, table = processes()) {
+    const children = new Map();
+    for (const [pid, { parent }] of table)
+        children.set(parent, [...(children.get(parent) ?? []), pid]);
+    const tree = [];
+    const pending = roots.flatMap((root) => children.get(root) ?? []);
+    while (pending.length > 0) {
+        const pid = pending.pop();
+        tree.push(pid);
+        pending.push(...(children.get(pid) ?? []));
+    }
+    return tree;
+}
+function marked(marker, doubted) {
+    if (process.platform === 'darwin') {
+        return [...listed(true)].filter(([, { command }]) => ` ${command} `.includes(` ${marker} `)).map(([pid]) => pid);
+    }
+    return readdirSync('/proc')
+        .filter((entry) => /^\d+$/.test(entry) && carries(entry, marker, doubted))
+        .map(Number);
+}
+function carries(pid, marker, doubted) {
+    try {
+        return readFileSync(`/proc/${pid}/environ`, 'utf8').split('\0').includes(marker);
+    }
+    catch (error) {
+        if (GONE.has(failure(error)))
+            return false;
+        if (failure(error) !== 'EACCES')
+            throw error;
+        return doubted && statSync(`/proc/${pid}`, { throwIfNoEntry: false })?.uid === process.getuid();
+    }
+}
+function killAll(pids) {
+    for (const pid of pids) {
+        for (const target of [-pid, pid]) {
+            try {
+                process.kill(target, 'SIGKILL');
+            }
+            catch { }
+        }
+    }
+}
+export function killTree(child) {
+    killAll([child.pid, ...descendants([child.pid])]);
+}
+export function killMarked(marker) {
+    const pids = marked(marker, false);
+    killAll([...pids, ...descendants(pids)]);
+}
+export function killDescendants() {
+    const pids = marked(`HOUSE_KIT_RESIDENT=${process.pid}`, false);
+    killAll([...pids, ...descendants([process.pid, ...pids])]);
+}
+function ownGroup() {
+    if (process.platform !== 'linux')
+        return null;
+    try {
+        const line = readFileSync('/proc/self/cgroup', 'utf8')
+            .split('\n')
+            .find((entry) => entry.startsWith('0::'));
+        return line === undefined ? null : join(CGROUPS, line.slice(3));
+    }
+    catch {
+        return null;
+    }
+}
+function members(group) {
+    const pids = readFileSync(join(group, 'cgroup.procs'), 'utf8').split('\n').filter(Boolean).map(Number);
+    for (const entry of readdirSync(group, { withFileTypes: true })) {
+        if (entry.isDirectory())
+            pids.push(...members(join(group, entry.name)));
+    }
+    return pids;
+}
+export class Scope {
+    marker;
+    cli;
+    group;
+    session = null;
+    recorded = null;
+    constructor(marker, name, cli) {
+        this.marker = marker;
+        this.cli = cli;
+        const own = ownGroup();
+        this.group = own === null ? null : join(own, name);
+        try {
+            if (this.group !== null)
+                mkdirSync(this.group);
+        }
+        catch {
+            this.group = null;
+        }
+    }
+    command(command, args) {
+        if (this.group === null)
+            return [command, args];
+        return ['/bin/sh', ['-c', 'echo $$ > "$0/cgroup.procs" 2>/dev/null; exec "$@"', this.group, command, ...args]];
+    }
+    entered(pid) {
+        this.session = process.platform === 'darwin' ? (listed(false).get(pid)?.session ?? null) : String(pid);
+        if (this.group === null)
+            return;
+        const joined = readFileSync(`/proc/${pid}/cgroup`, 'utf8').split('\n').find((entry) => entry.startsWith('0::'));
+        if (joined !== undefined && join(CGROUPS, joined.slice(3)) === this.group)
+            return;
+        this.close();
+        this.group = null;
+    }
+    record() {
+        const found = this.found();
+        if (found === null)
+            return;
+        this.recorded = new Set([...found].filter(([, { session }]) => session === this.session).map(([pid]) => pid));
+    }
+    working() {
+        const found = this.found();
+        if (found === null)
+            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}-`)));
+    }
+    empty() {
+        return this.found()?.size === 0;
+    }
+    kill() {
+        killMarked(this.marker);
+        if (this.group === null)
+            return;
+        try {
+            writeFileSync(join(this.group, 'cgroup.kill'), '1');
+        }
+        catch {
+            killAll([...(this.found()?.keys() ?? [])]);
+        }
+    }
+    close() {
+        if (this.group === null)
+            return;
+        try {
+            rmdirSync(this.group);
+        }
+        catch { }
+    }
+    found() {
+        try {
+            const table = processes();
+            const roots = this.group === null ? marked(this.marker, true) : members(this.group);
+            const pids = this.group === null ? [...roots, ...descendants(roots, table)] : roots;
+            return new Map(pids.flatMap((pid) => (table.has(pid) ? [[pid, table.get(pid)]] : [])));
+        }
+        catch {
+            return null;
+        }
+    }
+}

package/dist/sign-in.js

@@ -1,7 +1,7 @@
 import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
-import { killTree } from './acp.js';
 import { CLIS, withoutProxy } from './clis.js';
+import { killTree } from './scope.js';
 import { holdSecretInput } from './secret-input.js';
 const ESCAPE = /\u001b\[[\d;]*m/g;
 const LINK = /https:\/\/\S+/;