mt-lang 0.2.0

data/lib/milk_tea/dap/server/lldb_backend.rb

@@ -0,0 +1,380 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module DAP
+    class Server
+      module ServerLLDBBackend
+        private
+
+        def using_lldb_backend?
+          @session.backend_kind == "lldb-dap"
+        end
+
+        def start_lldb_backend(args)
+          return if @lldb_backend
+
+          adapter_path = args["adapterPath"].to_s
+          adapter_command = if adapter_path.empty?
+                               @default_adapter_command || ["lldb-dap"]
+                             else
+                               expanded = File.expand_path(adapter_path)
+                               expanded.end_with?(".rb") ? [RbConfig.ruby, expanded] : [expanded]
+                             end
+
+          @lldb_backend = if @backend_factory
+                             build_backend_via_factory(adapter_command)
+                           else
+                             Backends::LLDBDAP.new(
+                               adapter_command: adapter_command,
+                               on_event: method(:handle_backend_event),
+                               on_request: method(:handle_backend_request)
+                             )
+                           end
+          @lldb_backend.start!
+        end
+
+        def stop_lldb_backend
+          @backend_start_thread&.join(0.2)
+          @backend_start_thread = nil
+          @backend_auto_continue_after_configuration = false
+          @backend_stopped_thread_id = nil
+          @backend_pause_requested = false
+          @lldb_backend&.stop!
+        ensure
+          @lldb_backend = nil
+          @backend_initialized = false
+          @backend_capabilities = {}
+          reset_backend_configuration_ready
+          clear_debug_context
+        end
+
+        def ensure_backend_initialized(client_arguments)
+          return { "success" => true, "body" => @backend_capabilities } if @backend_initialized
+
+          response = backend_request("initialize", backend_initialize_arguments(client_arguments))
+          if response["success"]
+            @backend_initialized = true
+            @backend_capabilities = response["body"] || {}
+          end
+          response
+        end
+
+        def backend_request(command, arguments)
+          unless @lldb_backend
+            return {
+              "success" => false,
+              "message" => "lldb-dap backend is not running"
+            }
+          end
+
+          @lldb_backend.request(command, arguments)
+        end
+
+        def request_backend_terminate(arguments)
+          join_background_threads
+          terminate_response = backend_request("terminate", arguments)
+          return terminate_response if terminate_response["success"]
+          return terminate_response unless backend_terminate_unsupported?(terminate_response)
+
+          disconnect_response = backend_request("disconnect", arguments)
+          return disconnect_response unless disconnect_response["success"]
+
+          stop_lldb_backend
+          cleanup_tmp_dirs
+          unless @session.terminated?
+            @session.terminate!
+            write_event("terminated")
+          end
+          @session.request_exit!
+          disconnect_response
+        end
+
+        def start_backend_start_request(request, arguments)
+          @backend_start_thread = Thread.new do
+            Thread.current.report_on_exception = false if Thread.current.respond_to?(:report_on_exception=)
+
+            backend_response = backend_request(request["command"], arguments)
+            write_backend_response(request, backend_response)
+          rescue StandardError => e
+            write_error_response(request, "Internal error: #{e.message}")
+          ensure
+            @backend_start_thread = nil
+            @backend_configuration_mutex.synchronize do
+              @backend_configuration_condition.broadcast
+            end
+          end
+        end
+
+        def write_backend_response(request, backend_response)
+          if backend_response["success"]
+            write_response(request, backend_response["body"] || {})
+          else
+            write_error_response(request, backend_error_message(backend_response))
+          end
+        end
+
+        def backend_error_message(backend_response)
+          message = backend_response["message"].to_s
+          return message unless message.empty?
+
+          error_body = backend_response.dig("body", "error")
+          if error_body.is_a?(Hash)
+            format = error_body["format"].to_s
+            return format unless format.empty?
+
+            error_message = error_body["message"].to_s
+            return error_message unless error_message.empty?
+          end
+
+          "backend request failed"
+        end
+
+        def backend_terminate_unsupported?(backend_response)
+          message = backend_error_message(backend_response).downcase
+          message.include?("unknown request") || message.include?("unsupported command")
+        end
+
+        def build_backend_via_factory(adapter_command)
+          arity = @backend_factory.arity
+          if arity < 0 || arity >= 3
+            @backend_factory.call(adapter_command, method(:handle_backend_event), method(:handle_backend_request))
+          else
+            @backend_factory.call(adapter_command, method(:handle_backend_event))
+          end
+        end
+
+        def handle_backend_event(message)
+          event = message["event"].to_s
+          body = message["body"]
+
+          # The outer Milk Tea adapter owns the initialize/initialized handshake.
+          # Forwarding lldb-dap's own initialized event causes VS Code to repeat
+          # the configuration phase and emit a second configurationDone.
+          if event == "initialized"
+            mark_backend_configuration_ready
+            return
+          end
+
+          if event == "stopped"
+            pause_requested = @backend_pause_requested
+            body = rewrite_backend_stopped_event_body(body)
+            emit_pause_diagnostic_async(body) if pause_requested
+            @backend_stopped_thread_id = body && body["threadId"]
+            @backend_pause_requested = false
+            @last_forwarded_continued_signature = nil
+          elsif event == "continued"
+            signature = continued_event_signature(body)
+            return if signature && signature == @last_forwarded_continued_signature
+
+            @backend_stopped_thread_id = nil
+            @backend_pause_requested = false
+            @last_forwarded_continued_signature = signature
+          elsif event == "terminated" || event == "exited"
+            @backend_stopped_thread_id = nil
+            @backend_pause_requested = false
+            @last_forwarded_continued_signature = nil
+          end
+
+          write_event(event, body)
+
+          return unless event == "terminated" || event == "exited"
+
+          @session.terminate!
+        end
+
+        def handle_backend_request(message)
+          client_seq = @session.next_seq
+          queue = Queue.new
+          @client_request_mutex.synchronize do
+            @pending_client_responses[client_seq] = queue
+          end
+
+          write_message({
+            seq: client_seq,
+            type: "request",
+            command: message["command"],
+            arguments: message["arguments"] || {}
+          })
+
+          timeout_seconds = reverse_request_timeout
+          client_response = Timeout.timeout(timeout_seconds) { queue.pop }
+          build_backend_request_response(message, client_response)
+        rescue Timeout::Error
+          {
+            "seq" => @session.next_seq,
+            "type" => "response",
+            "request_seq" => message["seq"],
+            "success" => false,
+            "command" => message["command"],
+            "message" => format("client request timed out after %.1fs: %s", timeout_seconds, message["command"])
+          }
+        ensure
+          @client_request_mutex.synchronize do
+            @pending_client_responses.delete(client_seq) if defined?(client_seq)
+          end
+        end
+
+        def reverse_request_timeout
+          timeout = @reverse_request_timeout.to_f
+          timeout.positive? ? timeout : 15.0
+        rescue StandardError
+          15.0
+        end
+
+        def handle_client_response(message)
+          queue = @client_request_mutex.synchronize do
+            @pending_client_responses[message["request_seq"]]
+          end
+          queue&.push(message)
+        end
+
+        def build_backend_request_response(request, client_response)
+          response = {
+            "seq" => @session.next_seq,
+            "type" => "response",
+            "request_seq" => request["seq"],
+            "success" => !!client_response["success"],
+            "command" => request["command"]
+          }
+          response["body"] = client_response["body"] if client_response.key?("body")
+          response["message"] = client_response["message"] if client_response["message"]
+          response
+        end
+
+        def backend_configuration_ready?
+          @backend_configuration_mutex.synchronize { @backend_configuration_ready }
+        end
+
+        def backend_start_pending?
+          thread = @backend_start_thread
+          thread && thread.alive?
+        end
+
+        def backend_configuration_pending?
+          backend_start_pending? && !backend_configuration_ready?
+        end
+
+        def wait_for_backend_configuration_ready(timeout: 30)
+          return true unless backend_configuration_pending?
+
+          deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+
+          @backend_configuration_mutex.synchronize do
+            while @backend_start_thread&.alive? && !@backend_configuration_ready
+              remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+              return false if remaining <= 0
+
+              @backend_configuration_condition.wait(@backend_configuration_mutex, remaining)
+            end
+          end
+
+          true
+        end
+
+        def mark_backend_configuration_ready
+          @backend_configuration_mutex.synchronize do
+            @backend_configuration_ready = true
+            @backend_configuration_condition.broadcast
+          end
+        end
+
+        def reset_backend_configuration_ready
+          @backend_configuration_mutex.synchronize do
+            @backend_configuration_ready = false
+          end
+        end
+
+        def backend_thread_id_for_auto_continue
+          response = backend_request("threads", {})
+          return nil unless response["success"]
+
+          threads = response.dig("body", "threads")
+          return nil unless threads.is_a?(Array)
+
+          first_thread = threads.first
+          return nil unless first_thread.is_a?(Hash)
+
+          first_thread["id"]
+        end
+
+        def backend_initialize_arguments(client_arguments)
+          {
+            "adapterID" => "milk-tea",
+            "clientID" => "milk-tea",
+            "linesStartAt1" => true,
+            "columnsStartAt1" => true,
+            "pathFormat" => "path"
+          }.merge(client_arguments)
+        end
+
+        def filter_breakpoint_for_backend(breakpoint)
+          breakpoint.each_with_object({}) do |(key, value), result|
+            next if key.to_s == "id" || key.to_s == "verified"
+
+            result[key.to_s] = value
+          end
+        end
+
+        def backend_continue_arguments
+          thread_id = @backend_stopped_thread_id || backend_thread_id_for_auto_continue
+          return {} unless thread_id
+
+          { "threadId" => thread_id }
+        end
+
+        def continued_event_signature(body)
+          return nil unless body.is_a?(Hash)
+
+          [
+            normalize_reference_key(dap_value(body, "threadId")),
+            dap_value(body, "allThreadsContinued") == true,
+          ]
+        end
+
+        def rewrite_backend_stopped_event_body(body)
+          return body unless @backend_pause_requested
+          return body unless body.is_a?(Hash)
+
+          reason = dap_value(body, "reason").to_s
+          description = dap_value(body, "description").to_s
+          text = dap_value(body, "text").to_s
+          return body unless reason == "exception"
+          return body unless description.match?(/\bSIGSTOP\b/) || text.match?(/\bSIGSTOP\b/)
+
+          rewritten = body.dup
+          dap_set(rewritten, "reason", "pause")
+          dap_set(rewritten, "description", "Paused") if !description.empty? || rewritten.key?("description") || rewritten.key?(:description)
+          dap_set(rewritten, "text", "Paused") if !text.empty? || rewritten.key?("text") || rewritten.key?(:text)
+          rewritten
+        end
+
+        def effective_adapter_capabilities
+          capabilities = ADAPTER_CAPABILITIES.merge(
+            @backend_capabilities.transform_keys { |key| key.to_sym }
+          )
+          capabilities[:supportsSetVariable] = true if backend_supports_set_variable? || backend_supports_set_expression?
+
+          backend_filters = @backend_capabilities["exceptionBreakpointFilters"]
+          if backend_filters.is_a?(Array) && !backend_filters.empty?
+            capabilities[:exceptionBreakpointFilters] = backend_filters
+          end
+
+          capabilities
+        end
+
+        def backend_supports_set_variable?
+          capability_enabled?("supportsSetVariable")
+        end
+
+        def backend_supports_set_expression?
+          capability_enabled?("supportsSetExpression")
+        end
+
+        def capability_enabled?(name)
+          value = @backend_capabilities[name] || @backend_capabilities[name.to_sym]
+          !!value
+        end
+      end
+    end
+  end
+end

data/lib/milk_tea/dap/server/pause_diagnostics.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module DAP
+    class Server
+      module ServerPauseDiagnostics
+        private
+
+        def emit_pause_diagnostic_async(body)
+          return unless body.is_a?(Hash)
+
+          thread_id = normalize_reference_key(dap_value(body, "threadId"))
+          return if thread_id.nil?
+
+          track_background_thread(Thread.new(thread_id) do |diagnostic_thread_id|
+            stack_response = backend_request("stackTrace", {
+              "threadId" => diagnostic_thread_id,
+              "startFrame" => 0,
+              "levels" => 8
+            })
+
+            write_event("output", {
+              category: "console",
+              output: "#{pause_diagnostic_output(diagnostic_thread_id, stack_response)}\n"
+            })
+          rescue StandardError => e
+            write_event("output", {
+              category: "console",
+              output: "[milk-tea dap] pause top frame unavailable thread=#{diagnostic_thread_id}: #{e.message}\n"
+            })
+          end)
+        end
+
+        def pause_diagnostic_output(thread_id, stack_response)
+          unless stack_response["success"]
+            return "[milk-tea dap] pause focus unavailable thread=#{thread_id}: #{backend_error_message(stack_response)}"
+          end
+
+          frames = stack_response.dig("body", "stackFrames")
+          frames = frames.select { |candidate| candidate.is_a?(Hash) } if frames.is_a?(Array)
+          return "[milk-tea dap] pause focus unavailable thread=#{thread_id}: no stack frames" if !frames.is_a?(Array) || frames.empty?
+
+          raw_frame = frames.first
+          informative_index = frames.index { |frame| informative_pause_frame?(frame) }
+
+          unless informative_index
+            return "[milk-tea dap] pause top frame thread=#{thread_id}: #{pause_frame_summary(raw_frame, include_ip: true)}"
+          end
+
+          focus_frames = frames.drop(informative_index).first(3)
+          focus = focus_frames.map { |frame| pause_frame_summary(frame) }.join(" <- ")
+          raw_suffix = informative_index.zero? ? "" : " raw=#{pause_frame_summary(raw_frame, include_ip: true)}"
+
+          "[milk-tea dap] pause focus thread=#{thread_id}: #{focus}#{raw_suffix}"
+        end
+
+        def informative_pause_frame?(frame)
+          name = dap_value(frame, "name").to_s
+          return false if name.empty?
+          return false if name.match?(/\A___lldb_unnamed_symbol_/)
+          return false if %w[clock_nanosleep __nanosleep nanosleep].include?(name)
+
+          source = dap_value(frame, "source")
+          source_path = source.is_a?(Hash) ? dap_value(source, "path").to_s : ""
+
+          return true if source_path.start_with?("/usr/src/debug/")
+          return true if !source_path.empty? && !source_path.start_with?("/usr/lib/") && !source_path.start_with?("/lib/")
+
+          true
+        end
+
+        def pause_frame_summary(frame, include_ip: false)
+          frame_name = dap_value(frame, "name").to_s
+          frame_name = "(anonymous)" if frame_name.empty?
+
+          instruction_pointer = dap_value(frame, "instructionPointerReference").to_s
+          source = dap_value(frame, "source")
+          source_path = source.is_a?(Hash) ? dap_value(source, "path").to_s : ""
+          source_name = source.is_a?(Hash) ? dap_value(source, "name").to_s : ""
+          line = dap_value(frame, "line")
+
+          location_source = if !source_path.empty? && !source_path.include?("`")
+                              source_path
+                            elsif !source_name.empty?
+                              source_name
+                            elsif !source_path.empty?
+                              source_path
+                            else
+                              instruction_pointer
+                            end
+
+          location = if location_source.to_s.empty?
+                       "(unknown)"
+                     elsif line.to_i.positive? && !location_source.include?(":#{line}")
+                       "#{location_source}:#{line}"
+                     else
+                       location_source
+                     end
+
+          if include_ip && !instruction_pointer.empty? && location != instruction_pointer
+            "#{frame_name} @ #{location} ip=#{instruction_pointer}"
+          else
+            "#{frame_name} @ #{location}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/milk_tea/dap/server/utilities.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module DAP
+    class Server
+      module ServerUtilities
+        PERF_LOG_THRESHOLD_MS = 20
+
+        private
+
+        def register_handlers
+          @handlers["initialize"] = method(:handle_initialize)
+          @handlers["setBreakpoints"] = method(:handle_set_breakpoints)
+          @handlers["setFunctionBreakpoints"] = method(:handle_set_function_breakpoints)
+          @handlers["configurationDone"] = method(:handle_configuration_done)
+          @handlers["launch"] = method(:handle_launch)
+          @handlers["attach"] = method(:handle_attach)
+          @handlers["threads"] = method(:handle_threads)
+          @handlers["stackTrace"] = method(:handle_stack_trace)
+          @handlers["scopes"] = method(:handle_scopes)
+          @handlers["variables"] = method(:handle_variables)
+          @handlers["continue"] = method(:handle_continue)
+          @handlers["next"] = method(:handle_next)
+          @handlers["stepIn"] = method(:handle_step_in)
+          @handlers["stepOut"] = method(:handle_step_out)
+          @handlers["pause"] = method(:handle_pause)
+          @handlers["terminate"] = method(:handle_terminate)
+          @handlers["disconnect"] = method(:handle_disconnect)
+          @handlers["setExceptionBreakpoints"] = method(:handle_set_exception_breakpoints)
+          @handlers["evaluate"] = method(:handle_evaluate)
+          @handlers["setExpression"] = method(:handle_set_expression)
+          @handlers["setVariable"] = method(:handle_set_variable)
+          @handlers["dataBreakpointInfo"] = method(:handle_data_breakpoint_info)
+          @handlers["source"] = method(:handle_source)
+          @handlers["loadedSources"] = method(:handle_loaded_sources)
+          @handlers["restart"] = method(:handle_restart)
+          @handlers["cancel"] = method(:handle_cancel)
+        end
+
+        def process_message(message)
+          if message["type"] == "response"
+            handle_client_response(message)
+            return
+          end
+
+          return unless message["type"] == "request"
+
+          command = message["command"]
+          handler = @handlers[command]
+
+          unless command == "initialize" || @session.initialized?
+            write_error_response(message, "initialize request must be sent first")
+            return
+          end
+
+          t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+          if handler
+            handler.call(message)
+          elsif using_lldb_backend?
+            backend_response = backend_request(command, message["arguments"] || {})
+            write_backend_response(message, backend_response)
+          else
+            write_error_response(message, "Command '#{command}' is not supported by the process backend. Use the lldb-dap backend for full debugging features.")
+          end
+
+          elapsed_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0) * 1000).round(1)
+          if dap_perf_logging? && (dap_perf_verbose? || elapsed_ms > PERF_LOG_THRESHOLD_MS)
+            detail = dap_perf_verbose? ? " #{summarize_dap_arguments(message['arguments'])}" : ""
+            warn "[DAP perf] #{command} #{elapsed_ms}ms#{detail}"
+          end
+        rescue StandardError => e
+          write_error_response(message, "Internal error: #{e.message}")
+        end
+
+        def dap_perf_logging?
+          @dap_perf_logging ||= !ENV.fetch('MILK_TEA_DAP_PERF', nil).to_s.empty?
+        end
+
+        def dap_perf_verbose?
+          @dap_perf_verbose ||= ENV.fetch('MILK_TEA_DAP_PERF', nil).to_s == 'verbose'
+        end
+
+        def summarize_dap_arguments(arguments)
+          return "" unless arguments.is_a?(Hash)
+
+          keys = arguments.keys.map(&:to_s).sort
+          source_path = arguments.dig('source', 'path')
+          frame_id = arguments['frameId']
+          expression = arguments['expression']
+
+          bits = []
+          bits << "keys=#{keys.join(',')}" unless keys.empty?
+          bits << "source=#{source_path}" if source_path
+          bits << "frameId=#{frame_id}" if frame_id
+          bits << "expr=#{expression.inspect}" if expression
+          bits.join(' ')
+        rescue StandardError
+          ""
+        end
+
+        def dap_value(payload, key)
+          return nil unless payload.is_a?(Hash)
+
+          payload[key] || payload[key.to_sym]
+        end
+
+        def dap_set(payload, key, value)
+          return unless payload.is_a?(Hash)
+
+          if payload.key?(key)
+            payload[key] = value
+          elsif payload.key?(key.to_sym)
+            payload[key.to_sym] = value
+          else
+            payload[key] = value
+          end
+        end
+
+        def normalize_reference_key(value)
+          return nil if value.nil?
+          return value if value.is_a?(Integer)
+
+          text = value.to_s.strip
+          return text.to_i if text.match?(/\A\d+\z/)
+
+          text
+        end
+
+        def track_background_thread(thread)
+          @background_threads_mutex.synchronize do
+            @background_threads << thread
+          end
+          thread
+        end
+
+        def join_background_threads(timeout: 0.5)
+          threads = @background_threads_mutex.synchronize do
+            threads = @background_threads
+            @background_threads = []
+            threads
+          end
+
+          threads.each do |thread|
+            thread.join(timeout)
+          rescue StandardError
+            nil
+          end
+        end
+
+        def cleanup_tmp_dirs
+          @tmp_dirs.each do |dir|
+            FileUtils.remove_entry(dir) if File.exist?(dir)
+          end
+          @tmp_dirs.clear
+        end
+      end
+    end
+  end
+end