@structured-world/gitlab-mcp 6.62.2 → 7.0.2

package/dist/src/services/ConnectionManager.js

@@ -9,38 +9,59 @@ 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');
             }
@@ -54,19 +75,33 @@ class ConnectionManager {
             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);
+            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');
                 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', {
                             version: versionData.version,
                         });
-                        this.instanceInfo = {
+                        state.instanceInfo = {
                             version: versionData.version,
                             tier: versionData.enterprise ? 'premium' : 'free',
                             features: this.getDefaultFeatures(versionData.enterprise ?? false),
@@ -85,36 +120,43 @@ class ConnectionManager {
                         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) {
+                if (this.instances.get(baseUrl) !== state)
+                    return;
                 (0, logger_1.logInfo)('Using cached GraphQL introspection data');
-                this.instanceInfo = cached.instanceInfo;
-                this.schemaInfo = cached.schemaInfo;
-                this.introspectedInstanceUrl = baseUrl;
+                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...');
                 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,
@@ -122,30 +164,37 @@ class ConnectionManager {
                 });
                 (0, logger_1.logInfo)('GraphQL schema introspection completed');
             }
-            this.isInitialized = true;
+            state.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)
+                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) {
+            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) {
+    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.');
         }
-        const instanceUrl = (0, index_1.getGitLabApiUrlFromContext)() ?? this.currentInstanceUrl ?? config_1.GITLAB_BASE_URL;
-        if (this.instanceInfo && this.schemaInfo && this.introspectedInstanceUrl === instanceUrl) {
+        if (state.instanceInfo && state.schemaInfo && state.introspectedInstanceUrl === instanceUrl) {
+            return;
+        }
+        if (state.tokenScopeInfo && !state.tokenScopeInfo.hasGraphQLAccess) {
             return;
         }
         const existingPromise = this.introspectionPromises.get(instanceUrl);
@@ -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) {
+        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 = {
+                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) {
@@ -196,29 +248,22 @@ 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;
+            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 });
-            }
-        }
         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,
@@ -235,93 +280,131 @@ 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,
+            version: state.instanceInfo?.version,
+            tier: state.instanceInfo?.tier,
+            widgetTypes: state.schemaInfo?.workItemWidgetTypes.length || 0,
         });
     }
-    getClient() {
-        if (!this.client) {
+    resolveState(instanceUrl) {
+        const url = instanceUrl ? (0, url_1.normalizeInstanceUrl)(instanceUrl) : this.currentInstanceUrl;
+        if (!url) {
             throw new Error('Connection not initialized. Call initialize() first.');
         }
-        return this.client;
+        const state = this.instances.get(url);
+        if (!state) {
+            throw new Error(`Connection not initialized for ${url}. Call initialize() first.`);
+        }
+        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;
+    }
+    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];
     }
-    getTier() {
-        if (!this.instanceInfo) {
+    getTier(instanceUrl) {
+        const url = instanceUrl ? (0, url_1.normalizeInstanceUrl)(instanceUrl) : this.currentInstanceUrl;
+        if (!url)
             return 'unknown';
-        }
-        return this.instanceInfo.tier;
+        const state = this.instances.get(url);
+        if (!state?.instanceInfo)
+            return 'unknown';
+        return state.instanceInfo.tier;
     }
-    getVersion() {
-        if (!this.instanceInfo) {
+    getVersion(instanceUrl) {
+        const url = instanceUrl ? (0, url_1.normalizeInstanceUrl)(instanceUrl) : this.currentInstanceUrl;
+        if (!url)
             return 'unknown';
-        }
-        return this.instanceInfo.version;
+        const state = this.instances.get(url);
+        if (!state?.instanceInfo)
+            return 'unknown';
+        return state.instanceInfo.version;
     }
-    isWidgetAvailable(widgetType) {
-        if (!this.schemaIntrospector) {
+    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;
         }
@@ -330,8 +413,12 @@ class ConnectionManager {
             !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', {
                 previousScopes,
                 newScopes,
@@ -341,10 +428,10 @@ 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',
@@ -407,31 +494,69 @@ class ConnectionManager {
             emailParticipants: true,
         };
     }
-    async reinitialize(newInstanceUrl) {
+    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);
+        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: this.instanceInfo?.version,
-            tier: this.instanceInfo?.tier,
+            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;