A platform for community discussion. Free, open, simple.
# 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",
admin_managed: true,
),
)
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 update
McpOauthClient.transaction do
client.update_registration!(params.require(:client).permit(:name, redirect_uris: []))
StaffActionLogger.new(current_user).log_custom(
"mcp_client_updated",
client_id: client.id,
changes: client.saved_changes.except("updated_at"),
)
end
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,
admin_managed: value.admin_managed,
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