fix(mcp): timeout aborts Mocha runner so next run_test isn't blocked (#5551)

* fix(mcp): timeout aborts Mocha runner so next run_test isn't blocked

Previously the run_test / run_step_by_step timeout was just a setTimeout
that rejected the race promise — the Mocha runner kept going, the
recorder chain stayed queued, listeners stayed attached, and pause
sessions kept trapping. Subsequent run_test calls hit "Mocha instance
is currently running". cancel didn't help because pendingRunPromise was
only assigned in the paused branch, so it saw nothing to cancel.

- Assign pendingRunPromise immediately after runPromise creation in
  both run_test and run_step_by_step (was set only on pause).
- Wrap the Promise.race in try/catch + finally; clear the setTimeout
  and route timeout rejections through cancelRun(); return a clean
  status: "failed" payload to the client.
- Make cancelRun() actually abort: look up the Mocha runner via
  mocha._runner / _previousRunner / runner and call runner.abort();
  recorder.reset() to drop any queued tasks. Existing abortRun + pause
  release stay in place for stuck-on-pause cases.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* fix(mcp): drop unused runner.abort + recorder.reset hacks

The pause-and-abortRun chain alone is enough: resolveContinue releases
the current pauseSession, abortRun causes the next pauseNow-queued
pauseSession to reject inside setPauseHandler, the rejection propagates
through the recorder to codecept.run, and Mocha's runningNow clears
naturally. Reaching into mocha._runner / _previousRunner / .runner and
calling recorder.reset() were speculative — the timeout repro still
clears Mocha state without them.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* refactor(mcp): extract raceRunOutcome helper to dedupe run_test/run_step_by_step

Both tools had the same Promise.race + try/catch + finally + cancelRun
+ failure-response block. Extracted into raceRunOutcome(runPromise,
timeout) which returns a tagged outcome ({outcome:'paused'|'completed'}
or {outcome:'aborted', error}) so the caller branches once.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* refactor(mcp): rename raceRunOutcome → waitForTestResult, outcome → status

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: DavertMik <davert@testomat.io>
Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: 3 people

bin/mcp-server.js

@@ -412,6 +412,23 @@ async function cancelRun() {
   return true
 }
 
+async function waitForTestResult(runPromise, timeout) {
+  const pausedPromise = new Promise(resolve => pauseEvents.once('paused', () => resolve('paused')))
+  const completedPromise = runPromise.then(() => 'completed', () => 'completed')
+  let timeoutId
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => reject(new Error(`Timeout after ${timeout}ms`)), timeout)
+  })
+  try {
+    return { status: await Promise.race([completedPromise, pausedPromise, timeoutPromise]) }
+  } catch (err) {
+    await cancelRun()
+    return { status: 'aborted', error: err.message }
+  } finally {
+    clearTimeout(timeoutId)
+  }
+}
+
 async function closeBrowser() {
   if (!containerInitialized) return
   await cancelRun()
@@ -1025,18 +1042,15 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 throw err
               }
             })()
+            pendingRunPromise = runPromise
 
-            const pausedPromise = new Promise(resolve => pauseEvents.once('paused', () => resolve('paused')))
-            const completedPromise = runPromise.then(() => 'completed', () => 'completed')
-
-            const which = await Promise.race([
-              completedPromise,
-              pausedPromise,
-              new Promise((_, reject) => setTimeout(() => reject(new Error(`Timeout after ${timeout}ms`)), timeout)),
-            ])
+            const result = await waitForTestResult(runPromise, timeout)
+            if (result.status === 'aborted') {
+              await startShellSession()
+              return { content: [{ type: 'text', text: JSON.stringify({ status: 'failed', file: testFile, error: result.error }, null, 2) }] }
+            }
 
-            if (which === 'paused') {
-              pendingRunPromise = runPromise
+            if (result.status === 'paused') {
               const page = await gatherPageBrief()
               return {
                 content: [{
@@ -1046,6 +1060,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
               }
             }
 
+            pendingRunPromise = null
             const final = collectRunCompletion(runError?.message)
             await startShellSession()
             return { content: [{ type: 'text', text: JSON.stringify({ ...final, file: testFile }, null, 2) }] }
@@ -1121,18 +1136,15 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 throw err
               }
             })()
+            pendingRunPromise = runPromise
 
-            const pausedPromise = new Promise(resolve => pauseEvents.once('paused', () => resolve('paused')))
-            const completedPromise = runPromise.then(() => 'completed', () => 'completed')
-
-            const which = await Promise.race([
-              completedPromise,
-              pausedPromise,
-              new Promise((_, reject) => setTimeout(() => reject(new Error(`Timeout after ${timeout}ms`)), timeout)),
-            ])
+            const result = await waitForTestResult(runPromise, timeout)
+            if (result.status === 'aborted') {
+              await startShellSession()
+              return { content: [{ type: 'text', text: JSON.stringify({ status: 'failed', file: testFile, error: result.error }, null, 2) }] }
+            }
 
-            if (which === 'paused') {
-              pendingRunPromise = runPromise
+            if (result.status === 'paused') {
               const page = await gatherPageBrief()
               return {
                 content: [{
@@ -1142,6 +1154,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
               }
             }
 
+            pendingRunPromise = null
             const final = collectRunCompletion(runError?.message)
             await startShellSession()
             return { content: [{ type: 'text', text: JSON.stringify({ ...final, file: testFile }, null, 2) }] }