mbeditor 0.11.0 → 0.12.0

data/app/services/mbeditor/model_graph_service.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+module Mbeditor
+  # Builds a graph of the host app's ActiveRecord models and the associations
+  # between them, for the Models sidebar tab.
+  #
+  # Reads the associations by *reflection* rather than by parsing model files.
+  # mbeditor already runs inside the host app, so `reflect_on_all_associations`
+  # is right there — and it resolves `class_name:`, `through:`, polymorphic and
+  # inverse sides correctly, which regex or AST parsing of `has_many` lines
+  # silently gets wrong. (ruby-lsp cannot help here: its index models constants
+  # and methods, not associations.)
+  #
+  # Deliberately never touches the database connection. Reflections are pure
+  # metadata, so this works on an app whose database isn't running or migrated;
+  # column counts are only filled in when a connection happens to be live.
+  class ModelGraphService
+    # Rails' own models — ActiveStorage, ActionText, SolidQueue, schema
+    # migrations — are not what you opened this tab to look at.
+    IGNORED_NAMESPACES = %w[
+      ActiveRecord ActiveStorage ActionText ActionMailbox
+      SolidQueue SolidCache SolidCable
+    ].freeze
+
+    MAX_MODELS = 300
+
+    # Only the first few columns travel: the diagram box shows that many and the
+    # full list is a click away in the schema modal, which fetches its own data
+    # from /model_schema.
+    MAX_COLUMNS_SENT = 8
+
+    class << self
+      def call(workspace_root)
+        root = workspace_root.to_s
+        fingerprint = fingerprint_for(root)
+
+        cached = MUTEX.synchronize { @cache }
+        return cached[:payload] if cached && cached[:fingerprint] == fingerprint && cached[:root] == root
+
+        payload = build(root)
+        payload[:fingerprint] = fingerprint
+        MUTEX.synchronize { @cache = { root: root, fingerprint: fingerprint, payload: payload } }
+        write_artifacts(root, payload)
+        payload
+      end
+
+      # Only needed for an explicit refresh: ordinary saves are picked up by
+      # the fingerprint below, so there is no file-change hook to keep in sync.
+      def invalidate(_root = nil)
+        MUTEX.synchronize { @cache = nil }
+        nil
+      end
+
+      # A cheap stand-in for "have the models changed": the newest mtime and the
+      # file count across the model and migration directories. Avoids
+      # eager-loading the app just to decide whether the cache is stale.
+      def fingerprint_for(root)
+        dirs = [File.join(root, "app", "models"), File.join(root, "db", "migrate")]
+        newest = 0
+        count = 0
+        dirs.each do |dir|
+          next unless File.directory?(dir)
+
+          Dir.glob(File.join(dir, "**", "*.rb")).each do |f|
+            count += 1
+            mtime = File.mtime(f).to_i
+            newest = mtime if mtime > newest
+          end
+        end
+        "#{newest}:#{count}"
+      rescue StandardError
+        "unknown"
+      end
+
+      private
+
+      MUTEX = Mutex.new
+      private_constant :MUTEX
+
+      def build(root)
+        unless defined?(::ActiveRecord::Base)
+          return unavailable("This app does not use ActiveRecord, so there are no models to graph.")
+        end
+
+        eager_load!
+        classes = model_classes
+        return unavailable("No ActiveRecord models found in this application.") if classes.empty?
+
+        models = classes.first(MAX_MODELS).map { |klass| describe_model(klass, root) }
+        known = models.map { |m| m[:name] }.to_set
+
+        {
+          ok: true,
+          models: models,
+          # Edges to classes outside the graph (a gem's model, or a typo in
+          # class_name:) would render as arrows into nowhere.
+          edges: models.flat_map { |m| m.delete(:edges) }.select { |e| known.include?(e[:to]) }.uniq,
+          truncated: classes.length > MAX_MODELS,
+          generatedAt: Time.now.utc.iso8601
+        }
+      rescue StandardError => e
+        unavailable("Could not read the model graph: #{e.class}: #{e.message}")
+      end
+
+      def unavailable(message)
+        { ok: false, error: message, models: [], edges: [], generatedAt: Time.now.utc.iso8601 }
+      end
+
+      # In development the host app is lazily loaded, so most models are not
+      # constants yet. This is the one genuinely expensive step.
+      def eager_load!
+        Rails.application.eager_load! if defined?(Rails) && Rails.respond_to?(:application) && Rails.application
+      rescue StandardError => e
+        # A model that raises on load shouldn't cost you the whole diagram —
+        # whatever did load is still worth drawing.
+        Rails.logger.warn("[mbeditor] eager_load for the model graph failed: #{e.class}: #{e.message}") if defined?(Rails)
+      end
+
+      def model_classes
+        ::ActiveRecord::Base.descendants.reject do |klass|
+          klass.name.nil? ||
+            klass.abstract_class? ||
+            IGNORED_NAMESPACES.any? { |ns| klass.name.start_with?("#{ns}::") }
+        end.sort_by(&:name)
+      rescue StandardError
+        []
+      end
+
+      def describe_model(klass, root)
+        columns = column_list(klass)
+        {
+          name: klass.name,
+          table: safe(-> { klass.table_name }),
+          columns: columns.first(MAX_COLUMNS_SENT),
+          columnCount: columns.length,
+          superclass: klass.superclass&.name,
+          file: model_file(klass, root),
+          edges: associations_for(klass)
+        }
+      end
+
+      # Needs a live database connection, so it degrades to an empty list rather
+      # than failing: the graph is still worth drawing against a database that
+      # isn't running or migrated.
+      def column_list(klass)
+        klass.columns.map { |c| { name: c.name, type: c.type.to_s } }
+      rescue StandardError
+        []
+      end
+
+      # Where the class was defined, made workspace-relative so the editor can
+      # open it. Models outside the workspace (a gem, or an engine) get no file
+      # and simply aren't clickable.
+      def model_file(klass, root)
+        location = Object.const_source_location(klass.name)
+        path = location && location.first
+        return nil unless path
+
+        prefix = root.end_with?("/") ? root : "#{root}/"
+        path.start_with?(prefix) ? path.delete_prefix(prefix) : nil
+      rescue StandardError
+        nil
+      end
+
+      def associations_for(klass)
+        klass.reflect_on_all_associations.filter_map do |reflection|
+          # A polymorphic belongs_to has no single target class — there is no
+          # edge to draw.
+          next if safe(-> { reflection.polymorphic? })
+
+          target = safe(-> { reflection.class_name })
+          next if target.nil?
+
+          {
+            from: klass.name,
+            to: target,
+            macro: reflection.macro.to_s,
+            name: reflection.name.to_s,
+            through: safe(-> { reflection.options[:through]&.to_s })
+          }
+        end
+      rescue StandardError
+        []
+      end
+
+      # Reflection can raise for half-configured associations; one bad
+      # association must not take out the whole graph.
+      def safe(callable)
+        callable.call
+      rescue StandardError
+        nil
+      end
+
+      # The user asked for a file in tmp. The JSON is what the editor reads back
+      # if it wants to; the .mmd is a Mermaid ER diagram that GitHub, VS Code
+      # and mermaid.live all render, for when you want a prettier picture than
+      # the sidebar draws.
+      def write_artifacts(root, payload)
+        dir = File.join(root, "tmp")
+        return unless File.directory?(dir)
+
+        File.write(File.join(dir, "mbeditor_model_graph.json"), JSON.pretty_generate(payload))
+        File.write(File.join(dir, "mbeditor_model_graph.mmd"), to_mermaid(payload))
+      rescue StandardError => e
+        Rails.logger.debug("[mbeditor] could not write model graph artifacts: #{e.message}") if defined?(Rails)
+      end
+
+      MERMAID_CARDINALITY = {
+        "belongs_to" => "}o--||",
+        "has_one" => "||--o|",
+        "has_many" => "||--o{",
+        "has_and_belongs_to_many" => "}o--o{"
+      }.freeze
+
+      def to_mermaid(payload)
+        lines = ["erDiagram"]
+        payload[:models].each { |m| lines << "  #{mermaid_id(m[:name])} {" << "  }" }
+        payload[:edges].each do |e|
+          arrow = MERMAID_CARDINALITY.fetch(e[:macro], "||--||")
+          label = e[:through] ? "#{e[:name]} (through #{e[:through]})" : e[:name]
+          lines << %(  #{mermaid_id(e[:from])} #{arrow} #{mermaid_id(e[:to])} : "#{label}")
+        end
+        "#{lines.join("\n")}\n"
+      end
+
+      # Mermaid entity names can't contain ::
+      def mermaid_id(name)
+        name.to_s.gsub("::", "_")
+      end
+    end
+  end
+end

data/app/services/mbeditor/presence_registry.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Mbeditor
+  # Who is currently connected for collaborative editing. Thread-safe and
+  # in-memory, modelled on CollaborationDocStore (Mutex + monotonic clock).
+  #
+  # This exists because the clients cannot maintain an accurate roster between
+  # themselves. The original protocol relayed one "here"/"leave" event per
+  # participant and every client merged those into its own roster, which meant a
+  # single dropped or missed message — a peer's browser killed outright, a relay
+  # failure, or simply reloading your own page at the moment someone else closed
+  # theirs — left a participant in your roster permanently, with no expiry to
+  # reclaim it. That is not cosmetic: the roster gates collaboration, so one ghost
+  # kept persistent undo disabled and external on-disk changes suppressed for the
+  # rest of the session, for a peer who was not there.
+  #
+  # The server already knows exactly who is subscribed — Action Cable calls
+  # `unsubscribed` on a clean close and on its own connection timeout — so it is
+  # the only party that can answer this correctly. Every broadcast now carries the
+  # complete roster and clients replace theirs wholesale, so a dropped message
+  # costs one stale interval rather than a permanent phantom. No TTL sweep: an
+  # entry outlives its connection only if the process dies, which takes the
+  # registry with it.
+  module PresenceRegistry
+    module_function
+
+    MUTEX = Mutex.new
+    private_constant :MUTEX
+
+    # Fields a participant publishes about itself. Anything else in the payload is
+    # dropped — this is relayed to every other client, so the shape is a boundary.
+    # `seq` is the sender's own heartbeat counter, echoed back so they can tell
+    # which broadcast their message caused — every participant's heartbeat now
+    # rebroadcasts everyone, so "my entry came back" alone does not mean "my
+    # message round-tripped", and timing against it inflates the measurement.
+    # `seed` is a stable number derived from the sender's persisted identity. It
+    # exists so a colour clash resolves to the same winner on both sides and stays
+    # resolved across a reload; it is deliberately a hash rather than the id itself.
+    RELAYED_FIELDS = %w[name colour current_file rtt seq seed].freeze
+
+    def record(client_id, attrs, now: monotonic)
+      id = client_id.to_s
+      return if id.empty?
+
+      entry = attrs.slice(*RELAYED_FIELDS)
+      MUTEX.synchronize do
+        participants[id] = entry.merge("client_id" => id, "last_seen" => now)
+      end
+      nil
+    end
+
+    def remove(client_id)
+      id = client_id.to_s
+      MUTEX.synchronize { participants.delete(id) }
+      nil
+    end
+
+    # The full roster, with each entry's idle time resolved against a monotonic
+    # clock here rather than compared across machines — no clock skew to correct.
+    def roster(now: monotonic)
+      MUTEX.synchronize do
+        participants.transform_values do |entry|
+          entry.except("last_seen").merge("idle" => (now - entry["last_seen"]).round)
+        end
+      end
+    end
+
+    def reset!
+      MUTEX.synchronize { @participants = {} }
+      nil
+    end
+
+    def participants
+      @participants ||= {}
+    end
+    private_class_method :participants
+
+    def monotonic
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+    private_class_method :monotonic
+  end
+end

data/app/services/mbeditor/ri_definition_service.rb

@@ -17,8 +17,18 @@ module Mbeditor
     MAX_DESC_LINES  = 3
 
     # When a method is defined on many classes, prefer these over the
-    # first-alphabetical class (e.g. prefer BasicObject#new over Addrinfo#new).
-    PREFERRED_CLASSES = %w[BasicObject Object Kernel Module Class].freeze
+    # first-alphabetical class, which is almost never the one meant:
+    # `new` would resolve to Addrinfo and `each` to ARGF.
+    #
+    # Ordered most-general first. We don't know the receiver's type, so the
+    # honest answer for a bare `each` is Enumerable's, not the first class
+    # ri happens to list.
+    PREFERRED_CLASSES = %w[
+      BasicObject Object Kernel Module Class
+      Enumerable Comparable
+      Array Hash String Symbol Integer Float Numeric Range Enumerator
+      Struct Set Time File IO Exception Proc Method NilClass
+    ].freeze
 
     @cache = {}
     @mutex = Mutex.new
@@ -55,6 +65,12 @@ module Mbeditor
 
     private
 
+    # "map()" or "each()" — a name and empty parens, telling you nothing about
+    # arguments, block or return value.
+    def bare_signature?(signature)
+      signature.to_s.strip.match?(/\A[\w.:]+\(\)\z/)
+    end
+
     def run_ri
       out = nil
       Open3.popen3("ri", "--no-pager", "--format=rdoc", @symbol) do |stdin, stdout, _stderr, wait_thr|
@@ -83,8 +99,23 @@ module Mbeditor
       blocks = extract_blocks(lines)
       return [] if blocks.empty?
 
-      best = blocks.find { |b| PREFERRED_CLASSES.include?(b[:impl]) } || blocks.first
-      return [] if best[:sigs].empty?
+      # Rank by position in PREFERRED_CLASSES, not by ri's own ordering, so the
+      # most general implementation wins rather than whichever preferred class
+      # ri happened to print first.
+      #
+      # Choose only among recognised classes when there are any — otherwise a
+      # rich signature on some obscure class (Enumerator::Lazy#map) would beat
+      # the terse one on the class actually meant.
+      preferred = blocks.select { |b| PREFERRED_CLASSES.include?(b[:impl]) }
+      candidates = preferred.any? ? preferred : blocks
+
+      # Within that set, skip entries ri prints as a bare "map()" — they
+      # document nothing — before falling back to class order.
+      best = candidates.min_by do |b|
+        [bare_signature?(b[:sigs].first) ? 1 : 0,
+         PREFERRED_CLASSES.index(b[:impl]) || PREFERRED_CLASSES.length]
+      end
+      return [] if best.nil? || best[:sigs].empty?
 
       desc = best[:desc]
                .first(MAX_DESC_LINES)
@@ -127,8 +158,11 @@ module Mbeditor
       sep_indices = lines.each_index.select { |i| lines[i].match?(/\A-{5,}\z/) }
       return nil if sep_indices.length < 2
 
+      # ri pads signatures into columns for its terminal output, e.g.
+      # "each(sep=$/)             {|line| block }  -> ARGF". Those runs of
+      # spaces are meaningless here and render as a gaping hole in the hover.
       sigs = lines[(sep_indices[0] + 1)..(sep_indices[1] - 1)]
-               .map(&:strip)
+               .map { |l| l.strip.squeeze(" ") }
                .reject(&:empty?)
       return nil if sigs.empty?
 

data/app/services/mbeditor/search_replace_service.rb

@@ -39,6 +39,19 @@ module Mbeditor
         AvailabilityProbe.rg
       end
 
+      # The resolved ripgrep executable, shared with CodeSearchService so both
+      # search paths run the same binary.
+      def rg_command
+        AvailabilityProbe.rg_command || "rg"
+      end
+
+      # Which backend a search on this workspace will actually use. Reported by
+      # GET /workspace: the difference between the tiers is 10-30x, so "why is
+      # search slow" needs to be answerable without reading the source.
+      def backend(workspace_root)
+        pick_tier(workspace_root.to_s)
+      end
+
       # Returns up to +limit+ result rows. When +paths+ is given the scan is
       # restricted to those files (used by the live result-refresh) and the
       # result cache is bypassed.
@@ -242,7 +255,7 @@ module Mbeditor
 
         case tier
         when :rg
-          args = ["rg", "--json"]
+          args = [rg_command, "--json"]
           args << "--no-ignore" unless respect_gitignore?
           args << "-F" unless use_regex
           args << "--ignore-case" unless match_case
@@ -264,9 +277,16 @@ module Mbeditor
           args << "-w" if whole_word
           args += ["-e", query, "--"]
           args += paths.map { |p| relative_path(File.expand_path(p, root), root) } if paths
-          # C locale restores fast byte-wise case folding for -i (non-ASCII
-          # characters simply don't case-fold, which is acceptable here).
-          [{ "LC_ALL" => "C" }, args]
+          # Exclusions have to reach git as pathspecs, not just be dropped from
+          # the results by the matcher below: otherwise git walks node_modules
+          # and every other excluded tree in full before we discard the matches.
+          # A pathspec list of nothing but :(exclude) entries means
+          # "everything except these", which is exactly what the unscoped
+          # search wants.
+          args += exclusions.map { |p| ":(exclude)#{p}" }
+          # No LC_ALL=C: measured neutral for the -F -i default and 2.2x slower
+          # for -E, and the UTF-8 locale case-folds non-ASCII correctly.
+          [{}, args]
         else
           base_flags = use_regex ? "-E" : "-F"
           args = ["grep", "-I", "-Hn", base_flags]

data/app/views/layouts/mbeditor/application.html.erb

@@ -29,6 +29,8 @@
   <script defer src="<%= asset_path('react-dom.min.js') %>"></script>
   <script defer src="<%= asset_path('axios.min.js') %>"></script>
   <script defer src="<%= asset_path('lodash.min.js') %>"></script>
+  <!-- Yjs + y-monaco + y-protocols (awareness) — maintainer-prebuilt bundle for collaborative editing; exposes window.Y / window.MonacoBinding / window.awarenessProtocol -->
+  <script defer src="<%= asset_path('yjs-collab.js') %>"></script>
   <script defer src="<%= asset_path('minisearch.min.js') %>"></script>
   <script defer src="<%= asset_path('marked.min.js') %>"></script>
   <!-- ── Monaco (ESM bundle, ADR 0002): stylesheet here, JS loaded in body ── -->

data/lib/mbeditor/configuration.rb

@@ -5,14 +5,15 @@ module Mbeditor
     attr_accessor :allowed_environments, :workspace_root, :excluded_paths, :rubocop_command, :rubocop_server,
                   :redmine_enabled, :redmine_url, :redmine_api_key, :redmine_ticket_source,
                   :test_framework, :test_command, :test_timeout,
-                  :authenticate_with, :authentication_cache_ttl,
+                  :authenticate_with, :authentication_cache_ttl, :user_name_callback,
                   :lint_timeout, :base_branch_candidates, :git_timeout, :search_timeout,
                   :ruby_def_include_dirs, :related_files_custom_paths,
                   :mount_path, :resilient_routing, :js_global_identifiers,
                   :js_program, :js_program_exclude,
                   :js_syntax_check, :babel_standalone_path,
                   :ruby_lsp, :ruby_lsp_command, :ruby_lsp_timeout,
-                  :search_respect_gitignore
+                  :exception_capture,
+                  :search_respect_gitignore, :ripgrep_command
 
     def initialize
       @allowed_environments = [:development]
@@ -31,10 +32,33 @@ module Mbeditor
       @base_branch_candidates = %w[origin/develop origin/main origin/master develop main master]
       @git_timeout            = 10 # seconds; nil disables (no timeout on git subprocesses)
       @search_timeout         = 15 # seconds; wall-clock bound on every search subprocess, nil disables
-      @search_respect_gitignore = false # true skips .gitignore'd files in project search and definition lookups
+      # Skip .gitignore'd files in project search and definition lookups.
+      #
+      # Defaults to true, matching VS Code and ripgrep. The false path has to
+      # ask git for --no-index, which walks every ignored tree the app has —
+      # node_modules, public/packs, app/assets/builds, caches — and on the
+      # git-grep tier (no ripgrep installed) that measured 29x slower on this
+      # repo alone: 3714 files walked instead of 253. It also fills results
+      # with matches inside minified bundles.
+      #
+      # Set to false to search ignored files too; expect it to be slow on a
+      # machine without ripgrep.
+      @search_respect_gitignore = true
+      # Path to the ripgrep binary. nil auto-resolves: PATH first, then the
+      # usual install prefixes.
+      #
+      # This matters more than it looks. ripgrep is 10-30x faster than the
+      # git-grep fallback, and the probe used to run a bare "rg" — so it found
+      # ripgrep only if the *server process* had it on PATH. A Rails server
+      # started from launchd, systemd, foreman or an IDE typically inherits a
+      # stripped PATH without /opt/homebrew/bin or /usr/local/bin, so ripgrep
+      # could be installed and still invisible, silently dropping every search
+      # to the slow tier. GET /workspace reports the tier actually in use.
+      @ripgrep_command = nil
       @ruby_def_include_dirs  = %w[app/models app/controllers app/helpers app/concerns]
       @related_files_custom_paths = []
       @authentication_cache_ttl = 0
+      @user_name_callback = nil # proc resolved in controller context (instance_exec) → collaboration display name; nil falls through to the client-generated name
       @js_global_identifiers = [] # extra ambient JS globals for the editor (runtime-only names invisible to static scan, e.g. %w[Routes I18n])
       # Load the workspace's own JS source into Monaco's TypeScript program, so
       # cross-file references get real inferred types instead of ambient `any`.
@@ -50,6 +74,12 @@ module Mbeditor
       @ruby_lsp         = :auto # use the host's ruby-lsp for Ruby definitions/hover/completion when available; false disables
       @ruby_lsp_command = nil   # override the ruby-lsp launch command (String or Array); nil auto-resolves bin/ruby-lsp > gem > bundle exec
       @ruby_lsp_timeout = 3     # seconds per LSP request before falling back to the built-in services
+      # Record exceptions raised by the host app's controllers so they show up
+      # in the editor's Problems panel instead of only in the log. Development
+      # only. Exception messages can contain interpolated request params — the
+      # same exposure the log panel already has, since it tails the dev log.
+      # Set to false to record nothing.
+      @exception_capture = :auto
       @mount_path = nil # explicit URL prefix override; nil falls through to detection/"/mbeditor"
       @resilient_routing = true # serve /mbeditor from middleware so the editor survives a broken host routes.rb; false is the escape hatch
     end

data/lib/mbeditor/engine.rb

@@ -77,6 +77,8 @@ module Mbeditor
 
       cfg = Mbeditor.configuration
 
+      subscribe_to_exceptions if Rails.env.development? && cfg.exception_capture != false
+
       if cfg.workspace_root.present? && !File.directory?(cfg.workspace_root.to_s)
         raise ArgumentError, "[mbeditor] config.workspace_root is set to '#{cfg.workspace_root}' but that path is not a directory"
       end
@@ -110,6 +112,7 @@ module Mbeditor
         react-dom.min.js
         axios.min.js
         lodash.min.js
+        yjs-collab.js
         minisearch.min.js
         marked.min.js
         prettier-standalone.js
@@ -125,5 +128,36 @@ module Mbeditor
         fa-solid-900.woff2
       ]
     end
+
+    # Records controller exceptions into ExceptionLog and pushes them to any
+    # open editor over the existing cable channel.
+    #
+    # process_action.action_controller rather than a Rack middleware:
+    # ActionDispatch::DebugExceptions rescues and renders the error, so nothing
+    # outside it ever sees the raise. Rails.error.subscribe would be a cleaner
+    # API but only carries unhandled request errors reliably on newer Rails,
+    # and this gem supports 7.1.
+    def self.subscribe_to_exceptions
+      return if @exception_subscriber
+
+      @exception_subscriber = ActiveSupport::Notifications.subscribe(
+        "process_action.action_controller"
+      ) do |*args|
+        payload = ActiveSupport::Notifications::Event.new(*args).payload
+        exception = payload[:exception_object]
+        next unless exception
+
+        entry = Mbeditor::ExceptionLog.record(
+          exception, payload,
+          workspace_root: Mbeditor::WorkspaceRootResolver.call
+        )
+        next unless entry && defined?(ActionCable.server)
+
+        ActionCable.server.broadcast("mbeditor_editor", entry)
+      rescue StandardError => e
+        # A monitoring hook must never be able to break the request it observes.
+        Rails.logger.debug("[mbeditor] exception capture failed: #{e.class}: #{e.message}")
+      end
+    end
   end
 end

data/lib/mbeditor/exception_log.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Mbeditor
+  # A bounded, in-memory ring of exceptions raised by the host app, so a failed
+  # request shows up in the editor instead of only in the log.
+  #
+  # Lives in lib/ (required from lib/mbeditor.rb, NOT autoloaded) for the same
+  # reason as RubyLspClient: a Zeitwerk reload in the host's dev environment
+  # must not wipe the buffer you are trying to read.
+  #
+  # Fed by an ActiveSupport::Notifications subscriber wired up in the engine.
+  # A Rack middleware cannot be used here: ActionDispatch::DebugExceptions
+  # rescues and renders the error, so nothing outside it ever sees the raise.
+  module ExceptionLog
+    MAX_ENTRIES = 50
+
+    # Backtraces are mostly framework and gem frames, which this editor cannot
+    # open and which push the app's own frames off the end.
+    MAX_FRAMES = 10
+
+    MUTEX = Mutex.new
+    private_constant :MUTEX
+
+    class << self
+      # Returns the recorded entry, or nil when there was nothing to record.
+      def record(exception, payload = {}, workspace_root: nil)
+        return nil if exception.nil?
+
+        entry = build(exception, payload, workspace_root)
+        MUTEX.synchronize do
+          @entries ||= []
+          @entries << entry
+          @entries.shift while @entries.length > MAX_ENTRIES
+        end
+        entry
+      end
+
+      # Newest first — the one you just triggered is the one you want.
+      def entries
+        MUTEX.synchronize { (@entries || []).reverse }
+      end
+
+      def clear!
+        MUTEX.synchronize { @entries = [] }
+        nil
+      end
+
+      private
+
+      def build(exception, payload, workspace_root)
+        @seq = (@seq || 0) + 1
+        {
+          type: "exception",
+          id: @seq,
+          at: Time.now.utc.iso8601,
+          klass: exception.class.name,
+          message: exception.message.to_s[0, 2000],
+          controller: payload[:controller],
+          action: payload[:action],
+          path: payload[:path],
+          frames: workspace_frames(exception, workspace_root)
+        }
+      end
+
+      # Only frames inside the workspace, with the root stripped. Absolute host
+      # paths are both a leak and useless to an editor that addresses files
+      # workspace-relative.
+      def workspace_frames(exception, workspace_root)
+        root = workspace_root.to_s
+        return [] if root.empty?
+
+        prefix = root.end_with?("/") ? root : "#{root}/"
+        Array(exception.backtrace).filter_map do |frame|
+          next unless frame.start_with?(prefix)
+
+          file, line = frame.delete_prefix(prefix).split(":", 3)
+          next if file.nil? || file.empty?
+
+          { file: file, line: line.to_i }
+        end.first(MAX_FRAMES)
+      end
+    end
+  end
+end

data/lib/mbeditor/route_map.rb

@@ -17,6 +17,7 @@ module Mbeditor
     post   'file',            to: 'editors#save'
     post   'create_file',     to: 'editors#create_file'
     post   'create_dir',      to: 'editors#create_dir'
+    post   'import',          to: 'editors#import'
     patch  'rename',          to: 'editors#rename'
     delete 'delete',          to: 'editors#destroy_path'
     get    'state',           to: 'editors#state'
@@ -34,6 +35,10 @@ module Mbeditor
     get    'js_globals',      to: 'editors#js_globals'
     get    'js_program',      to: 'editors#js_program'
     post   'ruby_lsp',        to: 'editors#ruby_lsp'
+  post   'ruby_rename',     to: 'editors#ruby_rename'
+  get    'model_graph',     to: 'editors#model_graph'
+  get    'exceptions',      to: 'editors#exceptions'
+  delete 'exceptions',      to: 'editors#clear_exceptions'
     get    'module_members',  to: 'editors#module_members'
     get    'file_includes',   to: 'editors#file_includes'
     get    'client_config',   to: 'editors#client_config'