fix(opencode): flush stdio before cli exit

packages/opencode/src/cli/stdout.ts

@@ -0,0 +1,12 @@
+export type FlushableWriteStream = {
+  destroyed?: boolean
+  writableEnded?: boolean
+  write(chunk: string, callback: () => void): boolean
+}
+
+export function flushWriteStream(stream: FlushableWriteStream) {
+  if (stream.destroyed || stream.writableEnded) return Promise.resolve()
+  return new Promise<void>((resolve) => {
+    stream.write("", () => resolve())
+  })
+}

packages/opencode/src/index.ts

@@ -40,6 +40,7 @@ import { Heap } from "./cli/heap"
 import { drizzle } from "drizzle-orm/bun-sqlite"
 import { ensureProcessMetadata } from "@opencode-ai/core/util/opencode-process"
 import { isRecord } from "@/util/record"
+import { flushWriteStream } from "@/cli/stdout"
 
 const processMetadata = ensureProcessMetadata("main")
 
@@ -247,5 +248,6 @@ try {
   // Most notably, some docker-container-based MCP servers don't handle such signals unless
   // run using `docker run --init`.
   // Explicitly exit to avoid any hanging subprocesses.
+  await Promise.all([flushWriteStream(process.stdout), flushWriteStream(process.stderr)])
   process.exit()
 }

packages/opencode/test/cli/stdout.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, test } from "bun:test"
+import { flushWriteStream } from "../../src/cli/stdout"
+
+describe("flushWriteStream", () => {
+  test("waits for the stream write callback", async () => {
+    let flush: (() => void) | undefined
+    let resolved = false
+
+    const pending = flushWriteStream({
+      write(_chunk, callback) {
+        flush = () => callback()
+        return false
+      },
+    }).then(() => {
+      resolved = true
+    })
+
+    await Promise.resolve()
+    expect(resolved).toBe(false)
+
+    flush?.()
+    await pending
+
+    expect(resolved).toBe(true)
+  })
+
+  test("skips destroyed streams", async () => {
+    let wrote = false
+
+    await flushWriteStream({
+      destroyed: true,
+      write() {
+        wrote = true
+        return true
+      },
+    })
+
+    expect(wrote).toBe(false)
+  })
+})