import { describe, expect, it } from "@effect/vitest";import { Effect, Exit } from "effect"; import { bundleEntry } from "../pipeline/bundle";import { makeQuickjsToolSandbox } from "./quickjs-tool-sandbox";import { ISSUES_SYNC_TS } from "../testing/daily-brief";import { InputValidationError, type HandleBridge } from "../seams/tool-sandbox"; const run = <A, E>(effect: Effect.Effect<A, E>): Promise<A> => Effect.runPromise(effect); describe("QuickJS ToolSandbox", () => {  const sandbox = makeQuickjsToolSandbox();   it("bundles + collects a tool descriptor (deterministic)", async () => {    const files = new Map([["tools/issues-sync.ts", ISSUES_SYNC_TS]]);    const { code } = await run(bundleEntry({ files, entry: "tools/issues-sync.ts" }));    const result = await run(sandbox.collect(code));    const descriptor = result.artifacts.default.descriptor as {      kind: string;      integrations: Record<string, { integration: string }>;      inputJsonSchema: { type: string; properties: Record<string, unknown> };      hasHandler: boolean;    };    expect(descriptor.kind).toBe("tool");    expect(descriptor.integrations.github).toEqual(      expect.objectContaining({ integration: "github" }),    );    expect(descriptor.hasHandler).toBe(true);    expect(descriptor.inputJsonSchema.type).toBe("object");    expect(descriptor.inputJsonSchema.properties).toHaveProperty("repos");    expect(descriptor.inputJsonSchema.properties).toHaveProperty("since");  });   it("invokes a tool, routing injected-client calls through the bridge", async () => {    const files = new Map([["tools/issues-sync.ts", ISSUES_SYNC_TS]]);    const { code } = await run(bundleEntry({ files, entry: "tools/issues-sync.ts" }));     const calls: { root: string; path: readonly string[]; args: readonly unknown[] }[] = [];    const bridge: HandleBridge = {      call: ({ root, path, args }) =>        Effect.sync(() => {          calls.push({ root, path, args });          const key = `${root}.${path.join(".")}`;          if (key === "github.repos.listForAuthenticatedUser") {            return [{ full_name: "acme/app" }];          }          if (key === "github.issues.listForRepo") {            return [              {                number: 1,                title: "Bug",                labels: [{ name: "bug" }],                assignee: { login: "rhys" },                updated_at: "2026-01-01T00:00:00Z",                html_url: "https://github.com/acme/app/issues/1",              },            ];          }          return [];        }),    };     const result = await run(      sandbox.invoke(        code,        {          artifact: "issues-sync",          kind: "tool",          input: {},          roots: { github: { kind: "single" } },        },        bridge,      ),    );     expect(result.output).toEqual({      synced: 1,      repos: 1,      issues: [{ repo: "acme/app", number: 1, title: "Bug" }],    });    expect(calls.some((c) => c.root === "github")).toBe(true);  });   it("reports storage as unavailable when an old handler calls db.sql", async () => {    const source = `import { defineTool } from "executor:app";import { z } from "zod";export default defineTool({  description: "legacy storage",  input: z.object({}),  async handler(_input, { db }) {    await db.sql\`SELECT 1\`;    return { ok: true };  },});`;    const files = new Map([["tools/storage.ts", source]]);    const { code } = await run(bundleEntry({ files, entry: "tools/storage.ts" }));    const bridge: HandleBridge = { call: () => Effect.succeed(null) };     const exit = await Effect.runPromiseExit(      sandbox.invoke(code, { artifact: "storage", kind: "tool", input: {}, roots: {} }, bridge),    );     expect(Exit.isFailure(exit)).toBe(true);    expect(JSON.stringify(exit)).toContain("storage is not available yet");  });   it("surfaces Standard Schema validation issues before the handler runs", async () => {    const source = `import { defineTool } from "executor:app";import { z } from "zod";export default defineTool({  description: "validates",  input: z.object({ q: z.string() }),  async handler(){ return { ok: true }; },});`;    const files = new Map([["tools/validate.ts", source]]);    const { code } = await run(bundleEntry({ files, entry: "tools/validate.ts" }));    const bridge: HandleBridge = { call: () => Effect.succeed(null) };     const exit = await Effect.runPromiseExit(      sandbox.invoke(        code,        { artifact: "validate", kind: "tool", input: { q: 123 }, roots: {} },        bridge,      ),    );     expect(Exit.isFailure(exit)).toBe(true);    expect(JSON.stringify(exit)).toContain("InputValidationError");    expect(JSON.stringify(exit)).toContain("q");  });   it("invokes raw JSON Schema tools without sandbox Standard Schema validation", async () => {    const source = `import { defineTool } from "executor:app";export default defineTool({  description: "raw",  input: { type: "object", properties: { q: { type: "string" } }, required: ["q"] },  async handler(input){ return { q: input.q }; },});`;    const files = new Map([["tools/raw.ts", source]]);    const { code } = await run(bundleEntry({ files, entry: "tools/raw.ts" }));    const bridge: HandleBridge = { call: () => Effect.succeed(null) };     const result = await run(      sandbox.invoke(        code,        { artifact: "raw", kind: "tool", input: { q: "ok" }, roots: {} },        bridge,      ),    );     expect(result.output).toEqual({ q: "ok" });  });   it("rejects a non-deterministic descriptor (Math.random at describe time)", async () => {    const nondeterministic = `import { defineTool } from "executor:app";import { z } from "zod";export default defineTool({  description: "x-" + Math.random(),  input: z.object({}),  async handler() { return {}; },});`;    const files = new Map([["tools/rng.ts", nondeterministic]]);    const { code } = await run(bundleEntry({ files, entry: "tools/rng.ts" }));    const exit = await Effect.runPromiseExit(sandbox.collect(code));    expect(Exit.isFailure(exit)).toBe(true);  });   it("denies network (fetch throws in the sandbox)", async () => {    const usesFetch = `import { defineTool } from "executor:app";import { z } from "zod";export default defineTool({  description: "fetches",  input: z.object({}),  async handler() { await fetch("https://example.com"); return {}; },});`;    const files = new Map([["tools/net.ts", usesFetch]]);    const { code } = await run(bundleEntry({ files, entry: "tools/net.ts" }));    const bridge: HandleBridge = { call: () => Effect.succeed(null) };    const exit = await Effect.runPromiseExit(      sandbox.invoke(code, { artifact: "net", kind: "tool", input: {}, roots: {} }, bridge),    );    expect(Exit.isFailure(exit)).toBe(true);  });   it("returns typed InputValidationError from promise rejection", async () => {    const source = `import { defineTool } from "executor:app";import { z } from "zod";export default defineTool({  description: "typed",  input: z.object({ name: z.string() }),  async handler(){ return {}; },});`;    const files = new Map([["tools/typed.ts", source]]);    const { code } = await run(bundleEntry({ files, entry: "tools/typed.ts" }));    const bridge: HandleBridge = { call: () => Effect.succeed(null) };     await expect(      run(sandbox.invoke(code, { artifact: "typed", kind: "tool", input: {}, roots: {} }, bridge)),    ).rejects.toBeInstanceOf(InputValidationError);  });});