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

76d166176877779dfba11090d2849604e5fd242b

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

Signed

Parents: e5e931356b27f99e9124a7944ae47ed23453abae a5399b6614705b6db138526d9cc492890c4169c8

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	console.log(`Unknown chat template hash: ${hash} for [${chat_template}]`);	101	console.warn(`Unknown chat template hash: ${hash} for [${chat_template}]`);
101	return null;	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 { executeSlashCommandsOnChatInput, executeSlashCommandsWithOptions } from '../../../slash-commands.js';
-import { SlashCommandParser } from '../../../slash-commands/SlashCommandParser.js';
 import { SlashCommandScope } from '../../../slash-commands/SlashCommandScope.js';
-import { debounceAsync, log, warn } from '../index.js';
+import { SlashCommandParser } from '../../../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	renderSettings() {	89	renderSettings() {
107	if (!this.settingsDom) {	90	if (!this.settingsDom) {
108	this.settingsDom = document.createElement('div'); {	91	this.settingsDom = document.createElement('div'); {

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

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

@@ -207,6 +188,7 @@ export class QuickReplySet {
207	document.querySelector('#send_but').click();	188	document.querySelector('#send_but').click();
208	}	189	}
209	}	190	}
		191
210	/**	192	/**
211	* @param {QuickReply} qr	193	* @param {QuickReply} qr
212	* @param {string} [message] - optional altered message to be used	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 })
+                    ...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) {
+        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.log('Multimodal captioning request', body);
+        console.debug('Multimodal captioning request', body);
         const result = await fetch(url, {
             body: JSON.stringify(body),

         if (!result.ok) {
             const text = await result.text();
-            console.log(`Claude API returned error: ${result.status} ${result.statusText}`, text);
+            console.warn(`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.log('Claude response:', generateResponseJson);
+        console.debug('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	catch (err) {	178	catch (err) {
179	console.log(err);	179	console.error(err);
180	}	180	}
181	return response.send(output);	181	return response.send(output);
182	});	182	});

             category = i;
     if (category === null) {
-        console.debug('Bad request: unsupported asset category.');
+        console.error('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.debug('Request received to download', url, 'to', file_path);
+    console.info('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	// Move into asset place	243	// Move into asset place
244	console.debug('Download finished, moving file from', temp_path, 'to', file_path);	244	console.info('Download finished, moving file from', temp_path, 'to', file_path);
245	fs.copyFileSync(temp_path, file_path);	245	fs.copyFileSync(temp_path, file_path);
246	fs.rmSync(temp_path);	246	fs.rmSync(temp_path);
247	response.sendStatus(200);	247	response.sendStatus(200);
248	}	248	}
249	catch (error) {	249	catch (error) {
250	console.log(error);	250	console.error(error);
251	response.sendStatus(500);	251	response.sendStatus(500);
252	}	252	}
253	});	253	});

             category = i;
     if (category === null) {
-        console.debug('Bad request: unsupported asset category.');
+        console.error('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.debug('Request received to delete', category, file_path);
+    console.info('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	fs.unlink(file_path, (err) => {	288	fs.unlink(file_path, (err) => {
289	if (err) throw err;	289	if (err) throw err;
290	});	290	});
291	console.debug('Asset deleted.');	291	console.info('Asset deleted.');
292	}	292	}
293	else {	293	else {
294	console.debug('Asset not found.');	294	console.error('Asset not found.');
295	response.sendStatus(400);	295	response.sendStatus(400);
296	}	296	}
297	// Move into asset place	297	// Move into asset place
298	response.sendStatus(200);	298	response.sendStatus(200);
299	}	299	}
300	catch (error) {	300	catch (error) {
301	console.log(error);	301	console.error(error);
302	response.sendStatus(500);	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.debug('Bad request: unsupported asset category.');
+        console.error('Bad request: unsupported asset category.');
         return response.sendStatus(400);
+    }

@@ -364,7 +365,7 @@ router.post('/character', jsonParser, async (request, response) => {
364	return response.send(output);	365	return response.send(output);
365	}	366	}
366	catch (err) {	367	catch (err) {
367	console.log(err);	368	console.error(err);
368	return response.sendStatus(500);	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.error('Azure TTS API Key not set');
+            console.warn('Azure TTS API Key not set');
             return res.sendStatus(403);
+        }
         const region = req.body.region;
         if (!region) {
-            console.error('Azure TTS region not set');
+            console.warn('Azure TTS region not set');
             return res.sendStatus(400);
+        }

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

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

         });
         if (!response.ok) {
-            console.error('Azure Request failed', response.status, response.statusText);
+            console.warn('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	if (!apiKey) {	116	if (!apiKey) {
117	console.log(color.red(`Claude API key is missing.\n${divider}`));	117	console.warn(color.red(`Claude API key is missing.\n${divider}`));
118	return response.status(400).send({ error: true });	118	return response.status(400).send({ error: true });
119	}	119	}
120		120

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

         });
         if (!generateResponse.ok) {
-            console.log(`Scale API returned error: ${generateResponse.status} ${generateResponse.statusText} ${await generateResponse.text()}`);
+            console.warn(`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.log('Scale response:', generateResponseJson);
+        console.debug('Scale response:', generateResponseJson);
         const reply = { choices: [{ 'message': { 'content': generateResponseJson.output } }] };
         return response.send(reply);
     } catch (error) {
-        console.log(error);
+        console.error(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.log('Google AI Studio API key is missing.');
+        console.warn('Google AI Studio API key is missing.');
         return response.status(400).send({ error: true });
+    }

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

@@ -366,14 +366,14 @@ async function sendMakerSuiteRequest(request, response) {
366	// Pipe remote SSE stream to Express response	366	// Pipe remote SSE stream to Express response
367	forwardFetchResponse(generateResponse, response);	367	forwardFetchResponse(generateResponse, response);
368	} catch (error) {	368	} catch (error) {
369	console.log('Error forwarding streaming response:', error);	369	console.error('Error forwarding streaming response:', error);
370	if (!response.headersSent) {	370	if (!response.headersSent) {
371	return response.status(500).send({ error: true });	371	return response.status(500).send({ error: true });
372	}	372	}
373	}	373	}
374	} else {	374	} else {
375	if (!generateResponse.ok) {	375	if (!generateResponse.ok) {
376	console.log(`Google AI Studio API returned error: ${generateResponse.status} ${generateResponse.statusText} ${await generateResponse.text()}`);	376	console.warn(`Google AI Studio API returned error: ${generateResponse.status} ${generateResponse.statusText} ${await generateResponse.text()}`);
377	return response.status(generateResponse.status).send({ error: true });	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	const responseContent = candidates[0].content ?? candidates[0].output;	393	const responseContent = candidates[0].content ?? candidates[0].output;
394	console.log('Google AI Studio response:', responseContent);	394	console.warn('Google AI Studio response:', responseContent);
395		395
396	const responseText = typeof responseContent === 'string' ? responseContent : responseContent?.parts?.filter(part => !part.thought)?.map(part => part.text)?.join('\n\n');	396	const responseText = typeof responseContent === 'string' ? responseContent : responseContent?.parts?.filter(part => !part.thought)?.map(part => part.text)?.join('\n\n');
397	if (!responseText) {	397	if (!responseText) {
398	let message = 'Google AI Studio Candidate text empty';	398	let message = 'Google AI Studio Candidate text empty';
399	console.log(message, generateResponseJson);	399	console.warn(message, generateResponseJson);
400	return response.send({ error: { message } });	400	return response.send({ error: { message } });
401	}	401	}
402		402

@@ -405,7 +405,7 @@ async function sendMakerSuiteRequest(request, response) {
405	return response.send(reply);	405	return response.send(reply);
406	}	406	}
407	} catch (error) {	407	} catch (error) {
408	console.log('Error communicating with Google AI Studio API: ', error);	408	console.error('Error communicating with Google AI Studio API: ', error);
409	if (!response.headersSent) {	409	if (!response.headersSent) {
410	return response.status(500).send({ error: true });	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.log(request.body.messages);
+    console.debug(request.body.messages);
     request.socket.removeAllListeners('close');
     request.socket.on('close', function () {
         controller.abort();

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

         } else {
             if (!generateResponse.ok) {
                 const errorText = await generateResponse.text();
-                console.log(`AI21 API returned error: ${generateResponse.status} ${generateResponse.statusText} ${errorText}`);
+                console.warn(`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.log('AI21 response:', generateResponseJson);
+            console.debug('AI21 response:', generateResponseJson);
             return response.send(generateResponseJson);
+        }
     } catch (error) {
-        console.log('Error communicating with AI21 API: ', error);
+        console.error('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.log('MistralAI API key is missing.');
+        console.warn('MistralAI API key is missing.');
         return response.status(400).send({ error: true });
+    }

             timeout: 0,
         };
-        console.log('MisralAI request:', requestBody);
+        console.debug('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.log(`MistralAI API returned error: ${generateResponse.status} ${generateResponse.statusText} ${errorText}`);
+                console.warn(`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.log('MistralAI response:', generateResponseJson);
+            console.debug('MistralAI response:', generateResponseJson);
             return response.send(generateResponseJson);
+        }
     } catch (error) {
-        console.log('Error communicating with MistralAI API: ', error);
+        console.error('Error communicating with MistralAI API: ', error);
         if (!response.headersSent) {
             response.send({ error: true });
         } else {

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

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

             const generateResponse = await fetch(apiUrl, config);
             if (!generateResponse.ok) {
                 const errorText = await generateResponse.text();
-                console.log(`Cohere API returned error: ${generateResponse.status} ${generateResponse.statusText} ${errorText}`);
+                console.warn(`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.log('Cohere response:', generateResponseJson);
+            console.debug('Cohere response:', generateResponseJson);
             return response.send(generateResponseJson);
+        }
     } catch (error) {
-        console.log('Error communicating with Cohere API: ', error);
+        console.error('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.log('DeepSeek API key is missing.');
+        console.warn('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.log('This chat completion source is not supported yet.');
+        console.warn('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.log('Chat Completion API key is missing.');
+        console.warn('Chat Completion API key is missing.');
         return response_getstatus_openai.status(400).send({ error: true });
+    }

                     };
                 });
-                console.log('Available OpenRouter models:', models);
+                console.info('Available OpenRouter models:', models);
             } else if (request.body.chat_completion_source === CHAT_COMPLETION_SOURCES.MISTRALAI) {
                 const models = data?.data;
-                console.log(models);
+                console.info(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.log('Available models:', modelIds);
+                    console.info('Available models:', modelIds);
                 } else {
-                    console.log('Chat Completion endpoint did not return a list of models.');
+                    console.warn('Chat Completion endpoint did not return a list of models.');
+                }
+            }
+        }
         else {
-            console.log('Chat Completion status check failed. Either Access Token is incorrect or API endpoint is down.');
+            console.error('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.warn('Tokenizer not initialized:', model);
+                console.error('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.log('Applying custom prompt post-processing of type', request.body.custom_prompt_post_processing);
+            console.info('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.log('This chat completion source is not supported yet.');
+        console.warn('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.log('OpenAI API key is missing.');
+        console.warn('OpenAI API key is missing.');
         return response.status(400).send({ error: true });
+    }

         signal: controller.signal,
     };
-    console.log(requestBody);
+    console.debug(requestBody);
     makeRequest(config, response, request);

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

                 /** @type {any} */
                 let json = await fetchResponse.json();
                 response.send(json);
-                console.log(json);
+                console.debug(json);
-                console.log(json?.choices?.[0]?.message);
+                console.debug(json?.choices?.[0]?.message);
             } else if (fetchResponse.status === 429 && retries > 0) {
-                console.log(`Out of quota, retrying in ${Math.round(timeout / 1000)}s`);
+                console.warn(`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.log('Generation failed', error);
+            console.error('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.log('Chat completion request error: ', message, responseText);
+        console.error('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.log('Aborting Kobold generation...');
+                console.info('Aborting Kobold generation...');
                 // send abort signal to koboldcpp
                 const abortResponse = await fetch(`${request.body.api_server}/extra/abort`, {
                     method: 'POST',
                 });
                 if (!abortResponse.ok) {
-                    console.log('Error sending abort request to Kobold:', abortResponse.status);
+                    console.error('Error sending abort request to Kobold:', abortResponse.status);
+                }
             } catch (error) {
-                console.log(error);
+                console.error(error);
+            }
+        }
         controller.abort();

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

             } else {
                 if (!response.ok) {
                     const errorText = await response.text();
-                    console.log(`Kobold returned error: ${response.status} ${response.statusText} ${errorText}`);
+                    console.warn(`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	const data = await response.json();	119	const data = await response.json();
120	console.log('Endpoint response:', data);	120	console.debug('Endpoint response:', data);
121	return response_generate.send(data);	121	return response_generate.send(data);
122	}	122	}
123	} catch (error) {	123	} catch (error) {

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

         const server = request.body.server;
         if (!server) {
-            console.log('Server is not set');
+            console.error('Server is not set');
             return response.sendStatus(400);
+        }
         if (!request.file) {
-            console.log('No audio file found');
+            console.error('No audio file found');
             return response.sendStatus(400);
+        }
-        console.log('Transcribing audio with KoboldCpp', server);
+        console.debug('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.log('KoboldCpp request failed', result.statusText, text);
+            console.error('KoboldCpp request failed', result.statusText, text);
             return response.status(500).send(text);
+        }
         const data = await result.json();
-        console.log('KoboldCpp transcription response', data);
+        console.debug('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.log('No Scale cookie found');
+            console.error('No Scale cookie found');
             return response.sendStatus(400);
+        }

             },
         };
-        console.log('Scale request:', body);
+        console.debug('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.log('Scale request failed', result.statusText, text);
+            console.error('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.log('Scale response:', data);
+        console.debug('Scale response:', data);
         if (!output) {
             console.warn('Scale response is empty');

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

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

         });
         jsonStream.body.on('end', () => {
-            console.log('Streaming request finished');
+            console.info('Streaming request finished');
             response.write('data: [DONE]\n\n');
             response.end();
         });
     } catch (error) {
-        console.log('Error forwarding streaming response:', error);
+        console.error('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	async function abortKoboldCppRequest(url) {	80	async function abortKoboldCppRequest(url) {
81	try {	81	try {
82	console.log('Aborting Kobold generation...');	82	console.info('Aborting Kobold generation...');
83	const abortResponse = await fetch(`${url}/api/extra/abort`, {	83	const abortResponse = await fetch(`${url}/api/extra/abort`, {
84	method: 'POST',	84	method: 'POST',
85	});	85	});
86		86
87	if (!abortResponse.ok) {	87	if (!abortResponse.ok) {
88	console.log('Error sending abort request to Kobold:', abortResponse.status, abortResponse.statusText);	88	console.error('Error sending abort request to Kobold:', abortResponse.status, abortResponse.statusText);
89	}	89	}
90	} catch (error) {	90	} catch (error) {
91	console.log(error);	91	console.error(error);
92	}	92	}
93	}	93	}
94		94

             request.body.api_server = request.body.api_server.replace('localhost', '127.0.0.1');
+        }
-        console.log('Trying to connect to API:', request.body);
+        console.debug('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.log('Models endpoint is offline.');
+            console.error('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	if (!Array.isArray(data.data)) {	173	if (!Array.isArray(data.data)) {
176	console.log('Models response is not an array.');	174	console.error('Models response is not an array.');
177	return response.sendStatus(400);	175	return response.sendStatus(400);
178	}	176	}
179		177
180	const modelIds = data.data.map(x => x.id);	178	const modelIds = data.data.map(x => x.id);
181	console.log('Models available:', modelIds);	179	console.info('Models available:', modelIds);
182		180
183	// Set result to the first model ID	181	// Set result to the first model ID
184	result = modelIds[0] \|\| 'Valid';	182	result = modelIds[0] \|\| 'Valid';

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

                 if (modelInfoReply.ok) {
                     /** @type {any} */
                     const modelInfo = await modelInfoReply.json();
-                    console.log('Tabby model info:', modelInfo);
+                    console.debug('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.log(`Model properties: ${JSON.stringify(props)}`);
+        console.debug(`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.log(request.body);
+        console.debug(request.body);
         const controller = new AbortController();
         request.socket.removeAllListeners('close');

             if (completionsReply.ok) {
                 /** @type {any} */
                 const data = await completionsReply.json();
-                console.log('Endpoint response:', data);
+                console.debug('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 };
-                if (!response.headersSent) {
+                return !response.headersSent
-                    return response.send(errorBody);
+                    ? 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.log('Endpoint error:', error);
+        console.error('Endpoint error:', error);
-        if (!response.headersSent) {
-            return response.send(value);
-        }
-        return response.end();
+        return !response.headersSent
+            ? response.send(value)
+            : response.end();
+    }
 });

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

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

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

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

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

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

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

             return response.sendStatus(400);
+        }
-        console.log('LlamaCpp slots request:', request.body);
+        console.debug('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	if (!fetchResponse.ok) {	612	if (!fetchResponse.ok) {
619	console.log('LlamaCpp slots error:', fetchResponse.status, fetchResponse.statusText);	613	console.error('LlamaCpp slots error:', fetchResponse.status, fetchResponse.statusText);
620	return response.status(500).send({ error: true });	614	return response.status(500).send({ error: true });
621	}	615	}
622		616
623	const data = await fetchResponse.json();	617	const data = await fetchResponse.json();
624	console.log('LlamaCpp slots response:', data);	618	console.debug('LlamaCpp slots response:', data);
625		619
626	return response.send(data);	620	return response.send(data);
627		621

@@ -659,14 +653,14 @@ tabby.post('/download', jsonParser, async function (request, response) {
659	return response.status(403).send({ error: true });	653	return response.status(403).send({ error: true });
660	}	654	}
661	} else {	655	} else {
662	console.log('API Permission error:', permissionResponse.status, permissionResponse.statusText);	656	console.error('API Permission error:', permissionResponse.status, permissionResponse.statusText);
663	return response.status(permissionResponse.status).send({ error: true });	657	return response.status(permissionResponse.status).send({ error: true });
664	}	658	}
665		659
666	const fetchResponse = await fetch(`${baseUrl}/v1/download`, args);	660	const fetchResponse = await fetch(`${baseUrl}/v1/download`, args);
667		661
668	if (!fetchResponse.ok) {	662	if (!fetchResponse.ok) {
669	console.log('Download error:', fetchResponse.status, fetchResponse.statusText);	663	console.error('Download error:', fetchResponse.status, fetchResponse.statusText);
670	return response.status(fetchResponse.status).send({ error: true });	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.log('BG file not found');
+        console.error('BG file not found');
         return response.sendStatus(400);
+    }

@@ -43,12 +43,12 @@ router.post('/rename', jsonParser, function (request, response) {
43	const newFileName = path.join(request.user.directories.backgrounds, sanitize(request.body.new_bg));	43	const newFileName = path.join(request.user.directories.backgrounds, sanitize(request.body.new_bg));
44		44
45	if (!fs.existsSync(oldFileName)) {	45	if (!fs.existsSync(oldFileName)) {
46	console.log('BG file not found');	46	console.error('BG file not found');
47	return response.sendStatus(400);	47	return response.sendStatus(400);
48	}	48	}
49		49
50	if (fs.existsSync(newFileName)) {	50	if (fs.existsSync(newFileName)) {
51	console.log('New BG file already exists');	51	console.error('New BG file already exists');
52	return response.sendStatus(400);	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.log('Failed to parse captioned image');
+            console.warn('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.log('Image caption:', text);
+        console.info('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	writeFileAtomicSync(outputImagePath, outputImage);	97	writeFileAtomicSync(outputImagePath, outputImage);
98	return true;	98	return true;
99	} catch (err) {	99	} catch (err) {
100	console.log(err);	100	console.error(err);
101	return false;	101	return false;
102	}	102	}
103	}	103	}

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

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

     };
     _.forEach(fieldMappings, (v2Path, charField) => {
-        //console.log(`Migrating field: ${charField} from ${v2Path}`);
+        //console.info(`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	if (!_.isUndefined(defaultValue)) {	339	if (!_.isUndefined(defaultValue)) {
340	//console.debug(`Spec v2 extension data missing for field: ${charField}, using default value: ${defaultValue}`);	340	//console.warn(`Spec v2 extension data missing for field: ${charField}, using default value: ${defaultValue}`);
341	char[charField] = defaultValue;	341	char[charField] = defaultValue;
342	} else {	342	} else {
343	console.debug(`Char ${char['name']} has Spec v2 data missing for unknown field: ${charField}`);	343	console.warn(`Char ${char['name']} has Spec v2 data missing for unknown field: ${charField}`);
344	return;	344	return;
345	}	345	}
346	}	346	}
347	if (!_.isUndefined(char[charField]) && !_.isUndefined(v2Value) && String(char[charField]) !== String(v2Value)) {	347	if (!_.isUndefined(char[charField]) && !_.isUndefined(v2Value) && String(char[charField]) !== String(v2Value)) {
348	console.debug(`Char ${char['name']} has Spec v2 data mismatch with Spec v1 for field: ${charField}`, char[charField], v2Value);	348	console.warn(`Char ${char['name']} has Spec v2 data mismatch with Spec v1 for field: ${charField}`, char[charField], v2Value);
349	}	349	}
350	char[charField] = v2Value;	350	char[charField] = v2Value;
351	});	351	});

@@ -442,7 +442,7 @@ function charaFormatData(data, directories) {
442	}	442	}
443		443
444	} catch {	444	} catch {
445	console.debug(`Failed to read world info file: ${data.world}. Character book will not be available.`);	445	console.warn(`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	// Deep merge the extensions object	452	// Deep merge the extensions object
453	_.set(char, 'data.extensions', deepMerge(char.data.extensions, extensions));	453	_.set(char, 'data.extensions', deepMerge(char.data.extensions, extensions));
454	} catch {	454	} catch {
455	console.debug(`Failed to parse extensions JSON: ${data.extensions}`);	455	console.warn(`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.log('Importing from YAML');
+    console.info('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.log('Importing from CharX');
+    console.info('Importing from CharX');
     const cardBuffer = await extractFileFromZipBuffer(data, 'card.json');
     if (!cardBuffer) {

     let jsonData = JSON.parse(data);
     if (jsonData.spec !== undefined) {
-        console.log(`Importing from ${jsonData.spec} json`);
+        console.info(`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.log('Importing from v1 json');
+        console.info('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.log('Importing from gradio json');
+        console.info('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.log(`Found a ${jsonData.spec} character file.`);
+        console.info(`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.log('Found a v1 character file.');
+        console.info('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.error('Error: no response body detected');
+        console.warn('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.error('Error: invalid name.');
+        console.warn('Error: invalid name.');
         response.status(400).send('Error: invalid name.');
         return;
+    }

  * @returns {void}
  */
 router.post('/edit-attribute', jsonParser, validateAvatarUrlMiddleware, async function (request, response) {
-    console.log(request.body);
+    console.debug(request.body);
     if (!request.body) {
-        console.error('Error: no response body detected');
+        console.warn('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.error('Error: invalid name.');
+        console.warn('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.error('Error: invalid field.');
+            console.warn('Error: invalid field.');
             response.status(400).send('Error: invalid field.');
             return;
+        }

             await writeCharacterData(avatarPath, JSON.stringify(character), targetImg, request);
             response.sendStatus(200);
         } else {
-            console.log(validator.lastValidationError);
+            console.warn(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.log(`Found an empty chat file: ${pathToFile}`);
+                    console.warn(`Found an empty chat file: ${pathToFile}`);
                     res({});
                     return;
+                }

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

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

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

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

 router.post('/duplicate', jsonParser, validateAvatarUrlMiddleware, async function (request, response) {
     try {
         if (!request.body.avatar_url) {
-            console.log('avatar URL not found in request body');
+            console.warn('avatar URL not found in request body');
-            console.log(request.body);
+            console.debug(request.body);
             return response.sendStatus(400);
+        }
         let filename = path.join(request.user.directories.characters, sanitize(request.body.avatar_url));
         if (!fs.existsSync(filename)) {
-            console.log('file for dupe not found');
+            console.error('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	fs.copyFileSync(filename, newFilename);	1206	fs.copyFileSync(filename, newFilename);
1208	console.log(`${filename} was copied to ${newFilename}`);	1207	console.info(`${filename} was copied to ${newFilename}`);
1209	response.send({ path: path.parse(newFilename).base });	1208	response.send({ path: path.parse(newFilename).base });
1210	}	1209	}
1211	catch (error) {	1210	catch (error) {

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

@@ -50,7 +50,7 @@ function backupChat(directory, name, chat) {
50		50
51	removeOldBackups(directory, 'chat_', maxTotalChatBackups);	51	removeOldBackups(directory, 'chat_', maxTotalChatBackups);
52	} catch (err) {	52	} catch (err) {
53	console.log(`Could not backup chat for ${name}`, err);	53	console.error(`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) {
-        response.send(error);
+        console.error(error);
-        return console.log(error);
+        return response.send(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.log('Old chat name', pathToOriginalFile);
+    console.info('Old chat name', pathToOriginalFile);
-    console.log('New chat name', pathToRenamedFile);
+    console.info('New chat name', pathToRenamedFile);
     if (!fs.existsSync(pathToOriginalFile) || fs.existsSync(pathToRenamedFile)) {
-        console.log('Either Source or Destination files are not available');
+        console.error('Either Source or Destination files are not available');
         return response.status(400).send({ error: true });
+    }
     fs.copyFileSync(pathToOriginalFile, pathToRenamedFile);
     fs.rmSync(pathToOriginalFile);
-    console.log('Successfully renamed.');
+    console.info('Successfully renamed.');
     return response.send({ ok: true, sanitizedFileName });
 });

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

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

                     result: rawFile,
                 };
-                console.log(`Chat exported as ${exportfilename}`);
+                console.info(`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.log(errorMessage.message);
+                console.error(errorMessage.message);
                 return response.status(500).json(errorMessage);
+            }
+        }

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

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

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

@@ -647,7 +646,7 @@ router.post('/search', jsonParser, validateAvatarUrlMiddleware, function (reques
647	break;	646	break;
648	}	647	}
649	} catch (error) {	648	} catch (error) {
650	console.error(groupFile, 'group file is corrupted:', error);	649	console.warn(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	console.log('Classify input:', text);	47	console.debug('Classify input:', text);
48	const result = await getResult(text);	48	const result = await getResult(text);
49	console.log('Classify output:', result);	49	console.debug('Classify output:', result);
50		50
51	return res.json({ classification: result });	51	return res.json({ classification: result });
52	} catch (error) {	52	} catch (error) {

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

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

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

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

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

@@ -182,12 +182,12 @@ export async function checkForNewContent(directoriesList, forceCategories = [])
182	}	182	}
183		183
184	if (anyContentAdded && !contentCheckSkip && forceCategories?.length === 0) {	184	if (anyContentAdded && !contentCheckSkip && forceCategories?.length === 0) {
185	console.log();	185	console.info();
186	console.log(`${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.')}`);	186	console.info(`${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	console.log();	187	console.info();
188	}	188	}
189	} catch (err) {	189	} catch (err) {
190	console.log('Content check failed', err);	190	console.error('Content check failed', err);
191	}	191	}
192	}	192	}
193		193

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

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

     if (!result.ok) {
         const text = await result.text();
-        console.log('Pygsite returned error', result.status, text);
+        console.error('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	console.log('Janny returned error', result.statusText, await result.text());	488	console.error('Janny returned error', result.statusText, await result.text());
489	throw new Error('Failed to download character');	489	throw new Error('Failed to download character');
490	}	490	}
491		491

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

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

             type = 'character';
             result = await downloadRisuCharacter(uuid);
         } else if (isGeneric) {
-            console.log('Downloading from generic url.');
+            console.info('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.log('Importing custom content failed', error);
+        console.error('Importing custom content failed', error);
         return response.sendStatus(500);
+    }
 });

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

         response.set('X-Custom-Content-Type', uuidType);
         return response.send(result.buffer);
     } catch (error) {
-        console.log('Importing custom content failed', error);
+        console.error('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.warn(`User ${request.user.profile.handle} does not have permission to install global extensions.`);
+            console.error(`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.log(`Extension has been cloned at ${extensionPath}`);
+        console.info(`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.log('Importing custom content failed', error);
+        console.error('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.warn(`User ${request.user.profile.handle} does not have permission to update global extensions.`);
+            console.error(`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.log(`Extension has been updated at ${extensionPath}`);
+            console.info(`Extension has been updated at ${extensionPath}`);
         } else {
-            console.log(`Extension is up to date at ${extensionPath}`);
+            console.info(`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.log('Updating custom content failed', error);
+        console.error('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	if (!request.user.profile.admin) {	166	if (!request.user.profile.admin) {
167	console.warn(`User ${request.user.profile.handle} does not have permission to move extensions.`);	167	console.error(`User ${request.user.profile.handle} does not have permission to move extensions.`);
168	return response.status(403).send('Forbidden: No permission to move extensions.');	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.log(`Extension has been moved from ${sourcePath} to ${destinationPath}`);
+        console.info(`Extension has been moved from ${sourcePath} to ${destinationPath}`);
         return response.sendStatus(204);
     } catch (error) {
-        console.log('Moving extension failed', error);
+        console.error('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.log(extensionName, currentBranchName, currentCommitHash);
+        console.debug(extensionName, currentBranchName, currentCommitHash);
         const { isUpToDate, remoteUrl } = await checkIfRepoIsUpToDate(extensionPath);
         return response.send({ currentBranchName, currentCommitHash, isUpToDate, remoteUrl });
     } catch (error) {
-        console.log('Getting extension version failed', error);
+        console.error('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.warn(`User ${request.user.profile.handle} does not have permission to delete global extensions.`);
+            console.error(`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	await fs.promises.rm(extensionPath, { recursive: true });	279	await fs.promises.rm(extensionPath, { recursive: true });
280	console.log(`Extension has been deleted at ${extensionPath}`);	280	console.info(`Extension has been deleted at ${extensionPath}`);
281		281
282	return response.send(`Extension has been deleted at ${extensionPath}`);	282	return response.send(`Extension has been deleted at ${extensionPath}`);
283		283
284	} catch (error) {	284	} catch (error) {
285	console.log('Deleting custom content failed', error);	285	console.error('Deleting custom content failed', error);
286	return response.status(500).send(`Server Error: ${error.message}`);	286	return response.status(500).send(`Server Error: ${error.message}`);
287	}	287	}
288	});	288	});

     // Combine all extensions
     const allExtensions = [...builtInExtensions, ...userExtensions, ...globalExtensions];
-    console.log('Extensions available for', request.user.profile.handle, allExtensions);
+    console.info('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.log(error);
+        console.error(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.log(`Uploaded file: ${url} from ${request.user.profile.handle}`);
+        console.info(`Uploaded file: ${url} from ${request.user.profile.handle}`);
         return response.send({ path: url });
     } catch (error) {
-        console.log(error);
+        console.error(error);
         return response.sendStatus(500);
+    }
 });

@@ -68,10 +68,10 @@ router.post('/delete', jsonParser, async (request, response) => {
68	}	68	}
69		69
70	fs.rmSync(pathToDelete);	70	fs.rmSync(pathToDelete);
71	console.log(`Deleted file: ${request.body.path} from ${request.user.profile.handle}`);	71	console.info(`Deleted file: ${request.body.path} from ${request.user.profile.handle}`);
72	return response.sendStatus(200);	72	return response.sendStatus(200);
73	} catch (error) {	73	} catch (error) {
74	console.log(error);	74	console.error(error);
75	return response.sendStatus(500);	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.debug(`File verification: Invalid path: ${pathToVerify}`);
+                console.warn(`File verification: Invalid path: ${pathToVerify}`);
                 continue;
+            }
             const fileExists = fs.existsSync(pathToVerify);

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

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

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

         if (!result.ok) {
             const error = await result.json();
-            console.log(`Google AI Studio API returned error: ${result.status} ${result.statusText}`, error);
+            console.error(`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.log('Multimodal captioning response', data);
+        console.info('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.log('Deleting group chat', chat);
+                console.info('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.log(`Cancelled Horde task ${taskId}`);
+        console.info(`Cancelled Horde task ${taskId}`);
         return response.send(data);
     } catch (error) {
         console.error(error);

         });
         const data = await fetchResult.json();
-        console.log(`Horde task ${taskId} status:`, data);
+        console.info(`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.log(request.body);
+    console.debug(request.body);
     try {
         const result = await fetch(url, {
             method: 'POST',

         if (!result.ok) {
             const message = await result.text();
-            console.log('Horde returned an error:', message);
+            console.error('Horde returned an error:', message);
             return response.send({ error: { message } });
+        }
         const data = await result.json();
         return response.send(data);
     } catch (error) {
-        console.log(error);
+        console.error(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.log(status);
+            console.info(status);
             if (status.state === HordeAsyncRequestStates.done) {

                     return response.sendStatus(500);
+                }
-                console.log('Image interrogation result:', status);
+                console.debug('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	if (status.state === HordeAsyncRequestStates.faulted \|\| status.state === HordeAsyncRequestStates.cancelled) {	277	if (status.state === HordeAsyncRequestStates.faulted \|\| status.state === HordeAsyncRequestStates.cancelled) {
278	console.log('Image interrogation request is not successful.');	278	console.error('Image interrogation request is not successful.');
279	return response.sendStatus(503);	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.log('Stable Horde prompt is too long, truncating...');
+            console.warn('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.log('Stable Horde prompt was sanitized.');
+                console.info('Stable Horde prompt was sanitized.');
+            }
             request.body.prompt = sanitized;
+        }
         const api_key_horde = readSecret(request.user.directories, SECRET_KEYS.HORDE) || ANONYMOUS_KEY;
-        console.log('Stable Horde request:', request.body);
+        console.debug('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.error('Image generation request is not satisfyable:', generation.message || 'unknown error');
+            console.warn('Image generation request is not satisfyable:', generation.message || 'unknown error');
             return response.sendStatus(400);
+        }
-        console.log('Horde image generation request:', generation);
+        console.info('Horde image generation request:', generation);
         const controller = new AbortController();
         request.socket.removeAllListeners('close');
         request.socket.on('close', function () {
-            console.log('Horde image generation request aborted.');
+            console.warn('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.log(check);
+            console.info(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.log(error);
+        console.error(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.log('NovelAI Access Token is missing.');
+        console.warn('NovelAI Access Token is missing.');
         return res.sendStatus(400);
+    }

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

     const api_key_novel = readSecret(req.user.directories, SECRET_KEYS.NOVEL);
     if (!api_key_novel) {
-        console.log('NovelAI Access Token is missing.');
+        console.warn('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	console.log(util.inspect(data, { depth: 4 }));	244	console.debug(util.inspect(data, { depth: 4 }));
245		245
246	const args = {	246	const args = {
247	body: JSON.stringify(data),	247	body: JSON.stringify(data),

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

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

     const key = readSecret(request.user.directories, SECRET_KEYS.NOVEL);
     if (!key) {
-        console.log('NovelAI Access Token is missing.');
+        console.warn('NovelAI Access Token is missing.');
         return response.sendStatus(400);
+    }
     try {
-        console.log('NAI Diffusion request:', request.body);
+        console.debug('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.log('NovelAI returned an error.', generateResult.statusText, text);
+            console.warn('NovelAI returned an error.', generateResult.statusText, text);
             return response.sendStatus(500);
+        }

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

+        }
         try {
-            console.debug('Upscaling image...');
+            console.info('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	return response.send(originalBase64);	413	return response.send(originalBase64);
414	}	414	}
415	} catch (error) {	415	} catch (error) {
416	console.log(error);	416	console.error(error);
417	return response.sendStatus(500);	417	return response.sendStatus(500);
418	}	418	}
419	});	419	});

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

         if (!result.ok) {
             const errorText = await result.text();
-            console.log('NovelAI returned an error.', result.statusText, errorText);
+            console.error('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	if (!key && !request.body.reverse_proxy && ['custom', 'ooba', 'koboldcpp', 'vllm'].includes(request.body.api) === false) {	65	if (!key && !request.body.reverse_proxy && ['custom', 'ooba', 'koboldcpp', 'vllm'].includes(request.body.api) === false) {
66	console.log('No key found for API', request.body.api);	66	console.warn('No key found for API', request.body.api);
67	return response.sendStatus(400);	67	return response.sendStatus(400);
68	}	68	}
69		69

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

         if (!result.ok) {
             const text = await result.text();
-            console.log('Multimodal captioning request failed', result.statusText, text);
+            console.warn('Multimodal captioning request failed', result.statusText, text);
             return response.status(500).send(text);
+        }
         /** @type {any} */
         const data = await result.json();
-        console.log('Multimodal captioning response', data);
+        console.info('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.log('No OpenAI key found');
+            console.warn('No OpenAI key found');
             return response.sendStatus(400);
+        }
         if (!request.file) {
-            console.log('No audio file found');
+            console.warn('No audio file found');
             return response.sendStatus(400);
+        }
         const formData = new FormData();
-        console.log('Processing audio file', request.file.path);
+        console.info('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.log('OpenAI request failed', result.statusText, text);
+            console.warn('OpenAI request failed', result.statusText, text);
             return response.status(500).send(text);
+        }
         fs.rmSync(request.file.path);
         const data = await result.json();
-        console.log('OpenAI transcription response', data);
+        console.debug('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.log('No OpenAI key found');
+            console.warn('No OpenAI key found');
             return response.sendStatus(400);
+        }

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

         const key = readSecret(request.user.directories, SECRET_KEYS.OPENAI);
         if (!key) {
-            console.log('No OpenAI key found');
+            console.warn('No OpenAI key found');
             return response.sendStatus(400);
+        }
-        console.log('OpenAI request', request.body);
+        console.debug('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.log('OpenAI request failed', result.statusText, text);
+            console.warn('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.log('No OpenAI-compatible TTS provider endpoint provided');
+            console.warn('No OpenAI-compatible TTS provider endpoint provided');
             return response.sendStatus(400);
+        }

         if (!result.ok) {
             const text = await result.text();
-            console.log('OpenAI request failed', result.statusText, text);
+            console.warn('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.log(error);
+        console.error(error);
         return response.sendStatus(500);
+    }
 });

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

         const key = readSecret(request.user.directories, SECRET_KEYS.SERPAPI);
         if (!key) {
-            console.log('No SerpApi key found');
+            console.error('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.log('SerpApi query', query);
+        console.debug('SerpApi query', query);
         if (!result.ok) {
             const text = await result.text();
-            console.log('SerpApi request failed', result.statusText, text);
+            console.error('SerpApi request failed', result.statusText, text);
             return response.status(500).send(text);
+        }
         const data = await result.json();
         return response.json(data);
     } catch (error) {
-        console.log(error);
+        console.error(error);
         return response.sendStatus(500);
+    }
 });

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

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

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

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

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

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

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

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

         if (html) {
             if (!contentType.includes('text/html')) {
-                console.log(`Visit failed, content-type is ${contentType}, expected text/html`);
+                console.error(`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.log(error);
+        console.error(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.log('Secrets file does not exist');
+        console.error('Secrets file does not exist');
         return undefined;
+    }

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

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

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

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

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

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

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

         response.sendStatus(204);
     } catch (error) {
-        console.log(error);
+        console.error(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.log(`Execution duration: ${(end - start) / 1000} seconds`);
+        console.info(`Execution duration: ${(end - start) / 1000} seconds`);
-        console.log('Transcribed audio:', result.text);
+        console.info('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.log(`Execution duration: ${(end - start) / 1000} seconds`);
+        console.debug(`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	return;	82	return;
83	}	83	}
84		84
85	console.log(`RisuAI: Found ${images.length} sprites for ${name}. Writing to disk.`);	85	console.info(`RisuAI: Found ${images.length} sprites for ${name}. Writing to disk.`);
86	const files = fs.readdirSync(spritesPath);	86	const files = fs.readdirSync(spritesPath);
87		87
88	outer: for (const [label, fileBase64] of images) {	88	outer: for (const [label, fileBase64] of images) {
89	// Remove existing sprite with the same label	89	// Remove existing sprite with the same label
90	for (const file of files) {	90	for (const file of files) {
91	if (path.parse(file).name === label) {	91	if (path.parse(file).name === label) {
92	console.log(`RisuAI: The sprite ${label} for ${name} already exists. Skipping.`);	92	console.warn(`RisuAI: The sprite ${label} for ${name} already exists. Skipping.`);
93	continue outer;	93	continue outer;
94	}	94	}
95	}	95	}

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

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

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

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

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

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

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

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

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

@@ -283,13 +283,13 @@ router.post('/set-model', jsonParser, async (request, response) => {
283	break;	283	break;
284	}	284	}
285		285
286	console.log(`Waiting for SD WebUI to finish model loading... Progress: ${progress}; Job count: ${jobCount}`);	286	console.info(`Waiting for SD WebUI to finish model loading... Progress: ${progress}; Job count: ${jobCount}`);
287	await delay(CHECK_INTERVAL);	287	await delay(CHECK_INTERVAL);
288	}	288	}
289		289
290	return response.sendStatus(200);	290	return response.sendStatus(200);
291	} catch (error) {	291	} catch (error) {
292	console.log(error);	292	console.error(error);
293	return response.sendStatus(500);	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	} catch (error) {	311	} catch (error) {
312	console.log('SD WebUI failed to get options:', error);	312	console.error('SD WebUI failed to get options:', error);
313	}	313	}
314		314
315	const controller = new AbortController();	315	const controller = new AbortController();

             controller.abort();
         });
-        console.log('SD WebUI request:', request.body);
+        console.debug('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.log(error);
+        console.error(error);
         return response.sendStatus(500);
+    }
 });

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

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

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

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

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

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

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

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

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

@@ -526,7 +526,7 @@ comfy.post('/delete-workflow', jsonParser, async (request, response) => {
526	}	526	}
527	return response.sendStatus(200);	527	return response.sendStatus(200);
528	} catch (error) {	528	} catch (error) {
529	console.log(error);	529	console.error(error);
530	return response.sendStatus(500);	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.log('ComfyUI error:', error);
+        console.error('ComfyUI error:', error);
         response.status(500).send(error.message);
         return response;
+    }

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

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

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

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

         });
         if (!result.ok) {
-            console.log('TogetherAI returned an error.', { body: await result.text() });
+            console.warn('TogetherAI returned an error.', { body: await result.text() });
             return response.sendStatus(500);
+        }
         /** @type {any} */
         const data = await result.json();
-        console.log('TogetherAI response:', data);
+        console.debug('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.log(error);
+        console.error(error);
         return response.sendStatus(500);
+    }
 });

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

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

         return response.send(data['upscaler']);
     } catch (error) {
-        console.log(error);
+        console.error(error);
         return response.sendStatus(500);
+    }
 });
 drawthings.post('/generate', jsonParser, async (request, response) => {
     try {
-        console.log('SD DrawThings API request:', request.body);
+        console.debug('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.log(error);
+        console.error(error);
         return response.sendStatus(500);
+    }
 });

         const result = await fetch(modelsUrl);
         if (!result.ok) {
-            console.log('Pollinations returned an error.', result.status, result.statusText);
+            console.warn('Pollinations returned an error.', result.status, result.statusText);
             throw new Error('Pollinations request failed.');
+        }
         const data = await result.json();
         if (!Array.isArray(data)) {
-            console.log('Pollinations returned invalid data.');
+            console.warn('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.log(error);
+        console.error(error);
         return response.sendStatus(500);
+    }
 });

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

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

         const key = readSecret(request.user.directories, SECRET_KEYS.STABILITY);
         if (!key) {
-            console.log('Stability AI key not found.');
+            console.warn('Stability AI key not found.');
             return response.sendStatus(400);
+        }
         const { payload, model } = request.body;
-        console.log('Stability AI request:', model, payload);
+        console.debug('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.log('Stability AI returned an error.', result.status, result.statusText, text);
+            console.warn('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.log(error);
+        console.error(error);
         return response.sendStatus(500);
+    }
 });

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

         });
         if (!modelsResponse.ok) {
-            console.log('Block Entropy returned an error.');
+            console.warn('Block Entropy returned an error.');
             return response.sendStatus(500);
+        }
         const data = await modelsResponse.json();
         if (!Array.isArray(data)) {
-            console.log('Block Entropy returned invalid data.');
+            console.warn('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.log(error);
+        console.error(error);
         return response.sendStatus(500);
+    }
 });

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1223,7 +1223,7 @@ bfl.post('/generate', jsonParser, async (request, response) => {
1223	throw new Error('BFL failed to generate image.', { cause: statusData });	1223	throw new Error('BFL failed to generate image.', { cause: statusData });
1224	}	1224	}
1225	} catch (error) {	1225	} catch (error) {
1226	console.log(error);	1226	console.error(error);
1227	return response.sendStatus(500);	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.log('Collecting and creating stats for user:', handle);
+    console.info('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	await writeFileAtomic(statsFilePath, JSON.stringify(charStats));	200	await writeFileAtomic(statsFilePath, JSON.stringify(charStats));
201	TIMESTAMPS.set(handle, Date.now());	201	TIMESTAMPS.set(handle, Date.now());
202	} catch (error) {	202	} catch (error) {
203	console.log('Failed to save stats to file.', error);	203	console.error('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	const cachedStat = fs.statSync(pathToCachedFile);	103	const cachedStat = fs.statSync(pathToCachedFile);
105		104
106	if (originalStat.mtimeMs > cachedStat.ctimeMs) {	105	if (originalStat.mtimeMs > cachedStat.ctimeMs) {
107	//console.log('Original file changed. Regenerating thumbnail...');	106	//console.warn('Original file changed. Regenerating thumbnail...');
108	shouldRegenerate = true;	107	shouldRegenerate = true;
109	}	108	}
110	}	109	}

             return;
+        }
-        console.log('Generating thumbnails cache. Please wait...');
+        console.info('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	await Promise.all(tasks);	168	await Promise.all(tasks);
170	console.log(`Done! Generated: ${bgFiles.length} preview images`);	169	console.info(`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.log('Downloading tokenizer model:', model);
+        console.info('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.log(`Could not get a tokenizer from ${getLastSegment(model)}. Reason: ${error.message}. Using a fallback model: ${getLastSegment(fallbackModel)}.`);
+            console.error(`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.log('Instantiated the tokenizer for', path.parse(pathToModel).name);
+            console.info('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.log('Instantiated the tokenizer for', path.parse(pathToModel).name);
+            console.info('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	const tokenizer = tiktoken.encoding_for_model(model);	486	const tokenizer = tiktoken.encoding_for_model(model);
487	console.log('Instantiated the tokenizer for', model);	487	console.info('Instantiated the tokenizer for', model);
488	tokenizersCache[model] = tokenizer;	488	tokenizersCache[model] = tokenizer;
489	return tokenizer;	489	return tokenizer;
490	}	490	}

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -35,7 +35,7 @@ function decodeBuffer(buffer) {
35	try {	35	try {
36	return iconv.decode(Buffer.from(buffer), 'utf-8');	36	return iconv.decode(Buffer.from(buffer), 'utf-8');
37	} catch (error) {	37	} catch (error) {
38	console.log('Failed to decode buffer:', error);	38	console.error('Failed to decode buffer:', error);
39	return Buffer.from(buffer).toString('utf-8');	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.log('LibreTranslate URL is not configured.');
+            console.warn('LibreTranslate URL is not configured.');
             return response.sendStatus(400);
+        }

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

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

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

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

         params.append('lang', lang);
         const ucid = uuidv4().replaceAll('-', '');
-        console.log('Input text: ' + inputText);
+        console.debug('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.log('Yandex error: ', result.statusText, error);
+            console.warn('Yandex error: ', result.statusText, error);
             return response.sendStatus(500);
+        }
         /** @type {any} */
         const json = await result.json();
         const translated = json.text.join();
-        console.log('Translated text: ' + translated);
+        console.debug('Translated text: ' + translated);
         return response.send(translated);
     } catch (error) {
-        console.log('Translation error: ' + error.message);
+        console.error('Translation error: ' + error.message);
         return response.sendStatus(500);
+    }
 });

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

             return response.sendStatus(400);
+        }
-        console.log('Input text: ' + text);
+        console.debug('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.log('Lingva error: ', result.statusText, error);
+            console.warn('Lingva error: ', result.statusText, error);
+        }
         /** @type {any} */
         const data = await result.json();
-        console.log('Translated text: ' + data.translation);
+        console.debug('Translated text: ' + data.translation);
         return response.send(data.translation);
     } catch (error) {
-        console.log('Translation error', error);
+        console.error('Translation error', error);
         return response.sendStatus(500);
+    }
 });

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

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

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

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

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

             return response.sendStatus(400);
+        }
-        console.log('Input text: ' + text);
+        console.debug('Input text: ' + text);
         const result = await bingTranslate(text, null, lang);
         const translatedText = result?.translation;
-        console.log('Translated text: ' + translatedText);
+        console.debug('Translated text: ' + translatedText);
         return response.send(translatedText);
     } catch (error) {
-        console.log('Translation error', error);
+        console.error('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.log('Disable user failed: Missing required fields');
+            console.warn('Disable user failed: Missing required fields');
             return response.status(400).json({ error: 'Missing required fields' });
+        }
         if (request.body.handle === request.user.profile.handle) {
-            console.log('Disable user failed: Cannot disable yourself');
+            console.warn('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.log('Disable user failed: User not found');
+            console.error('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.log('Enable user failed: Missing required fields');
+            console.warn('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.log('Enable user failed: User not found');
+            console.error('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.log('Promote user failed: Missing required fields');
+            console.warn('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.log('Promote user failed: User not found');
+            console.error('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.log('Demote user failed: Missing required fields');
+            console.warn('Demote user failed: Missing required fields');
             return response.status(400).json({ error: 'Missing required fields' });
+        }
         if (request.body.handle === request.user.profile.handle) {
-            console.log('Demote user failed: Cannot demote yourself');
+            console.warn('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.log('Demote user failed: User not found');
+            console.error('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.log('Create user failed: Missing required fields');
+            console.warn('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	const handle = lodash.kebabCase(String(request.body.handle).toLowerCase().trim());	167	const handle = lodash.kebabCase(String(request.body.handle).toLowerCase().trim());
168		168
169	if (!handle) {	169	if (!handle) {
170	console.log('Create user failed: Invalid handle');	170	console.warn('Create user failed: Invalid handle');
171	return response.status(400).json({ error: 'Invalid handle' });	171	return response.status(400).json({ error: 'Invalid handle' });
172	}	172	}
173		173
174	if (handles.some(x => x === handle)) {	174	if (handles.some(x => x === handle)) {
175	console.log('Create user failed: User with that handle already exists');	175	console.warn('Create user failed: User with that handle already exists');
176	return response.status(409).json({ error: 'User already exists' });	176	return response.status(409).json({ error: 'User already exists' });
177	}	177	}
178		178

         await storage.setItem(toKey(handle), newUser);
         // Create user directories
-        console.log('Creating data directories for', newUser.handle);
+        console.info('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	router.post('/delete', requireAdminMiddleware, jsonParser, async (request, response) => {	206	router.post('/delete', requireAdminMiddleware, jsonParser, async (request, response) => {
207	try {	207	try {
208	if (!request.body.handle) {	208	if (!request.body.handle) {
209	console.log('Delete user failed: Missing required fields');	209	console.warn('Delete user failed: Missing required fields');
210	return response.status(400).json({ error: 'Missing required fields' });	210	return response.status(400).json({ error: 'Missing required fields' });
211	}	211	}
212		212
213	if (request.body.handle === request.user.profile.handle) {	213	if (request.body.handle === request.user.profile.handle) {
214	console.log('Delete user failed: Cannot delete yourself');	214	console.warn('Delete user failed: Cannot delete yourself');
215	return response.status(400).json({ error: 'Cannot delete yourself' });	215	return response.status(400).json({ error: 'Cannot delete yourself' });
216	}	216	}
217		217
218	if (request.body.handle === DEFAULT_USER.handle) {	218	if (request.body.handle === DEFAULT_USER.handle) {
219	console.log('Delete user failed: Cannot delete default user');	219	console.warn('Delete user failed: Cannot delete default user');
220	return response.status(400).json({ error: 'Sorry, but the default user cannot be deleted. It is required as a fallback.' });	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.log('Deleting data directories for', request.body.handle);
+            console.info('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.log('Slugify failed: Missing required fields');
+            console.warn('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.log('Change avatar failed: Missing required fields');
+            console.warn('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.log('Change avatar failed: Unauthorized');
+            console.error('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.log('Change avatar failed: Invalid data URL');
+            console.warn('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.log('Change avatar failed: User not found');
+            console.error('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.log('Change password failed: Missing required fields');
+            console.warn('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.log('Change password failed: Unauthorized');
+            console.error('Change password failed: Unauthorized');
             return response.status(403).json({ error: 'Unauthorized' });
+        }

@@ -106,17 +106,17 @@ router.post('/change-password', jsonParser, async (request, response) => {
106	const user = await storage.getItem(toKey(request.body.handle));	106	const user = await storage.getItem(toKey(request.body.handle));
107		107
108	if (!user) {	108	if (!user) {
109	console.log('Change password failed: User not found');	109	console.error('Change password failed: User not found');
110	return response.status(404).json({ error: 'User not found' });	110	return response.status(404).json({ error: 'User not found' });
111	}	111	}
112		112
113	if (!user.enabled) {	113	if (!user.enabled) {
114	console.log('Change password failed: User is disabled');	114	console.error('Change password failed: User is disabled');
115	return response.status(403).json({ error: 'User is disabled' });	115	return response.status(403).json({ error: 'User is disabled' });
116	}	116	}
117		117
118	if (!request.user.profile.admin && user.password && user.password !== getPasswordHash(request.body.oldPassword, user.salt)) {	118	if (!request.user.profile.admin && user.password && user.password !== getPasswordHash(request.body.oldPassword, user.salt)) {
119	console.log('Change password failed: Incorrect password');	119	console.error('Change password failed: Incorrect password');
120	return response.status(403).json({ error: 'Incorrect password' });	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	const handle = request.body.handle;	142	const handle = request.body.handle;
143		143
144	if (!handle) {	144	if (!handle) {
145	console.log('Backup failed: Missing required fields');	145	console.warn('Backup failed: Missing required fields');
146	return response.status(400).json({ error: 'Missing required fields' });	146	return response.status(400).json({ error: 'Missing required fields' });
147	}	147	}
148		148
149	if (handle !== request.user.profile.handle && !request.user.profile.admin) {	149	if (handle !== request.user.profile.handle && !request.user.profile.admin) {
150	console.log('Backup failed: Unauthorized');	150	console.error('Backup failed: Unauthorized');
151	return response.status(403).json({ error: 'Unauthorized' });	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.log('Reset settings failed: Incorrect password');
+            console.warn('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.log('Change name failed: Missing required fields');
+            console.warn('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.log('Change name failed: Unauthorized');
+            console.error('Change name failed: Unauthorized');
             return response.status(403).json({ error: 'Unauthorized' });
+        }

         const user = await storage.getItem(toKey(request.body.handle));
         if (!user) {
-            console.log('Change name failed: User not found');
+            console.warn('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.log();
+        console.info();
-        console.log(color.magenta(`${request.user.profile.name}, your account reset code is: `) + color.red(resetCode));
+        console.info(color.magenta(`${request.user.profile.name}, your account reset code is: `) + color.red(resetCode));
-        console.log();
+        console.info();
         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.log('Recover step 2 failed: Missing required fields');
+            console.warn('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.log('Recover step 2 failed: Incorrect password');
+            console.warn('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.log('Recover step 2 failed: Incorrect code');
+            console.warn('Recover step 2 failed: Incorrect code');
             return response.status(400).json({ error: 'Incorrect code' });
+        }
-        console.log('Resetting account data:', request.user.profile.handle);
+        console.info('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.log('Login failed: Missing required fields');
+            console.warn('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	const user = await storage.getItem(toKey(request.body.handle));	67	const user = await storage.getItem(toKey(request.body.handle));
68		68
69	if (!user) {	69	if (!user) {
70	console.log('Login failed: User', request.body.handle, 'not found');	70	console.error('Login failed: User', request.body.handle, 'not found');
71	return response.status(403).json({ error: 'Incorrect credentials' });	71	return response.status(403).json({ error: 'Incorrect credentials' });
72	}	72	}
73		73
74	if (!user.enabled) {	74	if (!user.enabled) {
75	console.log('Login failed: User', user.handle, 'is disabled');	75	console.warn('Login failed: User', user.handle, 'is disabled');
76	return response.status(403).json({ error: 'User is disabled' });	76	return response.status(403).json({ error: 'User is disabled' });
77	}	77	}
78		78
79	if (user.password && user.password !== getPasswordHash(request.body.password, user.salt)) {	79	if (user.password && user.password !== getPasswordHash(request.body.password, user.salt)) {
80	console.log('Login failed: Incorrect password for', user.handle);	80	console.warn('Login failed: Incorrect password for', user.handle);
81	return response.status(403).json({ error: 'Incorrect credentials' });	81	return response.status(403).json({ error: 'Incorrect credentials' });
82	}	82	}
83		83

         await loginLimiter.delete(ip);
         request.session.handle = user.handle;
-        console.log('Login successful:', user.handle, 'from', ip, 'at', new Date().toLocaleString());
+        console.info('Login successful:', user.handle, 'from', ip, 'at', new Date().toLocaleString());
         return response.json({ handle: user.handle });
     } catch (error) {
         if (error instanceof RateLimiterRes) {
-            console.log('Login failed: Rate limited from', getIpFromRequest(request));
+            console.error('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.log('Recover step 1 failed: Missing required fields');
+            console.warn('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.log('Recover step 1 failed: User', request.body.handle, 'not found');
+            console.error('Recover step 1 failed: User', request.body.handle, 'not found');
             return response.status(404).json({ error: 'User not found' });
+        }
         if (!user.enabled) {
-            console.log('Recover step 1 failed: User', user.handle, 'is disabled');
+            console.error('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.log();
+        console.info();
-        console.log(color.blue(`${user.name}, your password recovery code is: `) + color.magenta(mfaCode));
+        console.info(color.blue(`${user.name}, your password recovery code is: `) + color.magenta(mfaCode));
-        console.log();
+        console.info();
         MFA_CACHE.set(user.handle, mfaCode);
         return response.sendStatus(204);
     } catch (error) {
         if (error instanceof RateLimiterRes) {
-            console.log('Recover step 1 failed: Rate limited from', getIpFromRequest(request));
+            console.error('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.log('Recover step 2 failed: Missing required fields');
+            console.warn('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	const ip = getIpFromRequest(request);	153	const ip = getIpFromRequest(request);
154		154
155	if (!user) {	155	if (!user) {
156	console.log('Recover step 2 failed: User', request.body.handle, 'not found');	156	console.error('Recover step 2 failed: User', request.body.handle, 'not found');
157	return response.status(404).json({ error: 'User not found' });	157	return response.status(404).json({ error: 'User not found' });
158	}	158	}
159		159
160	if (!user.enabled) {	160	if (!user.enabled) {
161	console.log('Recover step 2 failed: User', user.handle, 'is disabled');	161	console.warn('Recover step 2 failed: User', user.handle, 'is disabled');
162	return response.status(403).json({ error: 'User is disabled' });	162	return response.status(403).json({ error: 'User is disabled' });
163	}	163	}
164		164

         if (request.body.code !== mfaCode) {
             await recoverLimiter.consume(ip);
-            console.log('Recover step 2 failed: Incorrect code');
+            console.warn('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.log('Recover step 2 failed: Rate limited from', getIpFromRequest(request));
+            console.error('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.error(`Corrupted index detected at ${path}, regenerating...`);
+                console.warn(`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	continue;	474	continue;
475	}	475	}
476	await fs.promises.rm(sourcePath, { recursive: true });	476	await fs.promises.rm(sourcePath, { recursive: true });
477	console.log(`Deleted vector source store at ${sourcePath}`);	477	console.info(`Deleted vector source store at ${sourcePath}`);
478	}	478	}
479		479
480	return res.sendStatus(200);	480	return res.sendStatus(200);

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

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

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

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

         http.globalAgent = proxyAgent;
         https.globalAgent = proxyAgent;
-        console.log();
+        console.info();
-        console.log(color.green(LOG_HEADER), 'Proxy URL is used:', color.blue(url));
+        console.info(color.green(LOG_HEADER), 'Proxy URL is used:', color.blue(url));
-        console.log();
+        console.info();
     } 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) {
+        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))
+                if (!(key in target)) {
                     Object.assign(output, { [key]: source[key] });
-                else
+                } 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 {