A self-improving RLM agent for coding workflows and long-running autonomous tasks.
Rust
fix(coding-agent): abort every in-flight bash command with its own controller (#1882)
Sebastian Müller853041ec88f5
diff --git a/packages/coding-agent/.changes/execute-bash-abort-controller.md b/packages/coding-agent/.changes/execute-bash-abort-controller.mdnew file mode 100644index 0000000000..c997cafa59--- /dev/null+++ b/packages/coding-agent/.changes/execute-bash-abort-controller.md@@ -0,0 +1 @@+- Fixed concurrent `execute_bash_and_wait` commands sharing one bash abort controller: each `executeBash` invocation now gets its own controller, so a finishing command no longer clears a still-running command's abort state and `abortBash` cancels every in-flight command.diff --git a/packages/coding-agent/src/core/agent-session.ts b/packages/coding-agent/src/core/agent-session.tsindex bc6a935e4d..c0e036cf1d 100644--- a/packages/coding-agent/src/core/agent-session.ts+++ b/packages/coding-agent/src/core/agent-session.ts@@ -1114,7 +1114,7 @@ export class AgentSession {/** Outcome disclosures whose session-file append failed; retained for context rebuilds. */private readonly _unpersistedOutcomes: CustomMessage[] = [];- private _bashAbortController: AbortController | undefined = undefined;+ private _bashAbortControllers = new Set<AbortController>();private _userBashRunning = false;private _userBashAbortRequested = false;private _pendingBashMessages: BashExecutionMessage[] = [];@@ -11086,7 +11086,9 @@ export class AgentSession {transient?: boolean;},): Promise<BashResult> {- this._bashAbortController = new AbortController();+ // Each invocation owns its controller so abortBash reaches every in-flight command.+ const abortController = new AbortController();+ this._bashAbortControllers.add(abortController);const prefix = this.settingsManager.getShellCommandPrefix();const shellPath = this.settingsManager.getShellPath();@@ -11099,7 +11101,7 @@ export class AgentSession {options?.operations ?? createLocalBashOperations({ shellPath }),{onChunk,- signal: this._bashAbortController.signal,+ signal: abortController.signal,},);@@ -11108,7 +11110,7 @@ export class AgentSession {}return result;} finally {- this._bashAbortController = undefined;+ this._bashAbortControllers.delete(abortController);this._notifySessionInputCheckpointChange();}}@@ -11279,14 +11281,17 @@ export class AgentSession {abortBash(): void {// A user bash command may not have spawned yet (extension dispatch in// progress); flag the request so runUserBash cancels before executing.- if (this._userBashRunning && this._bashAbortController === undefined) {+ // runUserBash clears the flag at each start, so a stale flag is harmless.+ if (this._userBashRunning) {this._userBashAbortRequested = true;}- this._bashAbortController?.abort();+ for (const controller of this._bashAbortControllers) {+ controller.abort();+ }}get isBashRunning(): boolean {- return this._bashAbortController !== undefined || this._userBashRunning;+ return this._bashAbortControllers.size > 0 || this._userBashRunning;}/** Whether there are pending bash messages waiting to be flushed */diff --git a/packages/coding-agent/test/ipython-provisioner.test.ts b/packages/coding-agent/test/ipython-provisioner.test.tsindex dd3a56afb6..ed32aab28e 100644--- a/packages/coding-agent/test/ipython-provisioner.test.ts+++ b/packages/coding-agent/test/ipython-provisioner.test.ts@@ -73,7 +73,7 @@ function writeFakeReplRuntime(markerPath: string): string {const fs = require("node:fs");const readline = require("node:readline");const emit = (event) => process.stdout.write(JSON.stringify(event) + "\\n");-emit({ event: "ready", protocol: 2, python: process.version });+emit({ event: "ready", protocol: 3, python: process.version });const input = readline.createInterface({ input: process.stdin });input.on("line", (line) => {const request = JSON.parse(line);diff --git a/packages/coding-agent/test/repl-kernel-protocol-corruption.test.ts b/packages/coding-agent/test/repl-kernel-protocol-corruption.test.tsindex 93bdfa0625..3e2ee779f3 100644--- a/packages/coding-agent/test/repl-kernel-protocol-corruption.test.ts+++ b/packages/coding-agent/test/repl-kernel-protocol-corruption.test.ts@@ -32,10 +32,10 @@ if (fs.existsSync(process.env.FAKE_REPL_CORRUPT_BOOT)) {process.stdout.write("BROKEN-BOOT\\n");} else if (fs.existsSync(process.env.FAKE_REPL_READY_WITH_GARBAGE)) {process.stdout.write(- JSON.stringify({ event: "ready", protocol: 2, python: process.version }) + "\\nBROKEN-WITH-READY\\n",+ JSON.stringify({ event: "ready", protocol: 3, python: process.version }) + "\\nBROKEN-WITH-READY\\n",);} else if (!(count > 1 && fs.existsSync(process.env.FAKE_REPL_DELAY_READY))) {- emit({ event: "ready", protocol: 2, python: process.version });+ emit({ event: "ready", protocol: 3, python: process.version });}const input = readline.createInterface({ input: process.stdin });input.on("line", (line) => {diff --git a/packages/coding-agent/test/suite/agent-session-bash-persistence.test.ts b/packages/coding-agent/test/suite/agent-session-bash-persistence.test.tsindex ef14362de3..ba061ef6df 100644--- a/packages/coding-agent/test/suite/agent-session-bash-persistence.test.ts+++ b/packages/coding-agent/test/suite/agent-session-bash-persistence.test.ts@@ -519,4 +519,88 @@ describe("AgentSession bash and persistence characterization", () => {releaseExec?.();await first;});++ it("keeps an earlier bash abortable after a concurrent later bash finishes", async () => {+ const harness = await createHarness();+ harnesses.push(harness);+ const abortableOperations: BashOperations = {+ exec: async (_command, _cwd, options) =>+ await new Promise<{ exitCode: number | null }>((_resolve, reject) => {+ options.signal?.addEventListener("abort", () => reject(new Error("aborted")), { once: true });+ }),+ };+ let releaseSecond: (() => void) | undefined;+ const secondOperations: BashOperations = {+ exec: async () => {+ await new Promise<void>((resolve) => {+ releaseSecond = resolve;+ });+ return { exitCode: 0 };+ },+ };++ const first = harness.session.executeBash("first", undefined, { operations: abortableOperations });+ const second = harness.session.executeBash("second", undefined, { operations: secondOperations });+ await new Promise((resolve) => setTimeout(resolve, 0));++ releaseSecond?.();+ const secondResult = await second;+ expect(secondResult.cancelled).toBe(false);++ // The earlier command stays running and abortable on its own controller.+ expect(harness.session.isBashRunning).toBe(true);+ harness.session.abortBash();+ const firstResult = await first;+ expect(firstResult.cancelled).toBe(true);+ expect(harness.session.isBashRunning).toBe(false);+ });++ it("cancels a pending user bash when abortBash arrives while another bash is in flight", async () => {+ const harness = await createHarness();+ harnesses.push(harness);+ const operations: BashOperations = {+ exec: async (_command, _cwd, options) =>+ await new Promise<{ exitCode: number | null }>((_resolve, reject) => {+ options.signal?.addEventListener("abort", () => reject(new Error("aborted")), { once: true });+ }),+ };++ // The user bash claims its slot first, then a concurrent wait-style+ // command (unguarded executeBash path) occupies the controller set while+ // the user bash is still in extension dispatch.+ const run = harness.session.runUserBash("echo should-not-run");+ const waitBash = harness.session.executeBash("wait", undefined, { operations });+ harness.session.abortBash();+ await run;+ expect((await waitBash).cancelled).toBe(true);++ const userBashMessage = harness.session.messages+ .slice()+ .reverse()+ .find((message) => message.role === "bashExecution" && message.command === "echo should-not-run");+ expect(userBashMessage?.role).toBe("bashExecution");+ if (userBashMessage?.role === "bashExecution") {+ expect(userBashMessage.cancelled).toBe(true);+ expect(userBashMessage.output).toBe("");+ }+ });++ it("aborts every in-flight bash command with abortBash", async () => {+ const harness = await createHarness();+ harnesses.push(harness);+ const makeAbortableOperations = (): BashOperations => ({+ exec: async (_command, _cwd, options) =>+ await new Promise<{ exitCode: number | null }>((_resolve, reject) => {+ options.signal?.addEventListener("abort", () => reject(new Error("aborted")), { once: true });+ }),+ });++ const first = harness.session.executeBash("first", undefined, { operations: makeAbortableOperations() });+ const second = harness.session.executeBash("second", undefined, { operations: makeAbortableOperations() });+ await new Promise((resolve) => setTimeout(resolve, 0));++ harness.session.abortBash();+ expect((await first).cancelled).toBe(true);+ expect((await second).cancelled).toBe(true);+ });});