@azure-devops/mcp 2.10.0-nightly.20260927 → 2.10.0-nightly.20260929

package/dist/shared/tool-annotations.js

@@ -53,7 +53,9 @@ const TOOL_ANNOTATIONS = {
     wit_backlog: MUTATING_ANNOTATIONS,
     wit_query: READ_ONLY_ANNOTATIONS,
     wit_work_item: READ_ONLY_ANNOTATIONS,
-    wit_work_item_attachment: ADDITIVE_ANNOTATIONS,
+    wit_work_item_attachment: READ_ONLY_ANNOTATIONS,
+    wit_work_item_attachment_link: ADDITIVE_ANNOTATIONS,
+    wit_work_item_attachment_upload: ADDITIVE_ANNOTATIONS,
     wit_work_item_comment_write: MUTATING_ANNOTATIONS,
     wit_work_item_link_write: MUTATING_ANNOTATIONS,
     wit_work_item_write: MUTATING_ANNOTATIONS,

package/dist/tools/pipelines.js

@@ -8,8 +8,23 @@ import { ConfigurationType, RepositoryType } from "azure-devops-node-api/interfa
 import { mkdirSync, createWriteStream } from "fs";
 import { createExternalContentResponse } from "../shared/content-safety.js";
 import { join, posix, resolve, win32 } from "path";
+import { Readable, Transform } from "stream";
+import { pipeline } from "stream/promises";
 import { pipelinesWriteShape } from "./pipelines.dto.js";
 const errorResult = (text) => ({ content: [{ type: "text", text }], isError: true });
+const MAX_ARTIFACT_FILE_BYTES = 1024 * 1024 * 1024;
+const MAX_ARTIFACT_BASE64_BYTES = 10 * 1024 * 1024;
+function getArtifactResponseStream(response) {
+    if (!response.body)
+        throw new Error("Artifact download returned an empty response body.");
+    return Readable.fromWeb(response.body);
+}
+function validateArtifactContentLength(response, maxBytes, limitDescription) {
+    const contentLength = Number(response.headers.get("content-length"));
+    if (Number.isFinite(contentLength) && contentLength > maxBytes) {
+        throw new Error(`Artifact download exceeds the ${limitDescription} limit.`);
+    }
+}
 async function runPipeline(args, connectionProvider) {
     if (!args.pipelineId)
         return errorResult("pipelineId is required for run_pipeline");
@@ -338,25 +353,47 @@ function configurePipelineTools(server, tokenProvider, connectionProvider, userA
                 if (!artifact) {
                     return { content: [{ type: "text", text: `Artifact ${resolvedArtifactName} not found in build ${buildId}.` }], isError: true };
                 }
-                const fileStream = await buildApi.getArtifactContentZip(project, buildId, resolvedArtifactName);
+                if (!artifact.resource?.downloadUrl) {
+                    throw new Error(`Artifact ${resolvedArtifactName} does not have a download URL.`);
+                }
+                const accessToken = await tokenProvider();
+                const response = await fetch(artifact.resource.downloadUrl, {
+                    headers: { "Authorization": `Bearer ${accessToken}`, "User-Agent": userAgentProvider() },
+                });
+                if (!response.ok) {
+                    throw new Error(`Artifact download failed: ${response.status} ${response.statusText}`);
+                }
                 if (destinationPath) {
+                    validateArtifactContentLength(response, MAX_ARTIFACT_FILE_BYTES, "1 GB file size");
                     const fullDestinationPath = resolve(destinationPath);
                     mkdirSync(fullDestinationPath, { recursive: true });
                     const fileDestinationPath = join(fullDestinationPath, `${resolvedArtifactName}.zip`);
                     const writeStream = createWriteStream(fileDestinationPath);
-                    await new Promise((resolve, reject) => {
-                        fileStream.pipe(writeStream);
-                        fileStream.on("end", () => resolve());
-                        fileStream.on("error", (err) => reject(err));
+                    let downloadedBytes = 0;
+                    const sizeLimitStream = new Transform({
+                        transform(chunk, _encoding, callback) {
+                            downloadedBytes += chunk.length;
+                            if (downloadedBytes > MAX_ARTIFACT_FILE_BYTES) {
+                                callback(new Error("Artifact download exceeds the 1 GB file size limit."));
+                                return;
+                            }
+                            callback(null, chunk);
+                        },
                     });
+                    await pipeline(getArtifactResponseStream(response), sizeLimitStream, writeStream);
                     return { content: [{ type: "text", text: `Artifact ${resolvedArtifactName} downloaded to ${destinationPath}.` }] };
                 }
+                validateArtifactContentLength(response, MAX_ARTIFACT_BASE64_BYTES, "10 MB base64 response size");
                 const chunks = [];
-                await new Promise((resolve, reject) => {
-                    fileStream.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
-                    fileStream.on("end", () => resolve());
-                    fileStream.on("error", (err) => reject(err));
-                });
+                let downloadedBytes = 0;
+                for await (const chunk of getArtifactResponseStream(response)) {
+                    const bufferChunk = Buffer.from(chunk);
+                    downloadedBytes += bufferChunk.length;
+                    if (downloadedBytes > MAX_ARTIFACT_BASE64_BYTES) {
+                        throw new Error("Artifact download exceeds the 10 MB base64 response size limit.");
+                    }
+                    chunks.push(bufferChunk);
+                }
                 const buffer = Buffer.concat(chunks);
                 const base64Data = buffer.toString("base64");
                 return {

package/dist/tools/work-items.js

@@ -1,7 +1,8 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-import * as fs from "fs";
+import { constants, open, realpath } from "fs/promises";
 import * as path from "path";
+import { Readable } from "stream";
 import { WorkItemExpand } from "azure-devops-node-api/interfaces/WorkItemTrackingInterfaces.js";
 import { QueryExpand } from "azure-devops-node-api/interfaces/WorkItemTrackingInterfaces.js";
 import { z } from "zod";
@@ -14,6 +15,8 @@ const WORKITEM_TOOLS = {
     wit_query: "wit_query",
     wit_backlog: "wit_backlog",
     wit_work_item_attachment: "wit_work_item_attachment",
+    wit_work_item_attachment_upload: "wit_work_item_attachment_upload",
+    wit_work_item_attachment_link: "wit_work_item_attachment_link",
     wit_work_item_write: "wit_work_item_write",
     wit_work_item_comment_write: "wit_work_item_comment_write",
     wit_work_item_link_write: "wit_work_item_link_write",
@@ -413,12 +416,12 @@ function configureWorkItemTools(server, tokenProvider, connectionProvider, userA
     // --- wit_work_item_attachment -----------------------------------------------
     server.tool(WORKITEM_TOOLS.wit_work_item_attachment, "Download a work item attachment by its ID. By default returns the content as a base64-encoded resource. If savePath is provided, saves the file locally to that directory and returns the file path instead. Useful for viewing images (e.g. screenshots) or other files attached to work items such as bugs. If a project is not specified, you will be prompted to select one.", {
         project: z.string().optional().describe("The name or ID of the Azure DevOps project. Reuse from prior context if already known. If not provided, a project selection prompt will be shown."),
-        attachmentId: z.string().describe("The GUID of the attachment. Found in the attachment URL: https://dev.azure.com/{org}/{project}/_apis/wit/attachments/{attachmentId}"),
+        attachmentId: z.string().describe("The GUID of the attachment. Found in the attachment URL: https://dev.azure.com/{org}/{project}/_apis/wit/attachments/{attachmentId}."),
         fileName: z.string().optional().describe("The file name of the attachment, e.g. 'screenshot.png'. Used to determine the MIME type or the saved file's name."),
         savePath: z
             .string()
             .optional()
-            .describe("Optional local directory path where the file should be saved. Must be a relative path (e.g. 'temp' or 'downloads/attachments'); absolute paths and path traversals are not allowed. If provided, saves the attachment to this directory and returns the file path. If omitted, returns the content as a base64-encoded resource."),
+            .describe("Optional local directory path where the downloaded file should be saved. Must be a relative path (e.g. 'temp' or 'downloads/attachments') to an existing directory that resolves (including symlinks) inside the server's working directory; absolute paths are not allowed. If provided, saves the attachment to this directory and returns the file path. If omitted, returns the content as a base64-encoded resource."),
     }, async ({ project, attachmentId, fileName, savePath }) => {
         const isAbsolutePath = (value) => path.posix.isAbsolute(value) || path.win32.isAbsolute(value);
         const hasDriveLetter = (value) => /^[a-zA-Z]:/.test(value);
@@ -428,6 +431,14 @@ function configureWorkItemTools(server, tokenProvider, connectionProvider, userA
         if (fileName !== undefined && fileName.includes("..")) {
             throw new Error("Invalid fileName: path traversal is not allowed.");
         }
+        if (!attachmentId)
+            return { content: [{ type: "text", text: "attachmentId is required for download" }], isError: true };
+        if (savePath) {
+            const localFileName = fileName ?? attachmentId;
+            if (localFileName.includes("\0") || path.posix.basename(localFileName) !== localFileName || path.win32.basename(localFileName) !== localFileName) {
+                throw new Error("Invalid fileName: path components are not allowed.");
+            }
+        }
         try {
             const connection = await connectionProvider();
             let resolvedProject = project;
@@ -447,12 +458,21 @@ function configureWorkItemTools(server, tokenProvider, connectionProvider, userA
             });
             const buffer = Buffer.concat(chunks);
             if (savePath) {
-                const resolvedFileName = fileName ?? attachmentId;
-                const localFilePath = path.join(savePath, resolvedFileName);
-                if (fs.existsSync(localFilePath)) {
-                    throw new Error(`File already exists: ${localFilePath}`);
+                const workspaceRoot = await realpath(process.cwd());
+                const resolvedDirectory = await realpath(path.resolve(workspaceRoot, savePath));
+                const relativeDirectory = path.relative(workspaceRoot, resolvedDirectory);
+                if (relativeDirectory === ".." || relativeDirectory.startsWith(`..${path.sep}`) || path.isAbsolute(relativeDirectory)) {
+                    throw new Error("Invalid savePath: destination must remain inside the workspace.");
+                }
+                const localFilePath = path.join(resolvedDirectory, fileName ?? attachmentId);
+                // O_EXCL fails if the file (or a symlink) already exists, so there is no check-then-write race.
+                const file = await open(localFilePath, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | (constants.O_NOFOLLOW ?? 0), 0o600);
+                try {
+                    await file.writeFile(buffer);
+                }
+                finally {
+                    await file.close();
                 }
-                fs.writeFileSync(localFilePath, buffer);
                 return {
                     content: [{ type: "text", text: `Attachment saved to: ${localFilePath}` }],
                 };
@@ -483,6 +503,80 @@ function configureWorkItemTools(server, tokenProvider, connectionProvider, userA
             };
         }
     });
+    // --- wit_work_item_attachment_upload ----------------------------------------
+    server.tool(WORKITEM_TOOLS.wit_work_item_attachment_upload, "Upload base64-encoded content as a new work item attachment. This tool only uploads the attachment; use wit_work_item_attachment_link separately to link the returned attachment URL to a work item.", {
+        project: z.string().optional().describe("The name or ID of the Azure DevOps project. Reuse from prior context if already known. If not provided, a project selection prompt will be shown."),
+        fileName: z.string().describe("The name of the file to upload, e.g. 'screenshot.png'."),
+        content: z.string().describe("Base64-encoded file content to upload."),
+    }, async ({ project, fileName, content }) => {
+        try {
+            if (fileName.includes(".."))
+                return { content: [{ type: "text", text: "Invalid fileName: path traversal is not allowed." }], isError: true };
+            if (!content)
+                return { content: [{ type: "text", text: "content is required for upload" }], isError: true };
+            if (!/^[A-Za-z0-9+/]+={0,2}$/.test(content))
+                return { content: [{ type: "text", text: "content must be valid base64-encoded data" }], isError: true };
+            const connection = await connectionProvider();
+            let resolvedProject = project;
+            if (!resolvedProject) {
+                const result = await elicitProject(server, connection, "Select the Azure DevOps project to upload the work item attachment to.");
+                if ("response" in result)
+                    return result.response;
+                resolvedProject = result.resolved;
+            }
+            const workItemApi = await connection.getWorkItemTrackingApi();
+            const attachmentReference = await workItemApi.createAttachment({}, Readable.from(Buffer.from(content, "base64")), fileName, undefined, resolvedProject);
+            return { content: [{ type: "text", text: JSON.stringify(attachmentReference, null, 2) }] };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error uploading work item attachment: ${errorMessage}` }],
+                isError: true,
+            };
+        }
+    });
+    // --- wit_work_item_attachment_link ------------------------------------------
+    server.tool(WORKITEM_TOOLS.wit_work_item_attachment_link, "Link an uploaded attachment to a work item using the attachment URL returned by wit_work_item_attachment_upload.", {
+        project: z.string().optional().describe("The name or ID of the Azure DevOps project. Reuse from prior context if already known. If not provided, a project selection prompt will be shown."),
+        workItemId: z.coerce.number().min(1).describe("The ID of the work item to link the uploaded attachment to."),
+        attachmentUrl: z.string().url().describe("The attachment URL returned by wit_work_item_attachment_upload."),
+        comment: z.string().optional().describe("Optional comment to include with the attachment link."),
+    }, async ({ project, workItemId, attachmentUrl, comment }) => {
+        try {
+            const connection = await connectionProvider();
+            let resolvedProject = project;
+            if (!resolvedProject) {
+                const result = await elicitProject(server, connection, "Select the Azure DevOps project containing the work item to link the attachment to.");
+                if ("response" in result)
+                    return result.response;
+                resolvedProject = result.resolved;
+            }
+            const patchDocument = [
+                {
+                    op: "add",
+                    path: "/relations/-",
+                    value: {
+                        rel: "AttachedFile",
+                        url: attachmentUrl,
+                        attributes: { comment: comment || "" },
+                    },
+                },
+            ];
+            const workItemApi = await connection.getWorkItemTrackingApi();
+            const workItem = await workItemApi.updateWorkItem({}, patchDocument, workItemId, resolvedProject);
+            if (!workItem)
+                throw new Error("Work item not found");
+            return { content: [{ type: "text", text: JSON.stringify({ attachmentUrl, workItemId }, null, 2) }] };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error linking work item attachment: ${errorMessage}` }],
+                isError: true,
+            };
+        }
+    });
     // --- wit_work_item_write ----------------------------------------------------
     server.tool(WORKITEM_TOOLS.wit_work_item_write, "Write operations for work items. Use the action parameter to specify the operation.", {
         action: z

package/dist/version.js

@@ -1 +1 @@
-export const packageVersion = "2.10.0-nightly.20260927";
+export const packageVersion = "2.10.0-nightly.20260929";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-devops/mcp",
-  "version": "2.10.0-nightly.20260927",
+  "version": "2.10.0-nightly.20260929",
   "mcpName": "microsoft.com/azure-devops",
   "description": "MCP server for interacting with Azure DevOps",
   "license": "MIT",