fix: waitForToken

Signed-off-by: Roman Nikitenko <rnikiten@redhat.com>

Author: RomanNikitenko

code/extensions/che-github-authentication/src/extension.ts

@@ -47,11 +47,9 @@ export async function activate(context: vscode.ExtensionContext): Promise<void>
     const deviceAuthentication = container.get(DeviceAuthentication);
     authenticationProvider.setDeviceAuthentication(deviceAuthentication);
 
-    await authenticationProvider.hydrateFromK8sToken();
-
     vscode.authentication.registerAuthenticationProvider('github', 'GitHub', authenticationProvider);
 
-    await authenticationProvider.notifyExistingSessions();
+    authenticationProvider.hydrateFromK8sToken();
 }
 
 export function deactivate(): void {

code/extensions/che-github-authentication/src/github.ts

@@ -60,14 +60,6 @@ export class GitHubAuthProvider implements vscode.AuthenticationProvider {
     this.deviceAuthentication = deviceAuthentication;
   }
 
-  async notifyExistingSessions(): Promise<void> {
-    const sessions = await this.sessionsPromise;
-    if (sessions.length > 0) {
-      this.logger.info(`GitHubAuthProvider: notifying about ${sessions.length} existing session(s)`);
-      this.sessionChangeEmitter.fire({ added: sessions, removed: [], changed: [] });
-    }
-  }
-
   async hydrateFromK8sToken(): Promise<void> {
     let sessions = await this.sessionsPromise;
     if (sessions.length > 0) {
@@ -96,51 +88,60 @@ export class GitHubAuthProvider implements vscode.AuthenticationProvider {
       }
     }
 
-    await this.tryHydrate(3, 500);
+    await this.doHydrate();
   }
 
-  private async tryHydrate(maxAttempts: number, delayMs: number): Promise<void> {
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+  private async waitForToken(timeoutMs: number, intervalMs: number): Promise<string | undefined> {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
       try {
-        const token = await this.githubService.getToken();
-        const tokenScopes = await this.githubService.getTokenScopes(token);
-        if (tokenScopes.length === 0) {
-          this.logger.info('GitHubAuthProvider: hydrate skipped, token has no scopes');
-          return;
-        }
+        return await this.githubService.getToken();
+      } catch {
+        await new Promise(resolve => setTimeout(resolve, intervalMs));
+      }
+    }
+    return undefined;
+  }
 
-        const githubUser = await this.githubService.getUser();
-        const matchingBundles = getMatchingHydrationScopeBundles(tokenScopes);
-        if (matchingBundles.length === 0) {
-          this.logger.info('GitHubAuthProvider: hydrate skipped, token scopes match no known bundle');
-          return;
-        }
+  private async doHydrate(): Promise<void> {
+    const token = await this.waitForToken(30000, 500);
+    if (!token) {
+      this.logger.warn('GitHubAuthProvider: hydrate failed, token not available after 30s');
+      return;
+    }
 
-        const isDeviceAuthToken = await this.githubService.isDeviceAuthToken();
-        const account = { label: githubUser.login, id: githubUser.id.toString() };
-        const hydratedSessions = matchingBundles.map(scopes => ({
-          id: v4(),
-          accessToken: token,
-          account,
-          scopes: isDeviceAuthToken ? scopes : [...scopes, WORKSPACE_PAT_SCOPE],
-        }));
-
-        await this.storeSessions(hydratedSessions);
-        this.sessionChangeEmitter.fire({ added: hydratedSessions, removed: [], changed: [] });
-        const tokenSource = isDeviceAuthToken ? 'device authentication' : 'workspace PAT';
-        this.logger.info(`GitHubAuthProvider: hydrated ${hydratedSessions.length} session(s) from K8s ${tokenSource}`);
+    try {
+      const tokenScopes = await this.githubService.getTokenScopes(token);
+      if (tokenScopes.length === 0) {
+        this.logger.info('GitHubAuthProvider: hydrate skipped, token has no scopes');
         return;
-      } catch (error) {
-        if (isUnauthorizedError(error)) {
-          this.logger.warn('GitHubAuthProvider: hydrate failed, token is not valid');
-          return;
-        }
-        if (attempt < maxAttempts) {
-          this.logger.info(`GitHubAuthProvider: hydrate attempt ${attempt}/${maxAttempts} failed: ${(error as Error).message}, retrying in ${delayMs}ms`);
-          await new Promise(resolve => setTimeout(resolve, delayMs));
-        } else {
-          this.logger.warn(`GitHubAuthProvider: hydrate failed after ${maxAttempts} attempts: ${(error as Error).message}`);
-        }
+      }
+
+      const githubUser = await this.githubService.getUser();
+      const matchingBundles = getMatchingHydrationScopeBundles(tokenScopes);
+      if (matchingBundles.length === 0) {
+        this.logger.info('GitHubAuthProvider: hydrate skipped, token scopes match no known bundle');
+        return;
+      }
+
+      const isDeviceAuthToken = await this.githubService.isDeviceAuthToken();
+      const account = { label: githubUser.login, id: githubUser.id.toString() };
+      const hydratedSessions = matchingBundles.map(scopes => ({
+        id: v4(),
+        accessToken: token,
+        account,
+        scopes: isDeviceAuthToken ? scopes : [...scopes, WORKSPACE_PAT_SCOPE],
+      }));
+
+      await this.storeSessions(hydratedSessions);
+      this.sessionChangeEmitter.fire({ added: hydratedSessions, removed: [], changed: [] });
+      const tokenSource = isDeviceAuthToken ? 'device authentication' : 'workspace PAT';
+      this.logger.info(`GitHubAuthProvider: hydrated ${hydratedSessions.length} session(s) from K8s ${tokenSource}`);
+    } catch (error) {
+      if (isUnauthorizedError(error)) {
+        this.logger.warn('GitHubAuthProvider: hydrate failed, token is not valid');
+      } else {
+        this.logger.warn(`GitHubAuthProvider: hydrate failed: ${(error as Error).message}`);
       }
     }
   }