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

package/dist/files.js

@@ -1,21 +1,144 @@
-import { mkdir, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-export async function placeFiles(house, directory, files, signal) {
-    const paths = [];
-    for (const file of files) {
-        const original = await house.post('/kit/conversation/originals/get', { version: file.version, download: true }, signal);
-        const answer = await fetch(original.download.url, { signal });
-        if (!answer.ok)
-            throw new Error(`${file.name} did not download: ${answer.status}`);
-        const folder = join(directory, '.house', 'files', original.message, file.version);
-        await mkdir(join(directory, '.house')).catch((error) => {
-            if (error.code !== 'EEXIST')
+import { createHash, randomUUID } from 'node:crypto';
+import { createWriteStream } from 'node:fs';
+import { mkdir, rename, rm } from 'node:fs/promises';
+import { basename, dirname, join } from 'node:path';
+import { Readable, Transform } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { parseDocument } from 'yaml';
+import { retryDelay } from './api.js';
+import { Unsettled } from './mcp.js';
+import { relayed } from './relay.js';
+const STALLED_ROUNDS = 8;
+const PART_CHECKSUM = 'x-amz-checksum-sha256';
+const LINK = /\]\((\/rooms\/[^/)\s]+\/[^)\s]+)\)/gu;
+export function linkedPaths(text) {
+    return [...new Set(Array.from(text.matchAll(LINK), (link) => link[1]))];
+}
+export function inspectedFile(answer) {
+    const document = parseDocument(answer);
+    if (document.errors.length > 0)
+        return null;
+    const inspected = document.toJS();
+    if (typeof inspected?.download !== 'string')
+        return null;
+    return {
+        download: inspected.download,
+        sha256: String(inspected.sha256),
+        media_type: typeof inspected.media_type === 'string' ? inspected.media_type : null,
+    };
+}
+export function paused(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+export function storeRefusal(act, status) {
+    return new Error(`the ${act} answered ${status}; ${act} the file again`);
+}
+async function partDigests(uploading, partBytes) {
+    const whole = createHash('sha256');
+    const digests = [];
+    for (let start = 0; digests.length === 0 || start < uploading.bytes; start += partBytes) {
+        const end = Math.min(start + partBytes, uploading.bytes);
+        const digest = createHash('sha256');
+        for await (const chunk of uploading.read(start, end)) {
+            digest.update(chunk);
+            whole.update(chunk);
+        }
+        digests.push(digest.digest());
+    }
+    if (whole.digest('hex') !== uploading.sha256)
+        throw new Error(`${uploading.name} changed while it was uploaded; upload it again`);
+    return digests;
+}
+export async function uploaded(declared, uploading) {
+    const partBytes = declared.part_bytes;
+    const digests = await partDigests(uploading, partBytes);
+    const partSha256 = digests.map((digest) => digest.toString('hex'));
+    let answer = await finishing(uploading, declared.id, partSha256);
+    let idle = 0;
+    let stalled = 0;
+    while ('upload' in answer) {
+        const { id, parts } = answer.upload;
+        let sent = 0;
+        let failure = null;
+        for (const { part, url } of parts ?? []) {
+            const start = (part - 1) * partBytes;
+            try {
+                await uploading.send(url, start, Math.min(start + partBytes, uploading.bytes), {
+                    [PART_CHECKSUM]: digests[part - 1].toString('base64'),
+                });
+                sent++;
+            }
+            catch (error) {
+                failure = error;
+                break;
+            }
+        }
+        if (sent > 0) {
+            idle = 0;
+            stalled = 0;
+        }
+        else {
+            if (failure !== null && ++stalled >= STALLED_ROUNDS)
+                throw failure;
+            // A round that sent no part, its store unreachable, is followed by the next finishing call on the jittered curve.
+            await paused(retryDelay(idle++));
+        }
+        answer = await finishing(uploading, id, partSha256);
+    }
+    return answer;
+}
+async function finishing(uploading, upload, partSha256) {
+    for (let unsettled = 1;; unsettled++) {
+        try {
+            return await uploading.finish(upload, partSha256);
+        }
+        catch (error) {
+            if (!(error instanceof Unsettled) || unsettled === STALLED_ROUNDS)
                 throw error;
+        }
+        // A finishing call House did not settle, unreached or refused short of final, is sent again on the jittered curve as a conversation resends it, so a dropped connection or a House restart resumes the upload instead of ending it.
+        await paused(retryDelay(unsettled - 1));
+    }
+}
+async function drained(body) {
+    for await (const _chunk of body)
+        ;
+}
+export async function downloaded(address, fetching, destination, name) {
+    for (let asked = 1;; asked++) {
+        const { download, sha256 } = await address();
+        const answer = await fetching(download);
+        if (answer.status === 403 && asked === 1) {
+            await drained(answer.body);
+            continue;
+        }
+        if (answer.status !== 200) {
+            await drained(answer.body);
+            throw storeRefusal('download', answer.status);
+        }
+        await mkdir(dirname(destination), { recursive: true });
+        const partial = join(dirname(destination), `.${basename(destination)}.${randomUUID()}`);
+        const digest = createHash('sha256');
+        const hashed = new Transform({
+            transform(chunk, _encoding, done) {
+                digest.update(chunk);
+                done(null, chunk);
+            },
         });
-        await mkdir(folder, { recursive: true });
-        const path = join(folder, file.name);
-        await writeFile(path, Buffer.from(await answer.arrayBuffer()));
-        paths.push(path);
+        try {
+            await pipeline(answer.body, hashed, createWriteStream(partial, { flags: 'wx' }));
+            if (digest.digest('hex') !== sha256)
+                throw new Error(`${name} did not arrive whole; download it again`);
+            await rename(partial, destination);
+        }
+        catch (error) {
+            await rm(partial, { force: true });
+            throw error;
+        }
+        return;
     }
-    return paths;
+}
+export async function fetched(url, signal) {
+    const answer = await fetch(relayed(url), { signal });
+    return { status: answer.status, body: answer.body === null ? Readable.from([]) : Readable.fromWeb(answer.body) };
 }

package/dist/git-main.js

@@ -4,7 +4,7 @@ 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 { localCopies } 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([
@@ -125,7 +125,7 @@ async function observed(git, args) {
         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}/`)) {
+    if (common === undefined || worktree === undefined || !dirname(common).startsWith(`${localCopies()}/`)) {
         return delegated(git, args);
     }
     const listing = [...globals, '-C', worktree, 'ls-files', '--stage', '-z'];

package/dist/git.js

@@ -1,12 +1,17 @@
 import { spawn } from 'node:child_process';
+import { isUtf8 } from 'node:buffer';
 import { createHash } from 'node:crypto';
-import { withoutProxy } from './clis.js';
-export const WORKING_COPIES = '/agents/house/working-copies';
+import { join } from 'node:path';
+import { workspaceRoot } from './home.js';
+import { childEnvironment } from './relay.js';
+export function localCopies() {
+    return join(workspaceRoot(), 'local-copies');
+}
 export const HOUSE_REF = 'refs/house/received';
-const COMMITTER = 'House Kit <house-kit@localhost>';
+const COMMITTER = '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 child = spawn('git', args, { cwd, env: { ...childEnvironment(), ...env } });
         const stdout = [];
         let stderr = '';
         child.stdout.on('data', (chunk) => stdout.push(chunk));
@@ -44,14 +49,15 @@ export async function tree(repository, commit) {
     }
     return entries;
 }
-export async function blobText(repository, object, path) {
-    const bytes = (await run(repository, ['cat-file', 'blob', object])).stdout;
-    try {
-        return new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(bytes);
-    }
-    catch {
-        throw new Error(`${path} is not UTF-8 text`);
-    }
+async function blob(repository, object) {
+    return (await run(repository, ['cat-file', 'blob', object])).stdout;
+}
+export async function blobText(repository, object) {
+    return (await blob(repository, object)).toString('utf8');
+}
+export async function isText(repository, object, maxBytes) {
+    const bytes = await blob(repository, object);
+    return bytes.length <= maxBytes && isUtf8(bytes) && !bytes.includes(0);
 }
 export function blobId(content) {
     const bytes = Buffer.from(content, 'utf8');
@@ -64,18 +70,52 @@ 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 = [];
+function written(stream, bytes) {
+    return new Promise((resolve, reject) => {
+        stream.write(bytes, (error) => (error ? reject(error) : resolve()));
+    });
+}
+async function imported(stream, commits) {
+    await written(stream, Buffer.from('feature done\n'));
     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));
+        await written(stream, Buffer.concat([
+            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 await (const [path, content] of commit.files) {
+            await written(stream, content === null
+                ? Buffer.from(`D ${quoted(path)}\n`)
+                : Buffer.concat([Buffer.from(`M 100644 inline ${quoted(path)}\n`), ...data(content)]));
         }
-        stream.push(Buffer.from('\n'));
+        await written(stream, Buffer.from('\n'));
+    }
+    await written(stream, Buffer.from('done\n'));
+}
+export async function importCommits(repository, commits) {
+    const child = spawn('git', ['fast-import', '--quiet', '--force'], { cwd: repository, env: childEnvironment() });
+    let stderr = '';
+    child.stdout.resume();
+    child.stderr.on('data', (chunk) => {
+        stderr += chunk.toString('utf8');
+    });
+    child.stdin.on('error', () => undefined);
+    const closed = new Promise((resolve, reject) => {
+        child.on('error', reject);
+        child.on('close', resolve);
+    });
+    try {
+        await imported(child.stdin, commits);
+        child.stdin.end();
+    }
+    catch (error) {
+        child.stdin.destroy();
+        await closed;
+        throw error.code === 'EPIPE' ? new Error(`git fast-import failed: ${stderr.trim()}`) : error;
     }
-    await git(repository, ['fast-import', '--quiet', '--force'], Buffer.concat(stream));
+    if ((await closed) !== 0)
+        throw new Error(`git fast-import failed: ${stderr.trim()}`);
     return revision(repository, HOUSE_REF);
 }

package/dist/home.js

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