codiedev 0.9.42 → 0.9.44

package/dist/codie.js

@@ -169,6 +169,87 @@ function installBrandWordmarkUnsafe(runtime) {
             (0, child_process_1.spawnSync)("codesign", ["--force", "--sign", "-", runtime], { stdio: "ignore" });
     }
 }
+async function runNonInteractive(runtime, runtimeArgs, env) {
+    const child = (0, child_process_1.spawn)(runtime, runtimeArgs, {
+        stdio: ["inherit", "pipe", "pipe"],
+        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);
+        };
+        child.stdout?.on("data", (chunk) => {
+            writeStdout(Buffer.from(chunk));
+        });
+        child.stderr?.on("data", (chunk) => {
+            const text = chunk.toString();
+            const reason = (0, codieLauncher_1.extractCodieSecurityBlock)(text);
+            if (reason) {
+                blockReason = reason;
+                return;
+            }
+            if (!blockReason)
+                process.stderr.write(chunk);
+        });
+        child.once("error", reject);
+        child.once("close", (status) => {
+            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);
+        });
+    });
+}
 async function main() {
     (0, codieRuntime_1.assertCodieNodeVersion)(process.versions.node);
     const connected = connectedCodiedevConfig();
@@ -235,23 +316,13 @@ async function main() {
     const nonInteractiveRun = runtimeArgs[0] === "run";
     if (nonInteractiveRun)
         env.CODIEDEV_SECURITY_BLOCK_OUTPUT = "marker";
-    const result = (0, child_process_1.spawnSync)(runtime, runtimeArgs, {
-        stdio: nonInteractiveRun ? ["inherit", "inherit", "pipe"] : "inherit",
-        encoding: nonInteractiveRun ? "utf8" : undefined,
-        env,
-    });
-    if (result.error)
-        throw result.error;
     if (nonInteractiveRun) {
-        const stderr = typeof result.stderr === "string" ? result.stderr : result.stderr?.toString() ?? "";
-        const blockReason = (0, codieLauncher_1.extractCodieSecurityBlock)(stderr);
-        if (blockReason) {
-            console.error(`Codie Security blocked this action:\n${blockReason}`);
-        }
-        else if (stderr) {
-            process.stderr.write(stderr);
-        }
+        process.exitCode = (await runNonInteractive(runtime, runtimeArgs, env)) ?? 1;
+        return;
     }
+    const result = (0, child_process_1.spawnSync)(runtime, runtimeArgs, { stdio: "inherit", env });
+    if (result.error)
+        throw result.error;
     process.exitCode = result.status === null ? 1 : result.status;
 }
 main().catch((error) => {

package/package.json

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