@agent-teams/engineering-foundation 0.20.0 → 1.0.0

package/dist/process-execution/windows-managed-process.js

@@ -1,390 +1,359 @@
 import { spawn } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { performance } from "node:perf_hooks";
+import { join, win32 } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
 import { fileURLToPath } from "node:url";
+export { describeManagedProcessCleanupFailure, managedProcessCleanupFailure } from "./windows-managed-process-diagnostics.js";
+const WINDOWS_BOOTSTRAP_PATH = fileURLToPath(new URL("../../assets/windows-managed-process/bootstrap.ps1", import.meta.url));
 const PROCESS_HOST_PATH = fileURLToPath(new URL("./windows-process-host.js", import.meta.url));
-const MAX_ENCODED_REQUEST_CHARACTERS = 24_000;
-const WINDOWS_JOB_RUNNER = String.raw `
-$ErrorActionPreference = "Stop"
-$ProgressPreference = "SilentlyContinue"
-Add-Type -TypeDefinition @'
-using System;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Runtime.InteropServices;
-using System.Text;
-using System.Threading;
-
-public static class AgentTeamsFoundationJobRunner
-{
-    private const uint CREATE_SUSPENDED = 0x00000004;
-    private const uint STARTF_USESTDHANDLES = 0x00000100;
-    private const uint JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE = 0x00002000;
-    private const int JobObjectBasicAccountingInformation = 1;
-    private const int JobObjectExtendedLimitInformation = 9;
-    private const uint INFINITE = 0xffffffff;
-    private const int STD_INPUT_HANDLE = -10;
-    private const int STD_OUTPUT_HANDLE = -11;
-    private const int STD_ERROR_HANDLE = -12;
-
-    [StructLayout(LayoutKind.Sequential)]
-    private struct PROCESS_INFORMATION
-    {
-        public IntPtr hProcess;
-        public IntPtr hThread;
-        public uint dwProcessId;
-        public uint dwThreadId;
+const MAX_WINDOWS_COMMAND_LINE_CHARACTERS = 32_766;
+const CONTROL_CONFIRMATION_TIMEOUT_MS = 30_000;
+const WRAPPER_EXIT_TIMEOUT_MS = 5_000;
+const WRAPPER_EXIT_CONFIRMATION_GRACE_MS = 1_000;
+const CONTROL_POLL_INTERVAL_MS = 10;
+const windowsProcessControls = new WeakMap();
+function createControl() {
+    const root = mkdtempSync(join(tmpdir(), "agent-teams-foundation-process-"));
+    return {
+        cancellationPath: join(root, "cancel"),
+        confirmationPath: join(root, "contained"),
+        launchPath: join(root, "launched"),
+        requestPath: join(root, "request.json"),
+        root
+    };
+}
+function resolveWindowsPowerShellPath(environment) {
+    const systemRoot = Object.entries(environment ?? {}).find(([key]) => key.toLowerCase() === "systemroot")?.[1];
+    if (typeof systemRoot !== "string" ||
+        systemRoot.length === 0 ||
+        !win32.isAbsolute(systemRoot)) {
+        throw new Error("SystemRoot must be an absolute Windows path.");
     }
-
-    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
-    private struct STARTUPINFO
-    {
-        public uint cb;
-        public string lpReserved;
-        public string lpDesktop;
-        public string lpTitle;
-        public uint dwX;
-        public uint dwY;
-        public uint dwXSize;
-        public uint dwYSize;
-        public uint dwXCountChars;
-        public uint dwYCountChars;
-        public uint dwFillAttribute;
-        public uint dwFlags;
-        public ushort wShowWindow;
-        public ushort cbReserved2;
-        public IntPtr lpReserved2;
-        public IntPtr hStdInput;
-        public IntPtr hStdOutput;
-        public IntPtr hStdError;
+    return win32.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+}
+function commandEnvironmentWithSystemRoot(environment, launcherEnvironment) {
+    if (Object.keys(environment).some((key) => key.toLowerCase() === "systemroot")) {
+        return environment;
     }
-
-    [StructLayout(LayoutKind.Sequential)]
-    private struct JOBOBJECT_BASIC_LIMIT_INFORMATION
-    {
-        public long PerProcessUserTimeLimit;
-        public long PerJobUserTimeLimit;
-        public uint LimitFlags;
-        public UIntPtr MinimumWorkingSetSize;
-        public UIntPtr MaximumWorkingSetSize;
-        public uint ActiveProcessLimit;
-        public UIntPtr Affinity;
-        public uint PriorityClass;
-        public uint SchedulingClass;
+    const systemRoot = Object.entries(launcherEnvironment).find(([key]) => key.toLowerCase() === "systemroot")?.[1];
+    return { ...environment, SystemRoot: systemRoot };
+}
+function removeControlRootBestEffort(root) {
+    try {
+        rmSync(root, { force: true, recursive: true });
+        return true;
     }
-
-    [StructLayout(LayoutKind.Sequential)]
-    private struct JOBOBJECT_BASIC_ACCOUNTING_INFORMATION
-    {
-        public long TotalUserTime;
-        public long TotalKernelTime;
-        public long ThisPeriodTotalUserTime;
-        public long ThisPeriodTotalKernelTime;
-        public uint TotalPageFaultCount;
-        public uint TotalProcesses;
-        public uint ActiveProcesses;
-        public uint TotalTerminatedProcesses;
+    catch {
+        return false;
     }
-
-    [StructLayout(LayoutKind.Sequential)]
-    private struct IO_COUNTERS
-    {
-        public ulong ReadOperationCount;
-        public ulong WriteOperationCount;
-        public ulong OtherOperationCount;
-        public ulong ReadTransferCount;
-        public ulong WriteTransferCount;
-        public ulong OtherTransferCount;
+}
+function disposeControl(child, control) {
+    if (removeControlRootBestEffort(control.root)) {
+        windowsProcessControls.delete(child);
     }
-
-    [StructLayout(LayoutKind.Sequential)]
-    private struct JOBOBJECT_EXTENDED_LIMIT_INFORMATION
-    {
-        public JOBOBJECT_BASIC_LIMIT_INFORMATION BasicLimitInformation;
-        public IO_COUNTERS IoInfo;
-        public UIntPtr ProcessMemoryLimit;
-        public UIntPtr JobMemoryLimit;
-        public UIntPtr PeakProcessMemoryUsed;
-        public UIntPtr PeakJobMemoryUsed;
+}
+function disposeControlAfterWrapperExit(child, control) {
+    const disposeAfterExit = () => {
+        disposeControl(child, control);
+    };
+    child.once("exit", disposeAfterExit);
+    if (child.exitCode !== null || child.signalCode !== null) {
+        child.removeListener("exit", disposeAfterExit);
+        disposeAfterExit();
     }
-
-    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
-    private static extern IntPtr CreateJobObject(IntPtr attributes, string name);
-
-    [DllImport("kernel32.dll", SetLastError = true)]
-    private static extern bool SetInformationJobObject(
-        IntPtr job,
-        int informationClass,
-        IntPtr information,
-        uint informationLength);
-
-    [DllImport("kernel32.dll", SetLastError = true)]
-    private static extern bool QueryInformationJobObject(
-        IntPtr job,
-        int informationClass,
-        IntPtr information,
-        uint informationLength,
-        IntPtr returnLength);
-
-    [DllImport("kernel32.dll", SetLastError = true)]
-    private static extern bool TerminateJobObject(IntPtr job, uint exitCode);
-
-    [DllImport("kernel32.dll", SetLastError = true)]
-    private static extern bool AssignProcessToJobObject(IntPtr job, IntPtr process);
-
-    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
-    private static extern bool CreateProcess(
-        string applicationName,
-        StringBuilder commandLine,
-        IntPtr processAttributes,
-        IntPtr threadAttributes,
-        bool inheritHandles,
-        uint creationFlags,
-        IntPtr environment,
-        string currentDirectory,
-        ref STARTUPINFO startupInfo,
-        out PROCESS_INFORMATION processInformation);
-
-    [DllImport("kernel32.dll", SetLastError = true)]
-    private static extern uint ResumeThread(IntPtr thread);
-
-    [DllImport("kernel32.dll", SetLastError = true)]
-    private static extern uint WaitForSingleObject(IntPtr handle, uint milliseconds);
-
-    [DllImport("kernel32.dll", SetLastError = true)]
-    private static extern bool GetExitCodeProcess(IntPtr process, out uint exitCode);
-
-    [DllImport("kernel32.dll", SetLastError = true)]
-    private static extern bool TerminateProcess(IntPtr process, uint exitCode);
-
-    [DllImport("kernel32.dll")]
-    private static extern IntPtr GetStdHandle(int standardHandle);
-
-    [DllImport("kernel32.dll")]
-    private static extern bool CloseHandle(IntPtr handle);
-
-    private static string Quote(string value)
-    {
-        if (value.Length > 0 && value.IndexOfAny(new[] { ' ', '\t', '"' }) < 0)
-        {
-            return value;
+}
+function quoteWindowsArgument(value) {
+    if (value.length > 0 && !/[ \t"]/u.test(value)) {
+        return value;
+    }
+    let output = '"';
+    let slashes = 0;
+    for (const character of value) {
+        if (character === "\\") {
+            slashes += 1;
+            continue;
         }
-        var output = new StringBuilder("\"");
-        var slashes = 0;
-        foreach (var character in value)
-        {
-            if (character == '\\')
-            {
-                slashes += 1;
-                continue;
-            }
-            if (character == '"')
-            {
-                output.Append('\\', slashes * 2 + 1);
-                output.Append(character);
-                slashes = 0;
-                continue;
-            }
-            output.Append('\\', slashes);
+        if (character === '"') {
+            output += "\\".repeat(slashes * 2 + 1) + character;
             slashes = 0;
-            output.Append(character);
+            continue;
         }
-        output.Append('\\', slashes * 2);
-        output.Append('"');
-        return output.ToString();
+        output += "\\".repeat(slashes) + character;
+        slashes = 0;
     }
-
-    private static uint ActiveProcessCount(IntPtr job)
-    {
-        var accounting = new JOBOBJECT_BASIC_ACCOUNTING_INFORMATION();
-        var length = Marshal.SizeOf(accounting);
-        var pointer = Marshal.AllocHGlobal(length);
-        try
-        {
-            if (!QueryInformationJobObject(
-                job,
-                JobObjectBasicAccountingInformation,
-                pointer,
-                (uint)length,
-                IntPtr.Zero))
-            {
-                throw new Win32Exception(
-                    Marshal.GetLastWin32Error(),
-                    "QueryInformationJobObject failed");
-            }
-            accounting = (JOBOBJECT_BASIC_ACCOUNTING_INFORMATION)
-                Marshal.PtrToStructure(pointer, typeof(JOBOBJECT_BASIC_ACCOUNTING_INFORMATION));
-            return accounting.ActiveProcesses;
+    return output + "\\".repeat(slashes * 2) + '"';
+}
+function assertWindowsCommandLineFits(executable, args) {
+    const commandLine = [executable, ...args]
+        .map((argument) => quoteWindowsArgument(argument))
+        .join(" ");
+    if (commandLine.length > MAX_WINDOWS_COMMAND_LINE_CHARACTERS) {
+        throw new Error(`The managed Windows process bootstrap command line exceeds ${MAX_WINDOWS_COMMAND_LINE_CHARACTERS} characters.`);
+    }
+}
+/**
+ * Starts the packaged PowerShell bootstrap with a fixed, short command line.
+ * The request is stored in the private control root for the contained host to
+ * read; only fixed bootstrap metadata crosses PowerShell as JSON on stdin. The
+ * native helper atomically creates the Node process host in its Job Object, and
+ * only that contained host can launch the requested command.
+ */
+export function spawnWindowsManagedProcess(request) {
+    const control = createControl();
+    const launcherEnvironment = request.launcherEnvironment ?? process.env;
+    const commandEnvironment = commandEnvironmentWithSystemRoot(request.environment ?? launcherEnvironment, launcherEnvironment);
+    const serializedRequest = JSON.stringify({
+        schemaVersion: 1,
+        command: request.command,
+        args: [...request.args],
+        cwd: request.cwd,
+        launchPath: control.launchPath
+    });
+    try {
+        writeFileSync(control.requestPath, serializedRequest, {
+            encoding: "utf8",
+            flag: "wx",
+            mode: 0o600
+        });
+        assertWindowsCommandLineFits(process.execPath, [
+            PROCESS_HOST_PATH,
+            control.requestPath
+        ]);
+    }
+    catch (error) {
+        removeControlRootBestEffort(control.root);
+        throw error;
+    }
+    let child;
+    try {
+        child = spawn(resolveWindowsPowerShellPath(launcherEnvironment), [
+            "-NoLogo",
+            "-NoProfile",
+            "-NonInteractive",
+            "-ExecutionPolicy",
+            "Bypass",
+            "-File",
+            WINDOWS_BOOTSTRAP_PATH
+        ], {
+            cwd: win32.dirname(WINDOWS_BOOTSTRAP_PATH),
+            env: launcherEnvironment,
+            stdio: ["pipe", "pipe", "pipe"],
+            windowsHide: true
+        });
+    }
+    catch (error) {
+        removeControlRootBestEffort(control.root);
+        throw error;
+    }
+    windowsProcessControls.set(child, control);
+    child.once("error", () => {
+        cleanUpWindowsManagedProcessLaunchFailure(child);
+    });
+    const bootstrapInput = child.stdin;
+    if (bootstrapInput === null) {
+        try {
+            child.kill("SIGKILL");
         }
-        finally
-        {
-            Marshal.FreeHGlobal(pointer);
+        finally {
+            disposeControlAfterWrapperExit(child, control);
         }
+        throw new Error("Windows Job Object wrapper did not expose its bootstrap input.");
     }
-
-    private static void TerminateRemainingProcessesAndWait(IntPtr job)
-    {
-        if (ActiveProcessCount(job) > 0 && !TerminateJobObject(job, 1))
-        {
-            throw new Win32Exception(Marshal.GetLastWin32Error(), "TerminateJobObject failed");
+    bootstrapInput.once("error", () => {
+        // The wrapper's process error is reported through its own error event.
+    });
+    bootstrapInput.end(JSON.stringify({
+        schemaVersion: 1,
+        nodeExecutable: process.execPath,
+        processHostPath: PROCESS_HOST_PATH,
+        requestPath: control.requestPath,
+        hostWorkingDirectory: win32.dirname(PROCESS_HOST_PATH),
+        environmentEntries: Object.entries(commandEnvironment)
+            .filter((entry) => entry[1] !== undefined)
+            .map(([key, value]) => `${key}=${value}`),
+        cancellationPath: control.cancellationPath,
+        confirmationPath: control.confirmationPath,
+        launchPath: control.launchPath
+    }));
+    return child;
+}
+/** Releases control artifacts when PowerShell was never launched. */
+export function cleanUpWindowsManagedProcessLaunchFailure(child) {
+    const control = windowsProcessControls.get(child);
+    if (child.pid === undefined && control !== undefined) {
+        disposeControl(child, control);
+    }
+}
+async function readContainmentConfirmation(control) {
+    try {
+        return await readFile(control.confirmationPath, "utf8");
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return undefined;
         }
-        var stopwatch = Stopwatch.StartNew();
-        while (ActiveProcessCount(job) > 0)
-        {
-            if (stopwatch.ElapsedMilliseconds >= 5000)
-            {
-                throw new TimeoutException(
-                    "Windows Job Object descendants did not terminate within 5000 ms");
-            }
-            Thread.Sleep(10);
+        throw error;
+    }
+}
+async function readContainmentConfirmationAfterWrapperExit(control, confirmationDeadline) {
+    const deadline = Math.min(confirmationDeadline, performance.now() + WRAPPER_EXIT_CONFIRMATION_GRACE_MS);
+    for (;;) {
+        const confirmation = await readContainmentConfirmation(control);
+        if (confirmation !== undefined) {
+            return confirmation;
+        }
+        const remainingMs = deadline - performance.now();
+        if (remainingMs <= 0) {
+            return undefined;
+        }
+        await delay(Math.min(CONTROL_POLL_INTERVAL_MS, remainingMs));
+    }
+}
+function controlFor(child) {
+    const control = windowsProcessControls.get(child);
+    if (control === undefined) {
+        throw new Error("The Windows process is not owned by the managed-process adapter.");
+    }
+    return control;
+}
+async function wrapperExitedWithin(child, timeoutMs) {
+    const exitDeadline = performance.now() + timeoutMs;
+    while (child.exitCode === null && child.signalCode === null) {
+        const remainingMs = exitDeadline - performance.now();
+        if (remainingMs <= 0) {
+            return false;
         }
+        await delay(Math.min(CONTROL_POLL_INTERVAL_MS, remainingMs));
     }
-
-    public static int Run(
-        string executable,
-        string hostPath,
-        string currentDirectory,
-        string encodedRequest)
-    {
-        var job = CreateJobObject(IntPtr.Zero, null);
-        if (job == IntPtr.Zero)
-        {
-            throw new Win32Exception(Marshal.GetLastWin32Error(), "CreateJobObject failed");
+    return true;
+}
+async function forceAndWaitForWrapperExit(child, control) {
+    const cleanupErrors = [];
+    if (child.exitCode === null && child.signalCode === null) {
+        let terminationRequested = false;
+        try {
+            terminationRequested = child.kill("SIGKILL");
         }
-        PROCESS_INFORMATION process = new PROCESS_INFORMATION();
-        try
-        {
-            var limits = new JOBOBJECT_EXTENDED_LIMIT_INFORMATION();
-            limits.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
-            var length = Marshal.SizeOf(limits);
-            var limitsPointer = Marshal.AllocHGlobal(length);
-            try
-            {
-                Marshal.StructureToPtr(limits, limitsPointer, false);
-                if (!SetInformationJobObject(
-                    job,
-                    JobObjectExtendedLimitInformation,
-                    limitsPointer,
-                    (uint)length))
-                {
-                    throw new Win32Exception(
-                        Marshal.GetLastWin32Error(),
-                        "SetInformationJobObject failed");
-                }
-            }
-            finally
-            {
-                Marshal.FreeHGlobal(limitsPointer);
-            }
-
-            var startup = new STARTUPINFO();
-            startup.cb = (uint)Marshal.SizeOf(startup);
-            startup.dwFlags = STARTF_USESTDHANDLES;
-            startup.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
-            startup.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
-            startup.hStdError = GetStdHandle(STD_ERROR_HANDLE);
-            var commandLine = new StringBuilder(
-                Quote(executable) + " " + Quote(hostPath) + " " + Quote(encodedRequest));
-            if (!CreateProcess(
-                executable,
-                commandLine,
-                IntPtr.Zero,
-                IntPtr.Zero,
-                true,
-                CREATE_SUSPENDED,
-                IntPtr.Zero,
-                currentDirectory,
-                ref startup,
-                out process))
-            {
-                throw new Win32Exception(Marshal.GetLastWin32Error(), "CreateProcess failed");
+        catch (error) {
+            cleanupErrors.push(error);
+        }
+        if (!await wrapperExitedWithin(child, WRAPPER_EXIT_TIMEOUT_MS)) {
+            if (!terminationRequested && cleanupErrors.length === 0) {
+                cleanupErrors.push(new Error("Windows Job Object wrapper could not be terminated."));
             }
-            if (!AssignProcessToJobObject(job, process.hProcess))
-            {
-                var errorCode = Marshal.GetLastWin32Error();
-                TerminateProcess(process.hProcess, 1);
-                throw new Win32Exception(
-                    errorCode,
-                    "AssignProcessToJobObject failed");
+            cleanupErrors.push(new Error(`Windows Job Object wrapper did not exit within ${String(WRAPPER_EXIT_TIMEOUT_MS)} ms after forced termination.`));
+            try {
+                disposeControlAfterWrapperExit(child, control);
             }
-            if (ResumeThread(process.hThread) == 0xffffffff)
-            {
-                var errorCode = Marshal.GetLastWin32Error();
-                TerminateProcess(process.hProcess, 1);
-                throw new Win32Exception(errorCode, "ResumeThread failed");
+            catch (error) {
+                cleanupErrors.push(error);
             }
-            if (WaitForSingleObject(process.hProcess, INFINITE) == 0xffffffff)
-            {
-                var errorCode = Marshal.GetLastWin32Error();
-                TerminateProcess(process.hProcess, 1);
-                throw new Win32Exception(errorCode, "WaitForSingleObject failed");
+        }
+        else {
+            try {
+                disposeControl(child, control);
             }
-            uint exitCode;
-            if (!GetExitCodeProcess(process.hProcess, out exitCode))
-            {
-                throw new Win32Exception(Marshal.GetLastWin32Error(), "GetExitCodeProcess failed");
+            catch (error) {
+                cleanupErrors.push(error);
             }
-            TerminateRemainingProcessesAndWait(job);
-            return unchecked((int)exitCode);
         }
-        finally
-        {
-            if (process.hThread != IntPtr.Zero) CloseHandle(process.hThread);
-            if (process.hProcess != IntPtr.Zero) CloseHandle(process.hProcess);
-            CloseHandle(job);
+    }
+    else {
+        try {
+            disposeControl(child, control);
         }
+        catch (error) {
+            cleanupErrors.push(error);
+        }
+    }
+    if (cleanupErrors.length === 1) {
+        throw cleanupErrors[0];
+    }
+    if (cleanupErrors.length > 1) {
+        const aggregateError = new AggregateError(cleanupErrors, "Windows Job Object wrapper termination produced multiple cleanup errors.");
+        aggregateError.cause = cleanupErrors.at(-1);
+        throw aggregateError;
     }
 }
-'@
-
-try {
-  $bootstrapRequest = [Console]::In.ReadToEnd() | ConvertFrom-Json
-  $exitCode = [AgentTeamsFoundationJobRunner]::Run(
-    [string]$bootstrapRequest.nodeExecutable,
-    [string]$bootstrapRequest.processHostPath,
-    (Get-Location).Path,
-    [string]$bootstrapRequest.encodedRequest)
-  exit $exitCode
-} catch {
-  [Console]::Error.WriteLine("Windows Job Object runner failed: " + $_.Exception.Message)
-  exit 1
+async function failAfterForcingWrapperExit(child, control, originalError, aggregateMessage) {
+    try {
+        await forceAndWaitForWrapperExit(child, control);
+    }
+    catch (cleanupError) {
+        const cleanupErrors = cleanupError instanceof AggregateError ?
+            cleanupError.errors :
+            [cleanupError];
+        const aggregateError = new AggregateError([originalError, ...cleanupErrors], aggregateMessage);
+        aggregateError.cause = cleanupErrors.at(-1);
+        throw aggregateError;
+    }
+    throw originalError;
 }
-`;
-const ENCODED_WINDOWS_JOB_RUNNER = Buffer.from(WINDOWS_JOB_RUNNER, "utf16le").toString("base64");
-/**
- * Starts a suspended Node host, assigns it to a kill-on-close Windows Job
- * Object, and only then allows it to launch the requested command. The Job
- * Object is the containment boundary for every descendant.
- */
-export function spawnWindowsManagedProcess(request) {
-    const encodedRequest = Buffer.from(JSON.stringify({
-        schemaVersion: 1,
-        command: request.command,
-        args: [...request.args],
-        cwd: request.cwd
-    })).toString("base64url");
-    if (encodedRequest.length > MAX_ENCODED_REQUEST_CHARACTERS) {
-        throw new Error(`The managed Windows process request exceeds ${MAX_ENCODED_REQUEST_CHARACTERS} encoded characters.`);
+export async function requestWindowsManagedProcessTermination(child) {
+    const control = controlFor(child);
+    try {
+        await writeFile(control.cancellationPath, "CANCEL", { encoding: "utf8" });
+    }
+    catch (error) {
+        await failAfterForcingWrapperExit(child, control, error, "Windows cancellation marker creation and wrapper cleanup both failed.");
+    }
+    await waitForWindowsManagedProcessContainment(child);
+}
+export async function waitForWindowsManagedProcessContainment(child, confirmationTimeoutMs = CONTROL_CONFIRMATION_TIMEOUT_MS) {
+    if (!Number.isSafeInteger(confirmationTimeoutMs) || confirmationTimeoutMs <= 0) {
+        throw new TypeError("The Windows containment timeout must be a positive safe integer.");
+    }
+    const control = controlFor(child);
+    const deadline = performance.now() + confirmationTimeoutMs;
+    for (;;) {
+        let confirmation;
+        try {
+            confirmation = await readContainmentConfirmation(control);
+        }
+        catch (error) {
+            await failAfterForcingWrapperExit(child, control, error, "Windows containment confirmation and wrapper cleanup both failed.");
+        }
+        if (confirmation !== undefined) {
+            if (confirmation !== "CONTAINED") {
+                await failAfterForcingWrapperExit(child, control, new Error("Windows Job Object wrapper sent an invalid containment confirmation."), "Windows containment confirmation and wrapper cleanup both failed.");
+            }
+            if (await wrapperExitedWithin(child, WRAPPER_EXIT_TIMEOUT_MS)) {
+                disposeControl(child, control);
+                return;
+            }
+            await forceAndWaitForWrapperExit(child, control);
+            return;
+        }
+        if (child.exitCode !== null || child.signalCode !== null) {
+            // The wrapper publishes the marker immediately before it exits. If exit
+            // wins the poll race, allow bounded filesystem visibility lag before
+            // retiring the control directory so a durable confirmation is not
+            // discarded unseen.
+            try {
+                confirmation = await readContainmentConfirmationAfterWrapperExit(control, deadline);
+            }
+            catch (error) {
+                await failAfterForcingWrapperExit(child, control, error, "Windows containment confirmation and wrapper cleanup both failed.");
+            }
+            if (confirmation === "CONTAINED") {
+                disposeControl(child, control);
+                return;
+            }
+            if (confirmation !== undefined) {
+                await failAfterForcingWrapperExit(child, control, new Error("Windows Job Object wrapper sent an invalid containment confirmation."), "Windows containment confirmation and wrapper cleanup both failed.");
+            }
+            disposeControl(child, control);
+            throw new Error("Windows Job Object wrapper exited before it confirmed process containment.");
+        }
+        const remainingMs = deadline - performance.now();
+        if (remainingMs <= 0) {
+            const timeoutError = new Error(`Windows Job Object wrapper did not confirm containment within ${String(confirmationTimeoutMs)} ms.`);
+            await failAfterForcingWrapperExit(child, control, timeoutError, "Windows Job Object wrapper timed out and could not be terminated.");
+        }
+        await delay(Math.min(CONTROL_POLL_INTERVAL_MS, remainingMs));
     }
-    const child = spawn("powershell.exe", [
-        "-NoLogo",
-        "-NoProfile",
-        "-NonInteractive",
-        "-ExecutionPolicy",
-        "Bypass",
-        "-EncodedCommand",
-        ENCODED_WINDOWS_JOB_RUNNER
-    ], {
-        cwd: request.cwd,
-        stdio: ["pipe", "pipe", "pipe"],
-        windowsHide: true
-    });
-    child.stdin.once("error", () => {
-        // The wrapper's process error is reported through its own error event.
-    });
-    child.stdin.end(JSON.stringify({
-        nodeExecutable: process.execPath,
-        processHostPath: PROCESS_HOST_PATH,
-        encodedRequest
-    }));
-    return child;
 }
 //# sourceMappingURL=windows-managed-process.js.map