stitchkit 0.114.2 → 0.116.0

package/dist/{index-zrtrjkbf.js → index-arjmb6de.js}

@@ -1,17 +1,22 @@
 import {
   loadDarwinBinding
 } from "./index-2kbysk9s.js";
+import {
+  errnoOf
+} from "./index-jj9228tt.js";
 
-// src/agent-runtime/contained-scan.ts
-import path2 from "node:path";
-
-// src/agent-runtime/contained-files.ts
+// src/internal/contained-directory.ts
 import { constants } from "node:fs";
-import { lstat, mkdir, open, readdir, realpath } from "node:fs/promises";
+import { mkdir, open, realpath } from "node:fs/promises";
 import path from "node:path";
 
-// src/agent-runtime/contained-darwin.ts
+// src/internal/contained-handle.ts
 import { close as closeDescriptor, fstat, read as readDescriptor } from "node:fs";
+function descriptorPath(handle) {
+  if (process.platform === "linux")
+    return `/proc/self/fd/${handle.fd}`;
+  throw new Error("Descriptor paths are available only in the Linux contained-files backend");
+}
 var FILE_TYPE_MASK = 61440;
 var FILE_TYPE_DIRECTORY = 16384;
 var FILE_TYPE_REGULAR = 32768;
@@ -22,10 +27,14 @@ function modeIs(mode, type) {
 
 class NumericFileHandle {
   fd;
+  closed = false;
   constructor(fd) {
     this.fd = fd;
   }
   close() {
+    if (this.closed)
+      return Promise.resolve();
+    this.closed = true;
     return new Promise((resolve, reject) => {
       closeDescriptor(this.fd, (error) => error ? reject(error) : resolve());
     });
@@ -42,55 +51,111 @@ class NumericFileHandle {
   }
 }
 
-// src/agent-runtime/contained-files.ts
-function containedEntryKind(entry) {
-  return entry.isDirectory() ? "directory" : entry.isSymbolicLink() ? "symlink" : entry.isFile() ? "file" : "other";
+// src/internal/contained-directory.ts
+var O_PATH_LINUX = 2097152;
+var O_SEARCH_DARWIN = 1073741824;
+function directoryFlags(searchOnly) {
+  const access = searchOnly ? process.platform === "linux" ? O_PATH_LINUX : O_SEARCH_DARWIN : constants.O_RDONLY;
+  return access | constants.O_DIRECTORY | constants.O_NOFOLLOW;
 }
-function descriptorPath(handle) {
-  if (process.platform === "linux")
-    return `/proc/self/fd/${handle.fd}`;
-  throw new Error("Descriptor paths are available only in the Linux contained-files backend");
+async function openDirectoryAt(directory, name, searchOnly = false) {
+  if (process.platform === "darwin") {
+    return new NumericFileHandle(loadDarwinBinding().openDirectoryAt(directory.fd, name, searchOnly));
+  }
+  return open(path.join(descriptorPath(directory), name), directoryFlags(searchOnly));
 }
-function sameIdentity(left, right) {
-  return left.dev === right.dev && left.ino === right.ino;
+async function descend(current, next) {
+  try {
+    await current.close();
+  } catch (error) {
+    await next.close();
+    throw error;
+  }
+  return next;
+}
+async function createDirectoryAt(directory, name) {
+  if (process.platform === "darwin") {
+    return loadDarwinBinding().createDirectoryAt(directory.fd, name, 511);
+  }
+  try {
+    await mkdir(path.join(descriptorPath(directory), name));
+    return true;
+  } catch (error) {
+    if (errnoOf(error) === "EEXIST")
+      return false;
+    throw error;
+  }
 }
-async function openPinnedDirectory(absolute) {
+async function openPinnedDirectory(absolute, options = {}, io = { realpath }) {
   if (process.platform !== "linux" && process.platform !== "darwin") {
     throw new Error("Contained filesystem operations support Linux and macOS only");
   }
-  const expected = await realpath(absolute);
-  const handle = await open(expected, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+  let prefix = path.resolve(absolute);
+  const missing = [];
+  let canonical;
+  for (;; ) {
+    try {
+      canonical = await io.realpath(prefix);
+      break;
+    } catch (error) {
+      if (!options.create || errnoOf(error) !== "ENOENT")
+        throw error;
+      const parent = path.dirname(prefix);
+      if (parent === prefix)
+        throw error;
+      missing.unshift(path.basename(prefix));
+      prefix = parent;
+    }
+  }
+  const anchor = path.parse(canonical).root;
+  let current = await open(anchor, directoryFlags(true));
+  if (canonical === anchor && missing.length === 0 && options.readable !== false) {
+    await current.close();
+    return open(anchor, directoryFlags(false));
+  }
+  const existing = path.relative(anchor, canonical).split(path.sep).filter(Boolean);
   try {
-    const [pathMetadata, handleMetadata] = await Promise.all([lstat(expected), handle.stat()]);
-    if (!pathMetadata.isDirectory() || !sameIdentity(pathMetadata, handleMetadata)) {
-      throw new Error("Contained directory identity changed while opening");
+    const segments = [...existing, ...missing];
+    for (const [index, segment] of segments.entries()) {
+      if (index >= existing.length)
+        await createDirectoryAt(current, segment);
+      const next = await openDirectoryAt(current, segment, index < segments.length - 1 || options.readable === false);
+      current = await descend(current, next);
     }
-    return handle;
+    return current;
   } catch (error) {
-    await handle.close();
+    await current.close();
     throw error;
   }
 }
+
+// src/internal/contained-files.ts
+import { constants as constants2 } from "node:fs";
+import { lstat, open as open2, readdir } from "node:fs/promises";
+import path2 from "node:path";
+function containedEntryKind(entry) {
+  return entry.isDirectory() ? "directory" : entry.isSymbolicLink() ? "symlink" : entry.isFile() ? "file" : "other";
+}
+function sameIdentity(left, right) {
+  return left.dev === right.dev && left.ino === right.ino;
+}
+function isSafeEntryName(name) {
+  return name !== "" && name !== "." && name !== ".." && !name.includes("\x00");
+}
 function safeSegments(relative) {
-  if (path.isAbsolute(relative))
+  if (path2.isAbsolute(relative))
     throw new Error("Contained paths must be relative");
   const segments = relative.split(/[\\/]/u);
-  if (segments.length === 0 || segments.some((segment) => segment === "" || segment === "." || segment === "..")) {
+  if (!segments.every(isSafeEntryName)) {
     throw new Error("Contained path has invalid segments");
   }
   return segments;
 }
-async function openDirectoryAt(directory, name) {
-  if (process.platform === "darwin") {
-    return new NumericFileHandle(loadDarwinBinding().openDirectoryAt(directory.fd, name));
-  }
-  return open(path.join(descriptorPath(directory), name), constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
-}
 async function openFileAt(directory, name) {
   if (process.platform === "darwin") {
     return new NumericFileHandle(loadDarwinBinding().openFileAt(directory.fd, name));
   }
-  return open(path.join(descriptorPath(directory), name), constants.O_RDONLY | constants.O_NOFOLLOW);
+  return open2(path2.join(descriptorPath(directory), name), constants2.O_RDONLY | constants2.O_NOFOLLOW | constants2.O_NONBLOCK);
 }
 function entryMetadata(mode, size) {
   return {
@@ -106,8 +171,8 @@ async function statAt(directory, name) {
     const metadata = loadDarwinBinding().statAt(directory.fd, name);
     return metadata ? entryMetadata(metadata.mode, metadata.size) : null;
   }
-  return lstat(path.join(descriptorPath(directory), name)).catch((error) => {
-    if (error.code === "ENOENT")
+  return lstat(path2.join(descriptorPath(directory), name)).catch((error) => {
+    if (errnoOf(error) === "ENOENT")
       return null;
     throw error;
   });
@@ -123,14 +188,7 @@ async function listContainedDirectory(root, relative, maxEntries, authorizePath)
   try {
     if (relative !== ".") {
       for (const segment of safeSegments(relative)) {
-        const next = await openDirectoryAt(current, segment);
-        const metadata = await next.stat();
-        if (!metadata.isDirectory()) {
-          await next.close();
-          throw new Error("Contained ancestor is not a directory");
-        }
-        await current.close();
-        current = next;
+        current = await descend(current, await openDirectoryAt(current, segment));
       }
     }
     const raw = [...await listAt(current)];
@@ -138,7 +196,7 @@ async function listContainedDirectory(root, relative, maxEntries, authorizePath)
     const admitted = [];
     const denied = [];
     for (const entry of raw) {
-      const entryPath = relative === "." ? entry.name : path.join(relative, entry.name);
+      const entryPath = relative === "." ? entry.name : path2.join(relative, entry.name);
       if (authorizePath && !await authorizePath(entryPath)) {
         denied.push({ name: entry.name, kind: containedEntryKind(entry) });
         continue;
@@ -174,19 +232,6 @@ async function listContainedDirectory(root, relative, maxEntries, authorizePath)
     await current.close();
   }
 }
-async function createDirectoryAt(directory, name) {
-  if (process.platform === "darwin") {
-    return loadDarwinBinding().createDirectoryAt(directory.fd, name, 511);
-  }
-  try {
-    await mkdir(path.join(descriptorPath(directory), name));
-    return true;
-  } catch (error) {
-    if (error.code === "EEXIST")
-      return false;
-    throw error;
-  }
-}
 async function missingContainedDirectories(root, relative) {
   const segments = safeSegments(relative);
   segments.pop();
@@ -197,26 +242,69 @@ async function missingContainedDirectories(root, relative) {
     for (const segment of segments) {
       walked = [...walked, segment];
       if (missing.length > 0) {
-        missing.push(walked.join(path.sep));
+        missing.push(walked.join(path2.sep));
         continue;
       }
       const next = await openDirectoryAt(current, segment).catch((error) => {
-        if (error.code === "ENOENT")
+        if (errnoOf(error) === "ENOENT")
           return null;
         throw error;
       });
       if (!next) {
-        missing.push(walked.join(path.sep));
+        missing.push(walked.join(path2.sep));
         continue;
       }
-      await current.close();
-      current = next;
+      current = await descend(current, next);
     }
     return missing;
   } finally {
     await current.close();
   }
 }
+function alternateSpellings(name) {
+  const swapped = [...name].map((letter) => letter === letter.toLowerCase() ? letter.toUpperCase() : letter.toLowerCase()).join("");
+  return [...new Set([swapped, name.normalize("NFC"), name.normalize("NFD")])].filter((spelling) => spelling !== name);
+}
+async function misspelledContainedSegment(root, relative) {
+  const segments = safeSegments(relative);
+  let current = await openPinnedDirectory(root);
+  try {
+    for (const [index, segment] of segments.entries()) {
+      const exists = async (name) => await statAt(current, name).catch(() => null) !== null;
+      let folded = false;
+      for (const spelling of alternateSpellings(segment)) {
+        folded ||= await exists(spelling);
+      }
+      if (folded && await exists(segment)) {
+        const stored = (await listAt(current)).some(({ name }) => name === segment);
+        if (!stored)
+          return segment;
+      }
+      if (index === segments.length - 1)
+        return;
+      const next = await openDirectoryAt(current, segment).catch((error) => {
+        if (["ENOENT", "ENOTDIR", "ELOOP"].includes(errnoOf(error) ?? ""))
+          return null;
+        throw error;
+      });
+      if (!next)
+        return;
+      current = await descend(current, next);
+    }
+    return;
+  } finally {
+    await current.close();
+  }
+}
+
+class UnapprovedContainedDirectoryError extends Error {
+  relative;
+  constructor(relative) {
+    super(`Contained directory creation was not authorized: ${relative}`);
+    this.relative = relative;
+    this.name = "UnapprovedContainedDirectoryError";
+  }
+}
 async function openContainedParent(root, relative, options = {}) {
   const segments = safeSegments(relative);
   const basename = segments.pop();
@@ -224,17 +312,20 @@ async function openContainedParent(root, relative, options = {}) {
     throw new Error("Contained path is missing a basename");
   let current = await openPinnedDirectory(root);
   try {
+    const approved = new Set(options.createDirectories);
+    const walked = [];
     for (const segment of segments) {
-      if (options.create)
+      walked.push(segment);
+      const next = await openDirectoryAt(current, segment).catch(async (error) => {
+        if (options.createDirectories === undefined || errnoOf(error) !== "ENOENT")
+          throw error;
+        const directory = walked.join(path2.sep);
+        if (!approved.has(directory))
+          throw new UnapprovedContainedDirectoryError(directory);
         await createDirectoryAt(current, segment);
-      const next = await openDirectoryAt(current, segment);
-      const metadata = await next.stat();
-      if (!metadata.isDirectory()) {
-        await next.close();
-        throw new Error("Contained ancestor is not a directory");
-      }
-      await current.close();
-      current = next;
+        return openDirectoryAt(current, segment);
+      });
+      current = await descend(current, next);
     }
     return { handle: current, basename };
   } catch (error) {
@@ -256,21 +347,38 @@ async function openContainedFile(root, relative) {
     await parent.handle.close();
   }
 }
+
+class ContainedPathChangedError extends Error {
+  relative;
+  constructor(relative) {
+    super(`Contained path changed during authorization: ${relative}`);
+    this.relative = relative;
+    this.name = "ContainedPathChangedError";
+  }
+}
+async function reopen(relative, open) {
+  return open().catch((error) => {
+    if (["ENOENT", "ENOTDIR", "ELOOP"].includes(errnoOf(error) ?? "")) {
+      throw new ContainedPathChangedError(relative);
+    }
+    throw error;
+  });
+}
 async function assertContainedFileCurrent(root, relative, expected) {
-  const current = await openContainedFile(root, relative);
+  const current = await reopen(relative, () => openContainedFile(root, relative));
   try {
     if (!sameIdentity(await expected.stat(), await current.stat())) {
-      throw new Error("Contained file identity changed during authorization");
+      throw new ContainedPathChangedError(relative);
     }
   } finally {
     await current.close();
   }
 }
 async function assertContainedParentCurrent(root, relative, expected) {
-  const current = await openContainedParent(root, relative);
+  const current = await reopen(relative, () => openContainedParent(root, relative));
   try {
     if (!sameIdentity(await expected.stat(), await current.handle.stat())) {
-      throw new Error("Contained parent identity changed during authorization");
+      throw new ContainedPathChangedError(relative);
     }
   } finally {
     await current.handle.close();
@@ -310,101 +418,4 @@ async function readContainedUtf8Handle(handle, maxBytes) {
   };
 }
 
-// src/agent-runtime/contained-scan.ts
-async function walkContainedFiles(input) {
-  const scan = await scanContainedFiles({ ...input, symlinks: "refuse" });
-  if (scan.truncated)
-    throw new Error("Contained file traversal exceeded its bounds");
-  return scan.files;
-}
-async function scanContainedFiles(input) {
-  const files = [];
-  let truncated = false;
-  let skippedDirectories = 0;
-  let skippedSymlinks = 0;
-  const denied = [];
-  let deniedTruncated = false;
-  const root = await openPinnedDirectory(input.root);
-  const visit = async (directory, relativeDirectory, depth) => {
-    if (truncated)
-      return;
-    if (depth > input.maxDepth) {
-      truncated = true;
-      return;
-    }
-    const entries = [...await listAt(directory)];
-    entries.sort((left, right) => left.name.localeCompare(right.name));
-    for (const entry of entries) {
-      const relative = relativeDirectory ? path2.join(relativeDirectory, entry.name) : entry.name;
-      const kind = entry.isDirectory() ? "directory" : entry.isSymbolicLink() ? "symlink" : entry.isFile() ? "file" : "other";
-      if (kind === "file" && input.includeFile && !input.includeFile(relative))
-        continue;
-      if (input.authorizePath && !await input.authorizePath(relative, kind)) {
-        if (denied.length < input.maxFiles)
-          denied.push({ relative, kind });
-        else
-          deniedTruncated = true;
-        continue;
-      }
-      if (entry.isSymbolicLink()) {
-        if (input.symlinks === "refuse") {
-          throw new Error(`Contained file traversal refuses symlink: ${relative}`);
-        }
-        skippedSymlinks += 1;
-        continue;
-      }
-      if (entry.isDirectory()) {
-        if (input.excludeDirectory?.(relative)) {
-          skippedDirectories += 1;
-          continue;
-        }
-        let child;
-        try {
-          child = await openDirectoryAt(directory, entry.name);
-        } catch (error) {
-          if (input.symlinks === "skip") {
-            skippedSymlinks += 1;
-            continue;
-          }
-          throw error;
-        }
-        try {
-          await visit(child, relative, depth + 1);
-        } finally {
-          await child.close();
-        }
-        continue;
-      }
-      if (!entry.isFile())
-        continue;
-      if (files.length >= input.maxFiles) {
-        truncated = true;
-        return;
-      }
-      let content;
-      if (input.readMaxBytes !== undefined) {
-        try {
-          const handle = await openFileAt(directory, entry.name);
-          try {
-            content = await readContainedUtf8Handle(handle, input.readMaxBytes);
-          } finally {
-            await handle.close();
-          }
-        } catch (error) {
-          if (input.skipUnreadable)
-            continue;
-          throw error;
-        }
-      }
-      files.push({ absolute: relative, relative, ...content && { content } });
-    }
-  };
-  try {
-    await visit(root, "", 0);
-  } finally {
-    await root.close();
-  }
-  return { files, truncated, skippedDirectories, skippedSymlinks, denied, deniedTruncated };
-}
-
-export { NumericFileHandle, descriptorPath, listContainedDirectory, missingContainedDirectories, openContainedParent, openContainedFile, assertContainedFileCurrent, assertContainedParentCurrent, containedEntryMetadata, openContainedParentFile, readContainedUtf8Handle, walkContainedFiles, scanContainedFiles };
+export { descriptorPath, NumericFileHandle, openDirectoryAt, openPinnedDirectory, isSafeEntryName, openFileAt, listAt, listContainedDirectory, missingContainedDirectories, misspelledContainedSegment, UnapprovedContainedDirectoryError, openContainedParent, openContainedFile, ContainedPathChangedError, assertContainedFileCurrent, assertContainedParentCurrent, containedEntryMetadata, openContainedParentFile, readContainedUtf8Handle };

package/dist/{index-7r4knwf8.js → index-dr3t5n1v.js}

@@ -11,7 +11,10 @@ import {
   spawnBunChild,
   spawnBunInheritedChild,
   ownerLossGuardEntry
-} from "./index-84bf5spd.js";
+} from "./index-f6m4c545.js";
+import {
+  errnoOf
+} from "./index-jj9228tt.js";
 import {
   raceAbort
 } from "./index-b0kddvzw.js";
@@ -30,7 +33,8 @@ var ObservationSchema = z.object({
   groupId: z.number().int().positive(),
   observations: z.number().int().nonnegative(),
   lastStates: z.array(z.string().max(32)).max(16),
-  elapsedMs: z.number().int().nonnegative()
+  elapsedMs: z.number().int().nonnegative(),
+  reason: z.string().max(32).optional()
 });
 var observations = new WeakMap;
 
@@ -119,6 +123,12 @@ function processGroups(timeoutMs) {
     });
   });
 }
+function observationFailureReason(cause) {
+  if (!(cause instanceof Error))
+    return "unknown";
+  const signal = "signal" in cause && typeof cause.signal === "string" ? cause.signal : undefined;
+  return (errnoOf(cause) ?? signal ?? cause.name).slice(0, 32);
+}
 async function waitForProcessGroupExit(pid, deadline, killLiveMembers) {
   if (pid === undefined)
     return;
@@ -155,7 +165,7 @@ async function waitForProcessGroupExit(pid, deadline, killLiveMembers) {
   } catch (cause) {
     if (cause instanceof GroupSettlementError)
       throw cause;
-    throw new GroupSettlementError("Could not observe command process group settlement", { ...observation(), failure: "observation" }, cause);
+    throw new GroupSettlementError("Could not observe command process group settlement", { ...observation(), failure: "observation", reason: observationFailureReason(cause) }, cause);
   }
 }
 
@@ -185,7 +195,7 @@ function deniedOnDarwin(error) {
   return process.platform === "darwin" && error instanceof Error && "code" in error && error.code === "EPERM";
 }
 function isErrno(error, code) {
-  return error instanceof Error && "code" in error && error.code === code;
+  return errnoOf(error) === code;
 }
 function signalGroup(pid, signal) {
   if (pid === undefined)

package/dist/{index-84bf5spd.js → index-f6m4c545.js}

@@ -1,3 +1,6 @@
+import {
+  errnoOf
+} from "./index-jj9228tt.js";
 import {
   MAX_TIMER_MS
 } from "./index-eemvahkc.js";
@@ -177,7 +180,7 @@ function abortOwnerLossLaunch(pid) {
   try {
     process.kill(-pid, "SIGKILL");
   } catch (error) {
-    if (!(error instanceof Error && ("code" in error) && error.code === "ESRCH"))
+    if (errnoOf(error) !== "ESRCH")
       throw error;
   }
 }
@@ -575,7 +578,7 @@ function runOwnerLossGuard(signalTarget, executable, args) {
         try {
           process.kill(targetPid, signal);
         } catch (error) {
-          if (!(error instanceof Error && ("code" in error) && error.code === "ESRCH"))
+          if (errnoOf(error) !== "ESRCH")
             throw error;
         }
       };

package/dist/{index-qj1sy4ep.js → index-fa435yq2.js}

@@ -19,7 +19,7 @@ import {
   appendEventIn,
   ArchiveProjectionSchema,
   createAgentRuntimeStore2
-} from "./index-a3462dqf.js";
+} from "./index-jq2ky8fw.js";
 import {
   AgentConversationPageSchema2,
   AgentConversationMessagePageSchema2

package/dist/{index-hy802jnr.js → index-fdk4r4r6.js}

@@ -1,15 +1,18 @@
 import {
   withExclusiveLock2
-} from "./index-6b3pcq5z.js";
+} from "./index-zqkz4af9.js";
 import {
   readBoundedFile
 } from "./index-m616f0yz.js";
 import {
   writeAtomicFileData
-} from "./index-07dcf2yn.js";
+} from "./index-ac6vvm30.js";
 import {
   publishAtomicFile
 } from "./index-b56nnscm.js";
+import {
+  errnoOf
+} from "./index-jj9228tt.js";
 import {
   assertPositiveSafeInteger
 } from "./index-0s4xebbg.js";
@@ -21,7 +24,7 @@ var NATIVE_IO = { write: writeAtomicFileData, lock: withExclusiveLock2 };
 var DEFAULT_MAX_BYTES = 64 * 1024 * 1024;
 var encode = (state) => `${JSON.stringify(state)}
 `;
-var missing = (error) => error instanceof Error && ("code" in error) && error.code === "ENOENT";
+var missing = (error) => errnoOf(error) === "ENOENT";
 function createFileStateStore2(path, options) {
   return createFileStateStoreOn(path, options, NATIVE_IO);
 }

package/dist/index-jj9228tt.js

@@ -0,0 +1,6 @@
+// src/internal/errno.ts
+function errnoOf(error) {
+  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : undefined;
+}
+
+export { errnoOf };

package/dist/{index-a3462dqf.js → index-jq2ky8fw.js}

@@ -4,7 +4,7 @@ import {
   AgentSandboxRestrictionSchema2,
   AgentSandboxGradeSchema2,
   AGENT_CODING_TOOL_NAMES
-} from "./index-s47ac8zt.js";
+} from "./index-n5sv4z0w.js";
 import {
   AgentRecordIdSchema2,
   AgentRecordVersionSchema2,