Skip to content

A self-improving RLM agent for coding workflows and long-running autonomous tasks.

Rust

refactor(coding-agent): await in-flight bash completion during daemon close (#1858)

Sebastian Müller6322b7bb977c
diff --git a/packages/coding-agent/.changes/await-daemon-bash-end.md b/packages/coding-agent/.changes/await-daemon-bash-end.md
new file mode 100644
index 0000000000..e74b823eb4
--- /dev/null
+++ b/packages/coding-agent/.changes/await-daemon-bash-end.md
@@ -0,0 +1 @@
+- Made daemon shutdown wait for Bash completion without polling.
diff --git a/packages/coding-agent/src/modes/daemon/active-session-state.ts b/packages/coding-agent/src/modes/daemon/active-session-state.ts
index fe062253ce..b0f9b3f648 100644
--- a/packages/coding-agent/src/modes/daemon/active-session-state.ts
+++ b/packages/coding-agent/src/modes/daemon/active-session-state.ts
@@ -40,6 +40,7 @@ export interface ActiveSessionState {
extensionUiRequests: Map<string, ActiveSessionExtensionUiRequest>;
eventGeneration: string;
lastEventSequence: DaemonEventSequence;
+ inFlightBash?: Promise<void>;
unsubscribe?: () => void;
/** Latest background status summary, surfaced in the agents view. */
summaryState?: AgentStatus;
diff --git a/packages/coding-agent/src/modes/daemon/daemon-mode.ts b/packages/coding-agent/src/modes/daemon/daemon-mode.ts
index e5f4b5e51b..c8601b2a3b 100644
--- a/packages/coding-agent/src/modes/daemon/daemon-mode.ts
+++ b/packages/coding-agent/src/modes/daemon/daemon-mode.ts
@@ -4178,28 +4178,23 @@ export class AgentDaemon {
}
// Respond before completion (bash can outlive the client request
// timeout); output and completion stream via bash_* session events.
- void state.runtime.session
- .runUserBash(command.command, {
- excludeFromContext: command.excludeFromContext,
- transient: command.transient,
- runId: command.runId,
- })
- .catch((error) => {
- this.broadcastToSession(
- state,
- failure(undefined, "execute_bash", error, serializeDaemonError(error)),
- );
- });
+ const bash = state.runtime.session.runUserBash(command.command, {
+ excludeFromContext: command.excludeFromContext,
+ transient: command.transient,
+ runId: command.runId,
+ });
+ state.inFlightBash = Promise.allSettled([state.inFlightBash, bash]).then(() => undefined);
+ void bash.catch((error) => {
+ this.broadcastToSession(state, failure(undefined, "execute_bash", error, serializeDaemonError(error)));
+ });
return success(command.id, "execute_bash");
}
case "execute_bash_and_wait": {
const state = this.getSessionState(command.activeSessionId);
- return success(
- command.id,
- "execute_bash_and_wait",
- await state.runtime.session.executeBash(command.command),
- );
+ const bash = state.runtime.session.executeBash(command.command);
+ state.inFlightBash = Promise.allSettled([state.inFlightBash, bash]).then(() => undefined);
+ return success(command.id, "execute_bash_and_wait", await bash);
}
case "abort_bash": {
@@ -6230,14 +6225,12 @@ export class AgentDaemon {
}
private async abortBashForClose(state: ActiveSessionState): Promise<void> {
- if (!state.runtime.session.isBashRunning) {
+ const session = state.runtime.session;
+ if (!session.isBashRunning) {
return;
}
- state.runtime.session.abortBash();
- const deadline = Date.now() + UPDATE_RESTART_ABORT_BASH_TIMEOUT_MS;
- while (state.runtime.session.isBashRunning && Date.now() < deadline) {
- await delay(50);
- }
+ session.abortBash();
+ await Promise.race([state.inFlightBash ?? Promise.resolve(), delay(UPDATE_RESTART_ABORT_BASH_TIMEOUT_MS)]);
}
private async closeSessionOnce(
diff --git a/packages/coding-agent/test/daemon-mode.test.ts b/packages/coding-agent/test/daemon-mode.test.ts
index 7ae54b7cc5..d41f4ec651 100644
--- a/packages/coding-agent/test/daemon-mode.test.ts
+++ b/packages/coding-agent/test/daemon-mode.test.ts
@@ -70,6 +70,103 @@ describe("daemon mode helpers", () => {
expect(client.id).toBe("public-client");
});
+ it("waits for overlapping Bash commands with a bounded close deadline", async () => {
+ vi.useFakeTimers();
+ try {
+ const daemon = new AgentDaemon("/tmp/unused-daemon.sock", {
+ defaultSessionConfig: { agentDir: "/tmp", cwd: "/tmp" },
+ createRuntime: vi.fn(),
+ });
+ const internals = daemon as unknown as {
+ sessions: Map<string, ActiveSessionState>;
+ handleCommand(client: DaemonSocketClient, command: DaemonCommand): Promise<DaemonOutbound | undefined>;
+ abortBashForClose(state: ActiveSessionState): Promise<void>;
+ };
+
+ let resolveFirstBash!: () => void;
+ let resolveSecondBash!: () => void;
+ const firstBash = new Promise<void>((resolve) => {
+ resolveFirstBash = resolve;
+ });
+ const secondBash = new Promise<void>((resolve) => {
+ resolveSecondBash = resolve;
+ });
+ let isBashRunning = false;
+ const abortBash = vi.fn();
+ const state = makeState("active");
+ state.runtime = {
+ ...state.runtime,
+ session: {
+ get isBashRunning() {
+ return isBashRunning;
+ },
+ runUserBash: vi.fn(() => {
+ isBashRunning = true;
+ return firstBash;
+ }),
+ executeBash: vi.fn(() => secondBash),
+ abortBash,
+ },
+ } as never;
+ internals.sessions.set(state.activeSessionId, state);
+ const client = makeClient("client", state.activeSessionId);
+
+ await internals.handleCommand(client, {
+ id: "first",
+ type: "execute_bash",
+ activeSessionId: state.activeSessionId,
+ command: "first",
+ });
+ const secondResponse = internals.handleCommand(client, {
+ id: "second",
+ type: "execute_bash_and_wait",
+ activeSessionId: state.activeSessionId,
+ command: "second",
+ });
+ resolveSecondBash();
+ await secondResponse;
+
+ const closing = internals.abortBashForClose(state);
+ expect(await Promise.race([closing.then(() => "done"), Promise.resolve("pending")])).toBe("pending");
+ resolveFirstBash();
+ await expect(closing).resolves.toBeUndefined();
+ expect(abortBash).toHaveBeenCalledOnce();
+
+ let isStalledBashRunning = false;
+ const abortStalledBash = vi.fn();
+ const stalledState = makeState("stalled");
+ stalledState.runtime = {
+ ...stalledState.runtime,
+ session: {
+ get isBashRunning() {
+ return isStalledBashRunning;
+ },
+ runUserBash: vi.fn(() => {
+ isStalledBashRunning = true;
+ return new Promise<void>(() => {});
+ }),
+ abortBash: abortStalledBash,
+ },
+ } as never;
+ internals.sessions.set(stalledState.activeSessionId, stalledState);
+ await internals.handleCommand(makeClient("stalled-client", stalledState.activeSessionId), {
+ id: "stalled",
+ type: "execute_bash",
+ activeSessionId: stalledState.activeSessionId,
+ command: "stalled",
+ });
+
+ const stalledClose = internals.abortBashForClose(stalledState);
+ await vi.advanceTimersByTimeAsync(4999);
+ expect(await Promise.race([stalledClose.then(() => "done"), Promise.resolve("pending")])).toBe("pending");
+ await vi.advanceTimersByTimeAsync(1);
+ await expect(stalledClose).resolves.toBeUndefined();
+ expect(abortStalledBash).toHaveBeenCalledOnce();
+ } finally {
+ vi.useRealTimers();
+ }
+ });
+
it("normalizes daemon session names before validation and persistence", async () => {
const daemon = new AgentDaemon("/tmp/unused-daemon.sock", {
defaultSessionConfig: { agentDir: "/tmp", cwd: "/tmp" },