OAuth2 VSCode

package.json

@@ -1718,7 +1718,7 @@
   },
   "devDependencies": {
     "@eslint/js": "^9.39.2",
-    "@intersystems-community/intersystems-servermanager": "^3.10.2",
+    "@intersystems-community/intersystems-servermanager": "^3.14.0",
     "@types/istextorbinary": "2.3.1",
     "@types/minimatch": "6.0.0",
     "@types/mocha": "^10.0.10",

src/api/index.ts

@@ -19,6 +19,7 @@ const DEFAULT_API_VERSION = 1;
 const DEFAULT_SERVER_VERSION = "2016.2.0";
 import * as Atelier from "./atelier";
 import { isfsConfig } from "../utils/FileProviderUtil";
+import { Authorization, IServerSpec } from "@intersystems-community/intersystems-servermanager";
 
 // Map of the authRequest promises for each `username@http(s)://host:port/pathPrefix` target to avoid concurrency issues
 const authRequestMap = new Map<string, Promise<any>>();
@@ -46,20 +47,19 @@ export async function logoutOfSessions(sessions?: string[]): Promise<void> {
   ).then(() => {}); // Returned object isn't needed
 }
 
-interface ConnectionSettings {
+export interface ConnectionSettings {
   serverName: string;
   active: boolean;
-  apiVersion: number;
-  serverVersion: string;
+  apiVersion?: number;
+  serverVersion?: string;
   https: boolean;
   host: string;
   port: number;
   superserverPort?: number;
-  pathPrefix: string;
+  pathPrefix?: string;
   ns: string;
-  username: string;
-  password: string;
-  docker: boolean;
+  auth: Authorization;
+  docker?: boolean;
   dockerService?: string;
 }
 
@@ -79,15 +79,15 @@ export class AtelierAPI {
   }
 
   public get config(): ConnectionSettings {
-    const { serverName, active = false, https = false, pathPrefix = "", username } = this._config;
+    const { serverName, active = false, https = false, pathPrefix = "", auth } = this._config;
     const ns = this.namespace || this._config.ns;
     const wsKey = this.configName.toLowerCase();
     const host = this.externalServer ? this._config.host : workspaceState.get(wsKey + ":host", this._config.host);
     const port = this.externalServer ? this._config.port : workspaceState.get(wsKey + ":port", this._config.port);
     const superserverPort = this.externalServer
       ? this._config.superserverPort
       : workspaceState.get(wsKey + ":superserverPort", this._config.superserverPort);
-    const password = workspaceState.get(wsKey + ":password", this._config.password);
+    auth.resolve({ accessToken: workspaceState.get(wsKey + ":password", undefined) });
     const apiVersion = workspaceState.get(wsKey + ":apiVersion", DEFAULT_API_VERSION);
     const serverVersion = workspaceState.get(wsKey + ":serverVersion", DEFAULT_SERVER_VERSION);
     const docker = workspaceState.get(wsKey + ":docker", false);
@@ -103,8 +103,7 @@ export class AtelierAPI {
       superserverPort,
       pathPrefix,
       ns,
-      username,
-      password,
+      auth,
       docker,
       dockerService,
     };
@@ -167,14 +166,12 @@ export class AtelierAPI {
    * Manually set the connection spec for this object,
    * where `connSpec` is the return value of `getResolvedConnectionSpec()`.
    */
-  public setConnSpec(serverName: string, connSpec: any): void {
+  public setConnSpec(serverName: string, connSpec: IServerSpec): void {
     const {
       webServer: { scheme, host, port, pathPrefix = "" },
-      username,
-      password,
+      auth,
     } = connSpec;
-    this._config.username = username;
-    this._config.password = password;
+    this._config.auth = auth;
     this._config.https = scheme == "https";
     this._config.host = host;
     this._config.port = port;
@@ -225,12 +222,12 @@ export class AtelierAPI {
 
   /** Return the key for getting values from connection-specific Maps for this connection */
   public mapKey(): string {
-    const { host, https, port, username } = this.config;
+    const { host, https, port, auth } = this.config;
     let pathPrefix = this._config.pathPrefix || "";
     if (pathPrefix.length && !pathPrefix.startsWith("/")) {
       pathPrefix = "/" + pathPrefix;
     }
-    return `${username}@http${https ? "s" : ""}://${host}:${port}${pathPrefix}`;
+    return `${auth.username}@http${https ? "s" : ""}://${host}:${port}${pathPrefix}`;
   }
 
   private setConnection(workspaceFolderName: string, namespace?: string): void {
@@ -255,8 +252,7 @@ export class AtelierAPI {
     if (serverName !== "") {
       const {
         webServer: { scheme, host, port, pathPrefix = "" },
-        username,
-        password,
+        auth,
         superServer,
       } = getResolvedConnectionSpec(serverName, config("intersystems.servers", workspaceFolderName).get(serverName));
       this._config = {
@@ -269,8 +265,7 @@ export class AtelierAPI {
         host,
         port,
         superserverPort: superServer?.port,
-        username,
-        password,
+        auth,
         pathPrefix,
         docker: false,
       };
@@ -280,8 +275,7 @@ export class AtelierAPI {
       if (resolvedSpec) {
         const {
           webServer: { scheme, host, port, pathPrefix = "" },
-          username,
-          password,
+          auth,
           superServer,
         } = resolvedSpec;
         this._config = {
@@ -294,21 +288,24 @@ export class AtelierAPI {
           host,
           port,
           superserverPort: superServer?.port,
-          username,
-          password,
+          auth,
           pathPrefix,
           docker: true,
           dockerService: conn["docker-compose"].service,
         };
       } else {
-        this._config = conn;
-        this._config.ns = ns;
-        this._config.serverName = "";
+        this._config = {
+          ...conn,
+          ns,
+          serverName: "",
+        };
       }
     } else {
-      this._config = conn;
-      this._config.ns = ns;
-      this._config.serverName = "";
+      this._config = {
+        ...conn,
+        ns,
+        serverName: "",
+      };
     }
   }
 
@@ -332,7 +329,7 @@ export class AtelierAPI {
     headers?: any,
     options?: any
   ): Promise<any> {
-    const { active, apiVersion, host, port, username, password, https } = this.config;
+    const { active, apiVersion, host, port, https } = this.config;
     if (!active || !port || !host) {
       return Promise.reject();
     }
@@ -385,12 +382,11 @@ export class AtelierAPI {
     let auth: Promise<any>;
     let authRequest = authRequestMap.get(mapKey);
     if (cookies.length || (method === "HEAD" && !originalPath)) {
-      auth = Promise.resolve(cookies);
-
       // Only send basic authorization if username and password specified (including blank, for unauthenticated access)
-      if (typeof username === "string" && typeof password === "string") {
-        headers["Authorization"] = `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`;
+      if (!cookies.length && this.config.auth.resolved()) {
+        headers["Authorization"] = this.config.auth.httpAuthorizationHeader;
       }
+      auth = Promise.resolve(cookies);
     } else if (!cookies.length) {
       if (!authRequest) {
         // Recursion point
@@ -465,7 +461,7 @@ export class AtelierAPI {
         if (this.wsOrFile && !checkingConnection) {
           setTimeout(() => {
             checkConnection(
-              password ? true : false,
+              this.config.auth.resolved(),
               typeof this.wsOrFile === "object" ? this.wsOrFile : undefined,
               true
             );

src/commands/connectFolderToServerNamespace.ts

@@ -7,7 +7,7 @@ import {
   serverManagerApi,
   resolveUsernameAndPassword,
 } from "../extension";
-import { handleError, isUnauthenticated, notIsfs, displayableUri } from "../utils";
+import { handleError, notIsfs, displayableUri } from "../utils";
 
 interface ConnSettings {
   server: string;
@@ -80,7 +80,7 @@ export async function connectFolderToServerNamespace(): Promise<void> {
     .serverInfo(false)
     .then((data) => data.result.content.namespaces)
     .catch(async (error) => {
-      if (error?.statusCode == 401 && isUnauthenticated(api.config.username)) {
+      if (error?.statusCode == 401 && !api.config.auth.resolved()) {
         // Attempt to resolve username and password and try again
         const newSpec = await resolveUsernameAndPassword(api.config.serverName, connSpec);
         if (newSpec) {

src/commands/restDebugPanel.ts

@@ -501,8 +501,8 @@ export class RESTDebugPanel {
           form.onchange = () => sendData(false);
           button.onclick = () => sendData(true);
           // Bubble change events up to the form
-          bodyContent.onchange = headersText.onchange = 
-            paramsText.onchange = path.onchange = 
+          bodyContent.onchange = headersText.onchange =
+            paramsText.onchange = path.onchange =
             () => form.dispatchEvent(new Event("change"));
         </script>
 			</body>
@@ -548,16 +548,7 @@ export class RESTDebugPanel {
                   .trim();
               }
             });
-            if (
-              headers["authorization"] == undefined &&
-              typeof api.config.username === "string" &&
-              typeof api.config.password === "string"
-            ) {
-              // Use the server connection's auth if the user didn't specify any
-              headers["authorization"] = `Basic ${Buffer.from(`${api.config.username}:${api.config.password}`).toString(
-                "base64"
-              )}`;
-            }
+            headers["authorization"] = headers["authorization"] ?? (api.config.auth.httpAuthorizationHeader || "");
             const hasBody =
               typeof message.bodyContent == "string" && message.bodyContent != "" && message.bodyType != "No Body";
             if (hasBody) {

src/commands/serverActions.ts

@@ -25,7 +25,7 @@ type ServerAction = { detail: string; id: string; label: string; rawLink?: strin
 export async function serverActions(): Promise<void> {
   const { apiTarget, configName: workspaceFolder } = connectionTarget();
   const api = new AtelierAPI(apiTarget);
-  const { active, host = "", ns = "", https, port = 0, pathPrefix, username, docker } = api.config;
+  const { active, host = "", ns = "", https, port = 0, pathPrefix, auth, docker } = api.config;
   const explorerCount = (await explorerProvider.getChildren()).length;
   if (!explorerCount && (!docker || host === "")) {
     await vscode.commands.executeCommand("ObjectScriptExplorer.focus");
@@ -152,7 +152,7 @@ export async function serverActions(): Promise<void> {
       .replace("${serverAuth}", "")
       .replace("${ns}", nsEncoded)
       .replace("${namespace}", ns == "%SYS" ? "sys" : nsEncoded.toLowerCase())
-      .replace("${username}", username)
+      .replace("${username}", auth.username)
       .replace("${classname}", classname)
       .replace("${classnameEncoded}", classnameEncoded)
       .replace("${project}", project);
@@ -248,7 +248,10 @@ export async function serverActions(): Promise<void> {
             if (addin) {
               sendStudioAddinTelemetryEvent(addin.label);
               let params = `Namespace=${nsEncoded}`;
-              params += `&User=${encodeURIComponent(username)}`;
+              const username = auth.username;
+              if (!username.includes("*")) {
+                params += `&User=${encodeURIComponent(username)}`;
+              }
               if (project != "") {
                 params += `&Project=${encodeURIComponent(project)}`;
               }

src/commands/webSocketTerminal.ts

@@ -224,8 +224,12 @@ class WebSocketTerminal implements vscode.Pseudoterminal {
     // Set terminal properties
     this._hideCursorWrite("\x1b]633;P;HasRichCommandDetection=True\x07");
     // Print the opening message
+    const username = api.config.auth.username;
+    const identity = username.includes("*")
+      ? `using \x1b[0m\x1b[3m${username.slice(1, -1)}\x1b[0m\r\n`
+      : `as \x1b[0m\x1b[3m${username}\x1b[0m\r\n`;
     this._hideCursorWrite(
-      `\x1b[32mConnected to \x1b[0m\x1b[4m${api.config.host}:${api.config.port}${api.config.pathPrefix}\x1b[0m\x1b[32m as \x1b[0m\x1b[3m${api.config.username}\x1b[0m\r\n`
+      `\x1b[32mConnected to \x1b[0m\x1b[4m${api.config.host}:${api.config.port}${api.config.pathPrefix}\x1b[0m\x1b[32m ${identity}`
     );
     // Add event handlers to the socket
     this._socket