RocketChat · ricardogarim · May 15, 2026 · May 15, 2026 · Jun 9, 2026 · Jun 8, 2026
@@ -1,4 +1,4 @@
-import { MeteorError, Presence, Team, Calendar } from '@rocket.chat/core-services';
+import { MeteorError, Presence, Team } from '@rocket.chat/core-services';
 import type { IExportOperation, ILoginToken, IPersonalAccessToken, IUser, UserStatus } from '@rocket.chat/core-typings';
 import { Users, Subscriptions, Sessions, OAuthAccessTokens, OAuthRefreshTokens, OAuthAuthCodes } from '@rocket.chat/models';
 import {
@@ -29,7 +29,7 @@ import {
 	validateForbiddenErrorResponse,
 } from '@rocket.chat/rest-typings';
 import { escapeRegExp } from '@rocket.chat/string-helpers';
-import { getLoginExpirationInMs, wrapExceptions } from '@rocket.chat/tools';
+import { getLoginExpirationInMs } from '@rocket.chat/tools';
 import { Accounts } from 'meteor/accounts-base';
 import { Match, check } from 'meteor/check';
 import { Meteor } from 'meteor/meteor';
@@ -1982,12 +1982,6 @@ API.v1
 				),
 			);
 
-			if (!settings.get('Accounts_AllowUserStatusMessageChange')) {
-				throw new Meteor.Error('error-not-allowed', 'Change status is not allowed', {
-					method: 'users.setStatus',
-				});
-			}
-
 			const user = await (async () => {
 				if (isUserFromParams(this.bodyParams, this.userId, this.user)) {
 					return Users.findOneById(this.userId);
@@ -2010,6 +2004,12 @@ API.v1
 
 			const { status, message, expiresAt } = this.bodyParams;
 
+			if (message && !settings.get('Accounts_AllowUserStatusMessageChange')) {
+				throw new Meteor.Error('error-not-allowed', 'Change status is not allowed', {
+					method: 'users.setStatus',
+				});
+			}
+
 			const statusExpiresAt = expiresAt ? new Date(expiresAt) : undefined;
 			if (statusExpiresAt && Number.isNaN(statusExpiresAt.getTime())) {
 				throw new Meteor.Error('error-invalid-date', 'Invalid expiresAt date string', {
@@ -2029,10 +2029,6 @@ API.v1
 
 			await Presence.setStatus(user._id, effectiveStatus, message, statusExpiresAt);
 
-			if (status) {
-				void wrapExceptions(() => Calendar.cancelUpcomingStatusChanges(user._id)).suppress();
-			}
-
 			return API.v1.success();
 		},
 	)

@@ -181,7 +181,7 @@ export class AppUserBridge extends UserBridge {
 
 	protected async setActiveState(
 		userId: IUser['id'],
-		state: Pick<IUser, 'statusDefault' | 'statusSource' | 'statusText' | 'statusExpiresAt'>,
+		state: Pick<IUser, 'statusDefault' | 'statusSource' | 'statusText' | 'statusExpiresAt' | 'statusId'>,
 		appId: string,
 	): Promise<void> {
 		this.orch.debugLog(`The App ${appId} is setting active state for user ${userId}`);
@@ -191,13 +191,14 @@ export class AppUserBridge extends UserBridge {
 			statusText: state.statusText,
 			statusSource: state.statusSource as PresenceSource,
 			...(state.statusExpiresAt && { statusExpiresAt: state.statusExpiresAt }),
+			...(state.statusId && { statusId: state.statusId }),
 		});
 	}
 
-	protected async endActiveState(userId: IUser['id'], appId: string): Promise<void> {
+	protected async endActiveState(userId: IUser['id'], appId: string, statusId?: string): Promise<void> {
 		this.orch.debugLog(`The App ${appId} is ending active state for user ${userId}`);
 
-		await Presence.endActiveState(userId);
+		await Presence.endActiveState(userId, statusId);
 	}
 
 	protected async getActiveUserCount(): Promise<number> {

@@ -29,8 +29,8 @@ function ComposerBoxPopup<
 >({ title, items, focused, select, renderItem = ({ item }: { item: T }) => <>{JSON.stringify(item)}</> }: ComposerBoxPopupProps<T>) {
 	const { t } = useTranslation();
 	const id = useId();
-	const composerBoxPopupRef = useRef<HTMLElement>(null);
-	const popupSizes = useContentBoxSize(composerBoxPopupRef);
+	const popupRef = useRef<HTMLElement>(null);
+	const popupSizes = useContentBoxSize(popupRef);
 
 	const variant = popupSizes && popupSizes.inlineSize < 480 ? 'small' : 'large';
 
@@ -52,6 +52,8 @@ function ComposerBoxPopup<
 		if (item.disabled) {
 			return t('Unavailable_in_encrypted_channels');
 		}
+
+		return undefined;
 	};
 
 	const itemsFlat = useMemo(
@@ -80,7 +82,7 @@ function ComposerBoxPopup<
 
 	return (
 		<Box position='relative'>
-			<Tile ref={composerBoxPopupRef} padding={0} role='menu' mbe={8} overflow='hidden' aria-labelledby={id} name='ComposerBoxPopup'>
+			<Tile ref={popupRef} padding={0} role='menu' mbe={8} overflow='hidden' aria-labelledby={id} name='ComposerBoxPopup'>
 				{title && (
 					<Box bg='tint' pi={16} pb={8} id={id}>
 						{title}

@@ -0,0 +1,39 @@
+import type { ReactNode } from 'react';
+
+export type ComposerPopupOption<T extends { _id: string; sort?: number } = { _id: string; sort?: number }> = {
+	title?: string;
+	getItemsFromLocal?: (filter: any) => Promise<T[]>;
+	getItemsFromServer?: (filter: any) => Promise<T[]>;
+	blurOnSelectItem?: boolean;
+	closeOnEsc?: boolean;
+
+	trigger?: string;
+	triggerAnywhere?: boolean;
+	triggerLength?: number;
+
+	suffix?: string;
+	prefix?: string;
+
+	matchSelectorRegex?: RegExp;
+	preview?: boolean;
+	enablePreviewQuery?: (filter: unknown) => boolean;
+
+	getValue: (item: T) => string;
+
+	renderItem?: ({ item }: { item: T }) => ReactNode;
+	disabled?: boolean;
+};
+
+export const createMessageBoxPopupConfig = <T extends { _id: string; sort?: number }>(
+	partial: Omit<ComposerPopupOption<T>, 'getValue'> & Partial<Pick<ComposerPopupOption<T>, 'getValue'>>,
+): ComposerPopupOption<T> => {
+	return {
+		blurOnSelectItem: true,
+		closeOnEsc: true,
+		triggerAnywhere: true,
+		suffix: ' ',
+		prefix: partial.prefix ?? partial.trigger ?? ' ',
+		getValue: (item) => item._id,
+		...partial,
+	};
+};
@@ -0,0 +1,34 @@
+export type EditableTextAdapter = {
+	textBeforeCaret(): string;
+	caret(): number;
+	replaceRange(text: string, start: number, end: number): void;
+};
+
+type InputLike = HTMLInputElement | HTMLTextAreaElement;
+
+// the prototype's native setter is what makes React's onChange fire on a programmatic edit
+const setNativeValue = (input: InputLike, value: string) => {
+	const proto = input instanceof HTMLTextAreaElement ? HTMLTextAreaElement.prototype : HTMLInputElement.prototype;
+	const setter = Object.getOwnPropertyDescriptor(proto, 'value')?.set;
+	setter?.call(input, value);
+};
+
+export const fromInputElement = (getInput: () => InputLike | null): EditableTextAdapter => ({
+	textBeforeCaret: () => {
+		const input = getInput();
+		return input ? input.value.substring(0, input.selectionStart ?? input.value.length) : '';
+	},
+	caret: () => getInput()?.selectionStart ?? 0,
+	replaceRange: (text, start, end) => {
+		const input = getInput();
+		if (!input) {
+			return;
+		}
+		const nextValue = input.value.slice(0, start) + text + input.value.slice(end);
+		const caret = start + text.length;
+		input.focus();
+		setNativeValue(input, nextValue);
+		input.setSelectionRange(caret, caret);
+		input.dispatchEvent(new Event('input', { bubbles: true }));
+	},
+});
@@ -0,0 +1,144 @@
+import { mockAppRoot } from '@rocket.chat/mock-providers';
+import { act, fireEvent, renderHook, waitFor } from '@testing-library/react';
+
+import { useComposerBoxPopup } from './useComposerBoxPopup';
+import { createMessageBoxPopupConfig } from '../ComposerPopupOption';
+import type { EditableTextAdapter } from '../editableTextAdapter';
+
+const keys = { ENTER: 13, ESC: 27, ARROW_UP: 38, ARROW_DOWN: 40 };
+
+type Item = { _id: string; username?: string };
+
+const createComposer = (text: string, caret = text.length) => ({
+	substring: (start: number, end?: number) => text.substring(start, end),
+	selection: { start: caret, end: caret },
+	replaceText: jest.fn(),
+});
+
+const adapterFor = (composer: ReturnType<typeof createComposer>): EditableTextAdapter => ({
+	textBeforeCaret: () => composer.substring(0, composer.selection.start),
+	caret: () => composer.selection.start,
+	replaceRange: (text, start, end) => composer.replaceText(text, { start, end }),
+});
+
+const userOption = createMessageBoxPopupConfig<Item>({
+	trigger: '@',
+	getItemsFromLocal: async () => [
+		{ _id: 'u1', username: 'alice' },
+		{ _id: 'u2', username: 'bob' },
+	],
+	getItemsFromServer: async () => [],
+	getValue: (item) => item.username ?? '',
+});
+
+const emojiOption = createMessageBoxPopupConfig<Item>({
+	trigger: ':',
+	triggerLength: 2,
+	getItemsFromLocal: async (filter: string) => [{ _id: `:${filter}a:` }, { _id: `:${filter}b:` }],
+	getItemsFromServer: async () => [],
+	getValue: (item) => item._id.substring(1),
+});
+
+const commandOption = createMessageBoxPopupConfig<Item>({
+	trigger: '/',
+	triggerAnywhere: false,
+	getItemsFromLocal: async () => [{ _id: 'archive' }],
+	getItemsFromServer: async () => [],
+	getValue: (item) => item._id,
+});
+
+const options = [userOption, emojiOption, commandOption];
+
+const setup = (text: string, caret = text.length) => {
+	const composer = createComposer(text, caret);
+	const node = document.createElement('textarea');
+
+	const { result } = renderHook(() => useComposerBoxPopup(options, adapterFor(composer)), {
+		wrapper: mockAppRoot().build(),
+	});
+	act(() => result.current.callbackRef(node));
+
+	const fire = (type: 'keyUp' | 'keyDown', which: number) => fireEvent[type](node, { which, keyCode: which });
+
+	return { result, composer, fire };
+};
+
+describe('useComposerBoxPopup (characterization)', () => {
+	it('opens no popup when the text has no trigger', () => {
+		const { result, fire } = setup('hello');
+		fire('keyUp', 0);
+		expect(result.current.option).toBeUndefined();
+	});
+
+	it('detects the `@` trigger and extracts the filter', () => {
+		const { result, fire } = setup('hi @al');
+		fire('keyUp', 0);
+		expect(result.current.option?.trigger).toBe('@');
+		expect(result.current.filter).toBe('al');
+	});
+
+	it('respects triggerLength: `:` alone does not open, `:ab` does', () => {
+		const closed = setup('x :');
+		closed.fire('keyUp', 0);
+		expect(closed.result.current.option).toBeUndefined();
+
+		const open = setup('x :ab');
+		open.fire('keyUp', 0);
+		expect(open.result.current.option?.trigger).toBe(':');
+		expect(open.result.current.filter).toBe('ab');
+	});
+
+	it('only triggers a start-only (`/`) option at the very start of the text', () => {
+		const mid = setup('hey /arch');
+		mid.fire('keyUp', 0);
+		expect(mid.result.current.option).toBeUndefined();
+
+		const start = setup('/arch');
+		start.fire('keyUp', 0);
+		expect(start.result.current.option?.trigger).toBe('/');
+		expect(start.result.current.filter).toBe('arch');
+	});
+
+	it('inserts prefix + value + suffix over the trigger range on select', async () => {
+		const { result, composer, fire } = setup('hi @al');
+		fire('keyUp', 0);
+		await waitFor(() => expect(result.current.focused).toBeDefined());
+
+		act(() => result.current.select?.({ _id: 'u1', username: 'alice' }));
+
+		expect(composer.replaceText).toHaveBeenCalledWith('@alice ', { start: 3, end: 6 });
+	});
+
+	it('moves focus with arrow keys and wraps around', async () => {
+		const { result, fire } = setup('hi @');
+		fire('keyUp', 0);
+		await waitFor(() => expect(result.current.focused?._id).toBe('u1'));
+
+		fire('keyDown', keys.ARROW_DOWN);
+		expect(result.current.focused?._id).toBe('u2');
+
+		fire('keyDown', keys.ARROW_DOWN);
+		expect(result.current.focused?._id).toBe('u1');
+
+		fire('keyDown', keys.ARROW_UP);
+		expect(result.current.focused?._id).toBe('u2');
+	});
+
+	it('selects the focused item on Enter', async () => {
+		const { result, composer, fire } = setup('hi @');
+		fire('keyUp', 0);
+		await waitFor(() => expect(result.current.focused?._id).toBe('u1'));
+
+		fire('keyDown', keys.ENTER);
+		expect(composer.replaceText).toHaveBeenCalledWith('@alice ', expect.objectContaining({ end: 4 }));
+	});
+
+	it('closes the popup on Escape', async () => {
+		const { result, fire } = setup('hi @al');
+		fire('keyUp', 0);
+		await waitFor(() => expect(result.current.option?.trigger).toBe('@'));
+
+		fire('keyUp', keys.ESC);
+		expect(result.current.option).toBeUndefined();
+	});
+});