@mcp-consultant-tools/azure-devops 24.0.0 → 25.0.0-beta.4

package/build/AzureDevOpsService.js

@@ -11,7 +11,21 @@ export class AzureDevOpsService {
             apiVersion: config.apiVersion || '7.1',
             enableWorkItemWrite: config.enableWorkItemWrite ?? false,
             enableWorkItemDelete: config.enableWorkItemDelete ?? false,
-            enableWikiWrite: config.enableWikiWrite ?? false
+            enableWikiWrite: config.enableWikiWrite ?? false,
+            // Tier 1: Read-only (master switch)
+            showDevOpsAdminReadonly: config.showDevOpsAdminReadonly ?? false,
+            // Tier 2: Upsert (create + update)
+            enablePipelineUpsert: config.enablePipelineUpsert ?? false,
+            enableServiceConnUpsert: config.enableServiceConnUpsert ?? false,
+            enableVariableGroupUpsert: config.enableVariableGroupUpsert ?? false,
+            enableAgentPoolUpsert: config.enableAgentPoolUpsert ?? false,
+            enableEnvironmentUpsert: config.enableEnvironmentUpsert ?? false,
+            // Tier 3: Delete/Disable (destructive operations)
+            enablePipelineDelete: config.enablePipelineDelete ?? false,
+            enableServiceConnDelete: config.enableServiceConnDelete ?? false,
+            enableVariableGroupDelete: config.enableVariableGroupDelete ?? false,
+            enableAgentPoolDisable: config.enableAgentPoolDisable ?? false,
+            enableEnvironmentDelete: config.enableEnvironmentDelete ?? false,
         };
         this.baseUrl = `https://dev.azure.com/${this.config.organization}`;
         this.searchUrl = `https://almsearch.dev.azure.com/${this.config.organization}`;
@@ -512,11 +526,13 @@ export class AzureDevOpsService {
         this.validateProject(project);
         // Comments API requires -preview suffix (not GA in 7.1)
         const response = await this.makeRequest(`${project}/_apis/wit/workItems/${workItemId}/comments?api-version=7.1-preview`);
+        // Handle case where response.value may be undefined or empty
+        const comments = response.value || [];
         return {
             workItemId,
             project,
-            totalCount: response.totalCount || response.value.length,
-            comments: response.value.map((comment) => ({
+            totalCount: response.totalCount ?? comments.length,
+            comments: comments.map((comment) => ({
                 id: comment.id,
                 text: comment.text,
                 createdBy: comment.createdBy?.displayName,
@@ -713,5 +729,1181 @@ export class AzureDevOpsService {
             }, {})
         };
     }
+    // ═══════════════════════════════════════════════════════════════════════════════
+    // PIPELINE/BUILD OPERATIONS (DevOps Admin Tools)
+    // ═══════════════════════════════════════════════════════════════════════════════
+    /**
+     * List all pipeline definitions in a project
+     * @param project The project name
+     * @returns List of pipeline definitions
+     */
+    async listPipelineDefinitions(project) {
+        this.validateProject(project);
+        const response = await this.makeRequest(`${project}/_apis/build/definitions?api-version=${this.apiVersion}`);
+        return {
+            project,
+            totalCount: response.value.length,
+            pipelines: response.value.map((def) => ({
+                id: def.id,
+                name: def.name,
+                path: def.path,
+                revision: def.revision,
+                type: def.type,
+                queueStatus: def.queueStatus,
+                createdDate: def.createdDate,
+                authoredBy: def.authoredBy?.displayName,
+                repository: def.repository ? {
+                    id: def.repository.id,
+                    name: def.repository.name,
+                    type: def.repository.type
+                } : null,
+                process: def.process ? {
+                    type: def.process.type,
+                    yamlFilename: def.process.yamlFilename
+                } : null,
+                url: def._links?.web?.href
+            }))
+        };
+    }
+    /**
+     * Get a specific pipeline definition with full details
+     * @param project The project name
+     * @param definitionId The pipeline definition ID
+     * @returns Full pipeline definition
+     */
+    async getPipelineDefinition(project, definitionId) {
+        this.validateProject(project);
+        const response = await this.makeRequest(`${project}/_apis/build/definitions/${definitionId}?api-version=${this.apiVersion}`);
+        return {
+            id: response.id,
+            name: response.name,
+            path: response.path,
+            revision: response.revision,
+            type: response.type,
+            queueStatus: response.queueStatus,
+            quality: response.quality,
+            createdDate: response.createdDate,
+            authoredBy: response.authoredBy?.displayName,
+            project: response.project?.name,
+            repository: response.repository ? {
+                id: response.repository.id,
+                name: response.repository.name,
+                type: response.repository.type,
+                defaultBranch: response.repository.defaultBranch,
+                url: response.repository.url
+            } : null,
+            process: response.process ? {
+                type: response.process.type,
+                yamlFilename: response.process.yamlFilename
+            } : null,
+            triggers: response.triggers || [],
+            variables: response.variables ? Object.keys(response.variables).reduce((acc, key) => {
+                const variable = response.variables[key];
+                acc[key] = {
+                    value: variable.isSecret ? '***SECRET***' : variable.value,
+                    isSecret: variable.isSecret || false,
+                    allowOverride: variable.allowOverride || false
+                };
+                return acc;
+            }, {}) : {},
+            queue: response.queue ? {
+                id: response.queue.id,
+                name: response.queue.name,
+                pool: response.queue.pool?.name
+            } : null,
+            url: response._links?.web?.href
+        };
+    }
+    /**
+     * Get the YAML content for a pipeline definition
+     * @param project The project name
+     * @param definitionId The pipeline definition ID
+     * @returns YAML content or location info for external repos
+     */
+    async getPipelineYaml(project, definitionId) {
+        this.validateProject(project);
+        // First get the pipeline definition to check repo type
+        const definition = await this.getPipelineDefinition(project, definitionId);
+        // If external repo (GitHub, Bitbucket, etc.), return helpful info instead of failing
+        if (definition.repository?.type && definition.repository.type !== 'TfsGit') {
+            return {
+                definitionId,
+                project,
+                pipelineName: definition.name,
+                yamlLocation: 'external',
+                repositoryType: definition.repository.type,
+                repositoryName: definition.repository.name,
+                repositoryUrl: definition.repository.url,
+                defaultBranch: definition.repository.defaultBranch,
+                yamlFilename: definition.process?.yamlFilename,
+                message: `YAML is stored in external ${definition.repository.type} repository. ` +
+                    `To view the YAML content, access the file "${definition.process?.yamlFilename}" ` +
+                    `at ${definition.repository.url}`
+            };
+        }
+        // For Azure Repos (TfsGit), fetch YAML content directly
+        const response = await this.makeRequest(`${project}/_apis/build/definitions/${definitionId}/yaml?api-version=${this.apiVersion}`);
+        return {
+            definitionId,
+            project,
+            pipelineName: definition.name,
+            yamlLocation: 'azureRepos',
+            yaml: response.yaml || response
+        };
+    }
+    /**
+     * List recent pipeline runs for a definition
+     * @param project The project name
+     * @param definitionId The pipeline definition ID
+     * @param top Maximum number of results (default: 10)
+     * @returns List of builds/runs
+     */
+    async listPipelineRuns(project, definitionId, top = 10) {
+        this.validateProject(project);
+        const response = await this.makeRequest(`${project}/_apis/build/builds?definitions=${definitionId}&$top=${top}&api-version=${this.apiVersion}`);
+        return {
+            project,
+            definitionId,
+            totalCount: response.value.length,
+            builds: response.value.map((build) => ({
+                id: build.id,
+                buildNumber: build.buildNumber,
+                status: build.status,
+                result: build.result,
+                queueTime: build.queueTime,
+                startTime: build.startTime,
+                finishTime: build.finishTime,
+                sourceBranch: build.sourceBranch,
+                sourceVersion: build.sourceVersion,
+                requestedBy: build.requestedBy?.displayName,
+                requestedFor: build.requestedFor?.displayName,
+                reason: build.reason,
+                priority: build.priority,
+                url: build._links?.web?.href
+            }))
+        };
+    }
+    /**
+     * Get build status and details
+     * @param project The project name
+     * @param buildId The build ID
+     * @param detail Level of detail: "summary" | "timeline" | "full"
+     * @returns Build details
+     */
+    async getBuildStatus(project, buildId, detail = 'summary') {
+        this.validateProject(project);
+        const response = await this.makeRequest(`${project}/_apis/build/builds/${buildId}?api-version=${this.apiVersion}`);
+        const result = {
+            id: response.id,
+            buildNumber: response.buildNumber,
+            status: response.status,
+            result: response.result,
+            queueTime: response.queueTime,
+            startTime: response.startTime,
+            finishTime: response.finishTime,
+            sourceBranch: response.sourceBranch,
+            sourceVersion: response.sourceVersion,
+            definition: response.definition ? {
+                id: response.definition.id,
+                name: response.definition.name
+            } : null,
+            requestedBy: response.requestedBy?.displayName,
+            requestedFor: response.requestedFor?.displayName,
+            reason: response.reason,
+            priority: response.priority,
+            project: response.project?.name,
+            url: response._links?.web?.href
+        };
+        // Add timeline if requested
+        if (detail === 'timeline' || detail === 'full') {
+            const timeline = await this.getBuildTimeline(project, buildId);
+            result.timeline = timeline;
+        }
+        // Add logs if full detail requested
+        if (detail === 'full') {
+            const logs = await this.getBuildLogs(project, buildId);
+            result.logs = logs;
+        }
+        return result;
+    }
+    /**
+     * Get build timeline (step-by-step breakdown)
+     * @param project The project name
+     * @param buildId The build ID
+     * @returns Build timeline with records
+     */
+    async getBuildTimeline(project, buildId) {
+        this.validateProject(project);
+        const response = await this.makeRequest(`${project}/_apis/build/builds/${buildId}/timeline?api-version=${this.apiVersion}`);
+        return {
+            buildId,
+            project,
+            changeId: response.changeId,
+            lastChangedBy: response.lastChangedBy,
+            lastChangedOn: response.lastChangedOn,
+            records: (response.records || []).map((record) => ({
+                id: record.id,
+                parentId: record.parentId,
+                type: record.type,
+                name: record.name,
+                state: record.state,
+                result: record.result,
+                startTime: record.startTime,
+                finishTime: record.finishTime,
+                order: record.order,
+                errorCount: record.errorCount,
+                warningCount: record.warningCount,
+                log: record.log ? { id: record.log.id, url: record.log.url } : null,
+                issues: record.issues || []
+            }))
+        };
+    }
+    /**
+     * Get build logs
+     * @param project The project name
+     * @param buildId The build ID
+     * @param logId Optional specific log ID
+     * @returns Build logs
+     */
+    async getBuildLogs(project, buildId, logId) {
+        this.validateProject(project);
+        if (logId !== undefined) {
+            // Get specific log content
+            const response = await this.makeRequest(`${project}/_apis/build/builds/${buildId}/logs/${logId}?api-version=${this.apiVersion}`);
+            return {
+                buildId,
+                logId,
+                project,
+                content: response
+            };
+        }
+        // Get list of all logs
+        const response = await this.makeRequest(`${project}/_apis/build/builds/${buildId}/logs?api-version=${this.apiVersion}`);
+        return {
+            buildId,
+            project,
+            totalCount: response.value.length,
+            logs: response.value.map((log) => ({
+                id: log.id,
+                type: log.type,
+                lineCount: log.lineCount,
+                createdOn: log.createdOn,
+                lastChangedOn: log.lastChangedOn,
+                url: log.url
+            }))
+        };
+    }
+    /**
+     * Create a new pipeline definition
+     * @param project The project name
+     * @param name Pipeline name
+     * @param repositoryId Repository ID
+     * @param yamlPath Path to YAML file in repository
+     * @param folder Optional folder path
+     * @returns Created pipeline definition
+     */
+    async createPipelineDefinition(project, name, repositoryId, yamlPath, folder) {
+        this.validateProject(project);
+        if (!this.config.enablePipelineUpsert) {
+            throw new Error('Pipeline upsert operations are disabled. Set AZUREDEVOPS_ENABLE_PIPELINE_UPSERT=true to enable.');
+        }
+        const definition = {
+            name,
+            path: folder || '\\',
+            type: 'build',
+            queueStatus: 'enabled',
+            process: {
+                type: 2, // YAML process type
+                yamlFilename: yamlPath
+            },
+            repository: {
+                id: repositoryId,
+                type: 'TfsGit'
+            }
+        };
+        const response = await this.makeRequest(`${project}/_apis/build/definitions?api-version=${this.apiVersion}`, 'POST', definition);
+        return {
+            id: response.id,
+            name: response.name,
+            path: response.path,
+            revision: response.revision,
+            project,
+            url: response._links?.web?.href
+        };
+    }
+    /**
+     * Update a pipeline definition
+     * @param project The project name
+     * @param definitionId The pipeline definition ID
+     * @param updates Object with updated properties
+     * @returns Updated pipeline definition
+     */
+    async updatePipelineDefinition(project, definitionId, updates) {
+        this.validateProject(project);
+        if (!this.config.enablePipelineUpsert) {
+            throw new Error('Pipeline upsert operations are disabled. Set AZUREDEVOPS_ENABLE_PIPELINE_UPSERT=true to enable.');
+        }
+        // Get current definition first
+        const current = await this.makeRequest(`${project}/_apis/build/definitions/${definitionId}?api-version=${this.apiVersion}`);
+        // Merge updates
+        const updated = {
+            ...current,
+            ...updates,
+            revision: current.revision // Must include current revision
+        };
+        const response = await this.makeRequest(`${project}/_apis/build/definitions/${definitionId}?api-version=${this.apiVersion}`, 'PUT', updated);
+        return {
+            id: response.id,
+            name: response.name,
+            path: response.path,
+            revision: response.revision,
+            project,
+            url: response._links?.web?.href
+        };
+    }
+    /**
+     * Rename a pipeline definition
+     * @param project The project name
+     * @param definitionId The pipeline definition ID
+     * @param newName The new name
+     * @returns Updated pipeline definition
+     */
+    async renamePipelineDefinition(project, definitionId, newName) {
+        return this.updatePipelineDefinition(project, definitionId, { name: newName });
+    }
+    /**
+     * Queue a new build
+     * @param project The project name
+     * @param definitionId The pipeline definition ID
+     * @param branch Optional source branch
+     * @param variables Optional variables to pass
+     * @param parameters Optional pipeline parameters
+     * @returns Queued build
+     */
+    async queueBuild(project, definitionId, branch, variables, parameters) {
+        this.validateProject(project);
+        if (!this.config.enablePipelineUpsert) {
+            throw new Error('Pipeline upsert operations are disabled. Set AZUREDEVOPS_ENABLE_PIPELINE_UPSERT=true to enable.');
+        }
+        const buildRequest = {
+            definition: { id: definitionId }
+        };
+        if (branch) {
+            buildRequest.sourceBranch = branch;
+        }
+        if (variables) {
+            buildRequest.parameters = JSON.stringify(variables);
+        }
+        if (parameters) {
+            buildRequest.templateParameters = parameters;
+        }
+        const response = await this.makeRequest(`${project}/_apis/build/builds?api-version=${this.apiVersion}`, 'POST', buildRequest);
+        return {
+            id: response.id,
+            buildNumber: response.buildNumber,
+            status: response.status,
+            queueTime: response.queueTime,
+            definition: response.definition?.name,
+            sourceBranch: response.sourceBranch,
+            project,
+            url: response._links?.web?.href
+        };
+    }
+    /**
+     * Cancel a running build
+     * @param project The project name
+     * @param buildId The build ID
+     * @returns Cancelled build
+     */
+    async cancelBuild(project, buildId) {
+        this.validateProject(project);
+        if (!this.config.enablePipelineUpsert) {
+            throw new Error('Pipeline upsert operations are disabled. Set AZUREDEVOPS_ENABLE_PIPELINE_UPSERT=true to enable.');
+        }
+        const response = await this.makeRequest(`${project}/_apis/build/builds/${buildId}?api-version=${this.apiVersion}`, 'PATCH', { status: 'cancelling' });
+        return {
+            id: response.id,
+            buildNumber: response.buildNumber,
+            status: response.status,
+            project,
+            message: 'Build cancellation requested'
+        };
+    }
+    /**
+     * Retry a failed build
+     * @param project The project name
+     * @param buildId The build ID to retry
+     * @returns New build
+     */
+    async retryBuild(project, buildId) {
+        this.validateProject(project);
+        if (!this.config.enablePipelineUpsert) {
+            throw new Error('Pipeline upsert operations are disabled. Set AZUREDEVOPS_ENABLE_PIPELINE_UPSERT=true to enable.');
+        }
+        // Get the original build to get definition and source info
+        const original = await this.makeRequest(`${project}/_apis/build/builds/${buildId}?api-version=${this.apiVersion}`);
+        // Queue a new build with the same parameters
+        return this.queueBuild(project, original.definition.id, original.sourceBranch);
+    }
+    /**
+     * Delete a pipeline definition
+     * @param project The project name
+     * @param definitionId The pipeline definition ID
+     * @returns Deletion confirmation
+     */
+    async deletePipelineDefinition(project, definitionId) {
+        this.validateProject(project);
+        if (!this.config.enablePipelineDelete) {
+            throw new Error('Pipeline delete operations are disabled. Set AZUREDEVOPS_ENABLE_PIPELINE_DELETE=true to enable.');
+        }
+        await this.makeRequest(`${project}/_apis/build/definitions/${definitionId}?api-version=${this.apiVersion}`, 'DELETE');
+        return {
+            definitionId,
+            project,
+            deleted: true
+        };
+    }
+    // ═══════════════════════════════════════════════════════════════════════════════
+    // SERVICE CONNECTION OPERATIONS (DevOps Admin Tools)
+    // ═══════════════════════════════════════════════════════════════════════════════
+    /**
+     * List all service connections in a project
+     * @param project The project name
+     * @returns List of service connections
+     */
+    async listServiceConnections(project) {
+        this.validateProject(project);
+        const response = await this.makeRequest(`${project}/_apis/serviceendpoint/endpoints?api-version=${this.apiVersion}`);
+        return {
+            project,
+            totalCount: response.value.length,
+            serviceConnections: response.value.map((conn) => ({
+                id: conn.id,
+                name: conn.name,
+                type: conn.type,
+                url: conn.url,
+                description: conn.description,
+                isShared: conn.isShared,
+                isReady: conn.isReady,
+                owner: conn.owner,
+                createdBy: conn.createdBy?.displayName,
+                authorization: conn.authorization ? {
+                    scheme: conn.authorization.scheme,
+                    // Mask any sensitive parameters
+                    parameters: conn.authorization.parameters ?
+                        Object.keys(conn.authorization.parameters).reduce((acc, key) => {
+                            acc[key] = key.toLowerCase().includes('password') ||
+                                key.toLowerCase().includes('secret') ||
+                                key.toLowerCase().includes('key') ||
+                                key.toLowerCase().includes('token')
+                                ? '***SECRET***'
+                                : conn.authorization.parameters[key];
+                            return acc;
+                        }, {}) : {}
+                } : null
+            }))
+        };
+    }
+    /**
+     * Get a specific service connection
+     * @param project The project name
+     * @param connectionId The service connection ID
+     * @returns Service connection details
+     */
+    async getServiceConnection(project, connectionId) {
+        this.validateProject(project);
+        const response = await this.makeRequest(`${project}/_apis/serviceendpoint/endpoints/${connectionId}?api-version=${this.apiVersion}`);
+        return {
+            id: response.id,
+            name: response.name,
+            type: response.type,
+            url: response.url,
+            description: response.description,
+            isShared: response.isShared,
+            isReady: response.isReady,
+            owner: response.owner,
+            createdBy: response.createdBy?.displayName,
+            project,
+            authorization: response.authorization ? {
+                scheme: response.authorization.scheme,
+                // Mask any sensitive parameters
+                parameters: response.authorization.parameters ?
+                    Object.keys(response.authorization.parameters).reduce((acc, key) => {
+                        acc[key] = key.toLowerCase().includes('password') ||
+                            key.toLowerCase().includes('secret') ||
+                            key.toLowerCase().includes('key') ||
+                            key.toLowerCase().includes('token')
+                            ? '***SECRET***'
+                            : response.authorization.parameters[key];
+                        return acc;
+                    }, {}) : {}
+            } : null,
+            data: response.data || {},
+            serviceEndpointProjectReferences: response.serviceEndpointProjectReferences
+        };
+    }
+    /**
+     * Get available service connection types
+     * @returns List of service connection types
+     */
+    async getServiceConnectionTypes() {
+        const response = await this.makeRequest(`_apis/serviceendpoint/types?api-version=${this.apiVersion}`);
+        return {
+            totalCount: response.value.length,
+            types: response.value.map((type) => ({
+                name: type.name,
+                displayName: type.displayName,
+                description: type.description,
+                helpMarkDown: type.helpMarkDown,
+                authenticationSchemes: type.authenticationSchemes?.map((scheme) => ({
+                    scheme: scheme.scheme,
+                    displayName: scheme.displayName
+                })) || []
+            }))
+        };
+    }
+    /**
+     * Create a new service connection
+     * @param project The project name
+     * @param name Connection name
+     * @param type Connection type
+     * @param configuration Type-specific configuration
+     * @returns Created service connection
+     */
+    async createServiceConnection(project, name, type, configuration) {
+        this.validateProject(project);
+        if (!this.config.enableServiceConnUpsert) {
+            throw new Error('Service connection upsert operations are disabled. Set AZUREDEVOPS_ENABLE_SERVICE_CONN_UPSERT=true to enable.');
+        }
+        const endpoint = {
+            name,
+            type,
+            url: configuration.url || '',
+            description: configuration.description || '',
+            authorization: configuration.authorization,
+            data: configuration.data || {},
+            isShared: false,
+            isReady: true
+        };
+        const response = await this.makeRequest(`${project}/_apis/serviceendpoint/endpoints?api-version=${this.apiVersion}`, 'POST', endpoint);
+        return {
+            id: response.id,
+            name: response.name,
+            type: response.type,
+            isReady: response.isReady,
+            project
+        };
+    }
+    /**
+     * Update a service connection
+     * @param project The project name
+     * @param connectionId The service connection ID
+     * @param updates Updated properties (not credentials)
+     * @returns Updated service connection
+     */
+    async updateServiceConnection(project, connectionId, updates) {
+        this.validateProject(project);
+        if (!this.config.enableServiceConnUpsert) {
+            throw new Error('Service connection upsert operations are disabled. Set AZUREDEVOPS_ENABLE_SERVICE_CONN_UPSERT=true to enable.');
+        }
+        // Get current connection first
+        const current = await this.makeRequest(`${project}/_apis/serviceendpoint/endpoints/${connectionId}?api-version=${this.apiVersion}`);
+        // Merge updates (but don't allow overwriting authorization for security)
+        const updated = {
+            ...current,
+            name: updates.name || current.name,
+            description: updates.description || current.description,
+            url: updates.url || current.url,
+            data: updates.data ? { ...current.data, ...updates.data } : current.data
+        };
+        const response = await this.makeRequest(`${project}/_apis/serviceendpoint/endpoints/${connectionId}?api-version=${this.apiVersion}`, 'PUT', updated);
+        return {
+            id: response.id,
+            name: response.name,
+            type: response.type,
+            isReady: response.isReady,
+            project
+        };
+    }
+    /**
+     * Share a service connection across projects
+     * @param connectionId The service connection ID
+     * @param projectIds Array of project IDs to share with
+     * @returns Updated service connection
+     */
+    async shareServiceConnection(connectionId, projectIds) {
+        if (!this.config.enableServiceConnUpsert) {
+            throw new Error('Service connection upsert operations are disabled. Set AZUREDEVOPS_ENABLE_SERVICE_CONN_UPSERT=true to enable.');
+        }
+        // This requires fetching the current endpoint and updating its project references
+        // Note: This is a simplified implementation - full implementation would need project name lookup
+        const shareRequest = projectIds.map(projectId => ({
+            projectReference: { id: projectId },
+            name: '' // Will be set by API
+        }));
+        const response = await this.makeRequest(`_apis/serviceendpoint/endpoints/${connectionId}?api-version=${this.apiVersion}`, 'PATCH', { serviceEndpointProjectReferences: shareRequest });
+        return {
+            id: response.id,
+            name: response.name,
+            sharedWith: projectIds
+        };
+    }
+    /**
+     * Delete a service connection
+     * @param project The project name
+     * @param connectionId The service connection ID
+     * @returns Deletion confirmation
+     */
+    async deleteServiceConnection(project, connectionId) {
+        this.validateProject(project);
+        if (!this.config.enableServiceConnDelete) {
+            throw new Error('Service connection delete operations are disabled. Set AZUREDEVOPS_ENABLE_SERVICE_CONN_DELETE=true to enable.');
+        }
+        await this.makeRequest(`${project}/_apis/serviceendpoint/endpoints/${connectionId}?api-version=${this.apiVersion}`, 'DELETE');
+        return {
+            connectionId,
+            project,
+            deleted: true
+        };
+    }
+    // ═══════════════════════════════════════════════════════════════════════════════
+    // VARIABLE GROUP UPSERT/DELETE OPERATIONS (DevOps Admin Tools)
+    // ═══════════════════════════════════════════════════════════════════════════════
+    /**
+     * Create a new variable group
+     * @param project The project name
+     * @param name Variable group name
+     * @param description Optional description
+     * @param variables Initial variables
+     * @returns Created variable group
+     */
+    async createVariableGroup(project, name, description, variables) {
+        this.validateProject(project);
+        if (!this.config.enableVariableGroupUpsert) {
+            throw new Error('Variable group upsert operations are disabled. Set AZUREDEVOPS_ENABLE_VARIABLE_GROUP_UPSERT=true to enable.');
+        }
+        const variableGroup = {
+            name,
+            description: description || '',
+            type: 'Vsts',
+            variables: variables || {},
+            variableGroupProjectReferences: [{
+                    projectReference: { name: project },
+                    name: name
+                }]
+        };
+        const response = await this.makeRequest(`${project}/_apis/distributedtask/variablegroups?api-version=${this.apiVersion}`, 'POST', variableGroup);
+        return {
+            id: response.id,
+            name: response.name,
+            project,
+            variableCount: Object.keys(response.variables || {}).length
+        };
+    }
+    /**
+     * Update a variable group's metadata
+     * @param project The project name
+     * @param groupId The variable group ID
+     * @param updates Updated properties
+     * @returns Updated variable group
+     */
+    async updateVariableGroupMetadata(project, groupId, updates) {
+        this.validateProject(project);
+        if (!this.config.enableVariableGroupUpsert) {
+            throw new Error('Variable group upsert operations are disabled. Set AZUREDEVOPS_ENABLE_VARIABLE_GROUP_UPSERT=true to enable.');
+        }
+        // Get current group first
+        const current = await this.makeRequest(`${project}/_apis/distributedtask/variablegroups/${groupId}?api-version=${this.apiVersion}`);
+        const updated = {
+            ...current,
+            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);
+        return {
+            id: response.id,
+            name: response.name,
+            description: response.description,
+            project
+        };
+    }
+    /**
+     * Set or update a variable in a variable group
+     * @param project The project name
+     * @param groupId The variable group ID
+     * @param variableName Variable name
+     * @param value Variable value
+     * @param isSecret Whether the variable is secret
+     * @returns Updated variable group
+     */
+    async setVariable(project, groupId, variableName, value, isSecret = false) {
+        this.validateProject(project);
+        if (!this.config.enableVariableGroupUpsert) {
+            throw new Error('Variable group upsert operations are disabled. Set AZUREDEVOPS_ENABLE_VARIABLE_GROUP_UPSERT=true to enable.');
+        }
+        // Get current group first
+        const current = await this.makeRequest(`${project}/_apis/distributedtask/variablegroups/${groupId}?api-version=${this.apiVersion}`);
+        // Update the variable
+        current.variables[variableName] = { value, isSecret };
+        const response = await this.makeRequest(`${project}/_apis/distributedtask/variablegroups/${groupId}?api-version=${this.apiVersion}`, 'PUT', current);
+        return {
+            id: response.id,
+            name: response.name,
+            project,
+            variableSet: variableName,
+            isSecret
+        };
+    }
+    /**
+     * Remove a variable from a variable group
+     * @param project The project name
+     * @param groupId The variable group ID
+     * @param variableName Variable name to remove
+     * @returns Updated variable group
+     */
+    async removeVariable(project, groupId, variableName) {
+        this.validateProject(project);
+        if (!this.config.enableVariableGroupDelete) {
+            throw new Error('Variable group delete operations are disabled. Set AZUREDEVOPS_ENABLE_VARIABLE_GROUP_DELETE=true to enable.');
+        }
+        // Get current group first
+        const current = await this.makeRequest(`${project}/_apis/distributedtask/variablegroups/${groupId}?api-version=${this.apiVersion}`);
+        // Remove the variable
+        if (current.variables[variableName]) {
+            delete current.variables[variableName];
+        }
+        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);
+        return {
+            id: response.id,
+            name: response.name,
+            project,
+            variableRemoved: variableName
+        };
+    }
+    /**
+     * Delete a variable group
+     * @param project The project name
+     * @param groupId The variable group ID
+     * @returns Deletion confirmation
+     */
+    async deleteVariableGroup(project, groupId) {
+        this.validateProject(project);
+        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');
+        return {
+            groupId,
+            project,
+            deleted: true
+        };
+    }
+    // ═══════════════════════════════════════════════════════════════════════════════
+    // AGENT POOL OPERATIONS (DevOps Admin Tools)
+    // ═══════════════════════════════════════════════════════════════════════════════
+    /**
+     * List all agent pools
+     * @param poolType Optional filter: "automation" or "deployment"
+     * @returns List of agent pools
+     */
+    async listAgentPools(poolType) {
+        let url = `_apis/distributedtask/pools?api-version=${this.apiVersion}`;
+        if (poolType) {
+            url += `&poolType=${poolType}`;
+        }
+        const response = await this.makeRequest(url);
+        return {
+            totalCount: response.value.length,
+            pools: response.value.map((pool) => ({
+                id: pool.id,
+                name: pool.name,
+                size: pool.size,
+                isHosted: pool.isHosted,
+                poolType: pool.poolType,
+                createdBy: pool.createdBy?.displayName,
+                createdOn: pool.createdOn,
+                autoProvision: pool.autoProvision,
+                autoUpdate: pool.autoUpdate,
+                autoSize: pool.autoSize,
+                targetSize: pool.targetSize
+            }))
+        };
+    }
+    /**
+     * Get a specific agent pool
+     * @param poolId The pool ID
+     * @returns Agent pool details
+     */
+    async getAgentPool(poolId) {
+        const response = await this.makeRequest(`_apis/distributedtask/pools/${poolId}?api-version=${this.apiVersion}`);
+        return {
+            id: response.id,
+            name: response.name,
+            size: response.size,
+            isHosted: response.isHosted,
+            poolType: response.poolType,
+            createdBy: response.createdBy?.displayName,
+            createdOn: response.createdOn,
+            autoProvision: response.autoProvision,
+            autoUpdate: response.autoUpdate,
+            autoSize: response.autoSize,
+            targetSize: response.targetSize,
+            owner: response.owner?.displayName,
+            agentCloudId: response.agentCloudId,
+            properties: response.properties
+        };
+    }
+    /**
+     * List agents in a pool
+     * @param poolId The pool ID
+     * @param includeCapabilities Include agent capabilities
+     * @returns List of agents
+     */
+    async listAgents(poolId, includeCapabilities = false) {
+        const response = await this.makeRequest(`_apis/distributedtask/pools/${poolId}/agents?includeCapabilities=${includeCapabilities}&api-version=${this.apiVersion}`);
+        return {
+            poolId,
+            totalCount: response.value.length,
+            agents: response.value.map((agent) => ({
+                id: agent.id,
+                name: agent.name,
+                version: agent.version,
+                osDescription: agent.osDescription,
+                enabled: agent.enabled,
+                status: agent.status,
+                provisioningState: agent.provisioningState,
+                createdOn: agent.createdOn,
+                maxParallelism: agent.maxParallelism,
+                systemCapabilities: includeCapabilities ? agent.systemCapabilities : undefined,
+                userCapabilities: includeCapabilities ? agent.userCapabilities : undefined
+            }))
+        };
+    }
+    /**
+     * Get a specific agent
+     * @param poolId The pool ID
+     * @param agentId The agent ID
+     * @returns Agent details
+     */
+    async getAgent(poolId, agentId) {
+        const response = await this.makeRequest(`_apis/distributedtask/pools/${poolId}/agents/${agentId}?includeCapabilities=true&api-version=${this.apiVersion}`);
+        return {
+            id: response.id,
+            name: response.name,
+            version: response.version,
+            osDescription: response.osDescription,
+            enabled: response.enabled,
+            status: response.status,
+            provisioningState: response.provisioningState,
+            accessPoint: response.accessPoint,
+            createdOn: response.createdOn,
+            maxParallelism: response.maxParallelism,
+            systemCapabilities: response.systemCapabilities,
+            userCapabilities: response.userCapabilities,
+            assignedRequest: response.assignedRequest,
+            lastCompletedRequest: response.lastCompletedRequest
+        };
+    }
+    /**
+     * Update an agent pool
+     * @param poolId The pool ID
+     * @param updates Updated settings
+     * @returns Updated agent pool
+     */
+    async updateAgentPool(poolId, updates) {
+        if (!this.config.enableAgentPoolUpsert) {
+            throw new Error('Agent pool upsert operations are disabled. Set AZUREDEVOPS_ENABLE_AGENT_POOL_UPSERT=true to enable.');
+        }
+        const response = await this.makeRequest(`_apis/distributedtask/pools/${poolId}?api-version=${this.apiVersion}`, 'PATCH', updates);
+        return {
+            id: response.id,
+            name: response.name,
+            autoProvision: response.autoProvision,
+            autoUpdate: response.autoUpdate,
+            autoSize: response.autoSize,
+            targetSize: response.targetSize
+        };
+    }
+    /**
+     * Enable a disabled agent
+     * @param poolId The pool ID
+     * @param agentId The agent ID
+     * @returns Updated agent
+     */
+    async enableAgent(poolId, agentId) {
+        if (!this.config.enableAgentPoolUpsert) {
+            throw new Error('Agent pool upsert operations are disabled. Set AZUREDEVOPS_ENABLE_AGENT_POOL_UPSERT=true to enable.');
+        }
+        const response = await this.makeRequest(`_apis/distributedtask/pools/${poolId}/agents/${agentId}?api-version=${this.apiVersion}`, 'PATCH', { enabled: true });
+        return {
+            id: response.id,
+            name: response.name,
+            enabled: response.enabled,
+            status: response.status
+        };
+    }
+    /**
+     * Disable an agent
+     * @param poolId The pool ID
+     * @param agentId The agent ID
+     * @returns Updated agent
+     */
+    async disableAgent(poolId, agentId) {
+        if (!this.config.enableAgentPoolDisable) {
+            throw new Error('Agent pool disable operations are disabled. Set AZUREDEVOPS_ENABLE_AGENT_POOL_DISABLE=true to enable.');
+        }
+        const response = await this.makeRequest(`_apis/distributedtask/pools/${poolId}/agents/${agentId}?api-version=${this.apiVersion}`, 'PATCH', { enabled: false });
+        return {
+            id: response.id,
+            name: response.name,
+            enabled: response.enabled,
+            status: response.status,
+            message: 'Agent disabled - will complete current job then stop accepting new jobs'
+        };
+    }
+    // ═══════════════════════════════════════════════════════════════════════════════
+    // ENVIRONMENT OPERATIONS (DevOps Admin Tools)
+    // ═══════════════════════════════════════════════════════════════════════════════
+    /**
+     * List all environments in a project
+     * @param project The project name
+     * @returns List of environments
+     */
+    async listEnvironments(project) {
+        this.validateProject(project);
+        const response = await this.makeRequest(`${project}/_apis/distributedtask/environments?api-version=${this.apiVersion}`);
+        return {
+            project,
+            totalCount: response.value.length,
+            environments: response.value.map((env) => ({
+                id: env.id,
+                name: env.name,
+                description: env.description,
+                createdBy: env.createdBy?.displayName,
+                createdOn: env.createdOn,
+                lastModifiedBy: env.lastModifiedBy?.displayName,
+                lastModifiedOn: env.lastModifiedOn
+            }))
+        };
+    }
+    /**
+     * Get a specific environment
+     * @param project The project name
+     * @param environmentId The environment ID
+     * @returns Environment details
+     */
+    async getEnvironment(project, environmentId) {
+        this.validateProject(project);
+        const response = await this.makeRequest(`${project}/_apis/distributedtask/environments/${environmentId}?expands=resourceReferences&api-version=${this.apiVersion}`);
+        return {
+            id: response.id,
+            name: response.name,
+            description: response.description,
+            createdBy: response.createdBy?.displayName,
+            createdOn: response.createdOn,
+            lastModifiedBy: response.lastModifiedBy?.displayName,
+            lastModifiedOn: response.lastModifiedOn,
+            project,
+            resources: response.resources || []
+        };
+    }
+    /**
+     * Get deployment history for an environment
+     * @param project The project name
+     * @param environmentId The environment ID
+     * @param top Maximum number of results
+     * @returns Deployment records
+     */
+    async getEnvironmentDeployments(project, environmentId, top = 10) {
+        this.validateProject(project);
+        const response = await this.makeRequest(`${project}/_apis/distributedtask/environments/${environmentId}/environmentdeploymentrecords?top=${top}&api-version=${this.apiVersion}`);
+        return {
+            project,
+            environmentId,
+            totalCount: response.value.length,
+            deployments: response.value.map((dep) => ({
+                id: dep.id,
+                environmentId: dep.environmentId,
+                definition: dep.definition ? {
+                    id: dep.definition.id,
+                    name: dep.definition.name
+                } : null,
+                owner: dep.owner?.displayName,
+                planType: dep.planType,
+                startTime: dep.startTime,
+                finishTime: dep.finishTime,
+                result: dep.result,
+                queueTime: dep.queueTime
+            }))
+        };
+    }
+    /**
+     * Create a new environment
+     * @param project The project name
+     * @param name Environment name
+     * @param description Optional description
+     * @returns Created environment
+     */
+    async createEnvironment(project, name, description) {
+        this.validateProject(project);
+        if (!this.config.enableEnvironmentUpsert) {
+            throw new Error('Environment upsert operations are disabled. Set AZUREDEVOPS_ENABLE_ENVIRONMENT_UPSERT=true to enable.');
+        }
+        const environment = {
+            name,
+            description: description || ''
+        };
+        const response = await this.makeRequest(`${project}/_apis/distributedtask/environments?api-version=${this.apiVersion}`, 'POST', environment);
+        return {
+            id: response.id,
+            name: response.name,
+            description: response.description,
+            project
+        };
+    }
+    /**
+     * Update an environment
+     * @param project The project name
+     * @param environmentId The environment ID
+     * @param updates Updated properties
+     * @returns Updated environment
+     */
+    async updateEnvironment(project, environmentId, updates) {
+        this.validateProject(project);
+        if (!this.config.enableEnvironmentUpsert) {
+            throw new Error('Environment upsert operations are disabled. Set AZUREDEVOPS_ENABLE_ENVIRONMENT_UPSERT=true to enable.');
+        }
+        const response = await this.makeRequest(`${project}/_apis/distributedtask/environments/${environmentId}?api-version=${this.apiVersion}`, 'PATCH', updates);
+        return {
+            id: response.id,
+            name: response.name,
+            description: response.description,
+            project
+        };
+    }
+    /**
+     * Delete an environment
+     * @param project The project name
+     * @param environmentId The environment ID
+     * @returns Deletion confirmation
+     */
+    async deleteEnvironment(project, environmentId) {
+        this.validateProject(project);
+        if (!this.config.enableEnvironmentDelete) {
+            throw new Error('Environment delete operations are disabled. Set AZUREDEVOPS_ENABLE_ENVIRONMENT_DELETE=true to enable.');
+        }
+        await this.makeRequest(`${project}/_apis/distributedtask/environments/${environmentId}?api-version=${this.apiVersion}`, 'DELETE');
+        return {
+            environmentId,
+            project,
+            deleted: true
+        };
+    }
+    /**
+     * Get all checks configured for an environment
+     * @param project The project name
+     * @param environmentId The environment ID
+     * @returns List of check configurations
+     */
+    async getEnvironmentChecks(project, environmentId) {
+        this.validateProject(project);
+        const response = await this.makeRequest(`${project}/_apis/pipelines/checks/configurations?resourceType=environment&resourceId=${environmentId}&api-version=7.1-preview.1`);
+        return {
+            project,
+            environmentId,
+            totalCount: response.value.length,
+            checks: response.value.map((check) => ({
+                id: check.id,
+                type: check.type?.name || check.type?.id,
+                settings: check.settings,
+                timeout: check.timeout,
+                retryInterval: check.retryInterval,
+                createdBy: check.createdBy?.displayName,
+                createdOn: check.createdOn,
+                modifiedBy: check.modifiedBy?.displayName,
+                modifiedOn: check.modifiedOn,
+                resource: check.resource
+            }))
+        };
+    }
+    /**
+     * Add a check to an environment
+     * @param project The project name
+     * @param environmentId The environment ID
+     * @param checkType The type of check (e.g., "Approval", "ExclusiveLock")
+     * @param configuration Check configuration
+     * @returns Created check
+     */
+    async addEnvironmentCheck(project, environmentId, checkType, configuration) {
+        this.validateProject(project);
+        if (!this.config.enableEnvironmentUpsert) {
+            throw new Error('Environment upsert operations are disabled. Set AZUREDEVOPS_ENABLE_ENVIRONMENT_UPSERT=true to enable.');
+        }
+        const check = {
+            type: { name: checkType },
+            settings: configuration,
+            resource: {
+                type: 'environment',
+                id: String(environmentId)
+            }
+        };
+        const response = await this.makeRequest(`${project}/_apis/pipelines/checks/configurations?api-version=7.1-preview.1`, 'POST', check);
+        return {
+            id: response.id,
+            type: response.type?.name,
+            environmentId,
+            project
+        };
+    }
+    /**
+     * Update an existing environment check
+     * @param project The project name
+     * @param checkId The check configuration ID
+     * @param updates Updated settings and/or timeout
+     * @returns Updated check
+     */
+    async updateEnvironmentCheck(project, checkId, updates) {
+        this.validateProject(project);
+        if (!this.config.enableEnvironmentUpsert) {
+            throw new Error('Environment upsert operations are disabled. Set AZUREDEVOPS_ENABLE_ENVIRONMENT_UPSERT=true to enable.');
+        }
+        // Get current check configuration first
+        const current = await this.makeRequest(`${project}/_apis/pipelines/checks/configurations/${checkId}?api-version=7.1-preview.1`);
+        // Merge updates
+        const updated = {
+            ...current,
+            settings: updates.settings !== undefined ? updates.settings : current.settings,
+            timeout: updates.timeout !== undefined ? updates.timeout : current.timeout
+        };
+        const response = await this.makeRequest(`${project}/_apis/pipelines/checks/configurations/${checkId}?api-version=7.1-preview.1`, 'PATCH', updated);
+        return {
+            id: response.id,
+            type: response.type?.name,
+            settings: response.settings,
+            timeout: response.timeout,
+            project
+        };
+    }
+    /**
+     * Remove a check from an environment
+     * @param project The project name
+     * @param checkId The check configuration ID
+     * @returns Deletion confirmation
+     */
+    async removeEnvironmentCheck(project, checkId) {
+        this.validateProject(project);
+        if (!this.config.enableEnvironmentDelete) {
+            throw new Error('Environment delete operations are disabled. Set AZUREDEVOPS_ENABLE_ENVIRONMENT_DELETE=true to enable.');
+        }
+        await this.makeRequest(`${project}/_apis/pipelines/checks/configurations/${checkId}?api-version=7.1-preview.1`, 'DELETE');
+        return {
+            checkId,
+            project,
+            deleted: true
+        };
+    }
 }
 //# sourceMappingURL=AzureDevOpsService.js.map