e4dc4896 · permissionBRICK/SillyTavern

.eslintrc.js+3 -0 Viewed

             env: {
                 node: true,
             },
+            parserOptions: {
+                sourceType: 'module',
+            },
         },
+        {
             files: ['src/**/*.mjs'],

jsconfig.json+1 -1 Viewed

     "compilerOptions": {
         "module": "ESNext",
         "target": "ESNext",
-        "moduleResolution": "node",
+        "moduleResolution": "Node",
         "strictNullChecks": true,
         "strictFunctionTypes": true,
         "checkJs": true,

package-lock.json+431 -40 Viewed

                 "csrf-csrf": "^2.2.3",
                 "express": "^4.21.0",
                 "form-data": "^4.0.0",
-                "google-translate-api-browser": "^3.0.1",
+                "google-translate-api-x": "^10.7.1",
-                "he": "^1.2.0",
                 "helmet": "^7.1.0",
+                "html-entities": "^2.5.2",
                 "iconv-lite": "^0.6.3",
                 "ip-matching": "^2.1.2",
                 "ipaddr.js": "^2.0.1",

                 "lodash": "^4.17.21",
                 "mime-types": "^2.1.35",
                 "multer": "^1.4.5-lts.1",
-                "node-fetch": "^2.6.11",
+                "node-fetch": "^3.3.2",
                 "node-persist": "^4.0.1",
                 "open": "^8.4.2",
                 "png-chunk-text": "^1.0.0",

                 "sillytavern": "server.js"
             },
             "devDependencies": {
+                "@types/archiver": "^6.0.2",
+                "@types/command-exists": "^1.2.3",
+                "@types/compression": "^1.7.5",
+                "@types/cookie-parser": "^1.4.7",
+                "@types/cookie-session": "^2.0.49",
+                "@types/cors": "^2.8.17",
                 "@types/dompurify": "^3.0.5",
+                "@types/express": "^4.17.21",
                 "@types/jquery": "^3.5.29",
+                "@types/lodash": "^4.17.10",
+                "@types/mime-types": "^2.1.4",
+                "@types/multer": "^1.4.12",
+                "@types/node": "^18.19.55",
+                "@types/node-persist": "^3.1.8",
+                "@types/png-chunk-text": "^1.0.3",
+                "@types/png-chunks-encode": "^1.0.2",
+                "@types/png-chunks-extract": "^1.0.2",
+                "@types/response-time": "^2.3.8",
                 "@types/toastr": "^2.1.43",
+                "@types/write-file-atomic": "^4.0.3",
+                "@types/yargs": "^17.0.33",
+                "@types/yauzl": "^2.10.3",
                 "eslint": "^8.57.0"
             },
             "engines": {

             "integrity": "sha512-C5Mc6rdnsaJDjO3UpGW/CQTHtCKaYlScZTly4JIu97Jxo/odCiH0ITnDXSJPTOrEKk/ycSZ0AOgTmkDtkOsvIA==",
             "license": "MIT"
         },
+        "node_modules/@types/archiver": {
+            "version": "6.0.2",
+            "resolved": "https://registry.npmjs.org/@types/archiver/-/archiver-6.0.2.tgz",
+            "integrity": "sha512-KmROQqbQzKGuaAbmK+ZcytkJ51+YqDa7NmbXjmtC5YBLSyQYo21YaUnQ3HbaPFKL1ooo6RQ6OPYPIDyxfpDDXw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@types/readdir-glob": "*"
+            }
+        },
+        "node_modules/@types/body-parser": {
+            "version": "1.19.5",
+            "resolved": "https://registry.npmjs.org/@types/body-parser/-/body-parser-1.19.5.tgz",
+            "integrity": "sha512-fB3Zu92ucau0iQ0JMCFQE7b/dv8Ot07NI3KaZIkIUNXq82k4eBAqUaneXfleGY9JWskeS9y+u0nXMyspcuQrCg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@types/connect": "*",
+                "@types/node": "*"
+            }
+        },
         "node_modules/@types/cacheable-request": {
             "version": "6.0.3",
             "resolved": "https://registry.npmjs.org/@types/cacheable-request/-/cacheable-request-6.0.3.tgz",

                 "@types/responselike": "^1.0.0"
+            }
         },
+        "node_modules/@types/command-exists": {
+            "version": "1.2.3",
+            "resolved": "https://registry.npmjs.org/@types/command-exists/-/command-exists-1.2.3.tgz",
+            "integrity": "sha512-PpbaE2XWLaWYboXD6k70TcXO/OdOyyRFq5TVpmlUELNxdkkmXU9fkImNosmXU1DtsNrqdUgWd/nJQYXgwmtdXQ==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/@types/compression": {
+            "version": "1.7.5",
+            "resolved": "https://registry.npmjs.org/@types/compression/-/compression-1.7.5.tgz",
+            "integrity": "sha512-AAQvK5pxMpaT+nDvhHrsBhLSYG5yQdtkaJE1WYieSNY2mVFKAgmU4ks65rkZD5oqnGCFLyQpUr1CqI4DmUMyDg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@types/express": "*"
+            }
+        },
+        "node_modules/@types/connect": {
+            "version": "3.4.38",
+            "resolved": "https://registry.npmjs.org/@types/connect/-/connect-3.4.38.tgz",
+            "integrity": "sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@types/node": "*"
+            }
+        },
+        "node_modules/@types/cookie-parser": {
+            "version": "1.4.7",
+            "resolved": "https://registry.npmjs.org/@types/cookie-parser/-/cookie-parser-1.4.7.tgz",
+            "integrity": "sha512-Fvuyi354Z+uayxzIGCwYTayFKocfV7TuDYZClCdIP9ckhvAu/ixDtCB6qx2TT0FKjPLf1f3P/J1rgf6lPs64mw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@types/express": "*"
+            }
+        },
+        "node_modules/@types/cookie-session": {
+            "version": "2.0.49",
+            "resolved": "https://registry.npmjs.org/@types/cookie-session/-/cookie-session-2.0.49.tgz",
+            "integrity": "sha512-4E/bBjlqLhU5l4iGPR+NkVJH593hpNsT4dC3DJDr+ODm6Qpe13kZQVkezRIb+TYDXaBMemS3yLQ+0leba3jlkQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@types/express": "*",
+                "@types/keygrip": "*"
+            }
+        },
+        "node_modules/@types/cors": {
+            "version": "2.8.17",
+            "resolved": "https://registry.npmjs.org/@types/cors/-/cors-2.8.17.tgz",
+            "integrity": "sha512-8CGDvrBj1zgo2qE+oS3pOCyYNqCPryMWY2bGfwA0dcfopWGgxs+78df0Rs3rc9THP4JkOhLsAa+15VdpAqkcUA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@types/node": "*"
+            }
+        },
         "node_modules/@types/dompurify": {
             "version": "3.0.5",
             "resolved": "https://registry.npmjs.org/@types/dompurify/-/dompurify-3.0.5.tgz",

                 "@types/trusted-types": "*"
+            }
         },
+        "node_modules/@types/express": {
+            "version": "4.17.21",
+            "resolved": "https://registry.npmjs.org/@types/express/-/express-4.17.21.tgz",
+            "integrity": "sha512-ejlPM315qwLpaQlQDTjPdsUFSc6ZsP4AN6AlWnogPjQ7CVi7PYF3YVz+CY3jE2pwYf7E/7HlDAN0rV2GxTG0HQ==",
+            "dev": true,
+            "dependencies": {
+                "@types/body-parser": "*",
+                "@types/express-serve-static-core": "^4.17.33",
+                "@types/qs": "*",
+                "@types/serve-static": "*"
+            }
+        },
+        "node_modules/@types/express-serve-static-core": {
+            "version": "4.19.6",
+            "resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-4.19.6.tgz",
+            "integrity": "sha512-N4LZ2xG7DatVqhCZzOGb1Yi5lMbXSZcmdLDe9EzSndPV2HpWYWzRbaerl2n27irrm94EPpprqa8KpskPT085+A==",
+            "dev": true,
+            "dependencies": {
+                "@types/node": "*",
+                "@types/qs": "*",
+                "@types/range-parser": "*",
+                "@types/send": "*"
+            }
+        },
         "node_modules/@types/http-cache-semantics": {
             "version": "4.0.2",
             "resolved": "https://registry.npmjs.org/@types/http-cache-semantics/-/http-cache-semantics-4.0.2.tgz",
             "integrity": "sha512-FD+nQWA2zJjh4L9+pFXqWOi0Hs1ryBCfI+985NjluQ1p8EYtoLvjLOKidXBtZ4/IcxDX4o8/E8qDS3540tNliw==",
             "license": "MIT"
         },
+        "node_modules/@types/http-errors": {
+            "version": "2.0.4",
+            "resolved": "https://registry.npmjs.org/@types/http-errors/-/http-errors-2.0.4.tgz",
+            "integrity": "sha512-D0CFMMtydbJAegzOyHjtiKPLlvnm3iTZyZRSZoLq2mRhDdmLfIWOCYPfQJ4cu2erKghU++QvjcUjp/5h7hESpA==",
+            "dev": true,
+            "license": "MIT"
+        },
         "node_modules/@types/jquery": {
             "version": "3.5.31",
             "resolved": "https://registry.npmjs.org/@types/jquery/-/jquery-3.5.31.tgz",

                 "@types/sizzle": "*"
+            }
         },
+        "node_modules/@types/keygrip": {
+            "version": "1.0.6",
+            "resolved": "https://registry.npmjs.org/@types/keygrip/-/keygrip-1.0.6.tgz",
+            "integrity": "sha512-lZuNAY9xeJt7Bx4t4dx0rYCDqGPW8RXhQZK1td7d4H6E9zYbLoOtjBvfwdTKpsyxQI/2jv+armjX/RW+ZNpXOQ==",
+            "dev": true,
+            "license": "MIT"
+        },
         "node_modules/@types/keyv": {
             "version": "3.1.4",
             "resolved": "https://registry.npmjs.org/@types/keyv/-/keyv-3.1.4.tgz",

                 "@types/node": "*"
+            }
         },
+        "node_modules/@types/lodash": {
+            "version": "4.17.10",
+            "resolved": "https://registry.npmjs.org/@types/lodash/-/lodash-4.17.10.tgz",
+            "integrity": "sha512-YpS0zzoduEhuOWjAotS6A5AVCva7X4lVlYLF0FYHAY9sdraBfnatttHItlWeZdGhuEkf+OzMNg2ZYAx8t+52uQ==",
+            "dev": true,
+            "license": "MIT"
+        },
         "node_modules/@types/long": {
             "version": "4.0.2",
             "resolved": "https://registry.npmjs.org/@types/long/-/long-4.0.2.tgz",
             "integrity": "sha512-MqTGEo5bj5t157U6fA/BiDynNkn0YknVdh48CMPkTSpFTVmvao5UQmm7uEF6xBEo7qIMAlY/JSleYaE6VOdpaA==",
             "license": "MIT"
         },
-        "node_modules/@types/node": {
+        "node_modules/@types/mime": {
-            "version": "16.9.1",
+            "version": "1.3.5",
-            "resolved": "https://registry.npmjs.org/@types/node/-/node-16.9.1.tgz",
+            "resolved": "https://registry.npmjs.org/@types/mime/-/mime-1.3.5.tgz",
-            "integrity": "sha512-QpLcX9ZSsq3YYUUnD3nFDY8H7wctAhQj/TFKL8Ya8v5fMm3CFXxo8zStsLAl780ltoYoo1WvKUVGBQK+1ifr7g==",
+            "integrity": "sha512-/pyBZWSLD2n0dcHE3hq8s8ZvcETHtEuF+3E7XVt0Ig2nvsVQXdghHVcEkIWjy9A0wKfTn97a/PSDYohKIlnP/w==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/@types/mime-types": {
+            "version": "2.1.4",
+            "resolved": "https://registry.npmjs.org/@types/mime-types/-/mime-types-2.1.4.tgz",
+            "integrity": "sha512-lfU4b34HOri+kAY5UheuFMWPDOI+OPceBSHZKp69gEyTL/mmJ4cnU6Y/rlme3UL3GyOn6Y42hyIEw0/q8sWx5w==",
+            "dev": true,
             "license": "MIT"
         },
+        "node_modules/@types/multer": {
+            "version": "1.4.12",
+            "resolved": "https://registry.npmjs.org/@types/multer/-/multer-1.4.12.tgz",
+            "integrity": "sha512-pQ2hoqvXiJt2FP9WQVLPRO+AmiIm/ZYkavPlIQnx282u4ZrVdztx0pkh3jjpQt0Kz+YI0YhSG264y08UJKoUQg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@types/express": "*"
+            }
+        },
+        "node_modules/@types/node": {
+            "version": "18.19.55",
+            "resolved": "https://registry.npmjs.org/@types/node/-/node-18.19.55.tgz",
+            "integrity": "sha512-zzw5Vw52205Zr/nmErSEkN5FLqXPuKX/k5d1D7RKHATGqU7y6YfX9QxZraUzUrFGqH6XzOzG196BC35ltJC4Cw==",
+            "license": "MIT",
+            "dependencies": {
+                "undici-types": "~5.26.4"
+            }
+        },
         "node_modules/@types/node-fetch": {
-            "version": "2.6.9",
+            "version": "2.6.11",
-            "resolved": "https://registry.npmjs.org/@types/node-fetch/-/node-fetch-2.6.9.tgz",
+            "resolved": "https://registry.npmjs.org/@types/node-fetch/-/node-fetch-2.6.11.tgz",
-            "integrity": "sha512-bQVlnMLFJ2d35DkPNjEPmd9ueO/rh5EiaZt2bhqiSarPjZIuIV6bPQVqcrEyvNo+AfTrRGVazle1tl597w3gfA==",
+            "integrity": "sha512-24xFj9R5+rfQJLRyM56qh+wnVSYhyXC2tkoBndtY0U+vubqNsYXGjufB2nn8Q6gt0LrARwL6UBtMCSVCwl4B1g==",
             "license": "MIT",
             "dependencies": {
                 "@types/node": "*",
                 "form-data": "^4.0.0"
+            }
         },
+        "node_modules/@types/node-persist": {
+            "version": "3.1.8",
+            "resolved": "https://registry.npmjs.org/@types/node-persist/-/node-persist-3.1.8.tgz",
+            "integrity": "sha512-QLidg6/SadZYPrTKxtxL1A85XBoQlG40bhoMdhu6DH6+eNCMr2j+RGfFZ9I9+IY8W/PDwQonJ+iBWD62jZjMfg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@types/node": "*"
+            }
+        },
+        "node_modules/@types/png-chunk-text": {
+            "version": "1.0.3",
+            "resolved": "https://registry.npmjs.org/@types/png-chunk-text/-/png-chunk-text-1.0.3.tgz",
+            "integrity": "sha512-7keEFz73uNJ9Ar1XMCNnHEXT9pICJnouMQCCYgBEmHMgdkXaQzSTmSvr6tUDSqgdEgmlRAxZd97wprgliyZoCg==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/@types/png-chunks-encode": {
+            "version": "1.0.2",
+            "resolved": "https://registry.npmjs.org/@types/png-chunks-encode/-/png-chunks-encode-1.0.2.tgz",
+            "integrity": "sha512-Dxn0aXEcSg1wVeHjvNlygm/+fKBDzWMCdxJYhjGUTeefFW/jYxWcrg+W7ppLBfH44iJMqeVBHtHBwtYQUeYvgw==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/@types/png-chunks-extract": {
+            "version": "1.0.2",
+            "resolved": "https://registry.npmjs.org/@types/png-chunks-extract/-/png-chunks-extract-1.0.2.tgz",
+            "integrity": "sha512-z6djfFIbrrddtunoMJBOPlyZrnmeuG1kkvHUNi2QfpOb+JMMLuLliHHTmMyRi7k7LiTAut0HbdGCF6ibDtQAHQ==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/@types/qs": {
+            "version": "6.9.16",
+            "resolved": "https://registry.npmjs.org/@types/qs/-/qs-6.9.16.tgz",
+            "integrity": "sha512-7i+zxXdPD0T4cKDuxCUXJ4wHcsJLwENa6Z3dCu8cfCK743OGy5Nu1RmAGqDPsoTDINVEcdXKRvR/zre+P2Ku1A==",
+            "dev": true
+        },
+        "node_modules/@types/range-parser": {
+            "version": "1.2.7",
+            "resolved": "https://registry.npmjs.org/@types/range-parser/-/range-parser-1.2.7.tgz",
+            "integrity": "sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==",
+            "dev": true
+        },
+        "node_modules/@types/readdir-glob": {
+            "version": "1.1.5",
+            "resolved": "https://registry.npmjs.org/@types/readdir-glob/-/readdir-glob-1.1.5.tgz",
+            "integrity": "sha512-raiuEPUYqXu+nvtY2Pe8s8FEmZ3x5yAH4VkLdihcPdalvsHltomrRC9BzuStrJ9yk06470hS0Crw0f1pXqD+Hg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@types/node": "*"
+            }
+        },
+        "node_modules/@types/response-time": {
+            "version": "2.3.8",
+            "resolved": "https://registry.npmjs.org/@types/response-time/-/response-time-2.3.8.tgz",
+            "integrity": "sha512-7qGaNYvdxc0zRab8oHpYx7AW17qj+G0xuag1eCrw3M2VWPJQ/HyKaaghWygiaOUl0y9x7QGQwppDpqLJ5V9pzw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@types/express": "*",
+                "@types/node": "*"
+            }
+        },
         "node_modules/@types/responselike": {
             "version": "1.0.1",
             "resolved": "https://registry.npmjs.org/@types/responselike/-/responselike-1.0.1.tgz",

                 "@types/node": "*"
+            }
         },
+        "node_modules/@types/send": {
+            "version": "0.17.4",
+            "resolved": "https://registry.npmjs.org/@types/send/-/send-0.17.4.tgz",
+            "integrity": "sha512-x2EM6TJOybec7c52BX0ZspPodMsQUd5L6PRwOunVyVUhXiBSKf3AezDL8Dgvgt5o0UfKNfuA0eMLr2wLT4AiBA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@types/mime": "^1",
+                "@types/node": "*"
+            }
+        },
+        "node_modules/@types/serve-static": {
+            "version": "1.15.7",
+            "resolved": "https://registry.npmjs.org/@types/serve-static/-/serve-static-1.15.7.tgz",
+            "integrity": "sha512-W8Ym+h8nhuRwaKPaDw34QUkwsGi6Rc4yYqvKFo5rm2FUEhCFbzVWrxXUxuKK8TASjWsysJY0nsmNCGhCOIsrOw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@types/http-errors": "*",
+                "@types/node": "*",
+                "@types/send": "*"
+            }
+        },
         "node_modules/@types/sizzle": {
             "version": "2.3.8",
             "resolved": "https://registry.npmjs.org/@types/sizzle/-/sizzle-2.3.8.tgz",

             "dev": true,
             "license": "MIT"
         },
+        "node_modules/@types/write-file-atomic": {
+            "version": "4.0.3",
+            "resolved": "https://registry.npmjs.org/@types/write-file-atomic/-/write-file-atomic-4.0.3.tgz",
+            "integrity": "sha512-qdo+vZRchyJIHNeuI1nrpsLw+hnkgqP/8mlaN6Wle/NKhydHmUN9l4p3ZE8yP90AJNJW4uB8HQhedb4f1vNayQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@types/node": "*"
+            }
+        },
+        "node_modules/@types/yargs": {
+            "version": "17.0.33",
+            "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-17.0.33.tgz",
+            "integrity": "sha512-WpxBCKWPLr4xSsHgz511rFJAM+wS28w2zEO1QDNY5zM/S8ok70NNfztH0xwhqKyaK0OHCbN98LDAZuy1ctxDkA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@types/yargs-parser": "*"
+            }
+        },
+        "node_modules/@types/yargs-parser": {
+            "version": "21.0.3",
+            "resolved": "https://registry.npmjs.org/@types/yargs-parser/-/yargs-parser-21.0.3.tgz",
+            "integrity": "sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/@types/yauzl": {
+            "version": "2.10.3",
+            "resolved": "https://registry.npmjs.org/@types/yauzl/-/yauzl-2.10.3.tgz",
+            "integrity": "sha512-oJoftv0LSuaDZE3Le4DbKX+KS9G36NzOeSap90UIK0yMA/NhKJhqlSGtNDORNRaIbQfzjXDrQa0ytJ6mNRGz/Q==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@types/node": "*"
+            }
+        },
         "node_modules/@ungap/structured-clone": {
             "version": "1.2.0",
             "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.2.0.tgz",

                 "pend": "~1.2.0"
+            }
         },
+        "node_modules/fetch-blob": {
+            "version": "3.2.0",
+            "resolved": "https://registry.npmjs.org/fetch-blob/-/fetch-blob-3.2.0.tgz",
+            "integrity": "sha512-7yAQpD2UMJzLi1Dqv7qFYnPbaPx7ZfFK6PiIxQ4PfkGPyNyl2Ugx+a/umUonmKqjhM4DnfbMvdX6otXq83soQQ==",
+            "funding": [
+                {
+                    "type": "github",
+                    "url": "https://github.com/sponsors/jimmywarting"
+                },
+                {
+                    "type": "paypal",
+                    "url": "https://paypal.me/jimmywarting"
+                }
+            ],
+            "license": "MIT",
+            "dependencies": {
+                "node-domexception": "^1.0.0",
+                "web-streams-polyfill": "^3.0.3"
+            },
+            "engines": {
+                "node": "^12.20 || >= 14.13"
+            }
+        },
         "node_modules/file-entry-cache": {
             "version": "6.0.1",
             "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz",

                 "node": ">= 14"
+            }
         },
+        "node_modules/formdata-polyfill": {
+            "version": "4.0.10",
+            "resolved": "https://registry.npmjs.org/formdata-polyfill/-/formdata-polyfill-4.0.10.tgz",
+            "integrity": "sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g==",
+            "license": "MIT",
+            "dependencies": {
+                "fetch-blob": "^3.1.2"
+            },
+            "engines": {
+                "node": ">=12.20.0"
+            }
+        },
         "node_modules/forwarded": {
             "version": "0.2.0",
             "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",

                 "url": "https://github.com/sponsors/sindresorhus"
+            }
         },
-        "node_modules/google-translate-api-browser": {
+        "node_modules/google-translate-api-x": {
-            "version": "3.0.1",
+            "version": "10.7.1",
-            "resolved": "https://registry.npmjs.org/google-translate-api-browser/-/google-translate-api-browser-3.0.1.tgz",
+            "resolved": "https://registry.npmjs.org/google-translate-api-x/-/google-translate-api-x-10.7.1.tgz",
-            "integrity": "sha512-KTLodkyGBWMK9IW6QIeJ2zCuju4Z0CLpbkADKo+yLhbSTD4l+CXXpQ/xaynGVAzeBezzJG6qn8MLeqOq3SmW0A==",
+            "integrity": "sha512-OdZDS6jRWzn1woOk62aOKQ5OyVaJSA+eyc6CktOWxo36IWfstOjwG/dkvnGl3Z2Sbpmk1A+jc2WwrBiRjqaY2A==",
-            "license": "MIT"
+            "license": "MIT",
+            "engines": {
+                "node": ">=14.0.0"
+            },
+            "funding": {
+                "type": "github",
+                "url": "https://github.com/sponsors/AidanWelch"
+            }
         },
         "node_modules/gopd": {
             "version": "1.0.1",

                 "node": ">= 0.4"
+            }
         },
-        "node_modules/he": {
-            "version": "1.2.0",
-            "resolved": "https://registry.npmjs.org/he/-/he-1.2.0.tgz",
-            "integrity": "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==",
-            "bin": {
-                "he": "bin/he"
-            }
-        },
         "node_modules/helmet": {
             "version": "7.1.0",
             "resolved": "https://registry.npmjs.org/helmet/-/helmet-7.1.0.tgz",

                 "node": ">=16.0.0"
+            }
         },
+        "node_modules/html-entities": {
+            "version": "2.5.2",
+            "resolved": "https://registry.npmjs.org/html-entities/-/html-entities-2.5.2.tgz",
+            "integrity": "sha512-K//PSRMQk4FZ78Kyau+mZurHn3FH0Vwr+H36eE0rPbeYkRRi9YxceYPhuN60UwWorxyKHhqoAJl2OFKa4BVtaA==",
+            "funding": [
+                {
+                    "type": "github",
+                    "url": "https://github.com/sponsors/mdevils"
+                },
+                {
+                    "type": "patreon",
+                    "url": "https://patreon.com/mdevils"
+                }
+            ],
+            "license": "MIT"
+        },
         "node_modules/htmlparser2": {
             "version": "8.0.2",
             "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-8.0.2.tgz",

                 "@types/node": "16.9.1"
+            }
         },
+        "node_modules/image-q/node_modules/@types/node": {
+            "version": "16.9.1",
+            "resolved": "https://registry.npmjs.org/@types/node/-/node-16.9.1.tgz",
+            "integrity": "sha512-QpLcX9ZSsq3YYUUnD3nFDY8H7wctAhQj/TFKL8Ya8v5fMm3CFXxo8zStsLAl780ltoYoo1WvKUVGBQK+1ifr7g==",
+            "license": "MIT"
+        },
         "node_modules/import-fresh": {
             "version": "3.3.0",
             "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz",

                 "whatwg-fetch": "^3.4.1"
+            }
         },
+        "node_modules/isomorphic-fetch/node_modules/node-fetch": {
+            "version": "2.7.0",
+            "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz",
+            "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==",
+            "license": "MIT",
+            "dependencies": {
+                "whatwg-url": "^5.0.0"
+            },
+            "engines": {
+                "node": "4.x || >=6.0.0"
+            },
+            "peerDependencies": {
+                "encoding": "^0.1.0"
+            },
+            "peerDependenciesMeta": {
+                "encoding": {
+                    "optional": true
+                }
+            }
+        },
         "node_modules/jackspeak": {
             "version": "2.3.6",
             "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-2.3.6.tgz",

+            }
         },
         "node_modules/node-fetch": {
-            "version": "2.6.12",
+            "version": "3.3.2",
-            "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.12.tgz",
+            "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-3.3.2.tgz",
-            "integrity": "sha512-C/fGU2E8ToujUivIO0H+tpQ6HWo4eEmchoPIoXtxCrVghxdKq+QOHqEZW7tuP3KlV3bC8FRMO5nMCC7Zm1VP6g==",
+            "integrity": "sha512-dRB78srN/l6gqWulah9SrxeYnxeddIG30+GOqK/9OlLVyLg3HPnr6SqOWTWOXKRwC2eGYCkZ59NNuSgvSrpgOA==",
             "license": "MIT",
             "dependencies": {
-                "whatwg-url": "^5.0.0"
+                "data-uri-to-buffer": "^4.0.0",
+                "fetch-blob": "^3.1.4",
+                "formdata-polyfill": "^4.0.10"
             },
             "engines": {
-                "node": "4.x || >=6.0.0"
+                "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
             },
-            "peerDependencies": {
+            "funding": {
-                "encoding": "^0.1.0"
+                "type": "opencollective",
-            },
+                "url": "https://opencollective.com/node-fetch"
-            "peerDependenciesMeta": {
+            }
-                "encoding": {
+        },
-                    "optional": true
+        "node_modules/node-fetch/node_modules/data-uri-to-buffer": {
-                }
+            "version": "4.0.1",
+            "resolved": "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-4.0.1.tgz",
+            "integrity": "sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A==",
+            "license": "MIT",
+            "engines": {
+                "node": ">= 12"
+            }
         },
         "node_modules/node-persist": {

                 "openai": "bin/cli"
+            }
         },
-        "node_modules/openai/node_modules/@types/node": {
+        "node_modules/openai/node_modules/node-fetch": {
-            "version": "18.18.9",
+            "version": "2.7.0",
-            "resolved": "https://registry.npmjs.org/@types/node/-/node-18.18.9.tgz",
+            "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz",
-            "integrity": "sha512-0f5klcuImLnG4Qreu9hPj/rEfFq6YRc5n2mAjSsH+ec/mJL+3voBH0+8T7o8RpFjH7ovc+TRsL/c7OYIQsPTfQ==",
+            "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==",
             "license": "MIT",
             "dependencies": {
-                "undici-types": "~5.26.4"
+                "whatwg-url": "^5.0.0"
+            },
+            "engines": {
+                "node": "4.x || >=6.0.0"
+            },
+            "peerDependencies": {
+                "encoding": "^0.1.0"
+            },
+            "peerDependenciesMeta": {
+                "encoding": {
+                    "optional": true
+                }
+            }
         },
         "node_modules/optionator": {

             "version": "5.0.0",
             "resolved": "https://registry.npmjs.org/tr46/-/tr46-5.0.0.tgz",
             "integrity": "sha512-tk2G5R2KRwBd+ZN0zaEXpmzdKyOYksXwywulIX95MBODjSzMIuQnQ3m8JxgbhnL1LeVo7lqQKsYa1O3Htl7K5g==",
+            "license": "MIT",
             "dependencies": {
                 "punycode": "^2.3.1"
             },

             "version": "7.0.0",
             "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-7.0.0.tgz",
             "integrity": "sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g==",
+            "license": "BSD-2-Clause",
             "engines": {
                 "node": ">=12"
+            }

             "version": "14.0.0",
             "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-14.0.0.tgz",
             "integrity": "sha512-1lfMEm2IEr7RIV+f4lUNPOqfFL+pO+Xw3fJSqmjX9AbXcXcYOkCe1P6+9VBZB6n94af16NfZf+sSk0JCBZC9aw==",
+            "license": "MIT",
             "dependencies": {
                 "tr46": "^5.0.0",
                 "webidl-conversions": "^7.0.0"

package.json+23 -4 Viewed

         "csrf-csrf": "^2.2.3",
         "express": "^4.21.0",
         "form-data": "^4.0.0",
-        "google-translate-api-browser": "^3.0.1",
+        "google-translate-api-x": "^10.7.1",
-        "he": "^1.2.0",
         "helmet": "^7.1.0",
+        "html-entities": "^2.5.2",
         "iconv-lite": "^0.6.3",
         "ip-matching": "^2.1.2",
         "ipaddr.js": "^2.0.1",

         "lodash": "^4.17.21",
         "mime-types": "^2.1.35",
         "multer": "^1.4.5-lts.1",
-        "node-fetch": "^2.6.11",
+        "node-fetch": "^3.3.2",
         "node-persist": "^4.0.1",
         "open": "^8.4.2",
         "png-chunk-text": "^1.0.0",

+        }
     },
     "name": "sillytavern",
-    "type": "commonjs",
+    "type": "module",
     "license": "AGPL-3.0",
     "repository": {
         "type": "git",

     },
     "main": "server.js",
     "devDependencies": {
+        "@types/archiver": "^6.0.2",
+        "@types/command-exists": "^1.2.3",
+        "@types/compression": "^1.7.5",
+        "@types/cookie-parser": "^1.4.7",
+        "@types/cookie-session": "^2.0.49",
+        "@types/cors": "^2.8.17",
         "@types/dompurify": "^3.0.5",
+        "@types/express": "^4.17.21",
         "@types/jquery": "^3.5.29",
+        "@types/lodash": "^4.17.10",
+        "@types/mime-types": "^2.1.4",
+        "@types/multer": "^1.4.12",
+        "@types/node": "^18.19.55",
+        "@types/node-persist": "^3.1.8",
+        "@types/png-chunk-text": "^1.0.3",
+        "@types/png-chunks-encode": "^1.0.2",
+        "@types/png-chunks-extract": "^1.0.2",
+        "@types/response-time": "^2.3.8",
         "@types/toastr": "^2.1.43",
+        "@types/write-file-atomic": "^4.0.3",
+        "@types/yargs": "^17.0.33",
+        "@types/yauzl": "^2.10.3",
         "eslint": "^8.57.0"
+    }
+}

plugins.js+16 -4 Viewed

 // 1. node plugins.js update
 // 2. node plugins.js install <plugin-git-url>
 // More operations coming soon.
-const { default: git } = require('simple-git');
+import fs from 'node:fs';
-const fs = require('fs');
+import path from 'node:path';
-const path = require('path');
+import process from 'node:process';
-const { color } = require('./src/util');
+import { fileURLToPath } from 'node:url';
+import { default as git } from 'simple-git';
+import { color } from './src/util.js';
+const __dirname = import.meta.dirname ?? path.dirname(fileURLToPath(import.meta.url));
 process.chdir(__dirname);
 const pluginsPath = './plugins';
 const command = process.argv[2];
+if (!command) {
+    console.log('Usage: node plugins.js <command>');
+    console.log('Commands:');
+    console.log('  update - Update all installed plugins');
+    console.log('  install <plugin-git-url> - Install plugin from a Git URL');
+    process.exit(1);
+}
 if (command === 'update') {
     console.log(color.magenta('Updating all plugins'));
     updatePlugins();

plugins/package.json+4 -0 Viewed

+{
+    "name": "sillytavern-plugins",
+    "type": "commonjs"
+}

post-install.js+15 -11 Viewed

 /**
  * Scripts to be done before starting the server for the first time.
  */
-const fs = require('fs');
+import fs from 'node:fs';
-const path = require('path');
+import path from 'node:path';
-const crypto = require('crypto');
+import crypto from 'node:crypto';
-const yaml = require('yaml');
+import process from 'node:process';
-const _ = require('lodash');
+import yaml from 'yaml';
+import _ from 'lodash';
+import { createRequire } from 'node:module';
 /**
  * Colorizes console output.

         try {
             console.log(color.blue('Converting config.conf to config.yaml. Your old config.conf will be renamed to config.conf.bak'));
-            const config = require(path.join(process.cwd(), './config.conf'));
+            fs.renameSync('./config.conf', './config.conf.cjs'); // Force loading as CommonJS
-            fs.copyFileSync('./config.conf', './config.conf.bak');
+            const require = createRequire(import.meta.url);
-            fs.rmSync('./config.conf');
+            const config = require(path.join(process.cwd(), './config.conf.cjs'));
+            fs.copyFileSync('./config.conf.cjs', './config.conf.bak');
+            fs.rmSync('./config.conf.cjs');
             fs.writeFileSync('./config.yaml', yaml.stringify(config));
             console.log(color.green('Conversion successful. Please check your config.yaml and fix it if necessary.'));
         } catch (error) {
-            console.error(color.red('FATAL: Config conversion failed. Please check your config.conf file and try again.'));
+            console.error(color.red('FATAL: Config conversion failed. Please check your config.conf file and try again.'), error);
             return;
+        }
+    }

  * Compares the current config.yaml with the default config.yaml and adds any missing values.
  */
 function addMissingConfigValues() {
-    try  {
+    try {
         const defaultConfig = yaml.parse(fs.readFileSync(path.join(process.cwd(), './default/config.yaml'), 'utf8'));
         let config = yaml.parse(fs.readFileSync(path.join(process.cwd(), './config.yaml'), 'utf8'));

 function getMd5Hash(data) {
     return crypto
         .createHash('md5')
-        .update(data)
+        .update(new Uint8Array(data))
         .digest('hex');
+}

recover.js+16 -10 Viewed

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

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

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

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

server.js+162 -182 Viewed

 #!/usr/bin/env node
 // native node modules
-const fs = require('fs');
+import fs from 'node:fs';
-const http = require('http');
+import http from 'node:http';
-const https = require('https');
+import https from 'node:https';
-const path = require('path');
+import path from 'node:path';
-const util = require('util');
+import util from 'node:util';
+import net from 'node:net';
+import dns from 'node:dns';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
 // cli/fs related library imports
-const open = require('open');
+import open from 'open';
-const yargs = require('yargs/yargs');
+import yargs from 'yargs/yargs';
-const { hideBin } = require('yargs/helpers');
+import { hideBin } from 'yargs/helpers';
 // express/server related library imports
-const cors = require('cors');
+import cors from 'cors';
-const doubleCsrf = require('csrf-csrf').doubleCsrf;
+import { doubleCsrf } from 'csrf-csrf';
-const express = require('express');
+import express from 'express';
-const compression = require('compression');
+import compression from 'compression';
-const cookieParser = require('cookie-parser');
+import cookieParser from 'cookie-parser';
-const cookieSession = require('cookie-session');
+import cookieSession from 'cookie-session';
-const multer = require('multer');
+import multer from 'multer';
-const responseTime = require('response-time');
+import responseTime from 'response-time';
-const helmet = require('helmet').default;
+import helmet from 'helmet';
+import bodyParser from 'body-parser';
 // net related library imports
-const net = require('net');
+import fetch from 'node-fetch';
-const dns = require('dns');
-const fetch = require('node-fetch').default;
 // Unrestrict console logs display limit
 util.inspect.defaultOptions.maxArrayLength = null;

 util.inspect.defaultOptions.depth = 4;
 // local library imports
-const userModule = require('./src/users');
+import{ loadPlugins } from './src/plugin-loader.js';
-const basicAuthMiddleware = require('./src/middleware/basicAuth');
+import {
-const whitelistMiddleware = require('./src/middleware/whitelist');
+    initUserStorage,
-const initRequestProxy = require('./src/request-proxy');
+    getCsrfSecret,
-const contentManager = require('./src/endpoints/content-manager');
+    getCookieSecret,
-const {
+    getCookieSessionName,
+    getAllEnabledUsers,
+    ensurePublicDirectoriesExist,
+    getUserDirectoriesList,
+    migrateSystemPrompts,
+    migrateUserData,
+    requireLoginMiddleware,
+    setUserDataMiddleware,
+    shouldRedirectToLogin,
+    tryAutoLogin,
+    router as userDataRouter,
+} from './src/users.js';
+import basicAuthMiddleware from './src/middleware/basicAuth.js';
+import whitelistMiddleware from './src/middleware/whitelist.js';
+import multerMonkeyPatch from './src/middleware/multerMonkeyPatch.js';
+import initRequestProxy from './src/request-proxy.js';
+import {
     getVersion,
     getConfigValue,
     color,
     forwardFetchResponse,
     removeColorFormatting,
     getSeparator,
-} = require('./src/util');
+} from './src/util.js';
-const { ensureThumbnailCache } = require('./src/endpoints/thumbnails');
+import { UPLOADS_DIRECTORY } from './src/constants.js';
+import { ensureThumbnailCache } from './src/endpoints/thumbnails.js';
+// Routers
+import { router as usersPublicRouter } from './src/endpoints/users-public.js';
+import { router as usersPrivateRouter } from './src/endpoints/users-private.js';
+import { router as usersAdminRouter } from './src/endpoints/users-admin.js';
+import { router as movingUIRouter } from './src/endpoints/moving-ui.js';
+import { router as imagesRouter } from './src/endpoints/images.js';
+import { router as quickRepliesRouter } from './src/endpoints/quick-replies.js';
+import { router as avatarsRouter } from './src/endpoints/avatars.js';
+import { router as themesRouter } from './src/endpoints/themes.js';
+import { router as openAiRouter } from './src/endpoints/openai.js';
+import { router as googleRouter } from './src/endpoints/google.js';
+import { router as anthropicRouter } from './src/endpoints/anthropic.js';
+import { router as tokenizersRouter } from './src/endpoints/tokenizers.js';
+import { router as presetsRouter } from './src/endpoints/presets.js';
+import { router as secretsRouter } from './src/endpoints/secrets.js';
+import { router as thumbnailRouter } from './src/endpoints/thumbnails.js';
+import { router as novelAiRouter } from './src/endpoints/novelai.js';
+import { router as extensionsRouter } from './src/endpoints/extensions.js';
+import { router as assetsRouter } from './src/endpoints/assets.js';
+import { router as filesRouter } from './src/endpoints/files.js';
+import { router as charactersRouter } from './src/endpoints/characters.js';
+import { router as chatsRouter } from './src/endpoints/chats.js';
+import { router as groupsRouter } from './src/endpoints/groups.js';
+import { router as worldInfoRouter } from './src/endpoints/worldinfo.js';
+import { router as statsRouter, init as statsInit, onExit as statsOnExit } from './src/endpoints/stats.js';
+import { router as backgroundsRouter } from './src/endpoints/backgrounds.js';
+import { router as spritesRouter } from './src/endpoints/sprites.js';
+import { router as contentManagerRouter, checkForNewContent } from './src/endpoints/content-manager.js';
+import { router as settingsRouter, init as settingsInit } from './src/endpoints/settings.js';
+import { router as stableDiffusionRouter } from './src/endpoints/stable-diffusion.js';
+import { router as hordeRouter } from './src/endpoints/horde.js';
+import { router as vectorsRouter } from './src/endpoints/vectors.js';
+import { router as translateRouter } from './src/endpoints/translate.js';
+import { router as classifyRouter } from './src/endpoints/classify.js';
+import { router as captionRouter } from './src/endpoints/caption.js';
+import { router as searchRouter } from './src/endpoints/search.js';
+import { router as openRouterRouter } from './src/endpoints/openrouter.js';
+import { router as chatCompletionsRouter } from './src/endpoints/backends/chat-completions.js';
+import { router as koboldRouter } from './src/endpoints/backends/kobold.js';
+import { router as textCompletionsRouter } from './src/endpoints/backends/text-completions.js';
+import { router as scaleAltRouter } from './src/endpoints/backends/scale-alt.js';
+import { router as speechRouter } from './src/endpoints/speech.js';
+import { router as azureRouter } from './src/endpoints/azure.js';
 // Work around a node v20.0.0, v20.1.0, and v20.2.0 bug. The issue was fixed in v20.3.0.
 // https://github.com/nodejs/node/issues/47822#issuecomment-1564708870

     }).parseSync();
 // change all relative paths
-console.log(`Node version: ${process.version}. Running in ${process.env.NODE_ENV} environment.`);
+const serverDirectory = import.meta.dirname ?? path.dirname(fileURLToPath(import.meta.url));
-const serverDirectory = __dirname;
+console.log(`Node version: ${process.version}. Running in ${process.env.NODE_ENV} environment. Server directory: ${serverDirectory}`);
 process.chdir(serverDirectory);
 const app = express();

 const perUserBasicAuth = getConfigValue('perUserBasicAuth', DEFAULT_PER_USER_BASIC_AUTH);
 const enableAccounts = getConfigValue('enableUserAccounts', DEFAULT_ACCOUNTS);
-const uploadsPath = path.join(dataRoot, require('./src/constants').UPLOADS_DIRECTORY);
+const uploadsPath = path.join(dataRoot, UPLOADS_DIRECTORY);
 const enableIPv6 = cliArguments.enableIPv6 ?? getConfigValue('protocol.ipv6', DEFAULT_ENABLE_IPV6);
 const enableIPv4 = cliArguments.enableIPv4 ?? getConfigValue('protocol.ipv4', DEFAULT_ENABLE_IPV4);

 app.use(whitelistMiddleware(enableWhitelist, listen));
 if (enableCorsProxy) {
-    const bodyParser = require('body-parser');
     app.use(bodyParser.json({
         limit: '200mb',
     }));

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

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

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

 app.use(express.static(process.cwd() + '/public', {}));
 // Public API
-app.use('/api/users', require('./src/endpoints/users-public').router);
+app.use('/api/users', usersPublicRouter);
 // Everything below this line requires authentication
-app.use(userModule.requireLoginMiddleware);
+app.use(requireLoginMiddleware);
 app.get('/api/ping', (_, response) => response.sendStatus(204));
 // File uploads
 app.use(multer({ dest: uploadsPath, limits: { fieldSize: 10 * 1024 * 1024 } }).single('avatar'));
-app.use(require('./src/middleware/multerMonkeyPatch'));
+app.use(multerMonkeyPatch);
 // User data mount
-app.use('/', userModule.router);
+app.use('/', userDataRouter);
 // Private endpoints
-app.use('/api/users', require('./src/endpoints/users-private').router);
+app.use('/api/users', usersPrivateRouter);
 // Admin endpoints
-app.use('/api/users', require('./src/endpoints/users-admin').router);
+app.use('/api/users', usersAdminRouter);
 app.get('/version', async function (_, response) {
     const data = await getVersion();

 redirect('/api/serpapi/visit', '/api/search/visit');
 redirect('/api/serpapi/transcript', '/api/search/transcript');
-// Moving UI
+app.use('/api/moving-ui', movingUIRouter);
-app.use('/api/moving-ui', require('./src/endpoints/moving-ui').router);
+app.use('/api/images', imagesRouter);
+app.use('/api/quick-replies', quickRepliesRouter);
-// Image management
+app.use('/api/avatars', avatarsRouter);
-app.use('/api/images', require('./src/endpoints/images').router);
+app.use('/api/themes', themesRouter);
+app.use('/api/openai', openAiRouter);
-// Quick reply management
+app.use('/api/google', googleRouter);
-app.use('/api/quick-replies', require('./src/endpoints/quick-replies').router);
+app.use('/api/anthropic', anthropicRouter);
+app.use('/api/tokenizers', tokenizersRouter);
-// Avatar management
+app.use('/api/presets', presetsRouter);
-app.use('/api/avatars', require('./src/endpoints/avatars').router);
+app.use('/api/secrets', secretsRouter);
+app.use('/thumbnail', thumbnailRouter);
-// Theme management
+app.use('/api/novelai', novelAiRouter);
-app.use('/api/themes', require('./src/endpoints/themes').router);
+app.use('/api/extensions', extensionsRouter);
+app.use('/api/assets', assetsRouter);
-// OpenAI API
+app.use('/api/files', filesRouter);
-app.use('/api/openai', require('./src/endpoints/openai').router);
+app.use('/api/characters', charactersRouter);
+app.use('/api/chats', chatsRouter);
-//Google API
+app.use('/api/groups', groupsRouter);
-app.use('/api/google', require('./src/endpoints/google').router);
+app.use('/api/worldinfo', worldInfoRouter);
+app.use('/api/stats', statsRouter);
-//Anthropic API
+app.use('/api/backgrounds', backgroundsRouter);
-app.use('/api/anthropic', require('./src/endpoints/anthropic').router);
+app.use('/api/sprites', spritesRouter);
+app.use('/api/content', contentManagerRouter);
-// Tokenizers
+app.use('/api/settings', settingsRouter);
-app.use('/api/tokenizers', require('./src/endpoints/tokenizers').router);
+app.use('/api/sd', stableDiffusionRouter);
+app.use('/api/horde', hordeRouter);
-// Preset management
+app.use('/api/vector', vectorsRouter);
-app.use('/api/presets', require('./src/endpoints/presets').router);
+app.use('/api/translate', translateRouter);
+app.use('/api/extra/classify', classifyRouter);
-// Secrets managemenet
+app.use('/api/extra/caption', captionRouter);
-app.use('/api/secrets', require('./src/endpoints/secrets').router);
+app.use('/api/search', searchRouter);
+app.use('/api/backends/text-completions', textCompletionsRouter);
-// Thumbnail generation. These URLs are saved in chat, so this route cannot be renamed!
+app.use('/api/openrouter', openRouterRouter);
-app.use('/thumbnail', require('./src/endpoints/thumbnails').router);
+app.use('/api/backends/kobold', koboldRouter);
+app.use('/api/backends/chat-completions', chatCompletionsRouter);
-// NovelAI generation
+app.use('/api/backends/scale-alt', scaleAltRouter);
-app.use('/api/novelai', require('./src/endpoints/novelai').router);
+app.use('/api/speech', speechRouter);
+app.use('/api/azure', azureRouter);
-// Third-party extensions
-app.use('/api/extensions', require('./src/endpoints/extensions').router);
-// Asset management
-app.use('/api/assets', require('./src/endpoints/assets').router);
-// File management
-app.use('/api/files', require('./src/endpoints/files').router);
-// Character management
-app.use('/api/characters', require('./src/endpoints/characters').router);
-// Chat management
-app.use('/api/chats', require('./src/endpoints/chats').router);
-// Group management
-app.use('/api/groups', require('./src/endpoints/groups').router);
-// World info management
-app.use('/api/worldinfo', require('./src/endpoints/worldinfo').router);
-// Stats calculation
-const statsEndpoint = require('./src/endpoints/stats');
-app.use('/api/stats', statsEndpoint.router);
-// Background management
-app.use('/api/backgrounds', require('./src/endpoints/backgrounds').router);
-// Character sprite management
-app.use('/api/sprites', require('./src/endpoints/sprites').router);
-// Custom content management
-app.use('/api/content', require('./src/endpoints/content-manager').router);
-// Settings load/store
-const settingsEndpoint = require('./src/endpoints/settings');
-app.use('/api/settings', settingsEndpoint.router);
-// Stable Diffusion generation
-app.use('/api/sd', require('./src/endpoints/stable-diffusion').router);
-// LLM and SD Horde generation
-app.use('/api/horde', require('./src/endpoints/horde').router);
-// Vector storage DB
-app.use('/api/vector', require('./src/endpoints/vectors').router);
-// Chat translation
-app.use('/api/translate', require('./src/endpoints/translate').router);
-// Emotion classification
-app.use('/api/extra/classify', require('./src/endpoints/classify').router);
-// Image captioning
-app.use('/api/extra/caption', require('./src/endpoints/caption').router);
-// Web search and scraping
-app.use('/api/search', require('./src/endpoints/search').router);
-// The different text generation APIs
-// Ooba/OpenAI text completions
-app.use('/api/backends/text-completions', require('./src/endpoints/backends/text-completions').router);
-// OpenRouter
-app.use('/api/openrouter', require('./src/endpoints/openrouter').router);
-// KoboldAI
-app.use('/api/backends/kobold', require('./src/endpoints/backends/kobold').router);
-// OpenAI chat completions
-app.use('/api/backends/chat-completions', require('./src/endpoints/backends/chat-completions').router);
-// Scale (alt method)
-app.use('/api/backends/scale-alt', require('./src/endpoints/backends/scale-alt').router);
-// Speech (text-to-speech and speech-to-text)
-app.use('/api/speech', require('./src/endpoints/speech').router);
-// Azure TTS
-app.use('/api/azure', require('./src/endpoints/azure').router);
 const tavernUrlV6 = new URL(
     (cliArguments.ssl ? 'https://' : 'http://') +

+    }
     console.log();
-    const directories = await userModule.getUserDirectoriesList();
+    const directories = await getUserDirectoriesList();
-    await contentManager.checkForNewContent(directories);
+    await checkForNewContent(directories);
     await ensureThumbnailCache();
     cleanUploads();
-    await settingsEndpoint.init();
+    await settingsInit();
-    await statsEndpoint.init();
+    await statsInit();
-    const cleanupPlugins = await loadPlugins();
+    const cleanupPlugins = await initializePlugins();
     const consoleTitle = process.title;
     let isExiting = false;
     const exitProcess = async () => {
         if (isExiting) return;
         isExiting = true;
-        statsEndpoint.onExit();
+        await statsOnExit();
         if (typeof cleanupPlugins === 'function') {
             await cleanupPlugins();
+        }

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

             }, app);
         server.on('error', reject);
         server.on('listening', resolve);
-        server.listen(url.port || 443, url.hostname);
+        server.listen(Number(url.port || 443), url.hostname);
     });
+}

         const server = http.createServer(app);
         server.on('error', reject);
         server.on('listening', resolve);
-        server.listen(url.port || 80, url.hostname);
+        server.listen(Number(url.port || 80), url.hostname);
     });
+}

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

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

src/additional-headers.js+20 -26 Viewed

-const { TEXTGEN_TYPES, OPENROUTER_HEADERS, FEATHERLESS_HEADERS } = require('./constants');
+import { TEXTGEN_TYPES, OPENROUTER_HEADERS, FEATHERLESS_HEADERS } from './constants.js';
-const { SECRET_KEYS, readSecret } = require('./endpoints/secrets');
+import { SECRET_KEYS, readSecret } from './endpoints/secrets.js';
-const { getConfigValue } = require('./util');
+import { getConfigValue } from './util.js';
 /**
  * Gets the headers for the Mancer API.
- * @param {import('./users').UserDirectoryList} directories User directories
+ * @param {import('./users.js').UserDirectoryList} directories User directories
  * @returns {object} Headers for the request
  */
 function getMancerHeaders(directories) {

 /**
  * Gets the headers for the TogetherAI API.
- * @param {import('./users').UserDirectoryList} directories User directories
+ * @param {import('./users.js').UserDirectoryList} directories User directories
  * @returns {object} Headers for the request
  */
 function getTogetherAIHeaders(directories) {

 /**
  * Gets the headers for the InfermaticAI API.
- * @param {import('./users').UserDirectoryList} directories User directories
+ * @param {import('./users.js').UserDirectoryList} directories User directories
  * @returns {object} Headers for the request
  */
 function getInfermaticAIHeaders(directories) {

 /**
  * Gets the headers for the DreamGen API.
- * @param {import('./users').UserDirectoryList} directories User directories
+ * @param {import('./users.js').UserDirectoryList} directories User directories
  * @returns {object} Headers for the request
  */
 function getDreamGenHeaders(directories) {

 /**
  * Gets the headers for the OpenRouter API.
- * @param {import('./users').UserDirectoryList} directories User directories
+ * @param {import('./users.js').UserDirectoryList} directories User directories
  * @returns {object} Headers for the request
  */
 function getOpenRouterHeaders(directories) {

 /**
  * Gets the headers for the vLLM API.
- * @param {import('./users').UserDirectoryList} directories User directories
+ * @param {import('./users.js').UserDirectoryList} directories User directories
  * @returns {object} Headers for the request
  */
 function getVllmHeaders(directories) {

 /**
  * Gets the headers for the Aphrodite API.
- * @param {import('./users').UserDirectoryList} directories User directories
+ * @param {import('./users.js').UserDirectoryList} directories User directories
  * @returns {object} Headers for the request
  */
 function getAphroditeHeaders(directories) {

 /**
  * Gets the headers for the Tabby API.
- * @param {import('./users').UserDirectoryList} directories User directories
+ * @param {import('./users.js').UserDirectoryList} directories User directories
  * @returns {object} Headers for the request
  */
 function getTabbyHeaders(directories) {

 /**
  * Gets the headers for the LlamaCPP API.
- * @param {import('./users').UserDirectoryList} directories User directories
+ * @param {import('./users.js').UserDirectoryList} directories User directories
  * @returns {object} Headers for the request
  */
 function getLlamaCppHeaders(directories) {

 /**
  * Gets the headers for the Ooba API.
- * @param {import('./users').UserDirectoryList} directories
+ * @param {import('./users.js').UserDirectoryList} directories
  * @returns {object} Headers for the request
  */
 function getOobaHeaders(directories) {

 /**
  * Gets the headers for the KoboldCpp API.
- * @param {import('./users').UserDirectoryList} directories
+ * @param {import('./users.js').UserDirectoryList} directories
  * @returns {object} Headers for the request
  */
 function getKoboldCppHeaders(directories) {

 /**
  * Gets the headers for the Featherless API.
- * @param {import('./users').UserDirectoryList} directories
+ * @param {import('./users.js').UserDirectoryList} directories
  * @returns {object} Headers for the request
  */
 function getFeatherlessHeaders(directories) {

 /**
  * Gets the headers for the HuggingFace API.
- * @param {import('./users').UserDirectoryList} directories
+ * @param {import('./users.js').UserDirectoryList} directories
  * @returns {object} Headers for the request
  */
 function getHuggingFaceHeaders(directories) {

     }) : {};
+}
-function getOverrideHeaders(urlHost) {
+export function getOverrideHeaders(urlHost) {
     const requestOverrides = getConfigValue('requestOverrides', []);
     const overrideHeaders = requestOverrides?.find((e) => e.hosts?.includes(urlHost))?.headers;
     if (overrideHeaders && urlHost) {

  * @param {object} args New request arguments
  * @param {string|null} server API server for new request
  */
-function setAdditionalHeaders(request, args, server) {
+export function setAdditionalHeaders(request, args, server) {
     setAdditionalHeadersByType(args.headers, request.body.api_type, server, request.user.directories);
+}

  * @param {object} requestHeaders Request headers
  * @param {string} type API type
  * @param {string|null} server API server for new request
- * @param {import('./users').UserDirectoryList} directories User directories
+ * @param {import('./users.js').UserDirectoryList} directories User directories
  */
-function setAdditionalHeadersByType(requestHeaders, type, server, directories) {
+export function setAdditionalHeadersByType(requestHeaders, type, server, directories) {
     const headerGetters = {
         [TEXTGEN_TYPES.MANCER]: getMancerHeaders,
         [TEXTGEN_TYPES.VLLM]: getVllmHeaders,

     Object.assign(requestHeaders, headers);
+}
-module.exports = {
-    getOverrideHeaders,
-    setAdditionalHeaders,
-    setAdditionalHeadersByType,
-};

src/character-card-parser.js+13 -15 Viewed

-const fs = require('fs');
+import fs from 'node:fs';
+import { Buffer } from 'node:buffer';
-const encode = require('png-chunks-encode');
+import encode from 'png-chunks-encode';
-const extract = require('png-chunks-extract');
+import extract from 'png-chunks-extract';
-const PNGtext = require('png-chunk-text');
+import PNGtext from 'png-chunk-text';
 /**
  * Writes Character metadata to a PNG image buffer.

  * @param {string} data Character data to write
  * @returns {Buffer} PNG image buffer with metadata
  */
-const write = (image, data) => {
+export const write = (image, data) => {
-    const chunks = extract(image);
+    const chunks = extract(new Uint8Array(image));
     const tEXtChunks = chunks.filter(chunk => chunk.name === 'tEXt');
     // Remove existing tEXt chunks

         const base64EncodedData = Buffer.from(JSON.stringify(v3Data), 'utf8').toString('base64');
         chunks.splice(-1, 0, PNGtext.encode('ccv3', base64EncodedData));
-    } catch (error) { }
+    } catch (error) {
+        // Ignore errors when adding v3 chunk
+    }
     const newBuffer = Buffer.from(encode(chunks));
     return newBuffer;

  * @param {Buffer} image PNG image buffer
  * @returns {string} Character data
  */
-const read = (image) => {
+export const read = (image) => {
-    const chunks = extract(image);
+    const chunks = extract(new Uint8Array(image));
     const textChunks = chunks.filter((chunk) => chunk.name === 'tEXt').map((chunk) => PNGtext.decode(chunk.data));

  * @param {string} format File format
  * @returns {string} Character data
  */
-const parse = (cardUrl, format) => {
+export const parse = (cardUrl, format) => {
     let fileFormat = format === undefined ? 'png' : format;
     switch (fileFormat) {

     throw new Error('Unsupported format');
 };
-module.exports = {
-    parse,
-    write,
-    read,
-};

src/constants.js+23 -48 Viewed

-const PUBLIC_DIRECTORIES = {
+export const PUBLIC_DIRECTORIES = {
     images: 'public/img/',
     backups: 'backups/',
     sounds: 'public/sounds',
     extensions: 'public/scripts/extensions',
 };
-const SETTINGS_FILE = 'settings.json';
+export const SETTINGS_FILE = 'settings.json';
 /**
- * @type {import('./users').UserDirectoryList}
+ * @type {import('./users.js').UserDirectoryList}
  * @readonly
  * @enum {string}
  */
-const USER_DIRECTORY_TEMPLATE = Object.freeze({
+export const USER_DIRECTORY_TEMPLATE = Object.freeze({
     root: '',
     thumbnails: 'thumbnails',
     thumbnailsBg: 'thumbnails/bg',

 });
 /**
- * @type {import('./users').User}
+ * @type {import('./users.js').User}
  * @readonly
  */
-const DEFAULT_USER = Object.freeze({
+export const DEFAULT_USER = Object.freeze({
     handle: 'default-user',
     name: 'User',
     created: Date.now(),

     salt: '',
 });
-const UNSAFE_EXTENSIONS = [
+export const UNSAFE_EXTENSIONS = [
     '.php',
     '.exe',
     '.com',

     '.ws',
 ];
-const GEMINI_SAFETY = [
+export const GEMINI_SAFETY = [
+    {
         category: 'HARM_CATEGORY_HARASSMENT',
         threshold: 'BLOCK_NONE',

     },
 ];
-const BISON_SAFETY = [
+export const BISON_SAFETY = [
+    {
         category: 'HARM_CATEGORY_DEROGATORY',
         threshold: 'BLOCK_NONE',

     },
 ];
-const CHAT_COMPLETION_SOURCES = {
+export const CHAT_COMPLETION_SOURCES = {
     OPENAI: 'openai',
     WINDOWAI: 'windowai',
     CLAUDE: 'claude',

 /**
  * Path to multer file uploads under the data root.
  */
-const UPLOADS_DIRECTORY = '_uploads';
+export const UPLOADS_DIRECTORY = '_uploads';
 // TODO: this is copied from the client code; there should be a way to de-duplicate it eventually
-const TEXTGEN_TYPES = {
+export const TEXTGEN_TYPES = {
     OOBA: 'ooba',
     MANCER: 'mancer',
     VLLM: 'vllm',

     HUGGINGFACE: 'huggingface',
 };
-const INFERMATICAI_KEYS = [
+export const INFERMATICAI_KEYS = [
     'model',
     'prompt',
     'max_tokens',

     'logprobs',
 ];
-const FEATHERLESS_KEYS = [
+export const FEATHERLESS_KEYS = [
     'model',
     'prompt',
     'best_of',

     'guided_whitespace_pattern',
 ];
 // https://dreamgen.com/docs/api#openai-text
-const DREAMGEN_KEYS = [
+export const DREAMGEN_KEYS = [
     'model',
     'prompt',
     'max_tokens',

 ];
 // https://docs.together.ai/reference/completions
-const TOGETHERAI_KEYS = [
+export const TOGETHERAI_KEYS = [
     'model',
     'prompt',
     'max_tokens',

 ];
 // https://github.com/jmorganca/ollama/blob/main/docs/api.md#request-with-options
-const OLLAMA_KEYS = [
+export const OLLAMA_KEYS = [
     'num_predict',
     'num_ctx',
     'stop',

     'min_p',
 ];
-const AVATAR_WIDTH = 512;
+export const AVATAR_WIDTH = 512;
-const AVATAR_HEIGHT = 768;
+export const AVATAR_HEIGHT = 768;
-const OPENROUTER_HEADERS = {
+export const OPENROUTER_HEADERS = {
     'HTTP-Referer': 'https://sillytavern.app',
     'X-Title': 'SillyTavern',
 };
-const FEATHERLESS_HEADERS = {
+export const FEATHERLESS_HEADERS = {
     'HTTP-Referer': 'https://sillytavern.app',
     'X-Title': 'SillyTavern',
 };
-const OPENROUTER_KEYS = [
+export const OPENROUTER_KEYS = [
     'max_tokens',
     'temperature',
     'top_k',

 ];
 // https://github.com/vllm-project/vllm/blob/0f8a91401c89ac0a8018def3756829611b57727f/vllm/entrypoints/openai/protocol.py#L220
-const VLLM_KEYS = [
+export const VLLM_KEYS = [
     'model',
     'prompt',
     'best_of',

     'guided_decoding_backend',
     'guided_whitespace_pattern',
 ];
-module.exports = {
-    DEFAULT_USER,
-    SETTINGS_FILE,
-    PUBLIC_DIRECTORIES,
-    USER_DIRECTORY_TEMPLATE,
-    UNSAFE_EXTENSIONS,
-    UPLOADS_DIRECTORY,
-    GEMINI_SAFETY,
-    BISON_SAFETY,
-    TEXTGEN_TYPES,
-    CHAT_COMPLETION_SOURCES,
-    AVATAR_WIDTH,
-    AVATAR_HEIGHT,
-    TOGETHERAI_KEYS,
-    OLLAMA_KEYS,
-    INFERMATICAI_KEYS,
-    DREAMGEN_KEYS,
-    OPENROUTER_HEADERS,
-    OPENROUTER_KEYS,
-    VLLM_KEYS,
-    FEATHERLESS_KEYS,
-    FEATHERLESS_HEADERS,
-};

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

-const { readSecret, SECRET_KEYS } = require('./secrets');
+import fetch from 'node-fetch';
-const fetch = require('node-fetch').default;
+import express from 'express';
-const express = require('express');
-const { jsonParser } = require('../express-common');
-const router = express.Router();
+import { readSecret, SECRET_KEYS } from './secrets.js';
+import { jsonParser } from '../express-common.js';
+export const router = express.Router();
 router.post('/caption-image', jsonParser, async (request, response) => {
     try {

                 'anthropic-version': '2023-06-01',
                 'x-api-key': request.body.reverse_proxy ? request.body.proxy_password : readSecret(request.user.directories, SECRET_KEYS.CLAUDE),
             },
-            timeout: 0,
         });
         if (!result.ok) {

             return response.status(result.status).send({ error: true });
+        }
+        /** @type {any} */
         const generateResponseJson = await result.json();
         const caption = generateResponseJson.content[0].text;
         console.log('Claude response:', generateResponseJson);

@@ -64,5 +65,3 @@ router.post('/caption-image', jsonParser, async (request, response) => {
64	response.status(500).send('Internal server error');	65	response.status(500).send('Internal server error');
65	}	66	}
66	});	67	});
67
68	module.exports = { router };

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

-const path = require('path');
+import path from 'node:path';
-const fs = require('fs');
+import fs from 'node:fs';
-const mime = require('mime-types');
+import { finished } from 'node:stream/promises';
-const express = require('express');
-const sanitize = require('sanitize-filename');
+import mime from 'mime-types';
-const fetch = require('node-fetch').default;
+import express from 'express';
-const { finished } = require('stream/promises');
+import sanitize from 'sanitize-filename';
-const { UNSAFE_EXTENSIONS } = require('../constants');
+import fetch from 'node-fetch';
-const { jsonParser } = require('../express-common');
-const { clientRelativePath } = require('../util');
+import { UNSAFE_EXTENSIONS } from '../constants.js';
+import { jsonParser } from '../express-common.js';
+import { clientRelativePath } from '../util.js';
 const VALID_CATEGORIES = ['bgm', 'ambient', 'blip', 'live2d', 'vrm', 'character', 'temp'];

  * @param {string} inputFilename Input filename
  * @returns {{error: boolean, message?: string}} Whether validation failed, and why if so
  */
-function validateAssetFileName(inputFilename) {
+export function validateAssetFileName(inputFilename) {
     if (!/^[a-zA-Z0-9_\-.]+$/.test(inputFilename)) {
         return {
             error: true,

 /**
  * Ensure that the asset folders exist.
- * @param {import('../users').UserDirectoryList} directories - The user's directories
+ * @param {import('../users.js').UserDirectoryList} directories - The user's directories
  */
 function ensureFoldersExist(directories) {
     const folderPath = path.join(directories.assets);

@@ -93,7 +95,7 @@ function ensureFoldersExist(directories) {
93	}	95	}
94	}	96	}
95		97
96	const router = express.Router();	98	export const router = express.Router();
97		99
98	/**	100	/**
99	* HTTP POST handler function to retrieve name of all files of a given folder path.	101	* HTTP POST handler function to retrieve name of all files of a given folder path.

@@ -366,5 +368,3 @@ router.post('/character', jsonParser, async (request, response) => {
366	return response.sendStatus(500);	368	return response.sendStatus(500);
367	}	369	}
368	});	370	});
369
370	module.exports = { router, validateAssetFileName };

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

-const express = require('express');
+import path from 'node:path';
-const path = require('path');
+import fs from 'node:fs';
-const fs = require('fs');
-const sanitize = require('sanitize-filename');
-const writeFileAtomicSync = require('write-file-atomic').sync;
-const { jsonParser, urlencodedParser } = require('../express-common');
-const { AVATAR_WIDTH, AVATAR_HEIGHT } = require('../constants');
-const { getImages, tryParse } = require('../util');
-// image processing related library imports
+import express from 'express';
-const jimp = require('jimp');
+import sanitize from 'sanitize-filename';
+import jimp from 'jimp';
+import { sync as writeFileAtomicSync } from 'write-file-atomic';
-const router = express.Router();
+import { jsonParser, urlencodedParser } from '../express-common.js';
+import { AVATAR_WIDTH, AVATAR_HEIGHT } from '../constants.js';
+import { getImages, tryParse } from '../util.js';
+export const router = express.Router();
 router.post('/get', jsonParser, function (request, response) {
     var images = getImages(request.user.directories.avatars);

@@ -58,5 +58,3 @@ router.post('/upload', urlencodedParser, async (request, response) => {
58	return response.status(400).send('Is not a valid image');	58	return response.status(400).send('Is not a valid image');
59	}	59	}
60	});	60	});
61
62	module.exports = { router };

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

-const { readSecret, SECRET_KEYS } = require('./secrets');
+import fetch from 'node-fetch';
-const fetch = require('node-fetch').default;
+import { Router } from 'express';
-const express = require('express');
-const { jsonParser } = require('../express-common');
-const router = express.Router();
+import { readSecret, SECRET_KEYS } from './secrets.js';
+import { jsonParser } from '../express-common.js';
+export const router = Router();
 router.post('/list', jsonParser, async (req, res) => {
     try {

         return res.sendStatus(500);
+    }
 });
-module.exports = {
-    router,
-};

src/endpoints/backends/chat-completions.js+44 -55 Viewed

-const express = require('express');
+import process from 'node:process';
-const fetch = require('node-fetch').default;
+import express from 'express';
+import fetch from 'node-fetch';
-const { jsonParser } = require('../../express-common');
-const { CHAT_COMPLETION_SOURCES, GEMINI_SAFETY, BISON_SAFETY, OPENROUTER_HEADERS } = require('../../constants');
+import { jsonParser } from '../../express-common.js';
-const { forwardFetchResponse, getConfigValue, tryParse, uuidv4, mergeObjectWithYaml, excludeKeysByYaml, color } = require('../../util');
+import {
-const { convertClaudeMessages, convertGooglePrompt, convertTextCompletionPrompt, convertCohereMessages, convertMistralMessages, convertAI21Messages, mergeMessages } = require('../../prompt-converters');
+    CHAT_COMPLETION_SOURCES,
+    GEMINI_SAFETY,
-const { readSecret, SECRET_KEYS } = require('../secrets');
+    BISON_SAFETY,
-const { getTokenizerModel, getSentencepiceTokenizer, getTiktokenTokenizer, sentencepieceTokenizers, TEXT_COMPLETION_MODELS } = require('../tokenizers');
+    OPENROUTER_HEADERS,
+} from '../../constants.js';
+import {
+    forwardFetchResponse,
+    getConfigValue,
+    tryParse,
+    uuidv4,
+    mergeObjectWithYaml,
+    excludeKeysByYaml,
+    color,
+} from '../../util.js';
+import {
+    convertClaudeMessages,
+    convertGooglePrompt,
+    convertTextCompletionPrompt,
+    convertCohereMessages,
+    convertMistralMessages,
+    convertAI21Messages,
+    mergeMessages,
+} from '../../prompt-converters.js';
+import { readSecret, SECRET_KEYS } from '../secrets.js';
+import {
+    getTokenizerModel,
+    getSentencepiceTokenizer,
+    getTiktokenTokenizer,
+    sentencepieceTokenizers,
+    TEXT_COMPLETION_MODELS,
+} from '../tokenizers.js';
 const API_OPENAI = 'https://api.openai.com/v1';
 const API_CLAUDE = 'https://api.anthropic.com/v1';

+}
 /**
- * Ollama strikes back. Special boy #2's steaming routine.
- * Wrap this abomination into proper SSE stream, again.
- * @param {Response} jsonStream JSON stream
- * @param {import('express').Request} request Express request
- * @param {import('express').Response} response Express response
- * @returns {Promise<any>} Nothing valuable
- */
-async function parseCohereStream(jsonStream, request, response) {
-    try {
-        const stream = new CohereStream({ stream: jsonStream.body, eventShape: { type: 'json', messageTerminator: '\n' } });
-        for await (const json of stream.iterMessages()) {
-            if (json.message) {
-                const message = json.message || 'Unknown error';
-                const chunk = { error: { message: message } };
-                response.write(`data: ${JSON.stringify(chunk)}\n\n`);
-            } else if (json.event_type === 'text-generation') {
-                const text = json.text || '';
-                const chunk = { choices: [{ text }] };
-                response.write(`data: ${JSON.stringify(chunk)}\n\n`);
-            }
-        }
-        console.log('Streaming request finished');
-        response.write('data: [DONE]\n\n');
-        response.end();
-    } catch (error) {
-        console.log('Error forwarding streaming response:', error);
-        if (!response.headersSent) {
-            return response.status(500).send({ error: true });
-        } else {
-            return response.end();
-        }
-    }
-}
-/**
  * Sends a request to Claude API.
  * @param {express.Request} request Express request
  * @param {express.Response} response Express response

                 'x-api-key': apiKey,
                 ...additionalHeaders,
             },
-            timeout: 0,
         });
         if (request.body.stream) {

                 return response.status(generateResponse.status).send({ error: true });
+            }
+            /** @type {any} */
             const generateResponseJson = await generateResponse.json();
             const responseText = generateResponseJson?.content?.[0]?.text || '';
             console.log('Claude response:', generateResponseJson);

                 'Content-Type': 'application/json',
                 'Authorization': `Basic ${apiKey}`,
             },
-            timeout: 0,
         });
         if (!generateResponse.ok) {

             return response.status(500).send({ error: true });
+        }
+        /** @type {any} */
         const generateResponseJson = await generateResponse.json();
         console.log('Scale response:', generateResponseJson);

                 'Content-Type': 'application/json',
             },
             signal: controller.signal,
-            timeout: 0,
         });
         // have to do this because of their busted ass streaming endpoint
         if (stream) {

                 return response.status(generateResponse.status).send({ error: true });
+            }
+            /** @type {any} */
             const generateResponseJson = await generateResponse.json();
             const candidates = generateResponseJson?.candidates;

@@ -626,7 +617,7 @@ async function sendCohereRequest(request, response) {
626	}	617	}
627	}	618	}
628		619
629	const router = express.Router();	620	export const router = express.Router();
630		621
631	router.post('/status', jsonParser, async function (request, response_getstatus_openai) {	622	router.post('/status', jsonParser, async function (request, response_getstatus_openai) {
632	if (!request.body) return response_getstatus_openai.sendStatus(400);	623	if (!request.body) return response_getstatus_openai.sendStatus(400);

         });
         if (response.ok) {
+            /** @type {any} */
             const data = await response.json();
             response_getstatus_openai.send(data);

         },
         body: JSON.stringify(requestBody),
         signal: controller.signal,
-        timeout: 0,
     };
     console.log(requestBody);

+            }
             if (fetchResponse.ok) {
+                /** @type {any} */
                 let json = await fetchResponse.json();
                 response.send(json);
                 console.log(json);

+    }
 });
-module.exports = {
-    router,
-};

src/endpoints/backends/kobold.js+10 -11 Viewed

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

     for (let i = 0; i < MAX_RETRIES; i++) {
         try {
             const url = request.body.streaming ? `${request.body.api_server}/extra/generate/stream` : `${request.body.api_server}/v1/generate`;
-            const response = await fetch(url, { method: 'POST', timeout: 0, ...args });
+            const response = await fetch(url, { method: 'POST', ...args });
             if (request.body.streaming) {
                 // Pipe remote SSE stream to Express response

     const result = {};
+    /** @type {any} */
     const [koboldUnitedResponse, koboldExtraResponse, koboldModelResponse] = await Promise.all([
         // We catch errors both from the response not having a successful HTTP status and from JSON parsing failing

@@ -237,5 +238,3 @@ router.post('/transcribe-audio', urlencodedParser, async function (request, resp
237	response.status(500).send('Internal server error');	238	response.status(500).send('Internal server error');
238	}	239	}
239	});	240	});
240
241	module.exports = { router };

src/endpoints/backends/scale-alt.js+6 -9 Viewed

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

                 'Content-Type': 'application/json',
                 'cookie': `_jwt=${cookie}`,
             },
-            timeout: 0,
             body: JSON.stringify(body),
         });

             return response.status(500).send({ error: { message: result.statusText } });
+        }
+        /** @type {any} */
         const data = await result.json();
         const output = data?.result?.data?.json?.outputs?.[0] || '';

@@ -97,5 +96,3 @@ router.post('/generate', jsonParser, async function (request, response) {
97	return response.sendStatus(500);	96	return response.sendStatus(500);
98	}	97	}
99	});	98	});
100
101	module.exports = { router };

src/endpoints/backends/text-completions.js+31 -19 Viewed

-const express = require('express');
+import { Readable } from 'node:stream';
-const fetch = require('node-fetch').default;
+import fetch from 'node-fetch';
-const _ = require('lodash');
+import express from 'express';
-const Readable = require('stream').Readable;
+import _ from 'lodash';
-const { jsonParser } = require('../../express-common');
+import { jsonParser } from '../../express-common.js';
-const { TEXTGEN_TYPES, TOGETHERAI_KEYS, OLLAMA_KEYS, INFERMATICAI_KEYS, OPENROUTER_KEYS, VLLM_KEYS, DREAMGEN_KEYS, FEATHERLESS_KEYS } = require('../../constants');
+import {
-const { forwardFetchResponse, trimV1, getConfigValue } = require('../../util');
+    TEXTGEN_TYPES,
-const { setAdditionalHeaders } = require('../../additional-headers');
+    TOGETHERAI_KEYS,
+    OLLAMA_KEYS,
-const router = express.Router();
+    INFERMATICAI_KEYS,
+    OPENROUTER_KEYS,
+    VLLM_KEYS,
+    DREAMGEN_KEYS,
+    FEATHERLESS_KEYS,
+} from '../../constants.js';
+import { forwardFetchResponse, trimV1, getConfigValue } from '../../util.js';
+import { setAdditionalHeaders } from '../../additional-headers.js';
+export const router = express.Router();
 /**
  * Special boy's steaming routine. Wrap this abomination into proper SSE stream.

  */
 async function parseOllamaStream(jsonStream, request, response) {
     try {
+        if (!jsonStream.body) {
+            throw new Error('No body in the response');
+        }
         let partialData = '';
         jsonStream.body.on('data', (data) => {
             const chunk = data.toString();

             return response.status(400);
+        }
+        /** @type {any} */
         let data = await modelsReply.json();
         if (request.body.legacy_api) {

                 const modelInfoReply = await fetch(modelInfoUrl, args);
                 if (modelInfoReply.ok) {
+                    /** @type {any} */
                     const modelInfo = await modelInfoReply.json();
                     console.log('Ooba model info:', modelInfo);

                 const modelInfoReply = await fetch(modelInfoUrl, args);
                 if (modelInfoReply.ok) {
+                    /** @type {any} */
                     const modelInfo = await modelInfoReply.json();
                     console.log('Tabby model info:', modelInfo);

             const completionsReply = await fetch(url, args);
             if (completionsReply.ok) {
+                /** @type {any} */
                 const data = await completionsReply.json();
                 console.log('Endpoint response:', data);

                 name: name,
                 stream: false,
             }),
-            timeout: 0,
         });
         if (!fetchResponse.ok) {

                 images: [request.body.image],
                 stream: false,
             }),
-            timeout: 0,
         });
         if (!fetchResponse.ok) {

             return response.status(500).send({ error: true });
+        }
+        /** @type {any} */
         const data = await fetchResponse.json();
         console.log('Ollama caption response:', data);

         const fetchResponse = await fetch(`${baseUrl}/completion`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
-            timeout: 0,
             body: JSON.stringify({
                 prompt: `USER:[img-1]${String(request.body.prompt).trim()}\nASSISTANT:`,
                 image_data: [{ data: request.body.image, id: 1 }],

             return response.status(500).send({ error: true });
+        }
+        /** @type {any} */
         const data = await fetchResponse.json();
         console.log('LlamaCpp caption response:', data);

         const fetchResponse = await fetch(`${baseUrl}/props`, {
             method: 'GET',
-            timeout: 0,
         });
         if (!fetchResponse.ok) {

         if (request.body.action === 'info') {
             fetchResponse = await fetch(`${baseUrl}/slots`, {
                 method: 'GET',
-                timeout: 0,
             });
         } else {
             if (!/^\d+$/.test(request.body.id_slot)) {

             fetchResponse = await fetch(`${baseUrl}/slots/${request.body.id_slot}?action=${request.body.action}`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
-                timeout: 0,
                 body: JSON.stringify({
                     filename: request.body.action !== 'erase' ? `${request.body.filename}` : undefined,
                 }),

         });
         if (permissionResponse.ok) {
+            /** @type {any} */
             const permissionJson = await permissionResponse.json();
             if (permissionJson['permission'] !== 'admin') {

 router.use('/ollama', ollama);
 router.use('/llamacpp', llamacpp);
 router.use('/tabby', tabby);
-module.exports = { router };

src/endpoints/backgrounds.js+9 -10 Viewed

-const fs = require('fs');
+import fs from 'node:fs';
-const path = require('path');
+import path from 'node:path';
-const express = require('express');
-const sanitize = require('sanitize-filename');
-const { jsonParser, urlencodedParser } = require('../express-common');
+import express from 'express';
-const { invalidateThumbnail } = require('./thumbnails');
+import sanitize from 'sanitize-filename';
-const { getImages } = require('../util');
-const router = express.Router();
+import { jsonParser, urlencodedParser } from '../express-common.js';
+import { invalidateThumbnail } from './thumbnails.js';
+import { getImages } from '../util.js';
+export const router = express.Router();
 router.post('/all', jsonParser, function (request, response) {
     var images = getImages(request.user.directories.backgrounds);

@@ -72,5 +73,3 @@ router.post('/upload', urlencodedParser, function (request, response) {
72	response.sendStatus(500);	73	response.sendStatus(500);
73	}	74	}
74	});	75	});
75
76	module.exports = { router };

src/endpoints/caption.js+6 -8 Viewed

-const express = require('express');
+import express from 'express';
-const { jsonParser } = require('../express-common');
+import { jsonParser } from '../express-common.js';
+import { getPipeline, getRawImage } from '../transformers.mjs';
 const TASK = 'image-to-text';
-const router = express.Router();
+export const router = express.Router();
 router.post('/', jsonParser, async (req, res) => {
     try {
         const { image } = req.body;
-        const module = await import('../transformers.mjs');
+        const rawImage = await getRawImage(image);
-        const rawImage = await module.default.getRawImage(image);
         if (!rawImage) {
             console.log('Failed to parse captioned image');
             return res.sendStatus(400);
+        }
-        const pipe = await module.default.getPipeline(TASK);
+        const pipe = await getPipeline(TASK);
         const result = await pipe(rawImage);
         const text = result[0].generated_text;
         console.log('Image caption:', text);

@@ -28,5 +28,3 @@ router.post('/', jsonParser, async (req, res) => {
28	return res.sendStatus(500);	28	return res.sendStatus(500);
29	}	29	}
30	});	30	});
31
32	module.exports = { router };

src/endpoints/characters.js+30 -31 Viewed

-const path = require('path');
+import path from 'node:path';
-const fs = require('fs');
+import fs from 'node:fs';
-const fsPromises = require('fs').promises;
+import { promises as fsPromises } from 'node:fs';
-const readline = require('readline');
+import readline from 'node:readline';
-const express = require('express');
+import { Buffer } from 'node:buffer';
-const sanitize = require('sanitize-filename');
-const writeFileAtomicSync = require('write-file-atomic').sync;
+import express from 'express';
-const yaml = require('yaml');
+import sanitize from 'sanitize-filename';
-const _ = require('lodash');
+import { sync as writeFileAtomicSync } from 'write-file-atomic';
-const mime = require('mime-types');
+import yaml from 'yaml';
+import _ from 'lodash';
-const jimp = require('jimp');
+import mime from 'mime-types';
+import jimp from 'jimp';
-const { AVATAR_WIDTH, AVATAR_HEIGHT } = require('../constants');
-const { jsonParser, urlencodedParser } = require('../express-common');
+import { AVATAR_WIDTH, AVATAR_HEIGHT } from '../constants.js';
-const { deepMerge, humanizedISO8601DateTime, tryParse, extractFileFromZipBuffer } = require('../util');
+import { jsonParser, urlencodedParser } from '../express-common.js';
-const { TavernCardValidator } = require('../validator/TavernCardValidator');
+import { deepMerge, humanizedISO8601DateTime, tryParse, extractFileFromZipBuffer } from '../util.js';
-const characterCardParser = require('../character-card-parser.js');
+import { TavernCardValidator } from '../validator/TavernCardValidator.js';
-const { readWorldInfoFile } = require('./worldinfo');
+import { parse, write } from '../character-card-parser.js';
-const { invalidateThumbnail } = require('./thumbnails');
+import { readWorldInfoFile } from './worldinfo.js';
-const { importRisuSprites } = require('./sprites');
+import { invalidateThumbnail } from './thumbnails.js';
+import { importRisuSprites } from './sprites.js';
 const defaultAvatarPath = './public/img/ai4.png';
 // KV-store for parsed character data

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

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

  * processCharacter - Process a given character, read its data and calculate its statistics.
+ *
  * @param  {string} item The name of the character.
- * @param  {import('../users').UserDirectoryList} directories User directories
+ * @param  {import('../users.js').UserDirectoryList} directories User directories
  * @return {Promise<object>}     A Promise that resolves when the character processing is done.
  */
 const processCharacter = async (item, directories) => {

 /**
  * Convert a character object to Spec V2 format.
  * @param {object} jsonObject Character object
- * @param {import('../users').UserDirectoryList} directories User directories
+ * @param {import('../users.js').UserDirectoryList} directories User directories
  * @param {boolean} hoistDate Will set the chat and create_date fields to the current date if they are missing
  * @returns {object} Character object in Spec V2 format
  */

 /**
  * Convert a character object to Spec V2 format.
  * @param {object} char Character object
- * @param {import('../users').UserDirectoryList} directories User directories
+ * @param {import('../users.js').UserDirectoryList} directories User directories
  * @returns {object} Character object in Spec V2 format
  */
 function convertToV2(char, directories) {

 /**
  * Format character data to Spec V2 format.
  * @param {object} data Character data
- * @param {import('../users').UserDirectoryList} directories User directories
+ * @param {import('../users.js').UserDirectoryList} directories User directories
  * @returns
  */
 function charaFormatData(data, directories) {

     return '';
+}
-const router = express.Router();
+export const router = express.Router();
 router.post('/create', urlencodedParser, async function (request, response) {
     try {

 /**
  * Gets the name for the uploaded PNG file.
  * @param {string} file File name
- * @param {import('../users').UserDirectoryList} directories User directories
+ * @param {import('../users.js').UserDirectoryList} directories User directories
  * @returns {string} - The name for the uploaded PNG file
  */
 function getPngName(file, directories) {

@@ -1231,5 +1232,3 @@ router.post('/export', jsonParser, async function (request, response) {
1231	response.sendStatus(500);	1232	response.sendStatus(500);
1232	}	1233	}
1233	});	1234	});
1234
1235	module.exports = { router };

src/endpoints/chats.js+12 -12 Viewed

-const fs = require('fs');
+import fs from 'node:fs';
-const path = require('path');
+import path from 'node:path';
-const readline = require('readline');
+import readline from 'node:readline';
-const express = require('express');
+import process from 'node:process';
-const sanitize = require('sanitize-filename');
-const writeFileAtomicSync = require('write-file-atomic').sync;
-const _ = require('lodash');
-const { jsonParser, urlencodedParser } = require('../express-common');
+import express from 'express';
-const { getConfigValue, humanizedISO8601DateTime, tryParse, generateTimestamp, removeOldBackups } = require('../util');
+import sanitize from 'sanitize-filename';
+import { sync as writeFileAtomicSync } from 'write-file-atomic';
+import _ from 'lodash';
+import { jsonParser, urlencodedParser } from '../express-common.js';
+import { getConfigValue, humanizedISO8601DateTime, tryParse, generateTimestamp, removeOldBackups } from '../util.js';
 /**
  * Saves a chat to the backups directory.

     return (lines ?? []).map(convert).join('\n');
+}
-const router = express.Router();
+export const router = express.Router();
 router.post('/save', jsonParser, function (request, response) {
     try {

     getBackupFunction(request.user.profile.handle)(request.user.directories.backups, String(id), jsonlData);
     return response.send({ ok: true });
 });
-module.exports = { router };

src/endpoints/classify.js+7 -9 Viewed

-const express = require('express');
+import express from 'express';
-const { jsonParser } = require('../express-common');
+import { getPipeline } from '../transformers.mjs';
+import { jsonParser } from '../express-common.js';
 const TASK = 'text-classification';
-const router = express.Router();
+export const router = express.Router();
 /**
  * @type {Map<string, object>} Cache for classification results

 router.post('/labels', jsonParser, async (req, res) => {
     try {
-        const module = await import('../transformers.mjs');
+        const pipe = await getPipeline(TASK);
-        const pipe = await module.default.getPipeline(TASK);
         const result = Object.keys(pipe.model.config.label2id);
         return res.json({ labels: result });
     } catch (error) {

             if (cacheObject.has(text)) {
                 return cacheObject.get(text);
             } else {
-                const module = await import('../transformers.mjs');
+                const pipe = await getPipeline(TASK);
-                const pipe = await module.default.getPipeline(TASK);
                 const result = await pipe(text, { topk: 5 });
                 result.sort((a, b) => b.score - a.score);
                 cacheObject.set(text, result);

@@ -54,5 +54,3 @@ router.post('/', jsonParser, async (req, res) => {
54	return res.sendStatus(500);	54	return res.sendStatus(500);
55	}	55	}
56	});	56	});
57
58	module.exports = { router };

src/endpoints/content-manager.js+27 -29 Viewed

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

  * @typedef {string} ContentType
  * @enum {string}
  */
-const CONTENT_TYPES = {
+export const CONTENT_TYPES = {
     SETTINGS: 'settings',
     CHARACTER: 'character',
     SPRITES: 'sprites',

 /**
  * Gets the default presets from the content directory.
- * @param {import('../users').UserDirectoryList} directories User directories
+ * @param {import('../users.js').UserDirectoryList} directories User directories
  * @returns {object[]} Array of default presets
  */
-function getDefaultPresets(directories) {
+export function getDefaultPresets(directories) {
     try {
         const contentIndex = getContentIndex();
         const presets = [];

  * @param {string} filename Name of the file to get
  * @returns {object | null} JSON object or null if the file doesn't exist
  */
-function getDefaultPresetFile(filename) {
+export function getDefaultPresetFile(filename) {
     try {
         const contentPath = path.join(contentDirectory, filename);

 /**
  * Seeds content for a user.
  * @param {ContentItem[]} contentIndex Content index
- * @param {import('../users').UserDirectoryList} directories User directories
+ * @param {import('../users.js').UserDirectoryList} directories User directories
  * @param {string[]} forceCategories List of categories to force check (even if content check is skipped)
  * @returns {Promise<boolean>} Whether any content was added
  */

 /**
  * Checks for new content and seeds it for all users.
- * @param {import('../users').UserDirectoryList[]} directoriesList List of user directories
+ * @param {import('../users.js').UserDirectoryList[]} directoriesList List of user directories
  * @param {string[]} forceCategories List of categories to force check (even if content check is skipped)
  * @returns {Promise<void>}
  */
-async function checkForNewContent(directoriesList, forceCategories = []) {
+export async function checkForNewContent(directoriesList, forceCategories = []) {
     try {
         const contentCheckSkip = getConfigValue('skipContentCheck', false);
         if (contentCheckSkip && forceCategories?.length === 0) {

  * @param {'json'|'string'|'raw'} format Format of content
  * @returns {string[]|Buffer[]} Array of content
  */
-function getContentOfType(type, format) {
+export function getContentOfType(type, format) {
     const contentIndex = getContentIndex();
     const indexItems = contentIndex.filter((item) => item.type === type && item.folder);
     const files = [];

 /**
  * Gets the target directory for the specified asset type.
  * @param {ContentType} type Asset type
- * @param {import('../users').UserDirectoryList} directories User directories
+ * @param {import('../users.js').UserDirectoryList} directories User directories
  * @returns {string | null} Target directory
  */
 function getTargetByType(type, directories) {

         throw new Error('Failed to download character');
+    }
+    /** @type {any} */
     const jsonData = await result.json();
     const characterData = jsonData?.character;

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

     });
     if (result.ok) {
+        /** @type {any} */
         const downloadResult = await result.json();
         if (downloadResult.status === 'ok') {
             const imageResult = await fetch(downloadResult.downloadUrl);

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

         return response.sendStatus(500);
+    }
 });
-module.exports = {
-    CONTENT_TYPES,
-    checkForNewContent,
-    getDefaultPresets,
-    getDefaultPresetFile,
-    getContentOfType,
-    router,
-};

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

-const path = require('path');
+import path from 'node:path';
-const fs = require('fs');
+import fs from 'node:fs';
-const express = require('express');
-const { default: simpleGit } = require('simple-git');
+import express from 'express';
-const sanitize = require('sanitize-filename');
+import sanitize from 'sanitize-filename';
-const { PUBLIC_DIRECTORIES } = require('../constants');
+import { default as simpleGit } from 'simple-git';
-const { jsonParser } = require('../express-common');
+import { PUBLIC_DIRECTORIES } from '../constants.js';
+import { jsonParser } from '../express-common.js';
 /**
  * This function extracts the extension information from the manifest file.

     };
+}
-const router = express.Router();
+export const router = express.Router();
 /**
  * HTTP POST handler function to clone a git repository from a provided URL, read the extension manifest,

     return response.send(extensions);
 });
-module.exports = { router };

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

-const path = require('path');
+import path from 'node:path';
-const fs = require('fs');
+import fs from 'node:fs';
-const writeFileSyncAtomic = require('write-file-atomic').sync;
-const express = require('express');
+import express from 'express';
-const sanitize = require('sanitize-filename');
+import sanitize from 'sanitize-filename';
-const router = express.Router();
+import { sync as writeFileSyncAtomic } from 'write-file-atomic';
-const { validateAssetFileName } = require('./assets');
-const { jsonParser } = require('../express-common');
+import { validateAssetFileName } from './assets.js';
-const { clientRelativePath } = require('../util');
+import { jsonParser } from '../express-common.js';
+import { clientRelativePath } from '../util.js';
+export const router = express.Router();
 router.post('/sanitize-filename', jsonParser, async (request, response) => {
     try {

@@ -97,5 +100,3 @@ router.post('/verify', jsonParser, async (request, response) => {
97	return response.sendStatus(500);	100	return response.sendStatus(500);
98	}	101	}
99	});	102	});
100
101	module.exports = { router };

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

-const { readSecret, SECRET_KEYS } = require('./secrets');
+import fetch from 'node-fetch';
-const fetch = require('node-fetch').default;
+import express from 'express';
-const express = require('express');
-const { jsonParser } = require('../express-common');
+import { readSecret, SECRET_KEYS } from './secrets.js';
-const { GEMINI_SAFETY } = require('../constants');
+import { jsonParser }  from '../express-common.js';
+import { GEMINI_SAFETY } from '../constants.js';
 const API_MAKERSUITE = 'https://generativelanguage.googleapis.com';
-const router = express.Router();
+export const router = express.Router();
 router.post('/caption-image', jsonParser, async (request, response) => {
     try {

             headers: {
                 'Content-Type': 'application/json',
             },
-            timeout: 0,
         });
         if (!result.ok) {

             return response.status(result.status).send({ error: true });
+        }
+        /** @type {any} */
         const data = await result.json();
         console.log('Multimodal captioning response', data);

@@ -67,5 +68,3 @@ router.post('/caption-image', jsonParser, async (request, response) => {
67	response.status(500).send('Internal server error');	68	response.status(500).send('Internal server error');
68	}	69	}
69	});	70	});
70
71	module.exports = { router };

src/endpoints/groups.js+9 -10 Viewed

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

     return response.send({ ok: true });
 });
-module.exports = { router };

src/endpoints/horde.js+7 -9 Viewed

-const fetch = require('node-fetch').default;
+import fetch from 'node-fetch';
-const express = require('express');
+import express from 'express';
-const { AIHorde, ModelGenerationInputStableSamplers, ModelInterrogationFormTypes, HordeAsyncRequestStates } = require('@zeldafan0225/ai_horde');
+import { AIHorde, ModelGenerationInputStableSamplers, ModelInterrogationFormTypes, HordeAsyncRequestStates } from '@zeldafan0225/ai_horde';
-const { getVersion, delay, Cache } = require('../util');
+import { getVersion, delay, Cache } from '../util.js';
-const { readSecret, SECRET_KEYS } = require('./secrets');
+import { readSecret, SECRET_KEYS } from './secrets.js';
-const { jsonParser } = require('../express-common');
+import { jsonParser } from '../express-common.js';
 const ANONYMOUS_KEY = '0000000000';
 const HORDE_TEXT_MODEL_METADATA_URL = 'https://raw.githubusercontent.com/db0/AI-Horde-text-model-reference/main/db.json';
 const cache = new Cache(60 * 1000);
-const router = express.Router();
+export const router = express.Router();
 /**
  * Returns the AIHorde client agent.

@@ -403,5 +403,3 @@ router.post('/generate-image', jsonParser, async (request, response) => {
403	return response.sendStatus(500);	403	return response.sendStatus(500);
404	}	404	}
405	});	405	});
406
407	module.exports = { router };

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

-const fs = require('fs');
+import fs from 'node:fs';
-const path = require('path');
+import path from 'node:path';
-const express = require('express');
+import { Buffer } from 'node:buffer';
-const sanitize = require('sanitize-filename');
-const { jsonParser } = require('../express-common');
+import express from 'express';
-const { clientRelativePath, removeFileExtension, getImages } = require('../util');
+import sanitize from 'sanitize-filename';
+import { jsonParser } from '../express-common.js';
+import { clientRelativePath, removeFileExtension, getImages } from '../util.js';
 /**
  * Ensure the directory for the provided file path exists.

     fs.mkdirSync(dirname);
+}
-const router = express.Router();
+export const router = express.Router();
 /**
  * Endpoint to handle image uploads.

         ensureDirectoryExistence(pathToNewFile);
         const imageBuffer = Buffer.from(base64Data, 'base64');
-        await fs.promises.writeFile(pathToNewFile, imageBuffer);
+        await fs.promises.writeFile(pathToNewFile, new Uint8Array(imageBuffer));
         response.send({ path: clientRelativePath(request.user.directories.root, pathToNewFile) });
     } catch (error) {
         console.log(error);

@@ -89,5 +91,3 @@ router.post('/list/:folder', (request, response) => {
89	return response.status(500).send({ error: 'Unable to retrieve files' });	91	return response.status(500).send({ error: 'Unable to retrieve files' });
90	}	92	}
91	});	93	});
92
93	module.exports = { router };

src/endpoints/moving-ui.js+6 -8 Viewed

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

     return response.sendStatus(200);
 });
-module.exports = { router };

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

-const fetch = require('node-fetch').default;
+import util from 'node:util';
-const express = require('express');
+import { Buffer } from 'node:buffer';
-const util = require('util');
-const { readSecret, SECRET_KEYS } = require('./secrets');
+import fetch from 'node-fetch';
-const { readAllChunks, extractFileFromZipBuffer, forwardFetchResponse } = require('../util');
+import express from 'express';
-const { jsonParser } = require('../express-common');
+import { readSecret, SECRET_KEYS } from './secrets.js';
+import { readAllChunks, extractFileFromZipBuffer, forwardFetchResponse } from '../util.js';
+import { jsonParser } from '../express-common.js';
 const API_NOVELAI = 'https://api.novelai.net';
 const TEXT_NOVELAI = 'https://text.novelai.net';

     return null;
+}
-const router = express.Router();
+export const router = express.Router();
 router.post('/status', jsonParser, async function (req, res) {
     if (!req.body) return res.sendStatus(400);

     try {
         const baseURL = (req.body.model.includes('kayra') || req.body.model.includes('erato')) ? TEXT_NOVELAI : API_NOVELAI;
         const url = req.body.streaming ? `${baseURL}/ai/generate-stream` : `${baseURL}/ai/generate`;
-        const response = await fetch(url, { method: 'POST', timeout: 0, ...args });
+        const response = await fetch(url, { method: 'POST', ...args });
         if (req.body.streaming) {
             // Pipe remote SSE stream to Express response

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

                 'Authorization': `Bearer ${token}`,
                 'Accept': 'audio/mpeg',
             },
-            timeout: 0,
         });
         if (!result.ok) {

@@ -423,7 +426,7 @@ router.post('/generate-voice', jsonParser, async (request, response) => {
423	}	426	}
424		427
425	const chunks = await readAllChunks(result.body);	428	const chunks = await readAllChunks(result.body);
426	const buffer = Buffer.concat(chunks);	429	const buffer = Buffer.concat(chunks.map(chunk => new Uint8Array(chunk)));
427	response.setHeader('Content-Type', 'audio/mpeg');	430	response.setHeader('Content-Type', 'audio/mpeg');
428	return response.send(buffer);	431	return response.send(buffer);
429	}	432	}

@@ -432,5 +435,3 @@ router.post('/generate-voice', jsonParser, async (request, response) => {
432	return response.sendStatus(500);	435	return response.sendStatus(500);
433	}	436	}
434	});	437	});
435
436	module.exports = { router };

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

-const { readSecret, SECRET_KEYS } = require('./secrets');
+import fs from 'node:fs';
-const fetch = require('node-fetch').default;
+import { Buffer } from 'node:buffer';
-const express = require('express');
-const FormData = require('form-data');
+import fetch from 'node-fetch';
-const fs = require('fs');
+import FormData from 'form-data';
-const { jsonParser, urlencodedParser } = require('../express-common');
+import express from 'express';
-const { getConfigValue, mergeObjectWithYaml, excludeKeysByYaml, trimV1 } = require('../util');
-const { setAdditionalHeaders } = require('../additional-headers');
+import { jsonParser, urlencodedParser } from '../express-common.js';
-const { OPENROUTER_HEADERS } = require('../constants');
+import { getConfigValue, mergeObjectWithYaml, excludeKeysByYaml, trimV1 } from '../util.js';
+import { setAdditionalHeaders } from '../additional-headers.js';
-const router = express.Router();
+import { readSecret, SECRET_KEYS } from './secrets.js';
+import { OPENROUTER_HEADERS } from '../constants.js';
+export const router = express.Router();
 router.post('/caption-image', jsonParser, async (request, response) => {
     try {

                 ...headers,
             },
             body: JSON.stringify(body),
-            timeout: 0,
         });
         if (!result.ok) {

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

                 Authorization: `Bearer ${key}`,
             },
             body: JSON.stringify(request.body),
-            timeout: 0,
         });
         if (!result.ok) {

 });
 router.use('/custom', custom);
-module.exports = { router };

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

-const express = require('express');
+import express from 'express';
-const { jsonParser } = require('../express-common');
+import { jsonParser } from '../express-common.js';
-const router = express.Router();
+export const router = express.Router();
 const API_OPENROUTER = 'https://openrouter.ai/api/v1';
 router.post('/models/multimodal', jsonParser, async (_req, res) => {

@@ -28,5 +28,3 @@ router.post('/models/multimodal', jsonParser, async (_req, res) => {
28	return res.sendStatus(500);	28	return res.sendStatus(500);
29	}	29	}
30	});	30	});
31
32	module.exports = { router };

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

-const fs = require('fs');
+import fs from 'node:fs';
-const path = require('path');
+import path from 'node:path';
-const express = require('express');
-const sanitize = require('sanitize-filename');
+import express from 'express';
-const writeFileAtomicSync = require('write-file-atomic').sync;
+import sanitize from 'sanitize-filename';
-const { getDefaultPresetFile, getDefaultPresets } = require('./content-manager');
+import { sync as writeFileAtomicSync } from 'write-file-atomic';
-const { jsonParser } = require('../express-common');
+import { getDefaultPresetFile, getDefaultPresets } from './content-manager.js';
+import { jsonParser } from '../express-common.js';
 /**
  * Gets the folder and extension for the preset settings based on the API source ID.
  * @param {string} apiId API source ID
- * @param {import('../users').UserDirectoryList} directories User directories
+ * @param {import('../users.js').UserDirectoryList} directories User directories
  * @returns {object} Object containing the folder and extension for the preset settings
  */
 function getPresetSettingsByAPI(apiId, directories) {

@@ -34,7 +36,7 @@ function getPresetSettingsByAPI(apiId, directories) {
34	}	36	}
35	}	37	}
36		38
37	const router = express.Router();	39	export const router = express.Router();
38		40
39	router.post('/save', jsonParser, function (request, response) {	41	router.post('/save', jsonParser, function (request, response) {
40	const name = sanitize(request.body.name);	42	const name = sanitize(request.body.name);

     return response.send({ error: true });
 });
-module.exports = { router };

src/endpoints/quick-replies.js+8 -9 Viewed

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

     return response.sendStatus(200);
 });
-module.exports = { router };

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

-const fetch = require('node-fetch').default;
+import fetch from 'node-fetch';
-const express = require('express');
+import express from 'express';
-const { readSecret, SECRET_KEYS } = require('./secrets');
-const { jsonParser } = require('../express-common');
-const router = express.Router();
+import { decode } from 'html-entities';
+import { readSecret, SECRET_KEYS } from './secrets.js';
+import { jsonParser } from '../express-common.js';
+export const router = express.Router();
 // Cosplay as Chrome
 const visitHeaders = {

  * @returns {Promise<string>} Transcript text
  */
 async function extractTranscript(videoPageBody, lang) {
-    const he = require('he');
     const RE_XML_TRANSCRIPT = /<text start="([^"]*)" dur="([^"]*)">([^<]*)<\/text>/g;
     const splittedHTML = videoPageBody.split('"captions":');

         lang: lang ?? captions.captionTracks[0].languageCode,
     }));
     // The text is double-encoded
-    const transcriptText = transcript.map((line) => he.decode(he.decode(line.text))).join(' ');
+    const transcriptText = transcript.map((line) => decode(decode(line.text))).join(' ');
     return transcriptText;
+}

@@ -263,5 +264,3 @@ router.post('/visit', jsonParser, async (request, response) => {
263	return response.sendStatus(500);	264	return response.sendStatus(500);
264	}	265	}
265	});	266	});
266
267	module.exports = { router };

src/endpoints/secrets.js+21 -30 Viewed

-const fs = require('fs');
+import fs from 'node:fs';
-const path = require('path');
+import path from 'node:path';
-const express = require('express');
-const { getConfigValue } = require('../util');
+import express from 'express';
-const writeFileAtomicSync = require('write-file-atomic').sync;
+import { sync as writeFileAtomicSync } from 'write-file-atomic';
-const { jsonParser } = require('../express-common');
+import { getConfigValue } from '../util.js';
+import { jsonParser } from '../express-common.js';
-const SECRETS_FILE = 'secrets.json';
-const SECRET_KEYS = {
+export const SECRETS_FILE = 'secrets.json';
+export const SECRET_KEYS = {
     HORDE: 'api_key_horde',
     MANCER: 'api_key_mancer',
     VLLM: 'api_key_vllm',

 /**
  * Writes a secret to the secrets file
- * @param {import('../users').UserDirectoryList} directories User directories
+ * @param {import('../users.js').UserDirectoryList} directories User directories
  * @param {string} key Secret key
  * @param {string} value Secret value
  */
-function writeSecret(directories, key, value) {
+export function writeSecret(directories, key, value) {
     const filePath = path.join(directories.root, SECRETS_FILE);
     if (!fs.existsSync(filePath)) {

 /**
  * Deletes a secret from the secrets file
- * @param {import('../users').UserDirectoryList} directories User directories
+ * @param {import('../users.js').UserDirectoryList} directories User directories
  * @param {string} key Secret key
  * @returns
  */
-function deleteSecret(directories, key) {
+export function deleteSecret(directories, key) {
     const filePath = path.join(directories.root, SECRETS_FILE);
     if (!fs.existsSync(filePath)) {

 /**
  * Reads a secret from the secrets file
- * @param {import('../users').UserDirectoryList} directories User directories
+ * @param {import('../users.js').UserDirectoryList} directories User directories
  * @param {string} key Secret key
  * @returns {string} Secret value
  */
-function readSecret(directories, key) {
+export function readSecret(directories, key) {
     const filePath = path.join(directories.root, SECRETS_FILE);
     if (!fs.existsSync(filePath)) {

 /**
  * Reads the secret state from the secrets file
- * @param {import('../users').UserDirectoryList} directories User directories
+ * @param {import('../users.js').UserDirectoryList} directories User directories
  * @returns {object} Secret state
  */
-function readSecretState(directories) {
+export function readSecretState(directories) {
     const filePath = path.join(directories.root, SECRETS_FILE);
     if (!fs.existsSync(filePath)) {

 /**
  * Reads all secrets from the secrets file
- * @param {import('../users').UserDirectoryList} directories User directories
+ * @param {import('../users.js').UserDirectoryList} directories User directories
  * @returns {Record<string, string> | undefined} Secrets
  */
-function getAllSecrets(directories) {
+export function getAllSecrets(directories) {
     const filePath = path.join(directories.root, SECRETS_FILE);
     if (!fs.existsSync(filePath)) {

     return secrets;
+}
-const router = express.Router();
+export const router = express.Router();
 router.post('/write', jsonParser, (request, response) => {
     const key = request.body.key;

         return response.sendStatus(500);
+    }
 });
-module.exports = {
-    writeSecret,
-    readSecret,
-    deleteSecret,
-    readSecretState,
-    getAllSecrets,
-    SECRET_KEYS,
-    router,
-};

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

-const fs = require('fs');
+import fs from 'node:fs';
-const path = require('path');
+import path from 'node:path';
-const express = require('express');
-const _ = require('lodash');
+import express from 'express';
-const writeFileAtomicSync = require('write-file-atomic').sync;
+import _ from 'lodash';
-const { SETTINGS_FILE } = require('../constants');
+import { sync as writeFileAtomicSync } from 'write-file-atomic';
-const { getConfigValue, generateTimestamp, removeOldBackups } = require('../util');
-const { jsonParser } = require('../express-common');
+import { SETTINGS_FILE } from '../constants.js';
-const { getAllUserHandles, getUserDirectories } = require('../users');
+import { getConfigValue, generateTimestamp, removeOldBackups } from '../util.js';
+import { jsonParser } from '../express-common.js';
+import { getAllUserHandles, getUserDirectories } from '../users.js';
 const ENABLE_EXTENSIONS = getConfigValue('enableExtensions', true);
 const ENABLE_EXTENSIONS_AUTO_UPDATE = getConfigValue('enableExtensionsAutoUpdate', true);

     return path.join(userDirectories.backups, latestBackup);
+}
-const router = express.Router();
+export const router = express.Router();
 router.post('/save', jsonParser, function (request, response) {
     try {

 /**
  * Initializes the settings endpoint
  */
-async function init() {
+export async function init() {
     await backupSettings();
+}
-module.exports = { router, init };

src/endpoints/speech.js+8 -11 Viewed

-const express = require('express');
+import { Buffer } from 'node:buffer';
-const { jsonParser } = require('../express-common');
+import express from 'express';
+import wavefile from 'wavefile';
+import { jsonParser } from '../express-common.js';
+import { getPipeline } from '../transformers.mjs';
-const router = express.Router();
+export const router = express.Router();
 /**
  * Gets the audio data from a base64-encoded audio file.

  * @returns {Float64Array} Audio data
  */
 function getWaveFile(audio) {
-    const wavefile = require('wavefile');
     const wav = new wavefile.WaveFile();
     wav.fromDataURI(audio);
     wav.toBitDepth('32f');

     try {
         const TASK = 'automatic-speech-recognition';
         const { model, audio, lang } = req.body;
-        const module = await import('../transformers.mjs');
+        const pipe = await getPipeline(TASK, model);
-        const pipe = await module.default.getPipeline(TASK, model);
         const wav = getWaveFile(audio);
         const start = performance.now();
         const result = await pipe(wav, { language: lang || null, task: 'transcribe' });

 router.post('/synthesize', jsonParser, async (req, res) => {
     try {
-        const wavefile = require('wavefile');
         const TASK = 'text-to-speech';
         const { text, model, speaker } = req.body;
-        const module = await import('../transformers.mjs');
+        const pipe = await getPipeline(TASK, model);
-        const pipe = await module.default.getPipeline(TASK, model);
         const speaker_embeddings = speaker
             ? new Float32Array(new Uint8Array(Buffer.from(speaker.startsWith('data:') ? speaker.split(',')[1] : speaker, 'base64')).buffer)
             : null;

@@ -78,5 +77,3 @@ router.post('/synthesize', jsonParser, async (req, res) => {
78	return res.sendStatus(500);	77	return res.sendStatus(500);
79	}	78	}
80	});	79	});
81
82	module.exports = { router };

src/endpoints/sprites.js+13 -17 Viewed

+import fs from 'node:fs';
+import path from 'node:path';
-const fs = require('fs');
+import express from 'express';
-const path = require('path');
+import mime from 'mime-types';
-const express = require('express');
+import sanitize from 'sanitize-filename';
-const mime = require('mime-types');
+import { sync as writeFileAtomicSync } from 'write-file-atomic';
-const sanitize = require('sanitize-filename');
-const writeFileAtomicSync = require('write-file-atomic').sync;
+import { getImageBuffers } from '../util.js';
-const { getImageBuffers } = require('../util');
+import { jsonParser, urlencodedParser } from '../express-common.js';
-const { jsonParser, urlencodedParser } = require('../express-common');
 /**
  * Gets the path to the sprites folder for the provided character name
- * @param {import('../users').UserDirectoryList} directories - User directories
+ * @param {import('../users.js').UserDirectoryList} directories - User directories
  * @param {string} name - The name of the character
  * @param {boolean} isSubfolder - Whether the name contains a subfolder
  * @returns {string | null} The path to the sprites folder. Null if the name is invalid.

  * Imports base64 encoded sprites from RisuAI character data.
  * The sprites are saved in the character's sprites folder.
  * The additionalAssets and emotions are removed from the data.
- * @param {import('../users').UserDirectoryList} directories User directories
+ * @param {import('../users.js').UserDirectoryList} directories User directories
  * @param {object} data RisuAI character data
  * @returns {void}
  */
-function importRisuSprites(directories, data) {
+export function importRisuSprites(directories, data) {
     try {
         const name = data?.data?.name;
         const risuData = data?.data?.extensions?.risuai;

@@ -106,7 +107,7 @@ function importRisuSprites(directories, data) {
106	}	107	}
107	}	108	}
108		109
109	const router = express.Router();	110	export const router = express.Router();
110		111
111	router.get('/get', jsonParser, function (request, response) {	112	router.get('/get', jsonParser, function (request, response) {
112	const name = String(request.query.name);	113	const name = String(request.query.name);

         return response.sendStatus(500);
+    }
 });
-module.exports = {
-    router,
-    importRisuSprites,
-};

src/endpoints/stable-diffusion.js+33 -19 Viewed

-const express = require('express');
+import fs from 'node:fs';
-const fetch = require('node-fetch').default;
+import path from 'node:path';
-const sanitize = require('sanitize-filename');
-const { getBasicAuthHeader, delay, getHexString } = require('../util.js');
+import express from 'express';
-const fs = require('fs');
+import fetch from 'node-fetch';
-const path = require('path');
+import sanitize from 'sanitize-filename';
-const writeFileAtomicSync = require('write-file-atomic').sync;
+import { sync as writeFileAtomicSync } from 'write-file-atomic';
-const { jsonParser } = require('../express-common');
+import FormData from 'form-data';
-const { readSecret, SECRET_KEYS } = require('./secrets.js');
-const FormData = require('form-data');
+import { getBasicAuthHeader, delay } from '../util.js';
+import { jsonParser } from '../express-common.js';
+import { readSecret, SECRET_KEYS } from './secrets.js';
 /**
  * Gets the comfy workflows.

         .sort(Intl.Collator().compare);
+}
-const router = express.Router();
+export const router = express.Router();
 router.post('/ping', jsonParser, async (request, response) => {
     try {

                 throw new Error('SD WebUI returned an error.');
+            }
+            /** @type {any} */
             const data = await result.json();
             const names = data.map(x => x.name);
             return names;

                 throw new Error('SD WebUI returned an error.');
+            }
+            /** @type {any} */
             const data = await result.json();
             const names = data.map(x => x.name);
             return names;

             throw new Error('SD WebUI returned an error.');
+        }
+        /** @type {any} */
         const data = await result.json();
         const names = data.map(x => x.model_name);
         return response.send(names);

             throw new Error('SD WebUI returned an error.');
+        }
+        /** @type {any} */
         const data = await result.json();
         const names = data.map(x => x.name);
         return response.send(names);

             throw new Error('SD WebUI returned an error.');
+        }
+        /** @type {any} */
         const data = await result.json();
         const names = data.map(x => x.name);
         return response.send(names);

             throw new Error('SD WebUI returned an error.');
+        }
+        /** @type {any} */
         const data = await result.json();
         const models = data.map(x => ({ value: x.title, text: x.title }));
         return response.send(models);

                 'Authorization': getBasicAuthHeader(request.body.auth),
             },
         });
+        /** @type {any} */
         const data = await result.json();
         return response.send(data['sd_model_checkpoint']);
     } catch (error) {

                 headers: {
                     'Authorization': getBasicAuthHeader(request.body.auth),
                 },
-                timeout: 0,
             });
             const data = await result.json();
             return data;

                 'Content-Type': 'application/json',
                 'Authorization': getBasicAuthHeader(request.body.auth),
             },
-            timeout: 0,
         });
         if (!result.ok) {

         const CHECK_INTERVAL = 2000;
         for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+            /** @type {any} */
             const progressState = await getProgress();
             const progress = progressState['progress'];

                 'Content-Type': 'application/json',
                 'Authorization': getBasicAuthHeader(request.body.auth),
             },
-            timeout: 0,
-            // @ts-ignore
             signal: controller.signal,
         });

         // Vlad doesn't provide Latent Upscalers in the API, so we have to hardcode them here
         const latentUpscalers = ['Latent', 'Latent (antialiased)', 'Latent (bicubic)', 'Latent (bicubic antialiased)', 'Latent (nearest)', 'Latent (nearest-exact)'];
+        /** @type {any} */
         const data = await result.json();
         const names = data.map(x => x.name);

             throw new Error('ComfyUI returned an error.');
+        }
+        /** @type {any} */
         const data = await result.json();
         return response.send(data.KSampler.input.required.sampler_name[0]);
     } catch (error) {

         if (!result.ok) {
             throw new Error('ComfyUI returned an error.');
+        }
+        /** @type {any} */
         const data = await result.json();
         return response.send(data.CheckpointLoaderSimple.input.required.ckpt_name[0].map(it => ({ value: it, text: it })));
     } catch (error) {

             throw new Error('ComfyUI returned an error.');
+        }
+        /** @type {any} */
         const data = await result.json();
         return response.send(data.KSampler.input.required.scheduler[0]);
     } catch (error) {

             throw new Error('ComfyUI returned an error.');
+        }
+        /** @type {any} */
         const data = await result.json();
         return response.send(data.VAELoader.input.required.vae_name[0]);
     } catch (error) {

             throw new Error('ComfyUI returned an error.');
+        }
+        /** @type {any} */
         const data = await promptResult.json();
         const id = data.prompt_id;
         let item;

             if (!result.ok) {
                 throw new Error('ComfyUI returned an error.');
+            }
+            /** @type {any} */
             const history = await result.json();
             item = history[id];
             if (item) {

             return response.sendStatus(500);
+        }
+        /** @type {any} */
         const data = await result.json();
         console.log('TogetherAI response:', data);

         const result = await fetch(url, {
             method: 'GET',
         });
+        /** @type {any} */
         const data = await result.json();
         return response.send(data['model']);

         const result = await fetch(url, {
             method: 'GET',
         });
+        /** @type {any} */
         const data = await result.json();
         return response.send(data['upscaler']);

                 'Content-Type': 'application/json',
                 'Authorization': auth,
             },
-            timeout: 0,
         });
         if (!result.ok) {

                 'Accept': 'image/*',
             },
             body: formData,
-            timeout: 0,
         });
         if (!result.ok) {

 router.use('/stability', stability);
 router.use('/blockentropy', blockentropy);
 router.use('/huggingface', huggingface);
-module.exports = { router };

src/endpoints/stats.js+12 -18 Viewed

-const fs = require('fs');
+import fs from 'node:fs';
-const path = require('path');
+import path from 'node:path';
-const express = require('express');
+import crypto from 'node:crypto';
-const writeFileAtomic = require('write-file-atomic');
-const crypto = require('crypto');
+import express from 'express';
+import writeFileAtomic from 'write-file-atomic';
 const readFile = fs.promises.readFile;
 const readdir = fs.promises.readdir;
-const { jsonParser } = require('../express-common');
+import { jsonParser } from '../express-common.js';
-const { getAllUserHandles, getUserDirectories } = require('../users');
+import { getAllUserHandles, getUserDirectories } from '../users.js';
 const STATS_FILE = 'stats.json';

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

  * Loads the stats file into memory. If the file doesn't exist or is invalid,
  * initializes stats by collecting and creating them for each character.
  */
-async function init() {
+export async function init() {
     try {
         const userHandles = await getAllUserHandles();
         for (const handle of userHandles) {

  * Attempts to save charStats to a file and then terminates the process.
  * If an error occurs during the file write, it logs the error before exiting.
  */
-async function onExit() {
+export async function onExit() {
     try {
         await saveStatsToFile();
     } catch (err) {

     };
+}
-const router = express.Router();
+export const router = express.Router();
 /**
  * Handle a POST request to get the stats object

     setCharStats(request.user.profile.handle, request.body);
     return response.sendStatus(200);
 });
-module.exports = {
-    router,
-    recreateStats,
-    init,
-    onExit,
-};

src/endpoints/themes.js+9 -9 Viewed

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

@@ -36,5 +38,3 @@ router.post('/delete', jsonParser, function (request, response) {
36	return response.sendStatus(500);	38	return response.sendStatus(500);
37	}	39	}
38	});	40	});
39
40	module.exports = { router };

src/endpoints/thumbnails.js+20 -24 Viewed

-const fs = require('fs');
+import fs from 'node:fs';
-const fsPromises = require('fs').promises;
+import { promises as fsPromises } from 'node:fs';
-const path = require('path');
+import path from 'node:path';
-const mime = require('mime-types');
-const express = require('express');
+import mime from 'mime-types';
-const sanitize = require('sanitize-filename');
+import express from 'express';
-const jimp = require('jimp');
+import sanitize from 'sanitize-filename';
-const writeFileAtomicSync = require('write-file-atomic').sync;
+import jimp from 'jimp';
-const { getAllUserHandles, getUserDirectories } = require('../users');
+import { sync as writeFileAtomicSync } from 'write-file-atomic';
-const { getConfigValue } = require('../util');
-const { jsonParser } = require('../express-common');
+import { getAllUserHandles, getUserDirectories } from '../users.js';
+import { getConfigValue } from '../util.js';
+import { jsonParser } from '../express-common.js';
 const thumbnailsDisabled = getConfigValue('disableThumbnails', false);
 const quality = getConfigValue('thumbnailsQuality', 95);

 /**
  * Gets a path to thumbnail folder based on the type.
- * @param {import('../users').UserDirectoryList} directories User directories
+ * @param {import('../users.js').UserDirectoryList} directories User directories
  * @param {'bg' | 'avatar'} type Thumbnail type
  * @returns {string} Path to the thumbnails folder
  */

 /**
  * Gets a path to the original images folder based on the type.
- * @param {import('../users').UserDirectoryList} directories User directories
+ * @param {import('../users.js').UserDirectoryList} directories User directories
  * @param {'bg' | 'avatar'} type Thumbnail type
  * @returns {string} Path to the original images folder
  */

 /**
  * Removes the generated thumbnail from the disk.
- * @param {import('../users').UserDirectoryList} directories User directories
+ * @param {import('../users.js').UserDirectoryList} directories User directories
  * @param {'bg' | 'avatar'} type Type of the thumbnail
  * @param {string} file Name of the file
  */
-function invalidateThumbnail(directories, type, file) {
+export function invalidateThumbnail(directories, type, file) {
     const folder = getThumbnailFolder(directories, type);
     if (folder === undefined) throw new Error('Invalid thumbnail type');

 /**
  * Generates a thumbnail for the given file.
- * @param {import('../users').UserDirectoryList} directories User directories
+ * @param {import('../users.js').UserDirectoryList} directories User directories
  * @param {'bg' | 'avatar'} type Type of the thumbnail
  * @param {string} file Name of the file
  * @returns

  * Ensures that the thumbnail cache for backgrounds is valid.
  * @returns {Promise<void>} Promise that resolves when the cache is validated
  */
-async function ensureThumbnailCache() {
+export async function ensureThumbnailCache() {
     const userHandles = await getAllUserHandles();
     for (const handle of userHandles) {
         const directories = getUserDirectories(handle);

@@ -166,7 +168,7 @@ async function ensureThumbnailCache() {
166	}	168	}
167	}	169	}
168		170
169	const router = express.Router();	171	export const router = express.Router();
170		172
171	// Important: This route must be mounted as '/thumbnail'. It is used in the client code and saved to chat files.	173	// Important: This route must be mounted as '/thumbnail'. It is used in the client code and saved to chat files.
172	router.get('/', jsonParser, async function (request, response) {	174	router.get('/', jsonParser, async function (request, response) {

         return response.sendStatus(500);
+    }
 });
-module.exports = {
-    invalidateThumbnail,
-    ensureThumbnailCache,
-    router,
-};

src/endpoints/tokenizers.js+23 -29 Viewed

-const fs = require('fs');
+import fs from 'node:fs';
-const path = require('path');
+import path from 'node:path';
-const express = require('express');
+import { Buffer } from 'node:buffer';
-const { SentencePieceProcessor } = require('@agnai/sentencepiece-js');
-const tiktoken = require('tiktoken');
+import express from 'express';
-const { Tokenizer } = require('@agnai/web-tokenizers');
+import { sync as writeFileAtomicSync } from 'write-file-atomic';
-const { convertClaudePrompt } = require('../prompt-converters');
-const { TEXTGEN_TYPES } = require('../constants');
+import { Tokenizer } from '@agnai/web-tokenizers';
-const { jsonParser } = require('../express-common');
+import { SentencePieceProcessor } from '@agnai/sentencepiece-js';
-const { setAdditionalHeaders } = require('../additional-headers');
+import tiktoken from 'tiktoken';
-const { getConfigValue, isValidUrl } = require('../util');
-const writeFileAtomicSync = require('write-file-atomic').sync;
+import { convertClaudePrompt } from '../prompt-converters.js';
+import { TEXTGEN_TYPES } from '../constants.js';
+import { jsonParser } from '../express-common.js';
+import { setAdditionalHeaders } from '../additional-headers.js';
+import { getConfigValue, isValidUrl } from '../util.js';
 /**
  * @typedef { (req: import('express').Request, res: import('express').Response) => Promise<any> } TokenizationHandler

 /**
  * @type {string[]}
  */
-const TEXT_COMPLETION_MODELS = [
+export const TEXT_COMPLETION_MODELS = [
     'gpt-3.5-turbo-instruct',
     'gpt-3.5-turbo-instruct-0914',
     'text-davinci-003',

 const qwen2Tokenizer = new WebTokenizer('https://github.com/SillyTavern/SillyTavern-Tokenizers/raw/main/qwen2.json', 'src/tokenizers/llama3.json');
 const nemoTokenizer = new WebTokenizer('https://github.com/SillyTavern/SillyTavern-Tokenizers/raw/main/nemo.json', 'src/tokenizers/llama3.json');
-const sentencepieceTokenizers = [
+export const sentencepieceTokenizers = [
     'llama',
     'nerdstash',
     'nerdstash_v2',

  * @param {string} model Sentencepiece model name
  * @returns {SentencePieceTokenizer|null} Sentencepiece tokenizer
  */
-function getSentencepiceTokenizer(model) {
+export function getSentencepiceTokenizer(model) {
     if (model.includes('llama')) {
         return spp_llama;
+    }

  * @param {string} requestModel Models to use for tokenization
  * @returns {string} Tokenizer model to use
  */
-function getTokenizerModel(requestModel) {
+export function getTokenizerModel(requestModel) {
     if (requestModel.includes('o1-preview') || requestModel.includes('o1-mini')) {
         return 'gpt-4o';
+    }

@@ -427,7 +431,7 @@ function getTokenizerModel(requestModel) {
427	return 'gpt-3.5-turbo';	431	return 'gpt-3.5-turbo';
428	}	432	}
429		433
430	function getTiktokenTokenizer(model) {	434	export function getTiktokenTokenizer(model) {
431	if (tokenizersCache[model]) {	435	if (tokenizersCache[model]) {
432	return tokenizersCache[model];	436	return tokenizersCache[model];
433	}	437	}

  * @param {object[]} messages Array of messages
  * @returns {number} Number of tokens
  */
-function countWebTokenizerTokens(tokenizer, messages) {
+export function countWebTokenizerTokens(tokenizer, messages) {
     // Should be fine if we use the old conversion method instead of the messages API one i think?
     const convertedPrompt = convertClaudePrompt(messages, false, '', false, false, '', false);

     };
+}
-const router = express.Router();
+export const router = express.Router();
 router.post('/llama/encode', jsonParser, createSentencepieceEncodingHandler(spp_llama));
 router.post('/nerdstash/encode', jsonParser, createSentencepieceEncodingHandler(spp_nerd));

         return response.send({ error: true });
+    }
 });
-module.exports = {
-    TEXT_COMPLETION_MODELS,
-    getTokenizerModel,
-    getTiktokenTokenizer,
-    countWebTokenizerTokens,
-    getSentencepiceTokenizer,
-    sentencepieceTokenizers,
-    router,
-};

src/endpoints/translate.js+21 -54 Viewed

-const fetch = require('node-fetch').default;
+import https from 'node:https';
-const https = require('https');
-const express = require('express');
+import fetch from 'node-fetch';
-const iconv = require('iconv-lite');
+import express from 'express';
-const { readSecret, SECRET_KEYS } = require('./secrets');
+import bingTranslateApi from 'bing-translate-api';
-const { getConfigValue, uuidv4 } = require('../util');
+import googleTranslateApi from 'google-translate-api-x';
-const { jsonParser } = require('../express-common');
+import { readSecret, SECRET_KEYS } from './secrets.js';
+import { getConfigValue, uuidv4 } from '../util.js';
+import { jsonParser } from '../express-common.js';
 const DEEPLX_URL_DEFAULT = 'http://127.0.0.1:1188/translate';
 const ONERING_URL_DEFAULT = 'http://127.0.0.1:4990/translate';
-/**
+export const router = express.Router();
- * Tries to decode a Node.js Buffer to a string using iconv-lite for UTF-8.
- * @param {Buffer} buffer Node.js Buffer
- * @returns {string} Decoded string
- */
-function decodeBuffer(buffer) {
-    try {
-        return iconv.decode(buffer, 'utf-8');
-    } catch (error) {
-        console.log('Failed to decode buffer:', error);
-        return buffer.toString('utf-8');
-    }
-}
-const router = express.Router();
 router.post('/libre', jsonParser, async (request, response) => {
     const key = readSecret(request.user.directories, SECRET_KEYS.LIBRE);

             return response.sendStatus(result.status);
+        }
+        /** @type {any} */
         const json = await result.json();
         console.log('Translated text: ' + json.translatedText);

 router.post('/google', jsonParser, async (request, response) => {
     try {
-        const { generateRequestUrl, normaliseResponse } = require('google-translate-api-browser');
         const text = request.body.text;
         const lang = request.body.lang;

         console.log('Input text: ' + text);
-        const url = generateRequestUrl(text, { to: lang });
+        const result = await googleTranslateApi(text, { to: lang, forceBatch: false });
+        const translatedText = Array.isArray(result) ? result.map(x => x.text).join('') : result.text;
-        https.get(url, (resp) => {
+        response.setHeader('Content-Type', 'text/plain; charset=utf-8');
-            const data = [];
+        console.log('Translated text: ' + translatedText);
+        return response.send(translatedText);
-            resp.on('data', (chunk) => {
-                data.push(chunk);
-            });
-            resp.on('end', () => {
-                try {
-                    const decodedData = decodeBuffer(Buffer.concat(data));
-                    const result = normaliseResponse(JSON.parse(decodedData));
-                    console.log('Translated text: ' + result.text);
-                    response.setHeader('Content-Type', 'text/plain; charset=utf-8');
-                    return response.send(result.text);
-                } catch (error) {
-                    console.log('Translation error', error);
-                    return response.sendStatus(500);
-                }
-            });
-        }).on('error', (err) => {
-            console.log('Translation error: ' + err.message);
-            return response.sendStatus(500);
-        });
     } catch (error) {
         console.log('Translation error', error);
         return response.sendStatus(500);

             headers: {
                 'Content-Type': 'application/x-www-form-urlencoded',
             },
-            timeout: 0,
         });
         if (!result.ok) {

             return response.sendStatus(500);
+        }
+        /** @type {any} */
         const json = await result.json();
         const translated = json.text.join();
         console.log('Translated text: ' + translated);

                 'Authorization': `DeepL-Auth-Key ${key}`,
                 'Content-Type': 'application/x-www-form-urlencoded',
             },
-            timeout: 0,
         });
         if (!result.ok) {

             return response.sendStatus(result.status);
+        }
+        /** @type {any} */
         const json = await result.json();
         console.log('Translated text: ' + json.translations[0].text);

         const result = await fetch(fetchUrl, {
             method: 'GET',
-            timeout: 0,
         });
         if (!result.ok) {

             return response.sendStatus(result.status);
+        }
+        /** @type {any} */
         const data = await result.json();
         console.log('Translated text: ' + data.result);

                 'Accept': 'application/json',
                 'Content-Type': 'application/json',
             },
-            timeout: 0,
         });
         if (!result.ok) {

             return response.sendStatus(result.status);
+        }
+        /** @type {any} */
         const json = await result.json();
         console.log('Translated text: ' + json.data);

 });
 router.post('/bing', jsonParser, async (request, response) => {
-    const bingTranslateApi = require('bing-translate-api');
     const text = request.body.text;
     let lang = request.body.lang;

         return response.sendStatus(500);
     });
 });
-module.exports = { router };

src/endpoints/users-admin.js+17 -20 Viewed

-const fsPromises = require('fs').promises;
+import { promises as fsPromises } from 'node:fs';
-const storage = require('node-persist');
-const express = require('express');
+import storage from 'node-persist';
-const lodash = require('lodash');
+import express from 'express';
-const { jsonParser } = require('../express-common');
+import lodash from 'lodash';
-const { checkForNewContent } = require('./content-manager');
+import { jsonParser } from '../express-common.js';
-const {
+import { checkForNewContent } from './content-manager.js';
+import {
     KEY_PREFIX,
     toKey,
     requireAdminMiddleware,

     getPasswordHash,
     getUserDirectories,
     ensurePublicDirectoriesExist,
-} = require('../users');
+} from '../users.js';
-const { DEFAULT_USER } = require('../constants');
+import { DEFAULT_USER } from '../constants.js';
-const router = express.Router();
+export const router = express.Router();
 router.post('/get', requireAdminMiddleware, jsonParser, async (_request, response) => {
     try {
-        /** @type {import('../users').User[]} */
+        /** @type {import('../users.js').User[]} */
         const users = await storage.values(x => x.key.startsWith(KEY_PREFIX));
-        /** @type {Promise<import('../users').UserViewModel>[]} */
+        /** @type {Promise<import('../users.js').UserViewModel>[]} */
         const viewModelPromises = users
             .map(user => new Promise(resolve => {
                 getUserAvatar(user.handle).then(avatar =>

             return response.status(400).json({ error: 'Cannot disable yourself' });
+        }
-        /** @type {import('../users').User} */
+        /** @type {import('../users.js').User} */
         const user = await storage.getItem(toKey(request.body.handle));
         if (!user) {

             return response.status(400).json({ error: 'Missing required fields' });
+        }
-        /** @type {import('../users').User} */
+        /** @type {import('../users.js').User} */
         const user = await storage.getItem(toKey(request.body.handle));
         if (!user) {

             return response.status(400).json({ error: 'Missing required fields' });
+        }
-        /** @type {import('../users').User} */
+        /** @type {import('../users.js').User} */
         const user = await storage.getItem(toKey(request.body.handle));
         if (!user) {

             return response.status(400).json({ error: 'Cannot demote yourself' });
+        }
-        /** @type {import('../users').User} */
+        /** @type {import('../users.js').User} */
         const user = await storage.getItem(toKey(request.body.handle));
         if (!user) {

         return response.sendStatus(500);
+    }
 });
-module.exports = {
-    router,
-};

src/endpoints/users-private.js+17 -20 Viewed

-const path = require('path');
+import path from 'node:path';
-const fsPromises = require('fs').promises;
+import { promises as fsPromises } from 'node:fs';
-const storage = require('node-persist');
+import crypto from 'node:crypto';
-const express = require('express');
-const crypto = require('crypto');
+import storage from 'node-persist';
-const { jsonParser } = require('../express-common');
+import express from 'express';
-const { getUserAvatar, toKey, getPasswordHash, getPasswordSalt, createBackupArchive, ensurePublicDirectoriesExist, toAvatarKey } = require('../users');
-const { SETTINGS_FILE } = require('../constants');
+import { jsonParser } from '../express-common.js';
-const contentManager = require('./content-manager');
+import { getUserAvatar, toKey, getPasswordHash, getPasswordSalt, createBackupArchive, ensurePublicDirectoriesExist, toAvatarKey } from '../users.js';
-const { color, Cache } = require('../util');
+import { SETTINGS_FILE } from '../constants.js';
-const { checkForNewContent } = require('./content-manager');
+import { checkForNewContent, CONTENT_TYPES } from './content-manager.js';
+import { color, Cache } from '../util.js';
 const RESET_CACHE = new Cache(5 * 60 * 1000);
-const router = express.Router();
+export const router = express.Router();
 router.post('/logout', async (request, response) => {
     try {

             return response.status(400).json({ error: 'Invalid data URL' });
+        }
-        /** @type {import('../users').User} */
+        /** @type {import('../users.js').User} */
         const user = await storage.getItem(toKey(request.body.handle));
         if (!user) {

             return response.status(403).json({ error: 'Unauthorized' });
+        }
-        /** @type {import('../users').User} */
+        /** @type {import('../users.js').User} */
         const user = await storage.getItem(toKey(request.body.handle));
         if (!user) {

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

             return response.status(403).json({ error: 'Unauthorized' });
+        }
-        /** @type {import('../users').User} */
+        /** @type {import('../users.js').User} */
         const user = await storage.getItem(toKey(request.body.handle));
         if (!user) {

         return response.sendStatus(500);
+    }
 });
-module.exports = {
-    router,
-};

src/endpoints/users-public.js+14 -17 Viewed

-const crypto = require('crypto');
+import crypto from 'node:crypto';
-const storage = require('node-persist');
-const express = require('express');
+import storage from 'node-persist';
-const { RateLimiterMemory, RateLimiterRes } = require('rate-limiter-flexible');
+import express from 'express';
-const { jsonParser, getIpFromRequest } = require('../express-common');
+import { RateLimiterMemory, RateLimiterRes } from 'rate-limiter-flexible';
-const { color, Cache, getConfigValue } = require('../util');
+import { jsonParser, getIpFromRequest } from '../express-common.js';
-const { KEY_PREFIX, getUserAvatar, toKey, getPasswordHash, getPasswordSalt } = require('../users');
+import { color, Cache, getConfigValue } from '../util.js';
+import { KEY_PREFIX, getUserAvatar, toKey, getPasswordHash, getPasswordSalt } from '../users.js';
 const DISCREET_LOGIN = getConfigValue('enableDiscreetLogin', false);
 const MFA_CACHE = new Cache(5 * 60 * 1000);
-const router = express.Router();
+export const router = express.Router();
 const loginLimiter = new RateLimiterMemory({
     points: 5,
     duration: 60,

             return response.sendStatus(204);
+        }
-        /** @type {import('../users').User[]} */
+        /** @type {import('../users.js').User[]} */
         const users = await storage.values(x => x.key.startsWith(KEY_PREFIX));
-        /** @type {Promise<import('../users').UserViewModel>[]} */
+        /** @type {Promise<import('../users.js').UserViewModel>[]} */
         const viewModelPromises = users
             .filter(x => x.enabled)
             .map(user => new Promise(async (resolve) => {

         const ip = getIpFromRequest(request);
         await loginLimiter.consume(ip);
-        /** @type {import('../users').User} */
+        /** @type {import('../users.js').User} */
         const user = await storage.getItem(toKey(request.body.handle));
         if (!user) {

         const ip = getIpFromRequest(request);
         await recoverLimiter.consume(ip);
-        /** @type {import('../users').User} */
+        /** @type {import('../users.js').User} */
         const user = await storage.getItem(toKey(request.body.handle));
         if (!user) {

             return response.status(400).json({ error: 'Missing required fields' });
+        }
-        /** @type {import('../users').User} */
+        /** @type {import('../users.js').User} */
         const user = await storage.getItem(toKey(request.body.handle));
         const ip = getIpFromRequest(request);

         return response.sendStatus(500);
+    }
 });
-module.exports = {
-    router,
-};

src/endpoints/vectors.js+46 -36 Viewed

-const vectra = require('vectra');
+import path from 'node:path';
-const path = require('path');
+import fs from 'node:fs';
-const fs = require('fs');
-const express = require('express');
+import vectra from 'vectra';
-const sanitize = require('sanitize-filename');
+import express from 'express';
-const { jsonParser } = require('../express-common');
+import sanitize from 'sanitize-filename';
-const { getConfigValue } = require('../util');
+import { jsonParser } from '../express-common.js';
+import { getConfigValue } from '../util.js';
+import { getNomicAIBatchVector, getNomicAIVector } from '../vectors/nomicai-vectors.js';
+import { getOpenAIVector, getOpenAIBatchVector } from '../vectors/openai-vectors.js';
+import { getTransformersVector, getTransformersBatchVector } from '../vectors/embedding.js';
+import { getExtrasVector, getExtrasBatchVector } from '../vectors/extras-vectors.js';
+import { getMakerSuiteVector, getMakerSuiteBatchVector } from '../vectors/makersuite-vectors.js';
+import { getCohereVector, getCohereBatchVector } from '../vectors/cohere-vectors.js';
+import { getLlamaCppVector, getLlamaCppBatchVector } from '../vectors/llamacpp-vectors.js';
+import { getVllmVector, getVllmBatchVector } from '../vectors/vllm-vectors.js';
+import { getOllamaVector, getOllamaBatchVector } from '../vectors/ollama-vectors.js';
 // Don't forget to add new sources to the SOURCES array
 const SOURCES = [

  * @param {Object} sourceSettings - Settings for the source, if it needs any
  * @param {string} text - The text to get the vector for
  * @param {boolean} isQuery - If the text is a query for embedding search
- * @param {import('../users').UserDirectoryList} directories - The directories object for the user
+ * @param {import('../users.js').UserDirectoryList} directories - The directories object for the user
  * @returns {Promise<number[]>} - The vector for the text
  */
 async function getVector(source, sourceSettings, text, isQuery, directories) {
     switch (source) {
         case 'nomicai':
-            return require('../vectors/nomicai-vectors').getNomicAIVector(text, source, directories);
+            return getNomicAIVector(text, source, directories);
         case 'togetherai':
         case 'mistral':
         case 'openai':
-            return require('../vectors/openai-vectors').getOpenAIVector(text, source, directories, sourceSettings.model);
+            return getOpenAIVector(text, source, directories, sourceSettings.model);
         case 'transformers':
-            return require('../vectors/embedding').getTransformersVector(text);
+            return getTransformersVector(text);
         case 'extras':
-            return require('../vectors/extras-vectors').getExtrasVector(text, sourceSettings.extrasUrl, sourceSettings.extrasKey);
+            return getExtrasVector(text, sourceSettings.extrasUrl, sourceSettings.extrasKey);
         case 'palm':
-            return require('../vectors/makersuite-vectors').getMakerSuiteVector(text, directories);
+            return getMakerSuiteVector(text, directories);
         case 'cohere':
-            return require('../vectors/cohere-vectors').getCohereVector(text, isQuery, directories, sourceSettings.model);
+            return getCohereVector(text, isQuery, directories, sourceSettings.model);
         case 'llamacpp':
-            return require('../vectors/llamacpp-vectors').getLlamaCppVector(text, sourceSettings.apiUrl, directories);
+            return getLlamaCppVector(text, sourceSettings.apiUrl, directories);
         case 'vllm':
-            return require('../vectors/vllm-vectors').getVllmVector(text, sourceSettings.apiUrl, sourceSettings.model, directories);
+            return getVllmVector(text, sourceSettings.apiUrl, sourceSettings.model, directories);
         case 'ollama':
-            return require('../vectors/ollama-vectors').getOllamaVector(text, sourceSettings.apiUrl, sourceSettings.model, sourceSettings.keep, directories);
+            return getOllamaVector(text, sourceSettings.apiUrl, sourceSettings.model, sourceSettings.keep, directories);
+    }
     throw new Error(`Unknown vector source ${source}`);

  * @param {Object} sourceSettings - Settings for the source, if it needs any
  * @param {string[]} texts - The array of texts to get the vector for
  * @param {boolean} isQuery - If the text is a query for embedding search
- * @param {import('../users').UserDirectoryList} directories - The directories object for the user
+ * @param {import('../users.js').UserDirectoryList} directories - The directories object for the user
  * @returns {Promise<number[][]>} - The array of vectors for the texts
  */
 async function getBatchVector(source, sourceSettings, texts, isQuery, directories) {

     for (let batch of batches) {
         switch (source) {
             case 'nomicai':
-                results.push(...await require('../vectors/nomicai-vectors').getNomicAIBatchVector(batch, source, directories));
+                results.push(...await getNomicAIBatchVector(batch, source, directories));
                 break;
             case 'togetherai':
             case 'mistral':
             case 'openai':
-                results.push(...await require('../vectors/openai-vectors').getOpenAIBatchVector(batch, source, directories, sourceSettings.model));
+                results.push(...await getOpenAIBatchVector(batch, source, directories, sourceSettings.model));
                 break;
             case 'transformers':
-                results.push(...await require('../vectors/embedding').getTransformersBatchVector(batch));
+                results.push(...await getTransformersBatchVector(batch));
                 break;
             case 'extras':
-                results.push(...await require('../vectors/extras-vectors').getExtrasBatchVector(batch, sourceSettings.extrasUrl, sourceSettings.extrasKey));
+                results.push(...await getExtrasBatchVector(batch, sourceSettings.extrasUrl, sourceSettings.extrasKey));
                 break;
             case 'palm':
-                results.push(...await require('../vectors/makersuite-vectors').getMakerSuiteBatchVector(batch, directories));
+                results.push(...await getMakerSuiteBatchVector(batch, directories));
                 break;
             case 'cohere':
-                results.push(...await require('../vectors/cohere-vectors').getCohereBatchVector(batch, isQuery, directories, sourceSettings.model));
+                results.push(...await getCohereBatchVector(batch, isQuery, directories, sourceSettings.model));
                 break;
             case 'llamacpp':
-                results.push(...await require('../vectors/llamacpp-vectors').getLlamaCppBatchVector(batch, sourceSettings.apiUrl, directories));
+                results.push(...await getLlamaCppBatchVector(batch, sourceSettings.apiUrl, directories));
                 break;
             case 'vllm':
-                results.push(...await require('../vectors/vllm-vectors').getVllmBatchVector(batch, sourceSettings.apiUrl, sourceSettings.model, directories));
+                results.push(...await getVllmBatchVector(batch, sourceSettings.apiUrl, sourceSettings.model, directories));
                 break;
             case 'ollama':
-                results.push(...await require('../vectors/ollama-vectors').getOllamaBatchVector(batch, sourceSettings.apiUrl, sourceSettings.model, sourceSettings.keep, directories));
+                results.push(...await getOllamaBatchVector(batch, sourceSettings.apiUrl, sourceSettings.model, sourceSettings.keep, directories));
                 break;
             default:
                 throw new Error(`Unknown vector source ${source}`);

 /**
  * Gets the index for the vector collection
- * @param {import('../users').UserDirectoryList} directories - User directories
+ * @param {import('../users.js').UserDirectoryList} directories - User directories
  * @param {string} collectionId - The collection ID
  * @param {string} source - The source of the vector
  * @param {object} sourceSettings - The model for the source

 /**
  * Inserts items into the vector collection
- * @param {import('../users').UserDirectoryList} directories - User directories
+ * @param {import('../users.js').UserDirectoryList} directories - User directories
  * @param {string} collectionId - The collection ID
  * @param {string} source - The source of the vector
  * @param {Object} sourceSettings - Settings for the source, if it needs any

 /**
  * Gets the hashes of the items in the vector collection
- * @param {import('../users').UserDirectoryList} directories - User directories
+ * @param {import('../users.js').UserDirectoryList} directories - User directories
  * @param {string} collectionId - The collection ID
  * @param {string} source - The source of the vector
  * @param {Object} sourceSettings - Settings for the source, if it needs any

 /**
  * Deletes items from the vector collection by hash
- * @param {import('../users').UserDirectoryList} directories - User directories
+ * @param {import('../users.js').UserDirectoryList} directories - User directories
  * @param {string} collectionId - The collection ID
  * @param {string} source - The source of the vector
  * @param {Object} sourceSettings - Settings for the source, if it needs any

 /**
  * Gets the hashes of the items in the vector collection that match the search text
- * @param {import('../users').UserDirectoryList} directories - User directories
+ * @param {import('../users.js').UserDirectoryList} directories - User directories
  * @param {string} collectionId - The collection ID
  * @param {string} source - The source of the vector
  * @param {Object} sourceSettings - Settings for the source, if it needs any

 /**
  * Queries multiple collections for the given search queries. Returns the overall top K results.
- * @param {import('../users').UserDirectoryList} directories - User directories
+ * @param {import('../users.js').UserDirectoryList} directories - User directories
  * @param {string[]} collectionIds - The collection IDs to query
  * @param {string} source - The source of the vector
  * @param {Object} sourceSettings - Settings for the source, if it needs any

     return res.sendStatus(500);
+}
-const router = express.Router();
+export const router = express.Router();
 router.post('/query', jsonParser, async (req, res) => {
     try {

@@ -495,5 +507,3 @@ router.post('/purge', jsonParser, async (req, res) => {
495	return res.sendStatus(500);	507	return res.sendStatus(500);
496	}	508	}
497	});	509	});
498
499	module.exports = { router };

src/endpoints/worldinfo.js+10 -11 Viewed

-const fs = require('fs');
+import fs from 'node:fs';
-const path = require('path');
+import path from 'node:path';
-const express = require('express');
-const sanitize = require('sanitize-filename');
-const writeFileAtomicSync = require('write-file-atomic').sync;
-const { jsonParser, urlencodedParser } = require('../express-common');
+import express from 'express';
+import sanitize from 'sanitize-filename';
+import { sync as writeFileAtomicSync } from 'write-file-atomic';
+import { jsonParser, urlencodedParser } from '../express-common.js';
 /**
  * Reads a World Info file and returns its contents
- * @param {import('../users').UserDirectoryList} directories User directories
+ * @param {import('../users.js').UserDirectoryList} directories User directories
  * @param {string} worldInfoName Name of the World Info file
  * @param {boolean} allowDummy If true, returns an empty object if the file doesn't exist
  * @returns {object} World Info file contents
  */
-function readWorldInfoFile(directories, worldInfoName, allowDummy) {
+export function readWorldInfoFile(directories, worldInfoName, allowDummy) {
     const dummyObject = allowDummy ? { entries: {} } : null;
     if (!worldInfoName) {

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

     return response.send({ ok: true });
 });
-module.exports = { router, readWorldInfoFile };

src/express-common.js+11 -12 Viewed

-const express = require('express');
+import express from 'express';
-const ipaddr = require('ipaddr.js');
+import ipaddr from 'ipaddr.js';
 // Instantiate parser middleware here with application-level size limits
-const jsonParser = express.json({ limit: '200mb' });
+export const jsonParser = express.json({ limit: '200mb' });
-const urlencodedParser = express.urlencoded({ extended: true, limit: '200mb' });
+export const urlencodedParser = express.urlencoded({ extended: true, limit: '200mb' });
 /**
  * Gets the IP address of the client from the request object.
- * @param {import('express'.Request)} req Request object
+ * @param {import('express').Request} req Request object
  * @returns {string} IP address of the client
  */
-function getIpFromRequest(req) {
+export function getIpFromRequest(req) {
-    let clientIp = req.connection.remoteAddress;
+    let clientIp = req.socket.remoteAddress;
+    if (!clientIp) {
+        return 'unknown';
+    }
     let ip = ipaddr.parse(clientIp);
     // Check if the IP address is IPv4-mapped IPv6 address
     if (ip.kind() === 'ipv6' && ip instanceof ipaddr.IPv6 && ip.isIPv4MappedAddress()) {
         const ipv4 = ip.toIPv4Address().toString();
         clientIp = ipv4;
     } else {
-        clientIp = ip;
+        clientIp = ip.toString();
-        clientIp = clientIp.toString();
+    }
     return clientIp;
+}
-module.exports = { jsonParser, urlencodedParser, getIpFromRequest };

src/middleware/basicAuth.js+5 -4 Viewed

  * When applied, this middleware will ensure the request contains the required header for basic authentication and only
  * allow access to the endpoint after successful authentication.
  */
-const { getAllUserHandles, toKey, getPasswordHash } = require('../users.js');
+import { Buffer } from 'node:buffer';
-const { getConfig, getConfigValue } = require('../util.js');
+import storage from 'node-persist';
-const storage = require('node-persist');
+import { getAllUserHandles, toKey, getPasswordHash } from '../users.js';
+import { getConfig, getConfigValue } from '../util.js';
 const PER_USER_BASIC_AUTH = getConfigValue('perUserBasicAuth', false);
 const ENABLE_ACCOUNTS = getConfigValue('enableUserAccounts', false);

     return unauthorizedResponse(response);
 };
-module.exports = basicAuthMiddleware;
+export default basicAuthMiddleware;

src/middleware/multerMonkeyPatch.js+3 -3 Viewed

+import { Buffer } from 'node:buffer';
 /**
  * Decodes a file name from Latin1 to UTF-8.
  * @param {string} str Input string

  * @param {import('express').Response} _res Response
  * @param {import('express').NextFunction} next Next middleware
  */
-function multerMonkeyPatch(req, _res, next) {
+export default function multerMonkeyPatch(req, _res, next) {
     try {
         if (req.file) {
             req.file.originalname = decodeFileName(req.file.originalname);

@@ -26,5 +28,3 @@ function multerMonkeyPatch(req, _res, next) {
26	next();	28	next();
27	}	29	}
28	}	30	}
29
30	module.exports = multerMonkeyPatch;

src/middleware/whitelist.js+7 -8 Viewed

-const path = require('path');
+import path from 'node:path';
-const fs = require('fs');
+import fs from 'node:fs';
-const ipMatching = require('ip-matching');
+import process from 'node:process';
+import ipMatching from 'ip-matching';
-const { getIpFromRequest } = require('../express-common');
+import { getIpFromRequest } from '../express-common.js';
-const { color, getConfigValue } = require('../util');
+import { color, getConfigValue } from '../util.js';
 const whitelistPath = path.join(process.cwd(), './whitelist.txt');
 const enableForwardedWhitelist = getConfigValue('enableForwardedWhitelist', false);

  * @param {boolean} listen If listen mode is enabled via config or command line
  * @returns {import('express').RequestHandler} The middleware function
  */
-function whitelistMiddleware(whitelistMode, listen) {
+export default function whitelistMiddleware(whitelistMode, listen) {
     return function (req, res, next) {
         const clientIp = getIpFromRequest(req);
         const forwardedIp = getForwardedIp(req);

@@ -82,5 +83,3 @@ function whitelistMiddleware(whitelistMode, listen) {
82	next();	83	next();
83	};	84	};
84	}	85	}
85
86	module.exports = whitelistMiddleware;

src/plugin-loader.js+17 -24 Viewed

-const fs = require('fs');
+import fs from 'node:fs';
-const path = require('path');
+import path from 'node:path';
-const url = require('url');
+import url from 'node:url';
-const express = require('express');
-const { getConfigValue } = require('./util');
+import express from 'express';
+import { getConfigValue } from './util.js';
 const enableServerPlugins = getConfigValue('enableServerPlugins', false);
 /**

  * @param {string} file Path to file
  * @returns {boolean} True if file is a CommonJS module
  */
-const isCommonJS = (file) => path.extname(file) === '.js';
+const isCommonJS = (file) => path.extname(file) === '.js' || path.extname(file) === '.cjs';
 /**
  * Determine if a file is an ECMAScript module.

  * @returns {Promise<Function>} Promise that resolves when all plugins are loaded. Resolves to a "cleanup" function to
  * be called before the server shuts down.
  */
-async function loadPlugins(app, pluginsPath) {
+export async function loadPlugins(app, pluginsPath) {
     const exitHooks = [];
-    const emptyFn = () => {};
+    const emptyFn = () => { };
     // Server plugins are disabled.
     if (!enableServerPlugins) {

@@ -89,19 +90,15 @@ async function loadFromDirectory(app, pluginDirectoryPath, exitHooks) {
89	}	90	}
90	}	91	}
91		92
92	// Plugin is a CommonJS module.	93	// Plugin is a module file.
93	const cjsFilePath = path.join(pluginDirectoryPath, 'index.js');	94	const fileTypes = ['index.js', 'index.cjs', 'index.mjs'];
94	if (fs.existsSync(cjsFilePath)) {
95	if (await loadFromFile(app, cjsFilePath, exitHooks)) {
96	return;
97	}
98	}
99		95
100	// Plugin is an ECMAScript module.	96	for (const fileType of fileTypes) {
101	const esmFilePath = path.join(pluginDirectoryPath, 'index.mjs');	97	const filePath = path.join(pluginDirectoryPath, fileType);
102	if (fs.existsSync(esmFilePath)) {	98	if (fs.existsSync(filePath)) {
103	if (await loadFromFile(app, esmFilePath, exitHooks)) {	99	if (await loadFromFile(app, filePath, exitHooks)) {
104	return;	100	return;
		101	}
105	}	102	}
106	}	103	}
107	}	104	}

     return true;
+}
-module.exports = {
-    loadPlugins,
-};

src/polyfill.js+0 -10 Viewed

-if (!Array.prototype.findLastIndex) {
-    Array.prototype.findLastIndex = function (callback, thisArg) {
-        for (let i = this.length - 1; i >= 0; i--) {
-            if (callback.call(thisArg, this[i], i, this)) return i;
-        }
-        return -1;
-    };
-}
-module.exports = {};

src/prompt-converters.js+10 -22 Viewed

-require('./polyfill.js');
+import crypto from 'node:crypto';
-const { getConfigValue } = require('./util.js');
+import { getConfigValue } from './util.js';
-const crypto = require('crypto');
 const PROMPT_PLACEHOLDER = getConfigValue('promptPlaceholder', 'Let\'s get started.');

  * @returns {string} Prompt for Claude
  * @copyright Prompt Conversion script taken from RisuAI by kwaroran (GPLv3).
  */
-function convertClaudePrompt(messages, addAssistantPostfix, addAssistantPrefill, withSysPromptSupport, useSystemPrompt, addSysHumanMsg, excludePrefixes) {
+export function convertClaudePrompt(messages, addAssistantPostfix, addAssistantPrefill, withSysPromptSupport, useSystemPrompt, addSysHumanMsg, excludePrefixes) {
     //Prepare messages for claude.
     //When 'Exclude Human/Assistant prefixes' checked, setting messages role to the 'system'(last message is exception).

  * @param {string}   charName Character name
  * @param {string}   userName User name
  */
-function convertClaudeMessages(messages, prefillString, useSysPrompt, useTools, humanMsgFix, charName = '', userName = '') {
+export function convertClaudeMessages(messages, prefillString, useSysPrompt, useTools, humanMsgFix, charName = '', userName = '') {
     let systemPrompt = [];
     if (useSysPrompt) {
         // Collect all the system messages up until the first instance of a non-system message, and then remove them from the messages array.

  * @param {string}   userName User name
  * @returns {{chatHistory: object[]}} Prompt for Cohere
  */
-function convertCohereMessages(messages, charName = '', userName = '') {
+export function convertCohereMessages(messages, charName = '', userName = '') {
     if (messages.length === 0) {
         messages.unshift({
             role: 'user',

  * @param {string} userName User name
  * @returns {{contents: *[], system_instruction: {parts: {text: string}}}} Prompt for Google MakerSuite models
  */
-function convertGooglePrompt(messages, model, useSysPrompt = false, charName = '', userName = '') {
+export function convertGooglePrompt(messages, model, useSysPrompt = false, charName = '', userName = '') {
     // This is a 1x1 transparent PNG
     const PNG_PIXEL = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=';

  * @param {string} charName Character name
  * @param {string} userName User name
  */
-function convertAI21Messages(messages, charName = '', userName = '') {
+export function convertAI21Messages(messages, charName = '', userName = '') {
     if (!Array.isArray(messages)) {
         return [];
+    }

  * @param {string} charName Character name
  * @param {string} userName User name
  */
-function convertMistralMessages(messages, charName = '', userName = '') {
+export function convertMistralMessages(messages, charName = '', userName = '') {
     if (!Array.isArray(messages)) {
         return [];
+    }

  * @param {boolean} strict Enable strict mode: only allow one system message at the start, force user first message
  * @returns {any[]} Merged messages
  */
-function mergeMessages(messages, charName, userName, strict) {
+export function mergeMessages(messages, charName, userName, strict) {
     let mergedMessages = [];
     // Remove names from the messages

  * @param {object[]} messages Array of messages
  * @returns {string} Prompt for Text Completion API
  */
-function convertTextCompletionPrompt(messages) {
+export function convertTextCompletionPrompt(messages) {
     if (typeof messages === 'string') {
         return messages;
+    }

     });
     return messageStrings.join('\n') + '\nassistant:';
+}
-module.exports = {
-    convertClaudePrompt,
-    convertClaudeMessages,
-    convertGooglePrompt,
-    convertTextCompletionPrompt,
-    convertCohereMessages,
-    convertMistralMessages,
-    convertAI21Messages,
-    mergeMessages,
-};

src/request-proxy.js+6 -10 Viewed

-const http = require('node:http');
+import process from 'node:process';
-const https = require('node:https');
+import http from 'node:http';
+import https from 'node:https';
-const { isValidUrl, color } = require('./util.js');
+import { ProxyAgent } from 'proxy-agent';
+import { isValidUrl, color } from './util.js';
 const LOG_HEADER = '[Request Proxy]';

  * @property {string} url Proxy URL.
  * @property {string[]} bypass List of URLs to bypass proxy.
  */
-function initRequestProxy({ enabled, url, bypass }) {
+export default function initRequestProxy({ enabled, url, bypass }) {
     try {
-        const { ProxyAgent } = require('proxy-agent');
         // No proxy is enabled, so return
         if (!enabled) {
             return;

         // Reference: https://github.com/Rob--W/proxy-from-env
         process.env.all_proxy = url;
         if (Array.isArray(bypass) && bypass.length > 0) {
             process.env.no_proxy = bypass.join(',');
+        }

@@ -52,5 +50,3 @@ function initRequestProxy({ enabled, url, bypass }) {
52	console.error(color.red(LOG_HEADER), 'Failed to initialize request proxy:', error);	50	console.error(color.red(LOG_HEADER), 'Failed to initialize request proxy:', error);
53	}	51	}
54	}	52	}
55
56	module.exports = initRequestProxy;

src/transformers.mjs+11 -7 Viewed

-import { pipeline, env, RawImage, Pipeline } from 'sillytavern-transformers';
+import path from 'node:path';
+import fs from 'node:fs';
+import process from 'node:process';
+import { Buffer } from 'node:buffer';
+import { pipeline, env, RawImage } from 'sillytavern-transformers';
 import { getConfigValue } from './util.js';
-import path from 'path';
-import fs from 'fs';
 configureTransformers();

  * @param {string} image Base64-encoded image
  * @returns {Promise<RawImage|null>} Object representing the image
  */
-async function getRawImage(image) {
+export async function getRawImage(image) {
     try {
         const buffer = Buffer.from(image, 'base64');
         const byteArray = new Uint8Array(buffer);

  * Gets the transformers.js pipeline for a given task.
  * @param {import('sillytavern-transformers').PipelineType} task The task to get the pipeline for
  * @param {string} forceModel The model to use for the pipeline, if any
- * @returns {Promise<Pipeline>} Pipeline for the task
+ * @returns {Promise<import('sillytavern-transformers').Pipeline>} The transformers.js pipeline
  */
-async function getPipeline(task, forceModel = '') {
+export async function getPipeline(task, forceModel = '') {
     await migrateCacheToDataDir();
     if (tasks[task].pipeline) {

     const instance = await pipeline(task, model, { cache_dir: cacheDir, quantized: tasks[task].quantized ?? true, local_files_only: localOnly });
     tasks[task].pipeline = instance;
     tasks[task].currentModel = model;
+    // @ts-ignore
     return instance;
+}
 export default {
-    getPipeline,
     getRawImage,
+    getPipeline,
 };

src/users.js+44 -70 Viewed

 // Native Node Modules
-const path = require('path');
+import path from 'node:path';
-const fs = require('fs');
+import fs from 'node:fs';
-const crypto = require('crypto');
+import crypto from 'node:crypto';
-const os = require('os');
+import os from 'node:os';
+import process from 'node:process';
+import { Buffer } from 'node:buffer';
 // Express and other dependencies
-const storage = require('node-persist');
+import storage from 'node-persist';
-const express = require('express');
+import express from 'express';
-const mime = require('mime-types');
+import mime from 'mime-types';
-const archiver = require('archiver');
+import archiver from 'archiver';
-const writeFileAtomicSync = require('write-file-atomic').sync;
+import _ from 'lodash';
-const _ = require('lodash');
+import { sync as writeFileAtomicSync } from 'write-file-atomic';
-const { USER_DIRECTORY_TEMPLATE, DEFAULT_USER, PUBLIC_DIRECTORIES, SETTINGS_FILE } = require('./constants');
+import { USER_DIRECTORY_TEMPLATE, DEFAULT_USER, PUBLIC_DIRECTORIES, SETTINGS_FILE } from './constants.js';
-const { getConfigValue, color, delay, setConfigValue, generateTimestamp } = require('./util');
+import { getConfigValue, color, delay, setConfigValue, generateTimestamp } from './util.js';
-const { readSecret, writeSecret } = require('./endpoints/secrets');
+import { readSecret, writeSecret } from './endpoints/secrets.js';
+import { getContentOfType } from './endpoints/content-manager.js';
-const KEY_PREFIX = 'user:';
+export const KEY_PREFIX = 'user:';
 const AVATAR_PREFIX = 'avatar:';
 const ENABLE_ACCOUNTS = getConfigValue('enableUserAccounts', false);
 const AUTHELIA_AUTH = getConfigValue('autheliaAuth', false);

 /**
  * Ensures that the content directories exist.
- * @returns {Promise<import('./users').UserDirectoryList[]>} - The list of user directories
+ * @returns {Promise<import('./users.js').UserDirectoryList[]>} - The list of user directories
  */
-async function ensurePublicDirectoriesExist() {
+export async function ensurePublicDirectoriesExist() {
     for (const dir of Object.values(PUBLIC_DIRECTORIES)) {
         if (!fs.existsSync(dir)) {
             fs.mkdirSync(dir, { recursive: true });

 /**
  * Gets a list of all user directories.
- * @returns {Promise<import('./users').UserDirectoryList[]>} - The list of user directories
+ * @returns {Promise<import('./users.js').UserDirectoryList[]>} - The list of user directories
  */
-async function getUserDirectoriesList() {
+export async function getUserDirectoriesList() {
     const userHandles = await getAllUserHandles();
     const directoriesList = userHandles.map(handle => getUserDirectories(handle));
     return directoriesList;

 /**
  * Perform migration from the old user data format to the new one.
  */
-async function migrateUserData() {
+export async function migrateUserData() {
     const publicDirectory = path.join(process.cwd(), 'public');
     // No need to migrate if the characters directory doesn't exists

     console.log(color.green('Migration completed!'));
+}
-async function migrateSystemPrompts() {
+export async function migrateSystemPrompts() {
     /**
      * Gets the default system prompts.
      * @returns {Promise<any[]>} - The list of default system prompts
      */
     async function getDefaultSystemPrompts() {
         try {
-            const { getContentOfType } = await import('./endpoints/content-manager.js');
             return getContentOfType('sysprompt', 'json');
         } catch {
             return [];

  * @param {string} handle User handle
  * @returns {string} The key for the user storage
  */
-function toKey(handle) {
+export function toKey(handle) {
     return `${KEY_PREFIX}${handle}`;
+}

  * @param {string} handle User handle
  * @returns {string} The key for the avatar storage
  */
-function toAvatarKey(handle) {
+export function toAvatarKey(handle) {
     return `${AVATAR_PREFIX}${handle}`;
+}

  * @param {string} dataRoot The root directory for user data
  * @returns {Promise<void>}
  */
-async function initUserStorage(dataRoot) {
+export async function initUserStorage(dataRoot) {
     global.DATA_ROOT = dataRoot;
     console.log('Using data root:', color.green(global.DATA_ROOT));
     console.log();

  * Get the cookie secret from the config. If it doesn't exist, generate a new one.
  * @returns {string} The cookie secret
  */
-function getCookieSecret() {
+export function getCookieSecret() {
     let secret = getConfigValue(STORAGE_KEYS.cookieSecret);
     if (!secret) {

  * Generates a random password salt.
  * @returns {string} The password salt
  */
-function getPasswordSalt() {
+export function getPasswordSalt() {
     return crypto.randomBytes(16).toString('base64');
+}

  * Get the session name for the current server.
  * @returns {string} The session name
  */
-function getCookieSessionName() {
+export function getCookieSessionName() {
     // Get server hostname and hash it to generate a session suffix
     const suffix = crypto.createHash('sha256').update(os.hostname()).digest('hex').slice(0, 8);
     return `session-${suffix}`;

  * @param {string} salt Salt to use for hashing
  * @returns {string} Hashed password
  */
-function getPasswordHash(password, salt) {
+export function getPasswordHash(password, salt) {
     return crypto.scryptSync(password.normalize(), salt, 64).toString('base64');
+}

  * @param {import('express').Request} [request] HTTP request object
  * @returns {string} The CSRF secret
  */
-function getCsrfSecret(request) {
+export function getCsrfSecret(request) {
     if (!request || !request.user) {
         return ANON_CSRF_SECRET;
+    }

  * Gets a list of all user handles.
  * @returns {Promise<string[]>} - The list of user handles
  */
-async function getAllUserHandles() {
+export async function getAllUserHandles() {
     const keys = await storage.keys(x => x.key.startsWith(KEY_PREFIX));
     const handles = keys.map(x => x.replace(KEY_PREFIX, ''));
     return handles;

  * @param {string} handle User handle
  * @returns {UserDirectoryList} User directories
  */
-function getUserDirectories(handle) {
+export function getUserDirectories(handle) {
     if (DIRECTORIES_CACHE.has(handle)) {
         const cache = DIRECTORIES_CACHE.get(handle);
         if (cache) {

  * @param {string} handle User handle
  * @returns {Promise<string>} User avatar URL
  */
-async function getUserAvatar(handle) {
+export async function getUserAvatar(handle) {
     try {
         // Check if the user has a custom avatar
         const avatarKey = toAvatarKey(handle);

  * @param {import('express').Request} request Request object
  * @returns {boolean} Whether the user should be redirected to the login page
  */
-function shouldRedirectToLogin(request) {
+export function shouldRedirectToLogin(request) {
     return ENABLE_ACCOUNTS && !request.user;
+}

  * @param {boolean} basicAuthMode If Basic auth mode is enabled
  * @returns {Promise<boolean>} Whether auto-login was performed
  */
-async function tryAutoLogin(request, basicAuthMode) {
+export async function tryAutoLogin(request, basicAuthMode) {
     if (!ENABLE_ACCOUNTS || request.user || !request.session) {
         return false;
+    }

  * @param {import('express').Response} response Response object
  * @param {import('express').NextFunction} next Next function
  */
-async function setUserDataMiddleware(request, response, next) {
+export async function setUserDataMiddleware(request, response, next) {
     // If user accounts are disabled, use the default user
     if (!ENABLE_ACCOUNTS) {
         const handle = DEFAULT_USER.handle;

  * @param {import('express').Response} response Response object
  * @param {import('express').NextFunction} next Next function
  */
-function requireLoginMiddleware(request, response, next) {
+export function requireLoginMiddleware(request, response, next) {
     if (!request.user) {
         return response.sendStatus(403);
+    }

  * @param {import('express').NextFunction} next Next function
  * @returns {any}
  */
-function requireAdminMiddleware(request, response, next) {
+export function requireAdminMiddleware(request, response, next) {
     if (!request.user) {
         return response.sendStatus(403);
+    }

  * @param {import('express').Response} response Express response object to write to
  * @returns {Promise<void>} Promise that resolves when the archive is created
  */
-async function createBackupArchive(handle, response) {
+export async function createBackupArchive(handle, response) {
     const directories = getUserDirectories(handle);
     console.log('Backup requested for', handle);

  * Gets all of the enabled users.
  * @returns {Promise<User[]>}
  */
-async function getAllEnabledUsers() {
+export async function getAllEnabledUsers() {
     const users = await getAllUsers();
     return users.filter(x => x.enabled);
+}

 /**
  * Express router for serving files from the user's directories.
  */
-const router = express.Router();
+export const router = express.Router();
 router.use('/backgrounds/*', createRouteHandler(req => req.user.directories.backgrounds));
 router.use('/characters/*', createRouteHandler(req => req.user.directories.characters));
 router.use('/User%20Avatars/*', createRouteHandler(req => req.user.directories.avatars));

 router.use('/user/images/*', createRouteHandler(req => req.user.directories.userImages));
 router.use('/user/files/*', createRouteHandler(req => req.user.directories.files));
 router.use('/scripts/extensions/third-party/*', createRouteHandler(req => req.user.directories.extensions));
-module.exports = {
-    KEY_PREFIX,
-    toKey,
-    toAvatarKey,
-    initUserStorage,
-    ensurePublicDirectoriesExist,
-    getUserDirectoriesList,
-    getAllUserHandles,
-    getUserDirectories,
-    setUserDataMiddleware,
-    requireLoginMiddleware,
-    requireAdminMiddleware,
-    migrateUserData,
-    migrateSystemPrompts,
-    getPasswordSalt,
-    getPasswordHash,
-    getCsrfSecret,
-    getCookieSecret,
-    getCookieSessionName,
-    getUserAvatar,
-    shouldRedirectToLogin,
-    createBackupArchive,
-    tryAutoLogin,
-    getAllUsers,
-    getAllEnabledUsers,
-    router,
-};

src/util.js+59 -81 Viewed

-const path = require('path');
+import path from 'node:path';
-const fs = require('fs');
+import fs from 'node:fs';
-const commandExistsSync = require('command-exists').sync;
+import http2 from 'node:http2';
-const writeFileAtomicSync = require('write-file-atomic').sync;
+import process from 'node:process';
-const _ = require('lodash');
+import { Readable } from 'node:stream';
-const yauzl = require('yauzl');
+import { createRequire } from 'node:module';
-const mime = require('mime-types');
+import { Buffer } from 'node:buffer';
-const yaml = require('yaml');
-const { default: simpleGit } = require('simple-git');
+import yaml from 'yaml';
-const { Readable } = require('stream');
+import { sync as commandExistsSync } from 'command-exists';
+import { sync as writeFileAtomicSync } from 'write-file-atomic';
+import _ from 'lodash';
+import yauzl from 'yauzl';
+import mime from 'mime-types';
+import { default as simpleGit } from 'simple-git';
 /**
  * Parsed config object.

  * Returns the config object from the config.yaml file.
  * @returns {object} Config object
  */
-function getConfig() {
+export function getConfig() {
     if (CACHED_CONFIG) {
         return CACHED_CONFIG;
+    }

  * @param {any} defaultValue - Default value to return if the key is not found
  * @returns {any} Value for the given key
  */
-function getConfigValue(key, defaultValue = null) {
+export function getConfigValue(key, defaultValue = null) {
     const config = getConfig();
     return _.get(config, key, defaultValue);
+}

  * @param {string} key Key to set
  * @param {any} value Value to set
  */
-function setConfigValue(key, value) {
+export function setConfigValue(key, value) {
     // Reset cache so that the next getConfig call will read the updated config file
     CACHED_CONFIG = null;
     const config = getConfig();

  * @param {string} auth username:password
  * @returns {string} Basic Auth header value
  */
-function getBasicAuthHeader(auth) {
+export function getBasicAuthHeader(auth) {
     const encoded = Buffer.from(`${auth}`).toString('base64');
     return `Basic ${encoded}`;
+}

  * Also returns the agent string for the Horde API.
  * @returns {Promise<{agent: string, pkgVersion: string, gitRevision: string | null, gitBranch: string | null, commitDate: string | null, isLatest: boolean}>} Version info object
  */
-async function getVersion() {
+export async function getVersion() {
     let pkgVersion = 'UNKNOWN';
     let gitRevision = null;
     let gitBranch = null;

     let isLatest = true;
     try {
+        const require = createRequire(import.meta.url);
         const pkgJson = require(path.join(process.cwd(), './package.json'));
         pkgVersion = pkgJson.version;
-        if (!process['pkg'] && commandExistsSync('git')) {
+        if (commandExistsSync('git')) {
             const git = simpleGit();
             const cwd = process.cwd();
             gitRevision = await git.cwd(cwd).revparse(['--short', 'HEAD']);

  * @param {number} ms Milliseconds to wait
  * @returns {Promise<void>} Promise that resolves after the given amount of milliseconds
  */
-function delay(ms) {
+export function delay(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
+}

  * @returns {string} Random hex string
  * @example getHexString(8) // 'a1b2c3d4'
  */
-function getHexString(length) {
+export function getHexString(length) {
     const chars = '0123456789abcdef';
     let result = '';
     for (let i = 0; i < length; i++) {

  * @param {string} fileExtension File extension to look for
  * @returns {Promise<Buffer|null>} Buffer containing the extracted file. Null if the file was not found.
  */
-async function extractFileFromZipBuffer(archiveBuffer, fileExtension) {
+export async function extractFileFromZipBuffer(archiveBuffer, fileExtension) {
     return await new Promise((resolve, reject) => yauzl.fromBuffer(Buffer.from(archiveBuffer), { lazyEntries: true }, (err, zipfile) => {
         if (err) {
             reject(err);

  * @param {string} zipFilePath Path to the ZIP archive
  * @returns {Promise<[string, Buffer][]>} Array of image buffers
  */
-async function getImageBuffers(zipFilePath) {
+export async function getImageBuffers(zipFilePath) {
     return new Promise((resolve, reject) => {
         // Check if the zip file exists
         if (!fs.existsSync(zipFilePath)) {

  * @param {any} readableStream Readable stream to read from
  * @returns {Promise<Buffer[]>} Array of chunks
  */
-async function readAllChunks(readableStream) {
+export async function readAllChunks(readableStream) {
     return new Promise((resolve, reject) => {
         // Consume the readable stream
         const chunks = [];

     return (item && typeof item === 'object' && !Array.isArray(item));
+}
-function deepMerge(target, source) {
+export function deepMerge(target, source) {
     let output = Object.assign({}, target);
     if (isObject(target) && isObject(source)) {
         Object.keys(source).forEach(key => {

     return output;
+}
-const color = {
+export const color = {
     byNum: (mess, fgNum) => {
         mess = mess || '';
         fgNum = fgNum === undefined ? 31 : fgNum;

  * Gets a random UUIDv4 string.
  * @returns {string} A UUIDv4 string
  */
-function uuidv4() {
+export function uuidv4() {
     if ('crypto' in global && 'randomUUID' in global.crypto) {
         return global.crypto.randomUUID();
+    }

     });
+}
-function humanizedISO8601DateTime(date) {
+export function humanizedISO8601DateTime(date) {
     let baseDate = typeof date === 'number' ? new Date(date) : new Date();
     let humanYear = baseDate.getFullYear();
     let humanMonth = (baseDate.getMonth() + 1);

     return HumanizedDateTime;
+}
-function tryParse(str) {
+export function tryParse(str) {
     try {
         return JSON.parse(str);
     } catch {

  * @param {string} inputPath The path to be converted.
  * @returns The relative URL path from which the client can access the file.
  */
-function clientRelativePath(root, inputPath) {
+export function clientRelativePath(root, inputPath) {
     if (!inputPath.startsWith(root)) {
         throw new Error('Input path does not start with the root directory');
+    }

  * @param {string} filename The file name to remove the extension from.
  * @returns The file name, sans extension
  */
-function removeFileExtension(filename) {
+export function removeFileExtension(filename) {
     return filename.replace(/\.[^.]+$/, '');
+}
-function generateTimestamp() {
+export function generateTimestamp() {
     const now = new Date();
     const year = now.getFullYear();
     const month = String(now.getMonth() + 1).padStart(2, '0');

  * @param {string} directory The root directory to remove backups from.
  * @param {string} prefix File prefix to filter backups by.
  */
-function removeOldBackups(directory, prefix) {
+export function removeOldBackups(directory, prefix) {
     const MAX_BACKUPS = Number(getConfigValue('numberOfBackups', 50));
     let files = fs.readdirSync(directory).filter(f => f.startsWith(prefix));

  * @param {'name' | 'date'} sortBy Sort images by name or date
  * @returns {string[]} List of image file names
  */
-function getImages(directoryPath, sortBy = 'name') {
+export function getImages(directoryPath, sortBy = 'name') {
     function getSortFunction() {
         switch (sortBy) {
             case 'name':

  * @param {import('node-fetch').Response} from The Fetch API response to pipe from.
  * @param {import('express').Response} to The Express response to pipe to.
  */
-function forwardFetchResponse(from, to) {
+export function forwardFetchResponse(from, to) {
     let statusCode = from.status;
     let statusText = from.statusText;

     to.statusCode = statusCode;
     to.statusMessage = statusText;
-    from.body.pipe(to);
-    to.socket.on('close', function () {
+    if (from.body && to.socket) {
-        if (from.body instanceof Readable) from.body.destroy(); // Close the remote stream
+        from.body.pipe(to);
-        to.end(); // End the Express response
-    });
+        to.socket.on('close', function () {
+            if (from.body instanceof Readable) from.body.destroy(); // Close the remote stream
+            to.end(); // End the Express response
+        });
-    from.body.on('end', function () {
+        from.body.on('end', function () {
-        console.log('Streaming request finished');
+            console.log('Streaming request finished');
+            to.end();
+        });
+    } else {
         to.end();
-    });
+    }
+}
 /**

  * @param {object} headers Request headers
  * @returns {Promise<string>} Response body
  */
-function makeHttp2Request(endpoint, method, body, headers) {
+export function makeHttp2Request(endpoint, method, body, headers) {
     return new Promise((resolve, reject) => {
         try {
-            const http2 = require('http2');
             const url = new URL(endpoint);
             const client = http2.connect(url.origin);

  * @param {string} yamlString YAML-serialized object
  * @returns
  */
-function mergeObjectWithYaml(obj, yamlString) {
+export function mergeObjectWithYaml(obj, yamlString) {
     if (!yamlString) {
         return;
+    }

  * @param {string} yamlString YAML-serialized array
  * @returns {void} Nothing
  */
-function excludeKeysByYaml(obj, yamlString) {
+export function excludeKeysByYaml(obj, yamlString) {
     if (!yamlString) {
         return;
+    }

  * @param {string} str Input string
  * @returns {string} Trimmed string
  */
-function trimV1(str) {
+export function trimV1(str) {
     return String(str ?? '').replace(/\/$/, '').replace(/\/v1$/, '');
+}
 /**
  * Simple TTL memory cache.
  */
-class Cache {
+export class Cache {
     /**
      * @param {number} ttl Time to live in milliseconds
      */

  * @param {string} text Text with color formatting
  * @returns {string} Text without color formatting
  */
-function removeColorFormatting(text) {
+export function removeColorFormatting(text) {
     // ANSI escape codes for colors are usually in the format \x1b[<codes>m
     return text.replace(/\x1b\[\d{1,2}(;\d{1,2})*m/g, '');
+}

  * @param {number} n Number of times to repeat the separator
  * @returns {string} Separator string
  */
-function getSeparator(n) {
+export function getSeparator(n) {
     return '='.repeat(n);
+}

  * @param {string} url String to check
  * @returns {boolean} If the URL is valid
  */
-function isValidUrl(url) {
+export function isValidUrl(url) {
     try {
         new URL(url);
         return true;

         return false;
+    }
+}
-module.exports = {
-    getConfig,
-    getConfigValue,
-    setConfigValue,
-    getVersion,
-    getBasicAuthHeader,
-    extractFileFromZipBuffer,
-    getImageBuffers,
-    readAllChunks,
-    delay,
-    deepMerge,
-    color,
-    uuidv4,
-    humanizedISO8601DateTime,
-    tryParse,
-    clientRelativePath,
-    removeFileExtension,
-    generateTimestamp,
-    removeOldBackups,
-    getImages,
-    forwardFetchResponse,
-    getHexString,
-    mergeObjectWithYaml,
-    excludeKeysByYaml,
-    trimV1,
-    Cache,
-    makeHttp2Request,
-    removeColorFormatting,
-    getSeparator,
-    isValidUrl,
-};

src/validator/TavernCardValidator.js+1 -3 Viewed

+ *
  * @link https://github.com/malfoyslastname/character-card-spec-v2
  */
-class TavernCardValidator {
+export class TavernCardValidator {
     /**
      * @type {string|null}
      */

@@ -167,5 +167,3 @@ class TavernCardValidator {
167	return true;	167	return true;
168	}	168	}
169	}	169	}
170
171	module.exports = { TavernCardValidator };

src/vectors/cohere-vectors.js+7 -10 Viewed

-const fetch = require('node-fetch').default;
+import fetch from 'node-fetch';
-const { SECRET_KEYS, readSecret } = require('../endpoints/secrets');
+import { SECRET_KEYS, readSecret } from '../endpoints/secrets.js';
 /**
  * Gets the vector for the given text batch from an OpenAI compatible endpoint.
  * @param {string[]} texts - The array of texts to get the vector for
  * @param {boolean} isQuery - If the text is a query for embedding search
- * @param {import('../users').UserDirectoryList} directories - The directories object for the user
+ * @param {import('../users.js').UserDirectoryList} directories - The directories object for the user
  * @param {string} model - The model to use for the embedding
  * @returns {Promise<number[][]>} - The array of vectors for the texts
  */
-async function getCohereBatchVector(texts, isQuery, directories, model) {
+export async function getCohereBatchVector(texts, isQuery, directories, model) {
     const key = readSecret(directories, SECRET_KEYS.COHERE);
     if (!key) {

         throw new Error('API request failed');
+    }
+    /** @type {any} */
     const data = await response.json();
     if (!Array.isArray(data?.embeddings?.float)) {
         console.log('API response was not an array');

  * Gets the vector for the given text from an OpenAI compatible endpoint.
  * @param {string} text - The text to get the vector for
  * @param {boolean} isQuery - If the text is a query for embedding search
- * @param {import('../users').UserDirectoryList} directories - The directories object for the user
+ * @param {import('../users.js').UserDirectoryList} directories - The directories object for the user
  * @param {string} model - The model to use for the embedding
  * @returns {Promise<number[]>} - The vector for the text
  */
-async function getCohereVector(text, isQuery, directories, model) {
+export async function getCohereVector(text, isQuery, directories, model) {
     const vectors = await getCohereBatchVector([text], isQuery, directories, model);
     return vectors[0];
+}
-module.exports = {
-    getCohereBatchVector,
-    getCohereVector,
-};

src/vectors/embedding.js+4 -9 Viewed

+import { getPipeline } from '../transformers.mjs';
 const TASK = 'feature-extraction';
 /**

  * @param {string} text - The text to vectorize
  * @returns {Promise<number[]>} - The vectorized text in form of an array of numbers
  */
-async function getTransformersVector(text) {
+export async function getTransformersVector(text) {
-    const module = await import('../transformers.mjs');
+    const pipe = await getPipeline(TASK);
-    const pipe = await module.default.getPipeline(TASK);
     const result = await pipe(text, { pooling: 'mean', normalize: true });
     const vector = Array.from(result.data);
     return vector;

  * @param {string[]} texts - The texts to vectorize
  * @returns {Promise<number[][]>} - The vectorized texts in form of an array of arrays of numbers
  */
-async function getTransformersBatchVector(texts) {
+export async function getTransformersBatchVector(texts) {
     const result = [];
     for (const text of texts) {
         result.push(await getTransformersVector(text));
+    }
     return result;
+}
-module.exports = {
-    getTransformersVector,
-    getTransformersBatchVector,
-};

src/vectors/extras-vectors.js+4 -8 Viewed

-const fetch = require('node-fetch').default;
+import fetch from 'node-fetch';
 /**
  * Gets the vector for the given text from SillyTavern-extras

  * @param {string} apiKey - The Extras API key, or empty string if API key not enabled
  * @returns {Promise<number[][]>} - The array of vectors for the texts
  */
-async function getExtrasBatchVector(texts, apiUrl, apiKey) {
+export async function getExtrasBatchVector(texts, apiUrl, apiKey) {
     return getExtrasVectorImpl(texts, apiUrl, apiKey);
+}

  * @param {string} apiKey - The Extras API key, or empty string if API key not enabled
  * @returns {Promise<number[]>} - The vector for the text
  */
-async function getExtrasVector(text, apiUrl, apiKey) {
+export async function getExtrasVector(text, apiUrl, apiKey) {
     return getExtrasVectorImpl(text, apiUrl, apiKey);
+}

         throw new Error('Extras request failed');
+    }
+    /** @type {any} */
     const data = await response.json();
     const vector = data.embedding;  // `embedding`: number[] (one text item), or number[][] (multiple text items).
     return vector;
+}
-module.exports = {
-    getExtrasVector,
-    getExtrasBatchVector,
-};

src/vectors/llamacpp-vectors.js+8 -12 Viewed

-const fetch = require('node-fetch').default;
+import fetch from 'node-fetch';
-const { setAdditionalHeadersByType } = require('../additional-headers');
+import { setAdditionalHeadersByType } from '../additional-headers.js';
-const { TEXTGEN_TYPES } = require('../constants');
+import { TEXTGEN_TYPES } from '../constants.js';
 /**
  * Gets the vector for the given text from LlamaCpp
  * @param {string[]} texts - The array of texts to get the vectors for
  * @param {string} apiUrl - The API URL
- * @param {import('../users').UserDirectoryList} directories - The directories object for the user
+ * @param {import('../users.js').UserDirectoryList} directories - The directories object for the user
  * @returns {Promise<number[][]>} - The array of vectors for the texts
  */
-async function getLlamaCppBatchVector(texts, apiUrl, directories) {
+export async function getLlamaCppBatchVector(texts, apiUrl, directories) {
     const url = new URL(apiUrl);
     url.pathname = '/v1/embeddings';

         throw new Error(`LlamaCpp: Failed to get vector for text: ${response.statusText} ${responseText}`);
+    }
+    /** @type {any} */
     const data = await response.json();
     if (!Array.isArray(data?.data)) {

  * Gets the vector for the given text from LlamaCpp
  * @param {string} text - The text to get the vector for
  * @param {string} apiUrl - The API URL
- * @param {import('../users').UserDirectoryList} directories - The directories object for the user
+ * @param {import('../users.js').UserDirectoryList} directories - The directories object for the user
  * @returns {Promise<number[]>} - The vector for the text
  */
-async function getLlamaCppVector(text, apiUrl, directories) {
+export async function getLlamaCppVector(text, apiUrl, directories) {
     const vectors = await getLlamaCppBatchVector([text], apiUrl, directories);
     return vectors[0];
+}
-module.exports = {
-    getLlamaCppBatchVector,
-    getLlamaCppVector,
-};

src/vectors/makersuite-vectors.js+7 -11 Viewed

-const fetch = require('node-fetch').default;
+import fetch from 'node-fetch';
-const { SECRET_KEYS, readSecret } = require('../endpoints/secrets');
+import { SECRET_KEYS, readSecret } from '../endpoints/secrets.js';
 const API_MAKERSUITE = 'https://generativelanguage.googleapis.com';
 /**
  * Gets the vector for the given text from gecko model
  * @param {string[]} texts - The array of texts to get the vector for
- * @param {import('../users').UserDirectoryList} directories - The directories object for the user
+ * @param {import('../users.js').UserDirectoryList} directories - The directories object for the user
  * @returns {Promise<number[][]>} - The array of vectors for the texts
  */
-async function getMakerSuiteBatchVector(texts, directories) {
+export async function getMakerSuiteBatchVector(texts, directories) {
     const promises = texts.map(text => getMakerSuiteVector(text, directories));
     return await Promise.all(promises);
+}

 /**
  * Gets the vector for the given text from Gemini API text-embedding-004 model
  * @param {string} text - The text to get the vector for
- * @param {import('../users').UserDirectoryList} directories - The directories object for the user
+ * @param {import('../users.js').UserDirectoryList} directories - The directories object for the user
  * @returns {Promise<number[]>} - The vector for the text
  */
-async function getMakerSuiteVector(text, directories) {
+export async function getMakerSuiteVector(text, directories) {
     const key = readSecret(directories, SECRET_KEYS.MAKERSUITE);
     if (!key) {

         throw new Error('Google AI Studio request failed');
+    }
+    /** @type {any} */
     const data = await response.json();
     // noinspection JSValidateTypes
     return data['embedding']['values'];
+}
-module.exports = {
-    getMakerSuiteVector,
-    getMakerSuiteBatchVector,
-};

src/vectors/nomicai-vectors.js+7 -11 Viewed

-const fetch = require('node-fetch').default;
+import fetch from 'node-fetch';
-const { SECRET_KEYS, readSecret } = require('../endpoints/secrets');
+import { SECRET_KEYS, readSecret } from '../endpoints/secrets.js';
 const SOURCES = {
     'nomicai': {

  * Gets the vector for the given text batch from an OpenAI compatible endpoint.
  * @param {string[]} texts - The array of texts to get the vector for
  * @param {string} source - The source of the vector
- * @param {import('../users').UserDirectoryList} directories - The directories object for the user
+ * @param {import('../users.js').UserDirectoryList} directories - The directories object for the user
  * @returns {Promise<number[][]>} - The array of vectors for the texts
  */
-async function getNomicAIBatchVector(texts, source, directories) {
+export async function getNomicAIBatchVector(texts, source, directories) {
     const config = SOURCES[source];
     if (!config) {

         throw new Error('API request failed');
+    }
+    /** @type {any} */
     const data = await response.json();
     if (!Array.isArray(data?.embeddings)) {
         console.log('API response was not an array');

  * Gets the vector for the given text from an OpenAI compatible endpoint.
  * @param {string} text - The text to get the vector for
  * @param {string} source - The source of the vector
- * @param {import('../users').UserDirectoryList} directories - The directories object for the user
+ * @param {import('../users.js').UserDirectoryList} directories - The directories object for the user
  * @returns {Promise<number[]>} - The vector for the text
  */
-async function getNomicAIVector(text, source, directories) {
+export async function getNomicAIVector(text, source, directories) {
     const vectors = await getNomicAIBatchVector([text], source, directories);
     return vectors[0];
+}
-module.exports = {
-    getNomicAIVector,
-    getNomicAIBatchVector,
-};

src/vectors/ollama-vectors.js+8 -12 Viewed

-const fetch = require('node-fetch').default;
+import fetch from 'node-fetch';
-const { setAdditionalHeadersByType } = require('../additional-headers');
+import { setAdditionalHeadersByType } from '../additional-headers.js';
-const { TEXTGEN_TYPES } = require('../constants');
+import { TEXTGEN_TYPES } from '../constants.js';
 /**
  * Gets the vector for the given text from Ollama

  * @param {string} apiUrl - The API URL
  * @param {string} model - The model to use
  * @param {boolean} keep - Keep the model loaded in memory
- * @param {import('../users').UserDirectoryList} directories - The directories object for the user
+ * @param {import('../users.js').UserDirectoryList} directories - The directories object for the user
  * @returns {Promise<number[][]>} - The array of vectors for the texts
  */
-async function getOllamaBatchVector(texts, apiUrl, model, keep, directories) {
+export async function getOllamaBatchVector(texts, apiUrl, model, keep, directories) {
     const result = [];
     for (const text of texts) {
         const vector = await getOllamaVector(text, apiUrl, model, keep, directories);

  * @param {string} apiUrl - The API URL
  * @param {string} model - The model to use
  * @param {boolean} keep - Keep the model loaded in memory
- * @param {import('../users').UserDirectoryList} directories - The directories object for the user
+ * @param {import('../users.js').UserDirectoryList} directories - The directories object for the user
  * @returns {Promise<number[]>} - The vector for the text
  */
-async function getOllamaVector(text, apiUrl, model, keep, directories) {
+export async function getOllamaVector(text, apiUrl, model, keep, directories) {
     const url = new URL(apiUrl);
     url.pathname = '/api/embeddings';

         throw new Error(`Ollama: Failed to get vector for text: ${response.statusText} ${responseText}`);
+    }
+    /** @type {any} */
     const data = await response.json();
     if (!Array.isArray(data?.embedding)) {

     return data.embedding;
+}
-module.exports = {
-    getOllamaBatchVector,
-    getOllamaVector,
-};

src/vectors/openai-vectors.js+7 -11 Viewed

-const fetch = require('node-fetch').default;
+import fetch from 'node-fetch';
-const { SECRET_KEYS, readSecret } = require('../endpoints/secrets');
+import { SECRET_KEYS, readSecret } from '../endpoints/secrets.js';
 const SOURCES = {
     'togetherai': {

  * Gets the vector for the given text batch from an OpenAI compatible endpoint.
  * @param {string[]} texts - The array of texts to get the vector for
  * @param {string} source - The source of the vector
- * @param {import('../users').UserDirectoryList} directories - The directories object for the user
+ * @param {import('../users.js').UserDirectoryList} directories - The directories object for the user
  * @param {string} model - The model to use for the embedding
  * @returns {Promise<number[][]>} - The array of vectors for the texts
  */
-async function getOpenAIBatchVector(texts, source, directories, model = '') {
+export async function getOpenAIBatchVector(texts, source, directories, model = '') {
     const config = SOURCES[source];
     if (!config) {

         throw new Error('API request failed');
+    }
+    /** @type {any} */
     const data = await response.json();
     if (!Array.isArray(data?.data)) {

  * Gets the vector for the given text from an OpenAI compatible endpoint.
  * @param {string} text - The text to get the vector for
  * @param {string} source - The source of the vector
- * @param {import('../users').UserDirectoryList} directories - The directories object for the user
+ * @param {import('../users.js').UserDirectoryList} directories - The directories object for the user
  * @param {string} model - The model to use for the embedding
  * @returns {Promise<number[]>} - The vector for the text
  */
-async function getOpenAIVector(text, source, directories, model = '') {
+export async function getOpenAIVector(text, source, directories, model = '') {
     const vectors = await getOpenAIBatchVector([text], source, directories, model);
     return vectors[0];
+}
-module.exports = {
-    getOpenAIVector,
-    getOpenAIBatchVector,
-};

src/vectors/vllm-vectors.js+8 -12 Viewed

-const fetch = require('node-fetch').default;
+import fetch from 'node-fetch';
-const { setAdditionalHeadersByType } = require('../additional-headers');
+import { setAdditionalHeadersByType } from '../additional-headers.js';
-const { TEXTGEN_TYPES } = require('../constants');
+import { TEXTGEN_TYPES } from '../constants.js';
 /**
  * Gets the vector for the given text from VLLM
  * @param {string[]} texts - The array of texts to get the vectors for
  * @param {string} apiUrl - The API URL
  * @param {string} model - The model to use
- * @param {import('../users').UserDirectoryList} directories - The directories object for the user
+ * @param {import('../users.js').UserDirectoryList} directories - The directories object for the user
  * @returns {Promise<number[][]>} - The array of vectors for the texts
  */
-async function getVllmBatchVector(texts, apiUrl, model, directories) {
+export async function getVllmBatchVector(texts, apiUrl, model, directories) {
     const url = new URL(apiUrl);
     url.pathname = '/v1/embeddings';

         throw new Error(`VLLM: Failed to get vector for text: ${response.statusText} ${responseText}`);
+    }
+    /** @type {any} */
     const data = await response.json();
     if (!Array.isArray(data?.data)) {

  * @param {string} text - The text to get the vector for
  * @param {string} apiUrl - The API URL
  * @param {string} model - The model to use
- * @param {import('../users').UserDirectoryList} directories - The directories object for the user
+ * @param {import('../users.js').UserDirectoryList} directories - The directories object for the user
  * @returns {Promise<number[]>} - The vector for the text
  */
-async function getVllmVector(text, apiUrl, model, directories) {
+export async function getVllmVector(text, apiUrl, model, directories) {
     const vectors = await getVllmBatchVector([text], apiUrl, model, directories);
     return vectors[0];
+}
-module.exports = {
-    getVllmBatchVector,
-    getVllmVector,
-};

Merge branch 'staging' into cc-async-count