@mablhq/playwright-tools 2.49.1

package/providers/authenticationProvider.js

@@ -0,0 +1,254 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isOidcError = exports.AuthenticationProvider = void 0;
+const open_1 = __importDefault(require("open"));
+const axios_1 = __importDefault(require("axios"));
+const env_1 = require("../env/env");
+const cliConfigProvider_1 = require("./cliConfigProvider");
+const types_1 = require("../api/types");
+const mablApiClientFactory_1 = require("../api/mablApiClientFactory");
+const loggingProvider_1 = require("./logging/loggingProvider");
+const pureUtil_1 = require("../util/pureUtil");
+const OktaClient_1 = require("../auth/OktaClient");
+const axiosProxyConfig_1 = require("../http/axiosProxyConfig");
+const types_2 = require("./types");
+const humanizeDuration = require('humanize-duration');
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+class AuthenticationProvider {
+    constructor() {
+        this.verbose = false;
+    }
+    async getOktaClient() {
+        if (!this.oktaClient) {
+            const client = axios_1.default.create(await (0, axiosProxyConfig_1.currentProxyConfig)());
+            this.oktaClient = new OktaClient_1.OktaClient(client);
+        }
+        return this.oktaClient;
+    }
+    async getAuthConfigWithAutoRenew() {
+        const authConfig = (await cliConfigProvider_1.CliConfigProvider.getCliConfig()).authentication;
+        if (authConfig.accessToken) {
+            if (this.verbose) {
+                loggingProvider_1.logger.info('Found existing access token');
+            }
+            return this.maybeRenewAuthentication(authConfig);
+        }
+        return authConfig;
+    }
+    async maybeRenewAuthentication(authConfig) {
+        if (!authConfig.refreshToken || authConfig.authType === types_1.AuthType.ApiKey) {
+            if (this.verbose) {
+                loggingProvider_1.logger.info(`Authentication refresh token ${chalk.red.bold('Not Found')}`);
+            }
+            return authConfig;
+        }
+        if (authConfig.authProvider === types_2.AuthProviderType.Auth0) {
+            if (this.verbose) {
+                loggingProvider_1.logger.info(`Authentication refresh token ${chalk.yellow.bold('not valid')}`);
+            }
+            return authConfig;
+        }
+        const nowMilliseconds = Date.now();
+        const refreshTokenValidMilliseconds = authConfig.refreshTokenExpirationTimeMilliseconds
+            ? authConfig.refreshTokenExpirationTimeMilliseconds - nowMilliseconds
+            : undefined;
+        if (refreshTokenValidMilliseconds !== undefined &&
+            refreshTokenValidMilliseconds <= 0) {
+            loggingProvider_1.logger.info(`Login has ${chalk.yellow.bold('expired')}.  Please run ${chalk.magenta('mabl auth login')} to log in with your mabl account`);
+            process.exit(1);
+        }
+        if (this.verbose) {
+            loggingProvider_1.logger.info('Found valid refresh token');
+        }
+        const RefreshAccessTokenWindowMilliseconds = 10 * 60 * 1000;
+        const accessTokenValidMilliseconds = authConfig.accessTokenExpirationTimeMilliseconds - nowMilliseconds;
+        if (this.verbose) {
+            if (accessTokenValidMilliseconds > 0) {
+                loggingProvider_1.logger.info(`Existing access token expires in [${chalk.magenta.bold(humanizeExpirationTime(accessTokenValidMilliseconds))}]`);
+            }
+            else {
+                loggingProvider_1.logger.info(`Access token has ${chalk.yellow.bold('expired')}`);
+            }
+        }
+        if (accessTokenValidMilliseconds < RefreshAccessTokenWindowMilliseconds) {
+            if (this.verbose) {
+                loggingProvider_1.logger.info(`Renewing authorization...`);
+            }
+            const oktaClient = await this.getOktaClient();
+            let newAuthInfo;
+            try {
+                newAuthInfo = await oktaClient.exchangeRefreshTokenForAccessToken(authConfig.refreshToken);
+            }
+            catch (error) {
+                processAuthorizationError(error, true);
+                process.exit(1);
+            }
+            if (newAuthInfo.error) {
+                loggingProvider_1.logger.error(chalk.red.bold(`Could not refresh authentication due to error: ${newAuthInfo.error_description}`));
+                process.exit(1);
+            }
+            if (!newAuthInfo.refresh_token_expires_at &&
+                authConfig.refreshTokenExpirationTimeMilliseconds) {
+                newAuthInfo.refresh_token_expires_at =
+                    authConfig.refreshTokenExpirationTimeMilliseconds / 1000;
+            }
+            await cliConfigProvider_1.CliConfigProvider.setCliAuthInfo(newAuthInfo, nowMilliseconds);
+            return (await cliConfigProvider_1.CliConfigProvider.getCliConfig()).authentication;
+        }
+        return authConfig;
+    }
+    static async getAuthType() {
+        const config = await cliConfigProvider_1.CliConfigProvider.getCliConfig();
+        return config.authentication.authType;
+    }
+    async displayInfo() {
+        var _a;
+        try {
+            const config = await cliConfigProvider_1.CliConfigProvider.getCliConfig();
+            if (config.authentication.authType === types_1.AuthType.ApiKey) {
+                loggingProvider_1.logger.info(`You are authenticated by ${chalk.magenta.bold('API key')}`);
+                return;
+            }
+            if (!config.email || config.authentication.authType === undefined) {
+                loggingProvider_1.logger.info('You are not logged in');
+                return;
+            }
+            loggingProvider_1.logger.info(`Logged in as user [${chalk.magenta.bold(config.email)}]`);
+            const expirationMilliseconds = ((_a = config.authentication.refreshTokenExpirationTimeMilliseconds) !== null && _a !== void 0 ? _a : config.authentication.accessTokenExpirationTimeMilliseconds) -
+                Date.now();
+            if (expirationMilliseconds > 0) {
+                loggingProvider_1.logger.info(`Login expires in [${chalk.magenta.bold(humanizeExpirationTime(expirationMilliseconds))}]`);
+            }
+            else {
+                loggingProvider_1.logger.info(`Login has ${chalk.yellow.bold('expired')}`);
+            }
+        }
+        catch (error) {
+            loggingProvider_1.logger.error(chalk.red.bold(error));
+            process.exit(1);
+        }
+    }
+    async clearAuthentication() {
+        try {
+            const config = await cliConfigProvider_1.CliConfigProvider.getCliConfig();
+            if (!config.email && config.authentication.authType !== types_1.AuthType.ApiKey) {
+                loggingProvider_1.logger.info('You are not logged in');
+                return;
+            }
+            await cliConfigProvider_1.CliConfigProvider.clearAuthConfig();
+            if (config.email) {
+                loggingProvider_1.logger.info(`Logged out user [${chalk.magenta.bold(config.email)}]`);
+            }
+            else {
+                loggingProvider_1.logger.info(`Removed ${chalk.magenta.bold('API key')}`);
+            }
+        }
+        catch (error) {
+            loggingProvider_1.logger.error(chalk.red.bold(error));
+            process.exit(1);
+        }
+    }
+    async activateApiKey(apiKey) {
+        const authInfo = {
+            auth_provider: types_2.AuthProviderType.Mabl,
+            auth_type: types_1.AuthType.ApiKey,
+            api_key: apiKey,
+        };
+        const requestTimeMilliseconds = Date.now();
+        await cliConfigProvider_1.CliConfigProvider.setCliAuthInfo(authInfo, requestTimeMilliseconds);
+    }
+    async authenticate() {
+        const oktaClient = await this.getOktaClient();
+        try {
+            const { codeChallenge, codeVerifier } = oktaClient.generateCodeChallenge();
+            const redirectUri = `${env_1.BASE_APP_URL}/app-code`;
+            const authUrl = oktaClient.buildAuthorizationUrl(codeChallenge, redirectUri);
+            loggingProvider_1.logger.info(`Your browser has been opened to the following URL for obtaining an authorization code:
+
+${authUrl}
+          `);
+            await this.openUrl(authUrl);
+            const response = await inquirer.prompt([
+                {
+                    type: 'password',
+                    name: 'authCode',
+                    message: 'Authorization code:',
+                    mask: true,
+                },
+            ]);
+            const requestTimeMilliseconds = Date.now();
+            let authInfo;
+            try {
+                authInfo = await oktaClient.validateAuthCode(response.authCode, codeVerifier, redirectUri);
+            }
+            catch (error) {
+                processAuthorizationError(error, false);
+                process.exit(1);
+            }
+            if (authInfo.error) {
+                loggingProvider_1.logger.error(chalk.red.bold(`Could not login due to error: ${authInfo.error_description}`));
+                process.exit(1);
+            }
+            await cliConfigProvider_1.CliConfigProvider.setCliAuthInfo(authInfo, requestTimeMilliseconds);
+            const userData = await AuthenticationProvider.requestUserInfo(authInfo.access_token);
+            const config = await cliConfigProvider_1.CliConfigProvider.getCliConfig();
+            config.userId = userData.id;
+            config.email = userData.email;
+            config.userFullName = userData.name;
+            await cliConfigProvider_1.CliConfigProvider.setCliConfig(config);
+            loggingProvider_1.logger.info(chalk.green.bold(`Login successful for: ${userData.email}`));
+        }
+        catch (error) {
+            loggingProvider_1.logger.info(chalk.red.bold('Login failed.'));
+            loggingProvider_1.logger.error(chalk.red.bold(error));
+            process.exit(1);
+        }
+    }
+    openUrl(path) {
+        return (0, open_1.default)(path);
+    }
+    static async requestUserInfo(accessToken) {
+        const apiClient = await mablApiClientFactory_1.MablApiClientFactory.createApiClientForAccessToken(accessToken);
+        return apiClient.getSelf();
+    }
+}
+exports.AuthenticationProvider = AuthenticationProvider;
+function processAuthorizationError(error, isTokenRefresh) {
+    var _a;
+    const mainErrorMessage = isTokenRefresh ? 'Token refresh' : 'Authorization';
+    loggingProvider_1.logger.error(chalk.red.bold(`${mainErrorMessage} failed.`));
+    loggingProvider_1.logger.error(chalk.red.bold(error.toString()));
+    let hasResponseData = false;
+    if (axios_1.default.isAxiosError(error)) {
+        const data = (_a = error.response) === null || _a === void 0 ? void 0 : _a.data;
+        if (isOidcError(data)) {
+            loggingProvider_1.logger.error(chalk.red.bold(`${mainErrorMessage} failed: ${data.error_description} [${data.error}]`));
+            hasResponseData = true;
+        }
+        else if (data) {
+            loggingProvider_1.logger.error(chalk.red.bold(`Response data: ${JSON.stringify(data)}`));
+            hasResponseData = true;
+        }
+    }
+    if (!hasResponseData) {
+        loggingProvider_1.logger.error(chalk.red.bold('No response data'));
+    }
+    if (isTokenRefresh) {
+        loggingProvider_1.logger.error(`Please try again. If the issue persists authenticate again with ${chalk.magenta('mabl auth login')}.`);
+    }
+}
+function humanizeExpirationTime(milliseconds) {
+    return humanizeDuration(milliseconds, {
+        maxDecimalPoints: 0,
+        units: ['h', 'm'],
+    });
+}
+function isOidcError(err) {
+    return ((0, pureUtil_1.isString)(err === null || err === void 0 ? void 0 : err.error) &&
+        (0, pureUtil_1.isString)(err === null || err === void 0 ? void 0 : err.error_description));
+}
+exports.isOidcError = isOidcError;

package/providers/cliConfigProvider.js

@@ -0,0 +1,271 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__resetIsKeytarAvailable = exports.CliConfigProvider = exports.getAuthConfigFile = exports.getEncryptionKey = exports.AUTH_KEY_NAMES = exports.IS_CONFIG_ENCRYPTED_KEY_NAME = void 0;
+const env_1 = require("../env/env");
+const conf_1 = __importDefault(require("conf"));
+const types_1 = require("./types");
+const types_2 = require("../api/types");
+const configKeys_1 = require("../commands/config/config_cmds/configKeys");
+const httpUtil_1 = require("../http/httpUtil");
+const crypto = __importStar(require("crypto"));
+const loggingProvider_1 = require("./logging/loggingProvider");
+const utilities_1 = require("../utilities");
+const USER_ID_NAME = 'userId';
+const USER_FULL_NAME_NAME = 'userFullName';
+const EMAIL_NAME = 'email';
+const WORKSPACE = 'workspace';
+const AUTH_PROVIDER = 'authProvider';
+const AUTH_TYPE = 'authType';
+const ACCESS_TOKEN_NAME = 'accessToken';
+const REFRESH_TOKEN_NAME = 'refreshToken';
+const ACCESS_TOKEN_EXPIRATION_MILLISECONDS_NAME = 'accessTokenExpirationTimeMilliseconds';
+const REFRESH_TOKEN_EXPIRATION_MILLISECONDS_NAME = `${REFRESH_TOKEN_NAME}ExpirationTimeMilliseconds`;
+exports.IS_CONFIG_ENCRYPTED_KEY_NAME = '_isConfigEncrypted';
+exports.AUTH_KEY_NAMES = [
+    AUTH_PROVIDER,
+    AUTH_TYPE,
+    ACCESS_TOKEN_NAME,
+    ACCESS_TOKEN_EXPIRATION_MILLISECONDS_NAME,
+    REFRESH_TOKEN_NAME,
+    REFRESH_TOKEN_EXPIRATION_MILLISECONDS_NAME,
+    USER_FULL_NAME_NAME,
+    USER_ID_NAME,
+    EMAIL_NAME,
+];
+let isKeytarAvailable = true;
+async function getEncryptionKey() {
+    var _a;
+    if ((0, utilities_1.areWeTestingInJest)()) {
+        return;
+    }
+    let maybeEncryptionKey;
+    if (isKeytarAvailable) {
+        try {
+            const keytar = require('keytar');
+            maybeEncryptionKey =
+                (_a = (await keytar.getPassword(env_1.CONF_FILE_PROJECT_NAME, env_1.ENV))) !== null && _a !== void 0 ? _a : undefined;
+            if (!maybeEncryptionKey) {
+                maybeEncryptionKey = crypto
+                    .randomFillSync(Buffer.alloc(48))
+                    .toString('base64');
+                await keytar.setPassword(env_1.CONF_FILE_PROJECT_NAME, env_1.ENV, maybeEncryptionKey);
+            }
+        }
+        catch (error) {
+            loggingProvider_1.logger.warn(`Creating finite login session because login auto-renewal is unsupported on this system.`);
+            isKeytarAvailable = false;
+        }
+    }
+    return maybeEncryptionKey;
+}
+exports.getEncryptionKey = getEncryptionKey;
+async function getAuthConfigFile() {
+    return getNonEncryptedConfig();
+    const maybeEncryptionKey = await getEncryptionKey();
+    if (!isKeytarAvailable || (0, utilities_1.areWeTestingInJest)()) {
+        return getNonEncryptedConfig();
+    }
+    const conf = new conf_1.default({
+        configName: 'access-enc',
+        projectName: env_1.CONF_FILE_PROJECT_NAME,
+        projectVersion: env_1.CONF_FILE_VERSION,
+        accessPropertiesByDotNotation: false,
+        encryptionKey: maybeEncryptionKey,
+    });
+    if (conf.has(exports.IS_CONFIG_ENCRYPTED_KEY_NAME)) {
+        return conf;
+    }
+    const oldConf = getNonEncryptedConfig();
+    copyConf(oldConf, conf);
+    conf.set(exports.IS_CONFIG_ENCRYPTED_KEY_NAME, true);
+    return conf;
+}
+exports.getAuthConfigFile = getAuthConfigFile;
+function shouldStoreRefreshTokens() {
+    return isKeytarAvailable || (0, utilities_1.areWeTestingInJest)();
+}
+function getNonEncryptedConfig() {
+    return new conf_1.default({
+        configName: 'access',
+        projectName: env_1.CONF_FILE_PROJECT_NAME,
+        projectVersion: env_1.CONF_FILE_VERSION,
+        accessPropertiesByDotNotation: false,
+    });
+}
+function copyConf(confFrom, confTo) {
+    for (const key of [...exports.AUTH_KEY_NAMES, ...configKeys_1.validConfigKeyChoices]) {
+        const value = confFrom.get(key);
+        if (value !== undefined) {
+            confTo.set(key, value);
+        }
+    }
+}
+class CliConfigProvider {
+    static setWorkspace(workspaceId) {
+        return setValue(WORKSPACE, workspaceId);
+    }
+    static clearWorkspace() {
+        return clearValue(WORKSPACE);
+    }
+    static async getWorkspace() {
+        return (await getAuthConfigFile()).get(WORKSPACE);
+    }
+    static async getProxyMode() {
+        const proxyMode = await this.getConfigProperty(configKeys_1.configKeys.proxyMode);
+        return (0, configKeys_1.isValidProxyMode)(proxyMode) ? proxyMode : 'mabl';
+    }
+    static async getProxyType() {
+        const proxyType = await this.getConfigProperty(configKeys_1.configKeys.proxyType);
+        return (0, configKeys_1.isValidProxyType)(proxyType) ? proxyType : 'legacy';
+    }
+    static getConfigProperty(key) {
+        return getValue(propertyKeyToStoredKey(key));
+    }
+    static clearConfigProperty(key) {
+        return clearValue(propertyKeyToStoredKey(key));
+    }
+    static setConfigProperty(key, value) {
+        return setValue(propertyKeyToStoredKey(key), value);
+    }
+    static async getCliConfig() {
+        const config = await getAuthConfigFile();
+        const authType = config.get(AUTH_TYPE);
+        let authProvider = config.get(AUTH_PROVIDER);
+        if (!authProvider && authType !== undefined) {
+            authProvider =
+                authType === types_2.AuthType.ApiKey
+                    ? types_1.AuthProviderType.Mabl
+                    : types_1.AuthProviderType.Auth0;
+        }
+        const authentication = {
+            authProvider,
+            authType,
+            accessToken: config.get(ACCESS_TOKEN_NAME),
+            refreshToken: config.get(REFRESH_TOKEN_NAME),
+            accessTokenExpirationTimeMilliseconds: config.get(ACCESS_TOKEN_EXPIRATION_MILLISECONDS_NAME),
+            refreshTokenExpirationTimeMilliseconds: config.get(REFRESH_TOKEN_EXPIRATION_MILLISECONDS_NAME),
+        };
+        const proxyType = await this.getProxyType();
+        const httpConfig = {
+            sslVerify: httpUtil_1.EXECUTION_ENGINE_SSL_VERIFY,
+            proxyType,
+        };
+        const sslVerifyValue = await this.getConfigProperty(configKeys_1.configKeys.sslVerify);
+        if (sslVerifyValue !== undefined) {
+            if (typeof sslVerifyValue !== 'boolean') {
+                throw new Error(`Invalid proxy sslVerify value`);
+            }
+            httpConfig.sslVerify = sslVerifyValue;
+        }
+        const mablHttpConfig = { ...httpConfig };
+        const testHttpConfig = { ...httpConfig };
+        const proxyHostValue = await this.getConfigProperty(configKeys_1.configKeys.proxy);
+        const proxyMode = await this.getProxyMode();
+        if (proxyHostValue) {
+            if (typeof proxyHostValue !== 'string') {
+                throw new Error('Invalid proxy host value');
+            }
+            if (proxyMode === 'mabl' || proxyMode === 'all') {
+                mablHttpConfig.proxyHost = new URL(proxyHostValue);
+            }
+            if (proxyMode === 'test' || proxyMode === 'all') {
+                testHttpConfig.proxyHost = new URL(proxyHostValue);
+            }
+        }
+        return {
+            authentication,
+            userId: config.get(USER_ID_NAME),
+            email: config.get(EMAIL_NAME),
+            userFullName: config.get(USER_FULL_NAME_NAME),
+            workspace: config.get(WORKSPACE),
+            http: { mabl: mablHttpConfig, test: testHttpConfig },
+        };
+    }
+    static clearAuthConfig() {
+        exports.AUTH_KEY_NAMES.forEach((keyName) => clearValue(keyName));
+        return this.getCliConfig();
+    }
+    static async setCliConfig(config) {
+        var _a, _b, _c, _d, _e, _f;
+        await setValue(AUTH_PROVIDER, (_a = config === null || config === void 0 ? void 0 : config.authentication) === null || _a === void 0 ? void 0 : _a.authProvider);
+        await setValue(AUTH_TYPE, (_b = config === null || config === void 0 ? void 0 : config.authentication) === null || _b === void 0 ? void 0 : _b.authType);
+        await setValue(ACCESS_TOKEN_NAME, (_c = config === null || config === void 0 ? void 0 : config.authentication) === null || _c === void 0 ? void 0 : _c.accessToken);
+        await setValue(REFRESH_TOKEN_NAME, (_d = config === null || config === void 0 ? void 0 : config.authentication) === null || _d === void 0 ? void 0 : _d.refreshToken);
+        await setValue(ACCESS_TOKEN_EXPIRATION_MILLISECONDS_NAME, (_e = config === null || config === void 0 ? void 0 : config.authentication) === null || _e === void 0 ? void 0 : _e.accessTokenExpirationTimeMilliseconds);
+        await setValue(REFRESH_TOKEN_EXPIRATION_MILLISECONDS_NAME, (_f = config === null || config === void 0 ? void 0 : config.authentication) === null || _f === void 0 ? void 0 : _f.refreshTokenExpirationTimeMilliseconds);
+        await setValue(USER_ID_NAME, config.userId);
+        await setValue(EMAIL_NAME, config.email);
+        await setValue(USER_FULL_NAME_NAME, config.userFullName);
+        return config;
+    }
+    static async setCliAuthInfo(authInfo, updateMilliseconds) {
+        await setValue(AUTH_TYPE, authInfo === null || authInfo === void 0 ? void 0 : authInfo.auth_type);
+        switch (authInfo.auth_type) {
+            case types_2.AuthType.Bearer:
+                const bearerAuthInfo = authInfo;
+                const expirationTimeMilliseconds = updateMilliseconds + bearerAuthInfo.expires_in * 1000;
+                await setValue(AUTH_PROVIDER, bearerAuthInfo.auth_provider);
+                await setValue(ACCESS_TOKEN_NAME, bearerAuthInfo === null || bearerAuthInfo === void 0 ? void 0 : bearerAuthInfo.access_token);
+                await setValue(REFRESH_TOKEN_NAME, bearerAuthInfo === null || bearerAuthInfo === void 0 ? void 0 : bearerAuthInfo.refresh_token);
+                await setValue(ACCESS_TOKEN_EXPIRATION_MILLISECONDS_NAME, expirationTimeMilliseconds);
+                if (bearerAuthInfo.refresh_token_expires_at) {
+                    await setValue(REFRESH_TOKEN_EXPIRATION_MILLISECONDS_NAME, bearerAuthInfo.refresh_token_expires_at * 1000);
+                }
+                return;
+            case types_2.AuthType.ApiKey:
+                const apiKeyAuthInfo = authInfo;
+                await setValue(AUTH_PROVIDER, apiKeyAuthInfo.auth_provider);
+                await setValue(ACCESS_TOKEN_NAME, apiKeyAuthInfo.api_key);
+                return;
+        }
+    }
+}
+exports.CliConfigProvider = CliConfigProvider;
+function propertyKeyToStoredKey(key) {
+    return `properties.${key}`;
+}
+async function setValue(key, value) {
+    if (value === undefined) {
+        return clearValue(key);
+    }
+    if (!shouldStoreRefreshTokens() && key.includes(REFRESH_TOKEN_NAME)) {
+        return;
+    }
+    (await getAuthConfigFile()).set(key, value);
+}
+async function getValue(key) {
+    return (await getAuthConfigFile()).get(key);
+}
+async function clearValue(key) {
+    (await getAuthConfigFile()).delete(key);
+}
+function __resetIsKeytarAvailable() {
+    isKeytarAvailable = true;
+}
+exports.__resetIsKeytarAvailable = __resetIsKeytarAvailable;