Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

[codex] Preserve desktop backend output read failures (#3444)

Julius Marminge803c2b77387b
diff --git a/apps/desktop/src/backend/DesktopBackendManager.test.ts b/apps/desktop/src/backend/DesktopBackendManager.test.ts
index 0c083889f..3c0a513c9 100644
--- a/apps/desktop/src/backend/DesktopBackendManager.test.ts
+++ b/apps/desktop/src/backend/DesktopBackendManager.test.ts
@@ -59,8 +59,8 @@ const configWithObservability: DesktopBackendBootstrapValue = {
};
function makeProcess(options?: {
- readonly stdout?: Stream.Stream<Uint8Array>;
- readonly stderr?: Stream.Stream<Uint8Array>;
+ readonly stdout?: Stream.Stream<Uint8Array, PlatformError.PlatformError>;
+ readonly stderr?: Stream.Stream<Uint8Array, PlatformError.PlatformError>;
readonly exitCode?: Effect.Effect<ChildProcessSpawner.ExitCode, PlatformError.PlatformError>;
readonly kill?: ChildProcessSpawner.ChildProcessHandle["kill"];
}): ChildProcessSpawner.ChildProcessHandle {
@@ -389,6 +389,93 @@ describe("DesktopBackendManager", () => {
}),
);
+ it.effect("reports output stream failures with process and stream context", () =>
+ Effect.gen(function* () {
+ const outputCause = PlatformError.systemError({
+ _tag: "BadResource",
+ module: "ChildProcess",
+ method: "stdout",
+ description: "output-stream-secret-sentinel",
+ });
+ const reported = yield* Deferred.make<DesktopBackendManager.BackendProcessOutputError>();
+ const spawnerLayer = Layer.succeed(
+ ChildProcessSpawner.ChildProcessSpawner,
+ ChildProcessSpawner.make(() =>
+ Effect.succeed(
+ makeProcess({
+ stdout: Stream.fail(outputCause),
+ exitCode: Deferred.await(reported).pipe(Effect.as(ChildProcessSpawner.ExitCode(0))),
+ }),
+ ),
+ ),
+ );
+
+ const exit = yield* DesktopBackendManager.runBackendProcess({
+ ...baseConfig,
+ onOutputFailure: (error) => Deferred.succeed(reported, error).pipe(Effect.asVoid),
+ }).pipe(Effect.scoped, Effect.provide(Layer.merge(spawnerLayer, healthyHttpClientLayer)));
+ const error = yield* Deferred.await(reported);
+
+ assert.equal(exit.code.pipe(Option.getOrUndefined), 0);
+ if (error._tag !== "BackendProcessOutputReadError") {
+ return assert.fail(`Expected output read error, received ${error._tag}`);
+ }
+ assert.equal(error.executablePath, "/electron");
+ assert.equal(error.entryPath, "/server/bin.mjs");
+ assert.equal(error.cwd, "/server");
+ assert.equal(error.httpBaseUrl.href, "http://127.0.0.1:3773/");
+ assert.equal(error.pid, 123);
+ assert.equal(error.streamName, "stdout");
+ assert.strictEqual(error.cause, outputCause);
+ assert.equal(error.message, "Failed to read stdout from desktop backend process 123.");
+ assert.notInclude(error.message, "output-stream-secret-sentinel");
+ }),
+ );
+
+ it.effect("reports output handler failures separately from stream read failures", () =>
+ Effect.gen(function* () {
+ const chunk = new TextEncoder().encode("backend output");
+ const outputCause = new Error("output-handler-secret-sentinel");
+ const reported = yield* Deferred.make<DesktopBackendManager.BackendProcessOutputError>();
+ const spawnerLayer = Layer.succeed(
+ ChildProcessSpawner.ChildProcessSpawner,
+ ChildProcessSpawner.make(() =>
+ Effect.succeed(
+ makeProcess({
+ stdout: Stream.make(chunk),
+ exitCode: Deferred.await(reported).pipe(Effect.as(ChildProcessSpawner.ExitCode(0))),
+ }),
+ ),
+ ),
+ );
+
+ const exit = yield* DesktopBackendManager.runBackendProcess({
+ ...baseConfig,
+ onOutput: () => Effect.fail(outputCause),
+ onOutputFailure: (error) => Deferred.succeed(reported, error).pipe(Effect.asVoid),
+ }).pipe(Effect.scoped, Effect.provide(Layer.merge(spawnerLayer, healthyHttpClientLayer)));
+ const error = yield* Deferred.await(reported);
+
+ assert.equal(exit.code.pipe(Option.getOrUndefined), 0);
+ if (error._tag !== "BackendProcessOutputHandlingError") {
+ return assert.fail(`Expected output handling error, received ${error._tag}`);
+ }
+ assert.equal(error.executablePath, "/electron");
+ assert.equal(error.entryPath, "/server/bin.mjs");
+ assert.equal(error.cwd, "/server");
+ assert.equal(error.httpBaseUrl.href, "http://127.0.0.1:3773/");
+ assert.equal(error.pid, 123);
+ assert.equal(error.streamName, "stdout");
+ assert.equal(error.chunkByteLength, chunk.byteLength);
+ assert.strictEqual(error.cause, outputCause);
+ assert.equal(
+ error.message,
+ `Failed to handle ${chunk.byteLength} bytes from stdout of desktop backend process 123.`,
+ );
+ assert.notInclude(error.message, "output-handler-secret-sentinel");
+ }),
+ );
+
it.effect("retries HTTP readiness before reporting the backend ready", () =>
Effect.gen(function* () {
const requestUrls: Array<string> = [];
diff --git a/apps/desktop/src/backend/DesktopBackendManager.ts b/apps/desktop/src/backend/DesktopBackendManager.ts
index 8a40c9d21..d92f62d16 100644
--- a/apps/desktop/src/backend/DesktopBackendManager.ts
+++ b/apps/desktop/src/backend/DesktopBackendManager.ts
@@ -105,6 +105,39 @@ export class BackendProcessSpawnError extends Schema.TaggedErrorClass<BackendPro
}
}
+export class BackendProcessOutputReadError extends Schema.TaggedErrorClass<BackendProcessOutputReadError>()(
+ "BackendProcessOutputReadError",
+ {
+ ...backendProcessContextSchema,
+ pid: Schema.Number,
+ streamName: Schema.Literals(["stdout", "stderr"]),
+ cause: Schema.Defect(),
+ },
+) {
+ override get message(): string {
+ return `Failed to read ${this.streamName} from desktop backend process ${this.pid}.`;
+ }
+}
+
+export class BackendProcessOutputHandlingError extends Schema.TaggedErrorClass<BackendProcessOutputHandlingError>()(
+ "BackendProcessOutputHandlingError",
+ {
+ ...backendProcessContextSchema,
+ pid: Schema.Number,
+ streamName: Schema.Literals(["stdout", "stderr"]),
+ chunkByteLength: Schema.Number,
+ cause: Schema.Defect(),
+ },
+) {
+ override get message(): string {
+ return `Failed to handle ${this.chunkByteLength} bytes from ${this.streamName} of desktop backend process ${this.pid}.`;
+ }
+}
+
+export type BackendProcessOutputError =
+ | BackendProcessOutputReadError
+ | BackendProcessOutputHandlingError;
+
export class BackendProcessExitStatusError extends Schema.TaggedErrorClass<BackendProcessExitStatusError>()(
"BackendProcessExitStatusError",
{
@@ -146,7 +179,8 @@ interface RunBackendProcessOptions extends DesktopBackendStartConfig {
readonly onOutput?: (
streamName: BackendProcessOutputStream,
chunk: Uint8Array,
- ) => Effect.Effect<void>;
+ ) => Effect.Effect<void, Error>;
+ readonly onOutputFailure?: (error: BackendProcessOutputError) => Effect.Effect<void>;
}
export interface DesktopBackendSnapshot {
@@ -254,13 +288,41 @@ export const waitForHttpReady = Effect.fn("desktop.backendManager.waitForHttpRea
});
function drainBackendOutput(
+ context: BackendProcessContext & { readonly pid: number },
streamName: BackendProcessOutputStream,
stream: Stream.Stream<Uint8Array, PlatformError.PlatformError>,
- onOutput: (streamName: BackendProcessOutputStream, chunk: Uint8Array) => Effect.Effect<void>,
+ onOutput: (
+ streamName: BackendProcessOutputStream,
+ chunk: Uint8Array,
+ ) => Effect.Effect<void, Error>,
+ onOutputFailure: (error: BackendProcessOutputError) => Effect.Effect<void>,
): Effect.Effect<void> {
return stream.pipe(
- Stream.runForEach((chunk) => onOutput(streamName, chunk)),
- Effect.ignore,
+ Stream.mapError(
+ (cause) =>
+ new BackendProcessOutputReadError({
+ ...context,
+ streamName,
+ cause,
+ }),
+ ),
+ Stream.runForEach((chunk) =>
+ onOutput(streamName, chunk).pipe(
+ Effect.mapError(
+ (cause) =>
+ new BackendProcessOutputHandlingError({
+ ...context,
+ streamName,
+ chunkByteLength: chunk.byteLength,
+ cause,
+ }),
+ ),
+ ),
+ ),
+ Effect.catchTags({
+ BackendProcessOutputReadError: onOutputFailure,
+ BackendProcessOutputHandlingError: onOutputFailure,
+ }),
);
}
@@ -321,8 +383,28 @@ export const runBackendProcess = Effect.fn("runBackendProcess")(function* (
yield* options.onStarted?.(handle.pid) ?? Effect.void;
if (options.captureOutput) {
- yield* drainBackendOutput("stdout", handle.stdout, onOutput).pipe(Effect.forkScoped);
- yield* drainBackendOutput("stderr", handle.stderr, onOutput).pipe(Effect.forkScoped);
+ const outputContext = {
+ executablePath: options.executablePath,
+ entryPath: options.entryPath,
+ cwd: options.cwd,
+ httpBaseUrl: options.httpBaseUrl,
+ pid: Number(handle.pid),
+ };
+ const onOutputFailure = options.onOutputFailure ?? (() => Effect.void);
+ yield* drainBackendOutput(
+ outputContext,
+ "stdout",
+ handle.stdout,
+ onOutput,
+ onOutputFailure,
+ ).pipe(Effect.forkScoped);
+ yield* drainBackendOutput(
+ outputContext,
+ "stderr",
+ handle.stderr,
+ onOutput,
+ onOutputFailure,
+ ).pipe(Effect.forkScoped);
}
yield* waitForHttpReady({
executablePath: options.executablePath,
@@ -560,6 +642,7 @@ export const make = Effect.gen(function* () {
error,
}),
onOutput: (streamName, chunk) => backendOutputLog.writeOutputChunk(streamName, chunk),
+ onOutputFailure: (error) => logBackendManagerError(error.message, { error }),
}).pipe(
Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
Effect.provideService(HttpClient.HttpClient, httpClient),