@neuvybe/jarvis 0.71.0 → 0.73.0

package/dist/assets/command-holder.ps1

@@ -0,0 +1,339 @@
+# Per-command containment holder for the bash tool (packages/core/src/tools/contained-command.ts).
+# One command per process. The holder joins a fresh kill-on-close job with no breakaway BEFORE it
+# starts anything, then starts the Git launcher inside it, so everything the command starts is in
+# the job and ends when the holder's job handle closes: when the holder exits after the command,
+# when the core kills it, or when the core dies (its standard input, the lifeline, reaches end of
+# file). It reads one binary spec from standard input, writes a per-command nonce first on each
+# output stream (the ready markers), and after the command a nonce-delimited trailer with the count
+# of processes the command left (all of them ended). It writes nothing else. Fixed exit codes:
+# 0x6A560001 restricted language mode, 0x6A560002 the compile failed, 0x6A560003 the job could not
+# be set up, 0x6A560004 the spec was rejected, 0x6A560005 the launcher did not start (after the
+# markers), 0x6A560006 an internal failure, 0x6A560007 the launcher or the working directory does
+# not exist (after the markers); otherwise the launcher's own exit code, exactly.
+$ErrorActionPreference = 'Stop'
+$ProgressPreference = 'SilentlyContinue'
+$PSModuleAutoLoadingPreference = 'None'
+# Restricted language mode blocks the compile below, so it exits with no output at all.
+if ($ExecutionContext.SessionState.LanguageMode -ne 'FullLanguage') { exit 0x6A560001 }
+$code = @'
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+
+public static class JarvisHolder {
+  const uint Job = 0x6A560003;
+  const uint Spec = 0x6A560004;
+  const uint Launch = 0x6A560005;
+  const uint Internal = 0x6A560006;
+  const uint NotFound = 0x6A560007;
+  const int MaxSpec = 1024 * 1024;
+  const int NonceBytes = 16;
+
+  const uint KillOnJobClose = 0x2000;
+  const uint DieOnUnhandledException = 0x400;
+  const int ExtendedLimitInformation = 9;
+  const int BasicAccountingInformation = 1;
+  const uint ExtendedStartupInfoPresent = 0x00080000;
+  const uint UnicodeEnvironment = 0x00000400;
+  const int UseStdHandles = 0x100;
+  const int UseShowWindow = 0x1;
+  const uint HandleFlagInherit = 1;
+  static readonly IntPtr HandleListAttribute = (IntPtr)0x00020002;
+
+  [StructLayout(LayoutKind.Sequential)]
+  struct BasicLimit {
+    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)]
+  struct IoCounters {
+    public ulong ReadOperationCount, WriteOperationCount, OtherOperationCount;
+    public ulong ReadTransferCount, WriteTransferCount, OtherTransferCount;
+  }
+
+  [StructLayout(LayoutKind.Sequential)]
+  struct ExtendedLimit {
+    public BasicLimit Basic;
+    public IoCounters Io;
+    public UIntPtr ProcessMemoryLimit;
+    public UIntPtr JobMemoryLimit;
+    public UIntPtr PeakProcessMemoryUsed;
+    public UIntPtr PeakJobMemoryUsed;
+  }
+
+  [StructLayout(LayoutKind.Sequential)]
+  struct Accounting {
+    public long TotalUserTime, TotalKernelTime, ThisPeriodTotalUserTime, ThisPeriodTotalKernelTime;
+    public uint TotalPageFaultCount, TotalProcesses, ActiveProcesses, TotalTerminatedProcesses;
+  }
+
+  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+  struct StartupInfo {
+    public int cb;
+    public string lpReserved, lpDesktop, lpTitle;
+    public int dwX, dwY, dwXSize, dwYSize, dwXCountChars, dwYCountChars, dwFillAttribute, dwFlags;
+    public short wShowWindow, cbReserved2;
+    public IntPtr lpReserved2, hStdInput, hStdOutput, hStdError;
+  }
+
+  [StructLayout(LayoutKind.Sequential)]
+  struct StartupInfoEx {
+    public StartupInfo StartupInfo;
+    public IntPtr lpAttributeList;
+  }
+
+  [StructLayout(LayoutKind.Sequential)]
+  struct ProcessInformation {
+    public IntPtr hProcess, hThread;
+    public int dwProcessId, dwThreadId;
+  }
+
+  delegate bool ConsoleHandler(uint kind);
+
+  [DllImport("kernel32.dll", SetLastError = true)] static extern IntPtr CreateJobObjectW(IntPtr attributes, IntPtr name);
+  [DllImport("kernel32.dll", SetLastError = true)] static extern bool SetInformationJobObject(IntPtr job, int kind, ref ExtendedLimit info, int size);
+  [DllImport("kernel32.dll", SetLastError = true)] static extern bool QueryInformationJobObject(IntPtr job, int kind, out Accounting info, int size, IntPtr returned);
+  [DllImport("kernel32.dll", SetLastError = true)] static extern bool AssignProcessToJobObject(IntPtr job, IntPtr process);
+  [DllImport("kernel32.dll", SetLastError = true)] static extern bool TerminateJobObject(IntPtr job, uint code);
+  [DllImport("kernel32.dll")] static extern IntPtr GetCurrentProcess();
+  [DllImport("kernel32.dll", SetLastError = true)] static extern IntPtr GetStdHandle(int kind);
+  [DllImport("kernel32.dll", SetLastError = true)] static extern bool SetHandleInformation(IntPtr handle, uint mask, uint flags);
+  [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)] static extern IntPtr CreateFileW(string name, uint access, uint share, IntPtr security, uint disposition, uint flags, IntPtr template);
+  [DllImport("kernel32.dll", SetLastError = true)] static extern bool WriteFile(IntPtr file, byte[] buffer, int count, out int written, IntPtr overlapped);
+  [DllImport("kernel32.dll", SetLastError = true)] static extern bool PeekNamedPipe(IntPtr pipe, IntPtr buffer, int size, IntPtr read, out int available, IntPtr left);
+  [DllImport("kernel32.dll", SetLastError = true)] static extern bool InitializeProcThreadAttributeList(IntPtr list, int count, int flags, ref IntPtr size);
+  [DllImport("kernel32.dll", SetLastError = true)] static extern bool UpdateProcThreadAttribute(IntPtr list, uint flags, IntPtr attribute, IntPtr value, IntPtr size, IntPtr previous, IntPtr returnSize);
+  [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)] static extern bool CreateProcessW(string application, StringBuilder commandLine, IntPtr processAttributes, IntPtr threadAttributes, bool inheritHandles, uint flags, IntPtr environment, string directory, ref StartupInfoEx startup, out ProcessInformation info);
+  [DllImport("kernel32.dll", SetLastError = true)] static extern uint WaitForSingleObject(IntPtr handle, uint milliseconds);
+  [DllImport("kernel32.dll", SetLastError = true)] static extern bool GetExitCodeProcess(IntPtr process, out uint code);
+  [DllImport("kernel32.dll", SetLastError = true)] static extern bool CloseHandle(IntPtr handle);
+  [DllImport("kernel32.dll")] static extern bool SetConsoleCtrlHandler(ConsoleHandler handler, bool add);
+  [DllImport("kernel32.dll")] static extern void ExitProcess(uint code);
+
+  static IntPtr job = IntPtr.Zero;
+  // Kept alive for the process's life: the console holds only a pointer to it.
+  static ConsoleHandler handler = Handled;
+
+  static bool Handled(uint kind) { return true; }
+
+  public static void Run() {
+    AppDomain.CurrentDomain.UnhandledException += (sender, e) => ExitProcess(Internal);
+    try {
+      ExitProcess(Hold());
+    } catch {
+      ExitProcess(Internal);
+    }
+  }
+
+  static uint Hold() {
+    // A terminal's Ctrl+C reaches the command as before; the core decides the rest. A handler,
+    // not the inherited ignore flag, so the command keeps its own default.
+    SetConsoleCtrlHandler(handler, true);
+    job = CreateJobObjectW(IntPtr.Zero, IntPtr.Zero);
+    if (job == IntPtr.Zero) return Job;
+    ExtendedLimit limit = new ExtendedLimit();
+    // Never a breakaway bit: MSYS asks to break away whenever the immediate job allows any.
+    limit.Basic.LimitFlags = KillOnJobClose | DieOnUnhandledException;
+    if (!SetInformationJobObject(job, ExtendedLimitInformation, ref limit, Marshal.SizeOf(typeof(ExtendedLimit)))) return Job;
+    // Joined before anything starts, so a kill during start misses nothing.
+    if (!AssignProcessToJobObject(job, GetCurrentProcess())) return Job;
+
+    Stream input = Console.OpenStandardInput();
+    byte[] spec = ReadSpec(input);
+    if (spec == null) return Spec;
+    int offset = 0;
+    byte[] nonce = new byte[NonceBytes];
+    Array.Copy(spec, offset, nonce, 0, NonceBytes);
+    offset += NonceBytes;
+    bool hide = spec[offset++] == 1;
+    string launcher = ReadField(spec, ref offset);
+    string commandLine = ReadField(spec, ref offset);
+    string directory = ReadField(spec, ref offset);
+    string environment = ReadField(spec, ref offset);
+    if (launcher == null || commandLine == null || directory == null || environment == null || offset != spec.Length) return Spec;
+    if (!IsDrivePath(launcher) || !launcher.EndsWith(".exe", StringComparison.OrdinalIgnoreCase)) return Spec;
+    // The working directory as Node's own spawn took it: a drive path, or a network share.
+    if (!IsDrivePath(directory) && !IsUncPath(directory)) return Spec;
+    foreach (char c in commandLine) if (c == '\0') return Spec;
+    IntPtr block = EnvironmentBlock(environment);
+    if (block == IntPtr.Zero) return Spec;
+
+    IntPtr stdout = GetStdHandle(-11);
+    IntPtr stderr = GetStdHandle(-12);
+    IntPtr nul = CreateFileW("NUL", 0x80000000, 3, IntPtr.Zero, 3, 0, IntPtr.Zero);
+    if (nul == (IntPtr)(-1)) return Internal;
+    foreach (IntPtr h in new IntPtr[] { nul, stdout, stderr }) SetHandleInformation(h, HandleFlagInherit, HandleFlagInherit);
+
+    // Exactly three handles reach the command: NUL as its input, and its two output pipes.
+    IntPtr size = IntPtr.Zero;
+    InitializeProcThreadAttributeList(IntPtr.Zero, 1, 0, ref size);
+    IntPtr list = Marshal.AllocHGlobal(size);
+    if (!InitializeProcThreadAttributeList(list, 1, 0, ref size)) return Internal;
+    IntPtr handles = Marshal.AllocHGlobal(IntPtr.Size * 3);
+    Marshal.WriteIntPtr(handles, 0, nul);
+    Marshal.WriteIntPtr(handles, IntPtr.Size, stdout);
+    Marshal.WriteIntPtr(handles, IntPtr.Size * 2, stderr);
+    if (!UpdateProcThreadAttribute(list, 0, HandleListAttribute, handles, (IntPtr)(IntPtr.Size * 3), IntPtr.Zero, IntPtr.Zero)) return Internal;
+
+    StartupInfoEx startup = new StartupInfoEx();
+    startup.StartupInfo.cb = Marshal.SizeOf(typeof(StartupInfoEx));
+    startup.StartupInfo.dwFlags = UseStdHandles | (hide ? UseShowWindow : 0);
+    startup.StartupInfo.wShowWindow = 0;
+    startup.StartupInfo.hStdInput = nul;
+    startup.StartupInfo.hStdOutput = stdout;
+    startup.StartupInfo.hStdError = stderr;
+    startup.lpAttributeList = list;
+
+    // The ready markers, stdout then stderr: the stderr marker is the last write before the
+    // launcher exists, so the core knows a command never ran when it never arrives.
+    if (!WriteAll(stdout, nonce) || !WriteAll(stderr, nonce)) return Internal;
+
+    // A cancel that landed while the holder was starting: the lifeline has already reached end of
+    // file, or carries a byte, so the command never starts (the lifeline thread ends any later one).
+    int waiting;
+    if (!PeekNamedPipe(GetStdHandle(-10), IntPtr.Zero, 0, IntPtr.Zero, out waiting, IntPtr.Zero) || waiting > 0) return Internal;
+
+    ProcessInformation info;
+    // No console flags: the launcher shares the holder's console, windowless when hidden, so no
+    // console host joins the job and a terminal's Ctrl+C still reaches the command.
+    if (!CreateProcessW(launcher, new StringBuilder(commandLine), IntPtr.Zero, IntPtr.Zero, true, ExtendedStartupInfoPresent | UnicodeEnvironment, block, directory, ref startup, out info)) {
+      // A launcher or working directory that does not exist reads as the shell's ENOENT, as
+      // Node's own spawn reported it; any other refusal as blocked.
+      int error = Marshal.GetLastWin32Error();
+      return error == 2 || error == 3 || error == 267 ? NotFound : Launch;
+    }
+    CloseHandle(info.hThread);
+
+    // The lifeline: any byte after the spec, or end of file, ends the job (the core wrote the
+    // spec and nothing else; it closes this pipe, or dies, to end the command).
+    Thread lifeline = new Thread(() => {
+      try {
+        byte[] one = new byte[1];
+        input.Read(one, 0, 1);
+      } catch {
+      }
+      // The holder is in the job too, so this ends it with H6 as well.
+      TerminateJobObject(job, Internal);
+      ExitProcess(Internal);
+    });
+    lifeline.IsBackground = true;
+    lifeline.Start();
+
+    WaitForSingleObject(info.hProcess, 0xFFFFFFFF);
+    uint code;
+    if (!GetExitCodeProcess(info.hProcess, out code)) return Internal;
+    // Closed before the count, so the launcher's place in the job never waits on this handle.
+    CloseHandle(info.hProcess);
+    Accounting accounting;
+    uint leftovers = 0;
+    if (QueryInformationJobObject(job, BasicAccountingInformation, out accounting, Marshal.SizeOf(typeof(Accounting)), IntPtr.Zero)) {
+      // The holder itself is in the job; everything else still in it, the command left.
+      leftovers = accounting.ActiveProcesses > 0 ? accounting.ActiveProcesses - 1 : 0;
+    }
+    byte[] trailer = new byte[NonceBytes * 2 + 8];
+    Array.Copy(nonce, 0, trailer, 0, NonceBytes);
+    Encoding.ASCII.GetBytes("END1").CopyTo(trailer, NonceBytes);
+    BitConverter.GetBytes(leftovers).CopyTo(trailer, NonceBytes + 4);
+    Array.Copy(nonce, 0, trailer, NonceBytes + 8, NonceBytes);
+    WriteAll(stdout, trailer);
+    // End the job outright rather than by its last handle closing, so a stray handle to it held
+    // elsewhere (a diagnostic tool, endpoint protection) cannot keep what the command left alive.
+    // The holder is in the job, so it ends here too, with the launcher's exact code.
+    TerminateJobObject(job, code);
+    return code;
+  }
+
+  static bool WriteAll(IntPtr handle, byte[] bytes) {
+    int written;
+    return WriteFile(handle, bytes, bytes.Length, out written, IntPtr.Zero) && written == bytes.Length;
+  }
+
+  // `JVH1`, the body's length, then the body; exactly that many bytes, so the rest of the input
+  // stays the lifeline.
+  static byte[] ReadSpec(Stream input) {
+    byte[] header = ReadExactly(input, 8);
+    if (header == null || header[0] != (byte)'J' || header[1] != (byte)'V' || header[2] != (byte)'H' || header[3] != (byte)'1') return null;
+    int length = BitConverter.ToInt32(header, 4);
+    if (length < NonceBytes + 1 || length > MaxSpec) return null;
+    return ReadExactly(input, length);
+  }
+
+  static byte[] ReadExactly(Stream input, int count) {
+    byte[] buffer = new byte[count];
+    int done = 0;
+    while (done < count) {
+      int read = input.Read(buffer, done, count - done);
+      if (read <= 0) return null;
+      done += read;
+    }
+    return buffer;
+  }
+
+  static string ReadField(byte[] spec, ref int offset) {
+    if (offset + 4 > spec.Length) return null;
+    int length = BitConverter.ToInt32(spec, offset);
+    offset += 4;
+    if (length < 0 || length % 2 != 0 || length > spec.Length - offset) return null;
+    string text = Encoding.Unicode.GetString(spec, offset, length);
+    offset += length;
+    return text;
+  }
+
+  static bool IsDrivePath(string path) {
+    if (path.Length < 3 || !char.IsLetter(path[0]) || path[1] != ':' || path[2] != '\\') return false;
+    return path.IndexOf('\0') < 0 && path.IndexOf('"') < 0;
+  }
+
+  // A network share (\\server\share\...), never a device or namespace path (\\.\ or \\?\).
+  static bool IsUncPath(string path) {
+    if (path.Length < 5 || path[0] != '\\' || path[1] != '\\') return false;
+    if (path[2] == '?' || path[2] == '.' || path[2] == '\\') return false;
+    int share = path.IndexOf('\\', 2) + 1;
+    if (share < 4 || share >= path.Length || path[share] == '\\') return false;
+    return path.IndexOf('\0') < 0 && path.IndexOf('"') < 0;
+  }
+
+  static string NameOf(string entry) {
+    return entry.Substring(0, entry.IndexOf('=', 1));
+  }
+
+  // The core's environment, exactly: `K=V` entries sorted by name ignoring case (libuv's order),
+  // each NUL-terminated, then a final NUL. The holder's own minimal environment never reaches
+  // the command.
+  static IntPtr EnvironmentBlock(string environment) {
+    string[] entries = environment.Length == 0 ? new string[0] : environment.Split('\0');
+    foreach (string entry in entries) if (entry.Length < 2 || entry.IndexOf('=', 1) < 1) return IntPtr.Zero;
+    Array.Sort(entries, (a, b) => {
+      int byName = string.Compare(NameOf(a), NameOf(b), StringComparison.OrdinalIgnoreCase);
+      return byName != 0 ? byName : string.CompareOrdinal(a, b);
+    });
+    StringBuilder block = new StringBuilder();
+    foreach (string entry in entries) {
+      block.Append(entry);
+      block.Append('\0');
+    }
+    block.Append('\0');
+    return Marshal.StringToHGlobalUni(block.ToString());
+  }
+}
+'@
+try {
+  # Add-Type lives in this one module. Importing it by path, with auto-loading off (as the host's
+  # privacy helper does), spares a new profile the analysis of every installed module.
+  Import-Module "$PSHOME\Modules\Microsoft.PowerShell.Utility\Microsoft.PowerShell.Utility.psd1"
+  Add-Type -TypeDefinition $code -Language CSharp
+} catch {
+  exit 0x6A560002
+}
+[JarvisHolder]::Run()
+exit 0x6A560006