Teamwork MCP

Instructions

Implementation Reference

• src/tools/comments/createComment.ts:66-96 (handler)

  The handler function that executes the createComment tool logic. It processes the input parameters, constructs the comment data, calls the teamwork service to create the comment, and returns the result or error response.

  export async function handleCreateComment(input: any) {
    logger.info('Calling teamworkService.createComment()');
    logger.info(`Resource: ${input?.resource}, Resource ID: ${input?.resourceId}`);
    
    try {
      const resource = input.resource;
      const resourceId = input.resourceId;
      const commentData: any = {};
      
      // Set required fields
      commentData.body = input.body;
      
      // Set optional fields if provided
      if (input.notify !== undefined) commentData.notify = input.notify;
      if (input.isPrivate !== undefined) commentData['isprivate'] = input.isPrivate;
      if (input.pendingFileAttachments) commentData.pendingFileAttachments = input.pendingFileAttachments;
      if (input.contentType === 'html') commentData['content-type'] = 'html';
      if (input.authorId) commentData['author-id'] = input.authorId;
      
      const result = await teamworkService.createComment(resource, resourceId, commentData);
      
      return {
        content: [{
          type: "text",
          text: JSON.stringify(result, null, 2)
        }]
      };
    } catch (error: any) {
      return createErrorResponse(error, 'Creating comment');
    }
  } 

• src/tools/comments/createComment.ts:11-63 (schema)

  The tool definition including name, description, input schema with properties and requirements, and annotations for the createComment tool.

  export const createCommentDefinition = {
    name: "createComment",
    description: "Creates a new comment for a specific resource (tasks, milestones, notebooks, links, fileversions) in Teamwork",
    inputSchema: {
      type: "object",
      properties: {
        resource: {
          type: "string",
          description: "The resource type (tasks, milestones, notebooks, links, fileversions)",
          enum: ["tasks", "milestones", "notebooks", "links", "fileversions"]
        },
        resourceId: {
          type: "string",
          description: "The ID of the resource to add a comment to"
        },
        body: {
          type: "string",
          description: "The content of the comment"
        },
        notify: {
          type: "string",
          description: "Who to notify ('all' to notify all project users, 'true' to notify followers, specific user IDs, or empty for no notification)",
          default: ""
        },
        isPrivate: {
          type: "boolean",
          description: "Whether the comment should be private",
          default: false
        },
        pendingFileAttachments: {
          type: "string",
          description: "Comma-separated list of pending file references to attach to the comment"
        },
        contentType: {
          type: "string",
          description: "Content type of the comment (html or plain text)",
          enum: ["html", "plaintext"],
          default: "plaintext"
        },
        authorId: {
          type: "string",
          description: "ID of the user to post as (only for admins)"
        }
      },
      required: ["resource", "resourceId", "body"]
    },
    annotations: {
      title: "Create Comment",
      readOnlyHint: false,
      destructiveHint: false,
      openWorldHint: false
    }
  };

• src/tools/index.ts:82-82 (registration)

  The registration entry in the toolPairs array that associates the createComment tool definition with its handler function.

  { definition: createComment, handler: handleCreateComment },

• src/services/comments/createComment.ts:11-35 (helper)

  The service function called by the tool handler to perform the actual API call to create a comment on the specified resource in Teamwork.

  export const createComment = async (resource: string, resourceId: string, commentData: any) => {
    try {
      // Validate resource type
      const validResources = ['tasks', 'milestones', 'notebooks', 'links', 'fileversions'];
      if (!validResources.includes(resource)) {
        throw new Error(`Invalid resource type. Must be one of: ${validResources.join(', ')}`);
      }
      
      // For API v1, we need the proper client
      const api = getApiClientForVersion('v1');
      
      // We're using the v1 API which has a different format for the request
      const payload = {
        comment: commentData
      };
      
      // The API v1 endpoint doesn't include the base path
      const response = await api.post(`/${resource}/${resourceId}/comments.json`, payload);
      
      return response.data;
    } catch (error: any) {
      logger.error(`Error creating comment for ${resource}/${resourceId}: ${error.message}`);
      throw new Error(`Failed to create comment for ${resource}/${resourceId}: ${error.message}`);
    }
  };