Skip to content

armgit / rea

Public Imported from GitHub
0

Reverse engineer anything with agents, from app behavior down to native binaries.

55.5 KB
Raw Blame
import { createInspectionResources } from "../../tests/fixtures/inspectionResources.js";

import { missingJavaProbe } from "./GhidraInstallation.fixture.js";
import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
import { ProviderAdapterError } from "../domain/providerAdapterError.js";
import { err } from "../domain/result.js";
import { ok as javaProbeOk } from "../domain/result.js";
import {
  parseGhidraJavaOutput,
  type GhidraJavaObservation,
} from "./GhidraJavaProbe.js";
import { chmod, mkdir, rm, symlink, unlink, writeFile } from "node:fs/promises";
import { join } from "node:path";
import { afterEach, describe, expect, it, vi } from "vitest";

import { elf, fat, thinMach } from "../domain/binaryTarget.fixture.js";
import { projectGhidraDoctorInspection } from "./GhidraDoctor.js";
import {
  ghidraInstallationDiagnostics,
  ghidraJavaEnvironment,
  discoverGhidraInstallationOnPath,
  inspectGhidraInstallation,
  type GhidraInstallationHost,
} from "./GhidraInstallation.js";
import {
  ghidraApplicationProperties,
  ghidraJavaRequirement,
} from "./GhidraInstallationPolicy.js";
import {
  SUPPORTED_GHIDRA_JAVA_MAJOR,
  SUPPORTED_GHIDRA_VERSION,
} from "./GhidraReleasePolicy.js";
import { createTestTempDirectory } from "../../tests/fixtures/temporaryDirectory.js";

let inspectionResources = createInspectionResources();
afterEach(async () => {
  await inspectionResources.close();
  inspectionResources = createInspectionResources();
});

const INSTALL = "/opt/ghidra";
const PROPERTIES = `${INSTALL}/Ghidra/application.properties`;
const HEADLESS = `${INSTALL}/support/analyzeHeadless`;
const LINUX_DECOMPILER = `${INSTALL}/Ghidra/Features/Decompiler/os/linux_x86_64/decompile`;
const MAC_DECOMPILER = `${INSTALL}/Ghidra/Features/Decompiler/os/mac_arm_64/decompile`;
const WINDOWS_INSTALL = "C:\\tools\\ghidra_12.1.4_PUBLIC";
const WINDOWS_PROPERTIES = `${WINDOWS_INSTALL}\\Ghidra\\application.properties`;
const WINDOWS_HEADLESS = `${WINDOWS_INSTALL}\\support\\analyzeHeadless.bat`;
const WINDOWS_DECOMPILER = `${WINDOWS_INSTALL}\\Ghidra\\Features\\Decompiler\\os\\win_x86_64\\decompile.exe`;

const headerProbe = (bytes: Buffer) =>
  javaProbeOk({ bytes, size: bytes.length });

const JAVA: GhidraJavaObservation = {
  osArch: "amd64",
  osName: "Linux",
  version: "21.0.11",
  major: SUPPORTED_GHIDRA_JAVA_MAJOR,
  home: "/usr/lib/jvm/jdk-21",
  bits: 64,
  runtime: "jdk",
};

const host = (
  overrides: Partial<GhidraInstallationHost> = {},
): GhidraInstallationHost => ({
  readText: (path) =>
    path === PROPERTIES
      ? `application.version=${SUPPORTED_GHIDRA_VERSION}\napplication.java.min=${String(SUPPORTED_GHIDRA_JAVA_MAJOR)}\n`
      : undefined,
  executable: (path) =>
    path === HEADLESS || path === MAC_DECOMPILER || path === LINUX_DECOMPILER,
  probeJava: () => javaProbeOk<GhidraJavaObservation>(JAVA),
  ...overrides,
});

afterEach(() => {
  vi.unstubAllEnvs();
});

it.skipIf(process.platform === "win32")(
  "resolves a PATH launcher only when its real target is a complete installation",
  async () => {
    const root = await createTestTempDirectory("rea-ghidra-path-");
    const installation = join(root, "installation");
    const pathDirectory = join(root, "bin");
    const launcher = join(installation, "ghidraRun");
    await mkdir(join(installation, "Ghidra"), { recursive: true });
    await mkdir(join(installation, "support"), { recursive: true });
    await mkdir(pathDirectory, { recursive: true });
    await writeFile(
      join(installation, "Ghidra", "application.properties"),
      "application.version=12.1.4\n",
    );
    await writeFile(launcher, "#!/bin/sh\nexit 0\n");
    await writeFile(
      join(installation, "support", "analyzeHeadless"),
      "#!/bin/sh\nexit 0\n",
    );
    await chmod(launcher, 0o700);
    await chmod(join(installation, "support", "analyzeHeadless"), 0o700);
    await symlink(launcher, join(pathDirectory, "ghidra"));

    expect(
      discoverGhidraInstallationOnPath(
        { PATH: pathDirectory },
        process.platform,
      ),
    ).toBe(installation);

    const incomplete = join(root, "incomplete");
    const incompletePath = join(root, "incomplete-bin");
    await mkdir(join(incomplete, "Ghidra"), { recursive: true });
    await mkdir(incompletePath, { recursive: true });
    await writeFile(
      join(incomplete, "Ghidra", "application.properties"),
      "application.version=12.1.4\n",
    );
    await writeFile(join(incomplete, "ghidraRun"), "launcher\n");
    await chmod(join(incomplete, "ghidraRun"), 0o700);
    await symlink(
      join(incomplete, "ghidraRun"),
      join(incompletePath, "ghidra"),
    );
    expect(
      discoverGhidraInstallationOnPath(
        { PATH: incompletePath },
        process.platform,
      ),
    ).toBeUndefined();

    const nonExecutable = join(root, "non-executable");
    const nonExecutablePath = join(root, "non-executable-bin");
    await mkdir(join(nonExecutable, "Ghidra"), { recursive: true });
    await mkdir(join(nonExecutable, "support"), { recursive: true });
    await mkdir(nonExecutablePath, { recursive: true });
    await writeFile(
      join(nonExecutable, "Ghidra", "application.properties"),
      "application.version=12.1.4\n",
    );
    await writeFile(
      join(nonExecutable, "support", "analyzeHeadless"),
      "headless\n",
    );
    await chmod(join(nonExecutable, "support", "analyzeHeadless"), 0o700);
    await writeFile(join(nonExecutablePath, "ghidra"), "not executable\n");
    expect(
      discoverGhidraInstallationOnPath(
        { PATH: nonExecutablePath },
        process.platform,
      ),
    ).toBeUndefined();
  },
);

it.skipIf(process.platform !== "darwin")(
  "uses a same-installation Homebrew opt alias for doctor registration and survives keg rotation",
  async () => {
    const temporaryRoot = await createTestTempDirectory("rea-ghidra-homebrew-");
    const prefix = join(temporaryRoot, "brew\n雪");
    await mkdir(prefix);
    const pathDirectory = join(prefix, "bin");
    const optDirectory = join(prefix, "opt");
    const optAlias = join(optDirectory, "ghidra");
    const firstKeg = join(prefix, "Cellar", "ghidra", "12.1.4");
    const secondKeg = join(prefix, "Cellar", "ghidra", "12.1.5");
    const foreignKeg = join(prefix, "Cellar", "other-ghidra", "12.1.4");

    const createKeg = async (keg: string) => {
      const libexec = join(keg, "libexec");
      await mkdir(join(libexec, "Ghidra"), { recursive: true });
      await mkdir(join(libexec, "support"), { recursive: true });
      await writeFile(
        join(libexec, "Ghidra", "application.properties"),
        `application.version=${SUPPORTED_GHIDRA_VERSION}\napplication.java.min=${String(SUPPORTED_GHIDRA_JAVA_MAJOR)}\n`,
      );
      await writeFile(join(libexec, "ghidraRun"), "launcher\n");
      await writeFile(
        join(libexec, "support", "analyzeHeadless"),
        "headless\n",
      );
      await chmod(join(libexec, "ghidraRun"), 0o700);
      await chmod(join(libexec, "support", "analyzeHeadless"), 0o700);
      return libexec;
    };

    const firstRoot = await createKeg(firstKeg);
    const secondRoot = await createKeg(secondKeg);
    await createKeg(foreignKeg);
    await mkdir(pathDirectory, { recursive: true });
    await mkdir(optDirectory, { recursive: true });
    await symlink(firstKeg, optAlias);
    await symlink(
      join(optAlias, "libexec", "ghidraRun"),
      join(pathDirectory, "ghidra"),
    );

    const environment = { PATH: pathDirectory };
    const registeredRoot = join(optAlias, "libexec");
    expect(
      discoverGhidraInstallationOnPath(environment, process.platform),
    ).toBe(registeredRoot);
    const inspection = await inspectGhidraInstallation(
      {
        environment,
        resourceOwner: inspectionResources.owner,
        platform: "darwin",
        architecture: "arm64",
      },
      host({
        discoverInstallDirOnPath: discoverGhidraInstallationOnPath,
        readText: (path) =>
          path === join(registeredRoot, "Ghidra", "application.properties")
            ? `application.version=${SUPPORTED_GHIDRA_VERSION}\napplication.java.min=${String(SUPPORTED_GHIDRA_JAVA_MAJOR)}\n`
            : undefined,
        executable: (path) =>
          path === join(registeredRoot, "support", "analyzeHeadless") ||
          path ===
            join(
              registeredRoot,
              "Ghidra",
              "Features",
              "Decompiler",
              "os",
              "mac_arm_64",
              "decompile",
            ),
        probeJava: () =>
          javaProbeOk({ ...JAVA, osArch: "aarch64", osName: "Mac OS X" }),
      }),
    );
    expect(inspection.status).toBe("available");
    expect(inspection.installDir).toBe(registeredRoot);
    expect(
      projectGhidraDoctorInspection(inspection).registrationEnvironment
        .GHIDRA_INSTALL_DIR,
    ).toBe(registeredRoot);

    await unlink(optAlias);
    await symlink(secondKeg, optAlias);
    await rm(firstKeg, { recursive: true });
    expect(
      discoverGhidraInstallationOnPath(environment, process.platform),
    ).toBe(registeredRoot);
    expect(
      discoverGhidraInstallationOnPath(environment, process.platform),
    ).not.toBe(firstRoot);

    await unlink(join(pathDirectory, "ghidra"));
    await symlink(join(secondRoot, "ghidraRun"), join(pathDirectory, "ghidra"));
    await unlink(optAlias);
    expect(
      discoverGhidraInstallationOnPath(environment, process.platform),
    ).toBe(secondRoot);
    await symlink(foreignKeg, optAlias);
    expect(
      discoverGhidraInstallationOnPath(environment, process.platform),
    ).toBe(secondRoot);
  },
);

it("does not fall back to PATH when an explicit Ghidra installation path is malformed", async () => {
  const inspection = await inspectGhidraInstallation(
    {
      resourceOwner: inspectionResources.owner,
      environment: { PATH: "/valid-ghidra-bin" },
      installDir: "relative/ghidra",
      platform: "linux",
      architecture: "x64",
    },
    host({ discoverInstallDirOnPath: () => INSTALL }),
  );
  expect(inspection.status).toBe("unavailable");
  expect(inspection.installDir).toBe("relative/ghidra");
  expect(inspection.checks[0]).toMatchObject({
    name: "configuration",
    status: "failed",
    detail: "GHIDRA_INSTALL_DIR must be absolute",
  });
});

it("probes the selected Java environment without reading conflicting ambient settings", async () => {
  vi.stubEnv("REA_GHIDRA_CONTEXT", "ambient");
  vi.stubEnv("REA_GHIDRA_AMBIENT", "ambient-only");
  const inspection = await inspectGhidraInstallation(
    {
      resourceOwner: inspectionResources.owner,
      environment: { REA_GHIDRA_CONTEXT: "selected", PATH: "/selected-bin" },
      installDir: INSTALL,
      platform: "linux",
      architecture: "x64",
    },
    host({
      probeJava: (_command, environment) =>
        environment.REA_GHIDRA_CONTEXT === "selected" &&
        environment.REA_GHIDRA_AMBIENT === undefined &&
        environment.PATH === "/selected-bin"
          ? javaProbeOk<GhidraJavaObservation>(JAVA)
          : missingJavaProbe,
    }),
  );
  expect(inspection.status).toBe("available");
});

describe("Ghidra installation inspection", () => {
  it("clears inherited JVM option injection before probing Java", () => {
    expect(
      ghidraJavaEnvironment(
        "/opt/jdk-21",
        {
          PATH: "/usr/bin",
          _JAVA_OPTIONS: "-Xmx99G",
          JAVA_TOOL_OPTIONS: "-javaagent:/tmp/agent.jar",
          JDK_JAVA_OPTIONS: "-XX:MaxRAMPercentage=99",
          GHIDRA_JAVA_OPTIONS: "-Duser.home=/tmp/unapproved",
        },
        "linux",
      ),
    ).toMatchObject({
      PATH: "/opt/jdk-21/bin:/usr/bin",
      JAVA_HOME: "/opt/jdk-21",
      _JAVA_OPTIONS: "",
      JAVA_TOOL_OPTIONS: "",
      JDK_JAVA_OPTIONS: "",
      GHIDRA_JAVA_OPTIONS: "",
    });
  });

  it("accepts the verified Linux x64 Ghidra release and JDK", async () => {
    expect(
      await inspectGhidraInstallation(
        {
          resourceOwner: inspectionResources.owner,
          environment: {},
          installDir: INSTALL,
          platform: "linux",
          architecture: "x64",
        },
        host(),
      ),
    ).toMatchObject({
      status: "available",
      providerVersion: SUPPORTED_GHIDRA_VERSION,
      analyzeHeadlessPath: HEADLESS,
      javaVersion: "21.0.11",
    });
  });

  it.each([
    ["12.1.2", "27", 27],
    ["12.1.2-2.1", "27", 27],
    ["12.1.0", "21.0.2", 21],
    [SUPPORTED_GHIDRA_VERSION, "25.0.1", 25],
  ])(
    "accepts Ghidra %s with JDK %s on the verified release line",
    async (providerVersion, javaVersion, major) => {
      const result = await inspectGhidraInstallation(
        {
          resourceOwner: inspectionResources.owner,
          environment: {},
          installDir: INSTALL,
          platform: "linux",
          architecture: "x64",
        },
        host({
          readText: () =>
            `application.version=${providerVersion}\napplication.java.min=21\napplication.java.max=\n`,
          probeJava: () =>
            javaProbeOk<GhidraJavaObservation>({
              ...JAVA,
              version: javaVersion,
              major,
            }),
        }),
      );
      expect(result.status).toBe("available");
      expect(result).toMatchObject({ providerVersion, javaVersion });
      expect(
        result.checks.find(({ name }) => name === "version"),
      ).toMatchObject({
        status: "passed",
        detail:
          providerVersion === SUPPORTED_GHIDRA_VERSION
            ? SUPPORTED_GHIDRA_VERSION
            : expect.stringContaining("verified build"),
      });
    },
  );

  it.each([
    ["darwin", "x64", "mac_x86_64"],
    ["darwin", "arm64", "mac_arm_64"],
    ["linux", "arm64", "linux_arm_64"],
  ] as const)(
    "accepts %s/%s with the matching distribution or locally built native tool",
    async (platform, architecture, nativeDirectory) => {
      for (const location of ["os", "build/os"]) {
        const decompiler = `${INSTALL}/Ghidra/Features/Decompiler/${location}/${nativeDirectory}/decompile`;
        expect(
          await inspectGhidraInstallation(
            {
              resourceOwner: inspectionResources.owner,
              environment: {},
              installDir: INSTALL,
              platform,
              architecture,
            },
            host({
              executable: (path) => path === HEADLESS || path === decompiler,
              probeJava: () =>
                javaProbeOk<GhidraJavaObservation>({
                  ...JAVA,
                  osArch: architecture === "arm64" ? "aarch64" : "amd64",
                  osName: platform === "darwin" ? "Mac OS X" : "Linux",
                }),
            }),
          ),
        ).toMatchObject({
          status: "available",
          platform,
          architecture,
          nativeDecompilerPath: decompiler,
        });
      }
    },
  );
});

describe("Ghidra Windows installation commitment", () => {
  it("accepts the exact Windows x64 batch launcher and JDK commitment", async () => {
    const windowsHost: GhidraInstallationHost = {
      platform: "win32",
      architecture: "x64",
      readText: (path) =>
        path === WINDOWS_PROPERTIES
          ? `application.version=${SUPPORTED_GHIDRA_VERSION}\napplication.java.min=21\n`
          : undefined,
      executable: (path) =>
        path === WINDOWS_HEADLESS || path === WINDOWS_DECOMPILER,
      probeJava: (command, environment) => {
        expect(command).toBe("C:\\Java\\jdk-21\\bin\\java.exe");
        expect(environment.PATH).toMatch(/^C:\\Java\\jdk-21\\bin;/u);
        return javaProbeOk<GhidraJavaObservation>({
          ...JAVA,
          home: "C:\\Java\\jdk-21",
          osName: "Windows 11",
        });
      },
    };

    expect(
      await inspectGhidraInstallation(
        {
          resourceOwner: inspectionResources.owner,
          environment: {},
          installDir: WINDOWS_INSTALL,
          javaHome: "C:\\Java\\jdk-21",
          platform: "win32",
          architecture: "x64",
        },
        windowsHost,
      ),
    ).toMatchObject({
      status: "available",
      platform: "win32",
      architecture: "x64",
      analyzeHeadlessPath: WINDOWS_HEADLESS,
      javaCommand: "C:\\Java\\jdk-21\\bin\\java.exe",
      providerVersion: SUPPORTED_GHIDRA_VERSION,
    });
  });
});

describe("Ghidra installation rejection diagnostics", () => {
  it.each([
    {
      name: "missing configuration",
      options: { platform: "linux" as const, architecture: "x64" as const },
      override: {},
      failed: "configuration",
      code: "not_configured",
    },
    {
      name: "unsupported platform",
      options: {
        installDir: INSTALL,
        platform: "aix" as const,
        architecture: "x64" as const,
      },
      override: {},
      failed: "platform",
      code: "unsupported_host",
    },
    {
      name: "unsupported architecture",
      options: {
        installDir: INSTALL,
        platform: "linux" as const,
        architecture: "arm" as const,
      },
      override: {},
      failed: "architecture",
      code: "unsupported_host",
    },
    {
      name: "bad installation root",
      options: {
        installDir: INSTALL,
        platform: "linux" as const,
        architecture: "x64" as const,
      },
      override: { readText: () => undefined },
      failed: "installation",
      code: "executable_missing",
    },
    {
      name: "wrong Ghidra version",
      options: {
        installDir: INSTALL,
        platform: "linux" as const,
        architecture: "x64" as const,
      },
      override: {
        readText: () => "application.version=11.4\napplication.java.min=21\n",
      },
      failed: "version",
      code: "unsupported_version",
    },
    {
      name: "missing analyzeHeadless",
      options: {
        installDir: INSTALL,
        platform: "linux" as const,
        architecture: "x64" as const,
      },
      override: { executable: () => false },
      failed: "headless",
      code: "executable_missing",
    },
    {
      name: "only a foreign-architecture decompiler on Linux arm64",
      options: {
        installDir: INSTALL,
        platform: "linux" as const,
        architecture: "arm64" as const,
      },
      override: {},
      failed: "native_decompiler",
      code: "executable_missing",
    },
    {
      name: "missing Java",
      options: {
        installDir: INSTALL,
        platform: "linux" as const,
        architecture: "x64" as const,
      },
      override: { probeJava: () => missingJavaProbe },
      failed: "java",
      code: "runtime_missing",
    },
    {
      name: "wrong Java",
      options: {
        installDir: INSTALL,
        platform: "linux" as const,
        architecture: "x64" as const,
      },
      override: {
        probeJava: () =>
          javaProbeOk<GhidraJavaObservation>({
            ...JAVA,
            major: 17,
            version: "17",
          }),
      },
      failed: "java",
      code: "unsupported_version",
    },
    {
      name: "JRE instead of JDK",
      options: {
        installDir: INSTALL,
        platform: "linux" as const,
        architecture: "x64" as const,
      },
      override: {
        probeJava: () =>
          javaProbeOk<GhidraJavaObservation>({
            ...JAVA,
            runtime: "jre" as const,
          }),
      },
      failed: "java",
      code: "unsupported_version",
    },
  ])("distinguishes $name", async ({ options, override, failed, code }) => {
    const result = await inspectGhidraInstallation(
      { resourceOwner: inspectionResources.owner, ...options, environment: {} },
      host(override),
    );
    expect(result.status).toBe("unavailable");
    expect(
      result.checks.find(({ status }) => status === "failed"),
    ).toMatchObject({
      name: failed,
      code,
    });
  });
});

describe("Ghidra configuration directory identity", () => {
  it.each([
    [
      "application.version=12.1.4\napplication.release.name=PUBLIC\n",
      "ghidra_12.1.4_PUBLIC",
    ],
    [
      "application.version=12.1.2-2.1\napplication.release.name=DEV\n",
      "ghidra_12.1.2-2.1_DEV",
    ],
    [
      "application.version=12.1.4\napplication.release.name=pub\\\n lic\n",
      "ghidra_12.1.4_PUBLIC",
    ],
    ["application.version=12.1.4\n", null],
    ["application.release.name=PUBLIC\n", null],
    ["application.version=12.1.4\napplication.release.name=\n", null],
    ["application.version=12.1.4\napplication.release.name=../outside\n", null],
    [
      "application.version=12.1.4\napplication.release.name=..\\\\outside\n",
      null,
    ],
    ["application.version=../12.1.4\napplication.release.name=PUBLIC\n", null],
    [
      "application.version=12.1.4+build\napplication.release.name=PUBLIC\n",
      null,
    ],
    ["application.version=12.1.4\napplication.release.name=\\uNOTHEX\n", null],
  ])("derives a safe release coordinate from %j", (content, expected) => {
    expect(ghidraApplicationProperties(content)).toMatchObject({
      configurationDirectoryName: expected,
    });
  });

  it.each([
    ["12.1.0", "ghidra_12.1_PUBLIC"],
    ["012.01.000", "ghidra_12.1_PUBLIC"],
    ["12.1.0-BETA", "ghidra_12.1-BETA_PUBLIC"],
    ["12.1.0-", "ghidra_12.1_PUBLIC"],
  ])(
    "uses Ghidra's canonical configuration version while retaining %s",
    (raw, expected) => {
      expect(
        ghidraApplicationProperties(
          `application.version=${raw}\napplication.release.name=PUBLIC\n`,
        ),
      ).toMatchObject({
        providerVersion: raw,
        configurationDirectoryName: expected,
      });
    },
  );

  it.each([
    [
      "application.version=12.1.4\napplication.release.name=PUBLIC\napplication.java.min=21\n",
      "ghidra_12.1.4_PUBLIC",
    ],
    ["application.version=12.1.4\napplication.java.min=21\n", null],
  ])(
    "preserves the inspected identity independently of the installation basename",
    async (content, expected) => {
      const inspection = await inspectGhidraInstallation(
        {
          resourceOwner: inspectionResources.owner,
          environment: {},
          installDir: INSTALL,
          platform: "linux",
          architecture: "x64",
        },
        host({ readText: () => content }),
      );
      expect(inspection).toMatchObject({
        status: "available",
        configurationDirectoryName: expected,
      });
    },
  );
});

describe("Ghidra release line and JDK bounds", () => {
  it("uses Java Properties last-key, delimiter, escape, and continuation rules", () => {
    const properties = ghidraApplicationProperties(
      [
        "application.version=11.4",
        "# comment ending with a slash " + "\\",
        "application.\\u0076ersion : 12.\\",
        "  1.\\u0034",
        "! another comment " + "\\",
        "application.java.\\u006din\t21",
        "application.java.max=",
      ].join("\n"),
    );
    expect(properties).toEqual({
      providerVersion: "12.1.4",
      configurationDirectoryName: null,
      javaMinimum: { status: "major", major: 21 },
      javaMaximum: { status: "absent" },
      parseError: null,
    });
    expect(
      ghidraApplicationProperties("application.version=12.1.4").javaMinimum,
    ).toEqual({
      status: "absent",
    });
    expect(
      ghidraApplicationProperties(
        "application.version=12.1.4\napplication.java.min=\n",
      ).javaMinimum,
    ).toEqual({ status: "unresolved", raw: "" });
    expect(
      ghidraApplicationProperties("application.version=12.1.4\\")
        .providerVersion,
    ).toBe("12.1.4");
    expect(
      ghidraApplicationProperties("application.version=12.\\\n #.1")
        .providerVersion,
    ).toBe("12.#.1");
    expect(
      ghidraApplicationProperties(
        "application.version=12.\\\n\napplication.version=12.1.4",
      ).providerVersion,
    ).toBe("12.1.4");
  });

  it("matches Ghidra integer Java bounds and zero maximum semantics", () => {
    const properties = ghidraApplicationProperties(
      "application.java.min=21.0\napplication.java.max=0\n",
    );
    expect(properties.javaMinimum).toEqual({
      status: "unresolved",
      raw: "21.0",
    });
    expect(properties.javaMaximum).toEqual({ status: "absent" });
    expect(
      ghidraApplicationProperties("application.java.max=+0").javaMaximum,
    ).toEqual({
      status: "absent",
    });
    expect(
      ghidraApplicationProperties("application.java.max=+0").javaMaximum,
    ).toEqual({ status: "absent" });
    expect(
      ghidraApplicationProperties("application.java.min=+21").javaMinimum,
    ).toEqual({
      status: "major",
      major: 21,
    });
    expect(
      ghidraApplicationProperties("application.java.min=٢١").javaMinimum,
    ).toEqual({
      status: "major",
      major: 21,
    });
    expect(
      ghidraApplicationProperties("application.java.min=21").javaMinimum,
    ).toEqual({
      status: "major",
      major: 21,
    });
    expect(
      ghidraApplicationProperties("application.java.max=+0").javaMaximum,
    ).toEqual({
      status: "unresolved",
      raw: "+0",
    });
    expect(
      ghidraApplicationProperties("application.java.min=②").javaMinimum,
    ).toEqual({
      status: "unresolved",
      raw: "②",
    });
    expect(
      ghidraApplicationProperties("application.java.min=2147483648")
        .javaMinimum,
    ).toEqual({ status: "unresolved", raw: "2147483648" });
  });

  it("keeps an unavailable properties file unresolved for Java admission", () => {
    expect(ghidraJavaRequirement(undefined).unresolved).toBe(
      "application.properties is unavailable",
    );
  });

  it("preserves property value trailing whitespace instead of normalizing it", () => {
    const properties = ghidraApplicationProperties(
      "application.version=12.1.4 \napplication.java.min=21 \n",
    );
    expect(properties.providerVersion).toBe("12.1.4 ");
    expect(properties.javaMinimum).toEqual({
      status: "unresolved",
      raw: "21 ",
    });
    expect(properties.parseError).toBeNull();
  });
});

describe("Ghidra malformed property admission", () => {
  it("fails installation and doctor admission closed on malformed Unicode escapes", async () => {
    const result = await inspectGhidraInstallation(
      {
        resourceOwner: inspectionResources.owner,
        environment: {},
        installDir: INSTALL,
        platform: "linux",
        architecture: "x64",
      },
      host({
        readText: () =>
          "application.version=12.1.4\nbroken=\\u12G4\napplication.java.min=17\n",
      }),
    );
    expect(result.status).toBe("unavailable");
    expect(result.providerVersion).toBeNull();
    expect(result.checks).toEqual(
      expect.arrayContaining([
        expect.objectContaining({
          name: "version",
          status: "failed",
          code: "version_unresolved",
          detail: expect.stringContaining("Malformed Unicode escape"),
        }),
        expect.objectContaining({
          name: "java",
          status: "failed",
          code: "version_unresolved",
          remediation: expect.stringContaining(
            "application.properties parse failed",
          ),
        }),
      ]),
    );
    expect(projectGhidraDoctorInspection(result)).toMatchObject({
      available: false,
      registrationEnvironment: {},
      checks: expect.arrayContaining([
        expect.objectContaining({ name: "version", ok: false }),
        expect.objectContaining({ name: "java", ok: false }),
      ]),
    });
  });
});

describe("Ghidra installation version admission", () => {
  it.each([
    {
      name: "JDK above the installation maximum",
      readText: () =>
        "application.version=12.1.4\napplication.java.min=21\napplication.java.max=25\n",
      probeJava: () =>
        javaProbeOk<GhidraJavaObservation>({
          ...JAVA,
          major: 27,
          version: "27",
        }),
      failed: "java",
      code: "unsupported_version",
    },
    {
      name: "unreadable Java minimum",
      readText: () =>
        "application.version=12.1.4\napplication.java.min=latest\n",
      probeJava: () => javaProbeOk<GhidraJavaObservation>(JAVA),
      failed: "java",
      code: "version_unresolved",
    },
    {
      name: "missing Java minimum",
      readText: () => "application.version=12.1.4\n",
      probeJava: () => javaProbeOk<GhidraJavaObservation>(JAVA),
      failed: "java",
      code: "version_unresolved",
    },
    {
      name: "unparseable Ghidra version",
      readText: () => "application.version=latest\napplication.java.min=21\n",
      probeJava: () => javaProbeOk<GhidraJavaObservation>(JAVA),
      failed: "version",
      code: "version_unresolved",
    },
    {
      name: "different Ghidra line",
      readText: () => "application.version=12.2.0\napplication.java.min=21\n",
      probeJava: () => javaProbeOk<GhidraJavaObservation>(JAVA),
      failed: "version",
      code: "unsupported_version",
    },
  ])("distinguishes $name", async ({ readText, probeJava, failed, code }) => {
    const result = await inspectGhidraInstallation(
      {
        resourceOwner: inspectionResources.owner,
        environment: {},
        installDir: INSTALL,
        platform: "linux",
        architecture: "x64",
      },
      host({ readText, probeJava }),
    );
    expect(result.status).toBe("unavailable");
    expect(
      result.checks.find(({ status }) => status === "failed"),
    ).toMatchObject({ name: failed, code });
  });

  it("names the accepted Ghidra line and JDK range in failure remediation", async () => {
    const result = await inspectGhidraInstallation(
      {
        resourceOwner: inspectionResources.owner,
        environment: {},
        installDir: INSTALL,
        javaHome: "/usr/lib/jvm/java-17-openjdk",
        platform: "linux",
        architecture: "x64",
      },
      host({
        readText: () =>
          "application.version=12.0.4\napplication.java.min=21\napplication.java.max=\n",
        probeJava: () =>
          javaProbeOk<GhidraJavaObservation>({
            ...JAVA,
            major: 17,
            version: "17.0.20.1",
          }),
      }),
    );
    expect(result.status).toBe("unavailable");
    if (result.status !== "unavailable") return;
    expect(result.rejection.reason).toContain("12.1.x");
    expect(result.rejection.reason).toContain(SUPPORTED_GHIDRA_VERSION);
    expect(result.checks.find(({ name }) => name === "java")).toMatchObject({
      status: "failed",
      remediation: expect.stringContaining("JDK 21 or newer"),
    });
  });

  it("accepts a lower Java minimum declared by the installation", async () => {
    expect(
      await inspectGhidraInstallation(
        {
          resourceOwner: inspectionResources.owner,
          environment: {},
          installDir: INSTALL,
          platform: "linux",
          architecture: "x64",
        },
        host({
          readText: () =>
            `application.version=${SUPPORTED_GHIDRA_VERSION}\napplication.java.min=17\n`,
          probeJava: () =>
            javaProbeOk<GhidraJavaObservation>({
              ...JAVA,
              major: 17,
              version: "17.0.20.1",
            }),
        }),
      ),
    ).toMatchObject({ status: "available", javaVersion: "17.0.20.1" });
  });
});

describe("Ghidra configuration paths", () => {
  it.each([
    [{ installDir: "./ghidra" }, "GHIDRA_INSTALL_DIR must be absolute"],
    [{ installDir: INSTALL, javaHome: "./jdk" }, "JAVA_HOME must be absolute"],
    [
      { installDir: "ghidra", javaHome: "jdk" },
      "GHIDRA_INSTALL_DIR and JAVA_HOME must be absolute",
    ],
  ])(
    "rejects relative paths that REA's configuration parser rejects (%o)",
    async (paths, detail) => {
      const result = await inspectGhidraInstallation(
        {
          resourceOwner: inspectionResources.owner,
          environment: {},
          ...paths,
          platform: "linux",
          architecture: "x64",
        },
        host(),
      );
      expect(result).toMatchObject({
        status: "unavailable",
        rejection: {
          code: "not_configured",
          reason: expect.stringContaining("reject relative paths"),
        },
      });
      expect(result.checks).toContainEqual(
        expect.objectContaining({ name: "configuration", detail }),
      );
      // Setup registers only an available inspection's environment.
      expect(projectGhidraDoctorInspection(result)).toMatchObject({
        available: false,
        registrationEnvironment: {},
      });
    },
  );

  it.each([
    ["linux", "./jdk"],
    ["linux", ""],
    ["win32", "jdk"],
  ] as const)(
    "does not run Java from a relative JAVA_HOME (%s %o)",
    async (platform, javaHome) => {
      const probed: string[] = [];
      const result = await inspectGhidraInstallation(
        {
          resourceOwner: inspectionResources.owner,
          environment: {},
          installDir: platform === "win32" ? WINDOWS_INSTALL : INSTALL,
          javaHome,
          platform,
          architecture: "x64",
        },
        host({
          probeJava: (command) => {
            probed.push(command);
            return javaProbeOk<GhidraJavaObservation>(JAVA);
          },
        }),
      );
      expect(probed).toEqual([]);
      expect(result).toMatchObject({
        status: "unavailable",
        rejection: { code: "not_configured" },
      });
    },
  );

  it.each([
    ["linux", undefined],
    ["linux", "/opt/jdk-21"],
    ["darwin", undefined],
    ["win32", "C:\\Java\\jdk-21"],
  ] as const)(
    "does not run Java without a Ghidra installation (%s %o)",
    async (platform, javaHome) => {
      const probed: string[] = [];
      const result = await inspectGhidraInstallation(
        {
          resourceOwner: inspectionResources.owner,
          environment: { PATH: "/usr/bin" },
          ...(javaHome === undefined ? {} : { javaHome }),
          platform,
          architecture: "x64",
        },
        host({
          discoverInstallDirOnPath: () => undefined,
          probeJava: (command) => {
            probed.push(command);
            return javaProbeOk<GhidraJavaObservation>(JAVA);
          },
        }),
      );
      expect(probed).toEqual([]);
      expect(result).toMatchObject({
        status: "unavailable",
        installDir: null,
        javaVersion: null,
        rejection: { code: "not_configured" },
      });
      expect(projectGhidraDoctorInspection(result)).toMatchObject({
        available: false,
        registrationEnvironment: {},
        checks: [
          expect.objectContaining({
            name: "configuration",
            code: "not_configured",
          }),
        ],
      });
    },
  );

  it("judges absolute paths by the inspected platform", async () => {
    const result = await inspectGhidraInstallation(
      {
        resourceOwner: inspectionResources.owner,
        environment: {},
        installDir: "C:\\ghidra",
        platform: "win32",
        architecture: "x64",
      },
      host(),
    );
    expect(result.checks).toContainEqual(
      expect.objectContaining({ name: "configuration", status: "passed" }),
    );
  });
});

describe("Ghidra FAT native decompiler admission", () => {
  it.each([
    {
      name: "foreign-only FAT",
      bytes: fat([0x01000007]),
      status: "unavailable",
      detail: "requires mach-o arm64",
    },
    {
      name: "foreign-only FAT whose first slice is undersized",
      bytes: (() => {
        const bytes = fat([0x01000007, 0x0000000c]);
        bytes.writeUInt32BE(31, 8 + 12);
        return bytes;
      })(),
      status: "unavailable",
      detail: "requires mach-o arm64",
    },
    {
      name: "foreign-only FAT declaring one family twice",
      bytes: fat([0x01000007, 0x01000007]),
      status: "unavailable",
      detail: "requires mach-o arm64",
    },
    {
      name: "foreign-only FAT whose first same-family slice is undersized",
      bytes: (() => {
        const bytes = fat([0x01000007, 0x01000007]);
        bytes.writeUInt32BE(31, 8 + 12);
        return bytes;
      })(),
      status: "unavailable",
      detail: "requires mach-o arm64",
    },
    {
      name: "matching universal FAT",
      bytes: fat([0x01000007, 0x0100000c]),
      status: "available",
      detail: "matches darwin/arm64",
    },
    {
      name: "truncated FAT table",
      bytes: fat([0x01000007], 2),
      status: "available",
      detail: "could not be established",
    },
  ])("distinguishes $name", async ({ bytes, status, detail }) => {
    const result = await inspectGhidraInstallation(
      {
        resourceOwner: inspectionResources.owner,
        environment: {},
        installDir: INSTALL,
        platform: "darwin",
        architecture: "arm64",
      },
      host({
        probeJava: () =>
          javaProbeOk<GhidraJavaObservation>({
            ...JAVA,
            osArch: "aarch64",
            osName: "Mac OS X",
          }),
        executableHeader: () => headerProbe(bytes),
      }),
    );
    expect(result.status).toBe(status);
    expect(
      result.checks.find(({ name }) => name === "native_decompiler")?.detail,
    ).toContain(detail);
  });

  it("keeps a truncated host slice unknown despite a readable foreign slice", async () => {
    const bytes = fat([0x01000007, 0x0100000c]);
    bytes.writeUInt32BE(bytes.length + 1, 8 + 20 + 12);
    const result = await inspectGhidraInstallation(
      {
        resourceOwner: inspectionResources.owner,
        environment: {},
        installDir: INSTALL,
        platform: "darwin",
        architecture: "arm64",
      },
      host({
        probeJava: () =>
          javaProbeOk<GhidraJavaObservation>({
            ...JAVA,
            osArch: "aarch64",
            osName: "Mac OS X",
          }),
        executableHeader: () => headerProbe(bytes),
      }),
    );
    expect(result.status).toBe("available");
    expect(
      result.checks.find(({ name }) => name === "native_decompiler")?.detail,
    ).toContain("could not be established");
  });
});

describe("Ghidra native decompiler admission", () => {
  it.each([
    {
      name: "a MIPS decompiler at the Linux x64 path",
      options: {
        environment: {},
        installDir: INSTALL,
        platform: "linux" as const,
        architecture: "x64" as const,
      },
      executableHeader: (path: string) =>
        path === LINUX_DECOMPILER
          ? headerProbe(elf(1, 1, 8))
          : javaProbeOk(undefined),
    },
    {
      name: "a Linux x86-64 decompiler at the macOS arm64 path",
      options: {
        environment: {},
        installDir: INSTALL,
        platform: "darwin" as const,
        architecture: "arm64" as const,
      },
      executableHeader: (path: string) =>
        path === MAC_DECOMPILER
          ? headerProbe(elf(2, 1, 62))
          : javaProbeOk(undefined),
    },
    {
      name: "a macOS arm64 decompiler at the Linux x64 path",
      options: {
        environment: {},
        installDir: INSTALL,
        platform: "linux" as const,
        architecture: "x64" as const,
      },
      executableHeader: (path: string) =>
        path === LINUX_DECOMPILER
          ? headerProbe(thinMach(0xcffaedfe, 0x0100000c))
          : javaProbeOk(undefined),
    },
  ])("distinguishes $name", async ({ options, executableHeader }) => {
    const result = await inspectGhidraInstallation(
      { ...options, resourceOwner: inspectionResources.owner },
      host({
        probeJava: () =>
          javaProbeOk<GhidraJavaObservation>({
            ...JAVA,
            osArch: options.architecture === "arm64" ? "aarch64" : "amd64",
            osName: options.platform === "darwin" ? "Mac OS X" : "Linux",
          }),
        executableHeader,
      }),
    );
    expect(result.status).toBe("unavailable");
    expect(
      result.checks.find(({ status }) => status === "failed"),
    ).toMatchObject({ name: "native_decompiler", code: "executable_missing" });
  });

  it("explains an accepted decompiler by its header, not only its path", async () => {
    const result = await inspectGhidraInstallation(
      {
        resourceOwner: inspectionResources.owner,
        environment: {},
        installDir: INSTALL,
        platform: "linux",
        architecture: "x64",
      },
      host({
        executableHeader: (path: string) =>
          path === LINUX_DECOMPILER
            ? headerProbe(elf(2, 1, 62))
            : javaProbeOk(undefined),
      }),
    );
    expect(result.status).toBe("available");
    if (result.status !== "available") return;
    expect(
      result.checks.find(({ name }) => name === "native_decompiler"),
    ).toMatchObject({
      status: "passed",
      detail: `${LINUX_DECOMPILER} reports elf x86_64, which matches linux/x64`,
    });
  });
});

describe("Ghidra native decompiler compatibility", () => {
  it("keeps an unreadable header unknown instead of failing the install", async () => {
    const result = await inspectGhidraInstallation(
      {
        resourceOwner: inspectionResources.owner,
        environment: {},
        installDir: INSTALL,
        platform: "linux",
        architecture: "x64",
      },
      host({ executableHeader: () => javaProbeOk(undefined) }),
    );
    expect(result.status).toBe("available");
    if (result.status !== "available") return;
    expect(
      result.checks.find(({ name }) => name === "native_decompiler"),
    ).toMatchObject({
      status: "passed",
      detail: expect.stringContaining("could not be established"),
    });
  });

  it("accepts a one-slice universal-format Darwin native decompiler", async () => {
    const bytes = fat([0x0100000c]);
    const result = await inspectGhidraInstallation(
      {
        resourceOwner: inspectionResources.owner,
        environment: {},
        installDir: INSTALL,
        platform: "darwin",
        architecture: "arm64",
      },
      host({
        probeJava: () =>
          javaProbeOk<GhidraJavaObservation>({
            ...JAVA,
            osArch: "aarch64",
            osName: "Mac OS X",
          }),
        executableHeader: (path: string) =>
          path === MAC_DECOMPILER ? headerProbe(bytes) : javaProbeOk(undefined),
      }),
    );
    expect(result.status).toBe("available");
    if (result.status !== "available") return;
    expect(
      result.checks.find(({ name }) => name === "native_decompiler"),
    ).toMatchObject({
      status: "passed",
      detail: `${MAC_DECOMPILER} reports mach-o-universal arm64, which matches darwin/arm64`,
    });
  });

  it("names the observed and the required executable in the failure", async () => {
    const result = await inspectGhidraInstallation(
      {
        resourceOwner: inspectionResources.owner,
        environment: {},
        installDir: INSTALL,
        platform: "darwin",
        architecture: "arm64",
      },
      host({
        probeJava: () =>
          javaProbeOk<GhidraJavaObservation>({
            ...JAVA,
            osArch: "aarch64",
            osName: "Mac OS X",
          }),
        executableHeader: (path: string) =>
          path === MAC_DECOMPILER
            ? headerProbe(elf(2, 1, 62))
            : javaProbeOk(undefined),
      }),
    );
    expect(result.status).toBe("unavailable");
    if (result.status !== "unavailable") return;
    expect(
      result.checks.find(({ name }) => name === "native_decompiler"),
    ).toMatchObject({
      status: "failed",
      detail: expect.stringMatching(
        /reports elf x86_64, but darwin\/arm64 requires mach-o arm64/u,
      ),
      remediation: expect.stringContaining("os/mac_arm_64/decompile"),
    });
  });
});

describe("Ghidra JVM native directory admission", () => {
  it("rejects a JDK whose os.arch selects a different native decompiler directory", async () => {
    const result = await inspectGhidraInstallation(
      {
        resourceOwner: inspectionResources.owner,
        environment: {},
        installDir: INSTALL,
        platform: "darwin",
        architecture: "arm64",
      },
      host({
        probeJava: () =>
          javaProbeOk<GhidraJavaObservation>({
            ...JAVA,
            osArch: "x86_64",
            osName: "Mac OS X",
          }),
      }),
    );
    expect(result.status).toBe("unavailable");
    if (result.status !== "unavailable") return;
    expect(
      result.checks.find(({ name }) => name === "native_decompiler"),
    ).toMatchObject({
      status: "failed",
      code: "executable_missing",
      detail: expect.stringContaining(
        "JVM reports os.arch=x86_64, so Ghidra selects its native decompiler from os/mac_x86_64",
      ),
      remediation: expect.stringContaining("JAVA_HOME"),
    });
  });

  it("accepts a JDK whose os.arch selects the validated native decompiler directory", async () => {
    const result = await inspectGhidraInstallation(
      {
        resourceOwner: inspectionResources.owner,
        environment: {},
        installDir: INSTALL,
        platform: "darwin",
        architecture: "arm64",
      },
      host({
        probeJava: () =>
          javaProbeOk<GhidraJavaObservation>({
            ...JAVA,
            osArch: "aarch64",
            osName: "Mac OS X",
          }),
      }),
    );
    expect(result.status).toBe("available");
  });

  it("rejects a successful Java probe that omits os.arch", async () => {
    const { osArch: _observedArchitecture, ...withoutArchitecture } = JAVA;
    const result = await inspectGhidraInstallation(
      {
        resourceOwner: inspectionResources.owner,
        environment: {},
        installDir: INSTALL,
        platform: "darwin",
        architecture: "arm64",
      },
      host({
        probeJava: () =>
          javaProbeOk<GhidraJavaObservation>(withoutArchitecture),
      }),
    );
    expect(result.status).toBe("unavailable");
    expect(
      result.checks.find(({ name }) => name === "native_decompiler"),
    ).toMatchObject({
      status: "failed",
      detail: expect.stringContaining("did not report os.arch"),
    });
    expect(projectGhidraDoctorInspection(result).available).toBe(false);
  });

  it.each(["riscv64", "sparcv9", ""])(
    "refuses an unrecognized JVM os.arch (%s) instead of assuming alignment",
    async (osArch) => {
      const result = await inspectGhidraInstallation(
        {
          resourceOwner: inspectionResources.owner,
          environment: {},
          installDir: INSTALL,
          platform: "darwin",
          architecture: "arm64",
        },
        host({
          probeJava: () =>
            javaProbeOk<GhidraJavaObservation>({ ...JAVA, osArch }),
        }),
      );
      expect(result.status).toBe("unavailable");
      if (result.status !== "unavailable") return;
      expect(
        result.checks.find(({ name }) => name === "native_decompiler"),
      ).toMatchObject({
        status: "failed",
        detail: expect.stringContaining("unrecognized os.arch="),
      });
    },
  );

  it("rejects a JDK whose os.name selects a different host OS", async () => {
    const result = await inspectGhidraInstallation(
      {
        resourceOwner: inspectionResources.owner,
        environment: {},
        installDir: INSTALL,
        platform: "darwin",
        architecture: "arm64",
      },
      host({
        probeJava: () =>
          javaProbeOk<GhidraJavaObservation>({
            ...JAVA,
            osArch: "aarch64",
            osName: "Windows 11",
          }),
      }),
    );
    expect(result.status).toBe("unavailable");
    if (result.status !== "unavailable") return;
    expect(
      result.checks.find(({ name }) => name === "native_decompiler"),
    ).toMatchObject({
      status: "failed",
      code: "executable_missing",
      detail: expect.stringContaining("JVM reports os.name=Windows 11"),
      remediation: expect.stringContaining("JAVA_HOME"),
    });
  });
});

describe("Ghidra JVM OS admission", () => {
  it("rejects a successful Java probe that omits os.name", async () => {
    const { osName: _observedOsName, ...withoutOsName } = JAVA;
    const result = await inspectGhidraInstallation(
      {
        resourceOwner: inspectionResources.owner,
        environment: {},
        installDir: INSTALL,
        platform: "linux",
        architecture: "x64",
      },
      host({
        probeJava: () => javaProbeOk<GhidraJavaObservation>(withoutOsName),
      }),
    );
    expect(result.status).toBe("unavailable");
    expect(
      result.checks.find(({ name }) => name === "native_decompiler"),
    ).toMatchObject({
      status: "failed",
      detail: expect.stringContaining("did not report os.name"),
    });
    expect(projectGhidraDoctorInspection(result).available).toBe(false);
  });

  it.each(["SunOS", "FreeBSD", ""])(
    "refuses an unrecognized JVM os.name (%s) instead of assuming alignment",
    async (osName) => {
      const result = await inspectGhidraInstallation(
        {
          resourceOwner: inspectionResources.owner,
          environment: {},
          installDir: INSTALL,
          platform: "linux",
          architecture: "x64",
        },
        host({
          probeJava: () =>
            javaProbeOk<GhidraJavaObservation>({ ...JAVA, osName }),
        }),
      );
      expect(result.status).toBe("unavailable");
      if (result.status !== "unavailable") return;
      expect(
        result.checks.find(({ name }) => name === "native_decompiler"),
      ).toMatchObject({
        status: "failed",
        detail: expect.stringContaining("os.name="),
      });
    },
  );
});

describe("Ghidra Java probe os.arch extraction", () => {
  it("extracts os.arch through the real Java probe into the installation diagnostics", async () => {
    const stderr = [
      "Property settings:",
      "    java.home = /usr/lib/jvm/jdk-21",
      "    java.version = 21.0.11",
      "    java.vm.name = OpenJDK 64-Bit Server VM",
      "    os.arch = x86_64",
      "    os.name = Linux",
      "    sun.arch.data.model = 64",
      "",
    ].join("\n");
    const inspection = await inspectGhidraInstallation(
      {
        resourceOwner: inspectionResources.owner,
        environment: {},
        installDir: INSTALL,
        javaHome: "/usr/lib/jvm/jdk-21",
        platform: "linux",
        architecture: "x64",
      },
      host({
        probeJava: (command) =>
          parseGhidraJavaOutput(command, {
            exitCode: 0,
            signal: null,
            stdout: { text: "", bytes: 0, observedBytes: 0 },
            stderr: {
              text: stderr,
              bytes: Buffer.byteLength(stderr),
              observedBytes: Buffer.byteLength(stderr),
            },
          }),
      }),
    );
    expect(ghidraInstallationDiagnostics(inspection)).toMatchObject({
      java_os_arch: "x86_64",
      java_os_name: "Linux",
    });
  });
});

it("explains the macOS keg-only JDK case without probing an unselected installation", async () => {
  const probed: string[] = [];
  const inspection = await inspectGhidraInstallation(
    {
      resourceOwner: inspectionResources.owner,
      environment: {},
      installDir: INSTALL,
      platform: "darwin",
      architecture: "arm64",
    },
    host({
      probeJava: (command) => {
        probed.push(command);
        return missingJavaProbe;
      },
    }),
  );
  expect(probed).toEqual(["java"]);
  expect(inspection.checks.find(({ name }) => name === "java")).toMatchObject({
    status: "failed",
    code: "runtime_missing",
    remediation: expect.stringContaining("Homebrew OpenJDK can be keg-only"),
  });
  const java = inspection.checks.find(({ name }) => name === "java");
  expect(java?.status === "failed" ? java.remediation : "").toContain(
    "/opt/homebrew/opt/openjdk/libexec/openjdk.jdk/Contents/Home",
  );
});

it.each([
  ["arm64", "/opt/homebrew"],
  ["x64", "/usr/local"],
] as const)(
  "discovers keg-only Java for macOS %s",
  async (architecture, prefix) => {
    const probed: string[] = [];
    const checked: string[] = [];
    const inspection = await inspectGhidraInstallation(
      {
        resourceOwner: inspectionResources.owner,
        environment: { PATH: ":relative-bin:/empty-bin" },
        installDir: INSTALL,
        platform: "darwin",
        architecture,
      },
      host({
        executable: (candidate) => {
          checked.push(candidate);
          return (
            candidate.includes("/opt/openjdk/") || host().executable(candidate)
          );
        },
        probeJava: (command) => {
          probed.push(command);
          return javaProbeOk({
            ...JAVA,
            home: `${prefix}/opt/openjdk/libexec/openjdk.jdk/Contents/Home`,
            osArch: architecture === "arm64" ? "aarch64" : "x86_64",
            osName: "Mac OS X",
          });
        },
      }),
    );
    expect(probed).toEqual([
      `${prefix}/opt/openjdk/libexec/openjdk.jdk/Contents/Home/bin/java`,
    ]);
    expect(checked).not.toContain("java");
    expect(checked).not.toContain("relative-bin/java");
    expect(inspection.checks.find(({ name }) => name === "java")).toMatchObject(
      {
        status: "passed",
      },
    );
  },
);

it.each([
  ["darwin", undefined, "/selected-bin/java", "java"],
  ["darwin", "/selected-jdk", undefined, "/selected-jdk/bin/java"],
  ["linux", undefined, undefined, "java"],
  ["win32", undefined, undefined, "java.exe"],
] as const)(
  "preserves selected Java on %s with JAVA_HOME %s",
  async (platform, javaHome, pathJava, expected) => {
    const checked: string[] = [];
    const probed: string[] = [];
    await inspectGhidraInstallation(
      {
        resourceOwner: inspectionResources.owner,
        environment: { PATH: "/selected-bin" },
        installDir: INSTALL,
        platform,
        architecture: "arm64",
        ...(javaHome === undefined ? {} : { javaHome }),
      },
      host({
        executable: (candidate) => {
          checked.push(candidate);
          return candidate === pathJava || host().executable(candidate);
        },
        probeJava: (command) => {
          probed.push(command);
          return missingJavaProbe;
        },
      }),
    );
    expect(probed).toEqual([expected]);
    expect(
      checked.some((candidate) => candidate.includes("/opt/openjdk/")),
    ).toBe(false);
  },
);

it("retains a failed header observation as unknown in installation and doctor diagnostics", async () => {
  const failure = new ProviderAdapterError("ghidra", "ghidra:installation", {
    userMessage: "controlled header read failure",
    diagnostics: {
      path: LINUX_DECOMPILER,
      stage: "native_decompiler_header",
      system_code: "EIO",
    },
  });
  const result = await inspectGhidraInstallation(
    {
      resourceOwner: inspectionResources.owner,
      environment: {},
      installDir: INSTALL,
      platform: "linux",
      architecture: "x64",
    },
    host({ executableHeader: () => err(failure) }),
  );
  expect(result.status).toBe("available");
  expect(result.nativeDecompilerHeaderFailure).toBe(failure);
  expect(ghidraInstallationDiagnostics(result)).toMatchObject({
    native_decompiler_header_failure: {
      details: {
        operation: "ghidra:installation",
        diagnostics: { system_code: "EIO" },
      },
    },
  });
  expect(
    projectGhidraDoctorInspection(result).checks.find(
      ({ name }) => name === "native_decompiler",
    ),
  ).toMatchObject({
    ok: true,
    detail: expect.stringContaining("header is unknown"),
    details: {
      header_failure: { details: { diagnostics: { system_code: "EIO" } } },
    },
  });
});

it.each(["cancelled", "cleanup"] as const)(
  "propagates header %s instead of treating it as optional unknown compatibility",
  async (kind) => {
    const reason = { request: "header interrupted" };
    const failure =
      kind === "cancelled"
        ? new AnalysisCancelledError("ghidra:installation", { cause: reason })
        : new ProviderAdapterError("ghidra", "ghidra:installation", {
            cleanup: {
              resources: [LINUX_DECOMPILER],
              reason: "controlled close refusal",
            },
          });
    await expect(
      inspectGhidraInstallation(
        {
          resourceOwner: inspectionResources.owner,
          environment: {},
          installDir: INSTALL,
          platform: "linux",
          architecture: "x64",
        },
        host({ executableHeader: () => err(failure) }),
      ),
    ).rejects.toBe(failure);
  },
);