@sonyjv/azure-devops-mcp 2.9.0-onprem.1

package/dist/tools/work.js

@@ -0,0 +1,345 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { z } from "zod";
+import { TreeStructureGroup, TreeNodeStructureType } from "azure-devops-node-api/interfaces/WorkItemTrackingInterfaces.js";
+import { elicitProject, elicitTeam } from "../shared/elicitations.js";
+const WORK_TOOLS = {
+    work: "work",
+    work_iteration_write: "work_iteration_write",
+    work_capacity_write: "work_capacity_write",
+};
+function configureWorkTools(server, _, connectionProvider) {
+    server.tool(WORK_TOOLS.work, "Retrieve work-related data for a project or team. Use the action parameter to specify the operation.", {
+        action: z
+            .enum(["list_iterations", "list_team_iterations", "get_team_settings", "get_team_capacity", "get_iteration_capacities"])
+            .describe("The action to perform. Options: list_iterations (list all iterations in a project), list_team_iterations (list iterations assigned to a team), get_team_settings (get team settings including default iteration and area path), get_team_capacity (get team capacity for an iteration), get_iteration_capacities (get capacity for all teams in an iteration)."),
+        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."),
+        team: z
+            .string()
+            .optional()
+            .describe("The name or ID of the Azure DevOps team. Required for list_team_iterations, get_team_settings, and get_team_capacity. Reuse from prior context if already known."),
+        iterationId: z.string().optional().describe("The Iteration ID. Required for get_team_capacity and get_iteration_capacities."),
+        timeframe: z.enum(["current"]).optional().describe("The timeframe for list_team_iterations. Only 'current' is supported."),
+        depth: z.coerce.number().default(2).describe("Depth of children to fetch. Used for list_iterations. Defaults to 2."),
+        excludedIds: z.array(z.coerce.number().min(1)).optional().describe("An optional array of iteration IDs, and their children, to exclude from results. Used for list_iterations."),
+    }, async ({ action, project, team, iterationId, timeframe, depth, excludedIds }) => {
+        try {
+            const connection = await connectionProvider();
+            let resolvedProject = project;
+            if (action === "list_team_iterations") {
+                if (!resolvedProject) {
+                    const result = await elicitProject(server, connection, "Select the Azure DevOps project to list team iterations for.");
+                    if ("response" in result)
+                        return result.response;
+                    resolvedProject = result.resolved;
+                }
+                let resolvedTeam = team;
+                if (!resolvedTeam) {
+                    const result = await elicitTeam(server, connection, resolvedProject, "Select the Azure DevOps team to list iterations for.");
+                    if ("response" in result)
+                        return result.response;
+                    resolvedTeam = result.resolved;
+                }
+                const workApi = await connection.getWorkApi();
+                const iterations = await workApi.getTeamIterations({ project: resolvedProject, team: resolvedTeam }, timeframe);
+                if (!iterations) {
+                    return { content: [{ type: "text", text: "No iterations found" }], isError: true };
+                }
+                return {
+                    content: [
+                        { type: "text", text: `Project: ${resolvedProject}, Team: ${resolvedTeam}` },
+                        { type: "text", text: JSON.stringify(iterations, null, 2) },
+                    ],
+                };
+            }
+            if (action === "list_iterations") {
+                if (!resolvedProject) {
+                    const result = await elicitProject(server, connection, "Select the Azure DevOps project to list iterations for.");
+                    if ("response" in result)
+                        return result.response;
+                    resolvedProject = result.resolved;
+                }
+                const workItemTrackingApi = await connection.getWorkItemTrackingApi();
+                const effectiveDepth = depth ?? 1;
+                const results = await workItemTrackingApi.getClassificationNodes(resolvedProject, [], effectiveDepth);
+                if (!results) {
+                    return { content: [{ type: "text", text: "No iterations were found" }], isError: true };
+                }
+                let filteredResults = results.filter((node) => node.structureType === TreeNodeStructureType.Iteration);
+                if (excludedIds && excludedIds.length > 0) {
+                    const filterOutIds = (nodes) => {
+                        return nodes
+                            .filter((node) => !node.id || !excludedIds.includes(node.id))
+                            .map((node) => {
+                            if (node.children && node.children.length > 0) {
+                                return {
+                                    ...node,
+                                    children: filterOutIds(node.children),
+                                };
+                            }
+                            return node;
+                        });
+                    };
+                    filteredResults = filterOutIds(filteredResults);
+                }
+                if (filteredResults.length === 0) {
+                    return { content: [{ type: "text", text: "No iterations were found" }], isError: true };
+                }
+                return {
+                    content: [{ type: "text", text: JSON.stringify(filteredResults, null, 2) }],
+                };
+            }
+            if (action === "get_team_settings") {
+                if (!resolvedProject) {
+                    const result = await elicitProject(server, connection, "Select the Azure DevOps project to get team settings for.");
+                    if ("response" in result)
+                        return result.response;
+                    resolvedProject = result.resolved;
+                }
+                let resolvedTeam = team;
+                if (!resolvedTeam) {
+                    const result = await elicitTeam(server, connection, resolvedProject, "Select the Azure DevOps team to get settings for.");
+                    if ("response" in result)
+                        return result.response;
+                    resolvedTeam = result.resolved;
+                }
+                const workApi = await connection.getWorkApi();
+                const teamContext = { project: resolvedProject, team: resolvedTeam };
+                const teamSettings = await workApi.getTeamSettings(teamContext);
+                if (!teamSettings) {
+                    return { content: [{ type: "text", text: "No team settings found" }], isError: true };
+                }
+                const teamFieldValues = await workApi.getTeamFieldValues(teamContext);
+                const settingsResult = {
+                    backlogIteration: teamSettings.backlogIteration,
+                    defaultIteration: teamSettings.defaultIteration,
+                    defaultIterationMacro: teamSettings.defaultIterationMacro,
+                    backlogVisibilities: teamSettings.backlogVisibilities,
+                    bugsBehavior: teamSettings.bugsBehavior,
+                    workingDays: teamSettings.workingDays,
+                    defaultAreaPath: teamFieldValues?.defaultValue,
+                    areaPathField: teamFieldValues?.field,
+                    areaPaths: teamFieldValues?.values,
+                };
+                return {
+                    content: [
+                        { type: "text", text: `Project: ${resolvedProject}, Team: ${resolvedTeam}` },
+                        { type: "text", text: JSON.stringify(settingsResult, null, 2) },
+                    ],
+                };
+            }
+            if (action === "get_team_capacity") {
+                if (!resolvedProject) {
+                    const result = await elicitProject(server, connection, "Select the Azure DevOps project to get team capacity for.");
+                    if ("response" in result)
+                        return result.response;
+                    resolvedProject = result.resolved;
+                }
+                if (!team) {
+                    return { content: [{ type: "text", text: "Team is required for get_team_capacity" }], isError: true };
+                }
+                if (!iterationId) {
+                    return { content: [{ type: "text", text: "iterationId is required for get_team_capacity" }], isError: true };
+                }
+                const workApi = await connection.getWorkApi();
+                const teamContext = { project: resolvedProject, team };
+                const rawResults = await workApi.getCapacitiesWithIdentityRefAndTotals(teamContext, iterationId);
+                if (!rawResults || rawResults.teamMembers?.length === 0) {
+                    return { content: [{ type: "text", text: "No team capacity assigned to the team" }], isError: true };
+                }
+                const simplifiedResults = {
+                    ...rawResults,
+                    teamMembers: (rawResults.teamMembers || []).map((member) => {
+                        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                        const { url, ...rest } = member;
+                        return {
+                            ...rest,
+                            teamMember: member.teamMember
+                                ? {
+                                    displayName: member.teamMember.displayName,
+                                    id: member.teamMember.id,
+                                    uniqueName: member.teamMember.uniqueName,
+                                }
+                                : undefined,
+                        };
+                    }),
+                };
+                return {
+                    content: [{ type: "text", text: JSON.stringify(simplifiedResults, null, 2) }],
+                };
+            }
+            if (action === "get_iteration_capacities") {
+                if (!resolvedProject) {
+                    const result = await elicitProject(server, connection, "Select the Azure DevOps project to get iteration capacities for.");
+                    if ("response" in result)
+                        return result.response;
+                    resolvedProject = result.resolved;
+                }
+                if (!iterationId) {
+                    return { content: [{ type: "text", text: "iterationId is required for get_iteration_capacities" }], isError: true };
+                }
+                const workApi = await connection.getWorkApi();
+                const rawResults = await workApi.getTotalIterationCapacities(resolvedProject, iterationId);
+                if (!rawResults || !rawResults.teams || rawResults.teams.length === 0) {
+                    return { content: [{ type: "text", text: "No iteration capacity assigned to the teams" }], isError: true };
+                }
+                return {
+                    content: [{ type: "text", text: JSON.stringify(rawResults, null, 2) }],
+                };
+            }
+            return { content: [{ type: "text", text: `Unknown action: ${action}` }], isError: true };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            const actionErrorMessages = {
+                list_team_iterations: `Error fetching team iterations: ${errorMessage}`,
+                list_iterations: `Error fetching iterations: ${errorMessage}`,
+                get_team_settings: `Error fetching team settings: ${errorMessage}`,
+                get_team_capacity: `Error getting team capacity: ${errorMessage}`,
+                get_iteration_capacities: `Error getting iteration capacities: ${errorMessage}`,
+            };
+            return {
+                content: [{ type: "text", text: actionErrorMessages[action] ?? `Error: ${errorMessage}` }],
+                isError: true,
+            };
+        }
+    });
+    server.tool(WORK_TOOLS.work_iteration_write, "Create or assign iterations in an Azure DevOps project. Use the action parameter to specify the operation.", {
+        action: z.enum(["create", "assign"]).describe("The action to perform. 'create' creates new iterations in the project; 'assign' assigns existing iterations to a team."),
+        project: z.string().describe("The name or ID of the Azure DevOps project."),
+        team: z.string().optional().describe("The name or ID of the Azure DevOps team. Required for assign."),
+        iterations: z
+            .array(z.object({
+            iterationName: z.string().optional().describe("The name of the iteration to create. Used for create."),
+            startDate: z.string().optional().describe("The start date of the iteration in ISO format (e.g., '2023-01-01T00:00:00Z'). Used for create."),
+            finishDate: z.string().optional().describe("The finish date of the iteration in ISO format (e.g., '2023-01-31T23:59:59Z'). Used for create."),
+            identifier: z.string().optional().describe("The identifier of the iteration to assign. Used for assign."),
+            path: z.string().optional().describe("The path of the iteration to assign, e.g., 'Project/Iteration'. Used for assign."),
+        }))
+            .describe("An array of iterations to process. For create: provide iterationName and optional dates. For assign: provide identifier and path."),
+    }, async ({ action, project, team, iterations }) => {
+        try {
+            const connection = await connectionProvider();
+            if (action === "create") {
+                const workItemTrackingApi = await connection.getWorkItemTrackingApi();
+                const results = [];
+                for (const { iterationName, startDate, finishDate } of iterations) {
+                    if (!iterationName)
+                        continue;
+                    const iteration = await workItemTrackingApi.createOrUpdateClassificationNode({
+                        name: iterationName,
+                        attributes: {
+                            startDate: startDate ? new Date(startDate) : undefined,
+                            finishDate: finishDate ? new Date(finishDate) : undefined,
+                        },
+                    }, project, TreeStructureGroup.Iterations);
+                    if (iteration) {
+                        results.push(iteration);
+                    }
+                }
+                if (results.length === 0) {
+                    return { content: [{ type: "text", text: "No iterations were created" }], isError: true };
+                }
+                return {
+                    content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
+                };
+            }
+            if (action === "assign") {
+                if (!team) {
+                    return { content: [{ type: "text", text: "Team is required for assign" }], isError: true };
+                }
+                const workApi = await connection.getWorkApi();
+                const teamContext = { project, team };
+                const results = [];
+                for (const { identifier, path } of iterations) {
+                    if (!identifier || !path)
+                        continue;
+                    const assignment = await workApi.postTeamIteration({ path: path, id: identifier }, teamContext);
+                    if (assignment) {
+                        results.push(assignment);
+                    }
+                }
+                if (results.length === 0) {
+                    return { content: [{ type: "text", text: "No iterations were assigned to the team" }], isError: true };
+                }
+                return {
+                    content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
+                };
+            }
+            return { content: [{ type: "text", text: `Unknown action: ${action}` }], isError: true };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            const actionErrorMessages = {
+                create: `Error creating iterations: ${errorMessage}`,
+                assign: `Error assigning iterations: ${errorMessage}`,
+            };
+            return {
+                content: [{ type: "text", text: actionErrorMessages[action] ?? `Error: ${errorMessage}` }],
+                isError: true,
+            };
+        }
+    });
+    server.tool(WORK_TOOLS.work_capacity_write, "Update the team capacity of a team member for a specific iteration in a project.", {
+        action: z.literal("update").describe("The action to perform. Only 'update' is supported."),
+        project: z.string().describe("The name or Id of the Azure DevOps project."),
+        team: z.string().describe("The name or Id of the Azure DevOps team."),
+        teamMemberId: z.string().describe("The team member Id for the specific team member."),
+        iterationId: z.string().describe("The Iteration Id to update the capacity for."),
+        activities: z
+            .array(z.object({
+            name: z.string().describe("The name of the activity (e.g., 'Development')."),
+            capacityPerDay: z.number().describe("The capacity per day for this activity."),
+        }))
+            .describe("Array of activities and their daily capacities for the team member."),
+        daysOff: z
+            .array(z.object({
+            start: z.string().describe("Start date of the day off in ISO format."),
+            end: z.string().describe("End date of the day off in ISO format."),
+        }))
+            .optional()
+            .describe("Array of days off for the team member, each with a start and end date in ISO format."),
+    }, async ({ project, team, teamMemberId, iterationId, activities, daysOff }) => {
+        try {
+            const connection = await connectionProvider();
+            const workApi = await connection.getWorkApi();
+            const teamContext = { project, team };
+            const capacityPatch = {
+                activities: activities.map((a) => ({
+                    name: a.name,
+                    capacityPerDay: a.capacityPerDay,
+                })),
+                daysOff: (daysOff || []).map((d) => ({
+                    start: new Date(d.start),
+                    end: new Date(d.end),
+                })),
+            };
+            const updatedCapacity = await workApi.updateCapacityWithIdentityRef(capacityPatch, teamContext, iterationId, teamMemberId);
+            if (!updatedCapacity) {
+                return { content: [{ type: "text", text: "Failed to update team member capacity" }], isError: true };
+            }
+            const simplifiedResult = {
+                teamMember: updatedCapacity.teamMember
+                    ? {
+                        displayName: updatedCapacity.teamMember.displayName,
+                        id: updatedCapacity.teamMember.id,
+                        uniqueName: updatedCapacity.teamMember.uniqueName,
+                    }
+                    : undefined,
+                activities: updatedCapacity.activities,
+                daysOff: updatedCapacity.daysOff,
+            };
+            return {
+                content: [{ type: "text", text: JSON.stringify(simplifiedResult, null, 2) }],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error updating team capacity: ${errorMessage}` }],
+                isError: true,
+            };
+        }
+    });
+}
+export { WORK_TOOLS, configureWorkTools };

package/dist/tools.js

@@ -0,0 +1,31 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { Domain } from "./shared/domains.js";
+import { configureAdvSecTools } from "./tools/advanced-security.js";
+import { configureMcpAppsTools } from "./tools/mcp-apps.js";
+import { configurePipelineTools } from "./tools/pipelines.js";
+import { configureCoreTools } from "./tools/core.js";
+import { configureRepoTools } from "./tools/repositories.js";
+import { configureSearchTools } from "./tools/search.js";
+import { configureTestPlanTools } from "./tools/test-plans.js";
+import { configureWikiTools } from "./tools/wiki.js";
+import { configureWorkTools } from "./tools/work.js";
+import { configureWorkItemTools } from "./tools/work-items.js";
+function configureAllTools(server, tokenProvider, connectionProvider, userAgentProvider, enabledDomains) {
+    const configureIfDomainEnabled = (domain, configureFn) => {
+        if (enabledDomains.has(domain)) {
+            configureFn();
+        }
+    };
+    configureIfDomainEnabled(Domain.CORE, () => configureCoreTools(server, tokenProvider, connectionProvider, userAgentProvider));
+    configureIfDomainEnabled(Domain.MCP_APPS, () => configureMcpAppsTools(server));
+    configureIfDomainEnabled(Domain.WORK, () => configureWorkTools(server, tokenProvider, connectionProvider));
+    configureIfDomainEnabled(Domain.PIPELINES, () => configurePipelineTools(server, tokenProvider, connectionProvider, userAgentProvider));
+    configureIfDomainEnabled(Domain.REPOSITORIES, () => configureRepoTools(server, tokenProvider, connectionProvider, userAgentProvider));
+    configureIfDomainEnabled(Domain.WORK_ITEMS, () => configureWorkItemTools(server, tokenProvider, connectionProvider, userAgentProvider));
+    configureIfDomainEnabled(Domain.WIKI, () => configureWikiTools(server, tokenProvider, connectionProvider, userAgentProvider));
+    configureIfDomainEnabled(Domain.TEST_PLANS, () => configureTestPlanTools(server, tokenProvider, connectionProvider, userAgentProvider));
+    configureIfDomainEnabled(Domain.SEARCH, () => configureSearchTools(server, tokenProvider, connectionProvider, userAgentProvider));
+    configureIfDomainEnabled(Domain.ADVANCED_SECURITY, () => configureAdvSecTools(server, tokenProvider, connectionProvider));
+}
+export { configureAllTools };

package/dist/useragent.js

@@ -0,0 +1,20 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+class UserAgentComposer {
+    _userAgent;
+    _mcpClientInfoAppended;
+    constructor(packageVersion) {
+        this._userAgent = `AzureDevOps.MCP/${packageVersion} (local)`;
+        this._mcpClientInfoAppended = false;
+    }
+    get userAgent() {
+        return this._userAgent;
+    }
+    appendMcpClientInfo(info) {
+        if (!this._mcpClientInfoAppended && info && info.name && info.version) {
+            this._userAgent += ` ${info.name}/${info.version}`;
+            this._mcpClientInfoAppended = true;
+        }
+    }
+}
+export { UserAgentComposer };

package/dist/utils.js

@@ -0,0 +1,173 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+export const apiVersion = "7.2-preview.1";
+export const batchApiVersion = "5.0";
+export const markdownCommentsApiVersion = "7.2-preview.4";
+/**
+ * Returns the user-supplied CLI arguments.
+ *
+ * The server is always started script-style — `[runtime, scriptPath, ...args]` — on Node
+ * and on Electron hosts alike, so the first two entries are always dropped.
+ *
+ * Do not replace this with yargs' `hideBin`: it drops a single entry whenever
+ * `process.versions.electron` is set and `process.defaultApp` is not, so on an Electron
+ * host the script path survives and is parsed as the organization name.
+ */
+export function getCliArgs(argv = process.argv) {
+    return argv.slice(2);
+}
+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.
+ * @param enumObject The TypeScript enum object
+ * @returns Array of string keys from the enum
+ */
+export function getEnumKeys(enumObject) {
+    return Object.keys(enumObject).filter((key) => isNaN(Number(key)));
+}
+/**
+ * Safely converts a string enum key to its corresponding enum value.
+ * Validates that the key exists in the enum before conversion.
+ * @param enumObject The TypeScript enum object
+ * @param key The string key to convert
+ * @returns The enum value if key is valid, undefined otherwise
+ */
+export function safeEnumConvert(enumObject, key) {
+    if (!key)
+        return undefined;
+    const validKeys = getEnumKeys(enumObject);
+    if (!validKeys.includes(key)) {
+        return undefined;
+    }
+    return enumObject[key];
+}
+/**
+ * Encodes `>` and `<` for Markdown formatted fields.
+ *
+ * @param value The text value to encode
+ * @param format The format of the field ('Markdown' or 'Html')
+ * @returns The encoded text, or original text if format is not Markdown
+ */
+export function encodeFormattedValue(value, format) {
+    if (!value || format !== "Markdown")
+        return value;
+    const result = value.replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    return result;
+}
+/**
+ * Detects whether a string returned from an ADO API stream is actually an error
+ * response serialized as JSON (e.g. a 404 GitItemNotFoundException or
+ * WikiPageNotFoundException) rather than real content.
+ *
+ * The ADO Node API client swallows non-2xx HTTP responses and delivers the
+ * error body as a stream, so callers must check explicitly after reading.
+ *
+ * @returns The human-readable error message extracted from the JSON, or null if
+ *          the content is not an ADO error response.
+ */
+export function extractAdoStreamError(content) {
+    try {
+        const json = JSON.parse(content.trim());
+        if (json && typeof json.typeName === "string" && typeof json.message === "string") {
+            return json.message;
+        }
+    }
+    catch {
+        // Not JSON — not an ADO error response.
+    }
+    return null;
+}
+/**
+ * Extracts the Azure DevOps organization identifier from a URL.
+ *
+ * Only recognized Azure DevOps hosts are accepted; any other host returns null
+ * so that callers can treat unrecognized URLs as a boundary violation.
+ *
+ * Supports both modern and legacy organization URL forms:
+ *  - https://dev.azure.com/{org}/...            -> org is the first path segment
+ *  - https://{org}.visualstudio.com/...         -> org is the host subdomain
+ *
+ * @param url Any Azure DevOps URL (e.g. a wiki page link or a connection serverUrl).
+ * @returns The lowercased organization name, or null if it cannot be determined.
+ */
+export function getOrgFromUrl(url) {
+    try {
+        const u = new URL(url);
+        const host = u.hostname.toLowerCase();
+        if (host === "visualstudio.com" || host.endsWith(".visualstudio.com")) {
+            const subdomain = host.split(".")[0];
+            return subdomain && subdomain !== "visualstudio" ? subdomain : null;
+        }
+        if (host === "dev.azure.com" || host.endsWith(".dev.azure.com")) {
+            const firstSegment = u.pathname.split("/").filter(Boolean)[0];
+            return firstSegment ? firstSegment.toLowerCase() : null;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolves the CLI `organization` argument to an Azure DevOps connection URL.
+ *
+ * Accepts either a bare Azure DevOps Services organization name (e.g. "contoso"),
+ * or a full base URL, which also covers on-premises Azure DevOps Server / TFS
+ * collections (e.g. "http://tfsserver:8080/tfs/DefaultCollection").
+ *
+ * `cloudOrgName` is non-null only when the resolved URL is a recognized Azure
+ * DevOps Services host (see {@link getOrgFromUrl}) — callers use it to gate
+ * cloud-only behavior (AAD tenant discovery, PAT host restrictions) that doesn't
+ * apply to on-premises servers.
+ *
+ * @param organizationArg The raw `organization` CLI argument.
+ * @returns The resolved connection URL and, when applicable, the cloud org name.
+ */
+export function resolveOrgUrl(organizationArg) {
+    if (/^https?:\/\//i.test(organizationArg)) {
+        const orgUrl = organizationArg.replace(/\/+$/, "");
+        return { orgUrl, cloudOrgName: getOrgFromUrl(orgUrl) };
+    }
+    return { orgUrl: `https://dev.azure.com/${organizationArg}`, cloudOrgName: organizationArg };
+}
+/**
+ * Convert a Node.js ReadableStream to a string.
+ * Shared utility for consistent stream handling across tools.
+ */
+export function streamToString(stream) {
+    return new Promise((resolve, reject) => {
+        let data = "";
+        stream.setEncoding("utf8");
+        stream.on("data", (chunk) => {
+            data += chunk;
+        });
+        stream.on("error", reject);
+        stream.on("end", () => resolve(data));
+    });
+}

package/dist/version.js

@@ -0,0 +1 @@
+export const packageVersion = "2.9.0-onprem.1";

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@sonyjv/azure-devops-mcp",
+  "version": "2.9.0-onprem.1",
+  "mcpName": "io.github.sonyjv/azure-devops-mcp",
+  "description": "MCP server for interacting with Azure DevOps",
+  "license": "MIT",
+  "author": "Microsoft Corporation",
+  "homepage": "https://github.com/sonyjv/azure-devops-mcp",
+  "bugs": "https://github.com/sonyjv/azure-devops-mcp/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sonyjv/azure-devops-mcp.git"
+  },
+  "type": "module",
+  "bin": {
+    "mcp-server-azuredevops": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "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 && husky",
+    "watch": "tsc --watch",
+    "inspect": "ALLOWED_ORIGINS=http://127.0.0.1:6274 npx @modelcontextprotocol/inspector@0.21.0 node dist/index.js",
+    "start": "node -r tsconfig-paths/register dist/index.js",
+    "eslint": "eslint",
+    "eslint-fix": "eslint --fix",
+    "format": "prettier --write .",
+    "format-check": "prettier --check .",
+    "clean": "shx rm -rf dist",
+    "test": "jest"
+  },
+  "dependencies": {
+    "@azure/identity": "^4.13.0",
+    "@azure/logger": "^1.3.0",
+    "@azure/msal-node": "^5.5.0",
+    "@azure/msal-node-extensions": "^5.3.5",
+    "@modelcontextprotocol/sdk": "1.29.0",
+    "azure-devops-extension-api": "^5.272.3",
+    "azure-devops-extension-sdk": "^4.0.2",
+    "azure-devops-node-api": "^15.1.2",
+    "open": "^10.2.0",
+    "winston": "^3.18.3",
+    "yargs": "^18.0.0",
+    "zod": "^3.25.63",
+    "zod-to-json-schema": "^3.24.5"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.19.1",
+    "eslint-config-prettier": "10.1.8",
+    "eslint-plugin-header": "^3.1.1",
+    "glob": "^13.0.0",
+    "husky": "^9.1.7",
+    "jest": "^30.0.2",
+    "jest-extended": "^7.0.0",
+    "lint-staged": "^17.0.0",
+    "prettier": "3.9.5",
+    "shx": "^0.4.0",
+    "ts-jest": "^29.4.6",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.54.0"
+  },
+  "lint-staged": {
+    "**/*.(js|ts|jsx|tsx|json|css|md)": [
+      "npm run format"
+    ]
+  },
+  "allowScripts": {
+    "keytar@7.9.0": true,
+    "@azure/msal-node-extensions@5.3.5": true
+  }
+}