@ctrl-spc/cs 0.7.14 → 0.7.16

package/dist/windows-job.js

@@ -0,0 +1,312 @@
+import { execFile, execFileSync } from 'node:child_process';
+import { existsSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { createHash, randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+import { ensureLifecycleDir } from './config.js';
+const execute = promisify(execFile);
+/** A Job Object owns descendants even after an intermediate .cmd wrapper exits.
+ * Windows 10's JOB_LIST creation attribute puts the first instruction inside the
+ * job atomically. Create-suspended/assign/resume leaves an orphan window if the
+ * helper dies between those calls. This executable uses only the Windows/.NET
+ * runtime already used by our PowerShell helpers; no downloaded native binary. */
+const source = String.raw `
+using System;
+using System.IO;
+using System.Text;
+using System.Threading;
+using System.ComponentModel;
+using System.Globalization;
+using System.Runtime.InteropServices;
+using System.Security.Principal;
+using System.Runtime.Serialization;
+using System.Runtime.Serialization.Json;
+public class CtrlSpcOwnedJob {
+  [StructLayout(LayoutKind.Sequential)] struct SA { public int size; public IntPtr descriptor; public int inherit; }
+  [StructLayout(LayoutKind.Sequential)] struct BasicLimits { public long processTime, jobTime; public uint flags; public UIntPtr minWorking, maxWorking; public uint activeLimit; public UIntPtr affinity; public uint priority, scheduling; }
+  [StructLayout(LayoutKind.Sequential)] struct IO { public ulong readOps, writeOps, otherOps, readBytes, writeBytes, otherBytes; }
+  [StructLayout(LayoutKind.Sequential)] struct Limits { public BasicLimits basic; public IO io; public UIntPtr processMemory, jobMemory, peakProcess, peakJob; }
+  [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)] struct SI { public int size; public string reserved, desktop, title; public int x,y,xSize,ySize,xChars,yChars,fill,flags; public short show,reservedSize; public IntPtr reservedBytes,input,output,error; }
+  [StructLayout(LayoutKind.Sequential)] struct SIEX { public SI startup; public IntPtr attributes; }
+  [StructLayout(LayoutKind.Sequential)] struct PI { public IntPtr process,thread; public uint pid,tid; }
+  [DataContract] public class Launch { [DataMember] public string application; [DataMember] public string command; [DataMember] public string cwd; }
+  [DllImport("kernel32.dll", CharSet=CharSet.Unicode, SetLastError=true)] static extern IntPtr CreateJobObject(ref SA sa, string name);
+  [DllImport("kernel32.dll", CharSet=CharSet.Unicode, SetLastError=true)] static extern IntPtr OpenJobObject(uint rights, bool inherit, string name);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool SetInformationJobObject(IntPtr job, int kind, ref Limits limits, uint length);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool QueryInformationJobObject(IntPtr job, int kind, IntPtr data, uint size, out uint written);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool TerminateJobObject(IntPtr job, uint code);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern IntPtr OpenProcess(uint rights, bool inherit, uint pid);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool GetProcessTimes(IntPtr process, out long created, out long exited, out long kernel, out long user);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool TerminateProcess(IntPtr process, uint code);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool IsProcessInJob(IntPtr process, IntPtr job, out bool assigned);
+  [DllImport("kernel32.dll")] static extern IntPtr GetCurrentProcess();
+  [DllImport("advapi32.dll", SetLastError=true)] static extern bool OpenProcessToken(IntPtr process, uint rights, out IntPtr token);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool InitializeProcThreadAttributeList(IntPtr list, int count, int flags, ref IntPtr bytes);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool UpdateProcThreadAttribute(IntPtr list, uint flags, IntPtr kind, IntPtr value, IntPtr size, IntPtr previous, IntPtr returned);
+  [DllImport("kernel32.dll")] static extern void DeleteProcThreadAttributeList(IntPtr list);
+  [DllImport("kernel32.dll", CharSet=CharSet.Unicode, SetLastError=true)] static extern bool CreateProcess(string app, StringBuilder command, IntPtr processSecurity, IntPtr threadSecurity, bool inherit, uint flags, IntPtr environment, string cwd, ref SIEX startup, out PI info);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool ReadFile(IntPtr file, byte[] bytes, uint count, out uint read, IntPtr overlapped);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool CreatePipe(out IntPtr read, out IntPtr write, ref SA security, uint size);
+  [DllImport("kernel32.dll", CharSet=CharSet.Unicode, SetLastError=true)] static extern IntPtr CreateFile(string path, uint access, uint share, ref SA security, uint creation, uint flags, IntPtr template);
+  [DllImport("kernel32.dll")] static extern IntPtr GetStdHandle(int kind);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool SetHandleInformation(IntPtr handle, uint mask, uint flags);
+  [DllImport("kernel32.dll")] static extern uint WaitForSingleObject(IntPtr handle, uint ms);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool GetExitCodeProcess(IntPtr process, out uint code);
+  [DllImport("kernel32.dll")] static extern bool CloseHandle(IntPtr handle);
+  [DllImport("kernel32.dll")] static extern IntPtr LocalFree(IntPtr value);
+  [DllImport("advapi32.dll", CharSet=CharSet.Unicode, SetLastError=true)] static extern bool ConvertStringSecurityDescriptorToSecurityDescriptor(string value, uint revision, out IntPtr descriptor, IntPtr size);
+  static void Check(bool result) { if (!result) throw new Win32Exception(Marshal.GetLastWin32Error()); }
+  static string Argument(string value) {
+    StringBuilder result=new StringBuilder("\""); int slashes=0;
+    foreach(char c in value) {
+      if(c=='\\') { slashes++; continue; }
+      result.Append('\\',c=='\"'?slashes*2+1:slashes).Append(c); slashes=0;
+    }
+    return result.Append('\\',slashes*2).Append('"').ToString();
+  }
+  static string Command(params string[] args) { return String.Join(" ",Array.ConvertAll(args,Argument)); }
+  static PI CreateWithHandles(string app,string command,string cwd,IntPtr input,IntPtr output,IntPtr error,IntPtr job,uint flags) {
+    SIEX startup=new SIEX(); startup.startup.size=Marshal.SizeOf(typeof(SIEX)); startup.startup.flags=0x100;
+    startup.startup.input=input; startup.startup.output=output; startup.startup.error=error;
+    var standard=new System.Collections.Generic.List<IntPtr>();
+    foreach(IntPtr handle in new IntPtr[]{input,output,error}) if(!standard.Contains(handle)) standard.Add(handle);
+    int count=job==IntPtr.Zero?1:2; IntPtr bytes=IntPtr.Zero; InitializeProcThreadAttributeList(IntPtr.Zero,count,0,ref bytes);
+    startup.attributes=Marshal.AllocHGlobal(bytes); IntPtr jobs=Marshal.AllocHGlobal(IntPtr.Size), handles=Marshal.AllocHGlobal(IntPtr.Size*standard.Count); bool initialized=false;
+    try {
+      Check(InitializeProcThreadAttributeList(startup.attributes,count,0,ref bytes)); initialized=true;
+      if(job!=IntPtr.Zero) {
+        Marshal.WriteIntPtr(jobs,job);
+        Check(UpdateProcThreadAttribute(startup.attributes,0,new IntPtr(0x2000D),jobs,new IntPtr(IntPtr.Size),IntPtr.Zero,IntPtr.Zero));
+      }
+      for(int i=0;i<standard.Count;i++) { Check(SetHandleInformation(standard[i],1,1)); Marshal.WriteIntPtr(handles,i*IntPtr.Size,standard[i]); }
+      Check(UpdateProcThreadAttribute(startup.attributes,0,new IntPtr(0x20002),handles,new IntPtr(IntPtr.Size*standard.Count),IntPtr.Zero,IntPtr.Zero));
+      PI child;
+      Check(CreateProcess(app,new StringBuilder(command),IntPtr.Zero,IntPtr.Zero,true,flags|0x80000,IntPtr.Zero,cwd,ref startup,out child));
+      return child;
+    } finally { if(initialized) DeleteProcThreadAttributeList(startup.attributes); Marshal.FreeHGlobal(startup.attributes); Marshal.FreeHGlobal(jobs); Marshal.FreeHGlobal(handles); }
+  }
+  static IntPtr ServiceFile(string path,uint access,uint creation) {
+    SA security=new SA { size=Marshal.SizeOf(typeof(SA)), inherit=1 };
+    IntPtr handle=CreateFile(path,access,3,ref security,creation,0x80,IntPtr.Zero);
+    if(handle==new IntPtr(-1)) throw new Win32Exception(Marshal.GetLastWin32Error());
+    return handle;
+  }
+  static void RequireIndependentService(IntPtr process) {
+    bool assigned; Check(IsProcessInJob(process,IntPtr.Zero,out assigned));
+    if(assigned) throw new Exception("This terminal still owns the replacement. Run cs restart from another terminal on this computer; no independent service was started.");
+  }
+  static int Service(string[] args) {
+    if(args.Length!=5 || !System.Text.RegularExpressions.Regex.IsMatch(args[3],@"^--lifecycle-handover=[0-9a-f-]{36}$") || !Path.IsPathRooted(args[1]) || !Path.IsPathRooted(args[2]) || !Path.IsPathRooted(args[4])) throw new Exception("Invalid installed service handover.");
+    bool detached=args[0]=="daemon-detached";
+    // Check before Node exists: libuv can later add Node to its own Job, which
+    // is independent of the terminal and must not be mistaken for its owner.
+    if(detached) RequireIndependentService(GetCurrentProcess());
+    IntPtr input=IntPtr.Zero,log=IntPtr.Zero,read=IntPtr.Zero,write=IntPtr.Zero;
+    try {
+      input=ServiceFile("NUL",0x80000000,3); log=ServiceFile(args[4],4,4);
+      if(detached) {
+        PI service=CreateWithHandles(args[1],Command(args[1],args[2],"start",args[3]),null,input,log,log,IntPtr.Zero,0x08000000);
+        CloseHandle(service.thread); CloseHandle(service.process);
+        Console.WriteLine("{\"pid\":"+service.pid+"}"); return 0;
+      }
+      SA security=new SA { size=Marshal.SizeOf(typeof(SA)), inherit=1 };
+      Check(CreatePipe(out read,out write,ref security,0)); Check(SetHandleInformation(read,1,0));
+      string executable=System.Reflection.Assembly.GetExecutingAssembly().Location;
+      PI stage;
+      try { stage=CreateWithHandles(executable,Command(executable,"daemon-detached",args[1],args[2],args[3],args[4]),null,input,write,log,IntPtr.Zero,0x09000000); }
+      catch(Win32Exception e) { throw new Exception("This terminal cannot launch an independent background service (Windows "+e.NativeErrorCode+"). Run cs restart from another terminal on this computer. Saved work remains.",e); }
+      CloseHandle(stage.thread); CloseHandle(write); write=IntPtr.Zero;
+      try {
+        RequireIndependentService(stage.process);
+        byte[] buffer=new byte[256]; StringBuilder response=new StringBuilder(); uint count;
+        while(true) {
+          bool ok=ReadFile(read,buffer,(uint)buffer.Length,out count,IntPtr.Zero);
+          if(!ok) { int error=Marshal.GetLastWin32Error(); if(error==109) break; throw new Win32Exception(error); }
+          if(count==0) break;
+          response.Append(Encoding.UTF8.GetString(buffer,0,(int)count));
+          if(response.Length>256) throw new Exception("Invalid installed service launch receipt.");
+        }
+        if(WaitForSingleObject(stage.process,0xFFFFFFFF)!=0) throw new Exception("Could not observe the detached launcher exit.");
+        uint code; Check(GetExitCodeProcess(stage.process,out code));
+        if(code!=0) throw new Exception("The detached launcher failed. Check cs status and this computer's service log; saved work remains.");
+        Console.Write(response.ToString()); return 0;
+      } finally { CloseHandle(stage.process); }
+    } finally { foreach(IntPtr handle in new IntPtr[]{input,log,read,write}) if(handle!=IntPtr.Zero) CloseHandle(handle); }
+  }
+  static int Process(string[] args) {
+    if(args.Length!=4) throw new Exception("Invalid process lifetime.");
+    uint pid; DateTime birth;
+    if(!UInt32.TryParse(args[1],out pid) || pid==0 || !DateTime.TryParseExact(args[3],"O",CultureInfo.InvariantCulture,DateTimeStyles.RoundtripKind,out birth) || birth.Kind!=DateTimeKind.Utc)
+      throw new Exception("Invalid process lifetime.");
+    string sid=WindowsIdentity.GetCurrent().User.Value;
+    if(args[2]!=sid) throw new Exception("Process ownership belongs to another user.");
+    bool terminate=args[0]=="process-terminate";
+    // Query-only never requests termination rights. The opened HANDLE pins the
+    // lifetime even if its PID is reused between verification and termination.
+    IntPtr process=OpenProcess(0x101000u | (terminate?1u:0u),false,pid);
+    if(process==IntPtr.Zero) {
+      int error=Marshal.GetLastWin32Error();
+      if(error!=87) throw new Win32Exception(error);
+      Console.WriteLine("{\"exists\":false,\"matches\":false}"); return 0;
+    }
+    try {
+      uint state=WaitForSingleObject(process,0);
+      if(state==0) { Console.WriteLine("{\"exists\":false,\"matches\":false}"); return 0; }
+      if(state!=258) throw new Win32Exception(Marshal.GetLastWin32Error());
+      long created,exited,kernel,user; Check(GetProcessTimes(process,out created,out exited,out kernel,out user));
+      IntPtr token; Check(OpenProcessToken(process,8,out token));
+      string owner;
+      try { using(WindowsIdentity identity=new WindowsIdentity(token)) owner=identity.User.Value; }
+      finally { CloseHandle(token); }
+      // Win32_Process CreationDate uses CIM_DATETIME's microsecond precision.
+      // Compare kernel FILETIME at that precision, retaining all available digits.
+      bool matches=owner==sid && created/10==birth.ToFileTimeUtc()/10;
+      if(matches && terminate && !TerminateProcess(process,1)) {
+        int error=Marshal.GetLastWin32Error();
+        if(WaitForSingleObject(process,0)!=0) throw new Win32Exception(error);
+      }
+      Console.WriteLine("{\"exists\":true,\"matches\":"+(matches?"true":"false")+"}"); return 0;
+    } finally { CloseHandle(process); }
+  }
+  static uint[] Members(IntPtr job) {
+    // A growing process list returns ERROR_MORE_DATA. Re-read the authoritative
+    // Job membership; never substitute a parent-PID snapshot for this boundary.
+    int capacity=64;
+    while (true) {
+      int size=8+capacity*IntPtr.Size; IntPtr data=Marshal.AllocHGlobal(size);
+      try {
+        uint written; bool ok=QueryInformationJobObject(job,3,data,(uint)size,out written);
+        if (!ok) { int error=Marshal.GetLastWin32Error(); if(error==234 && capacity<1048576) { capacity*=2; continue; } throw new Win32Exception(error); }
+        int count=Marshal.ReadInt32(data,4); if(count<0 || count>capacity) throw new Exception("Invalid Job membership.");
+        uint[] ids=new uint[count]; for(int i=0;i<count;i++) ids[i]=checked((uint)Marshal.ReadIntPtr(data,8+i*IntPtr.Size).ToInt64());
+        return ids;
+      } finally { Marshal.FreeHGlobal(data); }
+    }
+  }
+  static int Run(string name,string file) {
+    Launch launch; using(FileStream input=File.OpenRead(file)) launch=(Launch)new DataContractJsonSerializer(typeof(Launch)).ReadObject(input); File.Delete(file);
+    IntPtr descriptor; string sid=WindowsIdentity.GetCurrent().User.Value;
+    Check(ConvertStringSecurityDescriptorToSecurityDescriptor("D:P(A;;GA;;;"+sid+")",1,out descriptor,IntPtr.Zero));
+    IntPtr job=IntPtr.Zero;
+    try {
+      SA security=new SA { size=Marshal.SizeOf(typeof(SA)), descriptor=descriptor, inherit=0 };
+      job=CreateJobObject(ref security,name); int error=Marshal.GetLastWin32Error();
+      if(job==IntPtr.Zero) throw new Win32Exception(error);
+      if(error==183) throw new Exception("Execution boundary already exists.");
+      Limits limits=new Limits(); limits.basic.flags=0x2000; // KILL_ON_JOB_CLOSE; no breakaway.
+      Check(SetInformationJobObject(job,9,ref limits,(uint)Marshal.SizeOf(typeof(Limits))));
+      byte[] grant=new byte[1]; uint read;
+      // Exactly one byte. Buffered Console input can swallow prompt bytes which
+      // must remain in the inherited pipe for the actual harness.
+      bool received=ReadFile(GetStdHandle(-10),grant,1,out read,IntPtr.Zero);
+      if(!received) { int e=Marshal.GetLastWin32Error(); if(e==109) return 0; throw new Win32Exception(e); }
+      if(read!=1 || grant[0]!=1) return 0;
+      PI child=CreateWithHandles(launch.application,launch.command,launch.cwd,GetStdHandle(-10),GetStdHandle(-11),GetStdHandle(-12),job,0x08000000);
+      CloseHandle(child.thread);
+      try {
+        if(WaitForSingleObject(child.process,0xFFFFFFFF)!=0) throw new Exception("Could not observe harness exit.");
+        uint code; Check(GetExitCodeProcess(child.process,out code));
+        while(Members(job).Length!=0) Thread.Sleep(25);
+        return unchecked((int)code);
+      } finally { CloseHandle(child.process); }
+    } finally { if(job!=IntPtr.Zero) CloseHandle(job); LocalFree(descriptor); }
+  }
+  public static int Main(string[] args) {
+    try {
+      if(args.Length>0 && (args[0]=="service-launch" || args[0]=="daemon-detached")) return Service(args);
+      if(args.Length>0 && (args[0]=="process-query" || args[0]=="process-terminate")) return Process(args);
+      if(args.Length<2 || !System.Text.RegularExpressions.Regex.IsMatch(args[1],@"^Global\\CTRLSPCExecution-[0-9a-f-]{36}$")) throw new Exception("Invalid execution boundary.");
+      if(args[0]=="run" && args.Length==3) return Run(args[1],args[2]);
+      if(args.Length!=2 || (args[0]!="query" && args[0]!="terminate")) throw new Exception("Invalid execution boundary operation.");
+      IntPtr job=OpenJobObject(args[0]=="terminate" ? 0xCu : 0x4u,false,args[1]);
+      if(job==IntPtr.Zero) { int error=Marshal.GetLastWin32Error(); if(error!=2) throw new Win32Exception(error); Console.WriteLine("{\"exists\":false,\"pids\":[]}"); return 0; }
+      try {
+        if(args[0]=="terminate") Check(TerminateJobObject(job,1));
+        Console.WriteLine("{\"exists\":true,\"pids\":["+String.Join(",",Members(job))+"]}"); return 0;
+      } finally { CloseHandle(job); }
+    } catch(Exception e) { Console.Error.WriteLine("Windows execution boundary: "+e.Message); return 1; }
+  }
+}
+`;
+function remaining(deadline) {
+    const ms = deadline - Date.now();
+    if (ms <= 0)
+        throw new Error('Service operation exceeded its deadline.');
+    return Math.min(ms, 5000);
+}
+export function windowsJobName(reservationId) {
+    if (!/^[0-9a-f-]{36}$/i.test(reservationId))
+        throw new Error('Invalid execution reservation.');
+    return `Global\\CTRLSPCExecution-${reservationId.toLowerCase()}`;
+}
+/** Build once in the private lifecycle directory, then run/query without a
+ * PowerShell startup on every process inspection. Racing builders publish only
+ * a complete executable; compilation failures are actionable failures. */
+export function windowsJobExecutable(deadline = Date.now() + 5000) {
+    const directory = ensureLifecycleDir();
+    const target = join(directory, `owned-job-${createHash('sha256').update(source).digest('hex').slice(0, 16)}.exe`);
+    if (existsSync(target))
+        return target;
+    const temporary = join(directory, `owned-job-build-${randomUUID()}`);
+    writeFileSync(temporary + '.cs', source, { mode: 0o600 });
+    try {
+        execFileSync('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', "$ErrorActionPreference='Stop'; Add-Type -Path $env:CTRL_SPC_JOB_SOURCE -OutputAssembly $env:CTRL_SPC_JOB_OUTPUT -OutputType ConsoleApplication -ReferencedAssemblies System.dll,System.Core.dll,System.Xml.dll,System.Runtime.Serialization.dll"], {
+            env: { ...process.env, CTRL_SPC_JOB_SOURCE: temporary + '.cs', CTRL_SPC_JOB_OUTPUT: temporary + '.exe' }, windowsHide: true, timeout: remaining(deadline), stdio: ['ignore', 'ignore', 'pipe'],
+        });
+        try {
+            renameSync(temporary + '.exe', target);
+        }
+        catch (error) {
+            if (!existsSync(target))
+                throw error;
+        }
+        return target;
+    }
+    finally {
+        rmSync(temporary + '.cs', { force: true });
+        rmSync(temporary + '.exe', { force: true });
+    }
+}
+/** The launcher has already been compiled and lifecycle ownership rechecked. */
+export async function launchWindowsService(executable, entry, nonce, log, deadline) {
+    if (!/^[0-9a-f-]{36}$/.test(nonce))
+        throw new Error('Invalid installed service handover.');
+    const { stdout } = await execute(executable, ['service-launch', process.execPath, entry, '--lifecycle-handover=' + nonce, log], {
+        env: { ...process.env, CTRL_SPC_LIFECYCLE_HANDOVER: nonce }, windowsHide: true,
+        timeout: remaining(deadline), maxBuffer: 4096,
+    });
+    const receipt = JSON.parse(stdout);
+    if (!receipt || typeof receipt !== 'object' || !('pid' in receipt) || !Number.isSafeInteger(receipt.pid) || receipt.pid <= 0 || receipt.pid > 0xffffffff)
+        throw new Error('Windows returned an unreadable installed service launch receipt. Run cs status before retrying.');
+    remaining(deadline);
+    return receipt.pid;
+}
+export async function inspectWindowsJob(name, deadline = Date.now() + 5000, terminate = false) {
+    if (!/^Global\\CTRLSPCExecution-[0-9a-f-]{36}$/.test(name))
+        throw new Error('Invalid execution boundary.');
+    const executable = windowsJobExecutable(deadline);
+    const { stdout } = await execute(executable, [terminate ? 'terminate' : 'query', name], { windowsHide: true, timeout: remaining(deadline), maxBuffer: 8 * 1024 * 1024 });
+    const value = JSON.parse(stdout);
+    if (!value || typeof value !== 'object' || !('exists' in value) || typeof value.exists !== 'boolean' || !('pids' in value) || !Array.isArray(value.pids) || !value.pids.every((pid) => Number.isSafeInteger(pid) && pid > 0) || (!value.exists && value.pids.length))
+        throw new Error('Windows returned an unreadable execution boundary.');
+    remaining(deadline);
+    return { exists: value.exists, pids: value.pids };
+}
+/** Verify and optionally terminate the same kernel process handle, never a
+ * separately resolved PID after inspecting its creation time. */
+export async function inspectWindowsProcess(identity, deadline = Date.now() + 5000, terminate = false) {
+    if (!Number.isSafeInteger(identity.pid) || identity.pid <= 0 || identity.pid > 0xffffffff
+        || !/^S-\d+(?:-\d+)+$/.test(identity.owner) || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{7}Z$/.test(identity.birth)) {
+        throw new Error('Invalid Windows process lifetime.');
+    }
+    const executable = windowsJobExecutable(deadline);
+    const { stdout } = await execute(executable, [terminate ? 'process-terminate' : 'process-query',
+        String(identity.pid), identity.owner, identity.birth], { windowsHide: true, timeout: remaining(deadline), maxBuffer: 4096 });
+    const value = JSON.parse(stdout);
+    if (!value || typeof value !== 'object' || !('exists' in value) || typeof value.exists !== 'boolean'
+        || !('matches' in value) || typeof value.matches !== 'boolean' || (!value.exists && value.matches)) {
+        throw new Error('Windows returned an unreadable process lifetime.');
+    }
+    remaining(deadline);
+    return { exists: value.exists, matches: value.matches };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ctrl-spc/cs",
-  "version": "0.7.14",
+  "version": "0.7.16",
   "description": "CTRL+SPC — minimal, reliable per-machine agent presence. Sign-in, auto-start, agent detection, heartbeat presence, and ping acknowledgement.",
   "engines": {
     "node": ">=22"
@@ -16,9 +16,10 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && node src/native/build-darwin-helper.mjs",
     "start": "npm run build && node dist/index.js",
-    "test": "npm run build && node --test --test-concurrency=1 test/*.test.mjs"
+    "test": "npm run build && node --test --test-concurrency=1 test/*.test.mjs",
+    "postinstall": "node dist/daemon-lifecycle.js --installation-checkpoint"
   },
   "license": "UNLICENSED",
   "dependencies": {