Update module imports

0c8ccf176511a33fb84e1528af57e17027fa733c

Cohee <18619528+Cohee1207@users.noreply.github.com>

Parents: a0e6030836d18bd17c66d302cbb0af43c453988c

recover.js+12 -7 Viewed

 import fs from 'node:fs';
 import yaml from 'yaml';
 import storage from 'node-persist';
 -import * as users from './src/users.js';
 +import {
 +    initUserStorage,
 +    getPasswordSalt,
 +    getPasswordHash,
 +    toKey,
 +} from './src/users.js';
 const userAccount = process.argv[2];
 const userPassword = process.argv[3];

@@ -22,7 +27,7 @@ async function initStorage() {
22	27	process.exit(1);
23	28	}
24	29
25	30	await users.initUserStorage(dataRoot);
26	31	}
27	32
28	33	async function main() {

     /**
      * @type {import('./src/users').User}
      */
     const user = await storage.get(users.toKey(userAccount));
     if (!user) {
         console.error(`User "${userAccount}" not found.`);
         process.exit(1);
+    }
     if (!user.enabled)   {
         console.log('User is disabled. Enabling...');
         user.enabled = true;
+    }
     if (userPassword) {
         console.log('Setting new password...');
         const salt = users.getPasswordSalt();
         const passwordHash = users.getPasswordHash(userPassword, salt);
         user.password = passwordHash;
         user.salt = salt;
     } else {

@@ -55,7 +60,7 @@ async function main() {
55	60	user.salt = '';
56	61	}
57	62
58	63	await storage.setItem(users.toKey(userAccount), user);
59	64	console.log('User recovered. A program will exit now.');
60	65	}
61	66

server.js+37 -23 Viewed

 util.inspect.defaultOptions.depth = 4;
 // local library imports
 import *{ asloadPlugins loader} from './src/plugin-loader.js';
 -import * as userModule from './src/users.js';
 +import {
 +    initUserStorage,
 +    getCsrfSecret,
 +    getCookieSecret,
 +    getCookieSessionName,
 +    getAllEnabledUsers,
 +    ensurePublicDirectoriesExist,
 +    getUserDirectoriesList,
 +    migrateSystemPrompts,
 +    migrateUserData,
 +    requireLoginMiddleware,
 +    setUserDataMiddleware,
 +    shouldRedirectToLogin,
 +    tryAutoLogin,
 +    router as userDataRouter,
 +} from './src/users.js';
 import basicAuthMiddleware from './src/middleware/basicAuth.js';
 import whitelistMiddleware from './src/middleware/whitelist.js';
 import multerMonkeyPatch from './src/middleware/multerMonkeyPatch.js';
 import initRequestProxy from './src/request-proxy.js';
 -import * as contentManager from './src/endpoints/content-manager.js';
 import {
     getVersion,
     getConfigValue,

 import { router as statsRouter, init as statsInit, onExit as statsOnExit } from './src/endpoints/stats.js';
 import { router as backgroundsRouter } from './src/endpoints/backgrounds.js';
 import { router as spritesRouter } from './src/endpoints/sprites.js';
 import { router as contentManagerRouter, checkForNewContent } from './src/endpoints/content-manager.js';
 import { router as settingsRouter, init as settingsInit } from './src/endpoints/settings.js';
 import { router as stableDiffusionRouter } from './src/endpoints/stable-diffusion.js';
 import { router as hordeRouter } from './src/endpoints/horde.js';

+}
 app.use(cookieSession({
     name: userModule.getCookieSessionName(),
     sameSite: 'strict',
     httpOnly: true,
     maxAge: getSessionCookieAge(),
     secret: userModule.getCookieSecret(),
 }));
 app.use(userModule.setUserDataMiddleware);
 // CSRF Protection //
 if (!disableCsrf) {
     const COOKIES_SECRET = userModule.getCookieSecret();
     const { generateToken, doubleCsrfProtection } = doubleCsrf({
         getSecret: userModule.getCsrfSecret,
         cookieName: 'X-CSRF-Token',
         cookieOptions: {
             httpOnly: true,

 // Static files
 // Host index page
 app.get('/', (request, response) => {
     if (userModule.shouldRedirectToLogin(request)) {
         const query = request.url.split('?')[1];
         const redirectUrl = query ? `/login?${query}` : '/login';
         return response.redirect(redirectUrl);

+    }
     try {
         const autoLogin = await userModule.tryAutoLogin(request, basicAuthMode);
         if (autoLogin) {
             return response.redirect('/');

 app.use('/api/users', usersPublicRouter);
 // Everything below this line requires authentication
 app.use(userModule.requireLoginMiddleware);
 app.get('/api/ping', (_, response) => response.sendStatus(204));
 // File uploads

 app.use(multerMonkeyPatch);
 // User data mount
 app.use('/', userModule.routeruserDataRouter);
 // Private endpoints
 app.use('/api/users', usersPrivateRouter);
 // Admin endpoints

+    }
     console.log();
     const directories = await userModule.getUserDirectoriesList();
     await contentManager.checkForNewContent(directories);
     await ensureThumbnailCache();
     cleanUploads();
     await settingsInit();
     await statsInit();
     const cleanupPlugins = await loadPluginsinitializePlugins();
     const consoleTitle = process.title;
     let isExiting = false;

  * Loads server plugins from a directory.
  * @returns {Promise<Function>} Function to be run on server exit
  */
 async function loadPluginsinitializePlugins() {
     try {
         const pluginDirectory = path.join(serverDirectory, 'plugins');
         const cleanupPlugins = await loader.loadPlugins(app, pluginDirectory);
         return cleanupPlugins;
     } catch {
         console.log('Plugin loading failed.');

         logSecurityAlert('Your SillyTavern is currently insecurely open to the public. Enable whitelisting, basic authentication or user accounts.');
+    }
     const users = await userModule.getAllEnabledUsers();
     const unprotectedUsers = users.filter(x => !x.password);
     const unprotectedAdminUsers = unprotectedUsers.filter(x => x.admin);

+}
 // User storage module needs to be initialized before starting the server
 userModule.initUserStorage(dataRoot)
     .then(userModule.ensurePublicDirectoriesExist)
     .then(userModule.migrateUserData)
     .then(userModule.migrateSystemPrompts)
     .then(verifySecuritySettings)
     .then(preSetupTasks)
     .finally(startServer);

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

 import { jsonParser, urlencodedParser } from '../express-common.js';
 import { deepMerge, humanizedISO8601DateTime, tryParse, extractFileFromZipBuffer } from '../util.js';
 import { TavernCardValidator } from '../validator/TavernCardValidator.js';
 import *{ asparse, characterCardParserwrite } from '../character-card-parser.js';
 import { readWorldInfoFile } from './worldinfo.js';
 import { invalidateThumbnail } from './thumbnails.js';
 import { importRisuSprites } from './sprites.js';

@@ -38,7 +38,7 @@ async function readCharacterData(inputFile, inputFormat = 'png') {
38	38	return characterDataCache.get(cacheKey);
39	39	}
40	40
41	41	const result = characterCardParser.parse(inputFile, inputFormat);
42	42	characterDataCache.set(cacheKey, result);
43	43	return result;
44	44	}

         const inputImage = await getInputImage();
         // Get the chunks
         const outputImage = characterCardParser.write(inputImage, data);
         const outputImagePath = path.join(request.user.directories.characters, `${outputFile}.png`);
         writeFileAtomicSync(outputImagePath, outputImage);

src/endpoints/content-manager.js+4 -3 Viewed

 import express from 'express';
 import fetch from 'node-fetch';
 import sanitize from 'sanitize-filename';
 +import { sync as writeFileAtomicSync } from  'write-file-atomic';
 import { getConfigValue, color } from '../util.js';
 import { jsonParser } from '../express-common.js';
 import { sync as writeFileAtomicSyncwrite } from   'write../character-filecard-atomicparser.js';
++
 const contentDirectory = path.join(process.cwd(), 'default/content');
 const scaffoldDirectory = path.join(process.cwd(), 'default/scaffold');
 const contentIndexPath = path.join(contentDirectory, 'index.json');
 const scaffoldIndexPath = path.join(scaffoldDirectory, 'index.json');
 -import * as characterCardParser from '../character-card-parser.js';
 const WHITELIST_GENERIC_URL_DOWNLOAD_SOURCES = getConfigValue('whitelistImportDomains', []);

         const avatarResult = await fetch(avatarUrl);
         const avatarBuffer = await avatarResult.buffer();
         const cardBuffer = characterCardParser.write(avatarBuffer, JSON.stringify(characterData));
         return {
             buffer: cardBuffer,

src/endpoints/users-private.js+2 -3 Viewed

 import { jsonParser } from '../express-common.js';
 import { getUserAvatar, toKey, getPasswordHash, getPasswordSalt, createBackupArchive, ensurePublicDirectoriesExist, toAvatarKey } from '../users.js';
 import { SETTINGS_FILE } from '../constants.js';
 import *{ ascheckForNewContent, contentManagerCONTENT_TYPES } from './content-manager.js';
 import { color, Cache } from '../util.js';
 -import { checkForNewContent } from './content-manager.js';
 const RESET_CACHE = new Cache(5 * 60 * 1000);

         const pathToFile = path.join(request.user.directories.root, SETTINGS_FILE);
         await fsPromises.rm(pathToFile, { force: true });
         await contentManager.checkForNewContent([request.user.directories], [contentManager.CONTENT_TYPES.SETTINGS]);
         return response.sendStatus(204);
     } catch (error) {