6024b29e · permissionBRICK/SillyTavern

server.js+3 -3 Viewed

 app.use(compression());
 app.use(responseTime());
 +app.use(bodyParser.json({ limit: '200mb' }));
 +app.use(bodyParser.urlencoded({ extended: true, limit: '200mb' }));
++
 // CORS Settings //
 const CORS = cors({
     origin: 'null',

+}
 if (cliArgs.enableCorsProxy) {
 -    app.use(bodyParser.json({
 -        limit: '200mb',
 -    }));
     app.use('/proxy/:url(*)', corsProxyMiddleware);
 } else {
     app.use('/proxy/:url(*)', async (_, res) => {

src/endpoints/anthropic.js+1 -2 Viewed

 import express from 'express';
 import { readSecret, SECRET_KEYS } from './secrets.js';
 -import { jsonParser } from '../express-common.js';
 export const router = express.Router();
 router.post('/caption-image', jsonParser, async (request, response) => {
     try {
         const mimeType = request.body.image.split(';')[0].split(':')[1];
         const base64Data = request.body.image.split(',')[1];

src/endpoints/assets.js+4 -5 Viewed

 import fetch from 'node-fetch';
 import { UNSAFE_EXTENSIONS } from '../constants.js';
 -import { jsonParser } from '../express-common.js';
 import { clientRelativePath } from '../util.js';
 const VALID_CATEGORIES = ['bgm', 'ambient', 'blip', 'live2d', 'vrm', 'character', 'temp'];

+ *
  * @returns {void}
  */
 router.post('/get', jsonParser, async (request, response) => {
     const folderPath = path.join(request.user.directories.assets);
     let output = {};

+ *
  * @returns {void}
  */
 router.post('/download', jsonParser, async (request, response) => {
     const url = request.body.url;
     const inputCategory = request.body.category;

+ *
  * @returns {void}
  */
 router.post('/delete', jsonParser, async (request, response) => {
     const inputCategory = request.body.category;
     // Check category

+ *
  * @returns {void}
  */
 router.post('/character', jsonParser, async (request, response) => {
     if (request.query.name === undefined) return response.sendStatus(400);
     // For backwards compatibility, don't reject invalid character names, just sanitize them

src/endpoints/avatars.js+3 -4 Viewed

 import jimp from 'jimp';
 import { sync as writeFileAtomicSync } from 'write-file-atomic';
 -import { jsonParser, urlencodedParser } from '../express-common.js';
 import { AVATAR_WIDTH, AVATAR_HEIGHT } from '../constants.js';
 import { getImages, tryParse } from '../util.js';
 import { getFileNameValidationFunction } from '../middleware/validateFileName.js';
 export const router = express.Router();
 router.post('/get', jsonParser, function (request, response) {
     var images = getImages(request.user.directories.avatars);
     response.send(JSON.stringify(images));
 });
 router.post('/delete', jsonParser, getFileNameValidationFunction('avatar'), function (request, response) {
     if (!request.body) return response.sendStatus(400);
     if (request.body.avatar !== sanitize(request.body.avatar)) {

     return response.sendStatus(404);
 });
 router.post('/upload', urlencodedParser, async (request, response) => {
     if (!request.file) return response.sendStatus(400);
     try {

src/endpoints/azure.js+2 -3 Viewed

 import { Router } from 'express';
 import { readSecret, SECRET_KEYS } from './secrets.js';
 -import { jsonParser } from '../express-common.js';
 export const router = Router();
 router.post('/list', jsonParser, async (req, res) => {
     try {
         const key = readSecret(req.user.directories, SECRET_KEYS.AZURE_TTS);

+    }
 });
 router.post('/generate', jsonParser, async (req, res) => {
     try {
         const key = readSecret(req.user.directories, SECRET_KEYS.AZURE_TTS);

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

 import express from 'express';
 import fetch from 'node-fetch';
 -import { jsonParser } from '../../express-common.js';
 import {
     CHAT_COMPLETION_SOURCES,
     GEMINI_SAFETY,

 export const router = express.Router();
 router.post('/status', jsonParser, async function (request, response_getstatus_openai) {
     if (!request.body) return response_getstatus_openai.sendStatus(400);
     let api_url;

+    }
 });
 router.post('/bias', jsonParser, async function (request, response) {
     if (!request.body || !Array.isArray(request.body))
         return response.sendStatus(400);

 });
 router.post('/generate', jsonParser, function (request, response) {
     if (!request.body) return response.status(400).send({ error: true });
     switch (request.body.chat_completion_source) {

src/endpoints/backends/kobold.js+3 -4 Viewed

 import express from 'express';
 import fetch from 'node-fetch';
 -import { jsonParser, urlencodedParser } from '../../express-common.js';
 import { forwardFetchResponse, delay } from '../../util.js';
 import { getOverrideHeaders, setAdditionalHeaders, setAdditionalHeadersByType } from '../../additional-headers.js';
 import { TEXTGEN_TYPES } from '../../constants.js';
 export const router = express.Router();
 router.post('/generate', jsonParser, async function (request, response_generate) {
     if (!request.body) return response_generate.sendStatus(400);
     if (request.body.api_server.indexOf('localhost') != -1) {

     return response_generate.send({ error: true });
 });
 router.post('/status', jsonParser, async function (request, response) {
     if (!request.body) return response.sendStatus(400);
     let api_server = request.body.api_server;
     if (api_server.indexOf('localhost') != -1) {

     response.send(result);
 });
 router.post('/transcribe-audio', urlencodedParser, async function (request, response) {
     try {
         const server = request.body.server;

src/endpoints/backends/scale-alt.js+1 -2 Viewed

 import express from 'express';
 import fetch from 'node-fetch';
 -import { jsonParser } from '../../express-common.js';
 import { readSecret, SECRET_KEYS } from '../secrets.js';
 export const router = express.Router();
 router.post('/generate', jsonParser, async function (request, response) {
     if (!request.body) return response.sendStatus(400);
     try {

src/endpoints/backends/text-completions.js+9 -10 Viewed

 import express from 'express';
 import _ from 'lodash';
 -import { jsonParser } from '../../express-common.js';
 import {
     TEXTGEN_TYPES,
     TOGETHERAI_KEYS,

+}
 //************** Ooba/OpenAI text completions API
 router.post('/status', jsonParser, async function (request, response) {
     if (!request.body) return response.sendStatus(400);
     try {

+    }
 });
 router.post('/props', jsonParser, async function (request, response) {
     if (!request.body.api_server) return response.sendStatus(400);
     try {

+    }
 });
 router.post('/generate', jsonParser, async function (request, response) {
     if (!request.body) return response.sendStatus(400);
     try {

 const ollama = express.Router();
 ollama.post('/download', jsonParser, async function (request, response) {
     try {
         if (!request.body.name || !request.body.api_server) return response.sendStatus(400);

+    }
 });
 ollama.post('/caption-image', jsonParser, async function (request, response) {
     try {
         if (!request.body.server_url || !request.body.model) {
             return response.sendStatus(400);

 const llamacpp = express.Router();
 llamacpp.post('/caption-image', jsonParser, async function (request, response) {
     try {
         if (!request.body.server_url) {
             return response.sendStatus(400);

+    }
 });
 llamacpp.post('/props', jsonParser, async function (request, response) {
     try {
         if (!request.body.server_url) {
             return response.sendStatus(400);

+    }
 });
 llamacpp.post('/slots', jsonParser, async function (request, response) {
     try {
         if (!request.body.server_url) {
             return response.sendStatus(400);

 const tabby = express.Router();
 tabby.post('/download', jsonParser, async function (request, response) {
     try {
         const baseUrl = String(request.body.api_server).replace(/\/$/, '');

src/endpoints/backgrounds.js+4 -5 Viewed

 import express from 'express';
 import sanitize from 'sanitize-filename';
 -import { jsonParser, urlencodedParser } from '../express-common.js';
 import { invalidateThumbnail } from './thumbnails.js';
 import { getImages } from '../util.js';
 import { getFileNameValidationFunction } from '../middleware/validateFileName.js';
 export const router = express.Router();
 router.post('/all', jsonParser, function (request, response) {
     var images = getImages(request.user.directories.backgrounds);
     response.send(JSON.stringify(images));
 });
 router.post('/delete', jsonParser, getFileNameValidationFunction('bg'), function (request, response) {
     if (!request.body) return response.sendStatus(400);
     if (request.body.bg !== sanitize(request.body.bg)) {

     return response.send('ok');
 });
 router.post('/rename', jsonParser, function (request, response) {
     if (!request.body) return response.sendStatus(400);
     const oldFileName = path.join(request.user.directories.backgrounds, sanitize(request.body.old_bg));

     return response.send('ok');
 });
 router.post('/upload', urlencodedParser, function (request, response) {
     if (!request.body || !request.file) return response.sendStatus(400);
     const img_path = path.join(request.file.destination, request.file.filename);

src/endpoints/caption.js+1 -2 Viewed

 import express from 'express';
 -import { jsonParser } from '../express-common.js';
 import { getPipeline, getRawImage } from '../transformers.js';
 export const router = express.Router();
 const TASK = 'image-to-text';
 router.post('/', jsonParser, async (req, res) => {
     try {
         const { image } = req.body;

src/endpoints/characters.js+12 -13 Viewed

 import jimp from 'jimp';
 import { AVATAR_WIDTH, AVATAR_HEIGHT } from '../constants.js';
 -import { jsonParser, urlencodedParser } from '../express-common.js';
 import { default as validateAvatarUrlMiddleware, getFileNameValidationFunction } from '../middleware/validateFileName.js';
 import { deepMerge, humanizedISO8601DateTime, tryParse, extractFileFromZipBuffer, MemoryLimitedMap, getConfigValue } from '../util.js';
 import { TavernCardValidator } from '../validator/TavernCardValidator.js';

 export const router = express.Router();
 router.post('/create', urlencodedParser, async function (request, response) {
     try {
         if (!request.body) return response.sendStatus(400);

@@ -797,7 +796,7 @@ router.post('/create', urlencodedParser, async function (request, response) {
797	796	}
798	797	});
799	798
800	799	router.post('/rename', jsonParser, validateAvatarUrlMiddleware, async function (request, response) {
801	800	if (!request.body.avatar_url \|\| !request.body.new_name) {
802	801	return response.sendStatus(400);
803	802	}

+    }
 });
 router.post('/edit', urlencodedParser, validateAvatarUrlMiddleware, async function (request, response) {
     if (!request.body) {
         console.warn('Error: no response body detected');
         response.status(400).send('Error: no response body detected');

  * @param {Object} response - The HTTP response object.
  * @returns {void}
  */
 router.post('/edit-attribute', jsonParser, validateAvatarUrlMiddleware, async function (request, response) {
     console.debug(request.body);
     if (!request.body) {
         console.warn('Error: no response body detected');

+ *
  * @returns {void}
  * */
 router.post('/merge-attributes', jsonParser, getFileNameValidationFunction('avatar'), async function (request, response) {
     try {
         const update = request.body;
         const avatarPath = path.join(request.user.directories.characters, update.avatar);

@@ -973,7 +972,7 @@ router.post('/merge-attributes', jsonParser, getFileNameValidationFunction('avat
973	972	}
974	973	});
975	974
976	975	router.post('/delete', jsonParser, validateAvatarUrlMiddleware, async function (request, response) {
977	976	if (!request.body \|\| !request.body.avatar_url) {
978	977	return response.sendStatus(400);
979	978	}

  * @param  {import("express").Response} response The HTTP response object.
  * @return {void}
  */
 router.post('/all', jsonParser, async function (request, response) {
     try {
         const files = fs.readdirSync(request.user.directories.characters);
         const pngFiles = files.filter(file => file.endsWith('.png'));

+    }
 });
 router.post('/get', jsonParser, validateAvatarUrlMiddleware, async function (request, response) {
     try {
         if (!request.body) return response.sendStatus(400);
         const item = request.body.avatar_url;

+    }
 });
 router.post('/chats', jsonParser, validateAvatarUrlMiddleware, async function (request, response) {
     try {
         if (!request.body) return response.sendStatus(400);

         : undefined;
+}
 router.post('/import', urlencodedParser, async function (request, response) {
     if (!request.body || !request.file) return response.sendStatus(400);
     const uploadPath = path.join(request.file.destination, request.file.filename);

+    }
 });
 router.post('/duplicate', jsonParser, validateAvatarUrlMiddleware, async function (request, response) {
     try {
         if (!request.body.avatar_url) {
             console.warn('avatar URL not found in request body');

+    }
 });
 router.post('/export', jsonParser, validateAvatarUrlMiddleware, async function (request, response) {
     try {
         if (!request.body.format || !request.body.avatar_url) {
             return response.sendStatus(400);

src/endpoints/chats.js+11 -13 Viewed

 import { sync as writeFileAtomicSync } from 'write-file-atomic';
 import _ from 'lodash';
 -import { jsonParser, urlencodedParser } from '../express-common.js';
 import validateAvatarUrlMiddleware from '../middleware/validateFileName.js';
 import {
     getConfigValue,

 export const router = express.Router();
 router.post('/save', jsonParser, validateAvatarUrlMiddleware, function (request, response) {
     try {
         const directoryName = String(request.body.avatar_url).replace('.png', '');
         const chatData = request.body.chat;

+    }
 });
 router.post('/get', jsonParser, validateAvatarUrlMiddleware, function (request, response) {
     try {
         const dirName = String(request.body.avatar_url).replace('.png', '');
         const directoryPath = path.join(request.user.directories.chats, dirName);

@@ -347,8 +346,7 @@ router.post('/get', jsonParser, validateAvatarUrlMiddleware, function (request,
347	346	}
348	347	});
349	348
350		-
	349	+router.post('/rename', validateAvatarUrlMiddleware, async function (request, response) {
351		-router.post('/rename', jsonParser, validateAvatarUrlMiddleware, async function (request, response) {
352	350	if (!request.body \|\| !request.body.original_file \|\| !request.body.renamed_file) {
353	351	return response.sendStatus(400);
354	352	}

     return response.send({ ok: true, sanitizedFileName });
 });
 router.post('/delete', jsonParser, validateAvatarUrlMiddleware, function (request, response) {
     const dirName = String(request.body.avatar_url).replace('.png', '');
     const fileName = String(request.body.chatfile);
     const filePath = path.join(request.user.directories.chats, dirName, sanitize(fileName));

     return response.send('ok');
 });
 router.post('/export', jsonParser, validateAvatarUrlMiddleware, async function (request, response) {
     if (!request.body.file || (!request.body.avatar_url && request.body.is_group === false)) {
         return response.sendStatus(400);
+    }

+    }
 });
 router.post('/group/import', urlencodedParser, function (request, response) {
     try {
         const filedata = request.file;

+    }
 });
 router.post('/import', urlencodedParser, validateAvatarUrlMiddleware, function (request, response) {
     if (!request.body) return response.sendStatus(400);
     const format = request.body.file_type;

@@ -571,7 +569,7 @@ router.post('/import', urlencodedParser, validateAvatarUrlMiddleware, function (
571	569	}
572	570	});
573	571
574	572	router.post('/group/get', jsonParser, (request, response) => {
575	573	if (!request.body \|\| !request.body.id) {
576	574	return response.sendStatus(400);
577	575	}

@@ -591,7 +589,7 @@ router.post('/group/get', jsonParser, (request, response) => {
591	589	}
592	590	});
593	591
594	592	router.post('/group/delete', jsonParser, (request, response) => {
595	593	if (!request.body \|\| !request.body.id) {
596	594	return response.sendStatus(400);
597	595	}

     return response.send({ error: true });
 });
 router.post('/group/save', jsonParser, (request, response) => {
     if (!request.body || !request.body.id) {
         return response.sendStatus(400);
+    }

     return response.send({ ok: true });
 });
 router.post('/search', jsonParser, validateAvatarUrlMiddleware, function (request, response) {
     try {
         const { query, avatar_url, group_id } = request.body;
         let chatFiles = [];

src/endpoints/classify.js+2 -3 Viewed

 import express from 'express';
 import { getPipeline } from '../transformers.js';
 -import { jsonParser } from '../express-common.js';
 const TASK = 'text-classification';

  */
 const cacheObject = new Map();
 router.post('/labels', jsonParser, async (req, res) => {
     try {
         const pipe = await getPipeline(TASK);
         const result = Object.keys(pipe.model.config.label2id);

+    }
 });
 router.post('/', jsonParser, async (req, res) => {
     try {
         const { text } = req.body;

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

 import { sync as writeFileAtomicSync } from  'write-file-atomic';
 import { getConfigValue, color } from '../util.js';
 -import { jsonParser } from '../express-common.js';
 import { write } from '../character-card-parser.js';
 const contentDirectory = path.join(process.cwd(), 'default/content');

 export const router = express.Router();
 router.post('/importURL', jsonParser, async (request, response) => {
     if (!request.body.url) {
         return response.sendStatus(400);
+    }

@@ -713,7 +712,7 @@ router.post('/importURL', jsonParser, async (request, response) => {
713	712	}
714	713	});
715	714
716	715	router.post('/importUUID', jsonParser, async (request, response) => {
717	716	if (!request.body.url) {
718	717	return response.sendStatus(400);
719	718	}

src/endpoints/extensions.js+6 -7 Viewed

 import { default as simpleGit } from 'simple-git';
 import { PUBLIC_DIRECTORIES } from '../constants.js';
 -import { jsonParser } from '../express-common.js';
 /**
  * This function extracts the extension information from the manifest file.

@@ -60,7 +59,7 @@ export const router = express.Router();
60	59	*
61	60	* @returns {void}
62	61	*/
63	62	router.post('/install', jsonParser, async (request, response) => {
64	63	if (!request.body.url) {
65	64	return response.status(400).send('Bad Request: URL is required in the request body.');
66	65	}

+ *
  * @returns {void}
  */
 router.post('/update', jsonParser, async (request, response) => {
     const git = simpleGit();
     if (!request.body.extensionName) {
         return response.status(400).send('Bad Request: extensionName is required in the request body.');

+    }
 });
 router.post('/move', jsonParser, async (request, response) => {
     try {
         const { extensionName, source, destination } = request.body;

+ *
  * @returns {void}
  */
 router.post('/version', jsonParser, async (request, response) => {
     const git = simpleGit();
     if (!request.body.extensionName) {
         return response.status(400).send('Bad Request: extensionName is required in the request body.');

@@ -256,7 +255,7 @@ router.post('/version', jsonParser, async (request, response) => {
256	255	*
257	256	* @returns {void}
258	257	*/
259	258	router.post('/delete', jsonParser, async (request, response) => {
260	259	if (!request.body.extensionName) {
261	260	return response.status(400).send('Bad Request: extensionName is required in the request body.');
262	261	}

  * Discover the extension folders
  * If the folder is called third-party, search for subfolders instead
  */
 router.get('/discover', jsonParser, function (request, response) {
     if (!fs.existsSync(path.join(request.user.directories.extensions))) {
         fs.mkdirSync(path.join(request.user.directories.extensions));
+    }

src/endpoints/files.js+4 -5 Viewed

 import { sync as writeFileSyncAtomic } from 'write-file-atomic';
 import { validateAssetFileName } from './assets.js';
 -import { jsonParser } from '../express-common.js';
 import { clientRelativePath } from '../util.js';
 export const router = express.Router();
 router.post('/sanitize-filename', jsonParser, async (request, response) => {
     try {
         const fileName = String(request.body.fileName);
         if (!fileName) {

+    }
 });
 router.post('/upload', jsonParser, async (request, response) => {
     try {
         if (!request.body.name) {
             return response.status(400).send('No upload name specified');

+    }
 });
 router.post('/delete', jsonParser, async (request, response) => {
     try {
         if (!request.body.path) {
             return response.status(400).send('No path specified');

+    }
 });
 router.post('/verify', jsonParser, async (request, response) => {
     try {
         if (!Array.isArray(request.body.urls)) {
             return response.status(400).send('No URLs specified');

src/endpoints/google.js+2 -3 Viewed

 import { speak, languages } from 'google-translate-api-x';
 import { readSecret, SECRET_KEYS } from './secrets.js';
 -import { jsonParser } from '../express-common.js';
 import { GEMINI_SAFETY } from '../constants.js';
 const API_MAKERSUITE = 'https://generativelanguage.googleapis.com';
 export const router = express.Router();
 router.post('/caption-image', jsonParser, async (request, response) => {
     try {
         const mimeType = request.body.image.split(';')[0].split(':')[1];
         const base64Data = request.body.image.split(',')[1];

     return response.json(languages);
 });
 router.post('/generate-voice', jsonParser, async (request, response) => {
     try {
         const text = request.body.text;
         const voice = request.body.voice ?? 'en';

src/endpoints/groups.js+4 -5 Viewed

 import sanitize from 'sanitize-filename';
 import { sync as writeFileAtomicSync } from 'write-file-atomic';
 -import { jsonParser } from '../express-common.js';
 import { humanizedISO8601DateTime } from '../util.js';
 export const router = express.Router();
 router.post('/all', jsonParser, (request, response) => {
     const groups = [];
     if (!fs.existsSync(request.user.directories.groups)) {

     return response.send(groups);
 });
 router.post('/create', jsonParser, (request, response) => {
     if (!request.body) {
         return response.sendStatus(400);
+    }

     return response.send(groupMetadata);
 });
 router.post('/edit', jsonParser, (request, response) => {
     if (!request.body || !request.body.id) {
         return response.sendStatus(400);
+    }

     return response.send({ ok: true });
 });
 router.post('/delete', jsonParser, async (request, response) => {
     if (!request.body || !request.body.id) {
         return response.sendStatus(400);
+    }

src/endpoints/horde.js+11 -12 Viewed

 import { AIHorde, ModelGenerationInputStableSamplers, ModelInterrogationFormTypes, HordeAsyncRequestStates } from '@zeldafan0225/ai_horde';
 import { getVersion, delay, Cache } from '../util.js';
 import { readSecret, SECRET_KEYS } from './secrets.js';
 -import { jsonParser } from '../express-common.js';
 const ANONYMOUS_KEY = '0000000000';
 const HORDE_TEXT_MODEL_METADATA_URL = 'https://raw.githubusercontent.com/db0/AI-Horde-text-model-reference/main/db.json';

     return prompt;
+}
 router.post('/text-workers', jsonParser, async (request, response) => {
     try {
         const cachedWorkers = cache.get('workers');

     });
+}
 router.post('/text-models', jsonParser, async (request, response) => {
     try {
         const cachedModels = cache.get('models');
         if (cachedModels && !request.body.force) {

+    }
 });
 router.post('/status', jsonParser, async (_, response) => {
     try {
         const agent = await getClientAgent();
         const fetchResult = await fetch('https://aihorde.net/api/v2/status/heartbeat', {

+    }
 });
 router.post('/cancel-task', jsonParser, async (request, response) => {
     try {
         const taskId = request.body.taskId;
         const agent = await getClientAgent();

+    }
 });
 router.post('/task-status', jsonParser, async (request, response) => {
     try {
         const taskId = request.body.taskId;
         const agent = await getClientAgent();

+    }
 });
 router.post('/generate-text', jsonParser, async (request, response) => {
     const apiKey = readSecret(request.user.directories, SECRET_KEYS.HORDE) || ANONYMOUS_KEY;
     const url = 'https://aihorde.net/api/v2/generate/text/async';
     const agent = await getClientAgent();

+    }
 });
 router.post('/sd-samplers', jsonParser, async (_, response) => {
     try {
         const samplers = Object.values(ModelGenerationInputStableSamplers);
         response.send(samplers);

+    }
 });
 router.post('/sd-models', jsonParser, async (_, response) => {
     try {
         const ai_horde = await getHordeClient();
         const models = await ai_horde.getModels();

+    }
 });
 router.post('/caption-image', jsonParser, async (request, response) => {
     try {
         const api_key_horde = readSecret(request.user.directories, SECRET_KEYS.HORDE) || ANONYMOUS_KEY;
         const ai_horde = await getHordeClient();

+    }
 });
 router.post('/user-info', jsonParser, async (request, response) => {
     const api_key_horde = readSecret(request.user.directories, SECRET_KEYS.HORDE);
     if (!api_key_horde) {

@@ -303,7 +302,7 @@ router.post('/user-info', jsonParser, async (request, response) => {
303	302	}
304	303	});
305	304
306	305	router.post('/generate-image', jsonParser, async (request, response) => {
307	306	if (!request.body.prompt) {
308	307	return response.sendStatus(400);
309	308	}

src/endpoints/images.js+2 -3 Viewed

 import express from 'express';
 import sanitize from 'sanitize-filename';
 -import { jsonParser } from '../express-common.js';
 import { clientRelativePath, removeFileExtension, getImages } from '../util.js';
 /**

  * @param {string} [request.body.ch_name] - Optional character name to determine the sub-directory.
  * @returns {Object} response - The response object containing the path where the image was saved.
  */
 router.post('/upload', jsonParser, async (request, response) => {
     // Check for image data
     if (!request.body || !request.body.image) {
         return response.status(400).send({ error: 'No image data provided' });

+    }
 });
 router.post('/list/:folder?', jsonParser, (request, response) => {
     try {
         if (request.params.folder) {
             if (request.body.folder) {

src/endpoints/moving-ui.js+1 -3 Viewed

 import sanitize from 'sanitize-filename';
 import { sync as writeFileAtomicSync } from 'write-file-atomic';
 -import { jsonParser } from '../express-common.js';
+-
 export const router = express.Router();
 router.post('/save', jsonParser, (request, response) => {
     if (!request.body || !request.body.name) {
         return response.sendStatus(400);
+    }

src/endpoints/novelai.js+4 -5 Viewed

 import { readSecret, SECRET_KEYS } from './secrets.js';
 import { readAllChunks, extractFileFromZipBuffer, forwardFetchResponse } from '../util.js';
 -import { jsonParser } from '../express-common.js';
 const API_NOVELAI = 'https://api.novelai.net';
 const TEXT_NOVELAI = 'https://text.novelai.net';

 export const router = express.Router();
 router.post('/status', jsonParser, async function (req, res) {
     if (!req.body) return res.sendStatus(400);
     const api_key_novel = readSecret(req.user.directories, SECRET_KEYS.NOVEL);

+    }
 });
 router.post('/generate', jsonParser, async function (req, res) {
     if (!req.body) return res.sendStatus(400);
     const api_key_novel = readSecret(req.user.directories, SECRET_KEYS.NOVEL);

@@ -284,7 +283,7 @@ router.post('/generate', jsonParser, async function (req, res) {
284	283	}
285	284	});
286	285
287	286	router.post('/generate-image', jsonParser, async (request, response) => {
288	287	if (!request.body) {
289	288	return response.sendStatus(400);
290	289	}

+    }
 });
 router.post('/generate-voice', jsonParser, async (request, response) => {
     const token = readSecret(request.user.directories, SECRET_KEYS.NOVEL);
     if (!token) {

src/endpoints/openai.js+5 -6 Viewed

 import FormData from 'form-data';
 import express from 'express';
 -import { jsonParser, urlencodedParser } from '../express-common.js';
 import { getConfigValue, mergeObjectWithYaml, excludeKeysByYaml, trimV1 } from '../util.js';
 import { setAdditionalHeaders } from '../additional-headers.js';
 import { readSecret, SECRET_KEYS } from './secrets.js';

 export const router = express.Router();
 router.post('/caption-image', jsonParser, async (request, response) => {
     try {
         let key = '';
         let headers = {};

+    }
 });
 router.post('/transcribe-audio', urlencodedParser, async (request, response) => {
     try {
         const key = readSecret(request.user.directories, SECRET_KEYS.OPENAI);

+    }
 });
 router.post('/generate-voice', jsonParser, async (request, response) => {
     try {
         const key = readSecret(request.user.directories, SECRET_KEYS.OPENAI);

+    }
 });
 router.post('/generate-image', jsonParser, async (request, response) => {
     try {
         const key = readSecret(request.user.directories, SECRET_KEYS.OPENAI);

 const custom = express.Router();
 custom.post('/generate-voice', jsonParser, async (request, response) => {
     try {
         const key = readSecret(request.user.directories, SECRET_KEYS.CUSTOM_OPENAI_TTS);
         const { input, provider_endpoint, response_format, voice, speed, model } = request.body;

src/endpoints/openrouter.js+2 -3 Viewed

 import express from 'express';
 -import { jsonParser } from '../express-common.js';
 export const router = express.Router();
 const API_OPENROUTER = 'https://openrouter.ai/api/v1';
 router.post('/models/providers', jsonParser, async (req, res) => {
     try {
         const { model } = req.body;
         const response = await fetch(`${API_OPENROUTER}/models/${model}/endpoints`, {

+    }
 });
 router.post('/models/multimodal', jsonParser, async (_req, res) => {
     try {
         // The endpoint is available without authentication
         const response = await fetch(`${API_OPENROUTER}/models`, {

src/endpoints/presets.js+5 -6 Viewed

 import { sync as writeFileAtomicSync } from 'write-file-atomic';
 import { getDefaultPresetFile, getDefaultPresets } from './content-manager.js';
 -import { jsonParser } from '../express-common.js';
 /**
  * Gets the folder and extension for the preset settings based on the API source ID.

 export const router = express.Router();
 router.post('/save', jsonParser, function (request, response) {
     const name = sanitize(request.body.name);
     if (!request.body.preset || !name) {
         return response.sendStatus(400);

     return response.send({ name });
 });
 router.post('/delete', jsonParser, function (request, response) {
     const name = sanitize(request.body.name);
     if (!name) {
         return response.sendStatus(400);

+    }
 });
 router.post('/restore', jsonParser, function (request, response) {
     try {
         const settings = getPresetSettingsByAPI(request.body.apiId, request.user.directories);
         const name = sanitize(request.body.name);

 });
 // TODO: Merge with /api/presets/save
 router.post('/save-openai', jsonParser, function (request, response) {
     if (!request.body || typeof request.query.name !== 'string') return response.sendStatus(400);
     const name = sanitize(request.query.name);
     if (!name) return response.sendStatus(400);

 });
 // TODO: Merge with /api/presets/delete
 router.post('/delete-openai', jsonParser, function (request, response) {
     if (!request.body || !request.body.name) {
         return response.sendStatus(400);
+    }

src/endpoints/quick-replies.js+2 -4 Viewed

 import sanitize from 'sanitize-filename';
 import { sync as writeFileAtomicSync } from 'write-file-atomic';
 -import { jsonParser } from '../express-common.js';
+-
 export const router = express.Router();
 router.post('/save', jsonParser, (request, response) => {
     if (!request.body || !request.body.name) {
         return response.sendStatus(400);
+    }

     return response.sendStatus(200);
 });
 router.post('/delete', jsonParser, (request, response) => {
     if (!request.body || !request.body.name) {
         return response.sendStatus(400);
+    }

src/endpoints/search.js+7 -8 Viewed

 import { decode } from 'html-entities';
 import { readSecret, SECRET_KEYS } from './secrets.js';
 -import { jsonParser } from '../express-common.js';
 import { trimV1 } from '../util.js';
 import { setAdditionalHeaders } from '../additional-headers.js';

     return transcriptText;
+}
 router.post('/serpapi', jsonParser, async (request, response) => {
     try {
         const key = readSecret(request.user.directories, SECRET_KEYS.SERPAPI);

  * Get the transcript of a YouTube video
  * @copyright https://github.com/Kakulukian/youtube-transcript (MIT License)
  */
 router.post('/transcript', jsonParser, async (request, response) => {
     try {
         const id = request.body.id;
         const lang = request.body.lang;

+    }
 });
 router.post('/searxng', jsonParser, async (request, response) => {
     try {
         const { baseUrl, query, preferences, categories } = request.body;

+    }
 });
 router.post('/tavily', jsonParser, async (request, response) => {
     try {
         const apiKey = readSecret(request.user.directories, SECRET_KEYS.TAVILY);

+    }
 });
 router.post('/koboldcpp', jsonParser, async (request, response) => {
     try {
         const { query, url } = request.body;

+    }
 });
 router.post('/serper', jsonParser, async (request, response) => {
     try {
         const key = readSecret(request.user.directories, SECRET_KEYS.SERPER);

+    }
 });
 router.post('/visit', jsonParser, async (request, response) => {
     try {
         const url = request.body.url;
         const html = Boolean(request.body.html ?? true);

src/endpoints/secrets.js+4 -5 Viewed

 import express from 'express';
 import { sync as writeFileAtomicSync } from 'write-file-atomic';
 import { getConfigValue } from '../util.js';
 -import { jsonParser } from '../express-common.js';
 export const SECRETS_FILE = 'secrets.json';
 export const SECRET_KEYS = {

 export const router = express.Router();
 router.post('/write', jsonParser, (request, response) => {
     const key = request.body.key;
     const value = request.body.value;

     return response.send('ok');
 });
 router.post('/read', jsonParser, (request, response) => {
     try {
         const state = readSecretState(request.user.directories);
         return response.send(state);

+    }
 });
 router.post('/view', jsonParser, async (request, response) => {
     const allowKeysExposure = getConfigValue('allowKeysExposure', false, 'boolean');
     if (!allowKeysExposure) {

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

src/endpoints/settings.js+6 -7 Viewed

 import { SETTINGS_FILE } from '../constants.js';
 import { getConfigValue, generateTimestamp, removeOldBackups } from '../util.js';
 -import { jsonParser } from '../express-common.js';
 import { getAllUserHandles, getUserDirectories } from '../users.js';
 import { getFileNameValidationFunction } from '../middleware/validateFileName.js';

 export const router = express.Router();
 router.post('/save', jsonParser, function (request, response) {
     try {
         const pathToSettings = path.join(request.user.directories.root, SETTINGS_FILE);
         writeFileAtomicSync(pathToSettings, JSON.stringify(request.body, null, 4), 'utf8');

 });
 // Wintermute's code
 router.post('/get', jsonParser, (request, response) => {
     let settings;
     try {
         const pathToSettings = path.join(request.user.directories.root, SETTINGS_FILE);

     });
 });
 router.post('/get-snapshots', jsonParser, async (request, response) => {
     try {
         const snapshots = fs.readdirSync(request.user.directories.backups);
         const userFilesPattern = getFilePrefix(request.user.profile.handle);

+    }
 });
 router.post('/load-snapshot', jsonParser, getFileNameValidationFunction('name'), async (request, response) => {
     try {
         const userFilesPattern = getFilePrefix(request.user.profile.handle);

+    }
 });
 router.post('/make-snapshot', jsonParser, async (request, response) => {
     try {
         backupUserSettings(request.user.profile.handle, false);
         response.sendStatus(204);

+    }
 });
 router.post('/restore-snapshot', jsonParser, getFileNameValidationFunction('name'), async (request, response) => {
     try {
         const userFilesPattern = getFilePrefix(request.user.profile.handle);

src/endpoints/speech.js+2 -3 Viewed

 import { Buffer } from 'node:buffer';
 import express from 'express';
 import wavefile from 'wavefile';
 -import { jsonParser } from '../express-common.js';
 import { getPipeline } from '../transformers.js';
 export const router = express.Router();

     return audioData;
+}
 router.post('/recognize', jsonParser, async (req, res) => {
     try {
         const TASK = 'automatic-speech-recognition';
         const { model, audio, lang } = req.body;

+    }
 });
 router.post('/synthesize', jsonParser, async (req, res) => {
     try {
         const TASK = 'text-to-speech';
         const { text, model, speaker } = req.body;

src/endpoints/sprites.js+4 -5 Viewed

 import { sync as writeFileAtomicSync } from 'write-file-atomic';
 import { getImageBuffers } from '../util.js';
 -import { jsonParser, urlencodedParser } from '../express-common.js';
 /**
  * Gets the path to the sprites folder for the provided character name

 export const router = express.Router();
 router.get('/get', jsonParser, function (request, response) {
     const name = String(request.query.name);
     const isSubfolder = name.includes('/');
     const spritesPath = getSpritesPath(request.user.directories, name, isSubfolder);

     return response.send(sprites);
 });
 router.post('/delete', jsonParser, async (request, response) => {
     const label = request.body.label;
     const name = request.body.name;
     const spriteName = request.body.spriteName || label;

+    }
 });
 router.post('/upload-zip', urlencodedParser, async (request, response) => {
     const file = request.file;
     const name = request.body.name;

+    }
 });
 router.post('/upload', urlencodedParser, async (request, response) => {
     const file = request.file;
     const label = request.body.label;
     const name = request.body.name;

src/endpoints/stable-diffusion.js+38 -39 Viewed

 import _ from 'lodash';
 import { delay, getBasicAuthHeader, tryParse } from '../util.js';
 -import { jsonParser } from '../express-common.js';
 import { readSecret, SECRET_KEYS } from './secrets.js';
 /**

 export const router = express.Router();
 router.post('/ping', jsonParser, async (request, response) => {
     try {
         const url = new URL(request.body.url);
         url.pathname = '/sdapi/v1/options';

+    }
 });
 router.post('/upscalers', jsonParser, async (request, response) => {
     try {
         async function getUpscalerModels() {
             const url = new URL(request.body.url);

+    }
 });
 router.post('/vaes', jsonParser, async (request, response) => {
     try {
         const autoUrl = new URL(request.body.url);
         autoUrl.pathname = '/sdapi/v1/sd-vae';

+    }
 });
 router.post('/samplers', jsonParser, async (request, response) => {
     try {
         const url = new URL(request.body.url);
         url.pathname = '/sdapi/v1/samplers';

+    }
 });
 router.post('/schedulers', jsonParser, async (request, response) => {
     try {
         const url = new URL(request.body.url);
         url.pathname = '/sdapi/v1/schedulers';

+    }
 });
 router.post('/models', jsonParser, async (request, response) => {
     try {
         const url = new URL(request.body.url);
         url.pathname = '/sdapi/v1/sd-models';

+    }
 });
 router.post('/get-model', jsonParser, async (request, response) => {
     try {
         const url = new URL(request.body.url);
         url.pathname = '/sdapi/v1/options';

+    }
 });
 router.post('/set-model', jsonParser, async (request, response) => {
     try {
         async function getProgress() {
             const url = new URL(request.body.url);

+    }
 });
 router.post('/generate', jsonParser, async (request, response) => {
     try {
         try {
             const optionsUrl = new URL(request.body.url);

+    }
 });
 router.post('/sd-next/upscalers', jsonParser, async (request, response) => {
     try {
         const url = new URL(request.body.url);
         url.pathname = '/sdapi/v1/upscalers';

 const comfy = express.Router();
 comfy.post('/ping', jsonParser, async (request, response) => {
     try {
         const url = new URL(urlJoin(request.body.url, '/system_stats'));

+    }
 });
 comfy.post('/samplers', jsonParser, async (request, response) => {
     try {
         const url = new URL(urlJoin(request.body.url, '/object_info'));

+    }
 });
 comfy.post('/models', jsonParser, async (request, response) => {
     try {
         const url = new URL(urlJoin(request.body.url, '/object_info'));

+    }
 });
 comfy.post('/schedulers', jsonParser, async (request, response) => {
     try {
         const url = new URL(urlJoin(request.body.url, '/object_info'));

+    }
 });
 comfy.post('/vaes', jsonParser, async (request, response) => {
     try {
         const url = new URL(urlJoin(request.body.url, '/object_info'));

+    }
 });
 comfy.post('/workflows', jsonParser, async (request, response) => {
     try {
         const data = getComfyWorkflows(request.user.directories);
         return response.send(data);

+    }
 });
 comfy.post('/workflow', jsonParser, async (request, response) => {
     try {
         let filePath = path.join(request.user.directories.comfyWorkflows, sanitize(String(request.body.file_name)));
         if (!fs.existsSync(filePath)) {

+    }
 });
 comfy.post('/save-workflow', jsonParser, async (request, response) => {
     try {
         const filePath = path.join(request.user.directories.comfyWorkflows, sanitize(String(request.body.file_name)));
         writeFileAtomicSync(filePath, request.body.workflow, 'utf8');

+    }
 });
 comfy.post('/delete-workflow', jsonParser, async (request, response) => {
     try {
         const filePath = path.join(request.user.directories.comfyWorkflows, sanitize(String(request.body.file_name)));
         if (fs.existsSync(filePath)) {

+    }
 });
 comfy.post('/generate', jsonParser, async (request, response) => {
     try {
         let item;
         const url = new URL(urlJoin(request.body.url, '/prompt'));

 const together = express.Router();
 together.post('/models', jsonParser, async (request, response) => {
     try {
         const key = readSecret(request.user.directories, SECRET_KEYS.TOGETHERAI);

+    }
 });
 together.post('/generate', jsonParser, async (request, response) => {
     try {
         const key = readSecret(request.user.directories, SECRET_KEYS.TOGETHERAI);

 const drawthings = express.Router();
 drawthings.post('/ping', jsonParser, async (request, response) => {
     try {
         const url = new URL(request.body.url);
         url.pathname = '/';

+    }
 });
 drawthings.post('/get-model', jsonParser, async (request, response) => {
     try {
         const url = new URL(request.body.url);
         url.pathname = '/';

+    }
 });
 drawthings.post('/get-upscaler', jsonParser, async (request, response) => {
     try {
         const url = new URL(request.body.url);
         url.pathname = '/';

+    }
 });
 drawthings.post('/generate', jsonParser, async (request, response) => {
     try {
         console.debug('SD DrawThings API request:', request.body);

 const pollinations = express.Router();
 pollinations.post('/models', jsonParser, async (_request, response) => {
     try {
         const modelsUrl = new URL('https://image.pollinations.ai/models');
         const result = await fetch(modelsUrl);

+    }
 });
 pollinations.post('/generate', jsonParser, async (request, response) => {
     try {
         const promptUrl = new URL(`https://image.pollinations.ai/prompt/${encodeURIComponent(request.body.prompt)}`);
         const params = new URLSearchParams({

 const stability = express.Router();
 stability.post('/generate', jsonParser, async (request, response) => {
     try {
         const key = readSecret(request.user.directories, SECRET_KEYS.STABILITY);

 const blockentropy = express.Router();
 blockentropy.post('/models', jsonParser, async (request, response) => {
     try {
         const key = readSecret(request.user.directories, SECRET_KEYS.BLOCKENTROPY);

+    }
 });
 blockentropy.post('/generate', jsonParser, async (request, response) => {
     try {
         const key = readSecret(request.user.directories, SECRET_KEYS.BLOCKENTROPY);

 const huggingface = express.Router();
 huggingface.post('/generate', jsonParser, async (request, response) => {
     try {
         const key = readSecret(request.user.directories, SECRET_KEYS.HUGGINGFACE);

 const nanogpt = express.Router();
 nanogpt.post('/models', jsonParser, async (request, response) => {
     try {
         const key = readSecret(request.user.directories, SECRET_KEYS.NANOGPT);

+    }
 });
 nanogpt.post('/generate', jsonParser, async (request, response) => {
     try {
         const key = readSecret(request.user.directories, SECRET_KEYS.NANOGPT);

 const bfl = express.Router();
 bfl.post('/generate', jsonParser, async (request, response) => {
     try {
         const key = readSecret(request.user.directories, SECRET_KEYS.BFL);

 const falai = express.Router();
 falai.post('/models', jsonParser, async (_request, response) => {
     try {
         const modelsUrl = new URL('https://fal.ai/api/models?categories=text-to-image');
         const result = await fetch(modelsUrl);

+    }
 });
 falai.post('/generate', jsonParser, async (request, response) => {
     try {
         const key = readSecret(request.user.directories, SECRET_KEYS.FALAI);

             seed: request.body.seed ?? null,
             guidance_scale: request.body.guidance,
             enable_safety_checker: false, // Disable general safety checks
             safety_tolerance: 6, // Make Flux the least strict
         };
         console.debug('FAL.AI request:', requestBody);

src/endpoints/stats.js+3 -4 Viewed

 const readFile = fs.promises.readFile;
 const readdir = fs.promises.readdir;
 -import { jsonParser } from '../express-common.js';
 import { getAllUserHandles, getUserDirectories } from '../users.js';
 const STATS_FILE = 'stats.json';

 /**
  * Handle a POST request to get the stats object
  */
 router.post('/get', jsonParser, function (request, response) {
     const stats = STATS.get(request.user.profile.handle) || {};
     response.send(stats);
 });

 /**
  * Triggers the recreation of statistics from chat files.
  */
 router.post('/recreate', jsonParser, async function (request, response) {
     try {
         await recreateStats(request.user.profile.handle, request.user.directories.chats, request.user.directories.characters);
         return response.sendStatus(200);

 /**
  * Handle a POST request to update the stats object
 */
 router.post('/update', jsonParser, function (request, response) {
     if (!request.body) return response.sendStatus(400);
     setCharStats(request.user.profile.handle, request.body);
     return response.sendStatus(200);

src/endpoints/themes.js+2 -4 Viewed

 import sanitize from 'sanitize-filename';
 import { sync as writeFileAtomicSync } from 'write-file-atomic';
 -import { jsonParser } from '../express-common.js';
+-
 export const router = express.Router();
 router.post('/save', jsonParser, (request, response) => {
     if (!request.body || !request.body.name) {
         return response.sendStatus(400);
+    }

     return response.sendStatus(200);
 });
 router.post('/delete', jsonParser, function (request, response) {
     if (!request.body || !request.body.name) {
         return response.sendStatus(400);
+    }

src/endpoints/thumbnails.js+1 -2 Viewed

 import { getAllUserHandles, getUserDirectories } from '../users.js';
 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'))));

 export const router = express.Router();
 // Important: This route must be mounted as '/thumbnail'. It is used in the client code and saved to chat files.
 router.get('/', jsonParser, async function (request, response) {
     try{
         if (typeof request.query.file !== 'string' || typeof request.query.type !== 'string') {
             return response.sendStatus(400);

src/endpoints/tokenizers.js+34 -35 Viewed

 import { convertClaudePrompt } from '../prompt-converters.js';
 import { TEXTGEN_TYPES } from '../constants.js';
 -import { jsonParser } from '../express-common.js';
 import { setAdditionalHeaders } from '../additional-headers.js';
 import { getConfigValue, isValidUrl } from '../util.js';

 export const router = express.Router();
 router.post('/llama/encode', jsonParser, createSentencepieceEncodingHandler(spp_llama));
 router.post('/nerdstash/encode', jsonParser, createSentencepieceEncodingHandler(spp_nerd));
 router.post('/nerdstash_v2/encode', jsonParser, createSentencepieceEncodingHandler(spp_nerd_v2));
 router.post('/mistral/encode', jsonParser, createSentencepieceEncodingHandler(spp_mistral));
 router.post('/yi/encode', jsonParser, createSentencepieceEncodingHandler(spp_yi));
 router.post('/gemma/encode', jsonParser, createSentencepieceEncodingHandler(spp_gemma));
 router.post('/jamba/encode', jsonParser, createSentencepieceEncodingHandler(spp_jamba));
 router.post('/gpt2/encode', jsonParser, createTiktokenEncodingHandler('gpt2'));
 router.post('/claude/encode', jsonParser, createWebTokenizerEncodingHandler(claude_tokenizer));
 router.post('/llama3/encode', jsonParser, createWebTokenizerEncodingHandler(llama3_tokenizer));
 router.post('/qwen2/encode', jsonParser, createWebTokenizerEncodingHandler(qwen2Tokenizer));
 router.post('/command-r/encode', jsonParser, createWebTokenizerEncodingHandler(commandTokenizer));
 router.post('/nemo/encode', jsonParser, createWebTokenizerEncodingHandler(nemoTokenizer));
 router.post('/deepseek/encode', jsonParser, createWebTokenizerEncodingHandler(deepseekTokenizer));
 router.post('/llama/decode', jsonParser, createSentencepieceDecodingHandler(spp_llama));
 router.post('/nerdstash/decode', jsonParser, createSentencepieceDecodingHandler(spp_nerd));
 router.post('/nerdstash_v2/decode', jsonParser, createSentencepieceDecodingHandler(spp_nerd_v2));
 router.post('/mistral/decode', jsonParser, createSentencepieceDecodingHandler(spp_mistral));
 router.post('/yi/decode', jsonParser, createSentencepieceDecodingHandler(spp_yi));
 router.post('/gemma/decode', jsonParser, createSentencepieceDecodingHandler(spp_gemma));
 router.post('/jamba/decode', jsonParser, createSentencepieceDecodingHandler(spp_jamba));
 router.post('/gpt2/decode', jsonParser, createTiktokenDecodingHandler('gpt2'));
 router.post('/claude/decode', jsonParser, createWebTokenizerDecodingHandler(claude_tokenizer));
 router.post('/llama3/decode', jsonParser, createWebTokenizerDecodingHandler(llama3_tokenizer));
 router.post('/qwen2/decode', jsonParser, createWebTokenizerDecodingHandler(qwen2Tokenizer));
 router.post('/command-r/decode', jsonParser, createWebTokenizerDecodingHandler(commandTokenizer));
 router.post('/nemo/decode', jsonParser, createWebTokenizerDecodingHandler(nemoTokenizer));
 router.post('/deepseek/decode', jsonParser, createWebTokenizerDecodingHandler(deepseekTokenizer));
 router.post('/openai/encode', jsonParser, async function (req, res) {
     try {
         const queryModel = String(req.query.model || '');

+    }
 });
 router.post('/openai/decode', jsonParser, async function (req, res) {
     try {
         const queryModel = String(req.query.model || '');

+    }
 });
 router.post('/openai/count', jsonParser, async function (req, res) {
     try {
         if (!req.body) return res.sendStatus(400);

@@ -968,7 +967,7 @@ router.post('/openai/count', jsonParser, async function (req, res) {
968	967	}
969	968	});
970	969
971	970	router.post('/remote/kobold/count', jsonParser, async function (request, response) {
972	971	if (!request.body) {
973	972	return response.sendStatus(400);
974	973	}

@@ -1002,7 +1001,7 @@ router.post('/remote/kobold/count', jsonParser, async function (request, respons
1002	1001	}
1003	1002	});
1004	1003
1005	1004	router.post('/remote/textgenerationwebui/encode', jsonParser, async function (request, response) {
1006	1005	if (!request.body) {
1007	1006	return response.sendStatus(400);
1008	1007	}

src/endpoints/translate.js+8 -9 Viewed

 import { readSecret, SECRET_KEYS } from './secrets.js';
 import { getConfigValue, uuidv4 } from '../util.js';
 -import { jsonParser } from '../express-common.js';
 const DEEPLX_URL_DEFAULT = 'http://127.0.0.1:1188/translate';
 const ONERING_URL_DEFAULT = 'http://127.0.0.1:4990/translate';

@@ -40,7 +39,7 @@ function decodeBuffer(buffer) {
40	39	}
41	40	}
42	41
43	42	router.post('/libre', jsonParser, async (request, response) => {
44	43	try {
45	44	const key = readSecret(request.user.directories, SECRET_KEYS.LIBRE);
46	45	const url = readSecret(request.user.directories, SECRET_KEYS.LIBRE_URL);

+    }
 });
 router.post('/google', jsonParser, async (request, response) => {
     try {
         const text = request.body.text;
         const lang = request.body.lang;

+    }
 });
 router.post('/yandex', jsonParser, async (request, response) => {
     try {
         if (request.body.lang === 'pt-PT') {
             request.body.lang = 'pt';

+    }
 });
 router.post('/lingva', jsonParser, async (request, response) => {
     try {
         const secretUrl = readSecret(request.user.directories, SECRET_KEYS.LINGVA_URL);
         const baseUrl = secretUrl || LINGVA_DEFAULT;

+    }
 });
 router.post('/deepl', jsonParser, async (request, response) => {
     try {
         const key = readSecret(request.user.directories, SECRET_KEYS.DEEPL);

+    }
 });
 router.post('/onering', jsonParser, async (request, response) => {
     try {
         const secretUrl = readSecret(request.user.directories, SECRET_KEYS.ONERING_URL);
         const url = secretUrl || ONERING_URL_DEFAULT;

+    }
 });
 router.post('/deeplx', jsonParser, async (request, response) => {
     try {
         const secretUrl = readSecret(request.user.directories, SECRET_KEYS.DEEPLX_URL);
         const url = secretUrl || DEEPLX_URL_DEFAULT;

+    }
 });
 router.post('/bing', jsonParser, async (request, response) => {
     try {
         const text = request.body.text;
         let lang = request.body.lang;

src/endpoints/users-admin.js+8 -9 Viewed

 import storage from 'node-persist';
 import express from 'express';
 import lodash from 'lodash';
 -import { jsonParser } from '../express-common.js';
 import { checkForNewContent, CONTENT_TYPES } from './content-manager.js';
 import {
     KEY_PREFIX,

 export const router = express.Router();
 router.post('/get', requireAdminMiddleware, jsonParser, async (_request, response) => {
     try {
         /** @type {import('../users.js').User[]} */
         const users = await storage.values(x => x.key.startsWith(KEY_PREFIX));

+    }
 });
 router.post('/disable', requireAdminMiddleware, jsonParser, async (request, response) => {
     try {
         if (!request.body.handle) {
             console.warn('Disable user failed: Missing required fields');

+    }
 });
 router.post('/enable', requireAdminMiddleware, jsonParser, async (request, response) => {
     try {
         if (!request.body.handle) {
             console.warn('Enable user failed: Missing required fields');

+    }
 });
 router.post('/promote', requireAdminMiddleware, jsonParser, async (request, response) => {
     try {
         if (!request.body.handle) {
             console.warn('Promote user failed: Missing required fields');

+    }
 });
 router.post('/demote', requireAdminMiddleware, jsonParser, async (request, response) => {
     try {
         if (!request.body.handle) {
             console.warn('Demote user failed: Missing required fields');

+    }
 });
 router.post('/create', requireAdminMiddleware, jsonParser, async (request, response) => {
     try {
         if (!request.body.handle || !request.body.name) {
             console.warn('Create user failed: Missing required fields');

+    }
 });
 router.post('/delete', requireAdminMiddleware, jsonParser, async (request, response) => {
     try {
         if (!request.body.handle) {
             console.warn('Delete user failed: Missing required fields');

+    }
 });
 router.post('/slugify', requireAdminMiddleware, jsonParser, async (request, response) => {
     try {
         if (!request.body.text) {
             console.warn('Slugify failed: Missing required fields');

src/endpoints/users-private.js+7 -8 Viewed

 import storage from 'node-persist';
 import express from 'express';
 -import { jsonParser } from '../express-common.js';
 import { getUserAvatar, toKey, getPasswordHash, getPasswordSalt, createBackupArchive, ensurePublicDirectoriesExist, toAvatarKey } from '../users.js';
 import { SETTINGS_FILE } from '../constants.js';
 import { checkForNewContent, CONTENT_TYPES } from './content-manager.js';

+    }
 });
 router.post('/change-avatar', jsonParser, async (request, response) => {
     try {
         if (!request.body.handle) {
             console.warn('Change avatar failed: Missing required fields');

+    }
 });
 router.post('/change-password', jsonParser, async (request, response) => {
     try {
         if (!request.body.handle) {
             console.warn('Change password failed: Missing required fields');

+    }
 });
 router.post('/backup', jsonParser, async (request, response) => {
     try {
         const handle = request.body.handle;

+    }
 });
 router.post('/reset-settings', jsonParser, async (request, response) => {
     try {
         const password = request.body.password;

+    }
 });
 router.post('/change-name', jsonParser, async (request, response) => {
     try {
         if (!request.body.name || !request.body.handle) {
             console.warn('Change name failed: Missing required fields');

+    }
 });
 router.post('/reset-step1', jsonParser, async (request, response) => {
     try {
         const resetCode = String(crypto.randomInt(1000, 9999));
         console.log();

+    }
 });
 router.post('/reset-step2', jsonParser, async (request, response) => {
     try {
         if (!request.body.code) {
             console.warn('Recover step 2 failed: Missing required fields');

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

 import storage from 'node-persist';
 import express from 'express';
 import { RateLimiterMemory, RateLimiterRes } from 'rate-limiter-flexible';
 import { jsonParser, getIpFromRequest, getRealIpFromHeader } from '../express-common.js';
 import { color, Cache, getConfigValue } from '../util.js';
 import { KEY_PREFIX, getUserAvatar, toKey, getPasswordHash, getPasswordSalt } from '../users.js';

+    }
 });
 router.post('/login', jsonParser, async (request, response) => {
     try {
         if (!request.body.handle) {
             console.warn('Login failed: Missing required fields');

+    }
 });
 router.post('/recover-step1', jsonParser, async (request, response) => {
     try {
         if (!request.body.handle) {
             console.warn('Recover step 1 failed: Missing required fields');

+    }
 });
 router.post('/recover-step2', jsonParser, async (request, response) => {
     try {
         if (!request.body.handle || !request.body.code) {
             console.warn('Recover step 2 failed: Missing required fields');

src/endpoints/vectors.js+7 -8 Viewed

 import express from 'express';
 import sanitize from 'sanitize-filename';
 -import { jsonParser } from '../express-common.js';
 import { getConfigValue } from '../util.js';
 import { getNomicAIBatchVector, getNomicAIVector } from '../vectors/nomicai-vectors.js';

 export const router = express.Router();
 router.post('/query', jsonParser, async (req, res) => {
     try {
         if (!req.body.collectionId || !req.body.searchText) {
             return res.sendStatus(400);

+    }
 });
 router.post('/query-multi', jsonParser, async (req, res) => {
     try {
         if (!Array.isArray(req.body.collectionIds) || !req.body.searchText) {
             return res.sendStatus(400);

+    }
 });
 router.post('/insert', jsonParser, async (req, res) => {
     try {
         if (!Array.isArray(req.body.items) || !req.body.collectionId) {
             return res.sendStatus(400);

+    }
 });
 router.post('/list', jsonParser, async (req, res) => {
     try {
         if (!req.body.collectionId) {
             return res.sendStatus(400);

+    }
 });
 router.post('/delete', jsonParser, async (req, res) => {
     try {
         if (!Array.isArray(req.body.hashes) || !req.body.collectionId) {
             return res.sendStatus(400);

+    }
 });
 router.post('/purge-all', jsonParser, async (req, res) => {
     try {
         for (const source of SOURCES) {
             const sourcePath = path.join(req.user.directories.vectors, sanitize(source));

+    }
 });
 router.post('/purge', jsonParser, async (req, res) => {
     try {
         if (!req.body.collectionId) {
             return res.sendStatus(400);

src/endpoints/worldinfo.js+4 -6 Viewed

 import sanitize from 'sanitize-filename';
 import { sync as writeFileAtomicSync } from 'write-file-atomic';
 -import { jsonParser, urlencodedParser } from '../express-common.js';
+-
 /**
  * Reads a World Info file and returns its contents
  * @param {import('../users.js').UserDirectoryList} directories User directories

 export const router = express.Router();
 router.post('/get', jsonParser, (request, response) => {
     if (!request.body?.name) {
         return response.sendStatus(400);
+    }

     return response.send(file);
 });
 router.post('/delete', jsonParser, (request, response) => {
     if (!request.body?.name) {
         return response.sendStatus(400);
+    }

     return response.sendStatus(200);
 });
 router.post('/import', urlencodedParser, (request, response) => {
     if (!request.file) return response.sendStatus(400);
     const filename = `${path.parse(sanitize(request.file.originalname)).name}.json`;

     return response.send({ name: worldName });
 });
 router.post('/edit', jsonParser, (request, response) => {
     if (!request.body) {
         return response.sendStatus(400);
+    }

src/express-common.js+5 -4 Viewed

 -import express from 'express';
 import ipaddr from 'ipaddr.js';
 -// Instantiate parser middleware here with application-level size limits
 +const noopMiddleware = (_req, _res, next) => next();
 -export const jsonParser = express.json({ limit: '200mb' });
 +/** @deprecated Do not use. A global middleware is provided at the application level. */
 -export const urlencodedParser = express.urlencoded({ extended: true, limit: '200mb' });
 +export const jsonParser = noopMiddleware;
 +/** @deprecated Do not use. A global middleware is provided at the application level. */
 +export const urlencodedParser = noopMiddleware;
 /**
  * Gets the IP address of the client from the request object.

Merge pull request #3652 from SillyTavern/default-middleware Use default middleware for parsing request body