@structured-world/gitlab-mcp 6.62.1 → 7.0.1

package/dist/src/services/ConnectionManager.js

@@ -9,148 +9,197 @@ const config_1 = require("../config");
 const index_1 = require("../oauth/index");
 const fetch_1 = require("../utils/fetch");
 const logger_1 = require("../logger");
-const InstanceRegistry_js_1 = require("./InstanceRegistry.js");
+const InstanceRegistry_1 = require("./InstanceRegistry");
+const url_1 = require("../utils/url");
 class ConnectionManager {
     static instance = null;
-    client = null;
-    versionDetector = null;
-    schemaIntrospector = null;
-    instanceInfo = null;
-    schemaInfo = null;
-    tokenScopeInfo = null;
-    isInitialized = false;
+    instances = new Map();
     currentInstanceUrl = null;
-    introspectedInstanceUrl = null;
     introspectionPromises = new Map();
     static introspectionCache = new Map();
     static CACHE_TTL = 10 * 60 * 1000;
+    initializePromises = new Map();
+    latestRequestedUrl = null;
     constructor() { }
     static getInstance() {
         ConnectionManager.instance ??= new ConnectionManager();
         return ConnectionManager.instance;
     }
     async initialize(instanceUrl) {
-        if (this.isInitialized) {
+        const url = (0, url_1.normalizeInstanceUrl)(instanceUrl ?? config_1.GITLAB_BASE_URL);
+        this.latestRequestedUrl = url;
+        const existing = this.instances.get(url);
+        if (existing?.isInitialized) {
+            this.currentInstanceUrl = url;
             return;
         }
+        const inflight = this.initializePromises.get(url);
+        if (inflight) {
+            return inflight;
+        }
+        const promise = this.doInitialize(url);
+        this.initializePromises.set(url, promise);
+        try {
+            await promise;
+            const isOurPromise = this.initializePromises.get(url) === promise;
+            const initSucceeded = this.instances.get(url)?.isInitialized === true;
+            if ((isOurPromise && url === this.latestRequestedUrl) ||
+                (!this.currentInstanceUrl && initSucceeded)) {
+                this.currentInstanceUrl = url;
+            }
+        }
+        finally {
+            if (this.initializePromises.get(url) === promise) {
+                this.initializePromises.delete(url);
+            }
+        }
+    }
+    async doInitialize(baseUrl) {
+        let state;
         try {
             const oauthMode = (0, index_1.isOAuthEnabled)();
-            const registry = InstanceRegistry_js_1.InstanceRegistry.getInstance();
+            const registry = InstanceRegistry_1.InstanceRegistry.getInstance();
             if (!registry.isInitialized()) {
                 await registry.initialize();
             }
-            const baseUrl = instanceUrl ?? config_1.GITLAB_BASE_URL;
-            this.currentInstanceUrl = baseUrl;
             if (!baseUrl) {
-                throw new Error("GitLab base URL is required");
+                throw new Error('GitLab base URL is required');
             }
             if (!oauthMode && !config_1.GITLAB_TOKEN) {
-                throw new Error("GITLAB_TOKEN is required in static authentication mode. " +
-                    "Run `npx @structured-world/gitlab-mcp setup` for interactive configuration, " +
-                    "or set the environment variable and restart. " +
-                    "Docs: https://gitlab-mcp.sw.foundation/guide/quick-start");
+                throw new Error('GITLAB_TOKEN is required in static authentication mode. ' +
+                    'Run `npx @structured-world/gitlab-mcp setup` for interactive configuration, ' +
+                    'or set the environment variable and restart. ' +
+                    'Docs: https://gitlab-mcp.sw.foundation/guide/quick-start');
             }
             const endpoint = `${baseUrl}/api/graphql`;
             const clientOptions = oauthMode
                 ? {}
-                : { headers: { "PRIVATE-TOKEN": String(config_1.GITLAB_TOKEN) } };
-            this.client = new client_1.GraphQLClient(endpoint, clientOptions);
-            this.versionDetector = new GitLabVersionDetector_1.GitLabVersionDetector(this.client);
-            this.schemaIntrospector = new SchemaIntrospector_1.SchemaIntrospector(this.client);
+                : { headers: { 'PRIVATE-TOKEN': String(config_1.GITLAB_TOKEN) } };
+            const client = new client_1.GraphQLClient(endpoint, clientOptions);
+            const versionDetector = new GitLabVersionDetector_1.GitLabVersionDetector(client);
+            const schemaIntrospector = new SchemaIntrospector_1.SchemaIntrospector(client);
+            state = {
+                client,
+                versionDetector,
+                schemaIntrospector,
+                instanceInfo: null,
+                schemaInfo: null,
+                tokenScopeInfo: null,
+                isInitialized: false,
+                introspectedInstanceUrl: null,
+            };
+            this.instances.set(baseUrl, state);
             if (oauthMode) {
-                (0, logger_1.logInfo)("OAuth mode: attempting unauthenticated version detection");
+                (0, logger_1.logInfo)('OAuth mode: attempting unauthenticated version detection');
                 try {
-                    const versionResponse = await fetch(`${baseUrl}/api/v4/version`);
+                    const versionResponse = await (0, fetch_1.enhancedFetch)(`${baseUrl}/api/v4/version`, {
+                        retry: false,
+                        skipAuth: true,
+                    });
                     if (versionResponse.ok) {
                         const versionData = (await versionResponse.json());
-                        (0, logger_1.logInfo)("Detected GitLab version without authentication", {
+                        (0, logger_1.logInfo)('Detected GitLab version without authentication', {
                             version: versionData.version,
                         });
-                        this.instanceInfo = {
+                        state.instanceInfo = {
                             version: versionData.version,
-                            tier: versionData.enterprise ? "premium" : "free",
+                            tier: versionData.enterprise ? 'premium' : 'free',
                             features: this.getDefaultFeatures(versionData.enterprise ?? false),
                             detectedAt: new Date(),
                         };
-                        (0, logger_1.logInfo)("OAuth mode: version detected, full introspection deferred until first authenticated request");
+                        (0, logger_1.logInfo)('OAuth mode: version detected, full introspection deferred until first authenticated request');
                     }
                     else {
-                        (0, logger_1.logInfo)("OAuth mode: unauthenticated version detection failed, deferring all introspection", {
+                        (0, logger_1.logInfo)('OAuth mode: unauthenticated version detection failed, deferring all introspection', {
                             status: versionResponse.status,
                         });
                     }
                 }
                 catch (error) {
-                    (0, logger_1.logInfo)("OAuth mode: unauthenticated version detection failed, deferring all introspection", {
+                    (0, logger_1.logInfo)('OAuth mode: unauthenticated version detection failed, deferring all introspection', {
                         error: error instanceof Error ? error.message : String(error),
                     });
                 }
-                this.isInitialized = true;
+                if (this.instances.get(baseUrl) !== state)
+                    return;
+                state.isInitialized = true;
                 return;
             }
-            this.tokenScopeInfo = await (0, TokenScopeDetector_1.detectTokenScopes)();
-            if (this.tokenScopeInfo) {
+            state.tokenScopeInfo = await (0, TokenScopeDetector_1.detectTokenScopes)(baseUrl);
+            if (state.tokenScopeInfo) {
                 const totalTools = Object.keys((0, TokenScopeDetector_1.getToolScopeRequirements)()).length;
-                (0, TokenScopeDetector_1.logTokenScopeInfo)(this.tokenScopeInfo, totalTools);
-                if (!this.tokenScopeInfo.hasGraphQLAccess) {
-                    this.instanceInfo = await this.detectVersionViaREST();
-                    this.isInitialized = true;
+                (0, TokenScopeDetector_1.logTokenScopeInfo)(state.tokenScopeInfo, totalTools, baseUrl);
+                if (!state.tokenScopeInfo.hasGraphQLAccess) {
+                    state.instanceInfo = await this.detectVersionViaREST(baseUrl);
+                    state.isInitialized = true;
                     return;
                 }
             }
             const cached = ConnectionManager.introspectionCache.get(endpoint);
             const now = Date.now();
             if (cached && now - cached.timestamp < ConnectionManager.CACHE_TTL) {
-                (0, logger_1.logInfo)("Using cached GraphQL introspection data");
-                this.instanceInfo = cached.instanceInfo;
-                this.schemaInfo = cached.schemaInfo;
-                this.introspectedInstanceUrl = baseUrl;
+                if (this.instances.get(baseUrl) !== state)
+                    return;
+                (0, logger_1.logInfo)('Using cached GraphQL introspection data');
+                state.instanceInfo = cached.instanceInfo;
+                state.schemaInfo = cached.schemaInfo;
+                state.schemaIntrospector.rehydrate(cached.schemaInfo);
+                state.introspectedInstanceUrl = baseUrl;
             }
             else {
-                (0, logger_1.logDebug)("Introspecting GitLab GraphQL schema...");
+                (0, logger_1.logDebug)('Introspecting GitLab GraphQL schema...');
                 const [instanceInfo, schemaInfo] = await Promise.all([
-                    this.versionDetector.detectInstance(),
-                    this.schemaIntrospector.introspectSchema(),
+                    versionDetector.detectInstance(),
+                    schemaIntrospector.introspectSchema(),
                 ]);
-                this.instanceInfo = instanceInfo;
-                this.schemaInfo = schemaInfo;
-                this.introspectedInstanceUrl = baseUrl;
+                if (this.instances.get(baseUrl) !== state)
+                    return;
+                state.instanceInfo = instanceInfo;
+                state.schemaInfo = schemaInfo;
+                state.introspectedInstanceUrl = baseUrl;
                 ConnectionManager.introspectionCache.set(endpoint, {
                     instanceInfo,
                     schemaInfo,
                     timestamp: now,
                 });
-                (0, logger_1.logInfo)("GraphQL schema introspection completed");
+                (0, logger_1.logInfo)('GraphQL schema introspection completed');
             }
-            this.isInitialized = true;
-            (0, logger_1.logInfo)("GitLab instance and schema detected", {
-                version: this.instanceInfo?.version,
-                tier: this.instanceInfo?.tier,
-                features: this.instanceInfo
-                    ? Object.entries(this.instanceInfo.features)
+            state.isInitialized = true;
+            (0, logger_1.logInfo)('GitLab instance and schema detected', {
+                version: state.instanceInfo?.version,
+                tier: state.instanceInfo?.tier,
+                features: state.instanceInfo
+                    ? Object.entries(state.instanceInfo.features)
                         .filter(([, enabled]) => enabled)
                         .map(([feature]) => feature)
                     : [],
-                widgetTypes: this.schemaInfo?.workItemWidgetTypes.length || 0,
-                schemaTypes: this.schemaInfo?.typeDefinitions.size || 0,
+                widgetTypes: state.schemaInfo?.workItemWidgetTypes.length || 0,
+                schemaTypes: state.schemaInfo?.typeDefinitions.size || 0,
             });
         }
         catch (error) {
-            (0, logger_1.logError)("Failed to initialize connection", { err: error });
+            if (state && this.instances.get(baseUrl) === state) {
+                this.instances.delete(baseUrl);
+            }
+            (0, logger_1.logError)('Failed to initialize connection', { err: error });
             throw error;
         }
     }
-    async ensureIntrospected() {
-        if (!this.client || !this.versionDetector || !this.schemaIntrospector) {
-            throw new Error("Connection not initialized. Call initialize() first.");
+    async ensureIntrospected(explicitUrl) {
+        const instanceUrl = (0, url_1.normalizeInstanceUrl)(explicitUrl ?? (0, index_1.getGitLabApiUrlFromContext)() ?? this.currentInstanceUrl ?? config_1.GITLAB_BASE_URL);
+        const state = this.instances.get(instanceUrl);
+        if (!state?.client || !state.versionDetector || !state.schemaIntrospector) {
+            throw new Error('Connection not initialized. Call initialize() first.');
+        }
+        if (state.instanceInfo && state.schemaInfo && state.introspectedInstanceUrl === instanceUrl) {
+            return;
         }
-        const instanceUrl = (0, index_1.getGitLabApiUrlFromContext)() ?? this.currentInstanceUrl ?? config_1.GITLAB_BASE_URL;
-        if (this.instanceInfo && this.schemaInfo && this.introspectedInstanceUrl === instanceUrl) {
+        if (state.tokenScopeInfo && !state.tokenScopeInfo.hasGraphQLAccess) {
             return;
         }
         const existingPromise = this.introspectionPromises.get(instanceUrl);
         if (existingPromise) {
-            (0, logger_1.logDebug)("Awaiting existing introspection for instance", { url: instanceUrl });
+            (0, logger_1.logDebug)('Awaiting existing introspection for instance', { url: instanceUrl });
             await existingPromise;
             return;
         }
@@ -160,34 +209,37 @@ class ConnectionManager {
             await promise;
         }
         finally {
-            this.introspectionPromises.delete(instanceUrl);
+            if (this.introspectionPromises.get(instanceUrl) === promise) {
+                this.introspectionPromises.delete(instanceUrl);
+            }
         }
     }
     async doIntrospection(instanceUrl) {
-        const client = this.client;
-        const versionDet = this.versionDetector;
-        const schemaDet = this.schemaIntrospector;
-        if (!client || !versionDet || !schemaDet) {
-            throw new Error("Connection not initialized. Call initialize() first.");
+        const state = this.instances.get(instanceUrl);
+        if (!state?.client || !state.versionDetector || !state.schemaIntrospector) {
+            throw new Error('Connection not initialized. Call initialize() first.');
         }
+        const { client, versionDetector, schemaIntrospector } = state;
         const endpoint = client.endpoint;
-        const registry = InstanceRegistry_js_1.InstanceRegistry.getInstance();
+        const registry = InstanceRegistry_1.InstanceRegistry.getInstance();
         if (registry.isInitialized()) {
             const cachedIntrospection = registry.getIntrospection(instanceUrl);
             if (cachedIntrospection) {
-                (0, logger_1.logInfo)("Using cached introspection from InstanceRegistry", { url: instanceUrl });
-                this.instanceInfo = {
+                (0, logger_1.logInfo)('Using cached introspection from InstanceRegistry', { url: instanceUrl });
+                state.instanceInfo = {
                     version: cachedIntrospection.version,
                     tier: cachedIntrospection.tier,
                     features: cachedIntrospection.features,
                     detectedAt: cachedIntrospection.cachedAt,
                 };
-                this.schemaInfo = cachedIntrospection.schemaInfo;
-                this.introspectedInstanceUrl = instanceUrl;
+                const restoredSchema = cachedIntrospection.schemaInfo;
+                state.schemaInfo = restoredSchema;
+                state.schemaIntrospector.rehydrate(restoredSchema);
+                state.introspectedInstanceUrl = instanceUrl;
                 return;
             }
         }
-        const primaryCacheKey = instanceUrl ?? endpoint;
+        const primaryCacheKey = instanceUrl;
         const legacyCacheKey = endpoint;
         let cached = ConnectionManager.introspectionCache.get(primaryCacheKey);
         if (!cached && primaryCacheKey !== legacyCacheKey) {
@@ -195,30 +247,23 @@ class ConnectionManager {
         }
         const now = Date.now();
         if (cached && now - cached.timestamp < ConnectionManager.CACHE_TTL) {
-            (0, logger_1.logInfo)("Using cached GraphQL introspection data");
-            this.instanceInfo = cached.instanceInfo;
-            this.schemaInfo = cached.schemaInfo;
-            this.introspectedInstanceUrl = instanceUrl;
+            (0, logger_1.logInfo)('Using cached GraphQL introspection data');
+            state.instanceInfo = cached.instanceInfo;
+            state.schemaInfo = cached.schemaInfo;
+            state.schemaIntrospector.rehydrate(cached.schemaInfo);
+            state.introspectedInstanceUrl = instanceUrl;
             return;
         }
-        (0, logger_1.logDebug)("Introspecting GitLab GraphQL schema (deferred OAuth mode)...");
-        let versionDetector = versionDet;
-        let schemaIntrospector = schemaDet;
-        if (registry.isInitialized() && instanceUrl !== this.currentInstanceUrl) {
-            const instanceClient = this.getInstanceClient(instanceUrl);
-            if (instanceClient !== client) {
-                versionDetector = new GitLabVersionDetector_1.GitLabVersionDetector(instanceClient);
-                schemaIntrospector = new SchemaIntrospector_1.SchemaIntrospector(instanceClient);
-                (0, logger_1.logDebug)("Using per-instance detectors for introspection", { instanceUrl });
-            }
-        }
+        (0, logger_1.logDebug)('Introspecting GitLab GraphQL schema (deferred OAuth mode)...');
         const [instanceInfo, schemaInfo] = await Promise.all([
             versionDetector.detectInstance(),
             schemaIntrospector.introspectSchema(),
         ]);
-        this.instanceInfo = instanceInfo;
-        this.schemaInfo = schemaInfo;
-        this.introspectedInstanceUrl = instanceUrl;
+        if (this.instances.get(instanceUrl) !== state)
+            return;
+        state.instanceInfo = instanceInfo;
+        state.schemaInfo = schemaInfo;
+        state.introspectedInstanceUrl = instanceUrl;
         ConnectionManager.introspectionCache.set(primaryCacheKey, {
             instanceInfo,
             schemaInfo,
@@ -234,105 +279,147 @@ class ConnectionManager {
             };
             registry.setIntrospection(instanceUrl, cachedIntrospection);
         }
-        (0, logger_1.logInfo)("GraphQL schema introspection completed (deferred)", {
-            version: this.instanceInfo?.version,
-            tier: this.instanceInfo?.tier,
-            widgetTypes: this.schemaInfo?.workItemWidgetTypes.length || 0,
+        (0, logger_1.logInfo)('GraphQL schema introspection completed (deferred)', {
+            version: state.instanceInfo?.version,
+            tier: state.instanceInfo?.tier,
+            widgetTypes: state.schemaInfo?.workItemWidgetTypes.length || 0,
         });
     }
-    getClient() {
-        if (!this.client) {
-            throw new Error("Connection not initialized. Call initialize() first.");
+    resolveState(instanceUrl) {
+        const url = instanceUrl ? (0, url_1.normalizeInstanceUrl)(instanceUrl) : this.currentInstanceUrl;
+        if (!url) {
+            throw new Error('Connection not initialized. Call initialize() first.');
+        }
+        const state = this.instances.get(url);
+        if (!state) {
+            throw new Error(`Connection not initialized for ${url}. Call initialize() first.`);
         }
-        return this.client;
+        return [state, url];
+    }
+    getClient(instanceUrl) {
+        const [state] = this.resolveState(instanceUrl);
+        return state.client;
     }
     getInstanceClient(instanceUrl, authHeaders) {
-        const registry = InstanceRegistry_js_1.InstanceRegistry.getInstance();
-        const targetUrl = instanceUrl ?? (0, index_1.getGitLabApiUrlFromContext)() ?? this.currentInstanceUrl;
+        const registry = InstanceRegistry_1.InstanceRegistry.getInstance();
+        const rawTargetUrl = instanceUrl ?? (0, index_1.getGitLabApiUrlFromContext)() ?? this.currentInstanceUrl;
+        const targetUrl = rawTargetUrl ? (0, url_1.normalizeInstanceUrl)(rawTargetUrl) : null;
         if (targetUrl && registry.isInitialized() && registry.has(targetUrl)) {
             const client = registry.getGraphQLClient(targetUrl, authHeaders);
             if (client) {
                 return client;
             }
         }
-        if (!this.client) {
-            throw new Error("Connection not initialized. Call initialize() first.");
+        if (targetUrl) {
+            const state = this.instances.get(targetUrl);
+            if (state)
+                return state.client;
+            throw new Error(`Connection not initialized for ${targetUrl}. Call initialize() first.`);
         }
-        return this.client;
+        return this.getClient();
     }
-    getVersionDetector() {
-        if (!this.versionDetector) {
-            throw new Error("Connection not initialized. Call initialize() first.");
-        }
-        return this.versionDetector;
+    getVersionDetector(instanceUrl) {
+        const [state] = this.resolveState(instanceUrl);
+        return state.versionDetector;
     }
-    getSchemaIntrospector() {
-        if (!this.schemaIntrospector) {
-            throw new Error("Connection not initialized. Call initialize() first.");
-        }
-        return this.schemaIntrospector;
+    getSchemaIntrospector(instanceUrl) {
+        const [state] = this.resolveState(instanceUrl);
+        return state.schemaIntrospector;
     }
-    getInstanceInfo() {
-        if (!this.instanceInfo) {
-            throw new Error("Connection not initialized. Call initialize() first.");
+    getInstanceInfo(instanceUrl) {
+        const [state, resolvedUrl] = this.resolveState(instanceUrl);
+        if (!state.instanceInfo) {
+            throw new Error(`Instance information is not available for ${resolvedUrl}. Initialization may have completed without version detection (OAuth deferred/REST-only mode).`);
         }
-        return this.instanceInfo;
+        return state.instanceInfo;
     }
-    getSchemaInfo() {
-        if (!this.schemaInfo) {
-            throw new Error("Connection not initialized. Call initialize() first.");
+    getSchemaInfo(instanceUrl) {
+        const [state, resolvedUrl] = this.resolveState(instanceUrl);
+        if (!state.schemaInfo) {
+            throw new Error(`Schema information is not available for ${resolvedUrl}. Initialization may have completed without schema introspection.`);
         }
-        return this.schemaInfo;
+        return state.schemaInfo;
     }
     getCurrentInstanceUrl() {
         return this.currentInstanceUrl;
     }
-    isFeatureAvailable(feature) {
-        if (!this.instanceInfo) {
+    isConnected(instanceUrl) {
+        const url = instanceUrl ? (0, url_1.normalizeInstanceUrl)(instanceUrl) : this.currentInstanceUrl;
+        if (!url)
             return false;
-        }
-        return this.instanceInfo.features[feature];
+        const state = this.instances.get(url);
+        return state?.isInitialized ?? false;
     }
-    getTier() {
-        if (!this.instanceInfo) {
-            return "unknown";
-        }
-        return this.instanceInfo.tier;
+    isFeatureAvailable(feature, instanceUrl) {
+        const url = instanceUrl ? (0, url_1.normalizeInstanceUrl)(instanceUrl) : this.currentInstanceUrl;
+        if (!url)
+            return false;
+        const state = this.instances.get(url);
+        if (!state?.instanceInfo)
+            return false;
+        return state.instanceInfo.features[feature];
     }
-    getVersion() {
-        if (!this.instanceInfo) {
-            return "unknown";
-        }
-        return this.instanceInfo.version;
+    getTier(instanceUrl) {
+        const url = instanceUrl ? (0, url_1.normalizeInstanceUrl)(instanceUrl) : this.currentInstanceUrl;
+        if (!url)
+            return 'unknown';
+        const state = this.instances.get(url);
+        if (!state?.instanceInfo)
+            return 'unknown';
+        return state.instanceInfo.tier;
     }
-    isWidgetAvailable(widgetType) {
-        if (!this.schemaIntrospector) {
+    getVersion(instanceUrl) {
+        const url = instanceUrl ? (0, url_1.normalizeInstanceUrl)(instanceUrl) : this.currentInstanceUrl;
+        if (!url)
+            return 'unknown';
+        const state = this.instances.get(url);
+        if (!state?.instanceInfo)
+            return 'unknown';
+        return state.instanceInfo.version;
+    }
+    isWidgetAvailable(widgetType, instanceUrl) {
+        const url = instanceUrl ? (0, url_1.normalizeInstanceUrl)(instanceUrl) : this.currentInstanceUrl;
+        if (!url)
             return false;
-        }
-        return this.schemaIntrospector.isWidgetTypeAvailable(widgetType);
+        const state = this.instances.get(url);
+        return state?.schemaInfo?.workItemWidgetTypes.includes(widgetType) ?? false;
     }
-    getTokenScopeInfo() {
-        return this.tokenScopeInfo;
+    getTokenScopeInfo(instanceUrl) {
+        const url = instanceUrl ? (0, url_1.normalizeInstanceUrl)(instanceUrl) : this.currentInstanceUrl;
+        if (!url)
+            return null;
+        const state = this.instances.get(url);
+        return state?.tokenScopeInfo ?? null;
     }
     async refreshTokenScopes() {
         if ((0, index_1.isOAuthEnabled)()) {
             return false;
         }
-        const previousScopes = this.tokenScopeInfo?.scopes ?? [];
-        const previousHasGraphQL = this.tokenScopeInfo?.hasGraphQLAccess ?? false;
-        const previousHasWrite = this.tokenScopeInfo?.hasWriteAccess ?? false;
-        const newScopeInfo = await (0, TokenScopeDetector_1.detectTokenScopes)();
+        const url = this.currentInstanceUrl;
+        if (!url)
+            return false;
+        const state = this.instances.get(url);
+        if (!state)
+            return false;
+        const previousScopes = state.tokenScopeInfo?.scopes ?? [];
+        const previousHasGraphQL = state.tokenScopeInfo?.hasGraphQLAccess ?? false;
+        const previousHasWrite = state.tokenScopeInfo?.hasWriteAccess ?? false;
+        const newScopeInfo = await (0, TokenScopeDetector_1.detectTokenScopes)(url);
         if (!newScopeInfo) {
             return false;
         }
         const newScopes = newScopeInfo.scopes;
         const scopesChanged = previousScopes.length !== newScopes.length ||
-            !previousScopes.every(s => newScopes.includes(s)) ||
+            !previousScopes.every((s) => newScopes.includes(s)) ||
             previousHasGraphQL !== newScopeInfo.hasGraphQLAccess ||
             previousHasWrite !== newScopeInfo.hasWriteAccess;
+        const currentState = this.instances.get(url);
+        if (currentState !== state) {
+            return false;
+        }
+        state.tokenScopeInfo = newScopeInfo;
         if (scopesChanged) {
-            this.tokenScopeInfo = newScopeInfo;
-            (0, logger_1.logInfo)("Token scopes changed - tool registry will be refreshed", {
+            (0, logger_1.logInfo)('Token scopes changed - tool registry will be refreshed', {
                 previousScopes,
                 newScopes,
                 hasGraphQLAccess: newScopeInfo.hasGraphQLAccess,
@@ -341,39 +428,39 @@ class ConnectionManager {
         }
         return scopesChanged;
     }
-    async detectVersionViaREST() {
+    async detectVersionViaREST(baseUrl) {
         try {
-            const baseUrl = this.currentInstanceUrl ?? config_1.GITLAB_BASE_URL;
-            const response = await (0, fetch_1.enhancedFetch)(`${baseUrl}/api/v4/version`, {
+            const url = baseUrl ?? this.currentInstanceUrl ?? config_1.GITLAB_BASE_URL;
+            const response = await (0, fetch_1.enhancedFetch)(`${url}/api/v4/version`, {
                 headers: {
-                    "PRIVATE-TOKEN": config_1.GITLAB_TOKEN ?? "",
-                    Accept: "application/json",
+                    'PRIVATE-TOKEN': config_1.GITLAB_TOKEN ?? '',
+                    Accept: 'application/json',
                 },
                 retry: false,
             });
             if (response.ok) {
                 const data = (await response.json());
-                (0, logger_1.logInfo)("Detected GitLab version via REST (GraphQL unavailable)", {
+                (0, logger_1.logInfo)('Detected GitLab version via REST (GraphQL unavailable)', {
                     version: data.version,
                     enterprise: data.enterprise,
                 });
                 return {
                     version: data.version,
-                    tier: data.enterprise ? "premium" : "free",
+                    tier: data.enterprise ? 'premium' : 'free',
                     features: this.getDefaultFeatures(data.enterprise ?? false),
                     detectedAt: new Date(),
                 };
             }
-            (0, logger_1.logInfo)("REST version detection failed, using defaults", { status: response.status });
+            (0, logger_1.logInfo)('REST version detection failed, using defaults', { status: response.status });
         }
         catch (error) {
-            (0, logger_1.logInfo)("REST version detection failed, using defaults", {
+            (0, logger_1.logInfo)('REST version detection failed, using defaults', {
                 error: error instanceof Error ? error.message : String(error),
             });
         }
         return {
-            version: "unknown",
-            tier: "free",
+            version: 'unknown',
+            tier: 'free',
             features: this.getDefaultFeatures(false),
             detectedAt: new Date(),
         };
@@ -407,31 +494,69 @@ class ConnectionManager {
             emailParticipants: true,
         };
     }
-    async reinitialize(newInstanceUrl) {
-        (0, logger_1.logInfo)("Re-initializing ConnectionManager for new instance", {
+    async reinitialize(rawInstanceUrl) {
+        const newInstanceUrl = (0, url_1.normalizeInstanceUrl)(rawInstanceUrl);
+        (0, logger_1.logInfo)('Re-initializing ConnectionManager for new instance', {
             newInstanceUrl,
         });
-        this.reset();
-        const registry = InstanceRegistry_js_1.InstanceRegistry.getInstance();
-        registry.clearIntrospectionCache(newInstanceUrl);
-        await this.initialize(newInstanceUrl);
-        (0, logger_1.logInfo)("ConnectionManager re-initialized", {
-            version: this.instanceInfo?.version,
-            tier: this.instanceInfo?.tier,
+        const previousUrl = this.currentInstanceUrl;
+        const savedState = this.instances.get(newInstanceUrl);
+        const restorableState = savedState?.isInitialized ? savedState : undefined;
+        this.initializePromises.delete(newInstanceUrl);
+        this.introspectionPromises.delete(newInstanceUrl);
+        this.instances.delete(newInstanceUrl);
+        try {
+            const registry = InstanceRegistry_1.InstanceRegistry.getInstance();
+            registry.clearIntrospectionCache(newInstanceUrl);
+        }
+        catch {
+        }
+        ConnectionManager.introspectionCache.delete(newInstanceUrl);
+        ConnectionManager.introspectionCache.delete(`${newInstanceUrl}/api/graphql`);
+        try {
+            await this.initialize(newInstanceUrl);
+        }
+        catch (error) {
+            if (restorableState) {
+                this.instances.set(newInstanceUrl, restorableState);
+            }
+            if (previousUrl && this.instances.has(previousUrl)) {
+                this.currentInstanceUrl = previousUrl;
+            }
+            else if (restorableState) {
+                this.currentInstanceUrl = newInstanceUrl;
+            }
+            throw error;
+        }
+        if (previousUrl && previousUrl !== newInstanceUrl) {
+            this.initializePromises.delete(previousUrl);
+            this.introspectionPromises.delete(previousUrl);
+            this.instances.delete(previousUrl);
+        }
+        const state = this.instances.get(newInstanceUrl);
+        (0, logger_1.logInfo)('ConnectionManager re-initialized', {
+            version: state?.instanceInfo?.version,
+            tier: state?.instanceInfo?.tier,
             instanceUrl: this.currentInstanceUrl,
         });
     }
+    clearInflight(rawUrl) {
+        const url = (0, url_1.normalizeInstanceUrl)(rawUrl);
+        this.initializePromises.delete(url);
+        this.introspectionPromises.delete(url);
+    }
     reset() {
-        this.client = null;
-        this.versionDetector = null;
-        this.schemaIntrospector = null;
-        this.instanceInfo = null;
-        this.schemaInfo = null;
-        this.tokenScopeInfo = null;
+        this.instances.clear();
         this.currentInstanceUrl = null;
-        this.introspectedInstanceUrl = null;
+        this.latestRequestedUrl = null;
         this.introspectionPromises.clear();
-        this.isInitialized = false;
+        this.initializePromises.clear();
+        ConnectionManager.introspectionCache.clear();
+        try {
+            InstanceRegistry_1.InstanceRegistry.getInstance().clearIntrospectionCache();
+        }
+        catch {
+        }
     }
 }
 exports.ConnectionManager = ConnectionManager;