@agentshouse/kit 0.2.1-c30728be20485 → 0.2.1-c3cf4b145dcda

package/dist/events.js

@@ -0,0 +1,587 @@
+const COMMAND = { shown: 'command' };
+const HIDDEN = { shown: 'hidden' };
+const FINISHED = new Set(['completed', 'failed']);
+const RUNNING_JOB = new Set(['running', 'paused']);
+const ROUTINE_TARGETS = { send_routine_request: 'access', cancel_routine_request: '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;
+    }
+    const argument = ROUTINE_TARGETS[call.command];
+    if (argument === undefined)
+        return null;
+    const target = call.arguments?.[argument];
+    return { shown: 'message', command: call.command, target: typeof target === 'string' ? 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);
+    }
+    turnStarted() {
+        return [];
+    }
+    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: 'busy', key: `job:${id}`, running: state === 'running' },
+            { 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();
+    scheduled = new Map();
+    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) {
+            return [...super.update(update), { kind: 'ended' }];
+        }
+        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;
+        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);
+                return [];
+            case 'task_notification':
+                return sdk.tool_use_id === undefined ? [] : this.finish(sdk.tool_use_id, sdk.summary ?? null);
+            default:
+                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) {
+            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)) {
+            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 [];
+    }
+    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' }];
+                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: 'busy', key: `subagent:${update.subagentSessionId}`, running: true },
+                    { 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),
+                ];
+            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;
+        }
+        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) {
+        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();
+    queues = 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') {
+            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' }] : [])];
+        }
+        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' }] : [])];
+        }
+        if (message.method === '_x.ai/models/update') {
+            this.offered(message.params);
+            return [];
+        }
+        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;
+    }
+    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: '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 }];
+            case '_x.ai/session_notification':
+                return this.notification(update);
+            case '_x.ai/mcp_initialized':
+                return [{ kind: 'servers' }];
+            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 [{ kind: 'busy', key: `subagent:${update.child_session_id}`, running: true }];
+            }
+            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) : []),
+                ];
+            }
+            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 readerFor(kind) {
+    if (kind === 'claude-agent-acp')
+        return new ClaudeReader();
+    if (kind === 'grok-build')
+        return new GrokReader();
+    return new CodexReader();
+}

package/dist/files.js

@@ -1,5 +1,6 @@
 import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { HouseRefusal, retrying } from './api.js';
 import { relayed } from './relay.js';
 export async function placeFiles(house, directory, files, signal) {
     const paths = [];
@@ -20,3 +21,16 @@ export async function placeFiles(house, directory, files, signal) {
     }
     return paths;
 }
+export function uploadBytes(upload, bytes) {
+    return retrying(async () => {
+        const answer = await fetch(relayed(upload.url), {
+            method: 'POST',
+            headers: { 'content-type': 'application/octet-stream', 'x-house-byte-operation': upload.operation },
+            body: bytes,
+        });
+        const text = await answer.text();
+        if (!answer.ok)
+            throw new HouseRefusal(upload.url, answer.status, text);
+        return JSON.parse(text);
+    });
+}

package/dist/house-main.js

@@ -11,6 +11,7 @@ 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 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";
@@ -42,7 +43,7 @@ function bridged(path, body, headers = { 'content-type': 'application/json' }, t
                     reject(new Error(refused(path, answer.statusCode, text)));
             });
         });
-        sent.on('error', () => reject(new Error(CLOSED)));
+        sent.on('error', (error) => reject(new Error(error.code === 'EPERM' || error.code === 'EACCES' ? SANDBOXED : CLOSED)));
         sent.end(body instanceof Buffer ? body : JSON.stringify(body));
     });
 }
@@ -156,6 +157,8 @@ async function house([verb, argument]) {
 const argv = process.argv.slice(2);
 (argv[0] === 'push' ? push(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);
 }, (error) => {
     process.stderr.write(`house: ${error instanceof Error ? error.message : String(error)}\n`);
     process.exitCode = 1;

package/dist/kit-main.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { setGlobalProxyFromEnv } from 'node:http';
+import { answerGitCredential } from './app-git.js';
 import { login } from './login.js';
 import { logout } from './logout.js';
 import { resident } from './resident.js';
@@ -12,6 +13,8 @@ async function run() {
         return logout();
     if (command === 'resident')
         return resident();
+    if (command === 'git-credential')
+        return answerGitCredential(argv[0]);
     process.stderr.write('usage: kit <login|logout|resident>\n');
     process.exitCode = 2;
 }

package/dist/login.js

@@ -4,6 +4,7 @@ import { hostname } from 'node:os';
 import { createInterface } from 'node:readline/promises';
 import { parseArgs } from 'node:util';
 import { post } from './api.js';
+import { placeAppGit } from './app-git.js';
 import { forgetOwnAgent, readDisconnected, readEnrolment, readOwnAgent, writeEnrolment, writeOwnAgent } from './home.js';
 import { callHouse, rpc } from './mcp.js';
 const DEFAULT_HOUSE = 'https://agents.house';
@@ -104,6 +105,7 @@ export async function login(argv) {
             process.stdout.write("This computer's own agent was another User's; run kit login again to connect it to you.\n");
         }
     };
+    const placeGit = async () => placeAppGit(ownAgent, await readOwnAgent());
     if (values.manual) {
         const { start_url } = await post(house, '/kit', {
             ...started,
@@ -111,6 +113,7 @@ export async function login(argv) {
         });
         process.stdout.write(`Open this link and confirm: ${start_url}\n`);
         await exchange(await typed('Code: '));
+        await placeGit();
         return;
     }
     const callback = await listen();
@@ -133,4 +136,5 @@ export async function login(argv) {
     finally {
         callback.close();
     }
+    await placeGit();
 }