stitchkit 0.93.0 → 0.94.1

package/dist/index-px2gm2jp.js

@@ -0,0 +1,448 @@
+// src/agent-runtime/contained-scan.ts
+import path3 from "node:path";
+
+// src/agent-runtime/contained-files.ts
+import { constants } from "node:fs";
+import { lstat, mkdir, open, readdir, realpath } from "node:fs/promises";
+import path2 from "node:path";
+
+// src/agent-runtime/contained-darwin.ts
+import {
+  close as closeDescriptor,
+  existsSync,
+  fstat,
+  read as readDescriptor
+} from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+var FILE_TYPE_MASK = 61440;
+var FILE_TYPE_DIRECTORY = 16384;
+var FILE_TYPE_REGULAR = 32768;
+var FILE_TYPE_SYMLINK = 40960;
+function modeIs(mode, type) {
+  return (mode & FILE_TYPE_MASK) === type;
+}
+function hasFunctions(value, names) {
+  return typeof value === "object" && value !== null && names.every((name) => typeof Reflect.get(value, name) === "function");
+}
+var darwinBinding;
+function loadDarwinBinding() {
+  if (darwinBinding)
+    return darwinBinding;
+  const directory = path.dirname(fileURLToPath(import.meta.url));
+  const binary = `darwin-${process.arch}.node`;
+  const candidates = [
+    path.resolve(directory, "../native", binary),
+    path.resolve(directory, "../../native", binary)
+  ];
+  const selected = candidates.find((candidate) => existsSync(candidate));
+  if (!selected) {
+    throw new Error(`Contained filesystem operations need the packaged Darwin ${process.arch} backend`);
+  }
+  const loaded = createRequire(import.meta.url)(selected);
+  const methods = [
+    "openDirectoryAt",
+    "openFileAt",
+    "createFileAt",
+    "createDirectoryAt",
+    "statAt",
+    "listAt",
+    "renameAt",
+    "unlinkAt"
+  ];
+  if (!hasFunctions(loaded, methods)) {
+    throw new Error("The packaged Darwin contained-files backend has an invalid surface");
+  }
+  darwinBinding = loaded;
+  return darwinBinding;
+}
+
+class NumericFileHandle {
+  fd;
+  constructor(fd) {
+    this.fd = fd;
+  }
+  close() {
+    return new Promise((resolve, reject) => {
+      closeDescriptor(this.fd, (error) => error ? reject(error) : resolve());
+    });
+  }
+  read(buffer, offset, length, position) {
+    return new Promise((resolve, reject) => {
+      readDescriptor(this.fd, buffer, offset, length, position, (error, bytesRead) => error ? reject(error) : resolve({ bytesRead }));
+    });
+  }
+  stat() {
+    return new Promise((resolve, reject) => {
+      fstat(this.fd, (error, metadata) => error ? reject(error) : resolve(metadata));
+    });
+  }
+}
+
+// src/agent-runtime/contained-files.ts
+function containedEntryKind(entry) {
+  return entry.isDirectory() ? "directory" : entry.isSymbolicLink() ? "symlink" : entry.isFile() ? "file" : "other";
+}
+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");
+}
+function sameIdentity(left, right) {
+  return left.dev === right.dev && left.ino === right.ino;
+}
+async function openPinnedDirectory(absolute) {
+  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);
+  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");
+    }
+    return handle;
+  } catch (error) {
+    await handle.close();
+    throw error;
+  }
+}
+function safeSegments(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 === "..")) {
+    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(path2.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(path2.join(descriptorPath(directory), name), constants.O_RDONLY | constants.O_NOFOLLOW);
+}
+function entryMetadata(mode, size) {
+  return {
+    mode,
+    ...size !== undefined && { size },
+    isDirectory: () => modeIs(mode, FILE_TYPE_DIRECTORY),
+    isFile: () => modeIs(mode, FILE_TYPE_REGULAR),
+    isSymbolicLink: () => modeIs(mode, FILE_TYPE_SYMLINK)
+  };
+}
+async function statAt(directory, name) {
+  if (process.platform === "darwin") {
+    const metadata = loadDarwinBinding().statAt(directory.fd, name);
+    return metadata ? entryMetadata(metadata.mode, metadata.size) : null;
+  }
+  return lstat(path2.join(descriptorPath(directory), name)).catch((error) => {
+    if (error.code === "ENOENT")
+      return null;
+    throw error;
+  });
+}
+async function listAt(directory) {
+  if (process.platform === "darwin") {
+    return loadDarwinBinding().listAt(directory.fd).map(({ name, mode }) => ({ name, ...entryMetadata(mode) }));
+  }
+  return readdir(descriptorPath(directory), { withFileTypes: true });
+}
+async function listContainedDirectory(root, relative, maxEntries, authorizePath) {
+  let current = await openPinnedDirectory(root);
+  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;
+      }
+    }
+    const raw = [...await listAt(current)];
+    raw.sort((left, right) => left.name.localeCompare(right.name));
+    const admitted = [];
+    const denied = [];
+    for (const entry of raw) {
+      const entryPath = relative === "." ? entry.name : path2.join(relative, entry.name);
+      if (authorizePath && !await authorizePath(entryPath)) {
+        denied.push({ name: entry.name, kind: containedEntryKind(entry) });
+        continue;
+      }
+      admitted.push(entry);
+    }
+    const entries = [];
+    for (const entry of admitted.slice(0, maxEntries)) {
+      const kind = containedEntryKind(entry);
+      if (kind !== "file") {
+        entries.push({ name: entry.name, kind });
+        continue;
+      }
+      const metadata = await statAt(current, entry.name);
+      entries.push({
+        name: entry.name,
+        kind,
+        ...metadata && { bytes: metadata.size }
+      });
+    }
+    entries.sort((left, right) => {
+      if (left.kind === right.kind)
+        return left.name.localeCompare(right.name);
+      return left.kind === "directory" ? -1 : right.kind === "directory" ? 1 : 0;
+    });
+    return {
+      entries,
+      truncated: admitted.length > maxEntries,
+      denied: denied.slice(0, maxEntries),
+      deniedTruncated: denied.length > maxEntries
+    };
+  } finally {
+    await current.close();
+  }
+}
+async function createDirectoryAt(directory, name) {
+  if (process.platform === "darwin") {
+    return loadDarwinBinding().createDirectoryAt(directory.fd, name, 511);
+  }
+  try {
+    await mkdir(path2.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();
+  const missing = [];
+  let current = await openPinnedDirectory(root);
+  try {
+    let walked = [];
+    for (const segment of segments) {
+      walked = [...walked, segment];
+      if (missing.length > 0) {
+        missing.push(walked.join(path2.sep));
+        continue;
+      }
+      const next = await openDirectoryAt(current, segment).catch((error) => {
+        if (error.code === "ENOENT")
+          return null;
+        throw error;
+      });
+      if (!next) {
+        missing.push(walked.join(path2.sep));
+        continue;
+      }
+      await current.close();
+      current = next;
+    }
+    return missing;
+  } finally {
+    await current.close();
+  }
+}
+async function openContainedParent(root, relative, options = {}) {
+  const segments = safeSegments(relative);
+  const basename = segments.pop();
+  if (!basename)
+    throw new Error("Contained path is missing a basename");
+  let current = await openPinnedDirectory(root);
+  try {
+    for (const segment of segments) {
+      if (options.create)
+        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 { handle: current, basename };
+  } catch (error) {
+    await current.close();
+    throw error;
+  }
+}
+async function openContainedFile(root, relative) {
+  const parent = await openContainedParent(root, relative);
+  try {
+    const handle = await openFileAt(parent.handle, parent.basename);
+    const metadata = await handle.stat();
+    if (!metadata.isFile()) {
+      await handle.close();
+      throw new Error("Contained path is not a regular file");
+    }
+    return handle;
+  } finally {
+    await parent.handle.close();
+  }
+}
+async function assertContainedFileCurrent(root, relative, expected) {
+  const current = await openContainedFile(root, relative);
+  try {
+    if (!sameIdentity(await expected.stat(), await current.stat())) {
+      throw new Error("Contained file identity changed during authorization");
+    }
+  } finally {
+    await current.close();
+  }
+}
+async function assertContainedParentCurrent(root, relative, expected) {
+  const current = await openContainedParent(root, relative);
+  try {
+    if (!sameIdentity(await expected.stat(), await current.handle.stat())) {
+      throw new Error("Contained parent identity changed during authorization");
+    }
+  } finally {
+    await current.handle.close();
+  }
+}
+async function containedEntryMetadata(parent) {
+  return statAt(parent.handle, parent.basename);
+}
+async function openContainedParentFile(parent) {
+  const handle = await openFileAt(parent.handle, parent.basename);
+  if (!(await handle.stat()).isFile()) {
+    await handle.close();
+    throw new Error("Contained path is not a regular file");
+  }
+  return handle;
+}
+async function readContainedUtf8Handle(handle, maxBytes) {
+  const metadata = await handle.stat();
+  if (!metadata.isFile())
+    throw new Error("Contained path is not a regular file");
+  if (metadata.size > maxBytes)
+    throw new Error("Contained file exceeds byte budget");
+  const buffer = Buffer.alloc(metadata.size);
+  let offset = 0;
+  while (offset < buffer.byteLength) {
+    const { bytesRead } = await handle.read(buffer, offset, buffer.byteLength - offset, offset);
+    if (bytesRead === 0)
+      break;
+    offset += bytesRead;
+  }
+  if (offset !== metadata.size)
+    throw new Error("Contained file changed while being read");
+  return {
+    text: new TextDecoder("utf-8", { fatal: true }).decode(buffer),
+    bytes: offset,
+    mode: metadata.mode
+  };
+}
+
+// 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 ? path3.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 { loadDarwinBinding, NumericFileHandle, descriptorPath, listContainedDirectory, missingContainedDirectories, openContainedParent, openContainedFile, assertContainedFileCurrent, assertContainedParentCurrent, containedEntryMetadata, openContainedParentFile, readContainedUtf8Handle, walkContainedFiles, scanContainedFiles };

package/dist/index-qwhynv6x.js

@@ -0,0 +1,103 @@
+import {
+  isRecord
+} from "./index-hffjpmq9.js";
+
+// src/application/diagnostic-journal-contract.ts
+import { z } from "zod";
+var PositiveSafeIntegerSchema = z.number().int().positive().safe();
+var FileModeSchema = z.number().int().min(0).max(511);
+var DiagnosticJournalLimitsSchema = z.object({
+  maxEventBytes: PositiveSafeIntegerSchema,
+  maxPendingItems: PositiveSafeIntegerSchema,
+  maxPendingBytes: PositiveSafeIntegerSchema,
+  maxFileBytes: PositiveSafeIntegerSchema,
+  maxFiles: PositiveSafeIntegerSchema
+}).strict().readonly();
+var DiagnosticJournalLockPolicySchema = z.enum(["refuse", "reclaim-stale"]);
+var DiagnosticJournalStateSchema = z.enum(["open", "draining", "closed", "failed"]);
+var DiagnosticJournalRefusalReasonSchema = z.enum([
+  "closed",
+  "failed",
+  "invalid",
+  "oversized",
+  "item-capacity",
+  "byte-capacity"
+]);
+var DiagnosticJournalRefusalCountersSchema = z.object({
+  closed: z.number().int().nonnegative(),
+  failed: z.number().int().nonnegative(),
+  invalid: z.number().int().nonnegative(),
+  oversized: z.number().int().nonnegative(),
+  "item-capacity": z.number().int().nonnegative(),
+  "byte-capacity": z.number().int().nonnegative()
+}).strict().readonly();
+var DiagnosticJournalFailurePhaseSchema = z.enum(["write", "rotation", "close"]);
+var DiagnosticJournalStatusSchema = z.object({
+  state: DiagnosticJournalStateSchema,
+  epoch: z.uuid(),
+  limits: DiagnosticJournalLimitsSchema,
+  lock: z.object({
+    policy: DiagnosticJournalLockPolicySchema,
+    reclaimedStale: z.boolean()
+  }).strict().readonly(),
+  received: z.number().int().nonnegative(),
+  accepted: z.number().int().nonnegative(),
+  refused: z.number().int().nonnegative(),
+  refusals: DiagnosticJournalRefusalCountersSchema,
+  written: z.number().int().nonnegative(),
+  failedRecords: z.number().int().nonnegative(),
+  pendingItems: z.number().int().nonnegative(),
+  pendingBytes: z.number().int().nonnegative(),
+  inFlight: z.boolean(),
+  rotations: z.number().int().nonnegative(),
+  rotationFailures: z.number().int().nonnegative(),
+  partialTails: z.number().int().nonnegative(),
+  currentFileBytes: z.number().int().nonnegative(),
+  retainedFiles: z.number().int().nonnegative(),
+  lastAcceptedSequence: z.number().int().positive().optional(),
+  lastWrittenSequence: z.number().int().positive().optional(),
+  lastSettledSequence: z.number().int().positive().optional(),
+  lastFailure: z.object({
+    phase: DiagnosticJournalFailurePhaseSchema,
+    sequence: z.number().int().positive().optional()
+  }).strict().readonly().optional()
+}).strict().readonly();
+var DiagnosticJournalSubmitResultSchema = z.discriminatedUnion("outcome", [
+  z.object({
+    outcome: z.literal("accepted"),
+    epoch: z.uuid(),
+    sequence: z.number().int().positive()
+  }).strict().readonly(),
+  z.object({
+    outcome: z.literal("refused"),
+    reason: DiagnosticJournalRefusalReasonSchema
+  }).strict().readonly()
+]);
+var DiagnosticJournalWaitResultSchema = z.object({
+  outcome: z.enum(["settled", "timed-out", "cancelled"]),
+  state: DiagnosticJournalStateSchema,
+  throughSequence: z.number().int().nonnegative(),
+  settledSequence: z.number().int().nonnegative()
+}).strict().readonly();
+var DiagnosticJournalCloseResultSchema = z.object({
+  outcome: z.enum(["closed", "timed-out", "cancelled"]),
+  state: DiagnosticJournalStateSchema,
+  pendingItems: z.number().int().nonnegative()
+}).strict().readonly();
+var DiagnosticJournalFrameSchema = z.object({
+  schemaVersion: z.literal(1),
+  epoch: z.uuid(),
+  sequence: z.number().int().positive(),
+  event: z.json()
+}).strict().readonly();
+function parseDiagnosticJournalMode(mode) {
+  return FileModeSchema.parse(mode ?? 384);
+}
+function readDiagnosticJournalLockDiagnosis(error) {
+  if (!isRecord(error))
+    return;
+  const diagnosis = error.journalLock;
+  return isRecord(diagnosis) ? diagnosis : undefined;
+}
+
+export { DiagnosticJournalLimitsSchema, DiagnosticJournalLockPolicySchema, DiagnosticJournalStateSchema, DiagnosticJournalRefusalReasonSchema, DiagnosticJournalFailurePhaseSchema, DiagnosticJournalStatusSchema, DiagnosticJournalSubmitResultSchema, DiagnosticJournalWaitResultSchema, DiagnosticJournalCloseResultSchema, DiagnosticJournalFrameSchema, parseDiagnosticJournalMode, readDiagnosticJournalLockDiagnosis };

package/dist/index-s812ycat.js

@@ -0,0 +1,65 @@
+// src/internal/atomic-file.ts
+import { randomBytes } from "node:crypto";
+import {
+  closeSync,
+  fchmodSync,
+  fsyncSync,
+  openSync,
+  renameSync,
+  unlinkSync,
+  writeSync
+} from "node:fs";
+import { open, rename, unlink } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+var DEFAULT_MODE = 384;
+function stagingPath(target) {
+  return join(dirname(target), `.${basename(target)}.${randomBytes(12).toString("hex")}.tmp`);
+}
+function bytesOf(data) {
+  return typeof data === "string" ? new TextEncoder().encode(data) : data;
+}
+async function writeFileAtomic(target, data, options = {}) {
+  const mode = options.mode ?? DEFAULT_MODE;
+  const staged = stagingPath(target);
+  const handle = await open(staged, "wx", mode);
+  try {
+    try {
+      await handle.writeFile(bytesOf(data));
+      await handle.chmod(mode);
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    await rename(staged, target);
+  } catch (error) {
+    await unlink(staged).catch(() => {
+      return;
+    });
+    throw error;
+  }
+}
+function writeFileAtomicSync(target, data, options = {}) {
+  const mode = options.mode ?? DEFAULT_MODE;
+  const bytes = bytesOf(data);
+  const staged = stagingPath(target);
+  const handle = openSync(staged, "wx", mode);
+  try {
+    try {
+      for (let offset = 0;offset < bytes.byteLength; ) {
+        offset += writeSync(handle, bytes, offset, bytes.byteLength - offset);
+      }
+      fchmodSync(handle, mode);
+      fsyncSync(handle);
+    } finally {
+      closeSync(handle);
+    }
+    renameSync(staged, target);
+  } catch (error) {
+    try {
+      unlinkSync(staged);
+    } catch {}
+    throw error;
+  }
+}
+
+export { writeFileAtomic, writeFileAtomicSync };