@azure/msal-node-extensions 1.0.0-alpha.30 → 1.0.0-alpha.32

package/dist/msal-node-extensions.cjs.development.js

@@ -10,6 +10,7 @@ var path = require('path');
 var path__default = _interopDefault(path);
 var msalCommon = require('@azure/msal-common');
 var keytar = require('keytar');
+var msalNodeRuntime = require('@azure/msal-node-runtime');
 
 /*
  * Copyright (c) Microsoft Corporation. All rights reserved.
@@ -20,35 +21,29 @@ const Constants = {
    * An existing file was the target of an operation that required that the target not exist
    */
   EEXIST_ERROR: "EEXIST",
-
   /**
    * No such file or directory: Commonly raised by fs operations to indicate that a component
    * of the specified pathname does not exist. No entity (file or directory) could be found
    * by the given path
    */
   ENOENT_ERROR: "ENOENT",
-
   /**
    * Operation not permitted. An attempt was made to perform an operation that requires
    * elevated privileges.
    */
   EPERM_ERROR: "EPERM",
-
   /**
    * Default service name for using MSAL Keytar
    */
   DEFAULT_SERVICE_NAME: "msal-node-extensions",
-
   /**
    * Test data used to verify underlying persistence mechanism
    */
   PERSISTENCE_TEST_DATA: "Dummy data to verify underlying persistence mechanism",
-
   /**
    * This is the value of a the guid if the process is being ran by the root user
    */
   LINUX_ROOT_USER_GUID: 0,
-
   /**
    * List of environment variables
    */
@@ -65,18 +60,21 @@ const Constants = {
   DEFAULT_CACHE_FILE_NAME: "cache.json"
 };
 var Platform;
-
 (function (Platform) {
   Platform["WINDOWS"] = "win32";
   Platform["LINUX"] = "linux";
   Platform["MACOS"] = "darwin";
 })(Platform || (Platform = {}));
+var ErrorCodes;
+(function (ErrorCodes) {
+  ErrorCodes["INTERATION_REQUIRED_ERROR_CODE"] = "interaction_required";
+  ErrorCodes["SERVER_UNAVAILABLE"] = "server_unavailable";
+})(ErrorCodes || (ErrorCodes = {}));
 
 /*
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the MIT License.
  */
-
 /**
  * Error thrown when trying to write MSAL cache to persistence.
  */
@@ -92,8 +90,6 @@ class PersistenceError extends Error {
   /**
    * Error thrown when trying to access the file system.
    */
-
-
   static createFileSystemError(errorCode, errorMessage) {
     return new PersistenceError(errorCode, errorMessage);
   }
@@ -101,32 +97,24 @@ class PersistenceError extends Error {
    * Error thrown when trying to write, load, or delete data from secret service on linux.
    * Libsecret is used to access secret service.
    */
-
-
   static createLibSecretError(errorMessage) {
     return new PersistenceError("GnomeKeyringError", errorMessage);
   }
   /**
    * Error thrown when trying to write, load, or delete data from keychain on macOs.
    */
-
-
   static createKeychainPersistenceError(errorMessage) {
     return new PersistenceError("KeychainError", errorMessage);
   }
   /**
    * Error thrown when trying to encrypt or decrypt data using DPAPI on Windows.
    */
-
-
   static createFilePersistenceWithDPAPIError(errorMessage) {
     return new PersistenceError("DPAPIEncryptedFileError", errorMessage);
   }
   /**
    * Error thrown when using the cross platform lock.
    */
-
-
   static createCrossPlatformLockError(errorMessage) {
     return new PersistenceError("CrossPlatformLockError", errorMessage);
   }
@@ -136,8 +124,6 @@ class PersistenceError extends Error {
    * @param errorMessage string
    * @returns PersistenceError
    */
-
-
   static createCachePersistenceError(errorMessage) {
     return new PersistenceError("CachePersistenceError", errorMessage);
   }
@@ -147,8 +133,6 @@ class PersistenceError extends Error {
    * @param errorMessage string
    * @returns PersistenceError
    */
-
-
   static createNotSupportedError(errorMessage) {
     return new PersistenceError("NotSupportedError", errorMessage);
   }
@@ -158,8 +142,6 @@ class PersistenceError extends Error {
    * @param errorMessage string
    * @returns PersistenceError
    */
-
-
   static createPersistenceNotVerifiedError(errorMessage) {
     return new PersistenceError("PersistenceNotVerifiedError", errorMessage);
   }
@@ -169,12 +151,9 @@ class PersistenceError extends Error {
    * @param errorMessage string
    * @returns PersistenceError
    */
-
-
   static createPersistenceNotValidatedError(errorMessage) {
     return new PersistenceError("PersistenceNotValidatedError", errorMessage);
   }
-
 }
 
 /*
@@ -184,7 +163,6 @@ class PersistenceError extends Error {
 /**
  * Cross-process lock that works on all platforms.
  */
-
 class CrossPlatformLock {
   constructor(lockFilePath, logger, lockOptions) {
     this.lockFilePath = lockFilePath;
@@ -197,8 +175,6 @@ class CrossPlatformLock {
    * cache file but with .lockfile extension. If another process has already created
    * the lockfile, will back off and retry based on configuration settings set by CrossPlatformLockOptions
    */
-
-
   async lock() {
     for (let tryCount = 0; tryCount < this.retryNumber; tryCount++) {
       try {
@@ -217,15 +193,12 @@ class CrossPlatformLock {
         }
       }
     }
-
     this.logger.error(`${process$1.pid} was not able to acquire lock. Exceeded amount of retries set in the options`);
     throw PersistenceError.createCrossPlatformLockError("Not able to acquire lock. Exceeded amount of retries set in options");
   }
   /**
    * unlocks cache file by deleting .lockfile.
    */
-
-
   async unlock() {
     try {
       if (this.lockFileHandle) {
@@ -245,13 +218,11 @@ class CrossPlatformLock {
       }
     }
   }
-
   sleep(ms) {
     return new Promise(resolve => {
       setTimeout(resolve, ms);
     });
   }
-
 }
 
 /*
@@ -271,16 +242,15 @@ class CrossPlatformLock {
  * - LibSecretPersistence: Used on linux, writes and reads from secret service API. Requires
  * libsecret be installed.
  */
-
 class PersistenceCachePlugin {
   constructor(persistence, lockOptions) {
-    this.persistence = persistence; // initialize logger
-
-    this.logger = persistence.getLogger(); // create file lock
-
+    this.persistence = persistence;
+    // initialize logger
+    this.logger = persistence.getLogger();
+    // create file lock
     this.lockFilePath = `${this.persistence.getFilePath()}.lockfile`;
-    this.crossPlatformLock = new CrossPlatformLock(this.lockFilePath, this.logger, lockOptions); // initialize default values
-
+    this.crossPlatformLock = new CrossPlatformLock(this.lockFilePath, this.logger, lockOptions);
+    // initialize default values
     this.lastSync = 0;
     this.currentCache = null;
   }
@@ -292,21 +262,16 @@ class PersistenceCachePlugin {
    * afterCacheAccess() is called, to prevent the cache file from changing in between
    * beforeCacheAccess() and afterCacheAccess().
    */
-
-
   async beforeCacheAccess(cacheContext) {
     this.logger.info("Executing before cache access");
     const reloadNecessary = await this.persistence.reloadNecessary(this.lastSync);
-
     if (!reloadNecessary && this.currentCache !== null) {
       if (cacheContext.cacheHasChanged) {
         this.logger.verbose("Cache context has changed");
         await this.crossPlatformLock.lock();
       }
-
       return;
     }
-
     try {
       this.logger.info(`Reload necessary. Last sync time: ${this.lastSync}`);
       await this.crossPlatformLock.lock();
@@ -326,11 +291,8 @@ class PersistenceCachePlugin {
   /**
    * Writes to storage if MSAL in memory copy of cache has been changed.
    */
-
-
   async afterCacheAccess(cacheContext) {
     this.logger.info("Executing after cache access");
-
     try {
       if (cacheContext.cacheHasChanged) {
         this.logger.info("Msal in-memory cache has changed. Writing changes to persistence");
@@ -344,7 +306,6 @@ class PersistenceCachePlugin {
       this.logger.info(`Pid ${process$1.pid} afterCacheAccess released lock`);
     }
   }
-
 }
 
 /*
@@ -355,28 +316,23 @@ class BasePersistence {
   async verifyPersistence() {
     // We are using a different location for the test to avoid overriding the functional cache
     const persistenceValidator = await this.createForPersistenceValidation();
-
     try {
       await persistenceValidator.save(Constants.PERSISTENCE_TEST_DATA);
       const retrievedDummyData = await persistenceValidator.load();
-
       if (!retrievedDummyData) {
         throw PersistenceError.createCachePersistenceError("Persistence check failed. Data was written but it could not be read. " + "Possible cause: on Linux, LibSecret is installed but D-Bus isn't running \
                     because it cannot be started over SSH.");
       }
-
       if (retrievedDummyData !== Constants.PERSISTENCE_TEST_DATA) {
         throw PersistenceError.createCachePersistenceError(`Persistence check failed. Data written ${Constants.PERSISTENCE_TEST_DATA} is different \
                     from data read ${retrievedDummyData}`);
       }
-
       await persistenceValidator.delete();
       return true;
     } catch (e) {
       throw PersistenceError.createCachePersistenceError(`Verifing persistence failed with the error: ${e}`);
     }
   }
-
 }
 
 /*
@@ -390,7 +346,6 @@ class BasePersistence {
  * If file or directory has not been created, it FilePersistence.create() will create
  * file and any directories in the path recursively.
  */
-
 class FilePersistence extends BasePersistence {
   static async create(fileLocation, loggerOptions) {
     const filePersistence = new FilePersistence();
@@ -399,7 +354,6 @@ class FilePersistence extends BasePersistence {
     await filePersistence.createCacheFile();
     return filePersistence;
   }
-
   async save(contents) {
     try {
       await fs.promises.writeFile(this.getFilePath(), contents, "utf-8");
@@ -407,7 +361,6 @@ class FilePersistence extends BasePersistence {
       throw PersistenceError.createFileSystemError(err.code, err.message);
     }
   }
-
   async saveBuffer(contents) {
     try {
       await fs.promises.writeFile(this.getFilePath(), contents);
@@ -415,7 +368,6 @@ class FilePersistence extends BasePersistence {
       throw PersistenceError.createFileSystemError(err.code, err.message);
     }
   }
-
   async load() {
     try {
       return await fs.promises.readFile(this.getFilePath(), "utf-8");
@@ -423,7 +375,6 @@ class FilePersistence extends BasePersistence {
       throw PersistenceError.createFileSystemError(err.code, err.message);
     }
   }
-
   async loadBuffer() {
     try {
       return await fs.promises.readFile(this.getFilePath());
@@ -431,7 +382,6 @@ class FilePersistence extends BasePersistence {
       throw PersistenceError.createFileSystemError(err.code, err.message);
     }
   }
-
   async delete() {
     try {
       await fs.promises.unlink(this.getFilePath());
@@ -442,37 +392,31 @@ class FilePersistence extends BasePersistence {
         this.logger.warning("Cache file does not exist, so it could not be deleted");
         return false;
       }
-
       throw PersistenceError.createFileSystemError(err.code, err.message);
     }
   }
-
   getFilePath() {
     return this.filePath;
   }
-
   async reloadNecessary(lastSync) {
     return lastSync < (await this.timeLastModified());
   }
-
   getLogger() {
     return this.logger;
   }
-
   createForPersistenceValidation() {
     const testCacheFileLocation = `${path.dirname(this.filePath)}/test.cache`;
     return FilePersistence.create(testCacheFileLocation);
   }
-
   static createDefaultLoggerOptions() {
     return {
-      loggerCallback: () => {// allow users to not set loggerCallback
+      loggerCallback: () => {
+        // allow users to not set loggerCallback
       },
       piiLoggingEnabled: false,
       logLevel: msalCommon.LogLevel.Info
     };
   }
-
   async timeLastModified() {
     try {
       const stats = await fs.promises.stat(this.filePath);
@@ -483,19 +427,16 @@ class FilePersistence extends BasePersistence {
         this.logger.verbose("Cache file does not exist");
         return 0;
       }
-
       throw PersistenceError.createFileSystemError(err.code, err.message);
     }
   }
-
   async createCacheFile() {
-    await this.createFileDirectory(); // File is created only if it does not exist
-
+    await this.createFileDirectory();
+    // File is created only if it does not exist
     const fileHandle = await fs.promises.open(this.filePath, "a");
     await fileHandle.close();
     this.logger.info(`File created at ${this.filePath}`);
   }
-
   async createFileDirectory() {
     try {
       await fs.promises.mkdir(path.dirname(this.filePath), {
@@ -509,14 +450,12 @@ class FilePersistence extends BasePersistence {
       }
     }
   }
-
 }
 
 /*
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the MIT License.
  */
-
 /* eslint-disable-next-line @typescript-eslint/no-var-requires, no-var, import/no-commonjs */
 var Dpapi = /*#__PURE__*/require("../build/Release/dpapi.node");
 
@@ -524,7 +463,6 @@ var Dpapi = /*#__PURE__*/require("../build/Release/dpapi.node");
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the MIT License.
  */
-
 (function (DataProtectionScope) {
   DataProtectionScope["CurrentUser"] = "CurrentUser";
   DataProtectionScope["LocalMachine"] = "LocalMachine";
@@ -540,20 +478,17 @@ var Dpapi = /*#__PURE__*/require("../build/Release/dpapi.node");
  * scope: Scope of the data protection. Either local user or the current machine
  * optionalEntropy: Password or other additional entropy used to encrypt the data
  */
-
 class FilePersistenceWithDataProtection extends BasePersistence {
   constructor(scope, optionalEntropy) {
     super();
     this.scope = scope;
     this.optionalEntropy = optionalEntropy ? Buffer.from(optionalEntropy, "utf-8") : null;
   }
-
   static async create(fileLocation, scope, optionalEntropy, loggerOptions) {
     const persistence = new FilePersistenceWithDataProtection(scope, optionalEntropy);
     persistence.filePersistence = await FilePersistence.create(fileLocation, loggerOptions);
     return persistence;
   }
-
   async save(contents) {
     try {
       const encryptedContents = Dpapi.protectData(Buffer.from(contents, "utf-8"), this.optionalEntropy, this.scope.toString());
@@ -562,43 +497,34 @@ class FilePersistenceWithDataProtection extends BasePersistence {
       throw PersistenceError.createFilePersistenceWithDPAPIError(err.message);
     }
   }
-
   async load() {
     try {
       const encryptedContents = await this.filePersistence.loadBuffer();
-
       if (typeof encryptedContents === "undefined" || !encryptedContents || 0 === encryptedContents.length) {
         this.filePersistence.getLogger().info("Encrypted contents loaded from file were null or empty");
         return null;
       }
-
       return Dpapi.unprotectData(encryptedContents, this.optionalEntropy, this.scope.toString()).toString();
     } catch (err) {
       throw PersistenceError.createFilePersistenceWithDPAPIError(err.message);
     }
   }
-
   async delete() {
     return this.filePersistence.delete();
   }
-
   async reloadNecessary(lastSync) {
     return this.filePersistence.reloadNecessary(lastSync);
   }
-
   getFilePath() {
     return this.filePersistence.getFilePath();
   }
-
   getLogger() {
     return this.filePersistence.getLogger();
   }
-
   createForPersistenceValidation() {
     const testCacheFileLocation = `${path.dirname(this.filePersistence.getFilePath())}/test.cache`;
     return FilePersistenceWithDataProtection.create(testCacheFileLocation, exports.DataProtectionScope.CurrentUser);
   }
-
 }
 
 /*
@@ -611,31 +537,26 @@ class FilePersistenceWithDataProtection extends BasePersistence {
  * serviceName: Identifier used as key for whatever value is stored
  * accountName: Account under which password should be stored
  */
-
 class KeychainPersistence extends BasePersistence {
   constructor(serviceName, accountName) {
     super();
     this.serviceName = serviceName;
     this.accountName = accountName;
   }
-
   static async create(fileLocation, serviceName, accountName, loggerOptions) {
     const persistence = new KeychainPersistence(serviceName, accountName);
     persistence.filePersistence = await FilePersistence.create(fileLocation, loggerOptions);
     return persistence;
   }
-
   async save(contents) {
     try {
       await keytar.setPassword(this.serviceName, this.accountName, contents);
     } catch (err) {
       throw PersistenceError.createKeychainPersistenceError(err.message);
-    } // Write dummy data to update file mtime
-
-
+    }
+    // Write dummy data to update file mtime
     await this.filePersistence.save("{}");
   }
-
   async load() {
     try {
       return await keytar.getPassword(this.serviceName, this.accountName);
@@ -643,7 +564,6 @@ class KeychainPersistence extends BasePersistence {
       throw PersistenceError.createKeychainPersistenceError(err.message);
     }
   }
-
   async delete() {
     try {
       await this.filePersistence.delete();
@@ -652,24 +572,19 @@ class KeychainPersistence extends BasePersistence {
       throw PersistenceError.createKeychainPersistenceError(err.message);
     }
   }
-
   async reloadNecessary(lastSync) {
     return this.filePersistence.reloadNecessary(lastSync);
   }
-
   getFilePath() {
     return this.filePersistence.getFilePath();
   }
-
   getLogger() {
     return this.filePersistence.getLogger();
   }
-
   createForPersistenceValidation() {
     const testCacheFileLocation = `${path.dirname(this.filePersistence.getFilePath())}/test.cache`;
     return KeychainPersistence.create(testCacheFileLocation, "persistenceValidationServiceName", "persistencValidationAccountName");
   }
-
 }
 
 /*
@@ -683,31 +598,26 @@ class KeychainPersistence extends BasePersistence {
  * serviceName: Identifier used as key for whatever value is stored
  * accountName: Account under which password should be stored
  */
-
 class LibSecretPersistence extends BasePersistence {
   constructor(serviceName, accountName) {
     super();
     this.serviceName = serviceName;
     this.accountName = accountName;
   }
-
   static async create(fileLocation, serviceName, accountName, loggerOptions) {
     const persistence = new LibSecretPersistence(serviceName, accountName);
     persistence.filePersistence = await FilePersistence.create(fileLocation, loggerOptions);
     return persistence;
   }
-
   async save(contents) {
     try {
       await keytar.setPassword(this.serviceName, this.accountName, contents);
     } catch (err) {
       throw PersistenceError.createLibSecretError(err.message);
-    } // Write dummy data to update file mtime
-
-
+    }
+    // Write dummy data to update file mtime
     await this.filePersistence.save("{}");
   }
-
   async load() {
     try {
       return await keytar.getPassword(this.serviceName, this.accountName);
@@ -715,7 +625,6 @@ class LibSecretPersistence extends BasePersistence {
       throw PersistenceError.createLibSecretError(err.message);
     }
   }
-
   async delete() {
     try {
       await this.filePersistence.delete();
@@ -724,24 +633,19 @@ class LibSecretPersistence extends BasePersistence {
       throw PersistenceError.createLibSecretError(err.message);
     }
   }
-
   async reloadNecessary(lastSync) {
     return this.filePersistence.reloadNecessary(lastSync);
   }
-
   getFilePath() {
     return this.filePersistence.getFilePath();
   }
-
   getLogger() {
     return this.filePersistence.getLogger();
   }
-
   createForPersistenceValidation() {
     const testCacheFileLocation = `${path.dirname(this.filePersistence.getFilePath())}/test.cache`;
     return LibSecretPersistence.create(testCacheFileLocation, "persistenceValidationServiceName", "persistencValidationAccountName");
   }
-
 }
 
 /*
@@ -752,66 +656,50 @@ class Environment {
   static get homeEnvVar() {
     return this.getEnvironmentVariable(Constants.ENVIRONMENT.HOME);
   }
-
   static get lognameEnvVar() {
     return this.getEnvironmentVariable(Constants.ENVIRONMENT.LOGNAME);
   }
-
   static get userEnvVar() {
     return this.getEnvironmentVariable(Constants.ENVIRONMENT.USER);
   }
-
   static get lnameEnvVar() {
     return this.getEnvironmentVariable(Constants.ENVIRONMENT.LNAME);
   }
-
   static get usernameEnvVar() {
     return this.getEnvironmentVariable(Constants.ENVIRONMENT.USERNAME);
   }
-
   static getEnvironmentVariable(name) {
     return process.env[name];
   }
-
   static getEnvironmentPlatform() {
     return process.platform;
   }
-
   static isWindowsPlatform() {
     return this.getEnvironmentPlatform() === Platform.WINDOWS;
   }
-
   static isLinuxPlatform() {
     return this.getEnvironmentPlatform() === Platform.LINUX;
   }
-
   static isMacPlatform() {
     return this.getEnvironmentPlatform() === Platform.MACOS;
   }
-
   static isLinuxRootUser() {
     return process.getuid() === Constants.LINUX_ROOT_USER_GUID;
   }
-
   static getUserRootDirectory() {
     return !this.isWindowsPlatform ? this.getUserHomeDirOnUnix() : this.getUserHomeDirOnWindows();
   }
-
   static getUserHomeDirOnWindows() {
     return this.getEnvironmentVariable(Constants.ENVIRONMENT.LOCAL_APPLICATION_DATA);
   }
-
   static getUserHomeDirOnUnix() {
     if (this.isWindowsPlatform()) {
       throw PersistenceError.createNotSupportedError("Getting the user home directory for unix is not supported in windows");
     }
-
     if (!msalCommon.StringUtils.isEmpty(this.homeEnvVar)) {
       return this.homeEnvVar;
     }
-
     let username = null;
-
     if (!msalCommon.StringUtils.isEmpty(this.lognameEnvVar)) {
       username = this.lognameEnvVar;
     } else if (!msalCommon.StringUtils.isEmpty(this.userEnvVar)) {
@@ -821,7 +709,6 @@ class Environment {
     } else if (!msalCommon.StringUtils.isEmpty(this.usernameEnvVar)) {
       username = this.usernameEnvVar;
     }
-
     if (this.isMacPlatform()) {
       return !msalCommon.StringUtils.isEmpty(username) ? path__default.join("/Users", username) : null;
     } else if (this.isLinuxPlatform()) {
@@ -834,7 +721,6 @@ class Environment {
       throw PersistenceError.createNotSupportedError("Getting the user home directory for unix is not supported in windows");
     }
   }
-
 }
 
 /*
@@ -843,55 +729,441 @@ class Environment {
  */
 class PersistenceCreator {
   static async createPersistence(config) {
-    let peristence; // On Windows, uses a DPAPI encrypted file
-
+    let peristence;
+    // On Windows, uses a DPAPI encrypted file
     if (Environment.isWindowsPlatform()) {
       if (!config.cachePath || !config.dataProtectionScope) {
         throw PersistenceError.createPersistenceNotValidatedError("Cache path and/or data protection scope not provided for the FilePersistenceWithDataProtection cache plugin");
       }
-
       peristence = await FilePersistenceWithDataProtection.create(config.cachePath, exports.DataProtectionScope.CurrentUser, undefined, config.loggerOptions);
-    } // On Mac, uses keychain.
+    }
+    // On Mac, uses keychain.
     else if (Environment.isMacPlatform()) {
-        if (!config.cachePath || !config.serviceName || !config.accountName) {
-          throw PersistenceError.createPersistenceNotValidatedError("Cache path, service name and/or account name not provided for the KeychainPersistence cache plugin");
-        }
-
-        peristence = await KeychainPersistence.create(config.cachePath, config.serviceName, config.accountName, config.loggerOptions);
-      } // On Linux, uses  libsecret to store to secret service. Libsecret has to be installed.
-      else if (Environment.isLinuxPlatform()) {
-          if (!config.cachePath || !config.serviceName || !config.accountName) {
-            throw PersistenceError.createPersistenceNotValidatedError("Cache path, service name and/or account name not provided for the LibSecretPersistence cache plugin");
-          }
-
-          peristence = await LibSecretPersistence.create(config.cachePath, config.serviceName, config.accountName, config.loggerOptions);
-        } else {
-          throw PersistenceError.createNotSupportedError("The current environment is not supported by msal-node-extensions yet.");
-        } // Initially suppress the error thrown during persistence verification to allow us to fallback to plain text
-
-
+      if (!config.cachePath || !config.serviceName || !config.accountName) {
+        throw PersistenceError.createPersistenceNotValidatedError("Cache path, service name and/or account name not provided for the KeychainPersistence cache plugin");
+      }
+      peristence = await KeychainPersistence.create(config.cachePath, config.serviceName, config.accountName, config.loggerOptions);
+    }
+    // On Linux, uses  libsecret to store to secret service. Libsecret has to be installed.
+    else if (Environment.isLinuxPlatform()) {
+      if (!config.cachePath || !config.serviceName || !config.accountName) {
+        throw PersistenceError.createPersistenceNotValidatedError("Cache path, service name and/or account name not provided for the LibSecretPersistence cache plugin");
+      }
+      peristence = await LibSecretPersistence.create(config.cachePath, config.serviceName, config.accountName, config.loggerOptions);
+    } else {
+      throw PersistenceError.createNotSupportedError("The current environment is not supported by msal-node-extensions yet.");
+    }
+    // Initially suppress the error thrown during persistence verification to allow us to fallback to plain text
     const isPersistenceVerified = await peristence.verifyPersistence().catch(() => false);
-
     if (!isPersistenceVerified) {
       if (Environment.isLinuxPlatform() && config.usePlaintextFileOnLinux) {
         if (!config.cachePath) {
           throw PersistenceError.createPersistenceNotValidatedError("Cache path not provided for the FilePersistence cache plugin");
         }
-
         peristence = await FilePersistence.create(config.cachePath, config.loggerOptions);
         const isFilePersistenceVerified = await peristence.verifyPersistence();
-
         if (isFilePersistenceVerified) {
           return peristence;
         }
       }
-
       throw PersistenceError.createPersistenceNotVerifiedError("Persistence could not be verified");
     }
-
     return peristence;
   }
+}
+
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+class NativeAuthError extends msalCommon.AuthError {
+  constructor(errorStatus, errorContext, errorCode, errorTag) {
+    super(errorStatus, errorContext);
+    this.name = "NativeAuthError";
+    this.statusCode = errorCode;
+    this.tag = errorTag;
+    Object.setPrototypeOf(this, NativeAuthError.prototype);
+  }
+}
 
+/* eslint-disable header/header */
+const name = "@azure/msal-node-extensions";
+const version = "1.0.0-alpha.32";
+
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+class NativeBrokerPlugin {
+  constructor() {
+    const defaultLoggerOptions = {
+      loggerCallback: () => {
+        // Empty logger callback
+      },
+      piiLoggingEnabled: false
+    };
+    this.logger = new msalCommon.Logger(defaultLoggerOptions, name, version); // Default logger
+    this.isBrokerAvailable = msalNodeRuntime.msalNodeRuntime.StartupError ? false : true;
+  }
+  setLogger(loggerOptions) {
+    this.logger = new msalCommon.Logger(loggerOptions, name, version);
+    const logCallback = (message, logLevel, containsPii) => {
+      switch (logLevel) {
+        case msalNodeRuntime.LogLevel.Trace:
+          if (containsPii) {
+            this.logger.tracePii(message);
+          } else {
+            this.logger.trace(message);
+          }
+          break;
+        case msalNodeRuntime.LogLevel.Debug:
+          if (containsPii) {
+            this.logger.tracePii(message);
+          } else {
+            this.logger.trace(message);
+          }
+          break;
+        case msalNodeRuntime.LogLevel.Info:
+          if (containsPii) {
+            this.logger.infoPii(message);
+          } else {
+            this.logger.info(message);
+          }
+          break;
+        case msalNodeRuntime.LogLevel.Warning:
+          if (containsPii) {
+            this.logger.warningPii(message);
+          } else {
+            this.logger.warning(message);
+          }
+          break;
+        case msalNodeRuntime.LogLevel.Error:
+          if (containsPii) {
+            this.logger.errorPii(message);
+          } else {
+            this.logger.error(message);
+          }
+          break;
+        case msalNodeRuntime.LogLevel.Fatal:
+          if (containsPii) {
+            this.logger.errorPii(message);
+          } else {
+            this.logger.error(message);
+          }
+          break;
+        default:
+          if (containsPii) {
+            this.logger.infoPii(message);
+          } else {
+            this.logger.info(message);
+          }
+          break;
+      }
+    };
+    try {
+      msalNodeRuntime.msalNodeRuntime.RegisterLogger(logCallback, loggerOptions.piiLoggingEnabled);
+    } catch (e) {
+      const wrappedError = this.wrapError(e);
+      if (wrappedError) {
+        throw wrappedError;
+      }
+    }
+  }
+  async getAccountById(accountId, correlationId) {
+    this.logger.trace("NativeBrokerPlugin - getAccountById called", correlationId);
+    const readAccountResult = await this.readAccountById(accountId, correlationId);
+    return this.generateAccountInfo(readAccountResult.account);
+  }
+  async getAllAccounts(clientId, correlationId) {
+    this.logger.trace("NativeBrokerPlugin - getAllAccounts called", correlationId);
+    return new Promise((resolve, reject) => {
+      const resultCallback = result => {
+        try {
+          result.CheckError();
+        } catch (e) {
+          const wrappedError = this.wrapError(e);
+          if (wrappedError) {
+            reject(wrappedError);
+            return;
+          }
+        }
+        const accountInfoResult = [];
+        result.accounts.forEach(account => {
+          accountInfoResult.push(this.generateAccountInfo(account));
+        });
+        resolve(accountInfoResult);
+      };
+      try {
+        msalNodeRuntime.msalNodeRuntime.DiscoverAccountsAsync(clientId, correlationId, resultCallback);
+      } catch (e) {
+        const wrappedError = this.wrapError(e);
+        if (wrappedError) {
+          reject(wrappedError);
+        }
+      }
+    });
+  }
+  async acquireTokenSilent(request) {
+    this.logger.trace("NativeBrokerPlugin - acquireTokenSilent called", request.correlationId);
+    const authParams = this.generateRequestParameters(request);
+    const account = await this.getAccount(request);
+    return new Promise((resolve, reject) => {
+      const resultCallback = result => {
+        try {
+          result.CheckError();
+        } catch (e) {
+          const wrappedError = this.wrapError(e);
+          if (wrappedError) {
+            reject(wrappedError);
+            return;
+          }
+        }
+        const authenticationResult = this.getAuthenticationResult(request, result);
+        resolve(authenticationResult);
+      };
+      try {
+        if (account) {
+          msalNodeRuntime.msalNodeRuntime.AcquireTokenSilentlyAsync(authParams, request.correlationId, account, resultCallback);
+        } else {
+          msalNodeRuntime.msalNodeRuntime.SignInSilentlyAsync(authParams, request.correlationId, resultCallback);
+        }
+      } catch (e) {
+        const wrappedError = this.wrapError(e);
+        if (wrappedError) {
+          reject(wrappedError);
+        }
+      }
+    });
+  }
+  async acquireTokenInteractive(request, providedWindowHandle) {
+    this.logger.trace("NativeBrokerPlugin - acquireTokenInteractive called", request.correlationId);
+    const authParams = this.generateRequestParameters(request);
+    const account = await this.getAccount(request);
+    const windowHandle = providedWindowHandle || Buffer.from([0]);
+    return new Promise((resolve, reject) => {
+      const resultCallback = result => {
+        try {
+          result.CheckError();
+        } catch (e) {
+          const wrappedError = this.wrapError(e);
+          if (wrappedError) {
+            reject(wrappedError);
+            return;
+          }
+        }
+        const authenticationResult = this.getAuthenticationResult(request, result);
+        resolve(authenticationResult);
+      };
+      try {
+        switch (request.prompt) {
+          case msalCommon.PromptValue.LOGIN:
+          case msalCommon.PromptValue.SELECT_ACCOUNT:
+          case msalCommon.PromptValue.CREATE:
+            this.logger.info("Calling native interop SignInInteractively API", request.correlationId);
+            const loginHint = request.loginHint || msalCommon.Constants.EMPTY_STRING;
+            msalNodeRuntime.msalNodeRuntime.SignInInteractivelyAsync(windowHandle, authParams, request.correlationId, loginHint, resultCallback);
+            break;
+          case msalCommon.PromptValue.NONE:
+            if (account) {
+              this.logger.info("Calling native interop AcquireTokenSilently API", request.correlationId);
+              msalNodeRuntime.msalNodeRuntime.AcquireTokenSilentlyAsync(authParams, request.correlationId, account, resultCallback);
+            } else {
+              this.logger.info("Calling native interop SignInSilently API", request.correlationId);
+              msalNodeRuntime.msalNodeRuntime.SignInSilentlyAsync(authParams, request.correlationId, resultCallback);
+            }
+            break;
+          default:
+            if (account) {
+              this.logger.info("Calling native interop AcquireTokenInteractively API", request.correlationId);
+              msalNodeRuntime.msalNodeRuntime.AcquireTokenInteractivelyAsync(windowHandle, authParams, request.correlationId, account, resultCallback);
+            } else {
+              this.logger.info("Calling native interop SignIn API", request.correlationId);
+              const loginHint = request.loginHint || msalCommon.Constants.EMPTY_STRING;
+              msalNodeRuntime.msalNodeRuntime.SignInAsync(windowHandle, authParams, request.correlationId, loginHint, resultCallback);
+            }
+            break;
+        }
+      } catch (e) {
+        const wrappedError = this.wrapError(e);
+        if (wrappedError) {
+          reject(wrappedError);
+        }
+      }
+    });
+  }
+  async signOut(request) {
+    this.logger.trace("NativeBrokerPlugin - signOut called", request.correlationId);
+    const account = await this.getAccount(request);
+    if (!account) {
+      throw msalCommon.ClientAuthError.createNoAccountFoundError();
+    }
+    return new Promise((resolve, reject) => {
+      const resultCallback = result => {
+        try {
+          result.CheckError();
+        } catch (e) {
+          const wrappedError = this.wrapError(e);
+          if (wrappedError) {
+            reject(wrappedError);
+            return;
+          }
+        }
+        resolve();
+      };
+      try {
+        msalNodeRuntime.msalNodeRuntime.SignOutSilentlyAsync(request.clientId, request.correlationId, account, resultCallback);
+      } catch (e) {
+        const wrappedError = this.wrapError(e);
+        if (wrappedError) {
+          reject(wrappedError);
+        }
+      }
+    });
+  }
+  async getAccount(request) {
+    if (request.accountId) {
+      const readAccountResult = await this.readAccountById(request.accountId, request.correlationId);
+      return readAccountResult.account;
+    }
+    return null;
+  }
+  async readAccountById(accountId, correlationId) {
+    this.logger.trace("NativeBrokerPlugin - readAccountById called", correlationId);
+    return new Promise((resolve, reject) => {
+      const resultCallback = result => {
+        try {
+          result.CheckError();
+        } catch (e) {
+          const wrappedError = this.wrapError(e);
+          if (wrappedError) {
+            reject(wrappedError);
+            return;
+          }
+        }
+        resolve(result);
+      };
+      try {
+        msalNodeRuntime.msalNodeRuntime.ReadAccountByIdAsync(accountId, correlationId, resultCallback);
+      } catch (e) {
+        const wrappedError = this.wrapError(e);
+        if (wrappedError) {
+          reject(wrappedError);
+        }
+      }
+    });
+  }
+  generateRequestParameters(request) {
+    this.logger.trace("NativeBrokerPlugin - generateRequestParameters called", request.correlationId);
+    const authParams = new msalNodeRuntime.msalNodeRuntime.AuthParameters();
+    try {
+      authParams.CreateAuthParameters(request.clientId, request.authority);
+      authParams.SetRedirectUri(request.redirectUri);
+      authParams.SetRequestedScopes(request.scopes.join(" "));
+      if (request.claims) {
+        authParams.SetDecodedClaims(request.claims);
+      }
+      if (request.authenticationScheme === msalCommon.AuthenticationScheme.POP) {
+        if (!request.resourceRequestMethod || !request.resourceRequestUri || !request.shrNonce) {
+          throw new Error("Authentication Scheme set to POP but one or more of the following parameters are missing: resourceRequestMethod, resourceRequestUri, shrNonce");
+        }
+        const resourceUrl = new URL(request.resourceRequestUri);
+        authParams.SetPopParams(request.resourceRequestMethod, resourceUrl.host, resourceUrl.pathname, request.shrNonce);
+      }
+      if (request.extraParameters) {
+        Object.keys(request.extraParameters).forEach(key => {
+          authParams.SetAdditionalParameter(key, request.extraParameters[key]);
+        });
+      }
+    } catch (e) {
+      const wrappedError = this.wrapError(e);
+      if (wrappedError) {
+        throw wrappedError;
+      }
+    }
+    return authParams;
+  }
+  getAuthenticationResult(request, authResult) {
+    this.logger.trace("NativeBrokerPlugin - getAuthenticationResult called", request.correlationId);
+    let fromCache;
+    try {
+      const telemetryJSON = JSON.parse(authResult.telemetryData);
+      fromCache = !!telemetryJSON["is_cache"];
+    } catch (e) {
+      this.logger.error("NativeBrokerPlugin: getAuthenticationResult - Error parsing telemetry data. Could not determine if response came from cache.", request.correlationId);
+    }
+    let idTokenClaims;
+    try {
+      idTokenClaims = JSON.parse(authResult.idToken);
+    } catch (e) {
+      throw new Error("Unable to parse idToken claims");
+    }
+    const accountInfo = this.generateAccountInfo(authResult.account, idTokenClaims);
+    const result = {
+      authority: request.authority,
+      uniqueId: idTokenClaims.oid || idTokenClaims.sub || "",
+      tenantId: idTokenClaims.tid || "",
+      scopes: authResult.grantedScopes.split(" "),
+      account: accountInfo,
+      idToken: authResult.rawIdToken,
+      idTokenClaims: idTokenClaims,
+      accessToken: authResult.accessToken,
+      fromCache: fromCache,
+      expiresOn: new Date(authResult.expiresOn * 1000),
+      tokenType: authResult.isPopAuthorization ? msalCommon.AuthenticationScheme.POP : msalCommon.AuthenticationScheme.BEARER,
+      correlationId: request.correlationId,
+      fromNativeBroker: true
+    };
+    return result;
+  }
+  generateAccountInfo(account, idTokenClaims) {
+    this.logger.trace("NativeBrokerPlugin - generateAccountInfo called");
+    const accountInfo = {
+      homeAccountId: account.homeAccountId,
+      environment: account.environment,
+      tenantId: account.realm,
+      username: account.username,
+      localAccountId: account.localAccountId,
+      name: account.displayName,
+      idTokenClaims: idTokenClaims,
+      nativeAccountId: account.accountId
+    };
+    return accountInfo;
+  }
+  isMsalRuntimeError(result) {
+    return result.hasOwnProperty("errorCode") || result.hasOwnProperty("errorStatus") || result.hasOwnProperty("errorContext") || result.hasOwnProperty("errorTag");
+  }
+  wrapError(error) {
+    if (this.isMsalRuntimeError(error)) {
+      const {
+        errorCode,
+        errorStatus,
+        errorContext,
+        errorTag
+      } = error;
+      switch (errorStatus) {
+        case msalNodeRuntime.ErrorStatus.InteractionRequired:
+        case msalNodeRuntime.ErrorStatus.AccountUnusable:
+          return new msalCommon.InteractionRequiredAuthError(ErrorCodes.INTERATION_REQUIRED_ERROR_CODE, errorContext);
+        case msalNodeRuntime.ErrorStatus.NoNetwork:
+        case msalNodeRuntime.ErrorStatus.NetworkTemporarilyUnavailable:
+          return msalCommon.ClientAuthError.createNoNetworkConnectivityError();
+        case msalNodeRuntime.ErrorStatus.ServerTemporarilyUnavailable:
+          return new msalCommon.ServerError(ErrorCodes.SERVER_UNAVAILABLE, errorContext);
+        case msalNodeRuntime.ErrorStatus.UserCanceled:
+          return msalCommon.ClientAuthError.createUserCanceledError();
+        case msalNodeRuntime.ErrorStatus.AuthorityUntrusted:
+          return msalCommon.ClientConfigurationError.createUntrustedAuthorityError();
+        case msalNodeRuntime.ErrorStatus.UserSwitched:
+          // Not an error case, if there's customer demand we can surface this as a response property
+          return null;
+        case msalNodeRuntime.ErrorStatus.AccountNotFound:
+          return msalCommon.ClientAuthError.createNoAccountFoundError();
+        default:
+          return new NativeAuthError(msalNodeRuntime.ErrorStatus[errorStatus], errorContext, errorCode, errorTag);
+      }
+    }
+    return error;
+  }
 }
 
 exports.Environment = Environment;
@@ -899,6 +1171,7 @@ exports.FilePersistence = FilePersistence;
 exports.FilePersistenceWithDataProtection = FilePersistenceWithDataProtection;
 exports.KeychainPersistence = KeychainPersistence;
 exports.LibSecretPersistence = LibSecretPersistence;
+exports.NativeBrokerPlugin = NativeBrokerPlugin;
 exports.PersistenceCachePlugin = PersistenceCachePlugin;
 exports.PersistenceCreator = PersistenceCreator;
 //# sourceMappingURL=msal-node-extensions.cjs.development.js.map