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

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

@@ -0,0 +1,407 @@
+import { statSync } from "node:fs";
+import { join } from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { setLogger } from "../src/logger.js";
+import { runtime } from "../src/runtime.js";
+import {
+  EventWriter,
+  approxSize,
+  capFields,
+  encodeEntry,
+  roll,
+  sanitize,
+  scrubSurrogates,
+  validatedInterval,
+} from "../src/writer.js";
+import { indexUrl, runNode, useSpool } from "./helpers.js";
+import type { Spool } from "./helpers.js";
+
+let spool: Spool;
+
+beforeEach(() => {
+  spool = useSpool();
+});
+afterEach(async () => {
+  await spool.cleanup();
+  setLogger(null);
+});
+
+describe("flush interval validation", () => {
+  it("refuses a value the timer cannot run on, at the boundary", () => {
+    for (const bad of [0, -1, Number.NaN, Number.POSITIVE_INFINITY]) {
+      expect(() => validatedInterval(bad)).toThrow(/finite number greater than zero/);
+    }
+    expect(validatedInterval(0.25)).toBe(0.25);
+  });
+
+  it("leaves the writer on its old interval when a new one is rejected", () => {
+    const writer = new EventWriter(0.5);
+    try {
+      expect(() => writer.setFlushInterval(-1)).toThrow();
+      expect(writer.getFlushInterval()).toBe(0.5);
+    } finally {
+      writer.close();
+    }
+  });
+});
+
+describe("durability", () => {
+  it("publishes .jsonl files, never leaving a .tmp behind", async () => {
+    runtime.event.agentStart({ sessionId: "s" });
+    await runtime.writer.flushNow();
+    expect(spool.files()).toHaveLength(1);
+    expect(spool.files()[0]).toMatch(/^event-.*-\d+-\d+\.jsonl$/);
+  });
+
+  it("names each batch uniquely, so two in the same millisecond cannot overwrite", async () => {
+    runtime.event.agentStart({ sessionId: "s" });
+    await runtime.writer.flushNow();
+    runtime.event.agentStart({ sessionId: "s" });
+    await runtime.writer.flushNow();
+    const files = spool.files();
+    expect(new Set(files).size).toBe(2);
+    // The pid is in the stem so unrelated processes sharing one spool root
+    // cannot collide either.
+    for (const name of files) expect(name).toContain(`-${process.pid}-`);
+  });
+
+  it("writes 0600 batches inside a 0700 directory", async () => {
+    runtime.event.agentStart({ sessionId: "s" });
+    await runtime.writer.flushNow();
+    const eventsDir = join(spool.dir, "events");
+    expect(statSync(eventsDir).mode & 0o777).toBe(0o700);
+    expect(statSync(join(eventsDir, spool.files()[0]!)).mode & 0o777).toBe(0o600);
+  });
+
+  it("flushNow() writes an event emitted while another flush was already writing", async () => {
+    // The interval timer (or a second caller) can be mid-write when you call
+    // `flush()`. That flush drained the queue BEFORE this event arrived, so
+    // returning it — what flushNow() used to do — resolved with the newest
+    // event still in memory, breaking "resolves once your events are on disk"
+    // for exactly the emit-flush-exit script it exists for.
+    runtime.event.agentStart({ sessionId: "s" });
+    const alreadyWriting = runtime.writer.flushNow();
+    runtime.event.agentEnd({ sessionId: "s" });
+    await runtime.writer.flushNow();
+    expect(spool.events().map((e) => e.type)).toEqual(["agent_start", "agent_end"]);
+    await alreadyWriting;
+  });
+
+  it("ends every batch file with a newline, as the collector's line reader expects", async () => {
+    runtime.event.agentStart({ sessionId: "s" });
+    await runtime.writer.flushNow();
+    const raw = spool.lines();
+    expect(raw).toHaveLength(1);
+    expect(JSON.parse(raw[0]!)).toMatchObject({ type: "agent_start" });
+  });
+});
+
+describe("encoding isolation", () => {
+  it("drops ONE unencodable event rather than the batch around it", async () => {
+    const circular: Record<string, unknown> = { name: "loop" };
+    circular.self = circular;
+    setLogger({ debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() });
+
+    runtime.event.agentStart({ sessionId: "s", fw_before: 1 });
+    runtime.event.agentStart({ sessionId: "s", fw_cycle: circular });
+    runtime.event.agentStart({ sessionId: "s", fw_after: 1 });
+    await runtime.writer.flushNow();
+
+    const events = spool.events();
+    expect(events).toHaveLength(3);
+    // The cyclic one is still published — sanitized, not dropped.
+    expect(events[1]!.fw_cycle).toEqual({ name: "loop", self: "<circular reference>" });
+  });
+
+  it("sanitizes a cycle rather than failing the event", () => {
+    const node: Record<string, unknown> = { a: 1 };
+    node.self = node;
+    expect(sanitize(node, new Set())).toEqual({ a: 1, self: "<circular reference>" });
+  });
+
+  it("does not mistake a DAG for a cycle", () => {
+    const shared = { value: 1 };
+    expect(sanitize({ left: shared, right: shared }, new Set())).toEqual({
+      left: { value: 1 },
+      right: { value: 1 },
+    });
+  });
+
+  it("makes a lone surrogate inert, which ingest would otherwise skip at 200 OK", () => {
+    expect(scrubSurrogates("ok\ud800bad")).toBe("ok\\ud800bad");
+    // A well-formed pair is left alone.
+    expect(scrubSurrogates("emoji \u{1F600}")).toBe("emoji \u{1F600}");
+  });
+
+  it("scrubs a lone surrogate in a KEY as well as a value", () => {
+    // An unscrubbed key reaches the wire as a JSON lone-surrogate escape, ingest
+    // answers 200 with `{"accepted":0,"skipped":1}`, and the uploader parks that
+    // batch and poisons it after three retries — so one bad key loses every
+    // event batched with it. A filesystem path, the realistic source, is most
+    // naturally a key.
+    const encoded = encodeEntry({ type: "t", ["path\udcff"]: "x", value: "v\udcff" })!;
+    // No RAW surrogate survives anywhere in the line...
+    expect(/[\uD800-\uDFFF]/.test(encoded)).toBe(false);
+    // ...and both the key and the value carry the byte visibly instead.
+    const parsed = JSON.parse(encoded) as Record<string, unknown>;
+    expect(Object.keys(parsed)).toContain(String.raw`path\udcff`);
+    expect(parsed.value).toBe(String.raw`v\udcff`);
+  });
+
+  it("writes a non-finite number as null rather than invalid JSON", () => {
+    const encoded = encodeEntry({ type: "t", value: Number.NaN, other: Number.POSITIVE_INFINITY })!;
+    expect(JSON.parse(encoded)).toEqual({ type: "t", value: null, other: null });
+  });
+
+  it("encodes the values JSON.stringify refuses", () => {
+    const encoded = encodeEntry({
+      type: "t",
+      big: 1n,
+      set: new Set([1, 2]),
+      map: new Map([["a", 1]]),
+      when: new Date("2026-01-01T00:00:00Z"),
+    })!;
+    expect(JSON.parse(encoded)).toEqual({
+      type: "t",
+      big: "1",
+      set: [1, 2],
+      map: { a: 1 },
+      when: "2026-01-01T00:00:00.000Z",
+    });
+  });
+
+  it("never lets a throwing getter escape the encoder", () => {
+    const hostile = {
+      type: "t",
+      get boom(): never {
+        throw new Error("from the caller's own code");
+      },
+    };
+    setLogger({ debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() });
+    expect(() => encodeEntry(hostile)).not.toThrow();
+  });
+});
+
+describe("size bounds", () => {
+  it("caps an oversized event's fields so the collector can still deliver the batch", () => {
+    const huge = "x".repeat(5 * 1024 * 1024);
+    const encoded = encodeEntry({ type: "tool_result", output: huge })!;
+    expect(Buffer.byteLength(encoded, "utf8")).toBeLessThan(4 * 1024 * 1024);
+    expect(JSON.parse(encoded).output).toContain("…[truncated]");
+  });
+
+  it("never splits a surrogate pair when it truncates", () => {
+    const capped = capFields("\u{1F600}".repeat(10), 5) as string;
+    expect(capped.endsWith("…[truncated]")).toBe(true);
+    expect(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])/.test(capped)).toBe(false);
+  });
+
+  it("rolls lines into batches that each stay under the limit", () => {
+    const lines = Array.from({ length: 5 }, () => ({ text: "x".repeat(40), bytes: 40 }));
+    const chunks = roll(lines, 100);
+    expect(chunks.map((chunk) => chunk.length)).toEqual([2, 2, 1]);
+  });
+
+  it("emits an over-limit line alone rather than dropping it", () => {
+    const chunks = roll(
+      [
+        { text: "a", bytes: 1 },
+        { text: "b", bytes: 500 },
+      ],
+      100,
+    );
+    expect(chunks).toHaveLength(2);
+    expect(chunks[1]![0]!.bytes).toBe(500);
+  });
+
+  it("sizes a value by walking nodes, not characters", () => {
+    expect(approxSize("abcd")).toBe(4);
+    expect(approxSize({ a: "bb" })).toBe(3);
+    expect(approxSize([1, 2, 3])).toBe(24);
+  });
+});
+
+describe("queue bounds", () => {
+  it("discards the OLDEST events when the queue stops draining, and says so once", () => {
+    const warn = vi.fn();
+    setLogger({ debug: vi.fn(), info: vi.fn(), warn, error: vi.fn() });
+    const writer = new EventWriter(3600);
+    try {
+      for (let i = 0; i < 10_050; i += 1) writer.submit({ type: "t", index: i });
+      const stats = writer.stats();
+      expect(stats.queued).toBeLessThanOrEqual(10_000);
+      expect(stats.dropped).toBeGreaterThan(0);
+      expect(warn).toHaveBeenCalledWith(expect.stringContaining("queue is full"));
+    } finally {
+      writer.close();
+    }
+  });
+
+  it("bounds by BYTES as well as by count, because a count is not a memory bound", () => {
+    const writer = new EventWriter(3600);
+    try {
+      const chunk = "x".repeat(2 * 1024 * 1024);
+      for (let i = 0; i < 64; i += 1) writer.submit({ type: "t", blob: chunk });
+      // 64 x 2 MiB is 128 MiB, well past the 64 MiB ceiling, and far under the
+      // 10,000-event count cap — so only the byte bound can have stopped it.
+      expect(writer.stats().queuedBytes).toBeLessThanOrEqual(64 * 1024 * 1024);
+      expect(writer.stats().dropped).toBeGreaterThan(0);
+    } finally {
+      writer.close();
+    }
+  });
+});
+
+describe("process lifetime", () => {
+  it("lets a script that merely imports it exit, and flushes on the way out", async () => {
+    // The flush interval MUST be unref'd. Without that, importing this SDK
+    // stops every script that uses it from ever exiting — the most visible bug
+    // a telemetry library can ship, and one no in-process assertion can catch,
+    // because the test runner keeps the loop alive by itself.
+    const child = await runNode(`
+      const fp = await import(${JSON.stringify(indexUrl())});
+      fp.configure({ baseDir: ${JSON.stringify(spool.dir)}, flushInterval: 3600 });
+      fp.event.agentStart({ sessionId: "exit-test" });
+      console.log("emitted");
+    `);
+    expect(child.code).toBe(0);
+    expect(child.stdout.trim()).toBe("emitted");
+    // The exit hook is the only thing that can have written this: the interval
+    // was set to an hour.
+    expect(spool.events().map((event) => event.session_id)).toEqual(["exit-test"]);
+  });
+
+  it("closes the runs a SIGTERM abandons, so none renders as running forever", async () => {
+    // The documented shutdown recipe, killed mid-tool. It used to leave an
+    // agent_start with no agent_end and a tool_use with no tool_result, and
+    // exit 0 — every deploy stranded the runs it interrupted.
+    const child = await runNode(`
+      const fp = await import(${JSON.stringify(indexUrl())});
+      fp.configure({ baseDir: ${JSON.stringify(spool.dir)}, flushInterval: 3600 });
+      for (const signal of ["SIGINT", "SIGTERM"]) {
+        process.once(signal, () => { fp.flushSync(); process.exit(0); });
+      }
+      setInterval(() => {}, 1000); // a service's server keeps the loop alive
+      setTimeout(() => process.kill(process.pid, "SIGTERM"), 50);
+      await fp.agent("svc", { sessionId: "term-test" }, async () => {
+        await fp.agent("writer", async () => {
+          await fp.toolCall("slow", { toolCallId: "t1" }, () => new Promise(() => {}));
+        });
+      });
+    `);
+    expect(child.code).toBe(0);
+    const events = spool.events();
+    expect(events.map((e) => [e.agent_id, e.type])).toEqual([
+      ["svc", "agent_start"],
+      ["writer", "agent_start"],
+      ["writer", "tool_use"],
+      ["writer", "tool_result"],
+      ["writer", "error"],
+      ["writer", "agent_end"],
+      ["svc", "error"],
+      ["svc", "agent_end"],
+    ]);
+    const result = events.find((e) => e.type === "tool_result")!;
+    expect(result.tool_call_id).toBe("t1");
+    expect(result.error).toMatch(/^ProcessExit: the process exited \(code 0\) while tool "slow"/);
+    for (const end of events.filter((e) => e.type === "agent_end")) expect(end.outcome).toBe("failed");
+    expect(events.find((e) => e.type === "error")!.error_type).toBe("ProcessExit");
+  });
+
+  it("closes a hand-written model call left open by a SIGTERM", async () => {
+    // The no-framework recipe: modelRequest before the provider call,
+    // modelResponse after. Killed in between, the request had no response and
+    // rendered as running forever.
+    const child = await runNode(`
+      const fp = await import(${JSON.stringify(indexUrl())});
+      fp.configure({ baseDir: ${JSON.stringify(spool.dir)}, flushInterval: 3600 });
+      process.once("SIGTERM", () => { fp.flushSync(); process.exit(143); });
+      setInterval(() => {}, 1000);
+      setTimeout(() => process.kill(process.pid, "SIGTERM"), 50);
+      await fp.agent("planner", { sessionId: "model-term" }, async () => {
+        fp.event.modelRequest({ model: "m", requestId: "r1" });
+        await new Promise(() => {});
+      });
+    `);
+    expect(child.code).toBe(143);
+    const events = spool.events();
+    expect(events.map((e) => e.type)).toEqual(["agent_start", "model_request", "model_response", "error", "agent_end"]);
+    const response = events[2]!;
+    expect(response.request_id).toBe("r1");
+    expect(response.stop_reason).toBe("error");
+    expect(response.error).toMatch(/^ProcessExit: the process exited \(code 143\) while the model call/);
+    // Timed like the tools and hooks closed beside it.
+    expect(typeof response.duration_ms).toBe("number");
+  });
+
+  it("names the uncaught exception a crash exited on, in what it closes", async () => {
+    // A timer throwing mid-run used to leave only "the process exited (code 1)"
+    // in the trace — the exception itself was nowhere.
+    const child = await runNode(`
+      const fp = await import(${JSON.stringify(indexUrl())});
+      fp.configure({ baseDir: ${JSON.stringify(spool.dir)}, flushInterval: 3600 });
+      setInterval(() => {}, 1000);
+      class QuotaError extends Error {}
+      setTimeout(() => { throw new QuotaError("boom from a timer"); }, 50);
+      await fp.agent("svc", { sessionId: "crash" }, async () => {
+        await fp.toolCall("slow", { toolCallId: "t1" }, () => new Promise(() => {}));
+      });
+    `);
+    expect(child.code).toBe(1);
+    expect(child.stderr).toContain("boom from a timer"); // still crashes as it would have
+    const events = spool.events();
+    expect(events.map((e) => e.type)).toEqual(["agent_start", "tool_use", "tool_result", "error", "agent_end"]);
+    expect(events[2]!.error).toMatch(/\(code 1\) on an uncaught QuotaError: boom from a timer while tool "slow"/);
+    expect(events[3]!.message).toMatch(/on an uncaught QuotaError: boom from a timer/);
+  });
+
+  it("closes a nested run most-recent-first: a sub-agent ends before the tool that started it", async () => {
+    // Live: a planner's delegate tool ran a writer sub-agent, killed during the
+    // writer's model call. Closing all tools before all agents showed the
+    // delegate tool finishing while the writer it started was still running.
+    const child = await runNode(`
+      const fp = await import(${JSON.stringify(indexUrl())});
+      fp.configure({ baseDir: ${JSON.stringify(spool.dir)}, flushInterval: 3600 });
+      process.once("SIGTERM", () => { fp.flushSync(); process.exit(143); });
+      setInterval(() => {}, 1000);
+      setTimeout(() => process.kill(process.pid, "SIGTERM"), 50);
+      await fp.agent("planner", { sessionId: "nested-term" }, async () => {
+        await fp.toolCall("delegate_writer", { toolCallId: "d1" }, async () => {
+          await fp.agent("writer", async () => {
+            fp.event.modelRequest({ model: "m", requestId: "w1" });
+            await new Promise(() => {});
+          });
+        });
+      });
+    `);
+    expect(child.code).toBe(143);
+    const closing = spool.events().slice(4); // planner start, tool_use, writer start, model_request
+    expect(closing.map((e) => [e.agent_id, e.type])).toEqual([
+      ["writer", "model_response"],
+      ["writer", "error"],
+      ["writer", "agent_end"],
+      ["planner", "tool_result"],
+      ["planner", "error"],
+      ["planner", "agent_end"],
+    ]);
+    expect(closing.find((e) => e.type === "error")!.traceback).toBeUndefined();
+  });
+
+  it("closes nothing on a flushSync() while the process carries on", async () => {
+    const child = await runNode(`
+      const fp = await import(${JSON.stringify(indexUrl())});
+      fp.configure({ baseDir: ${JSON.stringify(spool.dir)}, flushInterval: 3600 });
+      await fp.agent("svc", { sessionId: "flush-test" }, async () => {
+        fp.flushSync();
+        await new Promise((r) => setTimeout(r, 10));
+      });
+    `);
+    expect(child.code).toBe(0);
+    expect(spool.events().map((e) => [e.type, e.outcome ?? null])).toEqual([
+      ["agent_start", null],
+      ["agent_end", "success"],
+    ]);
+  });
+});

package/.next/standalone/sdk/typescript/tsconfig.build.json

@@ -0,0 +1,15 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist/esm",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "noEmit": false,
+    // `@internal` exports (test hooks such as `_stats`, `_internals`,
+    // `attach`) stay out of the published declarations: a name in a `.d.ts`
+    // is a name a customer can come to depend on.
+    "stripInternal": true
+  },
+  "include": ["src/**/*.ts"]
+}

package/.next/standalone/sdk/typescript/tsconfig.cjs.json

@@ -0,0 +1,19 @@
+{
+  "extends": "./tsconfig.json",
+  // Declarations are emitted here too, and `exports[*].require.types` points
+  // at them. Under dist/cjs's `"type": "commonjs"` they ARE CommonJS
+  // declarations; handing `require` the ESM ones instead is what made every
+  // CommonJS project on `module: node16` fail with TS1479.
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist/cjs",
+    "module": "CommonJS",
+    "moduleResolution": "Node10",
+    "noEmit": false,
+    // `@internal` exports (test hooks such as `_stats`, `_internals`,
+    // `attach`) stay out of the published declarations: a name in a `.d.ts`
+    // is a name a customer can come to depend on.
+    "stripInternal": true
+  },
+  "include": ["src/**/*.ts"]
+}

package/.next/standalone/sdk/typescript/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2023", "ESNext.Disposable"],
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "types": ["node"],
+
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": false,
+    "noImplicitOverride": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "useUnknownInCatchVariables": true,
+    "verbatimModuleSyntax": false,
+
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "isolatedModules": true
+  },
+  "include": ["src/**/*.ts", "test/**/*.ts", "integration/*.ts", "scripts/**/*.mjs", "*.ts", "*.mts"]
+}

package/.next/standalone/sdk/typescript/vitest.config.ts

@@ -0,0 +1,33 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  // Vite searches UPWARD from the project root for a PostCSS config, and this
+  // package sits inside a monorepo whose root has one — which requires
+  // `@tailwindcss/postcss`, a root devDependency that is deliberately not in
+  // this package's isolated `node_modules`. Vite then dies before a single test
+  // runs.
+  //
+  // It only fails where the isolation is real: locally the root's
+  // `node_modules` is present and Node's resolution walks up into it, so the
+  // search succeeds and nothing looks wrong. In CI, where this package is
+  // installed on its own, it is fatal.
+  //
+  // An inline (empty) config turns the search off. This package has no CSS at
+  // all, so there is nothing to configure — the only thing that search can do
+  // here is find somebody else's tooling.
+  css: { postcss: {} },
+  test: {
+    include: ["test/**/*.test.ts"],
+    environment: "node",
+    globalSetup: ["./test/global-setup.ts"],
+    setupFiles: ["./test/setup.ts"],
+    // The writer, the sandbox and the adapters all reach for process-wide state
+    // (an exit hook, a patched prototype, a spool directory). Running files one
+    // at a time keeps a test from observing another file's patch, and keeps the
+    // sandbox suite from competing with itself for the concurrency semaphore.
+    pool: "forks",
+    fileParallelism: false,
+    testTimeout: 30_000,
+    hookTimeout: 30_000,
+  },
+});

package/.next/standalone/sdk/typescript/vitest.integration.config.ts

@@ -0,0 +1,23 @@
+import { defineConfig } from "vitest/config";
+
+/**
+ * The real-framework suite (`integration/`). Separate from `vitest.config.ts`
+ * because it installs real frameworks from the registry and spawns real Node
+ * processes against the PACKED artifact — minutes, not seconds, and it needs
+ * the network the unit suite deliberately does not.
+ */
+export default defineConfig({
+  // Same reason as vitest.config.ts: stop Vite finding the monorepo root's
+  // PostCSS config, which needs a package this isolated install does not have.
+  css: { postcss: {} },
+  test: {
+    include: ["integration/**/*.test.ts"],
+    environment: "node",
+    globalSetup: ["./integration/global-setup.ts"],
+    // Every case is its own child process with its own spool, so files are
+    // independent and can run side by side.
+    fileParallelism: true,
+    testTimeout: 120_000,
+    hookTimeout: 900_000,
+  },
+});

package/.next/standalone/server.js

@@ -9,7 +9,7 @@ const currentPort = parseInt(process.env.PORT, 10) || 3000
 const hostname = process.env.HOSTNAME || '0.0.0.0'
 
 let keepAliveTimeout = parseInt(process.env.KEEP_ALIVE_TIMEOUT, 10)
-const nextConfig = {"env":{"NEXT_PUBLIC_APP_VERSION":"1.0.7-beta.1"},"typescript":{"ignoreBuildErrors":false},"typedRoutes":false,"distDir":"./.next","cleanDistDir":true,"assetPrefix":"","cacheMaxMemorySize":52428800,"configOrigin":"next.config.ts","useFileSystemPublicRoutes":true,"generateEtags":true,"pageExtensions":["tsx","ts","jsx","js"],"instrumentationClientInject":[],"poweredByHeader":true,"compress":true,"images":{"deviceSizes":[640,750,828,1080,1200,1920,2048,3840],"imageSizes":[32,48,64,96,128,256,384],"path":"/_next/image","loader":"default","loaderFile":"","domains":[],"disableStaticImages":false,"minimumCacheTTL":14400,"formats":["image/webp"],"maximumRedirects":3,"maximumResponseBody":50000000,"dangerouslyAllowLocalIP":false,"dangerouslyAllowSVG":false,"contentSecurityPolicy":"script-src 'none'; frame-src 'none'; sandbox;","contentDispositionType":"attachment","localPatterns":[{"pathname":"**","search":""}],"remotePatterns":[],"qualities":[75],"unoptimized":true,"customCacheHandler":false},"devIndicators":{"position":"bottom-left"},"onDemandEntries":{"maxInactiveAge":60000,"pagesBufferLength":5},"basePath":"","sassOptions":{},"trailingSlash":false,"i18n":null,"productionBrowserSourceMaps":false,"excludeDefaultMomentLocales":true,"reactProductionProfiling":false,"reactStrictMode":null,"reactMaxHeadersLength":6000,"httpAgentOptions":{"keepAlive":true},"logging":{"serverFunctions":true,"browserToTerminal":"warn"},"compiler":{},"expireTime":31536000,"staticPageGenerationTimeout":60,"output":"standalone","modularizeImports":{"@mui/icons-material":{"transform":"@mui/icons-material/{{member}}"},"lodash":{"transform":"lodash/{{member}}"}},"outputFileTracingRoot":"/home/runner/work/failproofai/failproofai","enablePrerenderSourceMaps":true,"cacheComponents":false,"cacheLife":{"default":{"stale":300,"revalidate":900,"expire":4294967294},"seconds":{"stale":30,"revalidate":1,"expire":60},"minutes":{"stale":300,"revalidate":60,"expire":3600},"hours":{"stale":300,"revalidate":3600,"expire":86400},"days":{"stale":300,"revalidate":86400,"expire":604800},"weeks":{"stale":300,"revalidate":604800,"expire":2592000},"max":{"stale":300,"revalidate":2592000,"expire":31536000}},"cacheHandlers":{},"experimental":{"appNewScrollHandler":true,"coldCacheBadge":false,"devValidationWorker":true,"useSkewCookie":false,"cssChunking":true,"multiZoneDraftMode":false,"appNavFailHandling":false,"prerenderEarlyExit":true,"serverMinification":true,"linkNoTouchStart":false,"caseSensitiveRoutes":false,"cachedNavigations":false,"dynamicOnHover":false,"useOffline":false,"varyParams":true,"optimisticRouting":true,"instrumentationClientRouterTransitionEvents":false,"prefetchInlining":{"maxSize":2048,"maxBundleSize":10240},"preloadEntriesOnStart":true,"clientRouterFilter":true,"clientRouterFilterRedirects":false,"fetchCacheKeyPrefix":"","proxyPrefetch":"flexible","optimisticClientCache":true,"manualClientBasePath":false,"cpus":3,"memoryBasedWorkersCount":false,"imgOptConcurrency":null,"imgOptOperationCache":null,"imgOptTimeoutInSeconds":7,"imgOptMaxInputPixels":268402689,"imgOptSequentialRead":null,"isrFlushToDisk":true,"workerThreads":false,"optimizeCss":false,"nextScriptWorkers":false,"scrollRestoration":false,"externalDir":false,"devMemoryThresholdRestart":true,"disableOptimizedLoading":false,"gzipSize":true,"craCompat":false,"esmExternals":true,"fullySpecified":false,"swcTraceProfiling":false,"forceSwcTransforms":false,"requestInsights":false,"largePageDataBytes":128000,"typedEnv":false,"parallelServerCompiles":false,"parallelServerBuildTraces":false,"ppr":false,"authInterrupts":false,"webpackMemoryOptimizations":false,"optimizeServerReact":true,"strictRouteTypes":false,"useTypeScriptCli":true,"removeUncaughtErrorAndRejectionListeners":false,"validateRSCRequestHeaders":true,"staleTimes":{"dynamic":0,"static":300},"reactDebugChannel":true,"serverComponentsHmrCache":true,"serverComponentsHmrCancellation":false,"staticGenerationMaxConcurrency":8,"staticGenerationMinPagesPerWorker":25,"transitionIndicator":false,"gestureTransition":false,"inlineCss":false,"useCache":false,"globalNotFound":false,"browserDebugInfoInTerminal":"warn","lockDistDir":true,"proxyClientMaxBodySize":10485760,"hideLogsAfterAbort":false,"mcpServer":true,"turbopackFileSystemCacheForDev":true,"turbopackFileSystemCacheForBuild":true,"turbopackInferModuleSideEffects":true,"turbopackPluginRuntimeStrategy":"childProcesses","turbopackMemoryEvictionMode":"auto","optimizePackageImports":["lucide-react","date-fns","lodash-es","ramda","antd","react-bootstrap","ahooks","@ant-design/icons","@headlessui/react","@headlessui-float/react","@heroicons/react/20/solid","@heroicons/react/24/solid","@heroicons/react/24/outline","@visx/visx","@tremor/react","rxjs","@mui/material","@mui/icons-material","recharts","react-use","effect","@effect/schema","@effect/platform","@effect/platform-node","@effect/platform-browser","@effect/platform-bun","@effect/sql","@effect/sql-mssql","@effect/sql-mysql2","@effect/sql-pg","@effect/sql-sqlite-node","@effect/sql-sqlite-bun","@effect/sql-sqlite-wasm","@effect/sql-sqlite-react-native","@effect/rpc","@effect/rpc-http","@effect/typeclass","@effect/experimental","@effect/opentelemetry","@material-ui/core","@material-ui/icons","@tabler/icons-react","mui-core","react-icons/ai","react-icons/bi","react-icons/bs","react-icons/cg","react-icons/ci","react-icons/di","react-icons/fa","react-icons/fa6","react-icons/fc","react-icons/fi","react-icons/gi","react-icons/go","react-icons/gr","react-icons/hi","react-icons/hi2","react-icons/im","react-icons/io","react-icons/io5","react-icons/lia","react-icons/lib","react-icons/lu","react-icons/md","react-icons/pi","react-icons/ri","react-icons/rx","react-icons/si","react-icons/sl","react-icons/tb","react-icons/tfi","react-icons/ti","react-icons/vsc","react-icons/wi"],"useCacheTimeout":54,"instantInsights":{"validationLevel":"warning"},"trustHostHeader":false,"isExperimentalCompile":false},"htmlLimitedBots":"[\\w-]+-Google|Google-[\\w-]+|Chrome-Lighthouse|Slurp|DuckDuckBot|baiduspider|yandex|sogou|bitlybot|tumblr|vkShare|quora link preview|redditbot|ia_archiver|Bingbot|BingPreview|applebot|facebookexternalhit|facebookcatalog|Twitterbot|LinkedInBot|Slackbot|Discordbot|WhatsApp|SkypeUriPreview|Yeti|googleweblight","bundlePagesRouterDependencies":false,"configFileName":"next.config.ts","outputFileTracingExcludes":{"*":["node_modules/@img/**","node_modules/sharp/**"]},"turbopack":{"root":"/home/runner/work/failproofai/failproofai"},"repoRoot":"/home/runner/work/failproofai/failproofai","distDirRoot":".next"}
+const nextConfig = {"env":{"NEXT_PUBLIC_APP_VERSION":"1.0.7-beta.2"},"typescript":{"ignoreBuildErrors":false},"typedRoutes":false,"distDir":"./.next","cleanDistDir":true,"assetPrefix":"","cacheMaxMemorySize":52428800,"configOrigin":"next.config.ts","useFileSystemPublicRoutes":true,"generateEtags":true,"pageExtensions":["tsx","ts","jsx","js"],"instrumentationClientInject":[],"poweredByHeader":true,"compress":true,"images":{"deviceSizes":[640,750,828,1080,1200,1920,2048,3840],"imageSizes":[32,48,64,96,128,256,384],"path":"/_next/image","loader":"default","loaderFile":"","domains":[],"disableStaticImages":false,"minimumCacheTTL":14400,"formats":["image/webp"],"maximumRedirects":3,"maximumResponseBody":50000000,"dangerouslyAllowLocalIP":false,"dangerouslyAllowSVG":false,"contentSecurityPolicy":"script-src 'none'; frame-src 'none'; sandbox;","contentDispositionType":"attachment","localPatterns":[{"pathname":"**","search":""}],"remotePatterns":[],"qualities":[75],"unoptimized":true,"customCacheHandler":false},"devIndicators":{"position":"bottom-left"},"onDemandEntries":{"maxInactiveAge":60000,"pagesBufferLength":5},"basePath":"","sassOptions":{},"trailingSlash":false,"i18n":null,"productionBrowserSourceMaps":false,"excludeDefaultMomentLocales":true,"reactProductionProfiling":false,"reactStrictMode":null,"reactMaxHeadersLength":6000,"httpAgentOptions":{"keepAlive":true},"logging":{"serverFunctions":true,"browserToTerminal":"warn"},"compiler":{},"expireTime":31536000,"staticPageGenerationTimeout":60,"output":"standalone","modularizeImports":{"@mui/icons-material":{"transform":"@mui/icons-material/{{member}}"},"lodash":{"transform":"lodash/{{member}}"}},"outputFileTracingRoot":"/home/runner/work/failproofai/failproofai","enablePrerenderSourceMaps":true,"cacheComponents":false,"cacheLife":{"default":{"stale":300,"revalidate":900,"expire":4294967294},"seconds":{"stale":30,"revalidate":1,"expire":60},"minutes":{"stale":300,"revalidate":60,"expire":3600},"hours":{"stale":300,"revalidate":3600,"expire":86400},"days":{"stale":300,"revalidate":86400,"expire":604800},"weeks":{"stale":300,"revalidate":604800,"expire":2592000},"max":{"stale":300,"revalidate":2592000,"expire":31536000}},"cacheHandlers":{},"experimental":{"appNewScrollHandler":true,"coldCacheBadge":false,"devValidationWorker":true,"useSkewCookie":false,"cssChunking":true,"multiZoneDraftMode":false,"appNavFailHandling":false,"prerenderEarlyExit":true,"serverMinification":true,"linkNoTouchStart":false,"caseSensitiveRoutes":false,"cachedNavigations":false,"dynamicOnHover":false,"useOffline":false,"varyParams":true,"optimisticRouting":true,"instrumentationClientRouterTransitionEvents":false,"prefetchInlining":{"maxSize":2048,"maxBundleSize":10240},"preloadEntriesOnStart":true,"clientRouterFilter":true,"clientRouterFilterRedirects":false,"fetchCacheKeyPrefix":"","proxyPrefetch":"flexible","optimisticClientCache":true,"manualClientBasePath":false,"cpus":3,"memoryBasedWorkersCount":false,"imgOptConcurrency":null,"imgOptOperationCache":null,"imgOptTimeoutInSeconds":7,"imgOptMaxInputPixels":268402689,"imgOptSequentialRead":null,"isrFlushToDisk":true,"workerThreads":false,"optimizeCss":false,"nextScriptWorkers":false,"scrollRestoration":false,"externalDir":false,"devMemoryThresholdRestart":true,"disableOptimizedLoading":false,"gzipSize":true,"craCompat":false,"esmExternals":true,"fullySpecified":false,"swcTraceProfiling":false,"forceSwcTransforms":false,"requestInsights":false,"largePageDataBytes":128000,"typedEnv":false,"parallelServerCompiles":false,"parallelServerBuildTraces":false,"ppr":false,"authInterrupts":false,"webpackMemoryOptimizations":false,"optimizeServerReact":true,"strictRouteTypes":false,"useTypeScriptCli":true,"removeUncaughtErrorAndRejectionListeners":false,"validateRSCRequestHeaders":true,"staleTimes":{"dynamic":0,"static":300},"reactDebugChannel":true,"serverComponentsHmrCache":true,"serverComponentsHmrCancellation":false,"staticGenerationMaxConcurrency":8,"staticGenerationMinPagesPerWorker":25,"transitionIndicator":false,"gestureTransition":false,"inlineCss":false,"useCache":false,"globalNotFound":false,"browserDebugInfoInTerminal":"warn","lockDistDir":true,"proxyClientMaxBodySize":10485760,"hideLogsAfterAbort":false,"mcpServer":true,"turbopackFileSystemCacheForDev":true,"turbopackFileSystemCacheForBuild":true,"turbopackInferModuleSideEffects":true,"turbopackPluginRuntimeStrategy":"childProcesses","turbopackMemoryEvictionMode":"auto","optimizePackageImports":["lucide-react","date-fns","lodash-es","ramda","antd","react-bootstrap","ahooks","@ant-design/icons","@headlessui/react","@headlessui-float/react","@heroicons/react/20/solid","@heroicons/react/24/solid","@heroicons/react/24/outline","@visx/visx","@tremor/react","rxjs","@mui/material","@mui/icons-material","recharts","react-use","effect","@effect/schema","@effect/platform","@effect/platform-node","@effect/platform-browser","@effect/platform-bun","@effect/sql","@effect/sql-mssql","@effect/sql-mysql2","@effect/sql-pg","@effect/sql-sqlite-node","@effect/sql-sqlite-bun","@effect/sql-sqlite-wasm","@effect/sql-sqlite-react-native","@effect/rpc","@effect/rpc-http","@effect/typeclass","@effect/experimental","@effect/opentelemetry","@material-ui/core","@material-ui/icons","@tabler/icons-react","mui-core","react-icons/ai","react-icons/bi","react-icons/bs","react-icons/cg","react-icons/ci","react-icons/di","react-icons/fa","react-icons/fa6","react-icons/fc","react-icons/fi","react-icons/gi","react-icons/go","react-icons/gr","react-icons/hi","react-icons/hi2","react-icons/im","react-icons/io","react-icons/io5","react-icons/lia","react-icons/lib","react-icons/lu","react-icons/md","react-icons/pi","react-icons/ri","react-icons/rx","react-icons/si","react-icons/sl","react-icons/tb","react-icons/tfi","react-icons/ti","react-icons/vsc","react-icons/wi"],"useCacheTimeout":54,"instantInsights":{"validationLevel":"warning"},"trustHostHeader":false,"isExperimentalCompile":false},"htmlLimitedBots":"[\\w-]+-Google|Google-[\\w-]+|Chrome-Lighthouse|Slurp|DuckDuckBot|baiduspider|yandex|sogou|bitlybot|tumblr|vkShare|quora link preview|redditbot|ia_archiver|Bingbot|BingPreview|applebot|facebookexternalhit|facebookcatalog|Twitterbot|LinkedInBot|Slackbot|Discordbot|WhatsApp|SkypeUriPreview|Yeti|googleweblight","bundlePagesRouterDependencies":false,"configFileName":"next.config.ts","outputFileTracingExcludes":{"*":["node_modules/@img/**","node_modules/sharp/**"]},"turbopack":{"root":"/home/runner/work/failproofai/failproofai"},"repoRoot":"/home/runner/work/failproofai/failproofai","distDirRoot":".next"}
 
 process.env.__NEXT_PRIVATE_STANDALONE_CONFIG = JSON.stringify(nextConfig)
 

package/README.md

@@ -18,7 +18,7 @@
 Wherever your agents run, we see it — and we can say no. Failproof hooks 12 agent
 harnesses — coding CLIs like Claude Code and Codex, chat gateways like Hermes,
 self-hosted assistants like OpenClaw — capturing every run and blocking dangerous
-tool calls before they execute. 39 built-in policies. Zero latency. Runs locally.
+tool calls before they execute. 40 built-in policies. Zero latency. Runs locally.
 
 </div>
 
@@ -176,7 +176,7 @@ three are the developer favourites — coding CLIs are the harness class we cove
 deepest. The `sanitize-*` family is separate: it runs after a tool returns, so
 it reports a secret in tool output rather than keeping it out of the context.
 
-→ [All 39 built-in policies](https://docs.befailproof.ai/policies/packs)
+→ [All 40 built-in policies](https://docs.befailproof.ai/policies/packs)
 
 ---