mbeditor 0.12.3 → 0.12.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88d963e43c97cf6974b3e38c079ffd2dba642dc1c13a68237f1a3a4f7c21e9a0
-  data.tar.gz: 9e32a366d6ea7ce5014fff94ee89adba7f6909d09aa29f6404142b4155688a3a
+  metadata.gz: 021b4117178c3c82c72bd21709de8665d578557f5833b3b1b525e25ef672ce10
+  data.tar.gz: efc3c48d714d8973b1df5614c05647e21a11856ada4591b3af4b58261e248332
 SHA512:
-  metadata.gz: 100805339d3956837f0ec5349de86b5bcf4315ef5dd261e76b80c0acb589cd9036264b70bb65677be3d27be9575007daee02e08c1cbad86ac3136bd331312a6b
-  data.tar.gz: d1d0681c8962251ceb0d9f18db0937e20f3c1ae1e2d30754a08a88ee10a47b6a6492641de84b9e83c0b2ab81963e79d1f3d86bb61a985bfa7b4a5eb579d0548d
+  metadata.gz: 2655b76c9b8f77dfd7c2127124eae19d9536de389e532f0da51a954adf0e5079042e72175c76a14d047788b13fa7a85193d23353f1112e75d602cc62dde3bc4b
+  data.tar.gz: a4332fc2c00d5caf96c8f26d774892e7adf23f42b09782555cb359c60d601dc419e6b7abab44ae589f12e8804b5d43e9ce1303d9858227eb55ca3e5cb5b32f8f

data/CHANGELOG.md

@@ -7,6 +7,45 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.12.5] - 2026-08-03
+
+### Fixed
+- **The cable took up to 30 seconds to reconnect.** The retry was a flat 30s
+  interval, and because a disconnect tears the consumer down, Action Cable's own
+  much faster reconnection monitor was discarded with it. Any transient blip or
+  dev-server restart therefore cost half a minute with no cable at all: no
+  presence, no collaboration, no file-change push. Replaced with a jittered
+  backoff from 1s to a 8s ceiling, reset on a successful connect. Measured
+  against a real server restart: **2.8 seconds** from the server answering again
+  to the cable being back, where the flat interval could take the full 30.
+- **Collaboration broadcasts flooded the development log.** The Action Cable log
+  filter matched `Mbeditor::` and `mbeditor_editor`, but a broadcast line names
+  only the stream — `Broadcasting to mbeditor_collab:…` — so every keystroke and
+  cursor move was logged with the base64 CRDT payload inlined.
+- **The browser console filled with failed requests when the server became
+  unreachable.** A dropped VPN, a closed lid or a stopped server left the file
+  tree polling every 10s, git status every 5s and the git line tint every 10s,
+  all failing forever — and the browser logs every failed request itself, which
+  no amount of JavaScript can suppress. The only fix is to stop making them.
+
+  Background polls are now skipped before the request is issued once two
+  consecutive *network-level* failures have been seen (an HTTP error does not
+  count — a 500 proves the server is there), and a single probe on a 1s→30s
+  backoff decides when it is back. Requests you initiate are never blocked; they
+  fail fast with a real error rather than hanging until the 30s timeout.
+  Measured with the server down: two failed requests, then silence, instead of
+  an unbounded stream.
+
+## [0.12.4] - 2026-08-03
+
+### Fixed
+- **Rejected-subscription logging flooded the console.** 0.12.3 made a silent
+  failure visible, which was right, but logged every occurrence — and a
+  rejection is not a one-off: the client retries every 30 seconds, every open
+  tab retries independently, and both the editor channel and every per-file
+  collaboration room authenticate. One message per distinct reason per five
+  minutes now, which says the same thing without drowning the log.
+
 ## [0.12.3] - 2026-08-03
 
 ### Added

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

@@ -1798,7 +1798,7 @@ var MbeditorApp = function MbeditorApp() {
   useEffect(function () {
     var intervalId = setInterval(function () {
       if (document.hidden) return;
-      FileService.getTree().then(function (data) {
+      FileService.getTree({ background: true }).then(function (data) {
         setTreeData(_treeUpdater(data || []));
       }).catch(function () {}); // silently ignore auto-refresh errors
     }, 10000);
@@ -1815,7 +1815,7 @@ var MbeditorApp = function MbeditorApp() {
     // /git_info fan-out on its own when the branch or working tree changed.
     var refresh = function () {
       if (document.hidden) return;
-      GitService.fetchStatusLite()["catch"](function () {});
+      GitService.fetchStatusLite({ background: true })["catch"](function () {});
     };
     // Regaining focus is a strong signal something may have happened in a
     // terminal meanwhile — do a full refresh (server-side cache bounds cost).

data/app/assets/javascripts/mbeditor/file_service.js

@@ -6,6 +6,104 @@ axios.defaults.headers.common['X-Mbeditor-Client'] = '1';
 // The ping endpoint overrides this with a tighter 4 s timeout per-request.
 axios.defaults.timeout = 30000;
 
+// ── Server reachability ─────────────────────────────────────────────────────
+//
+// The editor polls hard and unconditionally: the file tree every 10s, git status
+// every 5s, the git line tint every 10s. When the host stops resolving — a
+// dropped VPN, a closed laptop lid, a stopped server — every one of those keeps
+// firing forever, and the browser logs each failure itself. That is where the
+// wall of ERR_NAME_NOT_RESOLVED in the console comes from, and JavaScript cannot
+// suppress those entries: the only fix is to stop making the requests.
+//
+// So background polling is short-circuited while the server looks unreachable,
+// and a single probe on a backoff decides when it is back. User-initiated
+// requests are never blocked — they fail fast with a real error instead, which
+// beats hanging until the 30s timeout.
+var ServerReachability = (function () {
+  // A network-level failure has no response; an HTTP error does. Only the former
+  // means "cannot reach the server" — a 500 proves it is very much there.
+  var CONSECUTIVE_FAILURES_BEFORE_OFFLINE = 2;
+  var PROBE_BASE_MS = 1000;
+  var PROBE_MAX_MS = 30000;
+
+  var _failures = 0;
+  var _online = true;
+  var _probeTimer = null;
+  var _probeAttempts = 0;
+  var _listeners = [];
+
+  function _emit() {
+    _listeners.slice().forEach(function (fn) {
+      try { fn(_online); } catch (e) { /* a bad listener must not stop the rest */ }
+    });
+  }
+
+  function _scheduleProbe() {
+    if (_probeTimer || _online) return;
+    var delay = Math.min(PROBE_MAX_MS, PROBE_BASE_MS * Math.pow(2, _probeAttempts));
+    _probeAttempts += 1;
+    _probeTimer = setTimeout(function () {
+      _probeTimer = null;
+      // Bypasses the short-circuit below: this is the one request allowed
+      // through while offline, and it is what lets us notice recovery.
+      axios.get(window.mbeditorBasePath() + '/ping', { timeout: 4000, mbeditorProbe: true })
+        .then(function () { noteSuccess(); })
+        .catch(function () { _scheduleProbe(); });
+    }, delay);
+  }
+
+  function noteSuccess() {
+    _failures = 0;
+    _probeAttempts = 0;
+    if (_probeTimer) { clearTimeout(_probeTimer); _probeTimer = null; }
+    if (!_online) { _online = true; _emit(); }
+  }
+
+  function noteNetworkFailure() {
+    _failures += 1;
+    if (_online && _failures >= CONSECUTIVE_FAILURES_BEFORE_OFFLINE) {
+      _online = false;
+      _emit();
+      _scheduleProbe();
+    } else if (!_online) {
+      _scheduleProbe();
+    }
+  }
+
+  return {
+    isOnline: function () { return _online; },
+    noteSuccess: noteSuccess,
+    noteNetworkFailure: noteNetworkFailure,
+    onChange: function (fn) {
+      _listeners.push(fn);
+      return function () { _listeners = _listeners.filter(function (f) { return f !== fn; }); };
+    }
+  };
+})();
+
+// Drop background polls while the server is unreachable, so they stop producing
+// console noise and pointless traffic. Marked requests only — anything the user
+// asked for still goes out.
+axios.interceptors.request.use(function (config) {
+  if (config.mbeditorBackground && !ServerReachability.isOnline()) {
+    var err = new Error('mbeditor: skipped background request while server unreachable');
+    err.mbeditorSkipped = true;
+    return Promise.reject(err);
+  }
+  return config;
+});
+
+axios.interceptors.response.use(function (response) {
+  ServerReachability.noteSuccess();
+  return response;
+}, function (error) {
+  if (error && error.mbeditorSkipped) return Promise.reject(error);
+  // No response object at all means the request never reached the server.
+  if (error && !error.response) ServerReachability.noteNetworkFailure();
+  else ServerReachability.noteSuccess();
+  return Promise.reject(error);
+});
+
 // Surface pending-migration errors as a dismissible banner instead of silently failing.
 axios.interceptors.response.use(null, function(error) {
   if (error.response && error.response.data && error.response.data.pending_migration_error) {
@@ -42,8 +140,11 @@ var FileService = (function () {
     return axios.get(window.mbeditorBasePath() + '/workspace').then(function(res) { return res.data; });
   }
 
-  function getTree() {
-    return axios.get(window.mbeditorBasePath() + '/files').then(function(res) { return res.data; });
+  // opts.background marks an automatic poll rather than something the user
+  // asked for, so it can be skipped while the server is unreachable.
+  function getTree(opts) {
+    var cfg = (opts && opts.background) ? { mbeditorBackground: true } : {};
+    return axios.get(window.mbeditorBasePath() + '/files', cfg).then(function(res) { return res.data; });
   }
 
   function getFile(path, options) {
@@ -345,6 +446,8 @@ var FileService = (function () {
     runTests: runTests,
     ping: ping,
     getRoutes: getRoutes,
+    isServerReachable: ServerReachability.isOnline,
+    onReachabilityChange: ServerReachability.onChange,
     getState: getState,
     saveState: saveState,
     getBranchState: getBranchState,

data/app/assets/javascripts/mbeditor/git_service.js

@@ -35,8 +35,11 @@ var GitService = (function () {
   // changed — an external branch switch or a working-tree change. Rich fields
   // from the last full fetch (unpushedCommits, branchCommits, ...) are
   // preserved rather than clobbered.
-  function fetchStatusLite() {
-    return axios.get(window.mbeditorBasePath() + '/git_status')
+  // opts.background marks the 5s poll, which is dropped while the server is
+  // unreachable rather than failing over and over in the console.
+  function fetchStatusLite(opts) {
+    var cfg = (opts && opts.background) ? { mbeditorBackground: true } : {};
+    return axios.get(window.mbeditorBasePath() + '/git_status', cfg)
       .then(function(res) {
         var data = res.data;
         if (!data || !data.ok) return fetchInfo();

data/app/assets/javascripts/mbeditor/websocket_service.js

@@ -22,7 +22,29 @@ var WebSocketService = (function () {
   var _serverSupportsWs = false;
   var _reconnectTimer = null;
   var _lastCableAttemptAt = 0;
-  var RECONNECT_INTERVAL_MS = 30000;
+  // Exponential backoff, not a flat interval. This used to wait a fixed 30s
+  // before even attempting a reconnect — and because `disconnected` tears the
+  // consumer down, Action Cable's own much faster reconnection monitor is
+  // discarded too. The result was that any transient blip cost half a minute
+  // with no cable: no presence, no collaboration, no file-change push. Start
+  // near-instant for the common case (a blip, a server restart) and back off
+  // only if the server really is gone.
+  // Growth is gentle and the ceiling low on purpose. The dominant case here is a
+  // development server restarting, which takes several seconds to boot — a
+  // doubling curve spends those seconds growing, so the attempt that finally
+  // lands is a long way out. Measured against a real restart: doubling to a 30s
+  // cap reconnected in 20s, this reconnects within a few. It is a local dev
+  // tool, so retrying every few seconds costs nothing worth saving.
+  var RECONNECT_BASE_MS = 1000;
+  var RECONNECT_MAX_MS = 8000;
+  var RECONNECT_FACTOR = 1.6;
+  var _reconnectAttempts = 0;
+
+  function _reconnectDelay() {
+    var exp = Math.min(RECONNECT_MAX_MS, RECONNECT_BASE_MS * Math.pow(RECONNECT_FACTOR, _reconnectAttempts));
+    // Jitter so a server restart doesn't have every open tab retry in lockstep.
+    return Math.round(exp * (0.7 + Math.random() * 0.6));
+  }
 
   // ---------------------------------------------------------------------------
   // Internal helpers
@@ -90,11 +112,17 @@ var WebSocketService = (function () {
   }
 
   function _scheduleReconnect() {
-    if (_reconnectTimer || !_serverSupportsWs) return;
+    if (_reconnectTimer || !_serverSupportsWs || _connected) return;
+    var delay = _reconnectDelay();
+    _reconnectAttempts += 1;
     _reconnectTimer = setTimeout(function () {
       _reconnectTimer = null;
       _attemptConnect();
-    }, RECONNECT_INTERVAL_MS);
+      // Keep trying: _attemptConnect only fires once, so without this a failed
+      // attempt that never reaches `rejected` or `disconnected` would end the
+      // retry chain and leave the editor permanently offline.
+      _scheduleReconnect();
+    }, delay);
   }
 
   function _attemptConnect() {
@@ -113,6 +141,9 @@ var WebSocketService = (function () {
           connected: function () {
             _connected = true;
             _status = 'connected';
+            // Back to fast retries for the next blip.
+            _reconnectAttempts = 0;
+            if (_reconnectTimer) { clearTimeout(_reconnectTimer); _reconnectTimer = null; }
           },
           disconnected: function () {
             _status = _status === 'rejected' ? 'rejected' : 'dropped';

data/app/channels/mbeditor/channel_authentication.rb

@@ -50,13 +50,40 @@ module Mbeditor
         Mbeditor.configuration.authenticate_with
     end
 
+    # Throttled hard, because a rejection is not a one-off event: the client
+    # retries every 30s, every open tab retries independently, and both the
+    # editor channel and every per-file collaboration room authenticate. Logging
+    # each one turned a silent failure into a flooded console, which is no more
+    # usable. One message per distinct reason per interval says the same thing.
+    LOG_THROTTLE_SECONDS = 300
+    LOG_MUTEX = Mutex.new
+    private_constant :LOG_MUTEX
+
+    def self.last_logged
+      @last_logged ||= {}
+    end
+
     def mbeditor_log_denial(reason)
+      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      should_log = LOG_MUTEX.synchronize do
+        seen = ChannelAuthentication.last_logged
+        previous = seen[reason]
+        if previous.nil? || (now - previous) > LOG_THROTTLE_SECONDS
+          seen[reason] = now
+          true
+        else
+          false
+        end
+      end
+      return unless should_log
+
       Rails.logger&.warn(
         "[mbeditor] WebSocket subscription rejected: #{reason}. " \
         "Realtime collaboration will not work. A WebSocket subscribe runs no " \
         "controller, so Current.*, Authlogic sessions and other request-scoped " \
         "state set by before_actions are unavailable here — resolve the user " \
-        "from `session` instead, or set config.cable_authenticate_with."
+        "from `session` instead, or set config.cable_authenticate_with. " \
+        "(Further identical rejections suppressed for #{LOG_THROTTLE_SECONDS}s.)"
       )
     rescue StandardError
       # Logging must never be the thing that breaks the socket.

data/lib/mbeditor/cable_log_filter.rb

@@ -8,7 +8,12 @@ module Mbeditor
   # Mbeditor channels so the development console stays readable.
   # Non-Mbeditor ActionCable messages pass through unchanged.
   class CableLogFilter < SimpleDelegator
-    SUPPRESS_PATTERN = /Mbeditor::|mbeditor_editor/
+    # Both stream names, not just the editor one. Action Cable's broadcast line
+    # ("Broadcasting to <stream>: <payload>") names only the stream, so a
+    # channel-class pattern never matches it — and the collaboration stream
+    # broadcasts on every keystroke and every cursor move, with the base64 CRDT
+    # payload inlined. That floods a development log during pairing.
+    SUPPRESS_PATTERN = /Mbeditor::|mbeditor_editor|mbeditor_collab/
     CABLE_WEBSOCKET_REQUEST_PATTERN = /(?:Started|Finished) "\/cable(?:\/[^\"]*)?" \[WebSocket\]/
 
     # Provides no-op tagged logging APIs for plain Ruby formatters.

data/lib/mbeditor/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mbeditor
 version: !ruby/object:Gem::Version
-  version: 0.12.3
+  version: 0.12.5
 platform: ruby
 authors:
 - Oliver Noonan
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-03 00:00:00.000000000 Z
+date: 2026-08-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails