@agentshouse/kit 0.2.1-alpha.9 → 0.2.1-c02dacffca87c

package/dist/end.js

@@ -0,0 +1,33 @@
+import { KIT_RELEASE } from './clis.js';
+import { forgetRejected } from './home.js';
+import { installCommand } from './placement.js';
+import { killDescendants } from './scope.js';
+export const REPLACED = 'another Kit process started for this Environment';
+function exit(reason, status) {
+    process.stderr.write(`kit: ${reason}\n`);
+    killDescendants();
+    process.exit(status);
+}
+export function end(reason) {
+    exit(reason, process.env.HOUSE_KIT_RESIDENT === String(process.pid) ? 0 : 1);
+}
+export function restart(reason) {
+    exit(reason, 1);
+}
+export function updateLine(lead) {
+    const command = installCommand();
+    return command === null ? `${lead}; install it again.` : `${lead}. Update it: ${command}`;
+}
+export function updateRequired() {
+    end(updateLine('This Kit is too old for House'));
+}
+export function unknownMethod(kind) {
+    return updateLine(`This Kit does not know ${kind}`);
+}
+export function newerThanHouse(release, command) {
+    end(`Kit ${KIT_RELEASE} is newer than this Building supports (Kit ${release}). Install Kit ${release}: ${command}`);
+}
+export async function signInAgain(rejected) {
+    await forgetRejected(rejected);
+    restart('sign in again');
+}

package/dist/enrol-main.js

@@ -1,4 +1,10 @@
 import { readFileSync } from 'node:fs';
 import { writeEnrolment } from './home.js';
 const [house, environment] = process.argv.slice(2);
-await writeEnrolment({ house: house, environment: environment, credential: readFileSync(0, 'utf8').trim() });
+const relay = process.env.HOUSE_KIT_RELAY || undefined;
+await writeEnrolment({
+    house: house,
+    ...(relay === undefined ? {} : { relay }),
+    environment: environment,
+    credential: readFileSync(0, 'utf8').trim(),
+});

package/dist/events.js

@@ -0,0 +1,546 @@
+const AUTONOMOUS_ORIGINS = new Set(['task-notification', 'peer', 'coordinator', 'observer', 'observer-activity']);
+const COMMAND = { shown: 'command' };
+const HIDDEN = { shown: 'hidden' };
+const FINISHED = new Set(['completed', 'failed']);
+export const RUNNING_JOB = new Set(['running', 'paused']);
+const MESSAGE_TARGETS = new Map([
+    ['send_agent_function_request', ['agent_function', 'agent']],
+    ['cancel_agent_function_request', ['request']],
+    ['send_mail', ['conversation', 'request']],
+]);
+function words(line) {
+    const found = [];
+    let word = null;
+    let quote = null;
+    for (let index = 0; index < line.length; index++) {
+        const character = line[index];
+        if (quote !== null) {
+            if (character === quote)
+                quote = null;
+            else if (character === '\\' && quote === '"')
+                word += line[++index] ?? '';
+            else
+                word += character;
+        }
+        else if (character === "'" || character === '"') {
+            quote = character;
+            word ??= '';
+        }
+        else if (character === '\\') {
+            word = (word ?? '') + (line[++index] ?? '');
+        }
+        else if (/\s/.test(character)) {
+            if (word !== null)
+                found.push(word);
+            word = null;
+        }
+        else {
+            word = (word ?? '') + character;
+        }
+    }
+    if (word !== null)
+        found.push(word);
+    return found;
+}
+export function houseMessage(line) {
+    const [program, verb, json] = words(line.trim());
+    if (program !== 'house' || verb !== 'run_command' || json === undefined)
+        return null;
+    let call;
+    try {
+        call = JSON.parse(json);
+    }
+    catch {
+        return null;
+    }
+    if (call === null)
+        return null;
+    const targets = MESSAGE_TARGETS.get(call.command);
+    if (targets === undefined)
+        return null;
+    const target = targets.map((argument) => call.arguments?.[argument]).find((value) => typeof value === 'string');
+    return { shown: 'message', command: call.command, target: target ?? null };
+}
+function decidedByLine(command, final) {
+    const line = typeof command === 'string' ? command : Array.isArray(command) ? command.at(-1) : undefined;
+    if (typeof line !== 'string')
+        return final ? COMMAND : null;
+    return houseMessage(line) ?? COMMAND;
+}
+function contentText(content) {
+    const text = (content ?? [])
+        .map((entry) => (entry.type === 'content' && entry.content?.type === 'text' ? entry.content.text : ''))
+        .filter((part) => part !== '')
+        .join('\n');
+    return text === '' ? null : text;
+}
+function plan(entries) {
+    return entries.map((entry) => ({ content: entry.content, status: entry.status }));
+}
+function merged(into, from) {
+    if (from === null || from === undefined)
+        return into;
+    const result = { ...into };
+    for (const [key, value] of Object.entries(from)) {
+        result[key] =
+            typeof value === 'object' && value !== null && !Array.isArray(value) && typeof into[key] === 'object'
+                ? merged(into[key], value)
+                : value;
+    }
+    return result;
+}
+function names(input, ids) {
+    const values = JSON.stringify(input ?? {});
+    for (const id of ids)
+        if (values.includes(id))
+            return true;
+    return false;
+}
+class Reader {
+    session = null;
+    calls = new Map();
+    subagents = new Set();
+    done = new Set();
+    seenOptions = new Map();
+    requestedOptions = new Map();
+    compactions = new Set();
+    jobs = new Map();
+    read(message) {
+        if (message.method === undefined)
+            return this.answered(message.result);
+        const session = message.params?.sessionId;
+        if (session !== undefined && this.session !== null && session !== this.session) {
+            return this.elsewhere(session, message);
+        }
+        return this.own(message);
+    }
+    requested(option, value) {
+        this.requestedOptions.set(option, value);
+    }
+    refused(option) {
+        this.requestedOptions.delete(option);
+    }
+    closeTurn() {
+        const events = [];
+        for (const [id, call] of this.calls) {
+            if (call.decided?.shown === 'subagent')
+                continue;
+            if (call.decided === null)
+                events.push(...this.shown(call, this.decide(call, true)));
+            this.calls.delete(id);
+        }
+        return events;
+    }
+    answered(result) {
+        if (typeof result?.sessionId === 'string' && this.session === null)
+            this.session = result.sessionId;
+        for (const option of (result?.configOptions ?? [])) {
+            this.seenOptions.set(option.id, option.currentValue);
+            this.requestedOptions.delete(option.id);
+        }
+        return [];
+    }
+    elsewhere(_session, _message) {
+        return [];
+    }
+    own(message) {
+        if (message.method !== 'session/update')
+            return this.extension(message);
+        return this.update(message.params.update);
+    }
+    extension(_message) {
+        return [];
+    }
+    update(update) {
+        switch (update.sessionUpdate) {
+            case 'agent_message_chunk':
+                if (update.content.type === 'image')
+                    return [{ kind: 'image', data: update.content.data, mediaType: update.content.mimeType }];
+                return update.content.type === 'text' ? [{ kind: 'text', id: update.messageId ?? null, text: update.content.text }] : [];
+            case 'agent_thought_chunk':
+                return update.content.type === 'text' ? [{ kind: 'reasoning', id: update.messageId ?? null, text: update.content.text }] : [];
+            case 'tool_call':
+            case 'tool_call_update':
+                return this.tool(update);
+            case 'plan':
+                return [{ kind: 'plan', entries: plan(update.entries) }];
+            case 'usage_update':
+                return [{ kind: 'context', used: update.used, window: update.size }];
+            case 'current_mode_update':
+                return [{ kind: 'marker', marker: 'mode', text: update.currentModeId }];
+            case 'available_commands_update':
+                return [{ kind: 'commands', commands: update.availableCommands }];
+            case 'config_option_update':
+                return [{ kind: 'options', options: update.configOptions }, ...this.optionsChanged(update.configOptions)];
+            case 'compaction_update':
+                if (update.status !== 'completed' || this.compactions.has(update.compactionId))
+                    return [];
+                this.compactions.add(update.compactionId);
+                return [{ kind: 'marker', marker: 'compaction', text: '' }];
+            case 'async_task_spawned':
+                return this.job(update.asyncTaskId, update.name ?? update.description ?? '', 'running');
+            case 'async_task_state_update':
+                return RUNNING_JOB.has(update.state) ? [] : this.job(update.asyncTaskId, null, update.state);
+            default:
+                return [];
+        }
+    }
+    job(id, name, state) {
+        if (name !== null)
+            this.jobs.set(id, name);
+        const label = this.jobs.get(id) ?? '';
+        if (state !== 'running')
+            this.jobs.delete(id);
+        return [{ kind: 'marker', marker: 'job', text: `${label}: ${state}` }];
+    }
+    optionsChanged(options) {
+        const events = [];
+        for (const option of options) {
+            const marker = this.watchedOptions[option.id];
+            const before = this.seenOptions.get(option.id);
+            this.seenOptions.set(option.id, option.currentValue);
+            if (marker === undefined || before === undefined || before === option.currentValue)
+                continue;
+            if (this.requestedOptions.get(option.id) === option.currentValue) {
+                this.requestedOptions.delete(option.id);
+                continue;
+            }
+            events.push({ kind: 'marker', marker, text: String(option.currentValue) });
+        }
+        return events;
+    }
+    tool(update) {
+        let call = this.calls.get(update.toolCallId);
+        if (call === undefined) {
+            if (update.sessionUpdate !== 'tool_call')
+                return [];
+            call = { id: update.toolCallId, decided: null, meta: {}, imaged: false, status: 'in_progress' };
+            this.calls.set(call.id, call);
+        }
+        if (update.kind !== undefined)
+            call.kind = update.kind;
+        if (update.title !== undefined)
+            call.title = update.title;
+        if (update.status !== undefined)
+            call.status = update.status;
+        if (update.rawInput !== undefined)
+            call.rawInput = merged(call.rawInput ?? {}, update.rawInput);
+        if (update.content !== undefined)
+            call.content = update.content;
+        call.meta = merged(call.meta, update._meta);
+        const events = [];
+        const finished = FINISHED.has(call.status);
+        if (call.decided === null) {
+            const decided = this.decide(call, finished);
+            if (decided !== null)
+                events.push(...this.shown(call, decided));
+        }
+        events.push(...this.produced(call));
+        if (call.decided?.shown === 'subagent' && finished)
+            events.push(...this.subagentFinished(call));
+        else if (finished)
+            this.calls.delete(call.id);
+        return events;
+    }
+    shown(call, decided) {
+        call.decided = decided;
+        switch (decided.shown) {
+            case 'command':
+                return [{ kind: 'command' }];
+            case 'hidden':
+                return [];
+            case 'message':
+                return [{ kind: 'message', command: decided.command, target: decided.target }];
+            case 'marker':
+                return [{ kind: 'marker', marker: decided.marker, text: decided.text }];
+            case 'subagent':
+                this.subagents.add(call.id);
+                return [{ kind: 'subagent', id: call.id, description: decided.description }];
+        }
+    }
+    produced(_call) {
+        return [];
+    }
+    subagentFinished(call) {
+        this.calls.delete(call.id);
+        return this.finish(call.id, contentText(call.content));
+    }
+    finish(id, result) {
+        if (!this.subagents.has(id) || this.done.has(id))
+            return [];
+        this.done.add(id);
+        this.calls.delete(id);
+        return [{ kind: 'subagent-done', id, result }];
+    }
+}
+class ClaudeReader extends Reader {
+    watchedOptions = { model: 'model' };
+    tasks = new Map();
+    stop = null;
+    own(message) {
+        if (message.params?.update?._meta?.claudeCode?.parentToolUseId !== undefined)
+            return [];
+        return super.own(message);
+    }
+    update(update) {
+        if (update.sessionUpdate === 'usage_update' && update._meta?.['_claude/origin'] !== undefined) {
+            const stop = this.stop;
+            this.stop = null;
+            return [...super.update(update), { kind: 'ended', stop }];
+        }
+        if (update.sessionUpdate === 'session_info_update' && update._meta?.jetbrains?.air?.sessionFailure !== undefined) {
+            return [{ kind: 'marker', marker: 'retry', text: update._meta.jetbrains.air.sessionFailure.title }];
+        }
+        return super.update(update);
+    }
+    extension(message) {
+        if (message.method !== '_claude/sdkMessage')
+            return [];
+        const sdk = message.params.message;
+        if (sdk.type === 'result') {
+            if (AUTONOMOUS_ORIGINS.has(sdk.origin?.kind))
+                this.stop = null;
+            else
+                this.stop = sdk.stop_reason === 'refusal' ? 'refusal' : sdk.is_error === true ? null : 'end_turn';
+            return [];
+        }
+        switch (sdk.subtype) {
+            case 'task_started':
+                if (sdk.tool_use_id !== undefined)
+                    this.tasks.set(sdk.task_id, sdk.tool_use_id);
+                return [];
+            case 'task_notification':
+                return sdk.tool_use_id === undefined ? [] : this.finish(sdk.tool_use_id, sdk.summary ?? null);
+            case 'task_progress':
+                if (!this.subagents.has(sdk.tool_use_id) || this.done.has(sdk.tool_use_id) || typeof sdk.description !== 'string')
+                    return [];
+                return [{ kind: 'subagent-activity', id: sdk.tool_use_id, activity: sdk.description }];
+            default:
+                return [];
+        }
+    }
+    decide(call, final) {
+        const tool = call.meta.claudeCode?.toolName;
+        if (tool === 'Agent' || tool === 'Task' || call.meta.jetbrains?.air?.subagent === true) {
+            const description = call.rawInput?.description;
+            if (description === undefined && !final)
+                return null;
+            return { shown: 'subagent', description: description ?? call.title ?? '' };
+        }
+        if (tool === 'TodoWrite' || tool === 'CronCreate')
+            return HIDDEN;
+        if (tool === 'ScheduleWakeup') {
+            if (call.rawInput === undefined)
+                return final ? COMMAND : null;
+            return call.rawInput.stop === true ? COMMAND : HIDDEN;
+        }
+        if (call.kind === 'switch_mode')
+            return { shown: 'marker', marker: 'mode', text: call.title ?? '' };
+        if (tool === 'Bash')
+            return decidedByLine(call.rawInput?.command, final);
+        if (tool === 'SendMessage' || tool === 'TaskStop') {
+            if (call.rawInput === undefined)
+                return final ? COMMAND : null;
+            return names(call.rawInput, this.tasks.keys()) ? HIDDEN : COMMAND;
+        }
+        return COMMAND;
+    }
+    produced(call) {
+        const tool = call.meta.claudeCode?.toolName;
+        if (call.status !== 'completed')
+            return [];
+        if (tool === 'CronCreate' || (tool === 'ScheduleWakeup' && call.rawInput?.stop !== true)) {
+            return [{ kind: 'marker', marker: 'job', text: `${call.rawInput?.prompt ?? call.title ?? ''}: scheduled` }];
+        }
+        return [];
+    }
+    subagentFinished(call) {
+        if (call.meta.claudeCode?.toolResponse?.isAsync === true)
+            return [];
+        return super.subagentFinished(call);
+    }
+}
+const COLLABORATION = new Set(['spawnAgent', 'sendInput', 'resumeAgent', 'wait', 'closeAgent', 'followupTask']);
+class CodexReader extends Reader {
+    watchedOptions = { mode: 'mode', collaboration_mode: 'mode' };
+    children = new Map();
+    own(message) {
+        if (message.method === 'session/request_permission' && message.params.toolCall?.kind === 'switch_mode') {
+            return [{ kind: 'started' }, { kind: 'marker', marker: 'mode', text: message.params.toolCall.title ?? '' }];
+        }
+        return super.own(message);
+    }
+    update(update) {
+        switch (update.sessionUpdate) {
+            case 'session_info_update': {
+                const codex = update._meta?.codex;
+                if (codex?.threadStatus?.type === 'active')
+                    return [{ kind: 'started' }];
+                if (codex?.threadStatus?.type === 'idle')
+                    return [{ kind: 'ended', stop: null }];
+                if (codex?.error !== undefined)
+                    return [{ kind: 'marker', marker: 'retry', text: codex.error.message ?? '' }];
+                return [];
+            }
+            case 'notice':
+                return update.severity === 'info' ? [{ kind: 'marker', marker: 'model', text: update.description ?? update.title }] : [];
+            case 'subagent_spawned':
+                this.children.set(update.subagentSessionId, { id: null, text: '' });
+                this.subagents.add(update.subagentSessionId);
+                return [{ kind: 'subagent', id: update.subagentSessionId, description: update.name }];
+            case 'subagent_state_update':
+                return this.finish(update.subagentSessionId, this.children.get(update.subagentSessionId)?.text || null);
+            default:
+                return super.update(update);
+        }
+    }
+    elsewhere(session, message) {
+        const child = this.children.get(session);
+        const update = message.params?.update;
+        if (child === undefined || update === undefined)
+            return [];
+        if (update.sessionUpdate === 'agent_message_chunk' && update.content.type === 'text') {
+            const id = update.messageId ?? null;
+            if (child.id !== id)
+                child.text = '';
+            child.id = id;
+            child.text += update.content.text;
+        }
+        return [];
+    }
+    decide(call) {
+        const air = call.meta.jetbrains?.air;
+        if (COLLABORATION.has(call.title ?? ''))
+            return HIDDEN;
+        if (air?.subagent !== undefined)
+            return { shown: 'subagent', description: call.title ?? '' };
+        if (call.kind === 'switch_mode')
+            return { shown: 'marker', marker: 'mode', text: call.title ?? '' };
+        if (call.kind === 'execute')
+            return decidedByLine(call.rawInput?.command, true);
+        if (call.title === 'Image generation')
+            return HIDDEN;
+        return COMMAND;
+    }
+    produced(call) {
+        if (call.imaged || call.kind === 'read')
+            return [];
+        const image = (call.content ?? []).find((entry) => entry.type === 'content' && entry.content?.type === 'image');
+        if (image === undefined)
+            return [];
+        call.imaged = true;
+        return [{ kind: 'image', data: image.content.data, mediaType: image.content.mimeType }];
+    }
+}
+class GrokReader extends Reader {
+    watchedOptions = {};
+    children = new Map();
+    models = [];
+    model = null;
+    answered(result) {
+        if (result?.models !== undefined)
+            this.offered(result.models);
+        return super.answered(result);
+    }
+    read(message) {
+        const session = message.params?.sessionId;
+        if (this.session !== null && session !== undefined && session !== this.session && !this.children.has(session))
+            return [];
+        if (message.method === '_x.ai/queue/changed') {
+            return (message.params.runningPromptId ?? null) !== null && session === this.session ? [{ kind: 'started' }] : [];
+        }
+        if (message.params?.update?.sessionUpdate === 'turn_completed') {
+            return session === this.session ? [{ kind: 'ended', stop: null }] : [];
+        }
+        if (message.method === '_x.ai/models/update') {
+            this.offered(message.params);
+            return [];
+        }
+        return super.read(message);
+    }
+    offered(models) {
+        this.models = models.availableModels ?? this.models;
+        this.model = models.currentModelId ?? this.model;
+    }
+    window() {
+        return this.models.find((model) => model.modelId === this.model)?._meta?.totalContextTokens ?? null;
+    }
+    extension(message) {
+        const update = message.params?.update;
+        switch (message.method) {
+            case '_x.ai/task_backgrounded':
+                return this.job(update.task_id, update.description ?? update.command ?? '', 'running');
+            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: 'marker', marker: 'job', text: `${update.prompt}: next run ${update.next_fire_at}` }];
+            case '_x.ai/session_notification':
+                return this.notification(update);
+            default:
+                return [];
+        }
+    }
+    notification(update) {
+        switch (update.sessionUpdate) {
+            case 'response_completed': {
+                const usage = update.usage;
+                const window = this.window();
+                if (window === null)
+                    return [];
+                const used = usage.input_tokens + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0) + usage.output_tokens;
+                return [{ kind: 'context', used, window }];
+            }
+            case 'subagent_spawned': {
+                const call = [...this.calls.values()].find((candidate) => candidate.decided?.shown === 'subagent' &&
+                    ![...this.children.values()].includes(candidate.id) &&
+                    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 [];
+            }
+            case 'subagent_finished': {
+                const call = this.children.get(update.child_session_id);
+                return typeof call === 'string' ? this.finish(call, update.output ?? null) : [];
+            }
+            case 'auto_compact_completed':
+                return [{ kind: 'marker', marker: 'compaction', text: '' }];
+            case 'model_auto_switched':
+                this.model = update.new_model_id;
+                return [{ kind: 'marker', marker: 'model', text: update.new_model_id }];
+            case 'retry_state':
+                return [{ kind: 'marker', marker: 'retry', text: update.message ?? update.reason ?? update.error_type ?? '' }];
+            default:
+                return [];
+        }
+    }
+    decide(call) {
+        const tool = (call.meta['x.ai/tool'] ?? {});
+        if (tool.name === 'spawn_subagent' || tool.kind === 'task') {
+            return { shown: 'subagent', description: call.rawInput?.description ?? call.title ?? '' };
+        }
+        if (tool.name === 'todo_write' || tool.name === 'scheduler_create')
+            return HIDDEN;
+        if (tool.name === 'enter_plan_mode' || tool.name === 'exit_plan_mode') {
+            return { shown: 'marker', marker: 'mode', text: tool.name };
+        }
+        if (tool.name === 'kill_command_or_subagent')
+            return names(call.rawInput, this.children.keys()) ? HIDDEN : COMMAND;
+        if (tool.name === 'run_terminal_command')
+            return decidedByLine(call.rawInput?.command, true);
+        return COMMAND;
+    }
+    subagentFinished(_call) {
+        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();
+    if (kind === 'grok-build')
+        return new GrokReader();
+    return new CodexReader();
+}