kaneo-mcp 0.0.0

package/dist/index.js

@@ -0,0 +1,1625 @@
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/client.ts
+var KaneoClient = class {
+  baseUrl;
+  token;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+    if (!this.baseUrl.endsWith("/api")) {
+      this.baseUrl = `${this.baseUrl}/api`;
+    }
+    this.token = config.token;
+  }
+  async request(path, options = {}) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.token}`,
+      ...options.headers
+    };
+    const response = await fetch(url, {
+      ...options,
+      headers
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Kaneo API error: ${response.status} ${error}`);
+    }
+    return response.json();
+  }
+  // Health
+  async health() {
+    return this.request("/health");
+  }
+  // Config
+  async getConfig() {
+    return this.request("/config");
+  }
+  // Projects
+  async listProjects(workspaceId) {
+    return this.request(
+      `/project?workspaceId=${encodeURIComponent(workspaceId)}`
+    );
+  }
+  async createProject(data) {
+    return this.request("/project", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async getProject(id) {
+    return this.request(`/project/${id}`);
+  }
+  async updateProject(id, data) {
+    return this.request(`/project/${id}`, {
+      method: "PUT",
+      body: JSON.stringify(data)
+    });
+  }
+  async deleteProject(id) {
+    return this.request(`/project/${id}`, {
+      method: "DELETE"
+    });
+  }
+  async archiveProject(id) {
+    return this.request(`/project/${id}/archive`, {
+      method: "PUT"
+    });
+  }
+  async unarchiveProject(id) {
+    return this.request(`/project/${id}/unarchive`, {
+      method: "PUT"
+    });
+  }
+  // Tasks
+  async listTasks(projectId, params) {
+    const query = new URLSearchParams();
+    if (params?.status) query.set("status", params.status);
+    if (params?.priority) query.set("priority", params.priority);
+    if (params?.assigneeId) query.set("assigneeId", params.assigneeId);
+    const queryString = query.toString();
+    return this.request(
+      `/task/tasks/${projectId}${queryString ? `?${queryString}` : ""}`
+    );
+  }
+  async createTask(projectId, data) {
+    return this.request(`/task/${projectId}`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async getTask(id) {
+    return this.request(`/task/${id}`);
+  }
+  async updateTask(id, data) {
+    return this.request(`/task/${id}`, {
+      method: "PUT",
+      body: JSON.stringify(data)
+    });
+  }
+  async deleteTask(id) {
+    return this.request(`/task/${id}`, {
+      method: "DELETE"
+    });
+  }
+  async updateTaskStatus(id, status) {
+    return this.request(`/task/status/${id}`, {
+      method: "PUT",
+      body: JSON.stringify({ status })
+    });
+  }
+  async updateTaskPriority(id, priority) {
+    return this.request(`/task/priority/${id}`, {
+      method: "PUT",
+      body: JSON.stringify({ priority })
+    });
+  }
+  async updateTaskAssignee(id, userId) {
+    return this.request(`/task/assignee/${id}`, {
+      method: "PUT",
+      body: JSON.stringify({ userId })
+    });
+  }
+  async updateTaskDueDate(id, dueDate) {
+    return this.request(`/task/due-date/${id}`, {
+      method: "PUT",
+      body: JSON.stringify({ dueDate })
+    });
+  }
+  async updateTaskTitle(id, title) {
+    return this.request(`/task/title/${id}`, {
+      method: "PUT",
+      body: JSON.stringify({ title })
+    });
+  }
+  async updateTaskDescription(id, description) {
+    return this.request(`/task/description/${id}`, {
+      method: "PUT",
+      body: JSON.stringify({ description })
+    });
+  }
+  async moveTask(id, projectId) {
+    return this.request(`/task/move/${id}`, {
+      method: "PUT",
+      body: JSON.stringify({ projectId })
+    });
+  }
+  // Columns
+  async listColumns(projectId) {
+    return this.request(`/column/${projectId}`);
+  }
+  async createColumn(projectId, data) {
+    return this.request(`/column/${projectId}`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async updateColumn(id, data) {
+    return this.request(`/column/${id}`, {
+      method: "PUT",
+      body: JSON.stringify(data)
+    });
+  }
+  async deleteColumn(id) {
+    return this.request(`/column/${id}`, {
+      method: "DELETE"
+    });
+  }
+  async reorderColumns(projectId, columnIds) {
+    return this.request(
+      `/column/reorder/${projectId}`,
+      {
+        method: "PUT",
+        body: JSON.stringify({ columnIds })
+      }
+    );
+  }
+  // Comments
+  async listComments(taskId) {
+    return this.request(`/comment/${taskId}`);
+  }
+  async createComment(taskId, content) {
+    return this.request(`/comment/${taskId}`, {
+      method: "POST",
+      body: JSON.stringify({ content })
+    });
+  }
+  async updateComment(id, content) {
+    return this.request(`/comment/${id}`, {
+      method: "PUT",
+      body: JSON.stringify({ content })
+    });
+  }
+  async deleteComment(id) {
+    return this.request(`/comment/${id}`, {
+      method: "DELETE"
+    });
+  }
+  // Labels
+  async listLabelsForTask(taskId) {
+    return this.request(`/label/task/${taskId}`);
+  }
+  async listWorkspaceLabels(workspaceId) {
+    return this.request(
+      `/label/workspace/${workspaceId}`
+    );
+  }
+  async createLabel(data) {
+    return this.request("/label", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async getLabel(id) {
+    return this.request(`/label/${id}`);
+  }
+  async updateLabel(id, data) {
+    return this.request(`/label/${id}`, {
+      method: "PUT",
+      body: JSON.stringify(data)
+    });
+  }
+  async deleteLabel(id) {
+    return this.request(`/label/${id}`, {
+      method: "DELETE"
+    });
+  }
+  async attachLabelToTask(labelId, taskId) {
+    return this.request(`/label/${labelId}/task`, {
+      method: "PUT",
+      body: JSON.stringify({ taskId })
+    });
+  }
+  async detachLabelFromTask(labelId, taskId) {
+    return this.request(`/label/${labelId}/task`, {
+      method: "DELETE",
+      body: JSON.stringify({ taskId })
+    });
+  }
+  // Time Entries
+  async listTimeEntries(taskId) {
+    return this.request(
+      `/time-entry/task/${taskId}`
+    );
+  }
+  async getTimeEntry(id) {
+    return this.request(`/time-entry/${id}`);
+  }
+  async createTimeEntry(data) {
+    return this.request("/time-entry", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async updateTimeEntry(id, data) {
+    return this.request(`/time-entry/${id}`, {
+      method: "PUT",
+      body: JSON.stringify(data)
+    });
+  }
+  // Task Relations
+  async listTaskRelations(taskId) {
+    return this.request(`/task-relation/${taskId}`);
+  }
+  async createTaskRelation(data) {
+    return this.request("/task-relation", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  async deleteTaskRelation(id) {
+    return this.request(`/task-relation/${id}`, {
+      method: "DELETE"
+    });
+  }
+  // Notifications
+  async listNotifications() {
+    return this.request("/notification");
+  }
+  async markNotificationRead(id) {
+    return this.request(`/notification/${id}/read`, {
+      method: "PATCH"
+    });
+  }
+  async markAllNotificationsRead() {
+    return this.request("/notification/read-all", {
+      method: "PATCH"
+    });
+  }
+  async clearAllNotifications() {
+    return this.request("/notification/clear-all", {
+      method: "DELETE"
+    });
+  }
+  // Workspace
+  async listWorkspaceMembers(workspaceId) {
+    return this.request(
+      `/workspace/${workspaceId}/members`
+    );
+  }
+  // Search
+  async search(query, type) {
+    const params = new URLSearchParams({ q: query });
+    if (type) params.set("type", type);
+    return this.request(`/search?${params.toString()}`);
+  }
+  // Activity
+  async listActivities(taskId) {
+    return this.request(`/activity/${taskId}`);
+  }
+  // Invitations
+  async listPendingInvitations() {
+    return this.request("/invitation/pending");
+  }
+  async getInvitation(id) {
+    return this.request(`/invitation/${id}`);
+  }
+};
+
+// src/index.ts
+var KaneoMCPServer = class {
+  server;
+  client;
+  constructor(config) {
+    this.client = new KaneoClient(config);
+    this.server = new Server(
+      {
+        name: "kaneo-mcp-server",
+        version: "1.0.0"
+      },
+      {
+        capabilities: {
+          tools: {}
+        }
+      }
+    );
+    this.setupToolHandlers();
+  }
+  setupToolHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      return { tools: this.getTools() };
+    });
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+      try {
+        switch (name) {
+          // Health & Config
+          case "health":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(await this.client.health())
+                }
+              ]
+            };
+          case "get_config":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(await this.client.getConfig())
+                }
+              ]
+            };
+          // Projects
+          case "list_projects":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.listProjects(args.workspaceId)
+                  )
+                }
+              ]
+            };
+          case "create_project":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(await this.client.createProject(args))
+                }
+              ]
+            };
+          case "get_project":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(await this.client.getProject(args.id))
+                }
+              ]
+            };
+          case "update_project":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.updateProject(args.id, args)
+                  )
+                }
+              ]
+            };
+          case "delete_project":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.deleteProject(args.id)
+                  )
+                }
+              ]
+            };
+          case "archive_project":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.archiveProject(args.id)
+                  )
+                }
+              ]
+            };
+          case "unarchive_project":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.unarchiveProject(args.id)
+                  )
+                }
+              ]
+            };
+          // Tasks
+          case "list_tasks":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.listTasks(args.projectId, args)
+                  )
+                }
+              ]
+            };
+          case "create_task":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.createTask(args.projectId, args)
+                  )
+                }
+              ]
+            };
+          case "get_task":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(await this.client.getTask(args.id))
+                }
+              ]
+            };
+          case "update_task":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.updateTask(args.id, args)
+                  )
+                }
+              ]
+            };
+          case "delete_task":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(await this.client.deleteTask(args.id))
+                }
+              ]
+            };
+          case "update_task_status":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.updateTaskStatus(args.id, args.status)
+                  )
+                }
+              ]
+            };
+          case "update_task_priority":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.updateTaskPriority(
+                      args.id,
+                      args.priority
+                    )
+                  )
+                }
+              ]
+            };
+          case "update_task_assignee":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.updateTaskAssignee(args.id, args.userId)
+                  )
+                }
+              ]
+            };
+          case "update_task_due_date":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.updateTaskDueDate(args.id, args.dueDate)
+                  )
+                }
+              ]
+            };
+          case "update_task_title":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.updateTaskTitle(args.id, args.title)
+                  )
+                }
+              ]
+            };
+          case "update_task_description":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.updateTaskDescription(
+                      args.id,
+                      args.description
+                    )
+                  )
+                }
+              ]
+            };
+          case "move_task":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.moveTask(args.id, args.projectId)
+                  )
+                }
+              ]
+            };
+          // Columns
+          case "list_columns":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.listColumns(args.projectId)
+                  )
+                }
+              ]
+            };
+          case "create_column":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.createColumn(args.projectId, args)
+                  )
+                }
+              ]
+            };
+          case "update_column":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.updateColumn(args.id, args)
+                  )
+                }
+              ]
+            };
+          case "delete_column":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(await this.client.deleteColumn(args.id))
+                }
+              ]
+            };
+          case "reorder_columns":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.reorderColumns(
+                      args.projectId,
+                      args.columnIds
+                    )
+                  )
+                }
+              ]
+            };
+          // Comments
+          case "list_comments":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.listComments(args.taskId)
+                  )
+                }
+              ]
+            };
+          case "create_comment":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.createComment(args.taskId, args.content)
+                  )
+                }
+              ]
+            };
+          case "update_comment":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.updateComment(args.id, args.content)
+                  )
+                }
+              ]
+            };
+          case "delete_comment":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.deleteComment(args.id)
+                  )
+                }
+              ]
+            };
+          // Labels
+          case "list_labels_for_task":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.listLabelsForTask(args.taskId)
+                  )
+                }
+              ]
+            };
+          case "list_workspace_labels":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.listWorkspaceLabels(args.workspaceId)
+                  )
+                }
+              ]
+            };
+          case "create_label":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(await this.client.createLabel(args))
+                }
+              ]
+            };
+          case "get_label":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(await this.client.getLabel(args.id))
+                }
+              ]
+            };
+          case "update_label":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.updateLabel(args.id, args)
+                  )
+                }
+              ]
+            };
+          case "delete_label":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(await this.client.deleteLabel(args.id))
+                }
+              ]
+            };
+          case "attach_label_to_task":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.attachLabelToTask(
+                      args.labelId,
+                      args.taskId
+                    )
+                  )
+                }
+              ]
+            };
+          case "detach_label_from_task":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.detachLabelFromTask(
+                      args.labelId,
+                      args.taskId
+                    )
+                  )
+                }
+              ]
+            };
+          // Time Entries
+          case "list_time_entries":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.listTimeEntries(args.taskId)
+                  )
+                }
+              ]
+            };
+          case "get_time_entry":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(await this.client.getTimeEntry(args.id))
+                }
+              ]
+            };
+          case "create_time_entry":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(await this.client.createTimeEntry(args))
+                }
+              ]
+            };
+          case "update_time_entry":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.updateTimeEntry(args.id, args)
+                  )
+                }
+              ]
+            };
+          // Task Relations
+          case "list_task_relations":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.listTaskRelations(args.taskId)
+                  )
+                }
+              ]
+            };
+          case "create_task_relation":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.createTaskRelation(args)
+                  )
+                }
+              ]
+            };
+          case "delete_task_relation":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.deleteTaskRelation(args.id)
+                  )
+                }
+              ]
+            };
+          // Notifications
+          case "list_notifications":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(await this.client.listNotifications())
+                }
+              ]
+            };
+          case "mark_notification_read":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.markNotificationRead(args.id)
+                  )
+                }
+              ]
+            };
+          case "mark_all_notifications_read":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.markAllNotificationsRead()
+                  )
+                }
+              ]
+            };
+          case "clear_all_notifications":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.clearAllNotifications()
+                  )
+                }
+              ]
+            };
+          // Workspace
+          case "list_workspace_members":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.listWorkspaceMembers(args.workspaceId)
+                  )
+                }
+              ]
+            };
+          // Search
+          case "search":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.search(args.q, args.type)
+                  )
+                }
+              ]
+            };
+          // Activity
+          case "list_activities":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.listActivities(args.taskId)
+                  )
+                }
+              ]
+            };
+          // Invitations
+          case "list_pending_invitations":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.listPendingInvitations()
+                  )
+                }
+              ]
+            };
+          case "get_invitation":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(
+                    await this.client.getInvitation(args.id)
+                  )
+                }
+              ]
+            };
+          default:
+            return {
+              content: [{ type: "text", text: `Unknown tool: ${name}` }],
+              isError: true
+            };
+        }
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    });
+  }
+  getTools() {
+    return [
+      // Health & Config
+      {
+        name: "health",
+        description: "Check if the Kaneo API server is healthy",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "get_config",
+        description: "Get public configuration from the Kaneo API server",
+        inputSchema: { type: "object", properties: {} }
+      },
+      // Projects
+      {
+        name: "list_projects",
+        description: "List all projects in a workspace",
+        inputSchema: {
+          type: "object",
+          properties: {
+            workspaceId: { type: "string", description: "The workspace ID" }
+          },
+          required: ["workspaceId"]
+        }
+      },
+      {
+        name: "create_project",
+        description: "Create a new project in a workspace",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: { type: "string", description: "Project name" },
+            description: { type: "string", description: "Project description" },
+            workspaceId: { type: "string", description: "Workspace ID" }
+          },
+          required: ["name", "workspaceId"]
+        }
+      },
+      {
+        name: "get_project",
+        description: "Get a project by ID",
+        inputSchema: {
+          type: "object",
+          properties: { id: { type: "string", description: "Project ID" } },
+          required: ["id"]
+        }
+      },
+      {
+        name: "update_project",
+        description: "Update a project",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Project ID" },
+            name: { type: "string", description: "Project name" },
+            description: { type: "string", description: "Project description" }
+          },
+          required: ["id"]
+        }
+      },
+      {
+        name: "delete_project",
+        description: "Delete a project",
+        inputSchema: {
+          type: "object",
+          properties: { id: { type: "string", description: "Project ID" } },
+          required: ["id"]
+        }
+      },
+      {
+        name: "archive_project",
+        description: "Archive a project",
+        inputSchema: {
+          type: "object",
+          properties: { id: { type: "string", description: "Project ID" } },
+          required: ["id"]
+        }
+      },
+      {
+        name: "unarchive_project",
+        description: "Unarchive a project",
+        inputSchema: {
+          type: "object",
+          properties: { id: { type: "string", description: "Project ID" } },
+          required: ["id"]
+        }
+      },
+      // Tasks
+      {
+        name: "list_tasks",
+        description: "List tasks in a project with optional filters",
+        inputSchema: {
+          type: "object",
+          properties: {
+            projectId: { type: "string", description: "Project ID" },
+            status: {
+              type: "string",
+              description: "Filter by status (todo, in_progress, done, canceled)"
+            },
+            priority: {
+              type: "string",
+              description: "Filter by priority (low, medium, high, urgent)"
+            },
+            assigneeId: {
+              type: "string",
+              description: "Filter by assignee ID"
+            }
+          },
+          required: ["projectId"]
+        }
+      },
+      {
+        name: "create_task",
+        description: "Create a new task in a project",
+        inputSchema: {
+          type: "object",
+          properties: {
+            projectId: { type: "string", description: "Project ID" },
+            title: { type: "string", description: "Task title" },
+            description: { type: "string", description: "Task description" },
+            status: {
+              type: "string",
+              description: "Task status (todo, in_progress, done, canceled)"
+            },
+            priority: {
+              type: "string",
+              description: "Task priority (low, medium, high, urgent)"
+            },
+            assigneeId: { type: "string", description: "Assignee user ID" },
+            startDate: { type: "string", description: "Start date (ISO 8601)" },
+            dueDate: { type: "string", description: "Due date (ISO 8601)" }
+          },
+          required: ["projectId", "title"]
+        }
+      },
+      {
+        name: "get_task",
+        description: "Get a task by ID",
+        inputSchema: {
+          type: "object",
+          properties: { id: { type: "string", description: "Task ID" } },
+          required: ["id"]
+        }
+      },
+      {
+        name: "update_task",
+        description: "Update a task",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Task ID" },
+            title: { type: "string", description: "Task title" },
+            description: { type: "string", description: "Task description" },
+            status: { type: "string", description: "Task status" },
+            priority: { type: "string", description: "Task priority" },
+            assigneeId: { type: "string", description: "Assignee user ID" },
+            startDate: { type: "string", description: "Start date" },
+            dueDate: { type: "string", description: "Due date" }
+          },
+          required: ["id"]
+        }
+      },
+      {
+        name: "delete_task",
+        description: "Delete a task",
+        inputSchema: {
+          type: "object",
+          properties: { id: { type: "string", description: "Task ID" } },
+          required: ["id"]
+        }
+      },
+      {
+        name: "update_task_status",
+        description: "Update only the status of a task",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Task ID" },
+            status: {
+              type: "string",
+              description: "New status (todo, in_progress, done, canceled)"
+            }
+          },
+          required: ["id", "status"]
+        }
+      },
+      {
+        name: "update_task_priority",
+        description: "Update only the priority of a task",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Task ID" },
+            priority: {
+              type: "string",
+              description: "New priority (low, medium, high, urgent)"
+            }
+          },
+          required: ["id", "priority"]
+        }
+      },
+      {
+        name: "update_task_assignee",
+        description: "Update the assignee of a task",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Task ID" },
+            userId: {
+              type: "string",
+              description: "User ID to assign (null to unassign)"
+            }
+          },
+          required: ["id"]
+        }
+      },
+      {
+        name: "update_task_due_date",
+        description: "Update the due date of a task",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Task ID" },
+            dueDate: {
+              type: "string",
+              description: "Due date ISO string (null to remove)"
+            }
+          },
+          required: ["id"]
+        }
+      },
+      {
+        name: "update_task_title",
+        description: "Update only the title of a task",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Task ID" },
+            title: { type: "string", description: "New title" }
+          },
+          required: ["id", "title"]
+        }
+      },
+      {
+        name: "update_task_description",
+        description: "Update only the description of a task",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Task ID" },
+            description: { type: "string", description: "New description" }
+          },
+          required: ["id", "description"]
+        }
+      },
+      {
+        name: "move_task",
+        description: "Move a task to another project",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Task ID" },
+            projectId: { type: "string", description: "Target project ID" }
+          },
+          required: ["id", "projectId"]
+        }
+      },
+      // Columns
+      {
+        name: "list_columns",
+        description: "List all columns in a project",
+        inputSchema: {
+          type: "object",
+          properties: {
+            projectId: { type: "string", description: "Project ID" }
+          },
+          required: ["projectId"]
+        }
+      },
+      {
+        name: "create_column",
+        description: "Create a new column in a project",
+        inputSchema: {
+          type: "object",
+          properties: {
+            projectId: { type: "string", description: "Project ID" },
+            name: { type: "string", description: "Column name" },
+            order: { type: "number", description: "Column order" }
+          },
+          required: ["projectId", "name"]
+        }
+      },
+      {
+        name: "update_column",
+        description: "Update a column",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Column ID" },
+            name: { type: "string", description: "Column name" },
+            order: { type: "number", description: "Column order" }
+          },
+          required: ["id"]
+        }
+      },
+      {
+        name: "delete_column",
+        description: "Delete a column",
+        inputSchema: {
+          type: "object",
+          properties: { id: { type: "string", description: "Column ID" } },
+          required: ["id"]
+        }
+      },
+      {
+        name: "reorder_columns",
+        description: "Reorder columns in a project",
+        inputSchema: {
+          type: "object",
+          properties: {
+            projectId: { type: "string", description: "Project ID" },
+            columnIds: {
+              type: "array",
+              items: { type: "string" },
+              description: "Array of column IDs in new order"
+            }
+          },
+          required: ["projectId", "columnIds"]
+        }
+      },
+      // Comments
+      {
+        name: "list_comments",
+        description: "List all comments on a task",
+        inputSchema: {
+          type: "object",
+          properties: { taskId: { type: "string", description: "Task ID" } },
+          required: ["taskId"]
+        }
+      },
+      {
+        name: "create_comment",
+        description: "Add a comment to a task",
+        inputSchema: {
+          type: "object",
+          properties: {
+            taskId: { type: "string", description: "Task ID" },
+            content: { type: "string", description: "Comment content" }
+          },
+          required: ["taskId", "content"]
+        }
+      },
+      {
+        name: "update_comment",
+        description: "Update a comment (author only)",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Comment ID" },
+            content: { type: "string", description: "New content" }
+          },
+          required: ["id", "content"]
+        }
+      },
+      {
+        name: "delete_comment",
+        description: "Delete a comment (author only)",
+        inputSchema: {
+          type: "object",
+          properties: { id: { type: "string", description: "Comment ID" } },
+          required: ["id"]
+        }
+      },
+      // Labels
+      {
+        name: "list_labels_for_task",
+        description: "List all labels attached to a task",
+        inputSchema: {
+          type: "object",
+          properties: { taskId: { type: "string", description: "Task ID" } },
+          required: ["taskId"]
+        }
+      },
+      {
+        name: "list_workspace_labels",
+        description: "List all labels in a workspace",
+        inputSchema: {
+          type: "object",
+          properties: {
+            workspaceId: { type: "string", description: "Workspace ID" }
+          },
+          required: ["workspaceId"]
+        }
+      },
+      {
+        name: "create_label",
+        description: "Create a new label in a workspace",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: { type: "string", description: "Label name" },
+            color: { type: "string", description: "Label color (hex code)" },
+            workspaceId: { type: "string", description: "Workspace ID" }
+          },
+          required: ["name", "color", "workspaceId"]
+        }
+      },
+      {
+        name: "get_label",
+        description: "Get a label by ID",
+        inputSchema: {
+          type: "object",
+          properties: { id: { type: "string", description: "Label ID" } },
+          required: ["id"]
+        }
+      },
+      {
+        name: "update_label",
+        description: "Update a label",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Label ID" },
+            name: { type: "string", description: "Label name" },
+            color: { type: "string", description: "Label color" }
+          },
+          required: ["id"]
+        }
+      },
+      {
+        name: "delete_label",
+        description: "Delete a label",
+        inputSchema: {
+          type: "object",
+          properties: { id: { type: "string", description: "Label ID" } },
+          required: ["id"]
+        }
+      },
+      {
+        name: "attach_label_to_task",
+        description: "Attach a label to a task",
+        inputSchema: {
+          type: "object",
+          properties: {
+            labelId: { type: "string", description: "Label ID" },
+            taskId: { type: "string", description: "Task ID" }
+          },
+          required: ["labelId", "taskId"]
+        }
+      },
+      {
+        name: "detach_label_from_task",
+        description: "Detach a label from a task",
+        inputSchema: {
+          type: "object",
+          properties: {
+            labelId: { type: "string", description: "Label ID" },
+            taskId: { type: "string", description: "Task ID" }
+          },
+          required: ["labelId", "taskId"]
+        }
+      },
+      // Time Entries
+      {
+        name: "list_time_entries",
+        description: "List time entries for a task",
+        inputSchema: {
+          type: "object",
+          properties: { taskId: { type: "string", description: "Task ID" } },
+          required: ["taskId"]
+        }
+      },
+      {
+        name: "get_time_entry",
+        description: "Get a time entry by ID",
+        inputSchema: {
+          type: "object",
+          properties: { id: { type: "string", description: "Time entry ID" } },
+          required: ["id"]
+        }
+      },
+      {
+        name: "create_time_entry",
+        description: "Create a time entry for a task",
+        inputSchema: {
+          type: "object",
+          properties: {
+            taskId: { type: "string", description: "Task ID" },
+            duration: { type: "number", description: "Duration in seconds" },
+            description: {
+              type: "string",
+              description: "Time entry description"
+            }
+          },
+          required: ["taskId", "duration"]
+        }
+      },
+      {
+        name: "update_time_entry",
+        description: "Update a time entry",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Time entry ID" },
+            duration: { type: "number", description: "Duration in seconds" },
+            description: {
+              type: "string",
+              description: "Time entry description"
+            }
+          },
+          required: ["id"]
+        }
+      },
+      // Task Relations
+      {
+        name: "list_task_relations",
+        description: "List all relations for a task",
+        inputSchema: {
+          type: "object",
+          properties: { taskId: { type: "string", description: "Task ID" } },
+          required: ["taskId"]
+        }
+      },
+      {
+        name: "create_task_relation",
+        description: "Create a relation between tasks",
+        inputSchema: {
+          type: "object",
+          properties: {
+            taskId: { type: "string", description: "Source task ID" },
+            relatedTaskId: { type: "string", description: "Related task ID" },
+            type: {
+              type: "string",
+              enum: ["subtask", "blocks", "related"],
+              description: "Relation type"
+            }
+          },
+          required: ["taskId", "relatedTaskId", "type"]
+        }
+      },
+      {
+        name: "delete_task_relation",
+        description: "Delete a task relation",
+        inputSchema: {
+          type: "object",
+          properties: { id: { type: "string", description: "Relation ID" } },
+          required: ["id"]
+        }
+      },
+      // Notifications
+      {
+        name: "list_notifications",
+        description: "List all notifications for the current user",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "mark_notification_read",
+        description: "Mark a notification as read",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Notification ID" }
+          },
+          required: ["id"]
+        }
+      },
+      {
+        name: "mark_all_notifications_read",
+        description: "Mark all notifications as read",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "clear_all_notifications",
+        description: "Clear all notifications",
+        inputSchema: { type: "object", properties: {} }
+      },
+      // Workspace
+      {
+        name: "list_workspace_members",
+        description: "List all members in a workspace",
+        inputSchema: {
+          type: "object",
+          properties: {
+            workspaceId: { type: "string", description: "Workspace ID" }
+          },
+          required: ["workspaceId"]
+        }
+      },
+      // Search
+      {
+        name: "search",
+        description: "Search across projects, tasks, comments, and activities",
+        inputSchema: {
+          type: "object",
+          properties: {
+            q: { type: "string", description: "Search query" },
+            type: {
+              type: "string",
+              enum: [
+                "all",
+                "tasks",
+                "projects",
+                "workspaces",
+                "comments",
+                "activities"
+              ],
+              description: "Search type"
+            }
+          },
+          required: ["q"]
+        }
+      },
+      // Activity
+      {
+        name: "list_activities",
+        description: "List all activities for a task",
+        inputSchema: {
+          type: "object",
+          properties: { taskId: { type: "string", description: "Task ID" } },
+          required: ["taskId"]
+        }
+      },
+      // Invitations
+      {
+        name: "list_pending_invitations",
+        description: "List pending invitations for the current user",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "get_invitation",
+        description: "Get an invitation by ID",
+        inputSchema: {
+          type: "object",
+          properties: { id: { type: "string", description: "Invitation ID" } },
+          required: ["id"]
+        }
+      }
+    ];
+  }
+  async start() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+  }
+};
+async function main() {
+  const baseUrl = process.env.KANEO_BASE_URL || "http://localhost:1337";
+  const token = process.env.KANEO_TOKEN;
+  if (!token) {
+    console.error("Error: KANEO_TOKEN environment variable is required");
+    process.exit(1);
+  }
+  const server = new KaneoMCPServer({ baseUrl, token });
+  await server.start();
+}
+main().catch(console.error);
+export {
+  KaneoMCPServer
+};