@qikdev/mcp 6.6.11 → 6.6.13

package/build/src/index.js

@@ -1,28 +1,17 @@
 #!/usr/bin/env node
 /**
- * Simplified Qik Platform MCP Server
+ * Qik Platform MCP Server
  *
- * A simple translation layer between AI models and the Qik API.
- * Focuses on core functionality with interactive error handling.
+ * MCP server for interacting with the Qik platform API.
+ * Provides tools for content management, user data, and more.
  */
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, ErrorCode, McpError, } from "@modelcontextprotocol/sdk/types.js";
-import axios from 'axios';
-import { ConfigManager } from './config.js';
-// Environment variables
-const QIK_API_URL = process.env.QIK_API_URL || 'https://api.qik.dev';
-const QIK_ACCESS_TOKEN = process.env.QIK_ACCESS_TOKEN;
+import { tools, getToolHandler, hasToolHandler } from "./tools/index.js";
 export class QikMCPServer {
     server;
-    axiosInstance;
-    userSession = null;
-    glossary = {};
-    serverName = 'Qik';
     constructor() {
-        if (!QIK_ACCESS_TOKEN) {
-            throw new Error('QIK_ACCESS_TOKEN environment variable is required. Run "qik-mcp-server setup" to configure.');
-        }
         this.server = new Server({
             name: "qik-mcp-server",
             version: "3.0.0",
@@ -31,609 +20,39 @@ export class QikMCPServer {
                 tools: {},
             },
         });
-        // Configure axios instance
-        this.axiosInstance = axios.create({
-            baseURL: QIK_API_URL,
-            headers: {
-                'Authorization': `Bearer ${QIK_ACCESS_TOKEN}`,
-                'Content-Type': 'application/json',
-            },
-            timeout: 30000,
-        });
         this.setupToolHandlers();
-        this.initializeServer();
         // Error handling
-        this.server.onerror = (error) => this.log(`MCP Error: ${error}`);
+        this.server.onerror = (error) => console.error(`MCP Error: ${error}`);
         process.on('SIGINT', async () => {
             await this.server.close();
             process.exit(0);
         });
     }
-    log(message) {
-        if (process.env.NODE_ENV !== 'production' || process.env.QIK_MCP_DEBUG === 'true') {
-            process.stderr.write(`[Qik MCP] ${message}\n`);
-        }
-    }
-    async initializeServer() {
-        try {
-            await this.loadServerName();
-            await this.loadUserSession();
-            await this.loadGlossary();
-            this.log(`Initialized with ${Object.keys(this.glossary).length} content types`);
-        }
-        catch (error) {
-            this.log(`Failed to initialize server: ${this.formatError(error)}`);
-        }
-    }
-    async loadServerName() {
-        try {
-            const configManager = new ConfigManager();
-            const config = await configManager.loadConfig();
-            if (config && config.serverName) {
-                this.serverName = config.serverName;
-            }
-        }
-        catch (error) {
-            this.log(`Failed to load server name: ${this.formatError(error)}`);
-        }
-    }
-    async loadUserSession() {
-        try {
-            const response = await this.axiosInstance.get('/user');
-            this.userSession = response.data.session || response.data;
-            this.log(`Authenticated as ${this.userSession?.firstName} ${this.userSession?.lastName}`);
-        }
-        catch (error) {
-            this.log(`Failed to load user session: ${this.formatError(error)}`);
-        }
-    }
-    async loadGlossary() {
-        try {
-            const response = await this.axiosInstance.get('/glossary/ai');
-            this.glossary = (response.data || []).reduce((memo, definition) => {
-                if (definition.key) {
-                    memo[definition.key] = definition;
-                }
-                return memo;
-            }, {});
-            this.log(`Loaded ${Object.keys(this.glossary).length} content types`);
-        }
-        catch (error) {
-            this.log(`Failed to load glossary: ${this.formatError(error)}`);
-        }
-    }
-    formatError(error) {
-        if (axios.isAxiosError(error)) {
-            const axiosError = error;
-            if (axiosError.response) {
-                const status = axiosError.response.status;
-                const data = axiosError.response.data;
-                return `HTTP ${status}: ${JSON.stringify(data)}`;
-            }
-            return `Network error: ${axiosError.message}`;
-        }
-        return error.message || String(error);
-    }
-    async promptUserForScopes() {
-        try {
-            const response = await this.axiosInstance.get('/scope/tree');
-            const scopes = this.extractAvailableScopes(response.data);
-            if (scopes.length === 0) {
-                throw new Error('No scopes available for content creation');
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: `🔐 **SCOPE SELECTION REQUIRED**
-
-To create content, you need to specify which scope(s) to create it in.
-
-**Available Scopes:**
-${scopes.map(s => `- **${s.id}**: ${s.title} (${s.path})`).join('\n')}
-
-Please retry your request with the scope ID(s) you want to use in the meta.scopes field.
-
-**Example:**
-\`\`\`json
-{
-  "meta": {
-    "scopes": ["${scopes[0].id}"]
-  }
-}
-\`\`\``,
-                    }],
-                isError: true,
-            };
-        }
-        catch (error) {
-            throw new Error(`Failed to get available scopes: ${this.formatError(error)}`);
-        }
-    }
-    extractAvailableScopes(scopeTree) {
-        const scopes = [];
-        const traverse = (node, path = '') => {
-            if (!node)
-                return;
-            const currentPath = path ? `${path} > ${node.title || node.name || node._id}` : (node.title || node.name || node._id);
-            if (node.permissions && node.permissions.create) {
-                scopes.push({
-                    id: node._id,
-                    title: node.title || node.name || node._id,
-                    path: currentPath
-                });
-            }
-            if (node.children && Array.isArray(node.children)) {
-                for (const child of node.children) {
-                    traverse(child, currentPath);
-                }
-            }
-        };
-        if (Array.isArray(scopeTree)) {
-            for (const scope of scopeTree) {
-                traverse(scope);
-            }
-        }
-        else {
-            traverse(scopeTree);
-        }
-        return scopes;
-    }
-    async handleApiError(error, operation, args) {
-        if (error.response?.status === 400) {
-            const errorData = error.response.data;
-            // Handle missing scopes
-            if (errorData.message && errorData.message.includes('scope')) {
-                return await this.promptUserForScopes();
-            }
-            // Handle validation errors - let user know what went wrong
-            return {
-                content: [{
-                        type: 'text',
-                        text: `❌ **VALIDATION ERROR**
-
-The API rejected your request for ${operation}:
-
-**Error Details:**
-${JSON.stringify(errorData, null, 2)}
-
-**Your Request:**
-${JSON.stringify(args, null, 2)}
-
-**Suggestions:**
-- Check that all required fields are provided
-- Verify field names match the content type definition
-- Ensure scope IDs are valid and you have permissions
-- Use \`qik_get_content_definition\` to see the exact field structure`,
-                    }],
-                isError: true,
-            };
-        }
-        if (error.response?.status === 403) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: `🚫 **PERMISSION DENIED**
-
-You don't have permission to perform ${operation}.
-
-**Possible causes:**
-- Your access token doesn't have the required permissions
-- The scope you're trying to access is restricted
-- The content type requires special permissions
-
-**Next steps:**
-- Check your token permissions with your administrator
-- Try using \`qik_get_scopes\` to see available scopes
-- Verify you have create/update permissions for this content type`,
-                    }],
-                isError: true,
-            };
-        }
-        // Generic error handling
-        return {
-            content: [{
-                    type: 'text',
-                    text: `❌ **API ERROR**
-
-Failed to ${operation}:
-
-**Error:** ${this.formatError(error)}
-
-**Your Request:**
-${JSON.stringify(args, null, 2)}
-
-**Troubleshooting:**
-- Check your internet connection
-- Verify your access token is valid
-- Try the request again in a few moments`,
-                }],
-            isError: true,
-        };
-    }
     setupToolHandlers() {
+        // List available tools
         this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            const tools = [
-                // Core requirement 1: Authentication
-                {
-                    name: 'qik_get_user_session',
-                    description: '👤 Get current user session information',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {},
-                    },
-                },
-                // Core requirement 2: Glossary discovery
-                {
-                    name: 'qik_get_glossary',
-                    description: '📚 Get all available content types and their definitions',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {},
-                    },
-                },
-                {
-                    name: 'qik_get_content_definition',
-                    description: '🔍 Get definition for a specific content type',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            type: {
-                                type: 'string',
-                                description: 'Content type key',
-                                enum: Object.keys(this.glossary),
-                            },
-                        },
-                        required: ['type'],
-                    },
-                },
-                // Core requirement 3: Session management (covered by user session)
-                {
-                    name: 'qik_get_scopes',
-                    description: '🔐 Get available scopes/permissions tree',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {},
-                    },
-                },
-                // Core requirement 4: Basic CRUD tools
-                {
-                    name: 'qik_get_content',
-                    description: '📄 Get content item by ID or slug',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            id: { type: 'string', description: 'Content ID' },
-                            slug: { type: 'string', description: 'Content slug' },
-                        },
-                        oneOf: [
-                            { required: ['id'] },
-                            { required: ['slug'] },
-                        ],
-                    },
-                },
-                {
-                    name: 'qik_list_content',
-                    description: '📋 List content items with filtering and search',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            type: {
-                                type: 'string',
-                                description: 'Content type to list',
-                                enum: Object.keys(this.glossary),
-                            },
-                            search: { type: 'string', description: 'Search keywords' },
-                            filter: { type: 'object', description: 'Filter criteria' },
-                            page: {
-                                type: 'object',
-                                properties: {
-                                    size: { type: 'number', minimum: 1, maximum: 100 },
-                                    index: { type: 'number', minimum: 1 },
-                                },
-                            },
-                        },
-                        required: ['type'],
-                    },
-                },
-                {
-                    name: 'qik_create_content',
-                    description: '✨ Create new content item',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            type: {
-                                type: 'string',
-                                description: 'Content type to create',
-                                enum: Object.keys(this.glossary),
-                            },
-                            title: { type: 'string', description: 'Content title' },
-                            data: { type: 'object', description: 'Content data fields' },
-                            meta: {
-                                type: 'object',
-                                description: 'Meta information (scopes required)',
-                                properties: {
-                                    scopes: {
-                                        type: 'array',
-                                        items: { type: 'string' },
-                                        description: 'Scope IDs where content should be created',
-                                    },
-                                    tags: { type: 'array', items: { type: 'string' } },
-                                    security: { type: 'string', enum: ['public', 'secure', 'private'] },
-                                },
-                            },
-                        },
-                        required: ['type', 'title'],
-                    },
-                },
-                {
-                    name: 'qik_update_content',
-                    description: '✏️ Update existing content item',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            id: { type: 'string', description: 'Content ID to update' },
-                            data: { type: 'object', description: 'Data to update' },
-                        },
-                        required: ['id', 'data'],
-                    },
-                },
-                {
-                    name: 'qik_delete_content',
-                    description: '🗑️ Delete content item',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            id: { type: 'string', description: 'Content ID to delete' },
-                        },
-                        required: ['id'],
-                    },
-                },
-            ];
             return { tools };
         });
+        // Handle tool calls
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            if (!hasToolHandler(name)) {
+                throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+            }
             try {
-                switch (request.params.name) {
-                    case 'qik_get_user_session':
-                        return await this.getUserSession();
-                    case 'qik_get_glossary':
-                        return await this.getGlossary();
-                    case 'qik_get_content_definition':
-                        return await this.getContentDefinition(request.params.arguments);
-                    case 'qik_get_scopes':
-                        return await this.getScopes();
-                    case 'qik_get_content':
-                        return await this.getContent(request.params.arguments);
-                    case 'qik_list_content':
-                        return await this.listContent(request.params.arguments);
-                    case 'qik_create_content':
-                        return await this.createContent(request.params.arguments);
-                    case 'qik_update_content':
-                        return await this.updateContent(request.params.arguments);
-                    case 'qik_delete_content':
-                        return await this.deleteContent(request.params.arguments);
-                    default:
-                        throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
-                }
+                const handler = getToolHandler(name);
+                const result = await handler(args);
+                return result;
             }
             catch (error) {
-                this.log(`Error in ${request.params.name}: ${this.formatError(error)}`);
-                if (axios.isAxiosError(error)) {
-                    return await this.handleApiError(error, request.params.name, request.params.arguments);
-                }
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `Error: ${this.formatError(error)}`,
-                        }],
-                    isError: true,
-                };
+                throw new McpError(ErrorCode.InternalError, `Tool execution failed: ${error.message}`);
             }
         });
     }
-    // Simplified tool implementations - let API handle validation
-    async getUserSession() {
-        if (!this.userSession) {
-            await this.loadUserSession();
-        }
-        return {
-            content: [{
-                    type: 'text',
-                    text: JSON.stringify(this.userSession, null, 2),
-                }],
-        };
-    }
-    async getGlossary() {
-        await this.loadGlossary();
-        const contentTypes = Object.entries(this.glossary).map(([key, type]) => ({
-            key,
-            title: type.title,
-            plural: type.plural,
-            description: type.description,
-            fieldCount: type.fields?.length || 0,
-        }));
-        return {
-            content: [{
-                    type: 'text',
-                    text: `Available Content Types (${contentTypes.length} total):
-
-${contentTypes.map(t => `${t.key}: ${t.title} (${t.fieldCount} fields)`).join('\n')}
-
-Full glossary data:
-${JSON.stringify(this.glossary, null, 2)}`,
-                }],
-        };
-    }
-    async getContentDefinition(args) {
-        if (!this.glossary[args.type]) {
-            const available = Object.keys(this.glossary).join(', ');
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Content type '${args.type}' not found. Available types: ${available}`,
-                    }],
-                isError: true,
-            };
-        }
-        try {
-            const response = await this.axiosInstance.get(`/content/${args.type}/definition`);
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify(response.data, null, 2),
-                    }],
-            };
-        }
-        catch (error) {
-            if (axios.isAxiosError(error)) {
-                return await this.handleApiError(error, 'get content definition', args);
-            }
-            throw error;
-        }
-    }
-    async getScopes() {
-        try {
-            const response = await this.axiosInstance.get('/scope/tree');
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify(response.data, null, 2),
-                    }],
-            };
-        }
-        catch (error) {
-            if (axios.isAxiosError(error)) {
-                return await this.handleApiError(error, 'get scopes', {});
-            }
-            throw error;
-        }
-    }
-    async getContent(args) {
-        try {
-            let response;
-            if (args.id) {
-                response = await this.axiosInstance.get(`/content/${args.id}`);
-            }
-            else if (args.slug) {
-                response = await this.axiosInstance.get(`/content/slug/${args.slug}`);
-            }
-            else {
-                throw new Error('Either id or slug must be provided');
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify(response.data, null, 2),
-                    }],
-            };
-        }
-        catch (error) {
-            if (axios.isAxiosError(error)) {
-                return await this.handleApiError(error, 'get content', args);
-            }
-            throw error;
-        }
-    }
-    async listContent(args) {
-        if (!this.glossary[args.type]) {
-            const available = Object.keys(this.glossary).join(', ');
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Content type '${args.type}' not found. Available types: ${available}`,
-                    }],
-                isError: true,
-            };
-        }
-        try {
-            const response = await this.axiosInstance.post(`/content/${args.type}/list`, {
-                search: args.search || '',
-                filter: args.filter || {},
-                page: args.page || { size: 20, index: 1 },
-            });
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify(response.data, null, 2),
-                    }],
-            };
-        }
-        catch (error) {
-            if (axios.isAxiosError(error)) {
-                return await this.handleApiError(error, 'list content', args);
-            }
-            throw error;
-        }
-    }
-    async createContent(args) {
-        if (!this.glossary[args.type]) {
-            const available = Object.keys(this.glossary).join(', ');
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Content type '${args.type}' not found. Available types: ${available}`,
-                    }],
-                isError: true,
-            };
-        }
-        try {
-            const response = await this.axiosInstance.post(`/content/${args.type}/create`, args);
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Successfully created ${args.type}:
-
-${JSON.stringify(response.data, null, 2)}`,
-                    }],
-            };
-        }
-        catch (error) {
-            if (axios.isAxiosError(error)) {
-                return await this.handleApiError(error, 'create content', args);
-            }
-            throw error;
-        }
-    }
-    async updateContent(args) {
-        try {
-            const response = await this.axiosInstance.patch(`/content/${args.id}`, args.data);
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Successfully updated content:
-
-${JSON.stringify(response.data, null, 2)}`,
-                    }],
-            };
-        }
-        catch (error) {
-            if (axios.isAxiosError(error)) {
-                return await this.handleApiError(error, 'update content', args);
-            }
-            throw error;
-        }
-    }
-    async deleteContent(args) {
-        try {
-            await this.axiosInstance.delete(`/content/${args.id}`);
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Successfully deleted content ${args.id}`,
-                    }],
-            };
-        }
-        catch (error) {
-            if (axios.isAxiosError(error)) {
-                return await this.handleApiError(error, 'delete content', args);
-            }
-            throw error;
-        }
-    }
     async run() {
         const transport = new StdioServerTransport();
         await this.server.connect(transport);
-        this.log('Simplified Qik MCP server running on stdio');
+        console.error('Qik MCP server running on stdio');
     }
 }
 // Only run the server if this file is executed directly