2cfaa034 · permissionBRICK/SillyTavern

default/config.yaml+0 -2 Viewed

 ## Set to 0 to expire session when the browser is closed
 ## Set to a negative number to disable session expiration
 sessionTimeout: -1
 -# Used to sign session cookies. Will be auto-generated if not set
 -cookieSecret: ''
 # Disable CSRF protection - NOT RECOMMENDED
 disableCsrfProtection: false
 # Disable startup security checks - NOT RECOMMENDED

post-install.js+19 -1 Viewed

         newKey: 'logging.minLogLevel',
         migrate: (value) => value,
     },
 +    // uncomment one release after 1.12.13
 +    /*
 +    {
 +        oldKey: 'cookieSecret',
 +        newKey: 'cookieSecret',
 +        migrate: () => void 0,
 +        remove: true,
 +    },
 +    */
 ];
 /**

         // Migrate old keys to new keys
         const migratedKeys = [];
         for (const { oldKey, newKey, migrate, remove } of keyMigrationMap) {
             if (_.has(config, oldKey)) {
 +                if (remove) {
 +                    _.unset(config, oldKey);
 +                    migratedKeys.push({
 +                        oldKey,
 +                        newValue: void 0,
 +                    });
 +                    continue;
 +                }
++
                 const oldValue = _.get(config, oldKey);
                 const newValue = migrate(oldValue);
                 _.set(config, newKey, newValue);

server.js+26 -25 Viewed

 /** @type {number} */
 const server_port = cliArguments.port ?? process.env.SILLY_TAVERN_PORT ?? getConfigValue('port', DEFAULT_PORT, 'number');
 /** @type {boolean} */
 const autorun = (cliArguments.autorun ?? getConfigValue('autorun', DEFAULT_AUTORUN, 'boolean')) && !cliArguments.ssl;
 /** @type {boolean} */
 const listen = cliArguments.listen ?? getConfigValue('listen', DEFAULT_LISTEN, 'boolean');
 /** @type {string} */
 const listenAddressIPv6 = cliArguments.listenAddressIPv6 ?? getConfigValue('listenAddress.ipv6', DEFAULT_LISTEN_ADDRESS_IPV6);
 /** @type {string} */
 const listenAddressIPv4 = cliArguments.listenAddressIPv4 ?? getConfigValue('listenAddress.ipv4', DEFAULT_LISTEN_ADDRESS_IPV4);
 /** @type {boolean} */
 const enableCorsProxy = cliArguments.corsProxy ?? getConfigValue('enableCorsProxy', DEFAULT_CORS_PROXY, 'boolean');
 const enableWhitelist = cliArguments.whitelist ?? getConfigValue('whitelistMode', DEFAULT_WHITELIST, 'boolean');
 /** @type {string} */
 const dataRootglobalThis.DATA_ROOT = cliArguments.dataRoot ?? getConfigValue('dataRoot', './data');
 /** @type {boolean} */
 const disableCsrf = cliArguments.disableCsrf ?? getConfigValue('disableCsrfProtection', DEFAULT_CSRF_DISABLED, 'boolean');
 const basicAuthMode = cliArguments.basicAuthMode ?? getConfigValue('basicAuthMode', DEFAULT_BASIC_AUTH, 'boolean');
 const perUserBasicAuth = getConfigValue('perUserBasicAuth', DEFAULT_PER_USER_BASIC_AUTH, 'boolean');
 /** @type {boolean} */
 const enableAccounts = getConfigValue('enableUserAccounts', DEFAULT_ACCOUNTS, 'boolean');
 const uploadsPath = path.join(dataRootglobalThis.DATA_ROOT, UPLOADS_DIRECTORY);
 /** @type {boolean | "auto"string} */
 let enableIPv6 = stringToBool(cliArguments.enableIPv6) ?? stringToBool(getConfigValue('protocol.ipv6', DEFAULT_ENABLE_IPV6)) ?? DEFAULT_ENABLE_IPV6;
 /** @type {boolean | "auto"string} */
 let enableIPv4 = stringToBool(cliArguments.enableIPv4) ?? stringToBool(getConfigValue('protocol.ipv4', DEFAULT_ENABLE_IPV4)) ?? DEFAULT_ENABLE_IPV4;
 /** @type {string} */
 const autorunHostname = cliArguments.autorunHostname ?? getConfigValue('autorunHostname', DEFAULT_AUTORUN_HOSTNAME);
 /** @type {number} */
 const autorunPortOverride = cliArguments.autorunPortOverride ?? getConfigValue('autorunPortOverride', DEFAULT_AUTORUN_PORT, 'number');
 /** @type {boolean} */
 const dnsPreferIPv6 = cliArguments.dnsPreferIPv6 ?? getConfigValue('dnsPreferIPv6', DEFAULT_PREFER_IPV6, 'boolean');
 /** @type {boolean} */
 const avoidLocalhost = cliArguments.avoidLocalhost ?? getConfigValue('avoidLocalhost', DEFAULT_AVOID_LOCALHOST, 'boolean');
 const proxyEnabled = cliArguments.requestProxyEnabled ?? getConfigValue('requestProxy.enabled', DEFAULT_PROXY_ENABLED, 'boolean');
 const proxyUrl = cliArguments.requestProxyUrl ?? getConfigValue('requestProxy.url', DEFAULT_PROXY_URL);
 const proxyBypass = cliArguments.requestProxyBypass ?? getConfigValue('requestProxy.bypass', DEFAULT_PROXY_BYPASS);

 function getSessionCookieAge() {
     // Defaults to "no expiration" if not set
     const configValue = getConfigValue('sessionTimeout', -1, 'number');
     // Convert to milliseconds
     if (configValue > 0) {

     sameSite: 'strict',
     httpOnly: true,
     maxAge: getSessionCookieAge(),
     secret: getCookieSecret(globalThis.DATA_ROOT),
 }));
 app.use(setUserDataMiddleware);

                 'Per-user basic authentication is enabled, but user accounts are disabled. This configuration may be insecure.',
             ));
         } else if (!perUserBasicAuth) {
             const basicAuthUserbasicAuthUserName = getConfigValue('basicAuthUser.username', {}'');
 -            if (!basicAuthUser?.username || !basicAuthUser?.password) {
 +            const basicAuthUserPassword = getConfigValue('basicAuthUser.password', '');
 +            if (!basicAuthUserName || !basicAuthUserPassword) {
                 console.warn(color.yellow(
                     'Basic Authentication is enabled, but username or password is not set or empty!',
                 ));

 function logSecurityAlert(message) {
     if (basicAuthMode || enableWhitelist) return; // safe!
     console.error(color.red(message));
     if (getConfigValue('securityOverride', false, 'boolean')) {
         console.warn(color.red('Security has been overridden. If it\'s not a trusted network, change the settings.'));
         return;
+    }

+}
 // User storage module needs to be initialized before starting the server
 initUserStorage(dataRootglobalThis.DATA_ROOT)
     .then(ensurePublicDirectoriesExist)
     .then(migrateUserData)
     .then(migrateSystemPrompts)

src/endpoints/backends/chat-completions.js+4 -4 Viewed

     const apiUrl = new URL(request.body.reverse_proxy || API_CLAUDE).toString();
     const apiKey = request.body.reverse_proxy ? request.body.proxy_password : readSecret(request.user.directories, SECRET_KEYS.CLAUDE);
     const divider = '-'.repeat(process.stdout.columns);
     const enableSystemPromptCache = getConfigValue('claude.enableSystemPromptCache', false, 'boolean') && request.body.model.startsWith('claude-3');
     let cachingAtDepth = getConfigValue('claude.cachingAtDepth', -1, 'number');
     // Disabled if not an integer or negative, or if the model doesn't support it
     if (!Number.isInteger(cachingAtDepth) || cachingAtDepth < 0 || !request.body.model.startsWith('claude-3')) {
         cachingAtDepth = -1;

@@ -1004,7 +1004,7 @@ router.post('/generate', jsonParser, function (request, response) {
1004	1004	bodyParams.logprobs = true;
1005	1005	}
1006	1006
1007	1007	if (getConfigValue('openai.randomizeUserId', false, 'boolean')) {
1008	1008	bodyParams['user'] = uuidv4();
1009	1009	}
1010	1010	} else if (request.body.chat_completion_source === CHAT_COMPLETION_SOURCES.OPENROUTER) {

@@ -1040,7 +1040,7 @@ router.post('/generate', jsonParser, function (request, response) {
1040	1040	bodyParams['route'] = 'fallback';
1041	1041	}
1042	1042
1043	1043	let cachingAtDepth = getConfigValue('claude.cachingAtDepth', -1, 'number');
1044	1044	if (Number.isInteger(cachingAtDepth) && cachingAtDepth >= 0 && request.body.model?.startsWith('anthropic/claude-3')) {
1045	1045	cachingAtDepthForOpenRouterClaude(request.body.messages, cachingAtDepth);
1046	1046	}

src/endpoints/backends/text-completions.js+2 -2 Viewed

@@ -372,8 +372,8 @@ router.post('/generate', jsonParser, async function (request, response) {
372	372	}
373	373
374	374	if (request.body.api_type === TEXTGEN_TYPES.OLLAMA) {
375	375	const keepAlive = Number(getConfigValue('ollama.keepAlive', -1, 'number'));
376	376	const numBatch = Number(getConfigValue('ollama.batchSize', -1, 'number'));
377	377	if (numBatch > 0) {
378	378	request.body['num_batch'] = numBatch;
379	379	}

src/endpoints/characters.js+1 -1 Viewed

 const defaultAvatarPath = './public/img/ai4.png';
 // KV-store for parsed character data
 const cacheCapacity = Number(getConfigValue('cardsCacheCapacity', 100, 'number')); // MB
 // With 100 MB limit it would take roughly 3000 characters to reach this limit
 const characterDataCache = new MemoryLimitedMap(1024 * 1024 * cacheCapacity);
 // Some Android devices require tighter memory management

src/endpoints/chats.js+3 -3 Viewed

     formatBytes,
 } from '../util.js';
 const isBackupEnabled = !!getConfigValue('backups.chat.enabled', true, 'boolean');
 const maxTotalChatBackups = Number(getConfigValue('backups.chat.maxTotalBackups', -1, 'number'));
 const throttleInterval = Number(getConfigValue('backups.chat.throttleInterval', 10_000, 'number'));
 /**
  * Saves a chat to the backups directory.

src/endpoints/content-manager.js+1 -1 Viewed

  */
 export async function checkForNewContent(directoriesList, forceCategories = []) {
     try {
         const contentCheckSkip = getConfigValue('skipContentCheck', false, 'boolean');
         if (contentCheckSkip && forceCategories?.length === 0) {
             return;
+        }

src/endpoints/secrets.js+2 -2 Viewed

 });
 router.post('/view', jsonParser, async (request, response) => {
     const allowKeysExposure = getConfigValue('allowKeysExposure', false, 'boolean');
     if (!allowKeysExposure) {
         console.error('secrets.json could not be viewed unless the value of allowKeysExposure in config.yaml is set to true');

 });
 router.post('/find', jsonParser, (request, response) => {
     const allowKeysExposure = getConfigValue('allowKeysExposure', false, 'boolean');
     const key = request.body.key;
     if (!allowKeysExposure && !EXPORTABLE_KEYS.includes(key)) {

src/endpoints/settings.js+3 -3 Viewed

 import { getAllUserHandles, getUserDirectories } from '../users.js';
 import { getFileNameValidationFunction } from '../middleware/validateFileName.js';
 const ENABLE_EXTENSIONS = !!getConfigValue('extensions.enabled', true, 'boolean');
 const ENABLE_EXTENSIONS_AUTO_UPDATE = !!getConfigValue('extensions.autoUpdate', true, 'boolean');
 const ENABLE_ACCOUNTS = !!getConfigValue('enableUserAccounts', false, 'boolean');
 // 10 minutes
 const AUTOSAVE_INTERVAL = 10 * 60 * 1000;

src/endpoints/thumbnails.js+6 -3 Viewed

 import { getConfigValue } from '../util.js';
 import { jsonParser } from '../express-common.js';
 const thumbnailsEnabled = !!getConfigValue('thumbnails.enabled', true, 'boolean');
 const quality = Math.min(100, Math.max(1, parseInt(getConfigValue('thumbnails.quality', 95, 'number'))));
 const pngFormat = String(getConfigValue('thumbnails.format', 'jpg')).toLowerCase().trim() === 'png';
 /** @type {Record<string, number[]>} */
 -const dimensions = getConfigValue('thumbnails.dimensions', { 'bg': [160, 90], 'avatar': [96, 144] });
 +const dimensions = {
 +    'bg': getConfigValue('thumbnails.dimensions.bg', [160, 90]),
 +    'avatar': getConfigValue('thumbnails.dimensions.avatar', [96, 144]),
 +};
 /**
  * Gets a path to thumbnail folder based on the type.

src/endpoints/tokenizers.js+1 -1 Viewed

 ];
 const CHARS_PER_TOKEN = 3.35;
 const IS_DOWNLOAD_ALLOWED = getConfigValue('enableDownloadableTokenizers', true, 'boolean');
 /**
  * Gets a path to the tokenizer model. Downloads the model if it's a URL.

src/endpoints/users-public.js+2 -2 Viewed

 import { color, Cache, getConfigValue } from '../util.js';
 import { KEY_PREFIX, getUserAvatar, toKey, getPasswordHash, getPasswordSalt } from '../users.js';
 const DISCREET_LOGIN = getConfigValue('enableDiscreetLogin', false, 'boolean');
 const PREFER_REAL_IP_HEADER = getConfigValue('rateLimiting.preferRealIpHeader', false, 'boolean');
 const MFA_CACHE = new Cache(5 * 60 * 1000);
 const getIpAddress = (request) => PREFER_REAL_IP_HEADER ? getRealIpFromHeader(request) : getIpFromRequest(request);

src/middleware/accessLogWriter.js+1 -1 Viewed

 import { getRealIpFromHeader } from '../express-common.js';
 import { color, getConfigValue } from '../util.js';
 const enableAccessLog = getConfigValue('logging.enableAccessLog', true, 'boolean');
 const knownIPs = new Set();

src/middleware/basicAuth.js+6 -5 Viewed

 import { Buffer } from 'node:buffer';
 import storage from 'node-persist';
 import { getAllUserHandles, toKey, getPasswordHash } from '../users.js';
 import { getConfig, getConfigValue, safeReadFileSync } from '../util.js';
 const PER_USER_BASIC_AUTH = getConfigValue('perUserBasicAuth', false, 'boolean');
 const ENABLE_ACCOUNTS = getConfigValue('enableUserAccounts', false, 'boolean');
 const basicAuthMiddleware = async function (request, response, callback) {
     const unauthorizedWebpage = safeReadFileSync('./public/error/unauthorized.html') ?? '';

         return res.status(401).send(unauthorizedWebpage);
     };
     const configbasicAuthUserName = getConfiggetConfigValue('basicAuthUser.username');
 +    const basicAuthUserPassword = getConfigValue('basicAuthUser.password');
     const authHeader = request.headers.authorization;
     if (!authHeader) {

         .toString('utf8')
         .split(':');
     if (!usePerUserAuth && username === config.basicAuthUser.usernamebasicAuthUserName && password === config.basicAuthUser.passwordbasicAuthUserPassword) {
         return callback();
     } else if (usePerUserAuth) {
         const userHandles = await getAllUserHandles();

src/middleware/whitelist.js+1 -1 Viewed

 import { color, getConfigValue, safeReadFileSync } from '../util.js';
 const whitelistPath = path.join(process.cwd(), './whitelist.txt');
 const enableForwardedWhitelist = getConfigValue('enableForwardedWhitelist', false, 'boolean');
 let whitelist = getConfigValue('whitelist', []);
 if (fs.existsSync(whitelistPath)) {

src/plugin-loader.js+2 -2 Viewed

 import { sync as commandExistsSync } from 'command-exists';
 import { getConfigValue, color } from './util.js';
 const enableServerPlugins = !!getConfigValue('enableServerPlugins', false, 'boolean');
 const enableServerPluginsAutoUpdate = !!getConfigValue('enableServerPluginsAutoUpdate', true, 'boolean');
 /**
  * Map of loaded plugins.

src/prompt-converters.js+1 -1 Viewed

+    }
     // Make the last assistant message a prefill
     const prefixEnabled = getConfigValue('mistral.enablePrefix', false, 'boolean');
     const lastMsg = messages[messages.length - 1];
     if (prefixEnabled && messages.length > 0 && lastMsg?.role === 'assistant') {
         lastMsg.prefix = true;

src/transformers.js+1 -1 Viewed

     const cacheDir = path.join(globalThis.DATA_ROOT, '_cache');
     const model = forceModel || getModelForTask(task);
     const localOnly = !getConfigValue('extensions.models.autoDownload', true, 'boolean');
     console.log('Initializing transformers.js pipeline for task', task, 'with model', model);
     const instance = await pipeline(task, model, { cache_dir: cacheDir, quantized: tasks[task].quantized ?? true, local_files_only: localOnly });
     tasks[task].pipeline = instance;

src/users.js+28 -13 Viewed

 import { sync as writeFileAtomicSync } from 'write-file-atomic';
 import { USER_DIRECTORY_TEMPLATE, DEFAULT_USER, PUBLIC_DIRECTORIES, SETTINGS_FILE } from './constants.js';
 import { getConfigValue, color, delay, setConfigValue, generateTimestamp } from './util.js';
 import { readSecret, writeSecret } from './endpoints/secrets.js';
 import { getContentOfType } from './endpoints/content-manager.js';
 export const KEY_PREFIX = 'user:';
 const AVATAR_PREFIX = 'avatar:';
 const ENABLE_ACCOUNTS = getConfigValue('enableUserAccounts', false, 'boolean');
 const AUTHELIA_AUTH = getConfigValue('autheliaAuth', false, 'boolean');
 const PER_USER_BASIC_AUTH = getConfigValue('perUserBasicAuth', false, 'boolean');
 const ANON_CSRF_SECRET = crypto.randomBytes(64).toString('base64');
 /**

  */
 const DIRECTORIES_CACHE = new Map();
 const PUBLIC_USER_AVATAR = '/img/default-user.png';
 +const COOKIE_SECRET_PATH = 'cookie-secret.txt';
 const STORAGE_KEYS = {
     csrfSecret: 'csrfSecret',
 +    /**
 +     * @deprecated Read from COOKIE_SECRET_PATH in DATA_ROOT instead.
 +     */
     cookieSecret: 'cookieSecret',
 };

  * @returns {Promise<void>}
  */
 export async function initUserStorage(dataRoot) {
 -    globalThis.DATA_ROOT = dataRoot;
 +    console.log('Using data root:', color.green(dataRoot));
 -    console.log('Using data root:', color.green(globalThis.DATA_ROOT));
     console.log();
     await storage.init({
         dir: path.join(globalThis.DATA_ROOTdataRoot, '_storage'),
         ttl: false, // Never expire
     });

 /**
  * Get the cookie secret from the config. If it doesn't exist, generate a new one.
 + * @param {string} dataRoot The root directory for user data
  * @returns {string} The cookie secret
  */
 export function getCookieSecret(dataRoot) {
     letconst secretcookieSecretPath = getConfigValue(STORAGE_KEYSpath.cookieSecretjoin(dataRoot, COOKIE_SECRET_PATH);
++
 +    if (fs.existsSync(cookieSecretPath)) {
 +        const stat = fs.statSync(cookieSecretPath);
 +        if (stat.size > 0) {
 +            return fs.readFileSync(cookieSecretPath, 'utf8');
 +        }
 +    }
 -    if (!secret) {
 +    const oldSecret = getConfigValue(STORAGE_KEYS.cookieSecret);
 -        console.warn(color.yellow('Cookie secret is missing from config.yaml. Generating a new one...'));
 +    if (oldSecret) {
 -        secret = crypto.randomBytes(64).toString('base64');
 +        console.log('Migrating cookie secret from config.yaml...');
 -        setConfigValue(STORAGE_KEYS.cookieSecret, secret);
 +        writeFileAtomicSync(cookieSecretPath, oldSecret, { encoding: 'utf8' });
 +        return oldSecret;
+    }
 +    console.warn(color.yellow('Cookie secret is missing from data root. Generating a new one...'));
 +    const secret = crypto.randomBytes(64).toString('base64');
 +    writeFileAtomicSync(cookieSecretPath, secret, { encoding: 'utf8' });
     return secret;
+}

src/util.js+61 -17 Viewed

 import yaml from 'yaml';
 import { sync as commandExistsSync } from 'command-exists';
 -import { sync as writeFileAtomicSync } from 'write-file-atomic';
 import _ from 'lodash';
 import yauzl from 'yauzl';
 import mime from 'mime-types';

 let CACHED_CONFIG = null;
 /**
 + * Converts a configuration key to an environment variable key.
 + * @param {string} key Configuration key
 + * @returns {string} Environment variable key
 + * @example keyToEnv('extensions.models.speechToText') // 'SILLYTAVERN_EXTENSIONS_MODELS_SPEECHTOTEXT'
 + */
 +export const keyToEnv = (key) => 'SILLYTAVERN_' + String(key).toUpperCase().replace(/\./g, '_');
++
 +/**
  * Returns the config object from the config.yaml file.
  * @returns {object} Config object
  */

  * Returns the value for the given key from the config object.
  * @param {string} key - Key to get from the config object
  * @param {any} defaultValue - Default value to return if the key is not found
 + * @param {'number'|'boolean'|null} typeConverter - Type to convert the value to
  * @returns {any} Value for the given key
  */
 export function getConfigValue(key, defaultValue = null, typeConverter = null) {
 -    const config = getConfig();
 +    function _getValue() {
 -    return _.get(config, key, defaultValue);
 +        const envKey = keyToEnv(key);
 +        if (envKey in process.env) {
 +            const needsJsonParse = defaultValue && typeof defaultValue === 'object';
 +            const envValue = process.env[envKey];
 +            return needsJsonParse ? (tryParse(envValue) ?? defaultValue) : envValue;
 +        }
 +        const config = getConfig();
 +        return _.get(config, key, defaultValue);
 +    }
++
 +    const value = _getValue();
 +    switch (typeConverter) {
 +        case 'number':
 +            return isNaN(parseFloat(value)) ? defaultValue : parseFloat(value);
 +        case 'boolean':
 +            return toBoolean(value);
 +        default:
 +            return value;
 +    }
+}
 /**
 - * Sets a value for the given key in the config object and writes it to the config.yaml file.
 + * THIS FUNCTION IS DEPRECATED AND ONLY EXISTS FOR BACKWARDS COMPATIBILITY. DON'T USE IT.
  * @param {stringany} key Key to_key setUnused
  * @param {any} value Value to_value setUnused
 + * @deprecated Configs are read-only. Use environment variables instead.
  */
 export function setConfigValue(key_key, value_value) {
 -    // Reset cache so that the next getConfig call will read the updated config file
 +    console.trace(color.yellow('setConfigValue is deprecated and should not be used.'));
 -    CACHED_CONFIG = null;
 -    const config = getConfig();
 -    _.set(config, key, value);
 -    writeFileAtomicSync('./config.yaml', yaml.stringify(config));
+}
 /**

  * @param {number?} limit Maximum number of backups to keep. If null, the limit is determined by the `backups.common.numberOfBackups` config value.
  */
 export function removeOldBackups(directory, prefix, limit = null) {
     const MAX_BACKUPS = limit ?? Number(getConfigValue('backups.common.numberOfBackups', 50, 'number'));
     let files = fs.readdirSync(directory).filter(f => f.startsWith(prefix));
     if (files.length > MAX_BACKUPS) {

+    }
+}
 +/**
 + * Converts various JavaScript primitives to boolean values.
 + * Handles special case for "true"/"false" strings (case-insensitive)
 + *
 + * @param {any} value - The value to convert to boolean
 + * @returns {boolean} - The boolean representation of the value
 + */
 +export function toBoolean(value) {
 +    // Handle string values case-insensitively
 +    if (typeof value === 'string') {
 +        // Trim and convert to lowercase for case-insensitive comparison
 +        const trimmedLower = value.trim().toLowerCase();
++
 +        // Handle explicit "true"/"false" strings
 +        if (trimmedLower === 'true') return true;
 +        if (trimmedLower === 'false') return false;
 +    }
++
 +    // Handle all other JavaScript values based on their "truthiness"
 +    return Boolean(value);
 +}
 /**
  * converts string to boolean accepts 'true' or 'false' else it returns the string put in

  * @returns {boolean|string|null} boolean else original input string or null if input is
  */
 export function stringToBool(str) {
     if (String(str).trim().toLowerCase() === 'true') return true;
     if (String(str).trim().toLowerCase() === 'false') return false;
     return str;
+}

  * Setup the minimum log level
  */
 export function setupLogLevel() {
     const logLevel = getConfigValue('logging.minLogLevel', LOG_LEVELS.DEBUG, 'number');
     globalThis.console.debug = logLevel <= LOG_LEVELS.DEBUG ? console.debug : () => {};
     globalThis.console.info = logLevel <= LOG_LEVELS.INFO ? console.info : () => {};

Merge branch 'staging' into persona-improvements