debugger: wait for initial break before starting REPL

Create the initial-break deferred before resuming the target. A delayed
Debugger.paused notification can no longer arrive after the REPL prompt.

Resolve the deferred on client close when no pause occurs.

Signed-off-by: Matteo Collina <hello@matteocollina.com>

Author: mcollina

lib/internal/debugger/inspect_repl.js

@@ -386,7 +386,6 @@ function createRepl(inspector) {
   let exitDebugRepl;
   let contextLineNumber = 2;
   let initialBreakRender;
-  let waitForInitialBreakRender = false;
 
   function resetOnStart() {
     knownScripts = {};
@@ -897,13 +896,6 @@ function createRepl(inspector) {
       });
   }
 
-  function createInitialBreakRenderPromise(pauseRender) {
-    const { promise, resolve, reject } = PromiseWithResolvers();
-    initialBreakRender = promise;
-    PromisePrototypeThen(pauseRender, resolve, reject);
-    return promise;
-  }
-
   Debugger.on('paused', ({ callFrames, reason /* , hitBreakpoints */ }) => {
     if (process.env.NODE_INSPECT_RESUME_ON_START === '1' &&
         reason === 'Break on start') {
@@ -934,8 +926,10 @@ function createRepl(inspector) {
           print(`${header}\n${breakContext}`);
         }));
 
-    if (waitForInitialBreakRender && !initialBreakRender) {
-      createInitialBreakRenderPromise(pauseRender);
+    if (initialBreakRender) {
+      const { resolve, reject } = initialBreakRender;
+      initialBreakRender = null;
+      PromisePrototypeThen(pauseRender, resolve, reject);
     }
   });
 
@@ -1204,23 +1198,36 @@ function createRepl(inspector) {
   }
 
   async function initAfterStart() {
-    waitForInitialBreakRender =
+    const waitForInitialBreakRender =
       !!inspector.options?.script &&
       process.env.NODE_INSPECT_RESUME_ON_START !== '1';
-    await Runtime.enable();
-    await Profiler.enable();
-    await Profiler.setSamplingInterval({ interval: 100 });
-    await Debugger.enable();
-    await Debugger.setAsyncCallStackDepth({ maxDepth: 0 });
-    await Debugger.setBlackboxPatterns({ patterns: [] });
-    await Debugger.setPauseOnExceptions({ state: pauseOnExceptionState });
-    await restoreBreakpoints();
-    await Runtime.runIfWaitingForDebugger();
-    await PromiseResolve();
-    waitForInitialBreakRender = false;
-    const initialBreakRenderPromise = initialBreakRender;
-    initialBreakRender = null;
-    await initialBreakRenderPromise;
+    const initialBreak = waitForInitialBreakRender ?
+      PromiseWithResolvers() : null;
+    initialBreakRender = initialBreak;
+    const onClientClose = initialBreak?.resolve;
+    if (onClientClose) {
+      inspector.client.once('close', onClientClose);
+    }
+
+    try {
+      await Runtime.enable();
+      await Profiler.enable();
+      await Profiler.setSamplingInterval({ interval: 100 });
+      await Debugger.enable();
+      await Debugger.setAsyncCallStackDepth({ maxDepth: 0 });
+      await Debugger.setBlackboxPatterns({ patterns: [] });
+      await Debugger.setPauseOnExceptions({ state: pauseOnExceptionState });
+      await restoreBreakpoints();
+      await Runtime.runIfWaitingForDebugger();
+      await initialBreak?.promise;
+    } finally {
+      if (onClientClose) {
+        inspector.client.removeListener('close', onClientClose);
+      }
+      if (initialBreakRender === initialBreak) {
+        initialBreakRender = null;
+      }
+    }
   }
 
   return async function startRepl() {

test/parallel/test-debugger-run-restart-init.js

@@ -56,7 +56,8 @@ function evalCommand(repl, command) {
   });
 }
 
-async function assertCommandWaitsForInit(repl, command, gate, calls) {
+async function assertCommandWaitsForInit(
+  repl, command, initGate, pauseGate, renderGate, calls) {
   let settled = false;
   const promise = evalCommand(repl, command).then(() => {
     settled = true;
@@ -69,7 +70,23 @@ async function assertCommandWaitsForInit(repl, command, gate, calls) {
     `${command} resolved before post-connect initialization completed: ${calls}`,
   );
 
-  gate.resolve();
+  initGate.resolve();
+  await new Promise(setImmediate);
+  assert.strictEqual(
+    settled,
+    false,
+    `${command} resolved before the initial break was rendered: ${calls}`,
+  );
+
+  pauseGate.resolve();
+  await new Promise(setImmediate);
+  assert.strictEqual(
+    settled,
+    false,
+    `${command} resolved before the initial break render completed: ${calls}`,
+  );
+
+  renderGate.resolve();
   await promise;
   assert.strictEqual(settled, true);
 }
@@ -79,27 +96,67 @@ async function assertCommandWaitsForInit(repl, command, gate, calls) {
   const runGate = createGate();
   const restartGate = createGate();
   const gates = [null, runGate, restartGate];
+  const initialRenderGate = createGate();
+  const runRenderGate = createGate();
+  const restartRenderGate = createGate();
+  const renderGates = [initialRenderGate, runRenderGate, restartRenderGate];
   const inspector = {
     client: new EventEmitter(),
     domainNames: ['Debugger', 'HeapProfiler', 'Profiler', 'Runtime'],
+    options: { script: 'fixture.js' },
     stdin: new PassThrough(),
     stdout: new PassThrough(),
     run: common.mustCall(async () => {
       calls.push('inspector.run');
     }, 2),
+    print(text, addNewline = true) {
+      this.stdout.write(`${text}${addNewline ? '\n' : ''}`);
+    },
     suspendReplWhile(fn) {
       return fn();
     },
   };
 
+  const pausedEvent = {
+    callFrames: [{
+      functionName: '',
+      location: { scriptId: '1', lineNumber: 0, columnNumber: 0 },
+      scopeChain: [],
+    }],
+    reason: 'other',
+  };
   for (const domain of inspector.domainNames) {
     inspector[domain] = createAgent(domain, calls, gates);
   }
-
-  const repl = await createRepl(inspector)();
-
-  await assertCommandWaitsForInit(repl, 'run', runGate, calls);
-  await assertCommandWaitsForInit(repl, 'restart', restartGate, calls);
+  inspector.Debugger.getScriptSource = async () => {
+    await renderGates.shift().promise;
+    return { scriptSource: 'const value = 1;\n' };
+  };
+  const emitPause = common.mustCall(() => {
+    inspector.Debugger.emit('paused', pausedEvent);
+  }, 3);
+  const initialPauseGate = { resolve: emitPause };
+  const runPauseGate = { resolve: emitPause };
+  const restartPauseGate = { resolve: emitPause };
+
+  let replSettled = false;
+  const replPromise = createRepl(inspector)().then((repl) => {
+    replSettled = true;
+    return repl;
+  });
+  await new Promise(setImmediate);
+  assert.strictEqual(replSettled, false);
+  initialPauseGate.resolve();
+  await new Promise(setImmediate);
+  assert.strictEqual(replSettled, false);
+  initialRenderGate.resolve();
+  const repl = await replPromise;
+
+  await assertCommandWaitsForInit(
+    repl, 'run', runGate, runPauseGate, runRenderGate, calls);
+  await assertCommandWaitsForInit(
+    repl, 'restart', restartGate, restartPauseGate,
+    restartRenderGate, calls);
 
   assert.deepStrictEqual(
     calls.filter((call) => (