import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";import { tmpdir } from "node:os";import { join } from "node:path";import { afterEach, describe, expect, it } from "@effect/vitest"; import { scanCodexPlugins } from "./codex-plugins"; // ---------------------------------------------------------------------------// `scanCodexPlugins` reads a Codex home layout from disk:////   <home>/computer-use/Codex Computer Use.app/…/SkyComputerUseClient   (curated)//   <home>/plugins/cache/<source>/<name>/<version>/.codex-plugin/plugin.json//// The three curated plugins must always be reported — available when the// client binary exists, with a setup hint when it does not — and the cache// scan must pick each plugin's newest version, resolve its relative command// and cwd against that version dir, skip remote (http) servers, and never// fail the whole scan on a malformed entry.// --------------------------------------------------------------------------- const CLIENT_RELATIVE = join(  "computer-use",  "Codex Computer Use.app",  "Contents",  "SharedSupport",  "SkyComputerUseClient.app",  "Contents",  "MacOS",  "SkyComputerUseClient",); const tempHomes: string[] = []; const makeHome = (): string => {  const home = mkdtempSync(join(tmpdir(), "codex-home-"));  tempHomes.push(home);  return home;}; afterEach(() => {  for (const home of tempHomes.splice(0)) rmSync(home, { recursive: true, force: true });}); const writeExecutable = (file: string): void => {  mkdirSync(join(file, ".."), { recursive: true });  writeFileSync(file, "#!/bin/sh\nexit 0\n", { mode: 0o755 });}; const writeCachedPlugin = (  home: string,  input: {    readonly source?: string;    readonly name: string;    readonly version: string;    readonly manifest?: unknown;    readonly servers?: unknown;  },): string => {  const versionDir = join(    home,    "plugins",    "cache",    input.source ?? "openai-curated-remote",    input.name,    input.version,  );  mkdirSync(join(versionDir, ".codex-plugin"), { recursive: true });  writeFileSync(    join(versionDir, ".codex-plugin", "plugin.json"),    JSON.stringify(      input.manifest ?? {        name: input.name,        mcpServers: "./.mcp.json",        interface: { displayName: input.name, shortDescription: `${input.name} server` },      },    ),  );  if (input.servers !== undefined) {    writeFileSync(join(versionDir, ".mcp.json"), JSON.stringify(input.servers));  }  return versionDir;}; /** Chrome's bundled browser client, reached through the `latest` symlink *  Codex maintains beside the versioned directories. */const CHROME_CLIENT_RELATIVE = join(  "plugins",  "cache",  "openai-bundled",  "chrome",  "latest",  "scripts",  "browser-client.mjs",); const writeChromePlugin = (home: string): void => {  const file = join(home, CHROME_CLIENT_RELATIVE);  mkdirSync(join(file, ".."), { recursive: true });  writeFileSync(file, "export const setupBrowserRuntime = async () => ({});\n");}; /** A fake `codex` CLI inside the temp home, passed explicitly so the scan *  never resolves the machine's real install through PATH. */const writeCodexCli = (home: string): string => {  const cli = join(home, "bin", "codex");  writeExecutable(cli);  return cli;}; describe("scanCodexPlugins", () => {  it("reports the curated plugins as app-server recipes when Codex is fully installed", () => {    const home = makeHome();    writeExecutable(join(home, CLIENT_RELATIVE));    writeChromePlugin(home);    const cli = writeCodexCli(home);     const entries = scanCodexPlugins({ codexHome: home, codexCli: cli });    const curated = entries.filter((entry) => entry.source === "curated");     expect(curated.map((entry) => entry.id)).toEqual([      "codex-messages",      "codex-computer-use",      "codex-chrome",      "codex-openai-docs",      "codex-computer-history",    ]);    for (const entry of curated) {      expect(entry.available, entry.id).toBe(true);      // Curated plugins go through the app-server bridge — the plugins' own      // service only honours Codex host sessions, so their binaries are never      // spawned directly.      expect(entry.command).toBe(cli);      expect(entry.args).toEqual(["app-server"]);      expect(entry.env).toEqual({ CODEX_HOME: home });      expect(entry.setupHint).toBeUndefined();    }    // Computer Use and Chrome have no MCP server of their own in current    // Codex: both ship as node-repl content, so they target `node_repl` with a    // projected surface. Chrome additionally carries the module its surface    // imports, resolved through the version-proof `latest` symlink.    expect(curated.map((entry) => entry.appServer)).toEqual([      { server: "messages" },      { server: "node_repl", surface: "sky" },      { server: "node_repl", surface: "browser", modulePath: join(home, CHROME_CLIENT_RELATIVE) },      { server: "openaiDeveloperDocs" },      { server: "computer-history" },    ]);  });   it("reports every curated plugin with a setup hint when Codex is not installed", () => {    const home = makeHome();     const entries = scanCodexPlugins({ codexHome: home, codexCli: join(home, "bin", "codex") });    const curated = entries.filter((entry) => entry.source === "curated");     expect(curated).toHaveLength(5);    for (const entry of curated) {      expect(entry.available, entry.id).toBe(false);      expect(entry.setupHint, entry.id).toContain("Codex");    }  });   it("gates each curated plugin on what it actually needs, not on Codex alone", () => {    const home = makeHome();    const cli = writeCodexCli(home);     const byId = new Map(      scanCodexPlugins({ codexHome: home, codexCli: cli }).map((entry) => [entry.id, entry]),    );     // `codex app-server` starts, but the plugins' own content is absent: no    // `messages` server without the Computer Use app, no browser client    // without the Chrome plugin. Those cards must not claim readiness.    expect(byId.get("codex-messages")?.available).toBe(false);    expect(byId.get("codex-computer-use")?.available).toBe(false);    expect(byId.get("codex-chrome")?.available).toBe(false);    // Each card's steps are about ITS requirement: Chrome needs the browser    // extension, which no other card mentions.    expect(byId.get("codex-chrome")?.setupHint).toContain("browser extension");    // A card that cannot be used still hands over where to go, and shows the    // plugin's published mark rather than a gap.    expect(byId.get("codex-messages")?.setupUrl).toBe("https://openai.com/codex");    expect(byId.get("codex-chrome")?.setupUrl).toContain("learn.chatgpt.com");    expect(byId.get("codex-computer-use")?.fallbackIcon).toContain("computer-use-plugin-icon");    expect(byId.get("codex-messages")?.fallbackIcon).toBe("/plugin-icons/messages.webp");    // Computer History has no published mark of its own, so it identifies its    // provider instead.    expect(byId.get("codex-computer-history")?.fallbackIcon).toContain("openai.com");    expect(byId.get("codex-messages")?.setupHint).not.toContain("browser extension");    // And the steps are numbered and name the plugin the person clicked.    expect(byId.get("codex-messages")?.setupHint).toContain("1. Install the Codex app");    expect(byId.get("codex-messages")?.setupHint).toContain("Open Messages once inside Codex");    // The docs server ships with Codex itself, so the CLI alone is enough.    expect(byId.get("codex-openai-docs")?.available).toBe(true);  });   it("keeps Chrome unavailable when only the Computer Use app is installed", () => {    const home = makeHome();    writeExecutable(join(home, CLIENT_RELATIVE));    const cli = writeCodexCli(home);     const byId = new Map(      scanCodexPlugins({ codexHome: home, codexCli: cli }).map((entry) => [entry.id, entry]),    );     expect(byId.get("codex-messages")?.available).toBe(true);    expect(byId.get("codex-chrome")?.available).toBe(false);  });   it("scans cached plugins, resolving command and cwd against the newest version", () => {    const home = makeHome();    // Two versions; numeric-aware pick must choose 0.1.10 over 0.1.9.    writeCachedPlugin(home, {      name: "sec-scan",      version: "0.1.9",      servers: { mcpServers: { "sec-scan": { command: "./scripts/run", args: ["--stdio"] } } },    });    const newest = writeCachedPlugin(home, {      name: "sec-scan",      version: "0.1.10",      servers: {        mcpServers: { "sec-scan": { command: "./scripts/run", args: ["--stdio"], cwd: "." } },      },    });    writeExecutable(join(newest, "scripts", "run"));     const entries = scanCodexPlugins({ codexHome: home });    const scanned = entries.find((entry) => entry.id === "codex-sec-scan");     expect(scanned).toMatchObject({      name: "sec-scan",      summary: "sec-scan server",      available: true,      slug: "codex_sec_scan",      source: "scanned",      command: join(newest, "scripts", "run"),      cwd: newest,      args: ["--stdio"],      env: { CODEX_HOME: home },    });  });   it("reports a scanned plugin whose command is missing as unavailable", () => {    const home = makeHome();    writeCachedPlugin(home, {      name: "ghost",      version: "1.0.0",      servers: { mcpServers: { ghost: { command: "./bin/gone" } } },    });     const scanned = scanCodexPlugins({ codexHome: home }).find(      (entry) => entry.id === "codex-ghost",    );     expect(scanned?.available).toBe(false);    expect(scanned?.setupHint).toContain("Install the Codex app");  });   it("skips remote servers, curated names, and malformed entries", () => {    const home = makeHome();    // Remote (http) server — Executor connects to those directly, no spawn.    writeCachedPlugin(home, {      name: "github",      version: "0.1.6",      servers: {        mcpServers: { github: { type: "http", url: "https://api.example.com/mcp/" } },      },    });    // Curated name in the cache — the curated card already covers it.    writeCachedPlugin(home, {      name: "messages",      version: "1.0.0",      servers: { mcpServers: { messages: { command: "./bin/launcher" } } },    });    // Skill-only plugin: no mcpServers in the manifest.    writeCachedPlugin(home, {      name: "templates",      version: "0.1.1",      manifest: { name: "templates" },    });    // Malformed manifest JSON must not break the scan.    const brokenDir = join(home, "plugins", "cache", "x", "broken", "1.0.0", ".codex-plugin");    mkdirSync(brokenDir, { recursive: true });    writeFileSync(join(brokenDir, "plugin.json"), "{not json");     const entries = scanCodexPlugins({ codexHome: home });     expect(entries.filter((entry) => entry.source === "scanned")).toEqual([]);    // Curated cards are still present (the cache copy of `messages` merged away).    expect(entries.filter((entry) => entry.id === "codex-messages")).toHaveLength(1);  });   it("collapses the same plugin cached under several sources into one entry", () => {    const home = makeHome();    const a = writeCachedPlugin(home, {      source: "openai-curated",      name: "dup",      version: "1.0.0",      servers: { mcpServers: { dup: { command: "./bin/run" } } },    });    writeCachedPlugin(home, {      source: "openai-curated-remote",      name: "dup",      version: "1.0.0",      servers: { mcpServers: { dup: { command: "./bin/run" } } },    });    writeExecutable(join(a, "bin", "run"));     const dups = scanCodexPlugins({ codexHome: home }).filter((entry) => entry.id === "codex-dup");     expect(dups).toHaveLength(1);    // The available copy wins over the one whose binary is missing.    expect(dups[0]?.available).toBe(true);  });});