76d16617 · permissionBRICK/SillyTavern

default/config.yaml+2 -0 Viewed

 # the username and passwords for basic auth are the same as those
 # for the individual accounts
 perUserBasicAuth: false
 +# Minimum log level to display in the terminal (DEBUG = 0, INFO = 1, WARN = 2, ERROR = 3)
 +minLogLevel: 0
 # User session timeout *in seconds* (defaults to 24 hours).
 ## Set to a positive number to expire session after a certain time of inactivity

public/scripts/chat-templates.js+2 -1 Viewed

     // DeepSeek R1
     'b6835114b7303ddd78919a82e4d9f7d8c26ed0d7dfc36beeb12d524f6144eab1':
         'DeepSeek-V2.5'
 +    ,
 };
 const substr_derivations = {

@@ -97,6 +98,6 @@ export async function deriveTemplatesFromChatTemplate(chat_template, hash) {
97	98	}
98	99	}
99	100
100	101	console.logwarn(`Unknown chat template hash: ${hash} for [${chat_template}]`);
101	102	return null;
102	103	}

public/scripts/extensions/quick-reply/src/QuickReplySet.js+6 -28 Viewed

 import { getRequestHeaders, substituteParams } from '../../../../script.js';
 import { Popup, POPUP_RESULT, POPUP_TYPE } from '../../../popup.js';
 import { executeSlashCommands, executeSlashCommandsOnChatInput, executeSlashCommandsWithOptions } from '../../../slash-commands.js';
 -import { SlashCommandParser } from '../../../slash-commands/SlashCommandParser.js';
 import { SlashCommandScope } from '../../../slash-commands/SlashCommandScope.js';
 import { debounceAsync, log, warnSlashCommandParser } from '../index../../slash-commands/SlashCommandParser.js';
 +import { debounceAsync, warn } from '../index.js';
 import { QuickReply } from './QuickReply.js';
 export class QuickReplySet {
     /**@type {QuickReplySet[]}*/ static list = [];
+-
     static from(props) {
         props.qrList = []; //props.qrList?.map(it=>QuickReply.from(it));
         const instance = Object.assign(new this(), props);

         return this.list.find(it=>it.name == name);
+    }
+-
+-
+-
     /**@type {string}*/ name;
     /**@type {boolean}*/ disableSend = false;
     /**@type {boolean}*/ placeBeforeInput = false;

     /**@type {string}*/ color = 'transparent';
     /**@type {boolean}*/ onlyBorderColor = false;
     /**@type {QuickReply[]}*/ qrList = [];
+-
     /**@type {number}*/ idIndex = 0;
+-
     /**@type {boolean}*/ isDeleted = false;
+-
     /**@type {function}*/ save;
+-
     /**@type {HTMLElement}*/ dom;
     /**@type {HTMLElement}*/ settingsDom;
+-
+-
+-
     constructor() {
         this.save = debounceAsync(()=>this.performSave(), 200);
+    }

         this.qrList.forEach(qr=>this.hookQuickReply(qr));
+    }
+-
+-
+-
     unrender() {
         this.dom?.remove();
         this.dom = null;

@@ -100,9 +86,6 @@ export class QuickReplySet {
100	86	}
101	87	}
102	88
103		-
104		-
105		-
106	89	renderSettings() {
107	90	if (!this.settingsDom) {
108	91	this.settingsDom = document.createElement('div'); {

@@ -123,9 +106,6 @@ export class QuickReplySet {
123	106	this.settingsDom.append(qr.renderSettings(idx));
124	107	}
125	108
126		-
127		-
128		-
129	109	/**
130	110	*
131	111	* @param {QuickReply} qr

@@ -138,6 +118,7 @@ export class QuickReplySet {
138	118	closure.scope.setMacro('arg::*', '');
139	119	return (await closure.execute())?.pipe;
140	120	}
	121	+
141	122	/**
142	123	*
143	124	* @param {QuickReply} qr The QR to execute.

@@ -207,6 +188,7 @@ export class QuickReplySet {
207	188	document.querySelector('#send_but').click();
208	189	}
209	190	}
	191	+
210	192	/**
211	193	* @param {QuickReply} qr
212	194	* @param {string} [message] - optional altered message to be used

         });
+    }
+-
+-
+-
     addQuickReply(data = {}) {
         const id = Math.max(this.idIndex, this.qrList.reduce((max,qr)=>Math.max(max,qr.id),0)) + 1;
         data.id =

         this.save();
         return qr;
+    }
++
     addQuickReplyFromText(qrJson) {
         let data;
         if (qrJson) {

         this.save();
+    }
+-
     toJSON() {
         return {
             version: 2,

         };
+    }
+-
     async performSave() {
         const response = await fetch('/api/quick-replies/save', {
             method: 'POST',

public/scripts/extensions/vectors/index.js+2 -4 Viewed

+                }
                 return textResult;
             };
+-
             if (args.return === 'chunks') {
                 return getChunksText();
+            }
             // @ts-ignore
             return slashCommandReturnHelper.doReturn(args.return ?? 'object', urls, { objectToStringFunc: list => list.join('\n') });
+-
         },
         aliases: ['databank-search', 'data-bank-search'],
         helpString: 'Search the Data Bank for a specific query using vector similarity. Returns a list of file URLs with the most relevant content.',

                 defaultValue: 'object',
                 enumList: [
                     new SlashCommandEnumValue('chunks', 'Return the actual content chunks', enumTypes.enum, '{}'),
                     ...slashCommandReturnHelper.enumList({ allowObject: true }),
                 ],
                 forceEnum: true,
             }),
         ],
         unnamedArgumentList: [
             new SlashCommandArgument('Query to search by.', ARGUMENT_TYPE.STRING, true, false),

public/scripts/openai.js+1 -3 Viewed

+    }
     const onStreamResult = (res, err) => {
         if (err) {return;
 -            return;
 -        }
         const thisContent = res?.message?.content;

server.js+6 -2 Viewed

     removeColorFormatting,
     getSeparator,
     safeReadFileSync,
 +    setupLogLevel,
 } from './src/util.js';
 import { UPLOADS_DIRECTORY } from './src/constants.js';
 import { ensureThumbnailCache } from './src/endpoints/thumbnails.js';

 function getAutorunHostname() {
     if (autorunHostname === 'auto') {
         if (enableIPv6 && enableIPv4) {
 -            if (avoidLocalhost) return '[::1]';
 +            return avoidLocalhost
 -            return 'localhost';
 +                ? '[::1]'
 +                : 'localhost';
+        }
         if (enableIPv6) {

@@ -765,6 +767,8 @@ const postSetupTasks = async function (v6Failed, v4Failed) {
765	767	}
766	768	}
767	769	}
	770	+
	771	+ setupLogLevel();
768	772	};
769	773
770	774	/**

src/constants.js+7 -0 Viewed

     'guided_decoding_backend',
     'guided_whitespace_pattern',
 ];
++
 +export const LOG_LEVELS = {
 +    DEBUG: 0,
 +    INFO: 1,
 +    WARN: 2,
 +    ERROR: 3,
 +};

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

             max_tokens: 4096,
         };
         console.logdebug('Multimodal captioning request', body);
         const result = await fetch(url, {
             body: JSON.stringify(body),

         if (!result.ok) {
             const text = await result.text();
             console.logwarn(`Claude API returned error: ${result.status} ${result.statusText}`, text);
             return response.status(result.status).send({ error: true });
+        }
         /** @type {any} */
         const generateResponseJson = await result.json();
         const caption = generateResponseJson.content[0].text;
         console.logdebug('Claude response:', generateResponseJson);
         if (!caption) {
             return response.status(500).send('No caption found');

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

@@ -176,7 +176,7 @@ router.post('/get', jsonParser, async (request, response) => {
176	176	}
177	177	}
178	178	catch (err) {
179	179	console.logerror(err);
180	180	}
181	181	return response.send(output);
182	182	});

             category = i;
     if (category === null) {
         console.debugerror('Bad request: unsupported asset category.');
         return response.sendStatus(400);
+    }

     const temp_path = path.join(request.user.directories.assets, 'temp', request.body.filename);
     const file_path = path.join(request.user.directories.assets, category, request.body.filename);
     console.debuginfo('Request received to download', url, 'to', file_path);
     try {
         // Download to temp

@@ -241,13 +241,13 @@ router.post('/download', jsonParser, async (request, response) => {
241	241	}
242	242
243	243	// Move into asset place
244	244	console.debuginfo('Download finished, moving file from', temp_path, 'to', file_path);
245	245	fs.copyFileSync(temp_path, file_path);
246	246	fs.rmSync(temp_path);
247	247	response.sendStatus(200);
248	248	}
249	249	catch (error) {
250	250	console.logerror(error);
251	251	response.sendStatus(500);
252	252	}
253	253	});

             category = i;
     if (category === null) {
         console.debugerror('Bad request: unsupported asset category.');
         return response.sendStatus(400);
+    }

         return response.status(400).send(validation.message);
     const file_path = path.join(request.user.directories.assets, category, request.body.filename);
     console.debuginfo('Request received to delete', category, file_path);
     try {
         // Delete if previous download failed

@@ -288,17 +288,17 @@ router.post('/delete', jsonParser, async (request, response) => {
288	288	fs.unlink(file_path, (err) => {
289	289	if (err) throw err;
290	290	});
291	291	console.debuginfo('Asset deleted.');
292	292	}
293	293	else {
294	294	console.debugerror('Asset not found.');
295	295	response.sendStatus(400);
296	296	}
297	297	// Move into asset place
298	298	response.sendStatus(200);
299	299	}
300	300	catch (error) {
301	301	console.logerror(error);
302	302	response.sendStatus(500);
303	303	}
304	304	});

  */
 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
     const name = sanitize(request.query.name.toString());
     const inputCategory = request.query.category;

             category = i;
     if (category === null) {
         console.debugerror('Bad request: unsupported asset category.');
         return response.sendStatus(400);
+    }

@@ -364,7 +365,7 @@ router.post('/character', jsonParser, async (request, response) => {
364	365	return response.send(output);
365	366	}
366	367	catch (err) {
367	368	console.logerror(err);
368	369	return response.sendStatus(500);
369	370	}
370	371	});

src/endpoints/azure.js+6 -6 Viewed

         const key = readSecret(req.user.directories, SECRET_KEYS.AZURE_TTS);
         if (!key) {
             console.errorwarn('Azure TTS API Key not set');
             return res.sendStatus(403);
+        }
         const region = req.body.region;
         if (!region) {
             console.errorwarn('Azure TTS region not set');
             return res.sendStatus(400);
+        }

         });
         if (!response.ok) {
             console.errorwarn('Azure Request failed', response.status, response.statusText);
             return res.sendStatus(500);
+        }

         const key = readSecret(req.user.directories, SECRET_KEYS.AZURE_TTS);
         if (!key) {
             console.errorwarn('Azure TTS API Key not set');
             return res.sendStatus(403);
+        }
         const { text, voice, region } = req.body;
         if (!text || !voice || !region) {
             console.errorwarn('Missing required parameters');
             return res.sendStatus(400);
+        }

         });
         if (!response.ok) {
             console.errorwarn('Azure Request failed', response.status, response.statusText);
             return res.sendStatus(500);
+        }

src/endpoints/backends/chat-completions.js+48 -47 Viewed

@@ -114,7 +114,7 @@ async function sendClaudeRequest(request, response) {
114	114	}
115	115
116	116	if (!apiKey) {
117	117	console.logwarn(color.red(`Claude API key is missing.\n${divider}`));
118	118	return response.status(400).send({ error: true });
119	119	}
120	120

     const apiKey = readSecret(request.user.directories, SECRET_KEYS.SCALE);
     if (!apiKey) {
         console.logwarn('Scale API key is missing.');
         return response.status(400).send({ error: true });
+    }
     const requestPrompt = convertTextCompletionPrompt(request.body.messages);
     console.logdebug('Scale request:', requestPrompt);
     try {
         const controller = new AbortController();

         });
         if (!generateResponse.ok) {
             console.logwarn(`Scale API returned error: ${generateResponse.status} ${generateResponse.statusText} ${await generateResponse.text()}`);
             return response.status(500).send({ error: true });
+        }
         /** @type {any} */
         const generateResponseJson = await generateResponse.json();
         console.logdebug('Scale response:', generateResponseJson);
         const reply = { choices: [{ 'message': { 'content': generateResponseJson.output } }] };
         return response.send(reply);
     } catch (error) {
         console.logerror(error);
         if (!response.headersSent) {
             return response.status(500).send({ error: true });
+        }

     const apiKey = request.body.reverse_proxy ? request.body.proxy_password : readSecret(request.user.directories, SECRET_KEYS.MAKERSUITE);
     if (!request.body.reverse_proxy && !apiKey) {
         console.logwarn('Google AI Studio API key is missing.');
         return response.status(400).send({ error: true });
+    }

+    }
     const body = getGeminiBody();
     console.logdebug('Google AI Studio request:', body);
     try {
         const controller = new AbortController();

@@ -366,14 +366,14 @@ async function sendMakerSuiteRequest(request, response) {
366	366	// Pipe remote SSE stream to Express response
367	367	forwardFetchResponse(generateResponse, response);
368	368	} catch (error) {
369	369	console.logerror('Error forwarding streaming response:', error);
370	370	if (!response.headersSent) {
371	371	return response.status(500).send({ error: true });
372	372	}
373	373	}
374	374	} else {
375	375	if (!generateResponse.ok) {
376	376	console.logwarn(`Google AI Studio API returned error: ${generateResponse.status} ${generateResponse.statusText} ${await generateResponse.text()}`);
377	377	return response.status(generateResponse.status).send({ error: true });
378	378	}
379	379

@@ -391,12 +391,12 @@ async function sendMakerSuiteRequest(request, response) {
391	391	}
392	392
393	393	const responseContent = candidates[0].content ?? candidates[0].output;
394	394	console.logwarn('Google AI Studio response:', responseContent);
395	395
396	396	const responseText = typeof responseContent === 'string' ? responseContent : responseContent?.parts?.filter(part => !part.thought)?.map(part => part.text)?.join('\n\n');
397	397	if (!responseText) {
398	398	let message = 'Google AI Studio Candidate text empty';
399	399	console.logwarn(message, generateResponseJson);
400	400	return response.send({ error: { message } });
401	401	}
402	402

@@ -405,7 +405,7 @@ async function sendMakerSuiteRequest(request, response) {
405	405	return response.send(reply);
406	406	}
407	407	} catch (error) {
408	408	console.logerror('Error communicating with Google AI Studio API: ', error);
409	409	if (!response.headersSent) {
410	410	return response.status(500).send({ error: true });
411	411	}

  */
 async function sendAI21Request(request, response) {
     if (!request.body) return response.sendStatus(400);
++
     const controller = new AbortController();
     console.logdebug(request.body.messages);
     request.socket.removeAllListeners('close');
     request.socket.on('close', function () {
         controller.abort();

         signal: controller.signal,
     };
     console.logdebug('AI21 request:', body);
     try {
         const generateResponse = await fetch(API_AI21 + '/chat/completions', options);

         } else {
             if (!generateResponse.ok) {
                 const errorText = await generateResponse.text();
                 console.logwarn(`AI21 API returned error: ${generateResponse.status} ${generateResponse.statusText} ${errorText}`);
                 const errorJson = tryParse(errorText) ?? { error: true };
                 return response.status(500).send(errorJson);
+            }
             const generateResponseJson = await generateResponse.json();
             console.logdebug('AI21 response:', generateResponseJson);
             return response.send(generateResponseJson);
+        }
     } catch (error) {
         console.logerror('Error communicating with AI21 API: ', error);
         if (!response.headersSent) {
             response.send({ error: true });
         } else {

     const apiKey = request.body.reverse_proxy ? request.body.proxy_password : readSecret(request.user.directories, SECRET_KEYS.MISTRALAI);
     if (!apiKey) {
         console.logwarn('MistralAI API key is missing.');
         return response.status(400).send({ error: true });
+    }

             timeout: 0,
         };
         console.logdebug('MisralAI request:', requestBody);
         const generateResponse = await fetch(apiUrl + '/chat/completions', config);
         if (request.body.stream) {

         } else {
             if (!generateResponse.ok) {
                 const errorText = await generateResponse.text();
                 console.logwarn(`MistralAI API returned error: ${generateResponse.status} ${generateResponse.statusText} ${errorText}`);
                 const errorJson = tryParse(errorText) ?? { error: true };
                 return response.status(500).send(errorJson);
+            }
             const generateResponseJson = await generateResponse.json();
             console.logdebug('MistralAI response:', generateResponseJson);
             return response.send(generateResponseJson);
+        }
     } catch (error) {
         console.logerror('Error communicating with MistralAI API: ', error);
         if (!response.headersSent) {
             response.send({ error: true });
         } else {

     });
     if (!apiKey) {
         console.logwarn('Cohere API key is missing.');
         return response.status(400).send({ error: true });
+    }

             requestBody.safety_mode = 'OFF';
+        }
         console.logdebug('Cohere request:', requestBody);
         const config = {
             method: 'POST',

             const generateResponse = await fetch(apiUrl, config);
             if (!generateResponse.ok) {
                 const errorText = await generateResponse.text();
                 console.logwarn(`Cohere API returned error: ${generateResponse.status} ${generateResponse.statusText} ${errorText}`);
                 const errorJson = tryParse(errorText) ?? { error: true };
                 return response.status(500).send(errorJson);
+            }
             const generateResponseJson = await generateResponse.json();
             console.logdebug('Cohere response:', generateResponseJson);
             return response.send(generateResponseJson);
+        }
     } catch (error) {
         console.logerror('Error communicating with Cohere API: ', error);
         if (!response.headersSent) {
             response.send({ error: true });
         } else {

     const apiKey = request.body.reverse_proxy ? request.body.proxy_password : readSecret(request.user.directories, SECRET_KEYS.DEEPSEEK);
     if (!apiKey && !request.body.reverse_proxy) {
         console.logwarn('DeepSeek API key is missing.');
         return response.status(400).send({ error: true });
+    }

         api_key_openai = request.body.reverse_proxy ? request.body.proxy_password : readSecret(request.user.directories, SECRET_KEYS.DEEPSEEK);
         headers = {};
     } else {
         console.logwarn('This chat completion source is not supported yet.');
         return response_getstatus_openai.status(400).send({ error: true });
+    }
     if (!api_key_openai && !request.body.reverse_proxy && request.body.chat_completion_source !== CHAT_COMPLETION_SOURCES.CUSTOM) {
         console.logwarn('Chat Completion API key is missing.');
         return response_getstatus_openai.status(400).send({ error: true });
+    }

                     };
                 });
                 console.loginfo('Available OpenRouter models:', models);
             } else if (request.body.chat_completion_source === CHAT_COMPLETION_SOURCES.MISTRALAI) {
                 const models = data?.data;
                 console.loginfo(models);
             } else {
                 const models = data?.data;
                 if (Array.isArray(models)) {
                     const modelIds = models.filter(x => x && typeof x === 'object').map(x => x.id).sort();
                     console.loginfo('Available models:', modelIds);
                 } else {
                     console.logwarn('Chat Completion endpoint did not return a list of models.');
+                }
+            }
+        }
         else {
             console.logerror('Chat Completion status check failed. Either Access Token is incorrect or API endpoint is down.');
             response_getstatus_openai.send({ error: true, can_bypass: true, data: { data: [] } });
+        }
     } catch (e) {

             const tokenizer = getSentencepiceTokenizer(model);
             const instance = await tokenizer?.get();
             if (!instance) {
                 console.warnerror('Tokenizer not initialized:', model);
                 return response.send({});
+            }
             encodeFunction = (text) => new Uint32Array(instance.encodeIds(text));

         mergeObjectWithYaml(headers, request.body.custom_include_headers);
         if (request.body.custom_prompt_post_processing) {
             console.loginfo('Applying custom prompt post-processing of type', request.body.custom_prompt_post_processing);
             request.body.messages = postProcessPrompt(
                 request.body.messages,
                 request.body.custom_prompt_post_processing,

         headers = {};
         bodyParams = {};
     } else {
         console.logwarn('This chat completion source is not supported yet.');
         return response.status(400).send({ error: true });
+    }
     if (!apiKey && !request.body.reverse_proxy && request.body.chat_completion_source !== CHAT_COMPLETION_SOURCES.CUSTOM) {
         console.logwarn('OpenAI API key is missing.');
         return response.status(400).send({ error: true });
+    }

         signal: controller.signal,
     };
     console.logdebug(requestBody);
     makeRequest(config, response, request);

             const fetchResponse = await fetch(endpointUrl, config);
             if (request.body.stream) {
                 console.loginfo('Streaming request in progress');
                 forwardFetchResponse(fetchResponse, response);
                 return;
+            }

                 /** @type {any} */
                 let json = await fetchResponse.json();
                 response.send(json);
                 console.logdebug(json);
                 console.logdebug(json?.choices?.[0]?.message);
             } else if (fetchResponse.status === 429 && retries > 0) {
                 console.logwarn(`Out of quota, retrying in ${Math.round(timeout / 1000)}s`);
                 setTimeout(() => {
                     timeout *= 2;
                     makeRequest(config, response, request, retries - 1, timeout);

                 await handleErrorResponse(fetchResponse);
+            }
         } catch (error) {
             console.logerror('Generation failed', error);
             const message = error.code === 'ECONNREFUSED'
                 ? `Connection refused: ${error.message}`
                 : error.message || 'Unknown error occurred';

         const message = errorResponse.statusText || 'Unknown error occurred';
         const quota_error = errorResponse.status === 429 && errorData?.error?.type === 'insufficient_quota';
         console.logerror('Chat completion request error: ', message, responseText);
         if (!response.headersSent) {
             response.send({ error: { message }, quota_error: quota_error });

src/endpoints/backends/kobold.js+14 -14 Viewed

     request.socket.on('close', async function () {
         if (request.body.can_abort && !response_generate.writableEnded) {
             try {
                 console.loginfo('Aborting Kobold generation...');
                 // send abort signal to koboldcpp
                 const abortResponse = await fetch(`${request.body.api_server}/extra/abort`, {
                     method: 'POST',
                 });
                 if (!abortResponse.ok) {
                     console.logerror('Error sending abort request to Kobold:', abortResponse.status);
+                }
             } catch (error) {
                 console.logerror(error);
+            }
+        }
         controller.abort();

@@ -81,7 +81,7 @@ router.post('/generate', jsonParser, async function (request, response_generate)
81	81	}
82	82	}
83	83
84	84	console.logdebug(this_settings);
85	85	const args = {
86	86	body: JSON.stringify(this_settings),
87	87	headers: Object.assign(

             } else {
                 if (!response.ok) {
                     const errorText = await response.text();
                     console.logwarn(`Kobold returned error: ${response.status} ${response.statusText} ${errorText}`);
                     try {
                         const errorJson = JSON.parse(errorText);

@@ -117,7 +117,7 @@ router.post('/generate', jsonParser, async function (request, response_generate)
117	117	}
118	118
119	119	const data = await response.json();
120	120	console.logdebug('Endpoint response:', data);
121	121	return response_generate.send(data);
122	122	}
123	123	} catch (error) {

@@ -125,19 +125,19 @@ router.post('/generate', jsonParser, async function (request, response_generate)
125	125	switch (error?.status) {
126	126	case 403:
127	127	case 503: // retry in case of temporary service issue, possibly caused by a queue failure?
128	128	console.debugwarn(`KoboldAI is busy. Retry attempt ${i + 1} of ${MAX_RETRIES}...`);
129	129	await delay(delayAmount);
130	130	break;
131	131	default:
132	132	if ('status' in error) {
133	133	console.logerror('Status Code from Kobold:', error.status);
134	134	}
135	135	return response_generate.send({ error: true });
136	136	}
137	137	}
138	138	}
139	139
140	140	console.logerror('Max retries exceeded. Giving up.');
141	141	return response_generate.send({ error: true });
142	142	});
143	143

         const server = request.body.server;
         if (!server) {
             console.logerror('Server is not set');
             return response.sendStatus(400);
+        }
         if (!request.file) {
             console.logerror('No audio file found');
             return response.sendStatus(400);
+        }
         console.logdebug('Transcribing audio with KoboldCpp', server);
         const fileBase64 = fs.readFileSync(request.file.path).toString('base64');
         fs.rmSync(request.file.path);

         if (!result.ok) {
             const text = await result.text();
             console.logerror('KoboldCpp request failed', result.statusText, text);
             return response.status(500).send(text);
+        }
         const data = await result.json();
         console.logdebug('KoboldCpp transcription response', data);
         return response.json(data);
     } catch (error) {
         console.error('KoboldCpp transcription failed', error);

src/endpoints/backends/scale-alt.js+5 -5 Viewed

         const cookie = readSecret(request.user.directories, SECRET_KEYS.SCALE_COOKIE);
         if (!cookie) {
             console.logerror('No Scale cookie found');
             return response.sendStatus(400);
+        }

             },
         };
         console.logdebug('Scale request:', body);
         const result = await fetch('https://dashboard.scale.com/spellbook/api/trpc/v2.variant.run', {
             method: 'POST',

         if (!result.ok) {
             const text = await result.text();
             console.logerror('Scale request failed', result.statusText, text);
             return response.status(500).send({ error: { message: result.statusText } });
+        }

         const data = await result.json();
         const output = data?.result?.data?.json?.outputs?.[0] || '';
         console.logdebug('Scale response:', data);
         if (!output) {
             console.warn('Scale response is empty');

         return response.json({ output });
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

src/endpoints/backends/text-completions.js+39 -45 Viewed

         });
         jsonStream.body.on('end', () => {
             console.loginfo('Streaming request finished');
             response.write('data: [DONE]\n\n');
             response.end();
         });
     } catch (error) {
         console.logerror('Error forwarding streaming response:', error);
         if (!response.headersSent) {
             return response.status(500).send({ error: true });
         } else {

@@ -79,16 +79,16 @@ async function parseOllamaStream(jsonStream, request, response) {
79	79	*/
80	80	async function abortKoboldCppRequest(url) {
81	81	try {
82	82	console.loginfo('Aborting Kobold generation...');
83	83	const abortResponse = await fetch(`${url}/api/extra/abort`, {
84	84	method: 'POST',
85	85	});
86	86
87	87	if (!abortResponse.ok) {
88	88	console.logerror('Error sending abort request to Kobold:', abortResponse.status, abortResponse.statusText);
89	89	}
90	90	} catch (error) {
91	91	console.logerror(error);
92	92	}
93	93	}
94	94

             request.body.api_server = request.body.api_server.replace('localhost', '127.0.0.1');
+        }
         console.logdebug('Trying to connect to API:', request.body);
         const baseUrl = trimV1(request.body.api_server);
         const args = {

             case TEXTGEN_TYPES.LLAMACPP:
             case TEXTGEN_TYPES.INFERMATICAI:
             case TEXTGEN_TYPES.OPENROUTER:
 +            case TEXTGEN_TYPES.FEATHERLESS:
                 url += '/v1/models';
                 break;
             case TEXTGEN_TYPES.DREAMGEN:

             case TEXTGEN_TYPES.OLLAMA:
                 url += '/api/tags';
                 break;
 -            case TEXTGEN_TYPES.FEATHERLESS:
 -                url += '/v1/models';
 -                break;
             case TEXTGEN_TYPES.HUGGINGFACE:
                 url += '/info';
                 break;

         const isPossiblyLmStudio = modelsReply.headers.get('x-powered-by') === 'Express';
         if (!modelsReply.ok) {
             console.logerror('Models endpoint is offline.');
             return response.sendStatus(400);
+        }

@@ -173,12 +171,12 @@ router.post('/status', jsonParser, async function (request, response) {
173	171	}
174	172
175	173	if (!Array.isArray(data.data)) {
176	174	console.logerror('Models response is not an array.');
177	175	return response.sendStatus(400);
178	176	}
179	177
180	178	const modelIds = data.data.map(x => x.id);
181	179	console.loginfo('Models available:', modelIds);
182	180
183	181	// Set result to the first model ID
184	182	result = modelIds[0] \|\| 'Valid';

                 if (modelInfoReply.ok) {
                     /** @type {any} */
                     const modelInfo = await modelInfoReply.json();
                     console.logdebug('Ooba model info:', modelInfo);
                     const modelName = modelInfo?.model_name;
                     result = modelName || result;

                 if (modelInfoReply.ok) {
                     /** @type {any} */
                     const modelInfo = await modelInfoReply.json();
                     console.logdebug('Tabby model info:', modelInfo);
                     const modelName = modelInfo?.id;
                     result = modelName || result;

             props['chat_template'] = props['chat_template'].slice(0, -1) + '\n';
+        }
         props['chat_template_hash'] = createHash('sha256').update(props['chat_template']).digest('hex');
         console.logdebug(`Model properties: ${JSON.stringify(props)}`);
         return response.send(props);
     } catch (error) {
         console.error(error);

         const apiType = request.body.api_type;
         const baseUrl = request.body.api_server;
         console.logdebug(request.body);
         const controller = new AbortController();
         request.socket.removeAllListeners('close');

             if (completionsReply.ok) {
                 /** @type {any} */
                 const data = await completionsReply.json();
                 console.logdebug('Endpoint response:', data);
                 // Map InfermaticAI response to OAI completions format
                 if (apiType === TEXTGEN_TYPES.INFERMATICAI) {

                 const text = await completionsReply.text();
                 const errorBody = { error: true, status: completionsReply.status, response: text };
                 ifreturn (!response.headersSent) {
                     return? response.send(errorBody);
 -                }
 +                    : response.end();
+-
 -                return response.end();
+            }
+        }
     } catch (error) {
         const status = error?.status ?? error?.code ?? 'UNKNOWN';
         const text = error?.error ?? error?.statusText ?? error?.message ?? 'Unknown error on /generate endpoint';
         let value = { error: true, status: status, response: text };
         console.logerror('Endpoint error:', error);
+-
 -        if (!response.headersSent) {
 -            return response.send(value);
 -        }
         return !response.end();headersSent
 +            ? response.send(value)
 +            : response.end();
+    }
 });

         });
         if (!fetchResponse.ok) {
             console.logerror('Download error:', fetchResponse.status, fetchResponse.statusText);
             return response.status(fetchResponse.status).send({ error: true });
+        }

             return response.sendStatus(400);
+        }
         console.logdebug('Ollama caption request:', request.body);
         const baseUrl = trimV1(request.body.server_url);
         const fetchResponse = await fetch(`${baseUrl}/api/generate`, {

         });
         if (!fetchResponse.ok) {
             console.logerror('Ollama caption error:', fetchResponse.status, fetchResponse.statusText);
             return response.status(500).send({ error: true });
+        }
         /** @type {any} */
         const data = await fetchResponse.json();
         console.logdebug('Ollama caption response:', data);
         const caption = data?.response || '';
         if (!caption) {
             console.logerror('Ollama caption is empty.');
             return response.status(500).send({ error: true });
+        }

             return response.sendStatus(400);
+        }
         console.logdebug('LlamaCpp caption request:', request.body);
         const baseUrl = trimV1(request.body.server_url);
         const fetchResponse = await fetch(`${baseUrl}/completion`, {

         });
         if (!fetchResponse.ok) {
             console.logerror('LlamaCpp caption error:', fetchResponse.status, fetchResponse.statusText);
             return response.status(500).send({ error: true });
+        }
         /** @type {any} */
         const data = await fetchResponse.json();
         console.logdebug('LlamaCpp caption response:', data);
         const caption = data?.content || '';
         if (!caption) {
             console.logerror('LlamaCpp caption is empty.');
             return response.status(500).send({ error: true });
+        }

             return response.sendStatus(400);
+        }
         console.logdebug('LlamaCpp props request:', request.body);
         const baseUrl = trimV1(request.body.server_url);
         const fetchResponse = await fetch(`${baseUrl}/props`, {

         });
         if (!fetchResponse.ok) {
             console.logerror('LlamaCpp props error:', fetchResponse.status, fetchResponse.statusText);
             return response.status(500).send({ error: true });
+        }
         const data = await fetchResponse.json();
         console.logdebug('LlamaCpp props response:', data);
         return response.send(data);

             return response.sendStatus(400);
+        }
         console.logdebug('LlamaCpp slots request:', request.body);
         const baseUrl = trimV1(request.body.server_url);
         let fetchResponse;

@@ -616,12 +610,12 @@ llamacpp.post('/slots', jsonParser, async function (request, response) {
616	610	}
617	611
618	612	if (!fetchResponse.ok) {
619	613	console.logerror('LlamaCpp slots error:', fetchResponse.status, fetchResponse.statusText);
620	614	return response.status(500).send({ error: true });
621	615	}
622	616
623	617	const data = await fetchResponse.json();
624	618	console.logdebug('LlamaCpp slots response:', data);
625	619
626	620	return response.send(data);
627	621

@@ -659,14 +653,14 @@ tabby.post('/download', jsonParser, async function (request, response) {
659	653	return response.status(403).send({ error: true });
660	654	}
661	655	} else {
662	656	console.logerror('API Permission error:', permissionResponse.status, permissionResponse.statusText);
663	657	return response.status(permissionResponse.status).send({ error: true });
664	658	}
665	659
666	660	const fetchResponse = await fetch(`${baseUrl}/v1/download`, args);
667	661
668	662	if (!fetchResponse.ok) {
669	663	console.logerror('Download error:', fetchResponse.status, fetchResponse.statusText);
670	664	return response.status(fetchResponse.status).send({ error: true });
671	665	}
672	666

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

     const fileName = path.join(request.user.directories.backgrounds, sanitize(request.body.bg));
     if (!fs.existsSync(fileName)) {
         console.logerror('BG file not found');
         return response.sendStatus(400);
+    }

@@ -43,12 +43,12 @@ router.post('/rename', jsonParser, function (request, response) {
43	43	const newFileName = path.join(request.user.directories.backgrounds, sanitize(request.body.new_bg));
44	44
45	45	if (!fs.existsSync(oldFileName)) {
46	46	console.logerror('BG file not found');
47	47	return response.sendStatus(400);
48	48	}
49	49
50	50	if (fs.existsSync(newFileName)) {
51	51	console.logerror('New BG file already exists');
52	52	return response.sendStatus(400);
53	53	}
54	54

src/endpoints/caption.js+4 -4 Viewed

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

         const rawImage = await getRawImage(image);
         if (!rawImage) {
             console.logwarn('Failed to parse captioned image');
             return res.sendStatus(400);
+        }
         const pipe = await getPipeline(TASK);
         const result = await pipe(rawImage);
         const text = result[0].generated_text;
         console.loginfo('Image caption:', text);
         return res.json({ caption: text });
     } catch (error) {

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

@@ -97,7 +97,7 @@ async function writeCharacterData(inputFile, data, outputFile, request, crop = u
97	97	writeFileAtomicSync(outputImagePath, outputImage);
98	98	return true;
99	99	} catch (err) {
100	100	console.logerror(err);
101	101	return false;
102	102	}
103	103	}

@@ -166,7 +166,7 @@ async function tryReadImage(imgPath, crop) {
166	166	}
167	167	// If it's an unsupported type of image (APNG) - just read the file as buffer
168	168	catch (error) {
169	169	console.logerror(`Failed to read image: ${imgPath}`, error);
170	170	return fs.readFileSync(imgPath);
171	171	}
172	172	}

         return character;
+    }
     catch (err) {
         console.logerror(`Could not process character: ${item}`);
         if (err instanceof SyntaxError) {
             console.logerror(`${item} does not contain a valid JSON object.`);
         } else {
             console.logerror('An unexpected error occurred: ', err);
+        }
         return {

     };
     _.forEach(fieldMappings, (v2Path, charField) => {
         //console.loginfo(`Migrating field: ${charField} from ${v2Path}`);
         const v2Value = _.get(char.data, v2Path);
         if (_.isUndefined(v2Value)) {
             let defaultValue = undefined;

@@ -337,15 +337,15 @@ function readFromV2(char) {
337	337	}
338	338
339	339	if (!_.isUndefined(defaultValue)) {
340	340	//console.debugwarn(`Spec v2 extension data missing for field: ${charField}, using default value: ${defaultValue}`);
341	341	char[charField] = defaultValue;
342	342	} else {
343	343	console.debugwarn(`Char ${char['name']} has Spec v2 data missing for unknown field: ${charField}`);
344	344	return;
345	345	}
346	346	}
347	347	if (!_.isUndefined(char[charField]) && !_.isUndefined(v2Value) && String(char[charField]) !== String(v2Value)) {
348	348	console.debugwarn(`Char ${char['name']} has Spec v2 data mismatch with Spec v1 for field: ${charField}`, char[charField], v2Value);
349	349	}
350	350	char[charField] = v2Value;
351	351	});

@@ -442,7 +442,7 @@ function charaFormatData(data, directories) {
442	442	}
443	443
444	444	} catch {
445	445	console.debugwarn(`Failed to read world info file: ${data.world}. Character book will not be available.`);
446	446	}
447	447	}
448	448

@@ -452,7 +452,7 @@ function charaFormatData(data, directories) {
452	452	// Deep merge the extensions object
453	453	_.set(char, 'data.extensions', deepMerge(char.data.extensions, extensions));
454	454	} catch {
455	455	console.debugwarn(`Failed to parse extensions JSON: ${data.extensions}`);
456	456	}
457	457	}
458	458

     const fileText = fs.readFileSync(uploadPath, 'utf8');
     fs.rmSync(uploadPath);
     const yamlData = yaml.parse(fileText);
     console.loginfo('Importing from YAML');
     yamlData.name = sanitize(yamlData.name);
     const fileName = preservedFileName || getPngName(yamlData.name, context.request.user.directories);
     let char = convertToV2({

 async function importFromCharX(uploadPath, { request }, preservedFileName) {
     const data = fs.readFileSync(uploadPath).buffer;
     fs.rmSync(uploadPath);
     console.loginfo('Importing from CharX');
     const cardBuffer = await extractFileFromZipBuffer(data, 'card.json');
     if (!cardBuffer) {

     let jsonData = JSON.parse(data);
     if (jsonData.spec !== undefined) {
         console.loginfo(`Importing from ${jsonData.spec} json`);
         importRisuSprites(request.user.directories, jsonData);
         unsetFavFlag(jsonData);
         jsonData = readFromV2(jsonData);

         const result = await writeCharacterData(defaultAvatarPath, char, pngName, request);
         return result ? pngName : '';
     } else if (jsonData.name !== undefined) {
         console.loginfo('Importing from v1 json');
         jsonData.name = sanitize(jsonData.name);
         if (jsonData.creator_notes) {
             jsonData.creator_notes = jsonData.creator_notes.replace('Creator\'s notes go here.', '');

         const result = await writeCharacterData(defaultAvatarPath, charJSON, pngName, request);
         return result ? pngName : '';
     } else if (jsonData.char_name !== undefined) {//json Pygmalion notepad
         console.loginfo('Importing from gradio json');
         jsonData.char_name = sanitize(jsonData.char_name);
         if (jsonData.creator_notes) {
             jsonData.creator_notes = jsonData.creator_notes.replace('Creator\'s notes go here.', '');

     const pngName = preservedFileName || getPngName(jsonData.name, request.user.directories);
     if (jsonData.spec !== undefined) {
         console.loginfo(`Found a ${jsonData.spec} character file.`);
         importRisuSprites(request.user.directories, jsonData);
         unsetFavFlag(jsonData);
         jsonData = readFromV2(jsonData);

         fs.unlinkSync(uploadPath);
         return result ? pngName : '';
     } else if (jsonData.name !== undefined) {
         console.loginfo('Found a v1 character file.');
         if (jsonData.creator_notes) {
             jsonData.creator_notes = jsonData.creator_notes.replace('Creator\'s notes go here.', '');

 router.post('/edit', urlencodedParser, validateAvatarUrlMiddleware, async function (request, response) {
     if (!request.body) {
         console.errorwarn('Error: no response body detected');
         response.status(400).send('Error: no response body detected');
         return;
+    }
     if (request.body.ch_name === '' || request.body.ch_name === undefined || request.body.ch_name === '.') {
         console.errorwarn('Error: invalid name.');
         response.status(400).send('Error: invalid name.');
         return;
+    }

  * @returns {void}
  */
 router.post('/edit-attribute', jsonParser, validateAvatarUrlMiddleware, async function (request, response) {
     console.logdebug(request.body);
     if (!request.body) {
         console.errorwarn('Error: no response body detected');
         return response.status(400).send('Error: no response body detected');
+    }
     if (request.body.ch_name === '' || request.body.ch_name === undefined || request.body.ch_name === '.') {
         console.errorwarn('Error: invalid name.');
         return response.status(400).send('Error: invalid name.');
+    }

         const char = JSON.parse(charJSON);
         //check if the field exists
         if (char[request.body.field] === undefined && char.data[request.body.field] === undefined) {
             console.errorwarn('Error: invalid field.');
             response.status(400).send('Error: invalid field.');
             return;
+        }

             await writeCharacterData(avatarPath, JSON.stringify(character), targetImg, request);
             response.sendStatus(200);
         } else {
             console.logwarn(validator.lastValidationError);
             response.status(400).send({ message: `Validation failed for ${character.name}`, error: validator.lastValidationError });
+        }
     } catch (exception) {

                 const fileSizeInKB = `${(stats.size / 1024).toFixed(2)}kb`;
                 if (stats.size === 0) {
                     console.logwarn(`Found an empty chat file: ${pathToFile}`);
                     res({});
                     return;
+                }

@@ -1082,7 +1082,7 @@ router.post('/chats', jsonParser, validateAvatarUrlMiddleware, async function (r
1082	1082
1083	1083	res(chatData);
1084	1084	} else {
1085	1085	console.logwarn('Found an invalid or corrupted chat file:', pathToFile);
1086	1086	res({});
1087	1087	}
1088	1088	}

         return response.send(validFiles);
     } catch (error) {
         console.logerror(error);
         return response.send({ error: true });
+    }
 });

         const fileName = await importFunction(uploadPath, { request, response }, preservedFileName);
         if (!fileName) {
             console.errorwarn('Failed to import character');
             return response.sendStatus(400);
+        }

         response.send({ file_name: fileName });
     } catch (err) {
         console.logerror(err);
         response.send({ error: true });
+    }
 });

 router.post('/duplicate', jsonParser, validateAvatarUrlMiddleware, async function (request, response) {
     try {
         if (!request.body.avatar_url) {
             console.logwarn('avatar URL not found in request body');
             console.logdebug(request.body);
             return response.sendStatus(400);
+        }
         let filename = path.join(request.user.directories.characters, sanitize(request.body.avatar_url));
         if (!fs.existsSync(filename)) {
             console.logerror('file for dupe not found', filename);
 -            console.log(filename);
             return response.sendStatus(404);
+        }
         let suffix = 1;

@@ -1205,7 +1204,7 @@ router.post('/duplicate', jsonParser, validateAvatarUrlMiddleware, async functio
1205	1204	}
1206	1205
1207	1206	fs.copyFileSync(filename, newFilename);
1208	1207	console.loginfo(`${filename} was copied to ${newFilename}`);
1209	1208	response.send({ path: path.parse(newFilename).base });
1210	1209	}
1211	1210	catch (error) {

src/endpoints/chats.js+17 -18 Viewed

@@ -50,7 +50,7 @@ function backupChat(directory, name, chat) {
50	50
51	51	removeOldBackups(directory, 'chat_', maxTotalChatBackups);
52	52	} catch (err) {
53	53	console.logerror(`Could not backup chat for ${name}`, err);
54	54	}
55	55	}
56	56

         getBackupFunction(request.user.profile.handle)(request.user.directories.backups, directoryName, jsonlData);
         return response.send({ result: 'ok' });
     } catch (error) {
         responseconsole.senderror(error);
         return consoleresponse.logsend(error);
+    }
 });

     const pathToOriginalFile = path.join(pathToFolder, sanitize(request.body.original_file));
     const pathToRenamedFile = path.join(pathToFolder, sanitize(request.body.renamed_file));
     const sanitizedFileName = path.parse(pathToRenamedFile).name;
     console.loginfo('Old chat name', pathToOriginalFile);
     console.loginfo('New chat name', pathToRenamedFile);
     if (!fs.existsSync(pathToOriginalFile) || fs.existsSync(pathToRenamedFile)) {
         console.logerror('Either Source or Destination files are not available');
         return response.status(400).send({ error: true });
+    }
     fs.copyFileSync(pathToOriginalFile, pathToRenamedFile);
     fs.rmSync(pathToOriginalFile);
     console.loginfo('Successfully renamed.');
     return response.send({ ok: true, sanitizedFileName });
 });

     const chatFileExists = fs.existsSync(filePath);
     if (!chatFileExists) {
         console.logerror(`Chat file not found '${filePath}'`);
         return response.sendStatus(400);
+    }
     fs.rmSync(filePath);
     console.loginfo('`Deleted chat file: ' + ${filePath}`);
     return response.send('ok');
 });

         const errorMessage = {
             message: `Could not find JSONL file to export. Source chat file: ${filename}.`,
         };
         console.logerror(errorMessage.message);
         return response.status(404).json(errorMessage);
+    }
     try {

                     result: rawFile,
                 };
                 console.loginfo(`Chat exported as ${exportfilename}`);
                 return response.status(200).json(successMessage);
             } catch (err) {
                 console.error(err);
                 const errorMessage = {
                     message: `Could not read JSONL file to export. Source chat file: ${filename}.`,
                 };
                 console.logerror(errorMessage.message);
                 return response.status(500).json(errorMessage);
+            }
+        }

                 message: `Chat saved to ${exportfilename}`,
                 result: buffer,
             };
             console.loginfo(`Chat exported as ${exportfilename}`);
             return response.status(200).json(successMessage);
         });
     } catch (err) {
         console.logerror('chat export failed.', err);
 -        console.log(err);
         return response.sendStatus(400);
+    }
 });

             } else if (jsonData.type === 'risuChat') { // RisuAI format
                 importFunc = importRisuChat;
             } else { // Unknown format
                 console.logerror('Incorrect chat format .json');
                 return response.send({ error: true });
+            }

             const jsonData = JSON.parse(header);
             if (!(jsonData.user_name !== undefined || jsonData.name !== undefined)) {
                 console.logerror('Incorrect chat format .jsonl');
                 return response.send({ error: true });
+            }

@@ -647,7 +646,7 @@ router.post('/search', jsonParser, validateAvatarUrlMiddleware, function (reques
647	646	break;
648	647	}
649	648	} catch (error) {
650	649	console.errorwarn(groupFile, 'group file is corrupted:', error);
651	650	}
652	651	}
653	652

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

@@ -44,9 +44,9 @@ router.post('/', jsonParser, async (req, res) => {
44	44	}
45	45	}
46	46
47	47	console.logdebug('Classify input:', text);
48	48	const result = await getResult(text);
49	49	console.logdebug('Classify output:', result);
50	50
51	51	return res.json({ classification: result });
52	52	} catch (error) {

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

@@ -71,7 +71,7 @@ export function getDefaultPresets(directories) {
71	71
72	72	return presets;
73	73	} catch (err) {
74	74	console.logwarn('Failed to get default presets', err);
75	75	return [];
76	76	}
77	77	}

@@ -92,7 +92,7 @@ export function getDefaultPresetFile(filename) {
92	92	const fileContent = fs.readFileSync(contentPath, 'utf8');
93	93	return JSON.parse(fileContent);
94	94	} catch (err) {
95	95	console.logwarn(`Failed to get default file ${filename}`, err);
96	96	return null;
97	97	}
98	98	}

@@ -121,21 +121,21 @@ async function seedContentForUser(contentIndex, directories, forceCategories) {
121	121	}
122	122
123	123	if (!contentItem.folder) {
124	124	console.logwarn(`Content file ${contentItem.filename} has no parent folder`);
125	125	continue;
126	126	}
127	127
128	128	const contentPath = path.join(contentItem.folder, contentItem.filename);
129	129
130	130	if (!fs.existsSync(contentPath)) {
131	131	console.logwarn(`Content file ${contentItem.filename} is missing`);
132	132	continue;
133	133	}
134	134
135	135	const contentTarget = getTargetByType(contentItem.type, directories);
136	136
137	137	if (!contentTarget) {
138	138	console.logwarn(`Content file ${contentItem.filename} has unknown type ${contentItem.type}`);
139	139	continue;
140	140	}
141	141

@@ -144,12 +144,12 @@ async function seedContentForUser(contentIndex, directories, forceCategories) {
144	144	contentLog.push(contentItem.filename);
145	145
146	146	if (fs.existsSync(targetPath)) {
147	147	console.logwarn(`Content file ${contentItem.filename} already exists in ${contentTarget}`);
148	148	continue;
149	149	}
150	150
151	151	fs.cpSync(contentPath, targetPath, { recursive: true, force: false });
152	152	console.loginfo(`Content file ${contentItem.filename} copied to ${contentTarget}`);
153	153	anyContentAdded = true;
154	154	}
155	155

@@ -182,12 +182,12 @@ export async function checkForNewContent(directoriesList, forceCategories = [])
182	182	}
183	183
184	184	if (anyContentAdded && !contentCheckSkip && forceCategories?.length === 0) {
185	185	console.loginfo();
186	186	console.loginfo(`${color.blue('If you don\'t want to receive content updates in the future, set')} ${color.yellow('skipContentCheck')} ${color.blue('to true in the config.yaml file.')}`);
187	187	console.loginfo();
188	188	}
189	189	} catch (err) {
190	190	console.logerror('Content check failed', err);
191	191	}
192	192	}
193	193

     if (!result.ok) {
         const text = await result.text();
         console.logerror('Chub returned error', result.statusText, text);
         throw new Error('Failed to download lorebook');
+    }

     if (!result.ok) {
         const text = await result.text();
         console.logerror('Chub returned error', result.statusText, text);
         throw new Error('Failed to download character');
+    }

     if (!result.ok) {
         const text = await result.text();
         console.logerror('Pygsite returned error', result.status, text);
         throw new Error('Failed to download character');
+    }

@@ -485,7 +485,7 @@ async function downloadJannyCharacter(uuid) {
485	485	}
486	486	}
487	487
488	488	console.logerror('Janny returned error', result.statusText, await result.text());
489	489	throw new Error('Failed to download character');
490	490	}
491	491

     if (!result.ok) {
         const text = await result.text();
         console.logerror('RisuAI returned error', result.statusText, text);
         throw new Error('Failed to download character');
+    }

             type = chubParsed?.type;
             if (chubParsed?.type === 'character') {
                 console.loginfo('Downloading chub character:', chubParsed.id);
                 result = await downloadChubCharacter(chubParsed.id);
+            }
             else if (chubParsed?.type === 'lorebook') {
                 console.loginfo('Downloading chub lorebook:', chubParsed.id);
                 result = await downloadChubLorebook(chubParsed.id);
+            }
             else {

             type = 'character';
             result = await downloadRisuCharacter(uuid);
         } else if (isGeneric) {
             console.loginfo('Downloading from generic url.');
             type = 'character';
             result = await downloadGenericPng(url);
         } else {

         response.set('X-Custom-Content-Type', type);
         return response.send(result.buffer);
     } catch (error) {
         console.logerror('Importing custom content failed', error);
         return response.sendStatus(500);
+    }
 });

         const uuidType = uuid.includes('lorebook') ? 'lorebook' : 'character';
         if (isPygmalion) {
             console.loginfo('Downloading Pygmalion character:', uuid);
             result = await downloadPygmalionCharacter(uuid);
         } else if (isJannny) {
             console.loginfo('Downloading Janitor character:', uuid.split('_')[0]);
             result = await downloadJannyCharacter(uuid.split('_')[0]);
         } else if (isAICC) {
             const [, author, card] = uuid.split('/');
             console.loginfo('Downloading AICC character:', `${author}/${card}`);
             result = await downloadAICCCharacter(`${author}/${card}`);
         } else {
             if (uuidType === 'character') {
                 console.loginfo('Downloading chub character:', uuid);
                 result = await downloadChubCharacter(uuid);
+            }
             else if (uuidType === 'lorebook') {
                 console.loginfo('Downloading chub lorebook:', uuid);
                 result = await downloadChubLorebook(uuid);
+            }
             else {

         response.set('X-Custom-Content-Type', uuidType);
         return response.send(result.buffer);
     } catch (error) {
         console.logerror('Importing custom content failed', error);
         return response.sendStatus(500);
+    }
 });

src/endpoints/extensions.js+16 -16 Viewed

         const { url, global } = request.body;
         if (global && !request.user.profile.admin) {
             console.warnerror(`User ${request.user.profile.handle} does not have permission to install global extensions.`);
             return response.status(403).send('Forbidden: No permission to install global extensions.');
+        }

+        }
         await git.clone(url, extensionPath, { '--depth': 1 });
         console.loginfo(`Extension has been cloned at ${extensionPath}`);
         const { version, author, display_name } = await getManifest(extensionPath);
         return response.send({ version, author, display_name, extensionPath });
     } catch (error) {
         console.logerror('Importing custom content failed', error);
         return response.status(500).send(`Server Error: ${error.message}`);
+    }
 });

         const { extensionName, global } = request.body;
         if (global && !request.user.profile.admin) {
             console.warnerror(`User ${request.user.profile.handle} does not have permission to update global extensions.`);
             return response.status(403).send('Forbidden: No permission to update global extensions.');
+        }

         const currentBranch = await git.cwd(extensionPath).branch();
         if (!isUpToDate) {
             await git.cwd(extensionPath).pull('origin', currentBranch.current);
             console.loginfo(`Extension has been updated at ${extensionPath}`);
         } else {
             console.loginfo(`Extension is up to date at ${extensionPath}`);
+        }
         await git.cwd(extensionPath).fetch('origin');
         const fullCommitHash = await git.cwd(extensionPath).revparse(['HEAD']);

         return response.send({ shortCommitHash, extensionPath, isUpToDate, remoteUrl });
     } catch (error) {
         console.logerror('Updating custom content failed', error);
         return response.status(500).send(`Server Error: ${error.message}`);
+    }
 });

@@ -164,7 +164,7 @@ router.post('/move', jsonParser, async (request, response) => {
164	164	}
165	165
166	166	if (!request.user.profile.admin) {
167	167	console.warnerror(`User ${request.user.profile.handle} does not have permission to move extensions.`);
168	168	return response.status(403).send('Forbidden: No permission to move extensions.');
169	169	}
170	170

         fs.cpSync(sourcePath, destinationPath, { recursive: true, force: true });
         fs.rmSync(sourcePath, { recursive: true, force: true });
         console.loginfo(`Extension has been moved from ${sourcePath} to ${destinationPath}`);
         return response.sendStatus(204);
     } catch (error) {
         console.logerror('Moving extension failed', error);
         return response.status(500).send('Internal Server Error. Try again later.');
+    }
 });

         // get only the working branch
         const currentBranchName = currentBranch.current;
         await git.cwd(extensionPath).fetch('origin');
         console.logdebug(extensionName, currentBranchName, currentCommitHash);
         const { isUpToDate, remoteUrl } = await checkIfRepoIsUpToDate(extensionPath);
         return response.send({ currentBranchName, currentCommitHash, isUpToDate, remoteUrl });
     } catch (error) {
         console.logerror('Getting extension version failed', error);
         return response.status(500).send(`Server Error: ${error.message}`);
+    }
 });

         const { extensionName, global } = request.body;
         if (global && !request.user.profile.admin) {
             console.warnerror(`User ${request.user.profile.handle} does not have permission to delete global extensions.`);
             return response.status(403).send('Forbidden: No permission to delete global extensions.');
+        }

@@ -277,12 +277,12 @@ router.post('/delete', jsonParser, async (request, response) => {
277	277	}
278	278
279	279	await fs.promises.rm(extensionPath, { recursive: true });
280	280	console.loginfo(`Extension has been deleted at ${extensionPath}`);
281	281
282	282	return response.send(`Extension has been deleted at ${extensionPath}`);
283	283
284	284	} catch (error) {
285	285	console.logerror('Deleting custom content failed', error);
286	286	return response.status(500).send(`Server Error: ${error.message}`);
287	287	}
288	288	});

     // Combine all extensions
     const allExtensions = [...builtInExtensions, ...userExtensions, ...globalExtensions];
     console.loginfo('Extensions available for', request.user.profile.handle, allExtensions);
     return response.send(allExtensions);
 });

src/endpoints/files.js+7 -7 Viewed

         const sanitizedFilename = sanitize(fileName);
         return response.send({ fileName: sanitizedFilename });
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

         const pathToUpload = path.join(request.user.directories.files, request.body.name);
         writeFileSyncAtomic(pathToUpload, request.body.data, 'base64');
         const url = clientRelativePath(request.user.directories.root, pathToUpload);
         console.loginfo(`Uploaded file: ${url} from ${request.user.profile.handle}`);
         return response.send({ path: url });
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

@@ -68,10 +68,10 @@ router.post('/delete', jsonParser, async (request, response) => {
68	68	}
69	69
70	70	fs.rmSync(pathToDelete);
71	71	console.loginfo(`Deleted file: ${request.body.path} from ${request.user.profile.handle}`);
72	72	return response.sendStatus(200);
73	73	} catch (error) {
74	74	console.logerror(error);
75	75	return response.sendStatus(500);
76	76	}
77	77	});

         for (const url of request.body.urls) {
             const pathToVerify = path.join(request.user.directories.root, url);
             if (!pathToVerify.startsWith(request.user.directories.files)) {
                 console.debugwarn(`File verification: Invalid path: ${pathToVerify}`);
                 continue;
+            }
             const fileExists = fs.existsSync(pathToVerify);

         return response.send(verified);
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

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

             generationConfig: { maxOutputTokens: 1000 },
         };
         console.logdebug('Multimodal captioning request', model, body);
         const result = await fetch(url, {
             body: JSON.stringify(body),

         if (!result.ok) {
             const error = await result.json();
             console.logerror(`Google AI Studio API returned error: ${result.status} ${result.statusText}`, error);
             return response.status(result.status).send({ error: true });
+        }
         /** @type {any} */
         const data = await result.json();
         console.loginfo('Multimodal captioning response', data);
         const candidates = data?.candidates;
         if (!candidates) {

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

         if (group && Array.isArray(group.chats)) {
             for (const chat of group.chats) {
                 console.loginfo('Deleting group chat', chat);
                 const pathToFile = path.join(request.user.directories.groupChats, `${id}.jsonl`);
                 if (fs.existsSync(pathToFile)) {

src/endpoints/horde.js+15 -15 Viewed

         });
         const data = await fetchResult.json();
         console.loginfo(`Cancelled Horde task ${taskId}`);
         return response.send(data);
     } catch (error) {
         console.error(error);

         });
         const data = await fetchResult.json();
         console.loginfo(`Horde task ${taskId} status:`, data);
         return response.send(data);
     } catch (error) {
         console.error(error);

     const url = 'https://aihorde.net/api/v2/generate/text/async';
     const agent = await getClientAgent();
     console.logdebug(request.body);
     try {
         const result = await fetch(url, {
             method: 'POST',

         if (!result.ok) {
             const message = await result.text();
             console.logerror('Horde returned an error:', message);
             return response.send({ error: { message } });
+        }
         const data = await result.json();
         return response.send(data);
     } catch (error) {
         console.logerror(error);
         return response.send({ error: true });
+    }
 });

         for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
             await delay(CHECK_INTERVAL);
             const status = await ai_horde.getInterrogationStatus(result.id);
             console.loginfo(status);
             if (status.state === HordeAsyncRequestStates.done) {

                     return response.sendStatus(500);
+                }
                 console.logdebug('Image interrogation result:', status);
                 const caption = status?.forms[0]?.result?.caption || '';
                 if (!caption) {

@@ -275,7 +275,7 @@ router.post('/caption-image', jsonParser, async (request, response) => {
275	275	}
276	276
277	277	if (status.state === HordeAsyncRequestStates.faulted \|\| status.state === HordeAsyncRequestStates.cancelled) {
278	278	console.logerror('Image interrogation request is not successful.');
279	279	return response.sendStatus(503);
280	280	}
281	281	}

     try {
         const maxLength = PROMPT_THRESHOLD - String(request.body.negative_prompt).length - 5;
         if (String(request.body.prompt).length > maxLength) {
             console.logwarn('Stable Horde prompt is too long, truncating...');
             request.body.prompt = String(request.body.prompt).substring(0, maxLength);
+        }

             const sanitized = sanitizeHordeImagePrompt(request.body.prompt);
             if (request.body.prompt !== sanitized) {
                 console.loginfo('Stable Horde prompt was sanitized.');
+            }
             request.body.prompt = sanitized;
+        }
         const api_key_horde = readSecret(request.user.directories, SECRET_KEYS.HORDE) || ANONYMOUS_KEY;
         console.logdebug('Stable Horde request:', request.body);
         const ai_horde = await getHordeClient();
         // noinspection JSCheckFunctionSignatures -- see @ts-ignore - use_gfpgan

             { token: api_key_horde });
         if (!generation.id) {
             console.errorwarn('Image generation request is not satisfyable:', generation.message || 'unknown error');
             return response.sendStatus(400);
+        }
         console.loginfo('Horde image generation request:', generation);
         const controller = new AbortController();
         request.socket.removeAllListeners('close');
         request.socket.on('close', function () {
             console.logwarn('Horde image generation request aborted.');
             controller.abort();
             if (generation.id) ai_horde.deleteImageGenerationRequest(generation.id);
         });

             controller.signal.throwIfAborted();
             await delay(CHECK_INTERVAL);
             const check = await ai_horde.getImageGenerationCheck(generation.id);
             console.loginfo(check);
             if (check.done) {
                 const result = await ai_horde.getImageGenerationStatus(generation.id);

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

         await fs.promises.writeFile(pathToNewFile, new Uint8Array(imageBuffer));
         response.send({ path: clientRelativePath(request.user.directories.root, pathToNewFile) });
     } catch (error) {
         console.logerror(error);
         response.status(500).send({ error: 'Failed to save the image' });
+    }
 });

src/endpoints/novelai.js+16 -16 Viewed

     const api_key_novel = readSecret(req.user.directories, SECRET_KEYS.NOVEL);
     if (!api_key_novel) {
         console.logwarn('NovelAI Access Token is missing.');
         return res.sendStatus(400);
+    }

             const data = await response.json();
             return res.send(data);
         } else if (response.status == 401) {
             console.logerror('NovelAI Access Token is incorrect.');
             return res.send({ error: true });
+        }
         else {
             console.logwarn('NovelAI returned an error:', response.statusText);
             return res.send({ error: true });
+        }
     } catch (error) {
         console.logerror(error);
         return res.send({ error: true });
+    }
 });

     const api_key_novel = readSecret(req.user.directories, SECRET_KEYS.NOVEL);
     if (!api_key_novel) {
         console.logwarn('NovelAI Access Token is missing.');
         return res.sendStatus(400);
+    }

@@ -241,7 +241,7 @@ router.post('/generate', jsonParser, async function (req, res) {
241	241	}
242	242	}
243	243
244	244	console.logdebug(util.inspect(data, { depth: 4 }));
245	245
246	246	const args = {
247	247	body: JSON.stringify(data),

             if (!response.ok) {
                 const text = await response.text();
                 let message = text;
                 console.logwarn(`Novel API returned error: ${response.status} ${response.statusText} ${text}`);
                 try {
                     const data = JSON.parse(text);

             /** @type {any} */
             const data = await response.json();
             console.loginfo('NovelAI Output', data?.output);
             return res.send(data);
+        }
     } catch (error) {

     const key = readSecret(request.user.directories, SECRET_KEYS.NOVEL);
     if (!key) {
         console.logwarn('NovelAI Access Token is missing.');
         return response.sendStatus(400);
+    }
     try {
         console.logdebug('NAI Diffusion request:', request.body);
         const generateUrl = `${IMAGE_NOVELAI}/ai/generate-image`;
         const generateResult = await fetch(generateUrl, {
             method: 'POST',

         if (!generateResult.ok) {
             const text = await generateResult.text();
             console.logwarn('NovelAI returned an error.', generateResult.statusText, text);
             return response.sendStatus(500);
+        }

         const imageBuffer = await extractFileFromZipBuffer(archiveBuffer, '.png');
         if (!imageBuffer) {
             console.warnerror('NovelAI generated an image, but the PNG file was not found.');
             return response.sendStatus(500);
+        }

+        }
         try {
             console.debuginfo('Upscaling image...');
             const upscaleUrl = `${API_NOVELAI}/ai/upscale`;
             const upscaleResult = await fetch(upscaleUrl, {
                 method: 'POST',

@@ -413,7 +413,7 @@ router.post('/generate-image', jsonParser, async (request, response) => {
413	413	return response.send(originalBase64);
414	414	}
415	415	} catch (error) {
416	416	console.logerror(error);
417	417	return response.sendStatus(500);
418	418	}
419	419	});

     const token = readSecret(request.user.directories, SECRET_KEYS.NOVEL);
     if (!token) {
         console.logerror('NovelAI Access Token is missing.');
         return response.sendStatus(400);
+    }

         if (!result.ok) {
             const errorText = await result.text();
             console.logerror('NovelAI returned an error.', result.statusText, errorText);
             return response.sendStatus(500);
+        }

src/endpoints/openai.js+16 -16 Viewed

@@ -63,7 +63,7 @@ router.post('/caption-image', jsonParser, async (request, response) => {
63	63	}
64	64
65	65	if (!key && !request.body.reverse_proxy && ['custom', 'ooba', 'koboldcpp', 'vllm'].includes(request.body.api) === false) {
66	66	console.logwarn('No key found for API', request.body.api);
67	67	return response.sendStatus(400);
68	68	}
69	69

@@ -93,7 +93,7 @@ router.post('/caption-image', jsonParser, async (request, response) => {
93	93	excludeKeysByYaml(body, request.body.custom_exclude_body);
94	94	}
95	95
96	96	console.logdebug('Multimodal captioning request', body);
97	97
98	98	let apiUrl = '';
99	99

         if (!result.ok) {
             const text = await result.text();
             console.logwarn('Multimodal captioning request failed', result.statusText, text);
             return response.status(500).send(text);
+        }
         /** @type {any} */
         const data = await result.json();
         console.loginfo('Multimodal captioning response', data);
         const caption = data?.choices[0]?.message?.content;
         if (!caption) {

         const key = readSecret(request.user.directories, SECRET_KEYS.OPENAI);
         if (!key) {
             console.logwarn('No OpenAI key found');
             return response.sendStatus(400);
+        }
         if (!request.file) {
             console.logwarn('No audio file found');
             return response.sendStatus(400);
+        }
         const formData = new FormData();
         console.loginfo('Processing audio file', request.file.path);
         formData.append('file', fs.createReadStream(request.file.path), { filename: 'audio.wav', contentType: 'audio/wav' });
         formData.append('model', request.body.model);

         if (!result.ok) {
             const text = await result.text();
             console.logwarn('OpenAI request failed', result.statusText, text);
             return response.status(500).send(text);
+        }
         fs.rmSync(request.file.path);
         const data = await result.json();
         console.logdebug('OpenAI transcription response', data);
         return response.json(data);
     } catch (error) {
         console.error('OpenAI transcription failed', error);

         const key = readSecret(request.user.directories, SECRET_KEYS.OPENAI);
         if (!key) {
             console.logwarn('No OpenAI key found');
             return response.sendStatus(400);
+        }

         if (!result.ok) {
             const text = await result.text();
             console.logwarn('OpenAI request failed', result.statusText, text);
             return response.status(500).send(text);
+        }

         const key = readSecret(request.user.directories, SECRET_KEYS.OPENAI);
         if (!key) {
             console.logwarn('No OpenAI key found');
             return response.sendStatus(400);
+        }
         console.logdebug('OpenAI request', request.body);
         const result = await fetch('https://api.openai.com/v1/images/generations', {
             method: 'POST',

         if (!result.ok) {
             const text = await result.text();
             console.logwarn('OpenAI request failed', result.statusText, text);
             return response.status(500).send(text);
+        }

         const { input, provider_endpoint, response_format, voice, speed, model } = request.body;
         if (!provider_endpoint) {
             console.logwarn('No OpenAI-compatible TTS provider endpoint provided');
             return response.sendStatus(400);
+        }

         if (!result.ok) {
             const text = await result.text();
             console.logwarn('OpenAI request failed', result.statusText, text);
             return response.status(500).send(text);
+        }

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

         return response.send(result);
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

src/endpoints/search.js+21 -21 Viewed

         const key = readSecret(request.user.directories, SECRET_KEYS.SERPAPI);
         if (!key) {
             console.logerror('No SerpApi key found');
             return response.sendStatus(400);
+        }
         const { query } = request.body;
         const result = await fetch(`https://serpapi.com/search.json?q=${encodeURIComponent(query)}&api_key=${key}`);
         console.logdebug('SerpApi query', query);
         if (!result.ok) {
             const text = await result.text();
             console.logerror('SerpApi request failed', result.statusText, text);
             return response.status(500).send(text);
+        }
         const data = await result.json();
         return response.json(data);
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

         const json = request.body.json;
         if (!id) {
             console.logerror('Id is required for /transcript');
             return response.sendStatus(400);
+        }

@@ -155,7 +155,7 @@ router.post('/transcript', jsonParser, async (request, response) => {
155	155	throw error;
156	156	}
157	157	} catch (error) {
158	158	console.logerror(error);
159	159	return response.sendStatus(500);
160	160	}
161	161	});

         const { baseUrl, query, preferences, categories } = request.body;
         if (!baseUrl || !query) {
             console.logerror('Missing required parameters for /searxng');
             return response.sendStatus(400);
+        }
         console.logdebug('SearXNG query', baseUrl, query);
         const mainPageUrl = new URL(baseUrl);
         const mainPageRequest = await fetch(mainPageUrl, { headers: visitHeaders });
         if (!mainPageRequest.ok) {
             console.logerror('SearXNG request failed', mainPageRequest.statusText);
             return response.sendStatus(500);
+        }

         if (!searchResult.ok) {
             const text = await searchResult.text();
             console.logerror('SearXNG request failed', searchResult.statusText, text);
             return response.sendStatus(500);
+        }
         const data = await searchResult.text();
         return response.send(data);
     } catch (error) {
         console.logerror('SearXNG request failed', error);
         return response.sendStatus(500);
+    }
 });

         const apiKey = readSecret(request.user.directories, SECRET_KEYS.TAVILY);
         if (!apiKey) {
             console.logerror('No Tavily key found');
             return response.sendStatus(400);
+        }

             body: JSON.stringify(body),
         });
         console.logdebug('Tavily query', query);
         if (!result.ok) {
             const text = await result.text();
             console.logerror('Tavily request failed', result.statusText, text);
             return response.status(500).send(text);
+        }
         const data = await result.json();
         return response.json(data);
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

         const html = Boolean(request.body.html ?? true);
         if (!url) {
             console.logerror('No url provided for /visit');
             return response.sendStatus(400);
+        }

@@ -330,16 +330,16 @@ router.post('/visit', jsonParser, async (request, response) => {
330	330	throw new Error('Invalid hostname');
331	331	}
332	332	} catch (error) {
333	333	console.logerror('Invalid url provided for /visit', url);
334	334	return response.sendStatus(400);
335	335	}
336	336
337	337	console.loginfo('Visiting web URL', url);
338	338
339	339	const result = await fetch(url, { headers: visitHeaders });
340	340
341	341	if (!result.ok) {
342	342	console.logerror(`Visit failed ${result.status} ${result.statusText}`);
343	343	return response.sendStatus(500);
344	344	}
345	345

         if (html) {
             if (!contentType.includes('text/html')) {
                 console.logerror(`Visit failed, content-type is ${contentType}, expected text/html`);
                 return response.sendStatus(500);
+            }

         const buffer = await result.arrayBuffer();
         return response.send(Buffer.from(buffer));
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

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

     const filePath = path.join(directories.root, SECRETS_FILE);
     if (!fs.existsSync(filePath)) {
         console.logerror('Secrets file does not exist');
         return undefined;
+    }

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

             fileNames.push(removeFileExtension ? item.replace(/\.[^/.]+$/, '') : item);
         } catch {
             // skip
             console.logwarn(`${item} is not a valid JSON`);
+        }
     });

@@ -120,7 +120,7 @@ async function backupSettings() {
120	120	backupUserSettings(handle, true);
121	121	}
122	122	} catch (err) {
123	123	console.logerror('Could not backup settings file', err);
124	124	}
125	125	}
126	126

         triggerAutoSave(request.user.profile.handle);
         response.send({ result: 'ok' });
     } catch (err) {
         console.logerror(err);
         response.send(err);
+    }
 });

         response.json(result);
     } catch (error) {
         console.logerror(error);
         response.sendStatus(500);
+    }
 });

         response.send(content);
     } catch (error) {
         console.logerror(error);
         response.sendStatus(500);
+    }
 });

         backupUserSettings(request.user.profile.handle, false);
         response.sendStatus(204);
     } catch (error) {
         console.logerror(error);
         response.sendStatus(500);
+    }
 });

         response.sendStatus(204);
     } catch (error) {
         console.logerror(error);
         response.sendStatus(500);
+    }
 });

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

         const start = performance.now();
         const result = await pipe(wav, { language: lang || null, task: 'transcribe' });
         const end = performance.now();
         console.loginfo(`Execution duration: ${(end - start) / 1000} seconds`);
         console.loginfo('Transcribed audio:', result.text);
         return res.json({ text: result.text });
     } catch (error) {

         const start = performance.now();
         const result = await pipe(text, { speaker_embeddings: speaker_embeddings });
         const end = performance.now();
         console.logdebug(`Execution duration: ${(end - start) / 1000} seconds`);
         const wav = new wavefile.WaveFile();
         wav.fromScratch(1, result.sampling_rate, '32f', result.audio);

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

@@ -82,14 +82,14 @@ export function importRisuSprites(directories, data) {
82	82	return;
83	83	}
84	84
85	85	console.loginfo(`RisuAI: Found ${images.length} sprites for ${name}. Writing to disk.`);
86	86	const files = fs.readdirSync(spritesPath);
87	87
88	88	outer: for (const [label, fileBase64] of images) {
89	89	// Remove existing sprite with the same label
90	90	for (const file of files) {
91	91	if (path.parse(file).name === label) {
92	92	console.logwarn(`RisuAI: The sprite ${label} for ${name} already exists. Skipping.`);
93	93	continue outer;
94	94	}
95	95	}

@@ -133,7 +133,7 @@ router.get('/get', jsonParser, function (request, response) {
133	133	}
134	134	}
135	135	catch (err) {
136	136	console.logerror(err);
137	137	}
138	138	return response.send(sprites);
139	139	});

src/endpoints/stable-diffusion.js+74 -74 Viewed

         return response.sendStatus(200);
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

         return response.send(upscalers);
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

         const names = data.map(x => x.model_name);
         return response.send(names);
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

         return response.send(names);
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

         const names = data.map(x => x.name);
         return response.send(names);
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

         const models = data.map(x => ({ value: x.title, text: x.title }));
         return response.send(models);
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

         const data = await result.json();
         return response.send(data['sd_model_checkpoint']);
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

@@ -283,13 +283,13 @@ router.post('/set-model', jsonParser, async (request, response) => {
283	283	break;
284	284	}
285	285
286	286	console.loginfo(`Waiting for SD WebUI to finish model loading... Progress: ${progress}; Job count: ${jobCount}`);
287	287	await delay(CHECK_INTERVAL);
288	288	}
289	289
290	290	return response.sendStatus(200);
291	291	} catch (error) {
292	292	console.logerror(error);
293	293	return response.sendStatus(500);
294	294	}
295	295	});

@@ -309,7 +309,7 @@ router.post('/generate', jsonParser, async (request, response) => {
309	309	}
310	310	}
311	311	} catch (error) {
312	312	console.logerror('SD WebUI failed to get options:', error);
313	313	}
314	314
315	315	const controller = new AbortController();

             controller.abort();
         });
         console.logdebug('SD WebUI request:', request.body);
         const txt2imgUrl = new URL(request.body.url);
         txt2imgUrl.pathname = '/sdapi/v1/txt2img';
         const result = await fetch(txt2imgUrl, {

         const data = await result.json();
         return response.send(data);
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

         return response.send(names);
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

         return response.sendStatus(200);
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

         const data = await result.json();
         return response.send(data.KSampler.input.required.sampler_name[0]);
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

         return response.send(models);
     } catch (error)     {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

         const data = await result.json();
         return response.send(data.KSampler.input.required.scheduler[0]);
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

         const data = await result.json();
         return response.send(data.VAELoader.input.required.vae_name[0]);
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

         const data = getComfyWorkflows(request.user.directories);
         return response.send(data);
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

         const data = fs.readFileSync(filePath, { encoding: 'utf-8' });
         return response.send(JSON.stringify(data));
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

         const data = getComfyWorkflows(request.user.directories);
         return response.send(data);
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

@@ -526,7 +526,7 @@ comfy.post('/delete-workflow', jsonParser, async (request, response) => {
526	526	}
527	527	return response.sendStatus(200);
528	528	} catch (error) {
529	529	console.logerror(error);
530	530	return response.sendStatus(500);
531	531	}
532	532	});

         const imgBuffer = await imgResponse.arrayBuffer();
         return response.send(Buffer.from(imgBuffer).toString('base64'));
     } catch (error) {
         console.logerror('ComfyUI error:', error);
         response.status(500).send(error.message);
         return response;
+    }

         const key = readSecret(request.user.directories, SECRET_KEYS.TOGETHERAI);
         if (!key) {
             console.logwarn('TogetherAI key not found.');
             return response.sendStatus(400);
+        }

         });
         if (!modelsResponse.ok) {
             console.logwarn('TogetherAI returned an error.');
             return response.sendStatus(500);
+        }
         const data = await modelsResponse.json();
         if (!Array.isArray(data)) {
             console.logwarn('TogetherAI returned invalid data.');
             return response.sendStatus(500);
+        }

         return response.send(models);
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

         const key = readSecret(request.user.directories, SECRET_KEYS.TOGETHERAI);
         if (!key) {
             console.logwarn('TogetherAI key not found.');
             return response.sendStatus(400);
+        }
         console.logdebug('TogetherAI request:', request.body);
         const result = await fetch('https://api.together.xyz/v1/images/generations', {
             method: 'POST',

         });
         if (!result.ok) {
             console.logwarn('TogetherAI returned an error.', { body: await result.text() });
             return response.sendStatus(500);
+        }
         /** @type {any} */
         const data = await result.json();
         console.logdebug('TogetherAI response:', data);
         const choice = data?.data?.[0];
         let b64_json = choice.b64_json;

         return response.send({ format: 'jpg', data: b64_json });
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

         return response.sendStatus(200);
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

         return response.send(data['model']);
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

         return response.send(data['upscaler']);
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });
 drawthings.post('/generate', jsonParser, async (request, response) => {
     try {
         console.logdebug('SD DrawThings API request:', request.body);
         const url = new URL(request.body.url);
         url.pathname = '/sdapi/v1/txt2img';

         const data = await result.json();
         return response.send(data);
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

         const result = await fetch(modelsUrl);
         if (!result.ok) {
             console.logwarn('Pollinations returned an error.', result.status, result.statusText);
             throw new Error('Pollinations request failed.');
+        }
         const data = await result.json();
         if (!Array.isArray(data)) {
             console.logwarn('Pollinations returned invalid data.');
             throw new Error('Pollinations request failed.');
+        }
         const models = data.map(x => ({ value: x, text: x }));
         return response.send(models);
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

         });
         promptUrl.search = params.toString();
         console.loginfo('Pollinations request URL:', promptUrl.toString());
         const result = await fetch(promptUrl);
         if (!result.ok) {
             console.logwarn('Pollinations returned an error.', result.status, result.statusText);
             throw new Error('Pollinations request failed.');
+        }

         return response.send({ image: base64 });
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

         const key = readSecret(request.user.directories, SECRET_KEYS.STABILITY);
         if (!key) {
             console.logwarn('Stability AI key not found.');
             return response.sendStatus(400);
+        }
         const { payload, model } = request.body;
         console.logdebug('Stability AI request:', model, payload);
         const formData = new FormData();
         for (const [key, value] of Object.entries(payload)) {

         if (!result.ok) {
             const text = await result.text();
             console.logwarn('Stability AI returned an error.', result.status, result.statusText, text);
             return response.sendStatus(500);
+        }
         const buffer = await result.arrayBuffer();
         return response.send(Buffer.from(buffer).toString('base64'));
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

         const key = readSecret(request.user.directories, SECRET_KEYS.BLOCKENTROPY);
         if (!key) {
             console.logwarn('Block Entropy key not found.');
             return response.sendStatus(400);
+        }

         });
         if (!modelsResponse.ok) {
             console.logwarn('Block Entropy returned an error.');
             return response.sendStatus(500);
+        }
         const data = await modelsResponse.json();
         if (!Array.isArray(data)) {
             console.logwarn('Block Entropy returned invalid data.');
             return response.sendStatus(500);
+        }
         const models = data.map(x => ({ value: x.name, text: x.name }));
         return response.send(models);
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

         const key = readSecret(request.user.directories, SECRET_KEYS.BLOCKENTROPY);
         if (!key) {
             console.logwarn('Block Entropy key not found.');
             return response.sendStatus(400);
+        }
         console.logdebug('Block Entropy request:', request.body);
         const result = await fetch('https://api.blockentropy.ai/sdapi/v1/txt2img', {
             method: 'POST',

         });
         if (!result.ok) {
             console.logwarn('Block Entropy returned an error.');
             return response.sendStatus(500);
+        }
         const data = await result.json();
         console.logdebug('Block Entropy response:', data);
         return response.send(data);
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

         const key = readSecret(request.user.directories, SECRET_KEYS.HUGGINGFACE);
         if (!key) {
             console.logwarn('Hugging Face key not found.');
             return response.sendStatus(400);
+        }
         console.logdebug('Hugging Face request:', request.body);
         const result = await fetch(`https://api-inference.huggingface.co/models/${request.body.model}`, {
             method: 'POST',

         });
         if (!result.ok) {
             console.logwarn('Hugging Face returned an error.');
             return response.sendStatus(500);
+        }

             image: Buffer.from(buffer).toString('base64'),
         });
     } catch (error) {
         console.logerror(error);
         return response.sendStatus(500);
+    }
 });

         const key = readSecret(request.user.directories, SECRET_KEYS.NANOGPT);
         if (!key) {
             console.logwarn('NanoGPT key not found.');
             return response.sendStatus(400);
+        }

         });
         if (!modelsResponse.ok) {
             console.logwarn('NanoGPT returned an error.');
             return response.sendStatus(500);
+        }

         const imageModels = data?.models?.image;
         if (!imageModels || typeof imageModels !== 'object') {
             console.logwarn('NanoGPT returned invalid data.');
             return response.sendStatus(500);
+        }

@@ -1067,7 +1067,7 @@ nanogpt.post('/models', jsonParser, async (request, response) => {
1067	1067	return response.send(models);
1068	1068	}
1069	1069	catch (error) {
1070	1070	console.logerror(error);
1071	1071	return response.sendStatus(500);
1072	1072	}
1073	1073	});

         const key = readSecret(request.user.directories, SECRET_KEYS.NANOGPT);
         if (!key) {
             console.logwarn('NanoGPT key not found.');
             return response.sendStatus(400);
+        }
         console.logdebug('NanoGPT request:', request.body);
         const result = await fetch('https://nano-gpt.com/api/generate-image', {
             method: 'POST',

         });
         if (!result.ok) {
             console.logwarn('NanoGPT returned an error.');
             return response.sendStatus(500);
+        }

@@ -1102,14 +1102,14 @@ nanogpt.post('/generate', jsonParser, async (request, response) => {
1102	1102
1103	1103	const image = data?.data?.[0]?.b64_json;
1104	1104	if (!image) {
1105	1105	console.logwarn('NanoGPT returned invalid data.');
1106	1106	return response.sendStatus(500);
1107	1107	}
1108	1108
1109	1109	return response.send({ image });
1110	1110	}
1111	1111	catch (error) {
1112	1112	console.logerror(error);
1113	1113	return response.sendStatus(500);
1114	1114	}
1115	1115	});

         const key = readSecret(request.user.directories, SECRET_KEYS.BFL);
         if (!key) {
             console.logwarn('BFL key not found.');
             return response.sendStatus(400);
+        }

             delete requestBody.guidance;
+        }
         console.logdebug('BFL request:', requestBody);
         const result = await fetch(`https://api.bfl.ml/v1/${request.body.model}`, {
             method: 'POST',

         });
         if (!result.ok) {
             console.logwarn('BFL returned an error.');
             return response.sendStatus(500);
+        }

             if (!statusResult.ok) {
                 const text = await statusResult.text();
                 console.logwarn('BFL returned an error.', text);
                 return response.sendStatus(500);
+            }

@@ -1223,7 +1223,7 @@ bfl.post('/generate', jsonParser, async (request, response) => {
1223	1223	throw new Error('BFL failed to generate image.', { cause: statusData });
1224	1224	}
1225	1225	} catch (error) {
1226	1226	console.logerror(error);
1227	1227	return response.sendStatus(500);
1228	1228	}
1229	1229	});

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

  * @param {string} charactersPath Path to the directory containing the character files.
  */
 export async function recreateStats(handle, chatsPath, charactersPath) {
     console.loginfo('Collecting and creating stats for user:', handle);
     const stats = await collectAndCreateStats(chatsPath, charactersPath);
     STATS.set(handle, stats);
     await saveStatsToFile();

@@ -200,7 +200,7 @@ async function saveStatsToFile() {
200	200	await writeFileAtomic(statsFilePath, JSON.stringify(charStats));
201	201	TIMESTAMPS.set(handle, Date.now());
202	202	} catch (error) {
203	203	console.logerror('Failed to save stats to file.', error);
204	204	}
205	205	}
206	206	}

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

     let thumbnailFolder = getThumbnailFolder(directories, type);
     let originalFolder = getOriginalFolder(directories, type);
     if (thumbnailFolder === undefined || originalFolder === undefined) throw new Error('Invalid thumbnail type');
+-
     const pathToCachedFile = path.join(thumbnailFolder, file);
     const pathToOriginalFile = path.join(originalFolder, file);

@@ -104,7 +103,7 @@ async function generateThumbnail(directories, type, file) {
104	103	const cachedStat = fs.statSync(pathToCachedFile);
105	104
106	105	if (originalStat.mtimeMs > cachedStat.ctimeMs) {
107	106	//console.logwarn('Original file changed. Regenerating thumbnail...');
108	107	shouldRegenerate = true;
109	108	}
110	109	}

             return;
+        }
         console.loginfo('Generating thumbnails cache. Please wait...');
         const bgFiles = fs.readdirSync(directories.backgrounds);
         const tasks = [];

@@ -167,7 +166,7 @@ export async function ensureThumbnailCache() {
167	166	}
168	167
169	168	await Promise.all(tasks);
170	169	console.loginfo(`Done! Generated: ${bgFiles.length} preview images`);
171	170	}
172	171	}
173	172

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

             throw new Error('Downloading tokenizers is disabled, the model is not cached');
+        }
         console.loginfo('Downloading tokenizer model:', model);
         const response = await fetch(model);
         if (!response.ok) {
             throw new Error(`Failed to fetch the model: ${response.status} ${response.statusText}`);

     } catch (error) {
         const getLastSegment = str => str?.split('/')?.pop() || '';
         if (fallbackModel) {
             console.logerror(`Could not get a tokenizer from ${getLastSegment(model)}. Reason: ${error.message}. Using a fallback model: ${getLastSegment(fallbackModel)}.`);
             return fallbackModel;
+        }

             const pathToModel = await getPathToTokenizer(this.#model, this.#fallbackModel);
             this.#instance = new SentencePieceProcessor();
             await this.#instance.load(pathToModel);
             console.loginfo('Instantiated the tokenizer for', path.parse(pathToModel).name);
             return this.#instance;
         } catch (error) {
             console.error('Sentencepiece tokenizer failed to load: ' + this.#model, error);

             const pathToModel = await getPathToTokenizer(this.#model, this.#fallbackModel);
             const arrayBuffer = fs.readFileSync(pathToModel).buffer;
             this.#instance = await Tokenizer.fromJSON(arrayBuffer);
             console.loginfo('Instantiated the tokenizer for', path.parse(pathToModel).name);
             return this.#instance;
         } catch (error) {
             console.error('Web tokenizer failed to load: ' + this.#model, error);

@@ -484,7 +484,7 @@ export function getTiktokenTokenizer(model) {
484	484	}
485	485
486	486	const tokenizer = tiktoken.encoding_for_model(model);
487	487	console.loginfo('Instantiated the tokenizer for', model);
488	488	tokenizersCache[model] = tokenizer;
489	489	return tokenizer;
490	490	}

             const chunks = instance?.encodePieces(text);
             return response.send({ ids, count, chunks });
         } catch (error) {
             console.logerror(error);
             return response.send({ ids: [], count: 0, chunks: [] });
+        }
     };

             const text = chunks.join('');
             return response.send({ text, chunks });
         } catch (error) {
             console.logerror(error);
             return response.send({ text: '', chunks: [] });
+        }
     };

             const chunks = await getTiktokenChunks(tokenizer, tokens);
             return response.send({ ids: tokens, count: tokens.length, chunks });
         } catch (error) {
             console.logerror(error);
             return response.send({ ids: [], count: 0, chunks: [] });
+        }
     };

             const text = new TextDecoder().decode(textBytes);
             return response.send({ text });
         } catch (error) {
             console.logerror(error);
             return response.send({ text: '' });
+        }
     };

             const chunks = getWebTokenizersChunks(instance, tokens);
             return response.send({ ids: tokens, count: tokens.length, chunks });
         } catch (error) {
             console.logerror(error);
             return response.send({ ids: [], count: 0, chunks: [] });
+        }
     };

             const text = instance.decode(new Int32Array(ids));
             return response.send({ text, chunks });
         } catch (error) {
             console.logerror(error);
             return response.send({ text: '', chunks: [] });
+        }
     };

         const handler = createTiktokenEncodingHandler(model);
         return handler(req, res);
     } catch (error) {
         console.logerror(error);
         return res.send({ ids: [], count: 0, chunks: [] });
+    }
 });

         const handler = createTiktokenDecodingHandler(model);
         return handler(req, res);
     } catch (error) {
         console.logerror(error);
         return res.send({ text: '' });
+    }
 });

         const result = await fetch(url, args);
         if (!result.ok) {
             console.logwarn(`API returned error: ${result.status} ${result.statusText}`);
             return response.send({ error: true });
+        }

         const ids = data['ids'] ?? [];
         return response.send({ count, ids });
     } catch (error) {
         console.logerror(error);
         return response.send({ error: true });
+    }
 });

         const result = await fetch(url, args);
         if (!result.ok) {
             console.logwarn(`API returned error: ${result.status} ${result.statusText}`);
             return response.send({ error: true });
+        }

         return response.send({ count, ids });
     } catch (error) {
         console.logerror(error);
         return response.send({ error: true });
+    }
 });

src/endpoints/translate.js+31 -31 Viewed

@@ -35,7 +35,7 @@ function decodeBuffer(buffer) {
35	35	try {
36	36	return iconv.decode(Buffer.from(buffer), 'utf-8');
37	37	} catch (error) {
38	38	console.logerror('Failed to decode buffer:', error);
39	39	return Buffer.from(buffer).toString('utf-8');
40	40	}
41	41	}

         const url = readSecret(request.user.directories, SECRET_KEYS.LIBRE_URL);
         if (!url) {
             console.logwarn('LibreTranslate URL is not configured.');
             return response.sendStatus(400);
+        }

             return response.sendStatus(400);
+        }
         console.logdebug('Input text: ' + text);
         const result = await fetch(url, {
             method: 'POST',

         if (!result.ok) {
             const error = await result.text();
             console.logwarn('LibreTranslate error: ', result.statusText, error);
             return response.sendStatus(500);
+        }
         /** @type {any} */
         const json = await result.json();
         console.logdebug('Translated text: ' + json.translatedText);
         return response.send(json.translatedText);
     } catch (error) {
         console.logerror('Translation error: ' + error.message);
         return response.sendStatus(500);
+    }
 });

             return response.sendStatus(400);
+        }
         console.logdebug('Input text: ' + text);
         const { generateRequestUrl, normaliseResponse } = getGoogleTranslateClient();
         const requestUrl = generateRequestUrl(text, { to: lang });
         const result = await fetch(requestUrl);
         if (!result.ok) {
             console.logwarn('Google Translate error: ', result.statusText);
             return response.sendStatus(500);
+        }

         const translatedText = translateResponse.text;
         response.setHeader('Content-Type', 'text/plain; charset=utf-8');
         console.logdebug('Translated text: ' + translatedText);
         return response.send(translatedText);
     } catch (error) {
         console.logerror('Translation error', error);
         return response.sendStatus(500);
+    }
 });

         params.append('lang', lang);
         const ucid = uuidv4().replaceAll('-', '');
         console.logdebug('Input text: ' + inputText);
         const result = await fetch(`https://translate.yandex.net/api/v1/tr.json/translate?ucid=${ucid}&srv=android&format=text`, {
             method: 'POST',

         if (!result.ok) {
             const error = await result.text();
             console.logwarn('Yandex error: ', result.statusText, error);
             return response.sendStatus(500);
+        }
         /** @type {any} */
         const json = await result.json();
         const translated = json.text.join();
         console.logdebug('Translated text: ' + translated);
         return response.send(translated);
     } catch (error) {
         console.logerror('Translation error: ' + error.message);
         return response.sendStatus(500);
+    }
 });

         const baseUrl = secretUrl || LINGVA_DEFAULT;
         if (!secretUrl && baseUrl === LINGVA_DEFAULT) {
             console.logwarn('Lingva URL is using default value.', LINGVA_DEFAULT);
+        }
         if (request.body.lang === 'zh-CN' || request.body.lang === 'zh-TW') {

             return response.sendStatus(400);
+        }
         console.logdebug('Input text: ' + text);
         const url = urlJoin(baseUrl, 'auto', lang, encodeURIComponent(text));
         const result = await fetch(url);
         if (!result.ok) {
             const error = await result.text();
             console.logwarn('Lingva error: ', result.statusText, error);
+        }
         /** @type {any} */
         const data = await result.json();
         console.logdebug('Translated text: ' + data.translation);
         return response.send(data.translation);
     } catch (error) {
         console.logerror('Translation error', error);
         return response.sendStatus(500);
+    }
 });

         const key = readSecret(request.user.directories, SECRET_KEYS.DEEPL);
         if (!key) {
             console.logwarn('DeepL key is not configured.');
             return response.sendStatus(400);
+        }

             return response.sendStatus(400);
+        }
         console.logdebug('Input text: ' + text);
         const params = new URLSearchParams();
         params.append('text', text);

         if (!result.ok) {
             const error = await result.text();
             console.logwarn('DeepL error: ', result.statusText, error);
             return response.sendStatus(500);
+        }
         /** @type {any} */
         const json = await result.json();
         console.logdebug('Translated text: ' + json.translations[0].text);
         return response.send(json.translations[0].text);
     } catch (error) {
         console.logerror('Translation error: ' + error.message);
         return response.sendStatus(500);
+    }
 });

             return response.sendStatus(400);
+        }
         console.logdebug('Input text: ' + text);
         const result = await fetch(url, {
             method: 'POST',

         if (!result.ok) {
             const error = await result.text();
             console.logwarn('DeepLX error: ', result.statusText, error);
             return response.sendStatus(500);
+        }
         /** @type {any} */
         const json = await result.json();
         console.logdebug('Translated text: ' + json.data);
         return response.send(json.data);
     } catch (error) {
         console.logerror('DeepLX translation error: ' + error.message);
         return response.sendStatus(500);
+    }
 });

             return response.sendStatus(400);
+        }
         console.logdebug('Input text: ' + text);
         const result = await bingTranslate(text, null, lang);
         const translatedText = result?.translation;
         console.logdebug('Translated text: ' + translatedText);
         return response.send(translatedText);
     } catch (error) {
         console.logerror('Translation error', error);
         return response.sendStatus(500);
+    }
 });

src/endpoints/users-admin.js+19 -19 Viewed

 router.post('/disable', requireAdminMiddleware, jsonParser, async (request, response) => {
     try {
         if (!request.body.handle) {
             console.logwarn('Disable user failed: Missing required fields');
             return response.status(400).json({ error: 'Missing required fields' });
+        }
         if (request.body.handle === request.user.profile.handle) {
             console.logwarn('Disable user failed: Cannot disable yourself');
             return response.status(400).json({ error: 'Cannot disable yourself' });
+        }

         const user = await storage.getItem(toKey(request.body.handle));
         if (!user) {
             console.logerror('Disable user failed: User not found');
             return response.status(404).json({ error: 'User not found' });
+        }

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

         const user = await storage.getItem(toKey(request.body.handle));
         if (!user) {
             console.logerror('Enable user failed: User not found');
             return response.status(404).json({ error: 'User not found' });
+        }

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

         const user = await storage.getItem(toKey(request.body.handle));
         if (!user) {
             console.logerror('Promote user failed: User not found');
             return response.status(404).json({ error: 'User not found' });
+        }

 router.post('/demote', requireAdminMiddleware, jsonParser, async (request, response) => {
     try {
         if (!request.body.handle) {
             console.logwarn('Demote user failed: Missing required fields');
             return response.status(400).json({ error: 'Missing required fields' });
+        }
         if (request.body.handle === request.user.profile.handle) {
             console.logwarn('Demote user failed: Cannot demote yourself');
             return response.status(400).json({ error: 'Cannot demote yourself' });
+        }

         const user = await storage.getItem(toKey(request.body.handle));
         if (!user) {
             console.logerror('Demote user failed: User not found');
             return response.status(404).json({ error: 'User not found' });
+        }

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

@@ -167,12 +167,12 @@ router.post('/create', requireAdminMiddleware, jsonParser, async (request, respo
167	167	const handle = lodash.kebabCase(String(request.body.handle).toLowerCase().trim());
168	168
169	169	if (!handle) {
170	170	console.logwarn('Create user failed: Invalid handle');
171	171	return response.status(400).json({ error: 'Invalid handle' });
172	172	}
173	173
174	174	if (handles.some(x => x === handle)) {
175	175	console.logwarn('Create user failed: User with that handle already exists');
176	176	return response.status(409).json({ error: 'User already exists' });
177	177	}
178	178

         await storage.setItem(toKey(handle), newUser);
         // Create user directories
         console.loginfo('Creating data directories for', newUser.handle);
         await ensurePublicDirectoriesExist();
         const directories = getUserDirectories(newUser.handle);
         await checkForNewContent([directories]);

@@ -206,17 +206,17 @@ router.post('/create', requireAdminMiddleware, jsonParser, async (request, respo
206	206	router.post('/delete', requireAdminMiddleware, jsonParser, async (request, response) => {
207	207	try {
208	208	if (!request.body.handle) {
209	209	console.logwarn('Delete user failed: Missing required fields');
210	210	return response.status(400).json({ error: 'Missing required fields' });
211	211	}
212	212
213	213	if (request.body.handle === request.user.profile.handle) {
214	214	console.logwarn('Delete user failed: Cannot delete yourself');
215	215	return response.status(400).json({ error: 'Cannot delete yourself' });
216	216	}
217	217
218	218	if (request.body.handle === DEFAULT_USER.handle) {
219	219	console.logwarn('Delete user failed: Cannot delete default user');
220	220	return response.status(400).json({ error: 'Sorry, but the default user cannot be deleted. It is required as a fallback.' });
221	221	}
222	222

         if (request.body.purge) {
             const directories = getUserDirectories(request.body.handle);
             console.loginfo('Deleting data directories for', request.body.handle);
             await fsPromises.rm(directories.root, { recursive: true, force: true });
+        }

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

src/endpoints/users-private.js+22 -22 Viewed

 router.post('/change-avatar', jsonParser, async (request, response) => {
     try {
         if (!request.body.handle) {
             console.logwarn('Change avatar failed: Missing required fields');
             return response.status(400).json({ error: 'Missing required fields' });
+        }
         if (request.body.handle !== request.user.profile.handle && !request.user.profile.admin) {
             console.logerror('Change avatar failed: Unauthorized');
             return response.status(403).json({ error: 'Unauthorized' });
+        }
         // Avatar is not a data URL or not an empty string
         if (!request.body.avatar.startsWith('data:image/') && request.body.avatar !== '') {
             console.logwarn('Change avatar failed: Invalid data URL');
             return response.status(400).json({ error: 'Invalid data URL' });
+        }

         const user = await storage.getItem(toKey(request.body.handle));
         if (!user) {
             console.logerror('Change avatar failed: User not found');
             return response.status(404).json({ error: 'User not found' });
+        }

 router.post('/change-password', jsonParser, async (request, response) => {
     try {
         if (!request.body.handle) {
             console.logwarn('Change password failed: Missing required fields');
             return response.status(400).json({ error: 'Missing required fields' });
+        }
         if (request.body.handle !== request.user.profile.handle && !request.user.profile.admin) {
             console.logerror('Change password failed: Unauthorized');
             return response.status(403).json({ error: 'Unauthorized' });
+        }

@@ -106,17 +106,17 @@ router.post('/change-password', jsonParser, async (request, response) => {
106	106	const user = await storage.getItem(toKey(request.body.handle));
107	107
108	108	if (!user) {
109	109	console.logerror('Change password failed: User not found');
110	110	return response.status(404).json({ error: 'User not found' });
111	111	}
112	112
113	113	if (!user.enabled) {
114	114	console.logerror('Change password failed: User is disabled');
115	115	return response.status(403).json({ error: 'User is disabled' });
116	116	}
117	117
118	118	if (!request.user.profile.admin && user.password && user.password !== getPasswordHash(request.body.oldPassword, user.salt)) {
119	119	console.logerror('Change password failed: Incorrect password');
120	120	return response.status(403).json({ error: 'Incorrect password' });
121	121	}
122	122

@@ -142,12 +142,12 @@ router.post('/backup', jsonParser, async (request, response) => {
142	142	const handle = request.body.handle;
143	143
144	144	if (!handle) {
145	145	console.logwarn('Backup failed: Missing required fields');
146	146	return response.status(400).json({ error: 'Missing required fields' });
147	147	}
148	148
149	149	if (handle !== request.user.profile.handle && !request.user.profile.admin) {
150	150	console.logerror('Backup failed: Unauthorized');
151	151	return response.status(403).json({ error: 'Unauthorized' });
152	152	}
153	153

         const password = request.body.password;
         if (request.user.profile.password && request.user.profile.password !== getPasswordHash(password, request.user.profile.salt)) {
             console.logwarn('Reset settings failed: Incorrect password');
             return response.status(403).json({ error: 'Incorrect password' });
+        }

 router.post('/change-name', jsonParser, async (request, response) => {
     try {
         if (!request.body.name || !request.body.handle) {
             console.logwarn('Change name failed: Missing required fields');
             return response.status(400).json({ error: 'Missing required fields' });
+        }
         if (request.body.handle !== request.user.profile.handle && !request.user.profile.admin) {
             console.logerror('Change name failed: Unauthorized');
             return response.status(403).json({ error: 'Unauthorized' });
+        }

         const user = await storage.getItem(toKey(request.body.handle));
         if (!user) {
             console.logwarn('Change name failed: User not found');
             return response.status(404).json({ error: 'User not found' });
+        }

 router.post('/reset-step1', jsonParser, async (request, response) => {
     try {
         const resetCode = String(crypto.randomInt(1000, 9999));
         console.loginfo();
         console.loginfo(color.magenta(`${request.user.profile.name}, your account reset code is: `) + color.red(resetCode));
         console.loginfo();
         RESET_CACHE.set(request.user.profile.handle, resetCode);
         return response.sendStatus(204);
     } catch (error) {

 router.post('/reset-step2', jsonParser, async (request, response) => {
     try {
         if (!request.body.code) {
             console.logwarn('Recover step 2 failed: Missing required fields');
             return response.status(400).json({ error: 'Missing required fields' });
+        }
         if (request.user.profile.password && request.user.profile.password !== getPasswordHash(request.body.password, request.user.profile.salt)) {
             console.logwarn('Recover step 2 failed: Incorrect password');
             return response.status(400).json({ error: 'Incorrect password' });
+        }
         const code = RESET_CACHE.get(request.user.profile.handle);
         if (!code || code !== request.body.code) {
             console.logwarn('Recover step 2 failed: Incorrect code');
             return response.status(400).json({ error: 'Incorrect code' });
+        }
         console.loginfo('Resetting account data:', request.user.profile.handle);
         await fsPromises.rm(request.user.directories.root, { recursive: true, force: true });
         await ensurePublicDirectoriesExist();

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

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

@@ -67,17 +67,17 @@ router.post('/login', jsonParser, async (request, response) => {
67	67	const user = await storage.getItem(toKey(request.body.handle));
68	68
69	69	if (!user) {
70	70	console.logerror('Login failed: User', request.body.handle, 'not found');
71	71	return response.status(403).json({ error: 'Incorrect credentials' });
72	72	}
73	73
74	74	if (!user.enabled) {
75	75	console.logwarn('Login failed: User', user.handle, 'is disabled');
76	76	return response.status(403).json({ error: 'User is disabled' });
77	77	}
78	78
79	79	if (user.password && user.password !== getPasswordHash(request.body.password, user.salt)) {
80	80	console.logwarn('Login failed: Incorrect password for', user.handle);
81	81	return response.status(403).json({ error: 'Incorrect credentials' });
82	82	}
83	83

         await loginLimiter.delete(ip);
         request.session.handle = user.handle;
         console.loginfo('Login successful:', user.handle, 'from', ip, 'at', new Date().toLocaleString());
         return response.json({ handle: user.handle });
     } catch (error) {
         if (error instanceof RateLimiterRes) {
             console.logerror('Login failed: Rate limited from', getIpFromRequest(request));
             return response.status(429).send({ error: 'Too many attempts. Try again later or recover your password.' });
+        }

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

         const user = await storage.getItem(toKey(request.body.handle));
         if (!user) {
             console.logerror('Recover step 1 failed: User', request.body.handle, 'not found');
             return response.status(404).json({ error: 'User not found' });
+        }
         if (!user.enabled) {
             console.logerror('Recover step 1 failed: User', user.handle, 'is disabled');
             return response.status(403).json({ error: 'User is disabled' });
+        }
         const mfaCode = String(crypto.randomInt(1000, 9999));
         console.loginfo();
         console.loginfo(color.blue(`${user.name}, your password recovery code is: `) + color.magenta(mfaCode));
         console.loginfo();
         MFA_CACHE.set(user.handle, mfaCode);
         return response.sendStatus(204);
     } catch (error) {
         if (error instanceof RateLimiterRes) {
             console.logerror('Recover step 1 failed: Rate limited from', getIpFromRequest(request));
             return response.status(429).send({ error: 'Too many attempts. Try again later or contact your admin.' });
+        }

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

@@ -153,12 +153,12 @@ router.post('/recover-step2', jsonParser, async (request, response) => {
153	153	const ip = getIpFromRequest(request);
154	154
155	155	if (!user) {
156	156	console.logerror('Recover step 2 failed: User', request.body.handle, 'not found');
157	157	return response.status(404).json({ error: 'User not found' });
158	158	}
159	159
160	160	if (!user.enabled) {
161	161	console.logwarn('Recover step 2 failed: User', user.handle, 'is disabled');
162	162	return response.status(403).json({ error: 'User is disabled' });
163	163	}
164	164

         if (request.body.code !== mfaCode) {
             await recoverLimiter.consume(ip);
             console.logwarn('Recover step 2 failed: Incorrect code');
             return response.status(403).json({ error: 'Incorrect code' });
+        }

         return response.sendStatus(204);
     } catch (error) {
         if (error instanceof RateLimiterRes) {
             console.logerror('Recover step 2 failed: Rate limited from', getIpFromRequest(request));
             return response.status(429).send({ error: 'Too many attempts. Try again later or contact your admin.' });
+        }

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

             if (exists) {
                 const path = index.folderPath;
                 console.errorwarn(`Corrupted index detected at ${path}, regenerating...`);
                 await index.deleteIndex();
                 return res.redirect(307, req.originalUrl + '?regenerated=true');
+            }

@@ -474,7 +474,7 @@ router.post('/purge-all', jsonParser, async (req, res) => {
474	474	continue;
475	475	}
476	476	await fs.promises.rm(sourcePath, { recursive: true });
477	477	console.loginfo(`Deleted vector source store at ${sourcePath}`);
478	478	}
479	479
480	480	return res.sendStatus(200);

@@ -498,7 +498,7 @@ router.post('/purge', jsonParser, async (req, res) => {
498	498	continue;
499	499	}
500	500	await fs.promises.rm(sourcePath, { recursive: true });
501	501	console.loginfo(`Deleted vector index at ${sourcePath}`);
502	502	}
503	503
504	504	return res.sendStatus(200);

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

     const pathToWorldInfo = path.join(directories.worlds, filename);
     if (!fs.existsSync(pathToWorldInfo)) {
         console.logerror(`World info file ${filename} doesn't exist.`);
         return dummyObject;
+    }

src/request-proxy.js+3 -3 Viewed

         http.globalAgent = proxyAgent;
         https.globalAgent = proxyAgent;
         console.loginfo();
         console.loginfo(color.green(LOG_HEADER), 'Proxy URL is used:', color.blue(url));
         console.loginfo();
     } catch (error) {
         console.error(color.red(LOG_HEADER), 'Failed to initialize request proxy:', error);
+    }

src/util.js+20 -5 Viewed

 import yauzl from 'yauzl';
 import mime from 'mime-types';
 import { default as simpleGit } from 'simple-git';
 +import { LOG_LEVELS } from './constants.js';
 /**
  * Parsed config object.

  */
 export function formatBytes(bytes) {
     if (bytes === 0) return '0 B';
++
     const k = 1024;
     const sizes = ['B', 'KB', 'MB', 'GB'];
     const i = Math.floor(Math.log(bytes) / Math.log(k));

  */
 export async function extractFileFromZipBuffer(archiveBuffer, fileExtension) {
     return await new Promise((resolve, reject) => yauzl.fromBuffer(Buffer.from(archiveBuffer), { lazyEntries: true }, (err, zipfile) => {
         if (err) {reject(err);
 -            reject(err);
 -        }
         zipfile.readEntry();
         zipfile.on('entry', (entry) => {

     if (isObject(target) && isObject(source)) {
         Object.keys(source).forEach(key => {
             if (isObject(source[key])) {
                 if (!(key in target)) {
                     Object.assign(output, { [key]: source[key] });
                 } else {
                     output[key] = deepMerge(target[key], source[key]);
 +                }
             } else {
                 Object.assign(output, { [key]: source[key] });
+            }

         to.socket.on('close', function () {
             if (from.body instanceof Readable) from.body.destroy(); // Close the remote stream
++
             to.end(); // End the Express response
         });

+}
 /**
 + * Setup the minimum log level
 + */
 +export function setupLogLevel() {
 +    const logLevel = getConfigValue('minLogLevel', LOG_LEVELS.DEBUG);
++
 +    globalThis.console.debug = logLevel <= LOG_LEVELS.DEBUG ? console.debug : () => {};
 +    globalThis.console.log = logLevel <= LOG_LEVELS.INFO ? console.log : () => {};
 +    globalThis.console.info = logLevel <= LOG_LEVELS.INFO ? console.info : () => {};
 +    globalThis.console.warn = logLevel <= LOG_LEVELS.WARN ? console.warn : () => {};
 +    globalThis.console.error = logLevel <= LOG_LEVELS.ERROR ? console.error : () => {};
 +}
++
 +/**
  * MemoryLimitedMap class that limits the memory usage of string values.
  */
 export class MemoryLimitedMap {

Merge pull request #3307 from Eradev/staging-3071-v2 Added option to disable the chat logs in terminal v2