mtech-ai-local-runner 0.1.41 → 0.1.42

package/README.md

@@ -1,3 +1,13 @@
+## 0.1.42: keep the guardian's reports when a late terminate fails
+
+The owned guardian now reports to the host on its own pipe (fd3) and takes the host's commands on another (fd5);
+fd4 stays parent liveness, and none of them reaches the executor. Before, one control socket carried both. When
+Codex exited by itself and the guardian confirmed and exited while the daemon was busy, the daemon's late terminate
+write failed on that socket, Node destroyed it, and the unread `root_exit` and `cleaned` reports were lost. 0.1.41
+recovered the cleanup confirmation from the exit code, but the lost root exit outcome still failed the P1 publication
+freeze with `OWNED_PROCESS_EXIT_UNCONFIRMED`. A failed command write now leaves the report pipe intact, so the host reads
+every report to its end. Cleanup is again confirmed only by `cleaned`; the exit-code fallback is removed.
+
 ## 0.1.41: confirm a cleanup the guardian finished before a late terminate
 
 When Codex exits by itself, the owned guardian confirms the cleanup and exits. A busy daemon could then write its

package/dist/src/process/owned-process-guardian.js

@@ -1,15 +1,18 @@
 import { spawn } from 'node:child_process';
 // Trusted, packaged JavaScript, deliberately independent of TypeScript loaders.
-// Only this helper creates and signals the new executor group. fd3 is private
-// control, fd4 parent liveness; neither is passed to the executor.
+// Only this helper creates and signals the new executor group. fd3 carries its
+// private reports to the host, fd4 parent liveness and fd5 the host's commands;
+// none is passed to the executor. Commands have their own pipe: a host write
+// that fails after the guardian exited cannot discard reports not yet read.
 const GUARDIAN_SOURCE = String.raw `
 const {spawn}=require('node:child_process');
 const {Socket}=require('node:net');
-const control=new Socket({fd:3,readable:true,writable:true});
-control.setEncoding('utf8');
+const reports=new Socket({fd:3,readable:false,writable:true});
 const liveness=new Socket({fd:4,readable:true,writable:false});
+const commands=new Socket({fd:5,readable:true,writable:false});
+commands.setEncoding('utf8');
 let child, ownedPid, ownedGone=false, cleaning, ready=Promise.resolve(), rootExited=false, closed=false, input='', configured=false, orphaned=false;
-const send=value=>{if(!control.destroyed)control.write(JSON.stringify(value)+'\n');};
+const send=value=>{if(!reports.destroyed)reports.write(JSON.stringify(value)+'\n');};
 const delay=ms=>new Promise(resolve=>setTimeout(resolve,ms));
 const alive=()=>{if(!ownedPid||ownedGone)return false;try{process.kill(-ownedPid,0);return true;}catch(e){if(e.code==='ESRCH'){ownedGone=true;return false;}if(e.code==='EPERM')return true;throw Error('cleanup');}};
 const signal=s=>{if(!ownedPid)throw Error('ownership');if(ownedGone)return 'esrch';try{process.kill(-ownedPid,s);return 'sent';}catch(e){if(e.code==='ESRCH'){ownedGone=true;return 'esrch';}if(e.code==='EPERM'){if(!rootExited)child.kill(s);return 'eperm';}throw Error('cleanup');}};
@@ -39,11 +42,11 @@ function cleanup(immediate=false,trigger='terminate'){
  })();
  return cleaning;
 }
-function finish(code){process.exitCode=code;process.stdin.destroy();liveness.destroy();control.end(()=>control.destroy());process.stdout.end();process.stderr.end();}
+function finish(code){process.exitCode=code;process.stdin.destroy();liveness.destroy();commands.destroy();reports.end(()=>reports.destroy());process.stdout.end();process.stderr.end();}
 function lost(){orphaned=true;if(configured)void cleanup(false,'lost');else finish(1);}
 liveness.on('data',()=>{});liveness.once('end',lost);liveness.once('error',lost);
-control.on('error',lost);control.on('end',lost);
-control.on('data',chunk=>{
+reports.on('error',lost);commands.on('error',lost);commands.on('end',lost);
+commands.on('data',chunk=>{
  input+=chunk.toString('utf8');if(input.length>2000000){lost();return;}
  let end;while((end=input.indexOf('\n'))>=0){
   let message;try{message=JSON.parse(input.slice(0,end));}catch{lost();return;}input=input.slice(end+1);
@@ -68,29 +71,31 @@ process.stderr.on('error',()=>{child?.stderr.resume();void cleanup(true,'output_
 `;
 export function spawnOwnedGuardian(command, args, options) {
     const child = spawn(process.execPath, ['--input-type=commonjs', '-e', GUARDIAN_SOURCE], {
-        cwd: options.cwd, env: {}, shell: false, detached: true, stdio: ['pipe', 'pipe', 'pipe', 'pipe', 'pipe'],
+        cwd: options.cwd, env: {}, shell: false, detached: true, stdio: ['pipe', 'pipe', 'pipe', 'pipe', 'pipe', 'pipe'],
     });
-    const control = child.stdio[3], liveness = child.stdio[4];
-    control.setEncoding('utf8');
+    // Node types only the first five stdio entries; fd5 is the sixth 'pipe' above.
+    const stdio = child.stdio;
+    const reports = stdio[3], liveness = stdio[4], commands = stdio[5];
+    reports.setEncoding('utf8');
     liveness.resume();
     let resolveStarted, rejectStarted;
     const started = new Promise((resolve, reject) => { resolveStarted = resolve; rejectStarted = reject; });
     // Hosts can attach observers after spawn returns without unhandled rejection.
     void started.catch(() => { });
     let confirmed = false, spawnFailed = false, protocolFailed = false, buffer = '';
-    let terminateWritten = false, hostTimeout = false, controlFailed = false, detail;
+    let terminateWritten = false, hostTimeout = false, commandFailed = false, detail;
     let outcome;
     let closePromise;
     const closed = new Promise(resolve => child.once('close', () => { liveness.destroy(); resolve(); }));
-    // A guardian that has confirmed and exited closes its control socket; a terminate written late by a
-    // busy host then fails, possibly before "cleaned" is read. That write error alone is not a protocol
-    // failure: the guardian exits 0 only after it sent "cleaned" (or after a spawn failure owned nothing).
-    control.on('error', () => { if (!confirmed && !spawnFailed)
-        controlFailed = true; });
+    // A guardian that has exited no longer reads commands, so a terminate written late by a busy host
+    // fails. That failure stays on the command pipe: the host still reads every report to its end.
+    commands.on('error', () => { if (!confirmed && !spawnFailed)
+        commandFailed = true; });
+    reports.on('error', () => { if (!confirmed && !spawnFailed)
+        protocolFailed = true; });
     liveness.on('error', () => { if (!confirmed && !spawnFailed)
         protocolFailed = true; });
-    const cleanedByExit = () => controlFailed && !protocolFailed && child.exitCode === 0 && child.signalCode === null;
-    control.on('data', (chunk) => {
+    reports.on('data', (chunk) => {
         buffer += chunk;
         if (buffer.length > 8192) {
             protocolFailed = true;
@@ -132,10 +137,10 @@ export function spawnOwnedGuardian(command, args, options) {
     });
     child.once('error', () => { spawnFailed = true; rejectStarted(new Error('Provider process could not start')); });
     child.once('close', () => { rejectStarted(new Error('Provider process could not start')); });
-    control.write(JSON.stringify({ type: 'launch', command, args, ...options }) + '\n');
+    commands.write(JSON.stringify({ type: 'launch', command, args, ...options }) + '\n');
     return { child, started, closed, outcome: () => outcome, spawnFailed: () => spawnFailed,
-        signal(immediate) { if (child.exitCode === null && child.signalCode === null && !confirmed && !spawnFailed && !control.destroyed) {
-            control.write(JSON.stringify({ type: 'terminate', immediate }) + '\n');
+        signal(immediate) { if (child.exitCode === null && child.signalCode === null && !confirmed && !spawnFailed && !commands.destroyed) {
+            commands.write(JSON.stringify({ type: 'terminate', immediate }) + '\n');
             terminateWritten = true;
         } },
         terminate(immediate = false) {
@@ -144,7 +149,7 @@ export function spawnOwnedGuardian(command, args, options) {
             this.signal(immediate);
             closePromise = new Promise((resolve, reject) => {
                 const timer = setTimeout(() => { protocolFailed = true; hostTimeout = true; liveness.destroy(); reject(new Error('Provider process group cleanup could not be confirmed')); }, 5500);
-                void closed.then(() => { clearTimeout(timer); if (protocolFailed || !(confirmed || cleanedByExit()))
+                void closed.then(() => { clearTimeout(timer); if (protocolFailed || !confirmed)
                     reject(new Error('Provider process group cleanup could not be confirmed'));
                 else
                     resolve(); });
@@ -153,14 +158,14 @@ export function spawnOwnedGuardian(command, args, options) {
         },
         /** Fixed cleanup observations after an unconfirmed cleanup; empty once cleanup is confirmed. */
         cleanupObservations() {
-            if ((confirmed || cleanedByExit()) && !protocolFailed)
+            if (confirmed && !protocolFailed)
                 return [];
-            if (!protocolFailed && !hostTimeout && !controlFailed)
+            if (!protocolFailed && !hostTimeout && !commandFailed)
                 return [];
             const observed = [terminateWritten ? 'cleanup_guardian_terminate_written' : 'cleanup_guardian_terminate_not_written'];
             if (hostTimeout)
                 observed.push('cleanup_guardian_host_timeout');
-            if (controlFailed)
+            if (commandFailed)
                 observed.push('cleanup_guardian_control_failed');
             if (!detail) {
                 if (!hostTimeout && protocolFailed)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mtech-ai-local-runner",
-  "version": "0.1.41",
+  "version": "0.1.42",
   "private": false,
   "license": "UNLICENSED",
   "bin": {