Skip to content

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.scss
index 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.scss
new file mode 100644
index 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.rb
new file mode 100644
index 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
+end
diff --git a/app/controllers/admin/mcp_authorizations_controller.rb b/app/controllers/admin/mcp_authorizations_controller.rb
new file mode 100644
index 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
+end
diff --git a/app/controllers/admin/mcp_clients_controller.rb b/app/controllers/admin/mcp_clients_controller.rb
new file mode 100644
index 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
+end
diff --git a/app/controllers/admin/mcp_controller.rb b/app/controllers/admin/mcp_controller.rb
new file mode 100644
index 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
+end
diff --git a/app/controllers/mcp_controller.rb b/app/controllers/mcp_controller.rb
new file mode 100644
index 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
+end
diff --git a/app/controllers/mcp_oauth_authorizations_controller.rb b/app/controllers/mcp_oauth_authorizations_controller.rb
new file mode 100644
index 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
+end
diff --git a/app/controllers/mcp_oauth_metadata_controller.rb b/app/controllers/mcp_oauth_metadata_controller.rb
new file mode 100644
index 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
+end
diff --git a/app/controllers/mcp_oauth_tokens_controller.rb b/app/controllers/mcp_oauth_tokens_controller.rb
new file mode 100644
index 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
+end
diff --git a/app/controllers/mcp_user_authorizations_controller.rb b/app/controllers/mcp_user_authorizations_controller.rb
new file mode 100644
index 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
+end
diff --git a/app/jobs/scheduled/clean_up_mcp_records.rb b/app/jobs/scheduled/clean_up_mcp_records.rb
new file mode 100644
index 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
+end
diff --git a/app/models/group.rb b/app/models/group.rb
index 4154bf19767..db452d83d71 100644
--- a/app/models/group.rb
+++ b/app/models/group.rb
@@ -37,6 +37,7 @@ class Group < ActiveRecord::Base
has_many :group_requests, dependent: :destroy
has_many :group_mentions, dependent: :destroy
has_many :group_associated_groups, dependent: :destroy
+ has_many :mcp_group_scopes, dependent: :destroy
has_many :group_archived_messages, dependent: :destroy
diff --git a/app/models/mcp_audit_log.rb b/app/models/mcp_audit_log.rb
new file mode 100644
index 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.rb
new file mode 100644
index 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.rb
new file mode 100644
index 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.rb
new file mode 100644
index 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.rb
new file mode 100644
index 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.rb
new file mode 100644
index 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.rb
new file mode 100644
index 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.rb
new file mode 100644
index 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
+end
diff --git a/app/models/mcp_oauth_refresh_token.rb b/app/models/mcp_oauth_refresh_token.rb
new file mode 100644
index 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.rb
new file mode 100644
index 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.rb
index 5d39c96260a..b7a22d5d8f3 100644
--- a/app/models/site_setting.rb
+++ b/app/models/site_setting.rb
@@ -24,6 +24,7 @@ class SiteSetting < ActiveRecord::Base
interface
legal
localization
+ mcp
navigation
notifications
permalinks
diff --git a/app/models/user.rb b/app/models/user.rb
index c170deeeb6a..59af9eaac75 100644
--- a/app/models/user.rb
+++ b/app/models/user.rb
@@ -24,6 +24,8 @@ class User < ActiveRecord::Base
has_many :category_users, dependent: :destroy
has_many :tag_users, dependent: :destroy
has_many :user_api_keys, dependent: :destroy
+ has_many :mcp_oauth_authorizations, dependent: :destroy
+ has_many :mcp_oauth_access_tokens, dependent: :destroy
has_many :topic_allowed_users, dependent: :destroy
has_many :user_archived_messages, dependent: :destroy
has_many :email_change_requests, dependent: :destroy
diff --git a/app/serializers/user_serializer.rb b/app/serializers/user_serializer.rb
index 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_authorizations
has_one :invited_by, embed: :object, serializer: BasicUserSerializer
has_many :groups, embed: :object, serializer: BasicGroupSerializer
@@ -150,6 +151,15 @@ class UserSerializer < UserCardSerializer
scope.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_keys
keys =
object
diff --git a/app/services/mcp_access_rule_updater.rb b/app/services/mcp_access_rule_updater.rb
new file mode 100644
index 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
+end
diff --git a/app/services/mcp_activity_report.rb b/app/services/mcp_activity_report.rb
new file mode 100644
index 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
+end
diff --git a/app/services/mcp_oauth_authorizations_page.rb b/app/services/mcp_oauth_authorizations_page.rb
new file mode 100644
index 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
+end
diff --git a/app/services/mcp_oauth_clients_page.rb b/app/services/mcp_oauth_clients_page.rb
new file mode 100644
index 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
+end
diff --git a/app/services/mcp_primitive_updater.rb b/app/services/mcp_primitive_updater.rb
new file mode 100644
index 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
+end
diff --git a/app/services/user_merger.rb b/app/services/user_merger.rb
index 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.erb
new file mode 100644
index 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.rb
new file mode 100644
index 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
+end
diff --git a/config/locales/client.en.yml b/config/locales/client.en.yml
index 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.yml
index 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.rb
index 853adde73c5..e3d0bbfeb72 100644
--- a/config/routes.rb
+++ b/config/routes.rb
@@ -425,6 +425,8 @@ Discourse::Application.routes.draw do
get "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 do
get "/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.yml
index 829f249de0e..f36a365c58e 100644
--- a/config/site_settings.yml
+++ b/config/site_settings.yml
@@ -4478,6 +4478,73 @@ user_preferences:
default: false
area: "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: 30
diff --git a/db/migrate/20260807000920_create_mcp_server_tables.rb b/db/migrate/20260807000920_create_mcp_server_tables.rb
new file mode 100644
index 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
+end
diff --git a/db/structure.sql b/db/structure.sql
index b98132f04b7..172e576eec5 100644
--- a/db/structure.sql
+++ b/db/structure.sql
@@ -7299,6 +7299,347 @@ CREATE SEQUENCE public.llm_quotas_id_seq
ALTER 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('pu
ALTER 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_quotas
ADD 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_s
CREATE 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 USIN
CREATE 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.gjs
new file mode 100644
index 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.js
new file mode 100644
index 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.js
new file mode 100644
index 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.js
new file mode 100644
index 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.js
new file mode 100644
index 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.js
new file mode 100644
index 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.js
new file mode 100644
index 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.js
new file mode 100644
index 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.js
new file mode 100644
index 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.js
new file mode 100644
index 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.js
new file mode 100644
index 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.js
new file mode 100644
index 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.js
index 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.gjs
new file mode 100644
index 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.gjs
new file mode 100644
index 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.gjs
new file mode 100644
index 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.gjs
new file mode 100644
index 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.gjs
new file mode 100644
index 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.gjs
new file mode 100644
index 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.gjs
new file mode 100644
index 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.gjs
new file mode 100644
index 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.gjs
new file mode 100644
index 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.gjs
new file mode 100644
index 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.gjs
new file mode 100644
index 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.gjs
new file mode 100644
index 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.gjs
new file mode 100644
index 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.gjs
new file mode 100644
index 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.gjs
new file mode 100644
index 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"
+ }}</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.js
index 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.gjs
index 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>
<PluginOutlet
diff --git a/frontend/discourse/tests/acceptance/admin-mcp-test.js b/frontend/discourse/tests/acceptance/admin-mcp-test.js
new file mode 100644
index 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.js
index 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.js
index 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.gjs
new file mode 100644
index 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.rb
index 33bf6327587..c9b549507ab 100644
--- a/lib/content_security_policy/middleware.rb
+++ b/lib/content_security_policy/middleware.rb
@@ -14,17 +14,24 @@ class ContentSecurityPolicy
return 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 trusted
protocol = (SiteSetting.force_https || request.ssl?) ? "https://" : "http://"
base_url = protocol + request.host_with_port + Discourse.base_path
theme_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
+ )
+ end
headers["Content-Security-Policy-Report-Only"] = policy(
theme_id,
base_url: base_url,
@@ -39,6 +46,13 @@ class ContentSecurityPolicy
delegate :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/
end
diff --git a/lib/discourse_mcp.rb b/lib/discourse_mcp.rb
new file mode 100644
index 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
+end
diff --git a/lib/discourse_mcp/access.rb b/lib/discourse_mcp/access.rb
new file mode 100644
index 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
+end
diff --git a/lib/discourse_mcp/authenticator.rb b/lib/discourse_mcp/authenticator.rb
new file mode 100644
index 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
+end
diff --git a/lib/discourse_mcp/authorization_status.rb b/lib/discourse_mcp/authorization_status.rb
new file mode 100644
index 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
+end
diff --git a/lib/discourse_mcp/catalog.rb b/lib/discourse_mcp/catalog.rb
new file mode 100644
index 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
+end
diff --git a/lib/discourse_mcp/core_primitives.rb b/lib/discourse_mcp/core_primitives.rb
new file mode 100644
index 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
+end
diff --git a/lib/discourse_mcp/core_tools.rb b/lib/discourse_mcp/core_tools.rb
new file mode 100644
index 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
+end
diff --git a/lib/discourse_mcp/oauth.rb b/lib/discourse_mcp/oauth.rb
new file mode 100644
index 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
+end
diff --git a/lib/discourse_mcp/primitive.rb b/lib/discourse_mcp/primitive.rb
new file mode 100644
index 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
+end
diff --git a/lib/discourse_mcp/registry.rb b/lib/discourse_mcp/registry.rb
new file mode 100644
index 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
+end
diff --git a/lib/discourse_mcp/request_context.rb b/lib/discourse_mcp/request_context.rb
new file mode 100644
index 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
+end
diff --git a/lib/discourse_mcp/server.rb b/lib/discourse_mcp/server.rb
new file mode 100644
index 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
+end
diff --git a/lib/plugin/instance.rb b/lib/plugin/instance.rb
index 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.rb
new file mode 100644
index 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
+end
diff --git a/plugins/chat/plugin.rb b/plugins/chat/plugin.rb
index d40208e2cd5..4e20149c93f 100644
--- a/plugins/chat/plugin.rb
+++ b/plugins/chat/plugin.rb
@@ -646,3 +646,83 @@ after_initialize do
DiscoursePluginRegistry.discourse_dev_populate_reviewable_types.add DiscourseDev::ReviewableMessage
end
end
+
+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 },
+ )
+end
diff --git a/plugins/discourse-events/lib/discourse_events/mcp_tools.rb b/plugins/discourse-events/lib/discourse_events/mcp_tools.rb
new file mode 100644
index 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
+end
diff --git a/plugins/discourse-events/plugin.rb b/plugins/discourse-events/plugin.rb
index dfd17a53d9f..7d1f2ef43b4 100644
--- a/plugins/discourse-events/plugin.rb
+++ b/plugins/discourse-events/plugin.rb
@@ -1062,3 +1062,32 @@ after_initialize do
DiscourseEvents::Livestream.publish_livestream_chat_status(membership, user: user) if membership
end
end
+
+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,
+ )
+end
diff --git a/plugins/discourse-events/spec/lib/discourse_events/mcp_tools_spec.rb b/plugins/discourse-events/spec/lib/discourse_events/mcp_tools_spec.rb
new file mode 100644
index 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
+end
diff --git a/plugins/discourse-reactions/config/locales/server.en.yml b/plugins/discourse-reactions/config/locales/server.en.yml
index 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.rb
new file mode 100644
index 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
+end
diff --git a/plugins/discourse-reactions/plugin.rb b/plugins/discourse-reactions/plugin.rb
index 59f78ddc884..17767aa88c1 100644
--- a/plugins/discourse-reactions/plugin.rb
+++ b/plugins/discourse-reactions/plugin.rb
@@ -434,3 +434,36 @@ after_initialize do
end
end
end
+
+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 },
+ )
+end
diff --git a/plugins/discourse-reactions/spec/lib/discourse_reactions/mcp_tools_spec.rb b/plugins/discourse-reactions/spec/lib/discourse_reactions/mcp_tools_spec.rb
new file mode 100644
index 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
+end
diff --git a/plugins/discourse-solved/lib/discourse_solved/mcp_tools.rb b/plugins/discourse-solved/lib/discourse_solved/mcp_tools.rb
new file mode 100644
index 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
+end
diff --git a/plugins/discourse-solved/plugin.rb b/plugins/discourse-solved/plugin.rb
index 339c1837eb9..2031047915e 100644
--- a/plugins/discourse-solved/plugin.rb
+++ b/plugins/discourse-solved/plugin.rb
@@ -483,3 +483,34 @@ after_initialize do
DiscourseDev::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 },
+ )
+end
diff --git a/plugins/discourse-topic-voting/lib/discourse_topic_voting/mcp_tools.rb b/plugins/discourse-topic-voting/lib/discourse_topic_voting/mcp_tools.rb
new file mode 100644
index 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
+end
diff --git a/plugins/discourse-topic-voting/plugin.rb b/plugins/discourse-topic-voting/plugin.rb
index 0f22b414eca..3c2ca21fca2 100755
--- a/plugins/discourse-topic-voting/plugin.rb
+++ b/plugins/discourse-topic-voting/plugin.rb
@@ -253,3 +253,34 @@ after_initialize do
)
end
end
+
+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 },
+ )
+end
diff --git a/script/mcp_client_interop b/script/mcp_client_interop
new file mode 100755
index 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.rb
new file mode 100644
index 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
+end
diff --git a/spec/lib/discourse_mcp/access_spec.rb b/spec/lib/discourse_mcp/access_spec.rb
new file mode 100644
index 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
+end
diff --git a/spec/lib/discourse_mcp/authorization_status_spec.rb b/spec/lib/discourse_mcp/authorization_status_spec.rb
new file mode 100644
index 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
+end
diff --git a/spec/lib/discourse_mcp/core_tools_spec.rb b/spec/lib/discourse_mcp/core_tools_spec.rb
new file mode 100644
index 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
+end
diff --git a/spec/lib/discourse_mcp/oauth_spec.rb b/spec/lib/discourse_mcp/oauth_spec.rb
new file mode 100644
index 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
+end
diff --git a/spec/models/mcp_oauth_client_id_metadata_policy_spec.rb b/spec/models/mcp_oauth_client_id_metadata_policy_spec.rb
new file mode 100644
index 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
+end
diff --git a/spec/models/mcp_oauth_client_spec.rb b/spec/models/mcp_oauth_client_spec.rb
new file mode 100644
index 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
+end
diff --git a/spec/models/mcp_oauth_refresh_token_spec.rb b/spec/models/mcp_oauth_refresh_token_spec.rb
new file mode 100644
index 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
+end
diff --git a/spec/models/mcp_primitive_spec.rb b/spec/models/mcp_primitive_spec.rb
new file mode 100644
index 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
+end
diff --git a/spec/requests/admin/mcp_activity_controller_spec.rb b/spec/requests/admin/mcp_activity_controller_spec.rb
new file mode 100644
index 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
+end
diff --git a/spec/requests/admin/mcp_authorizations_controller_spec.rb b/spec/requests/admin/mcp_authorizations_controller_spec.rb
new file mode 100644
index 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
+end
diff --git a/spec/requests/admin/mcp_clients_controller_spec.rb b/spec/requests/admin/mcp_clients_controller_spec.rb
new file mode 100644
index 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
+end
diff --git a/spec/requests/admin/mcp_controller_spec.rb b/spec/requests/admin/mcp_controller_spec.rb
new file mode 100644
index 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
+end
diff --git a/spec/requests/mcp_controller_spec.rb b/spec/requests/mcp_controller_spec.rb
new file mode 100644
index 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
+end
diff --git a/spec/requests/mcp_oauth_authorizations_controller_spec.rb b/spec/requests/mcp_oauth_authorizations_controller_spec.rb
new file mode 100644
index 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
+end
diff --git a/spec/requests/mcp_oauth_metadata_controller_spec.rb b/spec/requests/mcp_oauth_metadata_controller_spec.rb
new file mode 100644
index 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
+end
diff --git a/spec/requests/mcp_oauth_tokens_controller_spec.rb b/spec/requests/mcp_oauth_tokens_controller_spec.rb
new file mode 100644
index 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
+end
diff --git a/spec/requests/mcp_user_authorizations_controller_spec.rb b/spec/requests/mcp_user_authorizations_controller_spec.rb
new file mode 100644
index 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
+end
diff --git a/spec/serializers/user_serializer_spec.rb b/spec/serializers/user_serializer_spec.rb
index a0b9cfcea38..97c5913ebd1 100644
--- a/spec/serializers/user_serializer_spec.rb
+++ b/spec/serializers/user_serializer_spec.rb
@@ -658,6 +658,42 @@ RSpec.describe UserSerializer do
end
end
+ 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" do
fab!(:group) do
Fabricate(
diff --git a/spec/services/mcp_access_rule_updater_spec.rb b/spec/services/mcp_access_rule_updater_spec.rb
new file mode 100644
index 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
+end
diff --git a/spec/services/mcp_oauth_clients_page_spec.rb b/spec/services/mcp_oauth_clients_page_spec.rb
new file mode 100644
index 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
+end
diff --git a/spec/services/mcp_primitive_updater_spec.rb b/spec/services/mcp_primitive_updater_spec.rb
new file mode 100644
index 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
+end
diff --git a/spec/system/admin_site_setting_requires_confirmation_spec.rb b/spec/system/admin_site_setting_requires_confirmation_spec.rb
index 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" do
settings_page.toggle_bool_setting("can_permanently_delete")
expect(dialog).to be_closed
end
+
+ 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",
+ ),
+ )
+ end
end
context "with simple_on_disable confirmation type" do