simp

Author: isc-klu

src/api/index.ts

@@ -67,10 +67,7 @@ export class AtelierAPI {
     const superserverPort = this.externalServer
       ? this._config.superserverPort
       : workspaceState.get(wsKey + ":superserverPort", this._config.superserverPort);
-    const accessToken = workspaceState.get(wsKey + ":password", undefined);
-    if (accessToken !== undefined) {
-      auth.resolve({ accessToken });
-    }
+    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);
@@ -365,6 +362,10 @@ export class AtelierAPI {
     let auth: Promise<any>;
     let authRequest = authRequestMap.get(mapKey);
     if (cookies.length || (method === "HEAD" && !originalPath)) {
+      // Only send basic authorization if username and password specified (including blank, for unauthenticated access)
+      if (this.config.auth.resolved()) {
+        headers["Authorization"] = this.config.auth.httpAuthorizationHeader;
+      }
       auth = Promise.resolve(cookies);
     } else if (!cookies.length) {
       if (!authRequest) {
@@ -374,10 +375,6 @@ export class AtelierAPI {
       }
       auth = authRequest;
     }
-    // Always set Authorization header if credentials are resolved
-    if (this.config.auth.resolved()) {
-      headers["Authorization"] = this.config.auth.httpAuthorizationHeader;
-    }
 
     const outputTraffic = vscode.workspace.getConfiguration("objectscript").get<boolean>("outputRESTTraffic");
     let cookie;

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, auth: authorization, 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}", authorization.username)
+      .replace("${username}", auth.username)
       .replace("${classname}", classname)
       .replace("${classnameEncoded}", classnameEncoded)
       .replace("${project}", project);
@@ -248,7 +248,7 @@ export async function serverActions(): Promise<void> {
             if (addin) {
               sendStudioAddinTelemetryEvent(addin.label);
               let params = `Namespace=${nsEncoded}`;
-              params += `&User=${encodeURIComponent(authorization.username)}`;
+              params += `&User=${encodeURIComponent(auth.username)}`;
               if (project != "") {
                 params += `&Project=${encodeURIComponent(project)}`;
               }

src/extension.ts

@@ -208,7 +208,7 @@ export let checkingConnection = false;
 export let serverManagerApi: serverManager.ServerManagerAPI;
 
 /** Map of the intersystems.server connection specs we have resolved via the API to that extension */
-const resolvedConnSpecs = new Map<string, serverManager.IServerSpec & { accessToken?: string }>();
+const resolvedConnSpecs = new Map<string, serverManager.IServerSpec>();
 
 /**
  * If servermanager extension is available, fetch the connection spec unless already cached.
@@ -267,10 +267,10 @@ export async function resolveConnectionSpec(
 }
 
 async function resolvePassword(
-  serverSpec: Pick<serverManager.IServerSpec, "name" | "auth">,
+  serverSpec: serverManager.IServerSpec,
   ignoreUnauthenticated = false
 ): Promise<string | undefined> {
-  if (!((serverSpec.auth.resolved() as boolean) || ignoreUnauthenticated)) {
+  if (!(serverSpec.auth.resolved() as boolean) || ignoreUnauthenticated) {
     const scopes = [serverSpec.name, serverSpec.auth?.username || ""];
 
     // Handle Server Manager extension version < 3.8.0
@@ -304,15 +304,14 @@ export async function resolveUsernameAndPassword(
 ): Promise<(serverManager.IServerSpec & { accessToken?: string }) | undefined> {
   const { auth: _auth, ...newSpec } = oldSpec;
   newSpec.name = serverName;
-  const auth = _auth.clone();
+  const auth = _auth?.clone();
 
   const accessToken = await resolvePassword({ ...newSpec, auth }, true);
-  if (auth.resolved()) {
+  if (auth.resolve({ accessToken })) {
     // Update the connection spec
     resolvedConnSpecs.set(serverName, {
       ...oldSpec,
       auth,
-      accessToken,
     });
     return resolvedConnSpecs.get(serverName);
   }
@@ -365,7 +364,7 @@ export async function checkConnection(
     _onDidChangeConnection.fire();
   }
   let api = new AtelierAPI(apiTarget, false);
-  const { active, host = "", port = 0, superserverPort = 0, ns = "", auth: authorization } = api.config;
+  const { active, host = "", port = 0, superserverPort = 0, ns = "", auth } = api.config;
   vscode.commands.executeCommand("setContext", "vscode-objectscript.connectActive", active);
   if (!panel.text) {
     panel.text = `${PANEL_LABEL}`;
@@ -451,10 +450,10 @@ export async function checkConnection(
     const { serverName, host, port, pathPrefix } = api.config;
     if (serverName) {
       panel.tooltip = new vscode.MarkdownString(
-        `Connected to \`${host}:${port}${pathPrefix}\` as \`${authorization.username}\``
+        `Connected to \`${host}:${port}${pathPrefix}\` as \`${auth.username}\``
       );
     } else {
-      panel.tooltip = new vscode.MarkdownString(`Connected as \`${authorization.username}\``);
+      panel.tooltip = new vscode.MarkdownString(`Connected as \`${auth.username}\``);
     }
     inactiveServerIds.delete(api.serverId);
     if (!api.externalServer) await setConnectionState(configName, true);