strapi-oauth-mcp-manager 0.1.0

package/dist/server/src/bootstrap.d.ts

@@ -0,0 +1,5 @@
+import type { Core } from '@strapi/strapi';
+declare const bootstrap: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => Promise<void>;
+export default bootstrap;

package/dist/server/src/config/index.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    default: {};
+    validator(): void;
+};
+export default _default;

package/dist/server/src/content-types/index.d.ts

@@ -0,0 +1,208 @@
+declare const _default: {
+    'mcp-oauth-client': {
+        schema: {
+            kind: string;
+            collectionName: string;
+            info: {
+                singularName: string;
+                pluralName: string;
+                displayName: string;
+                description: string;
+            };
+            options: {
+                draftAndPublish: boolean;
+            };
+            pluginOptions: {
+                "content-manager": {
+                    visible: boolean;
+                };
+                "content-type-builder": {
+                    visible: boolean;
+                };
+            };
+            attributes: {
+                name: {
+                    type: string;
+                    required: boolean;
+                };
+                clientId: {
+                    type: string;
+                    required: boolean;
+                    unique: boolean;
+                };
+                clientSecret: {
+                    type: string;
+                    required: boolean;
+                    private: boolean;
+                };
+                redirectUris: {
+                    type: string;
+                    required: boolean;
+                };
+                strapiApiToken: {
+                    type: string;
+                    required: boolean;
+                    private: boolean;
+                };
+                description: {
+                    type: string;
+                };
+                active: {
+                    type: string;
+                    default: boolean;
+                };
+            };
+        };
+    };
+    'mcp-oauth-code': {
+        schema: {
+            kind: string;
+            collectionName: string;
+            info: {
+                singularName: string;
+                pluralName: string;
+                displayName: string;
+                description: string;
+            };
+            options: {
+                draftAndPublish: boolean;
+            };
+            pluginOptions: {
+                "content-manager": {
+                    visible: boolean;
+                };
+                "content-type-builder": {
+                    visible: boolean;
+                };
+            };
+            attributes: {
+                code: {
+                    type: string;
+                    required: boolean;
+                    unique: boolean;
+                };
+                clientId: {
+                    type: string;
+                    required: boolean;
+                };
+                redirectUri: {
+                    type: string;
+                    required: boolean;
+                };
+                codeChallenge: {
+                    type: string;
+                };
+                codeChallengeMethod: {
+                    type: string;
+                };
+                expiresAt: {
+                    type: string;
+                    required: boolean;
+                };
+                used: {
+                    type: string;
+                    default: boolean;
+                };
+            };
+        };
+    };
+    'mcp-oauth-token': {
+        schema: {
+            kind: string;
+            collectionName: string;
+            info: {
+                singularName: string;
+                pluralName: string;
+                displayName: string;
+                description: string;
+            };
+            options: {
+                draftAndPublish: boolean;
+            };
+            pluginOptions: {
+                "content-manager": {
+                    visible: boolean;
+                };
+                "content-type-builder": {
+                    visible: boolean;
+                };
+            };
+            attributes: {
+                accessToken: {
+                    type: string;
+                    required: boolean;
+                    unique: boolean;
+                    private: boolean;
+                };
+                refreshToken: {
+                    type: string;
+                    required: boolean;
+                    unique: boolean;
+                    private: boolean;
+                };
+                clientId: {
+                    type: string;
+                    required: boolean;
+                };
+                expiresAt: {
+                    type: string;
+                    required: boolean;
+                };
+                refreshExpiresAt: {
+                    type: string;
+                    required: boolean;
+                };
+                revoked: {
+                    type: string;
+                    default: boolean;
+                };
+            };
+        };
+    };
+    'mcp-endpoint': {
+        schema: {
+            kind: string;
+            collectionName: string;
+            info: {
+                singularName: string;
+                pluralName: string;
+                displayName: string;
+                description: string;
+            };
+            options: {
+                draftAndPublish: boolean;
+            };
+            pluginOptions: {
+                "content-manager": {
+                    visible: boolean;
+                };
+                "content-type-builder": {
+                    visible: boolean;
+                };
+            };
+            attributes: {
+                name: {
+                    type: string;
+                    required: boolean;
+                };
+                pluginId: {
+                    type: string;
+                    required: boolean;
+                };
+                path: {
+                    type: string;
+                    required: boolean;
+                    unique: boolean;
+                };
+                description: {
+                    type: string;
+                };
+                active: {
+                    type: string;
+                    default: boolean;
+                };
+            };
+        };
+    };
+};
+export default _default;

package/dist/server/src/controllers/index.d.ts

@@ -0,0 +1,11 @@
+declare const _default: {
+    oauth: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        discovery(ctx: any): Promise<void>;
+        protectedResource(ctx: any): Promise<void>;
+        authorize(ctx: any): Promise<void>;
+        token(ctx: any): Promise<void>;
+    };
+};
+export default _default;

package/dist/server/src/controllers/oauth.d.ts

@@ -0,0 +1,31 @@
+/**
+ * OAuth 2.0 Controller
+ *
+ * Handles OAuth authorization, token exchange, and discovery endpoints.
+ */
+import type { Core } from '@strapi/strapi';
+declare const oauthController: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    /**
+     * OAuth 2.0 Authorization Server Metadata (RFC 8414)
+     * GET /.well-known/oauth-authorization-server
+     */
+    discovery(ctx: any): Promise<void>;
+    /**
+     * OAuth 2.0 Protected Resource Metadata (RFC 9728)
+     * GET /.well-known/oauth-protected-resource
+     */
+    protectedResource(ctx: any): Promise<void>;
+    /**
+     * OAuth 2.0 Authorization Endpoint
+     * GET /oauth/authorize
+     */
+    authorize(ctx: any): Promise<void>;
+    /**
+     * OAuth 2.0 Token Endpoint
+     * POST /oauth/token
+     */
+    token(ctx: any): Promise<void>;
+};
+export default oauthController;

package/dist/server/src/destroy.d.ts

@@ -0,0 +1,5 @@
+import type { Core } from '@strapi/strapi';
+declare const destroy: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+export default destroy;

package/dist/server/src/index.d.ts

@@ -0,0 +1,278 @@
+declare const _default: {
+    register: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => void;
+    bootstrap: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => Promise<void>;
+    destroy: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => void;
+    config: {
+        default: {};
+        validator(): void;
+    };
+    controllers: {
+        oauth: ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            discovery(ctx: any): Promise<void>;
+            protectedResource(ctx: any): Promise<void>;
+            authorize(ctx: any): Promise<void>;
+            token(ctx: any): Promise<void>;
+        };
+    };
+    routes: {
+        'content-api': {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    auth: boolean;
+                    policies: any[];
+                };
+            }[];
+        };
+        admin: {
+            type: string;
+            routes: any[];
+        };
+    };
+    services: {
+        oauth: ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            validateToken(accessToken: string): Promise<import("./services/oauth").TokenValidationResult>;
+            revokeClientTokens(clientId: string): Promise<number>;
+            cleanupExpired(): Promise<{
+                tokens: number;
+                codes: number;
+            }>;
+        };
+        endpoint: ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            register(endpoint: import("./services/endpoint").EndpointRegistration): Promise<any>;
+            unregister(path: string): Promise<boolean>;
+            getAll(activeOnly?: boolean): Promise<any[]>;
+            getByPlugin(pluginId: string, activeOnly?: boolean): Promise<any[]>;
+            isProtected(path: string): Promise<boolean>;
+        };
+    };
+    contentTypes: {
+        'mcp-oauth-client': {
+            schema: {
+                kind: string;
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                    description: string;
+                };
+                options: {
+                    draftAndPublish: boolean;
+                };
+                pluginOptions: {
+                    "content-manager": {
+                        visible: boolean;
+                    };
+                    "content-type-builder": {
+                        visible: boolean;
+                    };
+                };
+                attributes: {
+                    name: {
+                        type: string;
+                        required: boolean;
+                    };
+                    clientId: {
+                        type: string;
+                        required: boolean;
+                        unique: boolean;
+                    };
+                    clientSecret: {
+                        type: string;
+                        required: boolean;
+                        private: boolean;
+                    };
+                    redirectUris: {
+                        type: string;
+                        required: boolean;
+                    };
+                    strapiApiToken: {
+                        type: string;
+                        required: boolean;
+                        private: boolean;
+                    };
+                    description: {
+                        type: string;
+                    };
+                    active: {
+                        type: string;
+                        default: boolean;
+                    };
+                };
+            };
+        };
+        'mcp-oauth-code': {
+            schema: {
+                kind: string;
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                    description: string;
+                };
+                options: {
+                    draftAndPublish: boolean;
+                };
+                pluginOptions: {
+                    "content-manager": {
+                        visible: boolean;
+                    };
+                    "content-type-builder": {
+                        visible: boolean;
+                    };
+                };
+                attributes: {
+                    code: {
+                        type: string;
+                        required: boolean;
+                        unique: boolean;
+                    };
+                    clientId: {
+                        type: string;
+                        required: boolean;
+                    };
+                    redirectUri: {
+                        type: string;
+                        required: boolean;
+                    };
+                    codeChallenge: {
+                        type: string;
+                    };
+                    codeChallengeMethod: {
+                        type: string;
+                    };
+                    expiresAt: {
+                        type: string;
+                        required: boolean;
+                    };
+                    used: {
+                        type: string;
+                        default: boolean;
+                    };
+                };
+            };
+        };
+        'mcp-oauth-token': {
+            schema: {
+                kind: string;
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                    description: string;
+                };
+                options: {
+                    draftAndPublish: boolean;
+                };
+                pluginOptions: {
+                    "content-manager": {
+                        visible: boolean;
+                    };
+                    "content-type-builder": {
+                        visible: boolean;
+                    };
+                };
+                attributes: {
+                    accessToken: {
+                        type: string;
+                        required: boolean;
+                        unique: boolean;
+                        private: boolean;
+                    };
+                    refreshToken: {
+                        type: string;
+                        required: boolean;
+                        unique: boolean;
+                        private: boolean;
+                    };
+                    clientId: {
+                        type: string;
+                        required: boolean;
+                    };
+                    expiresAt: {
+                        type: string;
+                        required: boolean;
+                    };
+                    refreshExpiresAt: {
+                        type: string;
+                        required: boolean;
+                    };
+                    revoked: {
+                        type: string;
+                        default: boolean;
+                    };
+                };
+            };
+        };
+        'mcp-endpoint': {
+            schema: {
+                kind: string;
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                    description: string;
+                };
+                options: {
+                    draftAndPublish: boolean;
+                };
+                pluginOptions: {
+                    "content-manager": {
+                        visible: boolean;
+                    };
+                    "content-type-builder": {
+                        visible: boolean;
+                    };
+                };
+                attributes: {
+                    name: {
+                        type: string;
+                        required: boolean;
+                    };
+                    pluginId: {
+                        type: string;
+                        required: boolean;
+                    };
+                    path: {
+                        type: string;
+                        required: boolean;
+                        unique: boolean;
+                    };
+                    description: {
+                        type: string;
+                    };
+                    active: {
+                        type: string;
+                        default: boolean;
+                    };
+                };
+            };
+        };
+    };
+    policies: {};
+    middlewares: {
+        'mcp-oauth': (config: any, { strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => (ctx: any, next: () => Promise<void>) => Promise<void>;
+    };
+};
+export default _default;

package/dist/server/src/middlewares/index.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    'mcp-oauth': (config: any, { strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => (ctx: any, next: () => Promise<void>) => Promise<void>;
+};
+export default _default;

package/dist/server/src/middlewares/mcp-oauth.d.ts

@@ -0,0 +1,19 @@
+/**
+ * MCP OAuth Authentication Middleware
+ *
+ * This middleware provides OAuth 2.0 authentication for all registered MCP endpoints.
+ * It supports dual authentication:
+ * - OAuth 2.0 tokens (for ChatGPT and other OAuth clients)
+ * - Direct Strapi API tokens (for Claude Desktop and scripts)
+ *
+ * On success: Sets ctx.state.strapiToken for use in controllers
+ * On failure: Returns 401 with WWW-Authenticate header for OAuth discovery
+ */
+import type { Core } from '@strapi/strapi';
+/**
+ * MCP OAuth Authentication Middleware Factory
+ */
+declare const mcpOauthMiddleware: (config: any, { strapi }: {
+    strapi: Core.Strapi;
+}) => (ctx: any, next: () => Promise<void>) => Promise<void>;
+export default mcpOauthMiddleware;

package/dist/server/src/pluginId.d.ts

@@ -0,0 +1 @@
+export declare const PLUGIN_ID = "strapi-oauth-mcp-manager";

package/dist/server/src/policies/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/server/src/register.d.ts

@@ -0,0 +1,5 @@
+import type { Core } from '@strapi/strapi';
+declare const register: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+export default register;

package/dist/server/src/routes/admin/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any[];
+export default _default;

package/dist/server/src/routes/content-api/index.d.ts

@@ -0,0 +1,10 @@
+declare const _default: {
+    method: string;
+    path: string;
+    handler: string;
+    config: {
+        auth: boolean;
+        policies: any[];
+    };
+}[];
+export default _default;

package/dist/server/src/routes/index.d.ts

@@ -0,0 +1,19 @@
+declare const _default: {
+    'content-api': {
+        type: string;
+        routes: {
+            method: string;
+            path: string;
+            handler: string;
+            config: {
+                auth: boolean;
+                policies: any[];
+            };
+        }[];
+    };
+    admin: {
+        type: string;
+        routes: any[];
+    };
+};
+export default _default;

package/dist/server/src/services/endpoint.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Endpoint Registration Service
+ *
+ * Allows MCP plugins to register their endpoints for OAuth protection.
+ */
+import type { Core } from '@strapi/strapi';
+export interface EndpointRegistration {
+    name: string;
+    pluginId: string;
+    path: string;
+    description?: string;
+}
+declare const endpointService: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    /**
+     * Register an MCP endpoint for OAuth protection
+     */
+    register(endpoint: EndpointRegistration): Promise<any>;
+    /**
+     * Unregister an MCP endpoint
+     */
+    unregister(path: string): Promise<boolean>;
+    /**
+     * Get all registered endpoints
+     */
+    getAll(activeOnly?: boolean): Promise<any[]>;
+    /**
+     * Get endpoints for a specific plugin
+     */
+    getByPlugin(pluginId: string, activeOnly?: boolean): Promise<any[]>;
+    /**
+     * Check if a path is a protected endpoint
+     */
+    isProtected(path: string): Promise<boolean>;
+};
+export default endpointService;

package/dist/server/src/services/index.d.ts

@@ -0,0 +1,22 @@
+declare const _default: {
+    oauth: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        validateToken(accessToken: string): Promise<import("./oauth").TokenValidationResult>;
+        revokeClientTokens(clientId: string): Promise<number>;
+        cleanupExpired(): Promise<{
+            tokens: number;
+            codes: number;
+        }>;
+    };
+    endpoint: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        register(endpoint: import("./endpoint").EndpointRegistration): Promise<any>;
+        unregister(path: string): Promise<boolean>;
+        getAll(activeOnly?: boolean): Promise<any[]>;
+        getByPlugin(pluginId: string, activeOnly?: boolean): Promise<any[]>;
+        isProtected(path: string): Promise<boolean>;
+    };
+};
+export default _default;