@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/aiCustomization/mcpServerCustomizationMigration.js

@@ -0,0 +1,860 @@
+
+import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
+import { parse } from '@codingame/monaco-vscode-api/vscode/vs/base/common/json';
+import { applyEdits, setProperty } from '@codingame/monaco-vscode-api/vscode/vs/base/common/jsonEdit';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
+import { isEqual, getComparisonKey, dirname, basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { normalizeMcpServerConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentPlugins/common/pluginParsers';
+import { toFileOperationResult, FileOperationResult, FileOperationError } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
+import { McpServerType } from '@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpPlatformTypes';
+import { ConfigurationResolverExpression } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/configurationResolver/common/configurationResolverExpression';
+import { McpServerCustomizationMigrationFailureReason, CustomizationMigrationType } from '../../common/promptSyntax/service/customizationMigrationService.js';
+import { AgentHostMcpServerApplicability, AgentHostMcpServerDelivery, AgentHostMcpServerSourceKind } from '../agentSessions/agentHost/agentHostMcpServerSupport.js';
+
+const LOG_PREFIX = "[MCP Customization Migration]";
+function isMcpServerMigrationDeliverable(server) {
+    return server.enablement.enabled && server.applicability === AgentHostMcpServerApplicability.Applicable && server.delivery === AgentHostMcpServerDelivery.ClientForwarded && server.compatibility.kind === "supported" && server.projectedConfiguration !== undefined;
+}
+class McpServerCustomizationMigrator {
+    constructor(fileService, logService) {
+        this.fileService = fileService;
+        this.logService = logService;
+    }
+    async createPlan(snapshot, roots) {
+        const candidates = [];
+        const exclusions = [];
+        const sourceServers = ( new ResourceMap());
+        this.logService.trace(
+            `${LOG_PREFIX} Planning: servers=${snapshot.servers.length}, roots=${roots.length}, discoveryComplete=${snapshot.discoveryComplete}`
+        );
+        for (const server of snapshot.servers) {
+            const sourceUri = server.source.collectionUri;
+            const root = sourceUri ? roots.find(
+                candidate => isEqual(sourceUri, URI.joinPath(candidate, ".vscode", "mcp.json"))
+            ) : undefined;
+            if (server.source.kind !== AgentHostMcpServerSourceKind.VscodeWorkspaceFolder || !sourceUri || !root) {
+                continue;
+            }
+            const targetUri = URI.joinPath(root, ".mcp.json");
+            const excluded = (reason, error) => {
+                this.logService.trace(`${LOG_PREFIX} Excluded '${server.name}' from ${( sourceUri.toString())}: reason=${reason}`);
+                exclusions.push({
+                    id: server.id,
+                    name: server.name,
+                    sourceUri,
+                    targetUri,
+                    reason,
+                    error
+                });
+            };
+            if (!isMcpServerMigrationDeliverable(server)) {
+                excluded(McpServerCustomizationMigrationFailureReason.NoLongerEligible);
+                continue;
+            }
+            let sourceServersPromise = sourceServers.get(sourceUri);
+            if (!sourceServersPromise) {
+                sourceServersPromise = this.readMcpServers(sourceUri);
+                sourceServers.set(sourceUri, sourceServersPromise);
+            }
+            let servers;
+            try {
+                servers = await sourceServersPromise;
+            } catch (error) {
+                const migrationError = error instanceof McpServerMigrationError ? error : undefined;
+                excluded(
+                    migrationError?.reason ?? McpServerCustomizationMigrationFailureReason.SourceUnavailable,
+                    migrationError ?? toError(error)
+                );
+                continue;
+            }
+            if (!servers) {
+                excluded(McpServerCustomizationMigrationFailureReason.SourceUnavailable);
+                continue;
+            }
+            if (!Object.hasOwn(servers, server.name)) {
+                excluded(McpServerCustomizationMigrationFailureReason.NoLongerEligible);
+                continue;
+            }
+            const rawConfiguration = servers[server.name];
+            const sourceConfiguration = canonicalizeSourceConfiguration(rawConfiguration);
+            const projectedConfiguration = canonicalizeConfiguration(server.projectedConfiguration);
+            if (!sourceConfiguration) {
+                excluded(
+                    normalizeMcpServerConfiguration(rawConfiguration) ? McpServerCustomizationMigrationFailureReason.UnrepresentableConfiguration : McpServerCustomizationMigrationFailureReason.InvalidSource
+                );
+                continue;
+            }
+            if (!isConfigurationRepresentable(server.projectedConfiguration) || !Iterable.isEmpty(
+                ConfigurationResolverExpression.parse(server.projectedConfiguration).unresolved()
+            ) || !equals(sourceConfiguration, projectedConfiguration)) {
+                excluded(McpServerCustomizationMigrationFailureReason.UnrepresentableConfiguration);
+                continue;
+            }
+            candidates.push({
+                type: CustomizationMigrationType.McpServers,
+                id: server.id,
+                name: server.name,
+                sourceUri,
+                targetUri,
+                projectedConfiguration: server.projectedConfiguration
+            });
+        }
+        this.logService.trace(
+            `${LOG_PREFIX} Planned: candidates=${candidates.length}, exclusions=${exclusions.length}`
+        );
+        return {
+            candidates,
+            exclusions
+        };
+    }
+    migrate(candidates, options = {}) {
+        return executeMigration(candidates, this.fileService, this.logService, options);
+    }
+    async readMcpServers(resource) {
+        let content;
+        try {
+            content = ( (await this.fileService.readFile(resource)).value.toString());
+        } catch (error) {
+            if (toFileOperationResult(error) === FileOperationResult.FILE_NOT_FOUND) {
+                return undefined;
+            }
+            throw error;
+        }
+        const errors = [];
+        const value = parse(content, errors, {
+            allowTrailingComma: true,
+            allowEmptyContent: false
+        });
+        const servers = errors.length === 0 && isJsonObject(value) ? getObjectProperty(value, "servers") : undefined;
+        if (!servers) {
+            throw ( new McpServerMigrationError(McpServerCustomizationMigrationFailureReason.InvalidSource, ( new Error(`MCP configuration ${( resource.toString())} does not contain a valid servers object.`))));
+        }
+        return servers;
+    }
+}
+async function executeMigration(candidates, fileService, logService, options) {
+    const groups = ( new Map());
+    const failures = [];
+    for (const candidate of candidates) {
+        if (!isStrictSourceTargetPair(candidate.sourceUri, candidate.targetUri)) {
+            logService.trace(`${LOG_PREFIX} Rejected '${candidate.name}': ${( candidate.sourceUri.toString())} to ${( candidate.targetUri.toString())} is not a strict .vscode/mcp.json to .mcp.json pair.`);
+            failures.push(
+                createFailure(candidate, McpServerCustomizationMigrationFailureReason.InconsistentTarget)
+            );
+            continue;
+        }
+        const key = JSON.stringify([
+            getComparisonKey(candidate.sourceUri),
+            getComparisonKey(candidate.targetUri)
+        ]);
+        const group = groups.get(key) ?? {
+            sourceUri: candidate.sourceUri,
+            targetUri: candidate.targetUri,
+            candidates: []
+        };
+        group.candidates.push(candidate);
+        groups.set(key, group);
+    }
+    logService.trace(
+        `${LOG_PREFIX} Executing: candidates=${candidates.length}, groups=${groups.size}, rejected=${failures.length}`
+    );
+    const roots = ( new ResourceMap());
+    for (const root of options.roots ?? []) {
+        roots.set(root, root);
+    }
+    const selectedCandidates = [...( groups.values())].flatMap(group => group.candidates);
+    for (const group of ( groups.values())) {
+        const root = dirname(group.targetUri);
+        roots.set(root, root);
+    }
+    const workingDirectories = [...( roots.values())];
+    let migratedCount = 0;
+    for (const group of ( groups.values())) {
+        if ((await options.isContextCurrent?.(group.candidates)) === false) {
+            logService.trace(`${LOG_PREFIX} Skipping ${( group.sourceUri.toString())}: execution context changed before the group started.`);
+            failures.push(...( group.candidates.map(
+                candidate => createFailure(candidate, McpServerCustomizationMigrationFailureReason.NoLongerEligible)
+            )));
+            continue;
+        }
+        let eligibleCandidates = group.candidates;
+        try {
+            const conflicts = await findCrossRootConflicts(group, workingDirectories, fileService);
+            eligibleCandidates = group.candidates.filter(candidate => {
+                const selectedConflict = selectedCandidates.find(
+                    other => other.name === candidate.name && !isEqual(other.targetUri, candidate.targetUri)
+                );
+                const conflictingUri = conflicts.get(candidate.name) ?? selectedConflict?.sourceUri;
+                if (!conflictingUri) {
+                    return true;
+                }
+                logService.warn(`${LOG_PREFIX} Rejected '${candidate.name}' from ${( candidate.sourceUri.toString())}: reason=${McpServerCustomizationMigrationFailureReason.CrossRootConflict}, conflictingUri=${( conflictingUri.toString())}`);
+                failures.push({
+                    ...createFailure(candidate, McpServerCustomizationMigrationFailureReason.CrossRootConflict),
+                    conflictingUri
+                });
+                return false;
+            });
+            if (eligibleCandidates.length === 0) {
+                continue;
+            }
+            const result = await migrateGroup({
+                ...group,
+                candidates: eligibleCandidates
+            }, fileService, logService, options, workingDirectories);
+            migratedCount += result.migratedCount;
+            failures.push(...result.failures);
+        } catch (error) {
+            const migrationError = toMigrationError(error);
+            logService.trace(`${LOG_PREFIX} Group ${( group.sourceUri.toString())} failed: reason=${migrationError.reason}`);
+            failures.push(...( eligibleCandidates.map(
+                candidate => createFailure(candidate, migrationError.reason, migrationError)
+            )));
+        }
+    }
+    return {
+        migratedCount,
+        failures
+    };
+}
+async function findCrossRootConflicts(group, roots, fileService) {
+    const conflicts = ( new Map());
+    for (const root of roots) {
+        const targetUri = URI.joinPath(root, ".mcp.json");
+        if (isEqual(targetUri, group.targetUri)) {
+            continue;
+        }
+        const sourceUri = URI.joinPath(root, ".vscode", "mcp.json");
+        let target;
+        try {
+            target = await readTargetDocument(targetUri, fileService);
+        } catch (error) {
+            throw ( new McpServerMigrationError(McpServerCustomizationMigrationFailureReason.InvalidTarget, toError(error)));
+        }
+        let sourceServers;
+        try {
+            sourceServers = getObjectProperty((await readSourceDocument(sourceUri, fileService)).value, "servers");
+        } catch (error) {
+            if (toFileOperationResult(error) !== FileOperationResult.FILE_NOT_FOUND) {
+                throw ( new McpServerMigrationError(
+                    McpServerCustomizationMigrationFailureReason.SourceUnavailable,
+                    toError(error)
+                ));
+            }
+        }
+        const targetServers = getTargetServers(target);
+        for (const candidate of group.candidates) {
+            if (( conflicts.has(candidate.name))) {
+                continue;
+            }
+            if (Object.hasOwn(targetServers, candidate.name)) {
+                conflicts.set(candidate.name, targetUri);
+            } else if (sourceServers && Object.hasOwn(sourceServers, candidate.name)) {
+                conflicts.set(candidate.name, sourceUri);
+            }
+        }
+    }
+    return conflicts;
+}
+async function ensureNoCrossRootConflicts(group, roots, fileService, logService) {
+    const conflicts = await findCrossRootConflicts(group, roots, fileService);
+    for (const [name, conflictingUri] of conflicts) {
+        logService.warn(
+            `${LOG_PREFIX} Cross-root conflict during migration of '${name}' from ${( group.sourceUri.toString())}: conflictingUri=${( conflictingUri.toString())}`
+        );
+        throw ( new McpServerMigrationError(
+            McpServerCustomizationMigrationFailureReason.CrossRootConflict,
+            ( new Error(`MCP server '${name}' is also defined in ${( conflictingUri.toString())}.`)),
+            conflictingUri
+        ));
+    }
+}
+async function migrateGroup(group, fileService, logService, options, roots) {
+    logService.trace(
+        `${LOG_PREFIX} Migrating ${group.candidates.length} server(s) from ${( group.sourceUri.toString())} to ${( group.targetUri.toString())}.`
+    );
+    let source;
+    try {
+        source = await readSourceDocument(group.sourceUri, fileService);
+    } catch (error) {
+        if (error instanceof McpServerMigrationError) {
+            throw error;
+        }
+        throw ( new McpServerMigrationError(
+            McpServerCustomizationMigrationFailureReason.SourceUnavailable,
+            toError(error)
+        ));
+    }
+    const sourceServers = getObjectProperty(source.value, "servers");
+    if (!sourceServers) {
+        throw ( new McpServerMigrationError(McpServerCustomizationMigrationFailureReason.InvalidSource, ( new Error(`MCP configuration ${( group.sourceUri.toString())} does not contain a servers object.`))));
+    }
+    let target;
+    try {
+        target = await readTargetDocument(group.targetUri, fileService);
+    } catch (error) {
+        throw ( new McpServerMigrationError(McpServerCustomizationMigrationFailureReason.InvalidTarget, toError(error)));
+    }
+    const targetServers = getTargetServers(target);
+    logService.trace(`${LOG_PREFIX} Target ${( group.targetUri.toString())}: exists=${target.exists}, wrapped=${target.wrapped}`);
+    const candidatesToMigrate = [];
+    const failures = [];
+    const reject = (candidate, reason) => {
+        logService.trace(
+            `${LOG_PREFIX} Rejected '${candidate.name}' before writing: reason=${reason}`
+        );
+        failures.push(createFailure(candidate, reason));
+    };
+    for (const candidate of group.candidates) {
+        if (!isConfigurationRepresentable(candidate.projectedConfiguration)) {
+            reject(
+                candidate,
+                McpServerCustomizationMigrationFailureReason.UnrepresentableConfiguration
+            );
+            continue;
+        }
+        if (!Object.hasOwn(sourceServers, candidate.name)) {
+            reject(candidate, McpServerCustomizationMigrationFailureReason.NoLongerEligible);
+            continue;
+        }
+        const sourceConfiguration = canonicalizeSourceConfiguration(sourceServers[candidate.name]);
+        const migrationConfiguration = canonicalizeConfiguration(candidate.projectedConfiguration);
+        if (!sourceConfiguration) {
+            reject(
+                candidate,
+                normalizeMcpServerConfiguration(sourceServers[candidate.name]) ? McpServerCustomizationMigrationFailureReason.UnrepresentableConfiguration : McpServerCustomizationMigrationFailureReason.InvalidSource
+            );
+            continue;
+        }
+        if (!equals(sourceConfiguration, migrationConfiguration)) {
+            reject(candidate, McpServerCustomizationMigrationFailureReason.SourceChanged);
+            continue;
+        }
+        const targetConfiguration = canonicalizeSourceConfiguration(targetServers[candidate.name]);
+        if (Object.hasOwn(targetServers, candidate.name) && (!targetConfiguration || !equals(targetConfiguration, migrationConfiguration))) {
+            reject(candidate, McpServerCustomizationMigrationFailureReason.TargetConflict);
+            continue;
+        }
+        candidatesToMigrate.push(candidate);
+    }
+    if (candidatesToMigrate.length === 0) {
+        logService.trace(`${LOG_PREFIX} Nothing left to migrate from ${( group.sourceUri.toString())}.`);
+        return {
+            migratedCount: 0,
+            failures
+        };
+    }
+    if ((await options.isContextCurrent?.(candidatesToMigrate)) === false) {
+        logService.trace(`${LOG_PREFIX} Aborting ${( group.sourceUri.toString())} before any write: execution context changed.`);
+        return {
+            migratedCount: 0,
+            failures: [...failures, ...( candidatesToMigrate.map(
+                candidate => createFailure(candidate, McpServerCustomizationMigrationFailureReason.NoLongerEligible)
+            ))]
+        };
+    }
+    let targetContent = target.content;
+    let targetChanged = false;
+    for (const candidate of candidatesToMigrate) {
+        if (!Object.hasOwn(targetServers, candidate.name)) {
+            targetContent = setJsonValue(
+                targetContent,
+                target.wrapped ? ["mcpServers", candidate.name] : [candidate.name],
+                canonicalizeConfiguration(candidate.projectedConfiguration)
+            );
+            targetChanged = true;
+        }
+    }
+    let sourceContent = source.content;
+    for (const candidate of candidatesToMigrate) {
+        sourceContent = setJsonValue(sourceContent, ["servers", candidate.name], undefined);
+    }
+    let writtenTarget;
+    const migrationGroup = {
+        ...group,
+        candidates: candidatesToMigrate
+    };
+    const beforeWrite = async () => {
+        if ((await options.isContextCurrent?.(candidatesToMigrate)) === false) {
+            throw ( new McpServerMigrationError(
+                McpServerCustomizationMigrationFailureReason.NoLongerEligible,
+                ( new Error("MCP migration context changed before writing."))
+            ));
+        }
+    };
+    if (targetChanged) {
+        logService.trace(`${LOG_PREFIX} Writing target ${( group.targetUri.toString())}.`);
+        try {
+            writtenTarget = await writeDocument(group.targetUri, targetContent, target, fileService, beforeWrite);
+        } catch (error) {
+            if (error instanceof McpServerMigrationError) {
+                throw error;
+            }
+            throw ( new McpServerMigrationError(
+                error instanceof McpServerDocumentChangedError ? McpServerCustomizationMigrationFailureReason.TargetChanged : McpServerCustomizationMigrationFailureReason.WriteFailed,
+                toError(error)
+            ));
+        }
+    } else {
+        logService.trace(`${LOG_PREFIX} Target ${( group.targetUri.toString())} already contains every selected entry.`);
+    }
+    try {
+        await ensureNoCrossRootConflicts({
+            ...group,
+            candidates: candidatesToMigrate
+        }, roots, fileService, logService);
+    } catch (error) {
+        if (writtenTarget) {
+            try {
+                await rollbackTarget(
+                    migrationGroup,
+                    target,
+                    writtenTarget,
+                    targetContent,
+                    fileService,
+                    logService
+                );
+            } catch (rollbackError) {
+                throw rollbackErrorWith(error, rollbackError, group.sourceUri);
+            }
+        }
+        throw error;
+    }
+    if ((await options.isContextCurrent?.(candidatesToMigrate)) === false) {
+        logService.trace(`${LOG_PREFIX} Aborting ${( group.sourceUri.toString())} after the target write: execution context changed.`);
+        if (writtenTarget) {
+            await rollbackTarget(
+                migrationGroup,
+                target,
+                writtenTarget,
+                targetContent,
+                fileService,
+                logService
+            );
+        }
+        return {
+            migratedCount: 0,
+            failures: [...failures, ...( candidatesToMigrate.map(
+                candidate => createFailure(candidate, McpServerCustomizationMigrationFailureReason.NoLongerEligible)
+            ))]
+        };
+    }
+    let writtenSource;
+    logService.trace(
+        `${LOG_PREFIX} Removing ${candidatesToMigrate.length} migrated entr${candidatesToMigrate.length === 1 ? "y" : "ies"} from ${( group.sourceUri.toString())}.`
+    );
+    try {
+        writtenSource = await writeDocument(group.sourceUri, sourceContent, source, fileService, beforeWrite);
+    } catch (error) {
+        const sourceChangedBeforeWrite = error instanceof McpServerDocumentChangedError;
+        if (sourceChangedBeforeWrite && (await isConcurrentMigrationComplete(migrationGroup, fileService))) {
+            await ensureNoCrossRootConflicts(migrationGroup, roots, fileService, logService);
+            logService.info(`${LOG_PREFIX} Concurrent migration already completed for ${( group.sourceUri.toString())}; retaining ${( group.targetUri.toString())}.`);
+            return {
+                migratedCount: candidatesToMigrate.length,
+                failures
+            };
+        }
+        const contextChangedBeforeWrite = error instanceof McpServerMigrationError && error.reason === McpServerCustomizationMigrationFailureReason.NoLongerEligible;
+        if (!sourceChangedBeforeWrite && !contextChangedBeforeWrite) {
+            logService.trace(`${LOG_PREFIX} Source write failed; restoring ${( group.sourceUri.toString())}.`);
+            try {
+                await restoreSourceAfterFailedWrite(group.sourceUri, source, sourceContent, fileService);
+            } catch (restoreError) {
+                throw rollbackErrorWith(error, restoreError, group.sourceUri);
+            }
+        }
+        if (writtenTarget) {
+            logService.trace(`${LOG_PREFIX} Rolling back target ${( group.targetUri.toString())}.`);
+            try {
+                await rollbackTarget(
+                    migrationGroup,
+                    target,
+                    writtenTarget,
+                    targetContent,
+                    fileService,
+                    logService
+                );
+            } catch (rollbackError) {
+                throw rollbackErrorWith(error, rollbackError, group.sourceUri);
+            }
+        }
+        if (contextChangedBeforeWrite) {
+            throw error;
+        }
+        throw ( new McpServerMigrationError(
+            sourceChangedBeforeWrite ? McpServerCustomizationMigrationFailureReason.SourceChanged : McpServerCustomizationMigrationFailureReason.WriteFailed,
+            toError(error)
+        ));
+    }
+    try {
+        await verifyMigration(group, candidatesToMigrate, fileService);
+        await ensureNoCrossRootConflicts({
+            ...group,
+            candidates: candidatesToMigrate
+        }, roots, fileService, logService);
+    } catch (verificationError) {
+        logService.trace(`${LOG_PREFIX} Verification failed for ${( group.sourceUri.toString())}; rolling both files back.`);
+        const rollbackErrors = [];
+        let sourceRestored = false;
+        try {
+            await restoreExistingDocument(group.sourceUri, source, writtenSource, sourceContent, fileService);
+            sourceRestored = true;
+        } catch (error) {
+            rollbackErrors.push(toError(error));
+        }
+        if (sourceRestored && writtenTarget) {
+            try {
+                await rollbackTarget(
+                    migrationGroup,
+                    target,
+                    writtenTarget,
+                    targetContent,
+                    fileService,
+                    logService
+                );
+            } catch (error) {
+                rollbackErrors.push(toError(error));
+            }
+        }
+        if (rollbackErrors.length > 0) {
+            throw ( new McpServerMigrationError(
+                McpServerCustomizationMigrationFailureReason.RollbackFailed,
+                ( new AggregateError(
+                    [toError(verificationError), ...rollbackErrors],
+                    `Failed to verify and roll back MCP servers from ${( group.sourceUri.toString())}.`
+                ))
+            ));
+        }
+        if (verificationError instanceof McpServerMigrationError) {
+            throw verificationError;
+        }
+        throw ( new McpServerMigrationError(
+            McpServerCustomizationMigrationFailureReason.TargetChanged,
+            toError(verificationError)
+        ));
+    }
+    logService.trace(
+        `${LOG_PREFIX} Verified ${candidatesToMigrate.length} migrated server(s) from ${( group.sourceUri.toString())}.`
+    );
+    return {
+        migratedCount: candidatesToMigrate.length,
+        failures
+    };
+}
+async function isConcurrentMigrationComplete(group, fileService) {
+    try {
+        const sourceServers = getObjectProperty((await readSourceDocument(group.sourceUri, fileService)).value, "servers");
+        const targetServers = getTargetServers(await readTargetDocument(group.targetUri, fileService));
+        return sourceServers !== undefined && group.candidates.every(
+            candidate => !Object.hasOwn(sourceServers, candidate.name) && Object.hasOwn(targetServers, candidate.name) && equals(
+                canonicalizeSourceConfiguration(targetServers[candidate.name]),
+                canonicalizeConfiguration(candidate.projectedConfiguration)
+            )
+        );
+    } catch {
+        return false;
+    }
+}
+async function restoreSourceAfterFailedWrite(resource, original, attemptedContent, fileService) {
+    const current = await fileService.readFile(resource);
+    const currentContent = ( current.value.toString());
+    if (currentContent === original.content) {
+        return;
+    }
+    if (currentContent !== attemptedContent) {
+        throw ( new Error(`Cannot safely restore ${( resource.toString())} because it changed during migration.`));
+    }
+    try {
+        await writeExistingDocument(resource, original.content, attemptedContent, fileService);
+    } catch (error) {
+        const afterFailedRestore = await fileService.readFile(resource);
+        if (( afterFailedRestore.value.toString()) === original.content) {
+            return;
+        }
+        throw error;
+    }
+    const restored = await fileService.readFile(resource);
+    if (( restored.value.toString()) !== original.content) {
+        throw ( new Error(`Could not verify restored MCP configuration ${( resource.toString())}.`));
+    }
+}
+async function verifyMigration(group, candidates, fileService) {
+    const source = await readSourceDocument(group.sourceUri, fileService);
+    const sourceServers = getObjectProperty(source.value, "servers");
+    const target = await readTargetDocument(group.targetUri, fileService);
+    const targetServers = getTargetServers(target);
+    for (const candidate of candidates) {
+        if (sourceServers?.[candidate.name] !== undefined || !equals(
+            canonicalizeSourceConfiguration(targetServers[candidate.name]),
+            canonicalizeConfiguration(candidate.projectedConfiguration)
+        )) {
+            throw ( new Error(`MCP server '${candidate.name}' changed during migration.`));
+        }
+    }
+}
+async function readSourceDocument(resource, fileService) {
+    const file = await fileService.readFile(resource);
+    const content = ( file.value.toString());
+    const errors = [];
+    const value = parse(content, errors, {
+        allowTrailingComma: true,
+        allowEmptyContent: false
+    });
+    if (errors.length > 0 || !isJsonObject(value)) {
+        throw ( new McpServerMigrationError(McpServerCustomizationMigrationFailureReason.InvalidSource, ( new Error(`MCP configuration ${( resource.toString())} contains invalid JSON.`))));
+    }
+    return {
+        content,
+        value,
+        exists: true
+    };
+}
+async function readTargetDocument(resource, fileService) {
+    try {
+        const file = await fileService.readFile(resource);
+        const content = ( file.value.toString());
+        const errors = [];
+        const value = parse(content, errors, {
+            allowTrailingComma: true,
+            allowEmptyContent: false
+        });
+        if (errors.length > 0 || !isJsonObject(value)) {
+            throw ( new Error(`MCP configuration ${( resource.toString())} contains invalid JSON.`));
+        }
+        const wrapped = Object.hasOwn(value, "mcpServers");
+        if (wrapped && !getObjectProperty(value, "mcpServers")) {
+            throw ( new Error(`MCP configuration ${( resource.toString())} does not contain a valid mcpServers object.`));
+        }
+        return {
+            content,
+            value,
+            exists: true,
+            wrapped
+        };
+    } catch (error) {
+        if (toFileOperationResult(error) !== FileOperationResult.FILE_NOT_FOUND) {
+            throw error;
+        }
+        const value = {
+            mcpServers: {}
+        };
+        return {
+            content: `${JSON.stringify(value, undefined, "\t")}\n`,
+            value,
+            exists: false,
+            wrapped: true
+        };
+    }
+}
+function getTargetServers(target) {
+    return target.wrapped ? getObjectProperty(target.value, "mcpServers") : target.value;
+}
+async function writeDocument(resource, content, document, fileService, beforeWrite) {
+    if (document.exists) {
+        return writeExistingDocument(resource, content, document.content, fileService, beforeWrite);
+    }
+    await beforeWrite?.();
+    return fileService.createFile(resource, VSBuffer.fromString(content), {
+        overwrite: false
+    });
+}
+async function writeExistingDocument(resource, content, expectedContent, fileService, beforeWrite) {
+    await ensureFileExists(resource, fileService);
+    const current = await fileService.readFile(resource);
+    if (( current.value.toString()) !== expectedContent) {
+        throw ( new McpServerDocumentChangedError(resource));
+    }
+    await beforeWrite?.();
+    return fileService.writeFile(resource, VSBuffer.fromString(content), {
+        etag: current.etag,
+        mtime: current.mtime
+    });
+}
+async function restoreExistingDocument(resource, original, written, writtenContent, fileService) {
+    const current = await fileService.readFile(resource);
+    if (current.etag !== written.etag || current.mtime !== written.mtime || ( current.value.toString()) !== writtenContent) {
+        throw ( new Error(`Cannot safely restore ${( resource.toString())} because it changed after migration.`));
+    }
+    await writeExistingDocument(resource, original.content, writtenContent, fileService);
+}
+async function rollbackTarget(group, original, written, writtenContent, fileService, logService) {
+    const resource = group.targetUri;
+    const current = await fileService.readFile(resource);
+    if (current.etag !== written.etag || current.mtime !== written.mtime || ( current.value.toString()) !== writtenContent) {
+        throw ( new McpServerMigrationError(
+            McpServerCustomizationMigrationFailureReason.RollbackFailed,
+            ( new Error(`Cannot safely restore ${( resource.toString())} because it changed after migration.`))
+        ));
+    }
+    if (original.exists) {
+        const originalServers = getTargetServers(original);
+        const addedCandidates = group.candidates.filter(candidate => !Object.hasOwn(originalServers, candidate.name));
+        await writeExistingDocument(resource, original.content, writtenContent, fileService, async () => {
+            try {
+                const sourceServers = getObjectProperty((await readSourceDocument(group.sourceUri, fileService)).value, "servers");
+                if (!sourceServers || ( addedCandidates.some(candidate => !Object.hasOwn(sourceServers, candidate.name) || !equals(
+                    canonicalizeSourceConfiguration(sourceServers[candidate.name]),
+                    canonicalizeConfiguration(candidate.projectedConfiguration)
+                )))) {
+                    throw ( new Error(`Source ${( group.sourceUri.toString())} no longer contains all entries added to ${( resource.toString())}.`));
+                }
+            } catch (error) {
+                logService.warn(`${LOG_PREFIX} Retaining ${( resource.toString())}: cannot verify surviving source entries in ${( group.sourceUri.toString())}.`);
+                throw ( new McpServerMigrationError(
+                    McpServerCustomizationMigrationFailureReason.RollbackFailed,
+                    toError(error)
+                ));
+            }
+        });
+    } else {
+        throw ( new McpServerMigrationError(
+            McpServerCustomizationMigrationFailureReason.RollbackFailed,
+            ( new Error(`Cannot safely remove newly created ${( resource.toString())} during rollback.`))
+        ));
+    }
+}
+async function ensureFileExists(resource, fileService) {
+    try {
+        await fileService.resolve(resource);
+    } catch (error) {
+        if (toFileOperationResult(error) === FileOperationResult.FILE_NOT_FOUND) {
+            throw ( new FileOperationError(`File was deleted during MCP migration: ${( resource.toString())}`, FileOperationResult.FILE_NOT_FOUND));
+        }
+        throw error;
+    }
+}
+function isStrictSourceTargetPair(sourceUri, targetUri) {
+    return basename(sourceUri) === "mcp.json" && basename(dirname(sourceUri)) === ".vscode" && isEqual(targetUri, URI.joinPath(dirname(dirname(sourceUri)), ".mcp.json"));
+}
+function getObjectProperty(value, key) {
+    const property = value[key];
+    return isJsonObject(property) ? property : undefined;
+}
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function canonicalizeConfiguration(configuration) {
+    if (configuration.type === McpServerType.LOCAL) {
+        return {
+            type: configuration.type,
+            command: configuration.command,
+            ...(configuration.args?.length ? {
+                args: [...configuration.args]
+            } : {}),
+            ...(configuration.env && ( Object.keys(configuration.env)).length > 0 ? {
+                env: {
+                    ...configuration.env
+                }
+            } : {}),
+            ...(configuration.cwd !== undefined ? {
+                cwd: configuration.cwd
+            } : {})
+        };
+    }
+    return {
+        type: configuration.type,
+        ...(configuration.transport === "sse" ? {
+            transport: "sse"
+        } : {}),
+        url: configuration.url,
+        ...(configuration.headers && ( Object.keys(configuration.headers)).length > 0 ? {
+            headers: {
+                ...configuration.headers
+            }
+        } : {})
+    };
+}
+function isConfigurationRepresentable(configuration) {
+    if (configuration.version !== undefined || configuration.gallery !== undefined || configuration.dev !== undefined) {
+        return false;
+    }
+    if (configuration.type === McpServerType.LOCAL) {
+        return configuration.envFile === undefined && configuration.cwd === undefined && configuration.sandboxEnabled !== true;
+    }
+    return configuration.oauth === undefined && configuration.transport !== "sse";
+}
+function canonicalizeSourceConfiguration(rawConfiguration) {
+    if (!isJsonObject(rawConfiguration)) {
+        return undefined;
+    }
+    const configuration = normalizeMcpServerConfiguration(rawConfiguration);
+    if (!configuration || !hasOnlyRepresentableProperties(rawConfiguration, configuration.type)) {
+        return undefined;
+    }
+    if (configuration.type === McpServerType.LOCAL) {
+        if ((rawConfiguration.args !== undefined && (!Array.isArray(rawConfiguration.args) || ( rawConfiguration.args.some(value => typeof value !== "string")))) || (rawConfiguration.env !== undefined && (!isJsonObject(rawConfiguration.env) || ( ( Object.values(rawConfiguration.env)).some(
+            value => typeof value !== "string" && typeof value !== "number" && value !== null
+        ))))) {
+            return undefined;
+        }
+    } else if (rawConfiguration.headers !== undefined && (!isJsonObject(rawConfiguration.headers) || ( ( Object.values(rawConfiguration.headers)).some(value => typeof value !== "string")))) {
+        return undefined;
+    }
+    return canonicalizeConfiguration(configuration);
+}
+function hasOnlyRepresentableProperties(rawConfiguration, type) {
+    const allowed = type === McpServerType.LOCAL ? ( new Set(["type", "command", "args", "env", "cwd"])) : ( new Set(["type", "transport", "url", "headers"]));
+    return ( Object.keys(rawConfiguration)).every(key => ( allowed.has(key)));
+}
+function setJsonValue(content, path, value) {
+    return applyEdits(
+        content,
+        setProperty(content, [...path], value, getFormattingOptions(content))
+    );
+}
+function getFormattingOptions(content) {
+    const indentation = /^([ \t]+)"/m.exec(content)?.[1];
+    const insertSpaces = indentation !== undefined && !indentation.includes("\t");
+    return {
+        insertSpaces,
+        tabSize: insertSpaces ? indentation.length : 1,
+        eol: content.includes("\r\n") ? "\r\n" : "\n"
+    };
+}
+function rollbackErrorWith(error, rollbackError, sourceUri) {
+    return ( new McpServerMigrationError(
+        McpServerCustomizationMigrationFailureReason.RollbackFailed,
+        ( new AggregateError(
+            [toError(error), toError(rollbackError)],
+            `Failed to migrate and roll back MCP servers from ${( sourceUri.toString())}.`
+        ))
+    ));
+}
+function toError(error) {
+    return error instanceof Error ? error : ( new Error(String(error)));
+}
+class McpServerMigrationError extends Error {
+    constructor(reason, underlyingError, conflictingUri) {
+        super(underlyingError.message);
+        this.reason = reason;
+        this.underlyingError = underlyingError;
+        this.conflictingUri = conflictingUri;
+    }
+}
+class McpServerDocumentChangedError extends Error {
+    constructor(resource) {
+        super(`MCP configuration ${( resource.toString())} changed during migration.`);
+    }
+}
+function toMigrationError(error) {
+    return error instanceof McpServerMigrationError ? error : ( new McpServerMigrationError(McpServerCustomizationMigrationFailureReason.WriteFailed, toError(error)));
+}
+function createFailure(candidate, reason, error) {
+    return {
+        id: candidate.id,
+        name: candidate.name,
+        sourceUri: candidate.sourceUri,
+        targetUri: candidate.targetUri,
+        reason,
+        error,
+        ...(error instanceof McpServerMigrationError && error.conflictingUri ? {
+            conflictingUri: error.conflictingUri
+        } : {})
+    };
+}
+
+export { McpServerCustomizationMigrator, isMcpServerMigrationDeliverable };