@loucompanion/forge-bridge 0.1.3-dev.b3bce6ba65a6 → 0.1.3-dev.ba293ccf876b

package/dist/worktree/worktree.types.d.ts

@@ -1,4 +1,4 @@
-import type { DispatchQaReworkContext, DispatchRepo, DispatchWorkItem, DispatchResolvedArtifact } from "../session/session.types.js";
+import type { DispatchQaReworkContext, DispatchPriorPhaseArtifact, DispatchRepo, DispatchWorkItem, DispatchResolvedArtifact } from "../session/session.types.js";
 import type { WarmDependenciesResult } from "./dependency-warmer.js";
 export interface WorktreePrepareRequest {
     readonly repo: DispatchRepo;
@@ -12,8 +12,11 @@ export interface WorktreePrepareRequest {
     readonly allowedRepoRoot: string;
     readonly cleanupWorktrees: boolean;
     readonly artifacts: readonly DispatchResolvedArtifact[];
+    readonly priorPhaseArtifacts?: readonly DispatchPriorPhaseArtifact[];
     readonly qaRework?: DispatchQaReworkContext | null;
     readonly warmPathOverrides?: readonly string[];
+    readonly applicationRuntimeRequired?: boolean;
+    readonly preserveExistingState?: boolean;
 }
 export interface WorktreeHandle {
     readonly repoPath: string;
@@ -23,4 +26,5 @@ export interface WorktreeHandle {
     readonly cleanupWorktrees: boolean;
     readonly dependencyWarm?: WarmDependenciesResult;
     readonly qaReworkPacketPath?: string;
+    readonly hydratedPriorPhaseArtifactCount?: number;
 }

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@loucompanion/forge-bridge",
-  "version": "0.1.3-dev.b3bce6ba65a6",
+  "version": "0.1.3-dev.ba293ccf876b",
   "description": "Forge runner bridge CLI for connecting local developer machines to Forge dispatch.",
   "license": "UNLICENSED",
   "type": "module",
   "bin": {
+    "forge": "dist/cli/bin.js",
     "forge-bridge": "dist/cli/bin.js"
   },
   "main": "./dist/index.js",
@@ -18,6 +19,7 @@
   },
   "files": [
     "dist",
+    "runtime",
     "README.md"
   ],
   "repository": {
@@ -37,13 +39,15 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "test": "vitest run",
+    "test": "node scripts/run-owned-tests.mjs",
+    "test:residue": "node scripts/run-owned-residue-gate.mjs",
     "test:watch": "vitest",
     "smoke:package": "npm run build && node scripts/smoke-package.mjs",
-    "lint": "eslint \"src/**/*.ts\" \"scripts/**/*.mjs\" \"vitest.config.ts\""
+    "lint": "eslint \"src/**/*.ts\" \"scripts/**/*.mjs\" \"vitest.config.ts\" \"vitest.setup.ts\""
   },
   "dependencies": {
-    "@microsoft/signalr": "^8.0.17"
+    "@microsoft/signalr": "^8.0.17",
+    "yaml": "^2.9.0"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",

package/runtime/windows-job-supervisor.ps1

@@ -0,0 +1,444 @@
+param(
+  [Parameter(Mandatory = $true)]
+  [ValidateSet("Outer", "Inner")]
+  [string]$Mode,
+
+  [Parameter(Mandatory = $true)]
+  [string]$PayloadPath,
+
+  [Parameter(Mandatory = $true)]
+  [ValidatePattern("^[0-9a-f]{64}$")]
+  [string]$PayloadSha256,
+
+  [string]$GateName
+)
+
+$ErrorActionPreference = "Stop"
+
+Add-Type -TypeDefinition @"
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+
+public static class ForgeWindowsJob
+{
+    [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;
+    }
+
+    [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;
+    }
+
+    [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;
+    }
+
+    private const uint JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE = 0x00002000;
+    private const int JobObjectExtendedLimitInformation = 9;
+
+    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+    private static extern IntPtr CreateJobObject(IntPtr securityAttributes, 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)]
+    public static extern bool AssignProcessToJobObject(IntPtr job, IntPtr process);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    public static extern bool TerminateJobObject(IntPtr job, uint exitCode);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    private static extern bool QueryInformationJobObject(
+        IntPtr job,
+        int informationClass,
+        IntPtr information,
+        uint informationLength,
+        out uint returnLength);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    public static extern bool CloseHandle(IntPtr handle);
+
+    public static IntPtr CreateKillOnCloseJob(string name)
+    {
+        IntPtr job = CreateJobObject(IntPtr.Zero, name);
+        if (job == IntPtr.Zero)
+        {
+            throw new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error(), "CreateJobObject failed.");
+        }
+
+        var limits = new JOBOBJECT_EXTENDED_LIMIT_INFORMATION();
+        limits.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
+        int size = Marshal.SizeOf(typeof(JOBOBJECT_EXTENDED_LIMIT_INFORMATION));
+        IntPtr pointer = Marshal.AllocHGlobal(size);
+        try
+        {
+            Marshal.StructureToPtr(limits, pointer, false);
+            if (!SetInformationJobObject(job, JobObjectExtendedLimitInformation, pointer, (uint)size))
+            {
+                throw new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error(), "SetInformationJobObject failed.");
+            }
+        }
+        catch
+        {
+            CloseHandle(job);
+            throw;
+        }
+        finally
+        {
+            Marshal.FreeHGlobal(pointer);
+        }
+
+        return job;
+    }
+
+    public static ulong PeakJobMemoryUsed(IntPtr job)
+    {
+        int size = Marshal.SizeOf(typeof(JOBOBJECT_EXTENDED_LIMIT_INFORMATION));
+        IntPtr pointer = Marshal.AllocHGlobal(size);
+        try
+        {
+            uint returned;
+            if (!QueryInformationJobObject(job, JobObjectExtendedLimitInformation, pointer, (uint)size, out returned))
+            {
+                throw new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error(), "QueryInformationJobObject failed.");
+            }
+            var information = (JOBOBJECT_EXTENDED_LIMIT_INFORMATION)Marshal.PtrToStructure(
+                pointer,
+                typeof(JOBOBJECT_EXTENDED_LIMIT_INFORMATION));
+            return information.PeakJobMemoryUsed.ToUInt64();
+        }
+        finally
+        {
+            Marshal.FreeHGlobal(pointer);
+        }
+    }
+
+    public static string BuildArguments(object[] arguments)
+    {
+        var result = new StringBuilder();
+        for (int index = 0; index < arguments.Length; index++)
+        {
+            if (index > 0) result.Append(' ');
+            result.Append(QuoteArgument(Convert.ToString(arguments[index]) ?? String.Empty));
+        }
+        return result.ToString();
+    }
+
+    private static string QuoteArgument(string argument)
+    {
+        if (argument.Length > 0 && argument.IndexOfAny(new[] { ' ', '\t', '\n', '\v', '"' }) < 0)
+        {
+            return argument;
+        }
+
+        var result = new StringBuilder();
+        result.Append('"');
+        int backslashes = 0;
+        foreach (char character in argument)
+        {
+            if (character == '\\')
+            {
+                backslashes++;
+                continue;
+            }
+
+            if (character == '"')
+            {
+                result.Append('\\', backslashes * 2 + 1);
+                result.Append('"');
+                backslashes = 0;
+                continue;
+            }
+
+            result.Append('\\', backslashes);
+            backslashes = 0;
+            result.Append(character);
+        }
+
+        result.Append('\\', backslashes * 2);
+        result.Append('"');
+        return result.ToString();
+    }
+}
+"@
+
+function Read-ForgeSupervisorPayload {
+  if (-not [IO.Path]::IsPathRooted($PayloadPath)) {
+    throw "The supervisor payload path must be absolute."
+  }
+  $bytes = [IO.File]::ReadAllBytes($PayloadPath)
+  $hasher = [Security.Cryptography.SHA256]::Create()
+  try {
+    $actualSha256 = -join ($hasher.ComputeHash($bytes) | ForEach-Object { $_.ToString("x2") })
+  }
+  finally {
+    $hasher.Dispose()
+  }
+  if (-not [string]::Equals($actualSha256, $PayloadSha256, [StringComparison]::Ordinal)) {
+    throw "The supervisor payload does not match its expected SHA-256 identity."
+  }
+  $utf8 = New-Object Text.UTF8Encoding($false, $true)
+  $json = $utf8.GetString($bytes)
+  return $json | ConvertFrom-Json
+}
+
+function New-ForgeChildProcess(
+  [string]$command,
+  [object[]]$arguments,
+  [string]$workingDirectory,
+  [bool]$redirectStreams
+) {
+  $maximumAttempts = 3
+  for ($attempt = 1; $attempt -le $maximumAttempts; $attempt += 1) {
+    $startInfo = New-Object System.Diagnostics.ProcessStartInfo
+    $startInfo.FileName = $command
+    $startInfo.Arguments = [ForgeWindowsJob]::BuildArguments($arguments)
+    $startInfo.WorkingDirectory = $workingDirectory
+    $startInfo.UseShellExecute = $false
+    $startInfo.CreateNoWindow = $true
+    $startInfo.RedirectStandardInput = $redirectStreams
+    $startInfo.RedirectStandardOutput = $redirectStreams
+    $startInfo.RedirectStandardError = $redirectStreams
+
+    $child = New-Object System.Diagnostics.Process
+    $child.StartInfo = $startInfo
+    try {
+      if (-not $child.Start()) {
+        throw "Failed to start supervised process '$command'."
+      }
+      $child | Add-Member -NotePropertyName ForgeStartAttempt -NotePropertyValue $attempt
+      return $child
+    }
+    catch {
+      $nativeError = $_.Exception
+      while ($nativeError.InnerException) {
+        $nativeError = $nativeError.InnerException
+      }
+      $retryable = $nativeError -is [ComponentModel.Win32Exception] -and $nativeError.NativeErrorCode -in @(5, 32, 33)
+      $child.Dispose()
+      if (-not $retryable -or $attempt -eq $maximumAttempts) {
+        throw
+      }
+      Start-Sleep -Milliseconds (100 * $attempt)
+    }
+  }
+}
+
+function Write-ForgeProviderReady([object]$request, [Diagnostics.Process]$provider) {
+  $readyPath = [string]$request.readyPath
+  if ([string]::IsNullOrWhiteSpace($readyPath) -or -not [IO.Path]::IsPathRooted($readyPath)) {
+    throw "The provider-ready path must be absolute."
+  }
+  $payloadDirectory = [IO.Path]::GetDirectoryName([IO.Path]::GetFullPath($PayloadPath))
+  $readyDirectory = [IO.Path]::GetDirectoryName([IO.Path]::GetFullPath($readyPath))
+  if (-not [string]::Equals($payloadDirectory, $readyDirectory, [StringComparison]::OrdinalIgnoreCase)) {
+    throw "The provider-ready path must be beside the supervisor payload."
+  }
+
+  $ready = @{
+    schemaVersion = 1
+    supervisorId = [string]$request.supervisorId
+    rootPid = [int]$env:FORGE_SUPERVISOR_ROOT_PID
+    rootIdentity = [string]$env:FORGE_SUPERVISOR_ROOT_IDENTITY
+    providerPid = $provider.Id
+    providerCreatedAt = $provider.StartTime.ToUniversalTime().ToString("O")
+    providerIdentity = "win32:$($provider.StartTime.ToUniversalTime().Ticks)"
+    startAttempt = [int]$provider.ForgeStartAttempt
+  } | ConvertTo-Json -Compress
+  $temporaryPath = "$readyPath.$([Guid]::NewGuid().ToString('N')).tmp"
+  [IO.File]::WriteAllText($temporaryPath, "$ready`n", (New-Object Text.UTF8Encoding($false)))
+  [IO.File]::Move($temporaryPath, $readyPath)
+}
+
+function Wait-ForgeProviderStartGrant([object]$request) {
+  $grantPath = [string]$request.startGrantPath
+  if ([string]::IsNullOrWhiteSpace($grantPath) -or -not [IO.Path]::IsPathRooted($grantPath)) {
+    throw "The provider start-grant path must be absolute."
+  }
+  $payloadDirectory = [IO.Path]::GetDirectoryName([IO.Path]::GetFullPath($PayloadPath))
+  $grantDirectory = [IO.Path]::GetDirectoryName([IO.Path]::GetFullPath($grantPath))
+  if (-not [string]::Equals($payloadDirectory, $grantDirectory, [StringComparison]::OrdinalIgnoreCase)) {
+    throw "The provider start-grant path must be beside the supervisor payload."
+  }
+  for ($attempt = 0; $attempt -lt 1200; $attempt += 1) {
+    if ([IO.File]::Exists($grantPath)) {
+      return
+    }
+    Start-Sleep -Milliseconds 25
+  }
+  throw "Timed out waiting for the provider start grant."
+}
+
+function Start-ForgeOutputCopies([Diagnostics.Process]$child) {
+  return @(
+    $child.StandardOutput.BaseStream.CopyToAsync([Console]::OpenStandardOutput()),
+    $child.StandardError.BaseStream.CopyToAsync([Console]::OpenStandardError())
+  )
+}
+
+function Write-ForgeStandardInput([Diagnostics.Process]$child, [string]$inputText) {
+  if ($inputText.Length -gt 0) {
+    $child.StandardInput.Write($inputText)
+  }
+  $child.StandardInput.Close()
+}
+
+function Write-ForgeMemoryTelemetry([object]$request, [IntPtr]$job) {
+  $telemetryPath = [string]$request.memoryTelemetryPath
+  if ([string]::IsNullOrWhiteSpace($telemetryPath) -or -not [IO.Path]::IsPathRooted($telemetryPath)) {
+    throw "The memory telemetry path must be absolute."
+  }
+  $payloadDirectory = [IO.Path]::GetDirectoryName([IO.Path]::GetFullPath($PayloadPath))
+  $telemetryDirectory = [IO.Path]::GetDirectoryName([IO.Path]::GetFullPath($telemetryPath))
+  if (-not [string]::Equals($payloadDirectory, $telemetryDirectory, [StringComparison]::OrdinalIgnoreCase)) {
+    throw "The memory telemetry path must be beside the supervisor payload."
+  }
+  $telemetry = @{
+    schemaVersion = 1
+    peakMemoryBytes = [ForgeWindowsJob]::PeakJobMemoryUsed($job)
+    sampleCount = 1
+    source = "windows_job_object_peak_job_memory"
+    observedAt = [DateTimeOffset]::UtcNow.ToString("O")
+  } | ConvertTo-Json -Compress
+  $temporaryPath = "$telemetryPath.$([Guid]::NewGuid().ToString('N')).tmp"
+  try {
+    [IO.File]::WriteAllText($temporaryPath, "$telemetry`n", (New-Object Text.UTF8Encoding($false)))
+    [IO.File]::Move($temporaryPath, $telemetryPath)
+  }
+  finally {
+    if ([IO.File]::Exists($temporaryPath)) {
+      try { [IO.File]::Delete($temporaryPath) } catch { }
+    }
+  }
+}
+
+function Write-ForgeMemoryTelemetryBestEffort([object]$request, [IntPtr]$job) {
+  try {
+    Write-ForgeMemoryTelemetry $request $job
+  }
+  catch {
+    # Telemetry is optional. Provider output, descendant cleanup, and the real
+    # provider exit code remain authoritative if querying or persisting it fails.
+  }
+}
+
+if ($Mode -eq "Inner") {
+  if ([string]::IsNullOrWhiteSpace($GateName)) {
+    throw "The inner supervisor requires a gate name."
+  }
+
+  $inputText = [Console]::In.ReadToEnd()
+  $request = Read-ForgeSupervisorPayload
+  $gate = [Threading.EventWaitHandle]::OpenExisting($GateName)
+  try {
+    if (-not $gate.WaitOne(30000)) {
+      throw "Timed out waiting for Windows Job Object assignment."
+    }
+  }
+  finally {
+    $gate.Dispose()
+  }
+
+  $provider = New-ForgeChildProcess ([string]$request.command) @($request.args) ([string]$request.cwd) $true
+  Write-ForgeProviderReady $request $provider
+  $copies = Start-ForgeOutputCopies $provider
+  Wait-ForgeProviderStartGrant $request
+  Write-ForgeStandardInput $provider $inputText
+  $provider.WaitForExit()
+  if (-not [Threading.Tasks.Task]::WaitAll([Threading.Tasks.Task[]]$copies, 1000)) {
+    $provider.StandardOutput.Dispose()
+    $provider.StandardError.Dispose()
+  }
+  exit $provider.ExitCode
+}
+
+$inputText = [Console]::In.ReadToEnd()
+$request = Read-ForgeSupervisorPayload
+$env:FORGE_SUPERVISOR_ROOT_PID = [string]$PID
+$env:FORGE_SUPERVISOR_ROOT_IDENTITY = "win32:$([Diagnostics.Process]::GetCurrentProcess().StartTime.ToUniversalTime().Ticks)"
+$parent = [Diagnostics.Process]::GetProcessById([int]$request.parentPid)
+$jobName = "Local\Forge-$([string]$request.supervisorId)"
+$job = [ForgeWindowsJob]::CreateKillOnCloseJob($jobName)
+$gateNameValue = "Local\ForgeGate-$([Guid]::NewGuid().ToString('N'))"
+$createdNew = $false
+$gate = New-Object Threading.EventWaitHandle($false, [Threading.EventResetMode]::ManualReset, $gateNameValue, [ref]$createdNew)
+$inner = $null
+
+try {
+  $powerShell = Join-Path $PSHOME "powershell.exe"
+  $innerArguments = @(
+    "-NoLogo",
+    "-NoProfile",
+    "-NonInteractive",
+    "-ExecutionPolicy",
+    "Bypass",
+    "-File",
+    $PSCommandPath,
+    "-Mode",
+    "Inner",
+    "-PayloadPath",
+    $PayloadPath,
+    "-PayloadSha256",
+    $PayloadSha256,
+    "-GateName",
+    $gateNameValue
+  )
+  $inner = New-ForgeChildProcess $powerShell $innerArguments ([string]$request.cwd) $true
+  if (-not [ForgeWindowsJob]::AssignProcessToJobObject($job, $inner.Handle)) {
+    throw (New-Object System.ComponentModel.Win32Exception([Runtime.InteropServices.Marshal]::GetLastWin32Error(), "AssignProcessToJobObject failed."))
+  }
+
+  $copies = Start-ForgeOutputCopies $inner
+  $gate.Set() | Out-Null
+  Write-ForgeStandardInput $inner $inputText
+  while (-not $inner.WaitForExit(250)) {
+    $parent.Refresh()
+    if ($parent.HasExited) {
+      [ForgeWindowsJob]::TerminateJobObject($job, 125) | Out-Null
+      exit 125
+    }
+  }
+
+  $exitCode = $inner.ExitCode
+  Write-ForgeMemoryTelemetryBestEffort $request $job
+  [ForgeWindowsJob]::TerminateJobObject($job, 1) | Out-Null
+  [Threading.Tasks.Task]::WaitAll([Threading.Tasks.Task[]]$copies, 2000) | Out-Null
+  exit $exitCode
+}
+finally {
+  if ($inner -and -not $inner.HasExited) {
+    [ForgeWindowsJob]::TerminateJobObject($job, 1) | Out-Null
+  }
+  $gate.Dispose()
+  [ForgeWindowsJob]::CloseHandle($job) | Out-Null
+}

package/runtime/windows-listener-owner.ps1

@@ -0,0 +1,33 @@
+param(
+  [Parameter(Mandatory = $true)]
+  [int]$RootProcessId,
+  [Parameter(Mandatory = $true)]
+  [string]$ListenerProcessIds
+)
+
+$ErrorActionPreference = "Stop"
+$parents = @{}
+Get-CimInstance Win32_Process | ForEach-Object {
+  $parents[[int]$_.ProcessId] = [int]$_.ParentProcessId
+}
+
+$results = @()
+foreach ($listenerText in $ListenerProcessIds.Split(',')) {
+  $current = [int]$listenerText
+  $visited = @{}
+  $owned = $false
+  while ($current -gt 0 -and -not $visited.ContainsKey($current)) {
+    if ($current -eq $RootProcessId) {
+      $owned = $true
+      break
+    }
+    $visited[$current] = $true
+    if (-not $parents.ContainsKey($current)) {
+      break
+    }
+    $current = [int]$parents[$current]
+  }
+  $results += $owned
+}
+
+ConvertTo-Json -Compress -InputObject @($results)