1078 lines
36 KiB
TypeScript
1078 lines
36 KiB
TypeScript
import { get, writable, type Writable } from "svelte/store"
|
|
import { alertCardExport, alertConfirm, alertError, alertInput, alertMd, alertNormal, alertSelect, alertStore, alertTOS, alertWait } from "./alert"
|
|
import { DataBase, defaultSdDataFunc, type character, setDatabase, type customscript, type loreSettings, type loreBook, type triggerscript } from "./storage/database"
|
|
import { checkNullish, decryptBuffer, encryptBuffer, selectFileByDom, selectMultipleFile, sleep } from "./util"
|
|
import { language } from "src/lang"
|
|
import { v4 as uuidv4 } from 'uuid';
|
|
import { characterFormatUpdate } from "./characters"
|
|
import { AppendableBuffer, checkCharOrder, downloadFile, loadAsset, LocalWriter, readImage, saveAsset, VirtualWriter } from "./storage/globalApi"
|
|
import { CurrentCharacter, selectedCharID } from "./stores"
|
|
import { convertImage, hasher } from "./parser"
|
|
import { CCardLib } from '@risuai/ccardlib'
|
|
import { reencodeImage } from "./process/files/image"
|
|
import { PngChunk } from "./pngChunk"
|
|
import type { OnnxModelFiles } from "./process/transformers"
|
|
|
|
export const hubURL = "https://sv.risuai.xyz"
|
|
|
|
export async function importCharacter() {
|
|
try {
|
|
const files = await selectFileByDom(['png', 'json'], 'multiple')
|
|
if(!files){
|
|
return
|
|
}
|
|
|
|
for(const f of files){
|
|
console.log(f)
|
|
await importCharacterProcess({
|
|
name: f.name,
|
|
data: f
|
|
})
|
|
checkCharOrder()
|
|
}
|
|
} catch (error) {
|
|
alertError(`${error}`)
|
|
return null
|
|
}
|
|
}
|
|
|
|
async function importCharacterProcess(f:{
|
|
name: string;
|
|
data: Uint8Array|File|ReadableStream<Uint8Array>
|
|
}) {
|
|
if(f.name.endsWith('json')){
|
|
if(f.data instanceof ReadableStream){
|
|
return null
|
|
}
|
|
const data = f.data instanceof Uint8Array ? f.data : new Uint8Array(await f.data.arrayBuffer())
|
|
const da = JSON.parse(Buffer.from(data).toString('utf-8'))
|
|
if(await importSpecv2(da)){
|
|
let db = get(DataBase)
|
|
return db.characters.length - 1
|
|
}
|
|
if((da.char_name || da.name) && (da.char_persona || da.description) && (da.char_greeting || da.first_mes)){
|
|
let db = get(DataBase)
|
|
db.characters.push(convertOldTavernAndJSON(da))
|
|
DataBase.set(db)
|
|
alertNormal(language.importedCharacter)
|
|
return
|
|
}
|
|
else{
|
|
alertError(language.errors.noData)
|
|
return
|
|
}
|
|
}
|
|
alertStore.set({
|
|
type: 'wait',
|
|
msg: 'Loading... (Reading)'
|
|
})
|
|
await sleep(10)
|
|
|
|
// const readed = PngChunk.read(img, ['chara'])?.['chara']
|
|
let readedChara = ''
|
|
let readedCCv3 = ''
|
|
let img:Uint8Array
|
|
const readGenerator = PngChunk.readGenerator(f.data, {
|
|
returnTrimed: true
|
|
})
|
|
const assets:{[key:string]:string} = {}
|
|
for await (const chunk of readGenerator){
|
|
console.log(chunk)
|
|
if(!chunk){
|
|
continue
|
|
}
|
|
if(chunk instanceof AppendableBuffer){
|
|
img = chunk.buffer
|
|
break
|
|
}
|
|
if(chunk.key === 'chara'){
|
|
//For memory reason, limit to 5MB
|
|
if(readedChara.length < 5 * 1024 * 1024){
|
|
readedChara = chunk.value
|
|
}
|
|
continue
|
|
}
|
|
if(chunk.key === 'ccv3'){
|
|
if(readedCCv3.length < 5 * 1024 * 1024){
|
|
readedCCv3 = chunk.value
|
|
}
|
|
continue
|
|
}
|
|
if(chunk.key.startsWith('chara-ext-asset_')){
|
|
const assetIndex = (chunk.key.replace('chara-ext-asset_', ''))
|
|
alertWait('Loading... (Reading Asset ' + assetIndex + ')' )
|
|
const assetData = Buffer.from(chunk.value, 'base64')
|
|
const assetId = await saveAsset(assetData)
|
|
assets[assetIndex] = assetId
|
|
}
|
|
}
|
|
if(!readedChara && !readedCCv3){
|
|
alertError(language.errors.noData)
|
|
return
|
|
}
|
|
|
|
if(!readedChara){
|
|
readedChara = readedCCv3
|
|
}
|
|
|
|
if(!img){
|
|
console.error("No Image Found")
|
|
alertError(language.errors.noData)
|
|
return
|
|
}
|
|
|
|
if(readedChara.startsWith('rcc||')){
|
|
const parts = readedChara.split('||')
|
|
const type = parts[1]
|
|
if(type === 'rccv1'){
|
|
if(parts.length !== 5){
|
|
alertError(language.errors.noData)
|
|
return
|
|
}
|
|
const encrypted = Buffer.from(parts[2], 'base64')
|
|
const hashed = await hasher(encrypted)
|
|
if(hashed !== parts[3]){
|
|
alertError(language.errors.noData)
|
|
return
|
|
}
|
|
const metaData:RccCardMetaData = JSON.parse(Buffer.from(parts[4], 'base64').toString('utf-8'))
|
|
if(metaData.usePassword){
|
|
const password = await alertInput(language.inputCardPassword)
|
|
if(!password){
|
|
return
|
|
}
|
|
else{
|
|
try {
|
|
const decrypted = await decryptBuffer(encrypted, password)
|
|
const charaData:CharacterCardV2 = JSON.parse(Buffer.from(decrypted).toString('utf-8'))
|
|
if(await importSpecv2(charaData, img, "normal", assets)){
|
|
let db = get(DataBase)
|
|
return db.characters.length - 1
|
|
}
|
|
else{
|
|
throw new Error('Error while importing')
|
|
}
|
|
} catch (error) {
|
|
alertError(language.errors.wrongPassword)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
else{
|
|
const decrypted = await decryptBuffer(encrypted, 'RISU_NONE')
|
|
try {
|
|
const charaData:CharacterCardV2 = JSON.parse(Buffer.from(decrypted).toString('utf-8'))
|
|
if(await importSpecv2(charaData, img, "normal", assets)){
|
|
let db = get(DataBase)
|
|
return db.characters.length - 1
|
|
}
|
|
} catch (error) {
|
|
alertError(language.errors.noData)
|
|
return
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
else {
|
|
const parsed = JSON.parse(Buffer.from(readedChara, 'base64').toString('utf-8'))
|
|
const checkedVersion = CCardLib.character.check(parsed)
|
|
if(checkedVersion === 'v2' || checkedVersion === 'v3'){
|
|
const charaData:CharacterCardV2 = CCardLib.character.convert(parsed, {
|
|
from: checkedVersion,
|
|
to: 'v2',
|
|
options: {
|
|
convertRisuFields: true
|
|
}
|
|
})
|
|
if(await importSpecv2(charaData, img, "normal", assets)){
|
|
let db = get(DataBase)
|
|
return db.characters.length - 1
|
|
}
|
|
}
|
|
}
|
|
const charaData:OldTavernChar = JSON.parse(Buffer.from(readedChara, 'base64').toString('utf-8'))
|
|
const imgp = await saveAsset(await reencodeImage(img))
|
|
let db = get(DataBase)
|
|
db.characters.push(convertOldTavernAndJSON(charaData, imgp))
|
|
DataBase.set(db)
|
|
alertNormal(language.importedCharacter)
|
|
return db.characters.length - 1
|
|
}
|
|
|
|
export const showRealmInfoStore:Writable<null|hubType> = writable(null)
|
|
|
|
export async function characterURLImport() {
|
|
const realmPath = (new URLSearchParams(location.search)).get('realm')
|
|
try {
|
|
if(realmPath){
|
|
const url = new URL(location.href);
|
|
url.searchParams.delete('realm');
|
|
window.history.pushState(null, '', url.toString());
|
|
|
|
const res = await fetch(`${hubURL}/hub/info/${realmPath}`)
|
|
if(res.status !== 200){
|
|
alertError(await res.text())
|
|
return
|
|
}
|
|
showRealmInfoStore.set(await res.json())
|
|
}
|
|
} catch (error) {
|
|
|
|
}
|
|
|
|
const charPath = (new URLSearchParams(location.search)).get('charahub')
|
|
try {
|
|
if(charPath){
|
|
alertWait('Loading from Chub...')
|
|
const url = new URL(location.href);
|
|
url.searchParams.delete('charahub');
|
|
window.history.pushState(null, '', url.toString());
|
|
const chara = await fetch("https://api.chub.ai/api/characters/download", {
|
|
method: "POST",
|
|
body: JSON.stringify({
|
|
"format": "tavern",
|
|
"fullPath": charPath,
|
|
"version": "main"
|
|
}),
|
|
headers: {
|
|
"content-type": "application/json"
|
|
}
|
|
})
|
|
const img = new Uint8Array(await chara.arrayBuffer())
|
|
await importCharacterProcess({
|
|
name: 'charahub.png',
|
|
data: img
|
|
})
|
|
}
|
|
} catch (error) {
|
|
alertError(language.errors.noData)
|
|
return null
|
|
}
|
|
}
|
|
|
|
|
|
function convertOldTavernAndJSON(charaData:OldTavernChar, imgp:string|undefined = undefined):character{
|
|
|
|
|
|
return {
|
|
name: charaData.name ?? 'unknown name',
|
|
firstMessage: charaData.first_mes ?? 'unknown first message',
|
|
desc: charaData.description ?? '',
|
|
notes: '',
|
|
chats: [{
|
|
message: [],
|
|
note: '',
|
|
name: 'Chat 1',
|
|
localLore: []
|
|
}],
|
|
chatPage: 0,
|
|
image: imgp,
|
|
emotionImages: [],
|
|
bias: [],
|
|
globalLore: [],
|
|
viewScreen: 'none',
|
|
chaId: uuidv4(),
|
|
sdData: defaultSdDataFunc(),
|
|
utilityBot: false,
|
|
customscript: [],
|
|
exampleMessage: charaData.mes_example,
|
|
creatorNotes:'',
|
|
systemPrompt:'',
|
|
postHistoryInstructions:'',
|
|
alternateGreetings:[],
|
|
tags:[],
|
|
creator:"",
|
|
characterVersion: '',
|
|
personality: charaData.personality ?? '',
|
|
scenario:charaData.scenario ?? '',
|
|
firstMsgIndex: -1,
|
|
replaceGlobalNote: "",
|
|
triggerscript: [],
|
|
additionalText: ''
|
|
}
|
|
}
|
|
|
|
export async function exportChar(charaID:number) {
|
|
const db = get(DataBase)
|
|
let char = structuredClone(db.characters[charaID])
|
|
|
|
if(char.type === 'group'){
|
|
return
|
|
}
|
|
|
|
if(!char.image){
|
|
alertError('Image Required')
|
|
return
|
|
}
|
|
const conf = await alertConfirm(language.exportConfirm)
|
|
if(!conf){
|
|
return
|
|
}
|
|
|
|
const option = await alertCardExport()
|
|
if(option.type === 'cancel'){
|
|
return
|
|
}
|
|
else if(option.type === 'rcc'){
|
|
char.license = option.license
|
|
exportSpecV2(char, 'rcc', {password:option.password})
|
|
}
|
|
else{
|
|
exportSpecV2(char,'png')
|
|
}
|
|
return
|
|
}
|
|
|
|
|
|
async function importSpecv2(card:CharacterCardV2, img?:Uint8Array, mode:'hub'|'normal' = 'normal', assetDict:{[key:string]:string} = {}):Promise<boolean>{
|
|
if(!card ||card.spec !== 'chara_card_v2'){
|
|
return false
|
|
}
|
|
|
|
const data = card.data
|
|
const im = img ? await saveAsset(await reencodeImage(img)) : undefined
|
|
let db = get(DataBase)
|
|
|
|
const risuext = structuredClone(data.extensions.risuai)
|
|
let emotions:[string, string][] = []
|
|
let bias:[string, number][] = []
|
|
let viewScreen: "none" | "emotion" | "imggen" = 'none'
|
|
let customScripts:customscript[] = []
|
|
let utilityBot = false
|
|
let sdData = defaultSdDataFunc()
|
|
let extAssets:[string,string,string][] = []
|
|
let vits:null|OnnxModelFiles = null
|
|
if(risuext){
|
|
if(risuext.emotions){
|
|
for(let i=0;i<risuext.emotions.length;i++){
|
|
alertStore.set({
|
|
type: 'wait',
|
|
msg: `Loading... (Getting Emotions ${i} / ${risuext.emotions.length})`
|
|
})
|
|
await sleep(10)
|
|
if(risuext.emotions[i][1].startsWith('__asset:')){
|
|
const key = risuext.emotions[i][1].replace('__asset:', '')
|
|
const imgp = assetDict[key]
|
|
if(!imgp){
|
|
throw new Error('Error while importing, asset ' + key + ' not found')
|
|
}
|
|
emotions.push([risuext.emotions[i][0],imgp])
|
|
continue
|
|
}
|
|
const imgp = await saveAsset(mode === 'hub' ? (await getHubResources(risuext.emotions[i][1])) : Buffer.from(risuext.emotions[i][1], 'base64'))
|
|
emotions.push([risuext.emotions[i][0],imgp])
|
|
}
|
|
}
|
|
if(risuext.additionalAssets){
|
|
for(let i=0;i<risuext.additionalAssets.length;i++){
|
|
alertStore.set({
|
|
type: 'wait',
|
|
msg: `Loading... (Getting Assets ${i} / ${risuext.additionalAssets.length})`
|
|
})
|
|
await sleep(10)
|
|
let fileName = ''
|
|
if(risuext.additionalAssets[i].length >= 3)
|
|
fileName = risuext.additionalAssets[i][2]
|
|
if(risuext.additionalAssets[i][1].startsWith('__asset:')){
|
|
const key = risuext.additionalAssets[i][1].replace('__asset:', '')
|
|
const imgp = assetDict[key]
|
|
if(!imgp){
|
|
throw new Error('Error while importing, asset ' + key + ' not found')
|
|
}
|
|
extAssets.push([risuext.additionalAssets[i][0],imgp,fileName])
|
|
continue
|
|
}
|
|
const imgp = await saveAsset(mode === 'hub' ? (await getHubResources(risuext.additionalAssets[i][1])) :Buffer.from(risuext.additionalAssets[i][1], 'base64'), '', fileName)
|
|
extAssets.push([risuext.additionalAssets[i][0],imgp,fileName])
|
|
}
|
|
}
|
|
if(risuext.vits){
|
|
const keys = Object.keys(risuext.vits)
|
|
for(let i=0;i<keys.length;i++){
|
|
alertStore.set({
|
|
type: 'wait',
|
|
msg: `Loading... (Getting VITS ${i} / ${keys.length})`
|
|
})
|
|
await sleep(10)
|
|
const key = keys[i]
|
|
if(risuext.vits[key].startsWith('__asset:')){
|
|
const rkey = risuext.vits[key].replace('__asset:', '')
|
|
const imgp = assetDict[rkey]
|
|
if(!imgp){
|
|
throw new Error('Error while importing, asset ' + rkey + ' not found')
|
|
}
|
|
risuext.vits[key] = imgp
|
|
continue
|
|
}
|
|
const imgp = await saveAsset(mode === 'hub' ? (await getHubResources(risuext.vits[key])) : Buffer.from(risuext.vits[key], 'base64'))
|
|
risuext.vits[key] = imgp
|
|
}
|
|
|
|
if(keys.length > 0){
|
|
vits = {
|
|
name: "Imported VITS",
|
|
files: risuext.vits,
|
|
id: uuidv4().replace(/-/g, '')
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
bias = risuext.bias ?? bias
|
|
viewScreen = risuext.viewScreen ?? viewScreen
|
|
customScripts = risuext.customScripts ?? customScripts
|
|
utilityBot = risuext.utilityBot ?? utilityBot
|
|
sdData = risuext.sdData ?? sdData
|
|
}
|
|
|
|
const charbook = data.character_book
|
|
let lorebook:loreBook[] = []
|
|
let loresettings:undefined|loreSettings = undefined
|
|
let loreExt:undefined|any = undefined
|
|
if(charbook){
|
|
if((!checkNullish(charbook.recursive_scanning)) &&
|
|
(!checkNullish(charbook.scan_depth)) &&
|
|
(!checkNullish(charbook.token_budget))){
|
|
loresettings = {
|
|
tokenBudget:charbook.token_budget,
|
|
scanDepth:charbook.scan_depth,
|
|
recursiveScanning: charbook.recursive_scanning,
|
|
fullWordMatching: charbook?.extensions?.risu_fullWordMatching ?? false,
|
|
}
|
|
}
|
|
|
|
loreExt = charbook.extensions
|
|
|
|
for(const book of charbook.entries){
|
|
lorebook.push({
|
|
key: book.keys.join(', '),
|
|
secondkey: book.secondary_keys?.join(', ') ?? '',
|
|
insertorder: book.insertion_order,
|
|
comment: book.name ?? book.comment ?? "",
|
|
content: book.content,
|
|
mode: "normal",
|
|
alwaysActive: book.constant ?? false,
|
|
selective: book.selective ?? false,
|
|
extentions: {...book.extensions, risu_case_sensitive: book.case_sensitive},
|
|
activationPercent: book.extensions?.risu_activationPercent,
|
|
loreCache: book.extensions?.risu_loreCache ?? null,
|
|
})
|
|
}
|
|
|
|
}
|
|
|
|
let ext = structuredClone(data?.extensions ?? {})
|
|
|
|
for(const key in ext){
|
|
if(key === 'risuai'){
|
|
delete ext[key]
|
|
}
|
|
if(key === 'depth_prompt'){
|
|
delete ext[key]
|
|
}
|
|
}
|
|
|
|
let char:character = {
|
|
name: data.name ?? '',
|
|
firstMessage: data.first_mes ?? '',
|
|
desc: data.description ?? '',
|
|
notes: '',
|
|
chats: [{
|
|
message: [],
|
|
note: '',
|
|
name: 'Chat 1',
|
|
localLore: []
|
|
}],
|
|
chatPage: 0,
|
|
image: im,
|
|
emotionImages: emotions,
|
|
bias: bias,
|
|
globalLore: lorebook, //lorebook
|
|
viewScreen: viewScreen,
|
|
chaId: uuidv4(),
|
|
sdData: sdData,
|
|
utilityBot: utilityBot,
|
|
customscript: customScripts,
|
|
exampleMessage: data.mes_example ?? '',
|
|
creatorNotes:data.creator_notes ?? '',
|
|
systemPrompt:data.system_prompt ?? '',
|
|
postHistoryInstructions:'',
|
|
alternateGreetings:data.alternate_greetings ?? [],
|
|
tags:data.tags ?? [],
|
|
creator:data.creator ?? '',
|
|
characterVersion: `${data.character_version}` ?? '',
|
|
personality:data.personality ?? '',
|
|
scenario:data.scenario ?? '',
|
|
firstMsgIndex: -1,
|
|
removedQuotes: false,
|
|
loreSettings: loresettings,
|
|
loreExt: loreExt,
|
|
additionalData: {
|
|
tag: data.tags ?? [],
|
|
creator: data.creator,
|
|
character_version: data.character_version
|
|
},
|
|
additionalAssets: extAssets,
|
|
replaceGlobalNote: data.post_history_instructions ?? '',
|
|
backgroundHTML: data?.extensions?.risuai?.backgroundHTML,
|
|
license: data?.extensions?.risuai?.license,
|
|
triggerscript: data?.extensions?.risuai?.triggerscript ?? [],
|
|
private: data?.extensions?.risuai?.private ?? false,
|
|
additionalText: data?.extensions?.risuai?.additionalText ?? '',
|
|
virtualscript: '', //removed dude to security issue
|
|
extentions: ext ?? {},
|
|
largePortrait: data?.extensions?.risuai?.largePortrait ?? (!data?.extensions?.risuai),
|
|
lorePlus: data?.extensions?.risuai?.lorePlus ?? false,
|
|
inlayViewScreen: data?.extensions?.risuai?.inlayViewScreen ?? false,
|
|
newGenData: data?.extensions?.risuai?.newGenData ?? undefined,
|
|
vits: vits,
|
|
ttsMode: vits ? 'vits' : 'normal',
|
|
imported: true,
|
|
}
|
|
|
|
db.characters.push(char)
|
|
|
|
|
|
setDatabase(db)
|
|
|
|
alertNormal(language.importedCharacter)
|
|
return true
|
|
|
|
}
|
|
|
|
|
|
async function createBaseV2(char:character) {
|
|
|
|
let charBook:charBookEntry[] = []
|
|
for(const lore of char.globalLore){
|
|
let ext:{
|
|
risu_case_sensitive?: boolean;
|
|
risu_activationPercent?: number
|
|
risu_loreCache?: {
|
|
key:string
|
|
data:string[]
|
|
}
|
|
} = structuredClone(lore.extentions ?? {})
|
|
|
|
let caseSensitive = ext.risu_case_sensitive ?? false
|
|
ext.risu_activationPercent = lore.activationPercent
|
|
ext.risu_loreCache = lore.loreCache
|
|
|
|
charBook.push({
|
|
keys: lore.key.split(',').map(r => r.trim()),
|
|
secondary_keys: lore.selective ? lore.secondkey.split(',').map(r => r.trim()) : undefined,
|
|
content: lore.content,
|
|
extensions: ext,
|
|
enabled: true,
|
|
insertion_order: lore.insertorder,
|
|
constant: lore.alwaysActive,
|
|
selective:lore.selective,
|
|
name: lore.comment,
|
|
comment: lore.comment,
|
|
case_sensitive: caseSensitive,
|
|
})
|
|
}
|
|
char.loreExt ??= {}
|
|
|
|
char.loreExt.risu_fullWordMatching = char.loreSettings?.fullWordMatching ?? false
|
|
|
|
const card:CharacterCardV2 = {
|
|
spec: "chara_card_v2",
|
|
spec_version: "2.0",
|
|
data: {
|
|
name: char.name,
|
|
description: char.desc ?? '',
|
|
personality: char.personality ?? '',
|
|
scenario: char.scenario ?? '',
|
|
first_mes: char.firstMessage ?? '',
|
|
mes_example: char.exampleMessage ?? '',
|
|
creator_notes: char.creatorNotes ?? '',
|
|
system_prompt: char.systemPrompt ?? '',
|
|
post_history_instructions: char.replaceGlobalNote ?? '',
|
|
alternate_greetings: char.alternateGreetings ?? [],
|
|
character_book: {
|
|
scan_depth: char.loreSettings?.scanDepth,
|
|
token_budget: char.loreSettings?.tokenBudget,
|
|
recursive_scanning: char.loreSettings?.recursiveScanning,
|
|
extensions: char.loreExt ?? {},
|
|
entries: charBook
|
|
},
|
|
tags: char.tags ?? [],
|
|
creator: char.additionalData?.creator ?? '',
|
|
character_version: `${char.additionalData?.character_version}` ?? '',
|
|
extensions: {
|
|
risuai: {
|
|
emotions: char.emotionImages,
|
|
bias: char.bias,
|
|
viewScreen: char.viewScreen,
|
|
customScripts: char.customscript,
|
|
utilityBot: char.utilityBot,
|
|
sdData: char.sdData,
|
|
additionalAssets: char.additionalAssets,
|
|
backgroundHTML: char.backgroundHTML,
|
|
license: char.license,
|
|
triggerscript: char.triggerscript,
|
|
additionalText: char.additionalText,
|
|
virtualscript: '', //removed dude to security issue
|
|
largePortrait: char.largePortrait,
|
|
lorePlus: char.lorePlus,
|
|
inlayViewScreen: char.inlayViewScreen,
|
|
newGenData: char.newGenData,
|
|
vits: {}
|
|
},
|
|
depth_prompt: char.depth_prompt
|
|
}
|
|
}
|
|
}
|
|
|
|
if(char.extentions){
|
|
for(const key in char.extentions){
|
|
if(key === 'risuai' || key === 'depth_prompt'){
|
|
continue
|
|
}
|
|
card.data.extensions[key] = char.extentions[key]
|
|
}
|
|
}
|
|
return card
|
|
}
|
|
|
|
|
|
export async function exportSpecV2(char:character, type:'png'|'json'|'rcc' = 'png', arg:{
|
|
password?:string
|
|
writer?:LocalWriter|VirtualWriter
|
|
} = {}) {
|
|
let img = await readImage(char.image)
|
|
|
|
try{
|
|
char.image = ''
|
|
const card = await createBaseV2(char)
|
|
img = await reencodeImage(img)
|
|
const localWriter = arg.writer ?? (new LocalWriter())
|
|
if(!arg.writer){
|
|
await (localWriter as LocalWriter).init(`Image file`, ['png'])
|
|
}
|
|
const writer = new PngChunk.streamWriter(img, localWriter)
|
|
await writer.init()
|
|
let assetIndex = 0
|
|
if(card.data.extensions.risuai.emotions && card.data.extensions.risuai.emotions.length > 0){
|
|
for(let i=0;i<card.data.extensions.risuai.emotions.length;i++){
|
|
alertStore.set({
|
|
type: 'wait',
|
|
msg: `Loading... (Adding Emotions ${i} / ${card.data.extensions.risuai.emotions.length})`
|
|
})
|
|
const key = card.data.extensions.risuai.emotions[i][1]
|
|
const rData = await readImage(key)
|
|
const b64encoded = Buffer.from(await convertImage(rData)).toString('base64')
|
|
assetIndex++
|
|
card.data.extensions.risuai.emotions[i][1] = `__asset:${assetIndex}`
|
|
await writer.write("chara-ext-asset_" + assetIndex, b64encoded)
|
|
}
|
|
}
|
|
|
|
|
|
if(card.data.extensions.risuai.additionalAssets && card.data.extensions.risuai.additionalAssets.length > 0){
|
|
for(let i=0;i<card.data.extensions.risuai.additionalAssets.length;i++){
|
|
alertStore.set({
|
|
type: 'wait',
|
|
msg: `Loading... (Adding Additional Assets ${i} / ${card.data.extensions.risuai.additionalAssets.length})`
|
|
})
|
|
const key = card.data.extensions.risuai.additionalAssets[i][1]
|
|
const rData = await readImage(key)
|
|
const b64encoded = Buffer.from(await convertImage(rData)).toString('base64')
|
|
assetIndex++
|
|
card.data.extensions.risuai.additionalAssets[i][1] = `__asset:${assetIndex}`
|
|
await writer.write("chara-ext-asset_" + assetIndex, b64encoded)
|
|
}
|
|
}
|
|
|
|
if(char.vits && char.ttsMode === 'vits'){
|
|
const keys = Object.keys(char.vits.files)
|
|
for(let i=0;i<keys.length;i++){
|
|
alertStore.set({
|
|
type: 'wait',
|
|
msg: `Loading... (Adding VITS ${i} / ${keys.length})`
|
|
})
|
|
const key = keys[i]
|
|
const rData = await loadAsset(char.vits.files[key])
|
|
const b64encoded = Buffer.from(rData).toString('base64')
|
|
assetIndex++
|
|
card.data.extensions.risuai.vits[key] = `__asset:${assetIndex}`
|
|
await writer.write("chara-ext-asset_" + assetIndex, b64encoded)
|
|
}
|
|
}
|
|
|
|
if(type === 'json'){
|
|
await downloadFile(`${char.name.replace(/[<>:"/\\|?*\.\,]/g, "")}_export.json`, Buffer.from(JSON.stringify(card, null, 4), 'utf-8'))
|
|
alertNormal(language.successExport)
|
|
return
|
|
}
|
|
|
|
await sleep(10)
|
|
alertStore.set({
|
|
type: 'wait',
|
|
msg: 'Loading... (Writing)'
|
|
})
|
|
|
|
if(type === 'rcc'){
|
|
const password = arg.password || 'RISU_NONE'
|
|
const json = JSON.stringify(card)
|
|
const encrypted = Buffer.from(await encryptBuffer(Buffer.from(json, 'utf-8'), password))
|
|
const hashed = await hasher(encrypted)
|
|
const metaData:RccCardMetaData = {}
|
|
if(password !== 'RISU_NONE'){
|
|
metaData.usePassword = true
|
|
}
|
|
const rccString = 'rcc||rccv1||' + encrypted.toString('base64') + '||' + hashed + '||' + Buffer.from(JSON.stringify(metaData)).toString('base64')
|
|
await writer.write("chara", rccString)
|
|
}
|
|
else{
|
|
await writer.write("chara", Buffer.from(JSON.stringify(card)).toString('base64'))
|
|
}
|
|
|
|
await writer.end()
|
|
|
|
await sleep(10)
|
|
|
|
if(!arg.writer){
|
|
alertNormal(language.successExport)
|
|
}
|
|
|
|
}
|
|
catch(e){
|
|
console.error(e, e.stack)
|
|
alertError(`${e}`)
|
|
}
|
|
}
|
|
|
|
export async function shareRisuHub2(char:character, arg:{
|
|
nsfw: boolean,
|
|
tag:string
|
|
license: string
|
|
anon: boolean,
|
|
update: boolean
|
|
}) {
|
|
try {
|
|
char = structuredClone(char)
|
|
char.license = arg.license
|
|
let tagList = arg.tag.split(',')
|
|
|
|
if(arg.nsfw){
|
|
tagList.push("nsfw")
|
|
}
|
|
|
|
await alertWait("Uploading...")
|
|
|
|
|
|
let tags = tagList.filter((v, i) => {
|
|
return (!!v) && (tagList.indexOf(v) === i)
|
|
})
|
|
char.tags = tags
|
|
|
|
|
|
const writer = new VirtualWriter()
|
|
await exportSpecV2(char, 'png', {writer: writer})
|
|
|
|
const fetchPromise = fetch(hubURL + '/hub/realm/upload', {
|
|
method: "POST",
|
|
body: writer.buf.buffer,
|
|
headers: {
|
|
"Content-Type": 'image/png',
|
|
"x-risu-api-version": "4",
|
|
"x-risu-token": get(DataBase)?.account?.token,
|
|
'x-risu-username': arg.anon ? '' : (get(DataBase)?.account?.id),
|
|
'x-risu-debug': 'true',
|
|
'x-risu-update-id': arg.update ? (char.realmId ?? 'null') : 'null'
|
|
}
|
|
})
|
|
|
|
|
|
const res = await fetchPromise
|
|
|
|
if(res.status !== 200){
|
|
alertError(await res.text())
|
|
}
|
|
else{
|
|
const resJSON = await res.json()
|
|
alertMd(resJSON.message)
|
|
const currentChar = get(CurrentCharacter)
|
|
if(currentChar.type === 'group'){
|
|
return
|
|
}
|
|
currentChar.realmId = resJSON.id
|
|
CurrentCharacter.set(currentChar)
|
|
}
|
|
} catch (error) {
|
|
alertError(`${error}`)
|
|
}
|
|
|
|
}
|
|
|
|
export async function shareRisuHub(char:character, arg:{
|
|
nsfw: boolean,
|
|
tag:string
|
|
license: string
|
|
anon: boolean
|
|
}) {
|
|
char = structuredClone(char)
|
|
char.license = arg.license
|
|
let tagList = arg.tag.split(',')
|
|
|
|
if(arg.nsfw){
|
|
tagList.push("nsfw")
|
|
}
|
|
|
|
|
|
|
|
let tags = tagList.filter((v, i) => {
|
|
return (!!v) && (tagList.indexOf(v) === i)
|
|
})
|
|
char.tags = tags
|
|
|
|
|
|
let img = await readImage(char.image)
|
|
|
|
try{
|
|
const card = await createBaseV2(char)
|
|
let resources:[string,string][] = []
|
|
if(card.data.extensions.risuai.emotions && card.data.extensions.risuai.emotions.length > 0){
|
|
for(let i=0;i<card.data.extensions.risuai.emotions.length;i++){
|
|
alertStore.set({
|
|
type: 'wait',
|
|
msg: `Loading... (Adding Emotions ${i} / ${card.data.extensions.risuai.emotions.length})`
|
|
})
|
|
const data = card.data.extensions.risuai.emotions[i][1]
|
|
const rData = await readImage(data)
|
|
resources.push([data, Buffer.from(await convertImage(rData)).toString('base64')])
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
if(card.data.extensions.risuai.additionalAssets && card.data.extensions.risuai.additionalAssets.length > 0){
|
|
for(let i=0;i<card.data.extensions.risuai.additionalAssets.length;i++){
|
|
alertStore.set({
|
|
type: 'wait',
|
|
msg: `Loading... (Adding Additional Assets ${i} / ${card.data.extensions.risuai.additionalAssets.length})`
|
|
})
|
|
const data = card.data.extensions.risuai.additionalAssets[i][1]
|
|
const rData = await readImage(data)
|
|
resources.push([data, Buffer.from(await convertImage(rData)).toString('base64')])
|
|
}
|
|
}
|
|
|
|
const da = await fetch(hubURL + '/hub/upload', {
|
|
method: "POST",
|
|
body: JSON.stringify({
|
|
card: card,
|
|
img: Buffer.from(img).toString('base64'),
|
|
resources: resources,
|
|
token: get(DataBase)?.account?.token,
|
|
username: arg.anon ? '' : (get(DataBase)?.account?.id),
|
|
apiver: 3
|
|
})
|
|
})
|
|
|
|
if(da.status !== 200){
|
|
alertError(await da.text())
|
|
}
|
|
else{
|
|
alertMd(await da.text())
|
|
}
|
|
}
|
|
catch(e){
|
|
alertError(`${e}`)
|
|
}
|
|
|
|
}
|
|
|
|
export type hubType = {
|
|
name:string
|
|
desc: string
|
|
download: string,
|
|
id: string,
|
|
img: string
|
|
tags: string[],
|
|
viewScreen: "none" | "emotion" | "imggen"
|
|
hasLore:boolean
|
|
hasEmotion:boolean
|
|
hasAsset:boolean
|
|
creator?:string
|
|
creatorName?:string
|
|
hot:number
|
|
license:string
|
|
authorname?:string
|
|
}
|
|
|
|
export async function getRisuHub(arg:{
|
|
search:string,
|
|
page:number,
|
|
nsfw:boolean
|
|
sort:string
|
|
}):Promise<hubType[]> {
|
|
try {
|
|
const stringArg = `search==${arg.search}&&page==${arg.page}&&nsfw==${arg.nsfw}&&sort==${arg.sort}`
|
|
|
|
const da = await fetch(hubURL + '/realm/' + encodeURIComponent(stringArg))
|
|
if(da.status !== 200){
|
|
return []
|
|
}
|
|
return da.json()
|
|
} catch (error) {
|
|
return[]
|
|
}
|
|
}
|
|
|
|
export async function downloadRisuHub(id:string) {
|
|
try {
|
|
if(!(await alertTOS())){
|
|
return
|
|
}
|
|
alertStore.set({
|
|
type: "wait",
|
|
msg: "Downloading..."
|
|
})
|
|
const res = await fetch("https://realm.risuai.net/api/v1/download/png-v3/" + id + '?cors=true', {
|
|
headers: {
|
|
"x-risu-api-version": "4"
|
|
}
|
|
})
|
|
if(res.status !== 200){
|
|
alertError(await res.text())
|
|
return
|
|
}
|
|
|
|
if(res.headers.get('content-type') === 'image/png'){
|
|
await importCharacterProcess({
|
|
name: 'realm.png',
|
|
data: res.body
|
|
})
|
|
checkCharOrder()
|
|
return
|
|
}
|
|
|
|
const result = await res.json()
|
|
const data:CharacterCardV2 = result.card
|
|
const img:string = result.img
|
|
|
|
await importSpecv2(data, await getHubResources(img), 'hub')
|
|
checkCharOrder()
|
|
let db = get(DataBase)
|
|
if(db.characters[db.characters.length-1]){
|
|
const index = db.characters.length-1
|
|
characterFormatUpdate(index);
|
|
selectedCharID.set(index);
|
|
}
|
|
} catch (error) {
|
|
console.error(error)
|
|
alertError("Error while importing")
|
|
}
|
|
}
|
|
|
|
export async function getHubResources(id:string) {
|
|
const res = await fetch(`${hubURL}/resource/${id}`)
|
|
if(res.status !== 200){
|
|
throw (await res.text())
|
|
}
|
|
return Buffer.from(await (res).arrayBuffer())
|
|
}
|
|
|
|
|
|
|
|
type CharacterCardV2 = {
|
|
spec: 'chara_card_v2'
|
|
spec_version: '2.0' // May 8th addition
|
|
data: {
|
|
name: string
|
|
description: string
|
|
personality: string
|
|
scenario: string
|
|
first_mes: string
|
|
mes_example: string
|
|
creator_notes: string
|
|
system_prompt: string
|
|
post_history_instructions: string
|
|
alternate_greetings: string[]
|
|
character_book?: CharacterBook
|
|
tags: string[]
|
|
creator: string
|
|
character_version: string
|
|
extensions: {
|
|
risuai?:{
|
|
emotions?:[string, string][]
|
|
bias?:[string, number][],
|
|
viewScreen?: any,
|
|
customScripts?:customscript[]
|
|
utilityBot?: boolean,
|
|
sdData?:[string,string][],
|
|
additionalAssets?:[string,string,string][],
|
|
backgroundHTML?:string,
|
|
license?:string,
|
|
triggerscript?:triggerscript[]
|
|
private?:boolean
|
|
additionalText?:string
|
|
virtualscript?:string
|
|
largePortrait?:boolean
|
|
lorePlus?:boolean
|
|
inlayViewScreen?:boolean
|
|
newGenData?: {
|
|
prompt: string,
|
|
negative: string,
|
|
instructions: string,
|
|
emotionInstructions: string,
|
|
},
|
|
vits?: {[key:string]:string}
|
|
}
|
|
depth_prompt?: { depth: number, prompt: string }
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
interface OldTavernChar{
|
|
avatar: "none"
|
|
chat: string
|
|
create_date: string
|
|
description: string
|
|
first_mes: string
|
|
mes_example: string
|
|
name: string
|
|
personality: string
|
|
scenario: string
|
|
talkativeness: "0.5"
|
|
}
|
|
type CharacterBook = {
|
|
name?: string
|
|
description?: string
|
|
scan_depth?: number // agnai: "Memory: Chat History Depth"
|
|
token_budget?: number // agnai: "Memory: Context Limit"
|
|
recursive_scanning?: boolean // no agnai equivalent. whether entry content can trigger other entries
|
|
extensions: Record<string, any>
|
|
entries: Array<charBookEntry>
|
|
}
|
|
|
|
interface charBookEntry{
|
|
keys: Array<string>
|
|
content: string
|
|
extensions: Record<string, any>
|
|
enabled: boolean
|
|
insertion_order: number // if two entries inserted, lower "insertion order" = inserted higher
|
|
|
|
// FIELDS WITH NO CURRENT EQUIVALENT IN SILLY
|
|
name?: string // not used in prompt engineering
|
|
priority?: number // if token budget reached, lower priority value = discarded first
|
|
|
|
// FIELDS WITH NO CURRENT EQUIVALENT IN AGNAI
|
|
id?: number // not used in prompt engineering
|
|
comment?: string // not used in prompt engineering
|
|
selective?: boolean // if `true`, require a key from both `keys` and `secondary_keys` to trigger the entry
|
|
secondary_keys?: Array<string> // see field `selective`. ignored if selective == false
|
|
constant?: boolean // if true, always inserted in the prompt (within budget limit)
|
|
position?: 'before_char' | 'after_char' // whether the entry is placed before or after the character defs
|
|
case_sensitive?:boolean
|
|
}
|
|
|
|
interface RccCardMetaData{
|
|
usePassword?: boolean
|
|
} |