@agentshouse/kit 0.2.1-alpha.5 → 0.2.1-alpha.6

package/dist/git-main.js

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+import { spawn, spawnSync } from 'node:child_process';
+import { accessSync, constants, realpathSync, statSync } from 'node:fs';
+import { request } from 'node:http';
+import { constants as system } from 'node:os';
+import { delimiter, dirname, join } from 'node:path';
+import { WORKING_COPIES } from './git.js';
+import { kitHome } from './home.js';
+const VALUED = new Set(['-C', '-c', '--git-dir', '--work-tree', '--namespace', '--config-env', '--attr-source', '--super-prefix']);
+const READS = new Set([
+    'blame',
+    'branch',
+    'cat-file',
+    'check-ignore',
+    'config',
+    'describe',
+    'diff',
+    'fetch',
+    'for-each-ref',
+    'grep',
+    'help',
+    'log',
+    'ls-files',
+    'ls-tree',
+    'reflog',
+    'remote',
+    'rev-list',
+    'rev-parse',
+    'shortlog',
+    'show',
+    'show-ref',
+    'status',
+    'tag',
+    'version',
+]);
+const RELAYED = ['SIGINT', 'SIGTERM', 'SIGHUP', 'SIGQUIT'];
+function nativeGit() {
+    const shim = join(kitHome(), 'shim');
+    for (const directory of (process.env.PATH ?? '').split(delimiter)) {
+        if (directory === '')
+            continue;
+        try {
+            if (realpathSync(directory) === realpathSync(shim))
+                continue;
+            const candidate = join(directory, 'git');
+            if (!statSync(candidate).isFile())
+                continue;
+            accessSync(candidate, constants.X_OK);
+            return candidate;
+        }
+        catch { }
+    }
+    return null;
+}
+function captured(git, args) {
+    const ran = spawnSync(git, args, {
+        stdio: ['ignore', 'pipe', 'ignore'],
+        maxBuffer: Infinity,
+        env: { ...process.env, LC_ALL: 'C' },
+    });
+    return ran.status === 0 ? ran.stdout.toString('utf8') : null;
+}
+function delegated(git, args) {
+    return new Promise((resolve) => {
+        const child = spawn(git, args, { stdio: 'inherit' });
+        const relay = (signal) => child.kill(signal);
+        for (const signal of RELAYED)
+            process.on(signal, relay);
+        const settle = (outcome) => {
+            for (const signal of RELAYED)
+                process.off(signal, relay);
+            resolve(outcome);
+        };
+        child.once('error', (error) => {
+            process.stderr.write(`git: ${error.message}\n`);
+            settle({ status: 127, signal: null });
+        });
+        child.once('close', (status, signal) => settle({ status, signal }));
+    });
+}
+function staged(listing) {
+    const entries = new Map();
+    for (const record of (listing ?? '').split('\0')) {
+        const tab = record.indexOf('\t');
+        if (tab >= 0)
+            entries.set(record.slice(tab + 1), record.slice(0, tab).split(' ')[1]);
+    }
+    return entries;
+}
+function moved(planned, before, after) {
+    const moves = [];
+    for (const line of planned.split('\n')) {
+        if (!line.startsWith('Renaming '))
+            continue;
+        const renaming = line.slice('Renaming '.length);
+        for (let at = renaming.indexOf(' to '); at >= 0; at = renaming.indexOf(' to ', at + 1)) {
+            const from = renaming.slice(0, at);
+            const to = renaming.slice(at + 4);
+            if (before.has(from) && !after.has(from) && after.get(to) === before.get(from)) {
+                moves.push({ from, to });
+                break;
+            }
+        }
+    }
+    return moves;
+}
+function reported(socketPath, body) {
+    return new Promise((resolve) => {
+        const sent = request({ socketPath, path: '/git/observed', method: 'POST' }, (answer) => {
+            answer.resume();
+            answer.on('end', resolve);
+        });
+        sent.on('error', () => resolve());
+        sent.end(JSON.stringify(body));
+    });
+}
+async function observed(git, args) {
+    let index = 0;
+    while (index < args.length && args[index].startsWith('-'))
+        index += VALUED.has(args[index]) ? 2 : 1;
+    const globals = args.slice(0, index);
+    const name = args[index];
+    const bridge = process.env.HOUSE_BRIDGE;
+    if (bridge === undefined || name === undefined || READS.has(name))
+        return delegated(git, args);
+    const located = captured(git, [...globals, 'rev-parse', '--path-format=absolute', '--git-common-dir', '--show-toplevel']);
+    const [common, worktree] = located?.split('\n') ?? [];
+    if (common === undefined || worktree === undefined || !dirname(common).startsWith(`${WORKING_COPIES}/`)) {
+        return delegated(git, args);
+    }
+    const listing = [...globals, '-C', worktree, 'ls-files', '--stage', '-z'];
+    const before = name === 'mv' ? staged(captured(git, listing)) : null;
+    const planned = name === 'mv' ? (captured(git, [...globals, 'mv', '--dry-run', ...args.slice(index + 1)]) ?? '') : '';
+    const outcome = await delegated(git, args);
+    const moves = before !== null && outcome.status === 0 ? moved(planned, before, staged(captured(git, listing))) : [];
+    await reported(bridge, { common, worktree, moves });
+    return outcome;
+}
+const git = nativeGit();
+if (git === null) {
+    process.stderr.write('git: no installed Git found on PATH\n');
+    process.exitCode = 127;
+}
+else {
+    observed(git, process.argv.slice(2)).then(({ status, signal }) => {
+        if (signal === null) {
+            process.exitCode = status ?? 1;
+            return;
+        }
+        process.exitCode = 128 + system.signals[signal];
+        process.kill(process.pid, signal);
+    });
+}

package/dist/git.js

@@ -0,0 +1,81 @@
+import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { withoutProxy } from './clis.js';
+export const WORKING_COPIES = '/agents/house/working-copies';
+export const HOUSE_REF = 'refs/house/received';
+const COMMITTER = 'House Kit <house-kit@localhost>';
+export function run(cwd, args, input, env = {}) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('git', args, { cwd, env: { ...withoutProxy(), ...env } });
+        const stdout = [];
+        let stderr = '';
+        child.stdout.on('data', (chunk) => stdout.push(chunk));
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk.toString('utf8');
+        });
+        child.on('error', reject);
+        child.on('close', (status) => resolve({ status, stdout: Buffer.concat(stdout), stderr }));
+        child.stdin.on('error', () => undefined);
+        child.stdin.end(input);
+    });
+}
+export async function git(cwd, args, input, env) {
+    const ran = await run(cwd, args, input, env);
+    if (ran.status !== 0)
+        throw new Error(`git ${args[0]} failed: ${ran.stderr.trim()}`);
+    return ran.stdout.toString('utf8');
+}
+export async function succeeded(cwd, args, env) {
+    return (await run(cwd, args, undefined, env)).status === 0;
+}
+export async function revision(cwd, name) {
+    return (await git(cwd, ['rev-parse', '--verify', `${name}^{commit}`])).trim();
+}
+export async function tree(repository, commit) {
+    const listed = await git(repository, ['ls-tree', '-r', '-z', commit]);
+    const entries = new Map();
+    for (const entry of listed.split('\0')) {
+        const tab = entry.indexOf('\t');
+        if (tab < 0)
+            continue;
+        const [, type, object] = entry.slice(0, tab).split(' ');
+        if (type === 'blob')
+            entries.set(entry.slice(tab + 1), object);
+    }
+    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 not UTF-8 text`);
+    }
+}
+export function blobId(content) {
+    const bytes = Buffer.from(content, 'utf8');
+    return createHash('sha1').update(`blob ${bytes.length}\0`).update(bytes).digest('hex');
+}
+function quoted(path) {
+    return `"${path.replace(/[\\"]/g, '\\$&').replace(/\n/g, '\\n')}"`;
+}
+function data(text) {
+    const bytes = Buffer.from(text, 'utf8');
+    return [Buffer.from(`data ${bytes.length}\n`), bytes, Buffer.from('\n')];
+}
+export async function importCommits(repository, commits) {
+    const stream = [];
+    for (const [index, commit] of commits.entries()) {
+        stream.push(Buffer.from(`commit ${HOUSE_REF}\nmark :${index + 1}\ncommitter ${COMMITTER} ${Math.floor(Date.now() / 1000)} +0000\n`), ...data(commit.message), ...(commit.from === null ? [] : [Buffer.from(`from ${commit.from}\n`)]), ...(commit.merge === undefined ? [] : [Buffer.from(`merge ${commit.merge}\n`)]), ...(commit.replaces === true ? [Buffer.from('deleteall\n')] : []));
+        for (const [path, content] of commit.files) {
+            if (content === null)
+                stream.push(Buffer.from(`D ${quoted(path)}\n`));
+            else
+                stream.push(Buffer.from(`M 100644 inline ${quoted(path)}\n`), ...data(content));
+        }
+        stream.push(Buffer.from('\n'));
+    }
+    await git(repository, ['fast-import', '--quiet', '--force'], Buffer.concat(stream));
+    return revision(repository, HOUSE_REF);
+}

package/dist/house-main.js

@@ -2,12 +2,15 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { readFile } from 'node:fs/promises';
 import { request } from 'node:http';
-import { basename } from 'node:path';
+import { basename, join } from 'node:path';
+import { kitHome } from './home.js';
 const USAGE = "usage: house <tool> ['<arguments as JSON>']";
+const GIT_HELP = 'Submit a Room commit to House; default HEAD. Use --owner only outside an Agent conversation. Native git push is not a House remote.';
+const GIT_USAGE = `usage: house git push [commit] [--owner]\n${GIT_HELP}`;
 const socketPath = process.env.HOUSE_BRIDGE;
-function bridged(path, body, headers = { 'content-type': 'application/json' }) {
+function bridged(path, body, headers = { 'content-type': 'application/json' }, to = socketPath) {
     return new Promise((resolve, reject) => {
-        const sent = request({ socketPath, path, method: 'POST', headers }, (answer) => {
+        const sent = request({ socketPath: to, path, method: 'POST', headers }, (answer) => {
             let text = '';
             answer.setEncoding('utf8');
             answer.on('data', (chunk) => {
@@ -47,9 +50,25 @@ async function upload(path, roomRef) {
         'x-house-byte-operation': declared.upload.operation,
     });
 }
+async function gitPush(args) {
+    if (args.includes('--help'))
+        return GIT_USAGE;
+    if (args[0] !== 'push')
+        throw new Error(GIT_USAGE);
+    const owner = args.includes('--owner');
+    const commit = args.slice(1).find((arg) => arg !== '--owner') ?? 'HEAD';
+    if (owner && socketPath !== undefined)
+        throw new Error('house git push --owner runs outside an Agent conversation');
+    if (!owner && socketPath === undefined)
+        throw new Error('outside an Agent conversation, house git push needs --owner');
+    const pushed = JSON.parse(await bridged('/git/push', { cwd: process.cwd(), commit }, undefined, owner ? join(kitHome(), 'owner.sock') : socketPath));
+    if (pushed.refused)
+        throw new Error(pushed.text);
+    return pushed.text;
+}
 async function house([verb, argument]) {
     if (verb === undefined || verb === '--help') {
-        return [USAGE, ...(await tools()).map((tool) => `${tool.name}: ${tool.description}`)].join('\n');
+        return [USAGE, `git push [commit]: ${GIT_HELP}`, ...(await tools()).map((tool) => `${tool.name}: ${tool.description}`)].join('\n');
     }
     if (argument === '--help') {
         const tool = (await tools()).find((listed) => listed.name === verb);
@@ -73,12 +92,13 @@ async function house([verb, argument]) {
         throw new Error(text);
     return text;
 }
-if (socketPath === undefined) {
+const argv = process.argv.slice(2);
+if (argv[0] !== 'git' && socketPath === undefined) {
     process.stderr.write('house: house runs inside an Agent conversation\n');
     process.exitCode = 1;
 }
 else {
-    house(process.argv.slice(2)).then((text) => {
+    (argv[0] === 'git' ? gitPush(argv.slice(1)) : house(argv)).then((text) => {
         process.stdout.write(`${text}\n`);
     }, (error) => {
         process.stderr.write(`house: ${error instanceof Error ? error.message : String(error)}\n`);

package/dist/instructions.js

@@ -1,6 +1,7 @@
 import { readEnrolment } from './home.js';
 const HOUSE_LINE = 'Work with House through the `house` CLI: run `house --help`.';
 const FILE_LINE = 'To give the User a file, upload it with `house upload_attachment` and link it in your answer.';
+const COPIES_LINE = 'These House paths are Git working copies here; commit in one and run `house git push` to send the commit to House:';
 const HOW_WE_WORK = '/private/library/how-we-work.md';
 const UNREADABLE = /^(?:\S+: )?(?:path_not_found|room_not_found|operation_denied)\b/;
 const CUT = /^stderr: shell: output_cut (\d+) of \d+ bytes; continue with: (.+)$/;
@@ -24,8 +25,9 @@ async function howWeWork(bridge) {
     }
     return document.replace(/\n$/, '');
 }
-export async function instructions(bridge, base) {
+export async function instructions(bridge, base, copies) {
     const app = new URL('/app/new.git', (await readEnrolment()).house).href;
     const appLine = `To show the User a page, upload it or push it to an App instead of starting a server; \`git clone ${app}\` starts a new App.`;
-    return [`${HOUSE_LINE}\n${FILE_LINE}\n${appLine}`, base, await howWeWork(bridge)].filter((part) => part !== '').join('\n\n');
+    const lines = [HOUSE_LINE, FILE_LINE, appLine, ...(copies.length === 0 ? [] : [COPIES_LINE, ...copies])];
+    return [lines.join('\n'), base, await howWeWork(bridge)].filter((part) => part !== '').join('\n\n');
 }

package/dist/operation.js

@@ -0,0 +1,9 @@
+import { randomBytes } from 'node:crypto';
+export function operationId() {
+    const bytes = randomBytes(16);
+    bytes.writeUIntBE(Date.now(), 0, 6);
+    bytes[6] = 0x70 | (bytes[6] & 0x0f);
+    bytes[8] = 0x80 | (bytes[8] & 0x3f);
+    const hex = bytes.toString('hex');
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}

package/dist/resident.js

@@ -1,8 +1,15 @@
+import { once } from 'node:events';
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { createServer } from 'node:http';
+import { extname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { killDescendants } from './acp.js';
 import { Agents } from './agents.js';
 import { house } from './api.js';
+import { received } from './bridge.js';
 import { Conversations } from './conversations.js';
-import { readEnrolment } from './home.js';
+import { WorkingCopies } from './copies.js';
+import { kitHome, readEnrolment } from './home.js';
 import { SignIns } from './sign-in.js';
 import { holdStream } from './stream.js';
 function report(error) {
@@ -11,6 +18,36 @@ function report(error) {
 function logged(work) {
     work.catch(report);
 }
+function quoted(value) {
+    return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+async function installShim() {
+    const main = fileURLToPath(new URL(`./git-main${extname(fileURLToPath(import.meta.url))}`, import.meta.url));
+    await mkdir(join(kitHome(), 'shim'), { recursive: true });
+    await writeFile(join(kitHome(), 'shim', 'git'), `#!/bin/sh\nexec ${quoted(process.execPath)} ${quoted(main)} "$@"\n`, {
+        mode: 0o755,
+    });
+}
+async function serveOwner(copies) {
+    const socketPath = join(kitHome(), 'owner.sock');
+    await rm(socketPath, { force: true });
+    const server = createServer(async (request, response) => {
+        try {
+            if (request.url !== '/git/push') {
+                response.writeHead(404).end();
+                return;
+            }
+            const { cwd, commit } = JSON.parse(await received(request));
+            const pushed = await copies.push(cwd, commit, copies.owner);
+            response.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify(pushed));
+        }
+        catch (error) {
+            response.writeHead(502).end(error instanceof Error ? error.message : String(error));
+        }
+    });
+    server.listen(socketPath);
+    await once(server, 'listening');
+}
 export async function resident() {
     if ((await readEnrolment()) === null) {
         process.stderr.write('kit: this Environment is not enrolled; run kit login\n');
@@ -19,6 +56,10 @@ export async function resident() {
     }
     process.env.HOUSE_KIT_RESIDENT = String(process.pid);
     const agents = new Agents(house);
+    const copies = new WorkingCopies(house);
+    await copies.load();
+    await installShim();
+    await serveOwner(copies);
     let stream = null;
     let reported = false;
     const idle = () => conversations.idle() && signIns.idle();
@@ -34,6 +75,7 @@ export async function resident() {
     const conversations = new Conversations({
         house,
         agents,
+        copies,
         send: (frame) => stream?.send(frame) ?? false,
         changed,
     });
@@ -50,16 +92,22 @@ export async function resident() {
         opened: () => {
             conversations.opened();
             changed();
+            logged(copies.select());
         },
-        frame: (received) => {
-            if (received.type === 'work_available' && received.subject === 'agents')
+        frame: (arrived) => {
+            if (arrived.type === 'work_available' && arrived.subject === 'agents')
                 logged(agents.refresh());
-            if (received.type === 'input') {
+            if (arrived.type === 'work_available' && arrived.subject === 'working_copy')
+                logged(copies.select());
+            if (arrived.type === 'entries') {
+                copies.entries(arrived);
+            }
+            if (arrived.type === 'input') {
                 reported = false;
-                if (received.kind === 'sign_in')
-                    signIns.start(received);
+                if (arrived.kind === 'sign_in')
+                    signIns.start(arrived);
                 else
-                    conversations.input(received);
+                    conversations.input(arrived);
             }
         },
     });

package/dist/translate.js

@@ -0,0 +1,49 @@
+import { apply, parse, serialize } from '@agentshouse/mdmodel';
+function same(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+function applied(document, changes) {
+    let current = document;
+    for (const change of changes) {
+        const result = apply(current, change);
+        if (result.outcome !== 'applied')
+            return null;
+        current = result.document;
+    }
+    return serialize(current);
+}
+function components(path, before, after, text) {
+    const edits = [];
+    const changes = [];
+    if (before.preamble !== after.preamble) {
+        edits.push({ op: 'replace_preamble', path, base: before.preamble, content: after.preamble });
+        changes.push({ kind: 'preamble', value: after.preamble, prior: before.preamble });
+    }
+    for (const name of new Set([...Object.keys(before.fields), ...Object.keys(after.fields)])) {
+        const prior = before.fields[name];
+        const value = after.fields[name];
+        if (same(prior, value))
+            continue;
+        if (value === undefined)
+            return null;
+        edits.push({ op: 'set_field', path, field: name, ...(prior === undefined ? {} : { base: prior }), value });
+        changes.push({ kind: 'field', name, value, prior });
+    }
+    for (const name of new Set([...Object.keys(before.sections), ...Object.keys(after.sections)])) {
+        const prior = before.sections[name];
+        const value = after.sections[name];
+        if (prior === value)
+            continue;
+        if (prior === undefined || value === undefined)
+            return null;
+        edits.push({ op: 'replace_section', path, section: name, base: prior, content: value });
+        changes.push({ kind: 'section', name, value, prior });
+    }
+    return edits.length > 0 && applied(before, changes) === text ? edits : null;
+}
+export function changed(path, file, base, before, after) {
+    const parsedBefore = parse(before, file);
+    const parsedAfter = parse(after, file);
+    const structured = parsedBefore.ok && parsedAfter.ok ? components(path, parsedBefore.document, parsedAfter.document, after) : null;
+    return structured ?? [{ op: 'replace', path, base, content: after }];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentshouse/kit",
-  "version": "0.2.1-alpha.5",
+  "version": "0.2.1-alpha.6",
   "description": "House Kit connects an Environment to agents.house.",
   "license": "MIT",
   "repository": {
@@ -20,7 +20,9 @@
     "test": "tsc -p tsconfig.json && vitest run"
   },
   "dependencies": {
-    "@agentclientprotocol/sdk": "1.7.0"
+    "@agentclientprotocol/sdk": "1.7.0",
+    "@agentshouse/mdmodel": "0.1.0-alpha.15",
+    "yaml": "2.9.1"
   },
   "peerDependencies": {
     "@agentclientprotocol/claude-agent-acp": "0.85.1",