rea-agents 2.0.0 → 2.2.0

package/dist/ghidra/GhidraLauncher.js

@@ -1,9 +1,9 @@
 import { mkdir } from "node:fs/promises";
-import { basename, dirname, join } from "node:path";
+import { basename, dirname, join, win32 } from "node:path";
 import writeFileAtomic from "write-file-atomic";
 import { AnalysisCancelledError } from "../domain/errors.js";
 import { err, ok } from "../domain/result.js";
-import { cleanupOwnedProcessGroup } from "../process/ProcessOwnership.js";
+import { cleanupOwnedProcessGroup, cleanupWindowsProcessTree, } from "../process/ProcessOwnership.js";
 import { spawnOwnedProviderProcess, } from "../process/ProviderProcess.js";
 import { GHIDRA_ANALYSIS_TIMEOUT_SECONDS, GHIDRA_MAX_CPU, GHIDRA_MAX_HEAP, } from "./GhidraDefaults.js";
 import { ghidraJavaEnvironment } from "./GhidraInstallation.js";
@@ -24,6 +24,7 @@ export class GhidraHeadlessLauncher {
         if (isAborted(options.signal))
             return err(new AnalysisCancelledError("open_binary"));
         const paths = ghidraRuntimePaths(session.runtimeRoot);
+        const platform = this.options.platform ?? process.platform;
         let started;
         try {
             await Promise.all([
@@ -35,30 +36,42 @@ export class GhidraHeadlessLauncher {
                 paths.dataRoot,
             ].map((path) => mkdir(path, { recursive: true, mode: 0o700 })));
             await writeFileAtomic(paths.descriptorPath, `${JSON.stringify({
-                schema_version: 1,
-                socket_path: session.socketPath,
+                schema_version: 2,
+                transport: session.transport,
+                endpoint_path: session.endpointPath,
                 token: session.token,
                 run_id: session.runId,
+                target_sha256: session.targetSha256,
                 provider_version: session.providerVersion,
                 profile_digest: session.profileDigest,
             })}\n`, { encoding: "utf8", mode: 0o600 });
             if (isAborted(options.signal))
                 return err(new AnalysisCancelledError("open_binary"));
+            const headlessArguments = ghidraHeadlessArguments({
+                projectRoot: paths.projectRoot,
+                targetPath: session.targetPath,
+                bridgeScriptPath: this.options.bridgeScriptPath,
+                descriptorPath: paths.descriptorPath,
+                ghidraLogPath: paths.ghidraLogPath,
+                scriptLogPath: paths.scriptLogPath,
+            });
+            const command = ghidraHeadlessCommand({
+                platform,
+                analyzeHeadlessPath: this.options.analyzeHeadlessPath,
+                arguments: headlessArguments,
+                ...(this.options.comSpec === undefined
+                    ? {}
+                    : { comSpec: this.options.comSpec }),
+            });
             started = await spawnOwnedProviderProcess({
-                command: this.options.analyzeHeadlessPath,
-                arguments: ghidraHeadlessArguments({
-                    projectRoot: paths.projectRoot,
-                    targetPath: session.targetPath,
-                    bridgeScriptPath: this.options.bridgeScriptPath,
-                    descriptorPath: paths.descriptorPath,
-                    ghidraLogPath: paths.ghidraLogPath,
-                    scriptLogPath: paths.scriptLogPath,
-                }),
+                command: command.command,
+                arguments: command.arguments,
                 runId: session.runId,
                 // analyzeHeadless is an interpreter-driven script. Parent identity and
                 // the per-process run token remain the cleanup authority.
                 expectedCommand: null,
-                env: ghidraLaunchEnvironment(paths, this.options.javaHome),
+                windowsVerbatimArguments: platform === "win32",
+                env: ghidraLaunchEnvironment(paths, this.options.javaHome, platform),
             });
             await writeFileAtomic(paths.ownershipPath, `${JSON.stringify({
                 schema_version: 1,
@@ -66,18 +79,21 @@ export class GhidraHeadlessLauncher {
                 pid: started.ownership.leaderPid,
                 process_group_id: started.ownership.processGroupId,
                 parent_pid: process.pid,
+                ownership_kind: platform === "win32"
+                    ? "windows-process-tree-p0"
+                    : "posix-process-group",
                 launcher: this.options.analyzeHeadlessPath,
                 created_at: new Date().toISOString(),
             })}\n`, { encoding: "utf8", mode: 0o600 });
             if (isAborted(options.signal)) {
-                await cleanupOwnedProcessGroup(started.ownership);
+                await cleanupStartedProcess(started, platform);
                 return err(new AnalysisCancelledError("open_binary"));
             }
-            const ownership = started.ownership;
+            const spawned = started;
             return ok({
-                process: started.process,
+                process: spawned.process,
                 ownsProcessLifetime: true,
-                cleanup: () => cleanupOwnedProcessGroup(ownership),
+                cleanup: () => cleanupStartedProcess(spawned, platform),
                 projectRoot: paths.projectRoot,
                 ghidraLogPath: paths.ghidraLogPath,
                 scriptLogPath: paths.scriptLogPath,
@@ -85,13 +101,49 @@ export class GhidraHeadlessLauncher {
         }
         catch (cause) {
             if (started !== undefined)
-                await cleanupOwnedProcessGroup(started.ownership).catch(() => undefined);
+                await cleanupStartedProcess(started, platform).catch(() => undefined);
             return isAborted(options.signal)
                 ? err(new AnalysisCancelledError("open_binary"))
                 : err(new GhidraLaunchError("Ghidra headless launch failed", { cause }));
         }
     }
 }
+/** Build a direct POSIX launch or a conservatively quoted Windows batch call. */
+export const ghidraHeadlessCommand = (options) => {
+    if (options.platform !== "win32")
+        return {
+            command: options.analyzeHeadlessPath,
+            arguments: [...options.arguments],
+        };
+    const comSpec = options.comSpec ??
+        process.env.ComSpec ??
+        (process.env.SystemRoot === undefined
+            ? "C:\\Windows\\System32\\cmd.exe"
+            : win32.join(process.env.SystemRoot, "System32", "cmd.exe"));
+    if (!win32.isAbsolute(comSpec) ||
+        win32.basename(comSpec).toLowerCase() !== "cmd.exe")
+        throw new GhidraLaunchError("Windows ComSpec must be an absolute cmd.exe path");
+    const tokens = [options.analyzeHeadlessPath, ...options.arguments].map(quoteWindowsBatchToken);
+    const invocation = `"${tokens.join(" ")}"`;
+    if (invocation.length > 30_000)
+        throw new GhidraLaunchError("Windows Ghidra command exceeds the P0 length limit");
+    return {
+        command: comSpec,
+        arguments: ["/d", "/e:on", "/v:off", "/s", "/c", invocation],
+    };
+};
+const quoteWindowsBatchToken = (value) => {
+    if (value.length === 0 ||
+        value.includes("\0") ||
+        value.includes("\r") ||
+        value.includes("\n") ||
+        /["%^!&|<>]/u.test(value))
+        throw new GhidraLaunchError("Windows Ghidra P0 paths cannot contain command-interpreter metacharacters");
+    return `"${value}"`;
+};
+const cleanupStartedProcess = (started, platform) => platform === "win32"
+    ? cleanupWindowsProcessTree(started.ownership.leaderPid)
+    : cleanupOwnedProcessGroup(started.ownership);
 /** Build the complete read-only headless invocation in deterministic order. */
 export const ghidraHeadlessArguments = (options) => [
     options.projectRoot,
@@ -126,14 +178,26 @@ const ghidraRuntimePaths = (runtimeRoot) => ({
     ghidraLogPath: join(runtimeRoot, "ghidra.log"),
     scriptLogPath: join(runtimeRoot, "script.log"),
 });
-const ghidraLaunchEnvironment = (paths, javaHome) => ({
-    ...ghidraJavaEnvironment(javaHome),
-    HOME: paths.homeRoot,
-    TMPDIR: paths.tempRoot,
-    XDG_CACHE_HOME: paths.cacheRoot,
-    XDG_CONFIG_HOME: paths.configRoot,
-    XDG_DATA_HOME: paths.dataRoot,
-    GHIDRA_HEADLESS_MAXMEM: GHIDRA_MAX_HEAP,
-    GHIDRA_HEADLESS_JAVA_OPTIONS: `-Duser.home=${paths.homeRoot} -Djava.io.tmpdir=${paths.tempRoot}`,
-});
+const ghidraLaunchEnvironment = (paths, javaHome, platform) => {
+    const javaOptions = platform === "win32"
+        ? `"-Duser.home=${paths.homeRoot}" "-Djava.io.tmpdir=${paths.tempRoot}"`
+        : `-Duser.home=${paths.homeRoot} -Djava.io.tmpdir=${paths.tempRoot}`;
+    return {
+        ...ghidraJavaEnvironment(javaHome, process.env, platform),
+        HOME: paths.homeRoot,
+        TMPDIR: paths.tempRoot,
+        ...(platform === "win32"
+            ? {
+                USERPROFILE: paths.homeRoot,
+                TEMP: paths.tempRoot,
+                TMP: paths.tempRoot,
+            }
+            : {}),
+        XDG_CACHE_HOME: paths.cacheRoot,
+        XDG_CONFIG_HOME: paths.configRoot,
+        XDG_DATA_HOME: paths.dataRoot,
+        GHIDRA_HEADLESS_MAXMEM: GHIDRA_MAX_HEAP,
+        GHIDRA_HEADLESS_JAVA_OPTIONS: javaOptions,
+    };
+};
 const isAborted = (signal) => signal?.aborted === true;

package/dist/ghidra/GhidraProvider.js

@@ -2,169 +2,18 @@ import { fileURLToPath } from "node:url";
 import { createAnalysisExecution, } from "../application/AnalysisProvider.js";
 import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisInputError, AnalysisTimeoutError, ProviderAdapterError, } from "../domain/errors.js";
 import { err, ok } from "../domain/result.js";
-import { ENHANCED_TOOL_CONTRACTS, OFFICIAL_TOOL_CONTRACTS, } from "../contracts/toolContracts.js";
 import { GhidraClient } from "./GhidraClient.js";
-import { GHIDRA_ANALYSIS_TIMEOUT_SECONDS, GHIDRA_DECOMPILE_REQUEST_TIMEOUT_MS, GHIDRA_DECOMPILE_TIMEOUT_SECONDS, GHIDRA_MAX_LINE_BYTES, GHIDRA_REQUEST_TIMEOUT_MS, GHIDRA_STARTUP_TIMEOUT_MS, } from "./GhidraDefaults.js";
-import { GHIDRA_FUNCTION_OPERATIONS, isGhidraFunctionOperation, parseGhidraFunctionInput, parseGhidraFunctionResult, } from "./GhidraFunctionValues.js";
-import { GHIDRA_INVENTORY_OPERATIONS, isGhidraInventoryOperation, parseGhidraInventoryInput, parseGhidraInventoryResult, } from "./GhidraInventoryValues.js";
+import { GHIDRA_ANALYSIS_TIMEOUT_SECONDS, GHIDRA_DECOMPILE_REQUEST_TIMEOUT_MS, GHIDRA_DECOMPILE_TIMEOUT_SECONDS, GHIDRA_STARTUP_TIMEOUT_MS, } from "./GhidraDefaults.js";
+import { isGhidraFunctionOperation, parseGhidraFunctionInput, parseGhidraFunctionResult, } from "./GhidraFunctionValues.js";
+import { isGhidraInventoryOperation, parseGhidraInventoryInput, parseGhidraInventoryResult, } from "./GhidraInventoryValues.js";
 import { ghidraInstallationDiagnostics, inspectGhidraInstallation, } from "./GhidraInstallation.js";
 import { GhidraHeadlessLauncher } from "./GhidraLauncher.js";
 import { resolveGhidraAnalysisProfile } from "./GhidraAnalysisProfile.js";
-/** Public identity committed by every Ghidra-backed observation. */
-export const GHIDRA_PROVIDER_IDENTITY = Object.freeze({
-    id: "ghidra",
-    name: "Ghidra",
-    version: null,
-});
-const providerContractByName = new Map([...OFFICIAL_TOOL_CONTRACTS, ...ENHANCED_TOOL_CONTRACTS].map((contract) => [
-    contract.name,
-    contract,
-]));
-/** Provider-neutral read-only contracts implemented by the Ghidra adapter. */
-export const GHIDRA_PROVIDER_TOOL_CONTRACTS = Object.freeze([...GHIDRA_INVENTORY_OPERATIONS, ...GHIDRA_FUNCTION_OPERATIONS].map((operation) => {
-    const contract = providerContractByName.get(operation);
-    if (contract === undefined)
-        throw new TypeError(`Missing provider-neutral contract for ${operation}`);
-    return contract;
-}));
-const PAGINATED_OPERATIONS = new Set([
-    "list_names",
-    "list_procedures",
-    "list_strings",
-    "search_procedures",
-    "search_strings",
-    "procedure_references",
-    "analyze_function",
-]);
-const SEARCH_OPERATIONS = new Set([
-    "search_procedures",
-    "search_strings",
-]);
-const DECOMPILE_OPERATIONS = new Set([
-    "procedure_pseudo_code",
-    "analyze_function",
-]);
-const healthLimitations = Object.freeze([
-    "The session serves operations only after default Ghidra auto-analysis completes; an analysis timeout fails the open instead of exposing partial results.",
-    "The imported Program and temporary project are ephemeral, read-only to REA, and deleted on close.",
-]);
-const limitationsFor = (operation) => {
-    const common = [
-        ...healthLimitations,
-        "Default-space addresses use lowercase 0x-prefixed hexadecimal; other address spaces use <percent-encoded-space>:0x<hex>.",
-    ];
-    switch (operation) {
-        case "list_documents":
-            return [
-                ...common,
-                "A headless Ghidra session contains exactly one imported Program, unlike Hopper's multi-document GUI session.",
-            ];
-        case "list_names":
-            return [
-                ...common,
-                "The symbol inventory includes memory and external symbols, including dynamic symbols, but excludes variable and no-address namespace records.",
-            ];
-        case "list_procedures":
-        case "procedure_address":
-            return [
-                ...common,
-                "External functions and local thunks are distinct; procedure metadata identifies both and preserves a thunk target when Ghidra resolves one.",
-            ];
-        case "list_strings":
-            return [
-                ...common,
-                "Only Ghidra-defined string Data is observed; charset is reported, while a non-missing terminator cannot distinguish a present terminator from a fixed or Pascal layout.",
-                "Returned values are bounded to 1,024 Unicode code points and mark value_truncated instead of silently crossing the wire budget.",
-            ];
-        case "list_segments":
-            return [
-                ...common,
-                "Memory-block end addresses are exclusive; permissions come from Ghidra MemoryBlock flags rather than inference from section names.",
-            ];
-        case "search_procedures":
-        case "search_strings":
-            return [
-                ...common,
-                "Literal search enforces 1,000,000 cumulative work units; regex mode also accepts only a conservative finite Java-regex subset with 10,000 static paths and 4,096 UTF-16 code units per candidate.",
-            ];
-        case "procedure_pseudo_code":
-            return [
-                ...common,
-                "Pseudocode is Ghidra decompiler output, not original source and not text-equivalent to Hopper output; each decompile has a 30-second native deadline.",
-                "External functions and functions without an analyzable body return null; other decompiler failures remain explicit.",
-            ];
-        case "procedure_assembly":
-            return [
-                ...common,
-                "Assembly is Ghidra Listing text and fails rather than silently truncating when the 100,000-instruction or 1 MiB wire bound is exceeded.",
-            ];
-        case "procedure_callers":
-        case "procedure_callees":
-            return [
-                ...common,
-                "Only resolved Ghidra call references are returned; unresolved computed or indirect calls remain unknown, while function classifications distinguish thunks and externals.",
-            ];
-        case "xrefs":
-            return [
-                ...common,
-                "The direct address list projects exact Ghidra references to one address but does not expose their kinds; procedure_references and analyze_function preserve available kind metadata.",
-                "Synthetic Ghidra entry-point references without actionable memory sources are omitted.",
-            ];
-        case "procedure_references":
-            return [
-                ...common,
-                "Reference kinds are direct Ghidra ReferenceManager observations; unresolved computed flows without a target are absent and remain unknown.",
-                "Synthetic Ghidra entry-point references without actionable memory sources are omitted.",
-                "Instruction scans stop at max_instructions; a truncated scan reports an unknown total and no false continuation.",
-            ];
-        case "analyze_function":
-            return [
-                ...common,
-                "The dossier combines Ghidra FunctionManager, Listing, ReferenceManager, BasicBlockModel, and decompiler observations; provider-specific pseudocode and assembly are not cross-provider text invariants.",
-                "Resolved reference metadata identifies computed, indirect, external, call, jump, and data edges; unresolved targetless flows remain unknown, and function classifications distinguish thunks and externals.",
-                "Synthetic Ghidra entry-point references without actionable memory sources are omitted.",
-                "The Java bridge serializes one function request per Program through a bounded 32-request queue and applies a 30-second native decompilation deadline.",
-            ];
-        default:
-            return common;
-    }
-};
-const CAPABILITIES = Object.freeze(GHIDRA_PROVIDER_TOOL_CONTRACTS.map((contract) => Object.freeze({
-    provider: GHIDRA_PROVIDER_IDENTITY,
-    operation: contract.name,
-    inputContractVersion: 1,
-    outputContractVersion: 1,
-    available: true,
-    reason: null,
-    pagination: PAGINATED_OPERATIONS.has(contract.name)
-        ? "offset"
-        : "none",
-    exhaustive: !PAGINATED_OPERATIONS.has(contract.name),
-    effects: Object.freeze({
-        mutatesArtifact: false,
-        launchesProcess: true,
-        mayShowUi: false,
-        mayAccessNetwork: false,
-        mayWriteFilesystem: true,
-        changesPermissions: false,
-        requiresRoot: false,
-    }),
-    limits: Object.freeze({
-        maxResults: PAGINATED_OPERATIONS.has(contract.name)
-            ? SEARCH_OPERATIONS.has(contract.name)
-                ? 100
-                : 500
-            : null,
-        maxPayloadBytes: GHIDRA_MAX_LINE_BYTES,
-        timeoutMs: DECOMPILE_OPERATIONS.has(contract.name)
-            ? GHIDRA_DECOMPILE_REQUEST_TIMEOUT_MS
-            : GHIDRA_REQUEST_TIMEOUT_MS,
-    }),
-    limitations: Object.freeze(limitationsFor(contract.name)),
-})));
+import { CAPABILITIES, WINDOWS_P0_CAPABILITIES, GHIDRA_PROVIDER_IDENTITY, GHIDRA_PROVIDER_TOOL_CONTRACTS, healthLimitations, windowsP0Limitations, limitationsFor, } from "./GhidraProviderCapabilities.js";
+export { GHIDRA_PROVIDER_IDENTITY, GHIDRA_PROVIDER_TOOL_CONTRACTS };
 const SUPPORTED_ARCHITECTURES = new Set(["x86", "x86_64", "arm", "arm64"]);
 const SUPPORTED_FORMATS = new Set(["elf", "pe", "mach-o"]);
-/** Linux Ghidra candidate backed by an isolated read-only headless import. */
+/** Ghidra candidate backed by an isolated read-only headless import. */
 export class GhidraProvider {
     config;
     logger;
@@ -181,7 +30,9 @@ export class GhidraProvider {
         return GHIDRA_PROVIDER_IDENTITY;
     }
     capabilities() {
-        return CAPABILITIES;
+        return (this.installationHost?.platform ?? process.platform) === "win32"
+            ? WINDOWS_P0_CAPABILITIES
+            : CAPABILITIES;
     }
     inspectAvailability() {
         const installation = this.#inspectInstallation();
@@ -201,10 +52,14 @@ export class GhidraProvider {
             };
     }
     inspectTargetSupport(target) {
+        const hostPlatform = this.installationHost?.platform ?? process.platform;
         const diagnostics = {
+            host_platform: hostPlatform,
             target_kind: target.kind,
             target_format: target.format,
             architecture: target.architecture ?? null,
+            executable_role: target.executableRole ?? null,
+            managed: target.managed ?? null,
         };
         if (target.kind !== "executable")
             return {
@@ -213,6 +68,8 @@ export class GhidraProvider {
                 reason: `Ghidra v1 imports executable targets, not ${target.kind} targets.`,
                 diagnostics,
             };
+        if (hostPlatform === "win32")
+            return inspectWindowsP0TargetSupport(target, diagnostics);
         if (!SUPPORTED_FORMATS.has(target.format))
             return {
                 status: "unsupported",
@@ -244,6 +101,7 @@ export class GhidraProvider {
         if (!prerequisites.ok)
             return unavailableClient(prerequisites.error);
         const committedProfile = prerequisites.value.profile;
+        const providerLimitations = installation.platform === "win32" ? windowsP0Limitations : [];
         const client = this.clientFactory({
             launcher: new GhidraHeadlessLauncher({
                 analyzeHeadlessPath: prerequisites.value.analyzeHeadlessPath,
@@ -251,8 +109,13 @@ export class GhidraProvider {
                     ? {}
                     : { javaHome: this.config.ghidraJavaHome }),
                 bridgeScriptPath: fileURLToPath(new URL("../../bridge/ghidra/ReaGhidraBridge.java", import.meta.url)),
+                platform: installation.platform,
             }),
             targetPath: target.path,
+            targetSha256: target.sha256,
+            transport: installation.platform === "win32"
+                ? "authenticated-loopback-tcp"
+                : "unix-socket",
             providerVersion: prerequisites.value.providerVersion,
             profileDigest: committedProfile.digest,
             logger: this.logger.child({ layer: "ghidra-bridge" }),
@@ -269,7 +132,7 @@ export class GhidraProvider {
                         return err(projectSessionError(operation, started.error));
                     return ok(createAnalysisExecution(started.value, committedProfile.provider, {
                         analysisProfile: committedProfile,
-                        limitations: healthLimitations,
+                        limitations: [...healthLimitations, ...providerLimitations],
                     }));
                 }
                 const input = isGhidraFunctionOperation(operation)
@@ -279,7 +142,8 @@ export class GhidraProvider {
                     return input;
                 const called = await client.callTool(operation, input.value, {
                     ...(options?.signal === undefined ? {} : { signal: options.signal }),
-                    ...(DECOMPILE_OPERATIONS.has(operation)
+                    ...(operation === "procedure_pseudo_code" ||
+                        operation === "analyze_function"
                         ? { timeoutMs: GHIDRA_DECOMPILE_REQUEST_TIMEOUT_MS }
                         : {}),
                 });
@@ -293,7 +157,7 @@ export class GhidraProvider {
                 return ok(createAnalysisExecution(result.value, committedProfile.provider, {
                     rawResult: called.value,
                     analysisProfile: committedProfile,
-                    limitations: limitationsFor(operation),
+                    limitations: [...limitationsFor(operation), ...providerLimitations],
                 }));
             },
             close: () => client.close(),
@@ -321,6 +185,42 @@ export class GhidraProvider {
         return this.#installation;
     }
 }
+const inspectWindowsP0TargetSupport = (target, diagnostics) => {
+    if (target.format !== "pe")
+        return {
+            status: "unsupported",
+            code: "target_format_unsupported",
+            reason: "Windows Ghidra P0 accepts PE targets only.",
+            diagnostics,
+        };
+    if (target.architecture !== "x86_64")
+        return {
+            status: "unsupported",
+            code: "architecture_unsupported",
+            reason: "Windows Ghidra P0 accepts x86-64 PE targets only.",
+            diagnostics,
+        };
+    if (target.executableRole !== "application")
+        return {
+            status: "unsupported",
+            code: "target_role_unsupported",
+            reason: "Windows Ghidra P0 accepts PE applications, not DLL or non-executable images.",
+            diagnostics,
+        };
+    if (target.managed !== false)
+        return {
+            status: "unsupported",
+            code: "managed_target_unsupported",
+            reason: "Windows Ghidra P0 accepts native PE applications; managed or unclassified PE targets are unsupported.",
+            diagnostics,
+        };
+    return {
+        status: "supported",
+        code: null,
+        reason: null,
+        diagnostics,
+    };
+};
 const ghidraClientPrerequisites = (target, profile, installation) => {
     if (target.kind !== "executable")
         return err(new AnalysisCapabilityUnavailableError("ghidra", "health", `Ghidra cannot import ${target.kind} targets through this adapter.`));

package/dist/ghidra/GhidraProviderCapabilities.js

@@ -0,0 +1,173 @@
+import { ENHANCED_TOOL_CONTRACTS, OFFICIAL_TOOL_CONTRACTS, } from "../contracts/toolContracts.js";
+import { GHIDRA_DECOMPILE_REQUEST_TIMEOUT_MS, GHIDRA_MAX_LINE_BYTES, GHIDRA_REQUEST_TIMEOUT_MS, } from "./GhidraDefaults.js";
+import { GHIDRA_FUNCTION_OPERATIONS } from "./GhidraFunctionValues.js";
+import { GHIDRA_INVENTORY_OPERATIONS } from "./GhidraInventoryValues.js";
+/** Public identity committed by every Ghidra-backed observation. */
+export const GHIDRA_PROVIDER_IDENTITY = Object.freeze({
+    id: "ghidra",
+    name: "Ghidra",
+    version: null,
+});
+const providerContractByName = new Map([...OFFICIAL_TOOL_CONTRACTS, ...ENHANCED_TOOL_CONTRACTS].map((contract) => [
+    contract.name,
+    contract,
+]));
+/** Provider-neutral read-only contracts implemented by the Ghidra adapter. */
+export const GHIDRA_PROVIDER_TOOL_CONTRACTS = Object.freeze([...GHIDRA_INVENTORY_OPERATIONS, ...GHIDRA_FUNCTION_OPERATIONS].map((operation) => {
+    const contract = providerContractByName.get(operation);
+    if (contract === undefined)
+        throw new TypeError(`Missing provider-neutral contract for ${operation}`);
+    return contract;
+}));
+const PAGINATED_OPERATIONS = new Set([
+    "list_names",
+    "list_procedures",
+    "list_strings",
+    "search_procedures",
+    "search_strings",
+    "procedure_references",
+    "analyze_function",
+]);
+const SEARCH_OPERATIONS = new Set([
+    "search_procedures",
+    "search_strings",
+]);
+const DECOMPILE_OPERATIONS = new Set([
+    "procedure_pseudo_code",
+    "analyze_function",
+]);
+/** Health limitations shared by every Ghidra-backed capability. */
+export const healthLimitations = Object.freeze([
+    "The session serves operations only after default Ghidra auto-analysis completes; an analysis timeout fails the open instead of exposing partial results.",
+    "The imported Program and temporary project are ephemeral, read-only to REA, and deleted on close.",
+]);
+/** Additional limitations applied to the experimental Windows x64 P0 boundary. */
+export const windowsP0Limitations = Object.freeze([
+    "Windows Ghidra P0 accepts approved native x86-64 PE applications only; DLL, managed, hostile, sensitive, and mutable-path targets are unsupported.",
+    "The Windows bridge uses authenticated IPv4 loopback because Node path-based IPC does not expose Java AF_UNIX sockets; the endpoint file contains no bearer token.",
+    "Windows P0 process-tree cleanup uses bounded taskkill termination and does not claim Job Object ownership, private DACL enforcement, or reparse-point-safe path authority.",
+]);
+/** Limitation text for one admitted operation, including the common base. */
+export const limitationsFor = (operation) => {
+    const common = [
+        ...healthLimitations,
+        "Default-space addresses use lowercase 0x-prefixed hexadecimal; other address spaces use <percent-encoded-space>:0x<hex>.",
+    ];
+    switch (operation) {
+        case "list_documents":
+            return [
+                ...common,
+                "A headless Ghidra session contains exactly one imported Program, unlike Hopper's multi-document GUI session.",
+            ];
+        case "list_names":
+            return [
+                ...common,
+                "The symbol inventory includes memory and external symbols, including dynamic symbols, but excludes variable and no-address namespace records.",
+            ];
+        case "list_procedures":
+        case "procedure_address":
+            return [
+                ...common,
+                "External functions and local thunks are distinct; procedure metadata identifies both and preserves a thunk target when Ghidra resolves one.",
+            ];
+        case "list_strings":
+            return [
+                ...common,
+                "Only Ghidra-defined string Data is observed; charset is reported, while a non-missing terminator cannot distinguish a present terminator from a fixed or Pascal layout.",
+                "Returned values are bounded to 1,024 Unicode code points and mark value_truncated instead of silently crossing the wire budget.",
+            ];
+        case "list_segments":
+            return [
+                ...common,
+                "Memory-block end addresses are exclusive; permissions come from Ghidra MemoryBlock flags rather than inference from section names.",
+            ];
+        case "search_procedures":
+        case "search_strings":
+            return [
+                ...common,
+                "Literal search enforces 1,000,000 cumulative work units; regex mode also accepts only a conservative finite Java-regex subset with 10,000 static paths and 4,096 UTF-16 code units per candidate.",
+            ];
+        case "procedure_pseudo_code":
+            return [
+                ...common,
+                "Pseudocode is Ghidra decompiler output, not original source and not text-equivalent to Hopper output; each decompile has a 30-second native deadline.",
+                "External functions and functions without an analyzable body return null; other decompiler failures remain explicit.",
+            ];
+        case "procedure_assembly":
+            return [
+                ...common,
+                "Assembly is Ghidra Listing text and fails rather than silently truncating when the 100,000-instruction or 1 MiB wire bound is exceeded.",
+            ];
+        case "procedure_callers":
+        case "procedure_callees":
+            return [
+                ...common,
+                "Only resolved Ghidra call references are returned; unresolved computed or indirect calls remain unknown, while function classifications distinguish thunks and externals.",
+            ];
+        case "xrefs":
+            return [
+                ...common,
+                "The direct address list projects exact Ghidra references to one address but does not expose their kinds; procedure_references and analyze_function preserve available kind metadata.",
+                "Synthetic Ghidra entry-point references without actionable memory sources are omitted.",
+            ];
+        case "procedure_references":
+            return [
+                ...common,
+                "Reference kinds are direct Ghidra ReferenceManager observations; unresolved computed flows without a target are absent and remain unknown.",
+                "Synthetic Ghidra entry-point references without actionable memory sources are omitted.",
+                "Instruction scans stop at max_instructions; a truncated scan reports an unknown total and no false continuation.",
+            ];
+        case "analyze_function":
+            return [
+                ...common,
+                "The dossier combines Ghidra FunctionManager, Listing, ReferenceManager, BasicBlockModel, and decompiler observations; provider-specific pseudocode and assembly are not cross-provider text invariants.",
+                "Resolved reference metadata identifies computed, indirect, external, call, jump, and data edges; unresolved targetless flows remain unknown, and function classifications distinguish thunks and externals.",
+                "Synthetic Ghidra entry-point references without actionable memory sources are omitted.",
+                "The Java bridge serializes one function request per Program through a bounded 32-request queue and applies a 30-second native decompilation deadline.",
+            ];
+        default:
+            return common;
+    }
+};
+/** Provider-neutral capabilities advertised by every non-Windows Ghidra session. */
+export const CAPABILITIES = Object.freeze(GHIDRA_PROVIDER_TOOL_CONTRACTS.map((contract) => Object.freeze({
+    provider: GHIDRA_PROVIDER_IDENTITY,
+    operation: contract.name,
+    inputContractVersion: 1,
+    outputContractVersion: 1,
+    available: true,
+    reason: null,
+    pagination: PAGINATED_OPERATIONS.has(contract.name)
+        ? "offset"
+        : "none",
+    exhaustive: !PAGINATED_OPERATIONS.has(contract.name),
+    effects: Object.freeze({
+        mutatesArtifact: false,
+        launchesProcess: true,
+        mayShowUi: false,
+        mayAccessNetwork: false,
+        mayWriteFilesystem: true,
+        changesPermissions: false,
+        requiresRoot: false,
+    }),
+    limits: Object.freeze({
+        maxResults: PAGINATED_OPERATIONS.has(contract.name)
+            ? SEARCH_OPERATIONS.has(contract.name)
+                ? 100
+                : 500
+            : null,
+        maxPayloadBytes: GHIDRA_MAX_LINE_BYTES,
+        timeoutMs: DECOMPILE_OPERATIONS.has(contract.name)
+            ? GHIDRA_DECOMPILE_REQUEST_TIMEOUT_MS
+            : GHIDRA_REQUEST_TIMEOUT_MS,
+    }),
+    limitations: Object.freeze(limitationsFor(contract.name)),
+})));
+/** Capabilities advertised for the experimental Windows x64 P0 boundary. */
+export const WINDOWS_P0_CAPABILITIES = Object.freeze(CAPABILITIES.map((capability) => Object.freeze({
+    ...capability,
+    limitations: Object.freeze([
+        ...capability.limitations,
+        ...windowsP0Limitations,
+    ]),
+})));