@mcp-consultant-tools/azure-devops-admin 27.0.0-beta.2 → 27.0.0-beta.20

package/build/AzureDevOpsAdminService.js

@@ -2,6 +2,7 @@ import axios from 'axios';
 export class AzureDevOpsAdminService {
     config;
     baseUrl;
+    feedsUrl;
     authHeader;
     apiVersion;
     constructor(config) {
@@ -18,8 +19,11 @@ export class AzureDevOpsAdminService {
             enableAgentPoolDisable: config.enableAgentPoolDisable ?? false,
             enableEnvironmentUpsert: config.enableEnvironmentUpsert ?? false,
             enableEnvironmentDelete: config.enableEnvironmentDelete ?? false,
+            enableClassificationNodeUpsert: config.enableClassificationNodeUpsert ?? false,
+            enableClassificationNodeDelete: config.enableClassificationNodeDelete ?? false,
         };
         this.baseUrl = `https://dev.azure.com/${this.config.organization}`;
+        this.feedsUrl = `https://feeds.dev.azure.com/${this.config.organization}`;
         this.apiVersion = this.config.apiVersion;
         this.authHeader = `Basic ${Buffer.from(`:${this.config.pat}`).toString('base64')}`;
     }
@@ -28,15 +32,38 @@ export class AzureDevOpsAdminService {
             throw new Error(`Project '${project}' is not in the allowed projects list. Allowed projects: ${this.config.projects.join(', ')}`);
         }
     }
-    async makeRequest(endpoint, method = 'GET', data, customHeaders) {
+    validateFeed(feedName) {
+        if (this.config.feeds && this.config.feeds.length > 0
+            && !this.config.feeds.includes(feedName)) {
+            throw new Error(`Feed '${feedName}' is not in the allowed feeds list. ` +
+                `Allowed feeds: ${this.config.feeds.join(', ')}`);
+        }
+    }
+    /**
+     * Converts a date string to ISO 8601 format with time component.
+     * Azure DevOps Classification Nodes API requires full ISO 8601 format.
+     * Input: "2026-02-16" → Output: "2026-02-16T00:00:00Z"
+     */
+    formatDateForAdo(dateStr) {
+        // If already has time component, return as-is
+        if (dateStr.includes('T')) {
+            return dateStr;
+        }
+        // Add time component (midnight UTC)
+        return `${dateStr}T00:00:00Z`;
+    }
+    async makeRequest(endpoint, method = 'GET', data, customHeaders, contentType, baseUrlOverride) {
         try {
-            const url = `${this.baseUrl}/${endpoint}`;
+            const url = `${baseUrlOverride || this.baseUrl}/${endpoint}`;
+            // Determine content type: explicit override > default based on method
+            // Note: Most PATCH endpoints use json-patch+json, but some (like classification nodes) use regular json
+            const defaultContentType = method === 'PATCH' ? 'application/json-patch+json' : 'application/json';
             const response = await axios({
                 method,
                 url,
                 headers: {
                     'Authorization': this.authHeader,
-                    'Content-Type': method === 'PATCH' ? 'application/json-patch+json' : 'application/json',
+                    'Content-Type': contentType || defaultContentType,
                     'Accept': 'application/json',
                     ...customHeaders
                 },
@@ -57,7 +84,8 @@ export class AzureDevOpsAdminService {
                 throw new Error('Azure DevOps authentication failed. Please check your PAT token and permissions.');
             }
             if (error.response?.status === 403) {
-                throw new Error('Azure DevOps access denied. Please check your PAT scopes and project permissions.');
+                const detail = typeof errorDetails === 'string' ? errorDetails : '';
+                throw new Error(`Azure DevOps access denied: ${detail || 'Please check your PAT scopes and project permissions.'}`);
             }
             if (error.response?.status === 404) {
                 throw new Error(`Azure DevOps resource not found: ${endpoint}`);
@@ -320,15 +348,63 @@ export class AzureDevOpsAdminService {
             records: mappedRecords
         };
     }
-    async getBuildLogs(project, buildId, logId) {
+    /**
+     * Filter log content to reduce noise from progress indicators
+     * @param content Raw log content string
+     * @param mode Filter mode: 'summary' removes progress, 'errors' shows only errors, 'full' returns everything
+     */
+    filterLogContent(content, mode) {
+        const lines = content.split('\n');
+        const originalLineCount = lines.length;
+        if (mode === 'full') {
+            return { filtered: content, originalLineCount, filteredLineCount: originalLineCount };
+        }
+        // Progress indicator patterns to remove in summary mode
+        const PROGRESS_PATTERNS = [
+            /remote: Counting objects:\s+\d+%/,
+            /remote: Compressing objects:\s+\d+%/,
+            /Receiving objects:\s+\d+%/,
+            /Resolving deltas:\s+\d+%/,
+            /Unpacking objects:\s+\d+%/,
+            /Updating files:\s+\d+%/,
+        ];
+        // Error/warning patterns for errors mode
+        const ERROR_PATTERNS = [
+            /##\[error\]/i,
+            /##\[warning\]/i,
+            /\berror\b.*:/i,
+            /\bfailed\b/i,
+            /\bexception\b/i,
+            /\bfatal\b/i,
+        ];
+        const filteredLines = lines.filter(line => {
+            // Remove timestamp prefix for pattern matching
+            const trimmedLine = line.replace(/^\d{4}-\d{2}-\d{2}T[\d:.]+Z\s*/, '');
+            if (mode === 'errors') {
+                return ERROR_PATTERNS.some(p => p.test(trimmedLine));
+            }
+            // summary mode: exclude progress indicators, keep everything else
+            return !PROGRESS_PATTERNS.some(p => p.test(trimmedLine));
+        });
+        return {
+            filtered: filteredLines.join('\n'),
+            originalLineCount,
+            filteredLineCount: filteredLines.length
+        };
+    }
+    async getBuildLogs(project, buildId, logId, mode = 'summary') {
         this.validateProject(project);
         if (logId !== undefined) {
             const response = await this.makeRequest(`${project}/_apis/build/builds/${buildId}/logs/${logId}?api-version=${this.apiVersion}`);
+            const { filtered, originalLineCount, filteredLineCount } = this.filterLogContent(response, mode);
             return {
                 buildId,
                 logId,
                 project,
-                content: response
+                mode,
+                originalLineCount,
+                filteredLineCount,
+                content: filtered
             };
         }
         const response = await this.makeRequest(`${project}/_apis/build/builds/${buildId}/logs?api-version=${this.apiVersion}`);
@@ -346,11 +422,46 @@ export class AzureDevOpsAdminService {
             }))
         };
     }
-    async createPipelineDefinition(project, name, repositoryId, yamlPath, folder) {
+    async createPipelineDefinition(project, name, repositoryId, yamlPath, folder, repositoryType = 'TfsGit', repositoryUrl, defaultBranch, serviceConnectionId) {
         this.validateProject(project);
         if (!this.config.enablePipelineUpsert) {
             throw new Error('Pipeline upsert operations are disabled. Set AZUREDEVOPS_ENABLE_PIPELINE_UPSERT=true to enable.');
         }
+        // Validation for external repositories
+        if (repositoryType !== 'TfsGit') {
+            if (!repositoryUrl) {
+                throw new Error(`repositoryUrl is required for ${repositoryType} repositories`);
+            }
+            if (!serviceConnectionId) {
+                throw new Error(`serviceConnectionId is required for ${repositoryType} repositories`);
+            }
+        }
+        // Normalize defaultBranch format
+        const normalizedBranch = defaultBranch
+            ? (defaultBranch.startsWith('refs/heads/') ? defaultBranch : `refs/heads/${defaultBranch}`)
+            : 'refs/heads/main';
+        // Build repository object based on type
+        let repository;
+        if (repositoryType === 'TfsGit') {
+            // Azure Repos - simple format
+            repository = {
+                id: repositoryId,
+                type: 'TfsGit'
+            };
+        }
+        else {
+            // GitHub / GitHubEnterprise - extended format
+            repository = {
+                id: repositoryId,
+                name: repositoryId, // Same as id for GitHub
+                type: repositoryType,
+                url: repositoryUrl,
+                defaultBranch: normalizedBranch,
+                properties: {
+                    connectedServiceId: serviceConnectionId
+                }
+            };
+        }
         const definition = {
             name,
             path: folder || '\\',
@@ -360,10 +471,7 @@ export class AzureDevOpsAdminService {
                 type: 2,
                 yamlFilename: yamlPath
             },
-            repository: {
-                id: repositoryId,
-                type: 'TfsGit'
-            }
+            repository
         };
         const response = await this.makeRequest(`${project}/_apis/build/definitions?api-version=${this.apiVersion}`, 'POST', definition);
         return {
@@ -372,6 +480,7 @@ export class AzureDevOpsAdminService {
             path: response.path,
             revision: response.revision,
             project,
+            repositoryType,
             url: response._links?.web?.href
         };
     }
@@ -463,6 +572,68 @@ export class AzureDevOpsAdminService {
         };
     }
     // ═══════════════════════════════════════════════════════════════════════════════
+    // PIPELINE APPROVAL OPERATIONS
+    // ═══════════════════════════════════════════════════════════════════════════════
+    async listPendingApprovals(project, buildId) {
+        this.validateProject(project);
+        // Step 1: Fetch build timeline to find Checkpoint.Approval records
+        const timeline = await this.makeRequest(`${project}/_apis/build/builds/${buildId}/timeline?api-version=${this.apiVersion}`);
+        const approvalRecords = (timeline.records || []).filter((r) => r.type === 'Checkpoint.Approval');
+        if (approvalRecords.length === 0) {
+            return {
+                project,
+                buildId,
+                totalCount: 0,
+                approvals: [],
+                message: 'No approval checkpoints found for this build'
+            };
+        }
+        // Step 2: Extract approval IDs from record identifiers
+        const approvalIds = approvalRecords.map((r) => r.id);
+        // Step 3: Query the approvals API with those IDs
+        const approvalIdsParam = approvalIds.join(',');
+        const approvalsResponse = await this.makeRequest(`${project}/_apis/pipelines/approvals?approvalIds=${approvalIdsParam}&$expand=steps&api-version=${this.apiVersion}`);
+        const approvals = (approvalsResponse.value || [approvalsResponse]).map((a) => ({
+            id: a.id,
+            status: a.status,
+            createdOn: a.createdOn,
+            executionOrder: a.executionOrder,
+            minRequiredApprovers: a.minRequiredApprovers,
+            instructions: a.instructions,
+            blockedApprovers: a.blockedApprovers,
+            steps: (a.steps || []).map((s) => ({
+                assignedApprover: s.assignedApprover?.displayName,
+                assignedApproverId: s.assignedApprover?.uniqueName,
+                status: s.status,
+                comment: s.comment,
+                initiatedOn: s.initiatedOn,
+                lastModifiedOn: s.lastModifiedOn
+            }))
+        }));
+        return {
+            project,
+            buildId,
+            totalCount: approvals.length,
+            approvals
+        };
+    }
+    async approveStage(project, approvalId, status, comment) {
+        this.validateProject(project);
+        if (!this.config.enablePipelineUpsert) {
+            throw new Error('Pipeline upsert operations are disabled. Set AZUREDEVOPS_ENABLE_PIPELINE_UPSERT=true to enable.');
+        }
+        const body = [{ approvalId, status, comment: comment || '' }];
+        const response = await this.makeRequest(`${project}/_apis/pipelines/approvals?api-version=${this.apiVersion}`, 'PATCH', body, { 'Content-Type': 'application/json' });
+        const result = Array.isArray(response.value) ? response.value[0] : response;
+        return {
+            id: result.id,
+            status: result.status,
+            comment,
+            project,
+            message: `Approval ${approvalId} ${status}`
+        };
+    }
+    // ═══════════════════════════════════════════════════════════════════════════════
     // SERVICE CONNECTION OPERATIONS
     // ═══════════════════════════════════════════════════════════════════════════════
     async listServiceConnections(project) {
@@ -689,7 +860,7 @@ export class AzureDevOpsAdminService {
                     name: name
                 }]
         };
-        const response = await this.makeRequest(`${project}/_apis/distributedtask/variablegroups?api-version=${this.apiVersion}`, 'POST', variableGroup);
+        const response = await this.makeRequest(`_apis/distributedtask/variablegroups?api-version=${this.apiVersion}`, 'POST', variableGroup);
         return {
             id: response.id,
             name: response.name,
@@ -708,7 +879,7 @@ export class AzureDevOpsAdminService {
             name: updates.name || current.name,
             description: updates.description || current.description
         };
-        const response = await this.makeRequest(`${project}/_apis/distributedtask/variablegroups/${groupId}?api-version=${this.apiVersion}`, 'PUT', updated);
+        const response = await this.makeRequest(`_apis/distributedtask/variablegroups/${groupId}?api-version=${this.apiVersion}`, 'PUT', updated);
         return {
             id: response.id,
             name: response.name,
@@ -723,7 +894,7 @@ export class AzureDevOpsAdminService {
         }
         const current = await this.makeRequest(`${project}/_apis/distributedtask/variablegroups/${groupId}?api-version=${this.apiVersion}`);
         current.variables[variableName] = { value, isSecret };
-        const response = await this.makeRequest(`${project}/_apis/distributedtask/variablegroups/${groupId}?api-version=${this.apiVersion}`, 'PUT', current);
+        const response = await this.makeRequest(`_apis/distributedtask/variablegroups/${groupId}?api-version=${this.apiVersion}`, 'PUT', current);
         return {
             id: response.id,
             name: response.name,
@@ -744,7 +915,7 @@ export class AzureDevOpsAdminService {
         else {
             throw new Error(`Variable '${variableName}' not found in group ${groupId}`);
         }
-        const response = await this.makeRequest(`${project}/_apis/distributedtask/variablegroups/${groupId}?api-version=${this.apiVersion}`, 'PUT', current);
+        const response = await this.makeRequest(`_apis/distributedtask/variablegroups/${groupId}?api-version=${this.apiVersion}`, 'PUT', current);
         return {
             id: response.id,
             name: response.name,
@@ -757,7 +928,7 @@ export class AzureDevOpsAdminService {
         if (!this.config.enableVariableGroupDelete) {
             throw new Error('Variable group delete operations are disabled. Set AZUREDEVOPS_ENABLE_VARIABLE_GROUP_DELETE=true to enable.');
         }
-        await this.makeRequest(`${project}/_apis/distributedtask/variablegroups/${groupId}?api-version=${this.apiVersion}`, 'DELETE');
+        await this.makeRequest(`_apis/distributedtask/variablegroups/${groupId}?api-version=${this.apiVersion}`, 'DELETE');
         return {
             groupId,
             project,
@@ -1061,5 +1232,263 @@ export class AzureDevOpsAdminService {
             deleted: true
         };
     }
+    // ═══════════════════════════════════════════════════════════════════════════════
+    // CLASSIFICATION NODE OPERATIONS (Iterations & Areas)
+    // ═══════════════════════════════════════════════════════════════════════════════
+    /**
+     * Flatten classification node hierarchy into a list
+     */
+    flattenClassificationNodes(node, parentPath = '') {
+        const result = [];
+        const currentPath = parentPath ? `${parentPath}\\${node.name}` : node.name;
+        result.push({
+            id: node.id,
+            identifier: node.identifier,
+            name: node.name,
+            path: currentPath,
+            structureType: node.structureType,
+            hasChildren: node.hasChildren || false,
+            attributes: node.attributes || {},
+            url: node.url
+        });
+        if (node.children && Array.isArray(node.children)) {
+            for (const child of node.children) {
+                result.push(...this.flattenClassificationNodes(child, currentPath));
+            }
+        }
+        return result;
+    }
+    async listClassificationNodes(project, structureType, depth = 10) {
+        this.validateProject(project);
+        const response = await this.makeRequest(`${project}/_apis/wit/classificationnodes/${structureType}?$depth=${depth}&api-version=${this.apiVersion}`);
+        const nodes = this.flattenClassificationNodes(response);
+        return {
+            project,
+            structureType,
+            totalCount: nodes.length,
+            nodes: nodes.map((node) => ({
+                id: node.id,
+                identifier: node.identifier,
+                name: node.name,
+                path: node.path,
+                hasChildren: node.hasChildren,
+                ...(structureType === 'iterations' && node.attributes ? {
+                    startDate: node.attributes.startDate,
+                    finishDate: node.attributes.finishDate,
+                    timeFrame: node.attributes.timeFrame
+                } : {})
+            }))
+        };
+    }
+    async getClassificationNode(project, structureType, path) {
+        this.validateProject(project);
+        // Path should be URL encoded and without leading backslash
+        const cleanPath = path.replace(/^\\/, '').replace(/\\/g, '/');
+        const encodedPath = encodeURIComponent(cleanPath).replace(/%2F/g, '/');
+        const response = await this.makeRequest(`${project}/_apis/wit/classificationnodes/${structureType}/${encodedPath}?api-version=${this.apiVersion}`);
+        return {
+            id: response.id,
+            identifier: response.identifier,
+            name: response.name,
+            structureType: response.structureType,
+            hasChildren: response.hasChildren || false,
+            path: response.path,
+            project,
+            ...(structureType === 'iterations' && response.attributes ? {
+                startDate: response.attributes.startDate,
+                finishDate: response.attributes.finishDate,
+                timeFrame: response.attributes.timeFrame
+            } : {}),
+            url: response.url
+        };
+    }
+    async createClassificationNode(project, structureType, name, parentPath, attributes) {
+        this.validateProject(project);
+        if (!this.config.enableClassificationNodeUpsert) {
+            throw new Error('Classification node upsert operations are disabled. Set AZUREDEVOPS_ENABLE_CLASSIFICATION_NODE_UPSERT=true to enable.');
+        }
+        const body = { name };
+        if (structureType === 'iterations' && attributes) {
+            body.attributes = {};
+            // Azure DevOps requires ISO 8601 format with time component
+            if (attributes.startDate)
+                body.attributes.startDate = this.formatDateForAdo(attributes.startDate);
+            if (attributes.finishDate)
+                body.attributes.finishDate = this.formatDateForAdo(attributes.finishDate);
+        }
+        // Build the endpoint - if parentPath is provided, create under that path
+        let endpoint = `${project}/_apis/wit/classificationnodes/${structureType}`;
+        if (parentPath) {
+            const cleanPath = parentPath.replace(/^\\/, '').replace(/\\/g, '/');
+            const encodedPath = encodeURIComponent(cleanPath).replace(/%2F/g, '/');
+            endpoint = `${project}/_apis/wit/classificationnodes/${structureType}/${encodedPath}`;
+        }
+        const response = await this.makeRequest(`${endpoint}?api-version=${this.apiVersion}`, 'POST', body);
+        return {
+            id: response.id,
+            identifier: response.identifier,
+            name: response.name,
+            path: response.path,
+            structureType,
+            project,
+            ...(structureType === 'iterations' && response.attributes ? {
+                startDate: response.attributes.startDate,
+                finishDate: response.attributes.finishDate
+            } : {}),
+            url: response.url
+        };
+    }
+    async addIterationToTeam(project, team, iterationId) {
+        this.validateProject(project);
+        if (!this.config.enableClassificationNodeUpsert) {
+            throw new Error('Classification node upsert operations are disabled. Set AZUREDEVOPS_ENABLE_CLASSIFICATION_NODE_UPSERT=true to enable.');
+        }
+        const encodedTeam = encodeURIComponent(team);
+        const endpoint = `${project}/${encodedTeam}/_apis/work/teamsettings/iterations?api-version=${this.apiVersion}`;
+        const response = await this.makeRequest(endpoint, 'POST', { id: iterationId });
+        return {
+            id: response.id,
+            name: response.name,
+            path: response.path,
+            url: response.url,
+            attributes: response.attributes ? {
+                startDate: response.attributes.startDate,
+                finishDate: response.attributes.finishDate,
+                timeFrame: response.attributes.timeFrame,
+            } : undefined,
+        };
+    }
+    async updateClassificationNode(project, structureType, path, updates) {
+        this.validateProject(project);
+        if (!this.config.enableClassificationNodeUpsert) {
+            throw new Error('Classification node upsert operations are disabled. Set AZUREDEVOPS_ENABLE_CLASSIFICATION_NODE_UPSERT=true to enable.');
+        }
+        const cleanPath = path.replace(/^\\/, '').replace(/\\/g, '/');
+        const encodedPath = encodeURIComponent(cleanPath).replace(/%2F/g, '/');
+        const body = {};
+        if (updates.name)
+            body.name = updates.name;
+        if (structureType === 'iterations') {
+            if (updates.startDate !== undefined || updates.finishDate !== undefined) {
+                body.attributes = {};
+                // Azure DevOps requires ISO 8601 format with time component
+                if (updates.startDate !== undefined)
+                    body.attributes.startDate = this.formatDateForAdo(updates.startDate);
+                if (updates.finishDate !== undefined)
+                    body.attributes.finishDate = this.formatDateForAdo(updates.finishDate);
+            }
+        }
+        // Classification Nodes API uses regular JSON, not JSON Patch format
+        const response = await this.makeRequest(`${project}/_apis/wit/classificationnodes/${structureType}/${encodedPath}?api-version=${this.apiVersion}`, 'PATCH', body, undefined, 'application/json' // Override default json-patch+json content type
+        );
+        return {
+            id: response.id,
+            identifier: response.identifier,
+            name: response.name,
+            path: response.path,
+            structureType,
+            project,
+            ...(structureType === 'iterations' && response.attributes ? {
+                startDate: response.attributes.startDate,
+                finishDate: response.attributes.finishDate
+            } : {}),
+            url: response.url
+        };
+    }
+    async deleteClassificationNode(project, structureType, path, reclassifyId) {
+        this.validateProject(project);
+        if (!this.config.enableClassificationNodeDelete) {
+            throw new Error('Classification node delete operations are disabled. Set AZUREDEVOPS_ENABLE_CLASSIFICATION_NODE_DELETE=true to enable.');
+        }
+        const cleanPath = path.replace(/^\\/, '').replace(/\\/g, '/');
+        const encodedPath = encodeURIComponent(cleanPath).replace(/%2F/g, '/');
+        await this.makeRequest(`${project}/_apis/wit/classificationnodes/${structureType}/${encodedPath}?$reclassifyId=${reclassifyId}&api-version=${this.apiVersion}`, 'DELETE');
+        return {
+            path,
+            structureType,
+            project,
+            reclassifyId,
+            deleted: true
+        };
+    }
+    // ========================================
+    // ARTIFACT FEED METHODS
+    // ========================================
+    async listFeedPackages(feedName, options) {
+        this.validateFeed(feedName);
+        if (options?.project) {
+            this.validateProject(options.project);
+        }
+        const projectPrefix = options?.project ? `${options.project}/` : '';
+        const queryParams = new URLSearchParams();
+        queryParams.append('api-version', this.apiVersion);
+        if (options?.namePrefix)
+            queryParams.append('packageNameQuery', options.namePrefix);
+        if (options?.packageType)
+            queryParams.append('protocolType', options.packageType);
+        if (options?.top)
+            queryParams.append('$top', String(options.top));
+        const endpoint = `${projectPrefix}_apis/packaging/Feeds/${encodeURIComponent(feedName)}/packages?${queryParams.toString()}`;
+        const response = await this.makeRequest(endpoint, 'GET', undefined, undefined, undefined, this.feedsUrl);
+        return {
+            feed: feedName,
+            project: options?.project || '(org-scoped)',
+            totalCount: response.value.length,
+            packages: response.value.map((pkg) => ({
+                id: pkg.id,
+                name: pkg.name,
+                protocolType: pkg.protocolType,
+                latestVersion: pkg.versions?.[0]?.version,
+                publishDate: pkg.versions?.[0]?.publishDate,
+                description: pkg.description,
+            })),
+        };
+    }
+    async getPackageVersions(feedName, packageName, options) {
+        this.validateFeed(feedName);
+        if (options?.project) {
+            this.validateProject(options.project);
+        }
+        // Step 1: Resolve package name → package ID
+        const projectPrefix = options?.project ? `${options.project}/` : '';
+        const listParams = new URLSearchParams();
+        listParams.append('api-version', this.apiVersion);
+        listParams.append('packageNameQuery', packageName);
+        if (options?.packageType)
+            listParams.append('protocolType', options.packageType);
+        const listEndpoint = `${projectPrefix}_apis/packaging/Feeds/${encodeURIComponent(feedName)}/packages?${listParams.toString()}`;
+        const listResponse = await this.makeRequest(listEndpoint, 'GET', undefined, undefined, undefined, this.feedsUrl);
+        const exactMatch = listResponse.value.find((pkg) => pkg.name.toLowerCase() === packageName.toLowerCase());
+        if (!exactMatch) {
+            const available = listResponse.value.map((pkg) => pkg.name).slice(0, 10);
+            throw new Error(`Package '${packageName}' not found in feed '${feedName}'. ` +
+                (available.length > 0
+                    ? `Similar packages: ${available.join(', ')}`
+                    : 'No matching packages found.'));
+        }
+        // Step 2: Get versions for the resolved package ID
+        const versionParams = new URLSearchParams();
+        versionParams.append('api-version', this.apiVersion);
+        if (options?.top)
+            versionParams.append('$top', String(options.top));
+        if (options?.includeDelisted)
+            versionParams.append('includeDelisted', 'true');
+        const versionEndpoint = `${projectPrefix}_apis/packaging/Feeds/${encodeURIComponent(feedName)}/packages/${exactMatch.id}/versions?${versionParams.toString()}`;
+        const versionResponse = await this.makeRequest(versionEndpoint, 'GET', undefined, undefined, undefined, this.feedsUrl);
+        return {
+            feed: feedName,
+            project: options?.project || '(org-scoped)',
+            packageName: exactMatch.name,
+            packageId: exactMatch.id,
+            protocolType: exactMatch.protocolType,
+            versions: versionResponse.value.map((v) => ({
+                version: v.version,
+                publishDate: v.publishDate,
+                isLatest: v.isLatest ?? false,
+                isListed: v.isListed ?? true,
+                description: v.description,
+            })),
+        };
+    }
 }
 //# sourceMappingURL=AzureDevOpsAdminService.js.map