Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
feat(ghidra): launch bounded Windows headless sessions
N0zoM1z0bc0fb45f16db
diff --git a/scripts/verify-real-ghidra.mjs b/scripts/verify-real-ghidra.mjsindex f76fbb0ed..5b03d2edd 100644--- a/scripts/verify-real-ghidra.mjs+++ b/scripts/verify-real-ghidra.mjs@@ -187,6 +187,7 @@ async function verifyTarget(targetPath, variant, expectedTarget = null) {bridgeScriptPath: fileURLToPath(new URL("../bridge/ghidra/ReaGhidraBridge.java", import.meta.url),),+ platform: installation.platform,}),targetPath: parsedTarget.value.path,targetSha256: parsedTarget.value.sha256,diff --git a/src/ghidra/GhidraLauncher.ts b/src/ghidra/GhidraLauncher.tsindex ee7929d08..18e5c86e3 100644--- a/src/ghidra/GhidraLauncher.ts+++ b/src/ghidra/GhidraLauncher.ts@@ -1,11 +1,15 @@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, type Result } from "../domain/result.js";-import { cleanupOwnedProcessGroup } from "../process/ProcessOwnership.js";+import {+ cleanupOwnedProcessGroup,+ cleanupWindowsProcessTree,+ type ProcessCleanupResult,+} from "../process/ProcessOwnership.js";import {type ProviderProcessLaunch,type SpawnedOwnedProviderProcess,@@ -60,6 +64,8 @@ export interface GhidraHeadlessLauncherOptions {readonly analyzeHeadlessPath: string;readonly javaHome?: string;readonly bridgeScriptPath: string;+ readonly platform?: NodeJS.Platform;+ readonly comSpec?: string;}/** Launch Ghidra without copying scripts into or modifying its installation. */@@ -73,6 +79,7 @@ export class GhidraHeadlessLauncher implements GhidraLauncher {if (isAborted(options.signal))return err(new AnalysisCancelledError("open_binary"));const paths = ghidraRuntimePaths(session.runtimeRoot);+ const platform = this.options.platform ?? process.platform;let started: SpawnedOwnedProviderProcess | undefined;try {await Promise.all(@@ -101,21 +108,30 @@ export class GhidraHeadlessLauncher implements GhidraLauncher {);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),+ env: ghidraLaunchEnvironment(paths, this.options.javaHome, platform),});await writeFileAtomic(paths.ownershipPath,@@ -125,29 +141,31 @@ export class GhidraHeadlessLauncher implements GhidraLauncher {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,});} catch (cause: unknown) {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(@@ -157,6 +175,67 @@ export class GhidraHeadlessLauncher implements GhidraLauncher {}}+/** Exact executable and argv passed to shell-free process creation. */+export interface GhidraHeadlessCommand {+ readonly command: string;+ readonly arguments: readonly string[];+}++/** Build a direct POSIX launch or a conservatively quoted Windows batch call. */+export const ghidraHeadlessCommand = (options: {+ readonly platform: NodeJS.Platform;+ readonly analyzeHeadlessPath: string;+ readonly arguments: readonly string[];+ readonly comSpec?: string;+}): GhidraHeadlessCommand => {+ 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: string): string => {+ if (value.length === 0 || /[\u0000\r\n"%^!&|<>]/u.test(value))+ throw new GhidraLaunchError(+ "Windows Ghidra P0 paths cannot contain command-interpreter metacharacters",+ );+ return `"${value}"`;+};++const cleanupStartedProcess = (+ started: SpawnedOwnedProviderProcess,+ platform: NodeJS.Platform,+): Promise<ProcessCleanupResult> =>+ platform === "win32"+ ? cleanupWindowsProcessTree(started.ownership.leaderPid)+ : cleanupOwnedProcessGroup(started.ownership);+/** Paths encoded into one bounded analyzeHeadless invocation. */export interface GhidraHeadlessArgumentOptions {readonly projectRoot: string;@@ -208,15 +287,29 @@ const ghidraRuntimePaths = (runtimeRoot: string) => ({const ghidraLaunchEnvironment = (paths: ReturnType<typeof ghidraRuntimePaths>,javaHome: string | undefined,-): NodeJS.ProcessEnv => ({- ...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}`,-});+ platform: NodeJS.Platform,+): NodeJS.ProcessEnv => {+ 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?: AbortSignal): boolean => signal?.aborted === true;diff --git a/src/ghidra/GhidraProvider.ts b/src/ghidra/GhidraProvider.tsindex 527f633aa..6cce99a1f 100644--- a/src/ghidra/GhidraProvider.ts+++ b/src/ghidra/GhidraProvider.ts@@ -109,6 +109,11 @@ 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 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.",+]);const limitationsFor = (operation: string): readonly string[] => {const common = [@@ -228,6 +233,17 @@ const CAPABILITIES: readonly CapabilityDescriptor[] = Object.freeze(}),),);+const WINDOWS_P0_CAPABILITIES: readonly CapabilityDescriptor[] = Object.freeze(+ CAPABILITIES.map((capability) =>+ Object.freeze({+ ...capability,+ limitations: Object.freeze([+ ...capability.limitations,+ ...windowsP0Limitations,+ ]),+ }),+ ),+);const SUPPORTED_ARCHITECTURES = new Set(["x86", "x86_64", "arm", "arm64"]);const SUPPORTED_FORMATS = new Set(["elf", "pe", "mach-o"]);@@ -254,7 +270,9 @@ export class GhidraProvider implements AnalysisProviderCandidate {}capabilities(): readonly CapabilityDescriptor[] {- return CAPABILITIES;+ return (this.installationHost?.platform ?? process.platform) === "win32"+ ? WINDOWS_P0_CAPABILITIES+ : CAPABILITIES;}inspectAvailability(): ProviderAvailability {@@ -345,6 +363,8 @@ export class GhidraProvider implements AnalysisProviderCandidate {);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,@@ -354,6 +374,7 @@ export class GhidraProvider implements AnalysisProviderCandidate {bridgeScriptPath: fileURLToPath(new URL("../../bridge/ghidra/ReaGhidraBridge.java", import.meta.url),),+ platform: installation.platform,}),targetPath: target.path,targetSha256: target.sha256,@@ -386,7 +407,7 @@ export class GhidraProvider implements AnalysisProviderCandidate {return ok(createAnalysisExecution(started.value, committedProfile.provider, {analysisProfile: committedProfile,- limitations: healthLimitations,+ limitations: [...healthLimitations, ...providerLimitations],}),);}@@ -410,7 +431,7 @@ export class GhidraProvider implements AnalysisProviderCandidate {createAnalysisExecution(result.value, committedProfile.provider, {rawResult: called.value,analysisProfile: committedProfile,- limitations: limitationsFor(operation),+ limitations: [...limitationsFor(operation), ...providerLimitations],}),);},diff --git a/src/process/ProcessOwnership.ts b/src/process/ProcessOwnership.tsindex 490b3e337..0852aa9f0 100644--- a/src/process/ProcessOwnership.ts+++ b/src/process/ProcessOwnership.ts@@ -39,6 +39,11 @@ export interface ProcessOwnershipHost {signalGroup(processGroupId: number, signal: NodeJS.Signals): void;}+/** Narrow Windows P0 seam for bounded process-tree termination. */+export interface WindowsProcessTreeHost {+ terminateTree(rootPid: number): Promise<"terminated" | "missing">;+}+/** Per-member reason that token-verified cleanup failed closed. */interface ProcessOwnershipValidationFailure {readonly pid: number;@@ -63,6 +68,30 @@ export type ProcessGroupObservation =| { readonly state: "alive" }| { readonly state: "unverifiable"; readonly reason: string };+/**+ * Terminate one Windows process tree through the platform utility.+ *+ * This is a bounded P0 cleanup mechanism, not Job Object ownership proof. The+ * caller-visible Windows limitations must preserve that distinction.+ */+export const cleanupWindowsProcessTree = async (+ rootPid: number,+ host: WindowsProcessTreeHost = systemWindowsProcessTreeHost,+): Promise<ProcessCleanupResult> => {+ if (!Number.isSafeInteger(rootPid) || rootPid <= 0)+ return { cleaned: false, reason: "Windows process-tree PID is invalid" };+ try {+ const result = await host.terminateTree(rootPid);+ return { cleaned: true, signaled: result === "terminated" };+ } catch {+ return {+ cleaned: false,+ reason:+ "Windows P0 process-tree termination failed; Job Object ownership is unavailable",+ };+ }+};+/** Select the PTY root group and groups led by an observed captured process. */export const selectCapturedProcessGroupIds = (rootPid: number,@@ -135,6 +164,27 @@ const systemHost: ProcessOwnershipHost = {},};+const systemWindowsProcessTreeHost: WindowsProcessTreeHost = {+ async terminateTree(rootPid) {+ try {+ await execFileAsync(+ "taskkill.exe",+ ["/pid", String(rootPid), "/t", "/f"],+ { windowsHide: true, timeout: 5_000 },+ );+ return "terminated";+ } catch (cause: unknown) {+ if (+ cause instanceof Error &&+ "code" in cause &&+ (cause.code === 128 || cause.code === "ESRCH")+ )+ return "missing";+ throw cause;+ }+ },+};+/** Read the capture run token currently exposed by one live process. */export const readProcessRunId = async (pid: number,diff --git a/src/process/ProviderProcess.ts b/src/process/ProviderProcess.tsindex be3b4d01f..6891efff0 100644--- a/src/process/ProviderProcess.ts+++ b/src/process/ProviderProcess.ts@@ -105,6 +105,7 @@ export const spawnOwnedProviderProcess = async (): Promise<SpawnedOwnedProviderProcess> => {const child = spawn(options.command, [...options.arguments], {shell: false,+ windowsHide: true,stdio: ["ignore", "pipe", "pipe"],detached: process.platform !== "win32",env: {diff --git a/tests/fixtures/captureGhidraLaunch.cmd b/tests/fixtures/captureGhidraLaunch.cmdnew file mode 100644index 000000000..e73e9b9f0--- /dev/null+++ b/tests/fixtures/captureGhidraLaunch.cmd@@ -0,0 +1,2 @@+@echo off+node "%~dp0captureGhidraLaunch.mjs" %*diff --git a/tests/fixtures/captureGhidraLaunch.mjs b/tests/fixtures/captureGhidraLaunch.mjsindex 0a5d88598..556c47316 100755--- a/tests/fixtures/captureGhidraLaunch.mjs+++ b/tests/fixtures/captureGhidraLaunch.mjs@@ -14,7 +14,10 @@ await writeFile(arguments: arguments_,environment: {HOME: process.env.HOME,+ USERPROFILE: process.env.USERPROFILE,TMPDIR: process.env.TMPDIR,+ TEMP: process.env.TEMP,+ TMP: process.env.TMP,XDG_CACHE_HOME: process.env.XDG_CACHE_HOME,XDG_CONFIG_HOME: process.env.XDG_CONFIG_HOME,XDG_DATA_HOME: process.env.XDG_DATA_HOME,diff --git a/tests/ghidraLauncher.test.ts b/tests/ghidraLauncher.test.tsindex 18285fb73..8e30f461c 100644--- a/tests/ghidraLauncher.test.ts+++ b/tests/ghidraLauncher.test.ts@@ -7,15 +7,23 @@ import { afterEach, beforeAll, describe, expect, it, vi } from "vitest";import {ghidraHeadlessArguments,+ ghidraHeadlessCommand,GhidraHeadlessLauncher,} from "../src/ghidra/GhidraLauncher.js";const fixturePath = fileURLToPath(- new URL("./fixtures/captureGhidraLaunch.mjs", import.meta.url),+ new URL(+ process.platform === "win32"+ ? "./fixtures/captureGhidraLaunch.cmd"+ : "./fixtures/captureGhidraLaunch.mjs",+ import.meta.url,+ ),);const roots: string[] = [];-beforeAll(() => chmod(fixturePath, 0o755));+beforeAll(async () => {+ if (process.platform !== "win32") await chmod(fixturePath, 0o755);+});afterEach(async () => {vi.unstubAllEnvs();await Promise.all(@@ -57,6 +65,48 @@ describe("Ghidra headless launcher", () => {]);});+ it("wraps the Windows batch launcher without enabling a Node shell", () => {+ const command = ghidraHeadlessCommand({+ platform: "win32",+ analyzeHeadlessPath:+ "C:\\Program Files\\Ghidra 12.1.2\\support\\analyzeHeadless.bat",+ arguments: [+ "C:\\REA Runtime\\project",+ "rea-project",+ "-import",+ "C:\\REA Runtime\\target.exe",+ ],+ comSpec: "C:\\Windows\\System32\\cmd.exe",+ });++ expect(command).toEqual({+ command: "C:\\Windows\\System32\\cmd.exe",+ arguments: [+ "/d",+ "/e:on",+ "/v:off",+ "/s",+ "/c",+ '""C:\\Program Files\\Ghidra 12.1.2\\support\\analyzeHeadless.bat" "C:\\REA Runtime\\project" "rea-project" "-import" "C:\\REA Runtime\\target.exe""',+ ],+ });+ });++ it.each([+ "C:\\targets\\%TEMP%\\fixture.exe",+ "C:\\targets\\fixture & calc.exe",+ 'C:\\targets\\fixture".exe',+ ])("rejects a Windows command-interpreter path: %s", (targetPath) => {+ expect(() =>+ ghidraHeadlessCommand({+ platform: "win32",+ analyzeHeadlessPath: "C:\\Ghidra\\support\\analyzeHeadless.bat",+ arguments: ["-import", targetPath],+ comSpec: "C:\\Windows\\System32\\cmd.exe",+ }),+ ).toThrow(/metacharacters/u);+ });+it("keeps authority in a private descriptor and isolates Ghidra state", async () => {vi.stubEnv("GHIDRA_JAVA_OPTIONS", "-javaagent:/unapproved/agent.jar");vi.stubEnv("JAVA_TOOL_OPTIONS", "-Duser.home=/unapproved/home");@@ -65,9 +115,11 @@ describe("Ghidra headless launcher", () => {const runtimeRoot = await mkdtemp(join(tmpdir(), "rea-launcher-test-"));roots.push(runtimeRoot);const token = "secret-token-that-must-not-leak";+ const javaHome =+ process.platform === "win32" ? "C:\\Java\\jdk-21" : "/opt/jdk-21";const launcher = new GhidraHeadlessLauncher({analyzeHeadlessPath: fixturePath,- javaHome: "/opt/jdk-21",+ javaHome,bridgeScriptPath: "/package/bridge/ReaGhidraBridge.java",});const launched = await launcher.launch({@@ -91,10 +143,17 @@ describe("Ghidra headless launcher", () => {expect(encodedArguments).not.toContain(token);expect(encodedEnvironment).not.toContain(token);expect(capture).toMatchObject({- descriptor_mode: 0o600,+ ...(process.platform === "win32" ? {} : { descriptor_mode: 0o600 }),descriptor_has_token: true,environment: {HOME: join(runtimeRoot, "home"),+ ...(process.platform === "win32"+ ? {+ USERPROFILE: join(runtimeRoot, "home"),+ TEMP: join(runtimeRoot, "tmp"),+ TMP: join(runtimeRoot, "tmp"),+ }+ : {}),TMPDIR: join(runtimeRoot, "tmp"),XDG_CACHE_HOME: join(runtimeRoot, "cache"),XDG_CONFIG_HOME: join(runtimeRoot, "config"),@@ -104,17 +163,22 @@ describe("Ghidra headless launcher", () => {JAVA_TOOL_OPTIONS: "",JDK_JAVA_OPTIONS: "",_JAVA_OPTIONS: "",- JAVA_HOME: "/opt/jdk-21",+ JAVA_HOME: javaHome,REA_PROCESS_RUN_ID: "d6fcbb66-e829-4ff6-a535-0035aec63139",},});- expect(capture.environment.PATH).toMatch(/^\/opt\/jdk-21\/bin:/u);+ expect(capture.environment.PATH).toMatch(+ process.platform === "win32"+ ? /^C:\\Java\\jdk-21\\bin;/u+ : /^\/opt\/jdk-21\/bin:/u,+ );expect(capture.environment.GHIDRA_HEADLESS_JAVA_OPTIONS).toContain(`-Duser.home=${join(runtimeRoot, "home")}`,);- expect((await stat(join(runtimeRoot, "ownership.json"))).mode & 0o777).toBe(- 0o600,- );+ if (process.platform !== "win32")+ expect(+ (await stat(join(runtimeRoot, "ownership.json"))).mode & 0o777,+ ).toBe(0o600);const cleaned = await launched.value.cleanup?.();expect(cleaned).toMatchObject({ cleaned: true });diff --git a/tests/ghidraProvider.test.ts b/tests/ghidraProvider.test.tsindex 41a68999f..414b8747b 100644--- a/tests/ghidraProvider.test.ts+++ b/tests/ghidraProvider.test.ts@@ -144,6 +144,17 @@ describe("Ghidra provider", () => {managed: false,},});+ expect(ghidra.capabilities()).toEqual(+ expect.arrayContaining([+ expect.objectContaining({+ operation: "list_procedures",+ limitations: expect.arrayContaining([+ expect.stringContaining("bounded taskkill termination"),+ expect.stringContaining("private DACL enforcement"),+ ]),+ }),+ ]),+ );expect(ghidra.inspectTargetSupport({...nativeApplication,diff --git a/tests/processOwnership.test.ts b/tests/processOwnership.test.tsindex 1fec52758..19dbb8f0f 100644--- a/tests/processOwnership.test.ts+++ b/tests/processOwnership.test.ts@@ -1,10 +1,12 @@import { describe, expect, it, vi } from "vitest";import {cleanupOwnedProcessGroup,+ cleanupWindowsProcessTree,observeOwnedProcessGroup,parseProcessEnvironment,selectCapturedProcessGroupIds,type ProcessOwnershipHost,+ type WindowsProcessTreeHost,} from "../src/process/ProcessOwnership.js";const ownership = {@@ -224,3 +226,39 @@ describe("owned process-group cleanup", () => {expect(signalGroup).not.toHaveBeenCalled();});});++describe("Windows P0 process-tree cleanup", () => {+ it("reports whether taskkill signaled or found an exited tree", async () => {+ const terminated: WindowsProcessTreeHost = {+ terminateTree: () => Promise.resolve("terminated"),+ };+ const missing: WindowsProcessTreeHost = {+ terminateTree: () => Promise.resolve("missing"),+ };++ await expect(cleanupWindowsProcessTree(42, terminated)).resolves.toEqual({+ cleaned: true,+ signaled: true,+ });+ await expect(cleanupWindowsProcessTree(42, missing)).resolves.toEqual({+ cleaned: true,+ signaled: false,+ });+ });++ it("keeps invalid identity and termination failures explicit", async () => {+ const failing: WindowsProcessTreeHost = {+ terminateTree: () => Promise.reject(new Error("taskkill failed")),+ };++ await expect(cleanupWindowsProcessTree(0, failing)).resolves.toEqual({+ cleaned: false,+ reason: "Windows process-tree PID is invalid",+ });+ await expect(cleanupWindowsProcessTree(42, failing)).resolves.toEqual({+ cleaned: false,+ reason:+ "Windows P0 process-tree termination failed; Job Object ownership is unavailable",+ });+ });+});