Creating a startDebugging reverse DAP request handler in lldb-vscode.

[ashgti]

Summary

Adds support for a reverse DAP request to startDebugging. The new request can be used to launch child processes from lldb scripts, for example it would be start forward to configure a debug configuration for a server and a client allowing you to launch both processes with a single debug configuraiton.

[ashgti]

Corrected a makefile reference.

[wallace]

pretty nice! Just a few nits, but other than that it's good to go

lldb/tools/lldb-vscode/lldb-vscode.cpp

1475

call it lldb-vscode instead of dap to have the same nomenclature all across

1478

1479

[wallace]

Please write an entry about this in the documentation of lldb-vscode

[ashgti]

Adding documentation to the lldb-vscode/README.md.

[ashgti]

In D153447#4439359, @wallace wrote:

Please write an entry about this in the documentation of lldb-vscode

Updated with some additional documentation in the lldb-vscode/README.md

[ashgti]

Enhancing the test coverage and fixing an issue when a reverse request is invoked a request from a DAP request handler.

[ashgti]

Cleaning up the runInTerminal test.

[ashgti]

Hi @wallace I updated the tests and discovered a deadlock with my implementation of the SendReverseRequest. I refactored the function and added some additional tests to cover this more thoroughly.

[ivanhernandez13]

lldb/tools/lldb-vscode/VSCode.cpp

569

Dead code?

[ashgti]

Removing a dead comment that is not needed.

[ivanhernandez13]

lldb/tools/lldb-vscode/VSCode.h

250–254

nit: Could you update this comment that is no longer accurate

[ashgti]

Fixing stale comment.

lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/vscode.py

def __init__(self, recv, send, init_commands, log_file=None):
             target=read_packet_thread, args=(self, log_file)
         )
         self.process_event_body = None
         self.exit_status = None
         self.initialize_body = None
         self.thread_stop_reasons = {}
         self.breakpoint_events = []
         self.progress_events = []
+        self.reverse_requests = []
         self.sequence = 1
         self.threads = None
         self.recv_thread.start()
         self.output_condition = threading.Condition()
         self.output = {}
         self.configuration_done_sent = False
         self.frame_scopes = {}
         self.init_commands = init_commands
def send_recv(self, command):
             response_or_request = self.recv_packet(filter_type=["response", "request"])
             if response_or_request is None:
                 desc = 'no response for "%s"' % (command["command"])
                 raise ValueError(desc)
             if response_or_request["type"] == "response":
                 self.validate_response(command, response_or_request)
                 return response_or_request
             else:
+                self.reverse_requests.append(response_or_request)
                 if response_or_request["command"] == "runInTerminal":
                     subprocess.Popen(
                         response_or_request["arguments"]["args"],
                         env=response_or_request["arguments"]["env"],
                     )
                     self.send_packet(
                         {
                             "type": "response",
                             "seq": -1,
                             "request_seq": response_or_request["seq"],
                             "success": True,
                             "command": "runInTerminal",
                             "body": {},
                         },
                         set_sequence=False,
                     )
+                elif response_or_request["command"] == "startDebugging":
+                    self.send_packet(
+                        {
+                            "type": "response",
+                            "seq": -1,
+                            "request_seq": response_or_request["seq"],
+                            "success": True,
+                            "command": "startDebugging",
+                            "body": {},
+                        },
+                        set_sequence=False,
+                    )
                 else:
-                    desc = 'unkonwn reverse request "%s"' % (
+                    desc = 'unknown reverse request "%s"' % (
                         response_or_request["command"]
                     )
                     raise ValueError(desc)
 
         return None
 
     def wait_for_event(self, filter=None, timeout=None):
         while True:

lldb/test/API/tools/lldb-vscode/runInTerminal/TestVSCode_runInTerminal.py

def test_runInTerminal(self):
             launch the inferior with the correct environment variables and arguments.
         """
         program = self.getBuildArtifact("a.out")
         source = "main.c"
         self.build_and_launch(
             program, runInTerminal=True, args=["foobar"], env=["FOO=bar"]
         )
 
+        self.assertEqual(
+            len(self.vscode.reverse_requests), 
+            1, 
+            "make sure we got a reverse request"
+        )
+
+        request = self.vscode.reverse_requests[0]
+        self.assertIn(self.lldbVSCodeExec, request["arguments"]["args"])
+        self.assertIn(program, request["arguments"]["args"])
+        self.assertIn("foobar", request["arguments"]["args"])
+        self.assertIn("FOO", request["arguments"]["env"])
+
         breakpoint_line = line_number(source, "// breakpoint")
 
         self.set_source_breakpoints(source, [breakpoint_line])
         self.continue_to_next_stop()
 
         # We verify we actually stopped inside the loop
         counter = int(self.vscode.get_local_variable_value("counter"))
         self.assertTrue(counter > 0)

lldb/test/API/tools/lldb-vscode/startDebugging/Makefile

+C_SOURCES := main.c
+
+include Makefile.rules

lldb/test/API/tools/lldb-vscode/startDebugging/TestVSCode_startDebugging.py

+"""
+Test lldb-vscode startDebugging reverse request
+"""
+
+
+import vscode
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+import lldbvscode_testcase
+
+
+class TestVSCode_startDebugging(lldbvscode_testcase.VSCodeTestCaseBase):
+    def test_startDebugging(self):
+        """
+            Tests the "startDebugging" reverse request. It makes sure that the IDE can
+            start a child debug session.
+        """
+        program = self.getBuildArtifact("a.out")
+        source = "main.c"
+        self.build_and_launch(program)
+
+        breakpoint_line = line_number(source, "// breakpoint")
+
+        self.set_source_breakpoints(source, [breakpoint_line])
+        self.continue_to_next_stop()
+        self.vscode.request_evaluate(
+            '`lldb-vscode startDebugging attach \'{"pid":321}\'', context='repl'
+        )
+
+        self.assertEqual(
+            len(self.vscode.reverse_requests), 
+            1, 
+            "make sure we got a reverse request"
+        )
+
+        request = self.vscode.reverse_requests[0]
+        self.assertEqual(request["arguments"]["configuration"]["pid"], 321)
+        self.assertEqual(request["arguments"]["request"], "attach")
 No newline at end of file

lldb/test/API/tools/lldb-vscode/startDebugging/main.c

+#include <stdio.h>
+
+int main(int argc, char const *argv[]) {
+  printf("example\n"); // breakpoint 1
+  return 0;
+}

lldb/tools/lldb-vscode/JSONUtils.cpp

 
 /// See
 /// https://microsoft.github.io/debug-adapter-protocol/specification#Reverse_Requests_RunInTerminal
 llvm::json::Object
 CreateRunInTerminalReverseRequest(const llvm::json::Object &launch_request,
                                   llvm::StringRef debug_adaptor_path,
                                   llvm::StringRef comm_file,
                                   lldb::pid_t debugger_pid) {
-  llvm::json::Object reverse_request;
-  reverse_request.try_emplace("type", "request");
-  reverse_request.try_emplace("command", "runInTerminal");
-
   llvm::json::Object run_in_terminal_args;
   // This indicates the IDE to open an embedded terminal, instead of opening the
   // terminal in a new window.
   run_in_terminal_args.try_emplace("kind", "integrated");
 
   auto launch_request_arguments = launch_request.getObject("arguments");
   // The program path must be the first entry in the "args" field
   std::vector<std::string> args = {
CreateRunInTerminalReverseRequest(const llvm::json::Object &launch_request,
   llvm::json::Object environment;
   for (const std::string &env : envs) {
     size_t index = env.find('=');
     environment.try_emplace(env.substr(0, index), env.substr(index + 1));
   }
   run_in_terminal_args.try_emplace("env",
                                    llvm::json::Value(std::move(environment)));
 
-  reverse_request.try_emplace(
-      "arguments", llvm::json::Value(std::move(run_in_terminal_args)));
-  return reverse_request;
+  return run_in_terminal_args;
 }
 
 // Keep all the top level items from the statistics dump, except for the
 // "modules" array. It can be huge and cause delay
 // Array and dictionary value will return as <key, JSON string> pairs
 void FilterAndGetValueForKey(const lldb::SBStructuredData data, const char *key,
                              llvm::json::Object &out) {
   lldb::SBStructuredData value = data.GetValueForKey(key);

lldb/tools/lldb-vscode/README.md

 
 # Table of Contents
 
 - [Introduction](#Introduction)
 - [Installation](#Installation-Visual-Studio-Code)
 - [Configurations](#configurations)
   - [Launch Configuration Settings](#launch-configuration-settings)
   - [Attach Configuration Settings](#attach-configuration-settings)
   - [Example configurations](#example-configurations)
     - [Launching](#launching)
     - [Attach to process using process ID](#attach-using-pid)
     - [Attach to process by name](#attach-by-name)
     - [Loading a core file](#loading-a-core-file)
+- [Custom Debugger Commands](#custom-debugger-commands)
+  - [startDebugging](#startDebugging)
 
 # Introduction
 
 The `lldb-vscode` tool creates a command line tool that implements the [Visual
 Studio Code Debug API](https://code.visualstudio.com/docs/extensionAPI/api-debugging).
 It can be installed as an extension for the Visual Studio Code and Nuclide IDE.
 The protocol is easy to run remotely and also can allow other tools and IDEs to
 get a full featured debugger with a well defined protocol.

 {
   "name": "Load coredump",
   "type": "lldb-vscode",
   "request": "attach",
   "coreFile": "/cores/123.core",
   "program": "/tmp/a.out"
 }
 ```
+
+# Custom debugger commands
+
+The `lldb-vscode` tool includes additional custom commands to support the Debug
+Adapter Protocol features.
+
+## startDebugging
+
+Using the command `lldb-vscode startDebugging` it is possible to trigger a
+reverse request to the client requesting a child debug session with the
+specified configuration. For example, this can be used to attached to forked or
+spawned processes. For more information see
+[Reverse Requests StartDebugging](https://microsoft.github.io/debug-adapter-protocol/specification#Reverse_Requests_StartDebugging).
+
+The custom command has the following format:
+
+```
+lldb-vscode startDebugging <launch|attach> <configuration>
+```
+
+This will launch a server and then request a child debug session for a client.
+
+```javascript
+{
+  "program": "server",
+  "postRunCommand": [
+    "lldb-vscode startDebugging launch '{\"program\":\"client\"}'"
+  ]
+}
+```

lldb/tools/lldb-vscode/VSCode.h

 //===-- VSCode.h ------------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_TOOLS_LLDB_VSCODE_VSCODE_H
 #define LLDB_TOOLS_LLDB_VSCODE_VSCODE_H
 
 #include "llvm/Config/llvm-config.h" // for LLVM_ON_UNIX
 
+#include <atomic>
 #include <condition_variable>
 #include <cstdio>
+#include <future>
 #include <iosfwd>
 #include <map>
 #include <optional>
 #include <set>
 #include <thread>
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"

 enum class OutputType { Console, Stdout, Stderr, Telemetry };
 
 enum VSCodeBroadcasterBits {
   eBroadcastBitStopEventThread = 1u << 0,
   eBroadcastBitStopProgressThread = 1u << 1
 };
 
 typedef void (*RequestCallback)(const llvm::json::Object &command);
+typedef void (*ResponseCallback)(llvm::Expected<llvm::json::Value> value);
 
 enum class PacketStatus {
   Success = 0,
   EndOfFile,
   JSONMalformed,
   JSONNotObject
 };
 
struct Variables {
   /// Insert a new \p variable.
   /// \return variableReference assigned to this expandable variable.
   int64_t InsertExpandableVariable(lldb::SBValue variable, bool is_permanent);
 
   /// Clear all scope variables and non-permanent expandable variables.
   void Clear();
 };
 
+struct StartDebuggingRequestHandler : public lldb::SBCommandPluginInterface {
+  bool DoExecute(lldb::SBDebugger debugger, char **command,
+                 lldb::SBCommandReturnObject &result) override;
+};
+
 struct VSCode {
   std::string debug_adaptor_path;
   InputStream input;
   OutputStream output;
   lldb::SBDebugger debugger;
   lldb::SBTarget target;
   Variables variables;
   lldb::SBBroadcaster broadcaster;
struct VSCode {
   std::vector<std::string> pre_run_commands;
   std::vector<std::string> exit_commands;
   std::vector<std::string> stop_commands;
   std::vector<std::string> terminate_commands;
   // A copy of the last LaunchRequest or AttachRequest so we can reuse its
   // arguments if we get a RestartRequest.
   std::optional<llvm::json::Object> last_launch_or_attach_request;
   lldb::tid_t focus_tid;
-  bool sent_terminated_event;
+  std::atomic<bool> sent_terminated_event;
   bool stop_at_entry;
   bool is_attach;
   // The process event thread normally responds to process exited events by
   // shutting down the entire adapter. When we're restarting, we keep the id of
   // the old process here so we can detect this case and keep running.
   lldb::pid_t restarting_process_id;
   bool configuration_done_sent;
-  uint32_t reverse_request_seq;
   std::map<std::string, RequestCallback> request_handlers;
   bool waiting_for_run_in_terminal;
   ProgressEventReporter progress_event_reporter;
   // Keep track of the last stop thread index IDs as threads won't go away
   // unless we send a "thread" event to indicate the thread exited.
   llvm::DenseSet<lldb::tid_t> thread_ids;
+  uint32_t reverse_request_seq;
+  std::mutex call_mutex;
+  std::map<int /* request_seq */, ResponseCallback /* reply handler */>
+      inflight_reverse_requests;
+  StartDebuggingRequestHandler start_debugging_request_handler;
+
   VSCode();
   ~VSCode();
   VSCode(const VSCode &rhs) = delete;
   void operator=(const VSCode &rhs) = delete;
   int64_t GetLineForPC(int64_t sourceReference, lldb::addr_t pc) const;
   ExceptionBreakpoint *GetExceptionBreakpoint(const std::string &filter);
   ExceptionBreakpoint *GetExceptionBreakpoint(const lldb::break_id_t bp_id);
 
struct VSCode {
   /// listeing for its breakpoint events.
   void SetTarget(const lldb::SBTarget target);
 
   const std::map<std::string, RequestCallback> &GetRequestHandlers();
 
   PacketStatus GetNextObject(llvm::json::Object &object);
   bool HandleObject(const llvm::json::Object &object);
 
-  /// Send a Debug Adapter Protocol reverse request to the IDE
+  llvm::Error Loop();
+
+  /// Send a Debug Adapter Protocol reverse request to the IDE.
   ///
-  /// \param[in] request
-  ///   The payload of the request to send.
+  /// \param[in] command
+  ///   The reverse request command.
   ///
-  /// \param[out] response
-  ///   The response of the IDE. It might be undefined if there was an error.
+  /// \param[in] arguments
+  ///   The reverse request arguements.
   ///
-  /// \return
-  ///   A \a PacketStatus object indicating the sucess or failure of the
-  ///   request.
-  PacketStatus SendReverseRequest(llvm::json::Object request,
-                                  llvm::json::Object &response);
+  /// \param[in] callback
+  ///   A callback to execute when the response arrives.
+  void SendReverseRequest(llvm::StringRef command, llvm::json::Value arguments,
+                          ResponseCallback callback);
 
   /// Registers a callback handler for a Debug Adapter Protocol request
   ///
   /// \param[in] request
   ///     The name of the request following the Debug Adapter Protocol
   ///     specification.
   ///
   /// \param[in] callback
   ///     The callback to execute when the given request is triggered by the

lldb/tools/lldb-vscode/VSCode.cpp

: broadcaster("lldb-vscode"),
            {"cpp_throw", "C++ Throw", lldb::eLanguageTypeC_plus_plus},
            {"objc_catch", "Objective-C Catch", lldb::eLanguageTypeObjC},
            {"objc_throw", "Objective-C Throw", lldb::eLanguageTypeObjC},
            {"swift_catch", "Swift Catch", lldb::eLanguageTypeSwift},
            {"swift_throw", "Swift Throw", lldb::eLanguageTypeSwift}}),
       focus_tid(LLDB_INVALID_THREAD_ID), sent_terminated_event(false),
       stop_at_entry(false), is_attach(false),
       restarting_process_id(LLDB_INVALID_PROCESS_ID),
-      configuration_done_sent(false), reverse_request_seq(0),
-      waiting_for_run_in_terminal(false),
+      configuration_done_sent(false), waiting_for_run_in_terminal(false),
       progress_event_reporter(
-          [&](const ProgressEvent &event) { SendJSON(event.ToJSON()); }) {
+          [&](const ProgressEvent &event) { SendJSON(event.ToJSON()); }),
+      reverse_request_seq(0) {
   const char *log_file_path = getenv("LLDBVSCODE_LOG");
 #if defined(_WIN32)
   // Windows opens stdout and stdin in text mode which converts \n to 13,10
   // while the value is just 10 on Darwin/Linux. Setting the file mode to binary
   // fixes this.
   int result = _setmode(fileno(stdout), _O_BINARY);
   assert(result);
   result = _setmode(fileno(stdin), _O_BINARY);
if (handler_pos != request_handlers.end()) {
       handler_pos->second(object);
       return true; // Success
     } else {
       if (log)
         *log << "error: unhandled command \"" << command.data() << std::endl;
       return false; // Fail
     }
   }
+
+  if (packet_type == "response") {
+    auto id = GetSigned(object, "request_seq", 0);
+    ResponseCallback response_handler = [](llvm::Expected<llvm::json::Value>) {
+      llvm::errs() << "Unhandled response\n";
+    };
+
+    {
+      std::lock_guard<std::mutex> locker(call_mutex);
+      auto inflight = inflight_reverse_requests.find(id);
+      if (inflight != inflight_reverse_requests.end()) {
+        response_handler = std::move(inflight->second);
+        inflight_reverse_requests.erase(inflight);
+      }
+    }
+
+    // Result should be given, use null if not.
+    if (GetBoolean(object, "success", false)) {
+      llvm::json::Value Result = nullptr;
+      if (auto *B = object.get("body")) {
+        Result = std::move(*B);
+      }
+      response_handler(Result);
+    } else {
+      llvm::StringRef message = GetString(object, "message");
+      if (message.empty()) {
+        message = "Unknown error, response failed";
+      }
+      response_handler(llvm::createStringError(
+          std::error_code(-1, std::generic_category()), message));
+    }
+
+    return true;
+  }
+
   return false;
 }
 
-PacketStatus VSCode::SendReverseRequest(llvm::json::Object request,
-                                        llvm::json::Object &response) {
-  request.try_emplace("seq", ++reverse_request_seq);
-  SendJSON(llvm::json::Value(std::move(request)));
-  while (true) {
-    PacketStatus status = GetNextObject(response);
-    const auto packet_type = GetString(response, "type");
-    if (packet_type == "response")
-      return status;
-    else {
-      // Not our response, we got another packet
-      HandleObject(response);
+llvm::Error VSCode::Loop() {
+  while (!sent_terminated_event) {
+    llvm::json::Object object;
+    lldb_vscode::PacketStatus status = GetNextObject(object);
+
+    if (status == lldb_vscode::PacketStatus::EndOfFile) {
+      break;
     }
+
+    if (status != lldb_vscode::PacketStatus::Success) {
+      return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                     "failed to send packet");
     }
-  return PacketStatus::EndOfFile;
+
+    if (!HandleObject(object)) {
+      return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                     "unhandled packet");
+    }
+  }
+
+  return llvm::Error::success();
+}
+
+void VSCode::SendReverseRequest(llvm::StringRef command,
+                                llvm::json::Value arguments,
+                                ResponseCallback callback) {
+  int64_t id;
+  {
+    std::lock_guard<std::mutex> locker(call_mutex);
+    id = ++reverse_request_seq;
+    inflight_reverse_requests.emplace(id, std::move(callback));
+  }
+
+  SendJSON(llvm::json::Object{
+      {"type", "request"},
+      {"seq", id},
+      {"command", command},
+      {"arguments", std::move(arguments)},
+  });
 }
 
 void VSCode::RegisterRequestCallback(std::string request,
                                      RequestCallback callback) {
   request_handlers[request] = callback;
 }
 
 lldb::SBError VSCode::WaitForProcessToStop(uint32_t seconds) {
int64_t Variables::InsertExpandableVariable(lldb::SBValue variable,
   int64_t var_ref = GetNewVariableRefence(is_permanent);
   if (is_permanent)
     expandable_permanent_variables.insert(std::make_pair(var_ref, variable));
   else
     expandable_variables.insert(std::make_pair(var_ref, variable));
   return var_ref;
 }
 
+bool StartDebuggingRequestHandler::DoExecute(
+    lldb::SBDebugger debugger, char **command,
+    lldb::SBCommandReturnObject &result) {
+  // Command format like: `startDebugging <launch|attach> <configuration>`
+  if (!command) {
+    result.SetError("Invalid use of startDebugging");
+    result.SetStatus(lldb::eReturnStatusFailed);
+    return false;
+  }
+
+  if (!command[0] || llvm::StringRef(command[0]).empty()) {
+    result.SetError("startDebugging request type missing.");
+    result.SetStatus(lldb::eReturnStatusFailed);
+    return false;
+  }
+
+  if (!command[1] || llvm::StringRef(command[1]).empty()) {
+    result.SetError("configuration missing.");
+    result.SetStatus(lldb::eReturnStatusFailed);
+    return false;
+  }
+
+  llvm::StringRef request{command[0]};
+  std::string raw_configuration{command[1]};
+
+  int i = 2;
+  while (command[i]) {
+    raw_configuration.append(" ").append(command[i]);
+  }
+
+  llvm::Expected<llvm::json::Value> configuration =
+      llvm::json::parse(raw_configuration);
+
+  if (!configuration) {
+    llvm::Error err = configuration.takeError();
+    std::string msg =
+        "Failed to parse json configuration: " + llvm::toString(std::move(err));
+    result.SetError(msg.c_str());
+    result.SetStatus(lldb::eReturnStatusFailed);
+    return false;
+  }
+
+  g_vsc.SendReverseRequest(
+      "startDebugging",
+      llvm::json::Object{{"request", request},
+                         {"configuration", std::move(*configuration)}},
+      [](llvm::Expected<llvm::json::Value> value) {
+        if (!value) {
+          llvm::Error err = value.takeError();
+          llvm::errs() << "reverse start debugging request failed: "
+                       << llvm::toString(std::move(err)) << "\n";
+        }
+      });
+
+  result.SetStatus(lldb::eReturnStatusSuccessFinishNoResult);
+
+  return true;
+}
+
 } // namespace lldb_vscode

lldb/tools/lldb-vscode/lldb-vscode.cpp

void request_initialize(const llvm::json::Object &request) {
   auto arguments = request.getObject("arguments");
   // sourceInitFile option is not from formal DAP specification. It is only
   // used by unit tests to prevent sourcing .lldbinit files from environment
   // which may affect the outcome of tests.
   bool source_init_file = GetBoolean(arguments, "sourceInitFile", true);
 
   g_vsc.debugger =
       lldb::SBDebugger::Create(source_init_file, log_cb, nullptr);
+  auto cmd = g_vsc.debugger.GetCommandInterpreter().AddMultiwordCommand(
+      "lldb-vscode", nullptr);
+  cmd.AddCommand(
+      "startDebugging", &g_vsc.start_debugging_request_handler,
+      "Sends a startDebugging request from the debug adapter to the client to "
+      "start a child debug session of the same type as the caller.");
+
   g_vsc.progress_event_thread = std::thread(ProgressEventThreadFunction);
 
   // Start our event thread so we can receive events from the debugger, target,
   // process and more.
   g_vsc.event_thread = std::thread(EventThreadFunction);
 
   llvm::json::Object response;
   FillResponse(request, response);
void request_initialize(const llvm::json::Object &request) {
   body.try_emplace("supportsProgressReporting", true);
   // The debug adapter supports 'logMessage' in breakpoint.
   body.try_emplace("supportsLogPoints", true);
 
   response.try_emplace("body", std::move(body));
   g_vsc.SendJSON(llvm::json::Value(std::move(response)));
 }
 
-llvm::Error request_runInTerminal(const llvm::json::Object &launch_request) {
+llvm::Error request_runInTerminal(const llvm::json::Object &launch_request,
+                                  const uint64_t timeout_seconds) {
   g_vsc.is_attach = true;
   lldb::SBAttachInfo attach_info;
 
   llvm::Expected<std::shared_ptr<FifoFile>> comm_file_or_err =
       CreateRunInTerminalCommFile();
   if (!comm_file_or_err)
     return comm_file_or_err.takeError();
   FifoFile &comm_file = *comm_file_or_err.get();
 
   RunInTerminalDebugAdapterCommChannel comm_channel(comm_file.m_path);
 
   lldb::pid_t debugger_pid = LLDB_INVALID_PROCESS_ID;
 #if !defined(_WIN32)
   debugger_pid = getpid();
 #endif
   llvm::json::Object reverse_request = CreateRunInTerminalReverseRequest(
       launch_request, g_vsc.debug_adaptor_path, comm_file.m_path, debugger_pid);
-  llvm::json::Object reverse_response;
-  lldb_vscode::PacketStatus status =
-      g_vsc.SendReverseRequest(reverse_request, reverse_response);
-  if (status != lldb_vscode::PacketStatus::Success)
-    return llvm::createStringError(llvm::inconvertibleErrorCode(),
-                                   "Process cannot be launched by the IDE. %s",
-                                   comm_channel.GetLauncherError().c_str());
+  g_vsc.SendReverseRequest("runInTerminal", std::move(reverse_request),
+                           [](llvm::Expected<llvm::json::Value> value) {
+                             if (!value) {
+                               llvm::Error err = value.takeError();
+                               llvm::errs()
+                                   << "runInTerminal request failed: "
+                                   << llvm::toString(std::move(err)) << "\n";
+                             }
+                           });
 
   if (llvm::Expected<lldb::pid_t> pid = comm_channel.GetLauncherPid())
     attach_info.SetProcessID(*pid);
   else
     return pid.takeError();
 
   g_vsc.debugger.SetAsync(false);
   lldb::SBError error;
if (GetBoolean(arguments, "shellExpandArguments", false))
     flags |= lldb::eLaunchFlagShellExpandArguments;
   const bool detachOnError = GetBoolean(arguments, "detachOnError", false);
   launch_info.SetDetachOnError(detachOnError);
   launch_info.SetLaunchFlags(flags | lldb::eLaunchFlagDebug |
                              lldb::eLaunchFlagStopAtEntry);
   const uint64_t timeout_seconds = GetUnsigned(arguments, "timeout", 30);
 
   if (GetBoolean(arguments, "runInTerminal", false)) {
-    if (llvm::Error err = request_runInTerminal(request))
+    if (llvm::Error err = request_runInTerminal(request, timeout_seconds))
       error.SetErrorString(llvm::toString(std::move(err)).c_str());
   } else if (launchCommands.empty()) {
     // Disable async events so the launch will be successful when we return from
     // the launch call and the launch will happen synchronously
     g_vsc.debugger.SetAsync(false);
     g_vsc.target.Launch(launch_info, error);
     g_vsc.debugger.SetAsync(true);
   } else {
if (portno != -1) {
     } else {
       return EXIT_FAILURE;
     }
   } else {
     g_vsc.input.descriptor = StreamDescriptor::from_file(fileno(stdin), false);
     g_vsc.output.descriptor = StreamDescriptor::from_file(new_stdout_fd, false);
   }
 
-  while (!g_vsc.sent_terminated_event) {
-    llvm::json::Object object;
-    lldb_vscode::PacketStatus status = g_vsc.GetNextObject(object);
-    if (status == lldb_vscode::PacketStatus::EndOfFile)
-      break;
-    if (status != lldb_vscode::PacketStatus::Success)
-      return 1; // Fatal error
-
-    if (!g_vsc.HandleObject(object))
-      return 1;
+  bool CleanExit = true;
+  if (auto Err = g_vsc.Loop()) {
+    if (g_vsc.log)
+      *g_vsc.log << "Transport Error: " << llvm::toString(std::move(Err))
+                 << "\n";
+    CleanExit = false;
   }
 
-  return EXIT_SUCCESS;
+  return CleanExit ? EXIT_SUCCESS : EXIT_FAILURE;
 }