Skip to content

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.md
new file mode 100644
index 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.ts
index 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.ts
index 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 | undefine
return 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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");