// Codex plugins as one-click stdio presets.
//
// The server-side scanner reads `$CODEX_HOME` and reports locally installed
// OpenAI Codex plugins with stdio MCP servers: the three curated ones the
// shared "Codex Computer Use" client binary implements (Apple Messages,
// Computer Use, Computer History) plus anything in the plugin cache with a
// local-command `.mcp.json`. This scenario boots the real local server with
// `CODEX_HOME` pointed at a fixture layout whose "client binary" is a wrapper
// around the e2e stdio MCP fixture, and drives the same API the add-form's
// Codex-plugins section uses:
//
//   1. `mcp.listCodexPlugins` reports the curated entries and the scanned
//      cache entry, all available.
//   2. Adding an entry with its reported recipe (the one-click card path)
//      registers the integration, auto-connects, and detects its tools —
//      including `saw_codex_home`, which the fixture advertises only when
//      CODEX_HOME actually reached the spawned subprocess.
import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { fileURLToPath } from "node:url";

import { expect } from "@effect/vitest";
import { Effect } from "effect";
import { HttpApiClient } from "effect/unstable/httpapi";
import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http";
import { composePluginApi } from "@executor-js/api/server";
import { mcpHttpPlugin } from "@executor-js/plugin-mcp/api";

import { scenario } from "../src/scenario";
import { Cli, RunDir } from "../src/services";
import { withLocalServer } from "./local-server";

const api = composePluginApi([mcpHttpPlugin()] as const);

const FIXTURE = fileURLToPath(new URL("./fixtures/stdio-mcp-server.mjs", import.meta.url));
const CHROME_CLIENT_RELATIVE = join(
  "plugins",
  "cache",
  "openai-bundled",
  "chrome",
  "latest",
  "scripts",
  "browser-client.mjs",
);
const APP_SERVER_FIXTURE = fileURLToPath(
  new URL("./fixtures/codex-app-server.mjs", import.meta.url),
);

/** A fixture CODEX_HOME: the curated install markers (the Computer Use app
 *  and a `codex` CLI whose `app-server` is the fake app-server fixture) and
 *  one cached plugin wrapping the self-contained stdio MCP fixture. */
const makeCodexHome = (): string => {
  const home = mkdtempSync(join(tmpdir(), "codex-home-e2e-"));
  const wrapper = `#!/bin/sh\nexec node "${FIXTURE}" "$@"\n`;

  // The Computer Use app is the plugin-installed marker; the bridge never
  // spawns it, so an empty executable is enough.
  const clientDir = join(
    home,
    "computer-use",
    "Codex Computer Use.app",
    "Contents",
    "SharedSupport",
    "SkyComputerUseClient.app",
    "Contents",
    "MacOS",
  );
  mkdirSync(clientDir, { recursive: true });
  writeFileSync(join(clientDir, "SkyComputerUseClient"), wrapper, { mode: 0o755 });

  // The `codex` CLI the curated recipes spawn — resolved through PATH, so
  // the scenario prepends this bin dir to the server's PATH.
  mkdirSync(join(home, "bin"), { recursive: true });
  writeFileSync(join(home, "bin", "codex"), `#!/bin/sh\nexec node "${APP_SERVER_FIXTURE}" "$@"\n`, {
    mode: 0o755,
  });

  // Chrome's bundled browser client, behind the `latest` symlink Codex keeps.
  const chromeClient = join(home, CHROME_CLIENT_RELATIVE);
  mkdirSync(join(chromeClient, ".."), { recursive: true });
  writeFileSync(chromeClient, "export const setupBrowserRuntime = async () => ({});\n");

  const versionDir = join(home, "plugins", "cache", "personal", "echo-suite", "1.0.2");
  mkdirSync(join(versionDir, ".codex-plugin"), { recursive: true });
  mkdirSync(join(versionDir, "bin"), { recursive: true });
  writeFileSync(
    join(versionDir, ".codex-plugin", "plugin.json"),
    JSON.stringify({
      name: "echo-suite",
      mcpServers: "./.mcp.json",
      interface: { displayName: "Echo Suite", shortDescription: "Echo tools for e2e" },
    }),
  );
  writeFileSync(
    join(versionDir, ".mcp.json"),
    JSON.stringify({ mcpServers: { "echo-suite": { command: "./bin/run", cwd: "." } } }),
  );
  writeFileSync(join(versionDir, "bin", "run"), wrapper, { mode: 0o755 });

  return home;
};

scenario(
  "Local · Codex plugins are discovered from CODEX_HOME and add as one-click stdio presets",
  // Above the 240s boot-URL wait in `withLocalServer` for the same reason as
  // stdio-mcp.test.ts: a cold vite boot must fail with the harness's
  // diagnostic, not vitest's generic timeout.
  { timeout: 300_000 },
  Effect.gen(function* () {
    const cli = yield* Cli;
    const runDir = yield* RunDir;
    const codexHome = makeCodexHome();

    yield* withLocalServer(
      cli,
      runDir,
      (server) =>
        Effect.gen(function* () {
          const client = yield* HttpApiClient.make(api, {
            baseUrl: new URL("/api", server.origin).toString(),
            transformClient: HttpClient.mapRequest((request) =>
              HttpClientRequest.setHeader(request, "authorization", `Bearer ${server.token}`),
            ),
          }).pipe(Effect.provide(FetchHttpClient.layer));

          // The scanner reports the curated plugins and the cached one, all
          // available (the fixture home has every binary in place).
          const { plugins } = yield* client.mcp.listCodexPlugins();
          const byId = new Map(plugins.map((plugin) => [plugin.id, plugin]));
          expect([...byId.keys()].sort(), "curated + scanned entries are reported").toEqual([
            "codex-chrome",
            "codex-computer-history",
            "codex-computer-use",
            "codex-echo-suite",
            "codex-messages",
            "codex-openai-docs",
          ]);
          for (const plugin of plugins) {
            expect(plugin.available, `${plugin.id} is available`).toBe(true);
            expect(plugin.env, `${plugin.id} declares CODEX_HOME`).toEqual({
              CODEX_HOME: codexHome,
            });
          }
          // Curated entries carry the app-server bridge recipe: `codex
          // app-server`, the server name the bridge calls tools on, and the
          // preset it came from — that last one is what lets a macOS refusal
          // name the exact grant to enable.
          const messages = byId.get("codex-messages");
          expect(messages?.command.endsWith("codex"), "curated entries spawn the codex CLI").toBe(
            true,
          );
          expect(messages?.args, "curated entries run the app-server").toEqual(["app-server"]);
          expect(messages?.appServer, "curated entries name their Codex server").toEqual({
            presetId: "codex-messages",
            server: "messages",
          });
          // Computer Use and Chrome have no server of their own: both are
          // projected onto `node_repl`, and Chrome carries the client module
          // its surface imports, resolved through the `latest` symlink.
          expect(byId.get("codex-computer-use")?.appServer).toEqual({
            presetId: "codex-computer-use",
            server: "node_repl",
            surface: "sky",
          });
          expect(byId.get("codex-chrome")?.appServer).toEqual({
            presetId: "codex-chrome",
            server: "node_repl",
            surface: "browser",
            modulePath: join(codexHome, CHROME_CLIENT_RELATIVE),
          });

          // Add two entries exactly as the add-form's Codex-plugins card does:
          // the reported recipe, verbatim.
          for (const id of ["codex-messages", "codex-echo-suite"] as const) {
            const plugin = byId.get(id)!;
            yield* client.mcp.addServer({
              payload: {
                transport: "stdio",
                name: plugin.name,
                slug: plugin.slug,
                description: plugin.summary,
                command: plugin.command,
                args: [...plugin.args],
                ...(plugin.cwd === undefined ? {} : { cwd: plugin.cwd }),
                // Static, not `env`: CODEX_HOME is a machine path the scanner
                // resolved, so it must not become a credential to type.
                ...(plugin.env === undefined ? {} : { staticEnv: { ...plugin.env } }),
                ...(plugin.appServer === undefined
                  ? {}
                  : { appServer: { server: plugin.appServer.server } }),
              },
            });
          }

          const integrations = yield* client.integrations.list();
          const slugs = integrations.map((integration) => String(integration.slug));
          expect(slugs, "both plugins registered").toEqual(
            expect.arrayContaining(["codex_messages", "codex_echo_suite"]),
          );

          // One-click means connected: the env values auto-create the default
          // connection, so tools are discovered with no further step.
          for (const slug of ["codex_messages", "codex_echo_suite"]) {
            const connections = yield* client.connections.list({ query: { integration: slug } });
            expect(
              connections.map((connection) => String(connection.name)),
              `${slug} auto-connected`,
            ).toContain("default");
            // Nothing to configure: the connection carries no credential, so
            // the person is never shown a field for a path we already know.
            expect(
              connections.map((connection) => String(connection.template)),
              `${slug} needs no credential`,
            ).toEqual(["none"]);

            const tools = yield* client.tools.list({ query: { integration: slug } });
            const names = tools.map((tool) => tool.name);
            expect(names, `${slug} tools are detected`).toContain("echo_tool");
            expect(
              names,
              `CODEX_HOME reached ${slug}'s spawned subprocess (saw_codex_home is gated on it)`,
            ).toContain("saw_codex_home");
          }
        }),
      {
        env: {
          CODEX_HOME: codexHome,
          // The scanner resolves the `codex` CLI through the server's PATH.
          PATH: `${join(codexHome, "bin")}:${process.env["PATH"] ?? ""}`,
        },
      },
    );
  }),
);