@delorenj/mcp-server-trello 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Model Context Protocol
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,252 @@
+# MCP Server Trello
+
+A Model Context Protocol (MCP) server that provides tools for interacting with Trello boards. This server enables seamless integration with Trello's API while handling rate limiting, type safety, and error handling automatically.
+
+## Changelog
+
+### 0.1.1
+
+- Added `move_card` tool to move cards between lists
+- Improved documentation
+
+### 0.1.0
+
+- Initial release with basic Trello board management features
+
+## Features
+
+- **Full Trello Board Integration**: Interact with cards, lists, and board activities
+- **Built-in Rate Limiting**: Respects Trello's API limits (300 requests/10s per API key, 100 requests/10s per token)
+- **Type-Safe Implementation**: Written in TypeScript with comprehensive type definitions
+- **Input Validation**: Robust validation for all API inputs
+- **Error Handling**: Graceful error handling with informative messages
+
+## Installation
+
+```bash
+npm install @delorenj/mcp-server-trello
+```
+
+## Configuration
+
+Add the server to your MCP settings file with the following configuration:
+
+```json
+{
+  "mcpServers": {
+    "trello": {
+      "command": "npx",
+      "args": ["-y", "@delorenj/mcp-server-trello"],
+      "env": {
+        "TRELLO_API_KEY": "your-api-key",
+        "TRELLO_TOKEN": "your-token",
+        "TRELLO_BOARD_ID": "your-board-id"
+      }
+    }
+  }
+}
+```
+
+### Required Environment Variables
+
+- `TRELLO_API_KEY`: Your Trello API key (get from <https://trello.com/app-key>)
+- `TRELLO_TOKEN`: Your Trello token (generate using your API key)
+- `TRELLO_BOARD_ID`: ID of the Trello board to interact with (found in board URL)
+
+## Available Tools
+
+### get_cards_by_list_id
+
+Fetch all cards from a specific list.
+
+```typescript
+{
+  name: 'get_cards_by_list_id',
+  arguments: {
+    listId: string  // ID of the Trello list
+  }
+}
+```
+
+### get_lists
+
+Retrieve all lists from the configured board.
+
+```typescript
+{
+  name: 'get_lists',
+  arguments: {}
+}
+```
+
+### get_recent_activity
+
+Fetch recent activity on the board.
+
+```typescript
+{
+  name: 'get_recent_activity',
+  arguments: {
+    limit?: number  // Optional: Number of activities to fetch (default: 10)
+  }
+}
+```
+
+### add_card_to_list
+
+Add a new card to a specified list.
+
+```typescript
+{
+  name: 'add_card_to_list',
+  arguments: {
+    listId: string,       // ID of the list to add the card to
+    name: string,         // Name of the card
+    description?: string, // Optional: Description of the card
+    dueDate?: string,    // Optional: Due date (ISO 8601 format)
+    labels?: string[]    // Optional: Array of label IDs
+  }
+}
+```
+
+### update_card_details
+
+Update an existing card's details.
+
+```typescript
+{
+  name: 'update_card_details',
+  arguments: {
+    cardId: string,       // ID of the card to update
+    name?: string,        // Optional: New name for the card
+    description?: string, // Optional: New description
+    dueDate?: string,    // Optional: New due date (ISO 8601 format)
+    labels?: string[]    // Optional: New array of label IDs
+  }
+}
+```
+
+### archive_card
+
+Send a card to the archive.
+
+```typescript
+{
+  name: 'archive_card',
+  arguments: {
+    cardId: string  // ID of the card to archive
+  }
+}
+```
+
+### add_list_to_board
+
+Add a new list to the board.
+
+```typescript
+{
+  name: 'add_list_to_board',
+  arguments: {
+    name: string  // Name of the new list
+  }
+}
+```
+
+### archive_list
+
+Send a list to the archive.
+
+```typescript
+{
+  name: 'archive_list',
+  arguments: {
+    listId: string  // ID of the list to archive
+  }
+}
+```
+
+### get_my_cards
+
+Fetch all cards assigned to the current user.
+
+```typescript
+{
+  name: 'get_my_cards',
+  arguments: {}
+}
+```
+
+### move_card
+
+Move a card to a different list.
+
+```typescript
+{
+  name: 'move_card',
+  arguments: {
+    cardId: string,  // ID of the card to move
+    listId: string   // ID of the target list
+  }
+}
+```
+
+## Rate Limiting
+
+The server implements a token bucket algorithm for rate limiting to comply with Trello's API limits:
+
+- 300 requests per 10 seconds per API key
+- 100 requests per 10 seconds per token
+
+Rate limiting is handled automatically, and requests will be queued if limits are reached.
+
+## Error Handling
+
+The server provides detailed error messages for various scenarios:
+
+- Invalid input parameters
+- Rate limit exceeded
+- API authentication errors
+- Network issues
+- Invalid board/list/card IDs
+
+## Development
+
+### Prerequisites
+
+- Node.js 16 or higher
+- npm or yarn
+
+### Setup
+
+1. Clone the repository
+
+```bash
+git clone https://github.com/delorenj/mcp-server-trello
+cd mcp-server-trello
+```
+
+2. Install dependencies
+
+```bash
+npm install
+```
+
+3. Build the project
+
+```bash
+npm run build
+```
+
+
+## Contributing
+
+Contributions are welcome!
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Acknowledgments
+
+- Built with the [Model Context Protocol SDK](https://github.com/modelcontextprotocol/sdk)
+- Uses the [Trello REST API](https://developer.atlassian.com/cloud/trello/rest/)

package/build/index.js

@@ -0,0 +1,308 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from '@modelcontextprotocol/sdk/types.js';
+import { TrelloClient } from './trello-client.js';
+import { validateGetCardsListRequest, validateGetRecentActivityRequest, validateAddCardRequest, validateUpdateCardRequest, validateArchiveCardRequest, validateAddListRequest, validateArchiveListRequest, validateMoveCardRequest, } from './validators.js';
+class TrelloServer {
+    constructor() {
+        const apiKey = process.env.TRELLO_API_KEY;
+        const token = process.env.TRELLO_TOKEN;
+        const boardId = process.env.TRELLO_BOARD_ID;
+        if (!apiKey || !token || !boardId) {
+            throw new Error('TRELLO_API_KEY, TRELLO_TOKEN, and TRELLO_BOARD_ID environment variables are required');
+        }
+        this.trelloClient = new TrelloClient({ apiKey, token, boardId });
+        this.server = new Server({
+            name: 'trello-server',
+            version: '0.1.1',
+        }, {
+            capabilities: {
+                tools: {},
+            },
+        });
+        this.setupToolHandlers();
+        // Error handling
+        this.server.onerror = (error) => console.error('[MCP Error]', error);
+        process.on('SIGINT', async () => {
+            await this.server.close();
+            process.exit(0);
+        });
+    }
+    setupToolHandlers() {
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+            tools: [
+                {
+                    name: 'get_cards_by_list_id',
+                    description: 'Fetch cards from a specific Trello list',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            listId: {
+                                type: 'string',
+                                description: 'ID of the Trello list',
+                            },
+                        },
+                        required: ['listId'],
+                    },
+                },
+                {
+                    name: 'get_lists',
+                    description: 'Retrieve all lists from the specified board',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {},
+                        required: [],
+                    },
+                },
+                {
+                    name: 'get_recent_activity',
+                    description: 'Fetch recent activity on the Trello board',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            limit: {
+                                type: 'number',
+                                description: 'Number of activities to fetch (default: 10)',
+                            },
+                        },
+                        required: [],
+                    },
+                },
+                {
+                    name: 'add_card_to_list',
+                    description: 'Add a new card to a specified list',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            listId: {
+                                type: 'string',
+                                description: 'ID of the list to add the card to',
+                            },
+                            name: {
+                                type: 'string',
+                                description: 'Name of the card',
+                            },
+                            description: {
+                                type: 'string',
+                                description: 'Description of the card',
+                            },
+                            dueDate: {
+                                type: 'string',
+                                description: 'Due date for the card (ISO 8601 format)',
+                            },
+                            labels: {
+                                type: 'array',
+                                items: {
+                                    type: 'string',
+                                },
+                                description: 'Array of label IDs to apply to the card',
+                            },
+                        },
+                        required: ['listId', 'name'],
+                    },
+                },
+                {
+                    name: 'update_card_details',
+                    description: 'Update an existing card\'s details',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            cardId: {
+                                type: 'string',
+                                description: 'ID of the card to update',
+                            },
+                            name: {
+                                type: 'string',
+                                description: 'New name for the card',
+                            },
+                            description: {
+                                type: 'string',
+                                description: 'New description for the card',
+                            },
+                            dueDate: {
+                                type: 'string',
+                                description: 'New due date for the card (ISO 8601 format)',
+                            },
+                            labels: {
+                                type: 'array',
+                                items: {
+                                    type: 'string',
+                                },
+                                description: 'New array of label IDs for the card',
+                            },
+                        },
+                        required: ['cardId'],
+                    },
+                },
+                {
+                    name: 'archive_card',
+                    description: 'Send a card to the archive',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            cardId: {
+                                type: 'string',
+                                description: 'ID of the card to archive',
+                            },
+                        },
+                        required: ['cardId'],
+                    },
+                },
+                {
+                    name: 'move_card',
+                    description: 'Move a card to a different list',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            cardId: {
+                                type: 'string',
+                                description: 'ID of the card to move',
+                            },
+                            listId: {
+                                type: 'string',
+                                description: 'ID of the target list',
+                            },
+                        },
+                        required: ['cardId', 'listId'],
+                    },
+                },
+                {
+                    name: 'add_list_to_board',
+                    description: 'Add a new list to the board',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            name: {
+                                type: 'string',
+                                description: 'Name of the new list',
+                            },
+                        },
+                        required: ['name'],
+                    },
+                },
+                {
+                    name: 'archive_list',
+                    description: 'Send a list to the archive',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            listId: {
+                                type: 'string',
+                                description: 'ID of the list to archive',
+                            },
+                        },
+                        required: ['listId'],
+                    },
+                },
+                {
+                    name: 'get_my_cards',
+                    description: 'Fetch all cards assigned to the current user',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {},
+                        required: [],
+                    },
+                },
+            ],
+        }));
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            try {
+                if (!request.params.arguments) {
+                    throw new McpError(ErrorCode.InvalidParams, 'Missing arguments');
+                }
+                const args = request.params.arguments;
+                switch (request.params.name) {
+                    case 'get_cards_by_list_id': {
+                        const validArgs = validateGetCardsListRequest(args);
+                        const cards = await this.trelloClient.getCardsByList(validArgs.listId);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(cards, null, 2) }],
+                        };
+                    }
+                    case 'get_lists': {
+                        const lists = await this.trelloClient.getLists();
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(lists, null, 2) }],
+                        };
+                    }
+                    case 'get_recent_activity': {
+                        const validArgs = validateGetRecentActivityRequest(args);
+                        const activity = await this.trelloClient.getRecentActivity(validArgs.limit);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(activity, null, 2) }],
+                        };
+                    }
+                    case 'add_card_to_list': {
+                        const validArgs = validateAddCardRequest(args);
+                        const card = await this.trelloClient.addCard(validArgs);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(card, null, 2) }],
+                        };
+                    }
+                    case 'update_card_details': {
+                        const validArgs = validateUpdateCardRequest(args);
+                        const card = await this.trelloClient.updateCard(validArgs);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(card, null, 2) }],
+                        };
+                    }
+                    case 'archive_card': {
+                        const validArgs = validateArchiveCardRequest(args);
+                        const card = await this.trelloClient.archiveCard(validArgs.cardId);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(card, null, 2) }],
+                        };
+                    }
+                    case 'move_card': {
+                        const validArgs = validateMoveCardRequest(args);
+                        const card = await this.trelloClient.moveCard(validArgs.cardId, validArgs.listId);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(card, null, 2) }],
+                        };
+                    }
+                    case 'add_list_to_board': {
+                        const validArgs = validateAddListRequest(args);
+                        const list = await this.trelloClient.addList(validArgs.name);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(list, null, 2) }],
+                        };
+                    }
+                    case 'archive_list': {
+                        const validArgs = validateArchiveListRequest(args);
+                        const list = await this.trelloClient.archiveList(validArgs.listId);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(list, null, 2) }],
+                        };
+                    }
+                    case 'get_my_cards': {
+                        const cards = await this.trelloClient.getMyCards();
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(cards, null, 2) }],
+                        };
+                    }
+                    default:
+                        throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
+                }
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: error instanceof Error ? error.message : 'Unknown error occurred',
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        });
+    }
+    async run() {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        console.error('Trello MCP server running on stdio');
+    }
+}
+const server = new TrelloServer();
+server.run().catch(console.error);

package/build/rate-limiter.js

@@ -0,0 +1,55 @@
+export class TokenBucketRateLimiter {
+    constructor(maxRequests, windowMs) {
+        this.maxTokens = maxRequests;
+        this.tokens = maxRequests;
+        this.lastRefill = Date.now();
+        this.refillInterval = windowMs;
+        this.refillRate = maxRequests / windowMs;
+    }
+    refillTokens() {
+        const now = Date.now();
+        const timePassed = now - this.lastRefill;
+        const newTokens = timePassed * this.refillRate;
+        this.tokens = Math.min(this.maxTokens, this.tokens + newTokens);
+        this.lastRefill = now;
+    }
+    canMakeRequest() {
+        this.refillTokens();
+        if (this.tokens >= 1) {
+            this.tokens -= 1;
+            return true;
+        }
+        return false;
+    }
+    async waitForAvailableToken() {
+        return new Promise((resolve) => {
+            const check = () => {
+                if (this.canMakeRequest()) {
+                    resolve();
+                }
+                else {
+                    // Calculate time until next token is available
+                    const tokensNeeded = 1 - this.tokens;
+                    const msToWait = (tokensNeeded / this.refillRate) * 1000;
+                    setTimeout(check, Math.min(msToWait, 100)); // Check at most every 100ms
+                }
+            };
+            check();
+        });
+    }
+}
+// Create rate limiters based on Trello's limits
+export const createTrelloRateLimiters = () => {
+    const apiKeyLimiter = new TokenBucketRateLimiter(300, 10000); // 300 requests per 10 seconds
+    const tokenLimiter = new TokenBucketRateLimiter(100, 10000); // 100 requests per 10 seconds
+    return {
+        apiKeyLimiter,
+        tokenLimiter,
+        async waitForAvailable() {
+            await Promise.all([
+                apiKeyLimiter.waitForAvailableToken(),
+                tokenLimiter.waitForAvailableToken(),
+            ]);
+        },
+    };
+};

package/build/trello-client.js

@@ -0,0 +1,118 @@
+import axios from 'axios';
+import { createTrelloRateLimiters } from './rate-limiter.js';
+export class TrelloClient {
+    constructor(config) {
+        this.config = config;
+        this.axiosInstance = axios.create({
+            baseURL: 'https://api.trello.com/1',
+            params: {
+                key: config.apiKey,
+                token: config.token,
+            },
+        });
+        this.rateLimiter = createTrelloRateLimiters();
+        // Add rate limiting interceptor
+        this.axiosInstance.interceptors.request.use(async (config) => {
+            await this.rateLimiter.waitForAvailable();
+            return config;
+        });
+    }
+    async handleRequest(request) {
+        try {
+            return await request();
+        }
+        catch (error) {
+            if (axios.isAxiosError(error)) {
+                if (error.response?.status === 429) {
+                    // Rate limit exceeded, wait and retry
+                    await new Promise(resolve => setTimeout(resolve, 1000));
+                    return this.handleRequest(request);
+                }
+                throw new Error(`Trello API error: ${error.response?.data?.message ?? error.message}`);
+            }
+            throw error;
+        }
+    }
+    async getCardsByList(listId) {
+        return this.handleRequest(async () => {
+            const response = await this.axiosInstance.get(`/lists/${listId}/cards`);
+            return response.data;
+        });
+    }
+    async getLists() {
+        return this.handleRequest(async () => {
+            const response = await this.axiosInstance.get(`/boards/${this.config.boardId}/lists`);
+            return response.data;
+        });
+    }
+    async getRecentActivity(limit = 10) {
+        return this.handleRequest(async () => {
+            const response = await this.axiosInstance.get(`/boards/${this.config.boardId}/actions`, {
+                params: { limit },
+            });
+            return response.data;
+        });
+    }
+    async addCard(params) {
+        return this.handleRequest(async () => {
+            const response = await this.axiosInstance.post('/cards', {
+                idList: params.listId,
+                name: params.name,
+                desc: params.description,
+                due: params.dueDate,
+                idLabels: params.labels,
+            });
+            return response.data;
+        });
+    }
+    async updateCard(params) {
+        return this.handleRequest(async () => {
+            const response = await this.axiosInstance.put(`/cards/${params.cardId}`, {
+                name: params.name,
+                desc: params.description,
+                due: params.dueDate,
+                idLabels: params.labels,
+            });
+            return response.data;
+        });
+    }
+    async archiveCard(cardId) {
+        return this.handleRequest(async () => {
+            const response = await this.axiosInstance.put(`/cards/${cardId}`, {
+                closed: true,
+            });
+            return response.data;
+        });
+    }
+    async moveCard(cardId, listId) {
+        return this.handleRequest(async () => {
+            const response = await this.axiosInstance.put(`/cards/${cardId}`, {
+                idList: listId,
+            });
+            return response.data;
+        });
+    }
+    async addList(name) {
+        return this.handleRequest(async () => {
+            const response = await this.axiosInstance.post('/lists', {
+                name,
+                idBoard: this.config.boardId,
+            });
+            return response.data;
+        });
+    }
+    async archiveList(listId) {
+        return this.handleRequest(async () => {
+            const response = await this.axiosInstance.put(`/lists/${listId}/closed`, {
+                value: true,
+            });
+            return response.data;
+        });
+    }
+    async getMyCards() {
+        return this.handleRequest(async () => {
+            const response = await this.axiosInstance.get('/members/me/cards');
+            return response.data;
+        });
+    }
+}

package/build/types.js

@@ -0,0 +1 @@
+export {};

package/build/validators.js

@@ -0,0 +1,104 @@
+import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
+export function validateString(value, field) {
+    if (typeof value !== 'string') {
+        throw new McpError(ErrorCode.InvalidParams, `${field} must be a string`);
+    }
+    return value;
+}
+export function validateOptionalString(value) {
+    if (value === undefined)
+        return undefined;
+    return validateString(value, 'value');
+}
+export function validateNumber(value, field) {
+    if (typeof value !== 'number') {
+        throw new McpError(ErrorCode.InvalidParams, `${field} must be a number`);
+    }
+    return value;
+}
+export function validateOptionalNumber(value) {
+    if (value === undefined)
+        return undefined;
+    return validateNumber(value, 'value');
+}
+export function validateStringArray(value) {
+    if (!Array.isArray(value) || !value.every(item => typeof item === 'string')) {
+        throw new McpError(ErrorCode.InvalidParams, 'Value must be an array of strings');
+    }
+    return value;
+}
+export function validateOptionalStringArray(value) {
+    if (value === undefined)
+        return undefined;
+    return validateStringArray(value);
+}
+export function validateGetCardsListRequest(args) {
+    if (!args.listId) {
+        throw new McpError(ErrorCode.InvalidParams, 'listId is required');
+    }
+    return {
+        listId: validateString(args.listId, 'listId'),
+    };
+}
+export function validateGetRecentActivityRequest(args) {
+    return {
+        limit: validateOptionalNumber(args.limit),
+    };
+}
+export function validateAddCardRequest(args) {
+    if (!args.listId || !args.name) {
+        throw new McpError(ErrorCode.InvalidParams, 'listId and name are required');
+    }
+    return {
+        listId: validateString(args.listId, 'listId'),
+        name: validateString(args.name, 'name'),
+        description: validateOptionalString(args.description),
+        dueDate: validateOptionalString(args.dueDate),
+        labels: validateOptionalStringArray(args.labels),
+    };
+}
+export function validateUpdateCardRequest(args) {
+    if (!args.cardId) {
+        throw new McpError(ErrorCode.InvalidParams, 'cardId is required');
+    }
+    return {
+        cardId: validateString(args.cardId, 'cardId'),
+        name: validateOptionalString(args.name),
+        description: validateOptionalString(args.description),
+        dueDate: validateOptionalString(args.dueDate),
+        labels: validateOptionalStringArray(args.labels),
+    };
+}
+export function validateArchiveCardRequest(args) {
+    if (!args.cardId) {
+        throw new McpError(ErrorCode.InvalidParams, 'cardId is required');
+    }
+    return {
+        cardId: validateString(args.cardId, 'cardId'),
+    };
+}
+export function validateAddListRequest(args) {
+    if (!args.name) {
+        throw new McpError(ErrorCode.InvalidParams, 'name is required');
+    }
+    return {
+        name: validateString(args.name, 'name'),
+    };
+}
+export function validateArchiveListRequest(args) {
+    if (!args.listId) {
+        throw new McpError(ErrorCode.InvalidParams, 'listId is required');
+    }
+    return {
+        listId: validateString(args.listId, 'listId'),
+    };
+}
+export function validateMoveCardRequest(args) {
+    if (!args.cardId || !args.listId) {
+        throw new McpError(ErrorCode.InvalidParams, 'cardId and listId are required');
+    }
+    return {
+        cardId: validateString(args.cardId, 'cardId'),
+        listId: validateString(args.listId, 'listId'),
+    };
+}

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@delorenj/mcp-server-trello",
+  "version": "0.1.1",
+  "description": "A Model Context Protocol (MCP) server for interacting with Trello boards",
+  "type": "module",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "bin": {
+    "mcp-server-trello": "./build/index.js"
+  },
+  "scripts": {
+    "build": "tsc && chmod +x build/index.js",
+    "start": "node build/index.js",
+    "dev": "ts-node --esm src/index.ts",
+    "lint": "eslint . --ext .ts",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "prepare": "npm run build",
+    "inspector": "npx @modelcontextprotocol/inspector build/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/delorenj/mcp-server-trello.git"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "trello",
+    "api",
+    "integration",
+    "automation",
+    "typescript",
+    "board-management",
+    "task-management",
+    "kanban"
+  ],
+  "author": "Jarad DeLorenzo",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/delorenj/mcp-server-trello/issues"
+  },
+  "homepage": "https://github.com/delorenj/mcp-server-trello#readme",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.4",
+    "axios": "^1.6.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "@typescript-eslint/eslint-plugin": "^6.12.0",
+    "@typescript-eslint/parser": "^6.12.0",
+    "eslint": "^8.54.0",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-plugin-prettier": "^5.0.1",
+    "prettier": "^3.1.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.3.2"
+  },
+  "files": [
+    "build/**/*"
+  ],
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}