@agentshouse/kit 0.2.1-cca9e1f43de44 → 0.2.1-ccf188e02985d

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: '' }];
@@ -578,6 +512,10 @@ class GrokReader extends Reader {
         return [];
     }
 }
+export function answeredFailure(answer) {
+    const failure = answer._meta?.jetbrains?.air?.sessionFailure;
+    return typeof failure?.title === 'string' ? { title: failure.title, limit: failure.category === 'limit' } : null;
+}
 export function readerFor(kind) {
     if (kind === 'claude-agent-acp')
         return new ClaudeReader();

package/dist/files.js

@@ -1,11 +1,17 @@
+import { createHash } from 'node:crypto';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { HouseRefusal, retrying } from './api.js';
 import { relayed } from './relay.js';
+export function verified(bytes, sha256, name) {
+    if (createHash('sha256').update(bytes).digest('hex') !== sha256)
+        throw new Error(`${name} did not arrive whole; download it again`);
+    return bytes;
+}
 export async function placeFiles(house, directory, files, signal) {
     const paths = [];
     for (const file of files) {
-        const original = await house.post('/kit/conversation/originals/get', { version: file.version, download: true }, signal);
+        const original = await retrying(() => house.post('/kit/conversation/originals/get', { version: file.version, download: true }, signal), signal);
         const answer = await fetch(relayed(original.download.url), { signal });
         if (!answer.ok)
             throw new Error(`${file.name} did not download: ${answer.status}`);
@@ -16,7 +22,7 @@ export async function placeFiles(house, directory, files, signal) {
         });
         await mkdir(folder, { recursive: true });
         const path = join(folder, file.name);
-        await writeFile(path, Buffer.from(await answer.arrayBuffer()));
+        await writeFile(path, verified(Buffer.from(await answer.arrayBuffer()), file.sha256, file.name));
         paths.push(path);
     }
     return paths;

package/dist/git.js

@@ -1,4 +1,5 @@
 import { spawn } from 'node:child_process';
+import { isUtf8 } from 'node:buffer';
 import { createHash } from 'node:crypto';
 import { join } from 'node:path';
 import { withoutProxy } from './clis.js';
@@ -48,14 +49,15 @@ export async function tree(repository, commit) {
     }
     return entries;
 }
-export async function blobText(repository, object, path) {
-    const bytes = (await run(repository, ['cat-file', 'blob', object])).stdout;
-    try {
-        return new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(bytes);
-    }
-    catch {
-        throw new Error(`${path} is binary and House stores only text; remove it from the commit`);
-    }
+async function blob(repository, object) {
+    return (await run(repository, ['cat-file', 'blob', object])).stdout;
+}
+export async function blobText(repository, object) {
+    return (await blob(repository, object)).toString('utf8');
+}
+export async function isText(repository, object, maxBytes) {
+    const bytes = await blob(repository, object);
+    return bytes.length <= maxBytes && isUtf8(bytes) && !bytes.includes(0);
 }
 export function blobId(content) {
     const bytes = Buffer.from(content, 'utf8');

package/dist/home.js

@@ -1,13 +1,63 @@
-import { existsSync } from 'node:fs';
+import { createHash, randomUUID } from 'node:crypto';
+import { accessSync, chmodSync, constants, existsSync, linkSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync } from 'node:fs';
 import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { homedir, tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { selectRelay } from './relay.js';
 const ENROLMENT = 'credential.json';
 const DISCONNECTED = 'disconnected.json';
 const CONFIGURATION = 'kit.json';
 const OWN_AGENT = 'own-agent.json';
+const RESTART = 'restart';
+let defaulted;
+function writable(directory) {
+    try {
+        accessSync(directory, constants.W_OK | constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function privateDirectory(path) {
+    try {
+        mkdirSync(path, { mode: 0o700 });
+    }
+    catch (error) {
+        if (error.code !== 'EEXIST')
+            throw error;
+    }
+    const found = lstatSync(path);
+    if (found.isSymbolicLink())
+        throw new Error(`${path} is a symbolic link`);
+    if (!found.isDirectory())
+        throw new Error(`${path} is not a directory`);
+    if (found.uid !== process.geteuid())
+        throw new Error(`${path} is not owned by this User`);
+    chmodSync(path, 0o700);
+    return path;
+}
+function ownTemporaryHome() {
+    return privateDirectory(join(tmpdir(), `house-kit-${process.getuid()}`));
+}
+function defaultHome() {
+    const home = join(homedir(), '.house-kit');
+    return existsSync(home) || writable(homedir()) ? home : ownTemporaryHome();
+}
 export function kitHome() {
-    return process.env.HOUSE_KIT_HOME ?? join(homedir(), '.house-kit');
+    return process.env.HOUSE_KIT_HOME || (defaulted ??= defaultHome());
+}
+export function socketDirectory() {
+    const sockets = privateDirectory(join(realpathSync('/tmp'), `hk-${process.geteuid()}`));
+    const home = kitHome();
+    const physical = existsSync(home) ? realpathSync(home) : resolve(home);
+    return privateDirectory(join(sockets, createHash('sha256').update(physical).digest('hex').slice(0, 12)));
+}
+export function ownerSocket() {
+    return join(socketDirectory(), 'owner.sock');
+}
+export function ownerLock() {
+    return join(socketDirectory(), 'owner.lock');
 }
 export function workspaceRoot() {
     return process.env.HOUSE_KIT_WORKSPACE ?? '/agents/house';
@@ -28,12 +78,15 @@ export async function readHome(name) {
 export async function writeHome(name, value) {
     const home = kitHome();
     await mkdir(home, { recursive: true, mode: 0o700 });
-    const temporary = join(home, `${name}.${process.pid}`);
+    const temporary = join(home, `${name}.${randomUUID()}`);
     await writeFile(temporary, `${JSON.stringify(value)}\n`, { mode: 0o600 });
     await rename(temporary, join(home, name));
 }
-export function readEnrolment() {
-    return readHome(ENROLMENT);
+export async function readEnrolment() {
+    const enrolment = await readHome(ENROLMENT);
+    if (enrolment !== null)
+        selectRelay(process.env.HOUSE_KIT_RELAY || enrolment.relay);
+    return enrolment;
 }
 export async function writeEnrolment(enrolment) {
     await writeHome(ENROLMENT, enrolment);
@@ -42,13 +95,49 @@ export async function writeEnrolment(enrolment) {
 export function readDisconnected() {
     return readHome(DISCONNECTED);
 }
+export function forgetDisconnected() {
+    return rm(join(kitHome(), DISCONNECTED), { force: true });
+}
 export async function forgetEnrolment({ house, environment }) {
     await writeHome(DISCONNECTED, { house, environment });
     await rm(join(kitHome(), ENROLMENT), { force: true });
 }
+export async function forgetRejected(rejected) {
+    const held = await readHome(ENROLMENT);
+    if (held?.credential !== rejected)
+        return;
+    await writeHome(DISCONNECTED, { house: held.house, environment: held.environment });
+    const enrolment = join(kitHome(), ENROLMENT);
+    const taken = `${enrolment}.${process.pid}`;
+    try {
+        renameSync(enrolment, taken);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return;
+        throw error;
+    }
+    if (JSON.parse(readFileSync(taken, 'utf8')).credential !== rejected) {
+        try {
+            linkSync(taken, enrolment);
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+        }
+        rmSync(join(kitHome(), DISCONNECTED), { force: true });
+    }
+    rmSync(taken);
+}
 export function enrolled() {
     return existsSync(join(kitHome(), ENROLMENT));
 }
+export function restartAsked() {
+    return existsSync(join(kitHome(), RESTART));
+}
+export function forgetRestart() {
+    return rm(join(kitHome(), RESTART), { force: true });
+}
 export function readOwnAgent() {
     return readHome(OWN_AGENT);
 }