debugger: await initialization after run and restart

Ensure the debugger CLI waits for post-connect initialization before
resolving the run and restart commands. This prevents tests and users
from observing a prompt before Runtime.runIfWaitingForDebugger() has
released the new debuggee.
Refs: #61762
Signed-off-by: Kamat, Trivikram <16024985+trivikr@users.noreply.github.com>
Assisted-by: openai:gpt-5.5
PR-URL: #63607
Refs: #61762
Reviewed-By: Daijiro Wachi <daijiro.wachi@gmail.com>

Author: trivikr

lib/internal/debugger/inspect_repl.js

@@ -945,6 +945,11 @@ function createRepl(inspector) {
 );
 });
 
+asyncfunctionrunAndInit(){
+awaitinspector.run();
+awaitinitAfterStart();
+}
+
 functioninitializeContext(context){
 ArrayPrototypeForEach(inspector.domainNames,(domain)=>{
 ObjectDefineProperty(context,domain,{
@@ -962,15 +967,15 @@ function createRepl(inspector) {
 },
 
 getrun(){
-returninspector.run();
+returnrunAndInit();
 },
 
 getkill(){
 returninspector.killChild();
 },
 
 getrestart(){
-returninspector.run();
+returnrunAndInit();
 },
 
 getcont(){
@@ -1196,9 +1201,6 @@ function createRepl(inspector) {
 inspector.client.on('close',()=>{
 resetOnStart();
 });
-inspector.client.on('ready',()=>{
-initAfterStart();
-});
 
 // Init once for the initial connection
 awaitinitAfterStart();

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

@@ -0,0 +1,119 @@
+// Flags: --expose-internals
+'use strict';
+
+constcommon=require('../common');
+
+common.skipIfInspectorDisabled();
+
+constassert=require('assert');
+const{ EventEmitter }=require('events');
+const{ PassThrough }=require('stream');
+constcreateRepl=require('internal/debugger/inspect_repl');
+
+functioncreateGate(){
+letresolve;
+constpromise=newPromise((res)=>{
+resolve=res;
+});
+return{ promise, resolve };
+}
+
+functioncreateAgent(domain,calls,gates){
+constagent=newEventEmitter();
+constmethod=(name)=>async()=>{
+calls.push(`${domain}.${name}`);
+if(domain==='Runtime'&&name==='runIfWaitingForDebugger'){
+constgate=gates.shift();
+if(gate){
+awaitgate.promise;
+}
+}
+};
+
+agent.enable=method('enable');
+agent.setSamplingInterval=method('setSamplingInterval');
+agent.setAsyncCallStackDepth=method('setAsyncCallStackDepth');
+agent.setBlackboxPatterns=method('setBlackboxPatterns');
+agent.setPauseOnExceptions=method('setPauseOnExceptions');
+agent.runIfWaitingForDebugger=method('runIfWaitingForDebugger');
+returnagent;
+}
+
+functionevalCommand(repl,command){
+returnnewPromise((resolve,reject)=>{
+repl.eval(
+command,
+repl.context,
+'debugger-repl-test',
+(error,result)=>{
+if(error){
+reject(error);
+}else{
+resolve(result);
+}
+},
+);
+});
+}
+
+asyncfunctionassertCommandWaitsForInit(repl,command,gate,calls){
+letsettled=false;
+constpromise=evalCommand(repl,command).then(()=>{
+settled=true;
+});
+
+awaitnewPromise(setImmediate);
+assert.strictEqual(
+settled,
+false,
+`${command} resolved before post-connect initialization completed: ${calls}`,
+);
+
+gate.resolve();
+awaitpromise;
+assert.strictEqual(settled,true);
+}
+
+(async()=>{
+constcalls=[];
+construnGate=createGate();
+constrestartGate=createGate();
+constgates=[null,runGate,restartGate];
+constinspector={
+client: newEventEmitter(),
+domainNames: ['Debugger','HeapProfiler','Profiler','Runtime'],
+stdin: newPassThrough(),
+stdout: newPassThrough(),
+run: common.mustCall(async()=>{
+calls.push('inspector.run');
+},2),
+suspendReplWhile(fn){
+returnfn();
+},
+};
+
+for(constdomainofinspector.domainNames){
+inspector[domain]=createAgent(domain,calls,gates);
+}
+
+constrepl=awaitcreateRepl(inspector)();
+
+awaitassertCommandWaitsForInit(repl,'run',runGate,calls);
+awaitassertCommandWaitsForInit(repl,'restart',restartGate,calls);
+
+assert.deepStrictEqual(
+calls.filter((call)=>(
+call==='inspector.run'||
+call==='Runtime.runIfWaitingForDebugger'
+)),
+[
+'Runtime.runIfWaitingForDebugger',
+'inspector.run',
+'Runtime.runIfWaitingForDebugger',
+'inspector.run',
+'Runtime.runIfWaitingForDebugger',
+],
+);
+
+repl.close();
+})().then(common.mustCall());