import { describe, expect, it } from "@effect/vitest";import { stat } from "node:fs/promises";import { join } from "node:path";import * as Data from "effect/Data";import * as Effect from "effect/Effect"; import type { SandboxToolInvoker } from "@executor-js/codemode-core";import {  createWorkerdModuleRunner,  isWorkerdAvailable,  makeWorkerdSubprocessExecutor,  WORKERD_VERSION,} from "./index"; class UnknownToolError extends Data.TaggedError("UnknownToolError")<{  readonly path: string;  readonly cause?: unknown;}> {} const makeInvoker = (handlers: Record<string, (args: unknown) => unknown>): SandboxToolInvoker => ({  invoke: ({ path, args }) => {    const handler = handlers[path];    if (!handler) return Effect.fail(new UnknownToolError({ path }));    return Effect.try({      try: () => handler(args),      catch: (cause) => new UnknownToolError({ path, cause }),    });  },}); const testDriver = (token: string): string => `const json = (body, status = 200) => Response.json(body, { status }); const callTool = async (env, toolPath, args) => {  const response = await env.HOST.fetch("http://host/tool", {    method: "POST",    headers: { "content-type": "application/json", "x-executor-token": ${JSON.stringify(token)} },    body: JSON.stringify({ toolPath, args }),  });  return await response.json();}; export default {  async fetch(request, env) {    if (request.url.endsWith("/__health")) return json({ ok: true, runnerToken: ${JSON.stringify(token)} });    const input = await request.json();    if (input.op === "echo") return json({ value: input.value });    if (input.op === "tool") return json(await callTool(env, input.toolPath, input.args));    if (input.op === "fetch") {      const response = await fetch("https://example.com");      return json({ status: response.status, text: await response.text() });    }    if (input.op === "timeout") {      const timeoutMs = input.timeoutMs;      try {        await Promise.race([          new Promise(() => {}),          new Promise((_, reject) => setTimeout(() => reject(new Error("Execution timed out after " + timeoutMs + "ms")), timeoutMs)),        ]);      } catch (error) {        return json({ error: error.message });      }    }    return json({ error: "unknown op" }, 400);  },};`; const makeRunner = (handlers: Record<string, (args: unknown) => unknown> = {}) => {  const token = crypto.randomUUID();  return createWorkerdModuleRunner({    mainModule: "driver.js",    modules: { "driver.js": testDriver(token) },    hostToken: token,    toolBridge: {      call: async (toolPath, args) => {        const handler = handlers[toolPath];        if (!handler) throw new Error(`unknown tool: ${toolPath}`);        return handler(args);      },    },    restartBackoffMs: 1,  });}; const pidIsGone = (pid: number): boolean => {  try {    process.kill(pid, 0);    return false;  } catch {    return true;  }}; const waitUntilGone = async (pid: number): Promise<boolean> => {  // kill(pid, 0) still succeeds for an exited-but-unreaped child, so poll on a  // real timer long enough for Node to reap it after the exit event.  const deadline = Date.now() + 5_000;  while (Date.now() < deadline) {    if (pidIsGone(pid)) return true;    await new Promise((resolve) => setTimeout(resolve, 10));  }  return pidIsGone(pid);}; it("exports the pinned workerd version", () => {  expect(WORKERD_VERSION).toBe("1.20260708.1");}); describe.skipIf(!isWorkerdAvailable())("runtime-workerd-subprocess", () => {  it("boots and executes a trivial module", async () => {    const runner = makeRunner();    try {      const output = await runner.run<{ value: number }>({ op: "echo", value: 42 });      expect(output.status).toBe(200);      expect(output.body.value).toBe(42);    } finally {      await runner.dispose();    }  });   it("round-trips tool calls through the host bridge", async () => {    const runner = makeRunner({      "math.add": (args) => {        const input = args as { readonly a: number; readonly b: number };        return { sum: input.a + input.b };      },    });    try {      const output = await runner.run<{ ok: boolean; result: unknown }>({        op: "tool",        toolPath: "math.add",        args: { a: 20, b: 22 },      });      expect(output.body).toEqual({ ok: true, result: { sum: 42 } });    } finally {      await runner.dispose();    }  });   it("blocks ambient fetch", async () => {    const runner = makeRunner();    try {      const output = await runner.run<{ status: number; text: string }>({ op: "fetch" });      expect(output.body.status).toBe(403);      expect(output.body.text).toContain("Outbound fetch is blocked");    } finally {      await runner.dispose();    }  });   it("writes generated workerd files with private permissions", async () => {    const runner = makeRunner();    try {      await runner.ensureStarted();      const tmp = runner.tempDirForTest();      if (tmp === undefined) throw new Error("workerd temp dir was unavailable");      expect((await stat(tmp)).mode & 0o777).toBe(0o700);      expect((await stat(join(tmp, "driver.js"))).mode & 0o777).toBe(0o600);      expect((await stat(join(tmp, "config.capnp"))).mode & 0o777).toBe(0o600);    } finally {      await runner.dispose();    }  });   it("fires the guest timeout", async () => {    const runner = makeRunner();    try {      const output = await runner.run<{ error: string }>({ op: "timeout", timeoutMs: 25 }, 100);      expect(output.body.error).toContain("Execution timed out after 25ms");    } finally {      await runner.dispose();    }  });   it("dispose kills the process", async () => {    const runner = makeRunner();    await runner.ensureStarted();    const pid = runner.pid();    expect(pid).toEqual(expect.any(Number));    if (pid === undefined) throw new Error("workerd pid was unavailable");    await runner.dispose();    expect(await waitUntilGone(pid)).toBe(true);  });   it("restarts after a crash", async () => {    const runner = makeRunner();    try {      await runner.ensureStarted();      const firstPid = runner.pid();      expect(firstPid).toEqual(expect.any(Number));      if (firstPid === undefined) throw new Error("workerd pid was unavailable");      runner.crashForTest();      expect(await waitUntilGone(firstPid)).toBe(true);      const output = await runner.run<{ value: string }>({ op: "echo", value: "after" });      expect(output.body.value).toBe("after");      expect(runner.pid()).not.toBe(firstPid);    } finally {      await runner.dispose();    }  });   it.effect("exports a CodeExecutor implementation", () =>    Effect.gen(function* () {      const executor = makeWorkerdSubprocessExecutor({ timeoutMs: 1000 });      const output = yield* executor.execute("return 1 + 2;", makeInvoker({}));      expect(output.result).toBe(3);      expect(output.error).toBeUndefined();    }),  );});