Use a non-blocking message when not signed in

joshmgross · joshmgross · commit c32fc8d46cc8 · 2023-03-13T16:02:18.000-04:00
diff --git a/src/api/handleSamlError.ts b/src/api/handleSamlError.ts
@@ -1,17 +1,21 @@
 import {Octokit} from "@octokit/rest";
-import {getSession} from "../auth/auth";
+import {AuthenticationSession} from "vscode";
+
+import {newSession} from "../auth/auth";
 import {logDebug} from "../log";
 import {getClient} from "./api";
 
-export async function handleSamlError<T>(request: (client: Octokit) => Promise<T>): Promise<T> {
+export async function handleSamlError<T>(
+  session: AuthenticationSession,
+  request: (client: Octokit) => Promise<T>
+): Promise<T> {
   try {
-    const session = await getSession();
     const client = getClient(session.accessToken);
     return await request(client);
   } catch (error) {
     if ((error as Error).message.includes("Resource protected by organization SAML enforcement.")) {
       logDebug("SAML error, re-authenticating");
-      const session = await getSession(
+      const session = await newSession(
         "Your organization is protected by SAML enforcement. Please sign-in again to continue."
       );
       const client = getClient(session.accessToken);
diff --git a/src/auth/auth.ts b/src/auth/auth.ts
@@ -3,23 +3,56 @@ import * as vscode from "vscode";
 const AUTH_PROVIDER_ID = "github";
 const DEFAULT_SCOPES = ["repo", "workflow"];
 
+let signInPrompted = false;
+
+const SESSION_ERROR = "Could not get token from the GitHub authentication provider. \nPlease sign-in and allow access.";
+
 /**
- * Retrieves a session from the GitHub authentication provider
- * @param forceMessage Force a new session with a prompt to the user
+ * Creates a session from the GitHub authentication provider
+ * @param forceMessage Prompt to the user when forcing a new session
  * @returns A {@link vscode.AuthenticationSession}
  */
-export async function getSession(forceMessage?: string): Promise<vscode.AuthenticationSession> {
-  // forceNewSession and createIfNone are mutually exclusive
-  const options: vscode.AuthenticationGetSessionOptions = forceMessage
-    ? {forceNewSession: {detail: forceMessage}}
-    : {createIfNone: true};
-  const existingSession = await vscode.authentication.getSession(AUTH_PROVIDER_ID, getScopes(), options);
+export async function newSession(forceMessage: string): Promise<vscode.AuthenticationSession> {
+  const session = await getSessionInternal(forceMessage);
+  if (session) {
+    return session;
+  }
+  throw new Error(SESSION_ERROR);
+}
 
-  if (!existingSession) {
-    throw new Error("Could not get token from the GitHub authentication provider. \nPlease sign-in and allow access.");
+/**
+ * Retrieves a session from the GitHub authentication provider or prompts the user to sign in
+ * @returns A {@link vscode.AuthenticationSession} or undefined
+ */
+export async function getSession(): Promise<vscode.AuthenticationSession | undefined> {
+  const session = await getSessionInternal(false);
+  if (session || signInPrompted) {
+    return session;
   }
 
-  return existingSession;
+  signInPrompted = true;
+  const signInAction = "Sign in to GitHub";
+  const result = await vscode.window.showInformationMessage(
+    "Sign in to GitHub to access your repositories and GitHub Actions workflows.",
+    signInAction
+  );
+  if (result === signInAction) {
+    return await getSessionInternal(true);
+  }
+  throw new Error(SESSION_ERROR);
+}
+
+async function getSessionInternal(forceNewMessage: string): Promise<vscode.AuthenticationSession | undefined>;
+async function getSessionInternal(createIfNone: boolean): Promise<vscode.AuthenticationSession | undefined>;
+async function getSessionInternal(
+  createOrForceMessage: string | boolean = false
+): Promise<vscode.AuthenticationSession | undefined> {
+  // forceNewSession and createIfNone are mutually exclusive
+  const options: vscode.AuthenticationGetSessionOptions =
+    typeof createOrForceMessage === "string"
+      ? {forceNewSession: {detail: createOrForceMessage}}
+      : {createIfNone: createOrForceMessage};
+  return await vscode.authentication.getSession(AUTH_PROVIDER_ID, getScopes(), options);
 }
 
 function getScopes(): string[] {
diff --git a/src/git/repository.ts b/src/git/repository.ts
@@ -163,9 +163,13 @@ export async function getGitHubContext(): Promise<GitHubContext | undefined> {
     logDebug("Found protocol infos", protocolInfos.length.toString());
 
     const session = await getSession();
+    if (!session) {
+      // User is not signed in, getSession will prompt them to sign in
+      return undefined;
+    }
     const username = session.account.label;
 
-    const repos = await handleSamlError(async (client: Octokit) => {
+    const repos = await handleSamlError(session, async (client: Octokit) => {
       return await Promise.all(
         protocolInfos.map(async (protocolInfo): Promise<GitHubRepoContext> => {
           logDebug("Getting infos for repository", protocolInfo.url);
diff --git a/src/workflow/languageServer.ts b/src/workflow/languageServer.ts
@@ -24,7 +24,7 @@ export async function initLanguageServer(context: vscode.ExtensionContext) {
 
   const ghContext = await getGitHubContext();
   const initializationOptions: InitializationOptions = {
-    sessionToken: session.accessToken,
+    sessionToken: session?.accessToken,
     userAgent: userAgent,
     repos: ghContext?.repos.map(repo => ({
       id: repo.id,
