mtech-ai-local-runner 0.1.14 → 0.1.15

package/README.md

@@ -10,6 +10,16 @@ The package stores safe runner configuration locally and keeps OAuth refresh cre
 
 Public npm installation requires no npm account or publishing OTP. Setup requires Gateway OAuth login, and local Claude Code must already be authenticated (`claude auth status`).
 
+## 0.1.15: startup output before MCP readiness
+
+The process host drains stdout from spawn, before the adapter starts consuming
+events after authenticated MCP discovery. A bounded queue prevents the child
+from blocking on ordinary startup output; overflow stops only its owned process
+group. This changes no tool permissions, preparation deadlines or task limits.
+Fake-process tests reproduce the defect, but do not prove the cause of a previous
+real-account failure or successful account/MCP acceptance. Publication and a
+foreground installation do not update the daemon or authorize a model run.
+
 ## 0.1.14: foreground administrator authentication wait
 
 The manual Codex pilot waits for administrator authentication before starting

package/dist/src/process/node-process-group-host.js

@@ -7,6 +7,19 @@ export class NodeProcessGroupHost {
         const child = spawn(command, args, { ...options, shell: false, detached: true, stdio: ["pipe", "pipe", "pipe"] });
         let failure;
         let owned = true;
+        let finished = false, consumed = false, queuedBytes = 0, wake;
+        const lines = [];
+        const MAX_QUEUED_BYTES = 1_048_576, MAX_QUEUED_LINES = 8192;
+        const notify = () => { const resolve = wake; wake = undefined; resolve?.(); };
+        let termination;
+        const exitCallbacks = [];
+        const terminated = (code, signal) => {
+            if (termination)
+                return;
+            termination = { code, signal };
+            for (const callback of exitCallbacks.splice(0))
+                callback(code, signal);
+        };
         const kill = (signal = "SIGKILL") => {
             if (!owned || !child.pid)
                 return;
@@ -28,47 +41,105 @@ export class NodeProcessGroupHost {
             if (signal === "SIGKILL")
                 owned = false;
         };
-        child.on("error", () => { failure = new Error("Provider process could not start"); });
-        child.stdin.on("error", () => { failure = new Error("Provider process input closed"); });
+        child.on("error", () => { failure ??= new Error("Provider process could not start"); terminated(null, null); notify(); });
+        child.stdin.on("error", () => {
+            failure ??= new Error("Provider process input closed");
+            try {
+                kill();
+            }
+            catch {
+                failure = new Error('Provider process group cleanup could not be confirmed');
+            }
+            terminated(null, null);
+            notify();
+        });
         // Provider stderr can contain account details. Consume without publishing it.
         child.stderr.resume();
-        child.once("exit", () => {
+        child.once("exit", (code, signal) => {
             try {
                 kill();
             }
             catch {
                 failure = new Error("Provider process group cleanup could not be confirmed");
             }
+            terminated(code, signal);
         });
+        // Drain from spawn, not from the first adapter event read: official exec can
+        // emit startup events before it initializes MCP, while the adapter awaits
+        // that initialization before consuming events. Bound the pre-consumer queue.
+        void (async () => {
+            let pending = Buffer.alloc(0);
+            const enqueue = (line) => {
+                if (line.length > 256_000)
+                    throw new Error("Provider event exceeded the allowed size");
+                if (queuedBytes + line.length + 1 > MAX_QUEUED_BYTES || lines.length >= MAX_QUEUED_LINES)
+                    throw new Error("Provider event buffer exceeded the allowed size");
+                lines.push({ text: line.toString('utf8').replace(/\r$/, ''), bytes: line.length + 1 });
+                queuedBytes += line.length + 1;
+                notify();
+            };
+            try {
+                for await (const chunk of child.stdout) {
+                    pending = Buffer.concat([pending, Buffer.from(chunk)]);
+                    let end;
+                    while ((end = pending.indexOf(10)) !== -1) {
+                        enqueue(pending.subarray(0, end));
+                        pending = pending.subarray(end + 1);
+                    }
+                    if (pending.length > 256_000)
+                        throw new Error("Provider event exceeded the allowed size");
+                }
+                if (pending.length)
+                    enqueue(pending);
+            }
+            catch (error) {
+                failure ??= error instanceof Error && ['Provider event exceeded the allowed size', 'Provider event buffer exceeded the allowed size'].includes(error.message) ? error : new Error('Provider event stream failed');
+                try {
+                    kill();
+                }
+                catch {
+                    failure = new Error('Provider process group cleanup could not be confirmed');
+                }
+            }
+            finally {
+                finished = true;
+                notify();
+            }
+        })();
         return {
             stdin: { write: (text) => { child.stdin.write(text); }, end: () => { child.stdin.end(); } },
             stdout: { async *[Symbol.asyncIterator]() {
-                    let pending = Buffer.alloc(0);
+                    if (consumed)
+                        throw new Error('Provider event stream already consumed');
+                    consumed = true;
                     try {
-                        for await (const chunk of child.stdout) {
-                            pending = Buffer.concat([pending, Buffer.from(chunk)]);
-                            let end;
-                            while ((end = pending.indexOf(10)) !== -1) {
-                                if (end > 256_000)
-                                    throw new Error("Provider event exceeded the allowed size");
-                                const line = pending.subarray(0, end).toString("utf8").replace(/\r$/, "");
-                                pending = pending.subarray(end + 1);
-                                yield line;
+                        while (true) {
+                            if (failure)
+                                throw failure;
+                            const line = lines.shift();
+                            if (line) {
+                                queuedBytes -= line.bytes;
+                                yield line.text;
+                                continue;
                             }
-                            if (pending.length > 256_000)
-                                throw new Error("Provider event exceeded the allowed size");
+                            if (finished)
+                                break;
+                            await new Promise(resolve => { wake = resolve; });
                         }
-                        if (pending.length)
-                            yield pending.toString("utf8");
-                        if (failure)
-                            throw failure;
                     }
                     finally {
+                        lines.length = 0;
+                        queuedBytes = 0;
                         kill();
                     }
                 } },
             kill: (signal) => kill((signal ?? "SIGKILL")),
-            once: (_event, callback) => { child.once("exit", callback); },
+            once: (_event, callback) => { if (termination) {
+                const ended = termination;
+                queueMicrotask(() => callback(ended.code, ended.signal));
+            }
+            else
+                exitCallbacks.push(callback); },
         };
     }
 }

package/package.json

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