diff --git a/packages/effect-codex-app-server/src/errors.ts b/packages/effect-codex-app-server/src/errors.ts index 33d8cf5c48839..9f16adcd66c87 100644 --- a/packages/effect-codex-app-server/src/errors.ts +++ b/packages/effect-codex-app-server/src/errors.ts @@ -109,6 +109,7 @@ export type CodexAppServerProtocolParseOperation = typeof CodexAppServerProtocol export const CodexAppServerTransportOperation = Schema.Literals([ "read-input-stream", + "write-output-stream", "read-process-exit-status", ]); export type CodexAppServerTransportOperation = typeof CodexAppServerTransportOperation.Type; diff --git a/packages/effect-codex-app-server/src/protocol.test.ts b/packages/effect-codex-app-server/src/protocol.test.ts index 965764f468b61..351f0d2b87731 100644 --- a/packages/effect-codex-app-server/src/protocol.test.ts +++ b/packages/effect-codex-app-server/src/protocol.test.ts @@ -1,8 +1,10 @@ import * as Deferred from "effect/Deferred"; import * as Effect from "effect/Effect"; import * as Fiber from "effect/Fiber"; +import * as PlatformError from "effect/PlatformError"; import * as Queue from "effect/Queue"; import * as Schema from "effect/Schema"; +import * as Sink from "effect/Sink"; import * as Stdio from "effect/Stdio"; import * as Stream from "effect/Stream"; import * as TestClock from "effect/testing/TestClock"; @@ -740,6 +742,43 @@ it.layer(NodeServices.layer)("effect-codex-app-server protocol", (it) => { }), ); + it.effect("fails pending requests when a write fails while input stays open", () => + Effect.gen(function* () { + const { stdio: baseStdio } = yield* makeInMemoryStdio(); + const writeFailure = PlatformError.systemError({ + _tag: "Unknown", + module: "Stdio", + method: "stdout", + cause: new Error("EPIPE"), + }); + const terminated = yield* Deferred.make(); + const transport = yield* CodexProtocol.makeCodexAppServerPatchedProtocol({ + stdio: Stdio.make({ + args: baseStdio.args, + stdin: baseStdio.stdin, + stdout: () => Sink.forEach(() => Effect.fail(writeFailure)), + stderr: baseStdio.stderr, + }), + onTermination: (error) => Deferred.succeed(terminated, error).pipe(Effect.asVoid), + }); + const pending = yield* transport.request("thread/read", {}).pipe(Effect.forkScoped); + + const failure = yield* Deferred.await(terminated); + assert.instanceOf(failure, CodexError.CodexAppServerTransportError); + assert.equal(failure.operation, "write-output-stream"); + assert.strictEqual(failure.cause, writeFailure); + for (const request of [Fiber.join(pending), transport.request("thread/read", {})]) { + const requestFailure = yield* request.pipe( + Effect.match({ + onFailure: (error) => error, + onSuccess: () => assert.fail("Expected the broken transport to reject the request"), + }), + ); + assert.strictEqual(requestFailure, failure); + } + }), + ); + it.effect("reports a process exit that follows input end", () => Effect.gen(function* () { const { stdio, input } = yield* makeInMemoryStdio(); diff --git a/packages/effect-codex-app-server/src/protocol.ts b/packages/effect-codex-app-server/src/protocol.ts index c6a28992cad16..c628079d0b491 100644 --- a/packages/effect-codex-app-server/src/protocol.ts +++ b/packages/effect-codex-app-server/src/protocol.ts @@ -479,7 +479,20 @@ export const makeCodexAppServerPatchedProtocol = Effect.fn("makeCodexAppServerPa Effect.forkScoped, ); - yield* Stream.fromQueue(outgoing).pipe(Stream.run(options.stdio.stdout()), Effect.forkScoped); + yield* Stream.fromQueue(outgoing).pipe( + Stream.run(options.stdio.stdout()), + Effect.catch((cause) => + handleTermination(() => + Effect.succeed( + new CodexError.CodexAppServerTransportError({ + operation: "write-output-stream", + cause, + }), + ), + ), + ), + Effect.forkScoped, + ); const request = Effect.fn("CodexAppServerProtocol.request")(function* ( method: string,