Update group chat metadata format (#4805) * Migrate group metadata to group chat files * Skip migration if chat already has metadata * Fix active group not being set on group conversion * Improve types in createGroup * Fix padding in hotswap group avatars * Fix centering of empty hotswap avatar * Added automatic backups of migrated data * Fix 'OVERWRITE' for GC * Fix metadata parsing order in migration * Remove color accents from regular migration logs * Always set gen_id in converted message * Clone messages before conversion * Reduce size of add/remove buttons * Fix group chat file size calculation

929d377da8cf3f08343d6ec95fa1a43c7053fb92

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

Signed

Parents: 051b2757950437170235edc8e3fcfef23d6cd670

public/css/rm-groups.css+8 -0 Viewed

+}
 .group_select.avatar {
 +    padding: 0;
 +}
++
 +.group_select.missing-avatar.inline_avatar {
 +    justify-content: center;
 +}
++
 +.group_select .avatar {
     flex: 0;
+}

public/global.d.ts+37 -0 Viewed

     type ChatCompletionSettings = typeof oai_settings;
     type TextCompletionSettings = typeof textgenerationwebui_settings;
     type MessageTimestamp = string | number | Date;
 +    type Character = import('./scripts/char-data').v1CharData;
++
 +    interface Group {
 +        id: string;
 +        name: string;
 +        members: string[];
 +        disabled_members: string[];
 +        chat_id: string;
 +        chats: string[];
 +        generation_mode?: number;
 +        generation_mode_join_prefix?: string;
 +        generation_mode_join_suffix?: string;
 +        activation_strategy?: number;
 +        auto_mode_delay?: number;
 +        allow_self_responses?: boolean;
 +        avatar_url?: string;
 +        hideMutedSprites?: boolean;
 +        fav?: boolean;
 +    }
++
 +    interface ChatFile extends Array<ChatMessage> {
 +        [index: number]: ChatMessage;
 +        0?: ChatHeader;
 +    }
++
 +    interface ChatHeader {
 +        chat_metadata: ChatMetadata;
 +    }
++
 +    interface ChatMetadata {
 +        tainted?: boolean;
 +        integrity?: string;
 +        scenario?: string;
 +        persona?: string;
 +        [key: string]: any;
 +    }
     interface ChatMessage {
         name?: string;

     };
     interface ChatMessageExtra {
 +        gen_id?: number;
         bias?: string;
         uses_system_ui?: boolean;
         memory?: string;

public/index.html+2 -3 Viewed

                         <div title="Move down" data-action="down" class="right_menu_button fa-solid fa-chevron-down" data-i18n="[title]Move down"></div>
                     </div>
                     <div title="View character card" data-action="view" class="right_menu_button fa-solid fa-xl fa-image-portrait" data-i18n="[title]View character card"></div>
                     <div title="Remove from group" data-action="remove" class="right_menu_button fa-solid fa-2xlxl fa-xmark" data-i18n="[title]Remove from group"></div>
 -                    </div>
 +                    <div title="Add to group" data-action="add" class="right_menu_button fa-solid fa-xl fa-plus" data-i18n="[title]Add to group"></div>
 -                    <div title="Add to group" data-action="add" class="right_menu_button fa-solid fa-2xl fa-plus" data-i18n="[title]Add to group"></div>
                 </div>
             </div>
         </div>

public/script.js+17 -32 Viewed

     renameGroupMember,
     createNewGroupChat,
     getGroupAvatar,
 -    editGroup,
     deleteGroupChat,
     renameGroupChat,
     importGroupChat,

 let chatSaveTimeout;
 let importFlashTimeout;
 export let isChatSaving = false;
 -let chat_create_date = '';
 let firstRun = false;
 let settingsReady = false;
 let currentVersion = '0.0.0';
 export let displayVersion = 'SillyTavern';
 let generation_started = new Date();
 /** @type {import('./scripts/char-data.js').v1CharDataCharacter[]} */
 export let characters = [];
 /**
  * Stringified index of a currently chosen entity in the characters array.

 let dialogueResolve = null;
 let dialogueCloseStop = false;
 +/** @type {ChatMetadata} */
 export let chat_metadata = {};
 /** @type {StreamingProcessor} */
 export let streamingProcessor = null;

     // Make sure all the data is loaded.
     await unshallowCharacter(characterId);
     /** @type {import('./scripts/char-data.js').v1CharDataCharacter} */
     const character = characters[characterId];
     if (!character) {
         console.warn(`Character with ID ${characterId} not found.`);

+                }
                 // Also rename as a group member
                 await renameGroupMember(oldAvatar, newAvatar, newValue.toString());
                 const renamePastChatsConfirm = renameChats !== null
                     ? renameChats
                     : silent

  * @returns {Promise<void>}
  */
 export async function saveChat({ chatName, withMetadata, mesId, force = false } = {}) {
 +    if (selected_group) {
 +        toastr.error(t`Operation was aborted to prevent data corruption.`, t`saveChat called for a group chat`);
 +        throw new Error('saveChat called for a group chat');
 +    }
++
     if (arguments.length > 0 && typeof arguments[0] !== 'object') {
         console.trace('saveChat called with positional arguments. Please use an object instead.');
         [chatName, withMetadata, mesId, force] = arguments;

+    }
     characters[this_chid]['date_last_chat'] = Date.now();
 -    chat.forEach(function (item, i) {
 -        if (item['is_group']) {
 -            toastr.error(t`Trying to save group chat with regular saveChat function. Aborting to prevent corruption.`);
 -            throw new Error('Group chat saved from saveChat');
 -        }
 -    });
     const trimmedChat = (mesId !== undefined && mesId >= 0 && mesId < chat.length)
         ? chat.slice(0, Number(mesId) + 1)
         : chat.slice();
 -    const chatToSave = [
 +    /** @type {ChatHeader} */
 -        {
 +    const chatHeader = {
 -            user_name: name1,
 -            character_name: name2,
 -            create_date: chat_create_date,
         chat_metadata: metadata,
 -        },
 +    };
 -        ...trimmedChat,
 -    ];
     try {
         const result = await fetch('/api/chats/save', {

             body: JSON.stringify({
                 ch_name: characters[this_chid].name,
                 file_name: fileName,
                 chat: chatToSave[chatHeader, ...trimmedChat],
                 avatar_url: characters[this_chid].avatar,
                 force: force,
             }),

         return;
+    }
     /** @type {import('./scripts/char-data.js').v1CharDataCharacter} */
     const character = characters[characterId];
     if (!character) {
         console.debug('Character not found:', characterId);

         });
         if (response[0] !== undefined) {
             chat.splice(0, chat.length, ...response);
 -            chat_create_date = chat[0]['create_date'];
             chat_metadata = chat[0]['chat_metadata'] ?? {};
             chat.shift();
             chat.forEach(ensureMessageMediaIsArray);
 -        } else {
 -            chat_create_date = humanizedDateTime();
+        }
         if (!chat_metadata['integrity']) {
             chat_metadata['integrity'] = uuidv4();

+}
 export async function saveMetadata() {
 -    if (selected_group) {
 +    return await saveChatConditional();
 -        await editGroup(selected_group, true, false);
 -    }
 -    else {
 -        await saveChatConditional();
 -    }
+}
 export async function saveChatConditional() {

     });
     $('#rm_button_selected_ch').on('click', function () {
         if (selected_group) {
             select_group_chats(selected_group, false);
         } else {
             selected_button = 'character_edit';
             select_selected_character(this_chid);

     $('#rm_button_group_chats').on('click', function () {
         selected_button = 'group_chats';
         select_group_chats(null, false);
     });
     $('#rm_button_back_from_group').on('click', function () {

public/scripts/bookmarks.js+21 -20 Viewed

     chat,
     saveChatConditional,
     saveItemizedPrompts,
 +    setActiveGroup,
 } from '../script.js';
 import { humanizedDateTime } from './RossAscends-mods.js';
 import {

     const chats = [chatName];
     const members = [character.avatar];
     const favChecked = character.fav || character.fav == 'true';
     /** @type {anyChatMetadata} */
     const metadata = Object.assign({}, chat_metadata);
     delete metadata.main_chat;
+-
 +    /** @type {ChatHeader} */
 -    const createGroupResponse = await fetch('/api/groups/create', {
 +    const chatHeader = { chat_metadata: metadata };
 -        method: 'POST',
 +    /** @type {Omit<Group, 'id'>} */
 -        headers: getRequestHeaders(),
 +    const groupCreateModel = {
 -        body: JSON.stringify({
         name: name,
         members: members,
         avatar_url: avatar,
         allow_self_responses: false,
         activation_strategy: group_activation_strategy.NATURAL,
         disabled_members: [],
 -            chat_metadata: metadata,
         fav: favChecked,
         chat_id: chatName,
         chats: chats,
         hideMutedSprites: false,
         generation_mode: group_generation_mode.SWAP,
         auto_mode_delay: DEFAULT_AUTO_MODE_DELAY,
 -        }),
 +    };
++
 +    const createGroupResponse = await fetch('/api/groups/create', {
 +        method: 'POST',
 +        headers: getRequestHeaders(),
 +        body: JSON.stringify(groupCreateModel),
     });
     if (!createGroupResponse.ok) {

         return;
+    }
 +    /** @type {Group} */
     const group = await createGroupResponse.json();
     // Convert tags list and assign to group

     await getCharacters();
     // Convert chat to group format
     const groupChat = [...chat].slicemap(m => structuredClone(m));
     const genIdFirst = Date.now();
     for (let index = 0; index < groupChat.length; index++) {
         const message = groupChat[index];
 -        // Save group-chat marker
 -        if (index == 0) {
 -            // @ts-ignore
 -            message.is_group = true;
 -        }
+-
         // Skip messages we don't care about
         if (message.is_user || message.is_system || message.extra?.type === system_message_types.NARRATOR || message.force_avatar !== undefined) {
             continue;
+        }
 +        if (!message.extra || typeof message.extra !== 'object') {
 +            message.extra = {};
 +        }
++
         // Set force fields for solo character
         message.name = character.name;
         message.original_avatar = character.avatar;
         message.force_avatar = getThumbnailUrl('avatar', character.avatar);
+-
         // Allow regens of a single message in group
 -        if (typeof message.extra !== 'object') {
 +        message.extra.gen_id = genIdFirst + index;
 -            message.extra = { gen_id: genIdFirst + index };
 -        }
+    }
     // Save group chat
     const createChatResponse = await fetch('/api/chats/group/save', {
         method: 'POST',
         headers: getRequestHeaders(),
         body: JSON.stringify({ id: chatName, chat: [chatHeader, ...groupChat] }),
     });
     if (!createChatResponse.ok) {

+    }
     // Click on the freshly selected group to open it
 +    setActiveGroup(group.id);
     await openGroupById(group.id);
     toastr.success(t`The chat has been successfully converted!`);

public/scripts/extensions/attachments/index.js+1 -1 Viewed

 /**
  * Clean up character attachments when a character is deleted.
  * @param {{character: import('../../char-data.js').v1CharDataCharacter}} data Event data
  */
 function cleanUpCharacterAttachments(data) {
     const avatar = data?.character?.avatar;

public/scripts/extensions/gallery/index.js+1 -1 Viewed

 /**
  * Retrieves the gallery folder for a given character.
  * @param {import('../../char-data.js').v1CharDataCharacter} char Character data
  * @returns {string} The gallery folder for the character
  */
 function getGalleryFolder(char) {

public/scripts/extensions/quick-reply/index.js+1 -1 Viewed

     lastCharId = this_chid;
     // If no character is loaded, there's nothing more to do.
     /** @type {import('../../char-data.js').v1CharDataCharacter} */
     const character = characters[this_chid];
     if (!character || selected_group) {
         return;

public/scripts/extensions/regex/engine.js+3 -3 Viewed

 /**
  * Check if character's regexes are allowed to be used; if character is undefined, returns false
  * @param {import('../../char-data.js').v1CharDataCharacter|undefined} character
  * @returns {boolean}
  */
 export function isScopedScriptsAllowed(character) {

 /**
  * Allow character's regexes to be used; if character is undefined, do nothing
  * @param {import('../../char-data.js').v1CharDataCharacter|undefined} character
  * @returns {void}
  */
 export function allowScopedScripts(character) {

 /**
  * Disallow character's regexes to be used; if character is undefined, do nothing
  * @param {import('../../char-data.js').v1CharDataCharacter|undefined} character
  * @returns {void}
  */
 export function disallowScopedScripts(character) {

public/scripts/group-chats.js+295 -75 Viewed

     renderPaginationDropdown,
     paginationDropdownChangeHandler,
     waitUntilCondition,
 +    uuidv4,
 +    humanFileSize,
 } from './utils.js';
 import { RA_CountCharTokens, humanizedDateTime, dragElement, favsToHotswap, getMessageTimeStamp } from './RossAscends-mods.js';
 import { power_user, loadMovingUIState, sortEntitiesList } from './power-user.js';

 let is_group_generating = false; // Group generation flag
 let is_group_automode_enabled = false;
 let hideMutedSprites = false;
 +/** @type {Group[]} */
 let groups = [];
 +/** @type {string|null} */
 let selected_group = null;
 let group_generation_id = null;
 let fav_grp_checked = false;

     autoModeWorker = setInterval(groupChatAutoModeWorker, autoModeDelay * 1000);
+}
 +/**
 + * Saves a group to the server.
 + * @param {Group} group Group object to save
 + * @param {boolean} reload Whether to reload characters after saving
 + */
 async function _save(group, reload = true) {
     await fetch('/api/groups/edit', {
         method: 'POST',

     generateGroupWrapper(false, 'normal', { signal: abortController.signal });
+}
 +/**
 + * Loads group chat messages from the server.
 + * @param {string} chatId Chat ID
 + * @returns {Promise<ChatFile>} Array of chat messages
 + */
 async function loadGroupChat(chatId) {
     const response = await fetch('/api/chats/group/get', {
         method: 'POST',

     if (response.ok) {
         const data = await response.json();
 +        if (!Array.isArray(data)) {
 +            return [];
 +        }
         return data;
+    }
     return [];
+}
 +/**
 + * Validates a group by checking if all members exist and removing duplicates.
 + * @param {Group} group Group to validate
 + * @returns {Promise<void>}
 + */
 async function validateGroup(group) {
     if (!group) return;

+    }
+}
 +/**
 + * Loads the chat messages for a specific group.
 + * @param {string} groupId - The ID of the group to load chat messages for.
 + * @param {boolean} reload - Whether to reload the group chat after loading.
 + * @returns {Promise<void>} A promise that resolves when the chat messages have been loaded.
 + */
 export async function getGroupChat(groupId, reload = false) {
     const group = groups.find((x) => x.id === groupId);
     if (!group) {

     const chat_id = group.chat_id;
     const data = await loadGroupChat(chat_id);
     const metadata = groupdata?.[0]?.chat_metadata ?? {};
     const freshChat = !metadata.tainted && (!Array.isArray(data) || !data.length);
 +    // Remove chat file header if present
 +    if (Array.isArray(data) && data.length && Object.hasOwn(data[0], 'chat_metadata')) {
 +        data.shift();
 +    }
++
 +    // Add integrity slug if missing
 +    if (!metadata['integrity']) {
 +        metadata['integrity'] = uuidv4();
 +    }
++
     await loadItemizedPrompts(getCurrentChatId());
     if (group && Array.isArray(group.members) && freshChat) {

+        }
         await saveGroupChat(groupId, false);
     } else if (Array.isArray(data) && data.length) {
 -        data[0].is_group = true;
         chat.splice(0, chat.length, ...data);
         chat.forEach(ensureMessageMediaIsArray);
         chatElement.find('.mes').remove();

     return { description, personality, scenario, mesExamples };
+}
 +/**
 + * Gets the first message for a character.
 + * @param {Character} character Character object
 + * @returns {Promise<ChatMessage>} First message object
 + */
 async function getFirstCharacterMessage(character) {
     let messageText = character.first_mes;

     is_group_generating = false;
+}
 -async function saveGroupChat(groupId, shouldSaveGroup) {
 +/**
 + * Saves a group chat to the server.
 + * @param {string} groupId Group ID
 + * @param {boolean} shouldSaveGroup Whether to save the group after saving the chat
 + * @param {boolean} force Force the saving on integrity error
 + * @returns {Promise<void>} A promise that resolves when the group chat has been saved.
 + */
 +async function saveGroupChat(groupId, shouldSaveGroup, force = false) {
     const group = groups.find(x => x.id == groupId);
     const chat_id = group.chat_id;
     group['date_last_chat'] = Date.now();
 +    /** @type {ChatHeader} */
 +    const chatHeader = {
 +        chat_metadata: { ...chat_metadata },
 +    };
     const response = await fetch('/api/chats/group/save', {
         method: 'POST',
         headers: getRequestHeaders(),
         body: JSON.stringify({ id: chat_id, chat: [chatHeader, ...chat], force: force }),
     });
     if (!response.ok) {
 +        const errorData = await response.json();
 +        const isIntegrityError = errorData?.error === 'integrity' && !force;
 +        if (!isIntegrityError) {
             toastr.error(t`Check the server connection and reload the page to prevent data loss.`, t`Group Chat could not be saved`);
             console.error('Group chat could not be saved', response);
             return;
+        }
 +        const popupResult = await Popup.show.input(
 +            t`ERROR: Chat integrity check failed while saving the file.`,
 +            t`<p>After you click OK, the page will be reloaded to prevent data corruption.</p>
 +              <p>To confirm an overwrite (and potentially <b>LOSE YOUR DATA</b>), enter <code>OVERWRITE</code> (in all caps) in the box below before clicking OK.</p>`,
 +            '',
 +            { okButton: 'OK', cancelButton: false },
 +        );
++
 +        const forceSaveConfirmed = popupResult === 'OVERWRITE';
++
 +        if (!forceSaveConfirmed) {
 +            console.warn('Chat integrity check failed, and user did not confirm the overwrite. Reloading the page.');
 +            window.location.reload();
 +            return;
 +        }
++
 +        await saveGroupChat(groupId, shouldSaveGroup, true);
 +    }
++
     if (shouldSaveGroup) {
         await editGroup(groupId, false, false);
+    }
+}
 +/**
 + * Renames a group member across all groups and their chats.
 + * @param {string} oldAvatar Old avatar name
 + * @param {string} newAvatar New avatar name
 + * @param {string} newName New character name
 + */
 export async function renameGroupMember(oldAvatar, newAvatar, newName) {
     // Scan every group for our renamed character
     for (const group of groups) {

                 if (Array.isArray(messages) && messages.length) {
                     // Iterate over every chat message
                     for (const message of messages) {
 +                        // Skip the chat header
 +                        if (Object.hasOwn(message, 'chat_metadata')) {
 +                            continue;
 +                        }
++
                         // Only look at character messages
                         if (message.is_user || message.is_system) {
                             continue;

@@ -652,6 +738,9 @@ export async function renameGroupMember(oldAvatar, newAvatar, newName) {
652	738	}
653	739	}
654	740
	741	+/**
	742	+ * Fetches all groups from the server and processes them.
	743	+ */
655	744	async function getGroups() {
656	745	const response = await fetch('/api/groups/all', {
657	746	method: 'POST',

     });
     if (response.ok) {
 +        /** @type {Group[]} */
         const data = await response.json();
 -        groups = data.sort((a, b) => a.id - b.id);
 +        groups = data.slice();
         // Convert groups to new format
         for (const group of groups) {

@@ -678,9 +768,6 @@ async function getGroups() {
678	768	.filter(x => x)
679	769	.filter(onlyUnique);
680	770	}
681		- if (group.past_metadata == undefined) {
682		- group.past_metadata = {};
683		- }
684	771	if (typeof group.chat_id === 'number') {
685	772	group.chat_id = String(group.chat_id);
686	773	}

+    }
+}
 +/**
 + * Gets a group UI block for the list.
 + * @param {Group} group Group object
 + * @returns {JQuery<HTMLElement>} jQuery element representing the group block
 + */
 export function getGroupBlock(group) {
     let count = 0;
     let namesList = [];

     template.find('.ch_name').text(group.name).attr('title', `[Group] ${group.name}`);
     template.find('.group_fav_icon').css('display', 'none');
     template.addClass(group.fav ? 'is_fav' : '');
     template.find('.ch_fav').val(String(group.fav));
     template.find('.group_select_counter').text(count + ' ' + (count != 1 ? t`characters` : t`character`));
     template.find('.group_select_block_list').text(namesList.join(', '));

     return template;
+}
 +/**
 + * Updates the avatar display for a given group.
 + * @param {Group} group Group object
 + */
 function updateGroupAvatar(group) {
     $('#group_avatar_preview').empty().append(getGroupAvatar(group));

     favsToHotswap();
+}
 -// check if isDataURLor if it's a valid local file url
 +/**
 + * Checks if a URL is a valid image URL.
 + * @param {string} url URL to check
 + * @returns {boolean} True if valid, false otherwise
 + */
 function isValidImageUrl(url) {
     // check if empty dict
     if (Object.keys(url).length === 0) {

     return isDataURL(url) || (url && (url.startsWith('user') || url.startsWith('/user')));
+}
 +/**
 + * Gets a group avatar element.
 + * @param {Group} group Group object
 + * @returns {JQuery<HTMLElement>} Group avatar element
 + */
 function getGroupAvatar(group) {
     if (!group) {
         return $(`<div class="avatar"><img src="${default_avatar}"></div>`);

     return groupAvatar;
+}
 +/**
 + * Gets chat IDs for a group.
 + * @param {string} groupId Group ID
 + * @returns {string[]} Array of chat IDs
 + */
 function getGroupChatNames(groupId) {
     const group = groups.find(x => x.id === groupId);

     return names;
+}
 -async function generateGroupWrapper(by_auto_mode, type = null, params = {}) {
 +/**
 + * Generates text for the group chat by queueing members according to the activation strategy.
 + * @param {boolean} byAutoMode If the generation was triggered by the auto mode.
 + * @param {string?} type Generation type
 + * @param {object} params Additional Generate parameters
 + * @returns {Promise<string|void>} Generated text or nothing if no generation occurred
 + */
 +async function generateGroupWrapper(byAutoMode, type = null, params = {}) {
     function throwIfAborted() {
         if (params.signal instanceof AbortSignal && params.signal.aborted) {
             throw new Error('AbortSignal was fired. Group generation stopped');

     // Auto-navigate back to group menu
     if (menu_type !== 'group_edit') {
         select_group_chats(selected_group, false);
         await delay(1);
+    }

         let activationText = '';
         let isUserInput = false;
         if (userInput?.length && !by_auto_modebyAutoMode) {
             isUserInput = true;
             activationText = userInput;
         } else {

             // Wait for generation to finish
             const generateType = ['swipe', 'impersonate', 'quiet', 'continue'].includes(type) ? type : 'normal';
             textResult = await Generate(generateType, { automatic_trigger: by_auto_modebyAutoMode, ...(params || {}) });
             let messageChunk = textResult?.messageChunk;
             if (messageChunk) {
                 while (shouldAutoContinue(messageChunk, type === 'impersonate')) {
                     textResult = await Generate('continue', { automatic_trigger: by_auto_modebyAutoMode, ...(params || {}) });
                     messageChunk = textResult?.messageChunk;
+                }
+            }

     return Promise.resolve(textResult);
+}
 +/**
 + * Gets the generation ID of the last chat message.
 + * @returns {number|null} Generation ID or null
 + */
 function getLastMessageGenerationId() {
     let generationId = null;
     if (chat.length > 0) {

     return generationId;
+}
 +/**
 + * Activate group chat members for 'impersonate' generation type.
 + * @param {string[]} members Array of group member avatar ids
 + * @returns {number[]} Array of character ids
 + */
 function activateImpersonate(members) {
     const randomIndex = Math.floor(Math.random() * members.length);
     const activatedMembers = [members[randomIndex]];

     return memberIds;
+}
 +/**
 + * Activate group members for the list activation order.
 + * @param {string[]} members Array of group member avatar ids
 + * @returns {number[]} Array of character ids
 + */
 function activateListOrder(members) {
     let activatedMembers = members.filter(onlyUnique);

     return memberId !== -1 ? [memberId] : [];
+}
 +/**
 + * Activate group members for the natural activation order.
 + * @param {string[]} members Array of group member avatar ids
 + * @param {string} input User input that triggered the generation
 + * @param {ChatMessage} lastMessage Last message in the chat
 + * @param {boolean} allowSelfResponses If the group allows self-responses
 + * @param {boolean} isUserInput If the generation was triggered by user input
 + * @returns {number[]} Array of character ids
 + */
 function activateNaturalOrder(members, input, lastMessage, allowSelfResponses, isUserInput) {
     let activatedMembers = [];

     return memberIds;
+}
 +/**
 + * Deletes a group from the server by ID.
 + * @param {string} id Group ID to delete
 + * @returns {Promise<void>} Promise that resolves when the group is deleted
 + */
 async function deleteGroup(id) {
     const group = groups.find((x) => x.id === id);

+    }
+}
 +/**
 + * Edits a group by ID.
 + * @param {string} id Group ID to edit
 + * @param {boolean} immediately Whether to save immediately
 + * @param {boolean} reload Whether to reload the groups after saving
 + * @returns {Promise<void>} Promise that resolves when the group is edited
 + */
 export async function editGroup(id, immediately, reload = true) {
     let group = groups.find((x) => x.id === id);

         return;
+    }
 -    if (id === selected_group) {
 -        // structuredClone may cause issues if metadata has non-cloneable references
 -        group['chat_metadata'] = JSON.parse(JSON.stringify(chat_metadata));
 -    }
+-
     if (immediately) {
         return await _save(group, reload);
+    }

     await generateGroupWrapper(true, 'auto', { signal: groupAutoModeAbortController.signal });
+}
 +/**
 + * Modifies a group member by adding or removing them.
 + * @param {string} groupId Group ID
 + * @param {JQuery<HTMLElement>} groupMember Group member element
 + * @param {boolean} isDelete If true, removes the member; otherwise adds the member
 + */
 async function modifyGroupMember(groupId, groupMember, isDelete) {
     const id = groupMember.data('id');
     const thisGroup = groups.find((x) => x.id == groupId);

     $('#rm_group_submit').prop('disabled', !groupHasMembers);
+}
 -async function reorderGroupMember(chat_id, groupMember, direction) {
 +/**
 + * Reorders a group member up or down.
 + * @param {string} groupId Group ID
 + * @param {JQuery<HTMLElement>} groupMember Group member element
 + * @param {string} direction Direction to move the member ('up' or 'down')
 + * @returns {Promise<void>} Promise that resolves when the member has been reordered
 + */
 +async function reorderGroupMember(groupId, groupMember, direction) {
     const id = groupMember.data('id');
     const thisGroup = groups.find((x) => x.id == chat_idgroupId);
     const memberArray = thisGroup?.members ?? newGroupMembers;
     const indexOf = memberArray.indexOf(id);

@@ -1312,7 +1472,7 @@ async function reorderGroupMember(chat_id, groupMember, direction) {
1312	1472
1313	1473	// Existing groups need to modify members list
1314	1474	if (openGroupId) {
1315	1475	await editGroup(chat_idgroupId, false, false);
1316	1476	updateGroupAvatar(thisGroup);
1317	1477	}
1318	1478	}

         let _thisGroup = groups.find((x) => x.id == openGroupId);
         _thisGroup.name = $(this).val();
         $('#rm_button_selected_ch').children('h2').text(_thisGroup.name);
         await editGroup(openGroupId, false);
+    }
+}
 +/**
 + * Checks if a character with the given avatar ID is a member of the group.
 + * @param {Group} group Group object
 + * @param {string} avatarId Avatar ID to check
 + * @returns {boolean} True if the avatar is a member of the group, false otherwise
 + */
 function isGroupMember(group, avatarId) {
     if (group && Array.isArray(group.members)) {
         return group.members.includes(avatarId);

+    }
+}
 +/**
 + * Gets group characters based on filters.
 + * @param {object} param
 + * @param {boolean} [param.doFilter=false] Whether to apply filters
 + * @param {boolean} [param.onlyMembers=false] Whether to include only group members
 + * @returns {Array<{item: Character, id: number, type: string}>} Array of group character objects
 + */
 function getGroupCharacters({ doFilter = false, onlyMembers = false } = {}) {
     function sortMembersFn(a, b) {
         const membersArray = thisGroup?.members ?? newGroupMembers;

     });
+}
 +/**
 + * Creates a jQuery element representing a group character block.
 + * @param {Character} character Character object
 + * @returns {JQuery<HTMLElement>} jQuery element representing the group character block
 + */
 function getGroupCharacterBlock(character) {
     const avatar = getThumbnailUrl('avatar', character.avatar);
     const template = $('#group_member_template .group_member').clone();
     const isFav = !!character.fav || character.fav == 'true';
     template.data('id', character.avatar);
     template.find('.avatar img').attr({ 'src': avatar, 'title': character.avatar });
     template.find('.ch_name').text(character.name);
     template.attr('data-chid', characters.indexOf(character));
     template.find('.ch_fav').val(String(isFav));
     template.toggleClass('is_fav', isFav);
     const auxFieldName = power_user.aux_field || 'character_version';

     return template;
+}
 +/**
 + * Checks if a group member is disabled.
 + * @param {string} avatarId Avatar ID of the group member
 + * @returns {boolean} True if the group member is disabled, false otherwise
 + */
 function isGroupMemberDisabled(avatarId) {
     const thisGroup = openGroupId && groups.find((x) => x.id == openGroupId);
     return Boolean(thisGroup && thisGroup.disabled_members.includes(avatarId));

+    }
+}
 +/**
 + * Toggles the visibility of hidden controls based on the group's generation mode.
 + * @param {Group} group Group object
 + * @param {number|null} generationMode Generation mode, or null to use the group's current generation mode
 + */
 function toggleHiddenControls(group, generationMode = null) {
     const isJoin = [group_generation_mode.APPEND, group_generation_mode.APPEND_DISABLED].includes(generationMode ?? group?.generation_mode);
     $('#rm_group_generation_mode_join_prefix').parent().toggle(isJoin);

+    }
+}
 +/**
 + * Opens a group creation/editing right menu.
 + * @param {string|null} groupId ID of the group to select or null if creating a new group
 + * @param {boolean} skipAnimation If true, skips the animation when selecting the group
 + */
 function select_group_chats(groupId, skipAnimation) {
     openGroupId = groupId;
     newGroupMembers = [];

     $('#group_favorite_button').toggleClass('fav_off', !fav_grp_checked);
+}
 +/**
 + * Opens a group chat by its ID and updates the UI accordingly.
 + * @param {string} groupId ID of the group to open
 + * @returns {Promise<boolean>} Whether the group was opened
 + */
 export async function openGroupById(groupId) {
     if (isChatSaving) {
         toastr.info(t`Please wait until the chat is saved before switching characters.`, t`Your chat is still saving...`);

+    }
     if (!is_send_press && !is_group_generating) {
         select_group_chats(groupId, false);
         if (selected_group !== groupId) {
             groupChatQueueOrder = new Map();

     return false;
+}
 +/**
 + * Peeks the character definition from a group member element.
 + * @param {JQuery<HTMLElement>} characterSelect Character select element
 + * @returns {Promise<void>}
 + */
 async function openCharacterDefinition(characterSelect) {
     if (is_group_generating) {
         toastr.warning(t`Can't peek a character while group reply is being generated`);

+}
 async function createGroup() {
     let name = $('#rm_group_chat_name').val().toString();
     let allowSelfResponses = !!$('#rm_group_allow_self_responses').prop('checked');
     let activationStrategy = Number($('#rm_group_activation_strategy').find(':selected').val()) ?? group_activation_strategy.NATURAL;
     let generationMode = Number($('#rm_group_generation_mode').find(':selected').val()) ?? group_generation_mode.SWAP;

         name = t`Group: ${memberNames}`;
+    }
     const avatar_urlavatarUrl = $('#group_avatar_preview img').attr('src');
+-
     const chatName = humanizedDateTime();
     const chats = [chatName];
 -    const createGroupResponse = await fetch('/api/groups/create', {
 +    /** @type {Omit<Group, 'id'>} */
 -        method: 'POST',
 +    const groupCreateModel = {
 -        headers: getRequestHeaders(),
 -        body: JSON.stringify({
         name: name,
         members: members,
                     avatar_url: isValidImageUrl(avatar_urlavatarUrl) ? avatar_urlavatarUrl : default_avatar,
         allow_self_responses: allowSelfResponses,
         hideMutedSprites: hideMutedSprites,
         activation_strategy: activationStrategy,
         generation_mode: generationMode,
         disabled_members: [],
 -            chat_metadata: {},
         fav: fav_grp_checked,
         chat_id: chatName,
         chats: chats,
         auto_mode_delay: autoModeDelay,
 -        }),
 +    };
++
 +    const createGroupResponse = await fetch('/api/groups/create', {
 +        method: 'POST',
 +        headers: getRequestHeaders(),
 +        body: JSON.stringify(groupCreateModel),
     });
     if (createGroupResponse.ok) {

@@ -1880,6 +2084,11 @@ async function createGroup() {
1880	2084	}
1881	2085	}
1882	2086
	2087	+/**
	2088	+ * Creates a new group chat within the specified group.
	2089	+ * @param {string} groupId Group ID
	2090	+ * @returns {Promise<void>} Promise that resolves when the new group chat is created
	2091	+ */
1883	2092	export async function createNewGroupChat(groupId) {
1884	2093	const group = groups.find(x => x.id === groupId);
1885	2094

         return;
+    }
 -    const oldChatName = group.chat_id;
 -    const newChatName = humanizedDateTime();
+-
 -    if (typeof group.past_metadata !== 'object') {
 -        group.past_metadata = {};
 -    }
+-
     await clearChat();
     chat.length = 0;
 -    if (oldChatName) {
 +    const newChatName = humanizedDateTime();
 -        group.past_metadata[oldChatName] = Object.assign({}, chat_metadata);
 -    }
     group.chats.push(newChatName);
     group.chat_id = newChatName;
 -    group.chat_metadata = {};
 +    updateChatMetadata({}, true);
 -    updateChatMetadata(group.chat_metadata, true);
     await editGroup(group.id, true, false);
     await getGroupChat(group.id);
+}
 +/**
 + * Retrieves past chats for a specified group.
 + * @param {string} groupId Group ID
 + * @returns {Promise<Array>} Array of past chats
 + */
 export async function getGroupPastChats(groupId) {
     const group = groups.find(x => x.id === groupId);

     try {
         for (const chatId of group.chats) {
             const messages = await loadGroupChat(chatId);
 -            let this_chat_file_size = (JSON.stringify(messages).length / 1024).toFixed(2) + 'kb';
 +            if (!Array.isArray(messages)) {
 -            let chat_items = messages.length;
 +                continue;
 +            }
 +            const fileSize = humanFileSize(JSON.stringify(messages).length);
 +            if (messages.length > 0 && Object.hasOwn(messages[0], 'chat_metadata')) {
 +                messages.shift();
 +            }
 +            const chatItems = messages.length;
             const lastMessage = messages.length ? messages[messages.length - 1].mes : '[The chat is empty]';
             const lastMessageDate = messages.length ? (messages[messages.length - 1].send_date || Date.now()) : Date.now();
             chats.push({
                 'file_name': chatId,
                 'mes': lastMessage,
                 'last_mes': lastMessageDate,
                 'file_size': this_chat_file_sizefileSize,
                 'chat_items': chat_itemschatItems,
             });
+        }
     } catch (err) {

     return chats;
+}
 +/**
 + * Opens a specific group chat for the specified group by its ID.
 + * @param {string} groupId Group ID
 + * @param {string} chatId Chat ID
 + * @returns {Promise<void>}
 + */
 export async function openGroupChat(groupId, chatId) {
     await waitUntilCondition(() => !isChatSaving, debounce_timeout.extended, 10);
     const group = groups.find(x => x.id === groupId);

     await clearChat();
     chat.length = 0;
 -    const previousChat = group.chat_id;
 -    group.past_metadata[previousChat] = Object.assign({}, chat_metadata);
     group.chat_id = chatId;
 -    group.chat_metadata = group.past_metadata[chatId] || {};
     group['date_last_chat'] = Date.now();
     updateChatMetadata(group.chat_metadata{}, true);
     await editGroup(groupId, true, false);
     await getGroupChat(groupId);
+}
 +/**
 + * Renames a group chat within the specified group.
 + * @param {string} groupId Group ID
 + * @param {string} oldChatId Old chat ID
 + * @param {string} newChatId New chat ID
 + * @returns {Promise<void>} Promise that resolves when the group chat is renamed
 + */
 export async function renameGroupChat(groupId, oldChatId, newChatId) {
     const group = groups.find(x => x.id === groupId);

     group.chats.splice(group.chats.indexOf(oldChatId), 1);
     group.chats.push(newChatId);
 -    group.past_metadata[newChatId] = (group.past_metadata[oldChatId] || {});
 -    delete group.past_metadata[oldChatId];
     await editGroup(groupId, true, true);
+}

         return;
+    }
 -    if (typeof group.past_metadata !== 'object') {
 -        group.past_metadata = {};
 -    }
+-
     group.chats.splice(group.chats.indexOf(chatName), 1);
 -    delete group.past_metadata[chatName];
     const response = await fetch('/api/chats/group/delete', {
         method: 'POST',

     // If the deleted chat was the current chat, switch to the last chat in the group
     if (group.chat_id === chatName) {
 -        group.chat_id = '';
 -        group.chat_metadata = {};
+-
         const newChatName = group.chats.length ? group.chats[group.chats.length - 1] : humanizedDateTime();
         group.chat_id = newChatName;
 -        group.chat_metadata = group.past_metadata[newChatName] || {};
+    }
     await editGroup(groupId, true, true);

+    }
     group.chats.splice(group.chats.indexOf(chatId), 1);
 -    delete group.past_metadata[chatId];
     if (group.chat_id === chatId) {
         group.chat_id = '';
 -        group.chat_metadata = {};
 +        updateChatMetadata({}, true);
 -        updateChatMetadata(group.chat_metadata, true);
+    }
     const response = await fetch('/api/chats/group/delete', {

     return [];
+}
 +/**
 + * Saves the current group chat as a bookmark chat.
 + * @param {string} groupId Group ID
 + * @param {string} name Name of the chat to save
 + * @param {ChatMetadata?} metadata New metadata to save with the chat
 + * @param {number|undefined} mesId Optional message ID to trim the chat up to
 + * @returns {Promise<void>} Promise that resolves when the group chat is saved
 + */
 export async function saveGroupBookmarkChat(groupId, name, metadata, mesId) {
     const group = groups.find(x => x.id === groupId);

         return;
+    }
 -    group.past_metadata[name] = { ...chat_metadata, ...(metadata || {}) };
     group.chats.push(name);
 -    const trimmed_chat = (mesId !== undefined && mesId >= 0 && mesId < chat.length)
 +    /** @type {ChatHeader} */
 -        ? chat.slice(0, parseInt(mesId) + 1)
 +    const chatHeader = {
 +        chat_metadata: { ...chat_metadata, ...(metadata || {}) },
 +    };
++
 +    /** @type {ChatMessage[]} */
 +    const trimmedChat = (mesId !== undefined && mesId >= 0 && mesId < chat.length)
 +        ? chat.slice(0, Number(mesId) + 1)
         : chat;
     await editGroup(groupId, true, false);

     const response = await fetch('/api/chats/group/save', {
         method: 'POST',
         headers: getRequestHeaders(),
         body: JSON.stringify({ id: name, chat: [chatHeader, ...trimmed_chattrimmedChat] }),
     });
     if (!response.ok) {

public/scripts/utils.js+1 -1 Viewed

  * @param {string[]?} [options.filteredByTags=null] - Tags to filter characters by
  * @param {boolean} [options.preferCurrentChar=true] - Whether to prefer the current character(s)
  * @param {boolean} [options.quiet=false] - Whether to suppress warnings
  * @returns {import('./char-data.js').v1CharDataCharacter?} - The found character or null if not found
  */
 export function findChar({ name = null, allowAvatar = true, insensitive = true, filteredByTags = null, preferCurrentChar = true, quiet = false } = {}) {
     const matches = (char) => !name || (allowAvatar && char.avatar === name) || (insensitive ? equalsIgnoreCaseAndAccents(char.name, name) : char.name === name);

public/scripts/welcome-screen.js+2 -2 Viewed

 /**
  * Returns a greeting message for the assistant based on the character.
  * @param {import('./char-data.js').v1CharDataCharacter} character Character data
  * @returns {string} Greeting message
 */
 function getAssistantGreeting(character) {

     if (characterId === undefined) {
         return;
+    }
     /** @type {import('./char-data.js').v1CharDataCharacter} */
     const character = characters[characterId];
     if (!character) {
         return;

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

         const jsonFilesPromise = jsonFiles.map((file) => {
             const withMetadata = !!request.body.metadata;
             const pathToFile = path.join(request.user.directories.chats, characterDirectory, file);
             return getChatInfo(pathToFile, {}, false, withMetadata);
         });
         const chatData = (await Promise.allSettled(jsonFilesPromise)).filter(x => x.status === 'fulfilled').map(x => x.value);

src/endpoints/chats.js+27 -19 Viewed

  * Reads the information from a chat file.
  * @param {string} pathToFile - Path to the chat file
  * @param {object} additionalData - Additional data to include in the result
 - * @param {boolean} isGroup - Whether the chat is a group chat
  * @param {boolean} withMetadata - Whether to read chat metadata
  * @returns {Promise<ChatInfo>}
  */
 export async function getChatInfo(pathToFile, additionalData = {}, isGroup = false, withMetadata = false) {
     return new Promise(async (res) => {
         const parsedPath = path.parse(pathToFile);
         const stats = await fs.promises.stat(pathToFile);

             ...additionalData,
         };
         if (stats.size === 0 && !isGroup) {
 -            console.warn(`Found an empty chat file: ${pathToFile}`);
 -            res({});
 -            return;
 -        }
+-
 -        if (stats.size === 0 && isGroup) {
             res(chatData);
             return;
+        }

             if (lastLine) {
                 const jsonData = tryParse(lastLine);
                 if (jsonData && (jsonData.name || jsonData.character_name || jsonData.chat_metadata)) {
                     chatData.chat_items = isGroup ? itemCounter : (itemCounter - 1);
                     chatData.mes = jsonData['mes'] || '[The message is empty]';
                     chatData.last_mes = jsonData['send_date'] || stats.mtimeMs;

     return response.send({ error: true });
 });
 router.post('/group/save', async (request, response) => {
 +    try{
         if (!request.body || !request.body.id) {
             return response.sendStatus(400);
+        }
         const id = request.body.id;
             const pathToFilefilePath = path.join(request.user.directories.groupChats, sanitize(`${id}.jsonl`));
         if (!fs.existsSync(request.user.directories.groupChats)) {
                     fs.mkdirSync(request.user.directories.groupChats, { recursive: true });
+        }
     let        const chat_datachatData = request.body.chat;
     let        const jsonlData = chat_datachatData.map(JSON.stringify).join('\n');
 -    writeFileAtomicSync(pathToFile, jsonlData, 'utf8');
++
 +        if (checkIntegrity && !request.body.force) {
 +            const integritySlug = chatData?.[0]?.chat_metadata?.integrity;
 +            const isIntact = await checkChatIntegrity(filePath, integritySlug);
 +            if (!isIntact) {
 +                console.error(`Chat integrity check failed for ${filePath}`);
 +                return response.status(400).send({ error: 'integrity' });
 +            }
 +        }
++
 +        writeFileAtomicSync(filePath, jsonlData, 'utf8');
         getBackupFunction(request.user.profile.handle)(request.user.directories.backups, String(id), jsonlData);
         return response.send({ ok: true });
 +    } catch (error) {
 +        console.error(error);
 +        return response.send({ error: true });
 +    }
 });
 router.post('/search', validateAvatarUrlMiddleware, function (request, response) {

         const max = parseInt(request.body.max ?? Number.MAX_SAFE_INTEGER);
         const recentChats = allChatFiles.sort((a, b) => b.mtime - a.mtime).slice(0, max);
         const jsonFilesPromise = recentChats.map((file) => {
             const withMetadata = Boolean(!!request.body.metadata);
             return file.groupId
                 ? getChatInfo(file.filePath, { group: file.groupId }, true, withMetadata)
                 : getChatInfo(file.filePath, { avatar: file.pngFile }, false, withMetadata);
         });
         const chatData = (await Promise.allSettled(jsonFilesPromise)).filter(x => x.status === 'fulfilled').map(x => x.value);

src/endpoints/data-maid.js+13 -0 Viewed

                         const fileContent = await fs.promises.readFile(pathToFile, 'utf-8');
                         const groupData = tryParse(fileContent);
                         if (groupData?.chat_metadata && filterFn(groupData.chat_metadata)) {
 +                            console.warn('Found group chat metadata in group definition - this is deprecated behavior.');
                             allMetadata.push(groupData.chat_metadata);
+                        }
                         if (groupData?.past_metadata) {
 +                            console.warn('Found group past chat metadata in group definition - this is deprecated behavior.');
                             allMetadata.push(...Object.values(groupData.past_metadata).filter(filterFn));
+                        }
                     } catch (error) {

+                }
+            }
 +            const groupChats = await fs.promises.readdir(this.directories.groupChats, { withFileTypes: true });
 +            for (const file of groupChats) {
 +                if (file.isFile() && path.parse(file.name).ext === '.jsonl') {
 +                    const chatMessages = await this.#parseChatFile(path.join(this.directories.groupChats, file.name));
 +                    const chatMetadata = chatMessages?.[0]?.chat_metadata;
 +                    if (chatMetadata && filterFn(chatMetadata)) {
 +                        allMetadata.push(chatMetadata);
 +                    }
 +                }
 +            }
++
             const chatDirectories = await fs.promises.readdir(this.directories.chats, { withFileTypes: true });
             for (const directory of chatDirectories) {
                 if (directory.isDirectory()) {

src/endpoints/groups.js+104 -3 Viewed

 import fs from 'node:fs';
 +import { promises as fsPromises } from 'node:fs';
 import path from 'node:path';
 import express from 'express';
 import sanitize from 'sanitize-filename';
 import { sync as writeFileAtomicSync, default as writeFileAtomic } from 'write-file-atomic';
 import { color, humanizedISO8601DateTime, tryParse } from '../util.js';
 import { getFileNameValidationFunction } from '../middleware/validateFileName.js';
 export const router = express.Router();
 +/**
 + * Warns if group data contains deprecated metadata keys and removes them.
 + * @param {object} groupData Group data object
 + */
 +function warnOnGroupMetadata(groupData) {
 +    if (typeof groupData !== 'object' || groupData === null) {
 +        return;
 +    }
 +    ['chat_metadata', 'past_metadata'].forEach(key => {
 +        if (Object.hasOwn(groupData, key)) {
 +            console.warn(color.yellow(`Group JSON data for "${groupData.id}" contains deprecated key "${key}".`));
 +            delete groupData[key];
 +        }
 +    });
 +}
++
 +/**
 + * Migrates group metadata to include chat metadata for each group chat instead of the group itself.
 + * @param {import('../users.js').UserDirectoryList[]} userDirectories Listing of all users' directories
 + */
 +export async function migrateGroupChatsMetadataFormat(userDirectories) {
 +    for (const userDirs of userDirectories) {
 +        try {
 +            let anyDataMigrated = false;
 +            const backupPath = path.join(userDirs.backups, '_group_metadata_update');
 +            const groupFiles = await fsPromises.readdir(userDirs.groups, { withFileTypes: true });
 +            const groupChatFiles = await fsPromises.readdir(userDirs.groupChats, { withFileTypes: true });
 +            for (const groupFile of groupFiles) {
 +                try {
 +                    const isJsonFile = groupFile.isFile() && path.extname(groupFile.name) === '.json';
 +                    if (!isJsonFile) {
 +                        continue;
 +                    }
 +                    const groupFilePath = path.join(userDirs.groups, groupFile.name);
 +                    const groupDataRaw = await fsPromises.readFile(groupFilePath, 'utf8');
 +                    const groupData = tryParse(groupDataRaw) || {};
 +                    const needsMigration = ['chat_metadata', 'past_metadata'].some(key => Object.hasOwn(groupData, key));
 +                    if (!needsMigration) {
 +                        continue;
 +                    }
 +                    if (!fs.existsSync(backupPath)){
 +                        await fsPromises.mkdir(backupPath, { recursive: true });
 +                    }
 +                    await fsPromises.copyFile(groupFilePath, path.join(backupPath, groupFile.name));
 +                    const allMetadata = {
 +                        ...(groupData.past_metadata || {}),
 +                        [groupData.chat_id]: (groupData.chat_metadata || {}),
 +                    };
 +                    if (!Array.isArray(groupData.chats)) {
 +                        console.warn(color.yellow(`Group ${groupFile.name} has no chats array, skipping migration.`));
 +                        continue;
 +                    }
 +                    for (const chatId of groupData.chats) {
 +                        try {
 +                            const chatFileName = sanitize(`${chatId}.jsonl`);
 +                            const chatFileDirent = groupChatFiles.find(f => f.isFile() && f.name === chatFileName);
 +                            if (!chatFileDirent) {
 +                                console.warn(color.yellow(`Group chat file ${chatId} not found, skipping migration.`));
 +                                continue;
 +                            }
 +                            const chatFilePath = path.join(userDirs.groupChats, chatFileName);
 +                            const chatMetadata = allMetadata[chatId] || {};
 +                            const chatDataRaw = await fsPromises.readFile(chatFilePath, 'utf8');
 +                            const chatData = chatDataRaw.split('\n').filter(line => line.trim()).map(line => tryParse(line)).filter(Boolean);
 +                            const alreadyHasMetadata = chatData.length > 0 && Object.hasOwn(chatData[0], 'chat_metadata');
 +                            if (alreadyHasMetadata) {
 +                                console.log(color.yellow(`Group chat ${chatId} already has chat metadata, skipping update.`));
 +                                continue;
 +                            }
 +                            await fsPromises.copyFile(chatFilePath, path.join(backupPath, chatFileName));
 +                            const chatHeader = { chat_metadata: chatMetadata };
 +                            const newChatData = [chatHeader, ...chatData];
 +                            const newChatDataRaw = newChatData.map(entry => JSON.stringify(entry)).join('\n');
 +                            await writeFileAtomic(chatFilePath, newChatDataRaw, 'utf8');
 +                            console.log(`Updated group chat data format for ${chatId}`);
 +                            anyDataMigrated = true;
 +                        } catch (chatError) {
 +                            console.error(color.red(`Could not update existing chat data for ${chatId}`), chatError);
 +                        }
 +                    }
 +                    delete groupData.chat_metadata;
 +                    delete groupData.past_metadata;
 +                    await writeFileAtomic(groupFilePath, JSON.stringify(groupData, null, 4), 'utf8');
 +                    console.log(`Migrated group chats metadata for group: ${groupData.id}`);
 +                    anyDataMigrated = true;
 +                } catch (groupError) {
 +                    console.error(color.red(`Could not process group file ${groupFile.name}`), groupError);
 +                }
 +            }
 +            if (anyDataMigrated) {
 +                console.log(color.green(`Completed migration of group chats metadata for user at ${userDirs.root}`));
 +                console.log(color.cyan(`Backups of modified files are located at ${backupPath}`));
 +            }
 +        } catch (directoryError) {
 +            console.error(color.red(`Error migrating group chats metadata for user at ${userDirs.root}`), directoryError);
 +        }
 +    }
 +}
++
 router.post('/all', (request, response) => {
     const groups = [];

         return response.sendStatus(400);
+    }
 +    warnOnGroupMetadata(request.body);
     const id = String(Date.now());
     const groupMetadata = {
         id: id,

         activation_strategy: request.body.activation_strategy ?? 0,
         generation_mode: request.body.generation_mode ?? 0,
         disabled_members: request.body.disabled_members ?? [],
 -        chat_metadata: request.body.chat_metadata ?? {},
         fav: request.body.fav,
         chat_id: request.body.chat_id ?? id,
         chats: request.body.chats ?? [id],

     if (!request.body || !request.body.id) {
         return response.sendStatus(400);
+    }
 +    warnOnGroupMetadata(request.body);
     const id = request.body.id;
     const pathToFile = path.join(request.user.directories.groups, sanitize(`${id}.json`));
     const fileData = JSON.stringify(request.body, null, 4);

src/server-main.js+2 -0 Viewed

 import { redirectDeprecatedEndpoints, ServerStartup, setupPrivateEndpoints } from './server-startup.js';
 import { diskCache } from './endpoints/characters.js';
 import { migrateFlatSecrets } from './endpoints/secrets.js';
 +import { migrateGroupChatsMetadataFormat } from './endpoints/groups.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

     console.log();
     const directories = await getUserDirectoriesList();
 +    await migrateGroupChatsMetadataFormat(directories);
     await checkForNewContent(directories);
     await ensureThumbnailCache(directories);
     await diskCache.verify(directories);