@agentshouse/kit 0.2.1-c3cf4b145dcda → 0.2.1-c3e86aacccc80

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/home.js

@@ -1,11 +1,13 @@
-import { existsSync } from 'node:fs';
+import { existsSync, linkSync, readFileSync, 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 { 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';
 export function kitHome() {
     return process.env.HOUSE_KIT_HOME ?? join(homedir(), '.house-kit');
 }
@@ -32,8 +34,11 @@ export async function writeHome(name, value) {
     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);
@@ -46,9 +51,42 @@ 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);
 }

package/dist/house-main.js

@@ -2,20 +2,52 @@
 import { createHash } from 'node:crypto';
 import { readFile } from 'node:fs/promises';
 import { request, setGlobalProxyFromEnv } from 'node:http';
-import { basename, join } from 'node:path';
-import { kitHome, readOwnAgent } from './home.js';
+import { extname, join } from 'node:path';
+import { HOUSE_REF } from './git.js';
+import { kitHome, readEnrolment, readOwnAgent } from './home.js';
 import { callHouse, rpc, UNREACHABLE } from './mcp.js';
 import { refusalOf } from './refusals.js';
+import { relayed } from './relay.js';
+import { parse, stringify } 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 FETCH_USAGE = 'usage: house fetch';
+const FETCH = `fetch: records House's changes on each Local copy's ${HOUSE_REF}`;
 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";
 const socketPath = process.env.HOUSE_BRIDGE;
+const MEDIA_TYPES = new Map([
+    ['avif', 'image/avif'],
+    ['csv', 'text/csv'],
+    ['docx', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'],
+    ['gif', 'image/gif'],
+    ['heic', 'image/heic'],
+    ['html', 'text/html'],
+    ['jpeg', 'image/jpeg'],
+    ['jpg', 'image/jpeg'],
+    ['json', 'application/json'],
+    ['m4a', 'audio/mp4'],
+    ['md', 'text/markdown'],
+    ['mov', 'video/quicktime'],
+    ['mp3', 'audio/mpeg'],
+    ['mp4', 'video/mp4'],
+    ['ogg', 'audio/ogg'],
+    ['pdf', 'application/pdf'],
+    ['png', 'image/png'],
+    ['pptx', 'application/vnd.openxmlformats-officedocument.presentationml.presentation'],
+    ['svg', 'image/svg+xml'],
+    ['txt', 'text/plain'],
+    ['wav', 'audio/wav'],
+    ['webm', 'video/webm'],
+    ['webp', 'image/webp'],
+    ['xlsx', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'],
+    ['zip', 'application/zip'],
+]);
 function refused(path, status, text) {
     const refusal = refusalOf(text);
     if (refusal !== null)
@@ -51,6 +83,7 @@ async function direct(message) {
     const ownAgent = await readOwnAgent();
     if (ownAgent === null)
         throw new Error(UNCONNECTED);
+    await readEnrolment();
     setGlobalProxyFromEnv();
     const answer = await callHouse(ownAgent.house, ownAgent.credential, message).catch(() => {
         throw new Error(UNREACHABLE);
@@ -79,25 +112,35 @@ async function localFile(path) {
             : `${path} is not a readable file`);
     }
 }
-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', {
-        ...(roomRef === undefined ? {} : { room_ref: roomRef }),
-        name: basename(path),
+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({ file, ...destination }) {
+    if (typeof file !== 'string' || file === '')
+        throw new Error('upload needs "file", a local file');
+    const bytes = await localFile(file);
+    const mediaType = MEDIA_TYPES.get(extname(file).slice(1).toLowerCase());
+    const answer = await called('upload', {
+        ...destination,
         bytes: bytes.length,
         sha256: createHash('sha256').update(bytes).digest('hex'),
-    }));
+        ...(mediaType === undefined ? {} : { media_type: mediaType }),
+    });
+    const declared = parse(answer);
     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,
-    }));
-    if (saved.upload_failure !== undefined)
-        throw new Error(`${path} was not saved: ${saved.upload_failure}; call again later`);
-    return saved.attachment;
+        return answer;
+    const written = JSON.parse(await sent(declared.upload.url, bytes, declared.upload.operation));
+    return stringify(written, { lineWidth: 0 }).trimEnd();
 }
 async function push(args) {
     if (args.includes('--help'))
@@ -113,6 +156,14 @@ async function push(args) {
         throw new Error(pushed.text);
     return pushed.text;
 }
+async function fetched(args) {
+    if (args.includes('--help'))
+        return FETCH_USAGE;
+    const answer = JSON.parse(await bridged('/git/fetch', {}, undefined, socketPath ?? join(kitHome(), 'owner.sock')));
+    if (answer.refused)
+        throw new Error(answer.text);
+    return answer.text;
+}
 function argumentsOf(argument) {
     if (argument === undefined)
         return {};
@@ -129,7 +180,7 @@ function argumentsOf(argument) {
 }
 async function house([verb, argument]) {
     if (verb === undefined || verb === '--help' || verb === 'help') {
-        return [USAGE, 'help', PUSH, ...(await tools()).map((tool) => (tool.description === undefined ? tool.name : `${tool.name}: ${tool.description}`))].join('\n');
+        return [USAGE, 'help', PUSH, FETCH, ...(await tools()).map((tool) => (tool.description === undefined ? tool.name : `${tool.name}: ${tool.description}`))].join('\n');
     }
     if (argument === '--help') {
         const tool = (await tools()).find((listed) => listed.name === verb);
@@ -138,24 +189,17 @@ 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 (socketPath !== undefined && 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 verb === 'upload' ? upload(args) : 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+$/, ''));
     return text;
 }
 const argv = process.argv.slice(2);
-(argv[0] === 'push' ? push(argv.slice(1)) : house(argv)).then((text) => {
+(argv[0] === 'push' ? push(argv.slice(1)) : argv[0] === 'fetch' ? fetched(argv.slice(1)) : house(argv)).then((text) => {
     process.stdout.write(`${text}\n`);
     if (argv[0] === 'shell')
         process.exitCode = Number(/^exit: (\d+)(?:\n|$)/.exec(text)?.[1] ?? 0);

package/dist/instructions.js

@@ -1,8 +1,10 @@
+import { HOUSE_REF } from './git.js';
 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 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 SOURCE_LINE = "From House:";
+const HOUSE_LINE = "Work with House through the `house` CLI: run `house --help`, and `house find_command` for House's guides and formats.";
+const FILE_LINE = 'To give the User a file, upload it with `house upload` and link it; for an App, a Site or a website, follow `house find_command \'{"query":"app"}\'`. Never start a server.';
+const READ_LINE = "Optional per-Room instructions: `/rooms/private/rooms/<handle>/AGENTS.md`.";
+const COPIES_LINE = `House Local copies; before work run \`house fetch\` and rebase onto \`${HOUSE_REF}\`; after it commit, then \`house push\`:`;
 const UNREADABLE = /^(?:\S+: )?(?:path_not_found|room_not_found|operation_denied)\b/;
 const FAILED = /^exit: [1-9]\d*$/;
 const CUT = /^stderr: shell: output_cut (\d+) of \d+ bytes; continue with: (.+)$/;
@@ -29,6 +31,6 @@ async function howWeWork(bridge) {
     return document.replace(/\n$/, '');
 }
 export async function instructions(bridge, base, copies) {
-    const lines = [HOUSE_LINE, FILE_LINE, READ_LINE, ...(copies.length === 0 ? [] : [COPIES_LINE, ...copies])];
+    const lines = [SOURCE_LINE, HOUSE_LINE, FILE_LINE, READ_LINE, ...(copies.length === 0 ? [] : [COPIES_LINE, ...copies])];
     return [lines.join('\n'), base, await howWeWork(bridge)].filter((part) => part !== '').join('\n\n');
 }