codiedev 0.9.44 → 0.9.46

package/dist/codie.js

@@ -176,76 +176,79 @@ async function runNonInteractive(runtime, runtimeArgs, env) {
     });
     return await new Promise((resolve, reject) => {
         let blockReason;
-        let stdoutTail = Buffer.alloc(0);
-        let possibleOpenCodeError;
         const errorPrefixes = [Buffer.from("\x1b[91m\x1b[1mError:"), Buffer.from("Error: {")];
         const retainedPrefixBytes = Math.max(...errorPrefixes.map((prefix) => prefix.length)) - 1;
-        // OpenCode reports a plugin rejection through two different pipes: the
-        // adapter's private reason on stderr, then its generic UnknownError on
-        // stdout. Pipe ordering is nondeterministic, so retain only a possible
-        // terminal error block until the marker arrives. Ordinary run output keeps
-        // streaming immediately (apart from the few bytes needed to match a prefix).
-        const writeStdout = (chunk) => {
-            if (blockReason) {
-                if (possibleOpenCodeError)
-                    possibleOpenCodeError.push(Buffer.from(chunk));
-                return;
-            }
-            if (possibleOpenCodeError) {
-                possibleOpenCodeError.push(Buffer.from(chunk));
-                return;
-            }
-            const combined = Buffer.concat([stdoutTail, 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)
-                    process.stdout.write(combined.subarray(0, errorStart));
-                possibleOpenCodeError = [combined.subarray(errorStart)];
-                stdoutTail = Buffer.alloc(0);
-                return;
-            }
-            const flushBytes = Math.max(0, combined.length - retainedPrefixBytes);
-            if (flushBytes > 0)
-                process.stdout.write(combined.subarray(0, flushBytes));
-            stdoutTail = combined.subarray(flushBytes);
+        // 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) => {
-            writeStdout(Buffer.from(chunk));
+            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;
+                child.kill("SIGTERM");
                 return;
             }
-            if (!blockReason)
-                process.stderr.write(chunk);
+            stderrGate.push(Buffer.from(chunk), Boolean(blockReason));
         });
         child.once("error", reject);
         child.once("close", (status) => {
+            stdoutGate.finish(Boolean(blockReason));
+            stderrGate.finish(Boolean(blockReason));
             if (blockReason) {
-                if (stdoutTail.length > 0)
-                    process.stdout.write(stdoutTail);
-                const heldError = possibleOpenCodeError
-                    ? Buffer.concat(possibleOpenCodeError).toString()
-                    : "";
-                if (heldError && !(heldError.includes("UnknownError") && heldError.includes("Unexpected server error"))) {
-                    process.stdout.write(heldError);
-                }
                 console.error(`Codie Security blocked this action:\n${blockReason}`);
             }
-            else {
-                if (stdoutTail.length > 0)
-                    process.stdout.write(stdoutTail);
-                if (possibleOpenCodeError)
-                    process.stdout.write(Buffer.concat(possibleOpenCodeError));
-            }
             resolve(status);
         });
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codiedev",
-  "version": "0.9.44",
+  "version": "0.9.46",
   "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",