import { describe, expect, it } from "@effect/vitest";import { Effect, Predicate } from "effect";import { fileURLToPath } from "node:url"; import { createMcpConnector, type StdioConnectorInput } from "./connection"; // ---------------------------------------------------------------------------// The Codex app-server bridge, driven end to end through the ORDINARY MCP// client path: `createMcpConnector` with an `appServer` marker spawns the// fixture (a fake `codex app-server` with real protocol shapes), and the// standard `Client` handshakes, lists, calls, and answers elicitations// against it. Nothing here touches the bridge internals — if these pass, the// discover/invoke/health paths work unchanged on top.// --------------------------------------------------------------------------- const fixture = fileURLToPath(new URL("./appserver-test-server.ts", import.meta.url)); const appServerInput = (  server: string,  appServer?: { readonly surface?: "sky" | "browser"; readonly modulePath?: string },): StdioConnectorInput => ({  transport: "stdio",  command: "bun",  args: ["run", fixture],  env: { CODEX_HOME: "/tmp/fixture-codex-home" },  appServer: { server, ...appServer },}); const withConnection = (input: StdioConnectorInput) =>  Effect.acquireRelease(createMcpConnector(input).pipe(Effect.orDie), (connection) =>    Effect.promise(connection.close),  ); describe("codex app-server bridge", () => {  it.effect("handshakes, follows status pagination, and lists the server's tools", () =>    Effect.scoped(      Effect.gen(function* () {        const connection = yield* withConnection(appServerInput("messages"));         const tools = yield* Effect.promise(() => connection.client.listTools());        expect(tools.tools.map(({ name }) => name).sort()).toEqual([          "announce_restart",          "echo",          "needs_approval",        ]);        const echo = tools.tools.find(({ name }) => name === "echo");        expect(echo?.description).toBe("Echo the arguments back");        expect(echo?.inputSchema).toMatchObject({ type: "object" });      }),    ),  );   it.effect("calls a tool and carries content, structuredContent, and the spawn env through", () =>    Effect.scoped(      Effect.gen(function* () {        const connection = yield* withConnection(appServerInput("messages"));         const result = yield* Effect.promise(() =>          connection.client.callTool({ name: "echo", arguments: { text: "hi" } }),        );        expect(result.isError).toBeFalsy();        expect(result.content).toEqual([{ type: "text", text: JSON.stringify({ text: "hi" }) }]);        // CODEX_HOME must reach the fixture's process env through the spawn.        expect(result.structuredContent).toEqual({ codexHome: "/tmp/fixture-codex-home" });      }),    ),  );   it.effect("bridges an app-server elicitation to the client's elicitation/create handler", () =>    Effect.scoped(      Effect.gen(function* () {        const connection = yield* withConnection(appServerInput("messages"));        const prompts: string[] = [];        connection.client.setRequestHandler("elicitation/create", (request) => {          prompts.push(request.params.message);          return Promise.resolve({ action: "accept" as const, content: {} });        });         const result = yield* Effect.promise(() =>          connection.client.callTool({ name: "needs_approval", arguments: {} }),        );        expect(result.content).toEqual([{ type: "text", text: "approved" }]);        expect(prompts).toEqual(["Allow the fixture to proceed?"]);      }),    ),  );   it.effect("starts the thread with an approval policy that lets prompts through", () =>    Effect.scoped(      Effect.gen(function* () {        // Codex declines MCP elicitations ITSELF on a thread whose approval        // policy does not allow them — the prompt never reaches the client and        // the tool just reports "access was not approved". The fixture only        // elicits when the bridge asked for a permitting policy, so reaching        // the handler at all is the assertion.        const connection = yield* withConnection(appServerInput("messages"));        let prompted = false;        connection.client.setRequestHandler("elicitation/create", () => {          prompted = true;          return Promise.resolve({ action: "accept" as const, content: {} });        });         const result = yield* Effect.promise(() =>          connection.client.callTool({ name: "needs_approval", arguments: {} }),        );        expect(prompted, "the plugin's own approval prompt reached the client").toBe(true);        expect(result.isError).toBeFalsy();      }),    ),  );   it.effect("a declined elicitation reaches the app-server as a decline, not an approval", () =>    Effect.scoped(      Effect.gen(function* () {        const connection = yield* withConnection(appServerInput("messages"));        connection.client.setRequestHandler("elicitation/create", () =>          Promise.resolve({ action: "decline" as const }),        );         const result = yield* Effect.promise(() =>          connection.client.callTool({ name: "needs_approval", arguments: {} }),        );        expect(result.isError).toBe(true);        expect(result.content).toEqual([{ type: "text", text: "denied: decline" }]);      }),    ),  );   it.effect("turns a server becoming ready into the spec's tool-list-changed", () =>    Effect.scoped(      Effect.gen(function* () {        // Installing or updating a plugin inside Codex can change a server's        // tools underneath a synced catalog. Executor already restales on the        // spec notification, so the bridge only has to translate Codex's.        const connection = yield* withConnection(appServerInput("messages"));        let changed = 0;        connection.client.setNotificationHandler("notifications/tools/list_changed", () => {          changed += 1;        });         yield* Effect.promise(() =>          connection.client.callTool({ name: "announce_restart", arguments: {} }),        );        // Give the notifications a turn to land after the call's response.        yield* Effect.promise(() => new Promise((resolve) => setTimeout(resolve, 50)));        expect(changed, "only this server's ready transition counts").toBe(1);      }),    ),  );   // -------------------------------------------------------------------------  // Computer Use: projected onto `node_repl`, not a server of its own.  // -------------------------------------------------------------------------   it.effect("the sky surface lists typed Computer Use tools, not the raw REPL", () =>    Effect.scoped(      Effect.gen(function* () {        const connection = yield* withConnection(appServerInput("node_repl", { surface: "sky" }));         const tools = yield* Effect.promise(() => connection.client.listTools());        const names = tools.tools.map(({ name }) => name);        expect(names, "the raw REPL is not exposed").not.toContain("js");        expect(names).toEqual(expect.arrayContaining(["list_apps", "click", "type_text"]));        const click = tools.tools.find(({ name }) => name === "click");        expect(click?.inputSchema, "tools carry real schemas").toMatchObject({          type: "object",          required: ["app"],        });      }),    ),  );   it.effect("a sky tool call compiles to one node_repl program carrying its arguments", () =>    Effect.scoped(      Effect.gen(function* () {        const connection = yield* withConnection(appServerInput("node_repl", { surface: "sky" }));         // Quotes in the arguments matter: they are embedded into a JS source        // text, so the encoding has to survive them exactly.        const args = { app: "com.apple.Safari", text: 'hi "there"' };        const result = yield* Effect.promise(() =>          connection.client.callTool({ name: "type_text", arguments: args }),        );        // The fixture echoes the program the bridge compiled.        const program = (result.content as readonly { readonly text: string }[])[0]!.text;        expect(program, "imports the bundled sky package idempotently").toContain(          'globalThis.sky ??= (await import("@oai/sky")).sky;',        );        expect(program, "calls the mapped method with the arguments verbatim").toContain(          `await sky.type_text(JSON.parse(${JSON.stringify(JSON.stringify(args))}))`,        );        expect(program, "returns the result as JSON through the REPL").toContain(          "nodeRepl.write(JSON.stringify(result ?? null));",        );        expect(program, "runs in its own scope so a reused REPL session stays clean").toContain(          "await (async () => {",        );      }),    ),  );   it.effect("an argument-less sky tool calls its method with no argument object", () =>    Effect.scoped(      Effect.gen(function* () {        const connection = yield* withConnection(appServerInput("node_repl", { surface: "sky" }));         const result = yield* Effect.promise(() =>          connection.client.callTool({ name: "list_apps", arguments: {} }),        );        const program = (result.content as readonly { readonly text: string }[])[0]!.text;        expect(program).toContain("await sky.list_apps();");      }),    ),  );   it.effect("a tool outside the sky surface is refused rather than sent to the REPL", () =>    Effect.scoped(      Effect.gen(function* () {        const connection = yield* withConnection(appServerInput("node_repl", { surface: "sky" }));         const outcome = yield* Effect.promise(() =>          connection.client.callTool({ name: "js", arguments: { code: "process.exit(0)" } }).then(            () => "unexpected success",            (failure: Error) => failure.message,          ),        );        expect(outcome).toContain("js");      }),    ),  );   // -------------------------------------------------------------------------  // Chrome: also projected onto `node_repl`, but handle-based.  // -------------------------------------------------------------------------   const BROWSER_MODULE = "/codex/chrome/latest/scripts/browser-client.mjs";  const browserInput = () =>    appServerInput("node_repl", { surface: "browser", modulePath: BROWSER_MODULE });   it.effect("the browser surface lists typed Chrome tools, not the raw REPL", () =>    Effect.scoped(      Effect.gen(function* () {        const connection = yield* withConnection(browserInput());         const names = yield* Effect.promise(() =>          connection.client.listTools().then((result) => result.tools.map(({ name }) => name)),        );        expect(names, "the raw REPL is not exposed").not.toContain("js");        expect(names).toEqual(          expect.arrayContaining(["list_tabs", "new_tab", "navigate", "read_page", "click"]),        );      }),    ),  );   it.effect("a browser call imports the machine's own client and resolves a tab", () =>    Effect.scoped(      Effect.gen(function* () {        const connection = yield* withConnection(browserInput());         const result = yield* Effect.promise(() =>          connection.client.callTool({            name: "navigate",            arguments: { url: "https://example.com/" },          }),        );        const program = (result.content as readonly { readonly text: string }[])[0]!.text;        expect(program, "imports the scanner-resolved client path").toContain(          `await import(${JSON.stringify(BROWSER_MODULE)})`,        );        expect(program, "caches the runtime across calls in the pooled session").toContain(          "globalThis.__executorBrowser ??=",        );        expect(program, "falls back to the selected tab, opening one if needed").toContain(          "(await __browser.tabs.selected()) ?? (await __browser.tabs.new())",        );        expect(program).toContain("await __tab.goto(__args.url)");      }),    ),  );   it.effect("stamps REPL calls with the turn metadata the Chrome client requires", () =>    Effect.scoped(      Effect.gen(function* () {        // Without this the real client refuses every call with "Missing        // required Codex turn metadata": Codex normally stamps a REPL call        // with its issuing turn, and this bridge runs no turns.        const connection = yield* withConnection(browserInput());         const result = yield* Effect.promise(() =>          connection.client.callTool({ name: "list_tabs", arguments: {} }),        );        const meta = (result.structuredContent as { readonly meta: Record<string, unknown> }).meta;        const turn = meta["x-codex-turn-metadata"] as Record<string, string>;        expect(typeof turn.session_id, "the pooled thread is the session").toBe("string");        expect(typeof turn.turn_id, "each call is its own turn").toBe("string");      }),    ),  );   it.effect("carries a prototype-named argument through to the program as data", () =>    Effect.scoped(      Effect.gen(function* () {        // Parsed, not written as a literal: `{ __proto__: … }` in source sets        // the prototype, so a literal fixture would assert nothing. This is        // the shape that arrives over the wire.        // oxlint-disable-next-line executor/no-json-parse -- an object literal would assign the PROTOTYPE; parsing produces the own key that actually arrives over the wire        const args = JSON.parse('{"url":"https://example.com/","__proto__":{"polluted":"yes"}}');        const connection = yield* withConnection(browserInput());         const result = yield* Effect.promise(() =>          connection.client.callTool({ name: "navigate", arguments: args }),        );        const program = (result.content as readonly { readonly text: string }[])[0]!.text;         expect(program, "embedded as parsed data").toContain("JSON.parse(");        expect(program, "with the key preserved rather than dropped").toContain("__proto__");      }),    ),  );   it.effect("a tab-less browser tool skips tab resolution entirely", () =>    Effect.scoped(      Effect.gen(function* () {        const connection = yield* withConnection(browserInput());         const result = yield* Effect.promise(() =>          connection.client.callTool({ name: "list_tabs", arguments: {} }),        );        const program = (result.content as readonly { readonly text: string }[])[0]!.text;        expect(program).toContain("await __browser.tabs.list()");        expect(program, "no tab is resolved for a browser-level call").not.toContain("const __tab");      }),    ),  );   it.effect("carries an approval's own terms upstream, not just its message", () =>    Effect.scoped(      Effect.gen(function* () {        // Chrome's per-site approval sends an EMPTY schema and puts the terms        // of the grant in `_meta` — accepting means "always, for this        // origin". Dropping that left a caller consenting to more than the        // prompt said, so the metadata has to reach the client.        const connection = yield* withConnection(browserInput());        let seen: Record<string, unknown> | undefined;        connection.client.setRequestHandler("elicitation/create", (request) => {          seen = request.params._meta;          return Promise.resolve({ action: "accept" as const, content: {} });        });         yield* Effect.promise(() =>          connection.client.callTool({            name: "navigate",            arguments: { url: "https://example.com/__needs_site_approval" },          }),        );        expect(seen?.["persist"], "the grant's persistence reaches the client").toBe("always");        expect(seen?.["origin"]).toBe("https://example.com");        expect(seen?.["connector_name"], "and which plugin is asking").toBe("Browser use");      }),    ),  );   it.effect("a server name Codex does not report fails the tools listing, not the connect", () =>    Effect.scoped(      Effect.gen(function* () {        const connection = yield* withConnection(appServerInput("not-installed"));         const outcome = yield* Effect.promise(() =>          connection.client.listTools().then(            () => "unexpected success",            (failure: Error) => failure.message,          ),        );        expect(outcome).toContain('"not-installed"');      }),    ),  );   it.effect("a missing codex binary surfaces as a connection error", () =>    Effect.gen(function* () {      const error = yield* createMcpConnector({        transport: "stdio",        command: "/nonexistent/codex",        args: ["app-server"],        appServer: { server: "messages" },      }).pipe(Effect.flip);       expect(Predicate.isTagged(error, "McpConnectionError")).toBe(true);    }),  );});