codiedev 0.9.43 → 0.9.45

package/dist/codie.js

@@ -176,55 +176,78 @@ async function runNonInteractive(runtime, runtimeArgs, env) {
     });
     return await new Promise((resolve, reject) => {
         let blockReason;
-        let pendingStdout = [];
-        let flushTimer;
-        // OpenCode reports a plugin rejection through two different pipes: the
-        // adapter's private reason on stderr, then its generic UnknownError on
-        // stdout. Hold stdout very briefly so the reason can win that race. Normal
-        // run output remains streaming with only an imperceptible delay.
-        const flushStdout = () => {
-            flushTimer = undefined;
-            if (!blockReason) {
-                for (const chunk of pendingStdout)
-                    process.stdout.write(chunk);
-            }
-            pendingStdout = [];
-        };
-        const scheduleStdoutFlush = () => {
-            if (!flushTimer)
-                flushTimer = setTimeout(flushStdout, 75);
+        const errorPrefixes = [Buffer.from("\x1b[91m\x1b[1mError:"), Buffer.from("Error: {")];
+        const retainedPrefixBytes = Math.max(...errorPrefixes.map((prefix) => prefix.length)) - 1;
+        // OpenCode's generic UnknownError and the adapter's private reason can be
+        // delivered in either order — and the generic block can arrive on stdout
+        // or stderr. Gate both streams by content, retaining only a possible final
+        // error block. Ordinary output stays streaming apart from the few bytes
+        // needed to recognize a split prefix.
+        const createOutputGate = (write) => {
+            let tail = Buffer.alloc(0);
+            let possibleError;
+            return {
+                push(chunk, blocked) {
+                    if (blocked) {
+                        if (possibleError)
+                            possibleError.push(Buffer.from(chunk));
+                        return;
+                    }
+                    if (possibleError) {
+                        possibleError.push(Buffer.from(chunk));
+                        return;
+                    }
+                    const combined = Buffer.concat([tail, chunk]);
+                    let errorStart = -1;
+                    for (const prefix of errorPrefixes) {
+                        const index = combined.indexOf(prefix);
+                        if (index >= 0 && (errorStart < 0 || index < errorStart))
+                            errorStart = index;
+                    }
+                    if (errorStart >= 0) {
+                        if (errorStart > 0)
+                            write(combined.subarray(0, errorStart));
+                        possibleError = [combined.subarray(errorStart)];
+                        tail = Buffer.alloc(0);
+                        return;
+                    }
+                    const flushBytes = Math.max(0, combined.length - retainedPrefixBytes);
+                    if (flushBytes > 0)
+                        write(combined.subarray(0, flushBytes));
+                    tail = combined.subarray(flushBytes);
+                },
+                finish(blocked) {
+                    if (tail.length > 0)
+                        write(tail);
+                    const heldError = possibleError ? Buffer.concat(possibleError).toString() : "";
+                    const genericBlockError = heldError.includes("UnknownError") &&
+                        heldError.includes("Unexpected server error");
+                    if (heldError && (!blocked || !genericBlockError))
+                        write(heldError);
+                },
+            };
         };
+        const stdoutGate = createOutputGate((chunk) => process.stdout.write(chunk));
+        const stderrGate = createOutputGate((chunk) => process.stderr.write(chunk));
         child.stdout?.on("data", (chunk) => {
-            if (blockReason)
-                return;
-            pendingStdout.push(Buffer.from(chunk));
-            scheduleStdoutFlush();
+            stdoutGate.push(Buffer.from(chunk), Boolean(blockReason));
         });
         child.stderr?.on("data", (chunk) => {
             const text = chunk.toString();
             const reason = (0, codieLauncher_1.extractCodieSecurityBlock)(text);
             if (reason) {
                 blockReason = reason;
-                pendingStdout = [];
-                if (flushTimer)
-                    clearTimeout(flushTimer);
-                flushTimer = undefined;
                 return;
             }
-            if (!blockReason)
-                process.stderr.write(chunk);
+            stderrGate.push(Buffer.from(chunk), Boolean(blockReason));
         });
         child.once("error", reject);
         child.once("close", (status) => {
-            if (flushTimer)
-                clearTimeout(flushTimer);
+            stdoutGate.finish(Boolean(blockReason));
+            stderrGate.finish(Boolean(blockReason));
             if (blockReason) {
-                pendingStdout = [];
                 console.error(`Codie Security blocked this action:\n${blockReason}`);
             }
-            else {
-                flushStdout();
-            }
             resolve(status);
         });
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codiedev",
-  "version": "0.9.43",
+  "version": "0.9.45",
   "description": "Connect Claude Code, Codex, Cursor, OpenCode, or VS Code Copilot to Codiedev for team session capture and artifact collaboration — and run the governed Codie harness",
   "bin": {
     "codiedev": "dist/cli.js",