snapshot of https://github.com/RocketChat/Rocket.Chat.git (develop, 2026-09-16; blobs > 131072B omitted)

apps/meteor/server/lib/media/custom-sounds/lib/deleteCustomSound.ts

@@ -0,0 +1,20 @@
+import { api } from '@rocket.chat/core-services';
+import { CustomSounds } from '@rocket.chat/models';
+import { Meteor } from 'meteor/meteor';
+
+import { RocketChatFileCustomSoundsInstance } from '../startup/custom-sounds';
+
+export const deleteCustomSound = async (_id: string): Promise<void> => {
+	const sound = await CustomSounds.findOneById(_id);
+
+	if (!sound) {
+		throw new Meteor.Error('Custom_Sound_Error_Invalid_Sound', 'Invalid sound', {
+			method: 'deleteCustomSound',
+		});
+	}
+
+	await RocketChatFileCustomSoundsInstance.deleteFile(`${sound._id}.${sound.extension}`);
+	await CustomSounds.removeById(_id);
+
+	void api.broadcast('notify.deleteCustomSound', { soundData: sound });
+};

apps/meteor/server/lib/media/custom-sounds/lib/insertOrUpdateSound.ts

@@ -0,0 +1,61 @@
+import { api } from '@rocket.chat/core-services';
+import { CustomSounds } from '@rocket.chat/models';
+import { Meteor } from 'meteor/meteor';
+
+import type { ICustomSoundData } from '../../../../meteor-methods/media/insertOrUpdateSound';
+import { RocketChatFileCustomSoundsInstance } from '../startup/custom-sounds';
+
+export const insertOrUpdateSound = async (soundData: ICustomSoundData): Promise<string> => {
+	// silently strip colon; this allows for uploading :soundname: as soundname
+	soundData.name = (soundData.name || '').replace(/:/g, '');
+
+	if (!soundData.name.trim()) {
+		throw new Meteor.Error('error-the-field-is-required', 'The field Name is required', {
+			method: 'insertOrUpdateSound',
+			field: 'Name',
+		});
+	}
+
+	// allow all characters except colon, whitespace, comma, >, <, &, ", ', /, \, (, )
+	// more practical than allowing specific sets of characters; also allows foreign languages
+	const nameValidation = /[\s,:><&"'\/\\\(\)]/;
+
+	if (nameValidation.test(soundData.name)) {
+		throw new Meteor.Error('error-input-is-not-a-valid-field', `${soundData.name} is not a valid name`, {
+			method: 'insertOrUpdateSound',
+			input: soundData.name,
+			field: 'Name',
+		});
+	}
+
+	const conflictingSound = await CustomSounds.findOneByName(soundData.name, soundData._id, { projection: { _id: 1 } });
+
+	if (conflictingSound) {
+		throw new Meteor.Error('Custom_Sound_Error_Name_Already_In_Use', 'The custom sound name is already in use', {
+			method: 'insertOrUpdateSound',
+		});
+	}
+
+	if (!soundData._id) {
+		return (
+			await CustomSounds.create({
+				name: soundData.name,
+				extension: soundData.extension,
+			})
+		).insertedId;
+	}
+
+	if (soundData.newFile) {
+		await RocketChatFileCustomSoundsInstance.deleteFile(`${soundData._id}.${soundData.previousExtension}`);
+	}
+
+	if (soundData.name !== soundData.previousName || soundData.extension !== soundData.previousExtension) {
+		await CustomSounds.updateById(soundData._id, { name: soundData.name, extension: soundData.extension });
+		const updatedSound = await CustomSounds.findOneById(soundData._id);
+		if (updatedSound) {
+			void api.broadcast('notify.updateCustomSound', { soundData: updatedSound });
+		}
+	}
+
+	return soundData._id;
+};

apps/meteor/server/lib/media/custom-sounds/lib/uploadCustomSound.ts

@@ -0,0 +1,44 @@
+import { api } from '@rocket.chat/core-services';
+import type { RequiredField } from '@rocket.chat/core-typings';
+import { CustomSounds } from '@rocket.chat/models';
+
+import type { ICustomSoundData } from '../../../../meteor-methods/media/insertOrUpdateSound';
+import { RocketChatFile } from '../../file';
+import { RocketChatFileCustomSoundsInstance } from '../startup/custom-sounds';
+
+export const uploadCustomSound = async (
+	buffer: Buffer,
+	contentType: string,
+	soundData: RequiredField<ICustomSoundData, '_id'>,
+): Promise<void> => {
+	const rs = RocketChatFile.bufferToStream(buffer);
+
+	if (soundData.previousExtension) {
+		await RocketChatFileCustomSoundsInstance.deleteFile(`${soundData._id}.${soundData.previousExtension}`);
+	}
+
+	return new Promise((resolve, reject) => {
+		const ws = RocketChatFileCustomSoundsInstance.createWriteStream(`${soundData._id}.${soundData.extension}`, contentType);
+
+		ws.on('error', (err: Error) => {
+			reject(err);
+		});
+
+		rs.on('error', (err: Error) => {
+			ws.destroy();
+			reject(err);
+		});
+
+		ws.on('end', () => {
+			setTimeout(async () => {
+				const sound = await CustomSounds.findOneById(soundData._id);
+				if (sound) {
+					void api.broadcast('notify.updateCustomSound', { soundData: sound });
+				}
+			}, 500);
+			resolve();
+		});
+
+		rs.pipe(ws);
+	});
+};

apps/meteor/server/lib/media/custom-sounds/startup/custom-sounds.js

@@ -0,0 +1,104 @@
+import { CustomSounds } from '@rocket.chat/models';
+import { Meteor } from 'meteor/meteor';
+import { WebApp } from 'meteor/webapp';
+
+import { settings } from '../../../../settings';
+import { SystemLogger } from '../../../logger/system';
+import { RocketChatFile } from '../../file';
+
+export let RocketChatFileCustomSoundsInstance;
+
+const initializeCustomSoundsStorage = () => {
+	let storeType = 'GridFS';
+
+	if (settings.get('CustomSounds_Storage_Type')) {
+		storeType = settings.get('CustomSounds_Storage_Type');
+	}
+
+	const RocketChatStore = RocketChatFile[storeType];
+
+	if (RocketChatStore == null) {
+		throw new Error(`Invalid RocketChatStore type [${storeType}]`);
+	}
+
+	SystemLogger.info({
+		msg: 'Using custom sounds storage',
+		storeType,
+	});
+
+	let path = '~/uploads';
+	if (settings.get('CustomSounds_FileSystemPath') != null) {
+		if (settings.get('CustomSounds_FileSystemPath').trim() !== '') {
+			path = settings.get('CustomSounds_FileSystemPath');
+		}
+	}
+
+	RocketChatFileCustomSoundsInstance = new RocketChatStore({
+		name: 'custom_sounds',
+		absolutePath: path,
+	});
+};
+
+Meteor.startup(() => {
+	initializeCustomSoundsStorage();
+	return WebApp.connectHandlers.use('/custom-sounds/', async (req, res /* , next*/) => {
+		const fileId = decodeURIComponent(req.url.replace(/^\//, '').replace(/\?.*$/, ''));
+
+		if (!fileId) {
+			res.writeHead(403);
+			res.write('Forbidden');
+			res.end();
+			return;
+		}
+
+		const sound = await CustomSounds.findOneById(fileId.split('.')[0], { projection: { _id: 1 } });
+
+		if (!sound) {
+			res.writeHead(404);
+			res.write('Not found');
+			res.end();
+			return;
+		}
+
+		const file = await RocketChatFileCustomSoundsInstance.getFileWithReadStream(fileId);
+
+		if (!file) {
+			res.writeHead(404);
+			res.write('Not found');
+			res.end();
+			return;
+		}
+
+		res.setHeader('Content-Disposition', 'inline');
+
+		let fileUploadDate = undefined;
+		if (file.uploadDate != null) {
+			fileUploadDate = file.uploadDate.toUTCString();
+		}
+
+		const reqModifiedHeader = req.headers['if-modified-since'];
+		if (reqModifiedHeader != null) {
+			if (reqModifiedHeader === fileUploadDate) {
+				res.setHeader('Last-Modified', reqModifiedHeader);
+				res.writeHead(304);
+				res.end();
+				return;
+			}
+		}
+
+		res.setHeader('Cache-Control', 'public, max-age=0');
+		res.setHeader('Expires', '-1');
+		if (fileUploadDate != null) {
+			res.setHeader('Last-Modified', fileUploadDate);
+		} else {
+			res.setHeader('Last-Modified', new Date().toUTCString());
+		}
+
+		res.setHeader('Content-Type', file.contentType);
+		res.setHeader('Content-Length', file.length);
+
+		file.readStream.pipe(res);
+	});
+});
+
+settings.watchMultiple(['CustomSounds_Storage_Type', 'CustomSounds_FileSystemPath'], initializeCustomSoundsStorage);