rails-markup 1.4.0 → 1.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c2efa8f1fca5e20c13c63a7157b47553cb893df6384bb0799b57b1dd9caa2bb6
-  data.tar.gz: 5b244141b9d9bab054f7baa2f15dd3af9560e0ee3aaefcaeaef81c5e4e3541bd
+  metadata.gz: 34e44f1b30e4c51432e862ee09efd9d1f72e906a41e0e38f9c7553267f737d6f
+  data.tar.gz: '0909684467d87ed6a1248657ea2fc0e120956b66203c55b47750e74b57971bcb'
 SHA512:
-  metadata.gz: d6b1da9212c6140e1db0767b6a27b972497063657a8b5f23d28e1ba84d21d1ed606473182516730708bd7f29447df448baf967f34cf291de40374b724b984cd4
-  data.tar.gz: 73f188f0de27d3fc628bc31388daa1a6e0048a124c3d1a0dfb91dcf9be0b048470179c4b47be58b403c2850653064d005fde99f10738bb394433c4cd17ba0cbd
+  metadata.gz: ea571e4c90037645f9f81ddc6e95710ffd6333addee88f6b43b3352ee8be8bcf9afb9b4d0d2868965f30825c370bf668a6e3a61e7fe345c6ae2469e8e205216c
+  data.tar.gz: ec0f2ff1ae946b95e7e6c6a7c0fb90429faa8bab7e8cbe30763a09440056760ab9049aed14b296a36c52095f9c1eae5d45941c6a1ccae8bcc346e5f12d03a5d3

data/app/assets/javascripts/rails_markup/toolbar.js

@@ -43,6 +43,7 @@
     _syncMaxRetryDelay: 30000,
     _syncMalformedLimit: 3,
     _syncUnavailable: null,
+    legacyStorageEndpoint: null,
 
     // Drawing state
     drawingMode: null,      // null | "arrow" | "rect" | "highlight"
@@ -73,6 +74,7 @@
       this.size = opts.size || "default";
       this.fabVisible = opts.fabVisible !== false;
       this.enableScreenshots = opts.enableScreenshots !== false;
+      this.legacyStorageEndpoint = opts.legacyStorageEndpoint || this.legacyStorageEndpoint;
       this.healthIntervalMs = (opts.healthInterval || 60) * 1000;
 
       if (document.getElementById("rm-toolbar-root")) {
@@ -1195,6 +1197,8 @@
 
         if (result.kind === "success") {
           if (!this._outboxEntryMatches(snapshot)) {
+            const supersedingDelete = this._advanceSupersedingDeleteBaseRevision(snapshot, result.data);
+            if (supersedingDelete === "failed") break;
             clientIds.push(clientId);
             continue;
           }
@@ -1215,13 +1219,14 @@
           continue;
         }
         if (result.kind === "conflict") {
-          const pulled = await this._pullAnnotations();
-          if (pulled && this.outbox[clientId]) {
+          const resolution = this._reconcileSyncConflict(snapshot, result);
+          await this._pullAnnotations();
+          if (resolution === "retry" && this.outbox[clientId]) {
             clientIds.push(clientId);
             continue;
           }
-          this._scheduleSyncRetry();
-          break;
+          this._resetSyncRetry();
+          continue;
         }
         if (result.kind === "malformed") {
           if (!this._outboxEntryMatches(snapshot)) {
@@ -1239,6 +1244,25 @@
       }
     },
 
+    _advanceSupersedingDeleteBaseRevision(snapshot, server) {
+      const current = this.outbox[snapshot.clientId];
+      const supersedesUpsert = snapshot.type === "upsert"
+        && current?.type === "delete"
+        && current.clientId === snapshot.clientId
+        && Number.isInteger(current.revision)
+        && current.revision > snapshot.revision
+        && Number.isInteger(server?.revision);
+      if (!supersedesUpsert) return "not-applicable";
+
+      const tombstone = this._immutableCopy(current);
+      const committed = this._commitLocalStateChange(() => {
+        if (!this._outboxEntryMatches(tombstone)) return;
+        const baseRevision = Number.isInteger(tombstone.baseRevision) ? tombstone.baseRevision : 0;
+        this.outbox[snapshot.clientId].baseRevision = Math.max(baseRevision, server.revision);
+      });
+      return committed ? "advanced" : "failed";
+    },
+
     async _sendOutboxEntry(snapshot) {
       const request = this._sameOriginMutationRequest(`/annotations/${encodeURIComponent(snapshot.clientId)}`);
       if (!request) return { kind: "auth", message: "Sync unavailable: endpoint must be same-origin" };
@@ -1250,7 +1274,11 @@
         redirect: "manual",
         signal: AbortSignal.timeout(5000)
       };
-      if (snapshot.type === "upsert") {
+      if (snapshot.type === "delete") {
+        options.body = JSON.stringify({
+          baseRevision: Number.isInteger(snapshot.baseRevision) ? snapshot.baseRevision : 0
+        });
+      } else {
         options.body = JSON.stringify(Object.assign({}, snapshot.annotation, {
           dirtyFields: snapshot.dirtyFields || [],
           baseRevision: Number.isInteger(snapshot.baseRevision) ? snapshot.baseRevision : 0
@@ -1292,7 +1320,7 @@
       if ([408, 425, 429].includes(status) || status >= 500) {
         return { kind: "retryable", retryAfter: this._retryAfterDelay(response) };
       }
-      if (status === 409 && snapshot.type === "upsert") return { kind: "conflict" };
+      if (status === 409) return this._classifyConflictResponse(snapshot, response);
       if (status >= 400) return { kind: "terminal" };
       if (!response.ok) return { kind: "retryable" };
       if (snapshot.type === "delete") return { kind: "success", data: null };
@@ -1311,6 +1339,25 @@
       }
     },
 
+    async _classifyConflictResponse(snapshot, response) {
+      const contentType = response.headers.get("Content-Type") || "";
+      if (!contentType.toLowerCase().includes("application/json")) return { kind: "malformed" };
+
+      try {
+        const body = await response.json();
+        if (!this._plainObject(body) || !Object.prototype.hasOwnProperty.call(body, "annotation")) {
+          return { kind: "malformed" };
+        }
+        if (body.annotation === null && snapshot.type === "upsert") {
+          return { kind: "conflict", missing: true, data: null };
+        }
+        if (!this._validServerAnnotation(body.annotation, snapshot.clientId)) return { kind: "malformed" };
+        return { kind: "conflict", missing: false, data: body.annotation };
+      } catch {
+        return { kind: "malformed" };
+      }
+    },
+
     _validServerAnnotation(data, expectedClientId) {
       if (!this._plainObject(data)) return false;
       const required = [
@@ -1385,6 +1432,65 @@
       annotation.syncState = "synced";
     },
 
+    _reconcileSyncConflict(snapshot, conflict) {
+      if (!this._outboxEntryMatches(snapshot)) return "stop";
+
+      let resolution = "stop";
+      const committed = this._commitLocalStateChange(() => {
+        if (!this._outboxEntryMatches(snapshot)) return;
+        const entry = this.outbox[snapshot.clientId];
+        const annotation = this.annotations.find(candidate => candidate.clientId === snapshot.clientId);
+
+        if (snapshot.type === "delete") {
+          delete this.outbox[snapshot.clientId];
+          if (annotation) this._mergePulledAnnotation(annotation, conflict.data, null);
+          else this.annotations.push(this._annotationFromServer(conflict.data));
+          this._assignDisplayIds();
+          return;
+        }
+
+        if (conflict.missing) {
+          if (entry.missingConflictRebased) {
+            entry.syncState = "failed";
+            if (annotation) annotation.syncState = "failed";
+            return;
+          }
+          if (!annotation) {
+            entry.syncState = "failed";
+            return;
+          }
+          // Recreate once from the complete desired browser state. Replaying a
+          // narrow edit delta onto a new row can omit required fields and lose
+          // the user's annotation to a permanent validation failure.
+          annotation.dirtyFields = this._legacyDirtyFields(annotation);
+          entry.annotation = this._desiredState(annotation);
+          entry.dirtyFields = annotation.dirtyFields.slice();
+          entry.baseRevision = 0;
+          entry.missingConflictRebased = true;
+          annotation.serverId = null;
+          annotation.serverRevision = 0;
+          resolution = "retry";
+          return;
+        }
+
+        if (!annotation) {
+          entry.syncState = "failed";
+          return;
+        }
+        this._mergePulledAnnotation(annotation, conflict.data, entry);
+        entry.annotation = this._desiredState(annotation);
+        entry.dirtyFields = (annotation.dirtyFields || []).slice();
+        entry.baseRevision = conflict.data.revision;
+        delete entry.missingConflictRebased;
+        resolution = "retry";
+      });
+      if (!committed) return "stop";
+      this._renderPins();
+      this._rebuildList();
+      this._updateCount();
+      return resolution;
+    },
+
     _markSyncFailed(snapshot) {
       if (!this._outboxEntryMatches(snapshot)) return;
       this._commitLocalStateChange(() => {
@@ -1479,9 +1585,9 @@
             ? data.legacyMigrations
             : {};
         }
-        // Pre-1.3 storage had no endpoint identity. The first configured endpoint
-        // to load on this origin claims it once; successful consolidation removes
-        // the source keys so another endpoint cannot import the same data later.
+        // Pre-1.3 bare storage has no endpoint provenance, so it is left intact
+        // unless the host explicitly designates this endpoint. Page-qualified
+        // legacy keys are only claimed by a toolbar currently on that exact page.
         const migratedKeys = this._migrateUnnamespacedStorage();
         migratedKeys.push(...this._migratePageAnnotations());
         this._normalizeStoredState();
@@ -1494,9 +1600,13 @@
 
     _migrateUnnamespacedStorage() {
       const sourceKeys = [];
+      const designatedEndpoint = (this.legacyStorageEndpoint || "").replace(/\/+$/, "");
+      const currentEndpoint = (this.endpoint || "").replace(/\/+$/, "");
+      const claimBareStorage = Boolean(designatedEndpoint) && designatedEndpoint === currentEndpoint;
+      const currentPageKey = `rm-annotations:${this._pageUrl()}`;
       for (let index = 0; index < localStorage.length; index++) {
         const key = localStorage.key(index);
-        if (key === "rm-annotations" || (key && key.startsWith("rm-annotations:/"))) sourceKeys.push(key);
+        if ((claimBareStorage && key === "rm-annotations") || key === currentPageKey) sourceKeys.push(key);
       }
 
       const migratedKeys = [];

data/app/controllers/rails_markup/annotations_controller.rb

@@ -88,8 +88,21 @@ module RailsMarkup
     def destroy
       client_uuid = normalized_route_uuid
       return render_invalid_uuid unless client_uuid
+      base_revision = normalized_base_revision
+      return render_invalid_base_revision unless base_revision
+
+      annotation = Annotation.find_by(client_uuid: client_uuid)
+      return head :no_content unless annotation
+
+      annotation.with_lock do
+        raise Annotation::RevisionConflict, annotation unless annotation.revision == base_revision
 
-      Annotation.find_by(client_uuid: client_uuid)&.destroy!
+        annotation.destroy!
+      end
+      head :no_content
+    rescue Annotation::RevisionConflict => error
+      render_revision_conflict(error)
+    rescue ActiveRecord::RecordNotFound
       head :no_content
     end
 
@@ -260,7 +273,7 @@ module RailsMarkup
     def render_revision_conflict(error)
       render json: {
         error: "revision conflict",
-        annotation: error.annotation.as_api_json
+        annotation: error.annotation.new_record? ? nil : error.annotation.as_api_json
       }, status: :conflict
     end
 

data/app/controllers/rails_markup/dashboard_controller.rb

@@ -106,7 +106,10 @@ module RailsMarkup
         return redirect_to root_path, alert: "Invalid status for bulk dismiss."
       end
 
-      count = Annotation.where(status: status).update_all(status: "dismissed")
+      # Bump revision per row so a stale toolbar edit (which checks baseRevision)
+      # conflicts (409) instead of silently overwriting this bulk dismiss.
+      count = Annotation.where(status: status)
+        .update_all("status = 'dismissed', revision = revision + 1")
       redirect_to root_path(status: "dismissed"), notice: "#{count} annotations dismissed."
     end
 
@@ -122,7 +125,11 @@ module RailsMarkup
       when "transition"
         new_status = params[:status]
         if Annotation::STATUSES.include?(new_status)
-          @annotation.update!(status: new_status)
+          # Lock + bump revision so a concurrent toolbar edit conflicts (409)
+          # instead of this board move silently losing to (or clobbering) it.
+          @annotation.with_lock do
+            @annotation.update!(status: new_status, revision: @annotation.revision + 1)
+          end
           return head :ok
         else
           return render json: { error: "invalid status" }, status: :unprocessable_entity

data/app/models/rails_markup/annotation.rb

@@ -26,6 +26,10 @@ module RailsMarkup
     LEGACY_SESSION_PATTERN = /\Arm-[0-9a-f]{16}\z/i
     LEGACY_CLIENT_ID_LIMIT = 256
     LEGACY_UUID_NAMESPACE = "265e7cf0-8be6-5e21-8f31-a582cfde8646"
+    # Bound thread growth so large or many reply/summary/reason messages (incl.
+    # via the MCP tools) can't grow a row without limit.
+    MAX_THREAD_ENTRIES = 500
+    MAX_THREAD_MESSAGE = 5000
 
     # Optional user association — no FK constraint, engine doesn't know host users table
     belongs_to :user, optional: true
@@ -45,6 +49,7 @@ module RailsMarkup
     validates :severity, inclusion: { in: SEVERITIES }
     validates :status, inclusion: { in: STATUSES }
     validate :thread_must_be_array
+    validate :thread_within_limits
 
     def self.valid_client_uuid?(value)
       value.is_a?(String) && CLIENT_UUID_PATTERN.match?(value)
@@ -208,5 +213,15 @@ module RailsMarkup
     def thread_must_be_array
       errors.add(:thread, "must be an array") unless thread.is_a?(Array)
     end
+
+    def thread_within_limits
+      return unless thread.is_a?(Array)
+
+      errors.add(:thread, "cannot exceed #{MAX_THREAD_ENTRIES} entries") if thread.size > MAX_THREAD_ENTRIES
+
+      if thread.any? { |entry| entry.is_a?(Hash) && entry["message"].to_s.length > MAX_THREAD_MESSAGE }
+        errors.add(:thread, "entry message cannot exceed #{MAX_THREAD_MESSAGE} characters")
+      end
+    end
   end
 end

data/lib/rails_markup/mcp_server.rb

@@ -22,6 +22,9 @@ module RailsMarkup
     class ToolError < StandardError; end
     class TargetError < ToolError; end
 
+    MAX_ACTION_MESSAGE_LENGTH = 5_000
+    MAX_ACTION_MESSAGE_BYTES = 5_000
+
     ENV_SCHEMA = {
       environment: {
         type: "string",
@@ -74,7 +77,11 @@ module RailsMarkup
           properties: {
             action: { type: "string", enum: %w[acknowledge resolve], description: "State transition to apply." },
             annotationId: { type: "string", description: "The annotation ID" },
-            summary: { type: "string", description: "Optional resolution summary; valid only for resolve." },
+            summary: {
+              type: "string",
+              maxLength: MAX_ACTION_MESSAGE_LENGTH,
+              description: "Optional resolution summary; valid only for resolve."
+            },
             **ENV_SCHEMA
           },
           required: %w[action annotationId],
@@ -89,7 +96,7 @@ module RailsMarkup
           type: "object",
           properties: {
             annotationId: { type: "string", description: "The annotation ID" },
-            message: { type: "string", description: "Reply message" },
+            message: { type: "string", maxLength: MAX_ACTION_MESSAGE_LENGTH, description: "Reply message" },
             **ENV_SCHEMA
           },
           required: %w[annotationId message],
@@ -104,7 +111,7 @@ module RailsMarkup
           type: "object",
           properties: {
             annotationId: { type: "string", description: "The annotation ID" },
-            reason: { type: "string", description: "Reason for dismissal" },
+            reason: { type: "string", maxLength: MAX_ACTION_MESSAGE_LENGTH, description: "Reason for dismissal" },
             **ENV_SCHEMA
           },
           required: %w[annotationId reason],
@@ -372,11 +379,14 @@ module RailsMarkup
         return "action must be acknowledge or resolve." unless %w[acknowledge resolve].include?(args["action"])
         return "annotationId must be a non-empty string." unless nonempty_string?(args["annotationId"])
         return "summary must be a string." if args.key?("summary") && !args["summary"].is_a?(String)
+        return oversized_action_message_error("summary", args["summary"]) if oversized_action_message?(args["summary"])
         return "summary is only valid for resolve." if args["action"] != "resolve" && args.key?("summary")
       when "rails_markup_reply"
         return "annotationId and message must be non-empty strings." unless nonempty_string?(args["annotationId"]) && nonempty_string?(args["message"])
+        return oversized_action_message_error("message", args["message"]) if oversized_action_message?(args["message"])
       when "rails_markup_dismiss"
         return "annotationId and reason must be non-empty strings." unless nonempty_string?(args["annotationId"]) && nonempty_string?(args["reason"])
+        return oversized_action_message_error("reason", args["reason"]) if oversized_action_message?(args["reason"])
       when "rails_markup_watch"
         return "sessionId must be a non-empty string." if args.key?("sessionId") && !nonempty_string?(args["sessionId"])
         unless !args.key?("timeoutSeconds") || numeric_between?(args["timeoutSeconds"], 0, 300)
@@ -400,6 +410,14 @@ module RailsMarkup
       value.is_a?(Numeric) && value.finite? && value.between?(minimum, maximum)
     end
 
+    def oversized_action_message?(value)
+      value.is_a?(String) && value.bytesize > MAX_ACTION_MESSAGE_BYTES
+    end
+
+    def oversized_action_message_error(name, _value)
+      "#{name} exceeds #{MAX_ACTION_MESSAGE_BYTES} bytes."
+    end
+
     def invalid_arguments_response(id, _unknown)
       tool_error_response(id, "Remove unsupported arguments.")
     end

data/lib/rails_markup/store.rb

@@ -22,6 +22,7 @@ module RailsMarkup
     MAX_TARGET_BYTES = 16_384
     MAX_SELECTED_TEXT_BYTES = 2_000
     MAX_METADATA_BYTES = 65_536
+    MAX_THREAD_MESSAGE_BYTES = 5_000
     INTENTS = %w[fix change question approve].freeze
     SEVERITIES = %w[suggestion important blocking].freeze
 
@@ -119,35 +120,64 @@ module RailsMarkup
     # --- Status transitions ---
 
     def acknowledge(annotation_id)
-      update_status(annotation_id, "acknowledged")
+      @mutex.synchronize do
+        ann = @annotations_index[annotation_id]
+        return nil unless ann
+        return ann if ann.status == "acknowledged"
+
+        validate_transition!(ann, "acknowledged", from: %w[pending])
+        ann.status = "acknowledged"
+        ann
+      end
     end
 
     def resolve(annotation_id, summary: nil)
-      ann = update_status(annotation_id, "resolved")
-      return nil unless ann
+      changed = false
+      ann = @mutex.synchronize do
+        annotation = @annotations_index[annotation_id]
+        return nil unless annotation
+        return annotation if annotation.status == "resolved"
+
+        validate_transition!(annotation, "resolved", from: %w[pending acknowledged])
+        append_thread_message!(annotation, summary) unless summary.nil? || summary == ""
+        annotation.status = "resolved"
+        changed = true
+        annotation
+      end
+      return ann unless changed
 
-      ann.thread << { role: "agent", message: summary, timestamp: Time.now.iso8601 } if summary
       notify(ann.session_id, type: "annotation_update", annotation: serialize_annotation(ann),
                              status: "resolved", summary: summary)
       ann
     end
 
     def dismiss(annotation_id, reason: nil)
-      ann = update_status(annotation_id, "dismissed")
-      return nil unless ann
+      changed = false
+      ann = @mutex.synchronize do
+        annotation = @annotations_index[annotation_id]
+        return nil unless annotation
+        return annotation if annotation.status == "dismissed"
+
+        validate_transition!(annotation, "dismissed", from: %w[pending acknowledged])
+        append_thread_message!(annotation, reason) unless reason.nil? || reason == ""
+        annotation.status = "dismissed"
+        changed = true
+        annotation
+      end
+      return ann unless changed
 
-      ann.thread << { role: "agent", message: reason, timestamp: Time.now.iso8601 } if reason
       notify(ann.session_id, type: "annotation_update", annotation: serialize_annotation(ann),
                              status: "dismissed", reason: reason)
       ann
     end
 
     def reply(annotation_id, message:)
-      ann = get_annotation(annotation_id)
-      return nil unless ann
+      ann = @mutex.synchronize do
+        annotation = @annotations_index[annotation_id]
+        return nil unless annotation
 
-      @mutex.synchronize do
-        ann.thread << { role: "agent", message: message, timestamp: Time.now.iso8601 }
+        append_thread_message!(annotation, message)
+        annotation
       end
       notify(ann.session_id, type: "annotation_update", annotation: serialize_annotation(ann),
                              status: ann.status, message: message)
@@ -201,12 +231,26 @@ module RailsMarkup
 
     private
 
-    def update_status(annotation_id, new_status)
-      ann = get_annotation(annotation_id)
-      return nil unless ann
+    def validate_transition!(annotation, new_status, from:)
+      return if from.include?(annotation.status)
 
-      @mutex.synchronize { ann.status = new_status }
-      ann
+      raise ValidationError, "cannot transition #{annotation.status} annotation to #{new_status}"
+    end
+
+    def append_thread_message!(annotation, message)
+      validate_string!("message", message, maximum: MAX_THREAD_MESSAGE_BYTES)
+      new_thread = annotation.thread + [{ role: "agent", message: message, timestamp: Time.now.iso8601 }]
+      enforce_thread_capacity!(annotation, new_thread)
+      annotation.thread = new_thread
+    end
+
+    def enforce_thread_capacity!(annotation, new_thread)
+      current_bytes = aggregate_annotation_bytes
+      proposed_bytes = current_bytes - annotation_storage_bytes(annotation) +
+        annotation_storage_bytes(annotation, thread: new_thread)
+      return if proposed_bytes <= @max_annotation_bytes
+
+      raise CapacityError, "aggregate annotation byte limit of #{@max_annotation_bytes} reached"
     end
 
     def notify(session_id, data)
@@ -235,7 +279,7 @@ module RailsMarkup
       raise ValidationError, "metadata exceeds #{MAX_METADATA_BYTES} bytes" if metadata_bytes > MAX_METADATA_BYTES
 
       JSON.generate(
-        target:, content:, intent:, severity:, selected_text:, metadata: metadata || {}
+        target:, content:, intent:, severity:, selected_text:, metadata: metadata || {}, thread: []
       ).bytesize
     rescue JSON::GeneratorError, Encoding::UndefinedConversionError
       raise ValidationError, "annotation fields must be JSON serializable"
@@ -268,22 +312,27 @@ module RailsMarkup
         raise CapacityError, "session annotation limit of #{@max_annotations_per_session} reached"
       end
 
-      current_bytes = @sessions.values.sum do |stored_session|
-        stored_session.annotations.sum { |annotation| annotation_storage_bytes(annotation) }
-      end
+      current_bytes = aggregate_annotation_bytes
       return if current_bytes + incoming_bytes <= @max_annotation_bytes
 
       raise CapacityError, "aggregate annotation byte limit of #{@max_annotation_bytes} reached"
     end
 
-    def annotation_storage_bytes(annotation)
+    def aggregate_annotation_bytes
+      @sessions.values.sum do |stored_session|
+        stored_session.annotations.sum { |annotation| annotation_storage_bytes(annotation) }
+      end
+    end
+
+    def annotation_storage_bytes(annotation, thread: annotation.thread)
       JSON.generate(
         target: annotation.target,
         content: annotation.content,
         intent: annotation.intent,
         severity: annotation.severity,
         selected_text: annotation.selected_text,
-        metadata: annotation.metadata
+        metadata: annotation.metadata,
+        thread: thread
       ).bytesize
     end
 

data/lib/rails_markup/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsMarkup
-  VERSION = "1.4.0"
+  VERSION = "1.4.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-markup
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.4.2
 platform: ruby
 authors:
 - InventList