@agentshouse/kit 0.1.0-alpha.2 → 0.1.0-alpha.20

package/src/launcher.js

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { commandHouseInstructions, commandHouseRequest } from "./adapter-mcp.js";
+import { commandHouseInstructions } from "./adapter-mcp.js";
 import {
   compiledContract,
   initializeCommandAdapter,
@@ -129,6 +129,12 @@ async function configureSession(acp, contract, sessionId, adapter) {
   }
 }
 
+function workingCopyContext(copies) {
+  if (!Array.isArray(copies) || copies.length === 0) return [];
+  const lines = copies.map((copy) => `${copy.path}: ${copy.repository}`);
+  return [{ type: "text", text: ["Local Git working copies of House paths:", ...lines].join("\n") }];
+}
+
 async function runTurn(channel, start, bridge, turn) {
   const contract = compiledContract(start.adapter?.kind);
   const adapter = startCommandAdapter(
@@ -185,14 +191,14 @@ async function runTurn(channel, start, bridge, turn) {
       loading = false;
     }
     await configureSession(acp, contract, providerSessionId, start.adapter);
-    const request = start.request === null ? await commandHouseRequest(bridge) : start.request;
     turn.adapterSession = true;
     turn.cancel = () => acp.cancel({ sessionId: providerSessionId });
     const prompted = await acp.request("session/prompt", {
       sessionId: providerSessionId,
       prompt: [
-        { type: "text", text: JSON.stringify(request) },
+        { type: "text", text: JSON.stringify(start.request) },
         { type: "text", text: instructions },
+        ...workingCopyContext(start.working_copies),
       ],
     });
     await new Promise((resolve) => setImmediate(resolve));

package/src/local-files.js

@@ -1,6 +1,7 @@
 import { isAbsolute } from "node:path";
-import { parse, stringify } from "yaml";
+import { stringify } from "yaml";
 import { AGENT_OPERATION_META, ATTACHMENT_FILE_META } from "./contract.js";
+import { answerText, answerYaml } from "./mcp.js";
 import { derivedOperationId } from "./operation.js";
 import { localAttachment, sendLocalConversationFile, uploadLocalAttachment } from "./original.js";
 import { KitRefusal } from "./refusal.js";
@@ -12,18 +13,9 @@ class HouseRefused extends Error {
   }
 }
 
-function parsed(text) {
-  try {
-    return parse(text);
-  } catch {
-    return null;
-  }
-}
-
 function answerOf(frame) {
   if (frame.error !== undefined || frame.result?.isError === true) throw new HouseRefused(frame);
-  const text = (frame.result?.content ?? []).filter((item) => item.type === "text").map((item) => item.text).join("\n");
-  const answer = parsed(text);
+  const answer = answerYaml(answerText(frame.result));
   if (answer === null || typeof answer !== "object") throw new KitRefusal("kit_house_answer_unreadable");
   return answer;
 }

package/src/login.js

@@ -8,7 +8,7 @@ import { createInterface } from "node:readline/promises";
 import { stdin, stdout } from "node:process";
 import { KIT_CREDENTIAL } from "./contract.js";
 import { launchBase, prepareLaunchBase } from "./directory.js";
-import { houseRequest } from "./house.js";
+import { houseRequest, refuseDrained } from "./house.js";
 import { KitRefusal } from "./refusal.js";
 import { writeText } from "./state.js";
 
@@ -260,6 +260,7 @@ export async function openBrowser(url) {
 }
 
 export async function connectHouse(options, dependencies = {}) {
+  refuseDrained(options.directory);
   await prepareLaunchBase(launchBase(dependencies));
   if (options.presentation === "manual") return login(options, dependencies);
   const callback = await loopback();

package/src/mcp.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { parse } from "yaml";
 import { bridgePeer } from "./peer.js";
 import { KitRefusal } from "./refusal.js";
 
@@ -69,3 +70,15 @@ export async function bridgeCall(bridge, request, signal = undefined) {
     await peer.end();
   }
 }
+
+export function answerText(result) {
+  return (result?.content ?? []).filter((item) => item.type === "text").map((item) => item.text).join("\n");
+}
+
+export function answerYaml(text) {
+  try {
+    return parse(text);
+  } catch {
+    return null;
+  }
+}

package/src/mount.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { join } from "node:path";
 import { readFile, writeFile } from "node:fs/promises";
-import { apply, links, parse, serialize } from "@agentshouse/mdmodel";
+import { apply, links, parse, retarget, serialize } from "@agentshouse/mdmodel";
 import {
   KIT_DOOR_BATCH_PATH,
   KIT_DOOR_BOOTSTRAP_PATH,
@@ -84,7 +84,6 @@ export function mountTarget(subtree) {
     refuse("kit_mount_subtree_invalid", subtree);
   }
   return {
-    kind: own ? "private" : "room",
     handle: own ? null : segments[1],
     root: own ? "/private" : `/rooms/${segments[1]}`,
     subtree,
@@ -107,10 +106,11 @@ function discoveryOf(value) {
 
 function authorityFor(discovery, target) {
   const found = discovery.authorities.find((entry) =>
-    target.kind === "private" ? entry.kind === "private" : entry.room_handle === target.handle,
+    entry.kind === "room" && entry.room_handle === target.handle,
   );
   if (found === undefined) refuse("kit_mount_authority_unknown", target.root);
   if (
+    typeof found.room_ref !== "string" ||
     !Array.isArray(found.protected_paths) ||
     found.operations === null ||
     typeof found.operations !== "object" ||
@@ -119,8 +119,8 @@ function authorityFor(discovery, target) {
     refuse("kit_mount_rejected", "discover");
   }
   return {
-    kind: found.kind,
-    authority: found.kind === "private" ? "private" : found.room_ref,
+    kind: "room",
+    authority: found.room_ref,
     path: target.root,
     protected_paths: found.protected_paths,
     operations: found.operations,
@@ -128,16 +128,11 @@ function authorityFor(discovery, target) {
   };
 }
 
-function hrefSuffix(href) {
-  const match = /[?#]/.exec(href);
-  return match === null ? "" : href.slice(match.index);
-}
-
 function replaceLink(document, href, destination) {
   const marker = `house-kit-link:${operationId()}`;
   const located = apply(document, { kind: "link", href, to: marker });
   if (located.outcome !== "applied") refuse("kit_mount_link_unwritable", href);
-  const cleared = parse(serialize(located.document).replaceAll(`${marker}${hrefSuffix(href)}`, marker));
+  const cleared = parse(serialize(located.document).replaceAll(retarget(href, marker), marker));
   if (!cleared.ok) refuse("kit_mount_link_unwritable", href);
   const changed = apply(cleared.document, { kind: "link", href: marker, to: destination });
   if (changed.outcome !== "applied") refuse("kit_mount_link_unwritable", href);
@@ -178,11 +173,8 @@ export function rewriteAttachmentLinks(held, mintVersion) {
         refuse("kit_migrator_referrer_undeclared", `${relative} -> ${path}`);
       }
       const version = mintVersion(path);
-      const applied = apply(document, {
-        kind: "link",
-        href: link.href,
-        to: `${PENDING_LINK_SCHEME}:${version}`,
-      });
+      const pending = `${PENDING_LINK_SCHEME}:${version}`;
+      const applied = apply(document, { kind: "link", href: link.href, to: pending });
       if (applied.outcome !== "applied") refuse("kit_mount_link_unwritable", link.href);
       document = applied.document;
       let save = saves.find((entry) => entry.path === path);
@@ -191,8 +183,8 @@ export function rewriteAttachmentLinks(held, mintVersion) {
         saves.push(save);
       }
       if (!save.documents.includes(relative)) save.documents.push(relative);
-      const suffix = hrefSuffix(link.href);
-      const href = `${PENDING_LINK_SCHEME}:${version}${suffix}`;
+      const suffix = retarget(link.href, "");
+      const href = retarget(link.href, pending);
       if (!save.hrefs.some((entry) => entry.document === relative && entry.href === href)) {
         save.hrefs.push({ document: relative, href, suffix });
       }
@@ -326,7 +318,7 @@ function pendingTransfer(held, save) {
   };
 }
 
-async function submitAttachments(session, held, target, authority, plan, signal) {
+async function submitAttachments(session, held, authority, plan, signal) {
   const transfers = [];
   for (const save of plan.saves) {
     const local = held.attachments.get(save.path);
@@ -341,7 +333,7 @@ async function submitAttachments(session, held, target, authority, plan, signal)
         version: save.version,
         name: declared.name,
         mediaType: declared.mediaType ?? undefined,
-        room: target.kind === "room" ? authority.authority : null,
+        room: authority.authority,
         body,
         signal,
       });
@@ -471,7 +463,7 @@ export async function mountPackage(held, options, dependencies = {}) {
     };
     const localReport = join(held.root, "MIGRATION.json");
     await writeFile(localReport, `${JSON.stringify(result, null, 2)}\n`);
-    result.transfers = await submitAttachments(session, held, target, authority, plan, signal);
+    result.transfers = await submitAttachments(session, held, authority, plan, signal);
 
     const report = `${target.subtree}/${MOUNT_REPORT_NAME}`;
     await writeFile(localReport, `${JSON.stringify(result, null, 2)}\n`);

package/src/repository.js

@@ -1,8 +1,8 @@
 import { createHash } from "node:crypto";
-import { spawn } from "node:child_process";
 import { constants } from "node:fs";
 import { open, readlink, realpath } from "node:fs/promises";
 import { join } from "node:path";
+import { runGit } from "./git.js";
 import { deliverPublicationChunk, maintainControl, openPublicationManifest, openSession } from "./house.js";
 import { KitRefusal } from "./refusal.js";
 import { readRepositoryState, writeRepositoryState } from "./state.js";
@@ -258,69 +258,11 @@ async function* chunkArchive(checkout, entries, signal) {
   yield Buffer.alloc(BLOCK_BYTES * 2);
 }
 
-function runGit(checkout, args, dependencies, capture, signal) {
-  active(signal);
-  const launcher = dependencies.spawn ?? spawn;
-  return new Promise((resolve, reject) => {
-    let child;
-    try {
-      child = launcher("git", args, {
-        cwd: checkout,
-        env: process.env,
-        stdio: capture ? ["ignore", "pipe", "inherit"] : "inherit",
-        signal,
-        killSignal: "SIGKILL",
-      });
-    } catch (error) {
-      reject(
-        signal?.aborted === true || error?.name === "AbortError"
-          ? new KitRefusal("kit_command_cancelled")
-          : new KitRefusal("kit_git_unavailable"),
-      );
-      return;
-    }
-    const output = [];
-    let settled = false;
-    const finish = (operation) => {
-      if (settled) return;
-      settled = true;
-      operation();
-    };
-    child.stdout?.on("data", (chunk) => output.push(Buffer.from(chunk)));
-    child.once("error", (error) =>
-      finish(() =>
-        reject(
-          signal?.aborted === true || error?.name === "AbortError"
-            ? new KitRefusal("kit_command_cancelled")
-            : new KitRefusal("kit_git_unavailable"),
-        ),
-      ),
-    );
-    child.once("close", (status) => {
-      finish(() => {
-        if (signal?.aborted === true) {
-          reject(new KitRefusal("kit_command_cancelled"));
-          return;
-        }
-        if (status !== 0) {
-          reject(
-            new KitRefusal(args[0] === "pull" ? "kit_git_pull_failed" : "kit_git_selection_failed"),
-          );
-          return;
-        }
-        resolve(Buffer.concat(output));
-      });
-    });
-  });
-}
-
 async function selectedPaths(checkout, dependencies, signal) {
   const output = await runGit(
     checkout,
     ["ls-files", "--cached", "--others", "--exclude-standard", "-z"],
-    dependencies,
-    true,
-    signal,
+    { dependencies, capture: true, signal, failure: "kit_git_selection_failed" },
   );
   const paths = [];
   let offset = 0;
@@ -469,7 +411,7 @@ export async function captureRepository(options, dependencies = {}) {
     session,
     async (signal) => {
       const state = stateOf(await readRepositoryState(options.directory, key), identity);
-      await runGit(identity.checkout, ["pull"], dependencies, false, signal);
+      await runGit(identity.checkout, ["pull"], { dependencies, signal, failure: "kit_git_pull_failed" });
       const now = dependencies.now ?? (() => new Date());
       let sourceRef = state.source_ref;
       let publication = null;

package/src/session-bin/git

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../git-main.js";

package/src/setup.js

@@ -114,14 +114,14 @@ async function signedIn(module) {
   }
 }
 
-async function setUpModule(context, module) {
+async function setUpModule(context, module, install = true) {
   const summary = (status, reason = null) => ({
     category: module.category,
     name: module.name,
     status,
     reason,
   });
-  if (module.install !== null) {
+  if (install && module.install !== null) {
     try {
       await module.install();
     } catch (error) {
@@ -144,10 +144,15 @@ async function setUpModule(context, module) {
   return summary("ready");
 }
 
+export function signInWantedAgent(context, kind) {
+  return setUpModule(context, agentModule(context, kind), false);
+}
+
 export async function runSetup(context, request) {
   await prepareLaunchBase(launchBase(context.dependencies));
   const modules = [];
   for (const kind of context.configuration.agents) {
+    await context.waitAgentLogin?.(kind);
     modules.push(await setUpModule(context, agentModule(context, kind)));
   }
   for (const instance of context.configuration.instances) {

package/src/source.js

@@ -12,7 +12,7 @@ import {
   newCheckpoint,
   stallOf,
 } from "./delivery.js";
-import { captureBatch, openSession } from "./house.js";
+import { captureBatch, maintainControl, openSession } from "./house.js";
 import { googlePage } from "./google/source.js";
 import { houseAnswered, houseAnsweredFailure, houseFailed, KitRefusal } from "./refusal.js";
 import { recordAcceptedOriginals, sameReference, saveSourceOriginals } from "./source-originals.js";
@@ -204,18 +204,24 @@ export async function captureSource(options, dependencies = {}) {
   const googleOAuthClient =
     instance.preset === "google" ? dependencies.googleOAuthClient() : null;
   const session = await openSession(options, dependencies);
-  const context = {
-    instance,
+  return maintainControl(
     session,
-    directory: options.directory,
-    signal: options.signal,
-    now: session.now,
-    dependencies,
-    googleOAuthClient,
-  };
-  const delivered = [];
-  for (const service of services) delivered.push(await deliverService(context, service));
-  return { instance: instance.id, services: delivered };
+    async (signal) => {
+      const context = {
+        instance,
+        session,
+        directory: options.directory,
+        signal,
+        now: session.now,
+        dependencies,
+        googleOAuthClient,
+      };
+      const delivered = [];
+      for (const service of services) delivered.push(await deliverService(context, service));
+      return { instance: instance.id, services: delivered };
+    },
+    options.signal,
+  );
 }
 
 export async function sourceStatus(options) {
@@ -255,32 +261,40 @@ export async function retrySourceOriginals(options, dependencies = {}) {
   const configuration = await readConfiguration(options.configuration);
   const instance = sourceInstance(configuration, options.instance);
   const services = declaredServices(instance, options.service ?? null);
-  const context = { instance, directory: options.directory, signal: options.signal };
   const outstanding = [];
   for (const service of services) {
     outstanding.push((await readSourceOriginals(options.directory, instance.id, service.service)).length);
   }
-  if (outstanding.some((count) => count > 0)) context.session = await openSession(options, dependencies);
-  const retried = [];
-  for (const [position, service] of services.entries()) {
-    retried.push({
-      service: service.service,
-      originals:
-        outstanding[position] === 0
-          ? []
-          : await saveSourceOriginals(context, serviceBinding(context, service)),
-    });
-  }
-  return { instance: instance.id, services: retried };
+  const retry = async (context) => {
+    const retried = [];
+    for (const [position, service] of services.entries()) {
+      retried.push({
+        service: service.service,
+        originals:
+          outstanding[position] === 0
+            ? []
+            : await saveSourceOriginals(context, serviceBinding(context, service)),
+      });
+    }
+    return { instance: instance.id, services: retried };
+  };
+  const context = { instance, directory: options.directory, signal: options.signal };
+  if (outstanding.every((count) => count === 0)) return retry(context);
+  const session = await openSession(options, dependencies);
+  return maintainControl(session, (signal) => retry({ ...context, session, signal }), options.signal);
 }
 
 export async function resetSource(options, dependencies = {}) {
   const configuration = await readConfiguration(options.configuration);
   const instance = sourceInstance(configuration, options.instance);
   declaredServices(instance, options.service);
-  await openSession(options, dependencies);
-  return {
-    instance: instance.id,
-    services: await resetCheckpoints(options.directory, instance.id, options.service),
-  };
+  const session = await openSession(options, dependencies);
+  return maintainControl(
+    session,
+    async () => ({
+      instance: instance.id,
+      services: await resetCheckpoints(options.directory, instance.id, options.service),
+    }),
+    options.signal,
+  );
 }

package/src/sync-library.js

@@ -100,13 +100,12 @@ function recordedMap(authority) {
   return new Map(authority.files.map((file) => [file.path, file]));
 }
 
-function structuredOrReplace(root, relative, recorded, content) {
+export function structuredOrReplace(root, relative, recorded, content) {
   const path = housePath(root, relative);
+  const whole = [{ op: "replace", path, base: recorded.revision, content }];
   const before = parse(recorded.content, relative);
   const after = parse(content, relative);
-  if (!before.ok || !after.ok) {
-    return [{ op: "replace", path, base: recorded.revision, content }];
-  }
+  if (!before.ok || !after.ok) return whole;
   const ops = [];
   if (before.document.preamble !== after.document.preamble) {
     ops.push({
@@ -124,9 +123,7 @@ function structuredOrReplace(root, relative, recorded, content) {
     if (JSON.stringify(before.document.fields[name]) === JSON.stringify(after.document.fields[name])) {
       continue;
     }
-    if (after.document.fields[name] === undefined) {
-      return [{ op: "replace", path, base: recorded.revision, content }];
-    }
+    if (after.document.fields[name] === undefined) return whole;
     const change = { op: "set_field", path, field: name, value: after.document.fields[name] };
     if (before.document.fields[name] !== undefined) change.base = before.document.fields[name];
     ops.push(change);
@@ -139,12 +136,11 @@ function structuredOrReplace(root, relative, recorded, content) {
     const prior = before.document.sections[name];
     const next = after.document.sections[name];
     if (prior === next) continue;
-    if (prior === undefined || next === undefined) {
-      return [{ op: "replace", path, base: recorded.revision, content }];
-    }
+    if (prior === undefined || next === undefined) return whole;
     ops.push({ op: "replace_section", path, section: name, base: prior, content: next });
   }
-  return ops.length === 0 ? [{ op: "replace", path, base: recorded.revision, content }] : ops;
+  if (ops.length === 0) return whole;
+  return applyChanges({ [relative]: recorded.content }, ops, root)[relative] === content ? ops : whole;
 }
 
 export function deriveChanges(state, authority, localFiles) {

package/src/sync-state.js

@@ -26,6 +26,9 @@ function syncFile(directory, key, kind = "") {
 function recordedAuthority(authority) {
   const operations = authority?.operations;
   return (
+    authority?.kind === "room" &&
+    typeof authority.authority === "string" &&
+    typeof authority.path === "string" &&
     typeof authority?.log_epoch === "string" &&
     operations !== null &&
     typeof operations === "object" &&
@@ -43,6 +46,7 @@ export async function readReplicaState(directory, replica) {
   }
   const state = await readNote(syncFile(directory, replicaKey(canonical)), null);
   if (state === null) return null;
+  if (state.version !== EXPLICIT_SYNC_VERSION) return null;
   if (!Array.isArray(state.authorities) || !state.authorities.every(recordedAuthority)) return null;
   return state;
 }

package/src/sync.js

@@ -41,12 +41,12 @@ function sessionDependencies(options, dependencies) {
   };
 }
 
-async function withSession(options, dependencies, operation) {
+export async function withSession(options, dependencies, operation) {
   const session = await openSession(options, sessionDependencies(options, dependencies));
   return maintainControl(session, (signal) => operation(session, signal), options.signal);
 }
 
-async function door(session, path, body, signal) {
+export async function door(session, path, body, signal) {
   return houseRequest(
     session.house,
     await heldControl(session, signal),
@@ -83,7 +83,7 @@ function changePosition(value, declaration) {
   return { position: value.position, log_epoch: value.log_epoch };
 }
 
-function discoveryOf(value) {
+export function discoveryOf(value) {
   if (typeof value?.md_model_version !== "string" || !Array.isArray(value.authorities)) {
     throw new KitRefusal("kit_sync_rejected", "discover");
   }
@@ -93,7 +93,7 @@ function discoveryOf(value) {
   return value;
 }
 
-async function bootstrapBundle(session, prefixes, signal) {
+export async function bootstrapBundle(session, prefixes, signal) {
   const answer = await door(session, KIT_DOOR_BOOTSTRAP_PATH, { prefixes }, signal);
   if (typeof answer?.transfer?.url === "string") {
     const granted = await houseGetJson(answer.transfer.url, session.dependencies, signal);
@@ -105,9 +105,6 @@ async function bootstrapBundle(session, prefixes, signal) {
 }
 
 function matchedDiscovery(discovery, scope) {
-  if (scope.manifest?.scope === "private") {
-    return discovery.authorities.find((entry) => entry.kind === "private");
-  }
   return discovery.authorities.find(
     (entry) => entry.kind === "room" && entry.room_ref === scope.manifest?.anchor,
   );
@@ -173,11 +170,17 @@ function operationsOf(value) {
 function authorityRecord(scope, discovery, files) {
   const found = matchedDiscovery(discovery, scope);
   const operations = found === undefined ? null : operationsOf(found.operations);
-  if (found === undefined || !stringList(found.protected_paths) || operations === null) {
+  if (
+    scope.manifest?.scope !== "room" ||
+    typeof scope.manifest.anchor !== "string" ||
+    found === undefined ||
+    !stringList(found.protected_paths) ||
+    operations === null
+  ) {
     throw new KitRefusal("kit_bootstrap_rejected");
   }
   return {
-    kind: scope.manifest.scope === "private" ? "private" : "room",
+    kind: "room",
     authority: scope.manifest.anchor,
     room_handle: scope.manifest.room_handle,
     path: scope.manifest.path,
@@ -192,9 +195,10 @@ function authorityRecord(scope, discovery, files) {
 async function materialize(options, discovery, bundle, signal, previous = null) {
   const authorities = [];
   for (const scope of bundle.scopes) {
+    const record = authorityRecord(scope, discovery, []);
     const held = previous?.authorities.find((entry) => entry.authority === scope.manifest?.anchor);
     const files = await replaceScope(options.replica, held, scope, signal);
-    authorities.push(authorityRecord(scope, discovery, files));
+    authorities.push({ ...record, files });
   }
   const state = {
     version: EXPLICIT_SYNC_VERSION,
@@ -409,6 +413,7 @@ export async function bootstrap(options, dependencies = {}) {
   const canonical = await canonicalReplica(options.replica);
   const existing = await readReplicaState(options.directory, canonical);
   if (existing !== null) throw new KitRefusal("kit_sync_already_bootstrapped", canonical);
+  await clearPending(options.directory, canonical);
   return withSession(options, dependencies, async (session, signal) => {
     const discovery = discoveryOf(
       await door(session, KIT_DOOR_DISCOVER_PATH, { prefixes: options.prefixes }, signal),