Merge pull request #3215 from ceruleandeep/feature/uploadSprite /uploadsprite slashcommand

352a8e9a6193c03dd2a348c942a40bd1725bc09a

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

Signed

Parents: e6107ad447721342ef9d8a35f37a79d402e5ff7b 0f93caa4271ed8107904be5f9cd10d8a37111437

public/lib/eventemitter.js+4 -2 Viewed

 };
 EventEmitter.prototype.emit = async function (event) {
 +    let args = [].slice.call(arguments, 1);
     if (localStorage.getItem('eventTracing') === 'true') {
         console.trace('Event emitted: ' + event, args);
     } else {
         console.debug('Event emitted: ' + event);
+    }
     varlet i, listeners, length, args = [].slice.call(arguments, 1);
     if (typeof this.events[event] === 'object') {
         listeners = this.events[event].slice();

 };
 EventEmitter.prototype.emitAndWait = function (event) {
 +    let args = [].slice.call(arguments, 1);
     if (localStorage.getItem('eventTracing') === 'true') {
         console.trace('Event emitted: ' + event, args);
     } else {
         console.debug('Event emitted: ' + event);
+    }
     varlet i, listeners, length, args = [].slice.call(arguments, 1);
     if (typeof this.events[event] === 'object') {
         listeners = this.events[event].slice();

public/scripts/extensions/expressions/index.js+104 -3 Viewed

 import { SlashCommandEnumValue, enumTypes } from '../../slash-commands/SlashCommandEnumValue.js';
 import { commonEnumProviders } from '../../slash-commands/SlashCommandCommonEnumsProvider.js';
 import { slashCommandReturnHelper } from '../../slash-commands/SlashCommandReturnHelper.js';
 -import { SlashCommandClosure } from '../../slash-commands/SlashCommandClosure.js';
 import { generateWebLlmChatPrompt, isWebLlmSupported } from '../shared.js';
 export { MODULE_NAME };

+}
 /**
 + * Returns the sprite folder name (including override) for a character.
 + * @param {object} char Character object
 + * @param {string} char.avatar Avatar filename with extension
 + * @returns {string} Sprite folder name
 + * @throws {Error} If character not found or avatar not set
 + */
 +function spriteFolderNameFromCharacter(char) {
 +    const avatarFileName = char.avatar.replace(/\.[^/.]+$/, '');
 +    const expressionOverride = extension_settings.expressionOverrides.find(e => e.name === avatarFileName);
 +    return expressionOverride?.path ? expressionOverride.path : avatarFileName;
 +}
++
 +/**
 + * Slash command callback for /uploadsprite
 + *
 + * label= is required
 + * if name= is provided, it will be used as a findChar lookup
 + * if name= is not provided, the last character's name will be used
 + * if folder= is a full path, it will be used as the folder
 + * if folder= is a partial path, it will be appended to the character's name
 + * if folder= is not provided, the character's override folder will be used, if set
 + *
 + * @param {object} args
 + * @param {string} args.name Character name or avatar key, passed through findChar
 + * @param {string} args.label Expression label
 + * @param {string} args.folder Sprite folder path, processed using backslash rules
 + * @param {string} imageUrl Image URI to fetch and upload
 + * @returns {Promise<void>}
 + */
 +async function uploadSpriteCommand({ name, label, folder }, imageUrl) {
 +    if (!imageUrl) throw new Error('Image URL is required');
 +    if (!label || typeof label !== 'string') throw new Error('Expression label is required');
++
 +    label = label.replace(/[^a-z]/gi, '').toLowerCase().trim();
 +    if (!label) throw new Error('Expression label must contain at least one letter');
++
 +    name = name || getLastCharacterMessage().original_avatar || getLastCharacterMessage().name;
 +    const char = findChar({ name });
++
 +    if (!folder) {
 +        folder = spriteFolderNameFromCharacter(char);
 +    } else if (folder.startsWith('/') || folder.startsWith('\\')) {
 +        const subfolder = folder.slice(1);
 +        folder = `${char.name}/${subfolder}`;
 +    }
++
 +    try {
 +        const response = await fetch(imageUrl);
 +        const blob = await response.blob();
 +        const file = new File([blob], 'image.png', { type: 'image/png' });
++
 +        const formData = new FormData();
 +        formData.append('name', folder); // this is the folder or character name
 +        formData.append('label', label); // this is the expression label
 +        formData.append('avatar', file);  // this is the image file
++
 +        await handleFileUpload('/api/sprites/upload', formData);
 +        console.debug(`[${MODULE_NAME}] Upload of ${imageUrl} completed for ${name} with label ${label}`);
 +    } catch (error) {
 +        console.error(`[${MODULE_NAME}] Error uploading file:`, error);
 +        throw error;
 +    }
 +}
++
 +/**
  * Processes the classification text to reduce the amount of text sent to the API.
  * Quotes and asterisks are to be removed. If the text is less than 300 characters, it is returned as is.
  * If the text is more than 300 characters, the first and last 150 characters are returned.

  * @returns {Promise<string>} Rendered list item template
  */
 async function getListItem(item, imageSrc, textClass, isCustom) {
 -    const isFirefox = navigator.userAgent.toLowerCase().indexOf('firefox') > -1;
 -    imageSrc = isFirefox ? `${imageSrc}?t=${Date.now()}` : imageSrc;
     return renderExtensionTemplateAsync(MODULE_NAME, 'list-item', { item, imageSrc, textClass, isCustom });
+}

             </div>
         `,
     }));
 +    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
 +        name: 'uploadsprite',
 +        callback: async (args, url) => {
 +            await uploadSpriteCommand(args, url);
 +            return '';
 +        },
 +        unnamedArgumentList: [
 +            SlashCommandArgument.fromProps({
 +                description: 'URL of the image to upload',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                isRequired: true,
 +            }),
 +        ],
 +        namedArgumentList: [
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'name',
 +                description: 'Character name or avatar key (default is current character)',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                isRequired: false,
 +                acceptsMultiple: false,
 +            }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'label',
 +                description: 'Sprite label/expression name',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                enumProvider: localEnumProviders.expressions,
 +                isRequired: true,
 +                acceptsMultiple: false,
 +            }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'folder',
 +                description: 'Override folder to upload into',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                isRequired: false,
 +                acceptsMultiple: false,
 +            }),
 +        ],
 +        helpString: '<div>Upload a sprite from a URL.</div><div>Example:</div><pre><code>/uploadsprite name=Seraphina label=joy /user/images/Seraphina/Seraphina_2024-12-22@12h37m57s.png</code></pre>',
 +    }));
 })();

src/endpoints/sprites.js+2 -1 Viewed

                 })
                 .map((file) => {
                     const pathToSprite = path.join(spritesPath, file);
 +                    const mtime = fs.statSync(pathToSprite).mtime?.toISOString().replace(/[^0-9]/g, '').slice(0, 14);
                     return {
                         label: path.parse(pathToSprite).name.toLowerCase(),
                         path: `/characters/${name}/${file}` + (mtime ? `?t=${mtime}` : ''),
                     };
                 });
+        }