stitchkit 0.93.0 → 0.94.1

package/dist/index-bn2cjajt.js

@@ -1,524 +0,0 @@
-// src/agent-runtime/contained-files.ts
-import {
-  close as closeDescriptor,
-  constants,
-  existsSync,
-  fchmod,
-  fstat,
-  read as readDescriptor,
-  write as writeDescriptor
-} from "node:fs";
-import {
-  lstat,
-  mkdir,
-  open,
-  readdir,
-  realpath,
-  rename,
-  unlink,
-  writeFile
-} from "node:fs/promises";
-import { createRequire } from "node:module";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-function containedEntryKind(entry) {
-  return entry.isDirectory() ? "directory" : entry.isSymbolicLink() ? "symlink" : entry.isFile() ? "file" : "other";
-}
-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));
-    });
-  }
-}
-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 (path.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(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);
-}
-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(path.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 : path.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(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();
-  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(path.sep));
-        continue;
-      }
-      const next = await openDirectoryAt(current, segment).catch((error) => {
-        if (error.code === "ENOENT")
-          return null;
-        throw error;
-      });
-      if (!next) {
-        missing.push(walked.join(path.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 writeDescriptorFully(descriptor, content) {
-  const bytes = Buffer.from(content);
-  let offset = 0;
-  while (offset < bytes.byteLength) {
-    const written = await new Promise((resolve, reject) => {
-      writeDescriptor(descriptor, bytes, offset, bytes.byteLength - offset, null, (error, bytesWritten) => error ? reject(error) : resolve(bytesWritten));
-    });
-    if (written === 0)
-      throw new Error("Contained file write made no progress");
-    offset += written;
-  }
-}
-async function chmodDescriptor(descriptor, mode) {
-  await new Promise((resolve, reject) => {
-    fchmod(descriptor, mode & 4095, (error) => error ? reject(error) : resolve());
-  });
-}
-async function createDarwinFile(parent, name, content, mode) {
-  const binding = loadDarwinBinding();
-  const descriptor = binding.createFileAt(parent.fd, name, mode & 4095);
-  let failed;
-  try {
-    await writeDescriptorFully(descriptor, content);
-    await chmodDescriptor(descriptor, mode);
-  } catch (error) {
-    failed = error;
-  } finally {
-    try {
-      await new NumericFileHandle(descriptor).close();
-    } catch (error) {
-      failed ??= error;
-    }
-  }
-  if (failed) {
-    binding.unlinkAt(parent.fd, name);
-    throw failed;
-  }
-}
-async function writeContainedFile(input) {
-  const mode = input.mode ?? 438;
-  if (!input.replace) {
-    if (process.platform === "darwin") {
-      await createDarwinFile(input.parent.handle, input.parent.basename, input.content, mode);
-      return;
-    }
-    await writeFile(path.join(descriptorPath(input.parent.handle), input.parent.basename), input.content, { flag: "wx", mode });
-    return;
-  }
-  const temporary = `.${input.parent.basename}.${process.pid}.${crypto.randomUUID()}.tmp`;
-  if (process.platform === "darwin") {
-    const binding = loadDarwinBinding();
-    let created = false;
-    try {
-      await createDarwinFile(input.parent.handle, temporary, input.content, mode);
-      created = true;
-      binding.renameAt(input.parent.handle.fd, temporary, input.parent.basename);
-    } catch (error) {
-      if (created)
-        binding.unlinkAt(input.parent.handle.fd, temporary);
-      throw error;
-    }
-    return;
-  }
-  const directory = descriptorPath(input.parent.handle);
-  const temporaryPath = path.join(directory, temporary);
-  try {
-    await writeFile(temporaryPath, input.content, { flag: "wx", mode });
-    await rename(temporaryPath, path.join(directory, input.parent.basename));
-  } catch (error) {
-    await unlink(temporaryPath).catch(() => {
-      return;
-    });
-    throw error;
-  }
-}
-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
-  };
-}
-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 ? path.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 { listContainedDirectory, missingContainedDirectories, openContainedParent, openContainedFile, assertContainedFileCurrent, assertContainedParentCurrent, writeContainedFile, containedEntryMetadata, openContainedParentFile, readContainedUtf8Handle, walkContainedFiles, scanContainedFiles };

package/dist/index-bx75zwt7.js

@@ -1,63 +0,0 @@
-import {
-  collectTools,
-  createToolRunner
-} from "./index-mzvgxp0n.js";
-import {
-  toolErrorFromResult
-} from "./index-yn8remb1.js";
-import {
-  assertUniqueToolName
-} from "./index-h9etkkyk.js";
-import {
-  AppError
-} from "./index-2vtcmrj9.js";
-
-// src/tools/invoker.ts
-function createToolInvoker(services, config) {
-  const serviceList = Array.isArray(services) ? services : [services];
-  const tools = new Map;
-  for (const service of serviceList) {
-    for (const tool of collectTools(service, config.transport, {
-      extend: config.extend,
-      flattenUnionInput: config.flattenUnionInput
-    })) {
-      assertUniqueToolName(tool.name, tools.has(tool.name), "in-process tool name");
-      tools.set(tool.name, tool);
-    }
-  }
-  const names = Object.freeze([...tools.keys()].sort());
-  const operation = (name) => {
-    const tool = tools.get(name);
-    if (tool)
-      return tool;
-    throw new AppError("NOT_FOUND", `Unknown tool: ${name}`, 404, {
-      available: names
-    });
-  };
-  const run = (name, args, options = {}) => {
-    const runTool = createToolRunner({
-      source: options.source ?? "internal",
-      context: options.context,
-      hooks: options.hooks,
-      lifecycle: options.lifecycle,
-      extend: config.extend,
-      coerceJsonArgs: config.coerceJsonArgs,
-      onOutputStrip: options.onOutputStrip
-    });
-    return runTool(operation(name), args);
-  };
-  return Object.freeze({
-    names,
-    invoke(name, args, options) {
-      return run(name, args, options);
-    },
-    async invokeOrThrow(name, args, options) {
-      const result = await run(name, args, options);
-      if (!result.ok)
-        throw toolErrorFromResult(result);
-      return result.data;
-    }
-  });
-}
-
-export { createToolInvoker };

package/dist/index-cby4ar3v.js

@@ -1,46 +0,0 @@
-// src/tools/json-schema.ts
-import { z } from "zod";
-function toJsonSchema(schema, io, unrepresentable = "throw", target = "draft-2020-12") {
-  return z.toJSONSchema(schema, {
-    io,
-    target,
-    unrepresentable,
-    cycles: "ref"
-  });
-}
-function isObjectNode(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function jsonSchemaFields(jsonSchema) {
-  const properties = jsonSchema.properties;
-  if (!isObjectNode(properties)) {
-    const conjunctive = Array.isArray(jsonSchema.allOf);
-    const members = conjunctive ? jsonSchema.allOf : Array.isArray(jsonSchema.oneOf) ? jsonSchema.oneOf : Array.isArray(jsonSchema.anyOf) ? jsonSchema.anyOf : [];
-    const byName = new Map;
-    for (const member of Array.isArray(members) ? members : []) {
-      if (!isObjectNode(member))
-        continue;
-      for (const field of jsonSchemaFields(member)) {
-        const existing = byName.get(field.name);
-        const required2 = existing ? conjunctive ? existing.required || field.required : existing.required && field.required : field.required;
-        byName.set(field.name, existing ? { ...field, required: required2 } : field);
-      }
-    }
-    return [...byName.values()];
-  }
-  const required = new Set(Array.isArray(jsonSchema.required) ? jsonSchema.required.filter((k) => typeof k === "string") : []);
-  const fields = [];
-  for (const [name, raw] of Object.entries(properties)) {
-    const schema = isObjectNode(raw) ? raw : {};
-    const description = typeof schema.description === "string" ? schema.description : undefined;
-    fields.push({
-      name,
-      schema,
-      required: required.has(name),
-      ...description && { description }
-    });
-  }
-  return fields;
-}
-
-export { toJsonSchema, jsonSchemaFields };

package/dist/index-cnyk6te3.js

@@ -1,77 +0,0 @@
-// src/agent-runtime/testing.ts
-function createAgentRaceBarrier(timeoutMs = 5000) {
-  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1) {
-    throw new TypeError("Agent race barrier timeoutMs must be a positive safe integer");
-  }
-  const reached = Promise.withResolvers();
-  const released = Promise.withResolvers();
-  let announced = false;
-  return {
-    reached: reached.promise,
-    async wait() {
-      if (!announced) {
-        announced = true;
-        reached.resolve();
-      }
-      let timer;
-      try {
-        await Promise.race([
-          released.promise,
-          new Promise((_resolve, reject) => {
-            timer = setTimeout(() => reject(new Error(`Agent race barrier exceeded ${timeoutMs}ms teardown bound`)), timeoutMs);
-          })
-        ]);
-      } finally {
-        if (timer !== undefined)
-          clearTimeout(timer);
-      }
-    },
-    release: released.resolve
-  };
-}
-function createAgentRaceTrace() {
-  const recorded = [];
-  return {
-    record(name) {
-      const entry = { name, sequence: recorded.length };
-      recorded.push(entry);
-      return entry;
-    },
-    entries: () => recorded.map((entry) => ({ ...entry })),
-    assertBefore(first, second) {
-      const firstEntry = recorded.find((entry) => entry.name === first);
-      const secondEntry = recorded.find((entry) => entry.name === second);
-      if (!firstEntry || !secondEntry || firstEntry.sequence >= secondEntry.sequence) {
-        throw new Error(`Expected ${first} before ${second}`);
-      }
-    },
-    assertSequence(names) {
-      const actual = recorded.map((entry) => entry.name);
-      if (actual.length !== names.length || actual.some((name, index) => name !== names[index])) {
-        throw new Error(`Expected trace ${names.join(" -> ")}, received ${actual.join(" -> ")}`);
-      }
-    },
-    count: (name) => recorded.filter((entry) => entry.name === name).length
-  };
-}
-function createAgentRaceDriver(timeoutMs = 5000) {
-  const trace = createAgentRaceTrace();
-  const barriers = new Map;
-  return {
-    trace,
-    barrier(name) {
-      const existing = barriers.get(name);
-      if (existing)
-        return existing;
-      const created = createAgentRaceBarrier(timeoutMs);
-      barriers.set(name, created);
-      return created;
-    },
-    releaseAll() {
-      for (const barrier of barriers.values())
-        barrier.release();
-    }
-  };
-}
-
-export { createAgentRaceBarrier, createAgentRaceTrace, createAgentRaceDriver };