A self-improving RLM agent for coding workflows and long-running autonomous tasks.
Rust
fix(coding-agent): surface the real spawn error when the daemon cannot launch a worker (#1918)
Sebastian Müller9f5edc192cfe
diff --git a/packages/coding-agent/.changes/emfile-worker-spawn.md b/packages/coding-agent/.changes/emfile-worker-spawn.mdnew file mode 100644index 0000000000..09ae1ac673--- /dev/null+++ b/packages/coding-agent/.changes/emfile-worker-spawn.md@@ -0,0 +1 @@+- Fixed daemon session create when the worker process cannot be spawned (e.g. EMFILE from fd exhaustion): the create now fails with the real spawn error plus a resident-worker/ulimit hint, and the CLI prints a one-line error instead of crashing with a TypeError stack dump.diff --git a/packages/coding-agent/src/main.ts b/packages/coding-agent/src/main.tsindex 8740776ec5..3c1a744f57 100644--- a/packages/coding-agent/src/main.ts+++ b/packages/coding-agent/src/main.ts@@ -74,7 +74,7 @@ import { isTelemetryEnabled } from "./core/telemetry.js";import { printTimings, resetTimings, time } from "./core/timings.js";import { runMigrations, showDeprecationWarnings } from "./migrations.js";import { isDaemonCatalogProcess, runDaemonCatalogProcess } from "./modes/daemon/daemon-catalog-process.js";-import { deserializeDaemonError } from "./modes/daemon/daemon-errors.js";+import { DaemonSessionCreateError, deserializeDaemonCreateError } from "./modes/daemon/daemon-errors.js";import { collectDaemonClientEnv, collectDaemonLaunchEnv } from "./modes/daemon/daemon-protocol.js";import {DAEMON_WORKER_ACTIVE_SESSION_ID_ENV,@@ -1006,7 +1006,7 @@ async function createDaemonClientConnection(options: {launchEnv: collectDaemonLaunchEnv(),});if (!response.success) {- throw deserializeDaemonError(response);+ throw deserializeDaemonCreateError(response);}if (!isDaemonSessionSummary(response.data)) {throw new Error("Daemon returned an invalid create response");@@ -1452,17 +1452,27 @@ export async function main(args: string[], options?: MainOptions) {// no DeferredAgentConnection is needed to avoid creating it up front.const isFreshDefaultSession =!activeDaemonSessionSummary && !getInteractiveDaemonSessionPath(parsed, sessionManager);- const { connection, summary } = await createDaemonClientConnection({- socketPath: daemonSocketPath,- config: defaultSessionConfig,- activeSessionId: activeDaemonSessionSummary- ? getDaemonSummaryActiveSessionId(activeDaemonSessionSummary)- : undefined,- sessionPath: getInteractiveDaemonSessionPath(parsed, sessionManager),- clientOwned: parsed.noSession,- noSession: parsed.noSession,- supportsExtensionUi: true,- });+ let connection: DaemonAgentConnection;+ let summary: SessionSummary;+ try {+ ({ connection, summary } = await createDaemonClientConnection({+ socketPath: daemonSocketPath,+ config: defaultSessionConfig,+ activeSessionId: activeDaemonSessionSummary+ ? getDaemonSummaryActiveSessionId(activeDaemonSessionSummary)+ : undefined,+ sessionPath: getInteractiveDaemonSessionPath(parsed, sessionManager),+ clientOwned: parsed.noSession,+ noSession: parsed.noSession,+ supportsExtensionUi: true,+ }));+ } catch (error) {+ if (error instanceof DaemonSessionCreateError) {+ console.error(chalk.red(`Error: ${error.message}`));+ process.exit(1);+ }+ throw error;+ }const agentConnection: AgentConnection = connection;const attachModelFallbackMessage = isFreshDefaultSession? startupModel.modelFallbackMessage@@ -1544,7 +1554,7 @@ export async function main(args: string[], options?: MainOptions) {supportsExtensionUi: appMode === "rpc",}));} catch (error) {- if (error instanceof SessionAlreadyActiveError) {+ if (error instanceof SessionAlreadyActiveError || error instanceof DaemonSessionCreateError) {console.error(chalk.red(`Error: ${error.message}`));process.exit(1);}diff --git a/packages/coding-agent/src/modes/daemon/daemon-errors.ts b/packages/coding-agent/src/modes/daemon/daemon-errors.tsindex 207f8e15a8..966810ee84 100644--- a/packages/coding-agent/src/modes/daemon/daemon-errors.ts+++ b/packages/coding-agent/src/modes/daemon/daemon-errors.ts@@ -20,6 +20,20 @@ export function serializeDaemonError(error: unknown): DaemonErrorInfo | undefinereturn undefined;}+export class DaemonSessionCreateError extends Error {+ constructor(message: string) {+ super(message);+ this.name = "DaemonSessionCreateError";+ }+}++/** Wraps untyped create failures so the CLI prints one line instead of rethrowing. */+export function deserializeDaemonCreateError(response: Extract<DaemonResponse, { success: false }>): Error {+ const error = deserializeDaemonError(response);+ if (response.errorInfo) return error;+ return new DaemonSessionCreateError(error.message);+}+export function deserializeDaemonError(response: Extract<DaemonResponse, { success: false }>): Error {const { errorInfo } = response;if (errorInfo?.code === "missing_session_cwd") {diff --git a/packages/coding-agent/src/modes/daemon/daemon-supervisor.ts b/packages/coding-agent/src/modes/daemon/daemon-supervisor.tsindex 5ba0b3e67c..2c45674070 100644--- a/packages/coding-agent/src/modes/daemon/daemon-supervisor.ts+++ b/packages/coding-agent/src/modes/daemon/daemon-supervisor.ts@@ -2546,6 +2546,15 @@ export class DaemonSupervisor {worker.transientCreateCommand = undefined;}+ private describeWorkerSpawnFailure(error: Error): Error {+ const errno = (error as NodeJS.ErrnoException).code;+ const hint =+ errno === "EMFILE" || errno === "ENFILE"+ ? ` (${this.workers.size} resident session workers are holding file descriptors; stop unused sessions or raise the open-file limit (ulimit -n))`+ : "";+ return new Error(`Failed to spawn session worker: ${error.message}${hint}`);+ }+private async launchWorker(command: DaemonCreateCommand,existing?: ResidentWorker,@@ -2601,12 +2610,21 @@ export class DaemonSupervisor {: () => {};child.once("close", detachWorkerStderr);const childClosed = new Promise<void>((resolveClose) => child.once("close", () => resolveClose()));+ let spawnFailure: Error | undefined;+ const spawnSettled = new Promise<void>((resolveSpawn) => {+ child.once("spawn", () => resolveSpawn());+ child.once("error", (error) => {+ spawnFailure = error instanceof Error ? error : new Error(String(error));+ resolveSpawn();+ });+ });child.on("error", (error) => {this.log(`Session worker ${workerId} process error: ${error instanceof Error ? error.message : String(error)}`,);});- const startupGate = child.stdio[WORKER_STARTUP_GATE_FD];+ // A failed spawn (e.g. EMFILE) leaves child.stdio undefined.+ const startupGate = child.stdio?.[WORKER_STARTUP_GATE_FD];const previousDescriptor = existing?.descriptor;const previousIntentionalStop = existing?.intentionalStop;let descriptorAssigned = false;@@ -2614,6 +2632,10 @@ export class DaemonSupervisor {let childProcessStartId: string | undefined;let worker: ResidentWorker;try {+ await spawnSettled;+ if (spawnFailure) {+ throw this.describeWorkerSpawnFailure(spawnFailure);+ }if (!child.pid) {throw new Error("Failed to obtain daemon session worker pid");}diff --git a/packages/coding-agent/test/daemon-errors.test.ts b/packages/coding-agent/test/daemon-errors.test.tsnew file mode 100644index 0000000000..b0d56037c6--- /dev/null+++ b/packages/coding-agent/test/daemon-errors.test.ts@@ -0,0 +1,27 @@+import { describe, expect, it } from "vitest";+import { SessionAlreadyActiveError } from "../src/core/session-lease.js";+import { DaemonSessionCreateError, deserializeDaemonCreateError } from "../src/modes/daemon/daemon-errors.js";++describe("deserializeDaemonCreateError", () => {+ it("wraps generic create failures so the CLI boundary prints one line instead of rethrowing", () => {+ const error = deserializeDaemonCreateError({+ type: "response",+ command: "create",+ success: false,+ error: "Failed to spawn session worker: spawn node EMFILE",+ });+ expect(error).toBeInstanceOf(DaemonSessionCreateError);+ expect(error.message).toContain("EMFILE");+ });++ it("preserves typed daemon errors for their dedicated boundaries", () => {+ const error = deserializeDaemonCreateError({+ type: "response",+ command: "create",+ success: false,+ error: "session already active",+ errorInfo: { code: "session_already_active", sessionPath: "/tmp/session.jsonl" },+ });+ expect(error).toBeInstanceOf(SessionAlreadyActiveError);+ });+});diff --git a/packages/coding-agent/test/daemon-supervisor-monitor.test.ts b/packages/coding-agent/test/daemon-supervisor-monitor.test.tsindex 5f5412e5d7..6e64fe9856 100644--- a/packages/coding-agent/test/daemon-supervisor-monitor.test.ts+++ b/packages/coding-agent/test/daemon-supervisor-monitor.test.ts@@ -38,6 +38,7 @@ const workerLaunchTestState = vi.hoisted(() => ({gateMarkerPath: "",tsxCliPath: "",cliEntrypoint: "",+ spawnFailureCode: undefined as string | undefined,spawned: [] as Array<{ child: ChildProcess; args: readonly string[] }>,}));@@ -48,6 +49,24 @@ vi.mock("node:child_process", async (importOriginal) => {return {...actual,spawn(command: string, args: readonly string[], options: SpawnOptions): ChildProcess {+ const failureCode = workerLaunchTestState.spawnFailureCode;+ if (failureCode) {+ // Node's failed-spawn shape: no pid, stdio undefined, "error" then "close".+ const failing = Object.assign(new EventEmitter(), {+ pid: undefined,+ stdio: undefined,+ stderr: undefined,+ unref: () => {},+ }) as unknown as ChildProcess;+ process.nextTick(() => {+ failing.emit(+ "error",+ Object.assign(new Error(`spawn ${command} ${failureCode}`), { code: failureCode }),+ );+ failing.emit("close", null, null);+ });+ return failing;+ }const child = actual.spawn(command, args, options);if (workerLaunchTestState.capture) {workerLaunchTestState.spawned.push({ child, args });@@ -288,6 +307,7 @@ describe("daemon worker supervisor monitoring", () => {workerLaunchTestState.gateMarkerPath = "";workerLaunchTestState.tsxCliPath = "";workerLaunchTestState.cliEntrypoint = "";+ workerLaunchTestState.spawnFailureCode = undefined;workerLaunchTestState.spawned.length = 0;vi.useRealTimers();for (const registryDir of supervisorRegistryDirs) {@@ -635,6 +655,39 @@ describe("daemon worker supervisor monitoring", () => {expect(child?.exitCode !== null || child?.signalCode !== null).toBe(true);});+ it("fails the create with the spawn error when the worker process cannot be spawned", async () => {+ workerLaunchTestState.spawnFailureCode = "EMFILE";+ const root = mkdtempSync(join(tmpdir(), "prime-supervisor-spawn-failure-test-"));+ const descriptorDir = join(root, "descriptors");+ mkdirSync(descriptorDir, { recursive: true });+ supervisorRegistryDirs.add(root);+ const workers = new Map<string, unknown>();+ const supervisor = Object.assign(Object.create(DaemonSupervisor.prototype), {+ ...createSupervisorSnapshotState(),+ defaultSessionConfig: { cwd: root, agentDir: root },+ descriptorDir,+ socketPath: join(root, "supervisor.sock"),+ workers,+ assertRecoveryAllowed: vi.fn(async () => {}),+ log: vi.fn(),+ }) as {+ launchWorker(command: { type: "create"; config: { cwd: string; agentDir: string } }): Promise<unknown>;+ };++ await expect(supervisor.launchWorker({ type: "create", config: { cwd: root, agentDir: root } })).rejects.toThrow(+ /EMFILE.*resident session workers.*ulimit -n/s,+ );+ expect(workers.size).toBe(0);++ workerLaunchTestState.spawnFailureCode = "ENOENT";+ const enoentFailure = await supervisor+ .launchWorker({ type: "create", config: { cwd: root, agentDir: root } })+ .then(() => undefined)+ .catch((error: Error) => error);+ expect(enoentFailure?.message).toContain("ENOENT");+ expect(enoentFailure?.message).not.toContain("ulimit");+ });+it("commits the startup marker after durable worker publication", async () => {const root = mkdtempSync(join(tmpdir(), "prime-supervisor-committed-gate-test-"));const descriptorDir = join(root, "descriptors");