@poe-platform/safe-js 0.1.0

package/dist/safe-js/cli.js

@@ -0,0 +1,724 @@
+#!/usr/bin/env node
+import {
+  countLineBreaks,
+  createBrokenPipeState,
+  createLintModulesFromRuntimeRegistry,
+  createSafeOutputStream,
+  extractBlock,
+  formatInterpreterError,
+  makeAgentModule,
+  makeEnvModule,
+  makeFailModule,
+  makeFsModule,
+  makeHarnessModule,
+  makeLogModule,
+  makeMcpModule,
+  makeMetricModule,
+  maskSource,
+  migrateSnapshotFile,
+  parseEnvConfig,
+  parseFsConfig,
+  parseMcpConfig,
+  resolveFsConfig,
+  splitFrontmatter,
+  withBrokenPipeGuard
+} from "./chunks/chunk-DC5B3GYM.js";
+import {
+  Budget,
+  SandboxError,
+  dump,
+  dumpCurrent,
+  hasOwnErrorCode,
+  lint,
+  parseModule,
+  replaceErrorStack,
+  restore,
+  run
+} from "./chunks/chunk-Z3D76J4U.js";
+import "./chunks/chunk-7M2SJPSZ.js";
+import "./chunks/chunk-2QRYPKQQ.js";
+import "./chunks/chunk-4YIDX44G.js";
+
+// packages/safe-js/src/cli.ts
+import { mkdir, readFile, realpath, stat, writeFile } from "node:fs/promises";
+import path, { dirname, extname } from "node:path";
+import { formatWithOptions } from "node:util";
+import { fileURLToPath } from "node:url";
+var EXIT_RUNTIME = 1;
+var EXIT_PARSE = 2;
+var EXIT_BUDGET = 3;
+var EXIT_SIGINT = 130;
+async function runCli(argv, options = {}) {
+  const brokenPipe = createBrokenPipeState();
+  const stdout = createSafeOutputStream(options.stdout ?? process.stdout, brokenPipe);
+  const stderr = createSafeOutputStream(options.stderr ?? process.stderr, brokenPipe);
+  return withBrokenPipeGuard(
+    [options.stdout ?? process.stdout, options.stderr ?? process.stderr],
+    brokenPipe,
+    async () => {
+      try {
+        if (argv.includes("--help") || argv.includes("-h")) {
+          stdout.write(`${createUsage()}
+`);
+          return 0;
+        }
+        if (argv[0] === "migrate") {
+          const result = await migrateSnapshotFile({
+            ...parseMigrationArgs(argv.slice(1)),
+            cwd: options.cwd ?? readCurrentWorkingDirectory()
+          });
+          stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+          return 0;
+        }
+        const parsed = parseArgs(argv);
+        if (parsed.filepath === void 0) {
+          stderr.write(`${createUsage()}
+`);
+          return brokenPipe.closed ? 0 : EXIT_RUNTIME;
+        }
+        const cwd = options.cwd ?? readCurrentWorkingDirectory();
+        const filepath = path.resolve(cwd, parsed.filepath);
+        const configuredFs = parsed.fsConfig === void 0 ? void 0 : await resolveFsConfig(
+          parseFsConfig(
+            await (options.readFile ?? readFile)(path.resolve(cwd, parsed.fsConfig), "utf8")
+          )
+        );
+        await assertHarnessFile({
+          displayPath: parsed.filepath,
+          filepath,
+          statFile: options.stat ?? stat
+        });
+        return await runScriptFile(filepath, parsed, {
+          cwd,
+          configuredFs,
+          env: options.env,
+          mcp: options.mcp,
+          modulesFor: options.modulesFor,
+          process: options.process ?? process,
+          readFile: options.readFile ?? readFile,
+          brokenPipe,
+          stderr,
+          stdout,
+          writeFile: options.writeFile ?? writeFile
+        });
+      } catch (error) {
+        if (brokenPipe.closed) {
+          return 0;
+        }
+        stderr.write(`${readErrorMessage(error)}
+`);
+        return brokenPipe.closed ? 0 : error instanceof CliExitError ? error.exitCode : exitCodeForError(error);
+      }
+    }
+  );
+}
+function readCurrentWorkingDirectory() {
+  try {
+    return process.cwd();
+  } catch (error) {
+    throw new Error(`Unable to resolve current working directory: ${readErrorMessage(error)}`);
+  }
+}
+function parseMigrationArgs(argv) {
+  const result = { snapshotPath: "", sourcePath: "" };
+  const paths = /* @__PURE__ */ new Map([
+    ["--from", "sourcePath"],
+    ["--to", "targetSourcePath"],
+    ["--plan", "planPath"],
+    ["--output", "outputPath"]
+  ]);
+  const seen = /* @__PURE__ */ new Set();
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (!argument.startsWith("-")) {
+      if (result.snapshotPath.length > 0)
+        throw new TypeError("Migration accepts exactly one snapshot path.");
+      result.snapshotPath = argument;
+      continue;
+    }
+    if (seen.has(argument)) throw new TypeError(`Duplicate migration option: ${argument}`);
+    seen.add(argument);
+    if (argument === "--inspect") {
+      result.inspect = true;
+      continue;
+    }
+    if (argument === "--dry-run") {
+      result.dryRun = true;
+      continue;
+    }
+    const key = paths.get(argument);
+    if (key === void 0) throw new TypeError(`Unknown migration option: ${argument}`);
+    const value = argv[++index];
+    if (value === void 0 || value.startsWith("--"))
+      throw new TypeError(`${argument} requires a path.`);
+    result[key] = value;
+  }
+  return result;
+}
+function parseArgs(argv) {
+  const parsed = {
+    fix: false,
+    fs: false
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--fix") {
+      parsed.fix = true;
+      continue;
+    }
+    if (arg === "--fs") {
+      parsed.fs = true;
+      continue;
+    }
+    if (arg === "--fs-root") {
+      parsed.fsRoot = readFlagValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--fs-config") {
+      if (parsed.fsConfig !== void 0) {
+        throw new CliExitError("--fs-config may be specified only once.", EXIT_RUNTIME);
+      }
+      const value = readFlagValue(argv, index, arg);
+      if (value.trim().length === 0 || value.startsWith("--")) {
+        throw new CliExitError("--fs-config needs a JSON file path.", EXIT_RUNTIME);
+      }
+      parsed.fsConfig = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--mcp-config") {
+      parsed.mcpConfig = readFlagValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--env-config") {
+      parsed.envConfig = readFlagValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--snapshot") {
+      parsed.snapshotPath = readFlagValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--restore") {
+      parsed.restorePath = readFlagValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--max-steps") {
+      parsed.maxSteps = readPositiveInteger(readFlagValue(argv, index, arg), arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--data-size") {
+      parsed.dataSize = readPositiveInteger(readFlagValue(argv, index, arg), arg);
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      throw new CliExitError(`Unknown flag: ${arg}`, EXIT_RUNTIME);
+    }
+    if (parsed.filepath !== void 0) {
+      throw new CliExitError(`Unexpected argument: ${arg}`, EXIT_RUNTIME);
+    }
+    parsed.filepath = arg;
+  }
+  if (parsed.fsConfig !== void 0 && (parsed.fs || parsed.fsRoot !== void 0)) {
+    throw new CliExitError("--fs-config cannot be combined with --fs or --fs-root.", EXIT_RUNTIME);
+  }
+  if (!parsed.fs && parsed.fsRoot !== void 0) {
+    throw new CliExitError(
+      "--fs-root requires --fs. Pass --fs to give the script a filesystem confined to that root, or drop --fs-root.",
+      EXIT_RUNTIME
+    );
+  }
+  return parsed;
+}
+function readFlagValue(argv, index, flag) {
+  const value = argv[index + 1];
+  if (value === void 0 || value.length === 0) {
+    throw new CliExitError(`Missing value for ${flag}`, EXIT_RUNTIME);
+  }
+  return value;
+}
+function readPositiveInteger(value, flag) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new CliExitError(`${flag} must be a positive integer`, EXIT_RUNTIME);
+  }
+  return parsed;
+}
+async function assertHarnessFile(input) {
+  let stats;
+  try {
+    stats = await input.statFile(input.filepath);
+  } catch (error) {
+    if (hasErrorCode(error, "ENOENT")) {
+      throw new CliExitError(`File not found: ${input.displayPath}`, EXIT_RUNTIME);
+    }
+    throw error;
+  }
+  if (!stats.isFile()) {
+    throw new CliExitError(`Harness path must point to a file: ${input.displayPath}`, EXIT_RUNTIME);
+  }
+}
+async function runScriptFile(filepath, parsed, options) {
+  const loaded = loadExecutableSource(filepath, await options.readFile(filepath, "utf8"));
+  const meta = {
+    filepath,
+    kind: loaded.frontmatter.kind,
+    version: loaded.frontmatter.version
+  };
+  const runtime = createRuntime(loaded.frontmatter, meta, {
+    fs: parsed.fs ? { root: path.resolve(options.cwd, parsed.fsRoot ?? dirname(filepath)) } : void 0,
+    modulesFor: options.modulesFor,
+    stderr: options.stderr,
+    stdout: options.stdout
+  });
+  if (options.configuredFs !== void 0) {
+    const registry = new Map(
+      runtime.registry instanceof Map ? runtime.registry : Object.entries(runtime.registry)
+    );
+    if (registry.has("fs")) throw new TypeError("fs is already registered by modulesFor.");
+    registry.set("fs", toModuleExports(makeFsModule(options.configuredFs)));
+    runtime.registry = registry;
+  }
+  let env = options.env;
+  if (parsed.envConfig !== void 0) {
+    if (env !== void 0)
+      throw new TypeError("Pass environment options or --env-config, not both.");
+    const configPath = path.resolve(options.cwd, parsed.envConfig);
+    env = parseEnvConfig(await options.readFile(configPath, "utf8"));
+  }
+  if (env !== void 0) {
+    const registry = new Map(
+      runtime.registry instanceof Map ? runtime.registry : Object.entries(runtime.registry)
+    );
+    if (registry.has("env"))
+      throw new TypeError("Environment is already registered by modulesFor.");
+    registry.set("env", makeEnvModule(env));
+    runtime.registry = registry;
+  }
+  let mcp = options.mcp;
+  if (parsed.mcpConfig !== void 0) {
+    if (mcp !== void 0) throw new TypeError("Pass MCP options or --mcp-config, not both.");
+    const configPath = path.resolve(options.cwd, parsed.mcpConfig);
+    mcp = parseMcpConfig(await options.readFile(configPath, "utf8"), dirname(configPath));
+  }
+  if (mcp !== void 0) {
+    const registry = new Map(
+      runtime.registry instanceof Map ? runtime.registry : Object.entries(runtime.registry)
+    );
+    if (registry.has("mcp")) throw new TypeError("MCP is already registered by modulesFor.");
+    registry.set("mcp", makeMcpModule(mcp));
+    runtime.registry = registry;
+  }
+  const modules = excludeHarnessModule(runtime.registry, loaded.isRawScript);
+  let executableSource = loaded.executableSource;
+  const lintResult = parsed.fix ? lint(executableSource, {
+    allowedExportNames: ["schema"],
+    filename: filepath,
+    fix: true,
+    fixRanges: loaded.fixRanges,
+    frontmatterFields: Object.keys(loaded.frontmatter),
+    modules: createLintModulesFromRuntimeRegistry(modules)
+  }) : lint(executableSource, {
+    allowedExportNames: ["schema"],
+    filename: filepath,
+    frontmatterFields: Object.keys(loaded.frontmatter),
+    modules: createLintModulesFromRuntimeRegistry(modules)
+  });
+  const diagnostics = Array.isArray(lintResult) ? lintResult : lintResult.diagnostics;
+  if (!Array.isArray(lintResult)) {
+    executableSource = lintResult.fixed;
+    if (lintResult.fixed !== loaded.executableSource) {
+      await options.writeFile(
+        filepath,
+        replaceExecutableSource(loaded.rawSource, loaded, lintResult.fixes),
+        {
+          encoding: "utf8"
+        }
+      );
+    }
+  }
+  const lintErrors = diagnostics.filter((diagnostic) => diagnostic.severity === "error");
+  if (lintErrors.length > 0) {
+    options.stderr.write(`Lint failed:
+${formatDiagnostics(lintErrors)}
+`);
+    if (options.brokenPipe.closed) {
+      return 0;
+    }
+    return lintErrors.some((diagnostic) => diagnostic.code === "AS001") ? EXIT_PARSE : EXIT_RUNTIME;
+  }
+  const lintWarnings = diagnostics.filter((diagnostic) => diagnostic.severity === "warning");
+  if (lintWarnings.length > 0) {
+    options.stderr.write(`Lint warnings:
+${formatDiagnostics(lintWarnings)}
+`);
+    if (options.brokenPipe.closed) {
+      return 0;
+    }
+  }
+  const snapshot = await readRestoreSnapshot(parsed.restorePath, options);
+  if (snapshot !== void 0) {
+    restore(snapshot, { source: executableSource });
+  }
+  const abortController = new AbortController();
+  let interrupted = false;
+  let runPromise;
+  let signalSnapshotWrite;
+  const onSigint = () => {
+    interrupted = true;
+    abortController.abort(createAbortError());
+    options.stderr.write("Interrupted by SIGINT\n");
+    if (parsed.snapshotPath !== void 0 && runPromise !== void 0) {
+      signalSnapshotWrite = writeCurrentSnapshot(runPromise, parsed.snapshotPath, options);
+    }
+  };
+  options.process.on("SIGINT", onSigint);
+  try {
+    runPromise = run(executableSource, {
+      budget: parsed.maxSteps === void 0 && parsed.dataSize === void 0 ? void 0 : new Budget({ dataSize: parsed.dataSize, maxSteps: parsed.maxSteps }),
+      entryPointArgs: hasDefaultExport(executableSource, filepath) ? [] : void 0,
+      filename: filepath,
+      modules,
+      signal: abortController.signal,
+      sink: createConsoleSink(options.stdout, options.stderr),
+      snapshot
+    });
+    const result = await runPromise;
+    await signalSnapshotWrite;
+    if (options.brokenPipe.closed) {
+      return 0;
+    }
+    if (parsed.snapshotPath !== void 0) {
+      await writeSnapshot(parsed.snapshotPath, await dump(result), options);
+    }
+    if (!result.ok) {
+      options.stderr.write(
+        `${formatInterpreterError(result.error, {
+          filename: filepath,
+          source: executableSource
+        })}
+`
+      );
+      if (options.brokenPipe.closed) {
+        return 0;
+      }
+      return interrupted ? EXIT_SIGINT : exitCodeForError(result.error);
+    }
+    options.stdout.write(`${JSON.stringify({ ok: true, returnValue: result.returnValue })}
+`);
+    return options.brokenPipe.closed ? 0 : interrupted ? EXIT_SIGINT : 0;
+  } catch (error) {
+    await signalSnapshotWrite;
+    if (parsed.snapshotPath !== void 0 && runPromise !== void 0) {
+      try {
+        await writeSnapshot(
+          parsed.snapshotPath,
+          await dump(runPromise, { onFailure: "checkpoint" }),
+          options
+        );
+      } catch (snapshotError) {
+        options.stderr.write(
+          `Failed to write recovery snapshot at ${parsed.snapshotPath}: ${readErrorMessage(snapshotError)}. Any existing snapshot may be stale.
+`
+        );
+      }
+    }
+    if (options.brokenPipe.closed) {
+      return 0;
+    }
+    options.stderr.write(
+      `${formatInterpreterError(error, {
+        filename: filepath,
+        source: executableSource
+      })}
+`
+    );
+    return options.brokenPipe.closed ? 0 : interrupted ? EXIT_SIGINT : exitCodeForError(error);
+  } finally {
+    options.process.off("SIGINT", onSigint);
+  }
+}
+function loadExecutableSource(filepath, rawSource) {
+  const source = stripByteOrderMark(rawSource);
+  const byteOrderMarkLength = rawSource.length - source.length;
+  if (isRawScriptExtension(extname(filepath))) {
+    return {
+      sourceOffset: byteOrderMarkLength,
+      executableSource: source,
+      frontmatter: {},
+      isRawScript: true,
+      rawSource
+    };
+  }
+  const { frontmatter, body } = splitFrontmatter(source);
+  const bodyStartOffset = rawSource.length - body.length;
+  const executableBlock = extractBlock(body, countLineBreaks(rawSource, 0, bodyStartOffset) + 1);
+  return {
+    sourceOffset: 0,
+    fixRanges: executableBlock.ranges.map(([start, end]) => [
+      bodyStartOffset + start,
+      bodyStartOffset + end
+    ]),
+    executableSource: maskSource(rawSource.slice(0, bodyStartOffset + executableBlock.startOffset)) + executableBlock.source,
+    frontmatter,
+    isRawScript: false,
+    rawSource
+  };
+}
+function isRawScriptExtension(extension) {
+  return extension === ".safejs" || extension === ".ajs";
+}
+function replaceExecutableSource(source, loaded, fixes) {
+  return fixes.reduce(
+    (result, fix) => `${result.slice(0, loaded.sourceOffset + fix.range[0])}${fix.replacement}${result.slice(loaded.sourceOffset + fix.range[1])}`,
+    source
+  );
+}
+function createRuntime(frontmatter, meta, options) {
+  if (options.modulesFor !== void 0) {
+    return {
+      registry: options.modulesFor(frontmatter, meta, {
+        stderr: options.stderr,
+        stdout: options.stdout
+      })
+    };
+  }
+  const state = {
+    metricCalls: /* @__PURE__ */ new Map(),
+    spawnCount: 0
+  };
+  const harness = makeHarnessModule(frontmatter, meta);
+  const agent = makeAgentModule(async (input) => {
+    state.spawnCount += 1;
+    return {
+      exitCode: 0,
+      stdout: "",
+      stderr: "",
+      summary: `${input.agent} handled ${summarizePrompt(input.prompt)}`,
+      durationMs: 25 * state.spawnCount
+    };
+  });
+  const log = makeLogModule((entry) => {
+    const normalized = normalizeLogEntry(entry);
+    const stream = normalized.type === "error" ? options.stderr : options.stdout;
+    stream.write(`${JSON.stringify(normalized)}
+`);
+  });
+  const metric = makeMetricModule(async (scriptName) => `${readMetricScore(scriptName, state)}
+`);
+  return {
+    registry: {
+      agent: toModuleExports(agent),
+      fail: toModuleExports(/* @__PURE__ */ new Map([["default", makeFailModule().default]])),
+      // The one module here that is not a stub, so it is registered only when asked for.
+      ...options.fs === void 0 ? {} : { fs: toModuleExports(makeFsModule(options.fs)) },
+      harness: toModuleExports(harness),
+      log: toModuleExports(log),
+      metric: toModuleExports(metric)
+    }
+  };
+}
+async function readRestoreSnapshot(restorePath, options) {
+  if (restorePath === void 0) {
+    return void 0;
+  }
+  const snapshotPath = path.resolve(options.cwd, restorePath);
+  let rawSnapshot;
+  try {
+    rawSnapshot = await options.readFile(snapshotPath, "utf8");
+  } catch (error) {
+    if (hasErrorCode(error, "ENOENT")) {
+      throw new CliExitError(`Snapshot not found: ${restorePath}`, EXIT_RUNTIME);
+    }
+    throw error;
+  }
+  try {
+    return JSON.parse(rawSnapshot);
+  } catch (error) {
+    throw new Error(`Failed to parse snapshot at ${restorePath}: ${readErrorMessage(error)}`);
+  }
+}
+async function writeCurrentSnapshot(result, snapshotPath, options) {
+  try {
+    await writeSnapshot(snapshotPath, await dumpCurrent(result), options);
+  } catch (error) {
+    options.stderr.write(
+      `Failed to write snapshot at ${snapshotPath}: ${readErrorMessage(error)}
+`
+    );
+  }
+}
+async function writeSnapshot(snapshotPath, content, options) {
+  const resolvedPath = path.resolve(options.cwd, snapshotPath);
+  await mkdir(dirname(resolvedPath), { recursive: true });
+  await options.writeFile(resolvedPath, content, { encoding: "utf8" });
+}
+function createConsoleSink(stdout, stderr) {
+  return {
+    error(...args) {
+      stderr.write(`${formatConsoleArgs(args)}
+`);
+    },
+    log(...args) {
+      stdout.write(`${formatConsoleArgs(args)}
+`);
+    }
+  };
+}
+function formatConsoleArgs(args) {
+  return formatWithOptions({ colors: false, depth: 4 }, ...args);
+}
+function createUsage() {
+  return [
+    "Usage: poe-safe-js [options] <script.md|script.safejs|script.ajs>",
+    "       poe-safe-js migrate <checkpoint.json> --from <original.ajs> --inspect",
+    "       poe-safe-js migrate <checkpoint.json> --from <original.ajs> --to <continuation.ajs>",
+    "                         --plan <migration.json> --output <new-checkpoint.json> [--dry-run]",
+    "",
+    "Compatibility alias: poe-safejs",
+    "",
+    "Options:",
+    "  --fix                 apply lint fixes before running",
+    "  --fs                  register the fs module: a real filesystem, unlike the agent",
+    "                        and metric stubs this runner bundles",
+    "  --fs-root <path>      directory --fs confines the script to (default: the script's",
+    "                        directory)",
+    "  --fs-config <path>    configure shared filesystem access from JSON (Node only)",
+    "  --mcp-config <path>   register named MCP servers from an explicit JSON config",
+    "  --env-config <path>   grant environment reads from an explicit JSON config",
+    "  --snapshot <path>     write success/failure state; best-effort snapshot on SIGINT",
+    "  --restore <path>      restore from a snapshot before running",
+    "  --max-steps <n>       cap interpreter step budget",
+    "  --data-size <n>       cap retained sandbox data units",
+    "  -h, --help            print this help",
+    "",
+    "Exit codes:",
+    "  0 success",
+    "  1 runtime, usage, file, or restore error",
+    "  2 parse error",
+    "  3 budget exceeded",
+    "  130 interrupted by SIGINT"
+  ].join("\n");
+}
+function formatDiagnostics(diagnostics) {
+  return diagnostics.map(
+    (diagnostic) => `${diagnostic.filename}:${diagnostic.line}:${diagnostic.column} ${diagnostic.code} ${diagnostic.message}`
+  ).join("\n");
+}
+function exitCodeForError(error) {
+  if (error instanceof SandboxError && error.code === "budgetExceeded") {
+    return EXIT_BUDGET;
+  }
+  if (isParseError(error)) {
+    return EXIT_PARSE;
+  }
+  return EXIT_RUNTIME;
+}
+function isParseError(error) {
+  return error instanceof Error && error.name === "ParseError";
+}
+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 = /* @__PURE__ */ Object.create(null);
+  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 normalizeLogEntry(entry) {
+  return {
+    ...entry,
+    ts: "2026-04-29T00:00:00.000Z"
+  };
+}
+function summarizePrompt(prompt) {
+  const normalizedPrompt = prompt.trim().replaceAll("\n", " ");
+  return normalizedPrompt.length <= 48 ? normalizedPrompt : `${normalizedPrompt.slice(0, 45)}...`;
+}
+function readMetricScore(scriptName, state) {
+  const callCount = (state.metricCalls.get(scriptName) ?? 0) + 1;
+  state.metricCalls.set(scriptName, callCount);
+  if (scriptName === "tests" && callCount === 1) {
+    return 10;
+  }
+  if (scriptName === "tests" && callCount === 2) {
+    return 9;
+  }
+  return 9 + callCount;
+}
+function toModuleExports(value) {
+  return value;
+}
+function createAbortError() {
+  if (typeof DOMException === "function") {
+    const error2 = new DOMException("This operation was aborted", "AbortError");
+    replaceErrorStack(error2);
+    return error2;
+  }
+  const error = new Error("This operation was aborted");
+  error.name = "AbortError";
+  replaceErrorStack(error);
+  return error;
+}
+function hasErrorCode(error, code) {
+  return hasOwnErrorCode(error, code);
+}
+function readErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+var CliExitError = class extends Error {
+  exitCode;
+  constructor(message, exitCode) {
+    super(message);
+    this.name = "CliExitError";
+    this.exitCode = exitCode;
+  }
+};
+async function isDirectExecution(entryPoint) {
+  if (typeof entryPoint !== "string" || entryPoint.length === 0) {
+    return false;
+  }
+  try {
+    const [resolvedEntryPoint, resolvedModule] = await Promise.all([
+      realpath(path.resolve(entryPoint)),
+      realpath(fileURLToPath(import.meta.url))
+    ]);
+    return resolvedEntryPoint === resolvedModule;
+  } catch {
+    return false;
+  }
+}
+if (await isDirectExecution(process.argv[1])) {
+  process.exitCode = await runCli(process.argv.slice(2));
+}
+export {
+  runCli
+};
+//# sourceMappingURL=cli.js.map