poe-code 8.0.0 → 8.0.1

package/packages/safejs/dist/index.js

@@ -1,30 +1,1072 @@
-export { parse } from "./parse.js";
-export { parseModule } from "./parse/parser.js";
-export { lint } from "./lint.js";
-export { run } from "./run.js";
-export { createReplayableRandom } from "./random.js";
-export { noopOtelSink } from "./observability/otel.js";
-export { FileSnapshotBackend } from "./snapshot/backend.js";
-export { declareHostOperation } from "./interp/host-bridge.js";
-export { HostCallResumabilityError } from "./interp/host-call.js";
-export { HostOperationResumePolicyError, registerPendingHostCallPolicy } from "./snapshot/policy.js";
-export { dump } from "./dump.js";
-export { restore } from "./restore.js";
-export { SnapshotValidationError } from "./snapshot/validation.js";
-export { Budget, SandboxError } from "./interp/budget.js";
-export { formatInterpreterError } from "./error/format.js";
-export { deepCopyFromSandbox, deepCopyToSandbox } from "./interp/values.js";
-export { runHarness, runHarnessPair } from "./runner/run-harness.js";
-export { extractBlock } from "./loader/extract-block.js";
-export { findExportedConstInitializer } from "./loader/find-exported.js";
-export { splitFrontmatter } from "./loader/frontmatter.js";
-export { AgentSpawnError, createSpawnUsageAccumulator, makeAgentModule, runWithSpawnUsageAccumulator } from "./modules/agent.js";
-export { makeEnvModule } from "./modules/env.js";
-export { makeFailModule } from "./modules/fail.js";
-export { makeFsModule } from "./modules/fs.js";
-export { makeGitModule } from "./modules/git.js";
-export { makeHarnessModule } from "./modules/harness.js";
-export { makeLogModule } from "./modules/log.js";
-export { makeMetricModule } from "./modules/metric.js";
-export { makeMcpModule } from "./modules/mcp.js";
-export { makeTimeModule } from "./modules/time.js";
+import {
+  AgentSpawnError,
+  SPAWN_MODES,
+  containsPath,
+  countLineBreaks,
+  createLintModulesFromRuntimeRegistry,
+  createSpawnUsageAccumulator,
+  extractBlock,
+  formatInterpreterError,
+  isSamePath,
+  makeAgentModule,
+  makeFailModule,
+  makeFsModule,
+  makeHarnessModule,
+  makeLogModule,
+  makeMetricModule,
+  resolveCanonicalPath,
+  runWithSpawnUsageAccumulator,
+  splitFrontmatter,
+  supportsSpawnMode
+} from "./chunks/chunk-AVDRLE3Y.js";
+import {
+  Budget,
+  FileSnapshotBackend,
+  HostCallResumabilityError,
+  HostOperationResumePolicyError,
+  SandboxError,
+  SnapshotValidationError,
+  createReplayableRandom,
+  createSeededRandom,
+  declareHostOperation,
+  deepCopyFromSandbox,
+  deepCopyToSandbox,
+  dump,
+  hasOwnErrorCode,
+  lint,
+  noopOtelSink,
+  parse,
+  parseModule,
+  registerPendingHostCallPolicy,
+  restore,
+  run
+} from "./chunks/chunk-ME5BTAZT.js";
+
+// packages/safejs/src/runner/run-harness.ts
+import { readFile, stat } from "node:fs/promises";
+import { extname } from "node:path";
+function getOwnEntry(record, key) {
+  return Object.prototype.hasOwnProperty.call(record, key) ? record[key] : void 0;
+}
+function createHarnessMeta(filepath, frontmatter) {
+  return {
+    filepath,
+    kind: getOwnEntry(frontmatter, "kind"),
+    version: getOwnEntry(frontmatter, "version")
+  };
+}
+function assertFrontmatterAgentModes(frontmatter) {
+  const agents = getOwnEntry(frontmatter, "agents");
+  if (typeof agents !== "object" || agents === null || Array.isArray(agents)) {
+    return;
+  }
+  for (const [name, definition] of Object.entries(agents)) {
+    if (typeof definition !== "object" || definition === null || Array.isArray(definition)) {
+      continue;
+    }
+    const record = definition;
+    const agent = getOwnEntry(record, "agent");
+    const mode = getOwnEntry(record, "mode");
+    if (typeof agent !== "string" || typeof mode !== "string") {
+      continue;
+    }
+    if (!SPAWN_MODES.includes(mode)) {
+      continue;
+    }
+    if (!supportsSpawnMode(agent, mode)) {
+      throw new Error(`Harness agent "${name}": agent "${agent}" does not support mode "${mode}".`);
+    }
+  }
+}
+var LintError = class extends Error {
+  diagnostics;
+  constructor(diagnostics) {
+    super(formatLintErrorMessage(diagnostics));
+    this.name = "LintError";
+    this.diagnostics = diagnostics;
+  }
+};
+async function runHarness(filepath, options) {
+  const rawSource = stripByteOrderMark(await readHarnessFile(filepath));
+  const { executableSource, frontmatter, isRawScript } = loadExecutableSource(filepath, rawSource);
+  assertFrontmatterAgentModes(frontmatter);
+  const meta = createHarnessMeta(filepath, frontmatter);
+  const modules = excludeHarnessModule(options.modulesFor(frontmatter, meta), isRawScript);
+  const diagnostics = lint(executableSource, {
+    filename: filepath,
+    modules: createLintModulesFromRuntimeRegistry(modules)
+  });
+  const lintErrors = diagnostics.filter((diagnostic) => diagnostic.severity === "error");
+  if (lintErrors.length > 0) {
+    throw new LintError(lintErrors);
+  }
+  return runHarnessSource(executableSource, {
+    entryPointArgs: hasDefaultExport(executableSource, filepath) ? [] : void 0,
+    filename: filepath,
+    modules,
+    otelSink: options.otelSink,
+    signal: options.signal,
+    snapshotBackend: options.snapshotBackend,
+    snapshotIntervalMs: options.snapshotIntervalMs,
+    snapshotPath: options.snapshotPath
+  });
+}
+async function runHarnessPair(filepath, options) {
+  const pair = resolveHarnessPair(filepath);
+  const [rawMarkdown, rawScript] = await Promise.all([
+    readHarnessFile(pair.markdownPath),
+    readHarnessFile(pair.scriptPath)
+  ]);
+  const { frontmatter, body } = splitFrontmatter(stripByteOrderMark(rawMarkdown));
+  assertFrontmatterAgentModes(frontmatter);
+  const executableSource = stripByteOrderMark(rawScript);
+  const meta = createHarnessMeta(pair.markdownPath, frontmatter);
+  const modules = options.modulesFor(frontmatter, meta);
+  const diagnostics = lint(executableSource, {
+    allowedExportNames: ["schema"],
+    defaultExport: {
+      parameters: ["frontmatter"],
+      required: true
+    },
+    filename: pair.scriptPath,
+    frontmatterFields: Object.keys(frontmatter),
+    modules: createLintModulesFromRuntimeRegistry(modules)
+  });
+  const lintErrors = diagnostics.filter((diagnostic) => diagnostic.severity === "error");
+  if (lintErrors.length > 0) {
+    throw new LintError(lintErrors);
+  }
+  return runHarnessSource(executableSource, {
+    entryPointArgs: [frontmatter],
+    filename: pair.scriptPath,
+    importMeta: {
+      body,
+      filepath: pair.markdownPath,
+      kind: meta.kind,
+      version: meta.version
+    },
+    modules,
+    otelSink: options.otelSink,
+    signal: options.signal,
+    snapshotBackend: options.snapshotBackend,
+    snapshotIntervalMs: options.snapshotIntervalMs,
+    snapshotPath: options.snapshotPath
+  });
+}
+async function readHarnessFile(filepath) {
+  try {
+    const stats = await stat(filepath);
+    if (!stats.isFile()) {
+      throw new Error(`Harness path must point to a file: ${filepath}`);
+    }
+    return await readFile(filepath, "utf8");
+  } catch (error) {
+    if (hasOwnErrorCode(error, "ENOENT") || hasOwnErrorCode(error, "ENOTDIR")) {
+      throw new Error(`Harness file not found: ${filepath}`);
+    }
+    throw error;
+  }
+}
+function loadExecutableSource(filepath, source) {
+  if (isRawScriptPath(filepath)) {
+    if (source.length === 0) {
+      throw new Error(`No code block found in empty harness file: ${filepath}`);
+    }
+    return {
+      executableSource: source,
+      frontmatter: {},
+      isRawScript: true
+    };
+  }
+  const { frontmatter, body } = splitFrontmatter(source);
+  if (source.length === 0 || body.trim().length === 0) {
+    throw new Error(`No code block found in empty harness file: ${filepath}`);
+  }
+  const bodyStartOffset = source.length - body.length;
+  const { source: executableBlock, startOffset } = extractBlock(
+    body,
+    countLineBreaks(source, 0, bodyStartOffset) + 1
+  );
+  const absoluteLineOffset = countLineBreaks(source, 0, bodyStartOffset + startOffset);
+  return {
+    executableSource: createLineOffsetSource(stripHashbang(executableBlock), absoluteLineOffset),
+    frontmatter,
+    isRawScript: false
+  };
+}
+function resolveHarnessPair(filepath) {
+  const extension = extname(filepath);
+  const basename = extension.length === 0 ? filepath : filepath.slice(0, -extension.length);
+  if (isRawScriptExtension(extension)) {
+    return {
+      markdownPath: `${basename}.md`,
+      scriptPath: filepath
+    };
+  }
+  return {
+    markdownPath: filepath,
+    scriptPath: `${basename}.ajs`
+  };
+}
+function isRawScriptPath(filepath) {
+  return isRawScriptExtension(extname(filepath));
+}
+function isRawScriptExtension(extension) {
+  return extension === ".safejs" || extension === ".ajs";
+}
+async function runHarnessSource(executableSource, options) {
+  try {
+    return await run(executableSource, options);
+  } catch (error) {
+    if (isSetupError(error)) {
+      throw error;
+    }
+    return {
+      ...isAbortError(error) ? { aborted: true } : {},
+      error,
+      ok: false
+    };
+  }
+}
+function isSetupError(error) {
+  return error instanceof Error && error.name === "ParseError";
+}
+function isAbortError(error) {
+  if (error instanceof Error) {
+    return error.name === "AbortError";
+  }
+  return typeof error === "object" && error !== null && Object.prototype.hasOwnProperty.call(error, "name") && error.name === "AbortError";
+}
+function hasDefaultExport(source, filename) {
+  return parseModule(source, filename).body.some(
+    (statement) => statement.type === "ExportDefaultDeclaration"
+  );
+}
+function excludeHarnessModule(modules, isRawScript) {
+  if (!isRawScript) {
+    return modules;
+  }
+  if (modules instanceof Map) {
+    const rawModules2 = new Map(modules);
+    rawModules2.delete("harness");
+    return rawModules2;
+  }
+  const rawModules = {};
+  for (const [moduleName, moduleExports] of Object.entries(modules)) {
+    if (moduleName !== "harness") {
+      rawModules[moduleName] = moduleExports;
+    }
+  }
+  return rawModules;
+}
+function stripByteOrderMark(source) {
+  return source.startsWith("\uFEFF") ? source.slice(1) : source;
+}
+function stripHashbang(source) {
+  if (!source.startsWith("#!")) {
+    return source;
+  }
+  let end = 2;
+  while (end < source.length && source[end] !== "\n" && source[end] !== "\r") end += 1;
+  return `${" ".repeat(end)}${source.slice(end)}`;
+}
+function createLineOffsetSource(source, lineOffset) {
+  return `${"\n".repeat(Math.max(lineOffset, 0))}${source}`;
+}
+function formatLintErrorMessage(diagnostics) {
+  if (diagnostics.length === 0) {
+    return "Script lint failed.";
+  }
+  return diagnostics.map(
+    (diagnostic) => `${diagnostic.filename}:${diagnostic.line}:${diagnostic.column} ${diagnostic.code} ${diagnostic.message}`
+  ).join("\n");
+}
+
+// packages/safejs/src/loader/find-exported.ts
+function findExportedConstInitializer(module, name) {
+  for (const statement of module.body) {
+    if (statement.type === "ExportDefaultDeclaration") {
+      if (name === "default") {
+        return statement.declaration;
+      }
+      continue;
+    }
+    if (statement.type !== "ExportNamedDeclaration") {
+      continue;
+    }
+    const declaration = statement.declaration;
+    if (declaration.kind !== "const") {
+      throw new Error(`Exported '${name}' must be declared with const.`);
+    }
+    if (declaration.declarations.length !== 1) {
+      throw new Error("Exported const declarations must contain exactly one declarator.");
+    }
+    const declarator = declaration.declarations[0];
+    if (declarator.id.type !== "Identifier") {
+      throw new Error("Destructured exported const bindings are not supported.");
+    }
+    if (declarator.id.name !== name) {
+      continue;
+    }
+    if (declarator.init === void 0) {
+      throw new Error(`Exported const '${name}' must have an initializer.`);
+    }
+    return declarator.init;
+  }
+  return void 0;
+}
+
+// packages/safejs/src/modules/env.ts
+function makeEnvModule(allowList) {
+  const allowedNames = normalizeAllowList(allowList);
+  return {
+    get(name) {
+      const normalizedName = readNonEmptyString(name, "Environment variable name");
+      if (!allowedNames.has(normalizedName)) {
+        return void 0;
+      }
+      return process.env[normalizedName];
+    }
+  };
+}
+function normalizeAllowList(allowList) {
+  if (!Array.isArray(allowList)) {
+    throw new Error("Environment allow list must be an array of non-empty strings.");
+  }
+  return new Set(
+    allowList.map((entry, index) => readNonEmptyString(entry, `Environment allow list[${index}]`))
+  );
+}
+function readNonEmptyString(value, label) {
+  if (typeof value !== "string") {
+    throw new Error(`${label} must be a non-empty string.`);
+  }
+  const normalizedValue = value.trim();
+  if (normalizedValue.length === 0) {
+    throw new Error(`${label} must be a non-empty string.`);
+  }
+  return normalizedValue;
+}
+
+// packages/safejs/src/modules/git.ts
+import { execFile } from "node:child_process";
+import { mkdir, readlink, realpath, rm, stat as stat2 } from "node:fs/promises";
+import { dirname, isAbsolute, resolve } from "node:path";
+var GIT_EXEC_MAX_BUFFER = 10 * 1024 * 1024;
+var SAVEPOINT_REF_PREFIX = "refs/poe-code/checkpoints/";
+function makeGitModule(cwd) {
+  const normalizedCwd = readNonEmptyString2(cwd, "Git module cwd");
+  return {
+    async head() {
+      return runGitAndTrim(normalizedCwd, ["rev-parse", "HEAD"]);
+    },
+    async checkpoint() {
+      const currentHead = await runGitAndTrim(normalizedCwd, ["rev-parse", "HEAD"]);
+      const status = await runGitAndTrim(normalizedCwd, ["status", "--porcelain"]);
+      if (status.length === 0) {
+        return {
+          head: currentHead
+        };
+      }
+      const stashRef = createSavepointRef();
+      const stashMessage = `poe-code checkpoint ${stashRef}`;
+      await runGit(normalizedCwd, [
+        "stash",
+        "push",
+        "--include-untracked",
+        "--message",
+        stashMessage
+      ]);
+      try {
+        const stashOid = await runGitAndTrim(normalizedCwd, ["rev-parse", "stash@{0}"]);
+        await runGit(normalizedCwd, ["update-ref", stashRef, stashOid]);
+        await runGit(normalizedCwd, ["stash", "apply", "--index", stashRef]);
+        await runGit(normalizedCwd, ["stash", "drop", "stash@{0}"]);
+        return {
+          head: currentHead,
+          stashRef
+        };
+      } catch (error) {
+        await cleanupFailedCheckpoint(normalizedCwd, stashRef);
+        throw error;
+      }
+    },
+    async commit(options) {
+      const normalizedOptions = normalizeCommitOptions(options);
+      if (normalizedOptions.files === void 0) {
+        await runGit(normalizedCwd, ["add", "--all"]);
+        await runGit(normalizedCwd, ["commit", "--message", normalizedOptions.message]);
+      } else {
+        await runGit(normalizedCwd, ["add", "--", ...normalizedOptions.files]);
+        await runGit(normalizedCwd, [
+          "commit",
+          "--message",
+          normalizedOptions.message,
+          "--",
+          ...normalizedOptions.files
+        ]);
+      }
+      return runGitAndTrim(normalizedCwd, ["rev-parse", "HEAD"]);
+    },
+    async revert(savepoint) {
+      const normalizedSavepoint = normalizeSavepoint(savepoint);
+      try {
+        await runGit(normalizedCwd, ["reset", "--hard", normalizedSavepoint.head]);
+        await runGit(normalizedCwd, ["clean", "--force", "-d"]);
+        if (normalizedSavepoint.stashRef !== void 0) {
+          await runGit(normalizedCwd, ["stash", "apply", "--index", normalizedSavepoint.stashRef]);
+        }
+      } finally {
+        if (normalizedSavepoint.stashRef !== void 0) {
+          await deleteSavepointRef(normalizedCwd, normalizedSavepoint.stashRef);
+        }
+      }
+    },
+    async diff() {
+      const { stdout } = await runGit(normalizedCwd, ["diff", "HEAD", "--"]);
+      return stdout;
+    },
+    async worktreeCreate(branch, options) {
+      const normalizedBranch = readNonEmptyString2(branch, "Git worktree branch");
+      const normalizedOptions = normalizeWorktreeCreateOptions(options);
+      const repoRoot = await getRepoRoot(normalizedCwd);
+      const worktreePath = await resolveWorktreePath(
+        repoRoot,
+        normalizedOptions.path ?? createDefaultWorktreePath(repoRoot, normalizedBranch),
+        "Git worktree path"
+      );
+      if (await gitRefExists(normalizedCwd, `refs/heads/${normalizedBranch}`)) {
+        throw new Error(`Git worktree branch '${normalizedBranch}' already exists.`);
+      }
+      await mkdir(dirname(worktreePath), { recursive: true });
+      try {
+        await runGit(normalizedCwd, [
+          "worktree",
+          "add",
+          "-b",
+          normalizedBranch,
+          worktreePath,
+          normalizedOptions.base
+        ]);
+      } catch (error) {
+        if (isBranchAlreadyExistsError(error, normalizedBranch)) {
+          throw new Error(`Git worktree branch '${normalizedBranch}' already exists.`);
+        }
+        throw error;
+      }
+      return {
+        path: worktreePath,
+        branch: normalizedBranch
+      };
+    },
+    async worktreeRemove(path) {
+      const repoRoot = await getRepoRoot(normalizedCwd);
+      const worktreePath = await resolveWorktreePath(repoRoot, path, "Git worktree path");
+      const worktrees = await listWorktrees(normalizedCwd);
+      if (!worktrees.some((worktree) => resolve(worktree.path) === worktreePath)) {
+        return;
+      }
+      await runGit(normalizedCwd, ["worktree", "remove", "--force", worktreePath]);
+      await rm(worktreePath, { recursive: true, force: true });
+    },
+    async worktreeList() {
+      return listWorktrees(normalizedCwd);
+    }
+  };
+}
+function normalizeCommitOptions(options) {
+  if (!isRecord(options)) {
+    throw new Error("Git commit options must be an object.");
+  }
+  const files = getOwnProperty(options, "files");
+  return {
+    message: readNonEmptyString2(getOwnProperty(options, "message"), "Git commit options message"),
+    files: files === void 0 ? void 0 : readNonEmptyStringArray(files, "Git commit options files")
+  };
+}
+function normalizeSavepoint(savepoint) {
+  if (!isRecord(savepoint)) {
+    throw new Error("Git savepoint must be an object.");
+  }
+  const stashRefValue = getOwnProperty(savepoint, "stashRef");
+  const stashRef = stashRefValue === void 0 ? void 0 : readNonEmptyString2(stashRefValue, "Git savepoint stashRef");
+  if (stashRef !== void 0 && !stashRef.startsWith(SAVEPOINT_REF_PREFIX)) {
+    throw new Error("Git savepoint stashRef must be a Poe checkpoint ref.");
+  }
+  return {
+    head: readNonEmptyString2(getOwnProperty(savepoint, "head"), "Git savepoint head"),
+    stashRef
+  };
+}
+function normalizeWorktreeCreateOptions(options) {
+  if (options === void 0) {
+    return {
+      base: "HEAD"
+    };
+  }
+  if (!isRecord(options)) {
+    throw new Error("Git worktree create options must be an object.");
+  }
+  const base = getOwnProperty(options, "base");
+  const path = getOwnProperty(options, "path");
+  return {
+    base: base === void 0 ? "HEAD" : readNonEmptyString2(base, "Git worktree create options base"),
+    path: path === void 0 ? void 0 : readNonEmptyString2(path, "Git worktree create options path")
+  };
+}
+function createSavepointRef() {
+  return `${SAVEPOINT_REF_PREFIX}${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function createDefaultWorktreePath(repoRoot, branch) {
+  return resolve(repoRoot, ".poe-code", "worktrees", createSafeBranchDirectoryName(branch));
+}
+function createSafeBranchDirectoryName(branch) {
+  return encodeURIComponent(branch);
+}
+async function getRepoRoot(cwd) {
+  return runGitAndTrim(cwd, ["rev-parse", "--show-toplevel"]);
+}
+async function gitRefExists(cwd, ref) {
+  try {
+    await runGit(cwd, ["show-ref", "--verify", "--quiet", ref]);
+    return true;
+  } catch (error) {
+    void error;
+    return false;
+  }
+}
+async function listWorktrees(cwd) {
+  const { stdout } = await runGit(cwd, ["worktree", "list", "--porcelain"]);
+  return parseWorktreeList(stdout);
+}
+function parseWorktreeList(output) {
+  const worktrees = [];
+  let current = {};
+  const finishCurrent = () => {
+    if (current.path !== void 0 && current.branch !== void 0) {
+      worktrees.push({
+        path: current.path,
+        branch: current.branch
+      });
+    }
+    current = {};
+  };
+  for (const line of output.split("\n")) {
+    if (line.length === 0) {
+      finishCurrent();
+      continue;
+    }
+    if (line.startsWith("worktree ")) {
+      current.path = line.slice("worktree ".length);
+      continue;
+    }
+    if (line.startsWith("branch ")) {
+      current.branch = parseBranchRef(line.slice("branch ".length));
+    }
+  }
+  finishCurrent();
+  return worktrees;
+}
+function parseBranchRef(ref) {
+  const branchPrefix = "refs/heads/";
+  return ref.startsWith(branchPrefix) ? ref.slice(branchPrefix.length) : ref;
+}
+async function resolveWorktreePath(repoRoot, path, label) {
+  const resolvedRoot = resolve(repoRoot);
+  const resolvedPath = isAbsolute(path) ? resolve(path) : resolve(resolvedRoot, path);
+  const canonicalRoot = await realpath(resolvedRoot);
+  const canonicalPath = await resolveCanonicalPath({ realpath, readlink }, resolvedPath);
+  const [inside, isRootItself] = await Promise.all([
+    containsPath(stat2, canonicalRoot, canonicalPath),
+    isSamePath(stat2, canonicalPath, canonicalRoot)
+  ]);
+  if (!inside || isRootItself) {
+    throw new Error(`${label} must be inside the git repository.`);
+  }
+  return canonicalPath;
+}
+function isBranchAlreadyExistsError(error, branch) {
+  return error instanceof Error && error.message.includes(branch) && error.message.includes("already exists");
+}
+async function runGitAndTrim(cwd, args) {
+  const { stdout } = await runGit(cwd, args);
+  return stdout.trim();
+}
+async function runGit(cwd, args) {
+  return new Promise((resolve2, reject) => {
+    execFile(
+      "git",
+      args,
+      {
+        cwd,
+        encoding: "utf8",
+        maxBuffer: GIT_EXEC_MAX_BUFFER
+      },
+      (error, stdout, stderr) => {
+        if (error) {
+          reject(
+            new Error(
+              `${formatGitCommand(args)} failed: ${pickGitFailureMessage(stdout, stderr, error)}`
+            )
+          );
+          return;
+        }
+        resolve2({
+          stdout,
+          stderr
+        });
+      }
+    );
+  });
+}
+async function cleanupFailedCheckpoint(cwd, stashRef) {
+  await deleteSavepointRef(cwd, stashRef);
+  const restored = await tryRunGit(cwd, ["stash", "apply", "--index", "stash@{0}"]);
+  if (restored) {
+    await tryRunGit(cwd, ["stash", "drop", "stash@{0}"]);
+  }
+}
+async function deleteSavepointRef(cwd, stashRef) {
+  await tryRunGit(cwd, ["update-ref", "--delete", stashRef]);
+}
+async function tryRunGit(cwd, args) {
+  try {
+    await runGit(cwd, args);
+    return true;
+  } catch (error) {
+    void error;
+    return false;
+  }
+}
+function formatGitCommand(args) {
+  return ["git", ...args].join(" ");
+}
+function pickGitFailureMessage(stdout, stderr, error) {
+  const stderrText = stderr.trim();
+  if (stderrText.length > 0) {
+    return stderrText;
+  }
+  const stdoutText = stdout.trim();
+  if (stdoutText.length > 0) {
+    return stdoutText;
+  }
+  return error.message;
+}
+function readNonEmptyString2(value, label) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`${label} must be a non-empty string.`);
+  }
+  return value;
+}
+function readNonEmptyStringArray(value, label) {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new Error(`${label} must be a non-empty array of strings.`);
+  }
+  const entries = value.map((entry, index) => readNonEmptyString2(entry, `${label}[${index}]`));
+  return [...entries];
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function getOwnProperty(value, name) {
+  return hasOwnProperty(value, name) ? value[name] : void 0;
+}
+function hasOwnProperty(value, name) {
+  return Object.prototype.hasOwnProperty.call(value, name);
+}
+
+// packages/safejs/src/modules/mcp.ts
+var DEFAULT_TOOL_BATCH_CONCURRENCY = 4;
+function makeMcpModule(connectMcp) {
+  return {
+    server(server) {
+      return normalizeServerHandle(server);
+    },
+    async client(handle) {
+      const connection = validateConnection(await connectMcp(normalizeServerHandle(handle)));
+      return {
+        async tools() {
+          return normalizeToolsResult(await connection.listTools());
+        },
+        async tool(name, args) {
+          return connection.callTool(
+            createNullRecord({
+              name: readNonEmptyTrimmedString(name, "MCP tool name"),
+              ...args === void 0 ? {} : { arguments: readToolArguments(args) }
+            })
+          );
+        },
+        async toolBatch(calls) {
+          return executeToolBatch(connection, readToolBatchCalls(calls));
+        }
+      };
+    }
+  };
+}
+async function executeToolBatch(connection, calls) {
+  if (calls.length === 0) {
+    return [];
+  }
+  if (connection.callToolBatch !== void 0 && calls.every((call) => call.ok)) {
+    try {
+      return normalizeProtocolBatchResults(
+        await connection.callToolBatch(calls.map((call) => call.request)),
+        calls.length
+      );
+    } catch (error) {
+      const batchError = normalizeToolBatchError(error);
+      return calls.map(
+        () => createNullRecord({
+          ok: false,
+          error: batchError
+        })
+      );
+    }
+  }
+  return executeToolBatchWithConcurrency(connection, calls, DEFAULT_TOOL_BATCH_CONCURRENCY);
+}
+async function executeToolBatchWithConcurrency(connection, calls, concurrency) {
+  const results = new Array(calls.length);
+  let nextIndex = 0;
+  let disconnectError;
+  const workerCount = Math.min(concurrency, calls.length);
+  const workers = Array.from({ length: workerCount }, async () => {
+    while (nextIndex < calls.length) {
+      const index = nextIndex;
+      nextIndex += 1;
+      const call = calls[index];
+      if (call === void 0) {
+        continue;
+      }
+      if (!call.ok) {
+        results[index] = createNullRecord({
+          ok: false,
+          error: call.error
+        });
+        continue;
+      }
+      if (disconnectError !== void 0) {
+        results[index] = createNullRecord({
+          ok: false,
+          error: disconnectError
+        });
+        continue;
+      }
+      try {
+        results[index] = createNullRecord({
+          ok: true,
+          value: await connection.callTool(call.request)
+        });
+      } catch (error) {
+        const toolError = normalizeToolBatchError(error);
+        results[index] = createNullRecord({
+          ok: false,
+          error: toolError
+        });
+        if (isMcpDisconnectError(toolError)) {
+          disconnectError = toolError;
+        }
+      }
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+function normalizeProtocolBatchResults(value, expectedLength) {
+  if (!Array.isArray(value) || value.length !== expectedLength) {
+    throw new Error(
+      "MCP callToolBatch() must resolve to a result array matching the input length."
+    );
+  }
+  return value.map((entry, index) => normalizeProtocolBatchResult(entry, index));
+}
+function normalizeProtocolBatchResult(value, index) {
+  if (!isRecord2(value)) {
+    throw new Error(`MCP callToolBatch()[${index}] must be a result envelope.`);
+  }
+  const ok = getOwnProperty2(value, "ok");
+  if (typeof ok !== "boolean") {
+    throw new Error(`MCP callToolBatch()[${index}] must be a result envelope.`);
+  }
+  if (ok === true) {
+    return createNullRecord({
+      ok: true,
+      value: getOwnProperty2(value, "value")
+    });
+  }
+  return createNullRecord({
+    ok: false,
+    error: normalizeToolBatchError(getOwnProperty2(value, "error"))
+  });
+}
+function normalizeServerHandle(value) {
+  if (!isRecord2(value)) {
+    throw new Error("MCP server must be an object.");
+  }
+  const command = getOwnProperty2(value, "command");
+  const args = getOwnProperty2(value, "args");
+  const env = getOwnProperty2(value, "env");
+  return createNullRecord({
+    command: readNonEmptyTrimmedString(command, "MCP server command"),
+    ...args === void 0 ? {} : { args: readStringArray(args, "MCP server args") },
+    ...env === void 0 ? {} : { env: readStringRecord(env, "MCP server env") }
+  });
+}
+function validateConnection(value) {
+  if (!isRecord2(value) || typeof value.listTools !== "function" || typeof value.callTool !== "function") {
+    throw new Error("connectMcp must resolve to an object with listTools() and callTool().");
+  }
+  const callToolBatch = getOwnProperty2(value, "callToolBatch");
+  return createNullRecord({
+    listTools: () => value.listTools(),
+    callTool: (params) => value.callTool(params),
+    ...typeof callToolBatch === "function" ? {
+      callToolBatch: (params) => callToolBatch(params)
+    } : {}
+  });
+}
+function normalizeToolsResult(value) {
+  const tools = isRecord2(value) ? getOwnProperty2(value, "tools") : void 0;
+  if (!Array.isArray(tools)) {
+    throw new Error("MCP listTools() must resolve to an object with a tools array.");
+  }
+  return tools.map((tool, index) => normalizeTool(tool, index));
+}
+function normalizeTool(value, index) {
+  if (!isRecord2(value)) {
+    throw new Error(`MCP tool[${index}] must be an object.`);
+  }
+  const description = getOwnProperty2(value, "description");
+  const inputSchema = getOwnProperty2(value, "inputSchema");
+  return createNullRecord({
+    name: readNonEmptyString3(getOwnProperty2(value, "name"), `MCP tool[${index}] name`),
+    ...description === void 0 ? {} : { description: readOptionalString(description, `MCP tool[${index}] description`) },
+    ...inputSchema === void 0 ? {} : { schema: inputSchema }
+  });
+}
+function readStringArray(value, label) {
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+    throw new Error(`${label} must be an array of strings.`);
+  }
+  return [...value];
+}
+function readStringRecord(value, label) {
+  if (!isRecord2(value)) {
+    throw new Error(`${label} must be an object.`);
+  }
+  const entries = Object.entries(value);
+  if (entries.some(([, entry]) => typeof entry !== "string")) {
+    throw new Error(`${label} must be a string record.`);
+  }
+  return createNullRecord(Object.fromEntries(entries));
+}
+function readOptionalString(value, label) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new Error(`${label} must be a string.`);
+  }
+  return value;
+}
+function readNonEmptyString3(value, label) {
+  const text = readOptionalString(value, label);
+  if (text === void 0 || text.trim().length === 0) {
+    throw new Error(`${label} must be a non-empty string.`);
+  }
+  return text;
+}
+function readNonEmptyTrimmedString(value, label) {
+  return readNonEmptyString3(value, label).trim();
+}
+function readToolArguments(value) {
+  if (!isPlainObjectRecord(value)) {
+    throw new Error("MCP tool arguments must be an object.");
+  }
+  return createNullRecord(Object.fromEntries(Object.entries(value)));
+}
+function readToolBatchCalls(value) {
+  if (!Array.isArray(value)) {
+    throw new Error("MCP toolBatch calls must be an array.");
+  }
+  return value.map((entry, index) => normalizeToolBatchCall(entry, index));
+}
+function normalizeToolBatchCall(value, index) {
+  try {
+    if (!isRecord2(value)) {
+      throw new Error(`MCP toolBatch call[${index}] must be an object.`);
+    }
+    const args = getOwnProperty2(value, "args");
+    return createNullRecord({
+      ok: true,
+      request: createNullRecord({
+        name: readNonEmptyTrimmedString(
+          getOwnProperty2(value, "name"),
+          `MCP toolBatch call[${index}] name`
+        ),
+        ...args === void 0 ? {} : { arguments: readToolArguments(args) }
+      })
+    });
+  } catch (error) {
+    return createNullRecord({
+      ok: false,
+      error: normalizeToolBatchError(error)
+    });
+  }
+}
+function normalizeToolBatchError(error) {
+  if (error instanceof Error) {
+    return createNullRecord({
+      name: error.name.length === 0 ? "Error" : error.name,
+      message: error.message
+    });
+  }
+  if (isRecord2(error)) {
+    const nameValue = getOwnProperty2(error, "name");
+    const messageValue = getOwnProperty2(error, "message");
+    const name = typeof nameValue === "string" && nameValue.trim().length > 0 ? nameValue : "Error";
+    const message = typeof messageValue === "string" ? messageValue : String(error);
+    return createNullRecord({
+      name,
+      message
+    });
+  }
+  return createNullRecord({
+    name: "Error",
+    message: error === void 0 ? "" : String(error)
+  });
+}
+function isMcpDisconnectError(error) {
+  const message = error.message.toLowerCase();
+  return message.includes("disconnected") || message.includes("connection closed") || message.includes("transport closed") || message.includes("disposed") || message.includes("eof");
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function getOwnProperty2(value, name) {
+  return hasOwnProperty2(value, name) ? value[name] : void 0;
+}
+function hasOwnProperty2(value, name) {
+  return Object.prototype.hasOwnProperty.call(value, name);
+}
+function createNullRecord(value) {
+  return Object.assign(/* @__PURE__ */ Object.create(null), value);
+}
+function isPlainObjectRecord(value) {
+  if (!isRecord2(value) || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+// packages/safejs/src/modules/time.ts
+function makeTimeModule(options = {}) {
+  const hasDeterministicRandom = options.random !== void 0 || options.seed !== void 0;
+  const random = options.random ?? (options.seed === void 0 ? () => Math.random() : createSeededRandom(options.seed).next);
+  const now = options.now ?? (() => Date.now());
+  const signal = options.signal;
+  async function sleep(ms) {
+    assertSleepDelay(ms);
+    return await new Promise((resolve2, reject) => {
+      if (signal?.aborted === true) {
+        reject(createSleepAbortError());
+        return;
+      }
+      const start = performance.now();
+      let timeout = setTimeout(resolveSleep, ms);
+      function cleanup() {
+        clearTimeout(timeout);
+        signal?.removeEventListener("abort", rejectSleep);
+      }
+      function resolveSleep() {
+        const remainingMs = ms - (performance.now() - start);
+        if (remainingMs > 0) {
+          timeout = setTimeout(resolveSleep, remainingMs);
+          return;
+        }
+        cleanup();
+        resolve2();
+      }
+      function rejectSleep() {
+        cleanup();
+        reject(createSleepAbortError());
+      }
+      signal?.addEventListener("abort", rejectSleep, { once: true });
+    });
+  }
+  return {
+    random,
+    now,
+    sleep,
+    uuid: hasDeterministicRandom ? () => createRandomUuid(random) : () => crypto.randomUUID()
+  };
+}
+function createRandomUuid(random) {
+  const bytes = Array.from({ length: 16 }, () => Math.floor(readRandomUnit(random()) * 256));
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = bytes.map((byte) => byte.toString(16).padStart(2, "0")).join("");
+  return [
+    hex.slice(0, 8),
+    hex.slice(8, 12),
+    hex.slice(12, 16),
+    hex.slice(16, 20),
+    hex.slice(20)
+  ].join("-");
+}
+function readRandomUnit(value) {
+  if (Number.isFinite(value) && value >= 0 && value < 1) {
+    return value;
+  }
+  throw new RangeError("time.uuid() random source must return a number in [0, 1).");
+}
+function assertSleepDelay(ms) {
+  if (Number.isFinite(ms) && ms >= 0) {
+    return;
+  }
+  throw new RangeError("time.sleep(ms) requires a non-negative finite millisecond delay.");
+}
+function createSleepAbortError() {
+  return new Error("time.sleep aborted.");
+}
+export {
+  AgentSpawnError,
+  Budget,
+  FileSnapshotBackend,
+  HostCallResumabilityError,
+  HostOperationResumePolicyError,
+  SandboxError,
+  SnapshotValidationError,
+  createReplayableRandom,
+  createSpawnUsageAccumulator,
+  declareHostOperation,
+  deepCopyFromSandbox,
+  deepCopyToSandbox,
+  dump,
+  extractBlock,
+  findExportedConstInitializer,
+  formatInterpreterError,
+  lint,
+  makeAgentModule,
+  makeEnvModule,
+  makeFailModule,
+  makeFsModule,
+  makeGitModule,
+  makeHarnessModule,
+  makeLogModule,
+  makeMcpModule,
+  makeMetricModule,
+  makeTimeModule,
+  noopOtelSink,
+  parse,
+  parseModule,
+  registerPendingHostCallPolicy,
+  restore,
+  run,
+  runHarness,
+  runHarnessPair,
+  runWithSpawnUsageAccumulator,
+  splitFrontmatter
+};
+//# sourceMappingURL=index.js.map