@catchmexz/fedin-cms-mcp 0.1.1

package/build/index.js

@@ -0,0 +1,1464 @@
+#!/usr/bin/env node
+process.on('unhandledRejection', (reason, promise) => {
+    console.error('[FATAL] Unhandled Rejection at:', promise, 'reason:', reason);
+});
+process.on('uncaughtException', (error) => {
+    console.error('[FATAL] Uncaught Exception:', error);
+    process.exit(1); // Mandatory exit after uncaught exception
+});
+/**
+ * Strapi MCP Server
+ *
+ * This MCP server integrates with any Strapi CMS instance to provide:
+ * - Access to Strapi content types as resources
+ * - Tools to create and update content types in Strapi
+ * - Tools to manage content entries (create, read, update, delete)
+ * - Support for Strapi in development mode
+ *
+ * This server is designed to be generic and work with any Strapi instance,
+ * regardless of the content types defined in that instance.
+ */
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, ErrorCode, McpError, } from "@modelcontextprotocol/sdk/types.js";
+import axios from "axios";
+import dotenv from 'dotenv';
+// Load environment variables from .env file
+dotenv.config();
+// Extended error codes to include additional ones we need
+var ExtendedErrorCode;
+(function (ExtendedErrorCode) {
+    // Original error codes from SDK
+    ExtendedErrorCode["InvalidRequest"] = "InvalidRequest";
+    ExtendedErrorCode["MethodNotFound"] = "MethodNotFound";
+    ExtendedErrorCode["InvalidParams"] = "InvalidParams";
+    ExtendedErrorCode["InternalError"] = "InternalError";
+    // Additional error codes
+    ExtendedErrorCode["ResourceNotFound"] = "ResourceNotFound";
+    ExtendedErrorCode["AccessDenied"] = "AccessDenied";
+})(ExtendedErrorCode || (ExtendedErrorCode = {}));
+// Custom error class extending McpError to support our extended error codes
+class ExtendedMcpError extends McpError {
+    extendedCode;
+    constructor(code, message) {
+        // Map our extended codes to standard MCP error codes when needed
+        let mcpCode;
+        // Map custom error codes to standard MCP error codes
+        switch (code) {
+            case ExtendedErrorCode.ResourceNotFound:
+            case ExtendedErrorCode.AccessDenied:
+                // Map custom codes to InternalError for SDK compatibility
+                mcpCode = ErrorCode.InternalError;
+                break;
+            case ExtendedErrorCode.InvalidRequest:
+                mcpCode = ErrorCode.InvalidRequest;
+                break;
+            case ExtendedErrorCode.MethodNotFound:
+                mcpCode = ErrorCode.MethodNotFound;
+                break;
+            case ExtendedErrorCode.InvalidParams:
+                mcpCode = ErrorCode.InvalidParams;
+                break;
+            case ExtendedErrorCode.InternalError:
+            default:
+                mcpCode = ErrorCode.InternalError;
+                break;
+        }
+        // Call super before accessing 'this'
+        super(mcpCode, message);
+        // Store the extended code for reference
+        this.extendedCode = code;
+    }
+}
+// Configuration from environment variables
+const STRAPI_URL = process.env.STRAPI_URL || "http://localhost:1337";
+const STRAPI_API_TOKEN = process.env.STRAPI_API_TOKEN;
+const STRAPI_DEV_MODE = process.env.STRAPI_DEV_MODE === "true";
+const STRAPI_ADMIN_EMAIL = process.env.STRAPI_ADMIN_EMAIL;
+const STRAPI_ADMIN_PASSWORD = process.env.STRAPI_ADMIN_PASSWORD;
+// Supabase Edge Function URL for content type management
+const SUPABASE_FUNCTION_URL = process.env.SUPABASE_FUNCTION_URL || "https://database.fedin.cn/functions/v1/cms_content-type-manager";
+const SUPABASE_CONTENT_FUNCTION_URL = process.env.SUPABASE_CONTENT_FUNCTION_URL || "https://database.fedin.cn/functions/v1/cms_content-manager";
+const SUPABASE_ANON_KEY = process.env.SUPABASE_ANON_KEY || "";
+const WEBSITE_ID = process.env.WEBSITE_ID || "";
+const USER_ID = process.env.USER_ID || "";
+// Validate required environment variables for Fedin CMS
+if (!WEBSITE_ID) {
+    console.error("[Error] Missing required environment variable: WEBSITE_ID");
+    console.error("[Error] Please set WEBSITE_ID in your environment variables");
+}
+// Axios instance for Strapi API
+const strapiClient = axios.create({
+    baseURL: STRAPI_URL,
+    headers: {
+        "Content-Type": "application/json",
+    },
+    validateStatus: function (status) {
+        // Consider only 5xx as errors - for more robust error handling
+        return status < 500;
+    }
+});
+// Axios instance for Supabase Edge Function (content types)
+const supabaseClient = axios.create({
+    baseURL: SUPABASE_FUNCTION_URL,
+    headers: {
+        "Content-Type": "application/json",
+        "apikey": SUPABASE_ANON_KEY,
+    },
+    validateStatus: function (status) {
+        return status < 500;
+    }
+});
+// Axios instance for Supabase Edge Function (content entries)
+const supabaseContentClient = axios.create({
+    baseURL: SUPABASE_CONTENT_FUNCTION_URL,
+    headers: {
+        "Content-Type": "application/json",
+        "apikey": SUPABASE_ANON_KEY,
+    },
+    validateStatus: function (status) {
+        return status < 500;
+    }
+});
+// Store admin JWT token if we log in
+let adminJwtToken = null;
+/**
+ * Log in to the Strapi admin API using provided credentials
+ */
+async function loginToStrapiAdmin() {
+    // Use process.env directly here to ensure latest values are used
+    const email = process.env.STRAPI_ADMIN_EMAIL;
+    const password = process.env.STRAPI_ADMIN_PASSWORD;
+    if (!email || !password) {
+        console.error("[Auth] No admin credentials found in process.env, skipping admin login");
+        return false;
+    }
+    try {
+        // Log the authentication attempt with more detail
+        console.error(`[Auth] Attempting login to Strapi admin at ${STRAPI_URL}/admin/login as ${email}`);
+        console.error(`[Auth] Full URL being used: ${STRAPI_URL}/admin/login`);
+        // Make the request with more detailed logging
+        console.error(`[Auth] Sending POST request with email and password`);
+        const response = await axios.post(`${STRAPI_URL}/admin/login`, {
+            email,
+            password
+        });
+        console.error(`[Auth] Response status: ${response.status}`);
+        console.error(`[Auth] Response headers:`, JSON.stringify(response.headers));
+        // Check if we got back valid data
+        if (response.data && response.data.data && response.data.data.token) {
+            adminJwtToken = response.data.data.token;
+            console.error("[Auth] Successfully logged in to Strapi admin");
+            console.error(`[Auth] Token received (first 20 chars): ${adminJwtToken?.substring(0, 20)}...`);
+            return true;
+        }
+        else {
+            console.error("[Auth] Login response missing token");
+            console.error(`[Auth] Response data:`, JSON.stringify(response.data));
+            return false;
+        }
+    }
+    catch (error) {
+        console.error("[Auth] Failed to log in to Strapi admin:");
+        if (axios.isAxiosError(error)) {
+            console.error(`[Auth] Status: ${error.response?.status}`);
+            console.error(`[Auth] Response data:`, error.response?.data);
+            console.error(`[Auth] Request URL: ${error.config?.url}`);
+            console.error(`[Auth] Request method: ${error.config?.method}`);
+        }
+        else {
+            console.error(error);
+        }
+        return false;
+    }
+}
+/**
+ * Make a request to the admin API using the admin JWT token
+ */
+async function makeAdminApiRequest(endpoint, method = 'get', data, params) {
+    if (!adminJwtToken) {
+        // Try to log in first
+        console.error(`[Admin API] No token available, attempting login...`);
+        const success = await loginToStrapiAdmin();
+        if (!success) {
+            console.error(`[Admin API] Login failed. Cannot authenticate for admin API access.`);
+            throw new Error("Not authenticated for admin API access");
+        }
+        console.error(`[Admin API] Login successful, proceeding with request.`);
+    }
+    const fullUrl = `${STRAPI_URL}${endpoint}`;
+    console.error(`[Admin API] Making ${method.toUpperCase()} request to: ${fullUrl}`);
+    if (data) {
+        console.error(`[Admin API] Request payload: ${JSON.stringify(data, null, 2)}`);
+    }
+    try {
+        console.error(`[Admin API] Sending request with Authorization header using token: ${adminJwtToken?.substring(0, 20)}...`);
+        const response = await axios({
+            method,
+            url: fullUrl,
+            headers: {
+                'Authorization': `Bearer ${adminJwtToken}`,
+                'Content-Type': 'application/json'
+            },
+            data, // Used for POST, PUT, etc.
+            params // Used for GET requests query parameters
+        });
+        console.error(`[Admin API] Response status: ${response.status}`);
+        if (response.data) {
+            console.error(`[Admin API] Response received successfully`);
+        }
+        return response.data;
+    }
+    catch (error) {
+        console.error(`[Admin API] Request to ${endpoint} failed:`);
+        if (axios.isAxiosError(error)) {
+            console.error(`[Admin API] Status: ${error.response?.status}`);
+            console.error(`[Admin API] Error data: ${JSON.stringify(error.response?.data)}`);
+            console.error(`[Admin API] Error headers: ${JSON.stringify(error.response?.headers)}`);
+            // Check if it's an auth error (e.g., token expired)
+            if (error.response?.status === 401 && adminJwtToken) {
+                console.error("[Admin API] Admin token might be expired. Attempting re-login...");
+                adminJwtToken = null; // Clear expired token
+                const loginSuccess = await loginToStrapiAdmin();
+                if (loginSuccess) {
+                    console.error("[Admin API] Re-login successful. Retrying original request...");
+                    // Retry the request once after successful re-login
+                    try {
+                        const retryResponse = await axios({
+                            method,
+                            url: fullUrl,
+                            headers: {
+                                'Authorization': `Bearer ${adminJwtToken}`,
+                                'Content-Type': 'application/json'
+                            },
+                            data,
+                            params
+                        });
+                        console.error(`[Admin API] Retry successful, status: ${retryResponse.status}`);
+                        return retryResponse.data;
+                    }
+                    catch (retryError) {
+                        console.error(`[Admin API] Retry failed:`, retryError);
+                        throw retryError;
+                    }
+                }
+                else {
+                    console.error("[Admin API] Re-login failed. Throwing original error.");
+                    throw new Error("Admin re-authentication failed after token expiry.");
+                }
+            }
+        }
+        else {
+            console.error(`[Admin API] Non-Axios error:`, error);
+        }
+        // If not a 401 or re-login failed, throw the original error
+        throw error;
+    }
+}
+// Cache for content types
+let contentTypesCache = [];
+/**
+ * Create an MCP server with capabilities for resources and tools
+ */
+const server = new Server({
+    name: "strapi-mcp",
+    version: "0.2.0",
+}, {
+    capabilities: {
+        resources: {},
+        tools: {},
+    },
+});
+/**
+ * Fetch all content types from Fedin CMS (Supabase)
+ */
+async function fetchContentTypes() {
+    try {
+        console.error("[API] Fetching content types from Fedin CMS");
+        if (!WEBSITE_ID) {
+            throw new Error("WEBSITE_ID environment variable is required to fetch content types");
+        }
+        const response = await supabaseClient.get('/content-types', {
+            params: { websiteId: WEBSITE_ID }
+        });
+        if (response.data && response.data.data && Array.isArray(response.data.data)) {
+            // Transform the response to match expected format
+            const contentTypes = response.data.data.map((ct) => ({
+                uid: ct.uid,
+                apiID: ct.uid,
+                info: {
+                    displayName: ct.title || ct.uid,
+                    description: ct.description || `${ct.uid} content type`,
+                },
+                attributes: ct.fields || {}
+            }));
+            contentTypesCache = contentTypes;
+            console.error(`[API] Successfully fetched ${contentTypes.length} content types`);
+            return contentTypes;
+        }
+        throw new Error("Invalid response format from Supabase Edge Function");
+    }
+    catch (error) {
+        console.error("[Error] Failed to fetch content types:", error);
+        let errorMessage = "Failed to fetch content types";
+        let errorCode = ExtendedErrorCode.InternalError;
+        if (axios.isAxiosError(error)) {
+            errorMessage += `: ${error.response?.status} ${error.response?.statusText}`;
+            if (error.response?.status === 400) {
+                errorCode = ExtendedErrorCode.InvalidParams;
+                errorMessage += ` (Bad Request - websiteId parameter is required)`;
+            }
+            else if (error.response?.status === 404) {
+                errorCode = ExtendedErrorCode.ResourceNotFound;
+                errorMessage += ` (Website not found)`;
+            }
+            else if (error.response?.status === 403) {
+                errorCode = ExtendedErrorCode.AccessDenied;
+                errorMessage += ` (Permission denied)`;
+            }
+            else if (error.response?.status === 401) {
+                errorCode = ExtendedErrorCode.AccessDenied;
+                errorMessage += ` (Unauthorized)`;
+            }
+        }
+        else if (error instanceof Error) {
+            errorMessage += `: ${error.message}`;
+        }
+        else {
+            errorMessage += `: ${String(error)}`;
+        }
+        throw new ExtendedMcpError(errorCode, errorMessage);
+    }
+}
+/**
+ * Fetch entries for a specific content type from Fedin CMS (Supabase)
+ */
+async function fetchEntries(uid, queryParams) {
+    try {
+        console.error(`[API] Fetching entries for content type: ${uid}`);
+        if (!WEBSITE_ID) {
+            throw new Error("WEBSITE_ID environment variable is required to fetch entries");
+        }
+        // 构建查询参数
+        const params = {
+            websiteId: WEBSITE_ID,
+            uid: uid
+        };
+        // 支持分页
+        if (queryParams?.pagination) {
+            params.page = queryParams.pagination.page || 1;
+            params.pageSize = queryParams.pagination.pageSize || 20;
+        }
+        else {
+            params.page = 1;
+            params.pageSize = 20;
+        }
+        // 支持状态过滤
+        if (queryParams?.filters?.status) {
+            params.status = queryParams.filters.status;
+        }
+        // 支持排序
+        if (queryParams?.sort && queryParams.sort.length > 0) {
+            const sortStr = queryParams.sort[0];
+            if (sortStr.includes(':')) {
+                const [sortBy, sortOrder] = sortStr.split(':');
+                params.sortBy = sortBy;
+                params.sortOrder = sortOrder || 'desc';
+            }
+        }
+        const response = await supabaseContentClient.get('/contents', { params });
+        if (response.data && response.data.data) {
+            console.error(`[API] Successfully fetched ${response.data.data.length} entries`);
+            return {
+                data: response.data.data,
+                meta: response.data.pagination || {}
+            };
+        }
+        throw new Error("Invalid response format from Supabase Edge Function");
+    }
+    catch (error) {
+        console.error("[Error] Failed to fetch entries:", error);
+        let errorMessage = "Failed to fetch entries";
+        let errorCode = ExtendedErrorCode.InternalError;
+        if (axios.isAxiosError(error)) {
+            errorMessage += `: ${error.response?.status} ${error.response?.statusText}`;
+            if (error.response?.status === 400) {
+                errorCode = ExtendedErrorCode.InvalidParams;
+                errorMessage += ` (Bad Request - websiteId parameter is required)`;
+            }
+            else if (error.response?.status === 404) {
+                errorCode = ExtendedErrorCode.ResourceNotFound;
+                errorMessage += ` (Content type or website not found)`;
+            }
+            else if (error.response?.status === 403) {
+                errorCode = ExtendedErrorCode.AccessDenied;
+                errorMessage += ` (Permission denied)`;
+            }
+            else if (error.response?.status === 401) {
+                errorCode = ExtendedErrorCode.AccessDenied;
+                errorMessage += ` (Unauthorized)`;
+            }
+        }
+        else if (error instanceof Error) {
+            errorMessage += `: ${error.message}`;
+        }
+        else {
+            errorMessage += `: ${String(error)}`;
+        }
+        throw new ExtendedMcpError(errorCode, errorMessage);
+    }
+}
+/**
+ * Fetch a specific entry by ID from Fedin CMS (Supabase)
+ */
+async function fetchEntry(uid, id, queryParams) {
+    try {
+        console.error(`[API] Fetching entry ${id} for content type: ${uid}`);
+        if (!WEBSITE_ID) {
+            throw new Error("WEBSITE_ID environment variable is required to fetch entry");
+        }
+        const response = await supabaseContentClient.get(`/contents/${id}`, {
+            params: { websiteId: WEBSITE_ID }
+        });
+        if (response.data && response.data.data) {
+            console.error(`[API] Successfully fetched entry ${id}`);
+            return response.data.data;
+        }
+        throw new Error("Invalid response format from Supabase Edge Function");
+    }
+    catch (error) {
+        console.error(`[Error] Failed to fetch entry ${id} for ${uid}:`, error);
+        let errorMessage = `Failed to fetch entry ${id} for ${uid}`;
+        let errorCode = ExtendedErrorCode.InternalError;
+        if (axios.isAxiosError(error)) {
+            errorMessage += `: ${error.response?.status} ${error.response?.statusText}`;
+            if (error.response?.status === 400) {
+                errorCode = ExtendedErrorCode.InvalidParams;
+                errorMessage += ` (Bad Request - websiteId parameter is required)`;
+            }
+            else if (error.response?.status === 404) {
+                errorCode = ExtendedErrorCode.ResourceNotFound;
+                errorMessage += ` (Entry not found)`;
+            }
+            else if (error.response?.status === 403) {
+                errorCode = ExtendedErrorCode.AccessDenied;
+                errorMessage += ` (Permission denied)`;
+            }
+            else if (error.response?.status === 401) {
+                errorCode = ExtendedErrorCode.AccessDenied;
+                errorMessage += ` (Unauthorized)`;
+            }
+        }
+        else if (error instanceof Error) {
+            errorMessage += `: ${error.message}`;
+        }
+        else {
+            errorMessage += `: ${String(error)}`;
+        }
+        throw new ExtendedMcpError(errorCode, errorMessage);
+    }
+}
+/**
+ * Create a new entry in Fedin CMS (Supabase)
+ */
+async function createEntry(uid, data) {
+    try {
+        console.error(`[API] Creating new entry for content type: ${uid}`);
+        if (!WEBSITE_ID) {
+            throw new Error("WEBSITE_ID environment variable is required to create entry");
+        }
+        const payload = {
+            uid,
+            data,
+            status: data.status || 'published',
+            user_id: USER_ID || null,
+            is_ai_generated: data.is_ai_generated || false
+        };
+        const response = await supabaseContentClient.post('/contents', payload, {
+            params: { websiteId: WEBSITE_ID }
+        });
+        if (response.data && response.data.data) {
+            console.error(`[API] Successfully created entry`);
+            return response.data.data;
+        }
+        throw new Error("Invalid response format from Supabase Edge Function");
+    }
+    catch (error) {
+        console.error(`[Error] Failed to create entry for ${uid}:`, error);
+        let errorMessage = `Failed to create entry for ${uid}`;
+        let errorCode = ExtendedErrorCode.InternalError;
+        if (axios.isAxiosError(error)) {
+            errorMessage += `: ${error.response?.status} ${error.response?.statusText}`;
+            if (error.response?.status === 400) {
+                errorCode = ExtendedErrorCode.InvalidParams;
+                errorMessage += ` (Bad Request): ${JSON.stringify(error.response?.data)}`;
+            }
+            else if (error.response?.status === 404) {
+                errorCode = ExtendedErrorCode.ResourceNotFound;
+                errorMessage += ` (Website not found)`;
+            }
+            else if (error.response?.status === 403 || error.response?.status === 401) {
+                errorCode = ExtendedErrorCode.AccessDenied;
+                errorMessage += ` (Permission Denied)`;
+            }
+        }
+        else if (error instanceof Error) {
+            errorMessage += `: ${error.message}`;
+        }
+        else {
+            errorMessage += `: ${String(error)}`;
+        }
+        throw new ExtendedMcpError(errorCode, errorMessage);
+    }
+}
+/**
+ * Update an existing entry in Fedin CMS (Supabase)
+ */
+async function updateEntry(uid, id, data) {
+    try {
+        console.error(`[API] Updating entry ${id} for content type: ${uid}`);
+        if (!WEBSITE_ID) {
+            throw new Error("WEBSITE_ID environment variable is required to update entry");
+        }
+        const payload = {
+            data: data.data !== undefined ? data.data : data,
+        };
+        // 支持更新其他字段
+        if (data.status !== undefined) {
+            payload.status = data.status;
+        }
+        if (USER_ID !== undefined) {
+            payload.user_id = USER_ID;
+        }
+        if (data.is_ai_generated !== undefined) {
+            payload.is_ai_generated = data.is_ai_generated;
+        }
+        if (data.uid !== undefined) {
+            payload.uid = data.uid;
+        }
+        const response = await supabaseContentClient.put(`/contents/${id}`, payload, {
+            params: { websiteId: WEBSITE_ID }
+        });
+        if (response.data && response.data.data) {
+            console.error(`[API] Successfully updated entry ${id}`);
+            return response.data.data;
+        }
+        throw new Error("Invalid response format from Supabase Edge Function");
+    }
+    catch (error) {
+        console.error(`[Error] Failed to update entry ${id} for ${uid}:`, error);
+        let errorMessage = `Failed to update entry ${id} for ${uid}`;
+        let errorCode = ExtendedErrorCode.InternalError;
+        if (axios.isAxiosError(error)) {
+            errorMessage += `: ${error.response?.status} ${error.response?.statusText}`;
+            if (error.response?.status === 400) {
+                errorCode = ExtendedErrorCode.InvalidParams;
+                errorMessage += ` (Bad Request): ${JSON.stringify(error.response?.data)}`;
+            }
+            else if (error.response?.status === 404) {
+                errorCode = ExtendedErrorCode.ResourceNotFound;
+                errorMessage += ` (Entry or website not found)`;
+            }
+            else if (error.response?.status === 403 || error.response?.status === 401) {
+                errorCode = ExtendedErrorCode.AccessDenied;
+                errorMessage += ` (Permission Denied)`;
+            }
+        }
+        else if (error instanceof Error) {
+            errorMessage += `: ${error.message}`;
+        }
+        else {
+            errorMessage += `: ${String(error)}`;
+        }
+        throw new ExtendedMcpError(errorCode, errorMessage);
+    }
+}
+/**
+ * Delete an entry from Fedin CMS (Supabase)
+ */
+async function deleteEntry(uid, id) {
+    try {
+        console.error(`[API] Deleting entry ${id} for content type: ${uid}`);
+        if (!WEBSITE_ID) {
+            throw new Error("WEBSITE_ID environment variable is required to delete entry");
+        }
+        const response = await supabaseContentClient.delete(`/contents/${id}`, {
+            params: { websiteId: WEBSITE_ID }
+        });
+        if (response.status >= 200 && response.status < 300) {
+            console.error(`[API] Successfully deleted entry ${id}`);
+            return;
+        }
+        throw new Error(`Unexpected response status: ${response.status}`);
+    }
+    catch (error) {
+        console.error(`[Error] Failed to delete entry ${id} for ${uid}:`, error);
+        let errorMessage = `Failed to delete entry ${id} for ${uid}`;
+        let errorCode = ExtendedErrorCode.InternalError;
+        if (axios.isAxiosError(error)) {
+            errorMessage += `: ${error.response?.status} ${error.response?.statusText}`;
+            if (error.response?.status === 400) {
+                errorCode = ExtendedErrorCode.InvalidParams;
+                errorMessage += ` (Bad Request - websiteId parameter is required)`;
+            }
+            else if (error.response?.status === 404) {
+                errorCode = ExtendedErrorCode.ResourceNotFound;
+                errorMessage += ` (Entry or website not found)`;
+            }
+            else if (error.response?.status === 403 || error.response?.status === 401) {
+                errorCode = ExtendedErrorCode.AccessDenied;
+                errorMessage += ` (Permission Denied)`;
+            }
+        }
+        else if (error instanceof Error) {
+            errorMessage += `: ${error.message}`;
+        }
+        else {
+            errorMessage += `: ${String(error)}`;
+        }
+        throw new ExtendedMcpError(errorCode, errorMessage);
+    }
+}
+/**
+ * Upload media file to Strapi
+ */
+/**
+ * Fetch the schema for a specific content type from Fedin CMS (Supabase)
+ */
+async function fetchContentTypeSchema(contentType) {
+    try {
+        console.error(`[API] Fetching schema for content type: ${contentType}`);
+        if (!WEBSITE_ID) {
+            throw new Error("WEBSITE_ID environment variable is required to fetch content type schema");
+        }
+        const response = await supabaseClient.get(`/content-types/${contentType}`, {
+            params: { websiteId: WEBSITE_ID }
+        });
+        if (response.data && response.data.data) {
+            const schemaData = response.data.data;
+            console.error("[API] Successfully fetched schema via Supabase Edge Function");
+            // Transform to match expected format
+            return {
+                uid: schemaData.uid || contentType,
+                apiID: schemaData.uid || contentType,
+                info: {
+                    displayName: schemaData.title || schemaData.uid || contentType,
+                    description: schemaData.description || `${contentType} content type`,
+                },
+                attributes: schemaData.fields || {}
+            };
+        }
+        throw new Error("Invalid response format from Supabase Edge Function");
+    }
+    catch (error) {
+        let errorMessage = `Failed to fetch schema for ${contentType}`;
+        let errorCode = ExtendedErrorCode.InternalError;
+        if (axios.isAxiosError(error)) {
+            errorMessage += `: ${error.response?.status} ${error.response?.statusText}`;
+            if (error.response?.status === 400) {
+                errorCode = ExtendedErrorCode.InvalidParams;
+                errorMessage += ` (Bad Request - websiteId parameter is required)`;
+            }
+            else if (error.response?.status === 404) {
+                errorCode = ExtendedErrorCode.ResourceNotFound;
+                errorMessage += ` (Content type or website not found)`;
+            }
+            else if (error.response?.status === 403) {
+                errorCode = ExtendedErrorCode.AccessDenied;
+                errorMessage += ` (Permission denied)`;
+            }
+            else if (error.response?.status === 401) {
+                errorCode = ExtendedErrorCode.AccessDenied;
+                errorMessage += ` (Unauthorized)`;
+            }
+        }
+        else if (error instanceof Error) {
+            errorMessage += `: ${error.message}`;
+        }
+        else {
+            errorMessage += `: ${String(error)}`;
+        }
+        console.error(`[Error] ${errorMessage}`);
+        throw new ExtendedMcpError(errorCode, errorMessage);
+    }
+}
+/**
+  * Update an existing content type in Fedin CMS (Supabase)
+  */
+/**
+ * Update a content type in Fedin CMS (Supabase)
+ * Only title and description can be updated. Fields are fixed and cannot be changed.
+ */
+async function updateContentType(contentTypeUid, updateData) {
+    try {
+        console.error(`[API] Updating content type: ${contentTypeUid}`);
+        if (!contentTypeUid) {
+            throw new Error("Missing required field: contentTypeUid");
+        }
+        if (!WEBSITE_ID) {
+            throw new Error("WEBSITE_ID environment variable is required to update content type");
+        }
+        // Construct the payload - only title and description can be updated
+        // Fields are fixed and cannot be changed
+        const payload = {};
+        if (updateData.title !== undefined) {
+            payload.title = updateData.title;
+        }
+        if (updateData.description !== undefined) {
+            payload.description = updateData.description;
+        }
+        console.error(`[API] Update Payload for PUT /content-types/${contentTypeUid}: ${JSON.stringify(payload, null, 2)}`);
+        const response = await supabaseClient.put(`/content-types/${contentTypeUid}`, payload, {
+            params: { websiteId: WEBSITE_ID }
+        });
+        console.error(`[API] Content type update response:`, response.data);
+        if (response.data && response.data.data) {
+            return response.data.data;
+        }
+        return { message: `Content type ${contentTypeUid} updated successfully` };
+    }
+    catch (error) {
+        console.error(`[Error] Failed to update content type ${contentTypeUid}:`, error);
+        let errorMessage = `Failed to update content type ${contentTypeUid}`;
+        let errorCode = ExtendedErrorCode.InternalError;
+        if (axios.isAxiosError(error)) {
+            errorMessage += `: ${error.response?.status} ${error.response?.statusText}`;
+            const responseData = JSON.stringify(error.response?.data);
+            if (error.response?.status === 400) {
+                errorCode = ExtendedErrorCode.InvalidParams;
+                errorMessage += ` (Bad Request): ${responseData}`;
+            }
+            else if (error.response?.status === 404) {
+                errorCode = ExtendedErrorCode.ResourceNotFound;
+                errorMessage += ` (Content Type or Website Not Found)`;
+            }
+            else if (error.response?.status === 403 || error.response?.status === 401) {
+                errorCode = ExtendedErrorCode.AccessDenied;
+                errorMessage += ` (Permission Denied)`;
+            }
+            else {
+                errorMessage += `: ${responseData}`;
+            }
+        }
+        else if (error instanceof Error) {
+            errorMessage += `: ${error.message}`;
+        }
+        else {
+            errorMessage += `: ${String(error)}`;
+        }
+        throw new ExtendedMcpError(errorCode, errorMessage);
+    }
+}
+/**
+ * Create a new content type in Fedin CMS (Supabase)
+ * Fields are fixed and handled by the backend, so we don't pass them
+ */
+async function createContentType(contentTypeData) {
+    try {
+        const { uid, title, description = "" } = contentTypeData;
+        if (!uid || !title) {
+            throw new Error("Missing required fields: uid, title");
+        }
+        if (!WEBSITE_ID) {
+            throw new Error("WEBSITE_ID environment variable is required to create content type");
+        }
+        // Construct the payload for Supabase Edge Function
+        // Fields are fixed and handled by the backend, so we don't pass them
+        const payload = {
+            uid,
+            title,
+            description
+        };
+        console.error(`[API] Creating new content type: ${title}`);
+        console.error(`[API] Attempting to create content type with payload: ${JSON.stringify(payload, null, 2)}`);
+        const response = await supabaseClient.post('/content-types', payload, {
+            params: { websiteId: WEBSITE_ID }
+        });
+        console.error(`[API] Content type creation response:`, response.data);
+        if (response.data && response.data.data) {
+            return response.data.data;
+        }
+        return { message: "Content type created successfully", uid };
+    }
+    catch (error) {
+        console.error(`[Error] Failed to create content type:`, error);
+        let errorMessage = `Failed to create content type`;
+        let errorCode = ExtendedErrorCode.InternalError;
+        if (axios.isAxiosError(error)) {
+            errorMessage += `: ${error.response?.status} ${error.response?.statusText}`;
+            if (error.response?.status === 400) {
+                errorCode = ExtendedErrorCode.InvalidParams;
+                errorMessage += ` (Bad Request): ${JSON.stringify(error.response?.data)}`;
+            }
+            else if (error.response?.status === 409) {
+                errorCode = ExtendedErrorCode.InvalidParams;
+                errorMessage += ` (Conflict - Content type already exists)`;
+            }
+            else if (error.response?.status === 404) {
+                errorCode = ExtendedErrorCode.ResourceNotFound;
+                errorMessage += ` (Website not found)`;
+            }
+            else if (error.response?.status === 403 || error.response?.status === 401) {
+                errorCode = ExtendedErrorCode.AccessDenied;
+                errorMessage += ` (Permission Denied)`;
+            }
+        }
+        else if (error instanceof Error) {
+            errorMessage += `: ${error.message}`;
+        }
+        else {
+            errorMessage += `: ${String(error)}`;
+        }
+        throw new ExtendedMcpError(errorCode, errorMessage);
+    }
+}
+/**
+ * Handler for listing available Strapi content as resources.
+ * Each content type and entry is exposed as a resource with:
+ * - A strapi:// URI scheme
+ * - JSON MIME type
+ * - Human readable name and description
+ */
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    try {
+        // Fetch all content types
+        const contentTypes = await fetchContentTypes();
+        // Create a resource for each content type
+        const contentTypeResources = contentTypes.map(ct => ({
+            uri: `strapi://content-type/${ct.uid}`,
+            mimeType: "application/json",
+            name: ct.info.displayName,
+            description: `Strapi content type: ${ct.info.displayName}`
+        }));
+        // Return the resources
+        return {
+            resources: contentTypeResources
+        };
+    }
+    catch (error) {
+        console.error("[Error] Failed to list resources:", error);
+        throw new McpError(ErrorCode.InternalError, `Failed to list resources: ${error instanceof Error ? error.message : String(error)}`);
+    }
+});
+/**
+ * Handler for reading the contents of a specific resource.
+ * Takes a strapi:// URI and returns the content as JSON.
+ *
+ * Supports URIs in the following formats:
+ * - strapi://content-type/[contentTypeUid] - Get all entries for a content type
+ * - strapi://content-type/[contentTypeUid]/[entryId] - Get a specific entry
+ * - strapi://content-type/[contentTypeUid]?[queryParams] - Get filtered entries
+ */
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    try {
+        const uri = request.params.uri;
+        // Parse the URI for content type
+        const contentTypeMatch = uri.match(/^strapi:\/\/content-type\/([^\/\?]+)(?:\/([^\/\?]+))?(?:\?(.+))?$/);
+        if (!contentTypeMatch) {
+            throw new McpError(ErrorCode.InvalidRequest, `Invalid URI format: ${uri}`);
+        }
+        const contentTypeUid = contentTypeMatch[1];
+        const entryId = contentTypeMatch[2];
+        const queryString = contentTypeMatch[3];
+        // Parse query parameters if present
+        let queryParams = {};
+        if (queryString) {
+            try {
+                // Parse the query string into an object
+                const parsedParams = new URLSearchParams(queryString);
+                // Extract filters
+                const filtersParam = parsedParams.get('filters');
+                if (filtersParam) {
+                    queryParams.filters = JSON.parse(filtersParam);
+                }
+                // Extract pagination
+                const pageParam = parsedParams.get('page');
+                const pageSizeParam = parsedParams.get('pageSize');
+                if (pageParam || pageSizeParam) {
+                    queryParams.pagination = {};
+                    if (pageParam)
+                        queryParams.pagination.page = parseInt(pageParam, 10);
+                    if (pageSizeParam)
+                        queryParams.pagination.pageSize = parseInt(pageSizeParam, 10);
+                }
+                // Extract sort
+                const sortParam = parsedParams.get('sort');
+                if (sortParam) {
+                    queryParams.sort = sortParam.split(',');
+                }
+                // Extract populate
+                const populateParam = parsedParams.get('populate');
+                if (populateParam) {
+                    try {
+                        // Try to parse as JSON
+                        queryParams.populate = JSON.parse(populateParam);
+                    }
+                    catch {
+                        // If not valid JSON, treat as comma-separated string
+                        queryParams.populate = populateParam.split(',');
+                    }
+                }
+                // Extract fields
+                const fieldsParam = parsedParams.get('fields');
+                if (fieldsParam) {
+                    queryParams.fields = fieldsParam.split(',');
+                }
+            }
+            catch (parseError) {
+                console.error("[Error] Failed to parse query parameters:", parseError);
+                throw new McpError(ErrorCode.InvalidRequest, `Invalid query parameters: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+            }
+        }
+        // If an entry ID is provided, fetch that specific entry
+        if (entryId) {
+            const entry = await fetchEntry(contentTypeUid, entryId, queryParams);
+            return {
+                contents: [{
+                        uri: request.params.uri,
+                        mimeType: "application/json",
+                        text: JSON.stringify(entry, null, 2)
+                    }]
+            };
+        }
+        // Otherwise, fetch entries with query parameters
+        const entries = await fetchEntries(contentTypeUid, queryParams);
+        // Return the entries as JSON
+        return {
+            contents: [{
+                    uri: request.params.uri,
+                    mimeType: "application/json",
+                    text: JSON.stringify(entries, null, 2)
+                }]
+        };
+    }
+    catch (error) {
+        console.error("[Error] Failed to read resource:", error);
+        throw new McpError(ErrorCode.InternalError, `Failed to read resource: ${error instanceof Error ? error.message : String(error)}`);
+    }
+});
+/**
+ * Handler that lists available tools.
+ * Exposes tools for working with Strapi content.
+ */
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: "list_content_types",
+                description: "List all available content types in Fedin CMS",
+                inputSchema: {
+                    type: "object",
+                    properties: {}
+                }
+            },
+            {
+                name: "get_entries",
+                description: "Get entries for a specific content type",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        uid: {
+                            type: "string",
+                            description: "The content type UID (e.g., 'blog-post')"
+                        },
+                        options: {
+                            type: "string",
+                            description: "JSON string with query options including filters, pagination, sort. Example: '{\"filters\":{\"status\":\"published\"},\"pagination\":{\"page\":1,\"pageSize\":10},\"sort\":[\"updated_at:desc\"]}'"
+                        }
+                    },
+                    required: ["uid"]
+                }
+            },
+            {
+                name: "get_entry",
+                description: "Get a specific entry by ID",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        uid: {
+                            type: "string",
+                            description: "The content type UID (e.g., 'blog-post')"
+                        },
+                        id: {
+                            type: "string",
+                            description: "The ID of the entry"
+                        }
+                    },
+                    required: ["uid", "id"]
+                }
+            },
+            {
+                name: "create_entry",
+                description: "Create a new entry for a content type",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        uid: {
+                            type: "string",
+                            description: "The content type UID (e.g., 'blog-post')"
+                        },
+                        data: {
+                            type: "object",
+                            description: "The data for the new entry"
+                        },
+                        status: {
+                            type: "string",
+                            enum: ["draft", "published"],
+                            description: "Entry status (default: 'published')"
+                        }
+                    },
+                    required: ["uid", "data"]
+                }
+            },
+            {
+                name: "update_entry",
+                description: "Update an existing entry",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        uid: {
+                            type: "string",
+                            description: "The content type UID (e.g., 'blog')"
+                        },
+                        id: {
+                            type: "string",
+                            description: "The ID of the entry to update"
+                        },
+                        data: {
+                            type: "object",
+                            description: "The updated data for the entry"
+                        },
+                        status: {
+                            type: "string",
+                            enum: ["draft", "published"],
+                            description: "Entry status (optional)"
+                        }
+                    },
+                    required: ["uid", "id", "data"]
+                }
+            },
+            {
+                name: "delete_entry",
+                description: "Deletes a specific entry.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        uid: {
+                            type: "string",
+                            description: "Content type UID (e.g., 'blog-post')",
+                        },
+                        id: {
+                            type: "string",
+                            description: "Entry ID.",
+                        },
+                    },
+                    required: ["uid", "id"]
+                }
+            },
+            {
+                name: "get_content_type_schema",
+                description: "Get the schema for a specific content type.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        contentType: {
+                            type: "string",
+                            description: "The UID of the content type (e.g., 'blog').",
+                        },
+                    },
+                    required: ["contentType"]
+                }
+            },
+            {
+                name: "create_content_type",
+                description: "Creates a new content type in Fedin CMS. Fields are fixed and cannot be customized.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        uid: { type: "string", description: "Unique identifier for the content type (e.g., 'blog')." },
+                        title: { type: "string", description: "Display title for content type." },
+                        description: { type: "string", description: "Optional description." }
+                    },
+                    required: ["uid", "title"]
+                }
+            },
+            {
+                name: "update_content_type",
+                description: "Updates a content type in Fedin CMS. Only title and description can be updated. Fields are fixed and cannot be changed.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        contentType: { type: "string", description: "UID of content type to update." },
+                        title: { type: "string", description: "Updated display title for content type." },
+                        description: { type: "string", description: "Updated description." }
+                    },
+                    required: ["contentType"]
+                }
+            },
+            {
+                name: "delete_content_type",
+                description: "Deletes a content type from Fedin CMS.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        contentType: { type: "string", description: "UID of content type to delete (e.g., 'blog-post')." }
+                    },
+                    required: ["contentType"]
+                }
+            },
+        ]
+    };
+});
+/**
+ * Handler for tool calls.
+ * Implements various tools for working with Strapi content.
+ */
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    try {
+        switch (request.params.name) {
+            case "list_content_types": {
+                const contentTypes = await fetchContentTypes();
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify(contentTypes.map(ct => ({
+                                uid: ct.uid,
+                                displayName: ct.info.displayName,
+                                description: ct.info.description
+                            })), null, 2)
+                        }]
+                };
+            }
+            case "get_entries": {
+                const { uid, options } = request.params.arguments;
+                if (!uid) {
+                    throw new McpError(ErrorCode.InvalidParams, "uid is required");
+                }
+                // Parse the options string into a queryParams object
+                let queryParams = {};
+                if (options) {
+                    try {
+                        queryParams = JSON.parse(options);
+                    }
+                    catch (parseError) {
+                        console.error("[Error] Failed to parse query options:", parseError);
+                        throw new McpError(ErrorCode.InvalidParams, `Invalid query options: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+                    }
+                }
+                // Fetch entries with query parameters
+                const entries = await fetchEntries(String(uid), queryParams);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify(entries, null, 2)
+                        }]
+                };
+            }
+            case "get_entry": {
+                const { uid, id } = request.params.arguments;
+                if (!uid || !id) {
+                    throw new McpError(ErrorCode.InvalidParams, "uid and id are required");
+                }
+                const entry = await fetchEntry(String(uid), String(id));
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify(entry, null, 2)
+                        }]
+                };
+            }
+            case "create_entry": {
+                const uid = String(request.params.arguments?.uid);
+                const data = request.params.arguments?.data;
+                const status = request.params.arguments?.status;
+                if (!uid || !data) {
+                    throw new McpError(ErrorCode.InvalidParams, "uid and data are required");
+                }
+                const entryData = {
+                    ...data,
+                    status: status || 'published'
+                };
+                const entry = await createEntry(uid, entryData);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify(entry, null, 2)
+                        }]
+                };
+            }
+            case "update_entry": {
+                const uid = String(request.params.arguments?.uid);
+                const id = String(request.params.arguments?.id);
+                const data = request.params.arguments?.data;
+                const status = request.params.arguments?.status;
+                if (!uid || !id || !data) {
+                    throw new McpError(ErrorCode.InvalidParams, "uid, id, and data are required");
+                }
+                const updateData = {
+                    data: data
+                };
+                if (status !== undefined) {
+                    updateData.status = status;
+                }
+                const entry = await updateEntry(uid, id, updateData);
+                if (entry) {
+                    return {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify(entry, null, 2)
+                            }]
+                    };
+                }
+                else {
+                    console.warn(`[API] Update for ${uid} ${id} completed, but no updated entry data was returned by the API.`);
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `Successfully updated entry ${id} for ${uid}, but no updated data was returned by the API.`
+                            }]
+                    };
+                }
+            }
+            case "delete_entry": {
+                const uid = String(request.params.arguments?.uid);
+                const id = String(request.params.arguments?.id);
+                if (!uid || !id) {
+                    throw new McpError(ErrorCode.InvalidParams, "uid and id are required");
+                }
+                await deleteEntry(uid, id);
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Successfully deleted entry ${id} from ${uid}`
+                        }]
+                };
+            }
+            case "get_content_type_schema": {
+                const contentType = String(request.params.arguments?.contentType);
+                if (!contentType) {
+                    throw new McpError(ErrorCode.InvalidParams, "Content type is required");
+                }
+                const schema = await fetchContentTypeSchema(contentType);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify(schema, null, 2)
+                        }]
+                };
+            }
+            case "create_content_type": {
+                const contentTypeData = request.params.arguments;
+                if (!contentTypeData || typeof contentTypeData !== 'object') {
+                    throw new McpError(ErrorCode.InvalidParams, "Content type data object is required.");
+                }
+                const creationResult = await createContentType(contentTypeData);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify(creationResult, null, 2)
+                        }]
+                };
+            }
+            case "update_content_type": {
+                const { contentType, title, description } = request.params.arguments;
+                if (!contentType) {
+                    throw new McpError(ErrorCode.InvalidParams, "contentType (string) is required.");
+                }
+                const updateData = {};
+                if (title !== undefined)
+                    updateData.title = String(title);
+                if (description !== undefined)
+                    updateData.description = String(description);
+                const updateResult = await updateContentType(String(contentType), updateData);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify(updateResult, null, 2)
+                        }]
+                };
+            }
+            case "delete_content_type": {
+                const contentTypeUid = String(request.params.arguments?.contentType);
+                if (!contentTypeUid) {
+                    throw new McpError(ErrorCode.InvalidParams, "Content type UID is required");
+                }
+                const deletionResult = await deleteContentType(contentTypeUid);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify(deletionResult, null, 2)
+                        }]
+                };
+            }
+            default:
+                throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
+        }
+    }
+    catch (error) {
+        console.error(`[Error] Tool execution failed: ${error instanceof Error ? error.message : String(error)}`);
+        // Handle both McpError and regular errors the same way - return error response
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{
+                    type: "text",
+                    text: `Error: ${errorMessage}`
+                }],
+            isError: true
+        };
+    }
+});
+/**
+ * Start the server using stdio transport.
+ */
+async function main() {
+    console.error("[Setup] Starting Strapi MCP server");
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("[Setup] Strapi MCP server running");
+}
+main().catch((error) => {
+    console.error("[Error] Server error:", error);
+    process.exit(1);
+});
+/**
+ * Delete a content type from Fedin CMS (Supabase)
+ */
+async function deleteContentType(contentTypeUid) {
+    try {
+        console.error(`[API] Deleting content type: ${contentTypeUid}`);
+        if (!contentTypeUid) {
+            throw new Error(`Content type UID is required`);
+        }
+        if (!WEBSITE_ID) {
+            throw new Error("WEBSITE_ID environment variable is required to delete content type");
+        }
+        const response = await supabaseClient.delete(`/content-types/${contentTypeUid}`, {
+            params: { websiteId: WEBSITE_ID }
+        });
+        console.error(`[API] Content type deletion response:`, response.data);
+        if (response.data && response.data.data) {
+            return response.data.data;
+        }
+        return { message: `Content type ${contentTypeUid} deleted successfully` };
+    }
+    catch (error) {
+        console.error(`[Error] Failed to delete content type ${contentTypeUid}:`, error);
+        let errorMessage = `Failed to delete content type ${contentTypeUid}`;
+        let errorCode = ExtendedErrorCode.InternalError;
+        if (axios.isAxiosError(error)) {
+            errorMessage += `: ${error.response?.status} ${error.response?.statusText}`;
+            if (error.response?.status === 404) {
+                errorCode = ExtendedErrorCode.ResourceNotFound;
+                errorMessage += ` (Content type or website not found)`;
+            }
+            else if (error.response?.status === 400) {
+                errorCode = ExtendedErrorCode.InvalidParams;
+                errorMessage += ` (Bad Request): ${JSON.stringify(error.response?.data)}`;
+            }
+            else if (error.response?.status === 409) {
+                errorCode = ExtendedErrorCode.InvalidParams;
+                errorMessage += ` (Conflict - Content type is still in use)`;
+            }
+            else if (error.response?.status === 403 || error.response?.status === 401) {
+                errorCode = ExtendedErrorCode.AccessDenied;
+                errorMessage += ` (Permission Denied)`;
+            }
+        }
+        else if (error instanceof Error) {
+            errorMessage += `: ${error.message}`;
+        }
+        else {
+            errorMessage += `: ${String(error)}`;
+        }
+        throw new ExtendedMcpError(errorCode, errorMessage);
+    }
+}
+// Add connection validation flag
+let connectionValidated = false;
+/**
+ * Test connection to Strapi and validate authentication
+ */
+async function validateStrapiConnection() {
+    if (connectionValidated)
+        return; // Already validated
+    try {
+        console.error("[Setup] Validating connection to Strapi...");
+        // Try a simple request to test connectivity - use a valid endpoint
+        // Try the admin/users/me endpoint to test admin authentication
+        // or fall back to a public content endpoint
+        let response;
+        let authMethod = "";
+        // First try admin authentication if available
+        if (STRAPI_ADMIN_EMAIL && STRAPI_ADMIN_PASSWORD) {
+            try {
+                // Test admin login
+                await loginToStrapiAdmin();
+                const adminData = await makeAdminApiRequest('/admin/users/me');
+                // makeAdminApiRequest returns data, not full response - if we get data, auth worked
+                if (adminData) {
+                    authMethod = "admin credentials";
+                    console.error("[Setup] ✓ Admin authentication successful");
+                    console.error(`[Setup] ✓ Connection to Strapi successful using ${authMethod}`);
+                    connectionValidated = true;
+                    return; // Success - exit early
+                }
+            }
+            catch (adminError) {
+                console.error("[Setup] Admin authentication failed, trying API token...");
+                // Fall through to API token test
+            }
+        }
+        // If admin failed or not available, try API token
+        try {
+            // Try a simple endpoint that should exist - use upload/files to test API token
+            response = await strapiClient.get('/api/upload/files?pagination[limit]=1');
+            authMethod = "API token";
+            console.error("[Setup] ✓ API token authentication successful");
+        }
+        catch (apiError) {
+            console.error("[Setup] API token test failed, trying root endpoint...");
+            try {
+                // Last resort - try to hit the root to see if server is running
+                response = await strapiClient.get('/');
+                authMethod = "server connection";
+                console.error("[Setup] ✓ Server is reachable");
+            }
+            catch (rootError) {
+                throw new Error("All connection tests failed");
+            }
+        }
+        // Check if we got a proper response from strapiClient calls
+        if (response && response.status >= 200 && response.status < 300) {
+            console.error(`[Setup] ✓ Connection to Strapi successful using ${authMethod}`);
+            connectionValidated = true;
+        }
+        else {
+            throw new Error(`Unexpected response status: ${response?.status}`);
+        }
+    }
+    catch (error) {
+        console.error("[Setup] ✗ Failed to connect to Strapi");
+        let errorMessage = "Cannot connect to Strapi instance";
+        if (axios.isAxiosError(error)) {
+            if (error.code === 'ECONNREFUSED') {
+                errorMessage += `: Connection refused. Is Strapi running at ${STRAPI_URL}?`;
+            }
+            else if (error.response?.status === 401) {
+                errorMessage += `: Authentication failed. Check your API token or admin credentials.`;
+            }
+            else if (error.response?.status === 403) {
+                errorMessage += `: Access forbidden. Your API token may lack necessary permissions.`;
+            }
+            else if (error.response?.status === 404) {
+                errorMessage += `: Endpoint not found. Strapi server might be running but not properly configured.`;
+            }
+            else {
+                errorMessage += `: ${error.message}`;
+            }
+        }
+        else {
+            errorMessage += `: ${error.message}`;
+        }
+        throw new ExtendedMcpError(ExtendedErrorCode.InternalError, errorMessage);
+    }
+}