mbeditor 0.7.1 → 0.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b7a1448f753b338a539d853fc6bebeba0960d5e2652273f69a725b25773b505
-  data.tar.gz: c20c3da8f5f8a27f3b3d3cd2a8d1038ac5451d2b1508c82ffe1e0eb272673070
+  metadata.gz: 720ab9c5f06c65a444d4e7a4d9204926a91e31941ed5d21df9a8cb234c322124
+  data.tar.gz: 3c31e3387d38ba23e997dd71051328678bd225ea6ec2078c7d8cae72b44b09c6
 SHA512:
-  metadata.gz: 7ff05b972124d55ba7074c9d2afe2c7fc82648b2b88ff884126832d57e9cf232712dd814768728ad1799eae448663845555b9ccf4cd696a06d4351406aeeed59
-  data.tar.gz: c61f528b91b20203b6667c53abb58e1e02dc7230d91b251e039bc1bf5f99cd660836921437c1c23e9295162dd8aded1fec11acc3972455f6ebfb767c5f2df76f
+  metadata.gz: aa5177a8fb2e8511a4452dc33d3965c5838001991883360e2767ad598edefcb0b3f4feeeb54cd9692b0d7e7527cdf87463faeef2713edcb48cdd672aadfc961b
+  data.tar.gz: 1634701e852db9e3273f0217e5268c6298f3443fdfc5b598d53cfff6a462771a754c7f4ed187cbc247429e0d19ba27913d188715e3846856c034f3382facab5b

data/CHANGELOG.md

@@ -5,6 +5,37 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.7.3] - 2026-06-03
+
+### Fixed
+- **Custom path reverse lookup** — moved the custom-path check in `extract_resource_names` before the `case` statement so paths under `app/assets/`, `app/javascript/`, etc. are handled. Stripped `_controller`/`_model`/`_helper`/`_service` suffixes from custom-path filenames in both backend and frontend for consistent label/grouping.
+- **Schema modal `self.table_name` support** — reads `self.table_name` from the model file before falling back to `ActiveSupport::Inflector.tableize`, enabling custom table names.
+- **Structure.sql broader schema-prefix regex** — handles quoted schemas, non-public schemas, and no prefix.
+- **PostgreSQL type coverage** — expanded `sql_type_to_rails` with full PostgreSQL type coverage (timestamptz, double precision, citext, hstore, geometric types, etc.).
+- **Schema read error handling** — broadened rescue in `try_schema_rb`/`try_structure_sql` to catch encoding errors.
+
+---
+
+## [0.7.2] - 2026-06-03
+
+### Changed
+- **Changelog entries backfilled** — added full release notes for 0.7.1 (persistent undo history, `db/structure.sql` schema support, Rails panel fixes) so the What's New panel shows accurate content on upgrade.
+- **Release workflow documented** — `CLAUDE.md` now describes the release process so future releases can be triggered with a single instruction.
+
+---
+
+## [0.7.1] - 2026-06-03
+
+### Added
+- **Persistent undo history** — edit operations are captured in the browser and flushed to the server on save and tab close, then replayed the next time the file is opened. Undo/redo now reaches back further than the current session. Stale history is pruned automatically when old branches are cleaned up.
+- **`db/structure.sql` schema support** — the model schema modal now reads `db/structure.sql` when `db/schema.rb` is absent (SQL-format migrations).
+
+### Fixed
+- **Rails panel long filenames** — long filenames in the Rails panel are now truncated correctly and custom-path entries populate reliably.
+- **Schema lookup error logging** — failures to parse the schema file now emit a diagnostic log entry to aid debugging.
+
+---
+
 ## [0.7.0] - 2026-05-21
 
 ### Added

data/README.md

@@ -71,26 +71,61 @@ Mbeditor.configure do |config|
   # Optional Ruby/Rails side panel tuning
   # config.ruby_def_include_dirs = %w[app/models app/controllers app/helpers app/concerns]
   # config.related_files_custom_paths = %w[app/assets/javascripts/app app/policies]
+
+  # Resilient routing (see the "Resilient Routing" section below)
+  # config.mount_path = "/mbeditor"   # explicit prefix override; auto-detected when nil
+  # config.resilient_routing = false  # escape hatch; true keeps the editor up when host routes break
 end
 ```
 
-Available options:
-
-- `allowed_environments` controls which Rails environments can access the engine. Default: `[:development]`.
-- `authenticate_with` accepts a proc that runs as a `before_action` in all engine controllers. Use it to plug in the host app's authentication. The proc executes via `instance_exec` inside the engine controller, so it has access to `session`, `cookies`, `redirect_to`, and auth library class methods (e.g. Authlogic's `UserSession.find`), but not helper methods defined in the host app's `ApplicationController`. Default: `nil` (no authentication).
-- `authentication_cache_ttl` caches the authentication result in the session for the given number of seconds (default: `0`, no caching). Set to e.g. `300` to avoid calling `authenticate_with` on every request — useful when the lambda is expensive (e.g. calls Authlogic's `current_user`). Trade-off: if the user logs out of the host app, mbeditor remains accessible for up to TTL seconds.
-- `workspace_root` sets the root directory exposed by Mbeditor. Default: `Rails.root` from the host app.
-- `excluded_paths` hides files and directories from the tree and path-based operations. Entries without `/` match names anywhere in the workspace path; entries with `/` match relative paths and their descendants. Default: `%w[.git tmp log node_modules .bundle coverage vendor/bundle]`.
-- `rubocop_command` sets the command used for inline Ruby linting and formatting. Default: `"rubocop"`.
-- `test_framework` sets the test framework. `:minitest` or `:rspec`. Auto-detected from file suffix, `.rspec`, or `test`/`spec` directory when `nil`. Default: `nil`.
-- `test_command` overrides the full command used to run a test file. When `nil`, the engine picks `bin/rails test` (Minitest) or `bin/rspec` / `bundle exec rspec` (RSpec). Default: `nil`.
-- `test_timeout` sets the maximum seconds a test run may take before being killed. Default: `60`.
-- `redmine_enabled` enables issue lookup integration. Default: `false`.
-- `redmine_url` sets the Redmine base URL. Required when `redmine_enabled` is `true`.
-- `redmine_api_key` sets the Redmine API key. Required when `redmine_enabled` is `true`.
-- `redmine_ticket_source` controls how the current Redmine ticket is identified. `:commit` scans the 100 most recent branch commits for a `#123` reference in the commit message. `:branch` reads the leading digits from the branch name (e.g. `123-my-feature` → ticket 123). Default: `:commit`.
-- `ruby_def_include_dirs` sets which workspace-relative directories are searched when resolving Ruby go-to-definition jumps (e.g. clicking a class name). Add any extra directories that hold Ruby source files you want the engine to index. Default: `%w[app/models app/controllers app/helpers app/concerns]`.
-- `related_files_custom_paths` adds extra base directories to the Rails related-files side panel. For each entry the panel looks for a subdirectory named after the current resource (plural or singular) and lists its files. For example, `"app/assets/javascripts/app"` will surface `app/assets/javascripts/app/users/` when you are editing a `users` resource. Default: `[]`.
+### Core
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `allowed_environments` | `[:development]` | Rails environments allowed to access the engine. |
+| `workspace_root` | `Rails.root` | Root directory exposed by Mbeditor. |
+| `excluded_paths` | `%w[.git tmp log node_modules .bundle coverage vendor/bundle]` | Files/directories hidden from the tree and path operations. Entries without `/` match a name anywhere in the path; entries with `/` match relative paths and their descendants. |
+| `rubocop_command` | `"rubocop"` | Command used for inline Ruby linting and formatting. |
+
+### Authentication
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `authenticate_with` | `nil` | Proc run as a `before_action` in all engine controllers. Executed via `instance_exec` inside the controller, so it has access to `session`, `cookies`, `redirect_to`, and auth-library class methods (e.g. Authlogic's `UserSession.find`) — but not helper methods from the host's `ApplicationController`. |
+| `authentication_cache_ttl` | `0` | Seconds to cache the auth result in the session (`0` = no caching). Set e.g. `300` to avoid calling `authenticate_with` on every request when the proc is expensive. Trade-off: after host logout, mbeditor stays accessible for up to TTL seconds. |
+
+### Test runner
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `test_framework` | `nil` | `:minitest` or `:rspec`. Auto-detected from file suffix, `.rspec`, or `test`/`spec` directory when `nil`. |
+| `test_command` | `nil` | Full command used to run a test file. When `nil`, picks `bin/rails test` (Minitest) or `bin/rspec` / `bundle exec rspec` (RSpec). |
+| `test_timeout` | `60` | Maximum seconds a test run may take before being killed. |
+
+### Redmine
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `redmine_enabled` | `false` | Enables issue-lookup integration. |
+| `redmine_url` | — | Redmine base URL. Required when `redmine_enabled` is `true`. |
+| `redmine_api_key` | — | Redmine API key. Required when `redmine_enabled` is `true`. |
+| `redmine_ticket_source` | `:commit` | How the current ticket is identified. `:commit` scans the 100 most recent branch commits for a `#123` reference; `:branch` reads leading digits from the branch name (e.g. `123-my-feature` → ticket 123). |
+
+### Ruby/Rails side panel
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `ruby_def_include_dirs` | `%w[app/models app/controllers app/helpers app/concerns]` | Workspace-relative directories searched when resolving Ruby go-to-definition jumps. Add any extra dirs holding Ruby source you want indexed. |
+| `related_files_custom_paths` | `[]` | Extra base directories for the Rails related-files side panel. For each entry the panel looks for a subdirectory named after the current resource (plural or singular). E.g. `"app/assets/javascripts/app"` surfaces `app/assets/javascripts/app/users/` when editing a `users` resource. |
+
+### Resilient routing
+
+See [Resilient Routing](#resilient-routing) for details.
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `mount_path` | `nil` | Explicit URL prefix to serve resilient routing from. When `nil`, auto-detected from your `mount Mbeditor::Engine, at: "..."` line on every healthy boot. Set only to override detection. |
+| `resilient_routing` | `true` | Keeps mbeditor reachable when the host's `config/routes.rb` is broken, by serving its traffic from middleware that dispatches to a private route set. Set to `false` as an escape hatch: no middleware is inserted and the private set is never built. |
 
 ## Test Runner
 
@@ -111,6 +146,22 @@ The Test button appears in the editor toolbar for any `.rb` file when a `test/`
 - Minitest: `bin/rails test <file>` if `bin/rails` exists, otherwise `bundle exec ruby -Itest <file>`
 - RSpec: `bin/rspec <file>` if `bin/rspec` exists, otherwise `bundle exec rspec --format json <file>`
 
+## Resilient Routing
+
+A broken `config/routes.rb` normally takes down the whole app — every request, including the one you'd use to fix it, raises while Rails tries to reload the route table. Mbeditor stays reachable anyway: it serves its own traffic from middleware that dispatches to a **private route set** built at boot and never registered with Rails' route reloader. When a bad route draw wipes the host route table, that private set survives the wipe, so `/mbeditor` keeps working while the rest of the app is down. This is on by default (`resilient_routing = true`); you don't need to configure anything.
+
+**Custom mount paths work with zero configuration.** On every healthy boot, mbeditor detects the prefix from your `mount Mbeditor::Engine, at: "..."` line and remembers it. If the route table later breaks, the remembered prefix is used — so resilient routing serves from your custom mount, not just `/mbeditor`. Detection only ever updates from a *healthy* load, so a broken reload can never overwrite a good prefix. Set `config.mount_path` only if you want to override detection explicitly.
+
+**What it cannot recover from: a host app that fails to *boot*.** Resilient routing relies on mbeditor's engine initializers running — that's when the middleware is inserted and the private route set is built. If the app can't boot at all, those initializers never run and there is nothing to fall back to. This includes:
+
+- a syntax error or raised exception in `config/application.rb` or other engine/initializer code,
+- a broken initializer in `config/initializers/`,
+- a bad or incompatible gem that fails to load.
+
+A *broken route* is recoverable in the browser; a *failed boot* is not. If the app won't boot, fix it from a terminal — mbeditor can't help until the app can start.
+
+**Turning it off.** Set `config.resilient_routing = false` as an escape hatch (e.g. to debug a middleware-ordering conflict). With the flag off, no mbeditor middleware is inserted and the private route set is never built; mbeditor is then served only through the normal mount and shares the fate of a broken `config/routes.rb`.
+
 ## Keyboard Shortcuts
 
 | Shortcut | Action |

data/app/assets/javascripts/mbeditor/components/MbeditorApp.js

@@ -1631,13 +1631,12 @@ var MbeditorApp = function MbeditorApp() {
         if (p.startsWith(base + '/')) {
           var rest = p.slice(base.length + 1);
           var resource = rest.split('/')[0].replace(/\.[^.]+$/, '');
-          if (resource) {
-            var seg = resource.replace(/_/g, ' ').replace(/\b\w/g, function(c) { return c.toUpperCase(); });
-            return seg;
-          }
+          // Strip Rails-style suffixes so custom-path files group with their controller/model
+          resource = resource.replace(/_(controller|model|helper|service)$/, '');
+          if (resource) { name = resource; break; }
         }
       }
-      return null;
+      if (!name) return null;
     }
     var seg = (name || '').split('/').pop() || name || '';
     // Normalize plural→singular so views/users and models/user share one group

data/app/controllers/mbeditor/editors_controller.rb

@@ -15,6 +15,7 @@ module Mbeditor
     before_action :verify_mbeditor_client, unless: -> { request.get? || request.head? }
 
     IMAGE_EXTENSIONS = %w[png jpg jpeg gif svg ico webp bmp avif].freeze
+    helper_method :mbeditor_base_path
 
     # GET /mbeditor — renders the IDE shell
     def index
@@ -545,8 +546,7 @@ module Mbeditor
 
     # GET /mbeditor/manifest.webmanifest — PWA manifest
     def pwa_manifest
-      raw  = root_path.chomp("/")
-      base = raw.start_with?("/") || raw.empty? ? raw : "/#{raw}"
+      base = mbeditor_base_path
       manifest = {
         name: "Mbeditor — #{Rails.root.basename}",
         short_name: "Mbeditor",
@@ -787,6 +787,15 @@ module Mbeditor
 
     private
 
+    # Normalized base prefix mbeditor renders URLs against. Sourced from
+    # MountPath (not the engine `root_path` helper) so it still resolves when a
+    # broken host config/routes.rb has wiped Mbeditor::Engine.routes — the exact
+    # state resilient routing exists to survive.
+    def mbeditor_base_path
+      raw = Mbeditor::MountPath.resolve.chomp("/")
+      raw.start_with?("/") || raw.empty? ? raw : "/#{raw}"
+    end
+
     def history_file_path(branch, rel_path)
       branch_hash = Digest::SHA256.hexdigest(branch.to_s)[0, 16]
       file_hash   = Digest::SHA256.hexdigest(rel_path.to_s)[0, 16]

data/app/services/mbeditor/rails_related_files_service.rb

@@ -124,6 +124,20 @@ module Mbeditor
       parts = relative_path.to_s.split("/")
       return nil unless parts.length >= 2
 
+      # Custom paths are checked first so they work regardless of top-level prefix.
+      # Paths under app/assets/, app/javascript/, etc. never reach the standard
+      # "app" branch, so the check must happen before the case statement.
+      Array(custom_paths).each do |base|
+        base = base.to_s.strip
+        next if base.empty?
+        next unless relative_path.start_with?("#{base}/")
+        rest = relative_path.delete_prefix("#{base}/")
+        resource = rest.split('/').first.to_s.sub(/\.[^.]+$/, '') # first segment, no extension
+        resource = resource.sub(/_(controller|model|helper|service)$/, '') # strip Rails suffixes
+        next if resource.empty?
+        return [pluralize(resource), singularize(resource)]
+      end
+
       case parts[0]
       when "app"
         case parts[1]
@@ -230,16 +244,6 @@ module Mbeditor
         end
 
       else
-        # Custom path fallback — must be last
-        Array(custom_paths).each do |base|
-          base = base.to_s.strip
-          next if base.empty?
-          next unless relative_path.start_with?("#{base}/")
-          rest = relative_path.delete_prefix("#{base}/")
-          resource = rest.split('/').first.to_s.sub(/\.[^.]+$/, '')  # first path segment, no extension
-          next if resource.empty?
-          return [pluralize(resource), singularize(resource)]
-        end
         nil
       end
     end

data/app/services/mbeditor/schema_service.rb

@@ -40,8 +40,25 @@ module Mbeditor
     private
 
     # "User" → "users", "OrderItem" → "order_items", "Order Item" → "order_items"
+    # Also checks the model file for an explicit `self.table_name = "..."` declaration.
     def derive_table_name(model_name)
       normalized = model_name.delete(" ")
+
+      # Check model file for an explicit table_name override
+      singular = ActiveSupport::Inflector.underscore(normalized)
+      model_file = File.join(@workspace_root, "app", "models", "#{singular}.rb")
+      if File.exist?(model_file)
+        begin
+          source = File.read(model_file, encoding: "utf-8")
+          # Matches: self.table_name = "name"  or  = :name  or  = 'name'
+          if (m = source.match(/self\.table_name\s*=\s*[:"']([^"'\s]+)["']?/))
+            return m[1]
+          end
+        rescue StandardError
+          # fall through to default derivation
+        end
+      end
+
       ActiveSupport::Inflector.tableize(normalized)
     end
 
@@ -53,7 +70,7 @@ module Mbeditor
       begin
         content = File.read(schema_path, encoding: "utf-8")
         parse_schema_rb(content, table_name)
-      rescue Errno::ENOENT, Errno::EACCES => e
+      rescue StandardError => e
         Rails.logger.debug("SchemaService: failed to read #{schema_path}: #{e.message}")
         nil
       end
@@ -67,7 +84,7 @@ module Mbeditor
       begin
         content = File.read(schema_path, encoding: "utf-8")
         parse_structure_sql(content, table_name)
-      rescue Errno::ENOENT, Errno::EACCES => e
+      rescue StandardError => e
         Rails.logger.debug("SchemaService: failed to read #{schema_path}: #{e.message}")
         nil
       end
@@ -145,11 +162,13 @@ module Mbeditor
       # Handles: PostgreSQL, MySQL, SQLite with quoted/unquoted names
       # Ends with different delimiters: ); ENGINE...; or just );
       quoted_name = Regexp.escape(table_name)
+      # Schema prefix pattern: matches public., "public"., myschema., "myschema". or nothing.
+      schema_prefix = /(?:(?:"[^"]+"|`[^`]+`|\w+)\.)?/
       patterns = [
-        # PostgreSQL with public schema: CREATE TABLE public."users" ( ... );
-        /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?(?:public\.)?["`]?#{quoted_name}["`]?\s*\(([\s\S]*?)\)\s*;/mi,
-        # MySQL with ENGINE: CREATE TABLE `users` ( ... ) ENGINE=...;
-        /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?["`]?#{quoted_name}["`]?\s*\(([\s\S]*?)\)\s*(?:ENGINE|DEFAULT)/mi
+        # PostgreSQL: CREATE TABLE [schema.]table ( ... );
+        /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?#{schema_prefix}["`]?#{quoted_name}["`]?\s*\(([\s\S]*?)\)\s*;/mi,
+        # MySQL: CREATE TABLE [schema.]`table` ( ... ) ENGINE=...;
+        /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?#{schema_prefix}["`]?#{quoted_name}["`]?\s*\(([\s\S]*?)\)\s*(?:ENGINE|DEFAULT)/mi
       ]
 
       table_def = nil
@@ -240,6 +259,9 @@ module Mbeditor
       type_map = {
         'integer' => 'integer',
         'int' => 'integer',
+        'int4' => 'integer',
+        'int2' => 'integer',
+        'int8' => 'bigint',
         'bigint' => 'bigint',
         'smallint' => 'integer',
         'bigserial' => 'bigint',
@@ -247,21 +269,50 @@ module Mbeditor
         'varchar' => 'string',
         'character varying' => 'string',
         'character' => 'string',
+        'char' => 'string',
         'text' => 'text',
+        'citext' => 'string',
         'boolean' => 'boolean',
         'bool' => 'boolean',
         'decimal' => 'decimal',
         'numeric' => 'decimal',
+        'real' => 'float',
         'float' => 'float',
+        'float4' => 'float',
+        'float8' => 'float',
+        'double precision' => 'float',
         'double' => 'float',
+        'money' => 'decimal',
         'timestamp' => 'datetime',
+        'timestamp without time zone' => 'datetime',
+        'timestamp with time zone' => 'datetime',
+        'timestamptz' => 'datetime',
         'datetime' => 'datetime',
         'date' => 'date',
         'time' => 'time',
+        'time without time zone' => 'time',
+        'time with time zone' => 'time',
+        'interval' => 'string',
         'json' => 'json',
         'jsonb' => 'jsonb',
         'uuid' => 'uuid',
-        'bytea' => 'binary'
+        'bytea' => 'binary',
+        'bit' => 'string',
+        'bit varying' => 'string',
+        'inet' => 'string',
+        'cidr' => 'string',
+        'macaddr' => 'string',
+        'xml' => 'string',
+        'hstore' => 'hstore',
+        'tsvector' => 'string',
+        'ltree' => 'string',
+        'point' => 'string',
+        'line' => 'string',
+        'lseg' => 'string',
+        'box' => 'string',
+        'path' => 'string',
+        'polygon' => 'string',
+        'circle' => 'string'
       }
 
       type_map[sql_type.downcase] || sql_type

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

@@ -7,7 +7,7 @@
   <meta name="theme-color" content="#1e1e2e" />
   <meta name="mobile-web-app-capable" content="yes" />
   <meta name="apple-mobile-web-app-capable" content="yes" />
-  <% _raw_base = root_path.chomp('/'); pwa_base = (_raw_base.start_with?('/') || _raw_base.empty?) ? _raw_base : "/#{_raw_base}" %>
+  <% pwa_base = mbeditor_base_path %>
   <link rel="manifest" href="<%= "#{pwa_base}/manifest.webmanifest" %>" />
   <script>
     if ('serviceWorker' in navigator) {

data/config/routes.rb

@@ -1,58 +1,6 @@
 # frozen_string_literal: true
 
-Mbeditor::Engine.routes.draw do
-  root to: 'editors#index'
-
-  get    'ping',            to: 'editors#ping'
-  get    'workspace',       to: 'editors#workspace'
-  get    'files',           to: 'editors#files'
-  get    'file',            to: 'editors#show'
-  get    'raw',             to: 'editors#raw'
-  post   'file',            to: 'editors#save'
-  post   'create_file',     to: 'editors#create_file'
-  post   'create_dir',      to: 'editors#create_dir'
-  patch  'rename',          to: 'editors#rename'
-  delete 'delete',          to: 'editors#destroy_path'
-  get    'state',           to: 'editors#state'
-  post   'state',           to: 'editors#save_state'
-  get    'branch_state',    to: 'editors#branch_state'
-  post   'branch_state',    to: 'editors#save_branch_state'
-  post   'prune_branch_states', to: 'editors#prune_branch_states'
-  get  'file_history', to: 'editors#file_history'
-  post 'file_history', to: 'editors#save_file_history'
-  get    'search',          to: 'editors#search'
-  post   'replace_in_files', to: 'editors#replace_in_files'
-  get    'definition',      to: 'editors#definition'
-  get    'js_definition',   to: 'editors#js_definition'
-  get    'js_members',      to: 'editors#js_members'
-  get    'module_members',  to: 'editors#module_members'
-  get    'file_includes',   to: 'editors#file_includes'
-  get    'client_config',   to: 'editors#client_config'
-  get    'related_files',   to: 'editors#related_files'
-  get    'model_schema',    to: 'editors#model_schema'
-  get    'changelog',       to: 'editors#changelog'
-  get    'git_info',        to: 'editors#git_info'
-  get    'git_status',      to: 'editors#git_status'
-  get    'manifest.webmanifest',            to: 'editors#pwa_manifest',   format: false
-  get    'sw.js',                           to: 'editors#pwa_sw',         format: false
-  get    'mbeditor-icon.svg',               to: 'editors#pwa_icon',       format: false
-  get    'monaco_worker.js',                to: 'editors#monaco_worker',  format: false
-  get    'ts_worker.js',                    to: 'editors#ts_worker',      format: false
-  get    'monaco-editor/*asset_path',       to: 'editors#monaco_asset', format: false
-  get    'min-maps/*asset_path',            to: 'editors#monaco_asset', format: false
-  post   'lint',            to: 'editors#lint'
-  post   'quick_fix',       to: 'editors#quick_fix'
-  post   'format',          to: 'editors#format_file'
-  post   'test',            to: 'editors#run_test'
-
-  # ── Git & Code Review ──────────────────────────────────────────────────────
-  get 'git/diff',           to: 'git#diff'
-  get 'git/blame',          to: 'git#blame'
-  get 'git/file_history',   to: 'git#file_history'
-  get 'git/commit_graph',   to: 'git#commit_graph'
-  get 'git/commit_detail',  to: 'git#commit_detail'
-  get 'git/combined_diff',  to: 'git#combined_diff'
-
-  # Redmine integration (enabled via config.mbeditor.redmine_enabled)
-  get 'redmine/issue/:id', to: 'git#redmine_issue', as: :redmine_issue
-end
+# Routes are declared in Mbeditor::ROUTE_MAP (lib/mbeditor/route_map.rb), the
+# single source of truth shared with the private, isolated route set. Drawing
+# from it here keeps the engine route set and the private set from drifting.
+Mbeditor::Engine.routes.draw(&Mbeditor::ROUTE_MAP)

data/lib/mbeditor/configuration.rb

@@ -7,7 +7,8 @@ module Mbeditor
                   :test_framework, :test_command, :test_timeout,
                   :authenticate_with, :authentication_cache_ttl,
                   :lint_timeout, :base_branch_candidates, :git_timeout,
-                  :ruby_def_include_dirs, :related_files_custom_paths
+                  :ruby_def_include_dirs, :related_files_custom_paths,
+                  :mount_path, :resilient_routing
 
     def initialize
       @allowed_environments = [:development]
@@ -27,6 +28,8 @@ module Mbeditor
       @ruby_def_include_dirs  = %w[app/models app/controllers app/helpers app/concerns]
       @related_files_custom_paths = []
       @authentication_cache_ttl = 0
+      @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
   end
 end

data/lib/mbeditor/engine.rb

@@ -2,6 +2,7 @@
 
 require "mbeditor/rack/silence_ping_request"
 require "mbeditor/rack/handle_pending_migrations"
+require "mbeditor/rack/resilient_router"
 require "mbeditor/cable_log_filter"
 
 module Mbeditor
@@ -12,6 +13,43 @@ module Mbeditor
       app.middleware.insert_before Rails::Rack::Logger, Mbeditor::Rack::SilencePingRequest
     end
 
+    initializer "mbeditor.resilient_routing" do |app|
+      # Serve mbeditor's own traffic from middleware that dispatches to a
+      # private, isolated route set, so the editor survives a broken host
+      # config/routes.rb. Disabling the flag is the escape hatch: no middleware
+      # is inserted and the private set is never built.
+      next unless Mbeditor.configuration.resilient_routing
+
+      # ActionDispatch::Reloader is only in the stack when reloading is enabled
+      # (the same condition Rails uses to add it). Sitting just above it means
+      # mbeditor requests are intercepted before any route reload can raise,
+      # while staying below DebugExceptions/ShowExceptions (mbeditor's own
+      # errors still get Rails error pages) and below Executor (dispatch runs
+      # inside app.executor's connection management).
+      if app.config.reloading_enabled?
+        app.middleware.insert_before ActionDispatch::Reloader, Mbeditor::Rack::ResilientRouter
+      end
+
+      # Build the private set at boot so it is ready before the first request
+      # and before the host route table can ever break.
+      Mbeditor::PrivateRoutes.route_set
+
+      # Auto-detect the mount prefix from each *healthy* route load and cache it,
+      # so resilient routing works at a custom mount with zero configuration.
+      # after_routes_loaded fires only after a successful load — a raising
+      # routes.rb skips it — so the cache is never populated from the wiped
+      # break-time table. MountPath.refresh! is a no-op when the engine isn't
+      # found, so a stray load can never clobber a prefix from an earlier
+      # healthy one.
+      #
+      # The hook's yielded receiver is NOT reliably Rails.application — the
+      # reloader's to_run path fires it with the reloader callback context as
+      # self — so read the live route set through Rails.application directly.
+      app.config.after_routes_loaded do
+        Mbeditor::MountPath.refresh!(Rails.application.routes)
+      end
+    end
+
     initializer "mbeditor.handle_pending_migrations" do |app|
       # Insert before CheckPending so our middleware wraps it and can rescue
       # the error it raises. Falls back silently if CheckPending is absent

data/lib/mbeditor/mount_path.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Mbeditor
+  # Resolves the active URL prefix mbeditor serves from.
+  #
+  # At break-time the host route table is wiped, so it is the wrong place to
+  # ask "where am I mounted?". MountPath answers from a resolution chain that
+  # never touches the route table directly:
+  #
+  #   1. explicit Mbeditor.configuration.mount_path (override)
+  #   2. the cached detected value (populated from a healthy route load)
+  #   3. the "/mbeditor" default
+  #
+  # The cache is guarded by a mutex because it is read at break-time from
+  # whatever request thread happens to be serving mbeditor.
+  module MountPath
+    DEFAULT = '/mbeditor'
+
+    @mutex = Mutex.new
+    @cached = nil
+
+    class << self
+      def resolve
+        Mbeditor.configuration.mount_path || cached || DEFAULT
+      end
+
+      # Scans a route set for the route that mounts Mbeditor::Engine and returns
+      # its path-spec prefix (e.g. "/mbeditor"), or nil if the engine is not
+      # mounted in this set. A mounted engine's route.app is a Constraints
+      # wrapper whose #app is the engine; an unmounted route's app is something
+      # else, so an unwrap-once-then-compare is enough.
+      def detect(route_set)
+        route_set.routes.each do |route|
+          app = route.app
+          target = app.respond_to?(:app) ? app.app : app
+          return route.path.spec.to_s if target == Mbeditor::Engine
+        end
+        nil
+      end
+
+      # Re-detects from a route set and caches the result. Called from the
+      # engine's after_routes_loaded hook, which fires only on a *healthy* route
+      # load — never at break-time, when the table is wiped. A nil detection is
+      # left as a no-op so a stray refresh from an engine-less set can never
+      # clobber a good prefix cached from an earlier healthy load.
+      def refresh!(route_set)
+        detected = detect(route_set)
+        self.cached = detected if detected
+      end
+
+      # The cached detected prefix, or nil if nothing has been detected yet.
+      def cached
+        @mutex.synchronize { @cached }
+      end
+
+      # Stores the detected prefix. Passing nil clears the cache.
+      def cached=(value)
+        @mutex.synchronize { @cached = value }
+      end
+    end
+  end
+end

data/lib/mbeditor/private_routes.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Mbeditor
+  # The private, isolated route set mbeditor dispatches to when the host route
+  # table is broken.
+  #
+  # It is built from Mbeditor::ROUTE_MAP — the same source the engine's own
+  # route set draws from — so the two can never drift apart. Crucially, this set
+  # is created with ActionDispatch::Routing::RouteSet.new and is *never*
+  # registered with the host RoutesReloader. The reloader's clear! wipes every
+  # route set it knows about when a host route draw raises; because this set is
+  # unknown to it, it survives the wipe and keeps mbeditor reachable.
+  #
+  # ROUTE_MAP declares controllers without a namespace (e.g. "editors#index").
+  # The engine resolves those under "mbeditor/" via isolate_namespace; a plain
+  # RouteSet does not, so we reproduce the namespacing with scope module:.
+  module PrivateRoutes
+    @mutex = Mutex.new
+
+    class << self
+      def route_set
+        @mutex.synchronize { @route_set ||= build }
+      end
+
+      private
+
+      def build
+        set = ActionDispatch::Routing::RouteSet.new
+        set.draw do
+          scope module: 'mbeditor' do
+            instance_exec(&Mbeditor::ROUTE_MAP)
+          end
+        end
+        set
+      end
+    end
+  end
+end

data/lib/mbeditor/rack/resilient_router.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Mbeditor
+  module Rack
+    # Serves mbeditor's own traffic from a private, isolated route set so the
+    # editor stays reachable even when the host config/routes.rb is broken.
+    #
+    # Sibling of HandlePendingMigrations: both intercept mbeditor requests when
+    # the normal path is blocked. This one sits above ActionDispatch::Reloader,
+    # so a prefix-matching request is dispatched before any route reload can
+    # raise. Requests that don't match the mount prefix pass through untouched.
+    #
+    # The matched request is rewritten to mirror how Rails mounts an engine:
+    # the prefix is stripped from PATH_INFO and moved to SCRIPT_NAME, so the
+    # private set sees the un-prefixed path while the rendered base path stays
+    # correct. Dispatch still flows through the mbeditor controllers, so
+    # verify_mbeditor_client and resolve_path run unchanged.
+    #
+    # Because this middleware sits above the Reloader — and therefore above the
+    # host's Cookies/Session/Flash middleware — a bare dispatch would leave
+    # resilient-routed requests without a session, breaking session-based
+    # authenticate_with. To keep parity with the normal mount, the private set
+    # is wrapped in the host app's own cookies/session/flash middleware. The
+    # crypto config (key generator, secret_key_base, serializer) is already in
+    # env, merged by Rails::Application#call before the stack runs.
+    class ResilientRouter
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        prefix = Mbeditor::MountPath.resolve
+        path = "#{env["SCRIPT_NAME"]}#{env["PATH_INFO"]}"
+
+        return @app.call(env) unless matches_prefix?(path, prefix)
+
+        remainder = path[prefix.length..] || ""
+        remainder = "/" if remainder.empty?
+        env["SCRIPT_NAME"] = prefix
+        env["PATH_INFO"] = remainder
+
+        dispatch.call(env)
+      end
+
+      private
+
+      def matches_prefix?(path, prefix)
+        path == prefix || path.start_with?("#{prefix}/")
+      end
+
+      # The private route set wrapped in the host's session middleware, so a
+      # resilient-routed request has the same session support as one that
+      # reaches mbeditor through the normal mount. Built lazily and memoized;
+      # the middleware instance lives for the process, so a benign double-build
+      # under a startup race is harmless.
+      def dispatch
+        @dispatch ||= build_dispatch
+      end
+
+      def build_dispatch
+        app = Mbeditor::PrivateRoutes.route_set
+        config = Rails.application.config
+        store = config.session_store
+        # config.session_store is the store class normally, but :disabled (a
+        # symbol) when sessions are off — in which case dispatch the bare set.
+        return app unless store.is_a?(Class)
+
+        app = ActionDispatch::Flash.new(app)
+        app = store.new(app, config.session_options)
+        ActionDispatch::Cookies.new(app)
+      end
+    end
+  end
+end

data/lib/mbeditor/route_map.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Mbeditor
+  # Single source of truth for the engine's routes.
+  #
+  # Both the engine's own route set (config/routes.rb via
+  # Mbeditor::Engine.routes.draw) and the (later) private, isolated route set
+  # draw from this same proc, so the two can never drift apart.
+  ROUTE_MAP = proc do
+    root to: 'editors#index'
+
+    get    'ping',            to: 'editors#ping'
+    get    'workspace',       to: 'editors#workspace'
+    get    'files',           to: 'editors#files'
+    get    'file',            to: 'editors#show'
+    get    'raw',             to: 'editors#raw'
+    post   'file',            to: 'editors#save'
+    post   'create_file',     to: 'editors#create_file'
+    post   'create_dir',      to: 'editors#create_dir'
+    patch  'rename',          to: 'editors#rename'
+    delete 'delete',          to: 'editors#destroy_path'
+    get    'state',           to: 'editors#state'
+    post   'state',           to: 'editors#save_state'
+    get    'branch_state',    to: 'editors#branch_state'
+    post   'branch_state',    to: 'editors#save_branch_state'
+    post   'prune_branch_states', to: 'editors#prune_branch_states'
+    get  'file_history', to: 'editors#file_history'
+    post 'file_history', to: 'editors#save_file_history'
+    get    'search',          to: 'editors#search'
+    post   'replace_in_files', to: 'editors#replace_in_files'
+    get    'definition',      to: 'editors#definition'
+    get    'js_definition',   to: 'editors#js_definition'
+    get    'js_members',      to: 'editors#js_members'
+    get    'module_members',  to: 'editors#module_members'
+    get    'file_includes',   to: 'editors#file_includes'
+    get    'client_config',   to: 'editors#client_config'
+    get    'related_files',   to: 'editors#related_files'
+    get    'model_schema',    to: 'editors#model_schema'
+    get    'changelog',       to: 'editors#changelog'
+    get    'git_info',        to: 'editors#git_info'
+    get    'git_status',      to: 'editors#git_status'
+    get    'manifest.webmanifest',            to: 'editors#pwa_manifest',   format: false
+    get    'sw.js',                           to: 'editors#pwa_sw',         format: false
+    get    'mbeditor-icon.svg',               to: 'editors#pwa_icon',       format: false
+    get    'monaco_worker.js',                to: 'editors#monaco_worker',  format: false
+    get    'ts_worker.js',                    to: 'editors#ts_worker',      format: false
+    get    'monaco-editor/*asset_path',       to: 'editors#monaco_asset', format: false
+    get    'min-maps/*asset_path',            to: 'editors#monaco_asset', format: false
+    post   'lint',            to: 'editors#lint'
+    post   'quick_fix',       to: 'editors#quick_fix'
+    post   'format',          to: 'editors#format_file'
+    post   'test',            to: 'editors#run_test'
+
+    # ── Git & Code Review ──────────────────────────────────────────────────────
+    get 'git/diff',           to: 'git#diff'
+    get 'git/blame',          to: 'git#blame'
+    get 'git/file_history',   to: 'git#file_history'
+    get 'git/commit_graph',   to: 'git#commit_graph'
+    get 'git/commit_detail',  to: 'git#commit_detail'
+    get 'git/combined_diff',  to: 'git#combined_diff'
+
+    # Redmine integration (enabled via config.mbeditor.redmine_enabled)
+    get 'redmine/issue/:id', to: 'git#redmine_issue', as: :redmine_issue
+  end
+end

data/lib/mbeditor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mbeditor
-  VERSION = "0.7.1"
+  VERSION = "0.7.3"
 end

data/lib/mbeditor.rb

@@ -2,6 +2,9 @@
 
 require "mbeditor/version"
 require "mbeditor/configuration"
+require "mbeditor/mount_path"
+require "mbeditor/route_map"
+require "mbeditor/private_routes"
 require "mbeditor/engine"
 
 module Mbeditor

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mbeditor
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.7.3
 platform: ruby
 authors:
 - Oliver Noonan
@@ -121,8 +121,12 @@ files:
 - lib/mbeditor/cable_log_filter.rb
 - lib/mbeditor/configuration.rb
 - lib/mbeditor/engine.rb
+- lib/mbeditor/mount_path.rb
+- lib/mbeditor/private_routes.rb
 - lib/mbeditor/rack/handle_pending_migrations.rb
+- lib/mbeditor/rack/resilient_router.rb
 - lib/mbeditor/rack/silence_ping_request.rb
+- lib/mbeditor/route_map.rb
 - lib/mbeditor/version.rb
 - mbeditor.gemspec
 - public/mbeditor-icon.svg