@azure-devops/mcp 1.2.1 → 1.3.0

package/dist/tools/workitems.test.js

@@ -0,0 +1,530 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { describe, expect, it } from "@jest/globals";
+import { configureWorkItemTools } from "../../../src/tools/workitems";
+import { _mockBacklogs, _mockQuery, _mockQueryResults, _mockWorkItem, _mockWorkItemComment, _mockWorkItemComments, _mockWorkItems, _mockWorkItemsForIteration, _mockWorkItemType } from "../../mocks/work-items";
+describe("configureWorkItemTools", () => {
+    let server;
+    let tokenProvider;
+    let connectionProvider;
+    let mockConnection;
+    let mockWorkApi;
+    let mockWorkItemTrackingApi;
+    beforeEach(() => {
+        server = { tool: jest.fn() };
+        tokenProvider = jest.fn();
+        mockWorkApi = {
+            getBacklogs: jest.fn(),
+            getBacklogLevelWorkItems: jest.fn(),
+            getPredefinedQueryResults: jest.fn(),
+            getTeamIterations: jest.fn(),
+            getIterationWorkItems: jest.fn(),
+        };
+        mockWorkItemTrackingApi = {
+            getWorkItemsBatch: jest.fn(),
+            getWorkItem: jest.fn(),
+            getComments: jest.fn(),
+            addComment: jest.fn(),
+            updateWorkItem: jest.fn(),
+            createWorkItem: jest.fn(),
+            getWorkItemType: jest.fn(),
+            getQuery: jest.fn(),
+            queryById: jest.fn(),
+        };
+        mockConnection = {
+            getWorkApi: jest.fn().mockResolvedValue(mockWorkApi),
+            getWorkItemTrackingApi: jest.fn().mockResolvedValue(mockWorkItemTrackingApi),
+        };
+        connectionProvider = jest.fn().mockResolvedValue(mockConnection);
+    });
+    describe("tool registration", () => {
+        it("registers core tools on the server", () => {
+            configureWorkItemTools(server, tokenProvider, connectionProvider);
+            expect(server.tool).toHaveBeenCalled();
+        });
+    });
+    describe("list_backlogs tool", () => {
+        it("should call getBacklogs API with the correct parameters and return the expected result", async () => {
+            configureWorkItemTools(server, tokenProvider, connectionProvider);
+            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_list_backlogs");
+            if (!call)
+                throw new Error("ado_list_backlogs tool not registered");
+            const [, , , handler] = call;
+            mockWorkApi.getBacklogs.mockResolvedValue([
+                _mockBacklogs,
+            ]);
+            const params = {
+                project: "Contoso",
+                team: "Fabrikam",
+            };
+            const result = await handler(params);
+            expect(mockWorkApi.getBacklogs).toHaveBeenCalledWith({
+                project: params.project,
+                team: params.team,
+            });
+            expect(result.content[0].text).toBe(JSON.stringify([
+                _mockBacklogs,
+            ], null, 2));
+        });
+    });
+    describe("list_backlog_work_items tool", () => {
+        it("should call getBacklogLevelWorkItems API with the correct parameters and return the expected result", async () => {
+            configureWorkItemTools(server, tokenProvider, connectionProvider);
+            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_list_backlog_work_items");
+            if (!call)
+                throw new Error("ado_list_backlog_work_items tool not registered");
+            const [, , , handler] = call;
+            mockWorkApi.getBacklogLevelWorkItems.mockResolvedValue([
+                {
+                    workItems: [
+                        {
+                            rel: null,
+                            source: null,
+                            target: {
+                                id: 50,
+                            },
+                        },
+                        {
+                            rel: null,
+                            source: null,
+                            target: {
+                                id: 49,
+                            },
+                        },
+                    ],
+                },
+            ]);
+            const params = {
+                project: "Contoso",
+                team: "Fabrikam",
+                backlogId: "Microsoft.FeatureCategory",
+            };
+            const result = await handler(params);
+            expect(mockWorkApi.getBacklogLevelWorkItems).toHaveBeenCalledWith({ project: params.project, team: params.team }, params.backlogId);
+            expect(result.content[0].text).toBe(JSON.stringify([
+                {
+                    workItems: [
+                        {
+                            rel: null,
+                            source: null,
+                            target: {
+                                id: 50,
+                            },
+                        },
+                        {
+                            rel: null,
+                            source: null,
+                            target: {
+                                id: 49,
+                            },
+                        },
+                    ],
+                }
+            ], null, 2));
+        });
+    });
+    describe("my_work_items tool", () => {
+        it("should call getPredefinedQueryResults API with the correct parameters and return the expected result", async () => {
+            configureWorkItemTools(server, tokenProvider, connectionProvider);
+            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_my_work_items");
+            if (!call)
+                throw new Error("ado_my_work_items tool not registered");
+            const [, , , handler] = call;
+            mockWorkApi.getPredefinedQueryResults.mockResolvedValue([
+                {
+                    id: "assignedtome",
+                    name: "Assigned to me",
+                    url: "https://dev.azure.com/org/project/_apis/work/predefinedQueries/assignedtome",
+                    webUrl: "https://dev.azure.com/org/project/project/_workitems/assignedtome",
+                    hasMore: false,
+                    results: [
+                        {
+                            id: 115784,
+                            url: "https://dev.azure.com/org/_apis/wit/workItems/115784",
+                        },
+                        {
+                            id: 115794,
+                            url: "https://dev.azure.com/org/_apis/wit/workItems/115794",
+                        },
+                        {
+                            id: 115792,
+                            url: "https://dev.azure.com/org/_apis/wit/workItems/115792",
+                        },
+                    ],
+                },
+            ]);
+            const params = {
+                project: "Contoso",
+                type: "assignedtome",
+                top: 10,
+                includeCompleted: false,
+            };
+            const result = await handler(params);
+            expect(mockWorkApi.getPredefinedQueryResults).toHaveBeenCalledWith(params.project, params.type, params.top, params.includeCompleted);
+            expect(result.content[0].text).toBe(JSON.stringify([
+                {
+                    id: "assignedtome",
+                    name: "Assigned to me",
+                    url: "https://dev.azure.com/org/project/_apis/work/predefinedQueries/assignedtome",
+                    webUrl: "https://dev.azure.com/org/project/project/_workitems/assignedtome",
+                    hasMore: false,
+                    results: [
+                        {
+                            id: 115784,
+                            url: "https://dev.azure.com/org/_apis/wit/workItems/115784",
+                        },
+                        {
+                            id: 115794,
+                            url: "https://dev.azure.com/org/_apis/wit/workItems/115794",
+                        },
+                        {
+                            id: 115792,
+                            url: "https://dev.azure.com/org/_apis/wit/workItems/115792",
+                        },
+                    ],
+                },
+            ], null, 2));
+        });
+    });
+    describe("getWorkItemsBatch tool", () => {
+        it("should call workItemApi.getWorkItemsBatch API with the correct parameters and return the expected result", async () => {
+            configureWorkItemTools(server, tokenProvider, connectionProvider);
+            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_get_work_items_batch_by_ids");
+            if (!call)
+                throw new Error("ado_get_work_items_batch_by_ids tool not registered");
+            const [, , , handler] = call;
+            mockWorkItemTrackingApi.getWorkItemsBatch.mockResolvedValue([
+                _mockWorkItems,
+            ]);
+            const params = {
+                ids: [297, 299, 300],
+                project: "Contoso",
+            };
+            const result = await handler(params);
+            expect(mockWorkItemTrackingApi.getWorkItemsBatch).toHaveBeenCalledWith({
+                ids: params.ids,
+                fields: ["System.Id", "System.WorkItemType", "System.Title", "System.State", "System.Parent", "System.Tags"]
+            }, params.project);
+            expect(result.content[0].text).toBe(JSON.stringify([
+                _mockWorkItems,
+            ], null, 2));
+        });
+    });
+    describe("get_work_item tool", () => {
+        it("should call workItemApi.getWorkItem API with the correct parameters and return the expected result", async () => {
+            configureWorkItemTools(server, tokenProvider, connectionProvider);
+            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_get_work_item");
+            if (!call)
+                throw new Error("ado_get_work_item tool not registered");
+            const [, , , handler] = call;
+            mockWorkItemTrackingApi.getWorkItem.mockResolvedValue([
+                _mockWorkItem
+            ]);
+            const params = {
+                id: 12,
+                fields: undefined,
+                asOf: undefined,
+                expand: "none",
+                project: "Contoso",
+            };
+            const result = await handler(params);
+            expect(mockWorkItemTrackingApi.getWorkItem).toHaveBeenCalledWith(params.id, params.fields, params.asOf, params.expand, params.project);
+            expect(result.content[0].text).toBe(JSON.stringify([
+                _mockWorkItem,
+            ], null, 2));
+        });
+    });
+    describe("list_work_item_comments tool", () => {
+        it("should call workItemApi.getComments API with the correct parameters and return the expected result", async () => {
+            configureWorkItemTools(server, tokenProvider, connectionProvider);
+            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_list_work_item_comments");
+            if (!call)
+                throw new Error("ado_list_work_item_comments tool not registered");
+            const [, , , handler] = call;
+            mockWorkItemTrackingApi.getComments.mockResolvedValue([
+                _mockWorkItemComments
+            ]);
+            const params = {
+                project: "Contoso",
+                workItemId: 299,
+                top: 10,
+            };
+            const result = await handler(params);
+            expect(mockWorkItemTrackingApi.getComments).toHaveBeenCalledWith(params.project, params.workItemId, params.top);
+            expect(result.content[0].text).toBe(JSON.stringify([
+                _mockWorkItemComments,
+            ], null, 2));
+        });
+    });
+    describe("add_work_item_comment tool", () => {
+        it("should call workItemApi.addComment API with the correct parameters and return the expected result", async () => {
+            configureWorkItemTools(server, tokenProvider, connectionProvider);
+            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_add_work_item_comment");
+            if (!call)
+                throw new Error("ado_add_work_item_comment tool not registered");
+            const [, , , handler] = call;
+            mockWorkItemTrackingApi.addComment.mockResolvedValue([
+                _mockWorkItemComment,
+            ]);
+            const params = {
+                comment: "hello world!",
+                project: "Contoso",
+                workItemId: 299,
+            };
+            const result = await handler(params);
+            expect(mockWorkItemTrackingApi.addComment).toHaveBeenCalledWith({ text: params.comment }, params.project, params.workItemId);
+            expect(result.content[0].text).toBe(JSON.stringify([
+                _mockWorkItemComment
+            ], null, 2));
+        });
+    });
+    describe("add_child_work_item tool", () => {
+        it("should call workItemApi.add_child_work_item API with the correct parameters and return the expected result", async () => {
+            configureWorkItemTools(server, tokenProvider, connectionProvider);
+            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_add_child_work_item");
+            if (!call)
+                throw new Error("ado_add_child_work_item tool not registered");
+            const [, , , handler] = call;
+            mockWorkItemTrackingApi.createWorkItem.mockResolvedValue([
+                _mockWorkItem,
+            ]);
+            const params = {
+                parentId: 299,
+                project: "Contoso",
+                workItemType: "Task",
+                title: "Sample task",
+                description: "This is a sample task",
+                areaPath: "Contoso\\Development",
+                iterationPath: "Contoso\\Sprint 1",
+            };
+            const document = [
+                {
+                    op: "add",
+                    path: "/fields/System.Title",
+                    value: params.title
+                },
+                {
+                    op: "add",
+                    path: "/fields/System.Description",
+                    value: params.description
+                },
+                {
+                    op: "add",
+                    path: "/relations/-",
+                    value: {
+                        rel: "System.LinkTypes.Hierarchy-Reverse",
+                        url: `undefined/${params.project}/_apis/wit/workItems/${params.parentId}`,
+                    },
+                },
+                {
+                    op: "add",
+                    path: "/fields/System.AreaPath",
+                    value: params.areaPath,
+                },
+                {
+                    op: "add",
+                    path: "/fields/System.IterationPath",
+                    value: params.iterationPath,
+                }
+            ];
+            const result = await handler(params);
+            expect(mockWorkItemTrackingApi.createWorkItem).toHaveBeenCalledWith(null, document, params.project, params.workItemType);
+            expect(result.content[0].text).toBe(JSON.stringify([
+                _mockWorkItem
+            ], null, 2));
+        });
+    });
+    describe("link_work_item_to_pull_request tool", () => {
+        it("should call workItemApi.updateWorkItem API with the correct parameters and return the expected result", async () => {
+            configureWorkItemTools(server, tokenProvider, connectionProvider);
+            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_link_work_item_to_pull_request");
+            if (!call)
+                throw new Error("ado_link_work_item_to_pull_request tool not registered");
+            const [, , , handler] = call;
+            mockWorkItemTrackingApi.updateWorkItem.mockResolvedValue([
+                _mockWorkItem,
+            ]);
+            const params = {
+                project: "Contoso",
+                repositoryId: 12345,
+                pullRequestId: 67890,
+                workItemId: 131489,
+            };
+            const artifactPathValue = `${params.project}/${params.repositoryId}/${params.pullRequestId}`;
+            const vstfsUrl = `vstfs:///Git/PullRequestId/${encodeURIComponent(artifactPathValue)}`;
+            const document = [
+                {
+                    op: "add",
+                    path: "/relations/-",
+                    value: {
+                        rel: "ArtifactLink",
+                        url: vstfsUrl,
+                        attributes: {
+                            name: "Pull Request",
+                        },
+                    },
+                },
+            ];
+            const result = await handler(params);
+            expect(mockWorkItemTrackingApi.updateWorkItem).toHaveBeenCalledWith({}, document, params.workItemId, params.project);
+            expect(result.content[0].text).toBe(JSON.stringify({
+                workItemId: 131489,
+                pullRequestId: 67890,
+                success: true,
+            }, null, 2));
+        });
+    });
+    describe("get_work_items_for_iteration tool", () => {
+        it("should call workApi.getIterationWorkItems API with the correct parameters and return the expected result", async () => {
+            configureWorkItemTools(server, tokenProvider, connectionProvider);
+            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_get_work_items_for_iteration");
+            if (!call)
+                throw new Error("ado_get_work_items_for_iterationt tool not registered");
+            const [, , , handler] = call;
+            mockWorkApi.getIterationWorkItems.mockResolvedValue([
+                _mockWorkItemsForIteration,
+            ]);
+            const params = {
+                project: "Contoso",
+                team: "Fabrikam",
+                iterationId: "6bfde89e-b22e-422e-814a-e8db432f5a58",
+            };
+            const result = await handler(params);
+            expect(mockWorkApi.getIterationWorkItems).toHaveBeenCalledWith({
+                project: params.project,
+                team: params.team
+            }, params.iterationId);
+            expect(result.content[0].text).toBe(JSON.stringify([
+                _mockWorkItemsForIteration,
+            ], null, 2));
+        });
+    });
+    describe("update_work_item tool", () => {
+        it("should call workItemApi.updateWorkItem API with the correct parameters and return the expected result", async () => {
+            configureWorkItemTools(server, tokenProvider, connectionProvider);
+            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_update_work_item");
+            if (!call)
+                throw new Error("ado_update_work_item tool not registered");
+            const [, , , handler] = call;
+            mockWorkItemTrackingApi.updateWorkItem.mockResolvedValue([
+                _mockWorkItem,
+            ]);
+            const params = {
+                id: 131489,
+                updates: [
+                    {
+                        op: "add",
+                        path: "/fields/System.Title",
+                        value: "Updated Sample Task"
+                    }
+                ]
+            };
+            const result = await handler(params);
+            expect(mockWorkItemTrackingApi.updateWorkItem).toHaveBeenCalledWith(null, params.updates, params.id);
+            expect(result.content[0].text).toBe(JSON.stringify([
+                _mockWorkItem
+            ], null, 2));
+        });
+    });
+    describe("get_work_item_type tool", () => {
+        it("should call workItemApi.getWorkItemType API with the correct parameters and return the expected result", async () => {
+            configureWorkItemTools(server, tokenProvider, connectionProvider);
+            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_get_work_item_type");
+            if (!call)
+                throw new Error("ado_get_work_item_type tool not registered");
+            const [, , , handler] = call;
+            mockWorkItemTrackingApi.getWorkItemType.mockResolvedValue([
+                _mockWorkItemType,
+            ]);
+            const params = {
+                project: "Contoso",
+                workItemType: "Bug",
+            };
+            const result = await handler(params);
+            expect(mockWorkItemTrackingApi.getWorkItemType).toHaveBeenCalledWith(params.project, params.workItemType);
+            expect(result.content[0].text).toBe(JSON.stringify([
+                _mockWorkItemType
+            ], null, 2));
+        });
+    });
+    describe("create_work_item tool", () => {
+        it("should call workItemApi.createWorkItem API with the correct parameters and return the expected result", async () => {
+            configureWorkItemTools(server, tokenProvider, connectionProvider);
+            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_create_work_item");
+            if (!call)
+                throw new Error("ado_create_work_item tool not registered");
+            const [, , , handler] = call;
+            mockWorkItemTrackingApi.createWorkItem.mockResolvedValue([
+                _mockWorkItem,
+            ]);
+            const params = {
+                project: "Contoso",
+                workItemType: "Task",
+                fields: [
+                    "System.Title", "Hello World!",
+                    "System.Description", "This is a sample task",
+                    "System.AreaPath", "Contoso\\Development",
+                ]
+            };
+            const document = Object.entries(params.fields).map(([key, value]) => ({
+                op: "add",
+                path: `/fields/${key}`,
+                value,
+            }));
+            const result = await handler(params);
+            expect(mockWorkItemTrackingApi.createWorkItem).toHaveBeenCalledWith(null, document, params.project, params.workItemType);
+            expect(result.content[0].text).toBe(JSON.stringify([
+                _mockWorkItem
+            ], null, 2));
+        });
+    });
+    describe("get_query tool", () => {
+        it("should call workItemApi.getQuery API with the correct parameters and return the expected result", async () => {
+            configureWorkItemTools(server, tokenProvider, connectionProvider);
+            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_get_query");
+            if (!call)
+                throw new Error("ado_get_query tool not registered");
+            const [, , , handler] = call;
+            mockWorkItemTrackingApi.getQuery.mockResolvedValue([
+                _mockQuery,
+            ]);
+            const params = {
+                project: "Contoso",
+                query: "342f0f44-4069-46b1-a940-3d0468979ceb",
+                expand: "none",
+                depth: 1,
+                includeDeleted: false,
+                useIsoDateFormat: false,
+            };
+            const result = await handler(params);
+            expect(mockWorkItemTrackingApi.getQuery).toHaveBeenCalledWith(params.project, params.query, params.expand, params.depth, params.includeDeleted, params.useIsoDateFormat);
+            expect(result.content[0].text).toBe(JSON.stringify([
+                _mockQuery,
+            ], null, 2));
+        });
+    });
+    describe("get_query_results_by_id tool", () => {
+        it("should call workItemApi.getQueryById API with the correct parameters and return the expected result", async () => {
+            configureWorkItemTools(server, tokenProvider, connectionProvider);
+            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_get_query_results_by_id");
+            if (!call)
+                throw new Error("ado_get_query_results_by_id tool not registered");
+            const [, , , handler] = call;
+            mockWorkItemTrackingApi.queryById.mockResolvedValue([
+                _mockQueryResults,
+            ]);
+            const params = {
+                id: "342f0f44-4069-46b1-a940-3d0468979ceb",
+                project: "Contoso",
+                team: "Fabrikam",
+                timePrecision: false,
+                top: 50,
+            };
+            const result = await handler(params);
+            expect(mockWorkItemTrackingApi.queryById).toHaveBeenCalledWith(params.id, { project: params.project, team: params.team }, params.timePrecision, params.top);
+            expect(result.content[0].text).toBe(JSON.stringify([
+                _mockQueryResults,
+            ], null, 2));
+        });
+    });
+});

package/dist/tools.js

@@ -1,14 +1,15 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-import { configureCoreTools } from "./tools/core.js";
-import { configureWorkTools } from "./tools/work.js";
+import { configureAdvSecTools } from "./tools/advsec.js";
 import { configureBuildTools } from "./tools/builds.js";
-import { configureRepoTools } from "./tools/repos.js";
-import { configureWorkItemTools } from "./tools/workitems.js";
+import { configureCoreTools } from "./tools/core.js";
 import { configureReleaseTools } from "./tools/releases.js";
-import { configureWikiTools } from "./tools/wiki.js";
-import { configureTestPlanTools } from "./tools/testplans.js";
+import { configureRepoTools } from "./tools/repos.js";
 import { configureSearchTools } from "./tools/search.js";
+import { configureTestPlanTools } from "./tools/testplans.js";
+import { configureWikiTools } from "./tools/wiki.js";
+import { configureWorkTools } from "./tools/work.js";
+import { configureWorkItemTools } from "./tools/workitems.js";
 function configureAllTools(server, tokenProvider, connectionProvider, userAgentProvider) {
     configureCoreTools(server, tokenProvider, connectionProvider);
     configureWorkTools(server, tokenProvider, connectionProvider);
@@ -19,5 +20,6 @@ function configureAllTools(server, tokenProvider, connectionProvider, userAgentP
     configureWikiTools(server, tokenProvider, connectionProvider);
     configureTestPlanTools(server, tokenProvider, connectionProvider);
     configureSearchTools(server, tokenProvider, connectionProvider, userAgentProvider);
+    configureAdvSecTools(server, tokenProvider, connectionProvider);
 }
 export { configureAllTools };

package/dist/utils.js

@@ -3,6 +3,32 @@
 export const apiVersion = "7.2-preview.1";
 export const batchApiVersion = "5.0";
 export const markdownCommentsApiVersion = "7.2-preview.4";
+export function createEnumMapping(enumObject) {
+    const mapping = {};
+    for (const [key, value] of Object.entries(enumObject)) {
+        if (typeof key === "string" && typeof value === "number") {
+            mapping[key.toLowerCase()] = value;
+        }
+    }
+    return mapping;
+}
+export function mapStringToEnum(value, enumObject, defaultValue) {
+    if (!value)
+        return defaultValue;
+    const enumMapping = createEnumMapping(enumObject);
+    return enumMapping[value.toLowerCase()] ?? defaultValue;
+}
+/**
+ * Maps an array of strings to an array of enum values, filtering out invalid values.
+ * @param values Array of string values to map
+ * @param enumObject The enum object to map to
+ * @returns Array of valid enum values
+ */
+export function mapStringArrayToEnum(values, enumObject) {
+    if (!values)
+        return [];
+    return values.map((value) => mapStringToEnum(value, enumObject)).filter((v) => v !== undefined);
+}
 /**
  * Converts a TypeScript numeric enum to an array of string keys for use with z.enum().
  * This ensures that enum schemas generate string values rather than numeric values.

package/dist/version.js

@@ -1 +1 @@
-export const packageVersion = "1.2.1";
+export const packageVersion = "1.3.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-devops/mcp",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "MCP server for interacting with Azure DevOps",
   "license": "MIT",
   "author": "Microsoft Corporation",
@@ -23,6 +23,7 @@
   "scripts": {
     "preinstall": "npm config set registry https://registry.npmjs.org/",
     "prebuild": "node -p \"'export const packageVersion = ' + JSON.stringify(require('./package.json').version) + ';\\n'\" > src/version.ts && prettier --write src/version.ts",
+    "validate-tools": "tsc --noEmit && node scripts/build-validate-tools.js",
     "build": "tsc && shx chmod +x dist/*.js",
     "prepare": "npm run build",
     "watch": "tsc --watch",
@@ -37,7 +38,7 @@
   },
   "dependencies": {
     "@azure/identity": "^4.10.0",
-    "@modelcontextprotocol/sdk": "1.16.0",
+    "@modelcontextprotocol/sdk": "1.17.0",
     "azure-devops-extension-api": "^4.252.0",
     "azure-devops-extension-sdk": "^4.0.2",
     "azure-devops-node-api": "^15.1.0",
@@ -51,6 +52,7 @@
     "@types/node": "^22",
     "eslint-config-prettier": "10.1.8",
     "eslint-plugin-header": "^3.1.1",
+    "glob": "^11.0.3",
     "jest": "^30.0.2",
     "jest-extended": "^6.0.0",
     "prettier": "3.6.2",

package/dist/http.js

@@ -1,52 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-import express from "express";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { serverBuildAndConnect } from "./server.js";
-import { packageVersion } from "./version.js";
-const app = express();
-app.use(express.json());
-app.post('/mcp/:orgName', async (req, res) => {
-    // In stateless mode, create a new instance of transport and server for each request
-    // to ensure complete isolation. A single instance would cause request ID collisions
-    // when multiple clients connect concurrently.
-    try {
-        const transport = new StreamableHTTPServerTransport({
-            sessionIdGenerator: undefined,
-        });
-        const server = await serverBuildAndConnect(req.params.orgName, transport);
-        res.on('close', () => {
-            transport.close();
-            server.close();
-        });
-        await transport.handleRequest(req, res, req.body);
-    }
-    catch (error) {
-        console.error('Error handling MCP request:', error);
-        if (!res.headersSent) {
-            res.status(500).json({
-                jsonrpc: '2.0',
-                error: {
-                    code: -32603,
-                    message: 'Internal server error',
-                },
-                id: null,
-            });
-        }
-    }
-});
-app.get('/mcp/:orgName', async (req, res) => {
-    console.log('Received GET MCP request');
-    res.writeHead(405).end(JSON.stringify({
-        jsonrpc: "2.0",
-        error: {
-            code: -32000,
-            message: "Method not allowed."
-        },
-        id: null
-    }));
-});
-const PORT = 3000;
-app.listen(PORT, () => {
-    console.log(`Azure DevOps MCP Server with http transport listening on port ${PORT}. Version: ${packageVersion}`);
-});