@agentshouse/kit 0.1.0-alpha.22 → 0.1.0-alpha.23

package/README.md

@@ -10,7 +10,7 @@ On Linux `amd64` or `arm64` with a working Docker Engine, run the published,
 versioned bootstrap once:
 
 ```sh
-bash <(curl -fsSL https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.22/connect-linux.sh)
+bash <(curl -fsSL https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.23/connect-linux.sh)
 ```
 
 The release asset pins one immutable multi-architecture image digest. It creates
@@ -1312,6 +1312,19 @@ control lease when a resident runs, and which otherwise acquires and releases
 its own. A Session refuses `--owner`, and a missing bridge is never replaced by
 owner authority.
 
+A Session's edit too large for one MCP request of 4 MiB goes through House's
+`prepare_edit_upload` Command on that Session's bridge, naming every changed
+path, the byte count and the SHA-256 of the bytes to upload under the push's
+operation. Those bytes are the serialized changes, padded with trailing spaces
+to one byte over 4 MiB when only the request around them passed the bound,
+because House takes no smaller upload. Kit sends them to the upload address
+House returns and then calls `edit` with the paths and the returned upload
+instead of the changes, so House applies them as the same one edit. The upload
+is recorded in Kit home before the edit is sent, so a push whose answer was lost
+resends that same edit; when House no longer holds the uploaded bytes and has
+not applied the edit, the push uploads them again once under the same operation.
+A change set beyond House's batch bounds is refused whole and never split.
+
 Inside an Agent Session `git` is Kit's shim in front of the installed Git, and
 every command runs exactly as that Git runs it. In a copy or one of its linked
 worktrees the shim compares that worktree's index before and after each

package/bootstrap.json

@@ -1,12 +1,12 @@
 {
   "schemaVersion": 1,
-  "version": "0.1.0-alpha.22",
+  "version": "0.1.0-alpha.23",
   "hosts": {
     "linux": {
-      "command": "bash <(curl -fsSL https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.22/connect-linux.sh)",
+      "command": "bash <(curl -fsSL https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.23/connect-linux.sh)",
       "asset": {
         "name": "connect-linux.sh",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.22/connect-linux.sh"
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.23/connect-linux.sh"
       },
       "workspace": {
         "argument": "--workspace",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentshouse/kit",
-  "version": "0.1.0-alpha.22",
+  "version": "0.1.0-alpha.23",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/bytes.js

@@ -31,6 +31,11 @@ async function downloadBody(response, signal) {
   return Buffer.concat(chunks, size);
 }
 
+function framedBody(request) {
+  if (request.method !== "POST" || !Buffer.isBuffer(request.body)) throw new KitRefusal("kit_byte_body_invalid");
+  return Buffer.concat([Buffer.from(`${request.operation}\n`, "utf8"), request.body]);
+}
+
 export async function transferBytes(request, dependencies = {}) {
   if (request.method !== "GET" && request.method !== "POST") {
     throw new KitRefusal("kit_byte_method_invalid", request.method);
@@ -41,23 +46,27 @@ export async function transferBytes(request, dependencies = {}) {
   if (typeof request.operation !== "string" || request.operation.length === 0) {
     throw new KitRefusal("kit_byte_operation_invalid");
   }
+  const framed = request.framed === true;
+  const body = framed ? framedBody(request) : request.body;
   if (request.method === "POST") {
-    if (!Buffer.isBuffer(request.body)) throw new KitRefusal("kit_byte_body_invalid");
-    if (request.body.length > BYTE_GRANT_POST_BYTES_MAX) {
+    if (!Buffer.isBuffer(body)) throw new KitRefusal("kit_byte_body_invalid");
+    if (body.length > BYTE_GRANT_POST_BYTES_MAX) {
       throw new KitRefusal("original_bytes_exceeded");
     }
   }
   const fetcher = dependencies.fetch ?? fetch;
-  const headers = {
-    [BYTE_GRANT_OPERATION_HEADER]: request.operation,
-  };
-  if (request.method === "POST") headers["content-type"] = "application/octet-stream";
+  const headers = framed
+    ? { "content-type": "text/plain; charset=utf-8" }
+    : {
+        [BYTE_GRANT_OPERATION_HEADER]: request.operation,
+        ...(request.method === "POST" ? { "content-type": "application/octet-stream" } : {}),
+      };
   let response;
   try {
     response = await fetcher(request.url, {
       method: request.method,
       headers,
-      body: request.method === "POST" ? request.body : undefined,
+      body: request.method === "POST" ? body : undefined,
       redirect: "manual",
       signal: request.signal,
     });

package/src/contract.js

@@ -308,6 +308,8 @@ export const WORKING_COPY_PUSH_METHOD = "house/git/push";
 export const WORKING_COPY_INDEX_METHOD = "house/git/index";
 export const WORKING_COPY_PUSH_HELP =
   "Submit a Room commit to House; default HEAD. Use --owner only outside an Agent Session. Native git push is not a House remote.";
+export const WORKING_COPY_UPLOAD_COMMAND = "prepare_edit_upload";
+export const MCP_REQUEST_BODY_MAX_BYTES = 4 * 1024 * 1024;
 
 export const MIGRATOR_CONTRACT = "kit-migrator/1";
 export const MIGRATOR_CATEGORY = "migrator";

package/src/worker.js

@@ -1,4 +1,4 @@
-import { randomBytes } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
@@ -11,6 +11,7 @@ import {
 import { readBindings, removeBinding, writeBinding } from "./binding.js";
 import { readContinuation, readContinuationRuns, writeContinuation, removeContinuation } from "./continuation.js";
 import { bridgedFrame, openBridge } from "./bridge.js";
+import { transferBytes } from "./bytes.js";
 import { assistantBlocks } from "./blocks.js";
 import { retryConversationFiles } from "./conversation-originals.js";
 import { openAssistantDrafts } from "./draft.js";
@@ -25,6 +26,7 @@ import {
   ownerCaller,
   pushWorkingCopy,
   recordIndexChange,
+  uploadedPaths,
   workingCopyPaths,
 } from "./working-copy.js";
 import { readConfiguration } from "./configuration.js";
@@ -32,6 +34,7 @@ import { launchBase, readyLaunchDirectory } from "./directory.js";
 import {
   BRIDGE_NONCE_ENVIRONMENT,
   BRIDGE_SOCKET_ENVIRONMENT,
+  MCP_REQUEST_BODY_MAX_BYTES,
   PROVIDER_CONTINUATION_UNAVAILABLE,
   WORKER_COMMAND_BATCH_MAX,
   WORKER_COMMAND_POLL_MS,
@@ -42,6 +45,7 @@ import {
   WORKER_SUPERVISION_POLL_MS,
   WORKING_COPY_INDEX_METHOD,
   WORKING_COPY_PUSH_METHOD,
+  WORKING_COPY_UPLOAD_COMMAND,
 } from "./contract.js";
 import { EpochReportRequired, formatCommandError, houseFailed, KitRefusal } from "./refusal.js";
 import {
@@ -299,20 +303,61 @@ function acceptedWith(text) {
   return { refused: null, written: [...written.values()] };
 }
 
+function toolFrame(name, args, operation) {
+  return bridgedFrame({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name, arguments: args } }, operation);
+}
+
+function uploadBody(changes) {
+  const body = Buffer.from(JSON.stringify({ changes }), "utf8");
+  if (body.length > MCP_REQUEST_BODY_MAX_BYTES) return body;
+  return Buffer.concat([body, Buffer.alloc(MCP_REQUEST_BODY_MAX_BYTES + 1 - body.length, " ")]);
+}
+
 async function sessionPush(context, bound, authority, frame, signal) {
-  const edit = async (body, sent) => {
-    const answer = await callHouseMcp(
-      context.session,
-      await sessionAuthority(context.session, bound.session, authority, sent),
-      bridgedFrame(
-        { jsonrpc: "2.0", id: 1, method: "tools/call", params: { name: "edit", arguments: { changes: body.changes } } },
-        body.operation_id,
-      ),
+  const call = async (sent, called) =>
+    callHouseMcp(context.session, await sessionAuthority(context.session, bound.session, authority, sent), called, sent);
+  const refused = (answer) =>
+    answer.error !== undefined
+      ? refusedWith(answer.error.message ?? "kit_house_refused")
+      : answer.result?.isError === true
+        ? refusedWith(answerText(answer.result))
+        : null;
+  const stage = async (body, sent) => {
+    const bytes = uploadBody(body.changes);
+    const sha256 = createHash("sha256").update(bytes).digest("hex");
+    const prepare = { paths: uploadedPaths(body.changes), bytes: bytes.length, sha256 };
+    const prepared = await call(
+      sent,
+      toolFrame("run_command", { command: WORKING_COPY_UPLOAD_COMMAND, arguments: prepare }, body.operation_id),
+    );
+    const refusal = refused(prepared);
+    if (refusal !== null) return refusal;
+    const transfer = answerYaml(answerText(prepared.result))?.transfer;
+    const staged = (
+      await transferBytes(
+        { url: transfer?.url, method: "POST", operation: transfer?.operation, body: bytes, framed: true, signal: sent },
+        context.session.dependencies,
+      )
+    ).transfer;
+    if (typeof staged?.url !== "string" || typeof staged.operation !== "string") {
+      throw new KitRefusal("kit_house_answer_unreadable", WORKING_COPY_UPLOAD_COMMAND);
+    }
+    return { upload: { url: staged.url, operation: staged.operation, bytes: bytes.length, sha256 } };
+  };
+  const edit = async (body, sent, retain) => {
+    let { upload } = body;
+    const inline = toolFrame("edit", { changes: body.changes }, body.operation_id);
+    if (upload === undefined && Buffer.byteLength(JSON.stringify(inline)) > MCP_REQUEST_BODY_MAX_BYTES) {
+      const staged = await stage(body, sent);
+      if (staged.upload === undefined) return staged;
+      ({ upload } = staged);
+      await retain(upload);
+    }
+    const answer = await call(
       sent,
+      upload === undefined ? inline : toolFrame("edit", { paths: uploadedPaths(body.changes), upload }, body.operation_id),
     );
-    if (answer.error !== undefined) return refusedWith(answer.error.message ?? "kit_house_refused");
-    const text = answerText(answer.result);
-    return answer.result?.isError === true ? refusedWith(text) : acceptedWith(text);
+    return refused(answer) ?? acceptedWith(answerText(answer.result));
   };
   let outcome;
   try {

package/src/working-copy.js

@@ -914,6 +914,10 @@ function pushedPaths(changes) {
   return new Set(changes.flatMap((change) => (change.op === "rename" ? [change.path, change.to] : [change.path])));
 }
 
+export function uploadedPaths(changes) {
+  return [...pushedPaths(changes)].sort();
+}
+
 async function enumerated(context, copy, since, signal) {
   const answer = await door(
     context.session,
@@ -1104,12 +1108,18 @@ async function expired(context, copy, text, signal) {
   return finish(context, accepted, signal);
 }
 
-async function settle(context, copy, caller, signal) {
+async function settle(context, copy, caller, signal, restaged = false) {
   const { push } = copy;
   if (!sameCaller(push.caller, caller.binding)) return orphaned(context, copy, signal);
+  let staged = push.upload !== undefined;
+  const retain = async (upload) => {
+    staged = true;
+    await writeCopy(context.directory, { ...copy, push: { ...push, upload } }, signal);
+  };
   let answer;
   try {
-    answer = await caller.submit({ operation_id: push.operation_id, changes: push.changes }, signal);
+    const { operation_id, changes, upload } = push;
+    answer = await caller.submit({ operation_id, changes, ...(upload === undefined ? {} : { upload }) }, signal, retain);
   } catch (error) {
     if (!definite(error)) {
       throw new KitRefusal("kit_working_copy_push_uncertain", "run house git push again to recover its outcome");
@@ -1118,6 +1128,12 @@ async function settle(context, copy, caller, signal) {
     answer = { refused: { code: error.code, text: formatCommandError(error), current: Array.isArray(current) ? current : null } };
   }
   const { refused } = answer;
+  if (refused?.code === "upload_unavailable" && staged && !restaged) {
+    const { upload, ...unstaged } = push;
+    const cleared = { ...copy, push: unstaged };
+    await writeCopy(context.directory, cleared, signal);
+    return settle(context, cleared, caller, signal, true);
+  }
   if (refused?.code === "operation_expired") return expired(context, copy, refused.text, signal);
   if (refused === null) {
     const pushed = pushedPaths(push.changes);