motionmcp 2.2.4 → 2.4.0

package/dist/mcp-server-old.js

@@ -0,0 +1,1304 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const motionApi_1 = require("./services/motionApi");
+const utils_1 = require("./utils");
+const sanitize_1 = require("./utils/sanitize");
+const validator_1 = require("./utils/validator");
+const dotenv = __importStar(require("dotenv"));
+dotenv.config();
+class MotionMCPServer {
+    constructor() {
+        this.server = new index_js_1.Server({
+            name: "motion-mcp-server",
+            version: "1.0.0",
+        }, {
+            capabilities: {
+                tools: {},
+            },
+        });
+        this.motionService = null;
+        this.workspaceResolver = null;
+        this.validator = new validator_1.InputValidator();
+        this.toolsConfig = process.env.MOTION_MCP_TOOLS || 'essential';
+        this.setupHandlers();
+    }
+    async initialize() {
+        try {
+            // Validate tools configuration
+            this.validateToolsConfig();
+            this.motionService = new motionApi_1.MotionApiService();
+            this.workspaceResolver = new utils_1.WorkspaceResolver(this.motionService);
+            // Initialize validators with tool definitions
+            this.validator.initializeValidators(this.getEnabledTools());
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            (0, utils_1.mcpLog)(utils_1.LOG_LEVELS.ERROR, "Failed to initialize Motion API service", { error: errorMessage });
+            process.exit(1);
+        }
+    }
+    validateToolsConfig() {
+        const validConfigs = ['minimal', 'essential', 'complete'];
+        // Check if it's a valid preset or custom configuration
+        if (!validConfigs.includes(this.toolsConfig) && !this.toolsConfig.startsWith('custom:')) {
+            (0, utils_1.mcpLog)(utils_1.LOG_LEVELS.ERROR, `Invalid MOTION_MCP_TOOLS configuration: "${this.toolsConfig}"`, {
+                validOptions: [...validConfigs, 'custom:tool1,tool2,...'],
+                defaulting: 'essential'
+            });
+            // Still default to essential, but log it prominently
+            (0, utils_1.mcpLog)(utils_1.LOG_LEVELS.WARN, 'Defaulting to "essential" configuration');
+            this.toolsConfig = 'essential';
+        }
+        // For custom configurations, validate tool names exist
+        if (this.toolsConfig.startsWith('custom:')) {
+            const customTools = this.toolsConfig.substring(7).split(',').map(s => s.trim());
+            const allToolNames = this.getAllToolDefinitions().map(t => t.name);
+            const invalidTools = customTools.filter(name => !allToolNames.includes(name));
+            if (invalidTools.length > 0) {
+                (0, utils_1.mcpLog)(utils_1.LOG_LEVELS.ERROR, 'Invalid tool names in custom configuration', {
+                    invalidTools,
+                    availableTools: allToolNames
+                });
+                throw new Error(`Invalid tool names in custom configuration: ${invalidTools.join(', ')}`);
+            }
+            if (customTools.length === 0) {
+                throw new Error('Custom configuration must specify at least one tool');
+            }
+        }
+        (0, utils_1.mcpLog)(utils_1.LOG_LEVELS.INFO, `Tool configuration validated: ${this.toolsConfig}`);
+    }
+    setupHandlers() {
+        this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+            return {
+                tools: this.getEnabledTools()
+            };
+        });
+        this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+            if (!this.motionService || !this.workspaceResolver) {
+                return (0, utils_1.formatMcpError)(new Error("Server not initialized"));
+            }
+            try {
+                const { name, arguments: args } = request.params;
+                // Runtime validation
+                const validation = this.validator.validateInput(name, args);
+                if (!validation.valid) {
+                    return (0, utils_1.formatMcpError)(new Error(`Invalid arguments for ${name}: ${validation.errors}`));
+                }
+                switch (name) {
+                    // Consolidated tools
+                    case "motion_projects":
+                        return await this.handleMotionProjects(args);
+                    case "motion_tasks":
+                        return await this.handleMotionTasks(args);
+                    case "motion_workspaces":
+                        return await this.handleMotionWorkspaces(args);
+                    case "motion_users":
+                        return await this.handleMotionUsers(args);
+                    case "motion_search":
+                        return await this.handleMotionSearch(args);
+                    case "motion_comments":
+                        return await this.handleMotionComments(args);
+                    case "motion_custom_fields":
+                        return await this.handleMotionCustomFields(args);
+                    case "motion_recurring_tasks":
+                        return await this.handleMotionRecurringTasks(args);
+                    case "motion_schedules":
+                        return await this.handleMotionSchedules(args);
+                    case "motion_statuses":
+                        return await this.handleMotionStatuses(args);
+                    default:
+                        return (0, utils_1.formatMcpError)(new Error(`Unknown tool: ${name}`));
+                }
+            }
+            catch (error) {
+                return (0, utils_1.formatMcpError)(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    }
+    getAllToolDefinitions() {
+        return [
+            // Consolidated tools
+            {
+                name: "motion_projects",
+                description: "Manage Motion projects - supports create, list, and get operations",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        operation: {
+                            type: "string",
+                            enum: ["create", "list", "get"],
+                            description: "Operation to perform"
+                        },
+                        projectId: {
+                            type: "string",
+                            description: "Project ID (required for get operation)"
+                        },
+                        workspaceId: {
+                            type: "string",
+                            description: "Workspace ID"
+                        },
+                        workspaceName: {
+                            type: "string",
+                            description: "Workspace name (alternative to ID)"
+                        },
+                        name: {
+                            type: "string",
+                            description: "Project name"
+                        },
+                        description: {
+                            type: "string",
+                            description: "Project description"
+                        },
+                        color: {
+                            type: "string",
+                            description: "Hex color code"
+                        },
+                        status: {
+                            type: "string",
+                            description: "Project status"
+                        }
+                    },
+                    required: ["operation"]
+                }
+            },
+            {
+                name: "motion_tasks",
+                description: "Manage Motion tasks - supports create, list, get, update, delete, move, and unassign operations",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        operation: {
+                            type: "string",
+                            enum: ["create", "list", "get", "update", "delete", "move", "unassign"],
+                            description: "Operation to perform"
+                        },
+                        taskId: {
+                            type: "string",
+                            description: "Task ID (required for get/update/delete/move/unassign)"
+                        },
+                        workspaceId: {
+                            type: "string",
+                            description: "Filter by workspace (for list)"
+                        },
+                        workspaceName: {
+                            type: "string",
+                            description: "Filter by workspace name (for list)"
+                        },
+                        projectId: {
+                            type: "string",
+                            description: "Filter by project (for list)"
+                        },
+                        projectName: {
+                            type: "string",
+                            description: "Project name (alternative to projectId)"
+                        },
+                        status: {
+                            type: "string",
+                            description: "Filter by status (for list)"
+                        },
+                        assigneeId: {
+                            type: "string",
+                            description: "Filter by assignee (for list)"
+                        },
+                        name: {
+                            type: "string",
+                            description: "Task name (required for create)"
+                        },
+                        description: {
+                            type: "string",
+                            description: "Task description"
+                        },
+                        priority: {
+                            type: "string",
+                            enum: ["ASAP", "HIGH", "MEDIUM", "LOW"],
+                            description: "Task priority"
+                        },
+                        dueDate: {
+                            type: "string",
+                            description: "ISO 8601 format"
+                        },
+                        duration: {
+                            oneOf: [
+                                { type: "string", enum: ["NONE", "REMINDER"] },
+                                { type: "number", minimum: 0 }
+                            ],
+                            description: "Minutes (as number) or 'NONE'/'REMINDER' (as string)"
+                        },
+                        labels: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Task labels"
+                        },
+                        autoScheduled: {
+                            oneOf: [
+                                { type: "object" },
+                                { type: "null" }
+                            ],
+                            description: "Auto-scheduling configuration"
+                        },
+                        targetProjectId: {
+                            type: "string",
+                            description: "Target project for move operation"
+                        },
+                        targetWorkspaceId: {
+                            type: "string",
+                            description: "Target workspace for move operation"
+                        },
+                        limit: {
+                            type: "number",
+                            description: "Maximum number of tasks to return (for list)"
+                        }
+                    },
+                    required: ["operation"]
+                }
+            },
+            // New consolidated tools for workspace and search management
+            {
+                name: "motion_workspaces",
+                description: "Manage Motion workspaces - supports list, get, and set_default operations",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        operation: {
+                            type: "string",
+                            enum: ["list", "get", "set_default"],
+                            description: "Operation to perform"
+                        },
+                        workspaceId: {
+                            type: "string",
+                            description: "Workspace ID (required for get and set_default operations)"
+                        }
+                    },
+                    required: ["operation"]
+                }
+            },
+            {
+                name: "motion_search",
+                description: "Search and context utilities for Motion - supports content, context, and smart operations",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        operation: {
+                            type: "string",
+                            enum: ["content", "context", "smart"],
+                            description: "Operation to perform"
+                        },
+                        query: {
+                            type: "string",
+                            description: "Search query (required for content and smart operations)"
+                        },
+                        searchScope: {
+                            type: "string",
+                            enum: ["tasks", "projects", "both"],
+                            description: "What to search for content operation (default: both)"
+                        },
+                        workspaceId: {
+                            type: "string",
+                            description: "Workspace ID to limit search/context"
+                        },
+                        workspaceName: {
+                            type: "string",
+                            description: "Workspace name (alternative to workspaceId)"
+                        },
+                        limit: {
+                            type: "number",
+                            description: "Maximum number of results for content operation"
+                        },
+                        includeProjects: {
+                            type: "boolean",
+                            description: "Include project information for context operation"
+                        },
+                        includeTasks: {
+                            type: "boolean",
+                            description: "Include task information for context operation"
+                        },
+                        includeUsers: {
+                            type: "boolean",
+                            description: "Include user information for context operation"
+                        },
+                        entityType: {
+                            type: "string",
+                            enum: ["project", "task"],
+                            description: "Entity type for smart operation"
+                        },
+                        entityId: {
+                            type: "string",
+                            description: "Entity ID for smart operation"
+                        },
+                        includeRelated: {
+                            type: "boolean",
+                            description: "Include related entities for smart operation"
+                        }
+                    },
+                    required: ["operation"]
+                }
+            },
+            {
+                name: "motion_users",
+                description: "Manage users and get current user information",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        operation: {
+                            type: "string",
+                            enum: ["list", "current"],
+                            description: "Operation to perform"
+                        },
+                        workspaceId: {
+                            type: "string",
+                            description: "Workspace ID (optional for list operation, ignored for current)"
+                        },
+                        workspaceName: {
+                            type: "string",
+                            description: "Workspace name (alternative to workspaceId, ignored for current)"
+                        }
+                    },
+                    required: ["operation"]
+                }
+            },
+            {
+                name: "motion_comments",
+                description: "Manage comments on tasks",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        operation: {
+                            type: "string",
+                            enum: ["list", "create"],
+                            description: "Operation to perform"
+                        },
+                        taskId: {
+                            type: "string",
+                            description: "Task ID to comment on or fetch comments from (required)"
+                        },
+                        content: {
+                            type: "string",
+                            description: "Comment content (required for create operation)"
+                        },
+                        cursor: {
+                            type: "string",
+                            description: "Pagination cursor for list operation (optional)"
+                        }
+                    },
+                    required: ["operation", "taskId"]
+                }
+            },
+            {
+                name: "motion_custom_fields",
+                description: "Manage custom fields for tasks and projects",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        operation: {
+                            type: "string",
+                            enum: ["list", "create", "delete", "add_to_project", "remove_from_project", "add_to_task", "remove_from_task"],
+                            description: "Operation to perform"
+                        },
+                        fieldId: {
+                            type: "string",
+                            description: "Custom field ID"
+                        },
+                        workspaceId: {
+                            type: "string",
+                            description: "Workspace ID"
+                        },
+                        name: {
+                            type: "string",
+                            description: "Field name (for create)"
+                        },
+                        field: {
+                            type: "string",
+                            enum: ["text", "url", "date", "person", "multiPerson", "phone", "select", "multiSelect", "number", "email", "checkbox", "relatedTo"],
+                            description: "Field type (for create)"
+                        },
+                        options: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Options for select/multiselect fields"
+                        },
+                        required: {
+                            type: "boolean",
+                            description: "Whether field is required"
+                        },
+                        projectId: {
+                            type: "string",
+                            description: "Project ID (for add/remove operations)"
+                        },
+                        taskId: {
+                            type: "string",
+                            description: "Task ID (for add/remove operations)"
+                        },
+                        value: {
+                            type: ["string", "number", "boolean", "array", "null"],
+                            description: "Field value"
+                        }
+                    },
+                    required: ["operation", "workspaceId"]
+                }
+            },
+            {
+                name: "motion_recurring_tasks",
+                description: "Manage recurring tasks",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        operation: {
+                            type: "string",
+                            enum: ["list", "create", "delete"],
+                            description: "Operation to perform"
+                        },
+                        recurringTaskId: {
+                            type: "string",
+                            description: "Recurring task ID (for delete)"
+                        },
+                        workspaceId: {
+                            type: "string",
+                            description: "Workspace ID"
+                        },
+                        name: {
+                            type: "string",
+                            description: "Task name (for create)"
+                        },
+                        description: {
+                            type: "string",
+                            description: "Task description"
+                        },
+                        projectId: {
+                            type: "string",
+                            description: "Project ID"
+                        },
+                        assigneeId: {
+                            type: "string",
+                            description: "User ID to assign the recurring task to (required for create)"
+                        },
+                        frequency: {
+                            type: "object",
+                            properties: {
+                                type: {
+                                    type: "string",
+                                    enum: ["daily", "weekly", "monthly", "yearly"],
+                                    description: "Frequency type"
+                                },
+                                interval: {
+                                    type: "number",
+                                    description: "Repeat every N periods"
+                                },
+                                daysOfWeek: {
+                                    type: "array",
+                                    items: { type: "number" },
+                                    description: "0-6 for Sunday-Saturday (for weekly)"
+                                },
+                                dayOfMonth: {
+                                    type: "number",
+                                    description: "1-31 for monthly recurrence"
+                                },
+                                endDate: {
+                                    type: "string",
+                                    description: "ISO 8601 format end date"
+                                }
+                            },
+                            required: ["type"],
+                            description: "Frequency configuration (required for create)"
+                        },
+                        deadlineType: {
+                            type: "string",
+                            enum: ["HARD", "SOFT"],
+                            description: "Deadline type (default: SOFT)"
+                        },
+                        duration: {
+                            oneOf: [
+                                { type: "number" },
+                                { type: "string", enum: ["REMINDER"] }
+                            ],
+                            description: "Task duration in minutes or REMINDER"
+                        },
+                        startingOn: {
+                            type: "string",
+                            description: "Start date (ISO 8601 format)"
+                        },
+                        idealTime: {
+                            type: "string",
+                            description: "Ideal time in HH:mm format"
+                        },
+                        schedule: {
+                            type: "string",
+                            description: "Schedule name (default: Work Hours)"
+                        },
+                        priority: {
+                            type: "string",
+                            enum: ["ASAP", "HIGH", "MEDIUM", "LOW"],
+                            description: "Task priority (default: MEDIUM)"
+                        }
+                    },
+                    required: ["operation"]
+                }
+            },
+            {
+                name: "motion_schedules",
+                description: "Get user schedules showing their weekly working hours and time zones",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        userId: {
+                            type: "string",
+                            description: "User ID to get schedule for (optional, returns all schedules if not specified)"
+                        },
+                        startDate: {
+                            type: "string",
+                            description: "Start date for filtering schedules (optional)"
+                        },
+                        endDate: {
+                            type: "string",
+                            description: "End date for filtering schedules (optional)"
+                        }
+                    },
+                    additionalProperties: false
+                }
+            },
+            {
+                name: "motion_statuses",
+                description: "Get available task/project statuses for a workspace",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        workspaceId: {
+                            type: "string",
+                            description: "Workspace ID to get statuses for (optional, returns all statuses if not specified)"
+                        }
+                    },
+                    additionalProperties: false
+                }
+            }
+        ];
+    }
+    getEnabledTools() {
+        const allTools = this.getAllToolDefinitions();
+        const toolsMap = new Map(allTools.map(tool => [tool.name, tool]));
+        switch (this.toolsConfig) {
+            case 'minimal':
+                // Only core consolidated tools
+                return [
+                    toolsMap.get('motion_tasks'),
+                    toolsMap.get('motion_projects'),
+                    toolsMap.get('motion_workspaces')
+                ].filter((tool) => tool !== undefined);
+            case 'essential':
+                // Consolidated tools plus commonly needed tools
+                return [
+                    toolsMap.get('motion_tasks'),
+                    toolsMap.get('motion_projects'),
+                    toolsMap.get('motion_workspaces'),
+                    toolsMap.get('motion_users'),
+                    toolsMap.get('motion_search'),
+                    toolsMap.get('motion_comments'),
+                    toolsMap.get('motion_schedules')
+                ].filter((tool) => tool !== undefined);
+            case 'complete':
+                // All consolidated tools
+                return [
+                    toolsMap.get('motion_tasks'),
+                    toolsMap.get('motion_projects'),
+                    toolsMap.get('motion_workspaces'),
+                    toolsMap.get('motion_users'),
+                    toolsMap.get('motion_search'),
+                    toolsMap.get('motion_comments'),
+                    toolsMap.get('motion_custom_fields'),
+                    toolsMap.get('motion_recurring_tasks'),
+                    toolsMap.get('motion_schedules'),
+                    toolsMap.get('motion_statuses')
+                ].filter((tool) => tool !== undefined);
+            default:
+                // Handle custom configuration (already validated in validateToolsConfig)
+                if (this.toolsConfig.startsWith('custom:')) {
+                    const customTools = this.toolsConfig.substring(7).split(',').map(s => s.trim());
+                    return customTools
+                        .map(name => toolsMap.get(name))
+                        .filter((tool) => tool !== undefined);
+                }
+                // This should never happen since we validate in initialize()
+                // But if it does, throw an error instead of silently defaulting
+                throw new Error(`Unexpected tools configuration: ${this.toolsConfig}`);
+        }
+    }
+    // Handler methods
+    // Consolidated handlers for resource-based tools
+    async handleMotionProjects(args) {
+        const motionService = this.motionService;
+        const workspaceResolver = this.workspaceResolver;
+        if (!motionService || !workspaceResolver) {
+            return (0, utils_1.formatMcpError)(new Error("Services not available"));
+        }
+        const { operation, ...params } = args;
+        try {
+            switch (operation) {
+                case 'create':
+                    if (!params.name) {
+                        return (0, utils_1.formatMcpError)(new Error("Project name is required for create operation"));
+                    }
+                    const projectData = (0, utils_1.parseProjectArgs)(params);
+                    const workspace = await workspaceResolver.resolveWorkspace({
+                        workspaceId: projectData.workspaceId,
+                        workspaceName: projectData.workspaceName
+                    });
+                    const project = await motionService.createProject({
+                        ...projectData,
+                        workspaceId: workspace.id
+                    });
+                    return (0, utils_1.formatMcpSuccess)(`Successfully created project "${project.name}" (ID: ${project.id})`);
+                case 'list':
+                    const listWorkspace = await workspaceResolver.resolveWorkspace({
+                        workspaceId: params.workspaceId,
+                        workspaceName: params.workspaceName
+                    });
+                    const projects = await motionService.getProjects(listWorkspace.id);
+                    return (0, utils_1.formatProjectList)(projects, listWorkspace.name);
+                case 'get':
+                    if (!params.projectId) {
+                        return (0, utils_1.formatMcpError)(new Error("Project ID is required for get operation"));
+                    }
+                    const projectDetails = await motionService.getProject(params.projectId);
+                    return (0, utils_1.formatDetailResponse)(projectDetails, `Project details for "${projectDetails.name}"`);
+                default:
+                    return (0, utils_1.formatMcpError)(new Error(`Unknown operation: ${operation}`));
+            }
+        }
+        catch (error) {
+            return (0, utils_1.formatMcpError)(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    async handleMotionTasks(args) {
+        const motionService = this.motionService;
+        const workspaceResolver = this.workspaceResolver;
+        if (!motionService || !workspaceResolver) {
+            return (0, utils_1.formatMcpError)(new Error("Services not available"));
+        }
+        const { operation, ...params } = args;
+        try {
+            switch (operation) {
+                case 'create':
+                    if (!params.name) {
+                        return (0, utils_1.formatMcpError)(new Error("Task name is required for create operation"));
+                    }
+                    const taskData = (0, utils_1.parseTaskArgs)(params);
+                    const workspace = await workspaceResolver.resolveWorkspace(taskData);
+                    const task = await motionService.createTask({
+                        ...taskData,
+                        workspaceId: workspace.id
+                    });
+                    return (0, utils_1.formatMcpSuccess)(`Successfully created task "${task.name}" (ID: ${task.id})`);
+                case 'list':
+                    const listWorkspace = await workspaceResolver.resolveWorkspace({
+                        workspaceId: params.workspaceId,
+                        workspaceName: params.workspaceName
+                    });
+                    const tasks = await motionService.getTasks(listWorkspace.id, params.projectId, 5, // maxPages
+                    params.limit);
+                    return (0, utils_1.formatTaskList)(tasks, {
+                        workspaceName: listWorkspace.name,
+                        projectName: params.projectName,
+                        status: params.status,
+                        limit: params.limit
+                    });
+                case 'get':
+                    if (!params.taskId) {
+                        return (0, utils_1.formatMcpError)(new Error("Task ID is required for get operation"));
+                    }
+                    const taskDetails = await motionService.getTask(params.taskId);
+                    return (0, utils_1.formatDetailResponse)(taskDetails, `Task details for "${taskDetails.name}"`);
+                case 'update':
+                    if (!params.taskId) {
+                        return (0, utils_1.formatMcpError)(new Error("Task ID is required for update operation"));
+                    }
+                    // Create update object with only valid MotionTask fields
+                    const updateData = {};
+                    if (params.name !== undefined)
+                        updateData.name = params.name;
+                    if (params.description !== undefined)
+                        updateData.description = params.description;
+                    if (params.status !== undefined)
+                        updateData.status = params.status;
+                    if (params.priority !== undefined)
+                        updateData.priority = params.priority;
+                    if (params.dueDate !== undefined)
+                        updateData.dueDate = params.dueDate;
+                    if (params.duration !== undefined) {
+                        // Convert string duration to number or keep special values
+                        if (typeof params.duration === 'string') {
+                            if (params.duration === 'NONE' || params.duration === 'REMINDER') {
+                                updateData.duration = params.duration;
+                            }
+                            else {
+                                const numDuration = parseInt(params.duration, 10);
+                                if (!isNaN(numDuration)) {
+                                    updateData.duration = numDuration;
+                                }
+                            }
+                        }
+                        else {
+                            updateData.duration = params.duration;
+                        }
+                    }
+                    if (params.labels !== undefined)
+                        updateData.labels = params.labels?.map(name => ({ name }));
+                    if (params.autoScheduled !== undefined)
+                        updateData.autoScheduled = params.autoScheduled;
+                    const updatedTask = await motionService.updateTask(params.taskId, updateData);
+                    return (0, utils_1.formatMcpSuccess)(`Successfully updated task "${updatedTask.name}" (ID: ${updatedTask.id})`);
+                case 'delete':
+                    if (!params.taskId) {
+                        return (0, utils_1.formatMcpError)(new Error("Task ID is required for delete operation"));
+                    }
+                    await motionService.deleteTask(params.taskId);
+                    return (0, utils_1.formatMcpSuccess)(`Successfully deleted task ${params.taskId}`);
+                case 'move':
+                    if (!params.taskId) {
+                        return (0, utils_1.formatMcpError)(new Error("Task ID is required for move operation"));
+                    }
+                    if (!params.targetProjectId && !params.targetWorkspaceId) {
+                        return (0, utils_1.formatMcpError)(new Error("Either target project ID or target workspace ID is required for move operation"));
+                    }
+                    const movedTask = await motionService.moveTask(params.taskId, params.targetProjectId, params.targetWorkspaceId);
+                    return (0, utils_1.formatMcpSuccess)(`Successfully moved task "${movedTask.name}" (ID: ${movedTask.id})`);
+                case 'unassign':
+                    if (!params.taskId) {
+                        return (0, utils_1.formatMcpError)(new Error("Task ID is required for unassign operation"));
+                    }
+                    const unassignedTask = await motionService.unassignTask(params.taskId);
+                    return (0, utils_1.formatMcpSuccess)(`Successfully unassigned task "${unassignedTask.name}" (ID: ${unassignedTask.id})`);
+                default:
+                    return (0, utils_1.formatMcpError)(new Error(`Unknown operation: ${operation}`));
+            }
+        }
+        catch (error) {
+            return (0, utils_1.formatMcpError)(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    async handleSearchContent(args) {
+        const motionService = this.motionService;
+        const workspaceResolver = this.workspaceResolver;
+        if (!motionService || !workspaceResolver) {
+            return (0, utils_1.formatMcpError)(new Error("Services not available"));
+        }
+        const { query, entityTypes = ['projects', 'tasks'] } = args;
+        // Use configurable limit to prevent resource exhaustion
+        const limit = utils_1.LIMITS.MAX_SEARCH_RESULTS;
+        const workspace = await workspaceResolver.resolveWorkspace(args);
+        let results = [];
+        if (entityTypes?.includes('tasks')) {
+            // Pass limit to prevent fetching unlimited results
+            const tasks = await motionService.searchTasks(query, workspace.id, limit);
+            results.push(...tasks);
+        }
+        if (entityTypes?.includes('projects')) {
+            // Pass limit to prevent fetching unlimited results
+            const projects = await motionService.searchProjects(query, workspace.id, limit);
+            results.push(...projects);
+        }
+        return (0, utils_1.formatSearchResults)(results.slice(0, limit), query, { limit, searchScope: entityTypes?.join(',') || 'both' });
+    }
+    async handleGetContext(args) {
+        const { entityType, entityId, includeRelated = false } = args;
+        let contextText = `Context for ${entityType} ${entityId}:\n\n`;
+        // For now, return a simple context message as Motion API doesn't have specific context endpoints
+        if (entityType === 'project') {
+            contextText += `Project ID: ${entityId}\n`;
+            if (includeRelated) {
+                contextText += `Related tasks would be listed here (when available)\n`;
+            }
+        }
+        else if (entityType === 'task') {
+            contextText += `Task ID: ${entityId}\n`;
+            if (includeRelated) {
+                contextText += `Related project and subtasks would be listed here (when available)\n`;
+            }
+        }
+        return (0, utils_1.formatMcpSuccess)(contextText);
+    }
+    async handleMotionUsers(args) {
+        const motionService = this.motionService;
+        const workspaceResolver = this.workspaceResolver;
+        if (!motionService) {
+            return (0, utils_1.formatMcpError)(new Error("Motion service is not available"));
+        }
+        const { operation, workspaceId, workspaceName } = args;
+        try {
+            switch (operation) {
+                case 'list':
+                    if (!workspaceResolver) {
+                        return (0, utils_1.formatMcpError)(new Error("Workspace resolver not available"));
+                    }
+                    const workspace = await workspaceResolver.resolveWorkspace({ workspaceId, workspaceName });
+                    const users = await motionService.getUsers(workspace.id);
+                    const userList = users.map(u => `- ${u.name} (${u.email}) [ID: ${u.id}]`).join('\n');
+                    return (0, utils_1.formatMcpSuccess)(`Users in workspace "${workspace.name}":\n${userList}`);
+                case 'current':
+                    const currentUser = await motionService.getCurrentUser();
+                    const userInfo = `Current user: ${currentUser.name || 'No name'} (${currentUser.email}) [ID: ${currentUser.id}]`;
+                    return (0, utils_1.formatMcpSuccess)(userInfo);
+                default:
+                    return (0, utils_1.formatMcpError)(new Error(`Unknown operation: ${operation}`));
+            }
+        }
+        catch (error) {
+            return (0, utils_1.formatMcpError)(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    async handleMotionComments(args) {
+        const motionService = this.motionService;
+        if (!motionService) {
+            return (0, utils_1.formatMcpError)(new Error("Motion service is not available"));
+        }
+        const { operation, taskId, content, cursor } = args;
+        try {
+            switch (operation) {
+                case 'list':
+                    if (!taskId) {
+                        return (0, utils_1.formatMcpError)(new Error('taskId is required for list operation'));
+                    }
+                    const commentsResponse = await motionService.getComments(taskId, cursor);
+                    // Format the comments list
+                    const commentsResult = (0, utils_1.formatCommentList)(commentsResponse.data);
+                    // Add pagination info if there's more data
+                    if (commentsResponse.meta.nextCursor && commentsResult.content[0]) {
+                        // Type guard to safely check if content[0] has text property
+                        function hasTextProperty(obj) {
+                            return typeof obj === 'object' && obj !== null && 'text' in obj && typeof obj.text === 'string';
+                        }
+                        if (hasTextProperty(commentsResult.content[0])) {
+                            commentsResult.content[0].text += `\n\n📄 More comments available. Use cursor: ${commentsResponse.meta.nextCursor}`;
+                        }
+                    }
+                    return commentsResult;
+                case 'create':
+                    if (!taskId) {
+                        return (0, utils_1.formatMcpError)(new Error('taskId is required for create operation'));
+                    }
+                    if (!content) {
+                        return (0, utils_1.formatMcpError)(new Error('content is required for create operation'));
+                    }
+                    // Sanitize and validate comment content
+                    const sanitizationResult = (0, sanitize_1.sanitizeCommentContent)(content);
+                    if (!sanitizationResult.isValid) {
+                        return (0, utils_1.formatMcpError)(new Error(sanitizationResult.error || 'Invalid comment content'));
+                    }
+                    const sanitizedContent = sanitizationResult.sanitized;
+                    if (sanitizedContent.length > utils_1.LIMITS.COMMENT_MAX_LENGTH) {
+                        return (0, utils_1.formatMcpError)(new Error(`Comment content exceeds maximum length of ${utils_1.LIMITS.COMMENT_MAX_LENGTH} characters`));
+                    }
+                    const commentData = {
+                        taskId,
+                        content: sanitizedContent
+                    };
+                    const newComment = await motionService.createComment(commentData);
+                    return (0, utils_1.formatCommentDetail)(newComment);
+                default:
+                    return (0, utils_1.formatMcpError)(new Error(`Unknown operation: ${operation}`));
+            }
+        }
+        catch (error) {
+            return (0, utils_1.formatMcpError)(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    async handleMotionCustomFields(args) {
+        const motionService = this.motionService;
+        if (!motionService) {
+            return (0, utils_1.formatMcpError)(new Error("Motion service is not available"));
+        }
+        const { operation, fieldId, workspaceId, name, field, options, projectId, taskId, value } = args;
+        try {
+            switch (operation) {
+                case 'list':
+                    if (!workspaceId) {
+                        return (0, utils_1.formatMcpError)(new Error('Workspace ID is required for list operation'));
+                    }
+                    const fields = await motionService.getCustomFields(workspaceId);
+                    return (0, utils_1.formatCustomFieldList)(fields);
+                case 'create':
+                    if (!workspaceId) {
+                        return (0, utils_1.formatMcpError)(new Error('Workspace ID is required for create operation'));
+                    }
+                    if (!name || !field) {
+                        return (0, utils_1.formatMcpError)(new Error('Name and field are required for create operation'));
+                    }
+                    // Validate custom field name length
+                    if (name.length > utils_1.LIMITS.CUSTOM_FIELD_NAME_MAX_LENGTH) {
+                        return (0, utils_1.formatMcpError)(new Error(`Field name exceeds ${utils_1.LIMITS.CUSTOM_FIELD_NAME_MAX_LENGTH} characters`));
+                    }
+                    // Validate options parameter - only allowed for select/multiSelect fields
+                    if (['select', 'multiSelect'].includes(field) !== Boolean(options)) {
+                        return (0, utils_1.formatMcpError)(new Error('Options parameter only allowed for select/multiSelect field types'));
+                    }
+                    const fieldData = {
+                        name,
+                        field,
+                        ...(options && { metadata: { options } })
+                    };
+                    const newField = await motionService.createCustomField(workspaceId, fieldData);
+                    return (0, utils_1.formatCustomFieldDetail)(newField);
+                case 'delete':
+                    if (!workspaceId) {
+                        return (0, utils_1.formatMcpError)(new Error('Workspace ID is required for delete operation'));
+                    }
+                    if (!fieldId) {
+                        return (0, utils_1.formatMcpError)(new Error('Field ID is required for delete operation'));
+                    }
+                    await motionService.deleteCustomField(workspaceId, fieldId);
+                    return (0, utils_1.formatCustomFieldSuccess)('deleted');
+                case 'add_to_project':
+                    if (!projectId || !fieldId) {
+                        return (0, utils_1.formatMcpError)(new Error('Project ID and field ID are required for add_to_project operation'));
+                    }
+                    await motionService.addCustomFieldToProject(projectId, fieldId, value);
+                    return (0, utils_1.formatCustomFieldSuccess)('added', 'project', projectId);
+                case 'remove_from_project':
+                    if (!projectId || !fieldId) {
+                        return (0, utils_1.formatMcpError)(new Error('Project ID and field ID are required for remove_from_project operation'));
+                    }
+                    await motionService.removeCustomFieldFromProject(projectId, fieldId);
+                    return (0, utils_1.formatCustomFieldSuccess)('removed', 'project', projectId);
+                case 'add_to_task':
+                    if (!taskId || !fieldId) {
+                        return (0, utils_1.formatMcpError)(new Error('Task ID and field ID are required for add_to_task operation'));
+                    }
+                    await motionService.addCustomFieldToTask(taskId, fieldId, value);
+                    return (0, utils_1.formatCustomFieldSuccess)('added', 'task', taskId);
+                case 'remove_from_task':
+                    if (!taskId || !fieldId) {
+                        return (0, utils_1.formatMcpError)(new Error('Task ID and field ID are required for remove_from_task operation'));
+                    }
+                    await motionService.removeCustomFieldFromTask(taskId, fieldId);
+                    return (0, utils_1.formatCustomFieldSuccess)('removed', 'task', taskId);
+                default:
+                    return (0, utils_1.formatMcpError)(new Error(`Unknown operation: ${operation}`));
+            }
+        }
+        catch (error) {
+            return (0, utils_1.formatMcpError)(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    async handleMotionRecurringTasks(args) {
+        const motionService = this.motionService;
+        const workspaceResolver = this.workspaceResolver;
+        if (!motionService || !workspaceResolver) {
+            return (0, utils_1.formatMcpError)(new Error("Services not available"));
+        }
+        const { operation, recurringTaskId, workspaceId, name, description, projectId, assigneeId, frequency, deadlineType, duration, startingOn, idealTime, schedule, priority } = args;
+        try {
+            switch (operation) {
+                case 'list':
+                    if (!workspaceId) {
+                        return (0, utils_1.formatMcpError)(new Error('Workspace ID is required for list operation'));
+                    }
+                    const recurringTasks = await motionService.getRecurringTasks(workspaceId);
+                    return (0, utils_1.formatRecurringTaskList)(recurringTasks);
+                case 'create':
+                    if (!name) {
+                        return (0, utils_1.formatMcpError)(new Error('Name is required for create operation'));
+                    }
+                    if (!workspaceId) {
+                        return (0, utils_1.formatMcpError)(new Error('Workspace ID is required for create operation'));
+                    }
+                    if (!assigneeId) {
+                        return (0, utils_1.formatMcpError)(new Error('Assignee ID is required for create operation'));
+                    }
+                    if (!frequency) {
+                        return (0, utils_1.formatMcpError)(new Error('Frequency is required for create operation'));
+                    }
+                    // Validate frequency
+                    if (!frequency.type || !['daily', 'weekly', 'monthly', 'yearly'].includes(frequency.type)) {
+                        return (0, utils_1.formatMcpError)(new Error('Frequency type must be one of: daily, weekly, monthly, yearly'));
+                    }
+                    // Validate frequency-specific fields
+                    if (frequency.interval && (!Number.isInteger(frequency.interval) || frequency.interval < 1)) {
+                        return (0, utils_1.formatMcpError)(new Error('Frequency interval must be a positive integer'));
+                    }
+                    if (frequency.daysOfWeek && !frequency.daysOfWeek.every(day => Number.isInteger(day) && day >= 0 && day <= 6)) {
+                        return (0, utils_1.formatMcpError)(new Error('daysOfWeek must contain integers between 0-6 (Sunday-Saturday)'));
+                    }
+                    if (frequency.dayOfMonth && (!Number.isInteger(frequency.dayOfMonth) || frequency.dayOfMonth < 1 || frequency.dayOfMonth > 31)) {
+                        return (0, utils_1.formatMcpError)(new Error('dayOfMonth must be an integer between 1-31'));
+                    }
+                    if (frequency.endDate) {
+                        const endDate = new Date(frequency.endDate);
+                        if (isNaN(endDate.getTime())) {
+                            return (0, utils_1.formatMcpError)(new Error('frequency.endDate must be a valid ISO 8601 date format'));
+                        }
+                        if (endDate <= new Date()) {
+                            return (0, utils_1.formatMcpError)(new Error('frequency.endDate must be in the future'));
+                        }
+                    }
+                    // Validate optional fields
+                    if (priority && !['ASAP', 'HIGH', 'MEDIUM', 'LOW'].includes(priority)) {
+                        return (0, utils_1.formatMcpError)(new Error('Priority must be one of: ASAP, HIGH, MEDIUM, LOW'));
+                    }
+                    if (deadlineType && !['HARD', 'SOFT'].includes(deadlineType)) {
+                        return (0, utils_1.formatMcpError)(new Error('Deadline type must be one of: HARD, SOFT'));
+                    }
+                    if (duration !== undefined) {
+                        if (typeof duration === 'number') {
+                            if (!Number.isInteger(duration) || duration <= 0) {
+                                return (0, utils_1.formatMcpError)(new Error('Duration must be a positive integer'));
+                            }
+                        }
+                        else if (typeof duration === 'string' && duration !== 'REMINDER') {
+                            return (0, utils_1.formatMcpError)(new Error('Duration string must be "REMINDER"'));
+                        }
+                    }
+                    if (startingOn) {
+                        const startDate = new Date(startingOn);
+                        if (isNaN(startDate.getTime())) {
+                            return (0, utils_1.formatMcpError)(new Error('startingOn must be a valid ISO 8601 date format'));
+                        }
+                    }
+                    if (idealTime && !/^\d{2}:\d{2}$/.test(idealTime)) {
+                        return (0, utils_1.formatMcpError)(new Error('idealTime must be in HH:mm format'));
+                    }
+                    const workspace = await workspaceResolver.resolveWorkspace({ workspaceId });
+                    const taskData = {
+                        name,
+                        workspaceId: workspace.id,
+                        assigneeId,
+                        frequency,
+                        ...(description && { description }),
+                        ...(projectId && { projectId }),
+                        ...(deadlineType && { deadlineType }),
+                        ...(duration && { duration }),
+                        ...(startingOn && { startingOn }),
+                        ...(idealTime && { idealTime }),
+                        ...(schedule && { schedule }),
+                        ...(priority && { priority })
+                    };
+                    const newTask = await motionService.createRecurringTask(taskData);
+                    return (0, utils_1.formatRecurringTaskDetail)(newTask);
+                case 'delete':
+                    if (!recurringTaskId) {
+                        return (0, utils_1.formatMcpError)(new Error('Recurring task ID is required for delete operation'));
+                    }
+                    await motionService.deleteRecurringTask(recurringTaskId);
+                    return (0, utils_1.formatMcpSuccess)(`Recurring task ${recurringTaskId} deleted successfully`);
+                default:
+                    return (0, utils_1.formatMcpError)(new Error(`Unknown operation: ${operation}`));
+            }
+        }
+        catch (error) {
+            return (0, utils_1.formatMcpError)(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    async handleMotionSchedules(args) {
+        const motionService = this.motionService;
+        if (!motionService) {
+            return (0, utils_1.formatMcpError)(new Error("Motion service not available"));
+        }
+        const { userId, startDate, endDate } = args;
+        // Validate date formats if provided using Date constructor
+        const isValidDate = (dateStr) => {
+            if (!dateStr)
+                return true; // Optional fields are valid when not provided
+            const date = new Date(dateStr);
+            return !isNaN(date.getTime());
+        };
+        if (!isValidDate(startDate)) {
+            return (0, utils_1.formatMcpError)(new Error('startDate must be a valid date string (e.g., "2024-01-15" or "2024-01-15T10:30:00Z")'));
+        }
+        if (!isValidDate(endDate)) {
+            return (0, utils_1.formatMcpError)(new Error('endDate must be a valid date string (e.g., "2024-01-15" or "2024-01-15T10:30:00Z")'));
+        }
+        // Validate date range logic if both dates are provided
+        if (startDate && endDate) {
+            const start = new Date(startDate);
+            const end = new Date(endDate);
+            if (start > end) {
+                return (0, utils_1.formatMcpError)(new Error('startDate must be before or equal to endDate'));
+            }
+        }
+        try {
+            const schedules = await motionService.getSchedules(userId, startDate, endDate);
+            return (0, utils_1.formatScheduleList)(schedules);
+        }
+        catch (error) {
+            return (0, utils_1.formatMcpError)(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    async handleMotionStatuses(args) {
+        const motionService = this.motionService;
+        if (!motionService) {
+            return (0, utils_1.formatMcpError)(new Error("Motion service not available"));
+        }
+        const { workspaceId } = args;
+        try {
+            const statuses = await motionService.getStatuses(workspaceId);
+            return (0, utils_1.formatStatusList)(statuses);
+        }
+        catch (error) {
+            return (0, utils_1.formatMcpError)(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    // New consolidated handlers
+    async handleMotionWorkspaces(args) {
+        const motionService = this.motionService;
+        if (!motionService) {
+            return (0, utils_1.formatMcpError)(new Error("Motion service not available"));
+        }
+        const { operation, workspaceId } = args;
+        try {
+            switch (operation) {
+                case 'list':
+                    const workspaces = await motionService.getWorkspaces();
+                    return (0, utils_1.formatWorkspaceList)(workspaces);
+                case 'get':
+                    if (!workspaceId) {
+                        return (0, utils_1.formatMcpError)(new Error("Workspace ID is required for get operation"));
+                    }
+                    const workspaces_all = await motionService.getWorkspaces();
+                    const workspace = workspaces_all.find(w => w.id === workspaceId);
+                    if (!workspace) {
+                        return (0, utils_1.formatMcpError)(new Error(`Workspace not found: ${workspaceId}`));
+                    }
+                    return (0, utils_1.formatDetailResponse)(workspace, `Workspace details for "${workspace.name}"`);
+                case 'set_default':
+                    if (!workspaceId) {
+                        return (0, utils_1.formatMcpError)(new Error("Workspace ID is required for set_default operation"));
+                    }
+                    // For now, we'll just return a success message since Motion API doesn't have a set default endpoint
+                    return (0, utils_1.formatMcpSuccess)(`Default workspace would be set to: ${workspaceId} (Note: This is a placeholder - actual implementation depends on Motion API support)`);
+                default:
+                    return (0, utils_1.formatMcpError)(new Error(`Unknown operation: ${operation}`));
+            }
+        }
+        catch (error) {
+            return (0, utils_1.formatMcpError)(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    async handleMotionSearch(args) {
+        const motionService = this.motionService;
+        const workspaceResolver = this.workspaceResolver;
+        if (!motionService || !workspaceResolver) {
+            return (0, utils_1.formatMcpError)(new Error("Services not available"));
+        }
+        const { operation } = args;
+        try {
+            switch (operation) {
+                case 'content':
+                    if (!args.query) {
+                        return (0, utils_1.formatMcpError)(new Error("Query is required for content search"));
+                    }
+                    return await this.handleSearchContent({
+                        query: args.query,
+                        entityTypes: args.searchScope === 'tasks' ? ['tasks'] :
+                            args.searchScope === 'projects' ? ['projects'] :
+                                ['tasks', 'projects'],
+                        workspaceId: args.workspaceId,
+                        workspaceName: args.workspaceName
+                    });
+                case 'context':
+                    if (!args.entityType || !args.entityId) {
+                        return (0, utils_1.formatMcpError)(new Error("EntityType and entityId are required for context operation"));
+                    }
+                    return await this.handleGetContext({
+                        entityType: args.entityType,
+                        entityId: args.entityId,
+                        includeRelated: args.includeRelated
+                    });
+                case 'smart':
+                    // Smart search combines content search with contextual information
+                    const { query, entityType, entityId, includeRelated = false } = args;
+                    if (!query) {
+                        return (0, utils_1.formatMcpError)(new Error("Query is required for smart search"));
+                    }
+                    let contextText = `Smart search results for "${query}":\n\n`;
+                    // Perform content search
+                    const searchResults = await this.handleSearchContent({
+                        query,
+                        entityTypes: args.searchScope === 'tasks' ? ['tasks'] :
+                            args.searchScope === 'projects' ? ['projects'] :
+                                ['tasks', 'projects'],
+                        workspaceId: args.workspaceId,
+                        workspaceName: args.workspaceName
+                    });
+                    contextText += "Content Results:\n";
+                    // Extract text from search results
+                    if ('content' in searchResults && searchResults.content && Array.isArray(searchResults.content)) {
+                        const textContent = searchResults.content.find(item => item.type === 'text');
+                        if (textContent && 'text' in textContent) {
+                            contextText += textContent.text + "\n\n";
+                        }
+                    }
+                    // Add contextual information if entity is specified
+                    if (entityType && entityId) {
+                        contextText += `Context for ${entityType} ${entityId}:\n`;
+                        if (entityType === 'project') {
+                            contextText += `Project ID: ${entityId}\n`;
+                            if (includeRelated) {
+                                contextText += `Related tasks would be listed here (when available)\n`;
+                            }
+                        }
+                        else if (entityType === 'task') {
+                            contextText += `Task ID: ${entityId}\n`;
+                            if (includeRelated) {
+                                contextText += `Related project and subtasks would be listed here (when available)\n`;
+                            }
+                        }
+                    }
+                    return (0, utils_1.formatMcpSuccess)(contextText);
+                default:
+                    return (0, utils_1.formatMcpError)(new Error(`Unknown operation: ${operation}`));
+            }
+        }
+        catch (error) {
+            return (0, utils_1.formatMcpError)(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    async run() {
+        await this.initialize();
+        const transport = new stdio_js_1.StdioServerTransport();
+        await this.server.connect(transport);
+        (0, utils_1.mcpLog)(utils_1.LOG_LEVELS.INFO, "Motion MCP Server running on stdio");
+    }
+}
+// Main execution
+if (require.main === module) {
+    const server = new MotionMCPServer();
+    server.run().catch((error) => {
+        console.error("Failed to run server:", error);
+        process.exit(1);
+    });
+}
+exports.default = MotionMCPServer;
+//# sourceMappingURL=mcp-server-old.js.map