A platform for community discussion. Free, open, simple.
FEATURE: Add an MCP server (#42798)
Rafael dos Santos Silva73b144a29bb2
diff --git a/app/assets/stylesheets/common/base/_index.scss b/app/assets/stylesheets/common/base/_index.scssindex 5821c631011..7cedc861905 100644--- a/app/assets/stylesheets/common/base/_index.scss+++ b/app/assets/stylesheets/common/base/_index.scss@@ -69,3 +69,4 @@@import "user-badges";@import "user-tips";@import "embed-mode";+@import "_mcp";diff --git a/app/assets/stylesheets/common/base/_mcp.scss b/app/assets/stylesheets/common/base/_mcp.scssnew file mode 100644index 00000000000..439affeba19--- /dev/null+++ b/app/assets/stylesheets/common/base/_mcp.scss@@ -0,0 +1,668 @@+@use "lib/viewport";++.admin-mcp {+ &__overview-grid {+ display: grid;+ grid-template-columns: repeat(auto-fit, minmax(min(100%, 20rem), 1fr));+ gap: var(--space-4);+ }++ &__endpoint {+ display: flex;+ align-items: center;+ gap: var(--space-2);+ margin-bottom: var(--space-4);++ code {+ overflow-wrap: anywhere;+ }+ }++ &__summary-list,+ &__detail-list {+ display: grid;+ gap: var(--space-2);+ margin: 0;++ div {+ display: flex;+ justify-content: space-between;+ gap: var(--space-4);+ }++ dt {+ color: var(--primary-medium);+ }++ dd {+ margin: 0;+ text-align: end;+ }+ }++ &__metric-grid {+ display: grid;+ grid-template-columns: repeat(auto-fit, minmax(8rem, 1fr));+ gap: var(--space-4);+ margin: 0;++ dt {+ color: var(--primary-medium);+ font-size: var(--font-down-1);+ }++ dd {+ margin: 0.25rem 0 0;+ font-size: var(--font-up-2);+ font-weight: bold;+ }+ }++ &__checklist {+ display: grid;+ gap: var(--space-2);+ margin: 0;+ padding-inline-start: 0;+ list-style: none;++ li {+ display: flex;+ align-items: center;+ gap: var(--space-2);+ }++ .is-complete {+ color: var(--success);+ }+ }++ &__warnings {+ margin-top: var(--space-4);+ padding: var(--space-4);+ border: 1px solid var(--danger);+ background: var(--danger-low);++ h2 {+ margin-top: 0;+ font-size: var(--font-up-1);+ }+ }++ &__scope-select {+ width: min(100%, 50rem);++ .d-multi-select-trigger__selection-label {+ max-width: none;+ }+ }++ &__scope-select-content {+ width: min(22rem, calc(100vw - 2rem));+ }++ &__scope-option {+ display: flex;+ flex-direction: column;++ small {+ color: var(--primary-medium);+ }+ }++ &__access-table {+ width: 100%;+ margin-bottom: var(--space-4);++ .--overview {+ width: 30%;+ }++ .--controls {+ width: 1%;+ white-space: nowrap;+ }++ .d-table__overview-name {+ display: block;+ }++ small {+ color: var(--primary-medium);+ }+ }++ &__access-scopes {+ display: flex;+ flex-wrap: wrap;+ gap: var(--space-1);+ margin: 0;+ padding: 0;+ list-style: none;+ }++ &__access-form {+ max-width: 50rem;+ padding-top: var(--space-4);+ border-top: 1px solid var(--primary-low);+ }++ &__access-form-actions {+ display: flex;+ align-items: center;+ gap: var(--space-2);+ }++ &__primitive-filters {+ display: grid;+ grid-template-columns: repeat(auto-fit, minmax(min(100%, 12rem), 1fr));+ gap: var(--space-2);+ margin-bottom: var(--space-4);++ .form-kit__field {+ min-width: 0;+ margin: 0;+ }++ .form-kit__control-select {+ width: 100%;+ }+ }++ &__activity-filters {+ display: flex;+ flex-flow: row wrap;+ align-items: end;+ gap: var(--space-2);+ margin-bottom: var(--space-2);++ .form-kit__field {+ flex: 0 1 auto;+ margin: 0;+ }++ .admin-mcp__filter-search {+ flex: 1 1 24rem;+ min-width: 0;+ max-width: 24rem;+ }++ .form-kit__field-select {+ flex: 0 1 10rem;+ min-width: 0;+ }++ .form-kit__control-input,+ .form-kit__control-select {+ width: 100%;+ }+ }++ &__uri-list {+ display: grid;+ gap: var(--space-1);+ margin: 0;+ padding: 0;+ list-style: none;++ code {+ overflow-wrap: anywhere;+ }+ }++ &__results-count {+ margin: var(--space-1) 0 0;+ color: var(--primary-medium);+ font-size: var(--font-down-1);+ }++ &__primitive-selection-form {+ --mcp-primitive-actions-offset: var(--space-3);++ &.has-floating-actions {+ padding-block-end: calc(+ var(--mcp-primitive-actions-height, 4em) ++ var(--mcp-primitive-actions-offset) + var(--space-4)+ );+ }++ .footer-nav-visible & {+ --mcp-primitive-actions-offset: calc(+ var(--footer-nav-height) + env(safe-area-inset-bottom) + var(--space-4)+ );+ }++ .form-kit__actions.is-floating {+ box-sizing: border-box;+ position: fixed;+ inset-block-end: var(--mcp-primitive-actions-offset);+ z-index: z("base");+ flex-wrap: wrap;+ padding: var(--space-3);+ border: 1px solid var(--primary-300);+ border-radius: var(--d-border-radius);+ background-color: var(--secondary);+ box-shadow: var(--shadow-card);+ }+ }++ &__primitive-browser {+ display: grid;+ width: 100%;+ gap: var(--space-4);+ margin-bottom: var(--space-4);++ @include viewport.from(md) {+ grid-template-columns: minmax(12rem, 16rem) minmax(0, 1fr);+ align-items: start;+ }+ }++ &__primitive-groups {+ padding: var(--space-1);+ border: 1px solid var(--token-color-border-default);+ border-radius: var(--d-border-radius);+ }++ &__primitive-group-list {+ display: grid;+ grid-template-columns: repeat(auto-fit, minmax(min(100%, 10rem), 1fr));+ gap: var(--space-1);+ margin: 0;+ padding: 0;+ list-style: none;++ @include viewport.from(md) {+ grid-template-columns: minmax(0, 1fr);+ }+ }++ &__primitive-group {+ box-sizing: border-box;+ display: flex;+ flex-direction: column;+ gap: var(--space-1);+ width: 100%;+ min-width: 0;+ padding: var(--space-2);+ border: 0;+ border-radius: var(--d-border-radius);+ background: transparent;+ color: var(--token-color-text-default);+ text-align: start;+ overflow-wrap: anywhere;+ cursor: pointer;++ small {+ color: var(--token-color-text-subtle);+ font-weight: normal;+ }++ &.is-selected {+ background: var(--token-color-surface-selected);+ font-weight: var(--token-font-weight-semibold);+ }++ &:focus-visible {+ outline: 2px solid var(--token-color-border-focused);+ outline-offset: -2px;+ }+ }++ &__primitive-panel {+ min-width: 0;+ }++ &__primitive-panel-header {+ padding-block: var(--space-3);++ h3 {+ margin: 0;+ font-size: var(--font-up-1);+ }+ }++ &__primitive-group-actions {+ display: flex;+ flex-wrap: wrap;+ gap: var(--space-2);+ margin-top: var(--space-3);++ @include viewport.until(sm) {+ .btn {+ flex: 1 1 auto;+ }+ }+ }++ &__primitive-list {+ display: grid;+ width: 100%;+ gap: var(--space-2);+ margin-top: var(--space-4);+ margin-bottom: var(--space-4);+ }++ &__primitive {+ position: relative;+ padding: var(--space-3);+ padding-inline-end: calc(var(--space-3) + 2.5rem);+ border: 1px solid var(--content-border-color);+ border-radius: var(--d-border-radius);++ .form-kit__container-content,+ .form-kit__control-checkbox-label {+ width: 100%;+ max-width: none;+ }++ .form-kit__control-checkbox-content {+ flex: 1 1 auto;+ min-width: 0;+ }+ }++ &__primitive-meta {+ display: flex;+ flex-wrap: wrap;+ gap: var(--space-2) var(--space-4);+ margin-block: var(--space-2) 0;+ margin-inline: 2rem 0;+ color: var(--primary-medium);+ font-size: var(--font-down-1);++ div {+ display: flex;+ gap: 0.25rem;+ }++ dt::after {+ content: ":";+ }++ dd {+ margin: 0;+ }+ }++ &__primitive-actions {+ position: absolute;+ inset-block-start: var(--space-2);+ inset-inline-end: var(--space-2);+ }++ &__status {+ display: inline-block;+ padding: 0.15em 0.55em;+ border-radius: 1em;+ background: var(--primary-low);+ color: var(--primary-high);+ font-size: var(--font-down-1);+ font-weight: 600;+ white-space: nowrap;++ &[data-state="approved"],+ &[data-state="active"],+ &[data-state="success"] {+ background: var(--success-low);+ color: var(--success);+ }++ &[data-state="pending"],+ &[data-state="server_disabled"],+ &[data-state="client_not_approved"],+ &[data-state="consent_required"],+ &[data-state="rate_limited"] {+ background: var(--tertiary-low);+ color: var(--tertiary-high);+ }++ &[data-state="blocked"],+ &[data-state="client_blocked"],+ &[data-state="access_removed"],+ &[data-state="user_unavailable"],+ &[data-state="revoked"],+ &[data-state="error"] {+ background: var(--danger-low);+ color: var(--danger);+ }+ }++ &__form-card {+ max-width: 50rem;+ }++ &__unavailable {+ margin-block: var(--space-2) 0;+ margin-inline: 2rem 0;+ color: var(--danger);+ }++ &__table-filter {+ width: min(100%, 24rem);+ margin-bottom: var(--space-4);++ .form-kit__field {+ margin: 0;+ }+ }++ &__table {+ width: 100%;+ margin-bottom: var(--space-4);++ small {+ display: block;+ overflow-wrap: anywhere;+ color: var(--primary-medium);+ }+ }++ &__authorizations-table {+ @include viewport.from(md) {+ table-layout: fixed;+ }+ }++ &__authorizations-client-column {+ @include viewport.from(md) {+ width: 20%;+ }+ }++ &__authorizations-user-column {+ @include viewport.from(md) {+ width: 10%;+ }+ }++ &__authorizations-scopes-column {+ @include viewport.from(md) {+ width: 37%;+ }+ }++ &__authorizations-last-used-column,+ &__authorizations-status-column {+ @include viewport.from(md) {+ width: 12%;+ }+ }++ &__authorizations-actions-column {+ @include viewport.from(md) {+ width: 9%;+ }+ }++ &__detail-list {+ max-width: 50rem;++ div {+ justify-content: flex-start;+ }++ dt {+ flex: 0 0 12rem;+ }++ dd {+ text-align: start;+ overflow-wrap: anywhere;+ }+ }++ &__activity-filters {+ margin-bottom: var(--space-4);+ }++ &__activity-metrics {+ margin-bottom: var(--space-4);+ padding: var(--space-4);+ border: 1px solid var(--content-border-color);+ border-radius: var(--d-border-radius);+ background: var(--secondary);+ }+}++.user-mcp-authorizations {+ margin-top: var(--space-6);++ &__table {+ margin-top: var(--space-4);++ @include viewport.from(md) {+ table-layout: fixed;+ }+ }++ &__application-column {+ @include viewport.from(md) {+ width: 30%;+ }+ }++ &__status-column {+ @include viewport.from(md) {+ width: 20%;+ }+ }++ &__empty {+ color: var(--primary-medium);+ }+}++.user-mcp-authorization {+ &__application {+ overflow-wrap: anywhere;+ }++ &__status {+ display: inline-block;+ padding: 0.15em 0.55em;+ border-radius: 1em;+ background: var(--primary-low);+ color: var(--primary-high);+ font-size: var(--font-down-1);+ font-weight: 600;+ white-space: nowrap;++ &[data-state="active"] {+ background: var(--success-low);+ color: var(--success);+ }++ &[data-state="server_disabled"],+ &[data-state="client_not_approved"],+ &[data-state="consent_required"] {+ background: var(--tertiary-low);+ color: var(--tertiary-high);+ }++ &[data-state="client_blocked"],+ &[data-state="access_removed"],+ &[data-state="user_unavailable"],+ &[data-state="revoked"] {+ background: var(--danger-low);+ color: var(--danger);+ }+ }++ &__status-details {+ display: flex;+ flex-direction: column;+ align-items: flex-start;+ gap: var(--space-1);+ }++ &__details {+ display: grid;+ gap: var(--space-1);+ color: var(--primary-medium);+ font-size: var(--font-down-1);+ }++ &__permissions {+ margin-top: var(--space-1);+ }++ &__permissions-toggle {+ font-size: inherit;+ }++ &__permissions-list {+ box-sizing: border-box;+ display: grid;+ gap: var(--space-1);+ max-width: 100%;+ margin: var(--space-1) 0 0;+ padding-inline-start: var(--space-2);+ color: var(--primary-medium);++ code {+ overflow-wrap: anywhere;+ }+ }+}++@media (max-width: $mobile-breakpoint) {+ .admin-mcp {+ &__activity-filters {+ flex-direction: column;+ align-items: stretch;++ > *,+ .form-kit__field {+ flex: 0 0 auto;+ width: 100%;+ }++ .admin-mcp__filter-search {+ max-width: 100%;+ }+ }++ &__table .d-table__cell.--detail {+ gap: var(--space-2);+ }++ &__primitive-meta {+ margin-inline-start: 0;+ }++ &__unavailable {+ margin-inline-start: 0;+ }++ &__detail-list {+ div {+ flex-direction: column;+ gap: 0;+ }++ dt {+ flex-basis: auto;+ }+ }+ }+}diff --git a/app/controllers/admin/mcp_activity_controller.rb b/app/controllers/admin/mcp_activity_controller.rbnew file mode 100644index 00000000000..9b143b83014--- /dev/null+++ b/app/controllers/admin/mcp_activity_controller.rb@@ -0,0 +1,15 @@+# frozen_string_literal: true++class Admin::McpActivityController < Admin::AdminController+ def index+ limit = fetch_limit_from_params(default: 50, max: 100)+ cursor = fetch_int_from_params(:cursor, default: nil, min: 1)+ render json:+ McpActivityReport.new(+ limit: limit,+ cursor: cursor,+ filter: params[:filter],+ outcome: params[:outcome],+ ).call+ end+enddiff --git a/app/controllers/admin/mcp_authorizations_controller.rb b/app/controllers/admin/mcp_authorizations_controller.rbnew file mode 100644index 00000000000..fee675f1f15--- /dev/null+++ b/app/controllers/admin/mcp_authorizations_controller.rb@@ -0,0 +1,56 @@+# frozen_string_literal: true++class Admin::McpAuthorizationsController < Admin::AdminController+ def index+ page =+ McpOauthAuthorizationsPage.new(+ limit: fetch_limit_from_params(default: 50, max: 100),+ cursor: fetch_int_from_params(:cursor, default: nil, min: 1),+ filter: params[:filter],+ ).call+ statuses = DiscourseMcp::AuthorizationStatus.for(page.records)+ render json: {+ authorizations:+ page.records.map do |authorization|+ serialize(authorization, status: statuses.fetch(authorization.id))+ end,+ meta: {+ next_cursor: page.next_cursor,+ },+ }+ end++ def destroy+ authorization = McpOauthAuthorization.find(params[:id])+ authorization.revoke!(by_user: current_user, reason: "admin_revoked")+ StaffActionLogger.new(current_user).log_custom(+ "mcp_authorization_revoked",+ authorization_id: authorization.id,+ subject_user_id: authorization.user_id,+ client_id: authorization.mcp_oauth_client_id,+ )+ head :no_content+ end++ private++ def serialize(authorization, status:)+ active_tokens =+ authorization.access_tokens.select do |token|+ token.revoked_at.nil? && token.expires_at.future?+ end+ {+ id: authorization.id,+ username: authorization.user&.username,+ client_name: authorization.client.name,+ client_id: authorization.client.client_id,+ resource: authorization.resource,+ status: status,+ scopes: authorization.scopes,+ consented_at: authorization.consented_at,+ revoked_at: authorization.revoked_at,+ last_used_at: authorization.access_tokens.filter_map(&:last_used_at).max,+ token_count: active_tokens.length,+ }+ end+enddiff --git a/app/controllers/admin/mcp_clients_controller.rb b/app/controllers/admin/mcp_clients_controller.rbnew file mode 100644index 00000000000..df261bb6ca5--- /dev/null+++ b/app/controllers/admin/mcp_clients_controller.rb@@ -0,0 +1,98 @@+# frozen_string_literal: true++class Admin::McpClientsController < Admin::AdminController+ def index+ page =+ McpOauthClientsPage.new(+ limit: fetch_limit_from_params(default: 50, max: 100),+ cursor: fetch_int_from_params(:cursor, default: nil, min: 1),+ filter: params[:filter],+ ).call+ render json: {+ clients: page.records.map { |client| serialize(client) },+ meta: {+ next_cursor: page.next_cursor,+ },+ }+ end++ def show+ render json: { client: serialize(client) }+ end++ def create+ client =+ McpOauthClient.create!(+ client_params.merge(registration_type: "pre_registered", trust_state: "approved"),+ )+ StaffActionLogger.new(current_user).log_custom("mcp_client_created", client_id: client.id)+ render json: { client: serialize(client) }, status: :created+ end++ def block+ blocked = ActiveModel::Type::Boolean.new.cast(params.fetch(:blocked, true))+ client.update!(trust_state: blocked ? "blocked" : "approved")+ if client.blocked?+ client.authorizations.active.find_each do |authorization|+ authorization.revoke!(by_user: current_user, reason: "client_blocked")+ end+ end+ StaffActionLogger.new(current_user).log_custom(+ "mcp_client_trust_updated",+ client_id: client.id,+ trust_state: client.trust_state,+ )+ render json: { client: serialize(client) }+ end++ def refresh+ raise Discourse::InvalidParameters if client.registration_type != "cimd"+ refreshed =+ DiscourseMcp::OAuth::ClientResolver.resolve!(+ client.client_id,+ force: true,+ user: current_user,+ )+ render json: { client: serialize(refreshed) }+ end++ private++ def client+ @client ||= McpOauthClient.find(params[:id])+ end++ def client_params+ params.require(:client).permit(:client_id, :name, redirect_uris: [])+ end++ def serialize(value)+ {+ id: value.id,+ client_id: value.client_id,+ name: value.name,+ domain: uri_host(value.client_id),+ registration_type: value.registration_type,+ trust_state: value.trust_state,+ blocked: value.blocked?,+ redirect_uris: value.redirect_uris,+ redirect_hosts: value.redirect_uris.filter_map { |uri| uri_host(uri) }.uniq,+ metadata_uri: value.metadata_uri,+ first_seen_at: value.created_at,+ last_seen_at: value.last_seen_at,+ authorization_count: authorization_count(value),+ }+ end++ def authorization_count(client)+ return client[:authorization_count] if client.has_attribute?(:authorization_count)++ client.authorizations.count+ end++ def uri_host(value)+ URI.parse(value).host+ rescue URI::InvalidURIError+ nil+ end+enddiff --git a/app/controllers/admin/mcp_controller.rb b/app/controllers/admin/mcp_controller.rbnew file mode 100644index 00000000000..6062fb20833--- /dev/null+++ b/app/controllers/admin/mcp_controller.rb@@ -0,0 +1,151 @@+# frozen_string_literal: true++class Admin::McpController < Admin::AdminController+ def overview+ exposed =+ McpPrimitive.exposed.filter_map do |policy|+ primitive = DiscourseMcp.registry.find(policy.kind, policy.identifier)+ next if !primitive&.available?+ primitive+ end+ enabled = SiteSetting.mcp_server_enabled+ metrics = {+ approved_oauth_clients: McpOauthClient.where(trust_state: "approved").count,+ authorizations: McpOauthAuthorization.active.count,+ tokens: McpOauthAccessToken.usable.count,+ errors:+ McpAuditLog.where("occurred_at > ?", 24.hours.ago).where.not(outcome: "success").count,+ }+ render json: {+ enabled: enabled,+ endpoint: DiscourseMcp.resource_url,+ protocol_version: DiscourseMcp::PROTOCOL_VERSION,+ server_version: Discourse::VERSION::STRING,+ status: enabled ? "available" : "disabled",+ catalog: {+ tools: exposed.count { |primitive| primitive.kind == :tool },+ resources:+ exposed.count { |primitive|+ %i[resource resource_template].include?(primitive.kind)+ },+ prompts: exposed.count { |primitive| primitive.kind == :prompt },+ schema_bytes:+ exposed.sum { |primitive| JSON.generate(primitive.input_schema).bytesize },+ },+ metrics: metrics,+ approved_oauth_clients: metrics[:approved_oauth_clients],+ active_authorizations: metrics[:authorizations],+ active_tokens: metrics[:tokens],+ recent_errors: metrics[:errors],+ setup_checklist: [+ {+ label: I18n.t("mcp.admin.site_enabled"),+ complete: SiteSetting.mcp_server_enabled,+ },+ { label: I18n.t("mcp.admin.primitives_enabled"), complete: exposed.present? },+ {+ label: I18n.t("mcp.admin.client_registered"),+ complete: metrics[:approved_oauth_clients].positive?,+ },+ ],+ warnings: [],+ }+ end++ def access+ render json: primitives_payload.merge(access_rules: access_rules_payload)+ end++ def primitives+ render json: primitives_payload+ end++ def update_access+ McpAccessRuleUpdater.replace!(+ actor: current_user,+ group_id: params.require(:group_id),+ scopes: params.require(:scopes),+ )+ access+ end++ def destroy_access+ McpAccessRuleUpdater.delete!(actor: current_user, group_id: params.require(:group_id))+ head :no_content+ end++ def update_primitives+ McpPrimitiveUpdater.update!(actor: current_user, primitive_ids: params[:primitive_ids])+ render json: primitives_payload+ end++ def emergency_block+ McpPrimitiveUpdater.set_emergency_block!(+ actor: current_user,+ primitive_id: params.require(:primitive_id),+ blocked: params.fetch(:blocked, true),+ )+ render json: { success: true }+ end++ private++ def primitives_payload+ primitive_records = McpPrimitive.all.index_by { |record| [record.kind, record.identifier] }+ primitives =+ DiscourseMcp::Primitive::KINDS.flat_map do |kind|+ DiscourseMcp+ .registry+ .all(kind)+ .map do |primitive|+ primitive_record = primitive_records[[kind.to_s, primitive.identifier]]+ primitive_payload(primitive, primitive_record)+ end+ end+ {+ initial_scope: DiscourseMcp::INITIAL_SCOPE,+ available_scopes: DiscourseMcp.registry.scopes,+ primitives: primitives,+ }+ end++ def access_rules_payload+ McpGroupScope.ensure_admins!+ rules =+ McpGroupScope+ .includes(:group)+ .order(:group_id, :scope)+ .group_by(&:group_id)+ .filter_map do |group_id, records|+ group = records.first.group+ next if group.blank?++ {+ group_id: group_id,+ group_name: group.name,+ scopes: (records.map(&:scope) | [DiscourseMcp::INITIAL_SCOPE]).sort,+ pre_registered: group_id == Group::AUTO_GROUPS[:admins],+ deletable: group_id != Group::AUTO_GROUPS[:admins],+ }+ end+ rules+ end++ def primitive_payload(primitive, primitive_record)+ {+ id: "#{primitive.kind}:#{primitive.identifier}",+ field_name:+ "primitive_#{primitive.kind}_#{Digest::SHA256.hexdigest(primitive.identifier).first(16)}",+ identifier: primitive.identifier,+ kind: primitive.kind,+ title: primitive.title,+ description: primitive.description,+ provider: primitive.provider,+ risk: primitive.risk,+ required_scopes: primitive.required_scopes,+ enabled: primitive_record&.enabled? || false,+ emergency_blocked: primitive_record&.emergency_blocked? || false,+ available: primitive.available?,+ }+ end+enddiff --git a/app/controllers/mcp_controller.rb b/app/controllers/mcp_controller.rbnew file mode 100644index 00000000000..e644007afdd--- /dev/null+++ b/app/controllers/mcp_controller.rb@@ -0,0 +1,135 @@+# frozen_string_literal: true++class McpController < ApplicationController+ skip_before_action :check_xhr, :preload_json, :verify_authenticity_token+ before_action :ensure_mcp_enabled+ before_action :validate_origin++ def create+ if !request.media_type.to_s.casecmp?("application/json")+ return(+ render json: jsonrpc_error(nil, -32_600, "Content-Type must be application/json"),+ status: :unsupported_media_type+ )+ end+ accept = request.headers["Accept"].to_s+ if !accept.include?("application/json") || !accept.include?("text/event-stream")+ return(+ render json:+ jsonrpc_error(+ nil,+ -32_600,+ "Accept must include application/json and text/event-stream",+ ),+ status: :not_acceptable+ )+ end++ request_context = DiscourseMcp::Authenticator.new(request).authenticate!+ enforce_rate_limits!(request_context)+ raw_payload = request.body.read(SiteSetting.mcp_max_request_bytes + 1) || ""+ if raw_payload.bytesize > SiteSetting.mcp_max_request_bytes+ return(+ render json: jsonrpc_error(nil, -32_600, "Request too large"), status: :payload_too_large+ )+ end++ payload = JSON.parse(raw_payload)+ mcp_response =+ DiscourseMcp::Server.new(request: request, request_context: request_context).call(payload)+ mcp_response.headers.each { |name, value| response.set_header(name, value) }+ return head mcp_response.http_status if mcp_response.body.nil?++ encoded_response = JSON.generate(mcp_response.body)+ if encoded_response.bytesize > SiteSetting.mcp_max_response_bytes+ return(+ render json: jsonrpc_error(payload["id"], -32_603, "Response too large"),+ status: :internal_server_error+ )+ end++ render json: encoded_response, status: mcp_response.http_status+ rescue RateLimiter::LimitExceeded => error+ record_rate_limited_audit(request_context)+ response.set_header("Retry-After", error.available_in.to_s)+ render json: jsonrpc_error(nil, -32_000, "Rate limit exceeded"), status: :too_many_requests+ rescue JSON::ParserError+ render json: jsonrpc_error(nil, -32_700, "Parse error"), status: :bad_request+ rescue DiscourseMcp::AuthenticationError => error+ response.set_header(+ "WWW-Authenticate",+ DiscourseMcp::Authenticator.challenge(+ scope: DiscourseMcp::INITIAL_SCOPE,+ error: error.oauth_error,+ ),+ )+ render json: jsonrpc_error(nil, -32_001, "Authorization required"), status: :unauthorized+ end++ def method_not_allowed+ head :method_not_allowed, allow: "POST"+ end++ private++ def enforce_rate_limits!(request_context)+ limit = SiteSetting.mcp_global_rate_limit_per_minute+ RateLimiter.new(+ request_context.user,+ "mcp-client-#{request_context.oauth_client_id}",+ limit,+ 1.minute,+ apply_limit_to_staff: true,+ ).performed!+ RateLimiter.new(+ nil,+ "mcp-ip-#{request.remote_ip}",+ limit,+ 1.minute,+ apply_limit_to_staff: true,+ ).performed!+ end++ def record_rate_limited_audit(request_context)+ bucket_at = Time.zone.now.beginning_of_minute+ audit_key =+ "mcp-rate-limit-audit:#{request_context&.user_id}:#{request_context&.oauth_client_id}:#{bucket_at.to_i}"+ return if !Discourse.redis.set(audit_key, "1", nx: true, ex: 2.minutes.to_i)++ McpAuditLog.create!(+ occurred_at: Time.zone.now,+ bucket_at:,+ user_id: request_context&.user_id,+ mcp_oauth_client_id: request_context&.oauth_client_id,+ outcome: "rate_limited",+ http_status: 429,+ )+ rescue StandardError => error+ Discourse.warn_exception(error, message: "MCP audit record failed")+ end++ def ensure_mcp_enabled+ raise Discourse::NotFound if !SiteSetting.mcp_server_enabled+ end++ def validate_origin+ origin = request.headers["Origin"]+ return if origin.blank?++ actual = URI.parse(origin)+ expected = URI.parse(DiscourseMcp.issuer)+ if actual.path.blank? && actual.userinfo.blank? &&+ [actual.scheme, actual.host, actual.port] ==+ [expected.scheme, expected.host, expected.port]+ return+ end++ render json: jsonrpc_error(nil, -32_001, "Invalid Origin"), status: :forbidden+ rescue URI::InvalidURIError+ render json: jsonrpc_error(nil, -32_001, "Invalid Origin"), status: :forbidden+ end++ def jsonrpc_error(id, code, message)+ { jsonrpc: "2.0", id: id, error: { code: code, message: message } }+ end+enddiff --git a/app/controllers/mcp_oauth_authorizations_controller.rb b/app/controllers/mcp_oauth_authorizations_controller.rbnew file mode 100644index 00000000000..345bf6be18d--- /dev/null+++ b/app/controllers/mcp_oauth_authorizations_controller.rb@@ -0,0 +1,90 @@+# frozen_string_literal: true++class McpOauthAuthorizationsController < ApplicationController+ layout "no_ember"+ requires_login+ skip_before_action :check_xhr, :preload_json+ skip_after_action :conditionally_allow_site_embedding+ before_action :validate_request+ before_action :ensure_mcp_access+ after_action :prevent_framing++ def show+ raise Discourse::InvalidAccess if current_user.is_impersonating+ @client = DiscourseMcp::OAuth::ClientResolver.resolve!(params[:client_id], user: current_user)+ validate_redirect!(@client)+ @requested_scopes = requested_scopes+ @granted_scopes =+ DiscourseMcp::OAuth::AuthorizationGrant.grantable_scopes(+ user: current_user,+ requested_scopes: @requested_scopes,+ )+ render :show+ end++ def create+ raise Discourse::InvalidAccess if current_user.is_impersonating+ client = DiscourseMcp::OAuth::ClientResolver.resolve!(params[:client_id], user: current_user)+ validate_redirect!(client)+ return redirect_with(error: "access_denied") if params[:decision] != "approve"++ authorization =+ DiscourseMcp::OAuth::AuthorizationGrant.create!(+ user: current_user,+ client: client,+ redirect_uri: params[:redirect_uri],+ requested_scopes: requested_scopes,+ )+ code =+ McpOauthAuthorizationCode.issue!(+ authorization: authorization,+ redirect_uri: params[:redirect_uri],+ resource: params[:resource],+ code_challenge: params[:code_challenge],+ )+ redirect_with(code: code)+ end++ private++ def prevent_framing+ response.headers["X-Frame-Options"] = "DENY"+ end++ def ensure_mcp_access+ if !SiteSetting.mcp_server_enabled || !DiscourseMcp::Access.allowed?(current_user)+ raise Discourse::InvalidAccess+ end+ end++ def validate_request+ raise Discourse::InvalidParameters if params[:response_type] != "code"+ raise Discourse::InvalidParameters if params[:code_challenge_method] != "S256"+ if !params[:code_challenge].to_s.match?(/\A[A-Za-z0-9_-]{43}\z/)+ raise Discourse::InvalidParameters+ end+ raise Discourse::InvalidParameters if params[:resource] != DiscourseMcp.resource_url+ URI.parse(params.require(:client_id)) if params[:client_id].to_s.start_with?("https://")+ URI.parse(params.require(:redirect_uri))+ rescue URI::InvalidURIError+ raise Discourse::InvalidParameters+ end++ def validate_redirect!(client)+ raise Discourse::InvalidAccess if !client.allows_redirect_uri?(params[:redirect_uri])+ end++ def requested_scopes+ params[:scope].to_s.split(" ").reject(&:blank?).uniq+ end++ def redirect_with(values)+ uri = URI.parse(params[:redirect_uri])+ query = Rack::Utils.parse_nested_query(uri.query)+ query.merge!(values.stringify_keys)+ query["state"] = params[:state] if params[:state].present?+ query["iss"] = DiscourseMcp.issuer+ uri.query = Rack::Utils.build_query(query)+ redirect_to uri.to_s, allow_other_host: true+ end+enddiff --git a/app/controllers/mcp_oauth_metadata_controller.rb b/app/controllers/mcp_oauth_metadata_controller.rbnew file mode 100644index 00000000000..0496c5a6754--- /dev/null+++ b/app/controllers/mcp_oauth_metadata_controller.rb@@ -0,0 +1,38 @@+# frozen_string_literal: true++class McpOauthMetadataController < ApplicationController+ skip_before_action :check_xhr, :preload_json+ before_action :ensure_mcp_enabled++ def protected_resource+ render json: {+ resource: DiscourseMcp.resource_url,+ authorization_servers: [DiscourseMcp.issuer],+ scopes_supported: [DiscourseMcp::INITIAL_SCOPE],+ bearer_methods_supported: ["header"],+ }+ end++ def authorization_server+ render json: {+ issuer: DiscourseMcp.issuer,+ authorization_endpoint: "#{Discourse.base_url}/oauth2/mcp/authorize",+ token_endpoint: "#{Discourse.base_url}/oauth2/mcp/token",+ revocation_endpoint: "#{Discourse.base_url}/oauth2/mcp/revoke",+ response_types_supported: ["code"],+ grant_types_supported: %w[authorization_code refresh_token],+ code_challenge_methods_supported: ["S256"],+ authorization_response_iss_parameter_supported: true,+ client_id_metadata_document_supported:+ SiteSetting.mcp_oauth_client_id_metadata_policy != "disabled",+ token_endpoint_auth_methods_supported: ["none"],+ scopes_supported: DiscourseMcp.registry.scopes,+ }+ end++ private++ def ensure_mcp_enabled+ raise Discourse::NotFound if !SiteSetting.mcp_server_enabled+ end+enddiff --git a/app/controllers/mcp_oauth_tokens_controller.rb b/app/controllers/mcp_oauth_tokens_controller.rbnew file mode 100644index 00000000000..db40cd509f6--- /dev/null+++ b/app/controllers/mcp_oauth_tokens_controller.rb@@ -0,0 +1,64 @@+# frozen_string_literal: true++class McpOauthTokensController < ApplicationController+ OAUTH_PARAMETERS = %w[code refresh_token token code_verifier].freeze++ skip_before_action :check_xhr, :preload_json, :verify_authenticity_token+ before_action :validate_request_format++ def create+ token_response =+ case params[:grant_type]+ when "authorization_code"+ DiscourseMcp::OAuth::TokenIssuer.exchange_code!(+ code: params.require(:code),+ client_id: params.require(:client_id),+ redirect_uri: params.require(:redirect_uri),+ code_verifier: params.require(:code_verifier),+ resource: params.require(:resource),+ )+ when "refresh_token"+ DiscourseMcp::OAuth::TokenIssuer.refresh!(+ refresh_token: params.require(:refresh_token),+ client_id: params.require(:client_id),+ resource: params.require(:resource),+ requested_scopes: params[:scope].presence&.split(" "),+ )+ else+ return oauth_error("unsupported_grant_type")+ end+ no_store!+ render json: token_response+ rescue Discourse::InvalidAccess+ oauth_error("invalid_grant", status: :bad_request)+ rescue ActionController::ParameterMissing+ oauth_error("invalid_request", status: :bad_request)+ end++ def revoke+ DiscourseMcp::OAuth::TokenIssuer.revoke!(params.require(:token))+ no_store!+ head :ok+ rescue ActionController::ParameterMissing+ oauth_error("invalid_request", status: :bad_request)+ end++ private++ def validate_request_format+ if !request.media_type.to_s.casecmp?("application/x-www-form-urlencoded") ||+ (request.query_parameters.keys & OAUTH_PARAMETERS).present?+ oauth_error("invalid_request", status: :bad_request)+ end+ end++ def no_store!+ response.set_header("Cache-Control", "no-store")+ response.set_header("Pragma", "no-cache")+ end++ def oauth_error(error, status: :bad_request)+ no_store!+ render json: { error: error }, status: status+ end+enddiff --git a/app/controllers/mcp_user_authorizations_controller.rb b/app/controllers/mcp_user_authorizations_controller.rbnew file mode 100644index 00000000000..5382cc8a4ee--- /dev/null+++ b/app/controllers/mcp_user_authorizations_controller.rb@@ -0,0 +1,54 @@+# frozen_string_literal: true++class McpUserAuthorizationsController < ApplicationController+ requires_login++ def index+ ensure_self!+ authorizations =+ current_user+ .mcp_oauth_authorizations+ .includes(:user, :client, :scope_records, :access_tokens)+ .order(updated_at: :desc)+ .to_a+ statuses = DiscourseMcp::AuthorizationStatus.for(authorizations)+ render json: {+ authorizations:+ authorizations.map do |authorization|+ serialize(authorization, status: statuses.fetch(authorization.id))+ end,+ }+ end++ def destroy+ ensure_self!+ authorization = current_user.mcp_oauth_authorizations.find(params[:id])+ authorization.revoke!(by_user: current_user, reason: "user_revoked")+ head :no_content+ end++ private++ def ensure_self!+ raise Discourse::InvalidAccess if current_user.username_lower != params[:username].to_s.downcase+ end++ def serialize(authorization, status:)+ active_tokens =+ authorization.access_tokens.select do |token|+ token.revoked_at.nil? && token.expires_at.future?+ end+ {+ id: authorization.id,+ client_name: authorization.client.name,+ client_id: authorization.client.client_id,+ resource: authorization.resource,+ status: status,+ scopes: authorization.scopes,+ authorized_at: authorization.consented_at,+ consented_at: authorization.consented_at,+ last_used_at: authorization.access_tokens.filter_map(&:last_used_at).max,+ token_count: active_tokens.length,+ }+ end+enddiff --git a/app/jobs/scheduled/clean_up_mcp_records.rb b/app/jobs/scheduled/clean_up_mcp_records.rbnew file mode 100644index 00000000000..dddf73c1a24--- /dev/null+++ b/app/jobs/scheduled/clean_up_mcp_records.rb@@ -0,0 +1,23 @@+# frozen_string_literal: true++module Jobs+ class CleanUpMcpRecords < ::Jobs::Scheduled+ BATCH_SIZE = 1_000++ every 1.day++ def execute(_args)+ now = Time.zone.now+ McpOauthAuthorizationCode.where("expires_at < ?", now).in_batches(of: BATCH_SIZE).delete_all+ McpOauthAccessToken.where("expires_at < ?", 30.days.ago).in_batches(of: BATCH_SIZE).delete_all+ McpOauthRefreshToken+ .where("expires_at < ?", 30.days.ago)+ .in_batches(of: BATCH_SIZE)+ .delete_all+ McpAuditLog+ .where("occurred_at < ?", SiteSetting.mcp_audit_log_retention_days.days.ago)+ .in_batches(of: BATCH_SIZE)+ .delete_all+ end+ end+enddiff --git a/app/models/group.rb b/app/models/group.rbindex 4154bf19767..db452d83d71 100644--- a/app/models/group.rb+++ b/app/models/group.rb@@ -37,6 +37,7 @@ class Group < ActiveRecord::Basehas_many :group_requests, dependent: :destroyhas_many :group_mentions, dependent: :destroyhas_many :group_associated_groups, dependent: :destroy+ has_many :mcp_group_scopes, dependent: :destroyhas_many :group_archived_messages, dependent: :destroydiff --git a/app/models/mcp_audit_log.rb b/app/models/mcp_audit_log.rbnew file mode 100644index 00000000000..b28156e9a04--- /dev/null+++ b/app/models/mcp_audit_log.rb@@ -0,0 +1,37 @@+# frozen_string_literal: true++class McpAuditLog < ActiveRecord::Base+ belongs_to :user, optional: true+ belongs_to :client,+ class_name: "McpOauthClient",+ foreign_key: :mcp_oauth_client_id,+ optional: true+ validates :occurred_at, :outcome, presence: true++ scope :recent_first, -> { order(occurred_at: :desc, id: :desc) }+end++# == Schema Information+#+# Table name: mcp_audit_logs+#+# id :bigint not null, primary key+# bucket_at :datetime+# duration_ms :integer+# http_status :integer+# method :string+# occurred_at :datetime not null+# occurrences :integer default(1), not null+# outcome :string not null+# target :jsonb not null+# tool :string+# created_at :datetime not null+# updated_at :datetime not null+# mcp_oauth_client_id :bigint+# request_id :string+# user_id :integer+#+# Indexes+#+# index_mcp_audit_logs_on_occurred_at_and_id (occurred_at,id)+#diff --git a/app/models/mcp_group_scope.rb b/app/models/mcp_group_scope.rbnew file mode 100644index 00000000000..6bc009e4b36--- /dev/null+++ b/app/models/mcp_group_scope.rb@@ -0,0 +1,42 @@+# frozen_string_literal: true++class McpGroupScope < ActiveRecord::Base+ belongs_to :group++ validates :scope, presence: true, uniqueness: { scope: :group_id }+ validate :scope_is_registered++ def self.ensure_admins!+ admin_group_id = Group::AUTO_GROUPS[:admins]+ return if exists?(group_id: admin_group_id)++ timestamp = Time.zone.now+ insert_all(+ DiscourseMcp.registry.scopes.map do |scope|+ { group_id: admin_group_id, scope:, created_at: timestamp, updated_at: timestamp }+ end,+ unique_by: %i[group_id scope],+ )+ end++ private++ def scope_is_registered+ errors.add(:scope, :inclusion) if !DiscourseMcp.registry.scopes.include?(scope)+ end+end++# == Schema Information+#+# Table name: mcp_group_scopes+#+# id :bigint not null, primary key+# scope :string not null+# created_at :datetime not null+# updated_at :datetime not null+# group_id :integer not null+#+# Indexes+#+# index_mcp_group_scopes_on_group_id_and_scope (group_id,scope) UNIQUE+#diff --git a/app/models/mcp_oauth_access_token.rb b/app/models/mcp_oauth_access_token.rbnew file mode 100644index 00000000000..5a284fb3f86--- /dev/null+++ b/app/models/mcp_oauth_access_token.rb@@ -0,0 +1,59 @@+# frozen_string_literal: true++class McpOauthAccessToken < ActiveRecord::Base+ belongs_to :authorization,+ class_name: "McpOauthAuthorization",+ foreign_key: :mcp_oauth_authorization_id+ belongs_to :client, class_name: "McpOauthClient", foreign_key: :mcp_oauth_client_id+ belongs_to :user++ scope :usable, -> { where(revoked_at: nil).where("expires_at > ?", Time.zone.now) }++ def self.digest(value)+ Digest::SHA256.hexdigest(value.to_s)+ end++ def self.issue!(authorization:, scopes: authorization.scopes)+ raw = SecureRandom.urlsafe_base64(48)+ create!(+ token_hash: digest(raw),+ authorization: authorization,+ client: authorization.client,+ user: authorization.user,+ resource: authorization.resource,+ scopes: scopes,+ grant_version: authorization.grant_version,+ expires_at: SiteSetting.mcp_access_token_lifetime_minutes.minutes.from_now,+ )+ raw+ end++ def touch_last_used!+ update_column(:last_used_at, Time.zone.now) if last_used_at.nil? || last_used_at < 1.minute.ago+ end+end++# == Schema Information+#+# Table name: mcp_oauth_access_tokens+#+# id :bigint not null, primary key+# expires_at :datetime not null+# grant_version :integer not null+# last_used_at :datetime+# resource :string not null+# revoked_at :datetime+# scopes :string default([]), not null, is an Array+# token_hash :string not null+# created_at :datetime not null+# updated_at :datetime not null+# mcp_oauth_authorization_id :bigint not null+# mcp_oauth_client_id :bigint not null+# user_id :integer not null+#+# Indexes+#+# index_mcp_oauth_access_tokens_on_mcp_oauth_authorization_id (mcp_oauth_authorization_id)+# index_mcp_oauth_access_tokens_on_token_hash (token_hash) UNIQUE+# index_mcp_oauth_access_tokens_on_user_id_and_revoked_at (user_id,revoked_at)+#diff --git a/app/models/mcp_oauth_authorization.rb b/app/models/mcp_oauth_authorization.rbnew file mode 100644index 00000000000..9f22916d898--- /dev/null+++ b/app/models/mcp_oauth_authorization.rb@@ -0,0 +1,92 @@+# frozen_string_literal: true++class McpOauthAuthorization < ActiveRecord::Base+ STATUSES = %w[active consent_required revoked].freeze++ belongs_to :user+ belongs_to :client, class_name: "McpOauthClient", foreign_key: :mcp_oauth_client_id+ has_many :scope_records,+ class_name: "McpOauthAuthorizationScope",+ dependent: :destroy,+ inverse_of: :authorization+ has_many :access_tokens, class_name: "McpOauthAccessToken", dependent: :destroy+ has_many :refresh_tokens, class_name: "McpOauthRefreshToken", dependent: :destroy+ has_many :authorization_codes, class_name: "McpOauthAuthorizationCode", dependent: :destroy++ validates :resource, presence: true+ validates :status, inclusion: { in: STATUSES }++ scope :active, -> { where(status: "active", revoked_at: nil) }++ def scopes+ scope_records.map(&:name)+ end++ def active?+ status == "active" && revoked_at.nil?+ end++ def consent_current?(consent_required_at: McpPrimitive.maximum(:consent_required_at))+ consent_required_at.blank? || consented_at >= consent_required_at+ end++ def self.require_consent!(scopes: nil, client_ids: nil)+ transaction do+ authorizations = active+ if scopes.present?+ authorization_ids =+ McpOauthAuthorizationScope.where(name: scopes).select(:mcp_oauth_authorization_id)+ authorizations = authorizations.where(id: authorization_ids)+ end+ authorizations = authorizations.where(mcp_oauth_client_id: client_ids) if client_ids.present?+ authorization_ids = authorizations.select(:id)+ now = Time.zone.now+ McpOauthAccessToken.where(+ mcp_oauth_authorization_id: authorization_ids,+ revoked_at: nil,+ ).update_all(revoked_at: now, updated_at: now)+ McpOauthRefreshToken.where(+ mcp_oauth_authorization_id: authorization_ids,+ revoked_at: nil,+ ).update_all(revoked_at: now, updated_at: now)+ authorizations.update_all(status: "consent_required", updated_at: now)+ end+ end++ def revoke!(by_user: nil, reason: nil)+ transaction do+ update!(+ status: "revoked",+ revoked_at: Time.zone.now,+ revoked_by_user_id: by_user&.id,+ revoked_reason: reason,+ )+ access_tokens.where(revoked_at: nil).update_all(revoked_at: Time.zone.now)+ refresh_tokens.where(revoked_at: nil).update_all(revoked_at: Time.zone.now)+ end+ end+end++# == Schema Information+#+# Table name: mcp_oauth_authorizations+#+# id :bigint not null, primary key+# client_metadata_hash :string+# consented_at :datetime not null+# grant_version :integer default(1), not null+# resource :string not null+# revoked_at :datetime+# revoked_reason :string+# status :string default("active"), not null+# created_at :datetime not null+# updated_at :datetime not null+# mcp_oauth_client_id :bigint not null+# revoked_by_user_id :integer+# user_id :integer not null+#+# Indexes+#+# idx_mcp_active_authorizations_unique (user_id,mcp_oauth_client_id) UNIQUE WHERE (revoked_at IS NULL)+# index_mcp_oauth_authorizations_on_mcp_oauth_client_id (mcp_oauth_client_id)+#diff --git a/app/models/mcp_oauth_authorization_code.rb b/app/models/mcp_oauth_authorization_code.rbnew file mode 100644index 00000000000..f6891510cdb--- /dev/null+++ b/app/models/mcp_oauth_authorization_code.rb@@ -0,0 +1,55 @@+# frozen_string_literal: true++class McpOauthAuthorizationCode < ActiveRecord::Base+ belongs_to :authorization,+ class_name: "McpOauthAuthorization",+ foreign_key: :mcp_oauth_authorization_id++ validates :code_hash, presence: true, uniqueness: true+ validates :code_challenge, :redirect_uri, :resource, presence: true++ scope :usable, -> { where(consumed_at: nil).where("expires_at > ?", Time.zone.now) }++ def self.digest(value)+ Digest::SHA256.hexdigest(value.to_s)+ end++ def self.issue!(authorization:, redirect_uri:, resource:, code_challenge:)+ raw = SecureRandom.urlsafe_base64(48)+ create!(+ code_hash: digest(raw),+ authorization: authorization,+ redirect_uri: redirect_uri,+ resource: resource,+ code_challenge: code_challenge,+ scopes: authorization.scopes,+ grant_version: authorization.grant_version,+ expires_at: SiteSetting.mcp_authorization_code_lifetime_seconds.seconds.from_now,+ )+ raw+ end+end++# == Schema Information+#+# Table name: mcp_oauth_authorization_codes+#+# id :bigint not null, primary key+# code_challenge :string not null+# code_challenge_method :string default("S256"), not null+# code_hash :string not null+# consumed_at :datetime+# expires_at :datetime not null+# grant_version :integer not null+# redirect_uri :string not null+# resource :string not null+# scopes :string default([]), not null, is an Array+# created_at :datetime not null+# updated_at :datetime not null+# mcp_oauth_authorization_id :bigint not null+#+# Indexes+#+# idx_on_mcp_oauth_authorization_id_d749d8a9de (mcp_oauth_authorization_id)+# index_mcp_oauth_authorization_codes_on_code_hash (code_hash) UNIQUE+#diff --git a/app/models/mcp_oauth_authorization_scope.rb b/app/models/mcp_oauth_authorization_scope.rbnew file mode 100644index 00000000000..740ca3e6beb--- /dev/null+++ b/app/models/mcp_oauth_authorization_scope.rb@@ -0,0 +1,25 @@+# frozen_string_literal: true++class McpOauthAuthorizationScope < ActiveRecord::Base+ belongs_to :authorization,+ class_name: "McpOauthAuthorization",+ foreign_key: :mcp_oauth_authorization_id,+ inverse_of: :scope_records++ validates :name, presence: true, uniqueness: { scope: :mcp_oauth_authorization_id }+end++# == Schema Information+#+# Table name: mcp_oauth_authorization_scopes+#+# id :bigint not null, primary key+# name :string not null+# created_at :datetime not null+# updated_at :datetime not null+# mcp_oauth_authorization_id :bigint not null+#+# Indexes+#+# idx_mcp_authorization_scopes_unique (mcp_oauth_authorization_id,name) UNIQUE+#diff --git a/app/models/mcp_oauth_client.rb b/app/models/mcp_oauth_client.rbnew file mode 100644index 00000000000..5f9e49488a1--- /dev/null+++ b/app/models/mcp_oauth_client.rb@@ -0,0 +1,95 @@+# frozen_string_literal: true++class McpOauthClient < ActiveRecord::Base+ REGISTRATION_TYPES = %w[pre_registered cimd].freeze+ TRUST_STATES = %w[pending approved blocked].freeze+ LOOPBACK_IP_HOSTS = %w[127.0.0.1 ::1].freeze+ LOCAL_REDIRECT_HOSTS = ["localhost", *LOOPBACK_IP_HOSTS].freeze++ has_many :authorizations, class_name: "McpOauthAuthorization", dependent: :destroy++ validates :client_id, presence: true, uniqueness: true, length: { maximum: 1000 }+ validates :name, presence: true, length: { maximum: 255 }+ validates :registration_type, inclusion: { in: REGISTRATION_TYPES }+ validates :trust_state, inclusion: { in: TRUST_STATES }+ validates :redirect_uris, presence: true+ validate :redirect_uris_are_absolute++ def approved?+ trust_state == "approved"+ end++ def blocked?+ trust_state == "blocked"+ end++ def allows_redirect_uri?(value)+ return true if redirect_uris.include?(value)++ requested_uri = URI.parse(value)+ return false if !local_redirect_uri?(requested_uri)++ redirect_uris.any? do |registered_value|+ registered_uri = URI.parse(registered_value)+ local_redirect_uri?(registered_uri) &&+ redirect_uris_match_except_port?(registered_uri, requested_uri)+ end+ rescue URI::InvalidURIError+ false+ end++ def self.valid_redirect_uri?(value)+ uri = URI.parse(value)+ if !uri.absolute? || uri.host.blank? || uri.userinfo.present? || uri.fragment.present?+ return false+ end+ return true if uri.scheme == "https"++ uri.scheme == "http" && LOCAL_REDIRECT_HOSTS.include?(uri.hostname.downcase)+ rescue URI::InvalidURIError+ false+ end++ private++ def local_redirect_uri?(uri)+ uri.scheme == "http" && LOCAL_REDIRECT_HOSTS.include?(uri.hostname&.downcase)+ end++ def redirect_uris_match_except_port?(registered_uri, requested_uri)+ %i[scheme userinfo hostname path query fragment].all? do |component|+ registered_uri.public_send(component) == requested_uri.public_send(component)+ end+ end++ def redirect_uris_are_absolute+ return if redirect_uris.blank?++ if !redirect_uris.all? { |value| self.class.valid_redirect_uri?(value) }+ errors.add(:redirect_uris, :invalid)+ end+ end+end++# == Schema Information+#+# Table name: mcp_oauth_clients+#+# id :bigint not null, primary key+# last_seen_at :datetime+# metadata :jsonb not null+# metadata_expires_at :datetime+# metadata_hash :string+# metadata_uri :string+# name :string not null+# redirect_uris :string default([]), not null, is an Array+# registration_type :string not null+# trust_state :string default("approved"), not null+# created_at :datetime not null+# updated_at :datetime not null+# client_id :string not null+#+# Indexes+#+# index_mcp_oauth_clients_on_client_id (client_id) UNIQUE+#diff --git a/app/models/mcp_oauth_client_id_metadata_policy.rb b/app/models/mcp_oauth_client_id_metadata_policy.rbnew file mode 100644index 00000000000..93453247ccc--- /dev/null+++ b/app/models/mcp_oauth_client_id_metadata_policy.rb@@ -0,0 +1,21 @@+# frozen_string_literal: true++require "enum_site_setting"++class McpOauthClientIdMetadataPolicy < EnumSiteSetting+ def self.valid_value?(value)+ values.any? { |policy| policy[:value] == value }+ end++ def self.values+ @values ||= [+ { name: "mcp_oauth_client_id_metadata_policy.disabled", value: "disabled" },+ { name: "mcp_oauth_client_id_metadata_policy.approved_domains", value: "approved_domains" },+ { name: "mcp_oauth_client_id_metadata_policy.any_domain", value: "any_domain" },+ ]+ end++ def self.translate_names?+ true+ end+enddiff --git a/app/models/mcp_oauth_refresh_token.rb b/app/models/mcp_oauth_refresh_token.rbnew file mode 100644index 00000000000..ec5cc5f4c3e--- /dev/null+++ b/app/models/mcp_oauth_refresh_token.rb@@ -0,0 +1,64 @@+# frozen_string_literal: true++class McpOauthRefreshToken < ActiveRecord::Base+ belongs_to :authorization,+ class_name: "McpOauthAuthorization",+ foreign_key: :mcp_oauth_authorization_id++ scope :usable,+ -> { where(consumed_at: nil, revoked_at: nil).where("expires_at > ?", Time.zone.now) }++ def self.digest(value)+ Digest::SHA256.hexdigest(value.to_s)+ end++ def self.issue!(+ authorization:,+ scopes: authorization.scopes,+ family_id: SecureRandom.uuid,+ parent: nil+ )+ raw = SecureRandom.urlsafe_base64(64)+ token =+ create!(+ token_hash: digest(raw),+ family_id: family_id,+ authorization: authorization,+ parent_id: parent&.id,+ scopes: scopes,+ grant_version: authorization.grant_version,+ expires_at: parent&.expires_at || SiteSetting.mcp_refresh_token_lifetime_days.days.from_now,+ )+ parent&.update!(replacement_id: token.id, consumed_at: Time.zone.now)+ [raw, token]+ end++ def revoke_family!+ self.class.where(family_id: family_id, revoked_at: nil).update_all(revoked_at: Time.zone.now)+ end+end++# == Schema Information+#+# Table name: mcp_oauth_refresh_tokens+#+# id :bigint not null, primary key+# consumed_at :datetime+# expires_at :datetime not null+# grant_version :integer not null+# revoked_at :datetime+# scopes :string default([]), not null, is an Array+# token_hash :string not null+# created_at :datetime not null+# updated_at :datetime not null+# family_id :string not null+# mcp_oauth_authorization_id :bigint not null+# parent_id :bigint+# replacement_id :bigint+#+# Indexes+#+# index_mcp_oauth_refresh_tokens_on_family_id (family_id)+# index_mcp_oauth_refresh_tokens_on_mcp_oauth_authorization_id (mcp_oauth_authorization_id)+# index_mcp_oauth_refresh_tokens_on_token_hash (token_hash) UNIQUE+#diff --git a/app/models/mcp_primitive.rb b/app/models/mcp_primitive.rbnew file mode 100644index 00000000000..802690657d2--- /dev/null+++ b/app/models/mcp_primitive.rb@@ -0,0 +1,33 @@+# frozen_string_literal: true++class McpPrimitive < ActiveRecord::Base+ KINDS = %w[tool resource resource_template prompt].freeze++ validates :kind, inclusion: { in: KINDS }+ validates :identifier, presence: true, length: { maximum: 200 }+ validates :identifier, uniqueness: { scope: :kind }++ scope :exposed, -> { where(enabled: true, emergency_blocked: false) }++ def exposed?+ enabled? && !emergency_blocked?+ end+end++# == Schema Information+#+# Table name: mcp_primitives+#+# id :bigint not null, primary key+# consent_required_at :datetime+# emergency_blocked :boolean default(FALSE), not null+# enabled :boolean default(FALSE), not null+# identifier :string not null+# kind :string not null+# created_at :datetime not null+# updated_at :datetime not null+#+# Indexes+#+# idx_mcp_primitives_unique (kind,identifier) UNIQUE+#diff --git a/app/models/site_setting.rb b/app/models/site_setting.rbindex 5d39c96260a..b7a22d5d8f3 100644--- a/app/models/site_setting.rb+++ b/app/models/site_setting.rb@@ -24,6 +24,7 @@ class SiteSetting < ActiveRecord::Baseinterfacelegallocalization+ mcpnavigationnotificationspermalinksdiff --git a/app/models/user.rb b/app/models/user.rbindex c170deeeb6a..59af9eaac75 100644--- a/app/models/user.rb+++ b/app/models/user.rb@@ -24,6 +24,8 @@ class User < ActiveRecord::Basehas_many :category_users, dependent: :destroyhas_many :tag_users, dependent: :destroyhas_many :user_api_keys, dependent: :destroy+ has_many :mcp_oauth_authorizations, dependent: :destroy+ has_many :mcp_oauth_access_tokens, dependent: :destroyhas_many :topic_allowed_users, dependent: :destroyhas_many :user_archived_messages, dependent: :destroyhas_many :email_change_requests, dependent: :destroydiff --git a/app/serializers/user_serializer.rb b/app/serializers/user_serializer.rbindex 1087726c667..c635a854c9b 100644--- a/app/serializers/user_serializer.rb+++ b/app/serializers/user_serializer.rb@@ -21,7 +21,8 @@ class UserSerializer < UserCardSerializer:profile_background_upload_url,:can_upload_profile_header,:can_upload_user_card_background,- :no_password+ :no_password,+ :show_mcp_authorizationshas_one :invited_by, embed: :object, serializer: BasicUserSerializerhas_many :groups, embed: :object, serializer: BasicGroupSerializer@@ -150,6 +151,15 @@ class UserSerializer < UserCardSerializerscope.can_change_tracking_preferences?(object)end+ def include_show_mcp_authorizations?+ user_is_current_user+ end++ def show_mcp_authorizations+ object.mcp_oauth_authorizations.exists? ||+ DiscourseMcp::Access.eligible_for_exposed_primitive?(object)+ end+def user_api_keyskeys =objectdiff --git a/app/services/mcp_access_rule_updater.rb b/app/services/mcp_access_rule_updater.rbnew file mode 100644index 00000000000..27d37c76c54--- /dev/null+++ b/app/services/mcp_access_rule_updater.rb@@ -0,0 +1,57 @@+# frozen_string_literal: true++class McpAccessRuleUpdater+ def self.replace!(actor:, group_id:, scopes:)+ new(actor:, group_id:, scopes:).replace!+ end++ def self.delete!(actor:, group_id:)+ new(actor:, group_id:, scopes: []).delete!+ end++ def initialize(actor:, group_id:, scopes:)+ @actor = actor+ @group_id = group_id.to_i+ @scopes = (Array(scopes).map(&:to_s) + [DiscourseMcp::INITIAL_SCOPE]).uniq.sort+ end++ def replace!+ validate_group!+ validate_scopes!++ McpGroupScope.transaction do+ McpGroupScope.where(group_id: group_id).delete_all+ scopes.each { |scope| McpGroupScope.create!(group_id: group_id, scope: scope) }+ log_change("mcp_access_rule_updated", scopes)+ end+ end++ def delete!+ validate_group!+ raise Discourse::InvalidParameters.new(:group_id) if group_id == Group::AUTO_GROUPS[:admins]++ McpGroupScope.transaction do+ removed_scopes = McpGroupScope.where(group_id: group_id).order(:scope).pluck(:scope)+ McpGroupScope.where(group_id: group_id).delete_all+ log_change("mcp_access_rule_deleted", removed_scopes)+ end+ end++ private++ attr_reader :actor, :group_id, :scopes++ def validate_group!+ raise Discourse::InvalidParameters.new(:group_id) if !Group.exists?(id: group_id)+ end++ def validate_scopes!+ if (scopes - DiscourseMcp.registry.scopes).present?+ raise Discourse::InvalidParameters.new(:scopes)+ end+ end++ def log_change(action, logged_scopes)+ StaffActionLogger.new(actor).log_custom(action, group_id: group_id, scopes: logged_scopes)+ end+enddiff --git a/app/services/mcp_activity_report.rb b/app/services/mcp_activity_report.rbnew file mode 100644index 00000000000..0a252f5cd99--- /dev/null+++ b/app/services/mcp_activity_report.rb@@ -0,0 +1,105 @@+# frozen_string_literal: true++class McpActivityReport+ MAX_FILTER_LENGTH = 200+ OUTCOMES = %w[success error rate_limited].freeze++ def initialize(limit:, cursor: nil, filter: nil, outcome: nil)+ @limit = limit+ @cursor = cursor+ @filter = filter.to_s.strip+ @outcome = outcome.presence+ end++ def call+ validate!++ values = activity_relation.limit(limit + 1).to_a+ if values.length > limit+ values.pop+ next_cursor = values.last.id+ end++ result = {+ activity: values.map { |entry| serialize(entry) },+ next_cursor: next_cursor,+ meta: {+ next_cursor: next_cursor,+ },+ }+ result[:metrics] = metrics if cursor.nil?+ result+ end++ private++ attr_reader :limit, :cursor, :filter, :outcome++ def validate!+ raise Discourse::InvalidParameters.new(:filter) if filter.length > MAX_FILTER_LENGTH+ if outcome.present? && !OUTCOMES.include?(outcome)+ raise Discourse::InvalidParameters.new(:outcome)+ end+ end++ def activity_relation+ relation = McpAuditLog.left_joins(:user, :client).preload(:user, :client).order(id: :desc)+ relation = relation.where("mcp_audit_logs.id < ?", cursor) if cursor+ relation = relation.where(outcome: outcome) if outcome++ if filter.present?+ pattern = "%#{ActiveRecord::Base.sanitize_sql_like(filter)}%"+ relation = relation.where(<<~SQL.squish, pattern: pattern, request_id: filter)+ users.username ILIKE :pattern OR+ mcp_oauth_clients.name ILIKE :pattern OR+ mcp_oauth_clients.client_id ILIKE :pattern OR+ mcp_audit_logs.tool ILIKE :pattern OR+ mcp_audit_logs.request_id = :request_id+ SQL+ end++ relation+ end++ def metrics+ tool_calls, errors, rate_limits, p95_latency_ms =+ McpAuditLog.where("occurred_at > ?", 24.hours.ago).pick(+ Arel.sql("COALESCE(SUM(occurrences), 0)::bigint"),+ Arel.sql("COALESCE(SUM(occurrences) FILTER (WHERE outcome <> 'success'), 0)::bigint"),+ Arel.sql("COALESCE(SUM(occurrences) FILTER (WHERE outcome = 'rate_limited'), 0)::bigint"),+ Arel.sql(<<~SQL.squish),+ COALESCE(+ PERCENTILE_DISC(0.95) WITHIN GROUP (ORDER BY duration_ms)+ FILTER (WHERE duration_ms IS NOT NULL),+ 0+ )::integer+ SQL+ )++ {+ tool_calls: tool_calls,+ errors: errors,+ rate_limits: rate_limits,+ p95_latency_ms: p95_latency_ms,+ }+ end++ def serialize(entry)+ {+ id: entry.id,+ occurred_at: entry.occurred_at,+ created_at: entry.occurred_at,+ username: entry.user&.username,+ client_id: entry.client&.client_id,+ client_name: entry.client&.name,+ method: entry[:method],+ tool: entry.tool,+ outcome: entry.outcome,+ http_status: entry.http_status,+ duration_ms: entry.duration_ms,+ request_id: entry.request_id,+ target: entry.target,+ occurrences: entry.occurrences,+ }+ end+enddiff --git a/app/services/mcp_oauth_authorizations_page.rb b/app/services/mcp_oauth_authorizations_page.rbnew file mode 100644index 00000000000..51f6d52d5f5--- /dev/null+++ b/app/services/mcp_oauth_authorizations_page.rb@@ -0,0 +1,50 @@+# frozen_string_literal: true++class McpOauthAuthorizationsPage+ MAX_FILTER_LENGTH = 200+ Result = Data.define(:records, :next_cursor)++ def initialize(limit:, cursor: nil, filter: nil)+ @limit = limit+ @cursor = cursor+ @filter = filter.to_s.strip+ end++ def call+ raise Discourse::InvalidParameters.new(:filter) if filter.length > MAX_FILTER_LENGTH++ records = relation.limit(limit + 1).to_a+ if records.length > limit+ records.pop+ next_cursor = records.last.id+ end+ Result.new(records:, next_cursor:)+ end++ private++ attr_reader :limit, :cursor, :filter++ def relation+ records =+ McpOauthAuthorization+ .left_joins(:user, :client, :scope_records)+ .preload(:user, :client, :scope_records, :access_tokens)+ .distinct+ .order(id: :desc)+ records = records.where("mcp_oauth_authorizations.id < ?", cursor) if cursor++ if filter.present?+ pattern = "%#{ActiveRecord::Base.sanitize_sql_like(filter)}%"+ records = records.where(<<~SQL.squish, pattern:)+ users.username ILIKE :pattern OR+ mcp_oauth_clients.name ILIKE :pattern OR+ mcp_oauth_clients.client_id ILIKE :pattern OR+ mcp_oauth_authorizations.status ILIKE :pattern OR+ mcp_oauth_authorization_scopes.name ILIKE :pattern+ SQL+ end++ records+ end+enddiff --git a/app/services/mcp_oauth_clients_page.rb b/app/services/mcp_oauth_clients_page.rbnew file mode 100644index 00000000000..a2cf685e1e4--- /dev/null+++ b/app/services/mcp_oauth_clients_page.rb@@ -0,0 +1,49 @@+# frozen_string_literal: true++class McpOauthClientsPage+ MAX_FILTER_LENGTH = 200+ Result = Data.define(:records, :next_cursor)++ def initialize(limit:, cursor: nil, filter: nil)+ @limit = limit+ @cursor = cursor+ @filter = filter.to_s.strip+ end++ def call+ raise Discourse::InvalidParameters.new(:filter) if filter.length > MAX_FILTER_LENGTH++ records = relation.limit(limit + 1).to_a+ if records.length > limit+ records.pop+ next_cursor = records.last.id+ end+ Result.new(records:, next_cursor:)+ end++ private++ attr_reader :limit, :cursor, :filter++ def relation+ records = McpOauthClient.select("mcp_oauth_clients.*", <<~SQL.squish).order(id: :desc)+ (+ SELECT COUNT(*)+ FROM mcp_oauth_authorizations+ WHERE mcp_oauth_authorizations.mcp_oauth_client_id = mcp_oauth_clients.id+ ) AS authorization_count+ SQL+ records = records.where("mcp_oauth_clients.id < ?", cursor) if cursor++ if filter.present?+ pattern = "%#{ActiveRecord::Base.sanitize_sql_like(filter)}%"+ records = records.where(<<~SQL.squish, pattern:)+ mcp_oauth_clients.name ILIKE :pattern OR+ mcp_oauth_clients.client_id ILIKE :pattern OR+ mcp_oauth_clients.registration_type ILIKE :pattern+ SQL+ end++ records+ end+enddiff --git a/app/services/mcp_primitive_updater.rb b/app/services/mcp_primitive_updater.rbnew file mode 100644index 00000000000..fb597a69404--- /dev/null+++ b/app/services/mcp_primitive_updater.rb@@ -0,0 +1,104 @@+# frozen_string_literal: true++class McpPrimitiveUpdater+ def self.update!(actor:, primitive_ids:)+ new(actor:).update!(primitive_ids:)+ end++ def self.set_emergency_block!(actor:, primitive_id:, blocked:)+ new(actor:).set_emergency_block!(primitive_id:, blocked:)+ end++ def initialize(actor:)+ @actor = actor+ end++ def update!(primitive_ids:)+ @enabled_primitive_ids = Array(primitive_ids).map(&:to_s).to_set+ previously_exposed_consent_relevant_ids = exposed_consent_relevant_primitive_ids++ McpPrimitive.transaction do+ update_primitive_records!+ require_fresh_consent_for_new_exposure!(previously_exposed_consent_relevant_ids)+ StaffActionLogger.new(actor).log_custom(+ "mcp_primitives_updated",+ primitive_count: enabled_primitive_ids.length,+ )+ end+ end++ def set_emergency_block!(primitive_id:, blocked:)+ kind, identifier = primitive_id.to_s.split(":", 2)+ primitive = DiscourseMcp.registry.find(kind, identifier)+ raise Discourse::NotFound if primitive.blank?++ primitive_record = McpPrimitive.find_or_initialize_by(kind:, identifier:)+ McpPrimitive.transaction do+ was_exposed = primitive_record.exposed?+ primitive_record.assign_attributes(emergency_blocked: blocked)+ if primitive_record.changed?+ expands_consent_relevant_access =+ !was_exposed && primitive_record.exposed? && primitive.consent_relevant?+ primitive_record.consent_required_at = Time.zone.now if expands_consent_relevant_access+ primitive_record.save!+ if expands_consent_relevant_access+ McpOauthAuthorization.require_consent!(scopes: primitive.required_scopes)+ end+ end+ StaffActionLogger.new(actor).log_custom(+ "mcp_primitive_emergency_block_updated",+ primitive: primitive_id,+ blocked: primitive_record.emergency_blocked?,+ )+ end+ primitive_record+ end++ private++ attr_reader :actor, :enabled_primitive_ids++ def update_primitive_records!+ DiscourseMcp.registry.all.each do |primitive|+ primitive_record =+ McpPrimitive.find_or_initialize_by(kind: primitive.kind, identifier: primitive.identifier)+ primitive_record.enabled =+ enabled_primitive_ids.include?("#{primitive.kind}:#{primitive.identifier}")+ primitive_record.save!+ end+ end++ def require_fresh_consent_for_new_exposure!(previously_exposed_ids)+ newly_exposed_ids = exposed_consent_relevant_primitive_ids - previously_exposed_ids+ return if newly_exposed_ids.blank?++ invalidated_at = Time.zone.now+ McpPrimitive.where(id: newly_exposed_ids).update_all(+ consent_required_at: invalidated_at,+ updated_at: invalidated_at,+ )+ McpOauthAuthorization.require_consent!(scopes: scopes_for_primitive_records(newly_exposed_ids))+ end++ def exposed_consent_relevant_primitive_ids+ McpPrimitive+ .exposed+ .filter_map do |primitive_record|+ primitive = DiscourseMcp.registry.find(primitive_record.kind, primitive_record.identifier)+ primitive_record.id if primitive&.consent_relevant?+ end+ .to_set+ end++ def scopes_for_primitive_records(primitive_record_ids)+ McpPrimitive+ .where(id: primitive_record_ids)+ .flat_map do |primitive_record|+ DiscourseMcp+ .registry+ .find(primitive_record.kind, primitive_record.identifier)+ &.required_scopes || []+ end+ .uniq+ end+enddiff --git a/app/services/user_merger.rb b/app/services/user_merger.rbindex 8c3212868db..c7d78e17cf0 100644--- a/app/services/user_merger.rb+++ b/app/services/user_merger.rb@@ -360,6 +360,11 @@ class UserMerger.where(deleted_by_id: @source_user.id).update_all(deleted_by_id: @target_user.id)+ McpAuditLog.where(user_id: @source_user.id).update_all(user_id: @target_user.id)+ McpOauthAuthorization.where(revoked_by_user_id: @source_user.id).update_all(+ revoked_by_user_id: @target_user.id,+ )+update_user_id(:muted_users, conditions: "x.muted_user_id = y.muted_user_id")update_user_id(:muted_users,diff --git a/app/views/mcp_oauth_authorizations/show.html.erb b/app/views/mcp_oauth_authorizations/show.html.erbnew file mode 100644index 00000000000..ff5f6aa5284--- /dev/null+++ b/app/views/mcp_oauth_authorizations/show.html.erb@@ -0,0 +1,37 @@+<% content_for :title do %><%= t("mcp.oauth.authorize_title") %><% end %>++<div class="mcp-consent">+ <h1><%= t("mcp.oauth.authorize_title") %></h1>+ <p><%= t("mcp.oauth.client_request", client_name: @client.name, site_name: SiteSetting.title) %></p>++ <dl>+ <dt><%= t("mcp.oauth.client_id") %></dt>+ <dd><code><%= @client.client_id %></code></dd>+ <dt><%= t("mcp.oauth.redirect_uri") %></dt>+ <dd><code><%= params[:redirect_uri] %></code></dd>+ <dt><%= t("mcp.oauth.resource") %></dt>+ <dd><code><%= params[:resource] %></code></dd>+ </dl>++ <p class="mcp-consent__scope-summary">+ <%= t("mcp.oauth.requested_permission_count", client_name: @client.name, count: @requested_scopes.length) %>+ <%= t("mcp.oauth.eligible_permission_count", count: @granted_scopes.length) %>+ </p>++ <h2><%= t("mcp.oauth.granted_permissions", count: @granted_scopes.length) %></h2>+ <ul class="mcp-consent__granted-scopes">+ <% @granted_scopes.each do |scope| %>+ <li><code><%= scope %></code></li>+ <% end %>+ </ul>++ <p><%= t("mcp.oauth.guardian_notice") %></p>++ <%= form_with url: oauth2_mcp_authorize_path, method: :post do |form| %>+ <% %i[client_id redirect_uri response_type code_challenge code_challenge_method resource scope state].each do |key| %>+ <%= form.hidden_field key, value: params[key] if params[key].present? %>+ <% end %>+ <%= form.button t("mcp.oauth.deny"), name: "decision", value: "deny", class: "btn btn-default" %>+ <%= form.button t("mcp.oauth.approve"), name: "decision", value: "approve", class: "btn btn-primary" %>+ <% end %>+</div>diff --git a/config/initializers/020-discourse-mcp.rb b/config/initializers/020-discourse-mcp.rbnew file mode 100644index 00000000000..d0596541990--- /dev/null+++ b/config/initializers/020-discourse-mcp.rb@@ -0,0 +1,23 @@+# frozen_string_literal: true++require "json_schemer"+require "discourse_mcp"+require "discourse_mcp/primitive"+require "discourse_mcp/registry"+require "discourse_mcp/access"+require "discourse_mcp/authorization_status"+require "discourse_mcp/request_context"+require "discourse_mcp/catalog"+require "discourse_mcp/authenticator"+require "discourse_mcp/server"+require "discourse_mcp/oauth"+require "discourse_mcp/core_tools"+require "discourse_mcp/core_primitives"++DiscourseMcp.reset_registry!++DiscourseEvent.on(:site_setting_changed) do |name, _old_value, _new_value|+ if %i[mcp_oauth_client_id_metadata_policy mcp_oauth_client_id_metadata_domains].include?(name)+ DiscourseMcp::OAuth::ClientResolver.revoke_disallowed_clients!+ end+enddiff --git a/config/locales/client.en.yml b/config/locales/client.en.ymlindex 89389f4483c..9464ebc7094 100644--- a/config/locales/client.en.yml+++ b/config/locales/client.en.yml@@ -1,5 +1,9 @@en:js:+ mcp_oauth_client_id_metadata_policy:+ disabled: "Admin registration only"+ approved_domains: "CIMD from approved domains"+ any_domain: "CIMD from any domain"ace_editor:resize: "Resize code editor"user_api_key:@@ -1987,6 +1991,37 @@ en:tracked_topics_link: "Show"automatically_unpin_topics: "Automatically unpin topics when I reach the bottom"apps: "Apps"+ mcp_authorizations:+ title: "MCP Apps"+ description: "Review applications authorized to access this account through the Model Context Protocol. Actions remain subject to your normal Discourse permissions."+ application: "App name"+ endpoint: "Resource"+ scopes: "Scopes"+ permissions: "Permissions (%{count})"+ authorized: "Authorized"+ details: "Details"+ last_used: "Last used"+ tokens: "Active tokens"+ active_tokens:+ one: "%{count} active token"+ other: "%{count} active tokens"+ never: "Never"+ status: "Status"+ revoke: "Revoke access"+ reauthorize: "Re-authorize"+ reauthorize_in_client: "Reconnect this application from the MCP client. The client must start a new secure authorization request."+ revoke_confirm: "Revoke access for “%{name}”? Existing access and refresh tokens will stop working."+ revoked: "MCP application access revoked."+ empty: "No MCP applications are connected to your account."+ statuses:+ active: "Active"+ server_disabled: "Server disabled"+ client_blocked: "Client blocked"+ client_not_approved: "Client not approved"+ access_removed: "Access removed"+ user_unavailable: "User unavailable"+ consent_required: "Re-authorization required"+ revoked: "Revoked"revoke_access: "Revoke Access"undo_revoke_access: "Undo Revoke Access"api_approved: "Approved:"@@ -6878,6 +6913,235 @@ en:developer:title: "Developer"header_description: "Developer settings to control safe mode and other advanced features"+ mcp:+ title: "MCP server"+ header_description: "Configure MCP access, primitives, OAuth clients, authorizations, and activity."+ settings:+ description: "Site settings that control the MCP server and OAuth security."+ tabs:+ overview: "Overview"+ access: "Access"+ capabilities: "Capabilities"+ clients: "OAuth clients"+ authorizations: "Authorizations"+ activity: "Activity"+ overview:+ title: "MCP server overview"+ description: "Review the server status, endpoint, exposed primitives, and setup checklist."+ endpoint_title: "Server endpoint"+ protocol: "Protocol version"+ server_version: "Server version"+ status: "Status"+ catalog_title: "Exposed primitives"+ tools: "Tools"+ resources: "Resources"+ prompts: "Prompts"+ schema_size: "Estimated schema size"+ schema_size_value: "%{bytes} bytes"+ activity_title: "Current usage"+ approved_oauth_clients: "Approved OAuth clients"+ authorizations: "Authorizations"+ tokens: "Active tokens"+ errors: "Recent errors"+ setup_title: "Setup checklist"+ warnings_title: "Security warnings"+ access:+ title: "Access"+ description: "Control who can connect to this server and which scopes apply."+ group: "Group"+ groups: "Groups"+ scopes: "Eligible scopes"+ scopes_description: "Choose the maximum OAuth scopes members of this group may authorize. A user's eligible scopes are combined across all of their groups. The initial scope required to connect is always included."+ scopes_placeholder: "Select scopes"+ actions: "Actions"+ admins_description: "Pre-registered"+ add: "Add group access"+ back: "Back to access"+ new_title: "Add group access"+ edit_title: "Edit group access"+ edit: "Edit"+ delete: "Delete"+ save: "Save access"+ saved: "Group access saved."+ confirm_delete: "Remove MCP access for the group %{group}?"+ scope_primitives:+ one: "%{count} primitive"+ other: "%{count} primitives"+ rate_limit: "Global request rate limit"+ capabilities:+ title: "Capabilities"+ description: "Choose the primitives (tools, resources, and prompts) this server exposes. MCP clients use the matching capabilities to list and use them."+ primitives:+ picker_description: "New primitives are disabled until they are explicitly enabled."+ search_placeholder: "Search primitives"+ group_by: "Group by"+ group_by_options:+ scope: "Scope"+ provider: "Provider"+ kind: "Type"+ groups_label: "Primitive groups"+ all_primitives: "All primitives"+ group_count: "%{enabled} of %{total} enabled"+ provider: "Provider"+ kind: "Type"+ scope: "Scope"+ any_scope: "Any scope"+ risk: "Impact"+ state: "State"+ scopes: "Scopes"+ results_count: "Showing %{visible} of %{total} primitives"+ enable_visible: "Enable visible"+ disable_visible: "Disable visible"+ emergency_blocked: "Immediately blocked. This primitive cannot be used, regardless of the server configuration."+ no_results: "No primitives match these filters."+ clients:+ title: "OAuth clients"+ description: "Review OAuth client registrations and metadata without exposing client secrets."+ search_placeholder: "Search clients"+ client: "Client"+ trust: "Trust"+ last_seen: "Last seen"+ authorizations: "Authorizations"+ actions: "Actions"+ block: "Block"+ unblock: "Unblock"+ add: "Add OAuth client"+ back: "Back to OAuth clients"+ back_to_presets: "Back to applications"+ new_title: "Add OAuth client"+ preset_title: "Choose an application"+ preset_description: "Start with values for a common MCP application, or configure the OAuth client manually."+ use_preset: "Set up"+ presets:+ codex: "Codex"+ chatgpt: "ChatGPT"+ claude_code: "Claude Code"+ mcp_inspector: "MCP Inspector"+ visual_studio_code: "Visual Studio Code"+ custom: "Custom"+ preset_descriptions:+ codex: "Use Codex's standard local callback."+ chatgpt: "Pre-register ChatGPT when CIMD is disabled."+ claude_code: "Use Claude Code with a fixed local callback port."+ mcp_inspector: "Allow the Inspector's browser and command-line callbacks."+ visual_studio_code: "Use Visual Studio Code's hosted callback."+ custom: "Enter the client ID and redirect URIs yourself."+ preset_help:+ codex: "In Codex, use the client ID below and confirm that its callback URI matches."+ chatgpt: "Only needed when CIMD clients are disabled. Otherwise, ChatGPT identifies itself automatically."+ claude_code: "Use the client ID below and --callback-port 8080 when adding this server to Claude Code."+ mcp_inspector: "Use the client ID below in MCP Inspector's OAuth settings. Both web and command-line callbacks are included."+ visual_studio_code: "When Visual Studio Code asks for client registration details, enter the client ID below."+ custom: "Enter the OAuth details provided by the application."+ name: "Client name"+ name_description: "Shown to users when they approve this application."+ client_id_description: "An identifier for this application. Enter the same value when configuring the client."+ redirect_uris: "Redirect URIs"+ redirect_uris_description: "Where the browser returns after a user approves access. Enter one exact URI per line."+ create: "Add client"+ created: "OAuth client added."+ empty: "No OAuth clients are registered."+ no_results: "No OAuth clients match this search."+ detail_title: "Client details"+ detail_description: "Review client metadata, redirect URIs, and registration history."+ client_id: "Client ID"+ domain: "Client domain"+ registration_type: "Registration type"+ first_seen: "First seen"+ authorizations:+ title: "Authorizations"+ description: "Review user authorizations and revoke access when necessary. Token values are never shown."+ search_placeholder: "Search authorizations"+ client: "Client"+ user: "User"+ scopes: "Granted scopes"+ last_used: "Last used"+ status: "Status"+ actions: "Actions"+ empty: "No MCP authorizations match this filter."+ activity:+ title: "Activity and diagnostics"+ description: "Review privacy-minimized protocol activity and aggregate diagnostics."+ tool_calls: "Tool calls"+ errors: "Errors"+ rate_limits: "Rate limits"+ p95_latency: "95th percentile latency"+ search_placeholder: "Search by user, client, tool, or exact request ID"+ outcome: "Outcome"+ time: "Time"+ method: "Method"+ user: "User"+ duration: "Duration"+ duration_value: "%{milliseconds} ms"+ request_id: "Request ID"+ empty: "No activity matches this filter."+ values:+ server_status:+ available: "Available"+ disabled: "Disabled"+ client_trust:+ approved: "Approved"+ pending: "Pending approval"+ blocked: "Blocked"+ registration_type:+ pre_registered: "Pre-registered"+ cimd: "Client ID metadata"+ authorization_status:+ active: "Active"+ server_disabled: "Server disabled"+ client_blocked: "Client blocked"+ client_not_approved: "Client not approved"+ access_removed: "Access removed"+ user_unavailable: "User unavailable"+ consent_required: "Re-authorization required"+ revoked: "Revoked"+ activity_outcome:+ all: "All Outcomes"+ success: "Success"+ error: "Error"+ rate_limited: "Rate limited"+ primitive_state:+ all: "All states"+ enabled: "Enabled"+ disabled: "Disabled"+ unavailable: "Unavailable"+ blocked: "Blocked"+ primitive_kind:+ all: "All types"+ tool: "Tool"+ resource: "Resource"+ resource_template: "Resource template"+ prompt: "Prompt"+ primitive_risk:+ all: "All impact levels"+ read: "Read-only"+ write: "Write"+ destructive: "Destructive"+ moderation: "Moderation"+ administration: "Administration"+ external_side_effect: "External side effect"+ filter:+ all: "All"+ never: "Never"+ actions:+ block_client: "Block client"+ unblock_client: "Unblock client"+ refresh_metadata: "Refresh metadata"+ block_primitive: "Block immediately"+ unblock_primitive: "Remove block"+ revoke: "Revoke"+ save_configuration: "Save configuration"+ save_primitives: "Save primitives"+ confirm_enable: "Enabling the MCP server allows eligible users to authorize external clients. Continue?"+ confirm_block_client: "Block %{name}? New requests from this client will be denied."+ confirm_emergency_block: "Block %{name} immediately? This primitive will be denied regardless of the server configuration."+ primitive_blocked: "%{name} was blocked immediately."+ primitive_unblocked: "The block on %{name} was removed."+ confirm_revoke_authorization: "Revoke the authorization for %{name}? Existing access and refresh tokens will stop working."+ saved: "MCP server configuration saved."+ primitives_saved: "MCP primitives saved."+ copy_endpoint: "Copy server endpoint"+ endpoint_copied: "MCP server endpoint copied to clipboard."experimental:title: "Experimental"header_description: "Toggle experimental features on or off for your site, most of these can be controlled on a group basis"@@ -10126,6 +10390,7 @@ en:spam: "Spam"rate_limits: "Rate Limits"developer: "Developer"+ mcp: "MCP"embedding: "Embedding"legal: "Legal"api: "API"@@ -10189,6 +10454,9 @@ en:content_security_policy:prompt: "Disabling the content security policy removes an important layer of protection against cross-site scripting (XSS) and other content injection attacks. This will leave your site vulnerable, and should only be done for debugging/testing purposes. Disabling CSP will never help to resolve CORS issues. Are you sure you want to proceed?"confirm: "Yes, disable the content security policy"+ mcp_server_enabled:+ prompt: "Enabling the MCP server allows eligible users to connect external applications. Connected applications act as the authorizing user and remain subject to granted scopes and normal Discourse permissions."+ confirm: "Enable MCP server"job_status:completed: "Update completed"enqueued: "Update in progress"diff --git a/config/locales/server.en.yml b/config/locales/server.en.ymlindex 6d8a13e4b82..ffe958cb0ba 100644--- a/config/locales/server.en.yml+++ b/config/locales/server.en.yml@@ -1,4 +1,28 @@en:+ mcp:+ oauth:+ authorize_title: "Authorize MCP client"+ client_request: "%{client_name} is requesting access to %{site_name}."+ client_id: "Client ID"+ redirect_uri: "Redirect URI"+ resource: "MCP server"+ requested_permission_count:+ one: "%{client_name} requested %{count} permission."+ other: "%{client_name} requested %{count} permissions."+ eligible_permission_count:+ one: "Your account is eligible for %{count}."+ other: "Your account is eligible for %{count}."+ granted_permissions:+ one: "The following permission will be granted"+ other: "The following permissions will be granted"+ guardian_notice: "The client acts as your account and remains subject to your normal Discourse permissions."+ deny: "Deny"+ approve: "Authorize"+ admin:+ site_enabled: "Enable the MCP server site setting"+ primitives_enabled: "Enable at least one primitive in Capabilities"+ client_registered: "Register or approve an OAuth client"+llms_txt:human_community_policy: "This is a community for human discussion. Do not impersonate people or create accounts autonomously. Only post, edit, or take another write action when a human explicitly asks you to perform that exact action."crawler_policy: "Fetch only the pages needed for the user's specific request. Do not systematically crawl or bulk-download this community. Respect `robots.txt`, the site's terms, and its crawler controls. If the server responds with HTTP 429, stop and wait for the `Retry-After` interval before retrying."@@ -2910,6 +2934,19 @@ en:default_sidebar_show_count_of_new_items: "Make navigation menu links show count of new items instead of badges by default."default_sidebar_switch_panel_position: "Position of button on sidebar to switch to chat"+ mcp_server_enabled: "Enable the site's Model Context Protocol server. MCP clients act as an authorized Discourse user and remain subject to normal permissions."+ mcp_server_instructions: "Optional instructions sent to MCP clients to explain how to use this server."+ mcp_cache_ttl_ms: "How long MCP clients may consider a cacheable response fresh, in milliseconds. Set to 0 to make responses immediately stale."+ mcp_oauth_client_id_metadata_policy: "Choose whether OAuth clients can register using Client ID Metadata Documents (CIMD). Admin-registered clients are always allowed. Users must still approve requested access."+ mcp_oauth_client_id_metadata_domains: "Hosts allowed to provide Client ID Metadata Documents when {{setting:mcp_oauth_client_id_metadata_policy}} is set to approved domains. Subdomains are not included unless listed separately."+ mcp_access_token_lifetime_minutes: "How long an MCP access token remains valid, in minutes."+ mcp_refresh_token_lifetime_days: "How long an MCP refresh token family remains valid, in days."+ mcp_authorization_code_lifetime_seconds: "How long a single-use MCP OAuth authorization code remains valid, in seconds."+ mcp_global_rate_limit_per_minute: "Maximum MCP requests accepted per user, client, and IP address each minute. Expensive tools can apply stricter limits."+ mcp_audit_log_retention_days: "Number of days to retain bounded MCP security audit records."+ mcp_max_request_bytes: "Maximum accepted MCP request body size in bytes."+ mcp_max_response_bytes: "Maximum MCP response size in bytes."+retain_web_hook_events_period_days: "Number of days to retain web hook event records."retain_web_hook_events_aggregate_days: "Number of days to retain web hook event aggregate records."retry_web_hook_events: "Automatically retry failed web hook events for 4 times. Time gaps between the retries are 1, 5, 25 and 125 minutes."diff --git a/config/routes.rb b/config/routes.rbindex 853adde73c5..e3d0bbfeb72 100644--- a/config/routes.rb+++ b/config/routes.rb@@ -425,6 +425,8 @@ Discourse::Application.routes.draw doget "content/posts-and-topics" => "site_settings#index"get "content/stats-and-thresholds" => "site_settings#index"get "developer" => "site_settings#index"+ get "mcp" => "site_settings#index"+ get "mcp/*path" => "site_settings#index"get "files" => "site_settings#index"get "interface" => "site_settings#index"get "legal" => "site_settings#index"@@ -1920,6 +1922,45 @@ Discourse::Application.routes.draw doget "/custom" => "home_page#custom"+ post "/mcp" => "mcp#create"+ match "/mcp" => "mcp#method_not_allowed", :via => %i[get delete put patch options]++ get "/.well-known/oauth-protected-resource/mcp" => "mcp_oauth_metadata#protected_resource"+ get "/.well-known/oauth-authorization-server" => "mcp_oauth_metadata#authorization_server"+ get "/.well-known/openid-configuration" => "mcp_oauth_metadata#authorization_server"++ get "/oauth2/mcp/authorize" => "mcp_oauth_authorizations#show", :as => :oauth2_mcp_authorize+ post "/oauth2/mcp/authorize" => "mcp_oauth_authorizations#create"+ post "/oauth2/mcp/token" => "mcp_oauth_tokens#create"+ post "/oauth2/mcp/revoke" => "mcp_oauth_tokens#revoke"++ scope "/admin/mcp", constraints: AdminConstraint.new do+ get "/overview" => "admin/mcp#overview"+ get "/access" => "admin/mcp#access"+ put "/access/:group_id" => "admin/mcp#update_access"+ delete "/access/:group_id" => "admin/mcp#destroy_access"+ get "/capabilities" => "admin/mcp#primitives"+ put "/capabilities" => "admin/mcp#update_primitives"+ put "/capabilities/emergency-block" => "admin/mcp#emergency_block"+ get "/clients" => "admin/mcp_clients#index"+ post "/clients" => "admin/mcp_clients#create"+ get "/clients/:id" => "admin/mcp_clients#show"+ put "/clients/:id/block" => "admin/mcp_clients#block"+ post "/clients/:id/refresh" => "admin/mcp_clients#refresh"+ get "/authorizations" => "admin/mcp_authorizations#index"+ delete "/authorizations/:id" => "admin/mcp_authorizations#destroy"+ get "/activity" => "admin/mcp_activity#index"+ end++ get "/u/:username/preferences/mcp-authorizations" => "mcp_user_authorizations#index",+ :constraints => {+ username: RouteFormat.username,+ }+ delete "/u/:username/preferences/mcp-authorizations/:id" => "mcp_user_authorizations#destroy",+ :constraints => {+ username: RouteFormat.username,+ }+get "/user-api-key/new" => "user_api_keys#new"post "/user-api-key" => "user_api_keys#create"post "/user-api-key/device" => "user_api_keys#create_device_request"diff --git a/config/site_settings.yml b/config/site_settings.ymlindex 829f249de0e..f36a365c58e 100644--- a/config/site_settings.yml+++ b/config/site_settings.yml@@ -4478,6 +4478,73 @@ user_preferences:default: falsearea: "categories_and_tags|user_defaults"+mcp:+ mcp_server_enabled:+ default: false+ client: true+ area: "mcp"+ requires_confirmation: simple_on_enable+ mcp_server_instructions:+ default: ""+ textarea: true+ area: "mcp"+ mcp_cache_ttl_ms:+ default: 300000+ min: 0+ max: 86400000+ area: "mcp"+ mcp_oauth_client_id_metadata_policy:+ type: enum+ default: "any_domain"+ enum: "McpOauthClientIdMetadataPolicy"+ area: "mcp"+ mcp_oauth_client_id_metadata_domains:+ type: host_list+ default: ""+ area: "mcp"+ depends_on:+ - mcp_oauth_client_id_metadata_policy+ depends_on_values:+ mcp_oauth_client_id_metadata_policy:+ - approved_domains+ depends_behavior: "hidden"+ dependent_setting_display: "inline"+ mcp_access_token_lifetime_minutes:+ default: 60+ min: 5+ max: 1440+ area: "mcp"+ mcp_refresh_token_lifetime_days:+ default: 30+ min: 1+ max: 365+ area: "mcp"+ mcp_authorization_code_lifetime_seconds:+ default: 300+ min: 60+ max: 600+ area: "mcp"+ mcp_global_rate_limit_per_minute:+ default: 120+ min: 10+ max: 10000+ area: "mcp"+ mcp_audit_log_retention_days:+ default: 90+ min: 1+ max: 3650+ area: "mcp"+ mcp_max_request_bytes:+ default: 1048576+ min: 16384+ max: 5242880+ hidden: true+ mcp_max_response_bytes:+ default: 5242880+ min: 16384+ max: 10485760+ hidden: true+api:retain_web_hook_events_period_days:default: 30diff --git a/db/migrate/20260807000920_create_mcp_server_tables.rb b/db/migrate/20260807000920_create_mcp_server_tables.rbnew file mode 100644index 00000000000..b95a1c2aecc--- /dev/null+++ b/db/migrate/20260807000920_create_mcp_server_tables.rb@@ -0,0 +1,134 @@+# frozen_string_literal: true++class CreateMcpServerTables < ActiveRecord::Migration[8.0]+ def change+ create_table :mcp_primitives do |table|+ table.string :kind, null: false+ table.string :identifier, null: false+ table.boolean :enabled, null: false, default: false+ table.boolean :emergency_blocked, null: false, default: false+ table.datetime :consent_required_at+ table.timestamps+ end+ add_index :mcp_primitives, %i[kind identifier], unique: true, name: "idx_mcp_primitives_unique"++ create_table :mcp_group_scopes do |table|+ table.integer :group_id, null: false+ table.string :scope, null: false+ table.timestamps+ end+ add_index :mcp_group_scopes, %i[group_id scope], unique: true++ create_table :mcp_oauth_clients do |table|+ table.string :client_id, null: false+ table.string :name, null: false+ table.string :registration_type, null: false+ table.string :trust_state, null: false, default: "approved"+ table.string :metadata_uri+ table.string :metadata_hash+ table.datetime :metadata_expires_at+ table.jsonb :metadata, null: false, default: {}+ table.string :redirect_uris, array: true, null: false, default: []+ table.datetime :last_seen_at+ table.timestamps+ end+ add_index :mcp_oauth_clients, :client_id, unique: true++ create_table :mcp_oauth_authorizations do |table|+ table.integer :user_id, null: false+ table.bigint :mcp_oauth_client_id, null: false+ table.string :resource, null: false+ table.string :status, null: false, default: "active"+ table.string :client_metadata_hash+ table.integer :grant_version, null: false, default: 1+ table.datetime :consented_at, null: false+ table.datetime :revoked_at+ table.string :revoked_reason+ table.integer :revoked_by_user_id+ table.timestamps+ end+ add_index :mcp_oauth_authorizations,+ %i[user_id mcp_oauth_client_id],+ unique: true,+ where: "revoked_at IS NULL",+ name: "idx_mcp_active_authorizations_unique"+ add_index :mcp_oauth_authorizations, :mcp_oauth_client_id++ create_table :mcp_oauth_authorization_scopes do |table|+ table.bigint :mcp_oauth_authorization_id, null: false+ table.string :name, null: false+ table.timestamps+ end+ add_index :mcp_oauth_authorization_scopes,+ %i[mcp_oauth_authorization_id name],+ unique: true,+ name: "idx_mcp_authorization_scopes_unique"++ create_table :mcp_oauth_authorization_codes do |table|+ table.string :code_hash, null: false+ table.bigint :mcp_oauth_authorization_id, null: false+ table.string :redirect_uri, null: false+ table.string :resource, null: false+ table.string :code_challenge, null: false+ table.string :code_challenge_method, null: false, default: "S256"+ table.string :scopes, array: true, null: false, default: []+ table.integer :grant_version, null: false+ table.datetime :expires_at, null: false+ table.datetime :consumed_at+ table.timestamps+ end+ add_index :mcp_oauth_authorization_codes, :code_hash, unique: true+ add_index :mcp_oauth_authorization_codes, :mcp_oauth_authorization_id++ create_table :mcp_oauth_access_tokens do |table|+ table.string :token_hash, null: false+ table.bigint :mcp_oauth_authorization_id, null: false+ table.bigint :mcp_oauth_client_id, null: false+ table.integer :user_id, null: false+ table.string :resource, null: false+ table.string :scopes, array: true, null: false, default: []+ table.integer :grant_version, null: false+ table.datetime :expires_at, null: false+ table.datetime :last_used_at+ table.datetime :revoked_at+ table.timestamps+ end+ add_index :mcp_oauth_access_tokens, :token_hash, unique: true+ add_index :mcp_oauth_access_tokens, :mcp_oauth_authorization_id+ add_index :mcp_oauth_access_tokens, %i[user_id revoked_at]++ create_table :mcp_oauth_refresh_tokens do |table|+ table.string :token_hash, null: false+ table.string :family_id, null: false+ table.bigint :mcp_oauth_authorization_id, null: false+ table.bigint :parent_id+ table.bigint :replacement_id+ table.string :scopes, array: true, null: false, default: []+ table.integer :grant_version, null: false+ table.datetime :expires_at, null: false+ table.datetime :consumed_at+ table.datetime :revoked_at+ table.timestamps+ end+ add_index :mcp_oauth_refresh_tokens, :token_hash, unique: true+ add_index :mcp_oauth_refresh_tokens, :family_id+ add_index :mcp_oauth_refresh_tokens, :mcp_oauth_authorization_id++ create_table :mcp_audit_logs do |table|+ table.datetime :occurred_at, null: false+ table.datetime :bucket_at+ table.integer :occurrences, null: false, default: 1+ table.integer :user_id+ table.bigint :mcp_oauth_client_id+ table.string :request_id+ table.string :method+ table.string :tool+ table.string :outcome, null: false+ table.integer :http_status+ table.integer :duration_ms+ table.jsonb :target, null: false, default: {}+ table.timestamps+ end+ add_index :mcp_audit_logs, %i[occurred_at id]+ end+enddiff --git a/db/structure.sql b/db/structure.sqlindex b98132f04b7..172e576eec5 100644--- a/db/structure.sql+++ b/db/structure.sql@@ -7299,6 +7299,347 @@ CREATE SEQUENCE public.llm_quotas_id_seqALTER SEQUENCE public.llm_quotas_id_seq OWNED BY public.llm_quotas.id;+--+-- Name: mcp_audit_logs; Type: TABLE; Schema: public; Owner: -+--++CREATE TABLE public.mcp_audit_logs (+ id bigint NOT NULL,+ occurred_at timestamp(6) without time zone NOT NULL,+ bucket_at timestamp(6) without time zone,+ occurrences integer DEFAULT 1 NOT NULL,+ user_id integer,+ mcp_oauth_client_id bigint,+ request_id character varying,+ method character varying,+ tool character varying,+ outcome character varying NOT NULL,+ http_status integer,+ duration_ms integer,+ target jsonb DEFAULT '{}'::jsonb NOT NULL,+ created_at timestamp(6) without time zone NOT NULL,+ updated_at timestamp(6) without time zone NOT NULL+);+++--+-- Name: mcp_audit_logs_id_seq; Type: SEQUENCE; Schema: public; Owner: -+--++CREATE SEQUENCE public.mcp_audit_logs_id_seq+ START WITH 1+ INCREMENT BY 1+ NO MINVALUE+ NO MAXVALUE+ CACHE 1;+++--+-- Name: mcp_audit_logs_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: -+--++ALTER SEQUENCE public.mcp_audit_logs_id_seq OWNED BY public.mcp_audit_logs.id;+++--+-- Name: mcp_group_scopes; Type: TABLE; Schema: public; Owner: -+--++CREATE TABLE public.mcp_group_scopes (+ id bigint NOT NULL,+ group_id integer NOT NULL,+ scope character varying NOT NULL,+ created_at timestamp(6) without time zone NOT NULL,+ updated_at timestamp(6) without time zone NOT NULL+);+++--+-- Name: mcp_group_scopes_id_seq; Type: SEQUENCE; Schema: public; Owner: -+--++CREATE SEQUENCE public.mcp_group_scopes_id_seq+ START WITH 1+ INCREMENT BY 1+ NO MINVALUE+ NO MAXVALUE+ CACHE 1;+++--+-- Name: mcp_group_scopes_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: -+--++ALTER SEQUENCE public.mcp_group_scopes_id_seq OWNED BY public.mcp_group_scopes.id;+++--+-- Name: mcp_oauth_access_tokens; Type: TABLE; Schema: public; Owner: -+--++CREATE TABLE public.mcp_oauth_access_tokens (+ id bigint NOT NULL,+ token_hash character varying NOT NULL,+ mcp_oauth_authorization_id bigint NOT NULL,+ mcp_oauth_client_id bigint NOT NULL,+ user_id integer NOT NULL,+ resource character varying NOT NULL,+ scopes character varying[] DEFAULT '{}'::character varying[] NOT NULL,+ grant_version integer NOT NULL,+ expires_at timestamp(6) without time zone NOT NULL,+ last_used_at timestamp(6) without time zone,+ revoked_at timestamp(6) without time zone,+ created_at timestamp(6) without time zone NOT NULL,+ updated_at timestamp(6) without time zone NOT NULL+);+++--+-- Name: mcp_oauth_access_tokens_id_seq; Type: SEQUENCE; Schema: public; Owner: -+--++CREATE SEQUENCE public.mcp_oauth_access_tokens_id_seq+ START WITH 1+ INCREMENT BY 1+ NO MINVALUE+ NO MAXVALUE+ CACHE 1;+++--+-- Name: mcp_oauth_access_tokens_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: -+--++ALTER SEQUENCE public.mcp_oauth_access_tokens_id_seq OWNED BY public.mcp_oauth_access_tokens.id;+++--+-- Name: mcp_oauth_authorization_codes; Type: TABLE; Schema: public; Owner: -+--++CREATE TABLE public.mcp_oauth_authorization_codes (+ id bigint NOT NULL,+ code_hash character varying NOT NULL,+ mcp_oauth_authorization_id bigint NOT NULL,+ redirect_uri character varying NOT NULL,+ resource character varying NOT NULL,+ code_challenge character varying NOT NULL,+ code_challenge_method character varying DEFAULT 'S256'::character varying NOT NULL,+ scopes character varying[] DEFAULT '{}'::character varying[] NOT NULL,+ grant_version integer NOT NULL,+ expires_at timestamp(6) without time zone NOT NULL,+ consumed_at timestamp(6) without time zone,+ created_at timestamp(6) without time zone NOT NULL,+ updated_at timestamp(6) without time zone NOT NULL+);+++--+-- Name: mcp_oauth_authorization_codes_id_seq; Type: SEQUENCE; Schema: public; Owner: -+--++CREATE SEQUENCE public.mcp_oauth_authorization_codes_id_seq+ START WITH 1+ INCREMENT BY 1+ NO MINVALUE+ NO MAXVALUE+ CACHE 1;+++--+-- Name: mcp_oauth_authorization_codes_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: -+--++ALTER SEQUENCE public.mcp_oauth_authorization_codes_id_seq OWNED BY public.mcp_oauth_authorization_codes.id;+++--+-- Name: mcp_oauth_authorization_scopes; Type: TABLE; Schema: public; Owner: -+--++CREATE TABLE public.mcp_oauth_authorization_scopes (+ id bigint NOT NULL,+ mcp_oauth_authorization_id bigint NOT NULL,+ name character varying NOT NULL,+ created_at timestamp(6) without time zone NOT NULL,+ updated_at timestamp(6) without time zone NOT NULL+);+++--+-- Name: mcp_oauth_authorization_scopes_id_seq; Type: SEQUENCE; Schema: public; Owner: -+--++CREATE SEQUENCE public.mcp_oauth_authorization_scopes_id_seq+ START WITH 1+ INCREMENT BY 1+ NO MINVALUE+ NO MAXVALUE+ CACHE 1;+++--+-- Name: mcp_oauth_authorization_scopes_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: -+--++ALTER SEQUENCE public.mcp_oauth_authorization_scopes_id_seq OWNED BY public.mcp_oauth_authorization_scopes.id;+++--+-- Name: mcp_oauth_authorizations; Type: TABLE; Schema: public; Owner: -+--++CREATE TABLE public.mcp_oauth_authorizations (+ id bigint NOT NULL,+ user_id integer NOT NULL,+ mcp_oauth_client_id bigint NOT NULL,+ resource character varying NOT NULL,+ status character varying DEFAULT 'active'::character varying NOT NULL,+ client_metadata_hash character varying,+ grant_version integer DEFAULT 1 NOT NULL,+ consented_at timestamp(6) without time zone NOT NULL,+ revoked_at timestamp(6) without time zone,+ revoked_reason character varying,+ revoked_by_user_id integer,+ created_at timestamp(6) without time zone NOT NULL,+ updated_at timestamp(6) without time zone NOT NULL+);+++--+-- Name: mcp_oauth_authorizations_id_seq; Type: SEQUENCE; Schema: public; Owner: -+--++CREATE SEQUENCE public.mcp_oauth_authorizations_id_seq+ START WITH 1+ INCREMENT BY 1+ NO MINVALUE+ NO MAXVALUE+ CACHE 1;+++--+-- Name: mcp_oauth_authorizations_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: -+--++ALTER SEQUENCE public.mcp_oauth_authorizations_id_seq OWNED BY public.mcp_oauth_authorizations.id;+++--+-- Name: mcp_oauth_clients; Type: TABLE; Schema: public; Owner: -+--++CREATE TABLE public.mcp_oauth_clients (+ id bigint NOT NULL,+ client_id character varying NOT NULL,+ name character varying NOT NULL,+ registration_type character varying NOT NULL,+ trust_state character varying DEFAULT 'approved'::character varying NOT NULL,+ metadata_uri character varying,+ metadata_hash character varying,+ metadata_expires_at timestamp(6) without time zone,+ metadata jsonb DEFAULT '{}'::jsonb NOT NULL,+ redirect_uris character varying[] DEFAULT '{}'::character varying[] NOT NULL,+ last_seen_at timestamp(6) without time zone,+ created_at timestamp(6) without time zone NOT NULL,+ updated_at timestamp(6) without time zone NOT NULL+);+++--+-- Name: mcp_oauth_clients_id_seq; Type: SEQUENCE; Schema: public; Owner: -+--++CREATE SEQUENCE public.mcp_oauth_clients_id_seq+ START WITH 1+ INCREMENT BY 1+ NO MINVALUE+ NO MAXVALUE+ CACHE 1;+++--+-- Name: mcp_oauth_clients_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: -+--++ALTER SEQUENCE public.mcp_oauth_clients_id_seq OWNED BY public.mcp_oauth_clients.id;+++--+-- Name: mcp_oauth_refresh_tokens; Type: TABLE; Schema: public; Owner: -+--++CREATE TABLE public.mcp_oauth_refresh_tokens (+ id bigint NOT NULL,+ token_hash character varying NOT NULL,+ family_id character varying NOT NULL,+ mcp_oauth_authorization_id bigint NOT NULL,+ parent_id bigint,+ replacement_id bigint,+ scopes character varying[] DEFAULT '{}'::character varying[] NOT NULL,+ grant_version integer NOT NULL,+ expires_at timestamp(6) without time zone NOT NULL,+ consumed_at timestamp(6) without time zone,+ revoked_at timestamp(6) without time zone,+ created_at timestamp(6) without time zone NOT NULL,+ updated_at timestamp(6) without time zone NOT NULL+);+++--+-- Name: mcp_oauth_refresh_tokens_id_seq; Type: SEQUENCE; Schema: public; Owner: -+--++CREATE SEQUENCE public.mcp_oauth_refresh_tokens_id_seq+ START WITH 1+ INCREMENT BY 1+ NO MINVALUE+ NO MAXVALUE+ CACHE 1;+++--+-- Name: mcp_oauth_refresh_tokens_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: -+--++ALTER SEQUENCE public.mcp_oauth_refresh_tokens_id_seq OWNED BY public.mcp_oauth_refresh_tokens.id;+++--+-- Name: mcp_primitives; Type: TABLE; Schema: public; Owner: -+--++CREATE TABLE public.mcp_primitives (+ id bigint NOT NULL,+ kind character varying NOT NULL,+ identifier character varying NOT NULL,+ enabled boolean DEFAULT false NOT NULL,+ emergency_blocked boolean DEFAULT false NOT NULL,+ consent_required_at timestamp(6) without time zone,+ created_at timestamp(6) without time zone NOT NULL,+ updated_at timestamp(6) without time zone NOT NULL+);+++--+-- Name: mcp_primitives_id_seq; Type: SEQUENCE; Schema: public; Owner: -+--++CREATE SEQUENCE public.mcp_primitives_id_seq+ START WITH 1+ INCREMENT BY 1+ NO MINVALUE+ NO MAXVALUE+ CACHE 1;+++--+-- Name: mcp_primitives_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: -+--++ALTER SEQUENCE public.mcp_primitives_id_seq OWNED BY public.mcp_primitives.id;++---- Name: message_bus; Type: TABLE; Schema: public; Owner: ---@@ -14450,6 +14791,69 @@ ALTER TABLE ONLY public.llm_quota_usages ALTER COLUMN id SET DEFAULT nextval('puALTER TABLE ONLY public.llm_quotas ALTER COLUMN id SET DEFAULT nextval('public.llm_quotas_id_seq'::regclass);+--+-- Name: mcp_audit_logs id; Type: DEFAULT; Schema: public; Owner: -+--++ALTER TABLE ONLY public.mcp_audit_logs ALTER COLUMN id SET DEFAULT nextval('public.mcp_audit_logs_id_seq'::regclass);+++--+-- Name: mcp_group_scopes id; Type: DEFAULT; Schema: public; Owner: -+--++ALTER TABLE ONLY public.mcp_group_scopes ALTER COLUMN id SET DEFAULT nextval('public.mcp_group_scopes_id_seq'::regclass);+++--+-- Name: mcp_oauth_access_tokens id; Type: DEFAULT; Schema: public; Owner: -+--++ALTER TABLE ONLY public.mcp_oauth_access_tokens ALTER COLUMN id SET DEFAULT nextval('public.mcp_oauth_access_tokens_id_seq'::regclass);+++--+-- Name: mcp_oauth_authorization_codes id; Type: DEFAULT; Schema: public; Owner: -+--++ALTER TABLE ONLY public.mcp_oauth_authorization_codes ALTER COLUMN id SET DEFAULT nextval('public.mcp_oauth_authorization_codes_id_seq'::regclass);+++--+-- Name: mcp_oauth_authorization_scopes id; Type: DEFAULT; Schema: public; Owner: -+--++ALTER TABLE ONLY public.mcp_oauth_authorization_scopes ALTER COLUMN id SET DEFAULT nextval('public.mcp_oauth_authorization_scopes_id_seq'::regclass);+++--+-- Name: mcp_oauth_authorizations id; Type: DEFAULT; Schema: public; Owner: -+--++ALTER TABLE ONLY public.mcp_oauth_authorizations ALTER COLUMN id SET DEFAULT nextval('public.mcp_oauth_authorizations_id_seq'::regclass);+++--+-- Name: mcp_oauth_clients id; Type: DEFAULT; Schema: public; Owner: -+--++ALTER TABLE ONLY public.mcp_oauth_clients ALTER COLUMN id SET DEFAULT nextval('public.mcp_oauth_clients_id_seq'::regclass);+++--+-- Name: mcp_oauth_refresh_tokens id; Type: DEFAULT; Schema: public; Owner: -+--++ALTER TABLE ONLY public.mcp_oauth_refresh_tokens ALTER COLUMN id SET DEFAULT nextval('public.mcp_oauth_refresh_tokens_id_seq'::regclass);+++--+-- Name: mcp_primitives id; Type: DEFAULT; Schema: public; Owner: -+--++ALTER TABLE ONLY public.mcp_primitives ALTER COLUMN id SET DEFAULT nextval('public.mcp_primitives_id_seq'::regclass);++---- Name: message_bus id; Type: DEFAULT; Schema: public; Owner: ---@@ -17032,6 +17436,78 @@ ALTER TABLE ONLY public.llm_quotasADD CONSTRAINT llm_quotas_pkey PRIMARY KEY (id);+--+-- Name: mcp_audit_logs mcp_audit_logs_pkey; Type: CONSTRAINT; Schema: public; Owner: -+--++ALTER TABLE ONLY public.mcp_audit_logs+ ADD CONSTRAINT mcp_audit_logs_pkey PRIMARY KEY (id);+++--+-- Name: mcp_group_scopes mcp_group_scopes_pkey; Type: CONSTRAINT; Schema: public; Owner: -+--++ALTER TABLE ONLY public.mcp_group_scopes+ ADD CONSTRAINT mcp_group_scopes_pkey PRIMARY KEY (id);+++--+-- Name: mcp_oauth_access_tokens mcp_oauth_access_tokens_pkey; Type: CONSTRAINT; Schema: public; Owner: -+--++ALTER TABLE ONLY public.mcp_oauth_access_tokens+ ADD CONSTRAINT mcp_oauth_access_tokens_pkey PRIMARY KEY (id);+++--+-- Name: mcp_oauth_authorization_codes mcp_oauth_authorization_codes_pkey; Type: CONSTRAINT; Schema: public; Owner: -+--++ALTER TABLE ONLY public.mcp_oauth_authorization_codes+ ADD CONSTRAINT mcp_oauth_authorization_codes_pkey PRIMARY KEY (id);+++--+-- Name: mcp_oauth_authorization_scopes mcp_oauth_authorization_scopes_pkey; Type: CONSTRAINT; Schema: public; Owner: -+--++ALTER TABLE ONLY public.mcp_oauth_authorization_scopes+ ADD CONSTRAINT mcp_oauth_authorization_scopes_pkey PRIMARY KEY (id);+++--+-- Name: mcp_oauth_authorizations mcp_oauth_authorizations_pkey; Type: CONSTRAINT; Schema: public; Owner: -+--++ALTER TABLE ONLY public.mcp_oauth_authorizations+ ADD CONSTRAINT mcp_oauth_authorizations_pkey PRIMARY KEY (id);+++--+-- Name: mcp_oauth_clients mcp_oauth_clients_pkey; Type: CONSTRAINT; Schema: public; Owner: -+--++ALTER TABLE ONLY public.mcp_oauth_clients+ ADD CONSTRAINT mcp_oauth_clients_pkey PRIMARY KEY (id);+++--+-- Name: mcp_oauth_refresh_tokens mcp_oauth_refresh_tokens_pkey; Type: CONSTRAINT; Schema: public; Owner: -+--++ALTER TABLE ONLY public.mcp_oauth_refresh_tokens+ ADD CONSTRAINT mcp_oauth_refresh_tokens_pkey PRIMARY KEY (id);+++--+-- Name: mcp_primitives mcp_primitives_pkey; Type: CONSTRAINT; Schema: public; Owner: -+--++ALTER TABLE ONLY public.mcp_primitives+ ADD CONSTRAINT mcp_primitives_pkey PRIMARY KEY (id);++---- Name: message_bus message_bus_pkey; Type: CONSTRAINT; Schema: public; Owner: ---@@ -19068,6 +19544,27 @@ CREATE INDEX idx_leaderboard_scores_lb_date ON public.gamification_leaderboard_sCREATE UNIQUE INDEX idx_leaderboard_scores_lb_user_date ON public.gamification_leaderboard_scores USING btree (leaderboard_id, user_id, date);+--+-- Name: idx_mcp_active_authorizations_unique; Type: INDEX; Schema: public; Owner: -+--++CREATE UNIQUE INDEX idx_mcp_active_authorizations_unique ON public.mcp_oauth_authorizations USING btree (user_id, mcp_oauth_client_id) WHERE (revoked_at IS NULL);+++--+-- Name: idx_mcp_authorization_scopes_unique; Type: INDEX; Schema: public; Owner: -+--++CREATE UNIQUE INDEX idx_mcp_authorization_scopes_unique ON public.mcp_oauth_authorization_scopes USING btree (mcp_oauth_authorization_id, name);+++--+-- Name: idx_mcp_primitives_unique; Type: INDEX; Schema: public; Owner: -+--++CREATE UNIQUE INDEX idx_mcp_primitives_unique ON public.mcp_primitives USING btree (kind, identifier);++---- Name: idx_notifications_speedup_unread_count; Type: INDEX; Schema: public; Owner: ---@@ -19082,6 +19579,13 @@ CREATE INDEX idx_notifications_speedup_unread_count ON public.notifications USINCREATE UNIQUE INDEX idx_on_llm_model_id_feature_name_2b0b794b27 ON public.llm_feature_credit_costs USING btree (llm_model_id, feature_name);+--+-- Name: idx_on_mcp_oauth_authorization_id_d749d8a9de; Type: INDEX; Schema: public; Owner: -+--++CREATE INDEX idx_on_mcp_oauth_authorization_id_d749d8a9de ON public.mcp_oauth_authorization_codes USING btree (mcp_oauth_authorization_id);++---- Name: idx_on_sidebar_section_id_locale_271bd8ee1c; Type: INDEX; Schema: public; Owner: ---@@ -21462,6 +21966,83 @@ CREATE UNIQUE INDEX index_llm_quotas_on_group_id_and_llm_model_id ON public.llm_CREATE INDEX index_llm_quotas_on_llm_model_id ON public.llm_quotas USING btree (llm_model_id);+--+-- Name: index_mcp_audit_logs_on_occurred_at_and_id; Type: INDEX; Schema: public; Owner: -+--++CREATE INDEX index_mcp_audit_logs_on_occurred_at_and_id ON public.mcp_audit_logs USING btree (occurred_at, id);+++--+-- Name: index_mcp_group_scopes_on_group_id_and_scope; Type: INDEX; Schema: public; Owner: -+--++CREATE UNIQUE INDEX index_mcp_group_scopes_on_group_id_and_scope ON public.mcp_group_scopes USING btree (group_id, scope);+++--+-- Name: index_mcp_oauth_access_tokens_on_mcp_oauth_authorization_id; Type: INDEX; Schema: public; Owner: -+--++CREATE INDEX index_mcp_oauth_access_tokens_on_mcp_oauth_authorization_id ON public.mcp_oauth_access_tokens USING btree (mcp_oauth_authorization_id);+++--+-- Name: index_mcp_oauth_access_tokens_on_token_hash; Type: INDEX; Schema: public; Owner: -+--++CREATE UNIQUE INDEX index_mcp_oauth_access_tokens_on_token_hash ON public.mcp_oauth_access_tokens USING btree (token_hash);+++--+-- Name: index_mcp_oauth_access_tokens_on_user_id_and_revoked_at; Type: INDEX; Schema: public; Owner: -+--++CREATE INDEX index_mcp_oauth_access_tokens_on_user_id_and_revoked_at ON public.mcp_oauth_access_tokens USING btree (user_id, revoked_at);+++--+-- Name: index_mcp_oauth_authorization_codes_on_code_hash; Type: INDEX; Schema: public; Owner: -+--++CREATE UNIQUE INDEX index_mcp_oauth_authorization_codes_on_code_hash ON public.mcp_oauth_authorization_codes USING btree (code_hash);+++--+-- Name: index_mcp_oauth_authorizations_on_mcp_oauth_client_id; Type: INDEX; Schema: public; Owner: -+--++CREATE INDEX index_mcp_oauth_authorizations_on_mcp_oauth_client_id ON public.mcp_oauth_authorizations USING btree (mcp_oauth_client_id);+++--+-- Name: index_mcp_oauth_clients_on_client_id; Type: INDEX; Schema: public; Owner: -+--++CREATE UNIQUE INDEX index_mcp_oauth_clients_on_client_id ON public.mcp_oauth_clients USING btree (client_id);+++--+-- Name: index_mcp_oauth_refresh_tokens_on_family_id; Type: INDEX; Schema: public; Owner: -+--++CREATE INDEX index_mcp_oauth_refresh_tokens_on_family_id ON public.mcp_oauth_refresh_tokens USING btree (family_id);+++--+-- Name: index_mcp_oauth_refresh_tokens_on_mcp_oauth_authorization_id; Type: INDEX; Schema: public; Owner: -+--++CREATE INDEX index_mcp_oauth_refresh_tokens_on_mcp_oauth_authorization_id ON public.mcp_oauth_refresh_tokens USING btree (mcp_oauth_authorization_id);+++--+-- Name: index_mcp_oauth_refresh_tokens_on_token_hash; Type: INDEX; Schema: public; Owner: -+--++CREATE UNIQUE INDEX index_mcp_oauth_refresh_tokens_on_token_hash ON public.mcp_oauth_refresh_tokens USING btree (token_hash);++---- Name: index_message_bus_on_created_at; Type: INDEX; Schema: public; Owner: ---@@ -24539,6 +25120,7 @@ INSERT INTO "schema_migrations" (version) VALUES('20260810154331'),('20260810012238'),('20260807182856'),+('20260807000920'),('20260806074210'),('20260806074204'),('20260803163818'),diff --git a/frontend/discourse/admin/components/admin-mcp.gjs b/frontend/discourse/admin/components/admin-mcp.gjsnew file mode 100644index 00000000000..ecf4b461296--- /dev/null+++ b/frontend/discourse/admin/components/admin-mcp.gjs@@ -0,0 +1,1994 @@+import Component from "@glimmer/component";+import { tracked } from "@glimmer/tracking";+import { array, concat, fn } from "@ember/helper";+import { on } from "@ember/modifier";+import { action } from "@ember/object";+import { LinkTo } from "@ember/routing";+import { service } from "@ember/service";+import AdminConfigAreaCard from "discourse/admin/components/admin-config-area-card";+import AdminConfigAreaEmptyList from "discourse/admin/components/admin-config-area-empty-list";+import AdminSectionLandingItem from "discourse/admin/components/admin-section-landing-item";+import AdminSectionLandingWrapper from "discourse/admin/components/admin-section-landing-wrapper";+import BackButton from "discourse/components/back-button";+import Form from "discourse/components/form";+import { ajax } from "discourse/lib/ajax";+import { popupAjaxError } from "discourse/lib/ajax-error";+import discourseDebounce from "discourse/lib/debounce";+import { INPUT_DELAY } from "discourse/lib/environment";+import { clipboardCopy } from "discourse/lib/utilities";+import GroupChooser from "discourse/select-kit/components/group-chooser";+import { eq, not, notEq, or } from "discourse/truth-helpers";+import DButton from "discourse/ui-kit/d-button";+import DConditionalLoadingSpinner from "discourse/ui-kit/d-conditional-loading-spinner";+import DLoadMore from "discourse/ui-kit/d-load-more";+import DMultiSelect from "discourse/ui-kit/d-multi-select";+import DPageSubheader from "discourse/ui-kit/d-page-subheader";+import dAgeWithTooltip from "discourse/ui-kit/helpers/d-age-with-tooltip";+import dConcatClass from "discourse/ui-kit/helpers/d-concat-class";+import dFormatDate from "discourse/ui-kit/helpers/d-format-date";+import dIcon from "discourse/ui-kit/helpers/d-icon";+import dOnResize from "discourse/ui-kit/modifiers/d-on-resize";+import { i18n } from "discourse-i18n";++const CLIENT_PRESETS = {+ codex: {+ name: "Codex",+ client_id: "codex",+ redirect_uris: "http://127.0.0.1/callback",+ },+ chatgpt: {+ name: "ChatGPT",+ client_id: "https://chatgpt.com/oauth/client.json",+ redirect_uris: "https://chatgpt.com/connector_platform_oauth_redirect",+ },+ claude_code: {+ name: "Claude Code",+ client_id: "claude-code",+ redirect_uris: "http://localhost:8080/callback",+ },+ mcp_inspector: {+ name: "MCP Inspector",+ client_id: "mcp-inspector",+ redirect_uris:+ "http://localhost:6274/oauth/callback\nhttp://127.0.0.1:6276/oauth/callback",+ },+ visual_studio_code: {+ name: "Visual Studio Code",+ client_id: "visual-studio-code",+ redirect_uris: "http://127.0.0.1:33418\nhttps://vscode.dev/redirect",+ },+ custom: { name: "", client_id: "", redirect_uris: "" },+};++function listValue(value) {+ return Array.isArray(value) ? value.join(", ") : value || "";+}++function normalizeList(value) {+ if (Array.isArray(value)) {+ return value;+ }++ return (value || "")+ .split(/[\n,]/)+ .map((item) => item.trim())+ .filter(Boolean);+}++function mcpValue(group, value) {+ return i18n(`admin.config.mcp.values.${group}.${value}`);+}++export default class AdminMcp extends Component {+ @service a11y;+ @service dialog;+ @service router;+ @service site;+ @service toasts;++ @tracked primitiveFilter = "";+ @tracked primitiveGroupBy = "scope";+ @tracked selectedPrimitiveGroup = "all";+ @tracked primitiveRisk = "all";+ @tracked primitiveState = "all";+ @tracked primitiveEnabledStates;+ @tracked authorizationFilter = "";+ @tracked clientFilter = "";+ @tracked activityFilter = "";+ @tracked activityOutcome = "all";+ @tracked primitiveFormApi;+ @tracked saving = false;+ @tracked clients;+ @tracked clientRecord;+ @tracked clientNextCursor;+ @tracked clientLoading = false;+ @tracked selectedClientPresetId;+ @tracked primitiveRecords;+ @tracked updatingPrimitiveId;+ @tracked authorizations;+ @tracked authorizationNextCursor;+ @tracked authorizationLoading = false;+ @tracked activity;+ @tracked activityMetrics;+ @tracked activityNextCursor;+ @tracked activityLoading = false;+ @tracked accessRules;+ @tracked accessFormData;+ @tracked editingAccessRule;++ primitiveFilterFormData = {+ primitiveFilter: "",+ primitiveGroupBy: "scope",+ primitiveRisk: "all",+ primitiveState: "all",+ };+ clientFilterFormData = { clientFilter: "" };+ authorizationFilterFormData = { authorizationFilter: "" };+ activityFilterFormData = { activityFilter: "", activityOutcome: "all" };+ clientPresetIds = Object.keys(CLIENT_PRESETS);+ clientRequestId = 0;+ authorizationRequestId = 0;+ activityRequestId = 0;++ constructor() {+ super(...arguments);+ const model = this.args.model || {};+ this.clients = model.clients || model.oauth_clients;+ this.clientNextCursor = model.meta?.next_cursor;+ this.clientRecord = model.client;+ this.primitiveRecords = model.primitives;+ this.primitiveEnabledStates = new Map(+ (model.primitives || []).map((primitive) => [+ primitive.id,+ Boolean(primitive.enabled),+ ])+ );+ this.authorizations = model.authorizations;+ this.authorizationNextCursor = model.meta?.next_cursor;+ this.activity = model.activity || model.events;+ this.activityMetrics = model.metrics;+ this.activityNextCursor = model.meta?.next_cursor;+ this.accessRules = model.access_rules || [];+ if (this.args.section === "access-new") {+ this.accessFormData = {+ group_ids: [],+ scopes: this.accessScopeSelections([]),+ };+ } else if (this.args.section === "access-edit") {+ this.editingAccessRule = model.access_rule;+ this.accessFormData = {+ group_ids: [model.access_rule.group_id.toString()],+ scopes: this.accessScopeSelections(model.access_rule.scopes),+ };+ }+ }++ get model() {+ return this.args.model || {};+ }++ get groupOptions() {+ return (this.site.groups || []).map((group) => ({+ id: group.id.toString(),+ name: group.name,+ }));+ }++ get primitives() {+ return this.primitiveRecords || this.model.primitives || [];+ }++ get catalog() {+ return this.model.catalog || {};+ }++ get metrics() {+ return this.activityMetrics || this.model.metrics || {};+ }++ get setupChecklist() {+ return this.model.setup_checklist || [];+ }++ get showSetupChecklist() {+ return this.setupChecklist.some((item) => !item.complete);+ }++ get warnings() {+ return this.model.warnings || [];+ }++ get client() {+ return this.clientRecord || this.model.client || this.model;+ }++ get filteredPrimitives() {+ const filter = (this.primitiveFilter || "").trim().toLowerCase();++ return this.primitives.filter((primitive) => {+ const matchesText =+ !filter ||+ [+ primitive.id,+ primitive.name,+ primitive.title,+ primitive.description,+ primitive.provider,+ ...(primitive.required_scopes || []),+ ]+ .filter(Boolean)+ .join(" ")+ .toLowerCase()+ .includes(filter);+ const matchesGroup =+ this.selectedPrimitiveGroup === "all" ||+ this.primitiveGroupValues(primitive).includes(+ this.selectedPrimitiveGroup+ );+ const matchesRisk =+ this.primitiveRisk === "all" || primitive.risk === this.primitiveRisk;+ const matchesState =+ this.primitiveState === "all" ||+ (this.primitiveState === "enabled" && primitive.enabled) ||+ (this.primitiveState === "disabled" && !primitive.enabled) ||+ (this.primitiveState === "unavailable" && !primitive.available) ||+ (this.primitiveState === "blocked" && primitive.emergency_blocked);++ return matchesText && matchesGroup && matchesRisk && matchesState;+ });+ }++ get primitiveProviders() {+ return [+ ...new Set(+ this.primitives.map((primitive) => primitive.provider).filter(Boolean)+ ),+ ];+ }++ get primitiveKinds() {+ return [+ ...new Set(+ this.primitives.map((primitive) => primitive.kind).filter(Boolean)+ ),+ ];+ }++ get primitiveRisks() {+ return [+ "all",+ ...new Set(+ this.primitives.map((primitive) => primitive.risk).filter(Boolean)+ ),+ ];+ }++ get primitiveStates() {+ return ["all", "enabled", "disabled", "unavailable", "blocked"];+ }++ get primitiveGroupByOptions() {+ return ["scope", "provider", "kind"];+ }++ get primitiveGroupIds() {+ switch (this.primitiveGroupBy) {+ case "provider":+ return this.primitiveProviders;+ case "kind":+ return this.primitiveKinds;+ default:+ return this.scopeOptions+ .filter((scope) => scope.primitiveCount > 0)+ .map((scope) => scope.id);+ }+ }++ get primitiveGroups() {+ return ["all", ...this.primitiveGroupIds].map((id) => {+ const primitives =+ id === "all"+ ? this.primitives+ : this.primitives.filter((primitive) =>+ this.primitiveGroupValues(primitive).includes(id)+ );++ return {+ id,+ label:+ id === "all"+ ? i18n("admin.config.mcp.primitives.all_primitives")+ : this.primitiveGroupLabel(id),+ enabled: primitives.filter((primitive) =>+ this.primitiveEnabledStates.get(primitive.id)+ ).length,+ total: primitives.length,+ };+ });+ }++ get selectedPrimitiveGroupDetails() {+ return (+ this.primitiveGroups.find(+ (group) => group.id === this.selectedPrimitiveGroup+ ) || this.primitiveGroups[0]+ );+ }++ get scopeOptions() {+ const counts = new Map();+ this.primitives.forEach((primitive) => {+ (primitive.required_scopes || []).forEach((scope) => {+ counts.set(scope, (counts.get(scope) || 0) + 1);+ });+ });++ const scopes = this.model.available_scopes || [...counts.keys()];+ return scopes.map((scope) => ({+ id: scope,+ name: scope,+ primitiveCount: counts.get(scope) || 0,+ preventRemoval: scope === this.model.initial_scope,+ }));+ }++ get groupChooserOptions() {+ return { maximum: 1 };+ }++ get availableAccessGroups() {+ const usedGroupIds = new Set(+ this.accessRules.map((rule) => rule.group_id.toString())+ );+ return this.groupOptions.filter((group) => !usedGroupIds.has(group.id));+ }++ get newClientFormData() {+ return { ...CLIENT_PRESETS[this.selectedClientPresetId] };+ }++ get primitiveFormData() {+ return this.primitives.reduce((data, primitive) => {+ data[this.primitiveFieldName(primitive)] = Boolean(primitive.enabled);+ return data;+ }, {});+ }++ get hasPrimitiveChanges() {+ return this.primitives.some(+ (primitive) =>+ this.primitiveEnabledStates.get(primitive.id) !==+ Boolean(primitive.enabled)+ );+ }++ get clientRecords() {+ return this.clients || this.model.clients || this.model.oauth_clients || [];+ }++ get hasClients() {+ return this.clientRecords.length > 0 || this.clientFilter.trim().length > 0;+ }++ get filteredClients() {+ return this.clientRecords;+ }++ get filteredAuthorizations() {+ return this.authorizations || this.model.authorizations || [];+ }++ get canLoadMoreClients() {+ return Boolean(this.clientNextCursor);+ }++ get canLoadMoreAuthorizations() {+ return Boolean(this.authorizationNextCursor);+ }++ get activityOutcomes() {+ return ["all", "success", "error", "rate_limited"];+ }++ get canLoadMoreActivity() {+ return Boolean(this.activityNextCursor);+ }++ accessScopeSelections(scopes) {+ const scopeIds = new Set(scopes || []);+ if (this.model.initial_scope) {+ scopeIds.add(this.model.initial_scope);+ }+ return this.scopeSelections([...scopeIds]);+ }++ scopeSelections(scopes) {+ const options = new Map(+ this.scopeOptions.map((option) => [option.id, option])+ );+ return (scopes || []).map(+ (scope) =>+ options.get(scope) || {+ id: scope,+ name: scope,+ primitiveCount: 0,+ }+ );+ }++ primitiveFieldName(primitive) {+ return primitive.field_name;+ }++ primitiveGroupValues(primitive) {+ switch (this.primitiveGroupBy) {+ case "provider":+ return primitive.provider ? [primitive.provider] : [];+ case "kind":+ return primitive.kind ? [primitive.kind] : [];+ default:+ return primitive.required_scopes || [];+ }+ }++ primitiveGroupLabel(id) {+ return this.primitiveGroupBy === "kind"+ ? mcpValue("primitive_kind", id)+ : id;+ }++ announcePrimitiveResults() {+ this.a11y.announce(+ i18n("admin.config.mcp.primitives.results_count", {+ visible: this.filteredPrimitives.length,+ total: this.primitives.length,+ }),+ "polite"+ );+ }++ @action+ async loadScopeOptions(filter) {+ const query = filter.trim().toLowerCase();+ return this.scopeOptions.filter((scope) =>+ scope.name.toLowerCase().includes(query)+ );+ }++ @action+ updateFilter(name, value) {+ switch (name) {+ case "primitiveFilter":+ this.selectedPrimitiveGroup = "all";+ this.primitiveFilter = value || "";+ this.announcePrimitiveResults();+ break;+ case "primitiveGroupBy":+ this.primitiveGroupBy = value;+ this.selectedPrimitiveGroup = "all";+ this.announcePrimitiveResults();+ break;+ case "primitiveRisk":+ this.primitiveRisk = value;+ this.announcePrimitiveResults();+ break;+ case "primitiveState":+ this.primitiveState = value;+ this.announcePrimitiveResults();+ break;+ case "clientFilter":+ this.clientFilter = value || "";+ discourseDebounce(this, this.reloadClients, INPUT_DELAY);+ break;+ case "authorizationFilter":+ this.authorizationFilter = value || "";+ discourseDebounce(this, this.reloadAuthorizations, INPUT_DELAY);+ break;+ case "activityFilter":+ this.activityFilter = value || "";+ discourseDebounce(this, this.reloadActivity, INPUT_DELAY);+ break;+ case "activityOutcome":+ this.activityOutcome = value;+ discourseDebounce(this, this.reloadActivity, 0);+ break;+ }+ }++ @action+ registerPrimitiveForm(api) {+ this.primitiveFormApi = api;+ }++ @action+ shouldConfirmPrimitiveChanges() {+ return this.hasPrimitiveChanges;+ }++ @action+ positionPrimitiveActions([entry]) {+ const sectionElement = entry.target.closest(+ ".admin-mcp__primitives-section"+ );+ const formElement = sectionElement?.querySelector(+ ".admin-mcp__primitive-selection-form"+ );+ const actionsElement = formElement?.querySelector(".form-kit__actions");++ if (!formElement || !actionsElement) {+ return;+ }++ const { width } = formElement.getBoundingClientRect();+ const { height } = actionsElement.getBoundingClientRect();+ actionsElement.style.width = `${width}px`;+ formElement.style.setProperty(+ "--mcp-primitive-actions-height",+ `${height}px`+ );+ }++ @action+ selectPrimitiveGroup(groupId) {+ this.selectedPrimitiveGroup = groupId;+ this.announcePrimitiveResults();+ }++ @action+ updatePrimitiveEnabled(primitive, event) {+ const enabled = event.target.checked;+ const states = new Map(this.primitiveEnabledStates);+ states.set(primitive.id, enabled);+ this.primitiveEnabledStates = states;+ }++ @action+ selectVisiblePrimitives(enabled) {+ const states = new Map(this.primitiveEnabledStates);+ this.filteredPrimitives.forEach((primitive) => {+ this.primitiveFormApi?.set(this.primitiveFieldName(primitive), enabled);+ states.set(primitive.id, enabled);+ });+ this.primitiveEnabledStates = states;+ }++ @action+ async saveAccessRule(data) {+ const groupId = this.editingAccessRule?.group_id || data.group_ids?.[0];+ this.saving = true;+ try {+ const result = await ajax(`/admin/mcp/access/${groupId}.json`, {+ type: "PUT",+ data: {+ scopes: (data.scopes || []).map((scope) => scope.id),+ },+ });+ this.accessRules = result.access_rules;+ this.model.access_rules = result.access_rules;+ this.toasts.success({+ duration: "short",+ data: { message: i18n("admin.config.mcp.access.saved") },+ });+ this.router.transitionTo("adminConfig.mcp.access");+ } catch (error) {+ popupAjaxError(error);+ } finally {+ this.saving = false;+ }+ }++ @action+ deleteAccessRule(rule) {+ this.dialog.confirm({+ message: i18n("admin.config.mcp.access.confirm_delete", {+ group: rule.group_name,+ }),+ didConfirm: async () => {+ try {+ await ajax(`/admin/mcp/access/${rule.group_id}.json`, {+ type: "DELETE",+ });+ this.accessRules = this.accessRules.filter(+ (item) => item.group_id !== rule.group_id+ );+ } catch (error) {+ popupAjaxError(error);+ }+ },+ });+ }++ @action+ async savePrimitives(data) {+ this.saving = true;+ try {+ const enabledPrimitives = Object.entries(data)+ .filter(([, enabled]) => enabled)+ .map(+ ([field]) =>+ this.primitives.find((primitive) => primitive.field_name === field)+ ?.id+ )+ .filter(Boolean);+ await ajax("/admin/mcp/capabilities.json", {+ type: "PUT",+ data: { primitive_ids: enabledPrimitives },+ });+ const enabledPrimitiveIds = new Set(enabledPrimitives);+ this.primitiveRecords = this.primitives.map((primitive) => ({+ ...primitive,+ enabled: enabledPrimitiveIds.has(primitive.id),+ }));+ this.toasts.success({+ duration: "short",+ data: { message: i18n("admin.config.mcp.primitives_saved") },+ });+ } catch (error) {+ popupAjaxError(error);+ } finally {+ this.saving = false;+ }+ }++ @action+ togglePrimitiveEmergencyBlock(primitive) {+ const blocked = !primitive.emergency_blocked;+ const updateBlock = () => this.#setPrimitiveBlocked(primitive, blocked);++ if (blocked) {+ this.dialog.confirm({+ message: i18n("admin.config.mcp.confirm_emergency_block", {+ name: primitive.title || primitive.name,+ }),+ didConfirm: updateBlock,+ });+ } else {+ updateBlock();+ }+ }++ @action+ copyEndpoint() {+ if (clipboardCopy(this.model.endpoint)) {+ this.toasts.success({+ duration: "short",+ data: { message: i18n("admin.config.mcp.endpoint_copied") },+ });+ }+ }++ @action+ async createClient(data) {+ this.saving = true;+ try {+ const result = await ajax("/admin/mcp/clients.json", {+ type: "POST",+ data: {+ client: {+ name: data.name,+ client_id: data.client_id,+ redirect_uris: normalizeList(data.redirect_uris),+ },+ },+ });+ this.toasts.success({+ duration: "short",+ data: { message: i18n("admin.config.mcp.clients.created") },+ });+ this.router.transitionTo(+ "adminConfig.mcp.clients.show",+ result.client.id+ );+ } catch (error) {+ popupAjaxError(error);+ } finally {+ this.saving = false;+ }+ }++ @action+ resetClientPreset() {+ this.selectedClientPresetId = null;+ }++ @action+ selectClientPreset(preset) {+ this.selectedClientPresetId = preset;+ }++ @action+ async toggleClientBlock(client) {+ const blocked = !client.blocked;+ const updateBlock = () =>+ ajax(`/admin/mcp/clients/${client.id}/block.json`, {+ type: "PUT",+ data: { blocked },+ }).then((result) => {+ const updatedClient = result.client || {+ ...client,+ blocked,+ trust_state: blocked ? "blocked" : "approved",+ };+ this.clientRecord = updatedClient;+ this.clients = this.clients?.map((item) =>+ item.id === client.id ? updatedClient : item+ );+ });++ if (blocked) {+ this.dialog.confirm({+ message: i18n("admin.config.mcp.confirm_block_client", {+ name: client.name,+ }),+ didConfirm: updateBlock,+ });+ } else {+ await updateBlock().catch(popupAjaxError);+ }+ }++ @action+ async refreshClient(client) {+ try {+ const result = await ajax(+ `/admin/mcp/clients/${client.id}/refresh.json`,+ {+ type: "POST",+ }+ );+ const updatedClient = result.client || result;+ this.clientRecord = updatedClient;+ this.clients = this.clients?.map((item) =>+ item.id === client.id ? updatedClient : item+ );+ } catch (error) {+ popupAjaxError(error);+ }+ }++ @action+ revokeAuthorization(authorization) {+ this.dialog.confirm({+ message: i18n("admin.config.mcp.confirm_revoke_authorization", {+ name: authorization.client_name,+ }),+ didConfirm: async () => {+ try {+ await ajax(`/admin/mcp/authorizations/${authorization.id}.json`, {+ type: "DELETE",+ });+ this.authorizations = this.authorizations.map((item) =>+ item.id === authorization.id ? { ...item, status: "revoked" } : item+ );+ } catch (error) {+ popupAjaxError(error);+ }+ },+ });+ }++ @action+ reloadClients() {+ return this.loadClients({ append: false });+ }++ @action+ loadMoreClients() {+ if (!this.canLoadMoreClients || this.clientLoading) {+ return;+ }++ return this.loadClients({ append: true });+ }++ async loadClients({ append }) {+ const cursor = append ? this.clientNextCursor : null;+ const requestId = this.clientRequestId + 1;+ this.clientRequestId = requestId;+ this.clientLoading = true;++ try {+ const result = await ajax("/admin/mcp/clients.json", {+ data: this.recordRequestData(this.clientFilter, cursor),+ });+ if (requestId !== this.clientRequestId) {+ return;+ }++ const clients = result.clients || [];+ this.clients = append ? [...this.clientRecords, ...clients] : clients;+ this.clientNextCursor =+ result.meta?.next_cursor || result.next_cursor || null;+ } catch (error) {+ if (requestId === this.clientRequestId) {+ popupAjaxError(error);+ }+ } finally {+ if (requestId === this.clientRequestId) {+ this.clientLoading = false;+ }+ }+ }++ @action+ reloadAuthorizations() {+ return this.loadAuthorizations({ append: false });+ }++ @action+ loadMoreAuthorizations() {+ if (!this.canLoadMoreAuthorizations || this.authorizationLoading) {+ return;+ }++ return this.loadAuthorizations({ append: true });+ }++ async loadAuthorizations({ append }) {+ const cursor = append ? this.authorizationNextCursor : null;+ const requestId = this.authorizationRequestId + 1;+ this.authorizationRequestId = requestId;+ this.authorizationLoading = true;++ try {+ const result = await ajax("/admin/mcp/authorizations.json", {+ data: this.recordRequestData(this.authorizationFilter, cursor),+ });+ if (requestId !== this.authorizationRequestId) {+ return;+ }++ const authorizations = result.authorizations || [];+ this.authorizations = append+ ? [...this.filteredAuthorizations, ...authorizations]+ : authorizations;+ this.authorizationNextCursor =+ result.meta?.next_cursor || result.next_cursor || null;+ } catch (error) {+ if (requestId === this.authorizationRequestId) {+ popupAjaxError(error);+ }+ } finally {+ if (requestId === this.authorizationRequestId) {+ this.authorizationLoading = false;+ }+ }+ }++ recordRequestData(filter, cursor) {+ const data = {};+ const normalizedFilter = filter.trim();+ if (normalizedFilter) {+ data.filter = normalizedFilter;+ }+ if (cursor) {+ data.cursor = cursor;+ }+ return data;+ }++ @action+ reloadActivity() {+ return this.loadActivity({ append: false });+ }++ @action+ loadMoreActivity() {+ if (!this.canLoadMoreActivity || this.activityLoading) {+ return;+ }++ return this.loadActivity({ append: true });+ }++ async loadActivity({ append }) {+ const cursor = append ? this.activityNextCursor : null;+ const requestId = this.activityRequestId + 1;+ this.activityRequestId = requestId;+ this.activityLoading = true;++ try {+ const result = await ajax("/admin/mcp/activity.json", {+ data: this.activityRequestData(cursor),+ });+ if (requestId !== this.activityRequestId) {+ return;+ }++ const activity = result.activity || result.events || [];+ this.activity = append ? [...this.activity, ...activity] : activity;+ this.activityNextCursor = result.meta?.next_cursor || result.next_cursor;+ this.activityMetrics = result.metrics || this.activityMetrics;+ } catch (error) {+ if (requestId === this.activityRequestId) {+ popupAjaxError(error);+ }+ } finally {+ if (requestId === this.activityRequestId) {+ this.activityLoading = false;+ }+ }+ }++ activityRequestData(cursor) {+ const data = {};+ const filter = this.activityFilter.trim();+ if (filter) {+ data.filter = filter;+ }+ if (this.activityOutcome !== "all") {+ data.outcome = this.activityOutcome;+ }+ if (cursor) {+ data.cursor = cursor;+ }+ return data;+ }++ async #setPrimitiveBlocked(primitive, blocked) {+ this.updatingPrimitiveId = primitive.id;+ try {+ await ajax("/admin/mcp/capabilities/emergency-block.json", {+ type: "PUT",+ data: { primitive_id: primitive.id, blocked },+ });+ this.primitiveRecords = this.primitiveRecords.map((item) =>+ item.id === primitive.id+ ? { ...item, emergency_blocked: blocked }+ : item+ );+ this.toasts.success({+ duration: "short",+ data: {+ message: i18n(+ blocked+ ? "admin.config.mcp.primitive_blocked"+ : "admin.config.mcp.primitive_unblocked",+ { name: primitive.title || primitive.name }+ ),+ },+ });+ } catch (error) {+ popupAjaxError(error);+ } finally {+ this.updatingPrimitiveId = null;+ }+ }++ <template>+ {{#if (eq @section "overview")}}+ <DPageSubheader+ @descriptionLabel={{i18n "admin.config.mcp.overview.description"}}+ @titleLabel={{i18n "admin.config.mcp.overview.title"}}+ />+ <div class="admin-mcp__overview-grid">+ <AdminConfigAreaCard+ class="admin-mcp__endpoint-card"+ @heading="admin.config.mcp.overview.endpoint_title"+ >+ <:content>+ <div class="admin-mcp__endpoint">+ <code>{{@model.endpoint}}</code>+ <DButton+ class="btn-transparent"+ @action={{this.copyEndpoint}}+ @icon="copy"+ @title="admin.config.mcp.copy_endpoint"+ />+ </div>+ <dl class="admin-mcp__summary-list">+ <div><dt>{{i18n "admin.config.mcp.overview.protocol"}}</dt><dd+ >{{@model.protocol_version}}</dd></div>+ <div><dt>{{i18n+ "admin.config.mcp.overview.server_version"+ }}</dt><dd>{{@model.server_version}}</dd></div>+ <div><dt>{{i18n "admin.config.mcp.overview.status"}}</dt><dd+ >{{mcpValue "server_status" @model.status}}</dd></div>+ </dl>+ </:content>+ </AdminConfigAreaCard>++ <AdminConfigAreaCard @heading="admin.config.mcp.overview.catalog_title">+ <:content>+ <dl class="admin-mcp__metric-grid">+ <div><dt>{{i18n "admin.config.mcp.overview.tools"}}</dt><dd+ >{{this.catalog.tools}}</dd></div>+ <div><dt>{{i18n "admin.config.mcp.overview.resources"}}</dt><dd+ >{{this.catalog.resources}}</dd></div>+ <div><dt>{{i18n "admin.config.mcp.overview.prompts"}}</dt><dd+ >{{this.catalog.prompts}}</dd></div>+ <div><dt>{{i18n "admin.config.mcp.overview.schema_size"}}</dt><dd+ >{{i18n+ "admin.config.mcp.overview.schema_size_value"+ bytes=this.catalog.schema_bytes+ }}</dd></div>+ </dl>+ </:content>+ </AdminConfigAreaCard>++ <AdminConfigAreaCard+ class="admin-mcp__usage"+ @heading="admin.config.mcp.overview.activity_title"+ >+ <:content>+ <dl class="admin-mcp__metric-grid">+ <div><dt>{{i18n+ "admin.config.mcp.overview.approved_oauth_clients"+ }}</dt><dd>{{this.metrics.approved_oauth_clients}}</dd></div>+ <div><dt>{{i18n+ "admin.config.mcp.overview.authorizations"+ }}</dt><dd>{{this.metrics.authorizations}}</dd></div>+ <div><dt>{{i18n "admin.config.mcp.overview.tokens"}}</dt><dd+ >{{this.metrics.tokens}}</dd></div>+ <div><dt>{{i18n "admin.config.mcp.overview.errors"}}</dt><dd+ >{{this.metrics.errors}}</dd></div>+ </dl>+ </:content>+ </AdminConfigAreaCard>++ {{#if this.showSetupChecklist}}+ <AdminConfigAreaCard+ class="admin-mcp__setup"+ @heading="admin.config.mcp.overview.setup_title"+ >+ <:content>+ <ol class="admin-mcp__checklist">+ {{#each this.setupChecklist as |item|}}+ <li class={{if item.complete "is-complete"}}>+ {{dIcon (if item.complete "circle-check" "circle")}}+ <span>{{item.label}}</span>+ </li>+ {{/each}}+ </ol>+ </:content>+ </AdminConfigAreaCard>+ {{/if}}+ </div>++ {{#if this.warnings.length}}+ <section+ aria-labelledby="mcp-warnings-title"+ class="admin-mcp__warnings"+ >+ <h2 id="mcp-warnings-title">{{i18n+ "admin.config.mcp.overview.warnings_title"+ }}</h2>+ <ul>+ {{#each this.warnings as |warning|}}<li>{{warning}}</li>{{/each}}+ </ul>+ </section>+ {{/if}}+ {{else if (eq @section "access")}}+ <section class="admin-mcp__access-section">+ <DPageSubheader+ @descriptionLabel={{i18n "admin.config.mcp.access.description"}}+ @titleLabel={{i18n "admin.config.mcp.access.title"}}+ >+ <:actions as |actions|>+ <actions.Primary+ @label="admin.config.mcp.access.add"+ @route="adminConfig.mcp.access.new"+ />+ </:actions>+ </DPageSubheader>++ <table class="d-table admin-mcp__access-table">+ <thead class="d-table__header">+ <tr class="d-table__row">+ <th class="d-table__cell --overview">{{i18n+ "admin.config.mcp.access.groups"+ }}</th>+ <th class="d-table__cell --detail">{{i18n+ "admin.config.mcp.access.scopes"+ }}</th>+ <th class="d-table__cell --controls"><span class="sr-only">{{i18n+ "admin.config.mcp.access.edit"+ }}</span></th>+ <th class="d-table__cell --controls"><span class="sr-only">{{i18n+ "admin.config.mcp.access.delete"+ }}</span></th>+ </tr>+ </thead>+ <tbody class="d-table__body">+ {{#each this.accessRules as |rule|}}+ <tr+ class="d-table__row admin-mcp__access-row"+ data-group-id={{rule.group_id}}+ >+ <td class="d-table__cell --overview">+ <span+ class="d-table__overview-name"+ >{{rule.group_name}}</span>+ {{#if rule.pre_registered}}+ <small>{{i18n+ "admin.config.mcp.access.admins_description"+ }}</small>+ {{/if}}+ </td>+ <td class="d-table__cell --detail">+ <div class="d-table__mobile-label">{{i18n+ "admin.config.mcp.access.scopes"+ }}</div>+ <ul class="admin-mcp__access-scopes">+ {{#each rule.scopes as |scope|}}<li><code+ >{{scope}}</code></li>{{/each}}+ </ul>+ </td>+ <td class="d-table__cell --controls">+ <DButton+ class="btn-small admin-mcp__edit-access-rule"+ @icon="pencil"+ @label="admin.config.mcp.access.edit"+ @route="adminConfig.mcp.access.edit"+ @routeModels={{array rule.group_id}}+ />+ </td>+ <td class="d-table__cell --controls">+ {{#if rule.deletable}}+ <DButton+ class="btn-danger btn-small admin-mcp__delete-access-rule"+ @action={{fn this.deleteAccessRule rule}}+ @icon="trash-can"+ @title="admin.config.mcp.access.delete"+ />+ {{/if}}+ </td>+ </tr>+ {{/each}}+ </tbody>+ </table>+ </section>++ {{else if (or (eq @section "access-new") (eq @section "access-edit"))}}+ <BackButton+ @label="admin.config.mcp.access.back"+ @route="adminConfig.mcp.access"+ />+ <AdminConfigAreaCard+ class="admin-mcp__form-card"+ @heading={{if+ this.editingAccessRule+ "admin.config.mcp.access.edit_title"+ "admin.config.mcp.access.new_title"+ }}+ >+ <:content>+ <Form+ class="admin-mcp__access-form"+ @data={{this.accessFormData}}+ @isLoading={{this.saving}}+ @onSubmit={{this.saveAccessRule}}+ as |form|+ >+ {{#if this.editingAccessRule}}+ <div class="form-kit__field">+ <span class="form-kit__label">{{i18n+ "admin.config.mcp.access.group"+ }}</span>+ <strong>{{this.editingAccessRule.group_name}}</strong>+ </div>+ {{else}}+ <form.Field+ @name="group_ids"+ @title={{i18n "admin.config.mcp.access.group"}}+ @type="custom"+ @validation="required"+ as |field|+ >+ <field.Control>+ <GroupChooser+ @content={{this.availableAccessGroups}}+ @onChange={{field.set}}+ @options={{this.groupChooserOptions}}+ @value={{field.value}}+ />+ </field.Control>+ </form.Field>+ {{/if}}+ <form.Field+ @description={{i18n "admin.config.mcp.access.scopes_description"}}+ @format="full"+ @name="scopes"+ @title={{i18n "admin.config.mcp.access.scopes"}}+ @type="custom"+ @validation="required"+ as |field|+ >+ <field.Control>+ <DMultiSelect+ class="admin-mcp__scope-select"+ id={{field.id}}+ @contentClass="admin-mcp__scope-select-content"+ @label={{i18n "admin.config.mcp.access.scopes_placeholder"}}+ @loadFn={{this.loadScopeOptions}}+ @onChange={{field.set}}+ @selection={{field.value}}+ >+ <:selection as |scope|>{{scope.name}}</:selection>+ <:result as |scope|>+ <span class="admin-mcp__scope-option">+ <span>{{scope.name}}</span>+ <small>{{i18n+ "admin.config.mcp.access.scope_primitives"+ count=scope.primitiveCount+ }}</small>+ </span>+ </:result>+ </DMultiSelect>+ </field.Control>+ </form.Field>+ <div class="admin-mcp__access-form-actions">+ <form.Submit @label="admin.config.mcp.access.save" />+ </div>+ </Form>+ </:content>+ </AdminConfigAreaCard>++ {{else if (eq @section "primitives")}}+ <DPageSubheader+ @descriptionLabel={{i18n "admin.config.mcp.capabilities.description"}}+ @titleLabel={{i18n "admin.config.mcp.capabilities.title"}}+ />+ <div+ class="admin-mcp__primitives-section"+ {{dOnResize this.positionPrimitiveActions}}+ >+ <p class="admin-mcp__primitives-description">{{i18n+ "admin.config.mcp.primitives.picker_description"+ }}</p>+ <Form+ class="admin-mcp__primitive-filters"+ @data={{this.primitiveFilterFormData}}+ @onSet={{this.updateFilter}}+ as |form|+ >+ <form.Field+ class="admin-mcp__filter-search"+ @format="full"+ @name="primitiveFilter"+ @showOptional={{false}}+ @showTitle={{false}}+ @title={{i18n "admin.config.mcp.primitives.search_placeholder"}}+ @type="input"+ as |field|+ >+ <field.Control+ placeholder={{i18n+ "admin.config.mcp.primitives.search_placeholder"+ }}+ />+ </form.Field>+ <form.Field+ @format="full"+ @name="primitiveGroupBy"+ @showOptional={{false}}+ @showTitle={{false}}+ @title={{i18n "admin.config.mcp.primitives.group_by"}}+ @type="select"+ as |field|+ >+ <field.Control+ aria-label={{i18n "admin.config.mcp.primitives.group_by"}}+ @includeNone={{false}}+ as |select|+ >+ {{#each this.primitiveGroupByOptions as |groupBy|}}+ <select.Option @value={{groupBy}}>{{i18n+ (concat+ "admin.config.mcp.primitives.group_by_options." groupBy+ )+ }}</select.Option>+ {{/each}}+ </field.Control>+ </form.Field>+ <form.Field+ class="admin-mcp__filter-impact"+ @format="full"+ @name="primitiveRisk"+ @showOptional={{false}}+ @showTitle={{false}}+ @title={{i18n "admin.config.mcp.primitives.risk"}}+ @type="select"+ as |field|+ >+ <field.Control+ aria-label={{i18n "admin.config.mcp.primitives.risk"}}+ @includeNone={{false}}+ as |select|+ >+ {{#each this.primitiveRisks as |risk|}}+ <select.Option @value={{risk}}>{{mcpValue+ "primitive_risk"+ risk+ }}</select.Option>+ {{/each}}+ </field.Control>+ </form.Field>+ <form.Field+ @format="full"+ @name="primitiveState"+ @showOptional={{false}}+ @showTitle={{false}}+ @title={{i18n "admin.config.mcp.primitives.state"}}+ @type="select"+ as |field|+ >+ <field.Control+ aria-label={{i18n "admin.config.mcp.primitives.state"}}+ @includeNone={{false}}+ as |select|+ >+ {{#each this.primitiveStates as |state|}}+ <select.Option @value={{state}}>{{mcpValue+ "primitive_state"+ state+ }}</select.Option>+ {{/each}}+ </field.Control>+ </form.Field>+ </Form>+ <Form+ class={{dConcatClass+ "admin-mcp__primitive-selection-form"+ (if this.hasPrimitiveChanges "has-floating-actions")+ }}+ @data={{this.primitiveFormData}}+ @isLoading={{this.saving}}+ @onDirtyCheck={{this.shouldConfirmPrimitiveChanges}}+ @onRegisterApi={{this.registerPrimitiveForm}}+ @onSubmit={{this.savePrimitives}}+ as |form|+ >+ <div class="admin-mcp__primitive-browser">+ <nav+ aria-label={{i18n "admin.config.mcp.primitives.groups_label"}}+ class="admin-mcp__primitive-groups"+ >+ <ul class="admin-mcp__primitive-group-list">+ {{#each this.primitiveGroups as |group|}}+ <li>+ <button+ aria-pressed={{eq group.id this.selectedPrimitiveGroup}}+ class={{dConcatClass+ "admin-mcp__primitive-group"+ (if+ (eq group.id this.selectedPrimitiveGroup)+ "is-selected"+ )+ }}+ data-primitive-group-id={{group.id}}+ type="button"+ {{on "click" (fn this.selectPrimitiveGroup group.id)}}+ >+ <span>{{group.label}}</span>+ <small>{{i18n+ "admin.config.mcp.primitives.group_count"+ enabled=group.enabled+ total=group.total+ }}</small>+ </button>+ </li>+ {{/each}}+ </ul>+ </nav>+ <section+ aria-labelledby="mcp-primitive-group-title"+ class="admin-mcp__primitive-panel"+ >+ <header class="admin-mcp__primitive-panel-header">+ <h3+ id="mcp-primitive-group-title"+ >{{this.selectedPrimitiveGroupDetails.label}}</h3>+ <p class="admin-mcp__results-count">{{i18n+ "admin.config.mcp.primitives.results_count"+ visible=this.filteredPrimitives.length+ total=this.primitives.length+ }}</p>+ <div class="admin-mcp__primitive-group-actions">+ <DButton+ class="btn-default btn-small"+ @action={{fn this.selectVisiblePrimitives true}}+ @label="admin.config.mcp.primitives.enable_visible"+ />+ <DButton+ class="btn-default btn-small"+ @action={{fn this.selectVisiblePrimitives false}}+ @label="admin.config.mcp.primitives.disable_visible"+ />+ </div>+ </header>+ <div class="admin-mcp__primitive-list">+ {{#each this.filteredPrimitives as |primitive|}}+ <article+ class="admin-mcp__primitive"+ data-primitive-id={{primitive.id}}+ >+ <form.Field+ @name={{primitive.field_name}}+ @showTitle={{false}}+ @title={{primitive.title}}+ @type="checkbox"+ as |field|+ >+ <field.Control+ disabled={{or+ (not primitive.available)+ primitive.emergency_blocked+ }}+ {{on+ "change"+ (fn this.updatePrimitiveEnabled primitive)+ }}+ >{{primitive.description}}</field.Control>+ </form.Field>+ <dl class="admin-mcp__primitive-meta">+ <div><dt>{{i18n+ "admin.config.mcp.primitives.provider"+ }}</dt><dd>{{primitive.provider}}</dd></div>+ <div><dt>{{i18n+ "admin.config.mcp.primitives.kind"+ }}</dt><dd>{{mcpValue+ "primitive_kind"+ primitive.kind+ }}</dd></div>+ <div><dt>{{i18n+ "admin.config.mcp.primitives.risk"+ }}</dt><dd>{{mcpValue+ "primitive_risk"+ primitive.risk+ }}</dd></div>+ <div><dt>{{i18n+ "admin.config.mcp.primitives.scopes"+ }}</dt><dd>{{listValue+ primitive.required_scopes+ }}</dd></div>+ </dl>+ {{#unless primitive.available}}<p+ class="admin-mcp__unavailable"+ >{{primitive.unavailable_reason}}</p>{{/unless}}+ {{#if primitive.emergency_blocked}}<p+ class="admin-mcp__unavailable"+ >{{i18n+ "admin.config.mcp.primitives.emergency_blocked"+ }}</p>{{/if}}+ <div class="admin-mcp__primitive-actions">+ <DButton+ class="btn-transparent btn-small"+ @action={{fn+ this.togglePrimitiveEmergencyBlock+ primitive+ }}+ @icon={{if primitive.emergency_blocked "unlock" "ban"}}+ @isLoading={{eq this.updatingPrimitiveId primitive.id}}+ @title={{if+ primitive.emergency_blocked+ "admin.config.mcp.actions.unblock_primitive"+ "admin.config.mcp.actions.block_primitive"+ }}+ />+ </div>+ </article>+ {{else}}+ <p class="admin-mcp__empty">{{i18n+ "admin.config.mcp.primitives.no_results"+ }}</p>+ {{/each}}+ </div>+ </section>+ </div>+ <form.Actions+ class={{if this.hasPrimitiveChanges "is-floating"}}+ {{dOnResize this.positionPrimitiveActions}}+ >+ <form.Submit @label="admin.config.mcp.save_primitives" />+ </form.Actions>+ </Form>+ </div>+ {{else if (eq @section "clients")}}+ <DPageSubheader+ @descriptionLabel={{i18n "admin.config.mcp.clients.description"}}+ @learnMoreUrl="https://meta.discourse.org/t/connecting-your-apps-to-discourse-mcp-server/411637#p-2033870-connecting-apps-via-oauth-2"+ @titleLabel={{i18n "admin.config.mcp.clients.title"}}+ >+ <:actions as |actions|>+ <actions.Primary+ @label="admin.config.mcp.clients.add"+ @route="adminConfig.mcp.clients.new"+ />+ </:actions>+ </DPageSubheader>+ {{#if this.hasClients}}+ <Form+ class="admin-mcp__table-filter"+ @data={{this.clientFilterFormData}}+ @onSet={{this.updateFilter}}+ as |form|+ >+ <form.Field+ @name="clientFilter"+ @showOptional={{false}}+ @showTitle={{false}}+ @title={{i18n "admin.config.mcp.clients.search_placeholder"}}+ @type="input"+ as |field|+ >+ <field.Control+ placeholder={{i18n "admin.config.mcp.clients.search_placeholder"}}+ />+ </form.Field>+ </Form>+ <DLoadMore+ class="admin-mcp__load-more"+ @action={{this.loadMoreClients}}+ @enabled={{this.canLoadMoreClients}}+ @isLoading={{this.clientLoading}}+ @rootMargin="0px 0px 250px 0px"+ >+ <table class="d-table admin-mcp__table">+ <thead class="d-table__header"><tr class="d-table__row"><th+ class="d-table__cell --overview"+ >{{i18n "admin.config.mcp.clients.client"}}</th><th+ class="d-table__cell --detail"+ >{{i18n "admin.config.mcp.clients.trust"}}</th><th+ class="d-table__cell --detail"+ >{{i18n "admin.config.mcp.clients.last_seen"}}</th><th+ class="d-table__cell --detail"+ >{{i18n "admin.config.mcp.clients.authorizations"}}</th><th+ class="d-table__cell --controls"+ ><span class="sr-only">{{i18n+ "admin.config.mcp.clients.actions"+ }}</span></th></tr></thead>+ <tbody class="d-table__body">+ {{#each this.filteredClients as |client|}}+ <tr class="d-table__row">+ <td class="d-table__cell --overview"><LinkTo+ class="d-table__overview-link"+ @model={{client.id}}+ @route="adminConfig.mcp.clients.show"+ ><span+ class="d-table__overview-name"+ >{{client.name}}</span><small+ >{{client.client_id}}</small></LinkTo></td>+ <td class="d-table__cell --detail"><div+ class="d-table__mobile-label"+ >{{i18n "admin.config.mcp.clients.trust"}}</div><span+ class="admin-mcp__status"+ data-state={{client.trust_state}}+ >{{mcpValue "client_trust" client.trust_state}}</span></td>+ <td class="d-table__cell --detail"><div+ class="d-table__mobile-label"+ >{{i18n "admin.config.mcp.clients.last_seen"}}</div>{{#if+ client.last_seen_at+ }}{{dAgeWithTooltip+ client.last_seen_at+ format="medium"+ }}{{else}}{{i18n "admin.config.mcp.never"}}{{/if}}</td>+ <td class="d-table__cell --detail"><div+ class="d-table__mobile-label"+ >{{i18n+ "admin.config.mcp.clients.authorizations"+ }}</div>{{client.authorization_count}}</td>+ <td class="d-table__cell --controls"><div+ class="d-table__mobile-label"+ >{{i18n "admin.config.mcp.clients.actions"}}</div><div+ class="d-table__cell-actions"+ >{{#if (eq client.registration_type "cimd")}}<DButton+ class="btn-small btn-transparent --primary admin-mcp__refresh-client"+ @action={{fn this.refreshClient client}}+ @label="admin.config.mcp.actions.refresh_metadata"+ />{{/if}}<DButton+ class={{if+ client.blocked+ "btn-small btn-default admin-mcp__toggle-client-block"+ "btn-small btn-danger admin-mcp__toggle-client-block"+ }}+ @action={{fn this.toggleClientBlock client}}+ @label={{if+ client.blocked+ "admin.config.mcp.clients.unblock"+ "admin.config.mcp.clients.block"+ }}+ /></div></td>+ </tr>+ {{else}}+ <tr class="d-table__row"><td+ class="d-table__cell"+ colspan="5"+ >{{i18n "admin.config.mcp.clients.no_results"}}</td></tr>+ {{/each}}+ </tbody>+ </table>+ </DLoadMore>+ <DConditionalLoadingSpinner @condition={{this.clientLoading}} />+ {{else}}+ <AdminConfigAreaEmptyList+ @ctaLabel="admin.config.mcp.clients.add"+ @ctaRoute="adminConfig.mcp.clients.new"+ @emptyLabel="admin.config.mcp.clients.empty"+ />+ {{/if}}+ {{else if (eq @section "client-new")}}+ {{#if this.selectedClientPresetId}}+ <DButton+ class="btn-transparent back-button admin-mcp__change-client-preset"+ @action={{this.resetClientPreset}}+ @icon="chevron-left"+ @label="admin.config.mcp.clients.back_to_presets"+ />+ <AdminConfigAreaCard+ class="admin-mcp__client-form"+ @heading="admin.config.mcp.clients.new_title"+ >+ <:content>+ <p>{{i18n+ (concat+ "admin.config.mcp.clients.preset_help."+ this.selectedClientPresetId+ )+ }}</p>+ <Form+ @data={{this.newClientFormData}}+ @isLoading={{this.saving}}+ @onSubmit={{this.createClient}}+ as |form|+ >+ <form.Field+ @description={{i18n+ "admin.config.mcp.clients.name_description"+ }}+ @format="large"+ @name="name"+ @title={{i18n "admin.config.mcp.clients.name"}}+ @type="input"+ @validation="required"+ as |field|+ ><field.Control /></form.Field>+ <form.Field+ @description={{i18n+ "admin.config.mcp.clients.client_id_description"+ }}+ @format="large"+ @name="client_id"+ @title={{i18n "admin.config.mcp.clients.client_id"}}+ @type="input"+ @validation="required"+ as |field|+ ><field.Control /></form.Field>+ <form.Field+ @description={{i18n+ "admin.config.mcp.clients.redirect_uris_description"+ }}+ @format="large"+ @name="redirect_uris"+ @title={{i18n "admin.config.mcp.clients.redirect_uris"}}+ @type="textarea"+ @validation="required"+ as |field|+ ><field.Control @height={{100}} /></form.Field>+ <form.Submit @label="admin.config.mcp.clients.create" />+ </Form>+ </:content>+ </AdminConfigAreaCard>+ {{else}}+ <BackButton+ @label="admin.config.mcp.clients.back"+ @route="adminConfig.mcp.clients"+ />+ <section class="admin-mcp__client-presets">+ <h2>{{i18n "admin.config.mcp.clients.preset_title"}}</h2>+ <p>{{i18n "admin.config.mcp.clients.preset_description"}}</p>+ <AdminSectionLandingWrapper>+ {{#each this.clientPresetIds as |preset|}}+ <AdminSectionLandingItem+ data-client-preset-id={{preset}}+ @descriptionLabel={{concat+ "admin.config.mcp.clients.preset_descriptions."+ preset+ }}+ @titleLabel={{concat+ "admin.config.mcp.clients.presets."+ preset+ }}+ >+ <:buttons as |buttons|>+ <buttons.Default+ @action={{fn this.selectClientPreset preset}}+ @icon="gear"+ @label="admin.config.mcp.clients.use_preset"+ />+ </:buttons>+ </AdminSectionLandingItem>+ {{/each}}+ </AdminSectionLandingWrapper>+ </section>+ {{/if}}+ {{else if (eq @section "client-detail")}}+ <BackButton+ @label="admin.config.mcp.clients.back"+ @route="adminConfig.mcp.clients"+ />+ <DPageSubheader+ @descriptionLabel={{i18n "admin.config.mcp.clients.detail_description"}}+ @titleLabel={{this.client.name}}+ >+ <:actions as |actions|>+ <actions.Default+ @action={{fn this.toggleClientBlock this.client}}+ @label={{if+ this.client.blocked+ "admin.config.mcp.actions.unblock_client"+ "admin.config.mcp.actions.block_client"+ }}+ />+ {{#if (eq this.client.registration_type "cimd")}}+ <actions.Default+ @action={{fn this.refreshClient this.client}}+ @label="admin.config.mcp.actions.refresh_metadata"+ />+ {{/if}}+ </:actions>+ </DPageSubheader>+ <AdminConfigAreaCard @heading="admin.config.mcp.clients.detail_title">+ <:content>+ <dl class="admin-mcp__detail-list">+ <div><dt>{{i18n "admin.config.mcp.clients.client_id"}}</dt><dd><code+ >{{this.client.client_id}}</code></dd></div>+ <div><dt>{{i18n "admin.config.mcp.clients.trust"}}</dt><dd><span+ class="admin-mcp__status"+ data-state={{this.client.trust_state}}+ >{{mcpValue+ "client_trust"+ this.client.trust_state+ }}</span></dd></div>+ {{#if this.client.domain}}+ <div><dt>{{i18n "admin.config.mcp.clients.domain"}}</dt><dd+ >{{this.client.domain}}</dd></div>+ {{/if}}+ <div><dt>{{i18n+ "admin.config.mcp.clients.registration_type"+ }}</dt><dd>{{mcpValue+ "registration_type"+ this.client.registration_type+ }}</dd></div>+ <div><dt>{{i18n "admin.config.mcp.clients.redirect_uris"}}</dt><dd>+ <ul class="admin-mcp__uri-list">+ {{#each this.client.redirect_uris as |uri|}}+ <li><code>{{uri}}</code></li>+ {{/each}}+ </ul>+ </dd></div>+ <div><dt>{{i18n "admin.config.mcp.clients.first_seen"}}</dt><dd+ >{{dFormatDate this.client.first_seen_at}}</dd></div>+ <div><dt>{{i18n "admin.config.mcp.clients.last_seen"}}</dt><dd>{{#if+ this.client.last_seen_at+ }}{{dFormatDate this.client.last_seen_at}}{{else}}{{i18n+ "admin.config.mcp.never"+ }}{{/if}}</dd></div>+ </dl>+ </:content>+ </AdminConfigAreaCard>+ {{else if (eq @section "authorizations")}}+ <DPageSubheader+ @descriptionLabel={{i18n "admin.config.mcp.authorizations.description"}}+ @titleLabel={{i18n "admin.config.mcp.authorizations.title"}}+ />+ <Form+ class="admin-mcp__table-filter"+ @data={{this.authorizationFilterFormData}}+ @onSet={{this.updateFilter}}+ as |form|+ >+ <form.Field+ @name="authorizationFilter"+ @showOptional={{false}}+ @showTitle={{false}}+ @title={{i18n "admin.config.mcp.authorizations.search_placeholder"}}+ @type="input"+ as |field|+ >+ <field.Control+ placeholder={{i18n+ "admin.config.mcp.authorizations.search_placeholder"+ }}+ />+ </form.Field>+ </Form>+ <DLoadMore+ class="admin-mcp__load-more"+ @action={{this.loadMoreAuthorizations}}+ @enabled={{this.canLoadMoreAuthorizations}}+ @isLoading={{this.authorizationLoading}}+ @rootMargin="0px 0px 250px 0px"+ >+ <table class="d-table admin-mcp__table admin-mcp__authorizations-table">+ <colgroup>+ <col class="admin-mcp__authorizations-client-column" />+ <col class="admin-mcp__authorizations-user-column" />+ <col class="admin-mcp__authorizations-scopes-column" />+ <col class="admin-mcp__authorizations-last-used-column" />+ <col class="admin-mcp__authorizations-status-column" />+ <col class="admin-mcp__authorizations-actions-column" />+ </colgroup>+ <thead class="d-table__header"><tr class="d-table__row"><th+ class="d-table__cell --overview"+ >{{i18n "admin.config.mcp.authorizations.client"}}</th><th+ class="d-table__cell --detail"+ >{{i18n "admin.config.mcp.authorizations.user"}}</th><th+ class="d-table__cell --detail"+ >{{i18n "admin.config.mcp.authorizations.scopes"}}</th><th+ class="d-table__cell --detail"+ >{{i18n "admin.config.mcp.authorizations.last_used"}}</th><th+ class="d-table__cell --detail"+ >{{i18n "admin.config.mcp.authorizations.status"}}</th><th+ class="d-table__cell --controls"+ ><span class="sr-only">{{i18n+ "admin.config.mcp.authorizations.actions"+ }}</span></th></tr></thead>+ <tbody class="d-table__body">+ {{#each this.filteredAuthorizations as |authorization|}}+ <tr class="d-table__row">+ <td class="d-table__cell --overview"><span+ class="d-table__overview-name"+ >{{authorization.client_name}}</span></td>+ <td class="d-table__cell --detail"><div+ class="d-table__mobile-label"+ >{{i18n+ "admin.config.mcp.authorizations.user"+ }}</div>{{authorization.username}}</td>+ <td class="d-table__cell --detail"><div+ class="d-table__mobile-label"+ >{{i18n "admin.config.mcp.authorizations.scopes"}}</div><code+ >{{listValue authorization.scopes}}</code></td>+ <td class="d-table__cell --detail"><div+ class="d-table__mobile-label"+ >{{i18n+ "admin.config.mcp.authorizations.last_used"+ }}</div>{{#if authorization.last_used_at}}{{dAgeWithTooltip+ authorization.last_used_at+ format="medium"+ }}{{else}}{{i18n "admin.config.mcp.never"}}{{/if}}</td>+ <td class="d-table__cell --detail"><div+ class="d-table__mobile-label"+ >{{i18n "admin.config.mcp.authorizations.status"}}</div><span+ class="admin-mcp__status"+ data-state={{authorization.status}}+ >{{mcpValue+ "authorization_status"+ authorization.status+ }}</span></td>+ <td class="d-table__cell --controls">{{#if+ (notEq authorization.status "revoked")+ }}<DButton+ class="btn-small btn-danger"+ @action={{fn this.revokeAuthorization authorization}}+ @label="admin.config.mcp.actions.revoke"+ />{{/if}}</td>+ </tr>+ {{else}}+ <tr class="d-table__row"><td+ class="d-table__cell"+ colspan="6"+ >{{i18n "admin.config.mcp.authorizations.empty"}}</td></tr>+ {{/each}}+ </tbody>+ </table>+ </DLoadMore>+ <DConditionalLoadingSpinner @condition={{this.authorizationLoading}} />+ {{else if (eq @section "activity")}}+ <DPageSubheader+ @descriptionLabel={{i18n "admin.config.mcp.activity.description"}}+ @titleLabel={{i18n "admin.config.mcp.activity.title"}}+ />+ <div class="admin-mcp__metric-grid admin-mcp__activity-metrics">+ <div><dt>{{i18n "admin.config.mcp.activity.tool_calls"}}</dt><dd+ >{{this.metrics.tool_calls}}</dd></div><div><dt>{{i18n+ "admin.config.mcp.activity.errors"+ }}</dt><dd>{{this.metrics.errors}}</dd></div><div><dt>{{i18n+ "admin.config.mcp.activity.rate_limits"+ }}</dt><dd>{{this.metrics.rate_limits}}</dd></div><div><dt>{{i18n+ "admin.config.mcp.activity.p95_latency"+ }}</dt><dd>{{i18n+ "admin.config.mcp.activity.duration_value"+ milliseconds=this.metrics.p95_latency_ms+ }}</dd></div>+ </div>+ <Form+ class="admin-mcp__activity-filters"+ @data={{this.activityFilterFormData}}+ @onSet={{this.updateFilter}}+ as |form|+ >+ <form.Field+ class="admin-mcp__filter-search"+ @format="full"+ @name="activityFilter"+ @showOptional={{false}}+ @showTitle={{false}}+ @title={{i18n "admin.config.mcp.activity.search_placeholder"}}+ @type="input"+ as |field|+ >+ <field.Control+ placeholder={{i18n "admin.config.mcp.activity.search_placeholder"}}+ />+ </form.Field>+ <form.Field+ @name="activityOutcome"+ @showOptional={{false}}+ @showTitle={{false}}+ @title={{i18n "admin.config.mcp.activity.outcome"}}+ @type="select"+ as |field|+ >+ <field.Control+ aria-label={{i18n "admin.config.mcp.activity.outcome"}}+ @includeNone={{false}}+ as |select|+ >+ {{#each this.activityOutcomes as |outcome|}}+ <select.Option @value={{outcome}}>+ {{mcpValue "activity_outcome" outcome}}+ </select.Option>+ {{/each}}+ </field.Control>+ </form.Field>+ </Form>+ <DLoadMore+ class="admin-mcp__load-more"+ @action={{this.loadMoreActivity}}+ @enabled={{this.canLoadMoreActivity}}+ @isLoading={{this.activityLoading}}+ @rootMargin="0px 0px 250px 0px"+ >+ <table class="d-table admin-mcp__table admin-mcp__activity-table">+ <thead class="d-table__header"><tr class="d-table__row"><th+ class="d-table__cell --detail"+ >{{i18n "admin.config.mcp.activity.time"}}</th><th+ class="d-table__cell --overview"+ >{{i18n "admin.config.mcp.activity.method"}}</th><th+ class="d-table__cell --detail"+ >{{i18n "admin.config.mcp.activity.user"}}</th><th+ class="d-table__cell --detail"+ >{{i18n "admin.config.mcp.activity.outcome"}}</th><th+ class="d-table__cell --detail"+ >{{i18n "admin.config.mcp.activity.duration"}}</th><th+ class="d-table__cell --detail"+ >{{i18n "admin.config.mcp.activity.request_id"}}</th></tr></thead>+ <tbody class="d-table__body">{{#each this.activity as |event|}}<tr+ class="d-table__row"+ ><td class="d-table__cell --detail"><div+ class="d-table__mobile-label"+ >{{i18n "admin.config.mcp.activity.time"}}</div>{{dFormatDate+ event.created_at+ }}</td><td class="d-table__cell --overview"><span+ class="d-table__overview-name"+ >{{event.tool}}</span><small>{{event.method}}</small></td><td+ class="d-table__cell --detail"+ ><div class="d-table__mobile-label">{{i18n+ "admin.config.mcp.activity.user"+ }}</div>{{event.username}}</td><td+ class="d-table__cell --detail"+ ><div class="d-table__mobile-label">{{i18n+ "admin.config.mcp.activity.outcome"+ }}</div><span+ class="admin-mcp__status"+ data-state={{event.outcome}}+ >{{mcpValue "activity_outcome" event.outcome}}</span></td><td+ class="d-table__cell --detail"+ ><div class="d-table__mobile-label">{{i18n+ "admin.config.mcp.activity.duration"+ }}</div>{{event.duration_ms}}+ ms</td><td class="d-table__cell --detail"><div+ class="d-table__mobile-label"+ >{{i18n "admin.config.mcp.activity.request_id"}}</div><code+ >{{event.request_id}}</code></td></tr>{{else}}<tr+ class="d-table__row"+ ><td class="d-table__cell" colspan="6">{{i18n+ "admin.config.mcp.activity.empty"+ }}</td></tr>{{/each}}</tbody>+ </table>+ </DLoadMore>+ <DConditionalLoadingSpinner @condition={{this.activityLoading}} />+ {{/if}}+ </template>+}diff --git a/frontend/discourse/admin/controllers/admin-config/mcp/settings.js b/frontend/discourse/admin/controllers/admin-config/mcp/settings.jsnew file mode 100644index 00000000000..54cb32e2a8b--- /dev/null+++ b/frontend/discourse/admin/controllers/admin-config/mcp/settings.js@@ -0,0 +1,3 @@+import AdminAreaSettingsBaseController from "discourse/admin/controllers/admin-area-settings-base";++export default class AdminConfigMcpSettingsController extends AdminAreaSettingsBaseController {}diff --git a/frontend/discourse/admin/routes/admin-config/mcp.js b/frontend/discourse/admin/routes/admin-config/mcp.jsnew file mode 100644index 00000000000..5f5aa259a4d--- /dev/null+++ b/frontend/discourse/admin/routes/admin-config/mcp.js@@ -0,0 +1,8 @@+import { i18n } from "discourse-i18n";+import AdminConfigWithSettingsRoute from "../admin-config-with-settings-route";++export default class AdminConfigMcpRoute extends AdminConfigWithSettingsRoute {+ titleToken() {+ return i18n("admin.config.mcp.title");+ }+}diff --git a/frontend/discourse/admin/routes/admin-config/mcp/access.js b/frontend/discourse/admin/routes/admin-config/mcp/access.jsnew file mode 100644index 00000000000..fbec6d3c1f2--- /dev/null+++ b/frontend/discourse/admin/routes/admin-config/mcp/access.js@@ -0,0 +1,8 @@+import { ajax } from "discourse/lib/ajax";+import DiscourseRoute from "discourse/routes/discourse";++export default class AdminConfigMcpAccessRoute extends DiscourseRoute {+ model() {+ return ajax("/admin/mcp/access.json");+ }+}diff --git a/frontend/discourse/admin/routes/admin-config/mcp/access/edit.js b/frontend/discourse/admin/routes/admin-config/mcp/access/edit.jsnew file mode 100644index 00000000000..67d006199fc--- /dev/null+++ b/frontend/discourse/admin/routes/admin-config/mcp/access/edit.js@@ -0,0 +1,11 @@+import DiscourseRoute from "discourse/routes/discourse";++export default class AdminConfigMcpAccessEditRoute extends DiscourseRoute {+ model({ group_id }) {+ const model = this.modelFor("adminConfig.mcp.access");+ model.access_rule = model.access_rules.find(+ (rule) => rule.group_id.toString() === group_id+ );+ return model;+ }+}diff --git a/frontend/discourse/admin/routes/admin-config/mcp/access/new.js b/frontend/discourse/admin/routes/admin-config/mcp/access/new.jsnew file mode 100644index 00000000000..2387f502b18--- /dev/null+++ b/frontend/discourse/admin/routes/admin-config/mcp/access/new.js@@ -0,0 +1,7 @@+import DiscourseRoute from "discourse/routes/discourse";++export default class AdminConfigMcpAccessNewRoute extends DiscourseRoute {+ model() {+ return this.modelFor("adminConfig.mcp.access");+ }+}diff --git a/frontend/discourse/admin/routes/admin-config/mcp/activity.js b/frontend/discourse/admin/routes/admin-config/mcp/activity.jsnew file mode 100644index 00000000000..15a5680131c--- /dev/null+++ b/frontend/discourse/admin/routes/admin-config/mcp/activity.js@@ -0,0 +1,8 @@+import { ajax } from "discourse/lib/ajax";+import DiscourseRoute from "discourse/routes/discourse";++export default class AdminConfigMcpActivityRoute extends DiscourseRoute {+ model() {+ return ajax("/admin/mcp/activity.json");+ }+}diff --git a/frontend/discourse/admin/routes/admin-config/mcp/authorizations.js b/frontend/discourse/admin/routes/admin-config/mcp/authorizations.jsnew file mode 100644index 00000000000..36749055e26--- /dev/null+++ b/frontend/discourse/admin/routes/admin-config/mcp/authorizations.js@@ -0,0 +1,8 @@+import { ajax } from "discourse/lib/ajax";+import DiscourseRoute from "discourse/routes/discourse";++export default class AdminConfigMcpAuthorizationsRoute extends DiscourseRoute {+ model() {+ return ajax("/admin/mcp/authorizations.json");+ }+}diff --git a/frontend/discourse/admin/routes/admin-config/mcp/capabilities.js b/frontend/discourse/admin/routes/admin-config/mcp/capabilities.jsnew file mode 100644index 00000000000..bf73efb97f7--- /dev/null+++ b/frontend/discourse/admin/routes/admin-config/mcp/capabilities.js@@ -0,0 +1,8 @@+import { ajax } from "discourse/lib/ajax";+import DiscourseRoute from "discourse/routes/discourse";++export default class AdminConfigMcpCapabilitiesRoute extends DiscourseRoute {+ model() {+ return ajax("/admin/mcp/capabilities.json");+ }+}diff --git a/frontend/discourse/admin/routes/admin-config/mcp/clients.js b/frontend/discourse/admin/routes/admin-config/mcp/clients.jsnew file mode 100644index 00000000000..2d9619d5625--- /dev/null+++ b/frontend/discourse/admin/routes/admin-config/mcp/clients.js@@ -0,0 +1,8 @@+import { ajax } from "discourse/lib/ajax";+import DiscourseRoute from "discourse/routes/discourse";++export default class AdminConfigMcpClientsRoute extends DiscourseRoute {+ model() {+ return ajax("/admin/mcp/clients.json");+ }+}diff --git a/frontend/discourse/admin/routes/admin-config/mcp/clients/show.js b/frontend/discourse/admin/routes/admin-config/mcp/clients/show.jsnew file mode 100644index 00000000000..f9ae91e9a28--- /dev/null+++ b/frontend/discourse/admin/routes/admin-config/mcp/clients/show.js@@ -0,0 +1,8 @@+import { ajax } from "discourse/lib/ajax";+import DiscourseRoute from "discourse/routes/discourse";++export default class AdminConfigMcpClientRoute extends DiscourseRoute {+ model({ id }) {+ return ajax(`/admin/mcp/clients/${id}.json`);+ }+}diff --git a/frontend/discourse/admin/routes/admin-config/mcp/index.js b/frontend/discourse/admin/routes/admin-config/mcp/index.jsnew file mode 100644index 00000000000..9b1eba7e2ac--- /dev/null+++ b/frontend/discourse/admin/routes/admin-config/mcp/index.js@@ -0,0 +1,8 @@+import { ajax } from "discourse/lib/ajax";+import DiscourseRoute from "discourse/routes/discourse";++export default class AdminConfigMcpIndexRoute extends DiscourseRoute {+ model() {+ return ajax("/admin/mcp/overview.json");+ }+}diff --git a/frontend/discourse/admin/routes/admin-route-map.js b/frontend/discourse/admin/routes/admin-route-map.jsindex a8f20702c59..49aa85af025 100644--- a/frontend/discourse/admin/routes/admin-route-map.js+++ b/frontend/discourse/admin/routes/admin-route-map.js@@ -395,6 +395,23 @@ export default function () {this.route("developer", function () {this.route("settings", { path: "/" });});+ this.route("mcp", function () {+ this.route("index", { path: "/" });+ this.route("access", function () {+ this.route("index", { path: "/" });+ this.route("new");+ this.route("edit", { path: "/:group_id/edit" });+ });+ this.route("capabilities");+ this.route("clients", function () {+ this.route("index", { path: "/" });+ this.route("new");+ this.route("show", { path: "/:id" });+ });+ this.route("authorizations");+ this.route("activity");+ this.route("settings");+ });this.route("logo");this.route("fonts");this.route("gifs", function () {diff --git a/frontend/discourse/admin/templates/admin-config/mcp.gjs b/frontend/discourse/admin/templates/admin-config/mcp.gjsnew file mode 100644index 00000000000..2cb69937480--- /dev/null+++ b/frontend/discourse/admin/templates/admin-config/mcp.gjs@@ -0,0 +1,60 @@+import DBreadcrumbsItem from "discourse/ui-kit/d-breadcrumbs-item";+import DNavItem from "discourse/ui-kit/d-nav-item";+import DPageHeader from "discourse/ui-kit/d-page-header";+import { i18n } from "discourse-i18n";++export default <template>+ <DPageHeader+ @descriptionLabel={{i18n "admin.config.mcp.header_description"}}+ @titleLabel={{i18n "admin.config.mcp.title"}}+ >+ <:breadcrumbs>+ <DBreadcrumbsItem @label={{i18n "admin_title"}} @path="/admin" />+ <DBreadcrumbsItem+ @label={{i18n "admin.config.mcp.title"}}+ @path="/admin/config/mcp"+ />+ </:breadcrumbs>+ <:tabs>+ <DNavItem+ class="admin-mcp-tabs__overview"+ @label="admin.config.mcp.tabs.overview"+ @route="adminConfig.mcp.index"+ />+ <DNavItem+ class="admin-mcp-tabs__capabilities"+ @label="admin.config.mcp.tabs.capabilities"+ @route="adminConfig.mcp.capabilities"+ />+ <DNavItem+ class="admin-mcp-tabs__access"+ @label="admin.config.mcp.tabs.access"+ @route="adminConfig.mcp.access"+ />+ <DNavItem+ class="admin-mcp-tabs__clients"+ @label="admin.config.mcp.tabs.clients"+ @route="adminConfig.mcp.clients"+ />+ <DNavItem+ class="admin-mcp-tabs__authorizations"+ @label="admin.config.mcp.tabs.authorizations"+ @route="adminConfig.mcp.authorizations"+ />+ <DNavItem+ class="admin-mcp-tabs__activity"+ @label="admin.config.mcp.tabs.activity"+ @route="adminConfig.mcp.activity"+ />+ <DNavItem+ class="admin-mcp-tabs__settings"+ @label="settings"+ @route="adminConfig.mcp.settings"+ />+ </:tabs>+ </DPageHeader>++ <div class="admin-container admin-config-page__main-area admin-mcp">+ {{outlet}}+ </div>+</template>diff --git a/frontend/discourse/admin/templates/admin-config/mcp/access.gjs b/frontend/discourse/admin/templates/admin-config/mcp/access.gjsnew file mode 100644index 00000000000..a087a33dfcb--- /dev/null+++ b/frontend/discourse/admin/templates/admin-config/mcp/access.gjs@@ -0,0 +1 @@+export default <template>{{outlet}}</template>diff --git a/frontend/discourse/admin/templates/admin-config/mcp/access/edit.gjs b/frontend/discourse/admin/templates/admin-config/mcp/access/edit.gjsnew file mode 100644index 00000000000..b482ed1a5e3--- /dev/null+++ b/frontend/discourse/admin/templates/admin-config/mcp/access/edit.gjs@@ -0,0 +1,5 @@+import AdminMcp from "discourse/admin/components/admin-mcp";++export default <template>+ <AdminMcp @model={{@model}} @section="access-edit" />+</template>diff --git a/frontend/discourse/admin/templates/admin-config/mcp/access/index.gjs b/frontend/discourse/admin/templates/admin-config/mcp/access/index.gjsnew file mode 100644index 00000000000..e4eec28c7c4--- /dev/null+++ b/frontend/discourse/admin/templates/admin-config/mcp/access/index.gjs@@ -0,0 +1,5 @@+import AdminMcp from "discourse/admin/components/admin-mcp";++export default <template>+ <AdminMcp @model={{@model}} @section="access" />+</template>diff --git a/frontend/discourse/admin/templates/admin-config/mcp/access/new.gjs b/frontend/discourse/admin/templates/admin-config/mcp/access/new.gjsnew file mode 100644index 00000000000..f4ffdae33db--- /dev/null+++ b/frontend/discourse/admin/templates/admin-config/mcp/access/new.gjs@@ -0,0 +1,5 @@+import AdminMcp from "discourse/admin/components/admin-mcp";++export default <template>+ <AdminMcp @model={{@model}} @section="access-new" />+</template>diff --git a/frontend/discourse/admin/templates/admin-config/mcp/activity.gjs b/frontend/discourse/admin/templates/admin-config/mcp/activity.gjsnew file mode 100644index 00000000000..22bd7a7b463--- /dev/null+++ b/frontend/discourse/admin/templates/admin-config/mcp/activity.gjs@@ -0,0 +1,5 @@+import AdminMcp from "discourse/admin/components/admin-mcp";++export default <template>+ <AdminMcp @model={{@model}} @section="activity" />+</template>diff --git a/frontend/discourse/admin/templates/admin-config/mcp/authorizations.gjs b/frontend/discourse/admin/templates/admin-config/mcp/authorizations.gjsnew file mode 100644index 00000000000..3822530de2a--- /dev/null+++ b/frontend/discourse/admin/templates/admin-config/mcp/authorizations.gjs@@ -0,0 +1,5 @@+import AdminMcp from "discourse/admin/components/admin-mcp";++export default <template>+ <AdminMcp @model={{@model}} @section="authorizations" />+</template>diff --git a/frontend/discourse/admin/templates/admin-config/mcp/capabilities.gjs b/frontend/discourse/admin/templates/admin-config/mcp/capabilities.gjsnew file mode 100644index 00000000000..8b00079baed--- /dev/null+++ b/frontend/discourse/admin/templates/admin-config/mcp/capabilities.gjs@@ -0,0 +1,5 @@+import AdminMcp from "discourse/admin/components/admin-mcp";++export default <template>+ <AdminMcp @model={{@model}} @section="primitives" />+</template>diff --git a/frontend/discourse/admin/templates/admin-config/mcp/clients.gjs b/frontend/discourse/admin/templates/admin-config/mcp/clients.gjsnew file mode 100644index 00000000000..a087a33dfcb--- /dev/null+++ b/frontend/discourse/admin/templates/admin-config/mcp/clients.gjs@@ -0,0 +1 @@+export default <template>{{outlet}}</template>diff --git a/frontend/discourse/admin/templates/admin-config/mcp/clients/index.gjs b/frontend/discourse/admin/templates/admin-config/mcp/clients/index.gjsnew file mode 100644index 00000000000..86495b40281--- /dev/null+++ b/frontend/discourse/admin/templates/admin-config/mcp/clients/index.gjs@@ -0,0 +1,5 @@+import AdminMcp from "discourse/admin/components/admin-mcp";++export default <template>+ <AdminMcp @model={{@model}} @section="clients" />+</template>diff --git a/frontend/discourse/admin/templates/admin-config/mcp/clients/new.gjs b/frontend/discourse/admin/templates/admin-config/mcp/clients/new.gjsnew file mode 100644index 00000000000..a3f113bfe5e--- /dev/null+++ b/frontend/discourse/admin/templates/admin-config/mcp/clients/new.gjs@@ -0,0 +1,3 @@+import AdminMcp from "discourse/admin/components/admin-mcp";++export default <template><AdminMcp @section="client-new" /></template>diff --git a/frontend/discourse/admin/templates/admin-config/mcp/clients/show.gjs b/frontend/discourse/admin/templates/admin-config/mcp/clients/show.gjsnew file mode 100644index 00000000000..74c3a9a9c0f--- /dev/null+++ b/frontend/discourse/admin/templates/admin-config/mcp/clients/show.gjs@@ -0,0 +1,5 @@+import AdminMcp from "discourse/admin/components/admin-mcp";++export default <template>+ <AdminMcp @model={{@model}} @section="client-detail" />+</template>diff --git a/frontend/discourse/admin/templates/admin-config/mcp/index.gjs b/frontend/discourse/admin/templates/admin-config/mcp/index.gjsnew file mode 100644index 00000000000..155caa2b8f4--- /dev/null+++ b/frontend/discourse/admin/templates/admin-config/mcp/index.gjs@@ -0,0 +1,5 @@+import AdminMcp from "discourse/admin/components/admin-mcp";++export default <template>+ <AdminMcp @model={{@model}} @section="overview" />+</template>diff --git a/frontend/discourse/admin/templates/admin-config/mcp/settings.gjs b/frontend/discourse/admin/templates/admin-config/mcp/settings.gjsnew file mode 100644index 00000000000..638ac66d1f6--- /dev/null+++ b/frontend/discourse/admin/templates/admin-config/mcp/settings.gjs@@ -0,0 +1,11 @@+import AdminAreaSettings from "discourse/admin/components/admin-area-settings";++export default <template>+ <AdminAreaSettings+ @adminSettingsFilterChangedCallback={{@controller.adminSettingsFilterChangedCallback}}+ @area="mcp"+ @filter={{@controller.filter}}+ @path="/admin/config/mcp"+ @showBreadcrumb={{false}}+ />+</template>diff --git a/frontend/discourse/app/components/user-preferences/user-mcp-authorizations.gjs b/frontend/discourse/app/components/user-preferences/user-mcp-authorizations.gjsnew file mode 100644index 00000000000..886f0d1bfb9--- /dev/null+++ b/frontend/discourse/app/components/user-preferences/user-mcp-authorizations.gjs@@ -0,0 +1,256 @@+import Component from "@glimmer/component";+import { tracked } from "@glimmer/tracking";+import { fn } from "@ember/helper";+import { action } from "@ember/object";+import { service } from "@ember/service";+import { ajax } from "discourse/lib/ajax";+import { popupAjaxError } from "discourse/lib/ajax-error";+import DButton from "discourse/ui-kit/d-button";+import DConditionalLoadingSpinner from "discourse/ui-kit/d-conditional-loading-spinner";+import dAgeWithTooltip from "discourse/ui-kit/helpers/d-age-with-tooltip";+import { i18n } from "discourse-i18n";++function authorizationStatus(status) {+ return i18n(`user.mcp_authorizations.statuses.${status}`);+}++class UserMcpAuthorizationRow extends Component {+ @tracked showPermissions = false;++ get hasPermissions() {+ return this.args.authorization.scopes?.length > 0;+ }++ get isReauthorizationRequired() {+ return this.args.authorization.status === "consent_required";+ }++ get canRevoke() {+ return this.args.authorization.status !== "revoked";+ }++ @action+ togglePermissions() {+ this.showPermissions = !this.showPermissions;+ }++ <template>+ <tr class="d-table__row user-mcp-authorization" ...attributes>+ <td class="d-table__cell --overview user-mcp-authorization__application">+ <div class="d-table__overview-name">{{@authorization.client_name}}</div>+ </td>+ <td class="d-table__cell --detail user-mcp-authorization__details-cell">+ <div class="d-table__mobile-label">{{i18n+ "user.mcp_authorizations.details"+ }}</div>+ <div class="user-mcp-authorization__details">+ <div class="user-mcp-authorization__authorized">+ <span>{{i18n "user.mcp_authorizations.authorized"}}:</span>+ {{dAgeWithTooltip @authorization.consented_at format="medium"}}+ </div>+ <div class="user-mcp-authorization__last-used">+ <span>{{i18n "user.mcp_authorizations.last_used"}}:</span>+ {{#if @authorization.last_used_at}}+ {{dAgeWithTooltip @authorization.last_used_at format="medium"}}+ {{else}}+ {{i18n "user.mcp_authorizations.never"}}+ {{/if}}+ </div>+ <span class="user-mcp-authorization__token-count">{{i18n+ "user.mcp_authorizations.active_tokens"+ [email protected]_count+ }}</span>++ {{#if this.hasPermissions}}+ <div class="user-mcp-authorization__permissions">+ <DButton+ aria-expanded={{if this.showPermissions "true" "false"}}+ class="user-mcp-authorization__permissions-toggle"+ @action={{this.togglePermissions}}+ @display="link"+ @icon={{if this.showPermissions "caret-up" "caret-down"}}+ @translatedLabel={{i18n+ "user.mcp_authorizations.permissions"+ }}+ />+ </div>++ {{#if this.showPermissions}}+ <ul class="user-mcp-authorization__permissions-list">+ {{#each @authorization.scopes as |scope|}}+ <li><code>{{scope}}</code></li>+ {{/each}}+ </ul>+ {{/if}}+ {{/if}}+ </div>+ </td>+ <td class="d-table__cell --detail user-mcp-authorization__status-cell">+ <div class="d-table__mobile-label">{{i18n+ "user.mcp_authorizations.status"+ }}</div>+ <div class="user-mcp-authorization__status-details">+ <span+ class="user-mcp-authorization__status"+ data-state={{@authorization.status}}+ >{{authorizationStatus @authorization.status}}</span>+ {{#if this.canRevoke}}+ <DButton+ class="btn-default btn-small"+ @action={{@onRevoke}}+ @label="user.mcp_authorizations.revoke"+ />+ {{/if}}+ {{#if this.isReauthorizationRequired}}+ <DButton+ class="btn-default btn-small"+ @action={{@onReauthorize}}+ @label="user.mcp_authorizations.reauthorize"+ />+ {{/if}}+ </div>+ </td>+ </tr>+ </template>+}++export default class UserMcpAuthorizations extends Component {+ @service a11y;+ @service currentUser;+ @service dialog;+ @service toasts;++ @tracked authorizations = [];+ @tracked loading = true;++ constructor() {+ super(...arguments);+ if (!this.shouldRender) {+ this.loading = false;+ return;+ }+ this.#loadAuthorizations();+ }++ get shouldRender() {+ return (+ this.args.model?.id === this.currentUser?.id &&+ this.args.model?.show_mcp_authorizations+ );+ }++ get username() {+ return this.args.model?.username;+ }++ get endpoint() {+ return `/u/${encodeURIComponent(this.username)}/preferences/mcp-authorizations`;+ }++ get hasAuthorizations() {+ return this.authorizations.length > 0;+ }++ @action+ revoke(authorization) {+ this.dialog.confirm({+ message: i18n("user.mcp_authorizations.revoke_confirm", {+ name: authorization.client_name,+ }),+ didConfirm: async () => {+ try {+ await ajax(`${this.endpoint}/${authorization.id}.json`, {+ type: "DELETE",+ });+ this.authorizations = this.authorizations.map((item) =>+ item.id === authorization.id+ ? { ...item, status: "revoked", token_count: 0 }+ : item+ );+ this.a11y.announce(i18n("user.mcp_authorizations.revoked"));+ this.toasts.success({+ duration: "short",+ data: { message: i18n("user.mcp_authorizations.revoked") },+ });+ } catch (error) {+ popupAjaxError(error);+ }+ },+ });+ }++ @action+ reauthorize() {+ this.dialog.alert({+ message: i18n("user.mcp_authorizations.reauthorize_in_client"),+ });+ }++ async #loadAuthorizations() {+ if (!this.username) {+ this.loading = false;+ return;+ }++ try {+ const result = await ajax(`${this.endpoint}.json`);+ this.authorizations = result.authorizations || result;+ } catch (error) {+ popupAjaxError(error);+ } finally {+ this.loading = false;+ }+ }++ <template>+ {{#if this.shouldRender}}+ <div class="control-group user-mcp-authorizations">+ <label class="control-label">{{i18n+ "user.mcp_authorizations.title"+ }}</label>+ <p class="instructions">{{i18n+ "user.mcp_authorizations.description"+ }}</p>++ <DConditionalLoadingSpinner @condition={{this.loading}}>+ {{#if this.hasAuthorizations}}+ <table class="d-table user-mcp-authorizations__table">+ <colgroup>+ <col class="user-mcp-authorizations__application-column" />+ <col />+ <col class="user-mcp-authorizations__status-column" />+ </colgroup>+ <thead class="d-table__header">+ <tr class="d-table__row">+ <th class="d-table__header-cell">{{i18n+ "user.mcp_authorizations.application"+ }}</th>+ <th class="d-table__header-cell">{{i18n+ "user.mcp_authorizations.details"+ }}</th>+ <th class="d-table__header-cell">{{i18n+ "user.mcp_authorizations.status"+ }}</th>+ </tr>+ </thead>+ <tbody class="d-table__body">+ {{#each this.authorizations as |authorization|}}+ <UserMcpAuthorizationRow+ @authorization={{authorization}}+ @onReauthorize={{this.reauthorize}}+ @onRevoke={{fn this.revoke authorization}}+ />+ {{/each}}+ </tbody>+ </table>+ {{else}}+ <p class="user-mcp-authorizations__empty">{{i18n+ "user.mcp_authorizations.empty"+ }}</p>+ {{/if}}+ </DConditionalLoadingSpinner>+ </div>+ {{/if}}+ </template>+}diff --git a/frontend/discourse/app/lib/sidebar/admin-nav-map.js b/frontend/discourse/app/lib/sidebar/admin-nav-map.jsindex 4e579e8bd18..67296f4a2da 100644--- a/frontend/discourse/app/lib/sidebar/admin-nav-map.js+++ b/frontend/discourse/app/lib/sidebar/admin-nav-map.js@@ -554,6 +554,52 @@ export const ADMIN_NAV_MAP = [icon: "keyboard",settings_category: "developer",},+ {+ name: "admin_mcp",+ route: "adminConfig.mcp.index",+ label: "admin.config.mcp.title",+ description: "admin.config.mcp.header_description",+ icon: "plug",+ multi_tabbed: true,+ links: [+ {+ name: "admin_mcp_capabilities",+ route: "adminConfig.mcp.capabilities",+ label: "admin.config.mcp.tabs.capabilities",+ description: "admin.config.mcp.capabilities.description",+ },+ {+ name: "admin_mcp_access",+ route: "adminConfig.mcp.access",+ label: "admin.config.mcp.tabs.access",+ description: "admin.config.mcp.access.description",+ },+ {+ name: "admin_mcp_clients",+ route: "adminConfig.mcp.clients",+ label: "admin.config.mcp.tabs.clients",+ description: "admin.config.mcp.clients.description",+ },+ {+ name: "admin_mcp_authorizations",+ route: "adminConfig.mcp.authorizations",+ label: "admin.config.mcp.tabs.authorizations",+ description: "admin.config.mcp.authorizations.description",+ },+ {+ name: "admin_mcp_activity",+ route: "adminConfig.mcp.activity",+ label: "admin.config.mcp.tabs.activity",+ description: "admin.config.mcp.activity.description",+ },+ {+ name: "admin_mcp_settings",+ route: "adminConfig.mcp.settings",+ label: "settings",+ description: "admin.config.mcp.settings.description",+ },+ ],+ },{name: "admin_embedding",route: "adminEmbedding",diff --git a/frontend/discourse/app/templates/preferences/security.gjs b/frontend/discourse/app/templates/preferences/security.gjsindex a47b45aabb5..f89a18f09cd 100644--- a/frontend/discourse/app/templates/preferences/security.gjs+++ b/frontend/discourse/app/templates/preferences/security.gjs@@ -4,6 +4,7 @@ import { trustHTML } from "@ember/template";import AuthTokenDropdown from "discourse/components/auth-token-dropdown";import PluginOutlet from "discourse/components/plugin-outlet";import UserApiKeys from "discourse/components/user-preferences/user-api-keys";+import UserMcpAuthorizations from "discourse/components/user-preferences/user-mcp-authorizations";import UserPasskeys from "discourse/components/user-preferences/user-passkeys";import lazyHash from "discourse/helpers/lazy-hash";import { not } from "discourse/truth-helpers";@@ -170,6 +171,7 @@ export default <template>{{/if}}<UserApiKeys @model={{@model}} />+ <UserMcpAuthorizations @model={{@model}} /><span><PluginOutletdiff --git a/frontend/discourse/tests/acceptance/admin-mcp-test.js b/frontend/discourse/tests/acceptance/admin-mcp-test.jsnew file mode 100644index 00000000000..4b0d2638882--- /dev/null+++ b/frontend/discourse/tests/acceptance/admin-mcp-test.js@@ -0,0 +1,1153 @@+import {+ click,+ currentURL,+ fillIn,+ findAll,+ select,+ visit,+ waitUntil,+} from "@ember/test-helpers";+import { test } from "qunit";+import { acceptance } from "discourse/tests/helpers/qunit-helpers";+import stubIntersectionObserver from "discourse/tests/helpers/stub-intersection-observer";+import {+ disableLoadMoreObserver,+ enableLoadMoreObserver,+} from "discourse/ui-kit/d-load-more";+import { i18n } from "discourse-i18n";++const refreshedClientName = "Updated client";++acceptance("Admin - MCP", function (needs) {+ let savedAccessRule;+ let emergencyBlockRequests;+ let refreshClientRequests;+ let setupComplete;+ let activityRequests;+ let authorizationRequests;+ let clientRequests;+ let savedPrimitiveIds;++ needs.user({ admin: true });+ needs.hooks.beforeEach(() => {+ savedAccessRule = null;+ emergencyBlockRequests = [];+ refreshClientRequests = [];+ setupComplete = true;+ activityRequests = [];+ authorizationRequests = [];+ clientRequests = [];+ savedPrimitiveIds = null;+ });++ needs.pretender((server, helper) => {+ server.get("/admin/config/site_settings.json", () =>+ helper.response({ site_settings: [] })+ );+ server.get("/admin/mcp/overview.json", () =>+ helper.response({+ enabled: false,+ endpoint: "https://forum.example.com/mcp",+ protocol_version: "2026-07-28",+ server_version: "test",+ status: "disabled",+ catalog: { tools: 0, resources: 0, prompts: 0, schema_bytes: 0 },+ metrics: {+ approved_oauth_clients: 0,+ authorizations: 0,+ tokens: 0,+ errors: 0,+ },+ setup_checklist: [+ { label: "Enable server", complete: setupComplete },+ { label: "Register client", complete: true },+ ],+ warnings: [],+ })+ );+ const capabilitiesResponse = () =>+ helper.response({+ initial_scope: "mcp:profile:read",+ available_scopes: [+ "chat:read",+ "mcp:content:read",+ "mcp:content:write",+ "mcp:profile:read",+ "voting:write",+ ],+ access_rules: [+ {+ group_id: 1,+ group_name: "admins",+ scopes: [+ "chat:read",+ "mcp:content:read",+ "mcp:content:write",+ "mcp:profile:read",+ "voting:write",+ ],+ pre_registered: true,+ deletable: false,+ },+ {+ group_id: 42,+ group_name: "writers",+ scopes: [+ "mcp:content:read",+ "mcp:content:write",+ "mcp:profile:read",+ ],+ pre_registered: false,+ deletable: true,+ },+ ],+ primitives: [+ {+ id: "tool:discourse_search",+ field_name: "primitive_search",+ title: "Search Discourse",+ description: "Search visible topics and posts.",+ provider: "core",+ kind: "tool",+ risk: "read",+ required_scopes: ["mcp:content:read"],+ enabled: true,+ available: true,+ emergency_blocked: false,+ },+ {+ id: "tool:discourse_topic_create",+ field_name: "primitive_create_topic",+ title: "Create topic",+ description: "Create a topic.",+ provider: "core",+ kind: "tool",+ risk: "write",+ required_scopes: ["mcp:content:write"],+ enabled: false,+ available: true,+ emergency_blocked: false,+ },+ {+ id: "resource_template:chat.channel",+ field_name: "primitive_chat_channel",+ title: "Chat channel",+ description: "A visible chat channel.",+ provider: "chat",+ kind: "resource_template",+ risk: "read",+ required_scopes: ["chat:read"],+ enabled: false,+ available: true,+ emergency_blocked: false,+ },+ {+ id: "tool:discourse_topic_vote",+ field_name: "primitive_topic_vote",+ title: "Set topic vote",+ description: "Votes in a topic poll.",+ provider: "voting",+ kind: "tool",+ risk: "write",+ required_scopes: ["voting:write"],+ enabled: false,+ available: true,+ emergency_blocked: false,+ },+ ],+ });+ server.get("/admin/mcp/access.json", capabilitiesResponse);+ server.get("/admin/mcp/capabilities.json", capabilitiesResponse);+ server.put("/admin/mcp/capabilities.json", (request) => {+ const body = new URLSearchParams(request.requestBody);+ savedPrimitiveIds = body.getAll("primitive_ids[]");+ return helper.response({ success: true });+ });+ server.get("/admin/mcp/authorizations.json", (request) => {+ authorizationRequests.push(request.queryParams);+ if (request.queryParams.filter === "former") {+ return helper.response({+ authorizations: [+ {+ id: 18,+ username: "alex",+ client_name: "Former assistant",+ client_id: "former-client",+ scopes: ["mcp:content:read"],+ status: "revoked",+ last_used_at: null,+ },+ ],+ meta: {},+ });+ }+ if (request.queryParams.cursor) {+ return helper.response({+ authorizations: [+ {+ id: 18,+ username: "alex",+ client_name: "Former assistant",+ client_id: "former-client",+ scopes: ["mcp:content:read"],+ status: "revoked",+ last_used_at: null,+ },+ ],+ meta: {},+ });+ }+ return helper.response({+ authorizations: [+ {+ id: 19,+ username: "sam",+ client_name: "Example assistant",+ client_id: "example-client",+ scopes: ["mcp:content:read"],+ status: "access_removed",+ last_used_at: null,+ },+ ],+ meta: { next_cursor: 19 },+ });+ });+ server.get("/admin/mcp/clients.json", (request) => {+ clientRequests.push(request.queryParams);+ if (request.queryParams.filter === "older") {+ return helper.response({+ clients: [+ {+ id: 6,+ client_id: "older-client",+ name: "Older client",+ registration_type: "pre_registered",+ trust_state: "approved",+ blocked: false,+ last_seen_at: null,+ authorization_count: 0,+ },+ ],+ meta: {},+ });+ }+ if (request.queryParams.cursor) {+ return helper.response({+ clients: [+ {+ id: 6,+ client_id: "older-client",+ name: "Older client",+ registration_type: "pre_registered",+ trust_state: "approved",+ blocked: false,+ last_seen_at: null,+ authorization_count: 0,+ },+ ],+ meta: {},+ });+ }+ return helper.response({+ clients: [+ {+ id: 7,+ client_id: "https://client.example.com/oauth/client.json",+ name: "Example client",+ registration_type: "cimd",+ trust_state: "approved",+ blocked: false,+ last_seen_at: null,+ authorization_count: 1,+ },+ {+ id: 8,+ client_id: "blocked-client",+ name: "Blocked client",+ registration_type: "pre_registered",+ trust_state: "blocked",+ blocked: true,+ last_seen_at: null,+ authorization_count: 0,+ },+ ],+ meta: { next_cursor: 7 },+ });+ });+ server.post("/admin/mcp/clients/7/refresh.json", () => {+ refreshClientRequests.push(7);+ return helper.response({+ client: {+ id: 7,+ client_id: "https://client.example.com/oauth/client.json",+ name: refreshedClientName,+ registration_type: "cimd",+ trust_state: "approved",+ blocked: false,+ last_seen_at: null,+ authorization_count: 1,+ },+ });+ });+ server.get("/admin/mcp/activity.json", (request) => {+ activityRequests.push(request.queryParams);++ const metrics = {+ tool_calls: 2,+ errors: 1,+ rate_limits: 0,+ p95_latency_ms: 25,+ };+ if (request.queryParams.filter !== "search") {+ return helper.response({ activity: [], metrics, meta: {} });+ }++ if (request.queryParams.cursor) {+ return helper.response({+ activity: [+ {+ id: 1,+ created_at: "2026-08-28T10:00:00Z",+ method: "tools/call",+ tool: "discourse_search_older",+ username: "sam",+ outcome: "error",+ duration_ms: 20,+ request_id: "request-older",+ },+ ],+ meta: {},+ });+ }++ return helper.response({+ activity: [+ {+ id: 2,+ created_at: "2026-08-28T11:00:00Z",+ method: "tools/call",+ tool: "discourse_search_newer",+ username: "sam",+ outcome: "error",+ duration_ms: 25,+ request_id: "request-newer",+ },+ ],+ metrics,+ meta: { next_cursor: 2 },+ });+ });+ server.put("/admin/mcp/access/:group_id.json", (request) => {+ const body = new URLSearchParams(request.requestBody);+ savedAccessRule = {+ groupId: request.url.split("/").at(-1).split(".")[0],+ scopes: body.getAll("scopes[]"),+ };+ return helper.response({+ access_rules: [+ {+ group_id: 1,+ group_name: "admins",+ scopes: [+ "chat:read",+ "mcp:content:read",+ "mcp:content:write",+ "mcp:profile:read",+ "voting:write",+ ],+ pre_registered: true,+ deletable: false,+ },+ {+ group_id: 42,+ group_name: "writers",+ scopes: body.getAll("scopes[]"),+ pre_registered: false,+ deletable: true,+ },+ ],+ });+ });+ server.put("/admin/mcp/capabilities/emergency-block.json", (request) => {+ const body = new URLSearchParams(request.requestBody);+ emergencyBlockRequests.push({+ primitiveId: body.get("primitive_id"),+ blocked: body.get("blocked") === "true",+ });+ return helper.response({ success: true });+ });+ });++ test("can navigate away from the settings tab", async function (assert) {+ await visit("/admin/config/mcp/settings");++ assert.strictEqual(+ currentURL(),+ "/admin/config/mcp/settings",+ "the settings route renders"+ );++ await click(".admin-mcp-tabs__overview a");++ assert.strictEqual(+ currentURL(),+ "/admin/config/mcp",+ "the overview route is entered"+ );+ assert+ .dom("h2")+ .hasText(+ i18n("admin.config.mcp.overview.title"),+ "the overview content renders"+ );+ assert+ .dom(".admin-mcp__usage")+ .includesText(+ i18n("admin.config.mcp.overview.approved_oauth_clients"),+ "the overview names approved OAuth clients"+ );+ assert+ .dom(".admin-mcp__setup")+ .doesNotExist("the completed setup checklist is hidden");+ });++ test("shows the setup checklist while setup is incomplete", async function (assert) {+ setupComplete = false;++ await visit("/admin/config/mcp");++ assert+ .dom(".admin-mcp__setup")+ .exists("the incomplete setup checklist is visible");+ });++ test("prefills known OAuth client applications", async function (assert) {+ await visit("/admin/config/mcp/clients/new");++ assert+ .dom(".admin-mcp__client-presets")+ .exists("the application choices are shown first");+ assert+ .dom("[data-client-preset-id]")+ .exists(+ { count: 6 },+ "the known applications and custom option are shown"+ );+ assert+ .dom(".admin-mcp__client-form")+ .doesNotExist("the form is hidden until an application is selected");++ await click('[data-client-preset-id="codex"] button');++ assert+ .dom(".admin-mcp__client-presets")+ .doesNotExist("the application choices are hidden while editing");+ assert+ .dom(".admin-mcp__client-form")+ .includesText(+ i18n("admin.config.mcp.clients.preset_help.codex"),+ "the selected application instructions are shown"+ );+ assert.dom('[name="name"]').hasValue("Codex", "Codex has a name");+ assert.dom('[name="client_id"]').hasValue("codex", "Codex has a client ID");+ assert+ .dom('[name="redirect_uris"]')+ .hasValue(+ "http://127.0.0.1/callback",+ "Codex has its portless loopback callback"+ );++ await click(".admin-mcp__change-client-preset");+ await click('[data-client-preset-id="chatgpt"] button');++ assert+ .dom(".admin-mcp__client-form")+ .includesText(+ i18n("admin.config.mcp.clients.preset_help.chatgpt"),+ "the ChatGPT instructions explain when registration is needed"+ );+ assert+ .dom('[name="client_id"]')+ .hasValue(+ "https://chatgpt.com/oauth/client.json",+ "ChatGPT has its stable metadata client ID"+ );+ assert+ .dom('[name="redirect_uris"]')+ .hasValue(+ "https://chatgpt.com/connector_platform_oauth_redirect",+ "ChatGPT has its stable hosted callback"+ );++ await click(".admin-mcp__change-client-preset");+ await click('[data-client-preset-id="claude_code"] button');++ assert+ .dom('[name="redirect_uris"]')+ .hasValue(+ "http://localhost:8080/callback",+ "Claude Code has a fixed callback port"+ );+ assert+ .dom(".admin-mcp__client-form")+ .includesText(+ i18n("admin.config.mcp.clients.preset_help.claude_code"),+ "the application instructions explain how to use the fixed port"+ );++ await click(".admin-mcp__change-client-preset");+ await click('[data-client-preset-id="mcp_inspector"] button');++ assert+ .dom('[name="redirect_uris"]')+ .hasValue(+ "http://localhost:6274/oauth/callback\nhttp://127.0.0.1:6276/oauth/callback",+ "MCP Inspector allows its web and command-line callbacks"+ );++ await click(".admin-mcp__change-client-preset");+ await click('[data-client-preset-id="visual_studio_code"] button');++ assert+ .dom('[name="redirect_uris"]')+ .hasValue(+ "http://127.0.0.1:33418\nhttps://vscode.dev/redirect",+ "Visual Studio Code allows its loopback and hosted callbacks"+ );++ await click(".admin-mcp__change-client-preset");+ await click('[data-client-preset-id="custom"] button');++ assert.dom('[name="name"]').hasValue("", "a custom client starts empty");+ assert+ .dom('[name="client_id"]')+ .hasValue("", "a custom client ID starts empty");+ });++ test("adds group access on a dedicated page", async function (assert) {+ await visit("/admin/config/mcp/access");+ await click(".admin-mcp__access-section .btn-primary");++ assert.strictEqual(+ currentURL(),+ "/admin/config/mcp/access/new",+ "the add action opens a dedicated route"+ );+ assert+ .dom(".admin-mcp__form-card")+ .includesText(+ i18n("admin.config.mcp.access.new_title"),+ "the add page follows the OAuth client form pattern"+ );+ assert+ .dom(".admin-mcp__access-form")+ .exists("the group access form is shown on the dedicated page");+ assert+ .dom(".admin-mcp__scope-select .d-multi-select-trigger__selected-item")+ .hasText("mcp:profile:read", "the initial scope is selected");+ });++ test("edits the eligible scopes for one group", async function (assert) {+ await visit("/admin/config/mcp/access");++ assert.strictEqual(+ currentURL(),+ "/admin/config/mcp/access",+ "the access route loads directly"+ );+ assert+ .dom(".admin-mcp-tabs__access")+ .hasText(+ i18n("admin.config.mcp.tabs.access"),+ "the access tab is selected"+ );+ assert+ .dom(".admin-mcp__access-section > .d-page-subheader h2")+ .hasText(+ i18n("admin.config.mcp.access.title"),+ "the page has one access heading"+ );+ await click('[data-group-id="42"] .admin-mcp__edit-access-rule');++ assert.strictEqual(+ currentURL(),+ "/admin/config/mcp/access/42/edit",+ "the edit action opens a dedicated route"+ );++ assert+ .dom(".admin-mcp__scope-select")+ .exists("eligible scopes use a multi-select control");+ assert+ .dom(".admin-mcp__scope-select .d-multi-select-trigger__selected-item")+ .exists({ count: 3 }, "the group's saved scopes are selected");++ const initialScope = findAll(+ ".admin-mcp__scope-select .d-multi-select-trigger__selected-item"+ ).find((scope) => scope.textContent.includes("mcp:profile:read"));+ await click(initialScope);+ assert+ .dom(".admin-mcp__scope-select .d-multi-select-trigger__selected-item")+ .exists({ count: 3 }, "the initial scope cannot be removed");++ await click(".admin-mcp__scope-select");++ const chatScopeResult = findAll(".d-multi-select__result").find((result) =>+ result.textContent.includes("chat:read")+ );++ assert+ .dom(chatScopeResult)+ .includesText("chat:read", "the server-provided scope is available");+ assert+ .dom(chatScopeResult)+ .includesText(+ i18n("admin.config.mcp.access.scope_primitives", { count: 1 }),+ "the option explains its primitive usage"+ );++ await click(chatScopeResult);+ await click(".admin-mcp__access-form .btn-primary");++ assert.strictEqual(+ savedAccessRule.groupId,+ "42",+ "the edited group is saved"+ );+ assert.deepEqual(+ savedAccessRule.scopes.sort(),+ [+ "chat:read",+ "mcp:content:read",+ "mcp:content:write",+ "mcp:profile:read",+ ],+ "selected scope identifiers are saved directly"+ );+ });++ test("shows access as one row per group", async function (assert) {+ await visit("/admin/config/mcp/access");++ assert+ .dom(".admin-mcp__access-table")+ .exists("group access is presented as a table");+ assert+ .dom(".admin-mcp__access-table thead th")+ .exists({ count: 4 }, "edit and delete have separate columns");+ assert+ .dom(".admin-mcp__access-table thead th:first-child")+ .hasText(+ i18n("admin.config.mcp.access.groups"),+ "the first column is Groups"+ );+ assert+ .dom(".admin-mcp__access-table thead th:nth-child(3) .sr-only")+ .hasText(+ i18n("admin.config.mcp.access.edit"),+ "the untitled edit column remains accessible"+ );+ assert+ .dom(".admin-mcp__access-table thead th:nth-child(4) .sr-only")+ .hasText(+ i18n("admin.config.mcp.access.delete"),+ "the untitled delete column remains accessible"+ );+ assert+ .dom(".admin-mcp__access-table tbody tr")+ .exists(+ { count: 2 },+ "the pre-registered Admins row and saved group row render"+ );+ assert+ .dom(".admin-mcp__access-table tbody tr:first-child")+ .includesText("admins", "the pre-registered Admins row is shown");+ assert+ .dom(+ ".admin-mcp__access-table tbody tr:first-child td:nth-child(3) .admin-mcp__edit-access-rule"+ )+ .exists("the Admins scopes can be edited");+ assert+ .dom(+ ".admin-mcp__access-table tbody tr:first-child td:nth-child(4) .admin-mcp__delete-access-rule"+ )+ .doesNotExist("the pre-registered Admins row cannot be removed");+ assert+ .dom(".admin-mcp__access-table tbody tr:last-child")+ .includesText("writers", "the persisted group row is shown");+ assert+ .dom(+ ".admin-mcp__access-table tbody tr:last-child td:nth-child(4) .admin-mcp__delete-access-rule"+ )+ .exists("deletable groups keep the separate delete column");+ });++ test("labels user grants as authorizations", async function (assert) {+ await visit("/admin/config/mcp/authorizations");++ assert+ .dom(".admin-mcp-tabs__authorizations")+ .hasText(+ i18n("admin.config.mcp.tabs.authorizations"),+ "the tab names the OAuth records"+ );+ assert+ .dom(".admin-mcp h2")+ .hasText(+ i18n("admin.config.mcp.authorizations.title"),+ "the page heading matches the tab"+ );+ assert+ .dom(".admin-mcp__authorizations-table th:nth-child(3)")+ .hasText(+ i18n("admin.config.mcp.authorizations.scopes"),+ "the table uses the OAuth scope term"+ );+ assert+ .dom(".admin-mcp__authorizations-table tbody td:nth-child(3) code")+ .exists("scope identifiers use monospace text");+ assert+ .dom('.admin-mcp__status[data-state="access_removed"]')+ .hasText(+ i18n("admin.config.mcp.values.authorization_status.access_removed"),+ "the current access restriction is shown"+ );+ });++ test("shows client actions in the expected order and refreshes metadata", async function (assert) {+ await visit("/admin/config/mcp/clients");++ assert+ .dom(".d-page-subheader__learn-more a")+ .hasAttribute(+ "href",+ "https://meta.discourse.org/t/connecting-your-apps-to-discourse-mcp-server/411637#p-2033870-connecting-apps-via-oauth-2",+ "the OAuth clients documentation is linked"+ );+ assert+ .dom(".admin-mcp__table th:last-child .sr-only")+ .hasText(+ i18n("admin.config.mcp.clients.actions"),+ "the untitled action column remains accessible"+ );+ assert+ .dom(+ ".admin-mcp__table tbody tr:first-child .d-table__cell-actions button:first-child"+ )+ .hasText(+ i18n("admin.config.mcp.actions.refresh_metadata"),+ "refresh metadata is the first action"+ )+ .hasClass("--primary", "refresh metadata uses the tertiary action color");+ assert+ .dom(+ ".admin-mcp__table tbody tr:first-child .d-table__cell-actions button:last-child"+ )+ .hasText(+ i18n("admin.config.mcp.clients.block"),+ "block is the last action"+ )+ .hasClass("btn-danger", "block uses the danger style");+ assert+ .dom(+ ".admin-mcp__table tbody tr:last-child .admin-mcp__toggle-client-block"+ )+ .hasText(+ i18n("admin.config.mcp.clients.unblock"),+ "blocked clients show Unblock"+ )+ .hasClass("btn-default", "unblock uses the neutral default style");++ await click(".admin-mcp__refresh-client");++ assert.deepEqual(refreshClientRequests, [7], "metadata is refreshed");+ assert+ .dom(".admin-mcp__table tbody .d-table__overview-name")+ .hasText(refreshedClientName, "the refreshed metadata updates the row");+ });++ test("filters clients and authorizations on the server", async function (assert) {+ await visit("/admin/config/mcp/clients");+ await fillIn(".admin-mcp__table-filter input", "older");+ await waitUntil(() =>+ clientRequests.some((request) => request.filter === "older")+ );++ assert+ .dom(".admin-mcp__table tbody tr")+ .exists({ count: 1 }, "the server-filtered client replaces the table");+ assert+ .dom(".admin-mcp__table")+ .includesText("Older client", "the matching client is shown");++ await visit("/admin/config/mcp/authorizations");+ await fillIn(".admin-mcp__table-filter input", "former");+ await waitUntil(() =>+ authorizationRequests.some((request) => request.filter === "former")+ );++ assert+ .dom(".admin-mcp__authorizations-table tbody tr")+ .exists(+ { count: 1 },+ "the server-filtered authorization replaces the table"+ );+ assert+ .dom(".admin-mcp__authorizations-table")+ .includesText("Former assistant", "the matching authorization is shown");+ });++ test("loads older clients and authorizations", async function (assert) {+ enableLoadMoreObserver();+ const observations = stubIntersectionObserver();++ try {+ await visit("/admin/config/mcp/clients");+ await observations+ .find(({ element }) => element.closest(".admin-mcp__load-more"))+ .trigger();+ await waitUntil(() =>+ clientRequests.some((request) => request.cursor === "7")+ );++ assert+ .dom(".admin-mcp__table tbody tr")+ .exists({ count: 3 }, "the older client is appended");++ await visit("/admin/config/mcp/authorizations");+ await observations+ .findLast(({ element }) => element.closest(".admin-mcp__load-more"))+ .trigger();+ await waitUntil(() =>+ authorizationRequests.some((request) => request.cursor === "19")+ );++ assert+ .dom(".admin-mcp__authorizations-table tbody tr")+ .exists({ count: 2 }, "the older authorization is appended");+ } finally {+ disableLoadMoreObserver();+ }+ });++ test("labels audited calls as tool calls", async function (assert) {+ await visit("/admin/config/mcp/activity");++ assert+ .dom(".admin-mcp__activity-filters select option:first-child")+ .hasText(+ i18n("admin.config.mcp.values.activity_outcome.all"),+ "the unfiltered option names the outcome filter"+ );+ assert+ .dom(".admin-mcp__activity-metrics")+ .includesText(+ i18n("admin.config.mcp.activity.tool_calls"),+ "the metric describes the audited method"+ );+ });++ test("filters on the server and automatically loads the next filtered page", async function (assert) {+ enableLoadMoreObserver();+ const observations = stubIntersectionObserver();++ try {+ await visit("/admin/config/mcp/activity");+ await fillIn(".admin-mcp__activity-filters input", "search");+ await waitUntil(() =>+ activityRequests.some((request) => request.filter === "search")+ );+ await select(".admin-mcp__activity-filters select", "error");+ await waitUntil(() =>+ activityRequests.some(+ (request) =>+ request.filter === "search" && request.outcome === "error"+ )+ );++ assert+ .dom(".admin-mcp__activity-table tbody tr")+ .exists({ count: 1 }, "the filtered first page replaces the table");+ assert+ .dom(".admin-mcp__activity-table")+ .includesText("discourse_search_newer", "the server result is shown");+ assert+ .dom(".admin-mcp__load-more")+ .exists("automatic loading is enabled while a cursor is present");++ await observations+ .find(({ element }) => element.closest(".admin-mcp__load-more"))+ .trigger();++ await waitUntil(() =>+ activityRequests.some((request) => request.cursor === "2")+ );++ assert.deepEqual(+ activityRequests.at(-1),+ { cursor: "2", filter: "search", outcome: "error" },+ "the cursor request preserves every active filter"+ );+ assert+ .dom(".admin-mcp__activity-table tbody tr")+ .exists({ count: 2 }, "the next filtered page is appended");+ assert+ .dom(".admin-mcp__activity-table")+ .includesText("discourse_search_older", "the older result is loaded");+ assert+ .dom(".admin-mcp__activity-metrics")+ .includesText("25 ms", "the initial metrics remain visible");+ } finally {+ disableLoadMoreObserver();+ }+ });++ test("blocks and unblocks a primitive immediately", async function (assert) {+ const primitiveSelector =+ '.admin-mcp__primitive[data-primitive-id="tool:discourse_search"]';++ await visit("/admin/config/mcp/capabilities");+ await click(`${primitiveSelector} .admin-mcp__primitive-actions button`);++ assert.dom(".dialog-body").includesText(+ i18n("admin.config.mcp.confirm_emergency_block", {+ name: "Search Discourse",+ }),+ "the action explains what will be blocked"+ );++ await click(".dialog-footer .btn-primary");++ assert.deepEqual(+ emergencyBlockRequests,+ [{ primitiveId: "tool:discourse_search", blocked: true }],+ "the primitive identifier is sent in the request body"+ );+ assert+ .dom(primitiveSelector)+ .includesText(+ i18n("admin.config.mcp.primitives.emergency_blocked"),+ "the blocked state is visible"+ );+ assert+ .dom(`${primitiveSelector} input[type="checkbox"]`)+ .isDisabled("the blocked primitive cannot be enabled");+ assert+ .dom(`${primitiveSelector} .admin-mcp__primitive-actions button`)+ .hasAttribute(+ "title",+ i18n("admin.config.mcp.actions.unblock_primitive"),+ "the action changes to unblock"+ );++ await click(`${primitiveSelector} .admin-mcp__primitive-actions button`);++ assert.deepEqual(+ emergencyBlockRequests,+ [+ { primitiveId: "tool:discourse_search", blocked: true },+ { primitiveId: "tool:discourse_search", blocked: false },+ ],+ "the block can be removed without another confirmation"+ );+ assert+ .dom(primitiveSelector)+ .doesNotIncludeText(+ i18n("admin.config.mcp.primitives.emergency_blocked"),+ "the blocked state is removed"+ );+ });++ test("groups primitives by scope, provider, and type", async function (assert) {+ await visit("/admin/config/mcp/capabilities");++ assert+ .dom(".admin-mcp-tabs__capabilities")+ .hasText(+ i18n("admin.config.mcp.tabs.capabilities"),+ "the capabilities tab uses the MCP term"+ );+ assert+ .dom(".admin-mcp h2")+ .hasText(+ i18n("admin.config.mcp.capabilities.title"),+ "the page heading uses the MCP term"+ );+ assert+ .dom(+ ".admin-mcp > .d-page-subheader:first-child .d-page-subheader__description"+ )+ .hasText(+ i18n("admin.config.mcp.capabilities.description"),+ "the page explains how primitives relate to capabilities"+ );+ assert+ .dom(".admin-mcp__primitive-filters.form-kit")+ .exists("the primitive filters use FormKit");+ assert+ .dom(".admin-mcp__primitives-description")+ .hasText(+ i18n("admin.config.mcp.primitives.picker_description"),+ "the primitive default state remains explained"+ );+ assert+ .dom(".admin-mcp__primitive-browser")+ .exists("the primitive browser renders below the section heading");+ assert+ .dom(".admin-mcp__primitive")+ .exists({ count: 4 }, "all primitives initially render");+ assert+ .dom('[name="primitiveGroupBy"]')+ .hasValue("scope", "primitives are grouped by scope by default");+ assert+ .dom(+ ".admin-mcp__primitive-panel-header > .admin-mcp__results-count + .admin-mcp__primitive-group-actions"+ )+ .exists("the visible primitive actions follow the result count");++ assert+ .dom('.admin-mcp__primitive-group[data-primitive-group-id="all"]')+ .includesText(+ i18n("admin.config.mcp.primitives.group_count", {+ enabled: 1,+ total: 4,+ }),+ "the group shows enabled and total counts"+ );++ await click(+ '.admin-mcp__primitive-group[data-primitive-group-id="mcp:content:write"]'+ );++ assert+ .dom(".admin-mcp__primitive")+ .exists({ count: 1 }, "selecting a scope shows its primitives");+ assert+ .dom(".admin-mcp__primitive")+ .includesText(+ "Create topic",+ "the primitive requiring that scope remains"+ );++ await select('[name="primitiveGroupBy"]', "provider");+ await click('.admin-mcp__primitive-group[data-primitive-group-id="chat"]');++ assert+ .dom(".admin-mcp__primitive")+ .exists({ count: 1 }, "selecting a provider shows its primitives");+ assert+ .dom(".admin-mcp__primitive")+ .includesText("Chat channel", "the provider primitive remains");++ await select('[name="primitiveGroupBy"]', "kind");+ await click(+ '.admin-mcp__primitive-group[data-primitive-group-id="resource_template"]'+ );++ assert+ .dom(".admin-mcp__primitive")+ .exists({ count: 1 }, "selecting a type shows its primitives");+ assert+ .dom(".admin-mcp__primitive")+ .includesText("Chat channel", "the resource template remains");++ await fillIn('[name="primitiveFilter"]', "vote");++ assert+ .dom(".admin-mcp__primitive")+ .exists({ count: 1 }, "search uses the full primitive set");+ assert+ .dom(".admin-mcp__primitive")+ .includesText("Set topic vote", "the matching primitive is visible");+ assert+ .dom('.admin-mcp__primitive-group[data-primitive-group-id="all"]')+ .hasClass("is-selected", "search returns to all primitives");++ await fillIn('[name="primitiveFilter"]', "");++ assert+ .dom(".admin-mcp__primitive")+ .exists({ count: 4 }, "clearing search restores the full primitive set");++ await fillIn('[name="primitiveFilter"]', "chat");++ assert+ .dom(".admin-mcp__primitive")+ .exists({ count: 1 }, "replacing the search term refilters the full set");+ assert+ .dom(".admin-mcp__primitive")+ .includesText("Chat channel", "the replacement match is visible");+ });++ test("floats the save action while primitive changes are unsaved", async function (assert) {+ await visit("/admin/config/mcp/capabilities");++ assert+ .dom(+ ".admin-mcp__primitive-selection-form .form-kit__actions.is-floating"+ )+ .doesNotExist("the save action is not floating before anything changes");++ await click('[name="primitive_create_topic"]');++ assert+ .dom(+ ".admin-mcp__primitive-selection-form .form-kit__actions.is-floating"+ )+ .exists("the save action floats when a primitive changes");++ await click(+ ".admin-mcp__primitive-selection-form .form-kit__actions .btn-primary"+ );++ assert.deepEqual(+ savedPrimitiveIds,+ ["tool:discourse_search", "tool:discourse_topic_create"],+ "the selected primitives are saved"+ );+ assert+ .dom(+ ".admin-mcp__primitive-selection-form .form-kit__actions.is-floating"+ )+ .doesNotExist("the save action returns to the page after saving");++ await click('[name="primitive_create_topic"]');++ assert+ .dom(+ ".admin-mcp__primitive-selection-form .form-kit__actions.is-floating"+ )+ .exists("later changes are compared with the newly saved value");++ await click('[name="primitive_create_topic"]');++ assert+ .dom(+ ".admin-mcp__primitive-selection-form .form-kit__actions.is-floating"+ )+ .doesNotExist("restoring the newly saved value clears the change");+ });++ test("clears a primitive change when its saved value is restored", async function (assert) {+ await visit("/admin/config/mcp/capabilities");++ await click('[name="primitive_create_topic"]');+ await click('[name="primitive_create_topic"]');++ assert+ .dom(+ ".admin-mcp__primitive-selection-form .form-kit__actions.is-floating"+ )+ .doesNotExist(+ "the save action stops floating after the change is undone"+ );++ await click(".admin-mcp-tabs__access a");++ assert.strictEqual(+ currentURL(),+ "/admin/config/mcp/access",+ "restoring the saved value allows navigation without a dirty-form warning"+ );+ });+});diff --git a/frontend/discourse/tests/acceptance/admin-site-settings-test.js b/frontend/discourse/tests/acceptance/admin-site-settings-test.jsindex a31afbc7884..7d4f7e59ab9 100644--- a/frontend/discourse/tests/acceptance/admin-site-settings-test.js+++ b/frontend/discourse/tests/acceptance/admin-site-settings-test.js@@ -9,6 +9,7 @@ import { test } from "qunit";import siteSettingFixture from "discourse/tests/fixtures/site-settings";import pretender from "discourse/tests/helpers/create-pretender";import { acceptance } from "discourse/tests/helpers/qunit-helpers";+import { i18n } from "discourse-i18n";acceptance("Admin - Site Settings", function (needs) {let updatedTitle;@@ -372,6 +373,76 @@ acceptance("Admin - Site Settings", function (needs) {);});+ test("labels the MCP settings category and client policies", async function (assert) {+ pretender.get("/admin/site_settings", () => {+ return [+ 200,+ { "Content-Type": "application/json" },+ JSON.stringify({+ site_settings: [+ {+ setting: "mcp_oauth_client_id_metadata_policy",+ humanized_name: "MCP OAuth Client ID metadata policy",+ description:+ "Choose how OAuth clients can register with this site. Users must still approve the access requested by each client.",+ default: "any_domain",+ value: "any_domain",+ category: "mcp",+ preview: null,+ secret: false,+ type: "enum",+ valid_values: [+ {+ name: "mcp_oauth_client_id_metadata_policy.disabled",+ value: "disabled",+ },+ {+ name: "mcp_oauth_client_id_metadata_policy.approved_domains",+ value: "approved_domains",+ },+ {+ name: "mcp_oauth_client_id_metadata_policy.any_domain",+ value: "any_domain",+ },+ ],+ translate_names: true,+ },+ ],+ }),+ ];+ });++ await visit("/admin/site_settings?filter=mcp%20client%20id%20metadata");++ assert+ .dom(".admin-site-settings-category-nav__item.mcp a")+ .hasAttribute(+ "title",+ i18n("admin.site_settings.categories.mcp"),+ "the MCP category has a translated label"+ );+ assert+ .dom(+ '[data-setting="mcp_oauth_client_id_metadata_policy"] .form-kit__control-select'+ )+ .hasValue("any_domain", "CIMD from any domain is selected by default");+ assert+ .dom(+ '[data-setting="mcp_oauth_client_id_metadata_policy"] option[value="disabled"]'+ )+ .hasText(i18n("mcp_oauth_client_id_metadata_policy.disabled"));+ assert+ .dom(+ '[data-setting="mcp_oauth_client_id_metadata_policy"] option[value="approved_domains"]'+ )+ .hasText(i18n("mcp_oauth_client_id_metadata_policy.approved_domains"));+ assert+ .dom(+ '[data-setting="mcp_oauth_client_id_metadata_policy"] option[value="any_domain"]'+ )+ .hasText(i18n("mcp_oauth_client_id_metadata_policy.any_domain"));+ });+test("shows all_results if current category has none", async function (assert) {await visit("/admin/site_settings");diff --git a/frontend/discourse/tests/acceptance/preferences-test.js b/frontend/discourse/tests/acceptance/preferences-test.jsindex e2082f3e8d9..37d428206ec 100644--- a/frontend/discourse/tests/acceptance/preferences-test.js+++ b/frontend/discourse/tests/acceptance/preferences-test.js@@ -112,6 +112,26 @@ acceptance("User Preferences", function (needs) {});});+acceptance("MCP authorizations in user preferences", function (needs) {+ needs.user({+ show_mcp_authorizations: true,+ });+ needs.pretender((server, helper) => {+ preferencesPretender(server, helper);+ server.get("/u/eviltrout/preferences/mcp-authorizations.json", () =>+ helper.response({ authorizations: [] })+ );+ });++ test("places MCP authorizations in Security", async function (assert) {+ await visit("/u/eviltrout/preferences/security");++ assert+ .dom(".user-mcp-authorizations")+ .exists("MCP authorizations are shown in Security when relevant");+ });+});+acceptance("Custom User Fields", function (needs) {needs.user();needs.site({diff --git a/frontend/discourse/tests/integration/components/user-preferences/user-mcp-authorizations-test.gjs b/frontend/discourse/tests/integration/components/user-preferences/user-mcp-authorizations-test.gjsnew file mode 100644index 00000000000..ea9a8654a7b--- /dev/null+++ b/frontend/discourse/tests/integration/components/user-preferences/user-mcp-authorizations-test.gjs@@ -0,0 +1,333 @@+import { click, find, render, settled } from "@ember/test-helpers";+import { module, test } from "qunit";+import sinon from "sinon";+import UserMcpAuthorizations from "discourse/components/user-preferences/user-mcp-authorizations";+import { setupRenderingTest } from "discourse/tests/helpers/component-test";+import pretender, { response } from "discourse/tests/helpers/create-pretender";+import { i18n } from "discourse-i18n";++module("Integration | Component | UserMcpAuthorizations", function (hooks) {+ setupRenderingTest(hooks);++ hooks.beforeEach(function () {+ this.siteSettings.mcp_server_enabled = true;+ this.model = { username: "mcp-user", show_mcp_authorizations: true };+ });++ hooks.afterEach(function () {+ sinon.restore();+ });++ test("does not render when MCP authorizations are not relevant", async function (assert) {+ this.model.show_mcp_authorizations = false;++ await render(+ <template><UserMcpAuthorizations @model={{this.model}} /></template>+ );++ assert+ .dom(".user-mcp-authorizations")+ .doesNotExist("irrelevant MCP authorization history is hidden");+ });++ test("renders authorization details returned by the preferences endpoint", async function (assert) {+ pretender.get("/u/mcp-user/preferences/mcp-authorizations.json", () =>+ response({+ authorizations: [+ {+ id: 42,+ client_name: "Example assistant",+ resource: "https://forum.example.com/mcp",+ scopes: ["mcp:content:read"],+ consented_at: "2026-08-01T10:00:00Z",+ last_used_at: null,+ token_count: 1,+ status: "active",+ },+ ],+ })+ );++ await render(+ <template><UserMcpAuthorizations @model={{this.model}} /></template>+ );++ assert+ .dom(".user-mcp-authorization")+ .exists("the connected application is rendered");+ assert+ .dom(".user-mcp-authorizations__table")+ .exists("authorizations are presented as a table");+ assert+ .dom(".user-mcp-authorizations > .control-label")+ .hasText(+ i18n("user.mcp_authorizations.title"),+ "the heading follows the Security section pattern"+ );+ assert+ .dom(".user-mcp-authorizations__table thead .d-table__header-cell")+ .exists({ count: 3 }, "the table describes each column");+ assert+ .dom(".user-mcp-authorizations__table thead th:nth-child(1)")+ .hasText(+ i18n("user.mcp_authorizations.application"),+ "the application column is labelled"+ );+ assert+ .dom(".user-mcp-authorizations__table thead th:nth-child(2)")+ .hasText(+ i18n("user.mcp_authorizations.details"),+ "the details column is labelled"+ );+ assert+ .dom(".user-mcp-authorizations__table thead th:nth-child(3)")+ .hasText(+ i18n("user.mcp_authorizations.status"),+ "the status column is labelled"+ );+ assert+ .dom(".user-mcp-authorization__application")+ .hasText(+ "Example assistant",+ "the application column only shows the name"+ );+ assert+ .dom('.user-mcp-authorization__status[data-state="active"]')+ .hasText(+ i18n("user.mcp_authorizations.statuses.active"),+ "the authorization status is easy to scan"+ );+ assert+ .dom(".user-mcp-authorization__details-cell")+ .includesText(+ i18n("user.mcp_authorizations.active_tokens", { count: 1 }),+ "active token usage is grouped with the authorization details"+ );+ assert+ .dom(".user-mcp-authorization__details-cell")+ .includesText(+ i18n("user.mcp_authorizations.authorized"),+ "the authorization date is grouped with the other details"+ );+ assert+ .dom(".user-mcp-authorization__status-cell .btn-default")+ .hasText(+ i18n("user.mcp_authorizations.revoke"),+ "active authorizations can be revoked"+ );+ assert+ .dom(".user-mcp-authorization__status-cell .btn-danger")+ .doesNotExist("the compact row does not overemphasize the revoke action");+ assert+ .dom(".user-mcp-authorization__actions")+ .doesNotExist("the table does not reserve a separate actions column");+ assert+ .dom(".user-mcp-authorization__permissions-list")+ .doesNotExist("permissions are collapsed initially");+ });++ test("expands granted permissions", async function (assert) {+ pretender.get("/u/mcp-user/preferences/mcp-authorizations.json", () =>+ response({+ authorizations: [+ {+ id: 42,+ client_name: "Example assistant",+ resource: "https://forum.example.com/mcp",+ scopes: [+ "mcp:content:read:a-very-long-permission-name-that-must-wrap",+ ],+ consented_at: "2026-08-01T10:00:00Z",+ last_used_at: null,+ token_count: 1,+ status: "active",+ },+ ],+ })+ );++ await render(+ <template>+ <div style="width: 31.25rem">+ <UserMcpAuthorizations @model={{this.model}} />+ </div>+ </template>+ );++ const applicationWidth = find(+ ".user-mcp-authorization__application"+ ).getBoundingClientRect().width;+ const statusWidth = find(+ ".user-mcp-authorization__status-cell"+ ).getBoundingClientRect().width;++ assert+ .dom(".user-mcp-authorization__permissions-toggle")+ .hasText(+ i18n("user.mcp_authorizations.permissions", { count: 1 }),+ "the permission count is shown"+ );++ await click(".user-mcp-authorization__permissions-toggle");++ assert+ .dom(".user-mcp-authorization__permissions-list")+ .includesText("mcp:content:read", "granted scopes are shown on request");+ assert+ .dom(".user-mcp-authorization__permissions-toggle")+ .hasAttribute("aria-expanded", "true", "the expanded state is exposed");+ assert.strictEqual(+ find(".user-mcp-authorization__application").getBoundingClientRect()+ .width,+ applicationWidth,+ "expanding permissions does not resize the application column"+ );+ assert.strictEqual(+ find(".user-mcp-authorization__status-cell").getBoundingClientRect()+ .width,+ statusWidth,+ "expanding permissions does not resize the status column"+ );+ });++ test("shows authorizations while the server is disabled", async function (assert) {+ this.siteSettings.mcp_server_enabled = false;+ pretender.get("/u/mcp-user/preferences/mcp-authorizations.json", () =>+ response({+ authorizations: [+ {+ id: 42,+ client_name: "Example assistant",+ scopes: ["mcp:content:read"],+ consented_at: "2026-08-01T10:00:00Z",+ last_used_at: null,+ token_count: 1,+ status: "server_disabled",+ },+ ],+ })+ );++ await render(+ <template><UserMcpAuthorizations @model={{this.model}} /></template>+ );++ assert+ .dom('.user-mcp-authorization__status[data-state="server_disabled"]')+ .hasText(+ i18n("user.mcp_authorizations.statuses.server_disabled"),+ "the temporary server state is explained"+ );+ assert+ .dom(".user-mcp-authorization__status-cell .btn-default")+ .hasText(+ i18n("user.mcp_authorizations.revoke"),+ "unusable authorizations can still be revoked"+ );+ });++ test("shows revoked authorization history", async function (assert) {+ pretender.get("/u/mcp-user/preferences/mcp-authorizations.json", () =>+ response({+ authorizations: [+ {+ id: 42,+ client_name: "Former assistant",+ scopes: ["mcp:content:read"],+ consented_at: "2026-08-01T10:00:00Z",+ last_used_at: null,+ token_count: 0,+ status: "revoked",+ },+ ],+ })+ );++ await render(+ <template><UserMcpAuthorizations @model={{this.model}} /></template>+ );++ assert+ .dom('.user-mcp-authorization__status[data-state="revoked"]')+ .hasText(+ i18n("user.mcp_authorizations.statuses.revoked"),+ "revoked authorization history remains visible"+ );+ assert+ .dom(".user-mcp-authorization__status-cell .btn-default")+ .doesNotExist("revoked authorizations have no available action");+ });++ test("quotes the application name in the revoke confirmation", async function (assert) {+ const confirm = sinon.stub(this.owner.lookup("service:dialog"), "confirm");+ pretender.get("/u/mcp-user/preferences/mcp-authorizations.json", () =>+ response({+ authorizations: [+ {+ id: 42,+ client_name: "Example assistant",+ resource: "https://forum.example.com/mcp",+ scopes: ["mcp:content:read"],+ consented_at: "2026-08-01T10:00:00Z",+ last_used_at: null,+ token_count: 1,+ status: "active",+ },+ ],+ })+ );++ await render(+ <template><UserMcpAuthorizations @model={{this.model}} /></template>+ );+ await click(".user-mcp-authorization__status-cell .btn-default");++ assert.strictEqual(+ confirm.firstCall.args[0].message,+ i18n("user.mcp_authorizations.revoke_confirm", {+ name: "Example assistant",+ }),+ "the application name is clearly delimited"+ );+ });++ test("keeps revoked authorization history visible", async function (assert) {+ const confirm = sinon.stub(this.owner.lookup("service:dialog"), "confirm");+ pretender.get("/u/mcp-user/preferences/mcp-authorizations.json", () =>+ response({+ authorizations: [+ {+ id: 42,+ client_name: "Example assistant",+ resource: "https://forum.example.com/mcp",+ scopes: ["mcp:content:read"],+ consented_at: "2026-08-01T10:00:00Z",+ last_used_at: null,+ token_count: 1,+ status: "active",+ },+ ],+ })+ );+ pretender.delete("/u/mcp-user/preferences/mcp-authorizations/42.json", () =>+ response(204)+ );++ await render(+ <template><UserMcpAuthorizations @model={{this.model}} /></template>+ );+ await click(".user-mcp-authorization__status-cell .btn-default");+ await confirm.firstCall.args[0].didConfirm();+ await settled();++ assert+ .dom('.user-mcp-authorization__status[data-state="revoked"]')+ .hasText(+ i18n("user.mcp_authorizations.statuses.revoked"),+ "the revoked authorization remains in the history"+ );+ assert+ .dom(".user-mcp-authorization__status-cell .btn-default")+ .doesNotExist("the revoked authorization has no available action");+ });+});diff --git a/lib/content_security_policy/middleware.rb b/lib/content_security_policy/middleware.rbindex 33bf6327587..c9b549507ab 100644--- a/lib/content_security_policy/middleware.rb+++ b/lib/content_security_policy/middleware.rb@@ -14,17 +14,24 @@ class ContentSecurityPolicyreturn response if headers["Content-Security-Policy"].present?return response unless html_response?(headers)+ prevent_framing = headers["X-Frame-Options"] == "DENY"+# The EnforceHostname middleware ensures request.host_with_port can be trustedprotocol = (SiteSetting.force_https || request.ssl?) ? "https://" : "http://"base_url = protocol + request.host_with_port + Discourse.base_paththeme_id = env[:resolved_theme_id]- headers["Content-Security-Policy"] = policy(- theme_id,- base_url: base_url,- path_info: env["PATH_INFO"],- ) if SiteSetting.content_security_policy+ if SiteSetting.content_security_policy || prevent_framing+ enforced_policy = policy(theme_id, base_url: base_url, path_info: env["PATH_INFO"])+ headers["Content-Security-Policy"] = (+ if prevent_framing+ policy_preventing_framing(enforced_policy)+ else+ enforced_policy+ end+ )+ endheaders["Content-Security-Policy-Report-Only"] = policy(theme_id,base_url: base_url,@@ -39,6 +46,13 @@ class ContentSecurityPolicydelegate :policy, to: :ContentSecurityPolicy+ def policy_preventing_framing(policy)+ directives = policy.split(";").map(&:strip)+ directives.reject! { |directive| directive.start_with?("frame-ancestors ") }+ directives << "frame-ancestors 'none'"+ directives.join("; ")+ end+def html_response?(headers)headers["Content-Type"] && headers["Content-Type"] =~ /html/enddiff --git a/lib/discourse_mcp.rb b/lib/discourse_mcp.rbnew file mode 100644index 00000000000..7d2c1441db4--- /dev/null+++ b/lib/discourse_mcp.rb@@ -0,0 +1,58 @@+# frozen_string_literal: true++module DiscourseMcp+ PROTOCOL_VERSION = "2026-07-28"+ LEGACY_PROTOCOL_VERSION = "2025-11-25"+ SUPPORTED_PROTOCOL_VERSIONS = [PROTOCOL_VERSION, LEGACY_PROTOCOL_VERSION].freeze+ JSONRPC_VERSION = "2.0"+ SERVER_NAME = "discourse"+ INITIAL_SCOPE = "mcp:profile:read"++ class Error < StandardError+ attr_reader :code, :data, :http_status, :headers++ def initialize(message, code: -32_000, data: nil, http_status: 400, headers: {})+ @code = code+ @data = data+ @http_status = http_status+ @headers = headers+ super(message)+ end+ end++ class ToolError < StandardError+ end++ class AuthenticationError < StandardError+ attr_reader :oauth_error++ def initialize(oauth_error = nil)+ @oauth_error = oauth_error+ super("Authorization required")+ end+ end++ class << self+ def registry+ @registry ||= Registry.new+ end++ def reset_registry!+ @registry = Registry.new+ CorePrimitives.register!+ @registry+ end++ def resource_url+ "#{Discourse.base_url}/mcp"+ end++ def issuer+ Discourse.base_url.delete_suffix("/")+ end++ def protected_resource_metadata_url+ "#{Discourse.base_url}/.well-known/oauth-protected-resource/mcp"+ end+ end+enddiff --git a/lib/discourse_mcp/access.rb b/lib/discourse_mcp/access.rbnew file mode 100644index 00000000000..a8d9e3cbdae--- /dev/null+++ b/lib/discourse_mcp/access.rb@@ -0,0 +1,57 @@+# frozen_string_literal: true++module DiscourseMcp+ class Access+ def self.eligible_scopes(user)+ eligible_scopes_by_user([user])[user&.id] || []+ end++ def self.eligible_scopes_by_user(users)+ users = Array(users).compact.uniq(&:id)+ scopes_by_user_id = users.to_h { |user| [user.id, []] }+ eligible_users = users.select { |user| user_available?(user) }+ McpGroupScope.ensure_admins! if eligible_users.any?(&:admin?)+ return scopes_by_user_id if eligible_users.blank?++ rows =+ McpGroupScope+ .joins("INNER JOIN group_users ON group_users.group_id = mcp_group_scopes.group_id")+ .where(group_users: { user_id: eligible_users.map(&:id) })+ .where(scope: DiscourseMcp.registry.scopes)+ .distinct+ .pluck("group_users.user_id", "mcp_group_scopes.scope")+ rows.each { |user_id, scope| scopes_by_user_id[user_id] << scope }+ scopes_by_user_id.each_value do |scopes|+ if scopes.present? && !scopes.include?(DiscourseMcp::INITIAL_SCOPE)+ scopes << DiscourseMcp::INITIAL_SCOPE+ end+ scopes.sort!+ end+ scopes_by_user_id+ end++ def self.user_available?(user)+ user.present? && user.active? && !user.suspended? && !user.staged?+ end++ def self.eligible_for_exposed_primitive?(user)+ return false if !SiteSetting.mcp_server_enabled++ eligible_scopes = eligible_scopes(user).to_set+ return false if eligible_scopes.empty?++ McpPrimitive+ .exposed+ .pluck(:kind, :identifier)+ .any? do |kind, identifier|+ primitive = DiscourseMcp.registry.find(kind, identifier)+ primitive&.available? &&+ primitive.required_scopes.all? { |scope| eligible_scopes.include?(scope) }+ end+ end++ def self.allowed?(user)+ eligible_scopes(user).present?+ end+ end+enddiff --git a/lib/discourse_mcp/authenticator.rb b/lib/discourse_mcp/authenticator.rbnew file mode 100644index 00000000000..06ea4666251--- /dev/null+++ b/lib/discourse_mcp/authenticator.rb@@ -0,0 +1,52 @@+# frozen_string_literal: true++module DiscourseMcp+ class Authenticator+ Challenge = Data.define(:status, :header)++ def initialize(request)+ @request = request+ end++ def authenticate!+ scheme, raw_token = request.authorization.to_s.split(" ", 2)+ raise AuthenticationError if scheme.blank? && raw_token.blank?+ if !scheme.to_s.casecmp?("Bearer") || raw_token.blank?+ raise AuthenticationError.new("invalid_token")+ end++ token = McpOauthAccessToken.usable.find_by(token_hash: McpOauthAccessToken.digest(raw_token))+ raise AuthenticationError.new("invalid_token") if token.blank?++ authorization = token.authorization+ client = token.client+ authorization_status =+ AuthorizationStatus.for(+ [authorization],+ scopes_by_authorization_id: {+ authorization.id => token.scopes,+ },+ ).fetch(authorization.id)+ valid =+ token.resource == DiscourseMcp.resource_url && authorization.active? &&+ token.grant_version == authorization.grant_version &&+ (token.scopes - authorization.scopes).empty? && client == authorization.client &&+ token.user_id == authorization.user_id && authorization_status == "active"+ raise AuthenticationError.new("invalid_token") if !valid++ token.touch_last_used!+ RequestContext.new(token)+ end++ def self.challenge(scope: nil, error: nil)+ values = [%(resource_metadata="#{DiscourseMcp.protected_resource_metadata_url}")]+ values << %(scope="#{scope}") if scope.present?+ values << %(error="#{error}") if error.present?+ "Bearer #{values.join(", ")}"+ end++ private++ attr_reader :request+ end+enddiff --git a/lib/discourse_mcp/authorization_status.rb b/lib/discourse_mcp/authorization_status.rbnew file mode 100644index 00000000000..8f18f55ade6--- /dev/null+++ b/lib/discourse_mcp/authorization_status.rb@@ -0,0 +1,75 @@+# frozen_string_literal: true++module DiscourseMcp+ class AuthorizationStatus+ def self.for(authorizations, scopes_by_authorization_id: {})+ authorizations = Array(authorizations)+ return {} if authorizations.empty?++ eligible_scopes_by_user_id = Access.eligible_scopes_by_user(authorizations.map(&:user))+ requirements = consent_requirements++ authorizations.to_h do |authorization|+ required_scopes =+ scopes_by_authorization_id.fetch(authorization.id) { authorization.scopes }+ status =+ new(+ authorization,+ eligible_scopes: eligible_scopes_by_user_id.fetch(authorization.user_id, []),+ consent_required_at:+ consent_required_at(requirements, required_scopes: required_scopes),+ required_scopes: required_scopes,+ ).status+ [authorization.id, status]+ end+ end++ def self.consent_requirements+ McpPrimitive+ .where.not(consent_required_at: nil)+ .filter_map do |policy|+ primitive = DiscourseMcp.registry.find(policy.kind, policy.identifier)+ [primitive.required_scopes, policy.consent_required_at] if primitive.present?+ end+ end++ def self.consent_required_at(consent_requirements, required_scopes:)+ consent_requirements+ .filter_map do |scopes, required_at|+ required_at if scopes.empty? || (scopes - required_scopes).empty?+ end+ .max+ end++ private_class_method :consent_requirements, :consent_required_at++ def initialize(authorization, eligible_scopes:, consent_required_at:, required_scopes:)+ @authorization = authorization+ @eligible_scopes = eligible_scopes+ @consent_required_at = consent_required_at+ @required_scopes = required_scopes+ end++ def status+ return "revoked" if authorization.status == "revoked" || authorization.revoked_at.present?+ return "consent_required" if authorization.status == "consent_required"+ return "server_disabled" if !SiteSetting.mcp_server_enabled+ return "user_unavailable" if !Access.user_available?(authorization.user)+ return "client_blocked" if authorization.client.blocked?+ if !OAuth::ClientResolver.allowed_by_current_policy?(authorization.client)+ return "client_not_approved"+ end+ if authorization.client_metadata_hash != authorization.client.metadata_hash ||+ !authorization.consent_current?(consent_required_at: consent_required_at)+ return "consent_required"+ end+ return "access_removed" if (required_scopes - eligible_scopes).present?++ "active"+ end++ private++ attr_reader :authorization, :eligible_scopes, :consent_required_at, :required_scopes+ end+enddiff --git a/lib/discourse_mcp/catalog.rb b/lib/discourse_mcp/catalog.rbnew file mode 100644index 00000000000..6397a8953e8--- /dev/null+++ b/lib/discourse_mcp/catalog.rb@@ -0,0 +1,34 @@+# frozen_string_literal: true++module DiscourseMcp+ class Catalog+ def initialize(request_context:)+ @request_context = request_context+ end++ def list(kind)+ exposed(kind).select { |primitive| request_context.has_scopes?(primitive.required_scopes) }+ end++ def find(kind, identifier)+ list(kind).find { |primitive| primitive.identifier == identifier.to_s }+ end++ def find_exposed(kind, identifier)+ exposed(kind).find { |primitive| primitive.identifier == identifier.to_s }+ end++ private++ attr_reader :request_context++ def exposed(kind)+ policies = McpPrimitive.exposed.where(kind: kind.to_s).pluck(:identifier).to_set++ DiscourseMcp+ .registry+ .all(kind)+ .select { |primitive| policies.include?(primitive.identifier) && primitive.available? }+ end+ end+enddiff --git a/lib/discourse_mcp/core_primitives.rb b/lib/discourse_mcp/core_primitives.rbnew file mode 100644index 00000000000..0af07b1dc31--- /dev/null+++ b/lib/discourse_mcp/core_primitives.rb@@ -0,0 +1,441 @@+# frozen_string_literal: true++module DiscourseMcp+ module CorePrimitives+ READ_ONLY = {+ readOnlyHint: true,+ destructiveHint: false,+ idempotentHint: true,+ openWorldHint: false,+ }.freeze+ WRITE = {+ readOnlyHint: false,+ destructiveHint: false,+ idempotentHint: false,+ openWorldHint: false,+ }.freeze+ DESTRUCTIVE = {+ readOnlyHint: false,+ destructiveHint: true,+ idempotentHint: false,+ openWorldHint: false,+ }.freeze++ module_function++ def object_schema(properties = {}, required: [])+ { type: "object", properties: properties, required: required, additionalProperties: false }+ end++ def register!+ registry = DiscourseMcp.registry+ register_read_tools(registry)+ register_write_tools(registry)+ register_resources(registry)+ register_prompts(registry)+ end++ def register_read_tools(registry)+ registry.register_tool(+ "discourse_current_user_get",+ title: "Get current user",+ description:+ "Returns the authenticated Discourse user, granted scopes, and MCP server URI.",+ implementation: Tools::CurrentUser,+ required_scopes: [DiscourseMcp::INITIAL_SCOPE],+ annotations: READ_ONLY,+ )+ registry.register_tool(+ "discourse_search",+ title: "Search Discourse",+ description:+ "Searches topics and posts visible to the authenticated user using Discourse search syntax.",+ implementation: Tools::Search,+ input_schema:+ object_schema(+ {+ query: {+ type: "string",+ minLength: 1,+ maxLength: 500,+ },+ limit: {+ type: "integer",+ minimum: 1,+ maximum: 50,+ },+ },+ required: %w[query],+ ),+ required_scopes: %w[mcp:content:read],+ annotations: READ_ONLY,+ )+ registry.register_tool(+ "discourse_topic_get",+ title: "Get topic",+ description: "Reads a topic and a bounded set of posts visible to the authenticated user.",+ implementation: Tools::GetTopic,+ input_schema:+ object_schema(+ {+ topic_id: {+ type: "integer",+ minimum: 1,+ },+ post_limit: {+ type: "integer",+ minimum: 1,+ maximum: 100,+ },+ },+ required: %w[topic_id],+ ),+ required_scopes: %w[mcp:content:read],+ annotations: READ_ONLY,+ )+ registry.register_tool(+ "discourse_post_get",+ title: "Get post",+ description: "Reads one visible post.",+ implementation: Tools::GetPost,+ input_schema:+ object_schema({ post_id: { type: "integer", minimum: 1 } }, required: %w[post_id]),+ required_scopes: %w[mcp:content:read],+ annotations: READ_ONLY,+ )+ registry.register_tool(+ "discourse_topic_list",+ title: "List topics",+ description: "Lists recent topics visible to the authenticated user.",+ implementation: Tools::ListTopics,+ input_schema: object_schema({ limit: { type: "integer", minimum: 1, maximum: 50 } }),+ required_scopes: %w[mcp:content:read],+ annotations: READ_ONLY,+ )+ registry.register_tool(+ "discourse_category_list",+ title: "List categories",+ description: "Lists the visible category hierarchy.",+ implementation: Tools::ListCategories,+ required_scopes: %w[mcp:content:read],+ annotations: READ_ONLY,+ )+ registry.register_tool(+ "discourse_tag_list",+ title: "List tags",+ description: "Lists visible tags ordered by usage.",+ implementation: Tools::ListTags,+ input_schema: object_schema({ limit: { type: "integer", minimum: 1, maximum: 200 } }),+ required_scopes: %w[mcp:content:read],+ annotations: READ_ONLY,+ )+ registry.register_tool(+ "discourse_user_get",+ title: "Get user",+ description: "Reads a user profile visible to the authenticated user.",+ implementation: Tools::GetUser,+ input_schema:+ object_schema(+ { username: { type: "string", minLength: 1, maxLength: 60 } },+ required: %w[username],+ ),+ required_scopes: %w[mcp:content:read],+ annotations: READ_ONLY,+ )+ registry.register_tool(+ "discourse_bookmark_list",+ title: "List bookmarks",+ description: "Lists the authenticated user's bookmarks.",+ implementation: Tools::ListBookmarks,+ input_schema: object_schema({ limit: { type: "integer", minimum: 1, maximum: 100 } }),+ required_scopes: %w[mcp:content:read],+ annotations: READ_ONLY,+ )+ registry.register_tool(+ "discourse_notification_list",+ title: "List notifications",+ description: "Lists the authenticated user's notifications.",+ implementation: Tools::ListNotifications,+ input_schema: object_schema({ limit: { type: "integer", minimum: 1, maximum: 100 } }),+ required_scopes: %w[mcp:content:read],+ annotations: READ_ONLY,+ )+ end++ def register_write_tools(registry)+ registry.register_tool(+ "discourse_topic_create",+ title: "Create topic",+ description: "Creates a topic as the authenticated user.",+ implementation: Tools::CreateTopic,+ input_schema:+ object_schema(+ {+ title: {+ type: "string",+ minLength: 1,+ },+ raw: {+ type: "string",+ minLength: 1,+ },+ category_id: {+ type: "integer",+ },+ tags: {+ type: "array",+ items: {+ type: "string",+ },+ maxItems: 10,+ },+ },+ required: %w[title raw],+ ),+ required_scopes: %w[mcp:content:write],+ annotations: WRITE,+ risk: :write,+ )+ registry.register_tool(+ "discourse_topic_reply",+ title: "Reply to topic",+ description: "Replies to a topic as the authenticated user.",+ implementation: Tools::ReplyTopic,+ input_schema:+ object_schema(+ {+ topic_id: {+ type: "integer",+ minimum: 1,+ },+ raw: {+ type: "string",+ minLength: 1,+ },+ reply_to_post_number: {+ type: "integer",+ minimum: 1,+ },+ },+ required: %w[topic_id raw],+ ),+ required_scopes: %w[mcp:content:write],+ annotations: WRITE,+ risk: :write,+ )+ registry.register_tool(+ "discourse_post_edit",+ title: "Edit post",+ description: "Edits a post when the authenticated user has permission.",+ implementation: Tools::EditPost,+ input_schema:+ object_schema(+ {+ post_id: {+ type: "integer",+ minimum: 1,+ },+ raw: {+ type: "string",+ minLength: 1,+ },+ edit_reason: {+ type: "string",+ maxLength: 200,+ },+ },+ required: %w[post_id raw],+ ),+ required_scopes: %w[mcp:content:write],+ annotations: WRITE,+ risk: :write,+ )+ registry.register_tool(+ "discourse_post_set_deleted",+ title: "Delete or recover own post",+ description: "Deletes or recovers a post owned by the authenticated user.",+ implementation: Tools::SetPostDeleted,+ input_schema:+ object_schema(+ { post_id: { type: "integer", minimum: 1 }, deleted: { type: "boolean" } },+ required: %w[post_id deleted],+ ),+ required_scopes: %w[mcp:content:write],+ annotations: DESTRUCTIVE,+ risk: :destructive,+ )+ registry.register_tool(+ "discourse_user_status_set",+ title: "Set user status",+ description: "Sets or clears the authenticated user's status.",+ implementation: Tools::SetUserStatus,+ input_schema:+ object_schema(+ {+ clear: {+ type: "boolean",+ },+ description: {+ type: "string",+ maxLength: 100,+ },+ emoji: {+ type: "string",+ maxLength: 100,+ },+ ends_at: {+ type: "string",+ format: "date-time",+ },+ },+ ).merge(+ oneOf: [+ { properties: { clear: { const: true } }, required: %w[clear] },+ { properties: { clear: { enum: [false] } }, required: %w[description emoji] },+ ],+ ),+ required_scopes: %w[mcp:content:write],+ annotations: WRITE,+ risk: :write,+ availability: -> { SiteSetting.enable_user_status },+ )+ end++ def register_resources(registry)+ registry.register_resource_template(+ "discourse.topic",+ title: "Discourse topic",+ description: "A topic visible to the authenticated user.",+ implementation: Resources::Topic,+ input_schema:+ object_schema(+ { uri: { type: "string", pattern: "\\Adiscourse://topic/[0-9]+\\z" } },+ required: %w[uri],+ ),+ required_scopes: %w[mcp:content:read],+ annotations: READ_ONLY,+ )+ registry.register_resource_template(+ "discourse.post",+ title: "Discourse post",+ description: "A post visible to the authenticated user.",+ implementation: Resources::Post,+ input_schema:+ object_schema(+ { uri: { type: "string", pattern: "\\Adiscourse://post/[0-9]+\\z" } },+ required: %w[uri],+ ),+ required_scopes: %w[mcp:content:read],+ annotations: READ_ONLY,+ )+ end++ def register_prompts(registry)+ registry.register_prompt(+ "discourse.research_topic",+ title: "Research discussions",+ description: "Builds a prompt for researching visible Discourse discussions.",+ implementation: Prompts::ResearchTopic,+ input_schema:+ object_schema(+ { question: { type: "string", minLength: 1, maxLength: 1000 } },+ required: %w[question],+ ),+ required_scopes: %w[mcp:content:read],+ annotations: READ_ONLY,+ )+ registry.register_prompt(+ "discourse.draft_reply",+ title: "Draft a reply",+ description: "Builds a prompt for drafting a grounded reply to a visible topic.",+ implementation: Prompts::DraftReply,+ input_schema:+ object_schema(+ {+ topic_id: {+ type: "integer",+ minimum: 1,+ },+ instructions: {+ type: "string",+ maxLength: 1000,+ },+ },+ required: %w[topic_id],+ ),+ required_scopes: %w[mcp:content:read],+ annotations: READ_ONLY,+ )+ end+ end++ module Resources+ class Topic+ def self.call(uri:, request_context:)+ id = uri.delete_prefix("discourse://topic/").to_i+ topic = ::Topic.find_by(id: id)+ if topic.blank? || !request_context.guardian.can_see?(topic)+ raise ToolError, "Resource not found"+ end+ {+ uri: uri,+ mimeType: "application/json",+ text: JSON.generate(ToolHelpers.topic_json(topic)),+ }+ end+ end++ class Post+ def self.call(uri:, request_context:)+ id = uri.delete_prefix("discourse://post/").to_i+ post = ::Post.secured(request_context.guardian).find_by(id: id)+ if post.blank? || !request_context.guardian.can_see?(post)+ raise ToolError, "Resource not found"+ end+ { uri: uri, mimeType: "application/json", text: JSON.generate(ToolHelpers.post_json(post)) }+ end+ end+ end++ module Prompts+ class ResearchTopic+ def self.call(arguments:, request_context:)+ {+ description: "Research visible Discourse discussions",+ messages: [+ {+ role: "user",+ content: {+ type: "text",+ text:+ "Research this question using Discourse search and topic resources. Cite canonical topic and post URLs: #{arguments.fetch("question")}",+ },+ },+ ],+ }+ end+ end++ class DraftReply+ def self.call(arguments:, request_context:)+ topic = ::Topic.find_by(id: arguments.fetch("topic_id").to_i)+ if topic.blank? || !request_context.guardian.can_see?(topic)+ raise ToolError, "Topic not found"+ end+ {+ description: "Draft a reply to #{topic.title}",+ messages: [+ {+ role: "user",+ content: {+ type: "text",+ text:+ "Read discourse://topic/#{topic.id} and draft a helpful reply. Do not post it. #{arguments["instructions"]}",+ },+ },+ ],+ }+ end+ end+ end+enddiff --git a/lib/discourse_mcp/core_tools.rb b/lib/discourse_mcp/core_tools.rbnew file mode 100644index 00000000000..9ec246cb7eb--- /dev/null+++ b/lib/discourse_mcp/core_tools.rb@@ -0,0 +1,295 @@+# frozen_string_literal: true++module DiscourseMcp+ module ToolHelpers+ module_function++ def text_and_structured(value)+ {+ content: [{ type: "text", text: JSON.generate(value) }],+ structuredContent: value,+ isError: false,+ }+ end++ def post_json(post)+ {+ id: post.id,+ topic_id: post.topic_id,+ post_number: post.post_number,+ username: post.username,+ raw: post.raw,+ created_at: post.created_at.iso8601,+ updated_at: post.updated_at.iso8601,+ url: post.full_url,+ }+ end++ def topic_json(topic)+ {+ id: topic.id,+ title: topic.title,+ slug: topic.slug,+ category_id: topic.category_id,+ tags: topic.tags.map(&:name),+ posts_count: topic.posts_count,+ created_at: topic.created_at.iso8601,+ last_posted_at: topic.last_posted_at&.iso8601,+ closed: topic.closed,+ archived: topic.archived,+ url: topic.url,+ }+ end+ end++ module Tools+ class CurrentUser+ def self.call(arguments:, request_context:)+ user = request_context.user or raise Discourse::InvalidAccess+ ToolHelpers.text_and_structured(+ id: user.id,+ username: user.username,+ name: user.name,+ trust_level: user.trust_level,+ admin: user.admin,+ moderator: user.moderator,+ scopes: request_context.scopes.to_a.sort,+ resource: DiscourseMcp.resource_url,+ )+ end+ end++ class Search+ def self.call(arguments:, request_context:)+ query = arguments.fetch("query").to_s+ limit = arguments.fetch("limit", 20).to_i.clamp(1, 50)+ results = ::Search.execute(query, guardian: request_context.guardian)+ posts = results.posts.first(limit).map { |post| ToolHelpers.post_json(post) }+ ToolHelpers.text_and_structured(query: query, posts: posts)+ end+ end++ class GetTopic+ def self.call(arguments:, request_context:)+ topic = Topic.find_by(id: arguments.fetch("topic_id").to_i)+ if topic.blank? || !request_context.guardian.can_see?(topic)+ raise DiscourseMcp::ToolError, "Topic not found"+ end++ limit = arguments.fetch("post_limit", 50).to_i.clamp(1, 100)+ posts =+ Post+ .secured(request_context.guardian)+ .where(topic_id: topic.id)+ .order(:post_number)+ .limit(limit)+ ToolHelpers.text_and_structured(+ topic: ToolHelpers.topic_json(topic),+ posts: posts.map { |post| ToolHelpers.post_json(post) },+ )+ end+ end++ class GetPost+ def self.call(arguments:, request_context:)+ post = Post.secured(request_context.guardian).find_by(id: arguments.fetch("post_id").to_i)+ if post.blank? || !request_context.guardian.can_see?(post)+ raise DiscourseMcp::ToolError, "Post not found"+ end++ ToolHelpers.text_and_structured(post: ToolHelpers.post_json(post))+ end+ end++ class ListTopics+ def self.call(arguments:, request_context:)+ limit = arguments.fetch("limit", 30).to_i.clamp(1, 50)+ topics = TopicQuery.new(request_context.user).list_latest.topics.first(limit)+ ActiveRecord::Associations::Preloader.new(records: topics, associations: :tags).call+ ToolHelpers.text_and_structured(+ topics: topics.map { |topic| ToolHelpers.topic_json(topic) },+ )+ end+ end++ class ListCategories+ def self.call(arguments:, request_context:)+ categories = Category.secured(request_context.guardian).order(:position, :id).limit(500)+ ToolHelpers.text_and_structured(+ categories:+ categories.map do |category|+ {+ id: category.id,+ name: category.name,+ slug: category.slug,+ parent_category_id: category.parent_category_id,+ topic_count: category.topic_count,+ }+ end,+ )+ end+ end++ class ListTags+ def self.call(arguments:, request_context:)+ column = Tag.topic_count_column(request_context.guardian)+ tags = Tag.order(column => :desc).limit(arguments.fetch("limit", 100).to_i.clamp(1, 200))+ visible = DiscourseTagging.filter_visible(tags, request_context.guardian)+ ToolHelpers.text_and_structured(+ tags:+ visible.map do |tag|+ { id: tag.id, name: tag.name, topic_count: tag.public_send(column) }+ end,+ )+ end+ end++ class GetUser+ def self.call(arguments:, request_context:)+ user = User.find_by_username(arguments.fetch("username"))+ if user.blank? || !request_context.guardian.can_see_profile?(user)+ raise DiscourseMcp::ToolError, "User not found"+ end++ details = {+ id: user.id,+ username: user.username,+ trust_level: user.trust_level,+ created_at: user.created_at.iso8601,+ }+ details[:name] = user.name if SiteSetting.enable_names?+ ToolHelpers.text_and_structured(user: details)+ end+ end++ class ListBookmarks+ def self.call(arguments:, request_context:)+ bookmarks =+ Bookmark+ .where(user_id: request_context.user_id)+ .includes(:bookmarkable)+ .order(updated_at: :desc)+ .limit(arguments.fetch("limit", 50).to_i.clamp(1, 100))+ values =+ bookmarks.filter_map do |bookmark|+ bookmarkable = bookmark.bookmarkable+ next if bookmarkable.blank? || !request_context.guardian.can_see?(bookmarkable)+ {+ id: bookmark.id,+ name: bookmark.name,+ reminder_at: bookmark.reminder_at&.iso8601,+ bookmarkable_type: bookmark.bookmarkable_type,+ bookmarkable_id: bookmark.bookmarkable_id,+ }+ end+ ToolHelpers.text_and_structured(bookmarks: values)+ end+ end++ class ListNotifications+ def self.call(arguments:, request_context:)+ limit = arguments.fetch("limit", 50).to_i.clamp(1, 100)+ notifications =+ Notification+ .where(user_id: request_context.user_id)+ .visible+ .includes(:topic)+ .order(id: :desc)+ .limit(limit)+ notifications =+ Notification.filter_inaccessible_topic_notifications(+ request_context.guardian,+ notifications,+ )+ notifications = Notification.filter_disabled_badge_notifications(notifications)+ notifications = Notification.populate_acting_user(notifications)+ serialized =+ notifications.map do |notification|+ NotificationSerializer.new(+ notification,+ scope: request_context.guardian,+ root: false,+ ).as_json+ end+ ToolHelpers.text_and_structured(notifications: serialized)+ end+ end++ class CreateTopic+ def self.call(arguments:, request_context:)+ post =+ PostCreator.create!(+ request_context.user,+ title: arguments.fetch("title"),+ raw: arguments.fetch("raw"),+ category: arguments["category_id"],+ tags: Array(arguments["tags"]),+ skip_validations: false,+ )+ ToolHelpers.text_and_structured(+ post: ToolHelpers.post_json(post),+ topic: ToolHelpers.topic_json(post.topic),+ )+ end+ end++ class ReplyTopic+ def self.call(arguments:, request_context:)+ post =+ PostCreator.create!(+ request_context.user,+ topic_id: arguments.fetch("topic_id"),+ raw: arguments.fetch("raw"),+ reply_to_post_number: arguments["reply_to_post_number"],+ )+ ToolHelpers.text_and_structured(post: ToolHelpers.post_json(post))+ end+ end++ class EditPost+ def self.call(arguments:, request_context:)+ post = Post.find_by(id: arguments.fetch("post_id").to_i)+ if post.blank? || !request_context.guardian.can_edit_post?(post)+ raise DiscourseMcp::ToolError, "Post not found"+ end++ fields = { raw: arguments.fetch("raw") }+ fields[:edit_reason] = arguments["edit_reason"] if arguments["edit_reason"].present?+ PostRevisor.new(post, post.topic).revise!(request_context.user, fields)+ ToolHelpers.text_and_structured(post: ToolHelpers.post_json(post.reload))+ end+ end++ class SetPostDeleted+ def self.call(arguments:, request_context:)+ post = Post.find_by(id: arguments.fetch("post_id").to_i, user_id: request_context.user_id)+ raise DiscourseMcp::ToolError, "Post not found" if post.blank?++ if arguments.fetch("deleted")+ raise Discourse::InvalidAccess if !request_context.guardian.can_delete_post?(post)+ PostDestroyer.new(request_context.user, post).destroy+ else+ raise Discourse::InvalidAccess if !request_context.guardian.can_recover_post?(post)+ PostDestroyer.new(request_context.user, post).recover+ end+ ToolHelpers.text_and_structured(post_id: post.id, deleted: arguments.fetch("deleted"))+ end+ end++ class SetUserStatus+ def self.call(arguments:, request_context:)+ user = request_context.user or raise Discourse::InvalidAccess+ if arguments.fetch("clear", false)+ user.clear_status!+ else+ user.set_status!(+ arguments.fetch("description"),+ arguments.fetch("emoji"),+ arguments["ends_at"],+ )+ end+ ToolHelpers.text_and_structured(success: true)+ end+ end+ end+enddiff --git a/lib/discourse_mcp/oauth.rb b/lib/discourse_mcp/oauth.rbnew file mode 100644index 00000000000..0a53050e005--- /dev/null+++ b/lib/discourse_mcp/oauth.rb@@ -0,0 +1,390 @@+# frozen_string_literal: true++module DiscourseMcp+ module OAuth+ class ClientResolver+ MAX_METADATA_BYTES = 64.kilobytes+ METADATA_CACHE_TTL = 1.hour+ METADATA_REQUESTS_PER_MINUTE = 10+ METADATA_HOST_REQUESTS_PER_MINUTE = 30++ def self.resolve!(client_id, force: false, user:)+ existing = McpOauthClient.find_by(client_id: client_id)+ raise Discourse::InvalidAccess if existing&.blocked?+ return existing if existing&.registration_type == "pre_registered" && existing.approved?+ if SiteSetting.mcp_oauth_client_id_metadata_policy == "disabled"+ raise Discourse::InvalidAccess+ end++ uri = URI.parse(client_id.to_s)+ raise Discourse::InvalidAccess if !valid_client_id_uri?(uri)+ if SiteSetting.mcp_oauth_client_id_metadata_policy == "approved_domains" &&+ !approved_domain?(uri.host)+ raise Discourse::InvalidAccess+ end+ return existing if !force && existing&.approved? && existing.metadata_expires_at&.future?++ enforce_rate_limits!(user, uri.host)+ metadata = fetch_metadata(uri)+ validate_metadata!(metadata, client_id)+ redirect_uris = metadata["redirect_uris"]+ metadata_hash = Digest::SHA256.hexdigest(JSON.generate(canonicalize(metadata)))+ trust_state = trust_state_for(uri.host)+ client = existing || McpOauthClient.new(client_id: client_id)+ previous_hash = client.metadata_hash++ McpOauthClient.transaction do+ client.assign_attributes(+ name: metadata["client_name"].presence || uri.host,+ registration_type: "cimd",+ trust_state: trust_state,+ metadata_uri: client_id,+ metadata_hash: metadata_hash,+ metadata_expires_at: METADATA_CACHE_TTL.from_now,+ metadata: metadata,+ redirect_uris: redirect_uris,+ last_seen_at: Time.zone.now,+ )+ client.save!+ if previous_hash.present? && previous_hash != metadata_hash+ client.authorizations.active.find_each do |authorization|+ authorization.update!(status: "consent_required")+ authorization+ .access_tokens+ .where(revoked_at: nil)+ .update_all(revoked_at: Time.zone.now)+ authorization+ .refresh_tokens+ .where(revoked_at: nil)+ .update_all(revoked_at: Time.zone.now)+ end+ end+ end+ raise Discourse::InvalidAccess if !client.approved?+ client+ rescue URI::InvalidURIError,+ JSON::ParserError,+ FinalDestination::SSRFError,+ SocketError,+ Net::OpenTimeout,+ Net::ReadTimeout+ raise Discourse::InvalidAccess+ end++ def self.allowed_by_current_policy?(client)+ return client.approved? if client.registration_type == "pre_registered"+ return false if client.registration_type != "cimd" || !client.approved?++ case SiteSetting.mcp_oauth_client_id_metadata_policy+ when "any_domain"+ true+ when "approved_domains"+ approved_domain?(URI.parse(client.client_id).host)+ else+ false+ end+ rescue URI::InvalidURIError+ false+ end++ def self.revoke_disallowed_clients!+ McpOauthClient+ .where(registration_type: "cimd", trust_state: "approved")+ .in_batches do |clients|+ disallowed_ids =+ clients.select { |client| !allowed_by_current_policy?(client) }.map(&:id)+ next if disallowed_ids.empty?++ McpOauthClient.transaction do+ McpOauthAuthorization.require_consent!(client_ids: disallowed_ids)+ McpOauthClient.where(id: disallowed_ids).update_all(+ trust_state: "pending",+ updated_at: Time.zone.now,+ )+ end+ end+ end++ def self.valid_client_id_uri?(uri)+ path_has_dot_segment =+ uri.path.split("/", -1).any? { |segment| %w[. ..].include?(segment.gsub(/%2e/i, ".")) }+ uri.scheme == "https" && uri.host.present? && uri.userinfo.blank? && uri.fragment.blank? &&+ uri.path.present? && uri.path != "/" && !path_has_dot_segment+ end+ private_class_method :valid_client_id_uri?++ def self.enforce_rate_limits!(user, host)+ normalized_host = host.downcase.delete_suffix(".")+ RateLimiter.new(+ user,+ "mcp-cimd-metadata",+ METADATA_REQUESTS_PER_MINUTE,+ 1.minute,+ apply_limit_to_staff: true,+ ).performed!+ RateLimiter.new(+ nil,+ "mcp-cimd-metadata-host-#{Digest::SHA256.hexdigest(normalized_host)}",+ METADATA_HOST_REQUESTS_PER_MINUTE,+ 1.minute,+ apply_limit_to_staff: true,+ ).performed!+ end+ private_class_method :enforce_rate_limits!++ def self.fetch_metadata(uri)+ body = +""+ status = nil+ content_type = nil+ FinalDestination+ .new(uri.to_s, validate_uri: true, max_redirects: 3, timeout: 5)+ .get do |response, chunk, _resolved_uri|+ status = response.code.to_i+ content_type = response["Content-Type"]+ body << chunk if chunk+ raise Discourse::InvalidAccess if body.bytesize > MAX_METADATA_BYTES+ end+ if status != 200 || !content_type.to_s.match?(%r{\Aapplication/(?:[a-z0-9.+-]+\+)?json\b}i)+ raise Discourse::InvalidAccess+ end++ parsed = JSON.parse(body)+ raise Discourse::InvalidAccess if !parsed.is_a?(Hash)+ parsed+ end+ private_class_method :fetch_metadata++ def self.validate_metadata!(metadata, client_id)+ redirect_uris = metadata["redirect_uris"]+ valid =+ metadata["client_id"] == client_id && metadata["client_name"].is_a?(String) &&+ metadata["client_name"].bytesize <= 255 && redirect_uris.is_a?(Array) &&+ redirect_uris.present? && redirect_uris.length <= 20 &&+ metadata.fetch("token_endpoint_auth_method", "none") == "none" &&+ !metadata.key?("client_secret") && !metadata.key?("client_secret_expires_at") &&+ redirect_uris.all? do |value|+ value.is_a?(String) && McpOauthClient.valid_redirect_uri?(value)+ end+ raise Discourse::InvalidAccess if !valid+ end+ private_class_method :validate_metadata!++ def self.canonicalize(value)+ case value+ when Hash+ value.keys.sort.to_h { |key| [key, canonicalize(value[key])] }+ when Array+ value.map { |item| canonicalize(item) }+ else+ value+ end+ end+ private_class_method :canonicalize++ def self.trust_state_for(host)+ case SiteSetting.mcp_oauth_client_id_metadata_policy+ when "any_domain"+ "approved"+ when "approved_domains"+ approved_domain?(host) ? "approved" : "pending"+ else+ "pending"+ end+ end+ private_class_method :trust_state_for++ def self.approved_domain?(host)+ SiteSetting+ .mcp_oauth_client_id_metadata_domains+ .split("|")+ .any? { |domain| domain.casecmp?(host) }+ end+ private_class_method :approved_domain?+ end++ class AuthorizationGrant+ def self.grantable_scopes(user:, requested_scopes:)+ scopes = Array(requested_scopes).map(&:to_s).uniq+ raise Discourse::InvalidAccess if !scopes.include?(DiscourseMcp::INITIAL_SCOPE)++ scopes & DiscourseMcp::Access.eligible_scopes(user)+ end++ def self.create!(user:, client:, redirect_uri:, requested_scopes:)+ if !SiteSetting.mcp_server_enabled || !DiscourseMcp::Access.allowed?(user)+ raise Discourse::InvalidAccess+ end+ if !ClientResolver.allowed_by_current_policy?(client) ||+ !client.allows_redirect_uri?(redirect_uri)+ raise Discourse::InvalidAccess+ end++ scopes = grantable_scopes(user:, requested_scopes:)++ authorization =+ McpOauthAuthorization.find_or_initialize_by(user: user, client: client, revoked_at: nil)+ McpOauthAuthorization.transaction do+ authorization.lock! if authorization.persisted?+ if authorization.persisted?+ authorization.access_tokens.where(revoked_at: nil).update_all(revoked_at: Time.zone.now)+ authorization+ .refresh_tokens+ .where(revoked_at: nil)+ .update_all(revoked_at: Time.zone.now)+ authorization.grant_version += 1+ end+ authorization.assign_attributes(+ resource: DiscourseMcp.resource_url,+ status: "active",+ client_metadata_hash: client.metadata_hash,+ consented_at: Time.zone.now,+ )+ authorization.save!+ authorization.scope_records.delete_all+ scopes.each { |scope| authorization.scope_records.create!(name: scope) }+ end+ authorization+ end+ end++ class TokenIssuer+ PKCE_VERIFIER_PATTERN = /\A[A-Za-z0-9\-._~]{43,128}\z/++ def self.exchange_code!(code:, client_id:, redirect_uri:, code_verifier:, resource:)+ code_record =+ McpOauthAuthorizationCode.find_by(code_hash: McpOauthAuthorizationCode.digest(code))+ raise Discourse::InvalidAccess if code_record.blank?++ access_token = nil+ refresh_token = nil+ scopes = nil+ code_record.with_lock do+ if code_record.consumed_at.present? || code_record.expires_at <= Time.zone.now+ raise Discourse::InvalidAccess+ end++ authorization = code_record.authorization+ raise Discourse::InvalidAccess if authorization.blank?+ raise Discourse::InvalidAccess if authorization.client.client_id != client_id+ raise Discourse::InvalidAccess if code_record.redirect_uri != redirect_uri+ if code_record.resource != resource || resource != DiscourseMcp.resource_url+ raise Discourse::InvalidAccess+ end+ if !secure_compare_challenge(code_record.code_challenge, code_verifier)+ raise Discourse::InvalidAccess+ end+ validate_authorization!(+ authorization,+ scopes: code_record.scopes,+ grant_version: code_record.grant_version,+ )++ scopes = code_record.scopes+ code_record.update!(consumed_at: Time.zone.now)+ access_token = McpOauthAccessToken.issue!(authorization: authorization, scopes: scopes)+ refresh_token, = McpOauthRefreshToken.issue!(authorization: authorization, scopes: scopes)+ end+ token_response(access_token, refresh_token, scopes)+ end++ def self.refresh!(refresh_token:, client_id:, resource:, requested_scopes: nil)+ record =+ McpOauthRefreshToken.find_by(token_hash: McpOauthRefreshToken.digest(refresh_token))+ raise Discourse::InvalidAccess if record.blank?++ replayed = false+ access_token = nil+ new_refresh_token = nil+ scopes = nil+ record.with_lock do+ if record.consumed_at.present?+ record.revoke_family!+ replayed = true+ next+ end++ if record.revoked_at.present? || record.expires_at <= Time.zone.now+ raise Discourse::InvalidAccess+ end+ authorization = record.authorization+ if authorization.client.client_id != client_id || authorization.resource != resource+ raise Discourse::InvalidAccess+ end++ scopes =+ (+ if requested_scopes.present?+ Array(requested_scopes).map(&:to_s).uniq+ else+ record.scopes+ end+ )+ if !scopes.include?(DiscourseMcp::INITIAL_SCOPE) || (scopes - record.scopes).present?+ raise Discourse::InvalidAccess+ end+ validate_authorization!(+ authorization,+ scopes: scopes,+ grant_version: record.grant_version,+ )++ access_token = McpOauthAccessToken.issue!(authorization: authorization, scopes: scopes)+ new_refresh_token, =+ McpOauthRefreshToken.issue!(+ authorization: authorization,+ scopes: scopes,+ family_id: record.family_id,+ parent: record,+ )+ end+ raise Discourse::InvalidAccess if replayed++ token_response(access_token, new_refresh_token, scopes)+ end++ def self.revoke!(token)+ digest = McpOauthAccessToken.digest(token)+ access = McpOauthAccessToken.find_by(token_hash: digest)+ return access.update!(revoked_at: Time.zone.now) if access++ refresh = McpOauthRefreshToken.find_by(token_hash: digest)+ refresh&.revoke_family!+ end++ def self.token_response(access_token, refresh_token, scopes)+ {+ access_token: access_token,+ token_type: "Bearer",+ expires_in: SiteSetting.mcp_access_token_lifetime_minutes.minutes.to_i,+ refresh_token: refresh_token,+ scope: scopes.join(" "),+ }+ end+ private_class_method :token_response++ def self.validate_authorization!(authorization, scopes:, grant_version:)+ status =+ AuthorizationStatus.for(+ [authorization],+ scopes_by_authorization_id: {+ authorization.id => scopes,+ },+ ).fetch(authorization.id)+ authorization.update!(status: "consent_required") if status == "consent_required"+ raise Discourse::InvalidAccess if status != "active"+ raise Discourse::InvalidAccess if grant_version != authorization.grant_version+ raise Discourse::InvalidAccess if (scopes - authorization.scopes).present?+ end+ private_class_method :validate_authorization!++ def self.secure_compare_challenge(expected, verifier)+ return false if !PKCE_VERIFIER_PATTERN.match?(verifier.to_s)++ actual = Base64.urlsafe_encode64(Digest::SHA256.digest(verifier), padding: false)+ expected.bytesize == actual.bytesize &&+ ActiveSupport::SecurityUtils.secure_compare(expected, actual)+ end+ private_class_method :secure_compare_challenge+ end+ end+enddiff --git a/lib/discourse_mcp/primitive.rb b/lib/discourse_mcp/primitive.rbnew file mode 100644index 00000000000..16eb5f6760f--- /dev/null+++ b/lib/discourse_mcp/primitive.rb@@ -0,0 +1,87 @@+# frozen_string_literal: true++module DiscourseMcp+ class Primitive+ KINDS = %i[tool resource resource_template prompt].freeze+ RISKS = %i[read write destructive moderation administration external_side_effect].freeze++ attr_reader :identifier,+ :kind,+ :title,+ :description,+ :input_schema,+ :output_schema,+ :required_scopes,+ :annotations,+ :risk,+ :provider,+ :implementation,+ :availability++ def initialize(+ identifier:,+ kind:,+ title:,+ description:,+ implementation:,+ input_schema: { type: "object", additionalProperties: false },+ output_schema: nil,+ required_scopes: [],+ annotations: {},+ risk: :read,+ provider: :core,+ availability: nil+ )+ @identifier = identifier.to_s+ @kind = kind.to_sym+ @title = title+ @description = description+ @implementation = implementation+ @input_schema = input_schema.deep_stringify_keys+ @output_schema = output_schema&.deep_stringify_keys+ @required_scopes = Array(required_scopes).map(&:to_s).freeze+ @annotations = annotations.deep_stringify_keys.freeze+ @risk = risk.to_sym+ @provider = provider.to_s+ @availability = availability+ validate!+ freeze+ end++ def available?+ availability.nil? || availability.call+ end++ def consent_relevant?+ %i[destructive moderation administration external_side_effect].include?(risk)+ end++ private++ def validate!+ raise ArgumentError, "invalid MCP primitive kind" if !KINDS.include?(kind)+ raise ArgumentError, "invalid MCP primitive risk" if !RISKS.include?(risk)+ if !identifier.match?(/\A[A-Za-z0-9_.-]{1,128}\z/)+ raise ArgumentError, "invalid MCP primitive identifier"+ end+ raise ArgumentError, "MCP primitive title is required" if title.blank?+ raise ArgumentError, "MCP primitive description is required" if description.blank?+ raise ArgumentError, "MCP primitive implementation is required" if implementation.blank?+ if kind == :tool && input_schema["type"] != "object"+ raise ArgumentError, "MCP tool input schema must describe an object"+ end+ JSONSchemer.schema(input_schema)+ JSONSchemer.schema(output_schema) if output_schema+ if required_scopes.any? { |scope| !scope.match?(/\A[a-z0-9][a-z0-9:_-]{0,127}\z/) }+ raise ArgumentError, "invalid MCP primitive scope"+ end+ allowed_annotations = %w[title readOnlyHint destructiveHint idempotentHint openWorldHint]+ if (annotations.keys - allowed_annotations).present? ||+ annotations.except("title").values.any? { |value| value != true && value != false }+ raise ArgumentError, "invalid MCP primitive annotations"+ end+ rescue JSONSchemer::InvalidSchema+ raise ArgumentError, "invalid MCP primitive schema"+ end+ end+enddiff --git a/lib/discourse_mcp/registry.rb b/lib/discourse_mcp/registry.rbnew file mode 100644index 00000000000..12df85503ce--- /dev/null+++ b/lib/discourse_mcp/registry.rb@@ -0,0 +1,53 @@+# frozen_string_literal: true++module DiscourseMcp+ class Registry+ def initialize+ @primitives = {}+ @mutex = Mutex.new+ end++ def register(**attributes)+ primitive = Primitive.new(**attributes)+ key = [primitive.kind, primitive.identifier]+ @mutex.synchronize do+ if @primitives.key?(key)+ raise ArgumentError, "MCP primitive already registered: #{key.join(":")}"+ end++ @primitives[key] = primitive+ end+ primitive+ end++ def register_tool(identifier, **attributes)+ register(identifier: identifier, kind: :tool, **attributes)+ end++ def register_resource(identifier, **attributes)+ register(identifier: identifier, kind: :resource, **attributes)+ end++ def register_resource_template(identifier, **attributes)+ register(identifier: identifier, kind: :resource_template, **attributes)+ end++ def register_prompt(identifier, **attributes)+ register(identifier: identifier, kind: :prompt, **attributes)+ end++ def find(kind, identifier)+ @primitives[[kind.to_sym, identifier.to_s]]+ end++ def all(kind = nil)+ values = @primitives.values+ values = values.select { |primitive| primitive.kind == kind.to_sym } if kind+ values.sort_by(&:identifier)+ end++ def scopes+ all.flat_map(&:required_scopes).uniq.sort+ end+ end+enddiff --git a/lib/discourse_mcp/request_context.rb b/lib/discourse_mcp/request_context.rbnew file mode 100644index 00000000000..dd09dd5a0f1--- /dev/null+++ b/lib/discourse_mcp/request_context.rb@@ -0,0 +1,45 @@+# frozen_string_literal: true++module DiscourseMcp+ class RequestContext+ attr_reader :user_id, :oauth_client_id, :authorization_id, :access_token_id, :scopes++ def initialize(token)+ @user_id = token.user_id+ @oauth_client_id = token.mcp_oauth_client_id+ @authorization_id = token.mcp_oauth_authorization_id+ @access_token_id = token.id+ @scopes = token.scopes.to_set.freeze+ end++ def user+ return @user if defined?(@user)++ @user = User.find_by(id: user_id)+ @user = nil if @user.blank? || [email protected]? || @user.suspended? || @user.staged?++ @user+ end++ def guardian+ return @guardian if defined?(@guardian)++ current_user = user+ raise Discourse::InvalidAccess if current_user.blank?++ @guardian = current_user.guardian+ end++ def client+ McpOauthClient.find(oauth_client_id)+ end++ def authorization+ McpOauthAuthorization.find(authorization_id)+ end++ def has_scopes?(required)+ Array(required).all? { |scope| scopes.include?(scope.to_s) }+ end+ end+enddiff --git a/lib/discourse_mcp/server.rb b/lib/discourse_mcp/server.rbnew file mode 100644index 00000000000..74e7d03ea4e--- /dev/null+++ b/lib/discourse_mcp/server.rb@@ -0,0 +1,458 @@+# frozen_string_literal: true++module DiscourseMcp+ class Server+ PAGE_SIZE = 50+ SERVER_INFO_META_KEY = "io.modelcontextprotocol/serverInfo"+ PROTOCOL_META_KEY = "io.modelcontextprotocol/protocolVersion"+ CAPABILITIES_META_KEY = "io.modelcontextprotocol/clientCapabilities"++ Response = Data.define(:http_status, :body, :headers)++ def initialize(request:, request_context:)+ @request = request+ @request_context = request_context+ @catalog = Catalog.new(request_context: request_context)+ end++ def call(payload)+ started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)+ mcp_response = process(payload)+ record_audit(payload, mcp_response, started_at)+ mcp_response+ end++ private++ def process(payload)+ validate_request!(payload)+ id = payload["id"]+ method = payload["method"]+ params = payload["params"].is_a?(Hash) ? payload["params"] : {}+ result = dispatch(method, params)++ return Response.new(http_status: 202, body: nil, headers: {}) if id.nil?++ Response.new(http_status: 200, body: success(id, result), headers: {})+ rescue DiscourseMcp::Error => error+ Response.new(+ http_status: error.http_status,+ body: failure(payload&.dig("id"), error),+ headers: error.headers,+ )+ rescue DiscourseMcp::ToolError => error+ result = complete_result(content: [{ type: "text", text: error.message }], isError: true)+ Response.new(http_status: 200, body: success(payload&.dig("id"), result), headers: {})+ rescue Discourse::InvalidAccess+ error = Error.new("Not authorized", code: -32_001, http_status: 403)+ Response.new(http_status: 403, body: failure(payload&.dig("id"), error), headers: {})+ rescue JSONSchemer::InvalidSchema => error+ protocol_error = Error.new("Invalid schema", code: -32_000, http_status: 500)+ Discourse.warn_exception(error, message: "MCP schema validation failed")+ Response.new(http_status: 500, body: failure(payload&.dig("id"), protocol_error), headers: {})+ rescue StandardError => error+ protocol_error = Error.new("Internal error", code: -32_603, http_status: 500)+ Discourse.warn_exception(error, message: "MCP request failed")+ Response.new(http_status: 500, body: failure(payload&.dig("id"), protocol_error), headers: {})+ end++ attr_reader :request, :request_context, :catalog++ def record_audit(payload, mcp_response, started_at)+ return if !payload.is_a?(Hash) || payload["method"] != "tools/call"++ duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round+ tool_error =+ mcp_response.body&.dig(:result, :isError) || mcp_response.body&.dig("result", "isError")+ McpAuditLog.create!(+ occurred_at: Time.zone.now,+ user_id: request_context.user_id,+ mcp_oauth_client_id: request_context.oauth_client_id,+ request_id: payload["id"].to_s.presence,+ method: payload["method"],+ tool: payload.dig("params", "name").to_s.first(255),+ outcome: mcp_response.http_status < 400 && !tool_error ? "success" : "error",+ http_status: mcp_response.http_status,+ duration_ms: duration_ms,+ )+ rescue StandardError => error+ Discourse.warn_exception(error, message: "MCP audit record failed")+ end++ def validate_request!(payload)+ raise Error.new("Invalid Request", code: -32_600) if !payload.is_a?(Hash)+ raise Error.new("Invalid Request", code: -32_600) if payload["jsonrpc"] != JSONRPC_VERSION+ raise Error.new("Invalid Request", code: -32_600) if payload["method"].blank?++ return validate_initialize_request!(payload) if payload["method"] == "initialize"++ header_version = request.headers["MCP-Protocol-Version"]+ if !SUPPORTED_PROTOCOL_VERSIONS.include?(header_version)+ raise Error.new(+ "Unsupported protocol version",+ code: -32_022,+ data: {+ supported: SUPPORTED_PROTOCOL_VERSIONS,+ },+ )+ end++ body_version = payload.dig("params", "_meta", PROTOCOL_META_KEY)+ if header_version == PROTOCOL_VERSION+ validate_dated_request_metadata!(payload, header_version, body_version)+ elsif body_version.present? && body_version != header_version+ raise Error.new(+ "HTTP headers do not match request metadata",+ code: -32_020,+ data: {+ header: "MCP-Protocol-Version",+ },+ )+ end+ end++ def validate_initialize_request!(payload)+ requested_version = payload.dig("params", "protocolVersion")+ raise Error.new("Missing protocol version", code: -32_602) if requested_version.blank?+ end++ def validate_dated_request_metadata!(payload, header_version, body_version)+ if body_version.blank? || header_version != body_version+ raise Error.new(+ "HTTP headers do not match request metadata",+ code: -32_020,+ data: {+ header: "MCP-Protocol-Version",+ },+ )+ end++ method_header = request.headers["Mcp-Method"]+ if method_header.blank? || method_header != payload["method"]+ raise Error.new(+ "HTTP headers do not match request body",+ code: -32_020,+ data: {+ header: "Mcp-Method",+ },+ )+ end++ if %w[tools/call resources/read prompts/get].include?(payload["method"])+ expected_name =+ payload.dig("params", payload["method"] == "resources/read" ? "uri" : "name")+ actual_name = decode_header(request.headers["Mcp-Name"])+ if expected_name.blank? || actual_name != expected_name+ raise Error.new(+ "HTTP headers do not match request body",+ code: -32_020,+ data: {+ header: "Mcp-Name",+ },+ )+ end+ end++ capabilities = payload.dig("params", "_meta", CAPABILITIES_META_KEY)+ if !capabilities.is_a?(Hash)+ raise Error.new("Missing required client capability metadata", code: -32_021)+ end+ end++ def dispatch(method, params)+ case method+ when "initialize"+ initialize_result(params)+ when "notifications/initialized", "notifications/cancelled",+ "notifications/roots/list_changed"+ {}+ when "ping"+ {}+ when "server/discover"+ discover+ when "tools/list"+ list_tools(params)+ when "tools/call"+ call_tool(params)+ when "resources/list"+ list_resources(params)+ when "resources/templates/list"+ list_resource_templates(params)+ when "resources/read"+ read_resource(params)+ when "prompts/list"+ list_prompts(params)+ when "prompts/get"+ get_prompt(params)+ else+ raise Error.new("Method not found", code: -32_601, http_status: 404)+ end+ end++ def initialize_result(params)+ requested_version = params["protocolVersion"]+ negotiated_version =+ if requested_version == LEGACY_PROTOCOL_VERSION+ requested_version+ else+ LEGACY_PROTOCOL_VERSION+ end+ result = {+ protocolVersion: negotiated_version,+ capabilities: server_capabilities,+ serverInfo: {+ name: SERVER_NAME,+ title: "Discourse MCP Server",+ version: Discourse::VERSION::STRING,+ },+ }+ if SiteSetting.mcp_server_instructions.present?+ result[:instructions] = SiteSetting.mcp_server_instructions+ end+ result+ end++ def server_capabilities+ {+ tools: {+ listChanged: false,+ },+ resources: {+ subscribe: false,+ listChanged: false,+ },+ prompts: {+ listChanged: false,+ },+ }+ end++ def discover+ result = {+ supportedVersions: SUPPORTED_PROTOCOL_VERSIONS,+ capabilities: server_capabilities,+ ttlMs: SiteSetting.mcp_cache_ttl_ms,+ cacheScope: "private",+ }+ if SiteSetting.mcp_server_instructions.present?+ result[:instructions] = SiteSetting.mcp_server_instructions+ end+ complete_result(**result)+ end++ def list_tools(params)+ page, next_cursor = paginate(catalog.list(:tool), params["cursor"])+ tools =+ page.map do |tool|+ value = {+ name: tool.identifier,+ title: tool.title,+ description: tool.description,+ inputSchema: tool.input_schema,+ annotations: tool.annotations,+ }+ value[:outputSchema] = tool.output_schema if tool.output_schema+ value+ end+ complete_result(+ tools: tools,+ nextCursor: next_cursor,+ ttlMs: SiteSetting.mcp_cache_ttl_ms,+ cacheScope: "private",+ )+ end++ def call_tool(params)+ tool = authorized_primitive(:tool, params["name"], "Unknown tool")++ arguments = params["arguments"].is_a?(Hash) ? params["arguments"] : {}+ errors = JSONSchemer.schema(tool.input_schema).validate(arguments).to_a+ if errors.present?+ raise Error.new("Invalid tool arguments", code: -32_602, data: { errors: errors.first(20) })+ end++ result = tool.implementation.call(arguments: arguments, request_context: request_context)+ complete_result(**result.symbolize_keys)+ rescue ActiveRecord::RecordInvalid => error+ raise ToolError, error.record.errors.full_messages.join(", ")+ rescue Discourse::InvalidParameters+ raise ToolError, "The operation parameters are invalid"+ end++ def list_resources(params)+ complete_result(resources: [], ttlMs: SiteSetting.mcp_cache_ttl_ms, cacheScope: "private")+ end++ def list_resource_templates(params)+ templates =+ catalog+ .list(:resource_template)+ .map do |resource|+ {+ uriTemplate: uri_template(resource.identifier),+ name: resource.identifier,+ title: resource.title,+ description: resource.description,+ }+ end+ complete_result(+ resourceTemplates: templates,+ ttlMs: SiteSetting.mcp_cache_ttl_ms,+ cacheScope: "private",+ )+ end++ def read_resource(params)+ uri = params["uri"].to_s+ resource = catalog.find_exposed(:resource_template, resource_identifier(uri))+ raise Error.new("Resource not found", code: -32_602) if resource.blank?+ ensure_scopes!(resource)++ content = resource.implementation.call(uri: uri, request_context: request_context)+ complete_result(+ contents: [content],+ ttlMs: SiteSetting.mcp_cache_ttl_ms,+ cacheScope: "private",+ )+ end++ def list_prompts(params)+ prompts =+ catalog+ .list(:prompt)+ .map do |prompt|+ properties = prompt.input_schema["properties"] || {}+ required = Array(prompt.input_schema["required"])+ arguments =+ properties.map do |name, schema|+ {+ name: name,+ description: schema["description"],+ required: required.include?(name),+ }.compact+ end+ {+ name: prompt.identifier,+ title: prompt.title,+ description: prompt.description,+ arguments: arguments,+ }+ end+ complete_result(prompts: prompts, ttlMs: SiteSetting.mcp_cache_ttl_ms, cacheScope: "private")+ end++ def get_prompt(params)+ prompt = authorized_primitive(:prompt, params["name"], "Prompt not found")+ arguments = params["arguments"].is_a?(Hash) ? params["arguments"] : {}+ errors = JSONSchemer.schema(prompt.input_schema).validate(arguments).to_a+ if errors.present?+ raise Error.new(+ "Invalid prompt arguments",+ code: -32_602,+ data: {+ errors: errors.first(20),+ },+ )+ end+ complete_result(+ **prompt+ .implementation+ .call(arguments: arguments, request_context: request_context)+ .symbolize_keys,+ )+ end++ def complete_result(**values)+ values.compact.merge(+ resultType: "complete",+ _meta: {+ SERVER_INFO_META_KEY => {+ name: SERVER_NAME,+ version: Discourse::VERSION::STRING,+ },+ },+ )+ end++ def success(id, result)+ { jsonrpc: JSONRPC_VERSION, id: id, result: result }+ end++ def failure(id, error)+ value = { code: error.code, message: error.message }+ value[:data] = error.data if error.data+ { jsonrpc: JSONRPC_VERSION, id: id, error: value }+ end++ def paginate(values, cursor)+ offset = 0+ if cursor.present?+ decoded = Base64.urlsafe_decode64(cursor)+ raise Error.new("Invalid cursor", code: -32_602) if !decoded.match?(/\A\d+\z/)+ offset = decoded.to_i+ end+ page = values.slice(offset, PAGE_SIZE) || []+ next_cursor = Base64.urlsafe_encode64((offset + PAGE_SIZE).to_s, padding: false) if offset ++ PAGE_SIZE < values.length+ [page, next_cursor]+ rescue ArgumentError+ raise Error.new("Invalid cursor", code: -32_602)+ end++ def decode_header(value)+ return if value.blank?+ return value if !value.start_with?("=?base64?") || !value.end_with?("?=")++ Base64.strict_decode64(value.delete_prefix("=?base64?").delete_suffix("?="))+ rescue ArgumentError+ raise Error.new("Invalid encoded header", code: -32_020)+ end++ def uri_template(identifier)+ {+ "discourse.topic" => "discourse://topic/{topic_id}",+ "discourse.post" => "discourse://post/{post_id}",+ }.fetch(identifier, "discourse://#{identifier}/{id}")+ end++ def resource_identifier(uri)+ return "discourse.topic" if uri.match?(%r{\Adiscourse://topic/\d+\z})+ return "discourse.post" if uri.match?(%r{\Adiscourse://post/\d+\z})++ DiscourseMcp+ .registry+ .all(:resource_template)+ .find do |primitive|+ uri.match?(%r{\Adiscourse://#{Regexp.escape(primitive.identifier)}/\d+\z})+ end+ &.identifier+ end++ def authorized_primitive(kind, identifier, not_found_message)+ primitive = catalog.find_exposed(kind, identifier)+ raise Error.new(not_found_message, code: -32_602) if primitive.blank?++ ensure_scopes!(primitive)+ primitive+ end++ def ensure_scopes!(primitive)+ missing = primitive.required_scopes.reject { |scope| request_context.scopes.include?(scope) }+ return if missing.empty?++ required_scopes = primitive.required_scopes.join(" ")+ raise Error.new(+ "Insufficient scope",+ code: -32_001,+ http_status: 403,+ data: {+ required_scopes: primitive.required_scopes,+ },+ headers: {+ "WWW-Authenticate" =>+ Authenticator.challenge(scope: required_scopes, error: "insufficient_scope"),+ },+ )+ end+ end+enddiff --git a/lib/plugin/instance.rb b/lib/plugin/instance.rbindex 3feac541dfb..90e0464aa34 100644--- a/lib/plugin/instance.rb+++ b/lib/plugin/instance.rb@@ -1083,6 +1083,29 @@ class Plugin::Instance)end+ # Register a primitive exposed through Discourse's MCP server. Registered+ # primitives remain disabled until an admin enables them.+ def register_mcp_tool(identifier, **attributes)+ register_mcp_primitive(:tool, identifier, **attributes)+ end++ def register_mcp_resource_template(identifier, **attributes)+ register_mcp_primitive(:resource_template, identifier, **attributes)+ end++ def register_mcp_prompt(identifier, **attributes)+ register_mcp_primitive(:prompt, identifier, **attributes)+ end++ def register_mcp_primitive(kind, identifier, **attributes)+ configured_availability = attributes.delete(:availability)+ attributes[:provider] ||= name || directory_name+ attributes[:availability] = -> do+ enabled? && (configured_availability.nil? || configured_availability.call)+ end+ DiscourseMcp.registry.public_send("register_#{kind}", identifier, **attributes)+ end+# Register a route which can be authenticated using an api key or user api key# in a query parameter rather than a header. For example:#diff --git a/plugins/chat/lib/chat/mcp_tools.rb b/plugins/chat/lib/chat/mcp_tools.rbnew file mode 100644index 00000000000..04d60587e90--- /dev/null+++ b/plugins/chat/lib/chat/mcp_tools.rb@@ -0,0 +1,72 @@+# frozen_string_literal: true++module Chat+ module McpTools+ class ListChannels+ def self.call(arguments:, request_context:)+ result = Chat::ListUserChannels.call(guardian: request_context.guardian)+ raise DiscourseMcp::ToolError, "Unable to list chat channels" if result.failure?+ structured = result.structured+ channels =+ (structured[:public_channels] + structured[:direct_message_channels]).map do |channel|+ {+ id: channel.id,+ title: channel.title(request_context.user),+ status: channel.status,+ direct_message: channel.direct_message_channel?,+ }+ end+ DiscourseMcp::ToolHelpers.text_and_structured(channels: channels)+ end+ end++ class ListMessages+ def self.call(arguments:, request_context:)+ result =+ Chat::ListChannelMessages.call(+ params: {+ channel_id: arguments.fetch("channel_id"),+ page_size: arguments.fetch("limit", 50),+ },+ guardian: request_context.guardian,+ )+ raise DiscourseMcp::ToolError, "Unable to list chat messages" if result.failure?+ messages =+ Array(result.messages).map do |message|+ {+ id: message.id,+ channel_id: message.chat_channel_id,+ user_id: message.user_id,+ username: message.user&.username,+ message: message.message,+ created_at: message.created_at.iso8601,+ thread_id: message.thread_id,+ }+ end+ DiscourseMcp::ToolHelpers.text_and_structured(messages: messages)+ end+ end++ class CreateMessage+ def self.call(arguments:, request_context:)+ result =+ Chat::CreateMessage.call(+ params: {+ chat_channel_id: arguments.fetch("channel_id"),+ message: arguments.fetch("message"),+ thread_id: arguments["thread_id"],+ in_reply_to_id: arguments["reply_to_message_id"],+ },+ guardian: request_context.guardian,+ )+ raise DiscourseMcp::ToolError, "Unable to create chat message" if result.failure?+ message = result.message_instance+ DiscourseMcp::ToolHelpers.text_and_structured(+ id: message.id,+ channel_id: message.chat_channel_id,+ created_at: message.created_at.iso8601,+ )+ end+ end+ end+enddiff --git a/plugins/chat/plugin.rb b/plugins/chat/plugin.rbindex d40208e2cd5..4e20149c93f 100644--- a/plugins/chat/plugin.rb+++ b/plugins/chat/plugin.rb@@ -646,3 +646,83 @@ after_initialize doDiscoursePluginRegistry.discourse_dev_populate_reviewable_types.add DiscourseDev::ReviewableMessageendend++after_initialize do+ require_relative "lib/chat/mcp_tools"++ register_mcp_tool(+ "chat_channel_list",+ title: "List chat channels",+ description:+ "Lists chat channels followed by the authenticated user, including direct-message channels.",+ implementation: Chat::McpTools::ListChannels,+ required_scopes: %w[chat:read],+ annotations: {+ readOnlyHint: true,+ destructiveHint: false,+ },+ availability: -> { SiteSetting.chat_enabled },+ )+ register_mcp_tool(+ "chat_message_list",+ title: "List chat messages",+ description: "Reads a bounded page of messages from a visible chat channel.",+ implementation: Chat::McpTools::ListMessages,+ input_schema: {+ type: "object",+ properties: {+ channel_id: {+ type: "integer",+ minimum: 1,+ },+ limit: {+ type: "integer",+ minimum: 1,+ maximum: 100,+ },+ },+ required: ["channel_id"],+ additionalProperties: false,+ },+ required_scopes: %w[chat:read],+ annotations: {+ readOnlyHint: true,+ destructiveHint: false,+ },+ availability: -> { SiteSetting.chat_enabled },+ )+ register_mcp_tool(+ "chat_message_create",+ title: "Create chat message",+ description: "Creates a message in a chat channel as the authenticated user.",+ implementation: Chat::McpTools::CreateMessage,+ input_schema: {+ type: "object",+ properties: {+ channel_id: {+ type: "integer",+ minimum: 1,+ },+ message: {+ type: "string",+ minLength: 1,+ },+ thread_id: {+ type: "integer",+ },+ reply_to_message_id: {+ type: "integer",+ },+ },+ required: %w[channel_id message],+ additionalProperties: false,+ },+ required_scopes: %w[chat:write],+ annotations: {+ readOnlyHint: false,+ destructiveHint: false,+ },+ risk: :write,+ availability: -> { SiteSetting.chat_enabled },+ )+enddiff --git a/plugins/discourse-events/lib/discourse_events/mcp_tools.rb b/plugins/discourse-events/lib/discourse_events/mcp_tools.rbnew file mode 100644index 00000000000..ab77e9f8b3f--- /dev/null+++ b/plugins/discourse-events/lib/discourse_events/mcp_tools.rb@@ -0,0 +1,31 @@+# frozen_string_literal: true++module DiscourseEvents+ module McpTools+ class ListEvents+ def self.call(arguments:, request_context:)+ limit = arguments.fetch("limit", 50).to_i.clamp(1, 100)+ events =+ DiscourseEvents::Events::Finder.search(+ request_context.user,+ after: "now",+ include_ongoing: true,+ limit:,+ ).preload(post: :topic)+ values =+ events.map do |event|+ {+ id: event.id,+ post_id: event.post.id,+ topic_id: event.post.topic_id,+ name: event.name,+ starts_at: event.starts_at&.iso8601,+ ends_at: event.ends_at&.iso8601,+ status: event.status,+ }+ end+ DiscourseMcp::ToolHelpers.text_and_structured(events: values)+ end+ end+ end+enddiff --git a/plugins/discourse-events/plugin.rb b/plugins/discourse-events/plugin.rbindex dfd17a53d9f..7d1f2ef43b4 100644--- a/plugins/discourse-events/plugin.rb+++ b/plugins/discourse-events/plugin.rb@@ -1062,3 +1062,32 @@ after_initialize doDiscourseEvents::Livestream.publish_livestream_chat_status(membership, user: user) if membershipendend++after_initialize do+ require_relative "lib/discourse_events/mcp_tools"+ register_mcp_tool(+ "discourse_calendar_event_list",+ title: "List events",+ description: "Lists upcoming events whose posts are visible to the authenticated user.",+ implementation: DiscourseEvents::McpTools::ListEvents,+ input_schema: {+ type: "object",+ properties: {+ limit: {+ type: "integer",+ minimum: 1,+ maximum: 100,+ },+ },+ additionalProperties: false,+ },+ required_scopes: %w[discourse-calendar:read],+ annotations: {+ readOnlyHint: true,+ destructiveHint: false,+ },+ availability: -> do+ SiteSetting.discourse_events_enabled && SiteSetting.discourse_post_event_enabled+ end,+ )+enddiff --git a/plugins/discourse-events/spec/lib/discourse_events/mcp_tools_spec.rb b/plugins/discourse-events/spec/lib/discourse_events/mcp_tools_spec.rbnew file mode 100644index 00000000000..7cbd6004626--- /dev/null+++ b/plugins/discourse-events/spec/lib/discourse_events/mcp_tools_spec.rb@@ -0,0 +1,26 @@+# frozen_string_literal: true++describe DiscourseEvents::McpTools::ListEvents do+ fab!(:user)++ it "returns upcoming events without past events" do+ Fabricate(+ :event,+ name: "Past event",+ original_starts_at: 2.days.ago.iso8601,+ original_ends_at: 1.day.ago.iso8601,+ )+ upcoming_event =+ Fabricate(+ :event,+ name: "Upcoming event",+ original_starts_at: 1.day.from_now.iso8601,+ original_ends_at: 2.days.from_now.iso8601,+ )+ request_context = instance_double(DiscourseMcp::RequestContext, user:, guardian: user.guardian)++ result = described_class.call(arguments: {}, request_context:)++ expect(result.dig(:structuredContent, :events).pluck(:id)).to eq([upcoming_event.id])+ end+enddiff --git a/plugins/discourse-reactions/config/locales/server.en.yml b/plugins/discourse-reactions/config/locales/server.en.ymlindex 82e524e321a..f69eca4f4eb 100644--- a/plugins/discourse-reactions/config/locales/server.en.yml+++ b/plugins/discourse-reactions/config/locales/server.en.yml@@ -1,4 +1,7 @@en:+ discourse_reactions:+ errors:+ reaction_unavailable: "Reaction is not available"site_settings:discourse_reactions_like_icon: "Defines the icon used for the main reaction button. This should be a <a href='https://fontawesome.com/v6/search?o=r&m=free' target='_blank'>Font Awesome</a> icon name, not an emoji name."discourse_reactions_reaction_for_like: "Defines the reaction associated to the Like action. Historical Like records will not be changed if this setting changes, it is <strong>strongly recommended</strong> that this setting is never changed."diff --git a/plugins/discourse-reactions/lib/discourse_reactions/mcp_tools.rb b/plugins/discourse-reactions/lib/discourse_reactions/mcp_tools.rbnew file mode 100644index 00000000000..ae2e84d25e8--- /dev/null+++ b/plugins/discourse-reactions/lib/discourse_reactions/mcp_tools.rb@@ -0,0 +1,24 @@+# frozen_string_literal: true++module DiscourseReactions+ module McpTools+ class SetReaction+ def self.call(arguments:, request_context:)+ post = Post.find_by(id: arguments.fetch("post_id"))+ if post.blank? || !request_context.guardian.can_see?(post)+ raise DiscourseMcp::ToolError, "Post not found"+ end+ reaction = arguments.fetch("reaction")+ if !DiscourseReactions::Reaction.valid?(reaction)+ raise DiscourseMcp::ToolError, I18n.t("discourse_reactions.errors.reaction_unavailable")+ end+ DiscourseReactions::ReactionManager.new(+ reaction_value: reaction,+ user: request_context.user,+ post: post,+ ).toggle!+ DiscourseMcp::ToolHelpers.text_and_structured(post_id: post.id, reaction: reaction)+ end+ end+ end+enddiff --git a/plugins/discourse-reactions/plugin.rb b/plugins/discourse-reactions/plugin.rbindex 59f78ddc884..17767aa88c1 100644--- a/plugins/discourse-reactions/plugin.rb+++ b/plugins/discourse-reactions/plugin.rb@@ -434,3 +434,36 @@ after_initialize doendendend++after_initialize do+ require_relative "lib/discourse_reactions/mcp_tools"+ register_mcp_tool(+ "discourse_reactions_post_reaction_set",+ title: "Set post reaction",+ description: "Adds, changes, or removes the authenticated user's reaction to a visible post.",+ implementation: DiscourseReactions::McpTools::SetReaction,+ input_schema: {+ type: "object",+ properties: {+ post_id: {+ type: "integer",+ minimum: 1,+ },+ reaction: {+ type: "string",+ minLength: 1,+ maxLength: 100,+ },+ },+ required: %w[post_id reaction],+ additionalProperties: false,+ },+ required_scopes: %w[discourse-reactions:write],+ annotations: {+ readOnlyHint: false,+ destructiveHint: false,+ },+ risk: :write,+ availability: -> { SiteSetting.discourse_reactions_enabled },+ )+enddiff --git a/plugins/discourse-reactions/spec/lib/discourse_reactions/mcp_tools_spec.rb b/plugins/discourse-reactions/spec/lib/discourse_reactions/mcp_tools_spec.rbnew file mode 100644index 00000000000..2192a2d4b20--- /dev/null+++ b/plugins/discourse-reactions/spec/lib/discourse_reactions/mcp_tools_spec.rb@@ -0,0 +1,28 @@+# frozen_string_literal: true++describe DiscourseReactions::McpTools::SetReaction do+ fab!(:user)+ fab!(:post)++ before do+ SiteSetting.discourse_reactions_enabled = true+ SiteSetting.discourse_reactions_enabled_reactions = "laughing"+ end++ it "rejects a reaction that is not enabled" do+ request_context = instance_double(DiscourseMcp::RequestContext, user:, guardian: user.guardian)++ expect do+ described_class.call(+ arguments: {+ "post_id" => post.id,+ "reaction" => "disabled-reaction",+ },+ request_context:,+ )+ end.to raise_error(DiscourseMcp::ToolError)+ expect(DiscourseReactions::Reaction.find_by(post:, reaction_value: "disabled-reaction")).to eq(+ nil,+ )+ end+enddiff --git a/plugins/discourse-solved/lib/discourse_solved/mcp_tools.rb b/plugins/discourse-solved/lib/discourse_solved/mcp_tools.rbnew file mode 100644index 00000000000..5d39d07aa00--- /dev/null+++ b/plugins/discourse-solved/lib/discourse_solved/mcp_tools.rb@@ -0,0 +1,30 @@+# frozen_string_literal: true++module DiscourseSolved+ module McpTools+ class SetSolution+ def self.call(arguments:, request_context:)+ service =+ (+ if arguments.fetch("accepted")+ DiscourseSolved::AcceptAnswer+ else+ DiscourseSolved::UnacceptAnswer+ end+ )+ result =+ service.call(+ params: {+ post_id: arguments.fetch("post_id"),+ },+ guardian: request_context.guardian,+ )+ raise DiscourseMcp::ToolError, "Unable to change solution" if result.failure?+ DiscourseMcp::ToolHelpers.text_and_structured(+ post_id: arguments.fetch("post_id"),+ accepted: arguments.fetch("accepted"),+ )+ end+ end+ end+enddiff --git a/plugins/discourse-solved/plugin.rb b/plugins/discourse-solved/plugin.rbindex 339c1837eb9..2031047915e 100644--- a/plugins/discourse-solved/plugin.rb+++ b/plugins/discourse-solved/plugin.rb@@ -483,3 +483,34 @@ after_initialize doDiscourseDev::DiscourseSolved.populate(self)DiscourseAutomation::EntryPoint.inject(self) if defined?(DiscourseAutomation)end++after_initialize do+ require_relative "lib/discourse_solved/mcp_tools"+ register_mcp_tool(+ "discourse_solved_solution_set",+ title: "Set accepted solution",+ description: "Accepts or unaccepts a post as the topic solution when permitted.",+ implementation: DiscourseSolved::McpTools::SetSolution,+ input_schema: {+ type: "object",+ properties: {+ post_id: {+ type: "integer",+ minimum: 1,+ },+ accepted: {+ type: "boolean",+ },+ },+ required: %w[post_id accepted],+ additionalProperties: false,+ },+ required_scopes: %w[discourse-solved:write],+ annotations: {+ readOnlyHint: false,+ destructiveHint: false,+ },+ risk: :write,+ availability: -> { SiteSetting.solved_enabled },+ )+enddiff --git a/plugins/discourse-topic-voting/lib/discourse_topic_voting/mcp_tools.rb b/plugins/discourse-topic-voting/lib/discourse_topic_voting/mcp_tools.rbnew file mode 100644index 00000000000..dafd503a1b3--- /dev/null+++ b/plugins/discourse-topic-voting/lib/discourse_topic_voting/mcp_tools.rb@@ -0,0 +1,30 @@+# frozen_string_literal: true++module DiscourseTopicVoting+ module McpTools+ class SetVote+ def self.call(arguments:, request_context:)+ service =+ (+ if arguments.fetch("voted")+ DiscourseTopicVoting::Votes::Cast+ else+ DiscourseTopicVoting::Votes::Remove+ end+ )+ result =+ service.call(+ params: {+ topic_id: arguments.fetch("topic_id"),+ },+ guardian: request_context.guardian,+ )+ raise DiscourseMcp::ToolError, "Unable to change vote" if result.failure?+ DiscourseMcp::ToolHelpers.text_and_structured(+ topic_id: arguments.fetch("topic_id"),+ voted: arguments.fetch("voted"),+ )+ end+ end+ end+enddiff --git a/plugins/discourse-topic-voting/plugin.rb b/plugins/discourse-topic-voting/plugin.rbindex 0f22b414eca..3c2ca21fca2 100755--- a/plugins/discourse-topic-voting/plugin.rb+++ b/plugins/discourse-topic-voting/plugin.rb@@ -253,3 +253,34 @@ after_initialize do)endend++after_initialize do+ require_relative "lib/discourse_topic_voting/mcp_tools"+ register_mcp_tool(+ "discourse_topic_voting_vote_set",+ title: "Set topic vote",+ description: "Casts or removes the authenticated user's vote on a visible votable topic.",+ implementation: DiscourseTopicVoting::McpTools::SetVote,+ input_schema: {+ type: "object",+ properties: {+ topic_id: {+ type: "integer",+ minimum: 1,+ },+ voted: {+ type: "boolean",+ },+ },+ required: %w[topic_id voted],+ additionalProperties: false,+ },+ required_scopes: %w[discourse-topic-voting:write],+ annotations: {+ readOnlyHint: false,+ destructiveHint: false,+ },+ risk: :write,+ availability: -> { SiteSetting.topic_voting_enabled },+ )+enddiff --git a/script/mcp_client_interop b/script/mcp_client_interopnew file mode 100755index 00000000000..212ea9f1e65--- /dev/null+++ b/script/mcp_client_interop@@ -0,0 +1,59 @@+#!/usr/bin/env bash++set -euo pipefail++if [[ -z "${MCP_URL:-}" || -z "${MCP_TOKEN:-}" ]]; then+ echo "Usage: MCP_URL=https://forum.example.com/mcp MCP_TOKEN=... $0" >&2+ exit 1+fi++workdir="$(mktemp -d)"+trap 'rm -rf "$workdir"' EXIT++cat >"$workdir/package.json" <<'JSON'+{"private":true,"type":"module"}+JSON+pnpm --dir "$workdir" add --silent @modelcontextprotocol/[email protected]++cat >"$workdir/client.mjs" <<'JAVASCRIPT'+import {+ Client,+ StreamableHTTPClientTransport,+} from "@modelcontextprotocol/client";++const client = new Client(+ { name: "discourse-mcp-interoperability", version: "1.0.0" },+ { versionNegotiation: { mode: { pin: "2026-07-28" } } }+);+const transport = new StreamableHTTPClientTransport(new URL(process.env.MCP_URL), {+ requestInit: { headers: { Authorization: `Bearer ${process.env.MCP_TOKEN}` } },+});++await client.connect(transport);+const tools = await client.listTools();+const currentUser = await client.callTool({+ name: "discourse_current_user_get",+ arguments: {},+});+const resourceTemplates = await client.listResourceTemplates();+const prompts = await client.listPrompts();++console.log(+ JSON.stringify(+ {+ era: client.getProtocolEra(),+ tools: tools.tools.map((tool) => tool.name),+ currentUser: currentUser.structuredContent,+ resourceTemplates: resourceTemplates.resourceTemplates.map(+ (resource) => resource.uriTemplate+ ),+ prompts: prompts.prompts.map((prompt) => prompt.name),+ },+ null,+ 2+ )+);+await client.close();+JAVASCRIPT++node "$workdir/client.mjs"diff --git a/spec/jobs/clean_up_mcp_records_spec.rb b/spec/jobs/clean_up_mcp_records_spec.rbnew file mode 100644index 00000000000..f452013e8d1--- /dev/null+++ b/spec/jobs/clean_up_mcp_records_spec.rb@@ -0,0 +1,99 @@+# frozen_string_literal: true++describe Jobs::CleanUpMcpRecords do+ fab!(:user)++ let(:client) do+ McpOauthClient.create!(+ client_id: "cleanup-spec-client",+ name: "Cleanup spec client",+ registration_type: "pre_registered",+ trust_state: "approved",+ redirect_uris: ["http://127.0.0.1/callback"],+ )+ end++ let(:authorization) do+ McpOauthAuthorization.create!(+ user:,+ client:,+ resource: DiscourseMcp.resource_url,+ consented_at: Time.zone.now,+ status: "active",+ )+ end++ before do+ freeze_time(Time.zone.local(2026, 8, 28, 12))+ SiteSetting.mcp_audit_log_retention_days = 90+ end++ around { |example| stub_const(described_class, :BATCH_SIZE, 2) { example.run } }++ it "deletes every expired batch and keeps records within retention" do+ 3.times do+ create_authorization_code(expires_at: 1.minute.ago)+ create_access_token(expires_at: 31.days.ago)+ create_refresh_token(expires_at: 31.days.ago)+ McpAuditLog.create!(occurred_at: 91.days.ago, outcome: "success")+ end++ current_authorization_code = create_authorization_code(expires_at: 1.hour.from_now)+ current_access_token = create_access_token(expires_at: 29.days.ago)+ current_refresh_token = create_refresh_token(expires_at: 29.days.ago)+ current_audit_log = McpAuditLog.create!(occurred_at: 89.days.ago, outcome: "success")++ queries = track_sql_queries { described_class.new.execute({}) }++ expect_delete_batches(queries, "mcp_oauth_authorization_codes", 2)+ expect_delete_batches(queries, "mcp_oauth_access_tokens", 2)+ expect_delete_batches(queries, "mcp_oauth_refresh_tokens", 2)+ expect_delete_batches(queries, "mcp_audit_logs", 2)+ expect(McpOauthAuthorizationCode.all).to contain_exactly(current_authorization_code)+ expect(McpOauthAccessToken.all).to contain_exactly(current_access_token)+ expect(McpOauthRefreshToken.all).to contain_exactly(current_refresh_token)+ expect(McpAuditLog.all).to contain_exactly(current_audit_log)+ end++ def create_authorization_code(expires_at:)+ McpOauthAuthorizationCode.create!(+ authorization:,+ code_hash: SecureRandom.hex,+ code_challenge: "challenge",+ redirect_uri: client.redirect_uris.first,+ resource: DiscourseMcp.resource_url,+ scopes: [],+ grant_version: authorization.grant_version,+ expires_at:,+ )+ end++ def create_access_token(expires_at:)+ McpOauthAccessToken.create!(+ authorization:,+ client:,+ user:,+ token_hash: SecureRandom.hex,+ resource: DiscourseMcp.resource_url,+ scopes: [],+ grant_version: authorization.grant_version,+ expires_at:,+ )+ end++ def create_refresh_token(expires_at:)+ McpOauthRefreshToken.create!(+ authorization:,+ token_hash: SecureRandom.hex,+ family_id: SecureRandom.uuid,+ scopes: [],+ grant_version: authorization.grant_version,+ expires_at:,+ )+ end++ def expect_delete_batches(queries, table, count)+ delete_queries = queries.grep(/DELETE FROM "#{table}"/)+ expect(delete_queries.size).to eq(count), -> { delete_queries.join("\n") }+ end+enddiff --git a/spec/lib/discourse_mcp/access_spec.rb b/spec/lib/discourse_mcp/access_spec.rbnew file mode 100644index 00000000000..41b241e4571--- /dev/null+++ b/spec/lib/discourse_mcp/access_spec.rb@@ -0,0 +1,84 @@+# frozen_string_literal: true++describe DiscourseMcp::Access do+ fab!(:group)+ fab!(:other_group, :group)+ fab!(:user)+ fab!(:admin)++ before do+ group.add(user)+ other_group.add(user)+ end++ describe ".eligible_scopes" do+ it "includes the initial scope for an eligible user with an older access rule" do+ McpGroupScope.create!(group: group, scope: "mcp:content:write")++ expect(described_class.eligible_scopes(user)).to contain_exactly(+ "mcp:content:write",+ "mcp:profile:read",+ )+ end++ it "returns the union of scopes from all of the user's groups" do+ McpGroupScope.create!(group: group, scope: "mcp:profile:read")+ McpGroupScope.create!(group: other_group, scope: "mcp:content:write")+ McpGroupScope.create!(group: other_group, scope: "mcp:profile:read")++ expect(described_class.eligible_scopes(user)).to contain_exactly(+ "mcp:profile:read",+ "mcp:content:write",+ )+ end++ it "pre-registers editable scopes for admins" do+ expect(described_class.eligible_scopes(admin)).to eq(DiscourseMcp.registry.scopes)+ expect(+ McpGroupScope.where(group_id: Group::AUTO_GROUPS[:admins]).order(:scope).pluck(:scope),+ ).to eq(DiscourseMcp.registry.scopes)++ McpAccessRuleUpdater.replace!(+ actor: admin,+ group_id: Group::AUTO_GROUPS[:admins],+ scopes: ["mcp:profile:read"],+ )++ expect(described_class.eligible_scopes(admin)).to eq(["mcp:profile:read"])+ end++ it "returns no scopes for an inactive user" do+ user.update!(active: false)+ McpGroupScope.create!(group: group, scope: "mcp:profile:read")++ expect(described_class.eligible_scopes(user)).to be_empty+ end+ end++ describe ".eligible_for_exposed_primitive?" do+ it "requires an enabled server and an exposed primitive covered by the user's scopes" do+ SiteSetting.mcp_server_enabled = true+ McpGroupScope.create!(group: group, scope: "mcp:profile:read")+ primitive =+ McpPrimitive.create!(kind: "tool", identifier: "discourse_current_user_get", enabled: false)++ expect(described_class.eligible_for_exposed_primitive?(user)).to eq(false)++ primitive.update!(enabled: true)+ expect(described_class.eligible_for_exposed_primitive?(user)).to eq(true)++ SiteSetting.mcp_server_enabled = false+ expect(described_class.eligible_for_exposed_primitive?(user)).to eq(false)+ end+ end++ describe "group lifecycle" do+ it "removes access when its group is deleted" do+ McpGroupScope.create!(group: group, scope: "mcp:profile:read")++ group.destroy!++ expect(McpGroupScope.where(group_id: group.id)).to be_empty+ end+ end+enddiff --git a/spec/lib/discourse_mcp/authorization_status_spec.rb b/spec/lib/discourse_mcp/authorization_status_spec.rbnew file mode 100644index 00000000000..5a8ecdee302--- /dev/null+++ b/spec/lib/discourse_mcp/authorization_status_spec.rb@@ -0,0 +1,81 @@+# frozen_string_literal: true++describe DiscourseMcp::AuthorizationStatus do+ fab!(:user)+ fab!(:group)+ fab!(:other_group, :group)++ let(:client) do+ McpOauthClient.create!(+ client_id: "authorization-status-spec-client",+ name: "Authorization status spec client",+ registration_type: "pre_registered",+ trust_state: "approved",+ redirect_uris: ["http://127.0.0.1/callback"],+ )+ end+ let(:authorization) do+ DiscourseMcp::OAuth::AuthorizationGrant.create!(+ user: user,+ client: client,+ redirect_uri: client.redirect_uris.first,+ requested_scopes: %w[mcp:profile:read mcp:content:read],+ )+ end++ before do+ SiteSetting.mcp_server_enabled = true+ group.add(user)+ other_group.add(user)+ McpGroupScope.create!(group: group, scope: "mcp:profile:read")+ McpGroupScope.create!(group: group, scope: "mcp:content:read")+ McpGroupScope.create!(group: other_group, scope: "mcp:content:read")+ end++ it "keeps access active while any group provides every granted scope" do+ McpGroupScope.where(group: other_group, scope: "mcp:content:read").delete_all++ expect(described_class.for([authorization])).to eq(authorization.id => "active")++ McpGroupScope.where(group: group, scope: "mcp:content:read").delete_all++ expect(described_class.for([authorization])).to eq(authorization.id => "access_removed")+ end++ it "reports the current server, client, and user restriction" do+ authorization+ SiteSetting.mcp_server_enabled = false+ expect(described_class.for([authorization])).to eq(authorization.id => "server_disabled")++ SiteSetting.mcp_server_enabled = true+ client.update!(trust_state: "blocked")+ expect(described_class.for([authorization])).to eq(authorization.id => "client_blocked")++ client.update!(trust_state: "pending")+ expect(described_class.for([authorization])).to eq(authorization.id => "client_not_approved")++ client.update!(trust_state: "approved")+ user.update!(active: false)+ expect(described_class.for([authorization])).to eq(authorization.id => "user_unavailable")+ end++ it "reports when fresh consent is required or access was revoked" do+ authorization+ client.update!(metadata_hash: "changed")+ expect(described_class.for([authorization])).to eq(authorization.id => "consent_required")++ authorization.revoke!(by_user: user)+ expect(described_class.for([authorization])).to eq(authorization.id => "revoked")+ end++ it "ignores fresh consent requirements for primitives outside the granted scopes" do+ McpPrimitive.create!(+ kind: "tool",+ identifier: "discourse_post_set_deleted",+ enabled: true,+ consent_required_at: 1.second.from_now,+ )++ expect(described_class.for([authorization])).to eq(authorization.id => "active")+ end+enddiff --git a/spec/lib/discourse_mcp/core_tools_spec.rb b/spec/lib/discourse_mcp/core_tools_spec.rbnew file mode 100644index 00000000000..da0b1a2f192--- /dev/null+++ b/spec/lib/discourse_mcp/core_tools_spec.rb@@ -0,0 +1,15 @@+# frozen_string_literal: true++describe DiscourseMcp::Tools::GetUser do+ fab!(:viewer, :admin)+ fab!(:user) { Fabricate(:user, name: "Hidden Name") }++ it "hides full names when names are disabled" do+ SiteSetting.enable_names = false+ request_context = instance_double(DiscourseMcp::RequestContext, guardian: viewer.guardian)++ result = described_class.call(arguments: { "username" => user.username }, request_context:)++ expect(result.dig(:structuredContent, :user)).not_to have_key(:name)+ end+enddiff --git a/spec/lib/discourse_mcp/oauth_spec.rb b/spec/lib/discourse_mcp/oauth_spec.rbnew file mode 100644index 00000000000..5b5fd39b296--- /dev/null+++ b/spec/lib/discourse_mcp/oauth_spec.rb@@ -0,0 +1,441 @@+# frozen_string_literal: true++describe DiscourseMcp::OAuth do+ fab!(:user)+ fab!(:group)+ fab!(:other_group, :group)++ let(:granted_scopes) { %w[mcp:profile:read mcp:content:read] }++ let(:client) do+ McpOauthClient.create!(+ client_id: "oauth-spec-client",+ name: "OAuth spec client",+ registration_type: "pre_registered",+ trust_state: "approved",+ redirect_uris: ["http://127.0.0.1/callback"],+ )+ end+ let(:authorization) do+ described_class::AuthorizationGrant.create!(+ user: user,+ client: client,+ redirect_uri: client.redirect_uris.first,+ requested_scopes: granted_scopes,+ )+ end+ let(:verifier) { "v" * 43 }+ let(:challenge) { Base64.urlsafe_encode64(Digest::SHA256.digest(verifier), padding: false) }++ before do+ SiteSetting.mcp_server_enabled = true+ group.add(user)+ other_group.add(user)+ McpGroupScope.create!(group: group, scope: "mcp:profile:read")+ McpGroupScope.create!(group: other_group, scope: "mcp:content:read")+ end++ it "rejects an unapproved metadata domain before registering the client" do+ client_id = "https://unapproved.example.com/oauth/client.json"+ SiteSetting.mcp_oauth_client_id_metadata_policy = "approved_domains"+ SiteSetting.mcp_oauth_client_id_metadata_domains = "approved.example.com"+ allow(described_class::ClientResolver).to receive(:fetch_metadata).and_return(+ {+ "client_id" => client_id,+ "client_name" => "Unapproved client",+ "redirect_uris" => ["https://unapproved.example.com/callback"],+ },+ )++ expect { described_class::ClientResolver.resolve!(client_id, user:) }.to raise_error(+ Discourse::InvalidAccess,+ )+ expect(McpOauthClient.find_by(client_id:)).to eq(nil)+ end++ it "rejects a cached metadata client that the current trust policy does not allow" do+ SiteSetting.mcp_oauth_client_id_metadata_policy = "disabled"+ client_id = "https://client.example.com/oauth/client.json"+ McpOauthClient.create!(+ client_id:,+ name: "Cached metadata client",+ registration_type: "cimd",+ trust_state: "approved",+ metadata_uri: client_id,+ metadata_expires_at: 1.hour.from_now,+ redirect_uris: ["https://client.example.com/callback"],+ )++ expect { described_class::ClientResolver.resolve!(client_id, user:) }.to raise_error(+ Discourse::InvalidAccess,+ )+ end++ it "rejects client ID URLs containing dot path segments" do+ SiteSetting.mcp_oauth_client_id_metadata_policy = "any_domain"+ client_id = "https://client.example.com/oauth/../client.json"+ allow(described_class::ClientResolver).to receive(:fetch_metadata).and_return(+ {+ "client_id" => client_id,+ "client_name" => "Invalid metadata client",+ "redirect_uris" => ["https://client.example.com/callback"],+ },+ )++ expect { described_class::ClientResolver.resolve!(client_id, user:) }.to raise_error(+ Discourse::InvalidAccess,+ )+ expect(McpOauthClient.find_by(client_id:)).to eq(nil)+ end++ it "rejects metadata that requires unsupported client authentication" do+ SiteSetting.mcp_oauth_client_id_metadata_policy = "any_domain"+ client_id = "https://client.example.com/oauth/client.json"+ allow(described_class::ClientResolver).to receive(:fetch_metadata).and_return(+ {+ "client_id" => client_id,+ "client_name" => "Confidential metadata client",+ "redirect_uris" => ["https://client.example.com/callback"],+ "token_endpoint_auth_method" => "private_key_jwt",+ },+ )++ expect { described_class::ClientResolver.resolve!(client_id, user:) }.to raise_error(+ Discourse::InvalidAccess,+ )+ expect(McpOauthClient.find_by(client_id:)).to eq(nil)+ end++ it "handles metadata responses without a body chunk" do+ SiteSetting.mcp_oauth_client_id_metadata_policy = "any_domain"+ client_id = "https://client.example.com/oauth/client.json"+ response = instance_double(Net::HTTPResponse, code: "302")+ allow(response).to receive(:[]).with("Content-Type").and_return("text/html")+ destination = instance_double(FinalDestination)+ allow(FinalDestination).to receive(:new).and_return(destination)+ allow(destination).to receive(:get).and_yield(response, nil, nil)++ expect { described_class::ClientResolver.resolve!(client_id, user:) }.to raise_error(+ Discourse::InvalidAccess,+ )+ end++ it "rate limits metadata lookups across hostname case variants" do+ SiteSetting.mcp_oauth_client_id_metadata_policy = "any_domain"+ RateLimiter.enable+ users = 4.times.map { Fabricate(:user) }+ lowercase_host = "client-#{SecureRandom.hex}.example.com"+ uppercase_host = lowercase_host.upcase+ allow(described_class::ClientResolver).to receive(:fetch_metadata) do |uri|+ {+ "client_id" => uri.to_s,+ "client_name" => "Metadata client",+ "redirect_uris" => ["https://client.example.com/callback"],+ }+ end++ 30.times do |index|+ host = index.even? ? lowercase_host : uppercase_host+ described_class::ClientResolver.resolve!(+ "https://#{host}/oauth/client-#{index}.json",+ user: users[index % users.length],+ )+ end++ expect do+ described_class::ClientResolver.resolve!(+ "https://#{uppercase_host}/oauth/client-30.json",+ user: users.last,+ )+ end.to raise_error(RateLimiter::LimitExceeded)+ end++ it "rejects existing credentials when the current policy no longer allows the client" do+ SiteSetting.mcp_oauth_client_id_metadata_policy = "any_domain"+ client_id = "https://client.example.com/oauth/client.json"+ metadata_client =+ McpOauthClient.create!(+ client_id:,+ name: "Metadata client",+ registration_type: "cimd",+ trust_state: "approved",+ metadata_uri: client_id,+ redirect_uris: ["https://client.example.com/callback"],+ )+ metadata_authorization =+ described_class::AuthorizationGrant.create!(+ user:,+ client: metadata_client,+ redirect_uri: metadata_client.redirect_uris.first,+ requested_scopes: granted_scopes,+ )+ access_token = McpOauthAccessToken.issue!(authorization: metadata_authorization)+ refresh_token, = McpOauthRefreshToken.issue!(authorization: metadata_authorization)+ request = Struct.new(:authorization).new("Bearer #{access_token}")+ SiteSetting.stubs(:mcp_oauth_client_id_metadata_policy).returns("disabled")++ expect { DiscourseMcp::Authenticator.new(request).authenticate! }.to raise_error(+ DiscourseMcp::AuthenticationError,+ )+ expect do+ described_class::TokenIssuer.refresh!(+ refresh_token:,+ client_id:,+ resource: DiscourseMcp.resource_url,+ )+ end.to raise_error(Discourse::InvalidAccess)+ end++ it "revokes metadata client grants when an approved domain is removed" do+ SiteSetting.mcp_oauth_client_id_metadata_policy = "approved_domains"+ SiteSetting.mcp_oauth_client_id_metadata_domains = "client.example.com"+ client_id = "https://client.example.com/oauth/client.json"+ metadata_client =+ McpOauthClient.create!(+ client_id:,+ name: "Metadata client",+ registration_type: "cimd",+ trust_state: "approved",+ metadata_uri: client_id,+ redirect_uris: ["https://client.example.com/callback"],+ )+ metadata_authorization =+ described_class::AuthorizationGrant.create!(+ user:,+ client: metadata_client,+ redirect_uri: metadata_client.redirect_uris.first,+ requested_scopes: granted_scopes,+ )+ access_token = McpOauthAccessToken.issue!(authorization: metadata_authorization)+ refresh_token, refresh_record =+ McpOauthRefreshToken.issue!(authorization: metadata_authorization)++ SiteSetting.mcp_oauth_client_id_metadata_domains = "other.example.com"++ expect(metadata_client.reload.trust_state).to eq("pending")+ expect(metadata_authorization.reload.status).to eq("consent_required")+ expect(+ McpOauthAccessToken.find_by(token_hash: McpOauthAccessToken.digest(access_token)).revoked_at,+ ).to be_present+ expect(refresh_record.reload.revoked_at).to be_present+ expect do+ described_class::TokenIssuer.refresh!(+ refresh_token:,+ client_id:,+ resource: DiscourseMcp.resource_url,+ )+ end.to raise_error(Discourse::InvalidAccess)+ end++ it "authorizes scopes combined from all of the user's groups" do+ expect(authorization.scopes).to contain_exactly(*granted_scopes)+ end++ it "requires the initial scope when granting authorization" do+ expect do+ described_class::AuthorizationGrant.create!(+ user: user,+ client: client,+ redirect_uri: client.redirect_uris.first,+ requested_scopes: %w[mcp:content:read],+ )+ end.to raise_error(Discourse::InvalidAccess)+ end++ it "grants only requested scopes that the user is eligible for" do+ authorization =+ described_class::AuthorizationGrant.create!(+ user: user,+ client: client,+ redirect_uri: client.redirect_uris.first,+ requested_scopes: %w[mcp:profile:read mcp:content:write],+ )++ expect(authorization.scopes).to eq(["mcp:profile:read"])+ end++ it "does not add newly eligible scopes during refresh" do+ subset_authorization =+ described_class::AuthorizationGrant.create!(+ user: user,+ client: client,+ redirect_uri: client.redirect_uris.first,+ requested_scopes: %w[mcp:profile:read],+ )+ refresh_token, = McpOauthRefreshToken.issue!(authorization: subset_authorization)+ McpGroupScope.create!(group: group, scope: "mcp:content:write")++ result =+ described_class::TokenIssuer.refresh!(+ refresh_token: refresh_token,+ client_id: client.client_id,+ resource: DiscourseMcp.resource_url,+ )++ expect(result[:scope]).to eq("mcp:profile:read")+ end++ it "does not allow refresh to remove the initial scope" do+ refresh_token, = McpOauthRefreshToken.issue!(authorization: authorization)++ expect do+ described_class::TokenIssuer.refresh!(+ refresh_token: refresh_token,+ client_id: client.client_id,+ resource: DiscourseMcp.resource_url,+ requested_scopes: %w[mcp:content:read],+ )+ end.to raise_error(Discourse::InvalidAccess)+ end++ it "keeps a token valid while another group still provides every token scope" do+ McpGroupScope.create!(group: group, scope: "mcp:content:read")+ access_token = McpOauthAccessToken.issue!(authorization: authorization)+ request = Struct.new(:authorization).new("Bearer #{access_token}")++ McpGroupScope.where(group: other_group, scope: "mcp:content:read").delete_all++ expect(DiscourseMcp::Authenticator.new(request).authenticate!).to be_a(+ DiscourseMcp::RequestContext,+ )++ McpGroupScope.where(group: group, scope: "mcp:content:read").delete_all++ expect { DiscourseMcp::Authenticator.new(request).authenticate! }.to raise_error(+ DiscourseMcp::AuthenticationError,+ )+ end++ it "keeps a subset token valid when another authorized scope is no longer eligible" do+ access_token =+ McpOauthAccessToken.issue!(authorization: authorization, scopes: %w[mcp:profile:read])+ request = Struct.new(:authorization).new("Bearer #{access_token}")++ McpGroupScope.where(group: other_group, scope: "mcp:content:read").delete_all++ expect(DiscourseMcp::AuthorizationStatus.for([authorization])[authorization.id]).to eq(+ "access_removed",+ )+ expect(DiscourseMcp::Authenticator.new(request).authenticate!).to be_a(+ DiscourseMcp::RequestContext,+ )+ end++ it "exchanges an S256 authorization code exactly once" do+ code =+ McpOauthAuthorizationCode.issue!(+ authorization: authorization,+ redirect_uri: client.redirect_uris.first,+ resource: DiscourseMcp.resource_url,+ code_challenge: challenge,+ )++ result =+ described_class::TokenIssuer.exchange_code!(+ code: code,+ client_id: client.client_id,+ redirect_uri: client.redirect_uris.first,+ code_verifier: verifier,+ resource: DiscourseMcp.resource_url,+ )++ expect(result.slice(:token_type, :scope)).to eq(+ token_type: "Bearer",+ scope: granted_scopes.join(" "),+ )+ expect(result.values_at(:access_token, :refresh_token)).to all(be_present)+ expect do+ described_class::TokenIssuer.exchange_code!(+ code: code,+ client_id: client.client_id,+ redirect_uri: client.redirect_uris.first,+ code_verifier: verifier,+ resource: DiscourseMcp.resource_url,+ )+ end.to raise_error(Discourse::InvalidAccess)+ end++ it "rotates refresh tokens and revokes the family when a consumed token is replayed" do+ refresh_token, record = McpOauthRefreshToken.issue!(authorization: authorization)++ result =+ described_class::TokenIssuer.refresh!(+ refresh_token: refresh_token,+ client_id: client.client_id,+ resource: DiscourseMcp.resource_url,+ )++ expect(result[:refresh_token]).to be_present+ expect(record.reload.consumed_at).to be_present+ expect do+ described_class::TokenIssuer.refresh!(+ refresh_token: refresh_token,+ client_id: client.client_id,+ resource: DiscourseMcp.resource_url,+ )+ end.to raise_error(Discourse::InvalidAccess)+ expect(+ McpOauthRefreshToken.where(family_id: record.family_id).where(revoked_at: nil),+ ).to be_empty+ end++ it "invalidates existing credentials when consent is replaced" do+ access_token = McpOauthAccessToken.issue!(authorization: authorization)++ described_class::AuthorizationGrant.create!(+ user: user,+ client: client,+ redirect_uri: client.redirect_uris.first,+ requested_scopes: %w[mcp:profile:read],+ )++ request = Struct.new(:authorization).new("Bearer #{access_token}")+ expect { DiscourseMcp::Authenticator.new(request).authenticate! }.to raise_error(+ DiscourseMcp::AuthenticationError,+ )+ expect(+ McpOauthAccessToken.find_by(token_hash: McpOauthAccessToken.digest(access_token)).revoked_at,+ ).to be_present+ end++ it "rejects credentials consented before the latest primitive consent change" do+ access_token = McpOauthAccessToken.issue!(authorization: authorization)+ McpPrimitive.create!(+ kind: "tool",+ identifier: "discourse_post_get",+ enabled: true,+ consent_required_at: 1.second.from_now,+ )+ request = Struct.new(:authorization).new("Bearer #{access_token}")++ expect { DiscourseMcp::Authenticator.new(request).authenticate! }.to raise_error(+ DiscourseMcp::AuthenticationError,+ )+ end++ it "rejects refresh scopes removed from the user's current group access" do+ refresh_token, = McpOauthRefreshToken.issue!(authorization: authorization)+ McpGroupScope.where(group: other_group, scope: "mcp:content:read").delete_all++ expect do+ described_class::TokenIssuer.refresh!(+ refresh_token: refresh_token,+ client_id: client.client_id,+ resource: DiscourseMcp.resource_url,+ )+ end.to raise_error(Discourse::InvalidAccess)+ end++ it "rejects authorization while the MCP server is disabled" do+ SiteSetting.mcp_server_enabled = false++ expect do+ described_class::AuthorizationGrant.create!(+ user: user,+ client: client,+ redirect_uri: client.redirect_uris.first,+ requested_scopes: granted_scopes,+ )+ end.to raise_error(Discourse::InvalidAccess)+ end+enddiff --git a/spec/models/mcp_oauth_client_id_metadata_policy_spec.rb b/spec/models/mcp_oauth_client_id_metadata_policy_spec.rbnew file mode 100644index 00000000000..d924f7f9aed--- /dev/null+++ b/spec/models/mcp_oauth_client_id_metadata_policy_spec.rb@@ -0,0 +1,19 @@+# frozen_string_literal: true++describe McpOauthClientIdMetadataPolicy do+ it "returns translated policy values" do+ expect(described_class.values).to contain_exactly(+ { name: "mcp_oauth_client_id_metadata_policy.disabled", value: "disabled" },+ { name: "mcp_oauth_client_id_metadata_policy.approved_domains", value: "approved_domains" },+ { name: "mcp_oauth_client_id_metadata_policy.any_domain", value: "any_domain" },+ )+ expect(described_class.translate_names?).to eq(true)+ end++ it "validates policy values" do+ expect(described_class.valid_value?("disabled")).to eq(true)+ expect(described_class.valid_value?("approved_domains")).to eq(true)+ expect(described_class.valid_value?("any_domain")).to eq(true)+ expect(described_class.valid_value?("invalid")).to eq(false)+ end+enddiff --git a/spec/models/mcp_oauth_client_spec.rb b/spec/models/mcp_oauth_client_spec.rbnew file mode 100644index 00000000000..fdc357ed2ba--- /dev/null+++ b/spec/models/mcp_oauth_client_spec.rb@@ -0,0 +1,50 @@+# frozen_string_literal: true++describe McpOauthClient do+ it "accepts an IPv6 loopback redirect URI" do+ expect(described_class.valid_redirect_uri?("http://[::1]/callback")).to eq(true)+ end++ describe "#allows_redirect_uri?" do+ it "allows a different port for a registered loopback IP redirect" do+ client =+ McpOauthClient.new(+ redirect_uris: [+ "http://127.0.0.1/callback?source=codex",+ "http://[::1]/callback?source=codex",+ ],+ )++ expect(+ [+ client.allows_redirect_uri?("http://127.0.0.1:49152/callback?source=codex"),+ client.allows_redirect_uri?("http://[::1]:49153/callback?source=codex"),+ ],+ ).to all(be(true))+ end++ it "allows a different port for a registered localhost redirect" do+ client = McpOauthClient.new(redirect_uris: ["http://localhost/callback"])++ expect(client.allows_redirect_uri?("http://localhost:49152/callback")).to eq(true)+ end++ it "does not relax other redirect URI components or remote hosts" do+ client =+ McpOauthClient.new(+ redirect_uris: %w[+ http://127.0.0.1/callback?source=codex+ https://client.example.com/callback+ ],+ )++ expect(+ [+ client.allows_redirect_uri?("http://127.0.0.1:49152/other?source=codex"),+ client.allows_redirect_uri?("http://127.0.0.1:49152/callback?source=other"),+ client.allows_redirect_uri?("https://client.example.com:49152/callback"),+ ],+ ).to all(be(false))+ end+ end+enddiff --git a/spec/models/mcp_oauth_refresh_token_spec.rb b/spec/models/mcp_oauth_refresh_token_spec.rbnew file mode 100644index 00000000000..aa2e1b0fcf1--- /dev/null+++ b/spec/models/mcp_oauth_refresh_token_spec.rb@@ -0,0 +1,31 @@+# frozen_string_literal: true++describe McpOauthRefreshToken do+ fab!(:user)++ it "keeps the original family expiry when rotating a token" do+ client =+ McpOauthClient.create!(+ client_id: "refresh-token-spec-client",+ name: "Refresh token spec client",+ registration_type: "pre_registered",+ trust_state: "approved",+ redirect_uris: ["http://127.0.0.1/callback"],+ )+ authorization =+ McpOauthAuthorization.create!(+ user:,+ client:,+ resource: DiscourseMcp.resource_url,+ consented_at: Time.zone.now,+ status: "active",+ )+ _, parent = described_class.issue!(authorization:)+ parent.update!(expires_at: 1.day.from_now)++ _, replacement =+ described_class.issue!(authorization:, family_id: parent.family_id, parent: parent)++ expect(replacement.expires_at).to eq_time(parent.expires_at)+ end+enddiff --git a/spec/models/mcp_primitive_spec.rb b/spec/models/mcp_primitive_spec.rbnew file mode 100644index 00000000000..eb5f1c5f324--- /dev/null+++ b/spec/models/mcp_primitive_spec.rb@@ -0,0 +1,23 @@+# frozen_string_literal: true++describe McpPrimitive do+ it "stores one exposure record for each primitive type and identifier" do+ described_class.create!(kind: "tool", identifier: "discourse_search", enabled: true)++ duplicate = described_class.new(kind: "tool", identifier: "discourse_search", enabled: false)++ expect(duplicate).not_to be_valid+ end++ it "returns only enabled primitives that are not emergency blocked" do+ exposed = described_class.create!(kind: "tool", identifier: "discourse_search", enabled: true)+ described_class.create!(+ kind: "tool",+ identifier: "discourse_post_set_deleted",+ enabled: true,+ emergency_blocked: true,+ )++ expect(described_class.exposed).to contain_exactly(exposed)+ end+enddiff --git a/spec/requests/admin/mcp_activity_controller_spec.rb b/spec/requests/admin/mcp_activity_controller_spec.rbnew file mode 100644index 00000000000..4a8ee588eea--- /dev/null+++ b/spec/requests/admin/mcp_activity_controller_spec.rb@@ -0,0 +1,151 @@+# frozen_string_literal: true++describe Admin::McpActivityController do+ fab!(:admin)++ describe "#index" do+ before { sign_in(admin) }++ it "returns activity and calculates the 24-hour metrics in one query" do+ McpAuditLog.create!(+ occurred_at: Time.zone.now,+ method: "tools/call",+ tool: "discourse_search",+ outcome: "success",+ occurrences: 2,+ duration_ms: 10,+ )+ McpAuditLog.create!(+ occurred_at: Time.zone.now,+ method: "tools/call",+ tool: "discourse_topic_create",+ outcome: "error",+ occurrences: 3,+ duration_ms: 100,+ )+ McpAuditLog.create!(+ occurred_at: Time.zone.now,+ method: "tools/call",+ outcome: "rate_limited",+ occurrences: 4,+ duration_ms: 200,+ )++ queries = track_sql_queries { get "/admin/mcp/activity.json" }++ expect(response.status).to eq(200)+ expect(response.parsed_body["metrics"]).to eq(+ "tool_calls" => 9,+ "errors" => 7,+ "rate_limits" => 4,+ "p95_latency_ms" => 200,+ )+ expect(response.parsed_body.dig("activity", 2, "tool")).to eq("discourse_search")+ metric_queries =+ queries.select do |sql|+ sql.include?('FROM "mcp_audit_logs"') && sql.match?(/occurred_at.*>/)+ end+ expect(metric_queries.length).to eq(1)+ end++ it "filters users, clients, tools, outcomes, and exact request IDs on the server" do+ user = Fabricate(:user, username: "activity-needle-user")+ client =+ McpOauthClient.create!(+ client_id: "activity-needle-client",+ name: "Activity Needle Client",+ registration_type: "pre_registered",+ trust_state: "approved",+ redirect_uris: ["http://127.0.0.1/callback"],+ )+ matching_log =+ McpAuditLog.create!(+ occurred_at: Time.zone.now,+ user: user,+ client: client,+ method: "tools/call",+ tool: "discourse.activity.needle",+ outcome: "error",+ request_id: "activity-request-exact",+ )+ McpAuditLog.create!(+ occurred_at: Time.zone.now,+ method: "tools/call",+ tool: "discourse.other",+ outcome: "success",+ request_id: "other-request",+ )++ [user.username, client.name, client.client_id, matching_log.tool].each do |filter|+ get "/admin/mcp/activity.json", params: { filter: filter }++ expect(response.parsed_body["activity"].map { |entry| entry["id"] }).to eq(+ [matching_log.id],+ )+ end++ get "/admin/mcp/activity.json", params: { outcome: "error" }+ expect(response.parsed_body["activity"].map { |entry| entry["id"] }).to eq([matching_log.id])++ get "/admin/mcp/activity.json", params: { filter: matching_log.request_id }+ expect(response.parsed_body["activity"].map { |entry| entry["id"] }).to eq([matching_log.id])++ get "/admin/mcp/activity.json", params: { filter: "activity-request" }+ expect(response.parsed_body["activity"]).to be_empty+ end++ it "applies filters before pagination and omits metrics from cursor requests" do+ older_match =+ McpAuditLog.create!(+ occurred_at: 2.minutes.ago,+ method: "tools/call",+ tool: "discourse_search",+ outcome: "success",+ )+ McpAuditLog.create!(+ occurred_at: 1.minute.ago,+ method: "tools/call",+ tool: "discourse.other",+ outcome: "success",+ )+ newer_match =+ McpAuditLog.create!(+ occurred_at: Time.zone.now,+ method: "tools/call",+ tool: "discourse_search",+ outcome: "success",+ )++ get "/admin/mcp/activity.json", params: { filter: "search", limit: 1 }++ expect(response.parsed_body["activity"].map { |entry| entry["id"] }).to eq([newer_match.id])+ cursor = response.parsed_body.dig("meta", "next_cursor")+ expect(cursor).to eq(newer_match.id)+ expect(response.parsed_body).to have_key("metrics")++ get "/admin/mcp/activity.json", params: { filter: "search", limit: 1, cursor: cursor }++ expect(response.parsed_body["activity"].map { |entry| entry["id"] }).to eq([older_match.id])+ expect(response.parsed_body).not_to have_key("metrics")+ end++ it "rejects invalid filter values" do+ get "/admin/mcp/activity.json", params: { outcome: "unknown" }+ expect(response.status).to eq(400)++ get "/admin/mcp/activity.json", params: { cursor: "not-an-id" }+ expect(response.status).to eq(400)++ get "/admin/mcp/activity.json", params: { filter: "a" * 201 }+ expect(response.status).to eq(400)+ end++ it "does not allow moderators to view MCP activity" do+ sign_in(Fabricate(:moderator))++ get "/admin/mcp/activity.json"++ expect(response.status).to eq(404)+ end+ end+enddiff --git a/spec/requests/admin/mcp_authorizations_controller_spec.rb b/spec/requests/admin/mcp_authorizations_controller_spec.rbnew file mode 100644index 00000000000..abdb12adb4e--- /dev/null+++ b/spec/requests/admin/mcp_authorizations_controller_spec.rb@@ -0,0 +1,93 @@+# frozen_string_literal: true++describe Admin::McpAuthorizationsController do+ fab!(:admin)+ fab!(:user)+ fab!(:group)++ before do+ sign_in(admin)+ SiteSetting.mcp_server_enabled = true+ group.add(user)+ end++ describe "#index" do+ it "returns the effective authorization status" do+ McpGroupScope.create!(group: group, scope: "mcp:profile:read")+ client = create_client(client_id: "admin-authorizations-spec-client")+ DiscourseMcp::OAuth::AuthorizationGrant.create!(+ user: user,+ client: client,+ redirect_uri: client.redirect_uris.first,+ requested_scopes: ["mcp:profile:read"],+ )+ SiteSetting.mcp_server_enabled = false++ get "/admin/mcp/authorizations.json"++ expect(response.status).to eq(200)+ expect(response.parsed_body.dig("authorizations", 0, "status")).to eq("server_disabled")+ end++ it "paginates authorizations" do+ older_authorization = create_authorization(user: user, client_id: "older-client")+ newer_authorization = create_authorization(user: user, client_id: "newer-client")++ get "/admin/mcp/authorizations.json", params: { limit: 1 }++ expect(response.status).to eq(200)+ expect(response.parsed_body["authorizations"].pluck("id")).to eq([newer_authorization.id])++ get "/admin/mcp/authorizations.json",+ params: {+ limit: 1,+ cursor: response.parsed_body.dig("meta", "next_cursor"),+ }++ expect(response.parsed_body["authorizations"].pluck("id")).to eq([older_authorization.id])+ end++ it "filters authorizations before applying the page limit" do+ matching_user = Fabricate(:user, username: "matching-user")+ matching_authorization = create_authorization(user: matching_user, client_id: "older-client")+ create_authorization(user: user, client_id: "newer-client")++ get "/admin/mcp/authorizations.json", params: { limit: 1, filter: "matching" }++ expect(response.status).to eq(200)+ expect(response.parsed_body["authorizations"].pluck("id")).to eq([matching_authorization.id])+ end++ it "returns an authorization that references a deleted user" do+ authorization = create_authorization(user: user, client_id: "deleted-user-client")+ User.where(id: user.id).delete_all++ get "/admin/mcp/authorizations.json"++ expect(response.status).to eq(200)+ expect(response.parsed_body["authorizations"]).to contain_exactly(+ include("id" => authorization.id, "username" => nil, "status" => "user_unavailable"),+ )+ end+ end++ def create_authorization(user:, client_id:)+ McpOauthAuthorization.create!(+ user:,+ client: create_client(client_id:),+ resource: DiscourseMcp.resource_url,+ consented_at: Time.zone.now,+ status: "active",+ )+ end++ def create_client(client_id:)+ McpOauthClient.create!(+ client_id:,+ name: client_id,+ registration_type: "pre_registered",+ trust_state: "approved",+ redirect_uris: ["http://127.0.0.1/callback"],+ )+ end+enddiff --git a/spec/requests/admin/mcp_clients_controller_spec.rb b/spec/requests/admin/mcp_clients_controller_spec.rbnew file mode 100644index 00000000000..9fff3c3ec23--- /dev/null+++ b/spec/requests/admin/mcp_clients_controller_spec.rb@@ -0,0 +1,96 @@+# frozen_string_literal: true++describe Admin::McpClientsController do+ fab!(:admin)++ before do+ sign_in(admin)+ SiteSetting.mcp_oauth_client_id_metadata_policy = "approved_domains"+ SiteSetting.mcp_oauth_client_id_metadata_domains = "client.example.com"+ end++ describe "#index" do+ it "paginates clients" do+ older_client = create_client(client_id: "older-client", name: "Older client")+ newer_client = create_client(client_id: "newer-client", name: "Newer client")++ get "/admin/mcp/clients.json", params: { limit: 1 }++ expect(response.status).to eq(200)+ expect(response.parsed_body["clients"].pluck("id")).to eq([newer_client.id])++ get "/admin/mcp/clients.json",+ params: {+ limit: 1,+ cursor: response.parsed_body.dig("meta", "next_cursor"),+ }++ expect(response.parsed_body["clients"].pluck("id")).to eq([older_client.id])+ end++ it "filters clients before applying the page limit" do+ older_client = create_client(client_id: "older-client", name: "Matching client")+ create_client(client_id: "newer-client", name: "Other client")++ get "/admin/mcp/clients.json", params: { limit: 1, filter: "matching" }++ expect(response.status).to eq(200)+ expect(response.parsed_body["clients"].pluck("id")).to eq([older_client.id])+ end+ end++ describe "#create" do+ it "serializes a non-URL client ID that starts with HTTPS" do+ post "/admin/mcp/clients.json",+ params: {+ client: {+ client_id: "https://%",+ name: "Malformed URL-like ID",+ redirect_uris: ["https://client.example.com/callback"],+ },+ }++ expect(response.status).to eq(201)+ expect(response.parsed_body.dig("client", "client_id")).to eq("https://%")+ expect(response.parsed_body.dig("client", "domain")).to eq(nil)+ end+ end++ describe "#refresh" do+ it "refreshes client ID metadata for an approved domain" do+ client_id = "https://client.example.com/oauth/client.json"+ client =+ McpOauthClient.create!(+ client_id:,+ name: "Old name",+ registration_type: "cimd",+ trust_state: "approved",+ metadata_uri: client_id,+ redirect_uris: ["https://client.example.com/callback"],+ )+ allow(DiscourseMcp::OAuth::ClientResolver).to receive(:fetch_metadata).and_return(+ {+ "client_id" => client_id,+ "client_name" => "Updated name",+ "redirect_uris" => ["https://client.example.com/callback"],+ },+ )++ post "/admin/mcp/clients/#{client.id}/refresh.json"++ expect(response.status).to eq(200)+ expect(response.parsed_body.dig("client", "name")).to eq("Updated name")+ expect(client.reload.name).to eq("Updated name")+ end+ end++ def create_client(client_id:, name:)+ McpOauthClient.create!(+ client_id:,+ name:,+ registration_type: "pre_registered",+ trust_state: "approved",+ redirect_uris: ["https://client.example.com/callback"],+ )+ end+enddiff --git a/spec/requests/admin/mcp_controller_spec.rb b/spec/requests/admin/mcp_controller_spec.rbnew file mode 100644index 00000000000..39a8b805c7b--- /dev/null+++ b/spec/requests/admin/mcp_controller_spec.rb@@ -0,0 +1,280 @@+# frozen_string_literal: true++describe Admin::McpController do+ fab!(:admin)+ fab!(:moderator)++ before { sign_in(admin) }++ describe "#overview" do+ it "reports approved OAuth client registrations" do+ get "/admin/mcp/overview.json"++ expect(response.status).to eq(200)+ expect(response.parsed_body["metrics"]).to include("approved_oauth_clients" => 0)+ checklist_labels = response.parsed_body["setup_checklist"].pluck("label")+ expect(checklist_labels).to contain_exactly(+ I18n.t("mcp.admin.site_enabled"),+ I18n.t("mcp.admin.primitives_enabled"),+ I18n.t("mcp.admin.client_registered"),+ )+ end+ end++ describe "#primitives" do+ it "returns the registered OAuth scopes as selectable configuration options" do+ get "/admin/mcp/capabilities.json"++ expect(response.status).to eq(200)+ scopes = response.parsed_body["available_scopes"]+ expect(scopes).to eq(scopes.uniq.sort)+ expect(scopes).to include("mcp:profile:read", "mcp:content:read", "mcp:content:write")+ expect(response.parsed_body["primitives"]).to be_present+ end+ end++ describe "#access" do+ it "returns one persisted access rule per group with Admins pre-registered" do+ group = Fabricate(:group, name: "writers")+ McpGroupScope.create!(group: group, scope: "mcp:profile:read")+ McpGroupScope.create!(group: group, scope: "mcp:content:read")++ get "/admin/mcp/access.json"++ expect(response.status).to eq(200)+ expect(response.parsed_body["available_scopes"]).to include(+ "mcp:profile:read",+ "mcp:content:read",+ )+ expect(response.parsed_body["primitives"]).to be_present+ expect(response.parsed_body["access_rules"]).to contain_exactly(+ {+ "group_id" => Group::AUTO_GROUPS[:admins],+ "group_name" => "admins",+ "scopes" => DiscourseMcp.registry.scopes,+ "pre_registered" => true,+ "deletable" => false,+ },+ {+ "group_id" => group.id,+ "group_name" => group.name,+ "scopes" => %w[mcp:content:read mcp:profile:read],+ "pre_registered" => false,+ "deletable" => true,+ },+ )+ expect(McpGroupScope.where(group_id: Group::AUTO_GROUPS[:admins])).to be_present+ end+ end++ describe "#update_access" do+ it "replaces the scopes for one group" do+ group = Fabricate(:group)+ McpGroupScope.create!(group: group, scope: "mcp:profile:read")++ put "/admin/mcp/access/#{group.id}.json",+ params: {+ scopes: %w[mcp:content:read mcp:content:write],+ }++ expect(response.status).to eq(200)+ expect(McpGroupScope.where(group: group).pluck(:scope)).to contain_exactly(+ "mcp:content:read",+ "mcp:content:write",+ "mcp:profile:read",+ )+ end++ it "rejects unknown scopes" do+ group = Fabricate(:group)++ put "/admin/mcp/access/#{group.id}.json", params: { scopes: ["mcp:unknown"] }++ expect(response.status).to eq(400)+ expect(McpGroupScope.where(group: group)).to be_empty+ end++ it "allows the pre-registered Admins scopes to be changed" do+ McpGroupScope.ensure_admins!++ put "/admin/mcp/access/#{Group::AUTO_GROUPS[:admins]}.json",+ params: {+ scopes: ["mcp:profile:read"],+ }++ expect(response.status).to eq(200)+ expect(McpGroupScope.where(group_id: Group::AUTO_GROUPS[:admins]).pluck(:scope)).to eq(+ ["mcp:profile:read"],+ )+ end++ it "does not allow moderators to change group access" do+ group = Fabricate(:group)+ sign_in(moderator)++ put "/admin/mcp/access/#{group.id}.json", params: { scopes: ["mcp:profile:read"] }++ expect(response.status).to eq(404)+ expect(McpGroupScope.where(group: group)).to be_empty+ end+ end++ describe "#destroy_access" do+ it "removes the scopes for one group" do+ group = Fabricate(:group)+ McpGroupScope.create!(group: group, scope: "mcp:profile:read")++ delete "/admin/mcp/access/#{group.id}.json"++ expect(response.status).to eq(204)+ expect(McpGroupScope.where(group: group)).to be_empty+ end++ it "does not remove the pre-registered Admins rule" do+ McpGroupScope.ensure_admins!++ delete "/admin/mcp/access/#{Group::AUTO_GROUPS[:admins]}.json"++ expect(response.status).to eq(400)+ expect(McpGroupScope.where(group_id: Group::AUTO_GROUPS[:admins])).to be_present+ end+ end++ describe "#emergency_block" do+ it "immediately blocks and unblocks a registered primitive" do+ params = { primitive_id: "tool:discourse_search", blocked: true }++ put "/admin/mcp/capabilities/emergency-block.json", params: params++ expect(response.status).to eq(200)+ policy = McpPrimitive.find_by!(kind: "tool", identifier: "discourse_search")+ expect(policy).to be_emergency_blocked++ put "/admin/mcp/capabilities/emergency-block.json", params: params.merge(blocked: false)++ expect(response.status).to eq(200)+ expect(policy.reload).not_to be_emergency_blocked+ end++ it "requires fresh consent only when unblocking expands privileged access" do+ SiteSetting.mcp_server_enabled = true+ McpGroupScope.ensure_admins!+ client =+ McpOauthClient.create!(+ client_id: "emergency-block-spec-client",+ name: "Emergency block spec client",+ registration_type: "pre_registered",+ trust_state: "approved",+ redirect_uris: ["http://127.0.0.1/callback"],+ )+ authorization =+ DiscourseMcp::OAuth::AuthorizationGrant.create!(+ user: admin,+ client: client,+ redirect_uri: client.redirect_uris.first,+ requested_scopes: %w[mcp:content:write mcp:profile:read],+ )+ McpOauthAccessToken.issue!(authorization: authorization)+ token = authorization.access_tokens.last+ McpPrimitive.create!(kind: "tool", identifier: "discourse_post_set_deleted", enabled: true)+ params = { primitive_id: "tool:discourse_post_set_deleted", blocked: true }++ put "/admin/mcp/capabilities/emergency-block.json", params: params++ expect(response.status).to eq(200)+ expect(authorization.reload.status).to eq("active")+ expect(token.reload.revoked_at).to be_blank++ put "/admin/mcp/capabilities/emergency-block.json", params: params.merge(blocked: false)++ expect(response.status).to eq(200)+ expect(authorization.reload.status).to eq("consent_required")+ expect(token.reload.revoked_at).to be_present+ end+ end++ describe "#update_primitives" do+ it "requires fresh consent and revokes tokens when a privileged primitive is exposed" do+ SiteSetting.mcp_server_enabled = true+ McpGroupScope.ensure_admins!+ client =+ McpOauthClient.create!(+ client_id: "admin-mcp-controller-spec-client",+ name: "Admin MCP controller spec client",+ registration_type: "pre_registered",+ trust_state: "approved",+ redirect_uris: ["http://127.0.0.1/callback"],+ )+ authorization =+ DiscourseMcp::OAuth::AuthorizationGrant.create!(+ user: admin,+ client: client,+ redirect_uri: client.redirect_uris.first,+ requested_scopes: %w[mcp:profile:read mcp:content:write],+ )+ McpOauthAccessToken.issue!(authorization: authorization)+ McpOauthRefreshToken.issue!(authorization: authorization)+ profile_client =+ McpOauthClient.create!(+ client_id: "profile-only-spec-client",+ name: "Profile-only spec client",+ registration_type: "pre_registered",+ trust_state: "approved",+ redirect_uris: ["http://127.0.0.1/profile-callback"],+ )+ profile_authorization =+ DiscourseMcp::OAuth::AuthorizationGrant.create!(+ user: admin,+ client: profile_client,+ redirect_uri: profile_client.redirect_uris.first,+ requested_scopes: ["mcp:profile:read"],+ )+ McpOauthAccessToken.issue!(authorization: profile_authorization)++ put "/admin/mcp/capabilities.json",+ params: {+ primitive_ids: ["tool:discourse_post_set_deleted"],+ }++ expect(response.status).to eq(200)+ primitive = McpPrimitive.find_by!(kind: "tool", identifier: "discourse_post_set_deleted")+ expect(primitive).to be_enabled+ expect(primitive.consent_required_at).to be_present+ expect(authorization.reload.status).to eq("consent_required")+ expect(authorization.access_tokens.where(revoked_at: nil)).to be_empty+ expect(authorization.refresh_tokens.where(revoked_at: nil)).to be_empty+ expect(profile_authorization.reload.status).to eq("active")+ expect(profile_authorization.access_tokens.where(revoked_at: nil)).to be_present+ end++ it "does not require fresh consent when a read-only primitive is exposed" do+ SiteSetting.mcp_server_enabled = true+ McpGroupScope.ensure_admins!+ client =+ McpOauthClient.create!(+ client_id: "read-only-primitive-spec-client",+ name: "Read-only primitive spec client",+ registration_type: "pre_registered",+ trust_state: "approved",+ redirect_uris: ["http://127.0.0.1/callback"],+ )+ authorization =+ DiscourseMcp::OAuth::AuthorizationGrant.create!(+ user: admin,+ client: client,+ redirect_uri: client.redirect_uris.first,+ requested_scopes: ["mcp:profile:read"],+ )++ put "/admin/mcp/capabilities.json",+ params: {+ primitive_ids: ["tool:discourse_current_user_get"],+ }++ expect(response.status).to eq(200)+ primitive = McpPrimitive.find_by!(kind: "tool", identifier: "discourse_current_user_get")+ expect(primitive.consent_required_at).to be_blank+ expect(authorization.reload.status).to eq("active")+ end+ end+enddiff --git a/spec/requests/mcp_controller_spec.rb b/spec/requests/mcp_controller_spec.rbnew file mode 100644index 00000000000..6beb042a782--- /dev/null+++ b/spec/requests/mcp_controller_spec.rb@@ -0,0 +1,226 @@+# frozen_string_literal: true++describe "MCP transport" do+ fab!(:admin)++ let(:client) do+ McpOauthClient.create!(+ client_id: "request-spec-client",+ name: "Request spec client",+ registration_type: "pre_registered",+ trust_state: "approved",+ redirect_uris: ["http://127.0.0.1/callback"],+ )+ end+ let(:authorization) do+ DiscourseMcp::OAuth::AuthorizationGrant.create!(+ user: admin,+ client: client,+ redirect_uri: client.redirect_uris.first,+ requested_scopes: %w[mcp:profile:read],+ )+ end+ let(:access_token) { McpOauthAccessToken.issue!(authorization: authorization) }+ let(:headers) do+ {+ "HTTP_AUTHORIZATION" => "Bearer #{access_token}",+ "CONTENT_TYPE" => "application/json",+ "HTTP_ACCEPT" => "application/json, text/event-stream",+ "HTTP_MCP_PROTOCOL_VERSION" => DiscourseMcp::PROTOCOL_VERSION,+ "HTTP_MCP_METHOD" => "tools/call",+ "HTTP_MCP_NAME" => "discourse_current_user_get",+ }+ end+ let(:classic_headers) do+ headers.slice("HTTP_AUTHORIZATION", "CONTENT_TYPE", "HTTP_ACCEPT").merge(+ "HTTP_MCP_PROTOCOL_VERSION" => "2025-11-25",+ )+ end+ let(:initialize_payload) do+ {+ jsonrpc: "2.0",+ id: 0,+ method: "initialize",+ params: {+ protocolVersion: "2025-11-25",+ capabilities: {+ roots: {+ listChanged: true,+ },+ },+ clientInfo: {+ name: "compatible-client",+ version: "1.0.0",+ },+ },+ }+ end+ let(:payload) do+ {+ jsonrpc: "2.0",+ id: 1,+ method: "tools/call",+ params: {+ name: "discourse_current_user_get",+ arguments: {+ },+ _meta: {+ "io.modelcontextprotocol/protocolVersion" => DiscourseMcp::PROTOCOL_VERSION,+ "io.modelcontextprotocol/clientCapabilities" => {+ },+ },+ },+ }+ end++ before do+ SiteSetting.mcp_server_enabled = true+ McpPrimitive.create!(kind: "tool", identifier: "discourse_current_user_get", enabled: true)+ end++ it "challenges requests without bearer credentials" do+ post "/mcp", params: payload.to_json, headers: headers.except("HTTP_AUTHORIZATION")++ expect(response.status).to eq(401)+ expect(response.headers["WWW-Authenticate"]).to eq(+ %(Bearer resource_metadata="#{DiscourseMcp.protected_resource_metadata_url}", scope="mcp:profile:read"),+ )+ expect(response.parsed_body.dig("error", "code")).to eq(-32_001)+ end++ it "rejects an invalid bearer credential with an RFC 6750 error" do+ post "/mcp",+ params: payload.to_json,+ headers: headers.merge("HTTP_AUTHORIZATION" => "bearer invalid")++ expect(response.status).to eq(401)+ expect(response.headers["WWW-Authenticate"]).to include('error="invalid_token"')+ end++ it "returns an OAuth insufficient-scope challenge for an exposed tool" do+ McpPrimitive.create!(kind: "tool", identifier: "discourse_post_get", enabled: true)+ scoped_payload =+ payload.deep_merge(+ method: "tools/call",+ params: {+ name: "discourse_post_get",+ arguments: {+ post_id: 1,+ },+ },+ )+ scoped_headers = headers.merge("HTTP_MCP_NAME" => "discourse_post_get")++ post "/mcp", params: scoped_payload.to_json, headers: scoped_headers++ expect(response.status).to eq(403)+ expect(response.headers["WWW-Authenticate"]).to include(+ 'error="insufficient_scope"',+ 'scope="mcp:content:read"',+ )+ end++ it "negotiates a compatible protocol through the standard initialize request" do+ post "/mcp",+ params: initialize_payload.to_json,+ headers: classic_headers.except("HTTP_MCP_PROTOCOL_VERSION")++ expect(response.status).to eq(200)+ expect(response.parsed_body.dig("result", "protocolVersion")).to eq(+ DiscourseMcp::LEGACY_PROTOCOL_VERSION,+ )+ expect(response.parsed_body.dig("result", "serverInfo", "name")).to eq("discourse")+ expect(response.parsed_body.dig("result", "capabilities", "tools")).to eq(+ "listChanged" => false,+ )+ end++ it "keeps legacy initialization on the classic protocol for an unsupported version" do+ unsupported_initialize_payload =+ initialize_payload.deep_merge(params: { protocolVersion: "2025-06-18" })++ post "/mcp",+ params: unsupported_initialize_payload.to_json,+ headers: classic_headers.except("HTTP_MCP_PROTOCOL_VERSION")++ expect(response.status).to eq(200)+ expect(response.parsed_body.dig("result", "protocolVersion")).to eq(+ DiscourseMcp::LEGACY_PROTOCOL_VERSION,+ )+ end++ it "accepts compatible stateless requests without dated request metadata" do+ notification = { jsonrpc: "2.0", method: "notifications/initialized" }+ post "/mcp", params: notification.to_json, headers: classic_headers+ expect(response.status).to eq(202)+ expect(response.body).to be_blank++ list_request = { jsonrpc: "2.0", id: 1, method: "tools/list", params: {} }+ post "/mcp", params: list_request.to_json, headers: classic_headers++ expect(response.status).to eq(200)+ expect(response.parsed_body.dig("result", "tools")).to be_an(Array)+ end++ it "lists tools with underscore-only names" do+ list_request = { jsonrpc: "2.0", id: 1, method: "tools/list", params: {} }++ post "/mcp", params: list_request.to_json, headers: classic_headers++ tool_names = response.parsed_body.dig("result", "tools").pluck("name")+ expect(tool_names).to include("discourse_current_user_get")+ expect(tool_names).to all(match(/\A[A-Za-z0-9_]+\z/))+ end++ it "uses the server-wide cache TTL setting for cacheable responses" do+ SiteSetting.mcp_cache_ttl_ms = 12_345+ discover_payload =+ payload.deep_merge(+ method: "server/discover",+ params: {+ _meta: {+ "io.modelcontextprotocol/protocolVersion" => DiscourseMcp::PROTOCOL_VERSION,+ "io.modelcontextprotocol/clientCapabilities" => {+ },+ },+ },+ )+ discover_headers = headers.except("HTTP_MCP_NAME").merge("HTTP_MCP_METHOD" => "server/discover")++ post "/mcp", params: discover_payload.to_json, headers: discover_headers++ expect(response.status).to eq(200)+ expect(response.parsed_body.dig("result", "ttlMs")).to eq(12_345)+ end++ it "executes a stateless dated-protocol tool request" do+ post "/mcp", params: payload.to_json, headers: headers++ expect(response.status).to eq(200)+ expect(response.parsed_body.dig("result", "structuredContent", "username")).to eq(+ admin.username,+ )+ expect(response.parsed_body.dig("result", "resultType")).to eq("complete")+ end++ it "records tool calls with long JSON-RPC request IDs" do+ request_id = "a" * 256++ expect do+ post "/mcp", params: payload.merge(id: request_id).to_json, headers: headers+ end.to change(McpAuditLog, :count).by(1)++ expect(response.status).to eq(200)+ expect(McpAuditLog.last.request_id).to eq(request_id)+ end++ it "records at most one rate-limit audit event per client each minute" do+ SiteSetting.mcp_global_rate_limit_per_minute = 10+ RateLimiter.enable++ 12.times { post "/mcp", params: payload.to_json, headers: headers }++ expect(response.status).to eq(429)+ expect(McpAuditLog.where(outcome: "rate_limited").count).to eq(1)+ end+enddiff --git a/spec/requests/mcp_oauth_authorizations_controller_spec.rb b/spec/requests/mcp_oauth_authorizations_controller_spec.rbnew file mode 100644index 00000000000..16bf9878628--- /dev/null+++ b/spec/requests/mcp_oauth_authorizations_controller_spec.rb@@ -0,0 +1,236 @@+# frozen_string_literal: true++describe McpOauthAuthorizationsController do+ fab!(:admin)+ fab!(:user)++ before do+ sign_in(admin)+ SiteSetting.mcp_server_enabled = true+ end++ it "labels the OAuth resource as the MCP server" do+ client =+ McpOauthClient.create!(+ client_id: "consent-page-client",+ name: "Consent page client",+ registration_type: "pre_registered",+ trust_state: "approved",+ redirect_uris: ["http://127.0.0.1/callback"],+ )++ get "/oauth2/mcp/authorize",+ params: {+ client_id: client.client_id,+ redirect_uri: client.redirect_uris.first,+ response_type: "code",+ code_challenge: "a" * 43,+ code_challenge_method: "S256",+ resource: DiscourseMcp.resource_url,+ scope: "mcp:profile:read mcp:content:read",+ }++ expect(response.status).to eq(200)+ labels = Nokogiri.HTML5(response.body).css("dt").map(&:text)+ expect(labels).to include(I18n.t("mcp.oauth.resource"))+ end++ it "prevents the authorization page from being framed when site embedding is enabled" do+ SiteSetting.allow_embedding_site_in_an_iframe = true+ SiteSetting.content_security_policy = false+ client =+ McpOauthClient.create!(+ client_id: "framing-protection-client",+ name: "Framing protection client",+ registration_type: "pre_registered",+ trust_state: "approved",+ redirect_uris: ["http://127.0.0.1/callback"],+ )++ get "/oauth2/mcp/authorize",+ params: {+ client_id: client.client_id,+ redirect_uri: client.redirect_uris.first,+ response_type: "code",+ code_challenge: "a" * 43,+ code_challenge_method: "S256",+ resource: DiscourseMcp.resource_url,+ scope: "mcp:profile:read",+ }++ expect(response.status).to eq(200)+ expect(response.headers["X-Frame-Options"]).to eq("DENY")+ expect(response.headers["Content-Security-Policy"]).to include("frame-ancestors 'none'")+ end++ it "rejects an authorization request without the initial scope" do+ client =+ McpOauthClient.create!(+ client_id: "missing-initial-scope-client",+ name: "Missing initial scope client",+ registration_type: "pre_registered",+ trust_state: "approved",+ redirect_uris: ["http://127.0.0.1/callback"],+ )++ get "/oauth2/mcp/authorize",+ params: {+ client_id: client.client_id,+ redirect_uri: client.redirect_uris.first,+ response_type: "code",+ code_challenge: "a" * 43,+ code_challenge_method: "S256",+ resource: DiscourseMcp.resource_url,+ scope: "mcp:content:read",+ }++ expect(response.status).to eq(403)+ end++ it "explains when only some requested scopes can be granted" do+ sign_in(user)+ group = Fabricate(:group)+ group.add(user)+ McpGroupScope.create!(group:, scope: "mcp:profile:read")+ client =+ McpOauthClient.create!(+ client_id: "partial-consent-client",+ name: "Partial consent client",+ registration_type: "pre_registered",+ trust_state: "approved",+ redirect_uris: ["http://127.0.0.1/callback"],+ )++ get "/oauth2/mcp/authorize",+ params: {+ client_id: client.client_id,+ redirect_uri: client.redirect_uris.first,+ response_type: "code",+ code_challenge: "a" * 43,+ code_challenge_method: "S256",+ resource: DiscourseMcp.resource_url,+ scope: "mcp:profile:read mcp:content:read mcp:content:write",+ }++ expect(response.status).to eq(200)+ document = Nokogiri.HTML5(response.body)+ expect(document.at_css(".mcp-consent__scope-summary").text.squish).to eq(+ "Partial consent client requested 3 permissions. Your account is eligible for 1.",+ )+ expect(document.css(".mcp-consent__granted-scopes code").map(&:text)).to eq(+ ["mcp:profile:read"],+ )+ end++ it "grants only the requested scopes available to the user" do+ sign_in(user)+ group = Fabricate(:group)+ group.add(user)+ McpGroupScope.create!(group:, scope: "mcp:profile:read")+ client =+ McpOauthClient.create!(+ client_id: "partial-grant-client",+ name: "Partial grant client",+ registration_type: "pre_registered",+ trust_state: "approved",+ redirect_uris: ["http://127.0.0.1/callback"],+ )++ post "/oauth2/mcp/authorize",+ params: {+ client_id: client.client_id,+ redirect_uri: client.redirect_uris.first,+ response_type: "code",+ code_challenge: "a" * 43,+ code_challenge_method: "S256",+ resource: DiscourseMcp.resource_url,+ scope: "mcp:profile:read mcp:content:read mcp:content:write",+ decision: "approve",+ }++ expect(response).to redirect_to(/\A#{Regexp.escape(client.redirect_uris.first)}\?code=/)+ expect(McpOauthAuthorization.find_by(user:, client:).scopes).to eq(["mcp:profile:read"])+ end++ it "authorizes a loopback redirect using the client's active port" do+ client =+ McpOauthClient.create!(+ client_id: "loopback-client",+ name: "Loopback client",+ registration_type: "pre_registered",+ trust_state: "approved",+ redirect_uris: ["http://127.0.0.1/callback"],+ )+ redirect_uri = "http://127.0.0.1:49152/callback"++ post "/oauth2/mcp/authorize",+ params: {+ client_id: client.client_id,+ redirect_uri: redirect_uri,+ response_type: "code",+ code_challenge: "a" * 43,+ code_challenge_method: "S256",+ resource: DiscourseMcp.resource_url,+ scope: "mcp:profile:read",+ decision: "approve",+ }++ expect(response).to redirect_to(/\A#{Regexp.escape(redirect_uri)}\?code=/)+ end++ it "rejects users without MCP access before registering a metadata client" do+ sign_in(user)+ client_id = "https://client.example.com/oauth/client.json"+ redirect_uri = "https://client.example.com/callback"+ SiteSetting.mcp_oauth_client_id_metadata_policy = "approved_domains"+ SiteSetting.mcp_oauth_client_id_metadata_domains = "client.example.com"+ allow(DiscourseMcp::OAuth::ClientResolver).to receive(:fetch_metadata).and_return(+ {+ "client_id" => client_id,+ "client_name" => "Metadata client",+ "redirect_uris" => [redirect_uri],+ },+ )++ get "/oauth2/mcp/authorize",+ params: {+ client_id:,+ redirect_uri:,+ response_type: "code",+ code_challenge: "a" * 43,+ code_challenge_method: "S256",+ resource: DiscourseMcp.resource_url,+ scope: "mcp:profile:read",+ }++ expect(response.status).to eq(403)+ expect(McpOauthClient.find_by(client_id:)).to eq(nil)+ end++ it "rate limits metadata lookups across unique client IDs" do+ SiteSetting.mcp_oauth_client_id_metadata_policy = "any_domain"+ RateLimiter.enable+ allow(DiscourseMcp::OAuth::ClientResolver).to receive(:fetch_metadata) do |uri|+ {+ "client_id" => uri.to_s,+ "client_name" => "Metadata client",+ "redirect_uris" => ["https://client.example.com/callback"],+ }+ end++ 11.times do |index|+ get "/oauth2/mcp/authorize",+ params: {+ client_id: "https://client.example.com/oauth/client-#{index}.json",+ redirect_uri: "https://client.example.com/callback",+ response_type: "code",+ code_challenge: "a" * 43,+ code_challenge_method: "S256",+ resource: DiscourseMcp.resource_url,+ scope: "mcp:profile:read",+ }+ end++ expect(response.status).to eq(429)+ end+enddiff --git a/spec/requests/mcp_oauth_metadata_controller_spec.rb b/spec/requests/mcp_oauth_metadata_controller_spec.rbnew file mode 100644index 00000000000..8cb0cb92bf1--- /dev/null+++ b/spec/requests/mcp_oauth_metadata_controller_spec.rb@@ -0,0 +1,44 @@+# frozen_string_literal: true++describe McpOauthMetadataController do+ before { SiteSetting.mcp_server_enabled = true }++ it "advertises the initial scope in protected resource metadata" do+ get "/.well-known/oauth-protected-resource/mcp"++ expect(response.status).to eq(200)+ expect(response.parsed_body["scopes_supported"]).to eq(["mcp:profile:read"])+ end++ it "advertises every registered scope in authorization server metadata" do+ get "/.well-known/oauth-authorization-server"++ expect(response.status).to eq(200)+ expect(response.parsed_body["scopes_supported"]).to eq(DiscourseMcp.registry.scopes)+ end++ it "advertises client ID metadata documents by default" do+ get "/.well-known/oauth-authorization-server"++ expect(response.status).to eq(200)+ expect(response.parsed_body["client_id_metadata_document_supported"]).to eq(true)+ end++ it "does not advertise client ID metadata documents when clients must be pre-registered" do+ SiteSetting.mcp_oauth_client_id_metadata_policy = "disabled"++ get "/.well-known/oauth-authorization-server"++ expect(response.status).to eq(200)+ expect(response.parsed_body["client_id_metadata_document_supported"]).to eq(false)+ end++ it "advertises client ID metadata documents when approved domains may register clients" do+ SiteSetting.mcp_oauth_client_id_metadata_policy = "approved_domains"++ get "/.well-known/oauth-authorization-server"++ expect(response.status).to eq(200)+ expect(response.parsed_body["client_id_metadata_document_supported"]).to eq(true)+ end+enddiff --git a/spec/requests/mcp_oauth_tokens_controller_spec.rb b/spec/requests/mcp_oauth_tokens_controller_spec.rbnew file mode 100644index 00000000000..637c17ab143--- /dev/null+++ b/spec/requests/mcp_oauth_tokens_controller_spec.rb@@ -0,0 +1,58 @@+# frozen_string_literal: true++describe McpOauthTokensController do+ fab!(:user)+ fab!(:group)++ let(:client) do+ McpOauthClient.create!(+ client_id: "token-controller-spec-client",+ name: "Token controller spec client",+ registration_type: "pre_registered",+ trust_state: "approved",+ redirect_uris: ["http://127.0.0.1/callback"],+ )+ end+ let(:authorization) do+ DiscourseMcp::OAuth::AuthorizationGrant.create!(+ user:,+ client:,+ redirect_uri: client.redirect_uris.first,+ requested_scopes: ["mcp:profile:read"],+ )+ end+ let(:verifier) { "v" * 43 }+ let(:challenge) { Base64.urlsafe_encode64(Digest::SHA256.digest(verifier), padding: false) }++ before do+ SiteSetting.mcp_server_enabled = true+ group.add(user)+ McpGroupScope.create!(group:, scope: "mcp:profile:read")+ end++ describe "#create" do+ it "returns invalid_grant when the authorization no longer exists" do+ code =+ McpOauthAuthorizationCode.issue!(+ authorization:,+ redirect_uri: client.redirect_uris.first,+ resource: DiscourseMcp.resource_url,+ code_challenge: challenge,+ )+ authorization.delete++ post "/oauth2/mcp/token",+ params: {+ grant_type: "authorization_code",+ code:,+ client_id: client.client_id,+ redirect_uri: client.redirect_uris.first,+ code_verifier: verifier,+ resource: DiscourseMcp.resource_url,+ }++ expect(response.status).to eq(400)+ expect(response.parsed_body).to eq("error" => "invalid_grant")+ end+ end+enddiff --git a/spec/requests/mcp_user_authorizations_controller_spec.rb b/spec/requests/mcp_user_authorizations_controller_spec.rbnew file mode 100644index 00000000000..2f26d318ea2--- /dev/null+++ b/spec/requests/mcp_user_authorizations_controller_spec.rb@@ -0,0 +1,41 @@+# frozen_string_literal: true++describe McpUserAuthorizationsController do+ fab!(:user)+ fab!(:group)+ fab!(:other_group, :group)++ before do+ sign_in(user)+ SiteSetting.mcp_server_enabled = true+ group.add(user)+ other_group.add(user)+ end++ it "returns access removed only after all matching groups lose a granted scope" do+ McpGroupScope.create!(group: group, scope: "mcp:profile:read")+ McpGroupScope.create!(group: other_group, scope: "mcp:profile:read")+ client =+ McpOauthClient.create!(+ client_id: "user-authorizations-spec-client",+ name: "User authorizations spec client",+ registration_type: "pre_registered",+ trust_state: "approved",+ redirect_uris: ["http://127.0.0.1/callback"],+ )+ DiscourseMcp::OAuth::AuthorizationGrant.create!(+ user: user,+ client: client,+ redirect_uri: client.redirect_uris.first,+ requested_scopes: ["mcp:profile:read"],+ )++ McpGroupScope.where(group: group).delete_all+ get "/u/#{user.username}/preferences/mcp-authorizations.json"+ expect(response.parsed_body.dig("authorizations", 0, "status")).to eq("active")++ McpGroupScope.where(group: other_group).delete_all+ get "/u/#{user.username}/preferences/mcp-authorizations.json"+ expect(response.parsed_body.dig("authorizations", 0, "status")).to eq("access_removed")+ end+enddiff --git a/spec/serializers/user_serializer_spec.rb b/spec/serializers/user_serializer_spec.rbindex a0b9cfcea38..97c5913ebd1 100644--- a/spec/serializers/user_serializer_spec.rb+++ b/spec/serializers/user_serializer_spec.rb@@ -658,6 +658,42 @@ RSpec.describe UserSerializer doendend+ context "with MCP authorization visibility" do+ it "includes MCP authorizations for the current user while authorization history exists" do+ SiteSetting.mcp_server_enabled = false+ client =+ McpOauthClient.create!(+ client_id: "user-serializer-mcp-client",+ name: "User serializer MCP client",+ registration_type: "pre_registered",+ trust_state: "approved",+ redirect_uris: ["http://127.0.0.1/callback"],+ )+ authorization =+ McpOauthAuthorization.create!(+ user: user,+ client: client,+ resource: DiscourseMcp.resource_url,+ status: "consent_required",+ client_metadata_hash: client.metadata_hash,+ consented_at: Time.zone.now,+ )++ json = UserSerializer.new(user, scope: Guardian.new(user), root: false).as_json+ expect(json[:show_mcp_authorizations]).to eq(true)++ authorization.revoke!(by_user: user)+ json = UserSerializer.new(user, scope: Guardian.new(user), root: false).as_json+ expect(json[:show_mcp_authorizations]).to eq(true)+ end++ it "does not expose MCP authorization visibility to another profile viewer" do+ json = UserSerializer.new(user, scope: Guardian.new(Fabricate(:admin)), root: false).as_json++ expect(json).not_to have_key(:show_mcp_authorizations)+ end+ end+context "with groups" dofab!(:group) doFabricate(diff --git a/spec/services/mcp_access_rule_updater_spec.rb b/spec/services/mcp_access_rule_updater_spec.rbnew file mode 100644index 00000000000..8b9373ec29b--- /dev/null+++ b/spec/services/mcp_access_rule_updater_spec.rb@@ -0,0 +1,48 @@+# frozen_string_literal: true++describe McpAccessRuleUpdater do+ fab!(:admin)+ fab!(:group)++ it "always includes the initial scope in group access" do+ logger = instance_spy(StaffActionLogger, log_custom: nil)+ allow(StaffActionLogger).to receive(:new).with(admin).and_return(logger)++ described_class.replace!(actor: admin, group_id: group.id, scopes: ["mcp:content:read"])++ expect(McpGroupScope.where(group:).order(:scope).pluck(:scope)).to eq(+ %w[mcp:content:read mcp:profile:read],+ )+ end++ it "keeps the previous access rule when staff logging fails" do+ McpGroupScope.create!(group:, scope: "mcp:profile:read")+ logger = instance_spy(StaffActionLogger)+ allow(StaffActionLogger).to receive(:new).with(admin).and_return(logger)+ allow(logger).to receive(:log_custom).and_raise(StandardError)++ expect do+ described_class.replace!(+ actor: admin,+ group_id: group.id,+ scopes: %w[mcp:content:read mcp:content:write],+ )+ end.to raise_error(StandardError)++ expect(McpGroupScope.where(group:).pluck(:scope)).to eq(["mcp:profile:read"])+ end++ it "logs the scopes removed with a group access rule" do+ McpGroupScope.create!(group:, scope: "mcp:profile:read")+ logger = instance_spy(StaffActionLogger, log_custom: nil)+ allow(StaffActionLogger).to receive(:new).with(admin).and_return(logger)++ described_class.delete!(actor: admin, group_id: group.id)++ expect(logger).to have_received(:log_custom).with(+ "mcp_access_rule_deleted",+ group_id: group.id,+ scopes: ["mcp:profile:read"],+ )+ end+enddiff --git a/spec/services/mcp_oauth_clients_page_spec.rb b/spec/services/mcp_oauth_clients_page_spec.rbnew file mode 100644index 00000000000..89a3c3646a6--- /dev/null+++ b/spec/services/mcp_oauth_clients_page_spec.rb@@ -0,0 +1,31 @@+# frozen_string_literal: true++describe McpOauthClientsPage do+ fab!(:user)+ fab!(:other_user, :user)++ it "returns authorization counts without loading authorization records" do+ client =+ McpOauthClient.create!(+ client_id: "counted-client",+ name: "Counted client",+ registration_type: "pre_registered",+ trust_state: "approved",+ redirect_uris: ["https://client.example.com/callback"],+ )+ [user, other_user].each do |authorization_user|+ McpOauthAuthorization.create!(+ user: authorization_user,+ client:,+ resource: DiscourseMcp.resource_url,+ status: "active",+ consented_at: Time.current,+ )+ end++ record = described_class.new(limit: 50).call.records.first++ expect(record.authorization_count).to eq(2)+ expect(record.association(:authorizations)).not_to be_loaded+ end+enddiff --git a/spec/services/mcp_primitive_updater_spec.rb b/spec/services/mcp_primitive_updater_spec.rbnew file mode 100644index 00000000000..0de24ce3d35--- /dev/null+++ b/spec/services/mcp_primitive_updater_spec.rb@@ -0,0 +1,76 @@+# frozen_string_literal: true++describe McpPrimitiveUpdater do+ fab!(:admin)++ it "updates primitive exposure and logs the enabled primitive count" do+ McpPrimitive.create!(kind: "tool", identifier: "discourse_search", enabled: true)+ logger = instance_spy(StaffActionLogger, log_custom: nil)+ allow(StaffActionLogger).to receive(:new).with(admin).and_return(logger)++ described_class.update!(actor: admin, primitive_ids: ["tool:discourse_current_user_get"])++ expect(+ McpPrimitive.find_by!(kind: "tool", identifier: "discourse_current_user_get"),+ ).to be_enabled+ expect(McpPrimitive.find_by!(kind: "tool", identifier: "discourse_search")).not_to be_enabled+ expect(logger).to have_received(:log_custom).with("mcp_primitives_updated", primitive_count: 1)+ end++ it "keeps the previous exposure when staff logging fails" do+ primitive =+ McpPrimitive.create!(kind: "tool", identifier: "discourse_current_user_get", enabled: false)+ logger = instance_spy(StaffActionLogger)+ allow(StaffActionLogger).to receive(:new).with(admin).and_return(logger)+ allow(logger).to receive(:log_custom).and_raise(StandardError, "staff logging failed")++ expect do+ described_class.update!(actor: admin, primitive_ids: ["tool:discourse_current_user_get"])+ end.to raise_error(StandardError, "staff logging failed")++ expect(primitive.reload).not_to be_enabled+ end++ it "changes the emergency block inside the staff logging transaction" do+ primitive =+ McpPrimitive.create!(kind: "tool", identifier: "discourse_current_user_get", enabled: true)+ logger = instance_spy(StaffActionLogger)+ allow(StaffActionLogger).to receive(:new).with(admin).and_return(logger)+ allow(logger).to receive(:log_custom).and_raise(StandardError, "staff logging failed")++ expect do+ described_class.set_emergency_block!(+ actor: admin,+ primitive_id: "tool:discourse_current_user_get",+ blocked: true,+ )+ end.to raise_error(StandardError, "staff logging failed")++ expect(primitive.reload).not_to be_emergency_blocked+ end++ it "requires fresh consent when unblocking a consent-relevant primitive" do+ primitive =+ McpPrimitive.create!(+ kind: "tool",+ identifier: "discourse_post_set_deleted",+ enabled: true,+ emergency_blocked: true,+ )+ logger = instance_spy(StaffActionLogger, log_custom: nil)+ allow(StaffActionLogger).to receive(:new).with(admin).and_return(logger)+ allow(McpOauthAuthorization).to receive(:require_consent!)++ described_class.set_emergency_block!(+ actor: admin,+ primitive_id: "tool:discourse_post_set_deleted",+ blocked: false,+ )++ expect(primitive.reload).not_to be_emergency_blocked+ expect(primitive.consent_required_at).to be_present+ expect(McpOauthAuthorization).to have_received(:require_consent!).with(+ scopes: ["mcp:content:write"],+ )+ end+enddiff --git a/spec/system/admin_site_setting_requires_confirmation_spec.rb b/spec/system/admin_site_setting_requires_confirmation_spec.rbindex 298e2266ef7..7db39b2153a 100644--- a/spec/system/admin_site_setting_requires_confirmation_spec.rb+++ b/spec/system/admin_site_setting_requires_confirmation_spec.rb@@ -63,6 +63,23 @@ describe "Admin Site Setting Requires Confirmation" dosettings_page.toggle_bool_setting("can_permanently_delete")expect(dialog).to be_closedend++ it "explains the effect of enabling the MCP server" do+ settings_page.visit("mcp_server_enabled")+ settings_page.toggle_bool_setting("mcp_server_enabled")++ expect(dialog).to be_open+ expect(dialog).to have_content(+ I18n.t(+ "admin_js.admin.site_settings.requires_confirmation_messages.mcp_server_enabled.prompt",+ ),+ )+ expect(dialog).to have_content(+ I18n.t(+ "admin_js.admin.site_settings.requires_confirmation_messages.mcp_server_enabled.confirm",+ ),+ )+ endendcontext "with simple_on_disable confirmation type" do