Import BYAF (#4300) * allow byaf import format * Add byaf import converters * Fix import of image and scenario * Update src/byaf.js Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Log JSON parsing errors * Use fsPromises for file acces * Fix callback variable name * Clear file input value after file upload to allow re-uploading --------- Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

e0b020f211c1538ee2a0c52f5807119c08f72989

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

Signed

Parents: 87ece15faf83d406852cc98099bf4a5ba830d2ee

public/index.html+2 -2 Viewed

                     </div>
                     <div id="rm_character_import" class="right_menu" style="display: none;">
                         <form id="form_import" action="javascript:void(null);" method="post" enctype="multipart/form-data">
-                            <input multiple type="file" id="character_import_file" accept=".json, image/png, .yaml, .yml, .charx" name="avatar">
+                            <input multiple type="file" id="character_import_file" accept=".json, image/png, .yaml, .yml, .charx, .byaf" name="avatar">
                             <input id="character_import_file_type" name="file_type" class="text_pole" value="" autocomplete="off">
                         </form>
-                        <input type="file" id="character_replace_file" accept=".json, image/png, .yaml, .yml, .charx" name="replace_avatar" hidden>
+                        <input type="file" id="character_replace_file" accept=".json, image/png, .yaml, .yml, .charx, .byaf" name="replace_avatar" hidden>
                     </div>
                     <div name="Character List Panel" id="rm_characters_block" class="right_menu">
                         <div id="charListFixedTop">

public/script.js+5 -1 Viewed

     const allowedExtensions = [
         'charx',
+        'byaf',
     ];
     const avatarFileNames = [];

@@ -8899,7 +8900,7 @@ async function importCharacter(file, { preserveFileName = '', importTags = false
8899	}	8900	}
8900		8901
8901	const ext = file.name.match(/\.(\w+)$/);	8902	const ext = file.name.match(/\.(\w+)$/);
8902	if (!ext \|\| !(['json', 'png', 'yaml', 'yml', 'charx'].includes(ext[1].toLowerCase()))) {	8903	if (!ext \|\| !(['json', 'png', 'yaml', 'yml', 'charx', 'byaf'].includes(ext[1].toLowerCase()))) {
8903	return;	8904	return;
8904	}	8905	}
8905		8906

             await importCharactersTags(avatarFileNames);
             selectImportedChar(avatarFileNames[avatarFileNames.length - 1]);
+        }
+        // Clear the file input value to allow re-uploading the same file
+        e.target.value = '';
     });
     $('#export_button').on('click', function () {

src/byaf.js+209 -0 Viewed

+import sanitize from 'sanitize-filename';
+import { promises as fsPromises } from 'node:fs';
+import path from 'node:path';
+import urlJoin from 'url-join';
+import { DEFAULT_AVATAR_PATH } from './constants.js';
+import { extractFileFromZipBuffer, humanizedISO8601DateTime } from './util.js';
+export const replaceByafMacros = (s) =>
+    String(s || '')
+        .replace(/#{user}:/gi, '{{user}}:')
+        .replace(/#{character}:/gi, '{{char}}:')
+        .replace(/{character}(?!})/gi, '{{char}}')
+        .replace(/{user}(?!})/gi, '{{user}}');
+export const formatByafExampleMessages = (examples) => {
+    if (!Array.isArray(examples)) {
+        return '';
+    }
+    let formattedExamples = '';
+    examples.forEach((example) => {
+        if (!example?.text) {
+            return;
+        }
+        formattedExamples += `<START>\n${replaceByafMacros(example.text)}\n`;
+    });
+    return formattedExamples.trimEnd();
+};
+export const formatByafAlternateGreetings = (greetings) => {
+    if (!Array.isArray(greetings)) {
+        return [];
+    }
+    if (greetings.length <= 1) {
+        return [];
+    }
+    // Skip one because it goes into 'first_mes'
+    return greetings.slice(1).map(g => replaceByafMacros(g?.text));
+};
+export const convertByafCharacterBook = (items) => {
+    if (!Array.isArray(items) || items.length === 0) {
+        return null;
+    }
+    const book = {
+        /** @type {any[]} */
+        entries: [],
+    };
+    items.forEach((item, index) => {
+        if (!item) {
+            return;
+        }
+        book.entries.push({
+            keys: replaceByafMacros(item?.key).split(',').map(key => key.trim()).filter(Boolean),
+            content: replaceByafMacros(item?.value),
+            extensions: {},
+            enabled: true,
+            insertion_order: index,
+        });
+    });
+    return book;
+};
+/**
+ * Extracts a character object from BYAF buffer.
+ * @param {ArrayBufferLike} data ZIP buffer
+ * @param {object} manifest BYAF manifest
+ * @returns {Promise<{character:object,characterPath:string}>} Character object
+ */
+export async function getCharacterFromByafManifest(data, manifest) {
+    const charactersArray = manifest?.characters;
+    if (!Array.isArray(charactersArray)) {
+        throw new Error('Invalid BYAF file: missing characters array');
+    }
+    if (charactersArray.length === 0) {
+        throw new Error('Invalid BYAF file: characters array is empty');
+    }
+    if (charactersArray.length > 1) {
+        console.warn('Warning: BYAF manifest contains more than one character, only the first one will be imported');
+    }
+    const characterPath = charactersArray[0];
+    if (!characterPath) {
+        throw new Error('Invalid BYAF file: missing character path');
+    }
+    const characterBuffer = await extractFileFromZipBuffer(data, characterPath);
+    if (!characterBuffer) {
+        throw new Error('Invalid BYAF file: failed to extract character JSON');
+    }
+    try {
+        const character = JSON.parse(characterBuffer.toString());
+        return { character, characterPath };
+    } catch (error) {
+        console.error('Failed to parse character JSON from BYAF:', error);
+        throw new Error('Invalid BYAF file: character is not a valid JSON');
+    }
+}
+/**
+ * Extracts a scenario object from BYAF buffer.
+ * @param {ArrayBufferLike} data ZIP buffer
+ * @param {object} manifest BYAF manifest
+ * @returns {Promise<object>} Scenario object
+ */
+export async function getScenarioFromByafManifest(data, manifest) {
+    const scenariosArray = manifest?.scenarios;
+    if (!Array.isArray(scenariosArray) || scenariosArray.length === 0) {
+        console.warn('Warning: BYAF manifest contains no scenarios');
+        return {};
+    }
+    if (scenariosArray.length > 1) {
+        console.warn('Warning: BYAF manifest contains more than one scenario, only the first one will be imported');
+    }
+    const scenarioPath = scenariosArray[0];
+    if (!scenarioPath) {
+        console.warn('Warning: missing BYAF scenario path');
+        return {};
+    }
+    const scenarioBuffer = await extractFileFromZipBuffer(data, scenarioPath);
+    if (!scenarioBuffer) {
+        console.warn('Warning: failed to extract BYAF scenario JSON');
+        return {};
+    }
+    try {
+        return JSON.parse(scenarioBuffer.toString());
+    } catch (error) {
+        console.warn('Warning: BYAF scenario is not a valid JSON', error);
+        return {};
+    }
+}
+/**
+ * Extracts an image from BYAF buffer.
+ * @param {ArrayBufferLike} data ZIP buffer
+ * @param {object} character Character object
+ * @param {string} characterPath Path to the character in the BYAF manifest
+ */
+export async function getImageBufferFromByafCharacter(data, character, characterPath) {
+    const defaultAvatarBuffer = await fsPromises.readFile(DEFAULT_AVATAR_PATH);
+    const characterImages = character?.images;
+    if (!Array.isArray(characterImages) || characterImages.length === 0) {
+        console.warn('Warning: BYAF character has no images');
+        return defaultAvatarBuffer;
+    }
+    const imagePath = characterImages[0]?.path;
+    if (!imagePath) {
+        console.warn('Warning: BYAF character image path is empty');
+        return defaultAvatarBuffer;
+    }
+    const fullImagePath = urlJoin(path.dirname(characterPath), imagePath);
+    const imageBuffer = await extractFileFromZipBuffer(data, fullImagePath);
+    if (!imageBuffer) {
+        console.warn('Warning: failed to extract BYAF character image');
+        return defaultAvatarBuffer;
+    }
+    return imageBuffer;
+}
+/**
+ * Formats BYAF data as a character card.
+ * @param {object} character
+ * @param {object} scenario
+ */
+export function formatByafAsCharacterCard(character, scenario) {
+    return {
+        spec: 'chara_card_v2',
+        spec_version: '2.0',
+        create_date: humanizedISO8601DateTime(),
+        data: {
+            name: sanitize(character?.name || character?.displayName || ''),
+            description: replaceByafMacros(character?.persona),
+            personality: '',
+            scenario: replaceByafMacros(scenario?.narrative),
+            first_mes: replaceByafMacros(scenario?.firstMessages?.[0]?.text),
+            mes_example: formatByafExampleMessages(scenario?.exampleMessages),
+            creator_notes: '',
+            system_prompt: replaceByafMacros(scenario?.formattingInstructions),
+            post_history_instructions: '',
+            alternate_greetings: formatByafAlternateGreetings(scenario?.firstMessages),
+            character_book: convertByafCharacterBook(character?.loreItems),
+            tags: [],
+            creator: '',
+            character_version: '',
+            extensions: {},
+        },
+    };
+}

src/endpoints/characters.js+23 -0 Viewed

 import { importRisuSprites } from './sprites.js';
 import { getUserDirectories } from '../users.js';
 import { getChatInfo } from './chats.js';
+import { formatByafAsCharacterCard, getCharacterFromByafManifest, getImageBufferFromByafCharacter, getScenarioFromByafManifest } from '../byaf.js';
 // With 100 MB limit it would take roughly 3000 characters to reach this limit
 const memoryCacheCapacity = getConfigValue('performance.memoryCacheCapacity', '100mb');

     return result ? fileName : '';
+}
+async function importFromByaf(uploadPath, { request }, preservedFileName) {
+    const data = (await fsPromises.readFile(uploadPath)).buffer;
+    await fsPromises.unlink(uploadPath);
+    console.info('Importing from BYAF');
+    const manifestBuffer = await extractFileFromZipBuffer(data, 'manifest.json');
+    if (!manifestBuffer) {
+        throw new Error('Failed to extract manifest.json from BYAF file');
+    }
+    const manifest = JSON.parse(manifestBuffer.toString());
+    const { character, characterPath } = await getCharacterFromByafManifest(data, manifest);
+    const scenario = await getScenarioFromByafManifest(data, manifest);
+    const image = await getImageBufferFromByafCharacter(data, character, characterPath);
+    const card = readFromV2(formatByafAsCharacterCard(character, scenario));
+    const fileName = preservedFileName || getPngName(card.name, request.user.directories);
+    const result = await writeCharacterData(image, JSON.stringify(card), fileName, request);
+    return result ? fileName : '';
+}
 /**
  * Import a character from a JSON file.
  * @param {string} uploadPath Path to the uploaded file

         'json': importFromJson,
         'png': importFromPng,
         'charx': importFromCharX,
+        'byaf': importFromByaf,
     };
     try {