failproofai 1.0.7-beta.1 → 1.0.7-beta.2

package/.next/standalone/sdk/typescript/test/packaging.test.ts

@@ -0,0 +1,312 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+import { describe, expect, it } from "vitest";
+
+import { VERSION } from "../src/version.js";
+import { runNode, indexUrl } from "./helpers.js";
+
+/**
+ * What a consumer actually gets.
+ *
+ * Everything else in this suite runs against `src/`. These cases run against
+ * `dist/` and `package.json`, because the failures they guard — a missing
+ * export condition, a CommonJS build Node reads as ESM, a dependency somebody
+ * added with `--save` — are invisible from inside the source tree and total
+ * from outside it.
+ */
+
+/** An `exports` value: a target, or conditions that nest (`require.types`). */
+type Conditions = string | { [condition: string]: Conditions };
+
+/** Every `[condition path, target]` under one `exports` entry. */
+const targetsOf = (value: Conditions, path: string[] = []): Array<[string[], string]> =>
+  typeof value === "string"
+    ? [[path, value]]
+    : Object.entries(value).flatMap(([condition, next]) => targetsOf(next, [...path, condition]));
+
+/** The single target the given condition path selects, e.g. `["require", "default"]`. */
+const targetAt = (value: Conditions, ...path: string[]): string => {
+  const found = targetsOf(value).filter(([p]) => p.join(".") === path.join("."));
+  if (found.length !== 1) throw new Error(`no single target at ${path.join(".")}`);
+  return found[0]![1];
+};
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const manifest = JSON.parse(readFileSync(join(root, "package.json"), "utf8")) as {
+  name: string;
+  version: string;
+  type: string;
+  bin: Record<string, string>;
+  exports: Record<string, Conditions>;
+  main: string;
+  types: string;
+  typesVersions?: Record<string, Record<string, string[]>>;
+  dependencies?: Record<string, string>;
+  optionalDependencies?: Record<string, string>;
+  peerDependencies?: Record<string, string>;
+  peerDependenciesMeta?: Record<string, { optional?: boolean }>;
+  files: string[];
+};
+
+describe("zero runtime dependencies", () => {
+  it("declares none, because every one would be a constraint the host inherits", () => {
+    // This package installs into other people's agent processes. A dependency
+    // we declare is a version they have to resolve against, in the process
+    // whose reliability we are supposed to be improving.
+    expect(manifest.dependencies ?? {}).toEqual({});
+    expect(manifest.optionalDependencies ?? {}).toEqual({});
+  });
+
+  it("marks every peer dependency optional, so npm installs none of them", () => {
+    for (const name of Object.keys(manifest.peerDependencies ?? {})) {
+      expect(manifest.peerDependenciesMeta?.[name]?.optional).toBe(true);
+    }
+  });
+
+  it("imports nothing outside node: builtins", () => {
+    const offenders: string[] = [];
+    const walk = (dir: string): void => {
+      for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const path = join(dir, entry.name);
+        if (entry.isDirectory()) {
+          walk(path);
+          continue;
+        }
+        if (!entry.name.endsWith(".ts")) continue;
+        const source = readFileSync(path, "utf8");
+        for (const match of source.matchAll(/^\s*import\s[^;]*?from\s+"([^"]+)"/gm)) {
+          const specifier = match[1]!;
+          const bare = !specifier.startsWith(".") && !specifier.startsWith("node:");
+          if (bare) offenders.push(`${path}: ${specifier}`);
+        }
+      }
+    };
+    walk(join(root, "src"));
+    // Framework imports are DYNAMIC and guarded — a static one would make
+    // `import "@failproofai/sdk"` pull LangChain into every process.
+    expect(offenders).toEqual([]);
+  });
+});
+
+describe("the published surface", () => {
+  it("builds every path its exports map promises", () => {
+    for (const [entry, conditions] of Object.entries(manifest.exports)) {
+      for (const [path, target] of targetsOf(conditions)) {
+        expect(existsSync(join(root, target)), `${entry}.${path.join(".")} -> ${target}`).toBe(true);
+      }
+    }
+  });
+
+  it("hands each module system the declarations of its own half", () => {
+    // A `.d.ts` takes its module format from the nearest package.json, exactly
+    // like a `.js`. ESM declarations under `require` told every CommonJS
+    // project on `module: node16` that a CommonJS file was an ES module
+    // (TS1479 on every import).
+    for (const [entry, conditions] of Object.entries(manifest.exports)) {
+      if (entry === "./package.json") continue;
+      if (entry === "./sandbox-worker") {
+        // CommonJS only, for both module systems: types and code agree.
+        for (const [path, target] of targetsOf(conditions)) {
+          expect(target.startsWith("./dist/cjs/"), `${entry}.${path.join(".")}`).toBe(true);
+        }
+        continue;
+      }
+      for (const [half, dir] of [
+        ["import", "./dist/esm/"],
+        ["require", "./dist/cjs/"],
+      ] as const) {
+        const types = targetAt(conditions, half, "types");
+        const code = targetAt(conditions, half, "default");
+        expect(types.startsWith(dir), `${entry}.${half}.types -> ${types}`).toBe(true);
+        expect(code.startsWith(dir), `${entry}.${half}.default -> ${code}`).toBe(true);
+        expect(types, entry).toBe(code.replace(/\.js$/, ".d.ts"));
+      }
+    }
+  });
+
+  it("gives moduleResolution: node (node10) every subpath, as CommonJS declarations", () => {
+    // node10 ignores `exports`; `typesVersions` is its only route to a subpath,
+    // and `types` to the root. A node10 project compiles to CommonJS.
+    expect(manifest.types).toBe("./dist/cjs/index.d.ts");
+    expect(manifest.main).toBe("./dist/cjs/index.js");
+    const mapping = manifest.typesVersions?.["*"] ?? {};
+    const subpaths = Object.keys(manifest.exports)
+      .filter((entry) => entry !== "." && entry !== "./package.json")
+      .map((entry) => entry.slice(2));
+    expect(Object.keys(mapping).sort()).toEqual(subpaths.sort());
+    for (const subpath of subpaths) {
+      const conditions = manifest.exports[`./${subpath}`]!;
+      const expected =
+        subpath === "sandbox-worker"
+          ? targetAt(conditions, "types")
+          : targetAt(conditions, "require", "types");
+      expect(mapping[subpath], subpath).toEqual([expected]);
+    }
+  });
+
+  it("builds the CommonJS declarations the require conditions point at", () => {
+    const cjs = readFileSync(join(root, "dist/cjs/index.d.ts"), "utf8");
+    expect(cjs).toContain("export declare function configure");
+    expect(existsSync(join(root, "dist/cjs/evaluator/sandbox-worker.d.ts"))).toBe(true);
+  });
+
+  it("tells Node which half of the dual build is CommonJS", () => {
+    // The package is `"type": "module"`, so without this every `.js` under
+    // `dist/cjs` is read as ESM and its `require` calls are a syntax error.
+    expect(manifest.type).toBe("module");
+    expect(JSON.parse(readFileSync(join(root, "dist/cjs/package.json"), "utf8"))).toEqual({
+      type: "commonjs",
+    });
+    expect(JSON.parse(readFileSync(join(root, "dist/esm/package.json"), "utf8"))).toEqual({
+      type: "module",
+    });
+  });
+
+  it("ships an executable CLI", () => {
+    const cli = join(root, manifest.bin["failproofai-evaluator"]!);
+    expect(existsSync(cli)).toBe(true);
+    expect(statSync(cli).mode & 0o111).toBeGreaterThan(0);
+    expect(readFileSync(cli, "utf8").startsWith("#!/usr/bin/env node")).toBe(true);
+  });
+
+  it("prints usage rather than a stack trace when run with no arguments", () => {
+    const cli = join(root, manifest.bin["failproofai-evaluator"]!);
+    const output = execFileSync(process.execPath, [cli, "--help"], { encoding: "utf8" });
+    expect(output).toContain("Usage: failproofai-evaluator");
+    expect(output).toContain("FAILPROOFAI_EVALUATOR_URL");
+  });
+
+  it("keeps the version in one place", () => {
+    expect(manifest.version).toBe(VERSION);
+  });
+
+  it("includes only what a consumer needs", () => {
+    expect(manifest.files).toContain("dist/");
+    expect(manifest.files).not.toContain("src/");
+    expect(manifest.files).not.toContain("test/");
+  });
+});
+
+describe("both module systems load it", () => {
+  it("works as ESM", async () => {
+    const child = await runNode(`
+      const fp = await import(${JSON.stringify(indexUrl())});
+      if (typeof fp.configure !== "function") throw new Error("configure is missing");
+      if (typeof fp.agent !== "function") throw new Error("agent is missing");
+      if (typeof fp.event.toolUse !== "function") throw new Error("event.toolUse is missing");
+      console.log(fp.version);
+    `);
+    expect(child.stderr).toBe("");
+    expect(child.stdout.trim()).toBe(VERSION);
+  });
+
+  it("works as CommonJS", async () => {
+    const cjs = JSON.stringify(join(root, "dist/cjs/index.js"));
+    const child = await runNode(`
+      const { createRequire } = await import("node:module");
+      const require_ = createRequire(${JSON.stringify(join(root, "anchor.js"))});
+      const fp = require_(${cjs});
+      if (typeof fp.configure !== "function") throw new Error("configure is missing");
+      if (typeof fp.session !== "function") throw new Error("session is missing");
+      console.log(fp.version);
+    `);
+    expect(child.stderr).toBe("");
+    expect(child.stdout.trim()).toBe(VERSION);
+  });
+
+  it("loads the evaluator and the adapters from their subpaths", async () => {
+    const require_ = createRequire(join(root, "anchor.js"));
+    for (const subpath of ["./evaluator", "./ai", "./mastra", "./langchain", "./llamaindex"]) {
+      const target = targetAt(manifest.exports[subpath]!, "require", "default");
+      expect(existsSync(join(root, target))).toBe(true);
+      expect(() => require_(join(root, target))).not.toThrow();
+    }
+  });
+
+  it("applies configure() from one copy to every copy in the process", async () => {
+    // Next.js without withFailproofai bundles a copy per route beside the one
+    // instrumentation.ts configures; the dual build loads ESM and CommonJS
+    // side by side. Per-copy settings sent the route's events out as `dev`,
+    // into whatever spool that copy defaulted to.
+    const dir = mkdtempSync(join(tmpdir(), "fpai-copies-"));
+    try {
+      const child = await runNode(`
+        const esm = await import(${JSON.stringify(indexUrl())});
+        const { createRequire } = await import("node:module");
+        const cjs = createRequire(${JSON.stringify(join(root, "anchor.js"))})(${JSON.stringify(join(root, "dist/cjs/index.js"))});
+        if (esm.configure === cjs.configure) throw new Error("expected two copies");
+        esm.configure({ environment: "prod-eu", baseDir: ${JSON.stringify(dir)} });
+        cjs.event.agentStart({ sessionId: "copies" });
+        await cjs.flush();
+      `);
+      expect(child.stderr).toBe("");
+      const events = readdirSync(join(dir, "events"))
+        .flatMap((f) => readFileSync(join(dir, "events", f), "utf8").split("\n").filter(Boolean))
+        .map((line) => JSON.parse(line) as Record<string, unknown>);
+      expect(events.map((e) => [e.session_id, e.environment])).toEqual([["copies", "prod-eu"]]);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("runs an evaluator module written as CommonJS or as ESM through the bin", () => {
+    // The bin is the ESM build. A CommonJS evals file gets `Evaluator` from
+    // `dist/cjs` — a second copy of the class — so an `instanceof` check in the
+    // loader refused it with "resolved to Evaluator, not an Evaluator", and the
+    // commonest setup (plain `tsc` output, no "type": "module") could not start.
+    const dir = mkdtempSync(join(tmpdir(), "fpai-evals-"));
+    const cjsEntry = JSON.stringify(join(root, targetAt(manifest.exports["./evaluator"]!, "require", "default")));
+    const esmEntry = JSON.stringify(
+      pathToFileURL(join(root, targetAt(manifest.exports["./evaluator"]!, "import", "default"))).href,
+    );
+    writeFileSync(
+      join(dir, "evals.cjs"),
+      `const { Evaluator } = require(${cjsEntry});\nexports.app = new Evaluator({ name: "cjs", version: "1" });\n`,
+    );
+    writeFileSync(
+      join(dir, "evals.mjs"),
+      `import { Evaluator } from ${esmEntry};\nexport const app = new Evaluator({ name: "esm", version: "1" });\n`,
+    );
+    writeFileSync(join(dir, "not-evals.cjs"), "exports.app = { runFromEnv() {} };\n");
+
+    const run = (file: string) => {
+      const env = { ...process.env };
+      delete env.FAILPROOFAI_EVALUATOR_URL;
+      delete env.FAILPROOFAI_EVALUATOR_TOKEN;
+      try {
+        execFileSync(process.execPath, [join(root, manifest.bin["failproofai-evaluator"]!), join(dir, file)], {
+          env,
+          encoding: "utf8",
+          stdio: ["ignore", "pipe", "pipe"],
+        });
+        return "";
+      } catch (error) {
+        return String((error as { stderr?: string }).stderr ?? error);
+      }
+    };
+    try {
+      // Loading succeeded when the worker gets as far as reading its config.
+      expect(run("evals.cjs")).toContain("FAILPROOFAI_EVALUATOR_URL is required");
+      expect(run("evals.mjs")).toContain("FAILPROOFAI_EVALUATOR_URL is required");
+      expect(run("not-evals.cjs")).toContain("not an Evaluator");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("does not pull a framework into the process just by being imported", async () => {
+    const child = await runNode(`
+      const fp = await import(${JSON.stringify(indexUrl())});
+      const loaded = Object.keys(await import("node:module").then((m) => m.createRequire(process.cwd() + "/x.js").cache));
+      const frameworks = loaded.filter((p) => /node_modules[\\\\/](@langchain|ai|@mastra|llamaindex)[\\\\/]/.test(p));
+      console.log(JSON.stringify(frameworks));
+    `);
+    expect(child.stderr).toBe("");
+    expect(JSON.parse(child.stdout.trim())).toEqual([]);
+  });
+});

package/.next/standalone/sdk/typescript/test/redaction.test.ts

@@ -0,0 +1,171 @@
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import { redactJsonLine, redactionEnabled, scrubString } from "../src/redact.js";
+import { runtime } from "../src/runtime.js";
+import { useSpool } from "./helpers.js";
+import type { Spool } from "./helpers.js";
+
+/**
+ * The SDK redacts before bytes reach disk; the daemon redacts again before
+ * upload. Both sides implement the same rules, so these cases are the contract
+ * between them — a rule that matches here and not there means a credential
+ * sitting in a spool file waiting for a collector that will not clean it.
+ *
+ * ## Why the fixtures are assembled rather than written out
+ *
+ * A credential-shaped literal in a source file is a credential-shaped literal,
+ * whatever the comment beside it says. This repository scans itself for exactly
+ * these prefixes (and so does every CI secret scanner worth having), so a test
+ * that spelled one out would trip its own tooling and train everybody to wave
+ * the alert through. `fake()` builds the same bytes at runtime from parts that
+ * are individually meaningless.
+ */
+const fake = (...parts: string[]): string => parts.join("");
+
+const ANTHROPIC = fake("sk-", "ant-", "api03-", "A".repeat(20));
+const GITHUB = fake("ghp", "_", "A".repeat(24));
+const GITHUB_OTHER = fake("ghp", "_", "B".repeat(24));
+const AWS = fake("AKIA", "IOSFODNN7EXAMPLE1234");
+const SLACK = fake("xoxb", "-1234567890-ABCDEFGHIJKLMNOP");
+
+describe("scrubString", () => {
+  const redacted = (value: string): string => scrubString(value)[0];
+
+  it("redacts provider key prefixes at a token boundary", () => {
+    expect(redacted(`use ${ANTHROPIC} now`)).toBe("use [redacted:anthropic-key] now");
+    expect(redacted(GITHUB)).toBe("[redacted:github-token]");
+    expect(redacted(AWS)).toBe("[redacted:aws-access-key-id]");
+    expect(redacted(SLACK)).toBe("[redacted:slack-token]");
+  });
+
+  it("leaves a prefix that is too short to be a key", () => {
+    expect(redacted(fake("sk-", "short"))).toBe("sk-short");
+  });
+
+  it("does not fire mid-token, where a match would be a coincidence", () => {
+    expect(redacted(`x${ANTHROPIC}`)).toBe(`x${ANTHROPIC}`);
+  });
+
+  it("redacts a three-segment JWT", () => {
+    const jwt = fake("eyJ", "hbGciOiJIUzI1NiJ9", ".", "a".repeat(30), ".", "b".repeat(20));
+    expect(redacted(jwt)).toBe("[redacted:jwt]");
+  });
+
+  it("redacts a bearer token, case-insensitively on the scheme", () => {
+    expect(redacted('Authorization: Bearer abcdefghijkl"')).toBe(
+      'Authorization: [redacted:bearer-token]"',
+    );
+    expect(redacted("authorization: bearer abcdefghijkl")).toBe(
+      "authorization: [redacted:bearer-token]",
+    );
+  });
+
+  it("redacts a secret-shaped assignment but not an ordinary one", () => {
+    expect(redacted("API_KEY=abcdefghijklmnop")).toBe("API_KEY=[redacted:secret-assignment]");
+    expect(redacted('DB_PASSWORD="hunter2hunter2"')).toBe(
+      'DB_PASSWORD="[redacted:secret-assignment]"',
+    );
+    // `key` on its own is too weak a name to be a secret; only a compound one
+    // counts, or the redactor eats every ordinary `key=` in a tool output.
+    expect(redacted("key=abcdefghijklmnop")).toBe("key=abcdefghijklmnop");
+    expect(redacted("NAME=abcdefghijklmnop")).toBe("NAME=abcdefghijklmnop");
+  });
+
+  it("leaves an interpolated or placeholder value alone", () => {
+    expect(redacted("API_KEY=${SECRET_FROM_VAULT}")).toBe("API_KEY=${SECRET_FROM_VAULT}");
+    expect(redacted("API_KEY=<your-key-here>")).toBe("API_KEY=<your-key-here>");
+  });
+
+  it("returns the original string when nothing matched", () => {
+    const value = "a perfectly ordinary tool output";
+    const [scrubbed, hits] = scrubString(value);
+    expect(hits).toBe(0);
+    expect(scrubbed).toBe(value);
+  });
+
+  it("counts UTF-8 bytes, not code units, for the length thresholds", () => {
+    // Two 3-byte characters is 6 bytes — under the bearer minimum of 8 — but a
+    // naive code-unit count would see 2 and a naive character count would see
+    // 2 as well, so only a byte count refuses this one and accepts the next.
+    expect(redacted("Bearer 日本")).toBe("Bearer 日本");
+    expect(redacted("Bearer 日本語日本語日本")).toBe("[redacted:bearer-token]");
+  });
+});
+
+describe("redactJsonLine", () => {
+  it("redacts values, and leaves an untouched line byte-identical", () => {
+    const clean = JSON.stringify({ type: "tool_use", input: { q: "kites" } });
+    expect(redactJsonLine(clean)).toBe(clean);
+
+    const dirty = JSON.stringify({ type: "tool_use", input: { token: GITHUB } });
+    expect(JSON.parse(redactJsonLine(dirty)).input.token).toBe("[redacted:github-token]");
+  });
+
+  it("redacts a secret-NAMED field even when the value has no recognisable shape", () => {
+    const line = JSON.stringify({ type: "t", api_secret: "totally-ordinary-looking" });
+    expect(JSON.parse(redactJsonLine(line)).api_secret).toBe("[redacted:secret-assignment]");
+  });
+
+  it("applies the field name to every element of an array value", () => {
+    const line = JSON.stringify({ type: "t", api_secret: ["aaaaaaaaaaaaaaa", "bbbbbbbbbbbbbbb"] });
+    expect(JSON.parse(redactJsonLine(line)).api_secret).toEqual([
+      "[redacted:secret-assignment]",
+      "[redacted:secret-assignment]",
+    ]);
+  });
+
+  it("keeps two keys distinct when redacting collapses them to the same name", () => {
+    const line = JSON.stringify({ [GITHUB]: 1, [GITHUB_OTHER]: 2 });
+    expect(Object.keys(JSON.parse(redactJsonLine(line)))).toEqual([
+      "[redacted:github-token]",
+      "[redacted:github-token]#2",
+    ]);
+  });
+});
+
+describe("the daemon's redaction switch", () => {
+  it("defaults to ON when there is no config at all", () => {
+    const home = mkdtempSync(join(tmpdir(), "fp-config-"));
+    expect(redactionEnabled(join(home, "custom-agents"))).toBe(true);
+  });
+
+  it("defaults to ON when the config is unreadable or malformed", () => {
+    const home = mkdtempSync(join(tmpdir(), "fp-config-"));
+    writeFileSync(join(home, "config.json"), "{ not json");
+    // Failing open here would mean one typo silently ships credentials.
+    expect(redactionEnabled(join(home, "custom-agents"))).toBe(true);
+  });
+
+  it("honours an explicit off", () => {
+    const home = mkdtempSync(join(tmpdir(), "fp-config-"));
+    writeFileSync(join(home, "config.json"), JSON.stringify({ collector: { redact: "off" } }));
+    expect(redactionEnabled(join(home, "custom-agents"))).toBe(false);
+  });
+});
+
+describe("end to end", () => {
+  let spool: Spool;
+  beforeEach(() => {
+    spool = useSpool();
+  });
+  afterEach(async () => {
+    await spool.cleanup();
+  });
+
+  it("redacts before the bytes reach disk", async () => {
+    runtime.event.toolUse({
+      sessionId: "s",
+      toolName: "shell",
+      toolCallId: "c1",
+      input: { command: "curl -H 'Authorization: Bearer abcdefghijklmnop'" },
+    });
+    await runtime.writer.flushNow();
+    const raw = spool.lines().join("");
+    expect(raw).not.toContain("abcdefghijklmnop");
+    expect(raw).toContain("[redacted:bearer-token]");
+  });
+});

package/.next/standalone/sdk/typescript/test/runtimes.test.ts

@@ -0,0 +1,101 @@
+import { spawnSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
+
+import { appImportsReachCommonJs, entryIsCommonJs, isCommonJsMain, isNextServer } from "../src/node-require.js";
+
+/**
+ * Runtime differences the SDK core has to read correctly. The end-to-end proof
+ * for each is in `integration/runtimes.*.test.ts` and `integration/nextjs.test.ts`;
+ * these pin the decisions.
+ */
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+
+describe("isCommonJsMain", () => {
+  it("reads Node's undefined and Deno's null alike: an ES-module entry", () => {
+    // Deno sets `require.main` to null for an ES-module entry. Treating that as
+    // CommonJS patched the frameworks' CommonJS copies in every ES-module Deno
+    // app, while the app ran the ES-module copies — nothing was recorded.
+    expect(isCommonJsMain(undefined)).toBe(false);
+    expect(isCommonJsMain(null)).toBe(false);
+  });
+
+  it("reads a module object as a CommonJS entry", () => {
+    expect(isCommonJsMain({ filename: "/app/index.cjs", id: "." })).toBe(true);
+  });
+});
+
+describe("appImportsReachCommonJs", () => {
+  const saved = process.env.NEXT_RUNTIME;
+  afterEach(() => {
+    if (saved === undefined) delete process.env.NEXT_RUNTIME;
+    else process.env.NEXT_RUNTIME = saved;
+  });
+
+  it("follows the entry point outside Next.js", () => {
+    delete process.env.NEXT_RUNTIME;
+    expect(isNextServer()).toBe(false);
+    expect(appImportsReachCommonJs()).toBe(entryIsCommonJs());
+  });
+
+  it("is false in a Next.js server, whatever the (CommonJS) launcher is", () => {
+    process.env.NEXT_RUNTIME = "nodejs";
+    expect(isNextServer()).toBe(true);
+    expect(appImportsReachCommonJs()).toBe(false);
+  });
+});
+
+/**
+ * The same decision from a real CommonJS entry, the shape `next start` has:
+ * Next's launcher is CommonJS, and it `import()`s every server-external
+ * package — so inside a Next server the ES-module copy is the one to patch.
+ */
+describe("requireModuleCopies under a CommonJS launcher", () => {
+  let app: string;
+
+  beforeAll(() => {
+    app = mkdtempSync(join(tmpdir(), "failproofai-launcher-"));
+    const pkg = join(app, "node_modules", "dualfw");
+    mkdirSync(join(pkg, "esm"), { recursive: true });
+    mkdirSync(join(pkg, "cjs"), { recursive: true });
+    writeFileSync(
+      join(pkg, "package.json"),
+      JSON.stringify({ name: "dualfw", exports: { ".": { import: "./esm/index.js", require: "./cjs/index.cjs" } } }),
+    );
+    writeFileSync(join(pkg, "esm", "index.js"), 'export const marker = "esm";\n');
+    writeFileSync(join(pkg, "esm", "package.json"), JSON.stringify({ type: "module" }));
+    writeFileSync(join(pkg, "cjs", "index.cjs"), 'exports.marker = "cjs";\n');
+    const compat = join(root, "dist", "cjs", "integrations", "compat.js");
+    writeFileSync(
+      join(app, "launcher.cjs"),
+      `const compat = require(${JSON.stringify(compat)});\n` +
+        `compat.requireModuleCopies("dualfw", "npm i dualfw").then((copies) => ` +
+        `console.log(JSON.stringify(copies.map((m) => m.marker))));\n`,
+    );
+  });
+
+  afterAll(() => rmSync(app, { recursive: true, force: true }));
+
+  const run = (env: Record<string, string>) => {
+    const child = spawnSync(process.execPath, [join(app, "launcher.cjs")], {
+      cwd: app,
+      encoding: "utf8",
+      env: { ...process.env, NEXT_RUNTIME: "", ...env },
+    });
+    expect(child.stderr).toBe("");
+    return JSON.parse(child.stdout.trim()) as string[];
+  };
+
+  it("patches the CommonJS copy for a plain CommonJS app", () => {
+    expect(run({})).toEqual(["cjs"]);
+  });
+
+  it("patches the ES-module copy inside a Next.js server", () => {
+    expect(run({ NEXT_RUNTIME: "nodejs" })).toEqual(["esm"]);
+  });
+});