#!/usr/bin/env node createDefaultFiles(); function createDefaultFiles() { const fs = require('fs'); const path = require('path'); const files = { settings: 'public/settings.json', bg_load: 'public/css/bg_load.css', config: 'config.conf', }; for (const file of Object.values(files)) { try { if (!fs.existsSync(file)) { const defaultFilePath = path.join('default', path.parse(file).base); fs.copyFileSync(defaultFilePath, file); console.log(`Created default file: ${file}`); } } catch (error) { console.error(`FATAL: Could not write default file: ${file}`, error); } } } const process = require('process') const yargs = require('yargs/yargs'); const { hideBin } = require('yargs/helpers'); const net = require("net"); // work around a node v20 bug: https://github.com/nodejs/node/issues/47822#issuecomment-1564708870 if (net.setDefaultAutoSelectFamily) { net.setDefaultAutoSelectFamily(false); } const cliArguments = yargs(hideBin(process.argv)) .option('disableCsrf', { type: 'boolean', default: false, describe: 'Disables CSRF protection' }).option('ssl', { type: 'boolean', default: false, describe: 'Enables SSL' }).option('certPath', { type: 'string', default: 'certs/cert.pem', describe: 'Path to your certificate file.' }).option('keyPath', { type: 'string', default: 'certs/privkey.pem', describe: 'Path to your private key file.' }).argv; // change all relative paths const path = require('path'); const directory = process.pkg ? path.dirname(process.execPath) : __dirname; console.log(process.pkg ? 'Running from binary' : 'Running from source'); process.chdir(directory); const express = require('express'); const compression = require('compression'); const app = express(); const responseTime = require('response-time'); const simpleGit = require('simple-git'); app.use(compression()); app.use(responseTime()); const fs = require('fs'); const writeFileAtomicSync = require('write-file-atomic').sync; const readline = require('readline'); const open = require('open'); const multer = require("multer"); const http = require("http"); const https = require('https'); const basicAuthMiddleware = require('./src/middleware/basicAuthMiddleware'); const contentManager = require('./src/content-manager'); const extract = require('png-chunks-extract'); const encode = require('png-chunks-encode'); const PNGtext = require('png-chunk-text'); const jimp = require('jimp'); const sanitize = require('sanitize-filename'); const mime = require('mime-types'); const cookieParser = require('cookie-parser'); const crypto = require('crypto'); const ipaddr = require('ipaddr.js'); const json5 = require('json5'); const exif = require('piexifjs'); const webp = require('webp-converter'); const DeviceDetector = require("device-detector-js"); const { TextEncoder, TextDecoder } = require('util'); const utf8Encode = new TextEncoder(); const commandExistsSync = require('command-exists').sync; // impoort from statsHelpers.js const statsHelpers = require('./statsHelpers.js'); const characterCardParser = require('./src/character-card-parser.js'); const config = require(path.join(process.cwd(), './config.conf')); const server_port = process.env.SILLY_TAVERN_PORT || config.port; const whitelistPath = path.join(process.cwd(), "./whitelist.txt"); let whitelist = config.whitelist; if (fs.existsSync(whitelistPath)) { try { let whitelistTxt = fs.readFileSync(whitelistPath, 'utf-8'); whitelist = whitelistTxt.split("\n").filter(ip => ip).map(ip => ip.trim()); } catch (e) { } } const whitelistMode = config.whitelistMode; const autorun = config.autorun && !cliArguments.ssl; const enableExtensions = config.enableExtensions; const listen = config.listen; const allowKeysExposure = config.allowKeysExposure; const axios = require('axios'); const tiktoken = require('@dqbd/tiktoken'); const WebSocket = require('ws'); function getHordeClient() { const AIHorde = require("./src/horde"); const ai_horde = new AIHorde({ client_agent: getVersion()?.agent || 'SillyTavern:UNKNOWN:Cohee#1207', }); return ai_horde; } const ipMatching = require('ip-matching'); const yauzl = require('yauzl'); const Client = require('node-rest-client').Client; const client = new Client(); client.on('error', (err) => { console.error('An error occurred:', err); }); let api_server = "http://0.0.0.0:5000"; let api_novelai = "https://api.novelai.net"; let api_openai = "https://api.openai.com/v1"; let api_claude = "https://api.anthropic.com/v1"; let main_api = "kobold"; let response_generate_novel; let characters = {}; let response_dw_bg; let response_getstatus; let first_run = true; let color = { byNum: (mess, fgNum) => { mess = mess || ''; fgNum = fgNum === undefined ? 31 : fgNum; return '\u001b[' + fgNum + 'm' + mess + '\u001b[39m'; }, black: (mess) => color.byNum(mess, 30), red: (mess) => color.byNum(mess, 31), green: (mess) => color.byNum(mess, 32), yellow: (mess) => color.byNum(mess, 33), blue: (mess) => color.byNum(mess, 34), magenta: (mess) => color.byNum(mess, 35), cyan: (mess) => color.byNum(mess, 36), white: (mess) => color.byNum(mess, 37) }; function get_mancer_headers() { const api_key_mancer = readSecret(SECRET_KEYS.MANCER); return api_key_mancer ? { "X-API-KEY": api_key_mancer } : {}; } //RossAscends: Added function to format dates used in files and chat timestamps to a humanized format. //Mostly I wanted this to be for file names, but couldn't figure out exactly where the filename save code was as everything seemed to be connected. //During testing, this performs the same as previous date.now() structure. //It also does not break old characters/chats, as the code just uses whatever timestamp exists in the chat. //New chats made with characters will use this new formatting. //Useable variable is (( humanizedISO8601Datetime )) const delay = ms => new Promise(resolve => setTimeout(resolve, ms)) const { SentencePieceProcessor } = require("@agnai/sentencepiece-js"); const { Tokenizer } = require('@agnai/web-tokenizers'); const CHARS_PER_TOKEN = 3.35; let spp_llama; let spp_nerd; let spp_nerd_v2; let claude_tokenizer; async function loadSentencepieceTokenizer(modelPath) { try { const spp = new SentencePieceProcessor(); await spp.load(modelPath); return spp; } catch (error) { console.error("Sentencepiece tokenizer failed to load: " + modelPath, error); return null; } }; async function countSentencepieceTokens(spp, text) { // Fallback to strlen estimation if (!spp) { return { ids: [], count: Math.ceil(text.length / CHARS_PER_TOKEN) }; } let cleaned = text; // cleanText(text); <-- cleaning text can result in an incorrect tokenization let ids = spp.encodeIds(cleaned); return { ids, count: ids.length }; } async function loadClaudeTokenizer(modelPath) { try { const arrayBuffer = fs.readFileSync(modelPath).buffer; const instance = await Tokenizer.fromJSON(arrayBuffer); return instance; } catch (error) { console.error("Claude tokenizer failed to load: " + modelPath, error); return null; } } function countClaudeTokens(tokenizer, messages) { const convertedPrompt = convertClaudePrompt(messages, false, false); // Fallback to strlen estimation if (!tokenizer) { return Math.ceil(convertedPrompt.length / CHARS_PER_TOKEN); } const count = tokenizer.encode(convertedPrompt).length; return count; } const tokenizersCache = {}; function getTokenizerModel(requestModel) { if (requestModel.includes('claude')) { return 'claude'; } if (requestModel.includes('gpt-4-32k')) { return 'gpt-4-32k'; } if (requestModel.includes('gpt-4')) { return 'gpt-4'; } if (requestModel.includes('gpt-3.5-turbo')) { return 'gpt-3.5-turbo'; } if (requestModel.startsWith('text-') || requestModel.startsWith('code-')) { return requestModel; } // default return 'gpt-3.5-turbo'; } function getTiktokenTokenizer(model) { if (tokenizersCache[model]) { return tokenizersCache[model]; } const tokenizer = tiktoken.encoding_for_model(model); console.log('Instantiated the tokenizer for', model); tokenizersCache[model] = tokenizer; return tokenizer; } function humanizedISO8601DateTime() { let baseDate = new Date(Date.now()); let humanYear = baseDate.getFullYear(); let humanMonth = (baseDate.getMonth() + 1); let humanDate = baseDate.getDate(); let humanHour = (baseDate.getHours() < 10 ? '0' : '') + baseDate.getHours(); let humanMinute = (baseDate.getMinutes() < 10 ? '0' : '') + baseDate.getMinutes(); let humanSecond = (baseDate.getSeconds() < 10 ? '0' : '') + baseDate.getSeconds(); let humanMillisecond = (baseDate.getMilliseconds() < 10 ? '0' : '') + baseDate.getMilliseconds(); let HumanizedDateTime = (humanYear + "-" + humanMonth + "-" + humanDate + " @" + humanHour + "h " + humanMinute + "m " + humanSecond + "s " + humanMillisecond + "ms"); return HumanizedDateTime; }; var is_colab = process.env.colaburl !== undefined; var charactersPath = 'public/characters/'; var chatsPath = 'public/chats/'; const UPLOADS_PATH = './uploads'; const AVATAR_WIDTH = 400; const AVATAR_HEIGHT = 600; const jsonParser = express.json({ limit: '100mb' }); const urlencodedParser = express.urlencoded({ extended: true, limit: '100mb' }); const baseRequestArgs = { headers: { "Content-Type": "application/json" } }; const directories = { worlds: 'public/worlds/', avatars: 'public/User Avatars', images: 'public/img/', userImages: 'public/user/images/', groups: 'public/groups/', groupChats: 'public/group chats', chats: 'public/chats/', characters: 'public/characters/', backgrounds: 'public/backgrounds', novelAI_Settings: 'public/NovelAI Settings', koboldAI_Settings: 'public/KoboldAI Settings', openAI_Settings: 'public/OpenAI Settings', textGen_Settings: 'public/TextGen Settings', thumbnails: 'thumbnails/', thumbnailsBg: 'thumbnails/bg/', thumbnailsAvatar: 'thumbnails/avatar/', themes: 'public/themes', movingUI: 'public/movingUI', extensions: 'public/scripts/extensions', instruct: 'public/instruct', context: 'public/context', backups: 'backups/', quickreplies: 'public/QuickReplies', assets: 'public/assets', }; // CSRF Protection // if (cliArguments.disableCsrf === false) { const doubleCsrf = require('csrf-csrf').doubleCsrf; const CSRF_SECRET = crypto.randomBytes(8).toString('hex'); const COOKIES_SECRET = crypto.randomBytes(8).toString('hex'); const { generateToken, doubleCsrfProtection } = doubleCsrf({ getSecret: () => CSRF_SECRET, cookieName: "X-CSRF-Token", cookieOptions: { httpOnly: true, sameSite: "strict", secure: false }, size: 64, getTokenFromRequest: (req) => req.headers["x-csrf-token"] }); app.get("/csrf-token", (req, res) => { res.json({ "token": generateToken(res) }); }); app.use(cookieParser(COOKIES_SECRET)); app.use(doubleCsrfProtection); } else { console.warn("\nCSRF protection is disabled. This will make your server vulnerable to CSRF attacks.\n"); app.get("/csrf-token", (req, res) => { res.json({ "token": 'disabled' }); }); } // CORS Settings // const cors = require('cors'); const CORS = cors({ origin: 'null', methods: ['OPTIONS'] }); app.use(CORS); if (listen && config.basicAuthMode) app.use(basicAuthMiddleware); // IP Whitelist // let knownIPs = new Set(); function getIpFromRequest(req) { let clientIp = req.connection.remoteAddress; let ip = ipaddr.parse(clientIp); // Check if the IP address is IPv4-mapped IPv6 address if (ip.kind() === 'ipv6' && ip.isIPv4MappedAddress()) { const ipv4 = ip.toIPv4Address().toString(); clientIp = ipv4; } else { clientIp = ip; clientIp = clientIp.toString(); } return clientIp; } app.use(function (req, res, next) { const clientIp = getIpFromRequest(req); if (listen && !knownIPs.has(clientIp)) { const userAgent = req.headers['user-agent']; console.log(color.yellow(`New connection from ${clientIp}; User Agent: ${userAgent}\n`)); knownIPs.add(clientIp); // Write access log const timestamp = new Date().toISOString(); const log = `${timestamp} ${clientIp} ${userAgent}\n`; fs.appendFile('access.log', log, (err) => { if (err) { console.error('Failed to write access log:', err); } }); } //clientIp = req.connection.remoteAddress.split(':').pop(); if (whitelistMode === true && !whitelist.some(x => ipMatching.matches(clientIp, ipMatching.getMatch(x)))) { console.log(color.red('Forbidden: Connection attempt from ' + clientIp + '. If you are attempting to connect, please add your IP address in whitelist or disable whitelist mode in config.conf in root of SillyTavern folder.\n')); return res.status(403).send('Forbidden: Connection attempt from ' + clientIp + '. If you are attempting to connect, please add your IP address in whitelist or disable whitelist mode in config.conf in root of SillyTavern folder.'); } next(); }); app.use(express.static(process.cwd() + "/public", { refresh: true })); app.use('/backgrounds', (req, res) => { const filePath = decodeURIComponent(path.join(process.cwd(), 'public/backgrounds', req.url.replace(/%20/g, ' '))); fs.readFile(filePath, (err, data) => { if (err) { res.status(404).send('File not found'); return; } //res.contentType('image/jpeg'); res.send(data); }); }); app.use('/characters', (req, res) => { const filePath = decodeURIComponent(path.join(process.cwd(), charactersPath, req.url.replace(/%20/g, ' '))); fs.readFile(filePath, (err, data) => { if (err) { res.status(404).send('File not found'); return; } res.send(data); }); }); app.use(multer({ dest: UPLOADS_PATH, limits: { fieldSize: 10 * 1024 * 1024 } }).single("avatar")); app.get("/", function (request, response) { response.sendFile(process.cwd() + "/public/index.html"); }); app.get("/notes/*", function (request, response) { response.sendFile(process.cwd() + "/public" + request.url + ".html"); }); app.get('/deviceinfo', function (request, response) { const userAgent = request.header('user-agent'); const deviceDetector = new DeviceDetector(); const deviceInfo = deviceDetector.parse(userAgent); return response.send(deviceInfo); }); app.get('/version', function (_, response) { const data = getVersion(); response.send(data); }) //**************Kobold api app.post("/generate", jsonParser, async function (request, response_generate = response) { if (!request.body) return response_generate.sendStatus(400); const request_prompt = request.body.prompt; const controller = new AbortController(); request.socket.removeAllListeners('close'); request.socket.on('close', async function () { if (request.body.can_abort && !response_generate.writableEnded) { try { console.log('Aborting Kobold generation...'); // send abort signal to koboldcpp const abortResponse = await fetch(`${api_server}/extra/abort`, { method: 'POST', }); if (!abortResponse.ok) { console.log('Error sending abort request to Kobold:', abortResponse.status); } } catch (error) { console.log(error); } } controller.abort(); }); let this_settings = { prompt: request_prompt, use_story: false, use_memory: false, use_authors_note: false, use_world_info: false, max_context_length: request.body.max_context_length, singleline: !!request.body.singleline, }; if (request.body.gui_settings == false) { const sampler_order = [request.body.s1, request.body.s2, request.body.s3, request.body.s4, request.body.s5, request.body.s6, request.body.s7]; this_settings = { prompt: request_prompt, use_story: false, use_memory: false, use_authors_note: false, use_world_info: false, max_context_length: request.body.max_context_length, max_length: request.body.max_length, rep_pen: request.body.rep_pen, rep_pen_range: request.body.rep_pen_range, rep_pen_slope: request.body.rep_pen_slope, temperature: request.body.temperature, tfs: request.body.tfs, top_a: request.body.top_a, top_k: request.body.top_k, top_p: request.body.top_p, typical: request.body.typical, sampler_order: sampler_order, singleline: !!request.body.singleline, }; if (!!request.body.stop_sequence) { this_settings['stop_sequence'] = request.body.stop_sequence; } } console.log(this_settings); const args = { body: JSON.stringify(this_settings), headers: { "Content-Type": "application/json" }, signal: controller.signal, }; const MAX_RETRIES = 50; const delayAmount = 2500; let fetch, url, response; for (let i = 0; i < MAX_RETRIES; i++) { try { fetch = require('node-fetch').default; url = request.body.streaming ? `${api_server}/extra/generate/stream` : `${api_server}/v1/generate`; response = await fetch(url, { method: 'POST', timeout: 0, ...args }); if (request.body.streaming) { request.socket.on('close', function () { response.body.destroy(); // Close the remote stream response_generate.end(); // End the Express response }); response.body.on('end', function () { console.log("Streaming request finished"); response_generate.end(); }); // Pipe remote SSE stream to Express response return response.body.pipe(response_generate); } else { if (!response.ok) { const errorText = await response.text(); console.log(`Kobold returned error: ${response.status} ${response.statusText} ${errorText}`); try { const errorJson = JSON.parse(errorText); const message = errorJson?.detail?.msg || errorText; return response_generate.status(400).send({ error: { message } }); } catch { return response_generate.status(400).send({ error: { message: errorText } }); } } const data = await response.json(); console.log("Endpoint response:", data); return response_generate.send(data); } } catch (error) { // response switch (error?.status) { case 403: case 503: // retry in case of temporary service issue, possibly caused by a queue failure? console.debug(`KoboldAI is busy. Retry attempt ${i + 1} of ${MAX_RETRIES}...`); await delay(delayAmount); break; default: if ('status' in error) { console.log('Status Code from Kobold:', error.status); } return response_generate.send({ error: true }); } } } console.log('Max retries exceeded. Giving up.'); return response_generate.send({ error: true }); }); //************** Text generation web UI app.post("/generate_textgenerationwebui", jsonParser, async function (request, response_generate = response) { if (!request.body) return response_generate.sendStatus(400); console.log(request.body); const controller = new AbortController(); let isGenerationStopped = false; request.socket.removeAllListeners('close'); request.socket.on('close', function () { isGenerationStopped = true; controller.abort(); }); if (request.header('X-Response-Streaming')) { response_generate.writeHead(200, { 'Content-Type': 'text/plain;charset=utf-8', 'Transfer-Encoding': 'chunked', 'Cache-Control': 'no-transform', }); async function* readWebsocket() { const streamingUrl = request.header('X-Streaming-URL').replace("localhost", "127.0.0.1"); const websocket = new WebSocket(streamingUrl); websocket.on('open', async function () { console.log('WebSocket opened'); const combined_args = Object.assign(request.body.use_mancer ? get_mancer_headers() : {}, request.body); websocket.send(JSON.stringify(combined_args)); }); websocket.on('close', (code, buffer) => { const reason = new TextDecoder().decode(buffer) console.log("WebSocket closed (reason: %o)", reason); }); while (true) { if (isGenerationStopped) { console.error('Streaming stopped by user. Closing websocket...'); websocket.close(); return; } let rawMessage = null; try { // This lunacy is because the websocket can fail to connect AFTER we're awaiting 'message'... so 'message' never triggers. // So instead we need to look for 'error' at the same time to reject the promise. And then remove the listener if we resolve. // This is awful. // Welcome to the shenanigan shack. rawMessage = await new Promise(function (resolve, reject) { websocket.once('error', reject); websocket.once('message', (data, isBinary) => { websocket.removeListener('error', reject); resolve(data, isBinary); }); }); } catch (err) { console.error("Socket error:", err); websocket.close(); yield "[SillyTavern] Streaming failed:\n" + err; return; } const message = json5.parse(rawMessage); switch (message.event) { case 'text_stream': yield message.text; break; case 'stream_end': websocket.close(); return; } } } let reply = ''; try { for await (const text of readWebsocket()) { if (typeof text !== 'string') { break; } let newText = text; if (!newText) { continue; } reply += text; response_generate.write(newText); } console.log(reply); } finally { response_generate.end(); } } else { const args = { body: JSON.stringify(request.body), headers: { "Content-Type": "application/json" }, signal: controller.signal, }; if (request.body.use_mancer) { args.headers = Object.assign(args.headers, get_mancer_headers()); } try { const data = await postAsync(api_server + "/v1/generate", args); console.log("Endpoint response:", data); return response_generate.send(data); } catch (error) { retval = { error: true, status: error.status, response: error.statusText }; console.log("Endpoint error:", error); try { retval.response = await error.json(); retval.response = retval.response.result; } catch { } return response_generate.send(retval); } } }); app.post("/savechat", jsonParser, function (request, response) { try { var dir_name = String(request.body.avatar_url).replace('.png', ''); let chat_data = request.body.chat; let jsonlData = chat_data.map(JSON.stringify).join('\n'); writeFileAtomicSync(`${chatsPath + sanitize(dir_name)}/${sanitize(String(request.body.file_name))}.jsonl`, jsonlData, 'utf8'); return response.send({ result: "ok" }); } catch (error) { response.send(error); return console.log(error); } }); app.post("/getchat", jsonParser, function (request, response) { try { const dirName = String(request.body.avatar_url).replace('.png', ''); const chatDirExists = fs.existsSync(chatsPath + dirName); //if no chat dir for the character is found, make one with the character name if (!chatDirExists) { fs.mkdirSync(chatsPath + dirName); return response.send({}); } if (!request.body.file_name) { return response.send({}); } const fileName = `${chatsPath + dirName}/${sanitize(String(request.body.file_name))}.jsonl`; const chatFileExists = fs.existsSync(fileName); if (!chatFileExists) { return response.send({}); } const data = fs.readFileSync(fileName, 'utf8'); const lines = data.split('\n'); // Iterate through the array of strings and parse each line as JSON const jsonData = lines.map(tryParse).filter(x => x); return response.send(jsonData); } catch (error) { console.error(error); return response.send({}); } }); app.post("/getstatus", jsonParser, async function (request, response_getstatus = response) { if (!request.body) return response_getstatus.sendStatus(400); api_server = request.body.api_server; main_api = request.body.main_api; if (api_server.indexOf('localhost') != -1) { api_server = api_server.replace('localhost', '127.0.0.1'); } var args = { headers: { "Content-Type": "application/json" } }; if (main_api == 'textgenerationwebui' && request.body.use_mancer) { args.headers = Object.assign(args.headers, get_mancer_headers()); } var url = api_server + "/v1/model"; let version = ''; let koboldVersion = {}; if (main_api == "kobold") { try { version = (await getAsync(api_server + "/v1/info/version")).result; } catch { version = '0.0.0'; } try { koboldVersion = (await getAsync(api_server + "/extra/version")); } catch { koboldVersion = { result: 'Kobold', version: '0.0', }; } } client.get(url, args, async function (data, response) { if (typeof data !== 'object') { data = {}; } if (response.statusCode == 200) { data.version = version; data.koboldVersion = koboldVersion; if (data.result == "ReadOnly") { data.result = "no_connection"; } } else { data.response = data.result; data.result = "no_connection"; } response_getstatus.send(data); }).on('error', function () { response_getstatus.send({ result: "no_connection" }); }); }); function getVersion() { let pkgVersion = 'UNKNOWN'; let gitRevision = null; let gitBranch = null; try { const pkgJson = require('./package.json'); pkgVersion = pkgJson.version; if (!process.pkg && commandExistsSync('git')) { gitRevision = require('child_process') .execSync('git rev-parse --short HEAD', { cwd: process.cwd(), stdio: ['ignore', 'pipe', 'ignore'] }) .toString().trim(); gitBranch = require('child_process') .execSync('git rev-parse --abbrev-ref HEAD', { cwd: process.cwd(), stdio: ['ignore', 'pipe', 'ignore'] }) .toString().trim(); } } catch { // suppress exception } const agent = `SillyTavern:${pkgVersion}:Cohee#1207`; return { agent, pkgVersion, gitRevision, gitBranch }; } function tryParse(str) { try { return json5.parse(str); } catch { return undefined; } } function convertToV2(char) { // Simulate incoming data from frontend form const result = charaFormatData({ json_data: JSON.stringify(char), ch_name: char.name, description: char.description, personality: char.personality, scenario: char.scenario, first_mes: char.first_mes, mes_example: char.mes_example, creator_notes: char.creatorcomment, talkativeness: char.talkativeness, fav: char.fav, creator: char.creator, tags: char.tags, }); result.chat = char.chat ?? humanizedISO8601DateTime(); result.create_date = char.create_date; return result; } function unsetFavFlag(char) { const _ = require('lodash'); _.set(char, 'fav', false); _.set(char, 'data.extensions.fav', false); } function readFromV2(char) { const _ = require('lodash'); if (_.isUndefined(char.data)) { console.warn('Spec v2 data missing'); return char; } const fieldMappings = { name: 'name', description: 'description', personality: 'personality', scenario: 'scenario', first_mes: 'first_mes', mes_example: 'mes_example', talkativeness: 'extensions.talkativeness', fav: 'extensions.fav', tags: 'tags', }; _.forEach(fieldMappings, (v2Path, charField) => { //console.log(`Migrating field: ${charField} from ${v2Path}`); const v2Value = _.get(char.data, v2Path); if (_.isUndefined(v2Value)) { let defaultValue = undefined; // Backfill default values for missing ST extension fields if (v2Path === 'extensions.talkativeness') { defaultValue = 0.5; } if (v2Path === 'extensions.fav') { defaultValue = false; } if (!_.isUndefined(defaultValue)) { //console.debug(`Spec v2 extension data missing for field: ${charField}, using default value: ${defaultValue}`); char[charField] = defaultValue; } else { console.debug(`Spec v2 data missing for unknown field: ${charField}`); return; } } if (!_.isUndefined(char[charField]) && !_.isUndefined(v2Value) && String(char[charField]) !== String(v2Value)) { console.debug(`Spec v2 data mismatch with Spec v1 for field: ${charField}`, char[charField], v2Value); } char[charField] = v2Value; }); char['chat'] = char['chat'] ?? humanizedISO8601DateTime(); return char; } //***************** Main functions function charaFormatData(data) { // This is supposed to save all the foreign keys that ST doesn't care about const _ = require('lodash'); const char = tryParse(data.json_data) || {}; // This function uses _.cond() to create a series of conditional checks that return the desired output based on the input data. // It checks if data.alternate_greetings is an array, a string, or neither, and acts accordingly. const getAlternateGreetings = data => _.cond([ [d => Array.isArray(d.alternate_greetings), d => d.alternate_greetings], [d => typeof d.alternate_greetings === 'string', d => [d.alternate_greetings]], [_.stubTrue, _.constant([])] ])(data); // Spec V1 fields _.set(char, 'name', data.ch_name); _.set(char, 'description', data.description || ''); _.set(char, 'personality', data.personality || ''); _.set(char, 'scenario', data.scenario || ''); _.set(char, 'first_mes', data.first_mes || ''); _.set(char, 'mes_example', data.mes_example || ''); // Old ST extension fields (for backward compatibility, will be deprecated) _.set(char, 'creatorcomment', data.creator_notes); _.set(char, 'avatar', 'none'); _.set(char, 'chat', data.ch_name + ' - ' + humanizedISO8601DateTime()); _.set(char, 'talkativeness', data.talkativeness); _.set(char, 'fav', data.fav == 'true'); _.set(char, 'create_date', humanizedISO8601DateTime()); // Spec V2 fields _.set(char, 'spec', 'chara_card_v2'); _.set(char, 'spec_version', '2.0'); _.set(char, 'data.name', data.ch_name); _.set(char, 'data.description', data.description || ''); _.set(char, 'data.personality', data.personality || ''); _.set(char, 'data.scenario', data.scenario || ''); _.set(char, 'data.first_mes', data.first_mes || ''); _.set(char, 'data.mes_example', data.mes_example || ''); // New V2 fields _.set(char, 'data.creator_notes', data.creator_notes || ''); _.set(char, 'data.system_prompt', data.system_prompt || ''); _.set(char, 'data.post_history_instructions', data.post_history_instructions || ''); _.set(char, 'data.tags', typeof data.tags == 'string' ? (data.tags.split(',').map(x => x.trim()).filter(x => x)) : data.tags || []); _.set(char, 'data.creator', data.creator || ''); _.set(char, 'data.character_version', data.character_version || ''); _.set(char, 'data.alternate_greetings', getAlternateGreetings(data)); // ST extension fields to V2 object _.set(char, 'data.extensions.talkativeness', data.talkativeness); _.set(char, 'data.extensions.fav', data.fav == 'true'); _.set(char, 'data.extensions.world', data.world || ''); //_.set(char, 'data.extensions.create_date', humanizedISO8601DateTime()); //_.set(char, 'data.extensions.avatar', 'none'); //_.set(char, 'data.extensions.chat', data.ch_name + ' - ' + humanizedISO8601DateTime()); if (data.world) { try { const file = readWorldInfoFile(data.world); // File was imported - save it to the character book if (file && file.originalData) { _.set(char, 'data.character_book', file.originalData); } // File was not imported - convert the world info to the character book if (file && file.entries) { _.set(char, 'data.character_book', convertWorldInfoToCharacterBook(data.world, file.entries)); } } catch { console.debug(`Failed to read world info file: ${data.world}. Character book will not be available.`); } } return char; } app.post("/createcharacter", urlencodedParser, async function (request, response) { if (!request.body) return response.sendStatus(400); request.body.ch_name = sanitize(request.body.ch_name); const char = JSON.stringify(charaFormatData(request.body)); const internalName = getPngName(request.body.ch_name); const avatarName = `${internalName}.png`; const defaultAvatar = './public/img/ai4.png'; const chatsPath = directories.chats + internalName; //path.join(chatsPath, internalName); if (!fs.existsSync(chatsPath)) fs.mkdirSync(chatsPath); if (!request.file) { charaWrite(defaultAvatar, char, internalName, response, avatarName); } else { const crop = tryParse(request.query.crop); const uploadPath = path.join(UPLOADS_PATH, request.file.filename); await charaWrite(uploadPath, char, internalName, response, avatarName, crop); fs.unlinkSync(uploadPath); } }); app.post('/renamechat', jsonParser, async function (request, response) { if (!request.body || !request.body.original_file || !request.body.renamed_file) { return response.sendStatus(400); } const pathToFolder = request.body.is_group ? directories.groupChats : path.join(directories.chats, String(request.body.avatar_url).replace('.png', '')); const pathToOriginalFile = path.join(pathToFolder, request.body.original_file); const pathToRenamedFile = path.join(pathToFolder, request.body.renamed_file); console.log('Old chat name', pathToOriginalFile); console.log('New chat name', pathToRenamedFile); if (!fs.existsSync(pathToOriginalFile) || fs.existsSync(pathToRenamedFile)) { console.log('Either Source or Destination files are not available'); return response.status(400).send({ error: true }); } console.log('Successfully renamed.'); fs.renameSync(pathToOriginalFile, pathToRenamedFile); return response.send({ ok: true }); }); app.post("/renamecharacter", jsonParser, async function (request, response) { if (!request.body.avatar_url || !request.body.new_name) { return response.sendStatus(400); } const oldAvatarName = request.body.avatar_url; const newName = sanitize(request.body.new_name); const oldInternalName = path.parse(request.body.avatar_url).name; const newInternalName = getPngName(newName); const newAvatarName = `${newInternalName}.png`; const oldAvatarPath = path.join(charactersPath, oldAvatarName); const oldChatsPath = path.join(chatsPath, oldInternalName); const newChatsPath = path.join(chatsPath, newInternalName); try { const _ = require('lodash'); // Read old file, replace name int it const rawOldData = await charaRead(oldAvatarPath); const oldData = getCharaCardV2(json5.parse(rawOldData)); _.set(oldData, 'data.name', newName); _.set(oldData, 'name', newName); const newData = JSON.stringify(oldData); // Write data to new location await charaWrite(oldAvatarPath, newData, newInternalName); // Rename chats folder if (fs.existsSync(oldChatsPath) && !fs.existsSync(newChatsPath)) { fs.renameSync(oldChatsPath, newChatsPath); } // Remove the old character file fs.rmSync(oldAvatarPath); // Return new avatar name to ST return response.send({ 'avatar': newAvatarName }); } catch (err) { console.error(err); return response.sendStatus(500); } }); app.post("/editcharacter", urlencodedParser, async function (request, response) { if (!request.body) { console.error('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.'); response.status(400).send('Error: invalid name.'); return; } let char = charaFormatData(request.body); char.chat = request.body.chat; char.create_date = request.body.create_date; char = JSON.stringify(char); let target_img = (request.body.avatar_url).replace('.png', ''); try { if (!request.file) { const avatarPath = path.join(charactersPath, request.body.avatar_url); await charaWrite(avatarPath, char, target_img, response, 'Character saved'); } else { const crop = tryParse(request.query.crop); const newAvatarPath = path.join(UPLOADS_PATH, request.file.filename); invalidateThumbnail('avatar', request.body.avatar_url); await charaWrite(newAvatarPath, char, target_img, response, 'Character saved', crop); fs.unlinkSync(newAvatarPath); } } catch { console.error('An error occured, character edit invalidated.'); } }); /** * Handle a POST request to edit a character attribute. * * This function reads the character data from a file, updates the specified attribute, * and writes the updated data back to the file. * * @param {Object} request - The HTTP request object. * @param {Object} response - The HTTP response object. * @returns {void} */ app.post("/editcharacterattribute", jsonParser, async function (request, response) { console.log(request.body); if (!request.body) { console.error('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.'); response.status(400).send('Error: invalid name.'); return; } try { const avatarPath = path.join(charactersPath, request.body.avatar_url); charaRead(avatarPath).then((char) => { char = JSON.parse(char); //check if the field exists if (char[request.body.field] === undefined && char.data[request.body.field] === undefined) { console.error('Error: invalid field.'); response.status(400).send('Error: invalid field.'); return; } char[request.body.field] = request.body.value; char.data[request.body.field] = request.body.value; char = JSON.stringify(char); return { char }; }).then(({ char }) => { charaWrite(avatarPath, char, (request.body.avatar_url).replace('.png', ''), response, 'Character saved'); }).catch((err) => { console.error('An error occured, character edit invalidated.', err); }); } catch { console.error('An error occured, character edit invalidated.'); } }); app.post("/deletecharacter", jsonParser, async function (request, response) { if (!request.body || !request.body.avatar_url) { return response.sendStatus(400); } if (request.body.avatar_url !== sanitize(request.body.avatar_url)) { console.error('Malicious filename prevented'); return response.sendStatus(403); } const avatarPath = charactersPath + request.body.avatar_url; if (!fs.existsSync(avatarPath)) { return response.sendStatus(400); } fs.rmSync(avatarPath); invalidateThumbnail('avatar', request.body.avatar_url); let dir_name = (request.body.avatar_url.replace('.png', '')); if (!dir_name.length) { console.error('Malicious dirname prevented'); return response.sendStatus(403); } if (request.body.delete_chats == true) { try { await fs.promises.rm(path.join(chatsPath, sanitize(dir_name)), { recursive: true, force: true }) } catch (err) { console.error(err); return response.sendStatus(500); } } return response.sendStatus(200); }); async function charaWrite(img_url, data, target_img, response = undefined, mes = 'ok', crop = undefined) { try { // Read the image, resize, and save it as a PNG into the buffer const image = await tryReadImage(img_url, crop); // Get the chunks const chunks = extract(image); const tEXtChunks = chunks.filter(chunk => chunk.create_date === 'tEXt' || chunk.name === 'tEXt'); // Remove all existing tEXt chunks for (let tEXtChunk of tEXtChunks) { chunks.splice(chunks.indexOf(tEXtChunk), 1); } // Add new chunks before the IEND chunk const base64EncodedData = Buffer.from(data, 'utf8').toString('base64'); chunks.splice(-1, 0, PNGtext.encode('chara', base64EncodedData)); //chunks.splice(-1, 0, text.encode('lorem', 'ipsum')); writeFileAtomicSync(charactersPath + target_img + '.png', new Buffer.from(encode(chunks))); if (response !== undefined) response.send(mes); return true; } catch (err) { console.log(err); if (response !== undefined) response.status(500).send(err); return false; } } async function tryReadImage(img_url, crop) { try { let rawImg = await jimp.read(img_url); let final_width = rawImg.bitmap.width, final_height = rawImg.bitmap.height // Apply crop if defined if (typeof crop == 'object' && [crop.x, crop.y, crop.width, crop.height].every(x => typeof x === 'number')) { rawImg = rawImg.crop(crop.x, crop.y, crop.width, crop.height); // Apply standard resize if requested if (crop.want_resize) { final_width = AVATAR_WIDTH final_height = AVATAR_HEIGHT } } const image = await rawImg.cover(final_width, final_height).getBufferAsync(jimp.MIME_PNG); return image; } // If it's an unsupported type of image (APNG) - just read the file as buffer catch { return fs.readFileSync(img_url); } } async function charaRead(img_url, input_format) { return characterCardParser.parse(img_url, input_format); } /** * calculateChatSize - Calculates the total chat size for a given character. * * @param {string} charDir The directory where the chats are stored. * @return {number} The total chat size. */ const calculateChatSize = (charDir) => { let chatSize = 0; let dateLastChat = 0; if (fs.existsSync(charDir)) { const chats = fs.readdirSync(charDir); if (Array.isArray(chats) && chats.length) { for (const chat of chats) { const chatStat = fs.statSync(path.join(charDir, chat)); chatSize += chatStat.size; dateLastChat = Math.max(dateLastChat, chatStat.mtimeMs); } } } return { chatSize, dateLastChat }; } // Calculate the total string length of the data object const calculateDataSize = (data) => { return typeof data === 'object' ? Object.values(data).reduce((acc, val) => acc + new String(val).length, 0) : 0; } /** * processCharacter - Process a given character, read its data and calculate its statistics. * * @param {string} item The name of the character. * @param {number} i The index of the character in the characters list. * @return {Promise} A Promise that resolves when the character processing is done. */ const processCharacter = async (item, i) => { try { const img_data = await charaRead(charactersPath + item); let jsonObject = getCharaCardV2(json5.parse(img_data)); jsonObject.avatar = item; characters[i] = jsonObject; characters[i]['json_data'] = img_data; const charStat = fs.statSync(path.join(charactersPath, item)); characters[i]['date_added'] = charStat.birthtimeMs; const char_dir = path.join(chatsPath, item.replace('.png', '')); const { chatSize, dateLastChat } = calculateChatSize(char_dir); characters[i]['chat_size'] = chatSize; characters[i]['date_last_chat'] = dateLastChat; characters[i]['data_size'] = calculateDataSize(jsonObject?.data); } catch (err) { characters[i] = { date_added: 0, date_last_chat: 0, chat_size: 0 }; console.log(`Could not process character: ${item}`); if (err instanceof SyntaxError) { console.log("String [" + i + "] is not valid JSON!"); } else { console.log("An unexpected error occurred: ", err); } } } /** * HTTP POST endpoint for the "/getcharacters" route. * * This endpoint is responsible for reading character files from the `charactersPath` directory, * parsing character data, calculating stats for each character and responding with the data. * Stats are calculated only on the first run, on subsequent runs the stats are fetched from * the `charStats` variable. * The stats are calculated by the `calculateStats` function. * The characters are processed by the `processCharacter` function. * * @param {object} request The HTTP request object. * @param {object} response The HTTP response object. * @return {undefined} Does not return a value. */ app.post("/getcharacters", jsonParser, function (request, response) { fs.readdir(charactersPath, async (err, files) => { if (err) { console.error(err); return; } const pngFiles = files.filter(file => file.endsWith('.png')); characters = {}; let processingPromises = pngFiles.map((file, index) => processCharacter(file, index)); await Promise.all(processingPromises); performance.mark('B'); response.send(JSON.stringify(characters)); }); }); app.post("/getonecharacter", jsonParser, async function (request, response) { if (!request.body) return response.sendStatus(400); const item = request.body.avatar_url; const filePath = path.join(charactersPath, item); if (!fs.existsSync(filePath)) { return response.sendStatus(404); } characters = {}; await processCharacter(item, 0); return response.send(characters[0]); }); /** * Handle a POST request to get the stats object * * This function returns the stats object that was calculated by the `calculateStats` function. * * * @param {Object} request - The HTTP request object. * @param {Object} response - The HTTP response object. * @returns {void} */ app.post("/getstats", jsonParser, function (request, response) { response.send(JSON.stringify(statsHelpers.getCharStats())); }); /** * Handle a POST request to update the stats object * * This function updates the stats object with the data from the request body. * * @param {Object} request - The HTTP request object. * @param {Object} response - The HTTP response object. * @returns {void} * */ app.post("/updatestats", jsonParser, function (request, response) { if (!request.body) return response.sendStatus(400); statsHelpers.setCharStats(request.body); return response.sendStatus(200); }); app.post("/getbackgrounds", jsonParser, function (request, response) { var images = getImages("public/backgrounds"); response.send(JSON.stringify(images)); }); app.post("/iscolab", jsonParser, function (request, response) { let send_data = false; if (is_colab) { send_data = String(process.env.colaburl).trim(); } response.send({ colaburl: send_data }); }); app.post("/getuseravatars", jsonParser, function (request, response) { var images = getImages("public/User Avatars"); response.send(JSON.stringify(images)); }); app.post('/deleteuseravatar', jsonParser, function (request, response) { if (!request.body) return response.sendStatus(400); if (request.body.avatar !== sanitize(request.body.avatar)) { console.error('Malicious avatar name prevented'); return response.sendStatus(403); } const fileName = path.join(directories.avatars, sanitize(request.body.avatar)); if (fs.existsSync(fileName)) { fs.rmSync(fileName); return response.send({ result: 'ok' }); } return response.sendStatus(404); }); app.post("/setbackground", jsonParser, function (request, response) { try { const bg = `#bg1 {background-image: url('../backgrounds/${request.body.bg}');}`; writeFileAtomicSync('public/css/bg_load.css', bg, 'utf8'); response.send({ result: 'ok' }); } catch (err) { console.log(err); response.send(err); } }); app.post("/delbackground", jsonParser, function (request, response) { if (!request.body) return response.sendStatus(400); if (request.body.bg !== sanitize(request.body.bg)) { console.error('Malicious bg name prevented'); return response.sendStatus(403); } const fileName = path.join('public/backgrounds/', sanitize(request.body.bg)); if (!fs.existsSync(fileName)) { console.log('BG file not found'); return response.sendStatus(400); } fs.rmSync(fileName); invalidateThumbnail('bg', request.body.bg); return response.send('ok'); }); app.post("/delchat", jsonParser, function (request, response) { console.log('/delchat entered'); if (!request.body) { console.log('no request body seen'); return response.sendStatus(400); } if (request.body.chatfile !== sanitize(request.body.chatfile)) { console.error('Malicious chat name prevented'); return response.sendStatus(403); } const dirName = String(request.body.avatar_url).replace('.png', ''); const fileName = `${chatsPath + dirName}/${sanitize(String(request.body.chatfile))}`; const chatFileExists = fs.existsSync(fileName); if (!chatFileExists) { console.log(`Chat file not found '${fileName}'`); return response.sendStatus(400); } else { console.log('found the chat file: ' + fileName); /* fs.unlinkSync(fileName); */ fs.rmSync(fileName); console.log('deleted chat file: ' + fileName); } return response.send('ok'); }); app.post('/renamebackground', jsonParser, function (request, response) { if (!request.body) return response.sendStatus(400); const oldFileName = path.join('public/backgrounds/', sanitize(request.body.old_bg)); const newFileName = path.join('public/backgrounds/', sanitize(request.body.new_bg)); if (!fs.existsSync(oldFileName)) { console.log('BG file not found'); return response.sendStatus(400); } if (fs.existsSync(newFileName)) { console.log('New BG file already exists'); return response.sendStatus(400); } fs.renameSync(oldFileName, newFileName); invalidateThumbnail('bg', request.body.old_bg); return response.send('ok'); }); app.post("/downloadbackground", urlencodedParser, function (request, response) { response_dw_bg = response; if (!request.body || !request.file) return response.sendStatus(400); const img_path = path.join(UPLOADS_PATH, request.file.filename); const filename = request.file.originalname; try { fs.copyFileSync(img_path, path.join('public/backgrounds/', filename)); invalidateThumbnail('bg', filename); response_dw_bg.send(filename); fs.unlinkSync(img_path); } catch (err) { console.error(err); response_dw_bg.sendStatus(500); } }); app.post("/savesettings", jsonParser, function (request, response) { try { writeFileAtomicSync('public/settings.json', JSON.stringify(request.body, null, 4), 'utf8'); response.send({ result: "ok" }); } catch (err) { console.log(err); response.send(err); } }); function getCharaCardV2(jsonObject) { if (jsonObject.spec === undefined) { jsonObject = convertToV2(jsonObject); } else { jsonObject = readFromV2(jsonObject); } return jsonObject; } function readAndParseFromDirectory(directoryPath, fileExtension = '.json') { const files = fs .readdirSync(directoryPath) .filter(x => path.parse(x).ext == fileExtension) .sort(); const parsedFiles = []; files.forEach(item => { try { const file = fs.readFileSync(path.join(directoryPath, item), 'utf-8'); parsedFiles.push(fileExtension == '.json' ? json5.parse(file) : file); } catch { // skip } }); return parsedFiles; } function sortByModifiedDate(directory) { return (a, b) => new Date(fs.statSync(`${directory}/${b}`).mtime) - new Date(fs.statSync(`${directory}/${a}`).mtime); } function sortByName(_) { return (a, b) => a.localeCompare(b); } function readPresetsFromDirectory(directoryPath, options = {}) { const { sortFunction, removeFileExtension = false } = options; const files = fs.readdirSync(directoryPath).sort(sortFunction); const fileContents = []; const fileNames = []; files.forEach(item => { try { const file = fs.readFileSync(path.join(directoryPath, item), 'utf8'); json5.parse(file); fileContents.push(file); fileNames.push(removeFileExtension ? item.replace(/\.[^/.]+$/, '') : item); } catch { // skip console.log(`${item} is not a valid JSON`); } }); return { fileContents, fileNames }; } // Wintermute's code app.post('/getsettings', jsonParser, (request, response) => { const settings = fs.readFileSync('public/settings.json', 'utf8', (err, data) => { if (err) return response.sendStatus(500); return data; }); // NovelAI Settings const { fileContents: novelai_settings, fileNames: novelai_setting_names } = readPresetsFromDirectory(directories.novelAI_Settings, { sortFunction: sortByName(directories.novelAI_Settings), removeFileExtension: true }); // OpenAI Settings const { fileContents: openai_settings, fileNames: openai_setting_names } = readPresetsFromDirectory(directories.openAI_Settings, { sortFunction: sortByModifiedDate(directories.openAI_Settings), removeFileExtension: true }); // TextGenerationWebUI Settings const { fileContents: textgenerationwebui_presets, fileNames: textgenerationwebui_preset_names } = readPresetsFromDirectory(directories.textGen_Settings, { sortFunction: sortByName(directories.textGen_Settings), removeFileExtension: true }); //Kobold const { fileContents: koboldai_settings, fileNames: koboldai_setting_names } = readPresetsFromDirectory(directories.koboldAI_Settings, { sortFunction: sortByName(directories.koboldAI_Settings), removeFileExtension: true }) const worldFiles = fs .readdirSync(directories.worlds) .filter(file => path.extname(file).toLowerCase() === '.json') .sort((a, b) => a < b); const world_names = worldFiles.map(item => path.parse(item).name); const themes = readAndParseFromDirectory(directories.themes); const movingUIPresets = readAndParseFromDirectory(directories.movingUI); const quickReplyPresets = readAndParseFromDirectory(directories.quickreplies); const instruct = readAndParseFromDirectory(directories.instruct); const context = readAndParseFromDirectory(directories.context); response.send({ settings, koboldai_settings, koboldai_setting_names, world_names, novelai_settings, novelai_setting_names, openai_settings, openai_setting_names, textgenerationwebui_presets, textgenerationwebui_preset_names, themes, movingUIPresets, quickReplyPresets, instruct, context, enable_extensions: enableExtensions, }); }); app.post('/getworldinfo', jsonParser, (request, response) => { if (!request.body?.name) { return response.sendStatus(400); } const file = readWorldInfoFile(request.body.name); return response.send(file); }); app.post('/deleteworldinfo', jsonParser, (request, response) => { if (!request.body?.name) { return response.sendStatus(400); } const worldInfoName = request.body.name; const filename = sanitize(`${worldInfoName}.json`); const pathToWorldInfo = path.join(directories.worlds, filename); if (!fs.existsSync(pathToWorldInfo)) { throw new Error(`World info file ${filename} doesn't exist.`); } fs.rmSync(pathToWorldInfo); return response.sendStatus(200); }); app.post('/savetheme', jsonParser, (request, response) => { if (!request.body || !request.body.name) { return response.sendStatus(400); } const filename = path.join(directories.themes, sanitize(request.body.name) + '.json'); writeFileAtomicSync(filename, JSON.stringify(request.body, null, 4), 'utf8'); return response.sendStatus(200); }); app.post('/savemovingui', jsonParser, (request, response) => { if (!request.body || !request.body.name) { return response.sendStatus(400); } const filename = path.join(directories.movingUI, sanitize(request.body.name) + '.json'); writeFileAtomicSync(filename, JSON.stringify(request.body, null, 4), 'utf8'); return response.sendStatus(200); }); app.post('/savequickreply', jsonParser, (request, response) => { if (!request.body || !request.body.name) { return response.sendStatus(400); } const filename = path.join(directories.quickreplies, sanitize(request.body.name) + '.json'); writeFileAtomicSync(filename, JSON.stringify(request.body, null, 4), 'utf8'); return response.sendStatus(200); }); function convertWorldInfoToCharacterBook(name, entries) { const result = { entries: [], name }; for (const index in entries) { const entry = entries[index]; const originalEntry = { id: entry.uid, keys: entry.key, secondary_keys: entry.keysecondary, comment: entry.comment, content: entry.content, constant: entry.constant, selective: entry.selective, insertion_order: entry.order, enabled: !entry.disable, position: entry.position == 0 ? 'before_char' : 'after_char', extensions: { position: entry.position, exclude_recursion: entry.excludeRecursion, display_index: entry.displayIndex, probability: entry.probability ?? null, useProbability: entry.useProbability ?? false, } }; result.entries.push(originalEntry); } return result; } function readWorldInfoFile(worldInfoName) { if (!worldInfoName) { return { entries: {} }; } const filename = `${worldInfoName}.json`; const pathToWorldInfo = path.join(directories.worlds, filename); if (!fs.existsSync(pathToWorldInfo)) { throw new Error(`World info file ${filename} doesn't exist.`); } const worldInfoText = fs.readFileSync(pathToWorldInfo, 'utf8'); const worldInfo = json5.parse(worldInfoText); return worldInfo; } function getImages(path) { return fs .readdirSync(path) .filter(file => { const type = mime.lookup(file); return type && type.startsWith('image/'); }) .sort(Intl.Collator().compare); } //***********Novel.ai API app.post("/getstatus_novelai", jsonParser, function (request, response_getstatus_novel = response) { if (!request.body) return response_getstatus_novel.sendStatus(400); const api_key_novel = readSecret(SECRET_KEYS.NOVEL); if (!api_key_novel) { return response_getstatus_novel.sendStatus(401); } var data = {}; var args = { data: data, headers: { "Content-Type": "application/json", "Authorization": "Bearer " + api_key_novel } }; client.get(api_novelai + "/user/subscription", args, function (data, response) { if (response.statusCode == 200) { //console.log(data); response_getstatus_novel.send(data);//data); } else { if (response.statusCode == 401) { console.log('Access Token is incorrect.'); } console.log(data); response_getstatus_novel.send({ error: true }); } }).on('error', function () { response_getstatus_novel.send({ error: true }); }); }); app.post("/generate_novelai", jsonParser, async function (request, response_generate_novel = response) { if (!request.body) return response_generate_novel.sendStatus(400); const api_key_novel = readSecret(SECRET_KEYS.NOVEL); if (!api_key_novel) { return response_generate_novel.sendStatus(401); } const controller = new AbortController(); request.socket.removeAllListeners('close'); request.socket.on('close', function () { controller.abort(); }); const novelai = require('./src/novelai'); const isNewModel = (request.body.model.includes('clio') || request.body.model.includes('kayra')); const isKrake = request.body.model.includes('krake'); const badWordsList = (isNewModel ? novelai.badWordsList : (isKrake ? novelai.krakeBadWordsList : novelai.euterpeBadWordsList)).slice(); // Add customized bad words for Clio and Kayra if (isNewModel && Array.isArray(request.body.bad_words_ids)) { for (const badWord of request.body.bad_words_ids) { if (Array.isArray(badWord) && badWord.every(x => Number.isInteger(x))) { badWordsList.push(badWord); } } } // Add default biases for dinkus and asterism const logit_bias_exp = isNewModel ? novelai.logitBiasExp.slice() : null; if (Array.isArray(logit_bias_exp) && Array.isArray(request.body.logit_bias_exp)) { logit_bias_exp.push(...request.body.logit_bias_exp); } const data = { "input": request.body.input, "model": request.body.model, "parameters": { "use_string": request.body.use_string, "temperature": request.body.temperature, "max_length": request.body.max_length, "min_length": request.body.min_length, "tail_free_sampling": request.body.tail_free_sampling, "repetition_penalty": request.body.repetition_penalty, "repetition_penalty_range": request.body.repetition_penalty_range, "repetition_penalty_slope": request.body.repetition_penalty_slope, "repetition_penalty_frequency": request.body.repetition_penalty_frequency, "repetition_penalty_presence": request.body.repetition_penalty_presence, "repetition_penalty_whitelist": isNewModel ? novelai.repPenaltyAllowList : null, "top_a": request.body.top_a, "top_p": request.body.top_p, "top_k": request.body.top_k, "typical_p": request.body.typical_p, "mirostat_lr": request.body.mirostat_lr, "mirostat_tau": request.body.mirostat_tau, "cfg_scale": request.body.cfg_scale, "cfg_uc": request.body.cfg_uc, "phrase_rep_pen": request.body.phrase_rep_pen, "stop_sequences": request.body.stop_sequences, "bad_words_ids": badWordsList, "logit_bias_exp": logit_bias_exp, "generate_until_sentence": request.body.generate_until_sentence, "use_cache": request.body.use_cache, "use_string": true, "return_full_text": request.body.return_full_text, "prefix": request.body.prefix, "order": request.body.order } }; const util = require('util'); console.log(util.inspect(data, { depth: 4 })) const args = { body: JSON.stringify(data), headers: { "Content-Type": "application/json", "Authorization": "Bearer " + api_key_novel }, signal: controller.signal, }; try { const fetch = require('node-fetch').default; const url = request.body.streaming ? `${api_novelai}/ai/generate-stream` : `${api_novelai}/ai/generate`; const response = await fetch(url, { method: 'POST', timeout: 0, ...args }); if (request.body.streaming) { // Pipe remote SSE stream to Express response response.body.pipe(response_generate_novel); request.socket.on('close', function () { response.body.destroy(); // Close the remote stream response_generate_novel.end(); // End the Express response }); response.body.on('end', function () { console.log("Streaming request finished"); response_generate_novel.end(); }); } else { if (!response.ok) { const text = await response.text(); let message = text; console.log(`Novel API returned error: ${response.status} ${response.statusText} ${text}`); try { const data = JSON.parse(text); message = data.message; } catch { // ignore } return response_generate_novel.status(response.status).send({ error: { message } }); } const data = await response.json(); console.log(data); return response_generate_novel.send(data); } } catch (error) { return response_generate_novel.send({ error: true }); } }); app.post("/getallchatsofcharacter", jsonParser, function (request, response) { if (!request.body) return response.sendStatus(400); var char_dir = (request.body.avatar_url).replace('.png', '') fs.readdir(chatsPath + char_dir, (err, files) => { if (err) { console.log('found error in history loading'); console.error(err); response.send({ error: true }); return; } // filter for JSON files const jsonFiles = files.filter(file => path.extname(file) === '.jsonl'); // sort the files by name //jsonFiles.sort().reverse(); // print the sorted file names var chatData = {}; let ii = jsonFiles.length; //this is the number of files belonging to the character if (ii !== 0) { //console.log('found '+ii+' chat logs to load'); for (let i = jsonFiles.length - 1; i >= 0; i--) { const file = jsonFiles[i]; const fileStream = fs.createReadStream(chatsPath + char_dir + '/' + file); const fullPathAndFile = chatsPath + char_dir + '/' + file const stats = fs.statSync(fullPathAndFile); const fileSizeInKB = (stats.size / 1024).toFixed(2) + "kb"; //console.log(fileSizeInKB); const rl = readline.createInterface({ input: fileStream, crlfDelay: Infinity }); let lastLine; let itemCounter = 0; rl.on('line', (line) => { itemCounter++; lastLine = line; }); rl.on('close', () => { ii--; if (lastLine) { let jsonData = tryParse(lastLine); if (jsonData && (jsonData.name !== undefined || jsonData.character_name !== undefined)) { chatData[i] = {}; chatData[i]['file_name'] = file; chatData[i]['file_size'] = fileSizeInKB; chatData[i]['chat_items'] = itemCounter - 1; chatData[i]['mes'] = jsonData['mes'] || '[The chat is empty]'; chatData[i]['last_mes'] = jsonData['send_date'] || Date.now(); } else { console.log('Found an invalid or corrupted chat file: ' + fullPathAndFile); } } if (ii === 0) { //console.log('ii count went to zero, responding with chatData'); response.send(chatData); } //console.log('successfully closing getallchatsofcharacter'); rl.close(); }); }; } else { //console.log('Found No Chats. Exiting Load Routine.'); response.send({ error: true }); }; }) }); function getPngName(file) { let i = 1; let base_name = file; while (fs.existsSync(charactersPath + file + '.png')) { file = base_name + i; i++; } return file; } app.post("/importcharacter", urlencodedParser, async function (request, response) { if (!request.body) return response.sendStatus(400); let png_name = ''; let filedata = request.file; let uploadPath = path.join(UPLOADS_PATH, filedata.filename); var format = request.body.file_type; const defaultAvatarPath = './public/img/ai4.png'; //console.log(format); if (filedata) { if (format == 'json') { fs.readFile(uploadPath, 'utf8', async (err, data) => { fs.unlinkSync(uploadPath); if (err) { console.log(err); response.send({ error: true }); } let jsonData = json5.parse(data); if (jsonData.spec !== undefined) { console.log('importing from v2 json'); importRisuSprites(jsonData); unsetFavFlag(jsonData); jsonData = readFromV2(jsonData); png_name = getPngName(jsonData.data?.name || jsonData.name); let char = JSON.stringify(jsonData); charaWrite(defaultAvatarPath, char, png_name, response, { file_name: png_name }); } else if (jsonData.name !== undefined) { console.log('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.", ""); } png_name = getPngName(jsonData.name); let char = { "name": jsonData.name, "description": jsonData.description ?? '', "creatorcomment": jsonData.creatorcomment ?? jsonData.creator_notes ?? '', "personality": jsonData.personality ?? '', "first_mes": jsonData.first_mes ?? '', "avatar": 'none', "chat": jsonData.name + " - " + humanizedISO8601DateTime(), "mes_example": jsonData.mes_example ?? '', "scenario": jsonData.scenario ?? '', "create_date": humanizedISO8601DateTime(), "talkativeness": jsonData.talkativeness ?? 0.5, "creator": jsonData.creator ?? '', "tags": jsonData.tags ?? '', }; char = convertToV2(char); char = JSON.stringify(char); charaWrite(defaultAvatarPath, char, png_name, response, { file_name: png_name }); } else if (jsonData.char_name !== undefined) {//json Pygmalion notepad console.log('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.", ""); } png_name = getPngName(jsonData.char_name); let char = { "name": jsonData.char_name, "description": jsonData.char_persona ?? '', "creatorcomment": jsonData.creatorcomment ?? jsonData.creator_notes ?? '', "personality": '', "first_mes": jsonData.char_greeting ?? '', "avatar": 'none', "chat": jsonData.name + " - " + humanizedISO8601DateTime(), "mes_example": jsonData.example_dialogue ?? '', "scenario": jsonData.world_scenario ?? '', "create_date": humanizedISO8601DateTime(), "talkativeness": jsonData.talkativeness ?? 0.5, "creator": jsonData.creator ?? '', "tags": jsonData.tags ?? '', }; char = convertToV2(char); char = JSON.stringify(char); charaWrite(defaultAvatarPath, char, png_name, response, { file_name: png_name }); } else { console.log('Incorrect character format .json'); response.send({ error: true }); } }); } else { try { var img_data = await charaRead(uploadPath, format); let jsonData = json5.parse(img_data); jsonData.name = sanitize(jsonData.data?.name || jsonData.name); png_name = getPngName(jsonData.name); if (format == 'webp') { try { let convertedPath = path.join(UPLOADS_PATH, path.basename(uploadPath, ".webp") + ".png") await webp.dwebp(uploadPath, convertedPath, "-o"); fs.unlinkSync(uploadPath); uploadPath = convertedPath; } catch { console.error('WEBP image conversion failed. Using the default character image.'); uploadPath = defaultAvatarPath; } } if (jsonData.spec !== undefined) { console.log('Found a v2 character file.'); importRisuSprites(jsonData); unsetFavFlag(jsonData); jsonData = readFromV2(jsonData); let char = JSON.stringify(jsonData); await charaWrite(uploadPath, char, png_name, response, { file_name: png_name }); fs.unlinkSync(uploadPath); } else if (jsonData.name !== undefined) { console.log('Found a v1 character file.'); if (jsonData.creator_notes) { jsonData.creator_notes = jsonData.creator_notes.replace("Creator's notes go here.", ""); } let char = { "name": jsonData.name, "description": jsonData.description ?? '', "creatorcomment": jsonData.creatorcomment ?? jsonData.creator_notes ?? '', "personality": jsonData.personality ?? '', "first_mes": jsonData.first_mes ?? '', "avatar": 'none', "chat": jsonData.name + " - " + humanizedISO8601DateTime(), "mes_example": jsonData.mes_example ?? '', "scenario": jsonData.scenario ?? '', "create_date": humanizedISO8601DateTime(), "talkativeness": jsonData.talkativeness ?? 0.5, "creator": jsonData.creator ?? '', "tags": jsonData.tags ?? '', }; char = convertToV2(char); char = JSON.stringify(char); await charaWrite(uploadPath, char, png_name, response, { file_name: png_name }); fs.unlinkSync(uploadPath); } else { console.log('Unknown character card format'); response.send({ error: true }); } } catch (err) { console.log(err); response.send({ error: true }); } } } }); app.post("/dupecharacter", jsonParser, async function (request, response) { try { if (!request.body.avatar_url) { console.log("avatar URL not found in request body"); console.log(request.body); return response.sendStatus(400); } let filename = path.join(directories.characters, sanitize(request.body.avatar_url)); if (!fs.existsSync(filename)) { console.log('file for dupe not found'); console.log(filename); return response.sendStatus(404); } let suffix = 1; let newFilename = filename; while (fs.existsSync(newFilename)) { let suffixStr = "_" + suffix; let ext = path.extname(filename); newFilename = filename.slice(0, -ext.length) + suffixStr + ext; suffix++; } fs.copyFile(filename, newFilename, (err) => { if (err) throw err; console.log(`${filename} was copied to ${newFilename}`); response.sendStatus(200); }); } catch (error) { console.error(error); return response.send({ error: true }); } }); app.post("/exportchat", jsonParser, async function (request, response) { if (!request.body.file || (!request.body.avatar_url && request.body.is_group === false)) { return response.sendStatus(400); } const pathToFolder = request.body.is_group ? directories.groupChats : path.join(directories.chats, String(request.body.avatar_url).replace('.png', '')); let filename = path.join(pathToFolder, request.body.file); let exportfilename = request.body.exportfilename if (!fs.existsSync(filename)) { const errorMessage = { message: `Could not find JSONL file to export. Source chat file: ${filename}.` } console.log(errorMessage.message); return response.status(404).json(errorMessage); } try { // Short path for JSONL files if (request.body.format == 'jsonl') { try { const rawFile = fs.readFileSync(filename, 'utf8'); const successMessage = { message: `Chat saved to ${exportfilename}`, result: rawFile, } console.log(`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); return response.status(500).json(errorMessage); } } const readline = require('readline'); const readStream = fs.createReadStream(filename); const rl = readline.createInterface({ input: readStream, }); let buffer = ''; rl.on('line', (line) => { const data = JSON.parse(line); if (data.mes) { const name = data.name; const message = (data?.extra?.display_text || data?.mes || '').replace(/\r?\n/g, '\n'); buffer += (`${name}: ${message}\n\n`); } }); rl.on('close', () => { const successMessage = { message: `Chat saved to ${exportfilename}`, result: buffer, } console.log(`Chat exported as ${exportfilename}`); return response.status(200).json(successMessage); }); } catch (err) { console.log("chat export failed.") console.log(err); return response.sendStatus(400); } }) app.post("/exportcharacter", jsonParser, async function (request, response) { if (!request.body.format || !request.body.avatar_url) { return response.sendStatus(400); } let filename = path.join(directories.characters, sanitize(request.body.avatar_url)); if (!fs.existsSync(filename)) { return response.sendStatus(404); } switch (request.body.format) { case 'png': return response.sendFile(filename, { root: process.cwd() }); case 'json': { try { let json = await charaRead(filename); let jsonObject = getCharaCardV2(json5.parse(json)); return response.type('json').send(jsonObject) } catch { return response.sendStatus(400); } } case 'webp': { try { let json = await charaRead(filename); let stringByteArray = utf8Encode.encode(json).toString(); let inputWebpPath = path.join(UPLOADS_PATH, `${Date.now()}_input.webp`); let outputWebpPath = path.join(UPLOADS_PATH, `${Date.now()}_output.webp`); let metadataPath = path.join(UPLOADS_PATH, `${Date.now()}_metadata.exif`); let metadata = { "Exif": { [exif.ExifIFD.UserComment]: stringByteArray, }, }; const exifString = exif.dump(metadata); writeFileAtomicSync(metadataPath, exifString, 'binary'); await webp.cwebp(filename, inputWebpPath, '-q 95'); await webp.webpmux_add(inputWebpPath, outputWebpPath, metadataPath, 'exif'); response.sendFile(outputWebpPath, { root: process.cwd() }, () => { fs.rmSync(inputWebpPath); fs.rmSync(metadataPath); fs.rmSync(outputWebpPath); }); return; } catch (err) { console.log(err); return response.sendStatus(400); } } } return response.sendStatus(400); }); app.post("/importgroupchat", urlencodedParser, function (request, response) { try { const filedata = request.file; const chatname = humanizedISO8601DateTime(); const pathToUpload = path.join(UPLOADS_PATH, filedata.filename); const pathToNewFile = path.join(directories.groupChats, `${chatname}.jsonl`); fs.copyFileSync(pathToUpload, pathToNewFile); fs.unlinkSync(pathToUpload); return response.send({ res: chatname }); } catch (error) { console.error(error); return response.send({ error: true }); } }); app.post("/importchat", urlencodedParser, function (request, response) { if (!request.body) return response.sendStatus(400); var format = request.body.file_type; let filedata = request.file; let avatar_url = (request.body.avatar_url).replace('.png', ''); let ch_name = request.body.character_name; let user_name = request.body.user_name || 'You'; if (filedata) { if (format === 'json') { fs.readFile(path.join(UPLOADS_PATH, filedata.filename), 'utf8', (err, data) => { if (err) { console.log(err); response.send({ error: true }); } const jsonData = json5.parse(data); if (jsonData.histories !== undefined) { //console.log('/importchat confirms JSON histories are defined'); const chat = { from(history) { return [ { user_name: user_name, character_name: ch_name, create_date: humanizedISO8601DateTime(), }, ...history.msgs.map( (message) => ({ name: message.src.is_human ? user_name : ch_name, is_user: message.src.is_human, is_name: true, send_date: humanizedISO8601DateTime(), mes: message.text, }) )]; } } const newChats = []; (jsonData.histories.histories ?? []).forEach((history) => { newChats.push(chat.from(history)); }); const errors = []; for (const chat of newChats) { const filePath = `${chatsPath + avatar_url}/${ch_name} - ${humanizedISO8601DateTime()} imported.jsonl`; const fileContent = chat.map(tryParse).filter(x => x).join('\n'); try { writeFileAtomicSync(filePath, fileContent, 'utf8'); } catch (err) { errors.push(err); } } if (0 < errors.length) { response.send('Errors occurred while writing character files. Errors: ' + JSON.stringify(errors)); } response.send({ res: true }); } else if (Array.isArray(jsonData.data_visible)) { // oobabooga's format const chat = [{ user_name: user_name, character_name: ch_name, create_date: humanizedISO8601DateTime(), }]; for (const arr of jsonData.data_visible) { if (arr[0]) { const userMessage = { name: user_name, is_user: true, is_name: true, send_date: humanizedISO8601DateTime(), mes: arr[0], }; chat.push(userMessage); } if (arr[1]) { const charMessage = { name: ch_name, is_user: false, is_name: true, send_date: humanizedISO8601DateTime(), mes: arr[1], }; chat.push(charMessage); } } writeFileAtomicSync(`${chatsPath + avatar_url}/${ch_name} - ${humanizedISO8601DateTime()} imported.jsonl`, chat.map(JSON.stringify).join('\n'), 'utf8'); response.send({ res: true }); } else { response.send({ error: true }); } }); } if (format === 'jsonl') { //console.log(humanizedISO8601DateTime()+':imported chat format is JSONL'); const fileStream = fs.createReadStream(path.join(UPLOADS_PATH, filedata.filename)); const rl = readline.createInterface({ input: fileStream, crlfDelay: Infinity }); rl.once('line', (line) => { let jsonData = json5.parse(line); if (jsonData.user_name !== undefined || jsonData.name !== undefined) { fs.copyFile(path.join(UPLOADS_PATH, filedata.filename), (`${chatsPath + avatar_url}/${ch_name} - ${humanizedISO8601DateTime()}.jsonl`), (err) => { if (err) { response.send({ error: true }); return console.log(err); } else { response.send({ res: true }); return; } }); } else { response.send({ error: true }); return; } rl.close(); }); } } }); app.post('/importworldinfo', urlencodedParser, (request, response) => { if (!request.file) return response.sendStatus(400); const filename = `${path.parse(sanitize(request.file.originalname)).name}.json`; let fileContents = null; if (request.body.convertedData) { fileContents = request.body.convertedData; } else { const pathToUpload = path.join(UPLOADS_PATH, request.file.filename); fileContents = fs.readFileSync(pathToUpload, 'utf8'); fs.unlinkSync(pathToUpload); } try { const worldContent = json5.parse(fileContents); if (!('entries' in worldContent)) { throw new Error('File must contain a world info entries list'); } } catch (err) { return response.status(400).send('Is not a valid world info file'); } const pathToNewFile = path.join(directories.worlds, filename); const worldName = path.parse(pathToNewFile).name; if (!worldName) { return response.status(400).send('World file must have a name'); } writeFileAtomicSync(pathToNewFile, fileContents); return response.send({ name: worldName }); }); app.post('/editworldinfo', jsonParser, (request, response) => { if (!request.body) { return response.sendStatus(400); } if (!request.body.name) { return response.status(400).send('World file must have a name'); } try { if (!('entries' in request.body.data)) { throw new Error('World info must contain an entries list'); } } catch (err) { return response.status(400).send('Is not a valid world info file'); } const filename = `${sanitize(request.body.name)}.json`; const pathToFile = path.join(directories.worlds, filename); writeFileAtomicSync(pathToFile, JSON.stringify(request.body.data, null, 4)); return response.send({ ok: true }); }); app.post('/uploaduseravatar', urlencodedParser, async (request, response) => { if (!request.file) return response.sendStatus(400); try { const pathToUpload = path.join(UPLOADS_PATH, request.file.filename); const crop = tryParse(request.query.crop); let rawImg = await jimp.read(pathToUpload); if (typeof crop == 'object' && [crop.x, crop.y, crop.width, crop.height].every(x => typeof x === 'number')) { rawImg = rawImg.crop(crop.x, crop.y, crop.width, crop.height); } const image = await rawImg.cover(AVATAR_WIDTH, AVATAR_HEIGHT).getBufferAsync(jimp.MIME_PNG); const filename = request.body.overwrite_name || `${Date.now()}.png`; const pathToNewFile = path.join(directories.avatars, filename); writeFileAtomicSync(pathToNewFile, image); fs.rmSync(pathToUpload); return response.send({ path: filename }); } catch (err) { return response.status(400).send('Is not a valid image'); } }); /** * Ensure the directory for the provided file path exists. * If not, it will recursively create the directory. * * @param {string} filePath - The full path of the file for which the directory should be ensured. */ function ensureDirectoryExistence(filePath) { const dirname = path.dirname(filePath); if (fs.existsSync(dirname)) { return true; } ensureDirectoryExistence(dirname); fs.mkdirSync(dirname); } /** * Endpoint to handle image uploads. * The image should be provided in the request body in base64 format. * Optionally, a character name can be provided to save the image in a sub-folder. * * @route POST /uploadimage * @param {Object} request.body - The request payload. * @param {string} request.body.image - The base64 encoded image data. * @param {string} [request.body.ch_name] - Optional character name to determine the sub-directory. * @returns {Object} response - The response object containing the path where the image was saved. */ app.post('/uploadimage', jsonParser, async (request, response) => { // Check for image data if (!request.body || !request.body.image) { return response.status(400).send({ error: "No image data provided" }); } // Extracting the base64 data and the image format const match = request.body.image.match(/^data:image\/(png|jpg|webp);base64,(.+)$/); if (!match) { return response.status(400).send({ error: "Invalid image format" }); } const [, format, base64Data] = match; // Constructing filename and path let filename = `${Date.now()}.${format}`; if (request.body.filename) { filename = `${request.body.filename}.${format}`; } // if character is defined, save to a sub folder for that character let pathToNewFile = path.join(directories.userImages, filename); if (request.body.ch_name) { pathToNewFile = path.join(directories.userImages, request.body.ch_name, filename); } try { ensureDirectoryExistence(pathToNewFile); const imageBuffer = Buffer.from(base64Data, 'base64'); await fs.promises.writeFile(pathToNewFile, imageBuffer); // send the path to the image, relative to the client folder, which means removing the first folder from the path which is 'public' pathToNewFile = pathToNewFile.split(path.sep).slice(1).join(path.sep); response.send({ path: pathToNewFile }); } catch (error) { console.log(error); response.status(500).send({ error: "Failed to save the image" }); } }); app.post('/getgroups', jsonParser, (_, response) => { const groups = []; if (!fs.existsSync(directories.groups)) { fs.mkdirSync(directories.groups); } const files = fs.readdirSync(directories.groups).filter(x => path.extname(x) === '.json'); const chats = fs.readdirSync(directories.groupChats).filter(x => path.extname(x) === '.jsonl'); files.forEach(function (file) { try { const filePath = path.join(directories.groups, file); const fileContents = fs.readFileSync(filePath, 'utf8'); const group = json5.parse(fileContents); const groupStat = fs.statSync(filePath); group['date_added'] = groupStat.birthtimeMs; let chat_size = 0; let date_last_chat = 0; if (Array.isArray(group.chats) && Array.isArray(chats)) { for (const chat of chats) { if (group.chats.includes(path.parse(chat).name)) { const chatStat = fs.statSync(path.join(directories.groupChats, chat)); chat_size += chatStat.size; date_last_chat = Math.max(date_last_chat, chatStat.mtimeMs); } } } group['date_last_chat'] = date_last_chat; group['chat_size'] = chat_size; groups.push(group); } catch (error) { console.error(error); } }); return response.send(groups); }); app.post('/creategroup', jsonParser, (request, response) => { if (!request.body) { return response.sendStatus(400); } const id = String(Date.now()); const groupMetadata = { id: id, name: request.body.name ?? 'New Group', members: request.body.members ?? [], avatar_url: request.body.avatar_url, allow_self_responses: !!request.body.allow_self_responses, activation_strategy: request.body.activation_strategy ?? 0, disabled_members: request.body.disabled_members ?? [], chat_metadata: request.body.chat_metadata ?? {}, fav: request.body.fav, chat_id: request.body.chat_id ?? id, chats: request.body.chats ?? [id], }; const pathToFile = path.join(directories.groups, `${id}.json`); const fileData = JSON.stringify(groupMetadata); if (!fs.existsSync(directories.groups)) { fs.mkdirSync(directories.groups); } writeFileAtomicSync(pathToFile, fileData); return response.send(groupMetadata); }); app.post('/editgroup', jsonParser, (request, response) => { if (!request.body || !request.body.id) { return response.sendStatus(400); } const id = request.body.id; const pathToFile = path.join(directories.groups, `${id}.json`); const fileData = JSON.stringify(request.body); writeFileAtomicSync(pathToFile, fileData); return response.send({ ok: true }); }); app.post('/getgroupchat', jsonParser, (request, response) => { if (!request.body || !request.body.id) { return response.sendStatus(400); } const id = request.body.id; const pathToFile = path.join(directories.groupChats, `${id}.jsonl`); if (fs.existsSync(pathToFile)) { const data = fs.readFileSync(pathToFile, 'utf8'); const lines = data.split('\n'); // Iterate through the array of strings and parse each line as JSON const jsonData = lines.map(json5.parse); return response.send(jsonData); } else { return response.send([]); } }); app.post('/deletegroupchat', jsonParser, (request, response) => { if (!request.body || !request.body.id) { return response.sendStatus(400); } const id = request.body.id; const pathToFile = path.join(directories.groupChats, `${id}.jsonl`); if (fs.existsSync(pathToFile)) { fs.rmSync(pathToFile); return response.send({ ok: true }); } return response.send({ error: true }); }); app.post('/savegroupchat', jsonParser, (request, response) => { if (!request.body || !request.body.id) { return response.sendStatus(400); } const id = request.body.id; const pathToFile = path.join(directories.groupChats, `${id}.jsonl`); if (!fs.existsSync(directories.groupChats)) { fs.mkdirSync(directories.groupChats); } let chat_data = request.body.chat; let jsonlData = chat_data.map(JSON.stringify).join('\n'); writeFileAtomicSync(pathToFile, jsonlData, 'utf8'); return response.send({ ok: true }); }); app.post('/deletegroup', jsonParser, async (request, response) => { if (!request.body || !request.body.id) { return response.sendStatus(400); } const id = request.body.id; const pathToGroup = path.join(directories.groups, sanitize(`${id}.json`)); try { // Delete group chats const group = json5.parse(fs.readFileSync(pathToGroup)); if (group && Array.isArray(group.chats)) { for (const chat of group.chats) { console.log('Deleting group chat', chat); const pathToFile = path.join(directories.groupChats, `${id}.jsonl`); if (fs.existsSync(pathToFile)) { fs.rmSync(pathToFile); } } } } catch (error) { console.error('Could not delete group chats. Clean them up manually.', error); } if (fs.existsSync(pathToGroup)) { fs.rmSync(pathToGroup); } return response.send({ ok: true }); }); /** * Discover the extension folders * If the folder is called third-party, search for subfolders instead */ app.get('/discover_extensions', jsonParser, function (_, response) { // get all folders in the extensions folder, except third-party const extensions = fs .readdirSync(directories.extensions) .filter(f => fs.statSync(path.join(directories.extensions, f)).isDirectory()) .filter(f => f !== 'third-party'); // get all folders in the third-party folder, if it exists if (!fs.existsSync(path.join(directories.extensions, 'third-party'))) { return response.send(extensions); } const thirdPartyExtensions = fs .readdirSync(path.join(directories.extensions, 'third-party')) .filter(f => fs.statSync(path.join(directories.extensions, 'third-party', f)).isDirectory()); // add the third-party extensions to the extensions array extensions.push(...thirdPartyExtensions.map(f => `third-party/${f}`)); console.log(extensions); return response.send(extensions); }); app.get('/get_sprites', jsonParser, function (request, response) { const name = request.query.name; const spritesPath = path.join(directories.characters, name); let sprites = []; try { if (fs.existsSync(spritesPath) && fs.statSync(spritesPath).isDirectory()) { sprites = fs.readdirSync(spritesPath) .filter(file => { const mimeType = mime.lookup(file); return mimeType && mimeType.startsWith('image/'); }) .map((file) => { const pathToSprite = path.join(spritesPath, file); return { label: path.parse(pathToSprite).name.toLowerCase(), path: `/characters/${name}/${file}`, }; }); } } catch (err) { console.log(err); } finally { return response.send(sprites); } }); function getThumbnailFolder(type) { let thumbnailFolder; switch (type) { case 'bg': thumbnailFolder = directories.thumbnailsBg; break; case 'avatar': thumbnailFolder = directories.thumbnailsAvatar; break; } return thumbnailFolder; } function getOriginalFolder(type) { let originalFolder; switch (type) { case 'bg': originalFolder = directories.backgrounds; break; case 'avatar': originalFolder = directories.characters; break; } return originalFolder; } function invalidateThumbnail(type, file) { const folder = getThumbnailFolder(type); const pathToThumbnail = path.join(folder, file); if (fs.existsSync(pathToThumbnail)) { fs.rmSync(pathToThumbnail); } } function cleanUploads() { try { if (fs.existsSync(UPLOADS_PATH)) { const uploads = fs.readdirSync(UPLOADS_PATH); if (!uploads.length) { return; } console.debug(`Cleaning uploads folder (${uploads.length} files)`); uploads.forEach(file => { const pathToFile = path.join(UPLOADS_PATH, file); fs.unlinkSync(pathToFile); }); } } catch (err) { console.error(err); } } async function ensureThumbnailCache() { const cacheFiles = fs.readdirSync(directories.thumbnailsBg); // files exist, all ok if (cacheFiles.length) { return; } console.log('Generating thumbnails cache. Please wait...'); const bgFiles = fs.readdirSync(directories.backgrounds); const tasks = []; for (const file of bgFiles) { tasks.push(generateThumbnail('bg', file)); } await Promise.all(tasks); console.log(`Done! Generated: ${bgFiles.length} preview images`); } async function generateThumbnail(type, file) { const pathToCachedFile = path.join(getThumbnailFolder(type), file); const pathToOriginalFile = path.join(getOriginalFolder(type), file); const cachedFileExists = fs.existsSync(pathToCachedFile); const originalFileExists = fs.existsSync(pathToOriginalFile); // to handle cases when original image was updated after thumb creation let shouldRegenerate = false; if (cachedFileExists && originalFileExists) { const originalStat = fs.statSync(pathToOriginalFile); const cachedStat = fs.statSync(pathToCachedFile); if (originalStat.mtimeMs > cachedStat.ctimeMs) { //console.log('Original file changed. Regenerating thumbnail...'); shouldRegenerate = true; } } if (cachedFileExists && !shouldRegenerate) { return pathToCachedFile; } if (!originalFileExists) { return null; } const imageSizes = { 'bg': [160, 90], 'avatar': [96, 144] }; const mySize = imageSizes[type]; try { let buffer; try { const image = await jimp.read(pathToOriginalFile); buffer = await image.cover(mySize[0], mySize[1]).quality(95).getBufferAsync(mime.lookup('jpg')); } catch (inner) { console.warn(`Thumbnailer can not process the image: ${pathToOriginalFile}. Using original size`); buffer = fs.readFileSync(pathToOriginalFile); } writeFileAtomicSync(pathToCachedFile, buffer); } catch (outer) { return null; } return pathToCachedFile; } app.get('/thumbnail', jsonParser, async function (request, response) { const type = request.query.type; const file = sanitize(request.query.file); if (!type || !file) { return response.sendStatus(400); } if (!(type == 'bg' || type == 'avatar')) { return response.sendStatus(400); } if (sanitize(file) !== file) { console.error('Malicious filename prevented'); return response.sendStatus(403); } if (config.disableThumbnails == true) { const pathToOriginalFile = path.join(getOriginalFolder(type), file); return response.sendFile(pathToOriginalFile, { root: process.cwd() }); } const pathToCachedFile = await generateThumbnail(type, file); if (!pathToCachedFile) { return response.sendStatus(404); } return response.sendFile(pathToCachedFile, { root: process.cwd() }); }); /* OpenAI */ app.post("/getstatus_openai", jsonParser, function (request, response_getstatus_openai = response) { if (!request.body) return response_getstatus_openai.sendStatus(400); let api_url; let api_key_openai; let headers; if (request.body.use_openrouter == false) { api_url = new URL(request.body.reverse_proxy || api_openai).toString(); api_key_openai = request.body.reverse_proxy ? request.body.proxy_password : readSecret(SECRET_KEYS.OPENAI); headers = {}; } else { api_url = 'https://openrouter.ai/api/v1'; api_key_openai = readSecret(SECRET_KEYS.OPENROUTER); // OpenRouter needs to pass the referer: https://openrouter.ai/docs headers = { 'HTTP-Referer': request.headers.referer }; } if (!api_key_openai && !request.body.reverse_proxy) { return response_getstatus_openai.status(401).send({ error: true }); } const args = { headers: { "Authorization": "Bearer " + api_key_openai, ...headers, }, }; client.get(api_url + "/models", args, function (data, response) { if (response.statusCode == 200) { response_getstatus_openai.send(data); if (request.body.use_openrouter) { let models = []; data.data.forEach(model => { const context_length = model.context_length; const tokens_dollar = parseFloat(1 / (1000 * model.pricing.prompt)); const tokens_rounded = (Math.round(tokens_dollar * 1000) / 1000).toFixed(0); models[model.id] = { tokens_per_dollar: tokens_rounded + 'k', context_length: context_length, }; }); console.log('Available OpenRouter models:', models); } else { const modelIds = data?.data?.map(x => x.id)?.sort(); console.log('Available OpenAI models:', modelIds); } } if (response.statusCode == 401) { console.log('Access Token is incorrect.'); response_getstatus_openai.send({ error: true }); } if (response.statusCode == 404) { console.log('Endpoint not found.'); response_getstatus_openai.send({ error: true }); } if (response.statusCode == 500 || response.statusCode == 501 || response.statusCode == 501 || response.statusCode == 503 || response.statusCode == 507) { console.log(data); response_getstatus_openai.send({ error: true }); } }).on('error', function () { response_getstatus_openai.send({ error: true }); }); }); app.post("/openai_bias", jsonParser, async function (request, response) { if (!request.body || !Array.isArray(request.body)) return response.sendStatus(400); let result = {}; const model = getTokenizerModel(String(request.query.model || '')); // no bias for claude if (model == 'claude') { return response.send(result); } const tokenizer = getTiktokenTokenizer(model); for (const entry of request.body) { if (!entry || !entry.text) { continue; } try { const tokens = tokenizer.encode(entry.text); for (const token of tokens) { result[token] = entry.value; } } catch { console.warn('Tokenizer failed to encode:', entry.text); } } // not needed for cached tokenizers //tokenizer.free(); return response.send(result); }); app.post("/deletepreset_openai", jsonParser, function (request, response) { if (!request.body || !request.body.name) { return response.sendStatus(400); } const name = request.body.name; const pathToFile = path.join(directories.openAI_Settings, `${name}.settings`); if (fs.existsSync(pathToFile)) { fs.rmSync(pathToFile); return response.send({ ok: true }); } return response.send({ error: true }); }); function convertChatMLPrompt(messages) { const messageStrings = []; messages.forEach(m => { if (m.role === 'system' && m.name === undefined) { messageStrings.push("System: " + m.content); } else if (m.role === 'system' && m.name !== undefined) { messageStrings.push(m.name + ": " + m.content); } else { messageStrings.push(m.role + ": " + m.content); } }); return messageStrings.join("\n"); } // Prompt Conversion script taken from RisuAI by @kwaroran (GPLv3). function convertClaudePrompt(messages, addHumanPrefix, addAssistantPostfix) { // Claude doesn't support message names, so we'll just add them to the message content. for (const message of messages) { if (message.name && message.role !== "system") { message.content = message.name + ": " + message.content; delete message.name; } } let requestPrompt = messages.map((v) => { let prefix = ''; switch (v.role) { case "assistant": prefix = "\n\nAssistant: "; break case "user": prefix = "\n\nHuman: "; break case "system": // According to the Claude docs, H: and A: should be used for example conversations. if (v.name === "example_assistant") { prefix = "\n\nA: "; } else if (v.name === "example_user") { prefix = "\n\nH: "; } else { prefix = "\n\n"; } break } return prefix + v.content; }).join(''); if (addHumanPrefix) { requestPrompt = "\n\nHuman: " + requestPrompt; } if (addAssistantPostfix) { requestPrompt = requestPrompt + '\n\nAssistant: '; } return requestPrompt; } async function sendScaleRequest(request, response) { const fetch = require('node-fetch').default; const api_url = new URL(request.body.api_url_scale).toString(); const api_key_scale = readSecret(SECRET_KEYS.SCALE); if (!api_key_scale) { return response.status(401).send({ error: true }); } const requestPrompt = convertChatMLPrompt(request.body.messages); console.log('Scale request:', requestPrompt); try { const controller = new AbortController(); request.socket.removeAllListeners('close'); request.socket.on('close', function () { controller.abort(); }); const generateResponse = await fetch(api_url, { method: "POST", body: JSON.stringify({ input: { input: requestPrompt } }), headers: { 'Content-Type': 'application/json', 'Authorization': `Basic ${api_key_scale}`, }, timeout: 0, }); if (!generateResponse.ok) { console.log(`Scale API returned error: ${generateResponse.status} ${generateResponse.statusText} ${await generateResponse.text()}`); return response.status(generateResponse.status).send({ error: true }); } const generateResponseJson = await generateResponse.json(); console.log('Scale response:', generateResponseJson); const reply = { choices: [{ "message": { "content": generateResponseJson.output, } }] }; return response.send(reply); } catch (error) { console.log(error); if (!response.headersSent) { return response.status(500).send({ error: true }); } } } app.post("/generate_altscale", jsonParser, function (request, response_generate_scale) { if (!request.body) return response_generate_scale.sendStatus(400); fetch('https://dashboard.scale.com/spellbook/api/trpc/v2.variant.run', { method: 'POST', headers: { 'Content-Type': 'application/json', 'cookie': `_jwt=${readSecret(SECRET_KEYS.SCALE_COOKIE)}`, }, body: JSON.stringify({ json: { variant: { name: 'New Variant', appId: '', taxonomy: null }, prompt: { id: '', template: '{{input}}\n', exampleVariables: {}, variablesSourceDataId: null, systemMessage: request.body.sysprompt }, modelParameters: { id: '', modelId: 'GPT4', modelType: 'OpenAi', maxTokens: request.body.max_tokens, temperature: request.body.temp, stop: "user:", suffix: null, topP: request.body.top_p, logprobs: null, logitBias: request.body.logit_bias }, inputs: [ { index: '-1', valueByName: { input: request.body.prompt } } ] }, meta: { values: { 'variant.taxonomy': ['undefined'], 'prompt.variablesSourceDataId': ['undefined'], 'modelParameters.suffix': ['undefined'], 'modelParameters.logprobs': ['undefined'], } } }) }) .then(response => response.json()) .then(data => { console.log(data.result.data.json.outputs[0]) return response_generate_scale.send({ output: data.result.data.json.outputs[0] }); }) .catch((error) => { console.error('Error:', error) return response_generate_scale.send({ error: true }) }); }); async function sendClaudeRequest(request, response) { const fetch = require('node-fetch').default; const api_url = new URL(request.body.reverse_proxy || api_claude).toString(); const api_key_claude = request.body.reverse_proxy ? request.body.proxy_password : readSecret(SECRET_KEYS.CLAUDE); if (!api_key_claude) { return response.status(401).send({ error: true }); } try { const controller = new AbortController(); request.socket.removeAllListeners('close'); request.socket.on('close', function () { controller.abort(); }); let requestPrompt = convertClaudePrompt(request.body.messages, true, !request.body.exclude_assistant); if (request.body.assistant_prefill && !request.body.exclude_assistant) { requestPrompt += request.body.assistant_prefill; } console.log('Claude request:', requestPrompt); const stop_sequences = ["\n\nHuman:", "\n\nSystem:", "\n\nAssistant:"]; // Add custom stop sequences if (Array.isArray(request.body.stop)) { stop_sequences.push(...request.body.stop); } const generateResponse = await fetch(api_url + '/complete', { method: "POST", signal: controller.signal, body: JSON.stringify({ prompt: requestPrompt, model: request.body.model, max_tokens_to_sample: request.body.max_tokens, stop_sequences: stop_sequences, temperature: request.body.temperature, top_p: request.body.top_p, top_k: request.body.top_k, stream: request.body.stream, }), headers: { "Content-Type": "application/json", "anthropic-version": '2023-06-01', "x-api-key": api_key_claude, }, timeout: 0, }); if (request.body.stream) { // Pipe remote SSE stream to Express response generateResponse.body.pipe(response); request.socket.on('close', function () { generateResponse.body.destroy(); // Close the remote stream response.end(); // End the Express response }); generateResponse.body.on('end', function () { console.log("Streaming request finished"); response.end(); }); } else { if (!generateResponse.ok) { console.log(`Claude API returned error: ${generateResponse.status} ${generateResponse.statusText} ${await generateResponse.text()}`); return response.status(generateResponse.status).send({ error: true }); } const generateResponseJson = await generateResponse.json(); const responseText = generateResponseJson.completion; console.log('Claude response:', responseText); // Wrap it back to OAI format const reply = { choices: [{ "message": { "content": responseText, } }] }; return response.send(reply); } } catch (error) { console.log('Error communicating with Claude: ', error); if (!response.headersSent) { return response.status(500).send({ error: true }); } } } app.post("/generate_openai", jsonParser, function (request, response_generate_openai) { if (!request.body) return response_generate_openai.status(400).send({ error: true }); if (request.body.use_claude) { return sendClaudeRequest(request, response_generate_openai); } if (request.body.use_scale) { return sendScaleRequest(request, response_generate_openai); } if (request.body.use_ai21) { return sendAI21Request(request, response_generate_openai); } let api_url; let api_key_openai; let headers; let bodyParams; if (!request.body.use_openrouter) { api_url = new URL(request.body.reverse_proxy || api_openai).toString(); api_key_openai = request.body.reverse_proxy ? request.body.proxy_password : readSecret(SECRET_KEYS.OPENAI); headers = {}; bodyParams = {}; } else { api_url = 'https://openrouter.ai/api/v1'; api_key_openai = readSecret(SECRET_KEYS.OPENROUTER); // OpenRouter needs to pass the referer: https://openrouter.ai/docs headers = { 'HTTP-Referer': request.headers.referer }; bodyParams = { 'transforms': ["middle-out"] }; if (request.body.use_fallback) { bodyParams['route'] = 'fallback'; } } if (!api_key_openai && !request.body.reverse_proxy) { return response_generate_openai.status(401).send({ error: true }); } // Add custom stop sequences if (Array.isArray(request.body.stop)) { bodyParams['stop'] = request.body.stop; } const isTextCompletion = Boolean(request.body.model && (request.body.model.startsWith('text-') || request.body.model.startsWith('code-'))); const textPrompt = isTextCompletion ? convertChatMLPrompt(request.body.messages) : ''; const endpointUrl = isTextCompletion ? `${api_url}/completions` : `${api_url}/chat/completions`; const controller = new AbortController(); request.socket.removeAllListeners('close'); request.socket.on('close', function () { controller.abort(); }); const config = { method: 'post', url: endpointUrl, headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + api_key_openai, ...headers, }, data: { "messages": isTextCompletion === false ? request.body.messages : undefined, "prompt": isTextCompletion === true ? textPrompt : undefined, "model": request.body.model, "temperature": request.body.temperature, "max_tokens": request.body.max_tokens, "stream": request.body.stream, "presence_penalty": request.body.presence_penalty, "frequency_penalty": request.body.frequency_penalty, "top_p": request.body.top_p, "top_k": request.body.top_k, "stop": request.body.stop, "logit_bias": request.body.logit_bias, ...bodyParams, }, signal: controller.signal, }; console.log(config.data); if (request.body.stream) { config.responseType = 'stream'; } async function makeRequest(config, response_generate_openai, request, retries = 5, timeout = 5000) { try { const response = await axios(config); if (response.status <= 299) { if (request.body.stream) { console.log('Streaming request in progress'); response.data.pipe(response_generate_openai); response.data.on('end', () => { console.log('Streaming request finished'); response_generate_openai.end(); }); } else { response_generate_openai.send(response.data); console.log(response.data); console.log(response.data?.choices[0]?.message); } } else { handleErrorResponse(response, response_generate_openai, request); } } catch (error) { if (error.response && error.response.status === 429 && retries > 0) { console.log(`Out of quota, retrying in ${Math.round(timeout / 1000)}s`); setTimeout(() => { makeRequest(config, response_generate_openai, request, retries - 1); }, timeout); } else { let errorData = error?.response?.data; if (request.body.stream) { try { const chunks = await readAllChunks(errorData); const blob = new Blob(chunks, { type: 'application/json' }); const text = await blob.text(); errorData = JSON.parse(text); } catch { console.warn('Error parsing streaming response'); } } else { errorData = typeof errorData === 'string' ? tryParse(errorData) : errorData; } handleError(error, response_generate_openai, errorData); } } } function handleErrorResponse(response, response_generate_openai, request) { if (response.status >= 400 && response.status <= 504) { console.log('Error occurred:', response.status, response.data); response_generate_openai.send({ error: true }); } } function handleError(error, response_generate_openai, errorData) { console.error('Error:', error?.message); let message = error?.response?.statusText; const statusMessages = { 400: 'Bad request', 401: 'Unauthorized', 402: 'Credit limit reached', 403: 'Forbidden', 404: 'Not found', 429: 'Too many requests', 451: 'Unavailable for legal reasons', }; const status = error?.response?.status; if (statusMessages.hasOwnProperty(status)) { message = errorData?.error?.message || statusMessages[status]; console.log(message); } const quota_error = error?.response?.status === 429 && errorData?.error?.type === 'insufficient_quota'; const response = { error: { message }, quota_error: quota_error } if (!response_generate_openai.headersSent) { response_generate_openai.send(response); } else if (!response_generate_openai.writableEnded) { response_generate_openai.write(response); } } makeRequest(config, response_generate_openai, request); }); app.post("/tokenize_openai", jsonParser, function (request, response_tokenize_openai = response) { if (!request.body) return response_tokenize_openai.sendStatus(400); let num_tokens = 0; const model = getTokenizerModel(String(request.query.model || '')); if (model == 'claude') { num_tokens = countClaudeTokens(claude_tokenizer, request.body); return response_tokenize_openai.send({ "token_count": num_tokens }); } const tokensPerName = model.includes('gpt-4') ? 1 : -1; const tokensPerMessage = model.includes('gpt-4') ? 3 : 4; const tokensPadding = 3; const tokenizer = getTiktokenTokenizer(model); for (const msg of request.body) { try { num_tokens += tokensPerMessage; for (const [key, value] of Object.entries(msg)) { num_tokens += tokenizer.encode(value).length; if (key == "name") { num_tokens += tokensPerName; } } } catch { console.warn("Error tokenizing message:", msg); } } num_tokens += tokensPadding; // not needed for cached tokenizers //tokenizer.free(); response_tokenize_openai.send({ "token_count": num_tokens }); }); async function sendAI21Request(request, response) { if (!request.body) return response.sendStatus(400); const controller = new AbortController(); console.log(request.body.messages) request.socket.removeAllListeners('close'); request.socket.on('close', function () { controller.abort(); }); const options = { method: 'POST', headers: { accept: 'application/json', 'content-type': 'application/json', Authorization: `Bearer ${readSecret(SECRET_KEYS.AI21)}` }, body: JSON.stringify({ numResults: 1, maxTokens: request.body.max_tokens, minTokens: 0, temperature: request.body.temperature, topP: request.body.top_p, stopSequences: request.body.stop_tokens, topKReturn: request.body.top_k, frequencyPenalty: { scale: request.body.frequency_penalty * 100, applyToWhitespaces: false, applyToPunctuations: false, applyToNumbers: false, applyToStopwords: false, applyToEmojis: false }, presencePenalty: { scale: request.body.presence_penalty, applyToWhitespaces: false, applyToPunctuations: false, applyToNumbers: false, applyToStopwords: false, applyToEmojis: false }, countPenalty: { scale: request.body.count_pen, applyToWhitespaces: false, applyToPunctuations: false, applyToNumbers: false, applyToStopwords: false, applyToEmojis: false }, prompt: request.body.messages }), signal: controller.signal, }; fetch(`https://api.ai21.com/studio/v1/${request.body.model}/complete`, options) .then(r => r.json()) .then(r => { if (r.completions === undefined) { console.log(r) } else { console.log(r.completions[0].data.text) } const reply = { choices: [{ "message": { "content": r.completions[0].data.text, } }] }; return response.send(reply) }) .catch(err => { console.error(err) return response.send({ error: true }) }); } app.post("/tokenize_ai21", jsonParser, function (request, response_tokenize_ai21 = response) { if (!request.body) return response_tokenize_ai21.sendStatus(400); const options = { method: 'POST', headers: { accept: 'application/json', 'content-type': 'application/json', Authorization: `Bearer ${readSecret(SECRET_KEYS.AI21)}` }, body: JSON.stringify({ text: request.body[0].content }) }; fetch('https://api.ai21.com/studio/v1/tokenize', options) .then(response => response.json()) .then(response => response_tokenize_ai21.send({ "token_count": response.tokens.length })) .catch(err => console.error(err)); }); app.post("/save_preset", jsonParser, function (request, response) { const name = sanitize(request.body.name); if (!request.body.preset || !name) { return response.sendStatus(400); } const settings = getPresetSettingsByAPI(request.body.apiId); const filename = name + settings.extension; if (!settings.folder) { return response.sendStatus(400); } const fullpath = path.join(settings.folder, filename); writeFileAtomicSync(fullpath, JSON.stringify(request.body.preset, null, 4), 'utf-8'); return response.send({ name }); }); app.post("/delete_preset", jsonParser, function (request, response) { const name = sanitize(request.body.name); if (!name) { return response.sendStatus(400); } const settings = getPresetSettingsByAPI(request.body.apiId); const filename = name + settings.extension; if (!settings.folder) { return response.sendStatus(400); } const fullpath = path.join(settings.folder, filename); if (fs.existsSync(fullpath)) { fs.unlinkSync(fullpath); return response.sendStatus(200); } else { return response.sendStatus(404); } }); app.post("/savepreset_openai", jsonParser, function (request, response) { const name = sanitize(request.query.name); if (!request.body || !name) { return response.sendStatus(400); } const filename = `${name}.settings`; const fullpath = path.join(directories.openAI_Settings, filename); writeFileAtomicSync(fullpath, JSON.stringify(request.body, null, 4), 'utf-8'); return response.send({ name }); }); function getPresetSettingsByAPI(apiId) { switch (apiId) { case 'kobold': case 'koboldhorde': return { folder: directories.koboldAI_Settings, extension: '.settings' }; case 'novel': return { folder: directories.novelAI_Settings, extension: '.settings' }; case 'textgenerationwebui': return { folder: directories.textGen_Settings, extension: '.settings' }; case 'instruct': return { folder: directories.instruct, extension: '.json' }; case 'context': return { folder: directories.context, extension: '.json' }; default: return { folder: null, extension: null }; } } function createTokenizationHandler(getTokenizerFn) { return async function (request, response) { if (!request.body) { return response.sendStatus(400); } const text = request.body.text || ''; const tokenizer = getTokenizerFn(); const { ids, count } = await countSentencepieceTokens(tokenizer, text); return response.send({ ids, count }); }; } app.post("/tokenize_llama", jsonParser, createTokenizationHandler(() => spp_llama)); app.post("/tokenize_nerdstash", jsonParser, createTokenizationHandler(() => spp_nerd)); app.post("/tokenize_nerdstash_v2", jsonParser, createTokenizationHandler(() => spp_nerd_v2)); app.post("/tokenize_via_api", jsonParser, async function (request, response) { if (!request.body) { return response.sendStatus(400); } const text = request.body.text || ''; try { const args = { body: JSON.stringify({ "prompt": text }), headers: { "Content-Type": "application/json" } }; if (main_api == 'textgenerationwebui' && request.body.use_mancer) { args.headers = Object.assign(args.headers, get_mancer_headers()); const data = await postAsync(api_server + "/v1/token-count", args); return response.send({ count: data['results'][0]['tokens'] }); } else if (main_api == 'kobold') { const data = await postAsync(api_server + "/extra/tokencount", args); const count = data['value']; return response.send({ count: count }); } else { return response.send({ error: true }); } } catch (error) { console.log(error); return response.send({ error: true }); } }); // ** REST CLIENT ASYNC WRAPPERS ** async function postAsync(url, args) { const fetch = require('node-fetch').default; const response = await fetch(url, { method: 'POST', timeout: 0, ...args }); if (response.ok) { const data = await response.json(); return data; } throw response; } function getAsync(url, args) { return new Promise((resolve, reject) => { client.get(url, args, (data, response) => { if (response.statusCode >= 400) { reject(data); } resolve(data); }).on('error', e => reject(e)); }) } // ** END ** const tavernUrl = new URL( (cliArguments.ssl ? 'https://' : 'http://') + (listen ? '0.0.0.0' : '127.0.0.1') + (':' + server_port) ); const autorunUrl = new URL( (cliArguments.ssl ? 'https://' : 'http://') + ('127.0.0.1') + (':' + server_port) ); const setupTasks = async function () { const version = getVersion(); console.log(`SillyTavern ${version.pkgVersion}` + (version.gitBranch ? ` '${version.gitBranch}' (${version.gitRevision})` : '')); backupSettings(); migrateSecrets(); ensurePublicDirectoriesExist(); await ensureThumbnailCache(); contentManager.checkForNewContent(); cleanUploads(); // Colab users could run the embedded tool if (!is_colab) await convertWebp(); [spp_llama, spp_nerd, spp_nerd_v2, claude_tokenizer] = await Promise.all([ loadSentencepieceTokenizer('src/sentencepiece/tokenizer.model'), loadSentencepieceTokenizer('src/sentencepiece/nerdstash.model'), loadSentencepieceTokenizer('src/sentencepiece/nerdstash_v2.model'), loadClaudeTokenizer('src/claude.json'), ]); await statsHelpers.loadStatsFile(directories.chats, directories.characters); // Set up event listeners for a graceful shutdown process.on('SIGINT', statsHelpers.writeStatsToFileAndExit); process.on('SIGTERM', statsHelpers.writeStatsToFileAndExit); process.on('uncaughtException', (err) => { console.error('Uncaught exception:', err); statsHelpers.writeStatsToFileAndExit(); }); setInterval(statsHelpers.saveStatsToFile, 5 * 60 * 1000); console.log('Launching...'); if (autorun) open(autorunUrl.toString()); console.log(color.green('SillyTavern is listening on: ' + tavernUrl)); if (listen) { console.log('\n0.0.0.0 means SillyTavern is listening on all network interfaces (Wi-Fi, LAN, localhost). If you want to limit it only to internal localhost (127.0.0.1), change the setting in config.conf to "listen=false". Check "access.log" file in the SillyTavern directory if you want to inspect incoming connections.\n'); } } if (listen && !config.whitelistMode && !config.basicAuthMode) { if (config.securityOverride) { console.warn(color.red("Security has been overridden. If it's not a trusted network, change the settings.")); } else { console.error(color.red('Your SillyTavern is currently unsecurely open to the public. Enable whitelisting or basic authentication.')); process.exit(1); } } if (true === cliArguments.ssl) https.createServer( { cert: fs.readFileSync(cliArguments.certPath), key: fs.readFileSync(cliArguments.keyPath) }, app) .listen( tavernUrl.port || 443, tavernUrl.hostname, setupTasks ); else http.createServer(app).listen( tavernUrl.port || 80, tavernUrl.hostname, setupTasks ); async function convertWebp() { const files = fs.readdirSync(directories.characters).filter(e => e.endsWith(".webp")); if (!files.length) { return; } console.log(`${files.length} WEBP files will be automatically converted.`); for (const file of files) { try { const source = path.join(directories.characters, file); const dest = path.join(directories.characters, path.basename(file, ".webp") + ".png"); if (fs.existsSync(dest)) { console.log(`${dest} already exists. Delete ${source} manually`); continue; } console.log(`Read... ${source}`); const data = await charaRead(source); console.log(`Convert... ${source} -> ${dest}`); await webp.dwebp(source, dest, "-o"); console.log(`Write... ${dest}`); const success = await charaWrite(dest, data, path.parse(dest).name); if (!success) { console.log(`Failure on ${source} -> ${dest}`); continue; } console.log(`Remove... ${source}`); fs.rmSync(source); } catch (err) { console.log(err); } } } function backupSettings() { const MAX_BACKUPS = 25; function generateTimestamp() { const now = new Date(); const year = now.getFullYear(); const month = String(now.getMonth() + 1).padStart(2, '0'); const day = String(now.getDate()).padStart(2, '0'); const hours = String(now.getHours()).padStart(2, '0'); const minutes = String(now.getMinutes()).padStart(2, '0'); const seconds = String(now.getSeconds()).padStart(2, '0'); return `${year}${month}${day}-${hours}${minutes}${seconds}`; } try { if (!fs.existsSync(directories.backups)) { fs.mkdirSync(directories.backups); } const backupFile = path.join(directories.backups, `settings_${generateTimestamp()}.json`); fs.copyFileSync(SETTINGS_FILE, backupFile); let files = fs.readdirSync(directories.backups); if (files.length > MAX_BACKUPS) { files = files.map(f => path.join(directories.backups, f)); files.sort((a, b) => fs.statSync(a).mtimeMs - fs.statSync(b).mtimeMs); fs.rmSync(files[0]); } } catch (err) { console.log('Could not backup settings file', err); } } function ensurePublicDirectoriesExist() { for (const dir of Object.values(directories)) { if (!fs.existsSync(dir)) { fs.mkdirSync(dir, { recursive: true }); } } } const SECRETS_FILE = './secrets.json'; const SETTINGS_FILE = './public/settings.json'; const SECRET_KEYS = { HORDE: 'api_key_horde', MANCER: 'api_key_mancer', OPENAI: 'api_key_openai', NOVEL: 'api_key_novel', CLAUDE: 'api_key_claude', DEEPL: 'deepl', OPENROUTER: 'api_key_openrouter', SCALE: 'api_key_scale', AI21: 'api_key_ai21', SCALE_COOKIE: 'scale_cookie', } function migrateSecrets() { if (!fs.existsSync(SETTINGS_FILE)) { console.log('Settings file does not exist'); return; } try { let modified = false; const fileContents = fs.readFileSync(SETTINGS_FILE); const settings = JSON.parse(fileContents); const oaiKey = settings?.api_key_openai; const hordeKey = settings?.horde_settings?.api_key; const novelKey = settings?.api_key_novel; if (typeof oaiKey === 'string') { console.log('Migrating OpenAI key...'); writeSecret(SECRET_KEYS.OPENAI, oaiKey); delete settings.api_key_openai; modified = true; } if (typeof hordeKey === 'string') { console.log('Migrating Horde key...'); writeSecret(SECRET_KEYS.HORDE, hordeKey); delete settings.horde_settings.api_key; modified = true; } if (typeof novelKey === 'string') { console.log('Migrating Novel key...'); writeSecret(SECRET_KEYS.NOVEL, novelKey); delete settings.api_key_novel; modified = true; } if (modified) { console.log('Writing updated settings.json...'); const settingsContent = JSON.stringify(settings); writeFileAtomicSync(SETTINGS_FILE, settingsContent, "utf-8"); } } catch (error) { console.error('Could not migrate secrets file. Proceed with caution.'); } } app.post('/writesecret', jsonParser, (request, response) => { const key = request.body.key; const value = request.body.value; writeSecret(key, value); return response.send('ok'); }); app.post('/readsecretstate', jsonParser, (_, response) => { if (!fs.existsSync(SECRETS_FILE)) { return response.send({}); } try { const fileContents = fs.readFileSync(SECRETS_FILE); const secrets = JSON.parse(fileContents); const state = {}; for (const key of Object.values(SECRET_KEYS)) { state[key] = !!secrets[key]; // convert to boolean } return response.send(state); } catch (error) { console.error(error); return response.send({}); } }); const ANONYMOUS_KEY = "0000000000"; app.post('/generate_horde', jsonParser, async (request, response) => { const api_key_horde = readSecret(SECRET_KEYS.HORDE) || ANONYMOUS_KEY; const url = 'https://horde.koboldai.net/api/v2/generate/text/async'; const args = { "body": JSON.stringify(request.body), "headers": { "Content-Type": "application/json", "Client-Agent": request.header('Client-Agent'), "apikey": api_key_horde, } }; console.log(args.body); try { const data = await postAsync(url, args); return response.send(data); } catch (error) { console.error(error); return response.sendStatus(500); } }); app.post('/viewsecrets', jsonParser, async (_, response) => { if (!allowKeysExposure) { console.error('secrets.json could not be viewed unless the value of allowKeysExposure in config.conf is set to true'); return response.sendStatus(403); } if (!fs.existsSync(SECRETS_FILE)) { console.error('secrets.json does not exist'); return response.sendStatus(404); } try { const fileContents = fs.readFileSync(SECRETS_FILE); const secrets = JSON.parse(fileContents); return response.send(secrets); } catch (error) { console.error(error); return response.sendStatus(500); } }); app.post('/horde_samplers', jsonParser, async (_, response) => { try { const ai_horde = getHordeClient(); const samplers = Object.values(ai_horde.ModelGenerationInputStableSamplers); response.send(samplers); } catch (error) { console.error(error); response.sendStatus(500); } }); app.post('/horde_models', jsonParser, async (_, response) => { try { const ai_horde = getHordeClient(); const models = await ai_horde.getModels(); response.send(models); } catch (error) { console.error(error); response.sendStatus(500); } }); app.post('/horde_userinfo', jsonParser, async (_, response) => { const api_key_horde = readSecret(SECRET_KEYS.HORDE); if (!api_key_horde) { return response.send({ anonymous: true }); } try { const ai_horde = getHordeClient(); const user = await ai_horde.findUser({ token: api_key_horde }); return response.send(user); } catch (error) { console.error(error); return response.sendStatus(500); } }) app.post('/horde_generateimage', jsonParser, async (request, response) => { const MAX_ATTEMPTS = 200; const CHECK_INTERVAL = 3000; const api_key_horde = readSecret(SECRET_KEYS.HORDE) || ANONYMOUS_KEY; console.log('Stable Horde request:', request.body); try { const ai_horde = getHordeClient(); const generation = await ai_horde.postAsyncImageGenerate( { prompt: `${request.body.prompt_prefix} ${request.body.prompt} ### ${request.body.negative_prompt}`, params: { sampler_name: request.body.sampler, hires_fix: request.body.enable_hr, use_gfpgan: request.body.restore_faces, cfg_scale: request.body.scale, steps: request.body.steps, width: request.body.width, height: request.body.height, karras: Boolean(request.body.karras), n: 1, }, r2: false, nsfw: request.body.nfsw, models: [request.body.model], }, { token: api_key_horde }); if (!generation.id) { console.error('Image generation request is not satisfyable:', generation.message || 'unknown error'); return response.sendStatus(400); } for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) { await delay(CHECK_INTERVAL); const check = await ai_horde.getImageGenerationCheck(generation.id); console.log(check); if (check.done) { const result = await ai_horde.getImageGenerationStatus(generation.id); return response.send(result.generations[0].img); } /* if (!check.is_possible) { return response.sendStatus(503); } */ if (check.faulted) { return response.sendStatus(500); } } return response.sendStatus(504); } catch (error) { console.error(error); return response.sendStatus(500); } }); app.post('/google_translate', jsonParser, async (request, response) => { const { generateRequestUrl, normaliseResponse } = require('google-translate-api-browser'); const text = request.body.text; const lang = request.body.lang; if (!text || !lang) { return response.sendStatus(400); } console.log('Input text: ' + text); const url = generateRequestUrl(text, { to: lang }); https.get(url, (resp) => { let data = ''; resp.on('data', (chunk) => { data += chunk; }); resp.on('end', () => { const result = normaliseResponse(JSON.parse(data)); console.log('Translated text: ' + result.text); return response.send(result.text); }); }).on("error", (err) => { console.log("Translation error: " + err.message); return response.sendStatus(500); }); }); app.post('/deepl_translate', jsonParser, async (request, response) => { const key = readSecret(SECRET_KEYS.DEEPL); if (!key) { return response.sendStatus(401); } const text = request.body.text; const lang = request.body.lang; if (!text || !lang) { return response.sendStatus(400); } console.log('Input text: ' + text); const fetch = require('node-fetch').default; const params = new URLSearchParams(); params.append('text', text); params.append('target_lang', lang); try { const result = await fetch('https://api-free.deepl.com/v2/translate', { method: 'POST', body: params, headers: { 'Accept': 'application/json', 'Authorization': `DeepL-Auth-Key ${key}`, 'Content-Type': 'application/x-www-form-urlencoded', }, timeout: 0, }); if (!result.ok) { return response.sendStatus(result.status); } const json = await result.json(); console.log('Translated text: ' + json.translations[0].text); return response.send(json.translations[0].text); } catch (error) { console.log("Translation error: " + error.message); return response.sendStatus(500); } }); app.post('/novel_tts', jsonParser, async (request, response) => { const token = readSecret(SECRET_KEYS.NOVEL); if (!token) { return response.sendStatus(401); } const text = request.body.text; const voice = request.body.voice; if (!text || !voice) { return response.sendStatus(400); } try { const fetch = require('node-fetch').default; const url = `${api_novelai}/ai/generate-voice?text=${encodeURIComponent(text)}&voice=-1&seed=${encodeURIComponent(voice)}&opus=false&version=v2`; const result = await fetch(url, { method: 'GET', headers: { 'Authorization': `Bearer ${token}`, 'Accept': 'audio/mpeg', }, timeout: 0, }); if (!result.ok) { return response.sendStatus(result.status); } const chunks = await readAllChunks(result.body); const buffer = Buffer.concat(chunks); response.setHeader('Content-Type', 'audio/mpeg'); return response.send(buffer); } catch (error) { console.error(error); return response.sendStatus(500); } }); app.post('/delete_sprite', jsonParser, async (request, response) => { const label = request.body.label; const name = request.body.name; if (!label || !name) { return response.sendStatus(400); } try { const spritesPath = path.join(directories.characters, name); // No sprites folder exists, or not a directory if (!fs.existsSync(spritesPath) || !fs.statSync(spritesPath).isDirectory()) { return response.sendStatus(404); } const files = fs.readdirSync(spritesPath); // Remove existing sprite with the same label for (const file of files) { if (path.parse(file).name === label) { fs.rmSync(path.join(spritesPath, file)); } } return response.sendStatus(200); } catch (error) { console.error(error); return response.sendStatus(500); } }); app.post('/upload_sprite_pack', urlencodedParser, async (request, response) => { const file = request.file; const name = request.body.name; if (!file || !name) { return response.sendStatus(400); } try { const spritesPath = path.join(directories.characters, name); // Create sprites folder if it doesn't exist if (!fs.existsSync(spritesPath)) { fs.mkdirSync(spritesPath); } // Path to sprites is not a directory. This should never happen. if (!fs.statSync(spritesPath).isDirectory()) { return response.sendStatus(404); } const spritePackPath = path.join(UPLOADS_PATH, file.filename); const sprites = await getImageBuffers(spritePackPath); const files = fs.readdirSync(spritesPath); for (const [filename, buffer] of sprites) { // Remove existing sprite with the same label const existingFile = files.find(file => path.parse(file).name === path.parse(filename).name); if (existingFile) { fs.rmSync(path.join(spritesPath, existingFile)); } // Write sprite buffer to disk const pathToSprite = path.join(spritesPath, filename); writeFileAtomicSync(pathToSprite, buffer); } // Remove uploaded ZIP file fs.rmSync(spritePackPath); return response.send({ count: sprites.length }); } catch (error) { console.error(error); return response.sendStatus(500); } }); app.post('/upload_sprite', urlencodedParser, async (request, response) => { const file = request.file; const label = request.body.label; const name = request.body.name; if (!file || !label || !name) { return response.sendStatus(400); } try { const spritesPath = path.join(directories.characters, name); // Create sprites folder if it doesn't exist if (!fs.existsSync(spritesPath)) { fs.mkdirSync(spritesPath); } // Path to sprites is not a directory. This should never happen. if (!fs.statSync(spritesPath).isDirectory()) { return response.sendStatus(404); } const files = fs.readdirSync(spritesPath); // Remove existing sprite with the same label for (const file of files) { if (path.parse(file).name === label) { fs.rmSync(path.join(spritesPath, file)); } } const filename = label + path.parse(file.originalname).ext; const spritePath = path.join(UPLOADS_PATH, file.filename); const pathToFile = path.join(spritesPath, filename); // Copy uploaded file to sprites folder fs.cpSync(spritePath, pathToFile); // Remove uploaded file fs.rmSync(spritePath); return response.sendStatus(200); } catch (error) { console.error(error); return response.sendStatus(500); } }); app.post('/import_custom', jsonParser, async (request, response) => { if (!request.body.url) { return response.sendStatus(400); } try { const url = request.body.url; let result; const chubParsed = parseChubUrl(url); if (chubParsed?.type === 'character') { console.log('Downloading chub character:', chubParsed.id); result = await downloadChubCharacter(chubParsed.id); } else if (chubParsed?.type === 'lorebook') { console.log('Downloading chub lorebook:', chubParsed.id); result = await downloadChubLorebook(chubParsed.id); } else { return response.sendStatus(404); } response.set('Content-Type', result.fileType); response.set('Content-Disposition', `attachment; filename="${result.fileName}"`); response.set('X-Custom-Content-Type', chubParsed?.type); return response.send(result.buffer); } catch (error) { console.log('Importing custom content failed', error); return response.sendStatus(500); } }); async function downloadChubLorebook(id) { const fetch = require('node-fetch').default; const result = await fetch('https://api.chub.ai/api/lorebooks/download', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ "fullPath": id, "format": "SILLYTAVERN", }), }); if (!result.ok) { console.log(await result.text()); throw new Error('Failed to download lorebook'); } const name = id.split('/').pop(); const buffer = await result.buffer(); const fileName = `${sanitize(name)}.json`; const fileType = result.headers.get('content-type'); return { buffer, fileName, fileType }; } async function downloadChubCharacter(id) { const fetch = require('node-fetch').default; const result = await fetch('https://api.chub.ai/api/characters/download', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ "format": "tavern", "fullPath": id, }) }); if (!result.ok) { throw new Error('Failed to download character'); } const buffer = await result.buffer(); const fileName = result.headers.get('content-disposition')?.split('filename=')[1] || `${sanitize(id)}.png`; const fileType = result.headers.get('content-type'); return { buffer, fileName, fileType }; } function parseChubUrl(str) { const splitStr = str.split('/'); const length = splitStr.length; if (length < 2) { return null; } let domainIndex = -1; splitStr.forEach((part, index) => { if (part === 'www.chub.ai' || part === 'chub.ai') { domainIndex = index; } }) const lastTwo = domainIndex !== -1 ? splitStr.slice(domainIndex + 1) : splitStr; const firstPart = lastTwo[0].toLowerCase(); if (firstPart === 'characters' || firstPart === 'lorebooks') { const type = firstPart === 'characters' ? 'character' : 'lorebook'; const id = type === 'character' ? lastTwo.slice(1).join('/') : lastTwo.join('/'); return { id: id, type: type }; } else if (length === 2) { return { id: lastTwo.join('/'), type: 'character' }; } return null; } function importRisuSprites(data) { try { const name = data?.data?.name; const risuData = data?.data?.extensions?.risuai; // Not a Risu AI character if (!risuData || !name) { return; } let images = []; if (Array.isArray(risuData.additionalAssets)) { images = images.concat(risuData.additionalAssets); } if (Array.isArray(risuData.emotions)) { images = images.concat(risuData.emotions); } // No sprites to import if (images.length === 0) { return; } // Create sprites folder if it doesn't exist const spritesPath = path.join(directories.characters, name); if (!fs.existsSync(spritesPath)) { fs.mkdirSync(spritesPath); } // Path to sprites is not a directory. This should never happen. if (!fs.statSync(spritesPath).isDirectory()) { return; } console.log(`RisuAI: Found ${images.length} sprites for ${name}. Writing to disk.`); const files = fs.readdirSync(spritesPath); outer: for (const [label, fileBase64] of images) { // Remove existing sprite with the same label for (const file of files) { if (path.parse(file).name === label) { console.log(`RisuAI: The sprite ${label} for ${name} already exists. Skipping.`); continue outer; } } const filename = label + '.png'; const pathToFile = path.join(spritesPath, filename); writeFileAtomicSync(pathToFile, fileBase64, { encoding: 'base64' }); } // Remove additionalAssets and emotions from data (they are now in the sprites folder) delete data.data.extensions.risuai.additionalAssets; delete data.data.extensions.risuai.emotions; } catch (error) { console.error(error); } } function writeSecret(key, value) { if (!fs.existsSync(SECRETS_FILE)) { const emptyFile = JSON.stringify({}); writeFileAtomicSync(SECRETS_FILE, emptyFile, "utf-8"); } const fileContents = fs.readFileSync(SECRETS_FILE); const secrets = JSON.parse(fileContents); secrets[key] = value; writeFileAtomicSync(SECRETS_FILE, JSON.stringify(secrets), "utf-8"); } function readSecret(key) { if (!fs.existsSync(SECRETS_FILE)) { return undefined; } const fileContents = fs.readFileSync(SECRETS_FILE); const secrets = JSON.parse(fileContents); return secrets[key]; } async function readAllChunks(readableStream) { return new Promise((resolve, reject) => { // Consume the readable stream const chunks = []; readableStream.on('data', (chunk) => { chunks.push(chunk); }); readableStream.on('end', () => { console.log('Finished reading the stream.'); resolve(chunks); }); readableStream.on('error', (error) => { console.error('Error while reading the stream:', error); reject(); }); }); } async function getImageBuffers(zipFilePath) { return new Promise((resolve, reject) => { // Check if the zip file exists if (!fs.existsSync(zipFilePath)) { reject(new Error('File not found')); return; } const imageBuffers = []; yauzl.open(zipFilePath, { lazyEntries: true }, (err, zipfile) => { if (err) { reject(err); } else { zipfile.readEntry(); zipfile.on('entry', (entry) => { const mimeType = mime.lookup(entry.fileName); if (mimeType && mimeType.startsWith('image/') && !entry.fileName.startsWith('__MACOSX')) { console.log(`Extracting ${entry.fileName}`); zipfile.openReadStream(entry, (err, readStream) => { if (err) { reject(err); } else { const chunks = []; readStream.on('data', (chunk) => { chunks.push(chunk); }); readStream.on('end', () => { imageBuffers.push([path.parse(entry.fileName).base, Buffer.concat(chunks)]); zipfile.readEntry(); // Continue to the next entry }); } }); } else { zipfile.readEntry(); // Continue to the next entry } }); zipfile.on('end', () => { resolve(imageBuffers); }); zipfile.on('error', (err) => { reject(err); }); } }); }); } /** * This function extracts the extension information from the manifest file. * @param {string} extensionPath - The path of the extension folder * @returns {Object} - Returns the manifest data as an object */ async function getManifest(extensionPath) { const manifestPath = path.join(extensionPath, 'manifest.json'); // Check if manifest.json exists if (!fs.existsSync(manifestPath)) { throw new Error(`Manifest file not found at ${manifestPath}`); } const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8')); return manifest; } async function checkIfRepoIsUpToDate(extensionPath) { const git = simpleGit(); await git.cwd(extensionPath).fetch('origin'); const currentBranch = await git.cwd(extensionPath).branch(); const currentCommitHash = await git.cwd(extensionPath).revparse(['HEAD']); const log = await git.cwd(extensionPath).log({ from: currentCommitHash, to: `origin/${currentBranch.current}`, }); // Fetch remote repository information const remotes = await git.cwd(extensionPath).getRemotes(true); return { isUpToDate: log.total === 0, remoteUrl: remotes[0].refs.fetch, // URL of the remote repository }; } /** * HTTP POST handler function to clone a git repository from a provided URL, read the extension manifest, * and return extension information and path. * * @param {Object} request - HTTP Request object, expects a JSON body with a 'url' property. * @param {Object} response - HTTP Response object used to respond to the HTTP request. * * @returns {void} */ app.post('/get_extension', jsonParser, async (request, response) => { const git = simpleGit(); if (!request.body.url) { return response.status(400).send('Bad Request: URL is required in the request body.'); } try { // make sure the third-party directory exists if (!fs.existsSync(directories.extensions + '/third-party')) { fs.mkdirSync(directories.extensions + '/third-party'); } const url = request.body.url; const extensionPath = path.join(directories.extensions, 'third-party', path.basename(url, '.git')); if (fs.existsSync(extensionPath)) { return response.status(409).send(`Directory already exists at ${extensionPath}`); } await git.clone(url, extensionPath); console.log(`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); return response.status(500).send(`Server Error: ${error.message}`); } }); /** * HTTP POST handler function to pull the latest updates from a git repository * based on the extension name provided in the request body. It returns the latest commit hash, * the path of the extension, the status of the repository (whether it's up-to-date or not), * and the remote URL of the repository. * * @param {Object} request - HTTP Request object, expects a JSON body with an 'extensionName' property. * @param {Object} response - HTTP Response object used to respond to the HTTP request. * * @returns {void} */ app.post('/update_extension', jsonParser, async (request, response) => { const git = simpleGit(); if (!request.body.extensionName) { return response.status(400).send('Bad Request: extensionName is required in the request body.'); } try { const extensionName = request.body.extensionName; const extensionPath = path.join(directories.extensions, 'third-party', extensionName); if (!fs.existsSync(extensionPath)) { return response.status(404).send(`Directory does not exist at ${extensionPath}`); } const { isUpToDate, remoteUrl } = await checkIfRepoIsUpToDate(extensionPath); 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}`); } else { console.log(`Extension is up to date at ${extensionPath}`); } await git.cwd(extensionPath).fetch('origin'); const fullCommitHash = await git.cwd(extensionPath).revparse(['HEAD']); const shortCommitHash = fullCommitHash.slice(0, 7); return response.send({ shortCommitHash, extensionPath, isUpToDate, remoteUrl }); } catch (error) { console.log('Updating custom content failed', error); return response.status(500).send(`Server Error: ${error.message}`); } }); /** * HTTP POST handler function to get the current git commit hash and branch name for a given extension. * It checks whether the repository is up-to-date with the remote, and returns the status along with * the remote URL of the repository. * * @param {Object} request - HTTP Request object, expects a JSON body with an 'extensionName' property. * @param {Object} response - HTTP Response object used to respond to the HTTP request. * * @returns {void} */ app.post('/get_extension_version', jsonParser, async (request, response) => { const git = simpleGit(); if (!request.body.extensionName) { return response.status(400).send('Bad Request: extensionName is required in the request body.'); } try { const extensionName = request.body.extensionName; const extensionPath = path.join(directories.extensions, 'third-party', extensionName); if (!fs.existsSync(extensionPath)) { return response.status(404).send(`Directory does not exist at ${extensionPath}`); } const currentBranch = await git.cwd(extensionPath).branch(); // get only the working branch const currentBranchName = currentBranch.current; await git.cwd(extensionPath).fetch('origin'); const currentCommitHash = await git.cwd(extensionPath).revparse(['HEAD']); console.log(currentBranch, currentCommitHash); const { isUpToDate, remoteUrl } = await checkIfRepoIsUpToDate(extensionPath); return response.send({ currentBranchName, currentCommitHash, isUpToDate, remoteUrl }); } catch (error) { console.log('Getting extension version failed', error); return response.status(500).send(`Server Error: ${error.message}`); } } ); /** * HTTP POST handler function to delete a git repository based on the extension name provided in the request body. * * @param {Object} request - HTTP Request object, expects a JSON body with a 'url' property. * @param {Object} response - HTTP Response object used to respond to the HTTP request. * * @returns {void} */ app.post('/delete_extension', jsonParser, async (request, response) => { if (!request.body.extensionName) { return response.status(400).send('Bad Request: extensionName is required in the request body.'); } // Sanatize the extension name to prevent directory traversal const extensionName = sanitize(request.body.extensionName); try { const extensionPath = path.join(directories.extensions, 'third-party', extensionName); if (!fs.existsSync(extensionPath)) { return response.status(404).send(`Directory does not exist at ${extensionPath}`); } await fs.promises.rmdir(extensionPath, { recursive: true }); console.log(`Extension has been deleted at ${extensionPath}`); return response.send(`Extension has been deleted at ${extensionPath}`); } catch (error) { console.log('Deleting custom content failed', error); return response.status(500).send(`Server Error: ${error.message}`); } }); /** * HTTP POST handler function to retrieve name of all files of a given folder path. * * @param {Object} request - HTTP Request object. Require folder path in query * @param {Object} response - HTTP Response object will contain a list of file path. * * @returns {void} */ app.post('/get_assets', jsonParser, async (request, response) => { const folderPath = path.join(directories.assets); let output = {} //console.info("Checking files into",folderPath); try { if (fs.existsSync(folderPath) && fs.statSync(folderPath).isDirectory()) { const folders = fs.readdirSync(folderPath) .filter(filename => { return fs.statSync(path.join(folderPath, filename)).isDirectory(); }); for (const folder of folders) { if (folder == "temp") continue; const files = fs.readdirSync(path.join(folderPath, folder)) .filter(filename => { return filename != ".placeholder"; }); output[folder] = []; for (const file of files) { output[folder].push(path.join("assets", folder, file)); } } } } catch (err) { console.log(err); } finally { return response.send(output); } }); function checkAssetFileName(inputFilename) { // Sanitize filename if (inputFilename.indexOf('\0') !== -1) { console.debug("Bad request: poisong null bytes in filename."); return ''; } if (!/^[a-zA-Z0-9_\-\.]+$/.test(inputFilename)) { console.debug("Bad request: illegal character in filename, only alphanumeric, '_', '-' are accepted."); return ''; } if (contentManager.unsafeExtensions.some(ext => inputFilename.toLowerCase().endsWith(ext))) { console.debug("Bad request: forbidden file extension."); return ''; } if (inputFilename.startsWith('.')) { console.debug("Bad request: filename cannot start with '.'"); return ''; } return path.normalize(inputFilename).replace(/^(\.\.(\/|\\|$))+/, '');; } /** * HTTP POST handler function to download the requested asset. * * @param {Object} request - HTTP Request object, expects a url, a category and a filename. * @param {Object} response - HTTP Response only gives status. * * @returns {void} */ app.post('/asset_download', jsonParser, async (request, response) => { const { Readable } = require('stream'); const { finished } = require('stream/promises'); const url = request.body.url; const inputCategory = request.body.category; const inputFilename = sanitize(request.body.filename); const validCategories = ["bgm", "ambient"]; // Check category let category = null; for (i of validCategories) if (i == inputCategory) category = i; if (category === null) { console.debug("Bad request: unsuported asset category."); return response.sendStatus(400); } // Sanitize filename const safe_input = checkAssetFileName(inputFilename); if (safe_input == '') return response.sendFile(400); const temp_path = path.join(directories.assets, "temp", safe_input) const file_path = path.join(directories.assets, category, safe_input) console.debug("Request received to download", url, "to", file_path); try { // Download to temp const downloadFile = (async (url, temp_path) => { const res = await fetch(url); if (!res.ok) { throw new Error(`Unexpected response ${res.statusText}`); } const destination = path.resolve(temp_path); // Delete if previous download failed if (fs.existsSync(temp_path)) { fs.unlink(temp_path, (err) => { if (err) throw err; }); } const fileStream = fs.createWriteStream(destination, { flags: 'wx' }); await finished(Readable.fromWeb(res.body).pipe(fileStream)); }); await downloadFile(url, temp_path); // Move into asset place console.debug("Download finished, moving file from", temp_path, "to", file_path); fs.renameSync(temp_path, file_path); response.sendStatus(200); } catch (error) { console.log(error); response.sendStatus(500); } }); /** * HTTP POST handler function to delete the requested asset. * * @param {Object} request - HTTP Request object, expects a category and a filename * @param {Object} response - HTTP Response only gives stats. * * @returns {void} */ app.post('/asset_delete', jsonParser, async (request, response) => { const { Readable } = require('stream'); const { finished } = require('stream/promises'); const inputCategory = request.body.category; const inputFilename = sanitize(request.body.filename); const validCategories = ["bgm", "ambient"]; // Check category let category = null; for (i of validCategories) if (i == inputCategory) category = i; if (category === null) { console.debug("Bad request: unsuported asset category."); return response.sendStatus(400); } // Sanitize filename const safe_input = checkAssetFileName(inputFilename); if (safe_input == '') return response.sendFile(400); const file_path = path.join(directories.assets, category, safe_input) console.debug("Request received to delete", category, file_path); try { // Delete if previous download failed if (fs.existsSync(file_path)) { fs.unlink(file_path, (err) => { if (err) throw err; }); console.debug("Asset deleted."); } else { console.debug("Asset not found."); response.sendStatus(400); } // Move into asset place response.sendStatus(200); } catch (error) { console.log(error); response.sendStatus(500); } }); /////////////////////////////// /** * HTTP POST handler function to retrieve a character background music list. * * @param {Object} request - HTTP Request object, expects a character name in the query. * @param {Object} response - HTTP Response object will contain a list of audio file path. * * @returns {void} */ app.post('/get_character_assets_list', jsonParser, async (request, response) => { const name = sanitize(request.query.name); const inputCategory = request.query.category; const validCategories = ["bgm", "ambient"] // Check category let category = null for (i of validCategories) if (i == inputCategory) category = i if (category === null) { console.debug("Bad request: unsuported asset category."); return response.sendStatus(400); } const folderPath = path.join(directories.characters, name, category); let output = []; try { if (fs.existsSync(folderPath) && fs.statSync(folderPath).isDirectory()) { const files = fs.readdirSync(folderPath) .filter(filename => { return filename != ".placeholder"; }); for (i of files) output.push(`/characters/${name}/${category}/${i}`); } return response.send(output); } catch (err) { console.log(err); return response.sendStatus(500); } });