targetprocess-mcp-server 2.2.1 → 2.2.3-a

package/README.md

@@ -65,6 +65,9 @@ Cards — Write
 - `create_user_story` — Create a new user story (title, optional description, optional featureId, optional releaseId, optional projectId, optional teamId)  
 > [!NOTE]  
 > `projectId` and `teamId` are optional — fall back to `TP_PROJECT_ID` and `TP_TEAM_ID` from config  
+- `create_feature` — Create a new feature (title, optional description, optional epicId, optional releaseId, optional projectId, optional teamId)  
+> [!NOTE]  
+> `projectId` and `teamId` are optional — fall back to `TP_PROJECT_ID` and `TP_TEAM_ID` from config  
 - `create_test_plan` — Create a test plan linked to a UserStory, Bug, or Feature (title, resourceId, optional resourceType, optional description/startDate/endDate)  
 > [!NOTE]  
 > requires `TP_PROJECT_ID`, 

package/build/index.js

@@ -1,11 +1,10 @@
 #!/usr/bin/env node
-import { execSync } from "child_process";
-import { homedir } from "os";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 import { JSDOM } from "jsdom";
 import { TpClient } from "./tp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { config } from "./config.js";
 const server = new McpServer({
     name: "tp",
     version: "1.0.0"
@@ -376,6 +375,7 @@ server.registerTool('search_tp_cards', {
             title: item.Name,
             id: item.Id,
             description: descriptionText,
+            url: `${config.tp.url}/entity/${item.Id}`,
         };
     });
     return {
@@ -751,6 +751,49 @@ server.registerTool('create_user_story', {
             }],
     };
 });
+server.registerTool('create_feature', {
+    title: 'Create a new feature',
+    description: `Create a new Feature in Targetprocess.`,
+    inputSchema: {
+        title: z.string()
+            .describe('Feature title'),
+        description: z.string()
+            .optional()
+            .describe('Optional feature description (when provided, format as HTML)'),
+        epicId: z.string()
+            .min(5)
+            .max(6)
+            .optional()
+            .describe('Optional Epic ID to link this feature to (e.g. 145636)'),
+        releaseId: z.string()
+            .min(5)
+            .max(6)
+            .optional()
+            .describe('Optional Release ID to link this feature to (e.g. 145200)'),
+        projectId: z.string()
+            .optional()
+            .describe('Optional Project ID — defaults to TP_PROJECT_ID from config'),
+        teamId: z.string()
+            .optional()
+            .describe('Optional Team ID — defaults to TP_TEAM_ID from config'),
+    },
+}, async ({ title, description, epicId, releaseId, projectId, teamId }) => {
+    const featureResponse = await tp.createFeature({ title, description, epicId, releaseId, projectId, teamId });
+    if (!featureResponse) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to create feature "${title}"\n JSON: ${JSON.stringify(featureResponse, null, 2)}`
+                }]
+        };
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(featureResponse)
+            }],
+    };
+});
 server.registerTool('create_test_plan', {
     title: 'Create a new test plan linked to a TP card',
     description: `Create a new test plan linked to a UserStory, Bug, or Feature. Name and Project are required by the API; Description, StartDate, and EndDate are optional.`,
@@ -1197,92 +1240,6 @@ server.registerTool('add_test_cases_to_test_plan', {
             }]
     };
 });
-server.registerTool('add_attached_file_to_card', {
-    title: 'Attach a file to a TP card',
-    description: 'Upload and attach a local file to a Targetprocess entity (UserStory, Bug, Feature, etc.) by its ID',
-    inputSchema: {
-        generalId: z.string()
-            .min(5)
-            .max(6)
-            .describe('TP entity ID to attach the file to (e.g. 145789)'),
-        filePath: z.string()
-            .describe('Absolute path to the local file to upload (e.g. /Users/mcs/Desktop/image.png)'),
-    },
-}, async ({ generalId, filePath }) => {
-    try {
-        const result = await tp.addAttachedFile(generalId, filePath);
-        if (!result) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Failed to attach file "${filePath}" to card id: ${generalId}`
-                    }]
-            };
-        }
-        return {
-            content: [{
-                    type: 'text',
-                    text: result
-                }]
-        };
-    }
-    catch (error) {
-        return {
-            content: [{
-                    type: 'text',
-                    text: `Error attaching file to card ${generalId}: ${error}`
-                }]
-        };
-    }
-});
-server.registerTool('find_file_on_disk', {
-    title: 'Find a file on disk by name',
-    description: `Search for a file by name on the local filesystem.
-      First tries an exact (case-insensitive) match.
-      If nothing is found, retries using the first half of the filename (without extension) as a wildcard — e.g. "screenshot_bug" becomes "*screensho*".
-      Returns a list of matching absolute paths.`,
-    inputSchema: {
-        fileName: z.string()
-            .describe('Filename to search for, with or without extension (e.g. "screenshot.png" or "report")'),
-        searchDir: z.string()
-            .optional()
-            .describe('Directory to search in — defaults to the user home directory'),
-    },
-}, async ({ fileName, searchDir }) => {
-    const dir = searchDir || homedir();
-    const runFind = (pattern) => {
-        try {
-            const out = execSync(`find "${dir}" -iname "${pattern}" 2>/dev/null`, {
-                encoding: 'utf8',
-                timeout: 15000,
-            });
-            return out.trim().split('\n').filter(Boolean);
-        }
-        catch {
-            return [];
-        }
-    };
-    // Exact match
-    let files = runFind(fileName);
-    if (files.length > 0) {
-        return {
-            content: [{ type: 'text', text: JSON.stringify({ match: 'exact', files }) }]
-        };
-    }
-    // Partial match: first half of name without extension
-    const dotIndex = fileName.lastIndexOf('.');
-    const nameOnly = dotIndex > 0 ? fileName.slice(0, dotIndex) : fileName;
-    const half = nameOnly.slice(0, Math.ceil(nameOnly.length / 2));
-    files = runFind(`*${half}*`);
-    if (files.length > 0) {
-        return {
-            content: [{ type: 'text', text: JSON.stringify({ match: 'partial', keyword: half, files }) }]
-        };
-    }
-    return {
-        content: [{ type: 'text', text: `No files found matching "${fileName}" or partial keyword "${half}" in ${dir}` }]
-    };
-});
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/build/tp.js

@@ -170,6 +170,23 @@ export class TpClient {
             param: { "format": "json" },
         }, userStory);
     }
+    async createFeature({ title, description, epicId, releaseId, projectId, teamId }) {
+        const feature = {
+            "Name": title,
+            "Project": { "Id": projectId || config.tp.projectId },
+            "assignedTeams": [{ "team": { "id": teamId || config.tp.teamId } }],
+        };
+        if (description)
+            feature["Description"] = description;
+        if (epicId)
+            feature["Epic"] = { "Id": epicId };
+        if (releaseId)
+            feature["Release"] = { "Id": releaseId };
+        return this.post({
+            pathParam: { "Features": '' },
+            param: { "format": "json" },
+        }, feature);
+    }
     async createBugBasedOnUserStory(title, userStoryId, bugContent) {
         const bug = {
             "Name": title,
@@ -476,13 +493,22 @@ export class TpClient {
             param: { "format": "json", }
         });
     }
-    async addAttachedFile(generalId, filePath) {
-        const fileContent = readFileSync(filePath);
-        const fileName = basename(filePath);
+    async addAttachedFile(generalId, source) {
+        let blob;
+        let fileName;
+        if ("filePath" in source) {
+            blob = new Blob([readFileSync(source.filePath)]);
+            fileName = basename(source.filePath);
+        }
+        else {
+            blob = new Blob([Buffer.from(source.fileContent, "base64")]);
+            fileName = source.fileName;
+        }
         const formData = new FormData();
         formData.append("generalId", generalId);
-        formData.append("file", new Blob([fileContent]), fileName);
+        formData.append("file", blob, fileName);
         const url = `${this.baseUrl}/UploadFile.ashx?access_token=${this.token}`;
+        console.error(JSON.stringify({ "UPLOAD_URL": url.replace(this.token, "***") }, null, 2));
         try {
             const response = await fetch(url, {
                 method: "POST",
@@ -491,7 +517,7 @@ export class TpClient {
             if (!response.ok) {
                 throw new Error(`HTTP error! status: ${response.status}`);
             }
-            return response.text();
+            return await response.text();
         }
         catch (error) {
             console.error("Error uploading file:", error);

package/package.json

@@ -25,7 +25,7 @@
   "engines": {
     "node": ">=20.x"
   },
-  "version": "2.2.1",
+  "version": "2.2.3a",
   "description": "MCP server for Tartget Process",
   "main": "build/index.js",
   "keywords": [