parse-stack-next 5.5.5 → 5.5.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ef7d7de047cc0a3b4a21f3b080745f36f67cd2a53a81787fe53fdbb68fc3ec41
-  data.tar.gz: 74af45b9e2f334ca13c99419fe71d1653b9a218dffcf2a02ff801088ab86850b
+  metadata.gz: b8f26110cea78b4a3fc393dce2ac3aada7d73442f7d1e970e2aa71d88d3ecba2
+  data.tar.gz: 753ead47dcc377ba89e5eca4d2e93a3f7767f5e71a168124f6f180fe7549b5a1
 SHA512:
-  metadata.gz: e31f81f269bf874438617b00a01f1fb095fc7853f544d0a38f02aff8f58e21b14e8561650e3d3fb29bad6ff6276722992451a4f78b640481de3e5ab421cd033a
-  data.tar.gz: 71063ac383cb393af56969a1b631885585f5863b764218d7bee65b79a34cc9b469a885e96cf5bac5239ec66c140602e2bbe8197a46fa90ff4568cb240571e80f
+  metadata.gz: c1261b7e8db1b2d61e69fe70a1327829afd8d4c1b0960cb1ca1b3d5b418fcbc81b21dc05921a59865d7c226108392f0c3968a982277410872585b5cc4f42760a
+  data.tar.gz: 64f53a649209415edf4c3cecaab383f5ea01e0f106711ae867bfc7ac6d506dde592bd09b628a7956ccb621428ff4cea9c6f5970660d40465581496092b3d18ee

data/CHANGELOG.md

@@ -1,5 +1,118 @@
 ## parse-stack-next Changelog
 
+### 5.5.6
+
+#### MCP clients now receive the SSE response instead of hanging
+
+- **FIXED**: The Streamable HTTP SSE transport framed its events with custom
+  event names — `event: progress` for `notifications/progress` and
+  `event: response` for the final JSON-RPC response. MCP defines a single SSE
+  event type for JSON-RPC traffic, and clients match only the default
+  `message` type, so every frame the SDK emitted was silently discarded: tool
+  progress never surfaced, and, critically, the terminating response never
+  arrived, leaving the client blocked until its own timeout on any streaming
+  `tools/call`. All frames on both the request-scoped POST stream and the
+  server-to-client GET notification stream now carry `event: message`, and
+  clients discriminate from the JSON-RPC envelope (`method` present for a
+  notification, `id` plus `result`/`error` for a response) as the protocol
+  intends. Deployments that worked around this with a middleware rewriting
+  the event name can drop it.
+
+### 5.5.5
+
+#### Agent `call_method` runs under the caller's scope, not the master key
+
+- **FIXED**: Instance `call_method` resolved its receiver with a bare
+  `klass.find` on the master-backed default client, so a scoped agent could
+  read — and through a write method, mutate — any object by id. The receiver
+  (both the real call and the dry-run existence check) is now fetched through
+  the requesting agent's scope: a session scope fetches with the session token
+  (Parse Server enforces ACL/CLP), an `acl_user` / `acl_role` scope routes
+  mongo-direct (ACL simulation), and a row the scope cannot read fails closed
+  to "not found". The method body runs inside the caller's session so its own
+  writes inherit the same principal, and an instance write/admin method under
+  an `acl_user` / `acl_role` scope — which has no session token to bind — is
+  refused rather than run with master authority.
+- **FIXED**: Aggregation pipelines now default-deny joins under an active
+  tenant scope. A `$lookup` / `$graphLookup` / `$unionWith` sub-pipeline runs
+  in the joined collection's context with no tenant predicate injected, so any
+  such join could surface rows from other tenants; all are refused while a
+  tenant scope is active. The `$unionWith` bare-string shorthand
+  (`{ "$unionWith" => "Class" }`) is now covered by that guard as well as the
+  class-allowlist, hidden/underscore, and CLP-`find` gates, which previously
+  inspected only the Hash form.
+- **IMPROVED**: Unimplemented agent tools now raise a typed
+  `Parse::Agent::NotImplemented` error, and tools without a handler are omitted
+  from tool listings.
+
+#### Blank or injected credentials no longer escalate to the master key
+
+- **FIXED**: An explicitly-supplied blank or whitespace `session_token:` no
+  longer falls through to the master key. It now fails closed to an anonymous
+  request (master suppressed, no session header) and does not fall back to a
+  bound or ambient token. `Parse.with_session` likewise rejects a blank token
+  at the source instead of storing a whitespace ambient that the request layer
+  would then drop.
+- **FIXED**: The control options `use_master_key` and `session` can no longer
+  be set from a string-keyed conditions hash — the "forward a request params
+  hash straight into `Query.new` / `where`" pattern. `{"use_master_key" =>
+  true}` from untrusted params was an ACL/CLP-bypass mass-assignment; these two
+  keys are now honored only when passed as symbols (code-authored), and a
+  string form is treated as an ordinary field constraint with a warning.
+
+#### Atlas Search and aggregation stay ACL-scoped
+
+- **FIXED**: Atlas Search keeps `$search` at pipeline stage 0 while running the
+  scoped ACL/CLP enforcement chain (ACL `$match` folded after `$search`,
+  protectedFields strip, pointerFields filter, and a protected-field `$expr`
+  oracle guard). Query-derived constraints on the builder-block, options, and
+  autocomplete paths are converted to MongoDB storage form before the
+  post-`$search` `$match`, so a pointer/date/objectId constraint targets the
+  correct storage column and no longer fails BSON serialization.
+- **FIXED**: `search_with_stage` rejects a non-`$search` stage and any
+  `returnStoredSource`, which could otherwise return only index-stored fields
+  (without `_rperm`), be read as public by the ACL match, and leak restricted
+  rows.
+- **FIXED**: A scoped `$geoNear` folds the ACL predicate into `$geoNear.query`
+  rather than prepending a `$match`, keeping `$geoNear` at stage 0 so the query
+  no longer fails under ACL scoping. The fold embeds a copy of the caller's
+  existing query so the caller's pipeline is not mutated.
+
+#### Outbound fetches and the shipped CLI are hardened
+
+- **FIXED**: `parse-console --url` now parses and scheme-validates its argument
+  (HTTP(S) only) before fetching, instead of passing it to `Kernel#open` —
+  closing a path where a `|command` argument would be executed as a subprocess.
+- **IMPROVED**: The Cohere reranker `base_url` is validated to reject
+  credentials embedded in the URL and plaintext HTTP to non-loopback hosts.
+- **IMPROVED**: Remote file/image fetches enforce a streaming size cap that
+  aborts mid-download; the per-call `max_bytes:` ceiling is validated as a
+  positive integer, so a zero, negative, or non-numeric value is refused up
+  front rather than silently rejecting every response.
+
+#### Redaction, locking, and API ergonomics
+
+- **IMPROVED**: Query-string credential redaction for logging and request
+  profiling is now a single shared implementation, so the two cannot drift. It
+  redacts the value of any credential-bearing parameter name (matched by a
+  generic rule with a safe-list, and aware of percent-encoded names) and uses
+  possessive-quantifier matching so it stays linear on pathological URLs.
+- **FIXED**: The in-process fallback mutex registry (used when no shared lock
+  store is configured) is bounded, and its eviction can no longer reclaim a
+  mutex a caller is about to lock — a pending-acquirer reservation prevents two
+  callers from getting distinct mutexes for the same key.
+- **IMPROVED**: `call_function` and `trigger_job` accept request options as
+  bare keyword arguments (for example `call_function("f", {}, session_token:
+  t)`), merged with the explicit `opts:` hash for back-compat.
+
+#### Packaging, CI, and docs
+
+- **CHANGED**: The shipped-gem file list was narrowed to an allowlist of the
+  library, binaries, docs, examples, and standard metadata.
+- **CHANGED**: The SHA-pinned `ruby/setup-ruby` GitHub action was bumped to
+  `v1.318.0` across the CI, docs, and release workflows.
+- **IMPROVED**: README, test-server, and guide updates, plus YARD styling.
+
 ### 5.5.4
 
 #### Dependency updates

data/lib/parse/agent/mcp_rack_app.rb

@@ -1183,10 +1183,21 @@ module Parse
       # Wire format for each SSE event (note: trailing blank line is required
       # by the SSE spec):
       #
-      #   event: progress\n
+      #   event: message\n
       #   data: <json>\n
       #   \n
       #
+      # EVERY frame — progress notifications, list-changed notifications,
+      # and the final JSON-RPC response alike — carries the event name
+      # `message`. MCP Streamable HTTP defines exactly one SSE event type
+      # for JSON-RPC traffic; clients discriminate by inspecting the
+      # envelope (`method` present => notification, `id` + `result`/`error`
+      # => response), NOT by the SSE event name. Earlier releases emitted
+      # `event: progress` and `event: response`, which real MCP clients
+      # silently discard — they match only the default `message` type — so
+      # the final response never arrived and the call appeared to hang.
+      # Do not reintroduce custom event names.
+      #
       # @api private
       class SSEBody
         # Sentinel pushed to the queue when the worker is done.
@@ -1546,6 +1557,9 @@ module Parse
         # The `total` field is omitted (rather than nil) so the wire
         # shape matches the spec's optional-field convention.
         #
+        # Emitted as `event: message` — see the SSEBody class docs. The
+        # payload's `method` is what marks it as progress.
+        #
         # @param elapsed [Float] seconds elapsed since the stream started.
         # @return [String] SSE event string (includes trailing blank line).
         def build_progress_event(elapsed)
@@ -1557,15 +1571,14 @@ module Parse
               "progress"      => elapsed,
             },
           })
-          "event: progress\ndata: #{data}\n\n"
+          "event: message\ndata: #{data}\n\n"
         end
 
         # Format a `notifications/tools/list_changed` or
         # `notifications/prompts/list_changed` SSE event. Both
         # notifications have no `params` — the wire shape is just the
-        # JSON-RPC envelope with `method` set. SSE event name is
-        # "message" since this is not a progress notification (the
-        # progress event name is reserved for progress notifications).
+        # JSON-RPC envelope with `method` set. Emitted as `event: message`,
+        # like every other frame on this stream.
         #
         # @param method [String] full MCP method string.
         # @return [String] SSE event string (includes trailing blank line).
@@ -1599,7 +1612,7 @@ module Parse
             "method"  => "notifications/progress",
             "params"  => params,
           })
-          "event: progress\ndata: #{data}\n\n"
+          "event: message\ndata: #{data}\n\n"
         end
 
         # Build the callback the dispatcher block passes into
@@ -1631,12 +1644,17 @@ module Parse
           end
         end
 
-        # Format the final `response` SSE event.
+        # Format the final JSON-RPC response SSE event.
+        #
+        # Emitted as `event: message` (NOT `event: response`) — an MCP
+        # client matching only the default `message` type would otherwise
+        # discard the response and block until its own timeout. The
+        # envelope's `id` + `result`/`error` is what marks it final.
         #
         # @param body [Hash] JSON-RPC response envelope.
         # @return [String] SSE event string (includes trailing blank line).
         def build_response_event(body)
-          "event: response\ndata: #{JSON.generate(body)}\n\n"
+          "event: message\ndata: #{JSON.generate(body)}\n\n"
         end
 
         # Build an internal-error JSON-RPC envelope (id may be nil at this layer).
@@ -1755,9 +1773,9 @@ module Parse
           end
         end
 
-        # SSE wire form for a server→client notification. Event name "message"
-        # (not "progress"/"response", which are reserved for the request-scoped
-        # SSE path).
+        # SSE wire form for a server→client notification. Event name
+        # "message" — the single event type MCP Streamable HTTP defines for
+        # JSON-RPC traffic, matching the request-scoped SSE path.
         def format_event(notification)
           "event: message\ndata: #{JSON.generate(notification)}\n\n"
         end

data/lib/parse/stack/version.rb

@@ -6,6 +6,6 @@ module Parse
   # The Parse Server SDK for Ruby
   module Stack
     # The current version.
-    VERSION = "5.5.5"
+    VERSION = "5.5.6"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parse-stack-next
 version: !ruby/object:Gem::Version
-  version: 5.5.5
+  version: 5.5.6
 platform: ruby
 authors:
 - Adrian Curtin