From 7bafe0390ea5f05084215c977c5604e09a605aa8 Mon Sep 17 00:00:00 2001
From: Lucas Pelegrino <lucas.pelegrino@rocket.chat>
Date: Tue, 17 Dec 2024 18:11:19 -0300
Subject: [PATCH 1/3] fix: Messages not being processed for all slack servers
 (#34148)

---
 .changeset/lovely-beers-argue.md              |  5 ++++
 .../app/slackbridge/server/RocketAdapter.js   | 23 +++++++++----------
 2 files changed, 16 insertions(+), 12 deletions(-)
 create mode 100644 .changeset/lovely-beers-argue.md

diff --git a/.changeset/lovely-beers-argue.md b/.changeset/lovely-beers-argue.md
new file mode 100644
index 000000000000..a01a97535e48
--- /dev/null
+++ b/.changeset/lovely-beers-argue.md
@@ -0,0 +1,5 @@
+---
+"@rocket.chat/meteor": patch
+---
+
+Fixes messages not being processed for all slack servers
diff --git a/apps/meteor/app/slackbridge/server/RocketAdapter.js b/apps/meteor/app/slackbridge/server/RocketAdapter.js
index 245e28c72203..70418d407443 100644
--- a/apps/meteor/app/slackbridge/server/RocketAdapter.js
+++ b/apps/meteor/app/slackbridge/server/RocketAdapter.js
@@ -62,8 +62,9 @@ export default class RocketAdapter {
 			try {
 				if (!slack.getSlackChannel(rocketMessageDeleted.rid)) {
 					// This is on a channel that the rocket bot is not subscribed on this slack server
-					return;
+					continue;
 				}
+
 				rocketLogger.debug('onRocketMessageDelete', rocketMessageDeleted);
 				await slack.postDeleteMessage(rocketMessageDeleted);
 			} catch (err) {
@@ -134,22 +135,23 @@ export default class RocketAdapter {
 			try {
 				if (!slack.getSlackChannel(rocketMessage.rid)) {
 					// This is on a channel that the rocket bot is not subscribed
-					return;
+					continue;
 				}
 				rocketLogger.debug('onRocketMessage', rocketMessage);
 
 				if (rocketMessage.editedAt) {
 					// This is an Edit Event
 					await this.processMessageChanged(rocketMessage, slack);
-					return rocketMessage;
+					continue;
 				}
 				// Ignore messages originating from Slack
 				if (rocketMessage._id.indexOf('slack-') === 0) {
-					return rocketMessage;
+					continue;
 				}
 
 				if (rocketMessage.file) {
-					return this.processFileShare(rocketMessage, slack);
+					await this.processFileShare(rocketMessage, slack);
+					continue;
 				}
 
 				// A new message from Rocket.Chat
@@ -206,10 +208,7 @@ export default class RocketAdapter {
 				}
 			}
 
-			const message = `${text} ${fileName}`;
-
-			rocketMessage.msg = message;
-			await slack.postMessage(slack.getSlackChannel(rocketMessage.rid), rocketMessage);
+			await slack.postMessage(slack.getSlackChannel(rocketMessage.rid), { ...rocketMessage, msg: `${text} ${fileName}` });
 		}
 	}
 
@@ -266,7 +265,7 @@ export default class RocketAdapter {
 
 		for await (const slack of this.slackAdapters) {
 			if (addedRoom) {
-				return;
+				continue;
 			}
 
 			const slackChannel = await slack.slackAPI.getRoomInfo(slackChannelID);
@@ -274,7 +273,7 @@ export default class RocketAdapter {
 				const members = await slack.slackAPI.getMembers(slackChannelID);
 				if (!members) {
 					rocketLogger.error('Could not fetch room members');
-					return;
+					continue;
 				}
 
 				const rocketRoom = await Rooms.findOneByName(slackChannel.name);
@@ -288,7 +287,7 @@ export default class RocketAdapter {
 
 					if (!rocketUserCreator) {
 						rocketLogger.error({ msg: 'Could not fetch room creator information', creator: slackChannel.creator });
-						return;
+						continue;
 					}
 
 					try {

From 75a14b2e013aca7361cac56316f2b7e8c07d9dc8 Mon Sep 17 00:00:00 2001
From: Guilherme Gazzo <guilhermegazzo@gmail.com>
Date: Tue, 17 Dec 2024 18:27:04 -0300
Subject: [PATCH 2/3] feat: Adds callout from cloud for subscription upgrade
 eligibility (#33549)

Co-authored-by: Aleksander Nicacio da Silva <aleksander.silva@rocket.chat>
Co-authored-by: Lucas Pelegrino <lucas.pelegrino@rocket.chat>
Co-authored-by: Kevin Aleman <kaleman960@gmail.com>
---
 .changeset/wicked-socks-hide.md               |   7 ++
 .../fetchWorkspaceSyncPayload.ts              |  42 ++++++++
 .../functions/syncWorkspace/syncCloudData.ts  |  55 ++--------
 .../components/Page/PageHeaderNoShadow.tsx    |   2 +-
 apps/meteor/client/hooks/useLicense.ts        |  15 ++-
 .../uikit/hooks/useBannerContextValue.ts      |   1 +
 .../admin/subscription/SubscriptionPage.tsx   |  20 ++--
 .../surface/UiKitSubscriptionLicense.tsx      | 102 ++++++++++++++++++
 .../UiKitSubscriptionLicenseSurface.tsx       |  33 ++++++
 apps/meteor/ee/server/api/licenses.ts         |  23 +++-
 .../core-apps/cloudAnnouncements.module.ts    |   5 +-
 .../cloudSubscriptionCommunication.module.ts  |  37 +++++++
 apps/meteor/server/settings/setup-wizard.ts   |   5 +
 apps/meteor/server/startup/coreApps.ts        |   2 +
 .../syncWorkspace/syncCloudData.spec.ts       | 101 +++++++++++++++++
 .../src/cloud/CloudSyncAnnouncement.ts        |  10 ++
 .../src/cloud/WorkspaceSyncPayload.ts         |   1 +
 packages/core-typings/src/cloud/index.ts      |   1 +
 .../core-typings/src/license/LicenseInfo.ts   |   2 +
 packages/rest-typings/src/v1/licenses.ts      |   3 +-
 20 files changed, 407 insertions(+), 60 deletions(-)
 create mode 100644 .changeset/wicked-socks-hide.md
 create mode 100644 apps/meteor/app/cloud/server/functions/syncWorkspace/fetchWorkspaceSyncPayload.ts
 create mode 100644 apps/meteor/client/views/admin/subscription/surface/UiKitSubscriptionLicense.tsx
 create mode 100644 apps/meteor/client/views/admin/subscription/surface/UiKitSubscriptionLicenseSurface.tsx
 create mode 100644 apps/meteor/server/modules/core-apps/cloudSubscriptionCommunication.module.ts
 create mode 100644 apps/meteor/tests/unit/app/cloud/server/functions/syncWorkspace/syncCloudData.spec.ts
 create mode 100644 packages/core-typings/src/cloud/CloudSyncAnnouncement.ts

diff --git a/.changeset/wicked-socks-hide.md b/.changeset/wicked-socks-hide.md
new file mode 100644
index 000000000000..3f425c3228e2
--- /dev/null
+++ b/.changeset/wicked-socks-hide.md
@@ -0,0 +1,7 @@
+---
+"@rocket.chat/meteor": minor
+"@rocket.chat/core-typings": minor
+"@rocket.chat/rest-typings": minor
+---
+
+Adds a new callout in the subscription page to inform users of subscription upgrade eligibility when applicable.
diff --git a/apps/meteor/app/cloud/server/functions/syncWorkspace/fetchWorkspaceSyncPayload.ts b/apps/meteor/app/cloud/server/functions/syncWorkspace/fetchWorkspaceSyncPayload.ts
new file mode 100644
index 000000000000..7d01f6305c83
--- /dev/null
+++ b/apps/meteor/app/cloud/server/functions/syncWorkspace/fetchWorkspaceSyncPayload.ts
@@ -0,0 +1,42 @@
+import type { Cloud, Serialized } from '@rocket.chat/core-typings';
+import { serverFetch as fetch } from '@rocket.chat/server-fetch';
+import { v, compile } from 'suretype';
+
+import { CloudWorkspaceConnectionError } from '../../../../../lib/errors/CloudWorkspaceConnectionError';
+import { settings } from '../../../../settings/server';
+
+const workspaceSyncPayloadSchema = v.object({
+	workspaceId: v.string().required(),
+	publicKey: v.string(),
+	license: v.string().required(),
+});
+
+const assertWorkspaceSyncPayload = compile(workspaceSyncPayloadSchema);
+
+export async function fetchWorkspaceSyncPayload({
+	token,
+	data,
+}: {
+	token: string;
+	data: Cloud.WorkspaceSyncRequestPayload;
+}): Promise<Serialized<Cloud.WorkspaceSyncResponse>> {
+	const workspaceRegistrationClientUri = settings.get<string>('Cloud_Workspace_Registration_Client_Uri');
+	const response = await fetch(`${workspaceRegistrationClientUri}/sync`, {
+		method: 'POST',
+		headers: {
+			Authorization: `Bearer ${token}`,
+		},
+		body: data,
+	});
+
+	if (!response.ok) {
+		const { error } = await response.json();
+		throw new CloudWorkspaceConnectionError(`Failed to connect to Rocket.Chat Cloud: ${error}`);
+	}
+
+	const payload = await response.json();
+
+	assertWorkspaceSyncPayload(payload);
+
+	return payload;
+}
diff --git a/apps/meteor/app/cloud/server/functions/syncWorkspace/syncCloudData.ts b/apps/meteor/app/cloud/server/functions/syncWorkspace/syncCloudData.ts
index fc55fc9e34fd..f28821b08387 100644
--- a/apps/meteor/app/cloud/server/functions/syncWorkspace/syncCloudData.ts
+++ b/apps/meteor/app/cloud/server/functions/syncWorkspace/syncCloudData.ts
@@ -1,57 +1,14 @@
-import type { Cloud, Serialized } from '@rocket.chat/core-typings';
 import { DuplicatedLicenseError } from '@rocket.chat/license';
-import { serverFetch as fetch } from '@rocket.chat/server-fetch';
-import { v, compile } from 'suretype';
+import { Settings } from '@rocket.chat/models';
 
 import { callbacks } from '../../../../../lib/callbacks';
 import { CloudWorkspaceAccessError } from '../../../../../lib/errors/CloudWorkspaceAccessError';
-import { CloudWorkspaceConnectionError } from '../../../../../lib/errors/CloudWorkspaceConnectionError';
 import { CloudWorkspaceRegistrationError } from '../../../../../lib/errors/CloudWorkspaceRegistrationError';
 import { SystemLogger } from '../../../../../server/lib/logger/system';
-import { settings } from '../../../../settings/server';
 import { buildWorkspaceRegistrationData } from '../buildRegistrationData';
 import { CloudWorkspaceAccessTokenEmptyError, getWorkspaceAccessToken } from '../getWorkspaceAccessToken';
 import { retrieveRegistrationStatus } from '../retrieveRegistrationStatus';
-
-const workspaceSyncPayloadSchema = v.object({
-	workspaceId: v.string().required(),
-	publicKey: v.string(),
-	license: v.string().required(),
-});
-
-const assertWorkspaceSyncPayload = compile(workspaceSyncPayloadSchema);
-
-const fetchWorkspaceSyncPayload = async ({
-	token,
-	data,
-}: {
-	token: string;
-	data: Cloud.WorkspaceSyncRequestPayload;
-}): Promise<Serialized<Cloud.WorkspaceSyncResponse>> => {
-	const workspaceRegistrationClientUri = settings.get<string>('Cloud_Workspace_Registration_Client_Uri');
-	const response = await fetch(`${workspaceRegistrationClientUri}/sync`, {
-		method: 'POST',
-		headers: {
-			Authorization: `Bearer ${token}`,
-		},
-		body: data,
-	});
-
-	if (!response.ok) {
-		try {
-			const { error } = await response.json();
-			throw new CloudWorkspaceConnectionError(`Failed to connect to Rocket.Chat Cloud: ${error}`);
-		} catch (error) {
-			throw new CloudWorkspaceConnectionError(`Failed to connect to Rocket.Chat Cloud: ${response.statusText}`);
-		}
-	}
-
-	const payload = await response.json();
-
-	assertWorkspaceSyncPayload(payload);
-
-	return payload;
-};
+import { fetchWorkspaceSyncPayload } from './fetchWorkspaceSyncPayload';
 
 export async function syncCloudData() {
 	try {
@@ -67,11 +24,17 @@ export async function syncCloudData() {
 
 		const workspaceRegistrationData = await buildWorkspaceRegistrationData(undefined);
 
-		const { license, removeLicense = false } = await fetchWorkspaceSyncPayload({
+		const {
+			license,
+			removeLicense = false,
+			cloudSyncAnnouncement,
+		} = await fetchWorkspaceSyncPayload({
 			token,
 			data: workspaceRegistrationData,
 		});
 
+		await Settings.updateValueById('Cloud_Sync_Announcement_Payload', JSON.stringify(cloudSyncAnnouncement ?? null));
+
 		if (removeLicense) {
 			await callbacks.run('workspaceLicenseRemoved');
 		} else {
diff --git a/apps/meteor/client/components/Page/PageHeaderNoShadow.tsx b/apps/meteor/client/components/Page/PageHeaderNoShadow.tsx
index 51feca504834..afc3891a5714 100644
--- a/apps/meteor/client/components/Page/PageHeaderNoShadow.tsx
+++ b/apps/meteor/client/components/Page/PageHeaderNoShadow.tsx
@@ -22,7 +22,7 @@ const PageHeaderNoShadow = ({ children = undefined, title, onClickBack, ...props
 	useDocumentTitle(typeof title === 'string' ? title : undefined);
 
 	return (
-		<Box is='header' borderBlockEndWidth='default' borderBlockEndColor='transparent' {...props}>
+		<Box is='header' borderBlockEndWidth='default' pb={8} borderBlockEndColor='transparent' {...props}>
 			<Box
 				height='100%'
 				marginInline={24}
diff --git a/apps/meteor/client/hooks/useLicense.ts b/apps/meteor/client/hooks/useLicense.ts
index 4ec8d29ec49c..6c50ff55fe74 100644
--- a/apps/meteor/client/hooks/useLicense.ts
+++ b/apps/meteor/client/hooks/useLicense.ts
@@ -49,7 +49,20 @@ export const useLicenseBase = <TData = LicenseDataType>({
 };
 
 export const useLicense = (params?: LicenseParams) => {
-	return useLicenseBase({ params, select: (data) => data.license });
+	return useLicenseBase({
+		params,
+		select: (data) => data.license,
+	});
+};
+
+export const useLicenseWithCloudAnnouncement = (params?: LicenseParams) => {
+	return useLicenseBase({
+		params,
+		select: ({ license, cloudSyncAnnouncement }) => ({
+			...license,
+			cloudSyncAnnouncement,
+		}),
+	});
 };
 
 export const useHasLicense = (): UseQueryResult<boolean> => {
diff --git a/apps/meteor/client/uikit/hooks/useBannerContextValue.ts b/apps/meteor/client/uikit/hooks/useBannerContextValue.ts
index 35b38e8dee63..81cb70af6636 100644
--- a/apps/meteor/client/uikit/hooks/useBannerContextValue.ts
+++ b/apps/meteor/client/uikit/hooks/useBannerContextValue.ts
@@ -41,6 +41,7 @@ export const useBannerContextValue = ({ view, values }: UseBannerContextValuePar
 		},
 		updateState: (): void => undefined,
 		appId: view.appId,
+		viewId: view.viewId,
 		values,
 	};
 };
diff --git a/apps/meteor/client/views/admin/subscription/SubscriptionPage.tsx b/apps/meteor/client/views/admin/subscription/SubscriptionPage.tsx
index e6f5beffe7ba..aaf4f984c89e 100644
--- a/apps/meteor/client/views/admin/subscription/SubscriptionPage.tsx
+++ b/apps/meteor/client/views/admin/subscription/SubscriptionPage.tsx
@@ -21,9 +21,12 @@ import PlanCardCommunity from './components/cards/PlanCard/PlanCardCommunity';
 import SeatsCard from './components/cards/SeatsCard';
 import { useCancelSubscriptionModal } from './hooks/useCancelSubscriptionModal';
 import { useWorkspaceSync } from './hooks/useWorkspaceSync';
-import { Page, PageHeader, PageScrollableContentWithShadow } from '../../../components/Page';
+import UiKitSubscriptionLicense from './surface/UiKitSubscriptionLicense';
+import { Page, PageScrollableContentWithShadow } from '../../../components/Page';
+import PageBlockWithBorder from '../../../components/Page/PageBlockWithBorder';
+import PageHeaderNoShadow from '../../../components/Page/PageHeaderNoShadow';
 import { useIsEnterprise } from '../../../hooks/useIsEnterprise';
-import { useInvalidateLicense, useLicense } from '../../../hooks/useLicense';
+import { useInvalidateLicense, useLicenseWithCloudAnnouncement } from '../../../hooks/useLicense';
 import { useRegistrationStatus } from '../../../hooks/useRegistrationStatus';
 
 function useShowLicense() {
@@ -48,7 +51,7 @@ const SubscriptionPage = () => {
 	const router = useRouter();
 	const { data: enterpriseData } = useIsEnterprise();
 	const { isRegistered } = useRegistrationStatus();
-	const { data: licensesData, isLoading: isLicenseLoading } = useLicense({ loadValues: true });
+	const { data: licensesData, isLoading: isLicenseLoading } = useLicenseWithCloudAnnouncement({ loadValues: true });
 	const syncLicenseUpdate = useWorkspaceSync();
 	const invalidateLicenseQuery = useInvalidateLicense();
 
@@ -56,7 +59,7 @@ const SubscriptionPage = () => {
 
 	const showSubscriptionCallout = useDebouncedValue(subscriptionSuccess || syncLicenseUpdate.isLoading, 10000);
 
-	const { license, limits, activeModules = [] } = licensesData || {};
+	const { license, limits, activeModules = [], cloudSyncAnnouncement } = licensesData || {};
 	const { isEnterprise = true } = enterpriseData || {};
 
 	const getKeyLimit = (key: 'monthlyActiveContacts' | 'activeUsers') => {
@@ -99,7 +102,7 @@ const SubscriptionPage = () => {
 
 	return (
 		<Page bg='tint'>
-			<PageHeader title={t('Subscription')}>
+			<PageHeaderNoShadow title={t('Subscription')}>
 				<ButtonGroup>
 					{isRegistered && (
 						<Button loading={syncLicenseUpdate.isLoading} icon='reload' onClick={() => handleSyncLicenseUpdate()}>
@@ -110,7 +113,12 @@ const SubscriptionPage = () => {
 						{t(isEnterprise ? 'Manage_subscription' : 'Upgrade')}
 					</UpgradeButton>
 				</ButtonGroup>
-			</PageHeader>
+			</PageHeaderNoShadow>
+			{cloudSyncAnnouncement && (
+				<PageBlockWithBorder>
+					<UiKitSubscriptionLicense key='license' initialView={cloudSyncAnnouncement} />
+				</PageBlockWithBorder>
+			)}
 			<PageScrollableContentWithShadow p={16}>
 				{(showSubscriptionCallout || syncLicenseUpdate.isLoading) && (
 					<Callout type='info' title={t('Sync_license_update_Callout_Title')} m={8}>
diff --git a/apps/meteor/client/views/admin/subscription/surface/UiKitSubscriptionLicense.tsx b/apps/meteor/client/views/admin/subscription/surface/UiKitSubscriptionLicense.tsx
new file mode 100644
index 000000000000..9946425673fa
--- /dev/null
+++ b/apps/meteor/client/views/admin/subscription/surface/UiKitSubscriptionLicense.tsx
@@ -0,0 +1,102 @@
+import { useDebouncedCallback } from '@rocket.chat/fuselage-hooks';
+import { UiKitContext, bannerParser, UiKitComponent } from '@rocket.chat/fuselage-ui-kit';
+import type { View } from '@rocket.chat/ui-kit';
+import type { ContextType, Dispatch, ReactElement } from 'react';
+import React, { useMemo } from 'react';
+
+import type { SubscriptionLicenseLayout } from './UiKitSubscriptionLicenseSurface';
+import { UiKitSubscriptionLicenseSurface } from './UiKitSubscriptionLicenseSurface';
+import MarkdownText from '../../../../components/MarkdownText';
+import { useUiKitActionManager } from '../../../../uikit/hooks/useUiKitActionManager';
+import { useUiKitView } from '../../../../uikit/hooks/useUiKitView';
+
+// TODO: move this to fuselage-ui-kit itself
+bannerParser.mrkdwn = ({ text }): ReactElement => <MarkdownText variant='inline' content={text} />;
+
+type UiKitSubscriptionLicenseProps = {
+	key: string;
+	initialView: {
+		viewId: string;
+		appId: string;
+		blocks: SubscriptionLicenseLayout;
+	};
+};
+
+type UseSubscriptionLicenseContextValueParams = {
+	view: View & {
+		viewId: string;
+	};
+	values: {
+		[actionId: string]: {
+			value: unknown;
+			blockId?: string | undefined;
+		};
+	};
+	updateValues: Dispatch<{
+		actionId: string;
+		payload: {
+			value: unknown;
+			blockId?: string | undefined;
+		};
+	}>;
+};
+type UseSubscriptionLicenseContextValueReturn = ContextType<typeof UiKitContext>;
+
+const useSubscriptionLicenseContextValue = ({
+	view,
+	values,
+	updateValues,
+}: UseSubscriptionLicenseContextValueParams): UseSubscriptionLicenseContextValueReturn => {
+	const actionManager = useUiKitActionManager();
+
+	const emitInteraction = useMemo(() => actionManager.emitInteraction.bind(actionManager), [actionManager]);
+	const debouncedEmitInteraction = useDebouncedCallback(emitInteraction, 700);
+
+	return {
+		action: async ({ appId, viewId, actionId, dispatchActionConfig, blockId, value }): Promise<void> => {
+			if (!appId || !viewId) {
+				return;
+			}
+
+			const emit = dispatchActionConfig?.includes('on_character_entered') ? debouncedEmitInteraction : emitInteraction;
+
+			await emit(appId, {
+				type: 'blockAction',
+				actionId,
+				container: {
+					type: 'view',
+					id: viewId,
+				},
+				payload: {
+					blockId,
+					value,
+				},
+			});
+		},
+		updateState: ({ actionId, value, blockId = 'default' }) => {
+			updateValues({
+				actionId,
+				payload: {
+					blockId,
+					value,
+				},
+			});
+		},
+		...view,
+		values,
+		viewId: view.viewId,
+	};
+};
+
+const UiKitSubscriptionLicense = ({ initialView }: UiKitSubscriptionLicenseProps) => {
+	const { view, values, updateValues } = useUiKitView(initialView);
+	const contextValue = useSubscriptionLicenseContextValue({ view, values, updateValues });
+
+	return (
+		<UiKitContext.Provider value={contextValue}>
+			<UiKitComponent render={UiKitSubscriptionLicenseSurface} blocks={view.blocks} />
+		</UiKitContext.Provider>
+	);
+};
+
+export default UiKitSubscriptionLicense;
diff --git a/apps/meteor/client/views/admin/subscription/surface/UiKitSubscriptionLicenseSurface.tsx b/apps/meteor/client/views/admin/subscription/surface/UiKitSubscriptionLicenseSurface.tsx
new file mode 100644
index 000000000000..d3642f772f1f
--- /dev/null
+++ b/apps/meteor/client/views/admin/subscription/surface/UiKitSubscriptionLicenseSurface.tsx
@@ -0,0 +1,33 @@
+import { Margins } from '@rocket.chat/fuselage';
+import { createSurfaceRenderer, Surface, FuselageSurfaceRenderer, renderTextObject } from '@rocket.chat/fuselage-ui-kit';
+import type { CalloutBlock, ContextBlock, DividerBlock, ImageBlock, SectionBlock } from '@rocket.chat/ui-kit';
+import type { ReactElement, ReactNode } from 'react';
+import React from 'react';
+
+type SubscriptionLicenseSurfaceProps = {
+	children?: ReactNode;
+};
+
+type SubscriptionLicenseLayoutBlock = ContextBlock | DividerBlock | ImageBlock | SectionBlock | CalloutBlock;
+
+export type SubscriptionLicenseLayout = SubscriptionLicenseLayoutBlock[];
+
+const SubscriptionLicenseSurface = ({ children }: SubscriptionLicenseSurfaceProps): ReactElement => (
+	<Surface type='custom'>
+		<Margins blockEnd={16}>{children}</Margins>
+	</Surface>
+);
+
+export class SubscriptionLicenseSurfaceRenderer extends FuselageSurfaceRenderer {
+	public constructor() {
+		super(['context', 'divider', 'image', 'section', 'callout']);
+	}
+
+	plain_text = renderTextObject;
+
+	mrkdwn = renderTextObject;
+}
+
+export default SubscriptionLicenseSurface;
+
+export const UiKitSubscriptionLicenseSurface = createSurfaceRenderer(SubscriptionLicenseSurface, new SubscriptionLicenseSurfaceRenderer());
diff --git a/apps/meteor/ee/server/api/licenses.ts b/apps/meteor/ee/server/api/licenses.ts
index 1e5a2a90575c..5c686c0e532e 100644
--- a/apps/meteor/ee/server/api/licenses.ts
+++ b/apps/meteor/ee/server/api/licenses.ts
@@ -6,6 +6,7 @@ import { check } from 'meteor/check';
 import { API } from '../../../app/api/server/api';
 import { hasPermissionAsync } from '../../../app/authorization/server/functions/hasPermission';
 import { notifyOnSettingChangedById } from '../../../app/lib/server/lib/notifyListener';
+import { settings } from '../../../app/settings/server';
 import { updateAuditedByUser } from '../../../server/settings/lib/auditedSettingUpdates';
 
 API.v1.addRoute(
@@ -16,9 +17,27 @@ API.v1.addRoute(
 			const unrestrictedAccess = await hasPermissionAsync(this.userId, 'view-privileged-setting');
 			const loadCurrentValues = unrestrictedAccess && Boolean(this.queryParams.loadValues);
 
-			const license = await License.getInfo({ limits: unrestrictedAccess, license: unrestrictedAccess, currentValues: loadCurrentValues });
+			const license = await License.getInfo({
+				limits: unrestrictedAccess,
+				license: unrestrictedAccess,
+				currentValues: loadCurrentValues,
+			});
+
+			try {
+				// TODO: Remove this logic after setting type object is implemented.
+				const cloudSyncAnnouncement = JSON.parse(settings.get('Cloud_Sync_Announcement_Payload') ?? null);
+				const canManageCloud = await hasPermissionAsync(this.userId, 'manage-cloud');
+				return API.v1.success({
+					license,
+					...(canManageCloud && cloudSyncAnnouncement && { cloudSyncAnnouncement }),
+				});
+			} catch (error) {
+				console.error('Unable to parse Cloud_Sync_Announcement_Payload');
+			}
 
-			return API.v1.success({ license });
+			return API.v1.success({
+				license,
+			});
 		},
 	},
 );
diff --git a/apps/meteor/server/modules/core-apps/cloudAnnouncements.module.ts b/apps/meteor/server/modules/core-apps/cloudAnnouncements.module.ts
index 68599162cdef..569e9d639b17 100644
--- a/apps/meteor/server/modules/core-apps/cloudAnnouncements.module.ts
+++ b/apps/meteor/server/modules/core-apps/cloudAnnouncements.module.ts
@@ -67,9 +67,8 @@ export class CloudAnnouncementsModule implements IUiKitCoreApp {
 		const type = announcement?.surface === 'banner' ? 'banner.close' : 'modal.close';
 
 		// for viewClosed we just need to let Cloud know that the banner was closed, no need to wait for the response
-		setImmediate(async () => {
-			await this.handlePayload(payload);
-		});
+
+		void this.handlePayload(payload);
 
 		return {
 			type,
diff --git a/apps/meteor/server/modules/core-apps/cloudSubscriptionCommunication.module.ts b/apps/meteor/server/modules/core-apps/cloudSubscriptionCommunication.module.ts
new file mode 100644
index 000000000000..8e5789f91099
--- /dev/null
+++ b/apps/meteor/server/modules/core-apps/cloudSubscriptionCommunication.module.ts
@@ -0,0 +1,37 @@
+import type { UiKitCoreAppPayload } from '@rocket.chat/core-services';
+import type * as UiKit from '@rocket.chat/ui-kit';
+
+import { CloudAnnouncementsModule } from './cloudAnnouncements.module';
+
+export class CloudSubscriptionCommunication extends CloudAnnouncementsModule {
+	appId = 'cloud-communication-core';
+
+	async viewClosed(payload: UiKitCoreAppPayload): Promise<UiKit.ServerInteraction> {
+		const {
+			payload: { view: { viewId } = {} },
+			user: { _id: userId } = {},
+		} = payload;
+
+		if (!userId) {
+			throw new Error('invalid user');
+		}
+
+		if (!viewId) {
+			throw new Error('invalid view');
+		}
+
+		if (!payload.triggerId) {
+			throw new Error('invalid triggerId');
+		}
+
+		// for viewClosed we just need to let Cloud know that the banner was closed, no need to wait for the response
+
+		void this.handlePayload(payload);
+
+		return {
+			type: 'modal.close',
+			triggerId: payload.triggerId,
+			appId: payload.appId,
+		};
+	}
+}
diff --git a/apps/meteor/server/settings/setup-wizard.ts b/apps/meteor/server/settings/setup-wizard.ts
index 91e3125d1280..13d76a6070d9 100644
--- a/apps/meteor/server/settings/setup-wizard.ts
+++ b/apps/meteor/server/settings/setup-wizard.ts
@@ -1342,5 +1342,10 @@ export const createSetupWSettings = () =>
 				},
 				secret: true,
 			});
+			await this.add('Cloud_Sync_Announcement_Payload', 'null', {
+				type: 'string', // TODO: replace setting type string for object once is implemented.
+				hidden: true,
+				secret: true,
+			});
 		});
 	});
diff --git a/apps/meteor/server/startup/coreApps.ts b/apps/meteor/server/startup/coreApps.ts
index 9638d99ab559..38f95da93d20 100644
--- a/apps/meteor/server/startup/coreApps.ts
+++ b/apps/meteor/server/startup/coreApps.ts
@@ -1,11 +1,13 @@
 import { BannerModule } from '../modules/core-apps/banner.module';
 import { CloudAnnouncementsModule } from '../modules/core-apps/cloudAnnouncements.module';
+import { CloudSubscriptionCommunication } from '../modules/core-apps/cloudSubscriptionCommunication.module';
 import { MentionModule } from '../modules/core-apps/mention.module';
 import { Nps } from '../modules/core-apps/nps.module';
 import { VideoConfModule } from '../modules/core-apps/videoconf.module';
 import { registerCoreApp } from '../services/uikit-core-app/service';
 
 registerCoreApp(new CloudAnnouncementsModule());
+registerCoreApp(new CloudSubscriptionCommunication());
 registerCoreApp(new Nps());
 registerCoreApp(new BannerModule());
 registerCoreApp(new VideoConfModule());
diff --git a/apps/meteor/tests/unit/app/cloud/server/functions/syncWorkspace/syncCloudData.spec.ts b/apps/meteor/tests/unit/app/cloud/server/functions/syncWorkspace/syncCloudData.spec.ts
new file mode 100644
index 000000000000..f17cb5986da8
--- /dev/null
+++ b/apps/meteor/tests/unit/app/cloud/server/functions/syncWorkspace/syncCloudData.spec.ts
@@ -0,0 +1,101 @@
+import { expect } from 'chai';
+import { describe, it, beforeEach } from 'mocha';
+import proxyquire from 'proxyquire';
+import sinon from 'sinon';
+
+const models = {
+	Settings: { updateValueById: sinon.stub() },
+};
+
+const mockedFetchWorkspaceSyncPayload = sinon.stub();
+
+const { syncCloudData } = proxyquire.noCallThru().load('../../../../../../../app/cloud/server/functions/syncWorkspace/syncCloudData.ts', {
+	'@rocket.chat/license': { DuplicatedLicenseError: sinon.stub() },
+	'@rocket.chat/models': models,
+	'../../../../../lib/callbacks': { callbacks: { run: sinon.stub() } },
+	'../../../../../lib/errors/CloudWorkspaceAccessError': { CloudWorkspaceAccessError: sinon.stub() },
+	'../../../../../lib/errors/CloudWorkspaceRegistrationError': { CloudWorkspaceRegistrationError: sinon.stub() },
+	'../../../../../server/lib/logger/system': { SystemLogger: { info: sinon.stub(), error: sinon.stub() } },
+	'../buildRegistrationData': { buildWorkspaceRegistrationData: sinon.stub().resolves({}) },
+	'../getWorkspaceAccessToken': {
+		getWorkspaceAccessToken: sinon.stub().resolves('token'),
+		CloudWorkspaceAccessTokenEmptyError: sinon.stub(),
+	},
+	'../retrieveRegistrationStatus': { retrieveRegistrationStatus: sinon.stub().resolves({ workspaceRegistered: true }) },
+	'./fetchWorkspaceSyncPayload': { fetchWorkspaceSyncPayload: mockedFetchWorkspaceSyncPayload },
+});
+
+describe('SyncCloudData', () => {
+	beforeEach(() => {
+		models.Settings.updateValueById.reset();
+		mockedFetchWorkspaceSyncPayload.reset();
+	});
+
+	it('should save cloudSyncAnnouncement payload on Cloud_Sync_Announcement_Payload setting when present', async () => {
+		const workspaceSyncPayloadResponse = {
+			workspaceId: 'workspaceId',
+			publicKey: 'publicKey',
+			license: {},
+			removeLicense: false,
+			cloudSyncAnnouncement: {
+				viewId: 'subscription-announcement',
+				appId: 'cloud-announcements-core',
+				blocks: [
+					{
+						type: 'callout',
+						title: {
+							type: 'plain_text',
+							text: 'Workspace eligible for Starter Plan',
+						},
+						text: {
+							type: 'plain_text',
+							text: 'Get free access to premium capabilities for up to 50 users',
+						},
+						accessory: {
+							type: 'button',
+							text: {
+								type: 'plain_text',
+								text: 'Switch Plan',
+							},
+							actionId: 'callout-action',
+							appId: 'cloud-announcements-core',
+							blockId: 'section-button',
+						},
+					},
+				],
+			},
+		};
+
+		mockedFetchWorkspaceSyncPayload.resolves(workspaceSyncPayloadResponse);
+
+		await syncCloudData();
+
+		expect(mockedFetchWorkspaceSyncPayload.calledOnce).to.be.true;
+
+		expect(
+			models.Settings.updateValueById.calledOnceWith(
+				'Cloud_Sync_Announcement_Payload',
+				JSON.stringify(workspaceSyncPayloadResponse.cloudSyncAnnouncement),
+			),
+		).to.be.true;
+	});
+
+	it("Should save as 'null' the setting update if cloudSyncAnnouncement is not present", async () => {
+		const workspaceSyncPayloadResponse = {
+			workspaceId: 'workspaceId',
+			publicKey: 'publicKey',
+			license: {},
+			removeLicense: false,
+		};
+
+		mockedFetchWorkspaceSyncPayload.resolves(workspaceSyncPayloadResponse);
+
+		await syncCloudData();
+
+		expect(mockedFetchWorkspaceSyncPayload.calledOnce).to.be.true;
+
+		expect(models.Settings.updateValueById.calledOnce).to.be.true;
+
+		expect(models.Settings.updateValueById.calledWith('Cloud_Sync_Announcement_Payload', 'null')).to.be.true;
+	});
+});
diff --git a/packages/core-typings/src/cloud/CloudSyncAnnouncement.ts b/packages/core-typings/src/cloud/CloudSyncAnnouncement.ts
new file mode 100644
index 000000000000..96856538ff72
--- /dev/null
+++ b/packages/core-typings/src/cloud/CloudSyncAnnouncement.ts
@@ -0,0 +1,10 @@
+import type { CalloutBlock, ContextBlock, DividerBlock, ImageBlock, SectionBlock } from '@rocket.chat/ui-kit';
+
+type CloudSyncAnnouncementLayoutBlock = ContextBlock | DividerBlock | ImageBlock | SectionBlock | CalloutBlock;
+type CloudSyncAnnouncementLayout = CloudSyncAnnouncementLayoutBlock[];
+
+export interface ICloudSyncAnnouncement {
+	viewId: string;
+	appId: string;
+	blocks: CloudSyncAnnouncementLayout;
+}
diff --git a/packages/core-typings/src/cloud/WorkspaceSyncPayload.ts b/packages/core-typings/src/cloud/WorkspaceSyncPayload.ts
index 1a3e6c12cf5e..e8821e93ac13 100644
--- a/packages/core-typings/src/cloud/WorkspaceSyncPayload.ts
+++ b/packages/core-typings/src/cloud/WorkspaceSyncPayload.ts
@@ -49,6 +49,7 @@ export interface WorkspaceSyncResponse {
 	publicKey: string;
 	license: unknown;
 	removeLicense?: boolean;
+	cloudSyncAnnouncement: unknown;
 }
 
 export interface WorkspaceCommsRequestPayload {
diff --git a/packages/core-typings/src/cloud/index.ts b/packages/core-typings/src/cloud/index.ts
index 8232ffce267f..63efbd0bcf18 100644
--- a/packages/core-typings/src/cloud/index.ts
+++ b/packages/core-typings/src/cloud/index.ts
@@ -9,3 +9,4 @@ export {
 	WorkspaceCommsResponsePayload,
 	WorkspaceInteractionResponsePayload,
 } from './WorkspaceSyncPayload';
+export { ICloudSyncAnnouncement } from './CloudSyncAnnouncement';
diff --git a/packages/core-typings/src/license/LicenseInfo.ts b/packages/core-typings/src/license/LicenseInfo.ts
index 85e7c3fba506..855602283cd3 100644
--- a/packages/core-typings/src/license/LicenseInfo.ts
+++ b/packages/core-typings/src/license/LicenseInfo.ts
@@ -1,6 +1,7 @@
 import type { ILicenseTag } from './ILicenseTag';
 import type { ExternalModule, ILicenseV3, LicenseLimitKind } from './ILicenseV3';
 import type { LicenseModule } from './LicenseModule';
+import type { ICloudSyncAnnouncement } from '../cloud';
 
 export type LicenseInfo = {
 	license?: ILicenseV3;
@@ -10,4 +11,5 @@ export type LicenseInfo = {
 	limits: Record<LicenseLimitKind, { value?: number; max: number }>;
 	tags: ILicenseTag[];
 	trial: boolean;
+	cloudSyncAnnouncement?: ICloudSyncAnnouncement;
 };
diff --git a/packages/rest-typings/src/v1/licenses.ts b/packages/rest-typings/src/v1/licenses.ts
index 99ba936e3492..8240546ddc37 100644
--- a/packages/rest-typings/src/v1/licenses.ts
+++ b/packages/rest-typings/src/v1/licenses.ts
@@ -1,4 +1,4 @@
-import type { LicenseInfo } from '@rocket.chat/core-typings';
+import type { LicenseInfo, Cloud } from '@rocket.chat/core-typings';
 import Ajv from 'ajv';
 
 const ajv = new Ajv({
@@ -43,6 +43,7 @@ export type LicensesEndpoints = {
 	'/v1/licenses.info': {
 		GET: (params: licensesInfoProps) => {
 			license: LicenseInfo;
+			cloudSyncAnnouncement?: Cloud.ICloudSyncAnnouncement;
 		};
 	};
 	'/v1/licenses.add': {

From 037e692bee67d89fd7ceb9a89638591012f83bd8 Mon Sep 17 00:00:00 2001
From: Matheus Barbosa Silva
 <36537004+matheusbsilva137@users.noreply.github.com>
Date: Wed, 18 Dec 2024 08:41:01 -0300
Subject: [PATCH 3/3] fix: Old custom fields from migrated contacts are not
 ignored on update (#34139)

---
 .changeset/wet-chicken-scream.md              |   5 +
 .../server/lib/contacts/updateContact.ts      |  28 +++-
 .../lib/contacts/validateCustomFields.ts      |   8 +-
 .../tests/end-to-end/api/livechat/contacts.ts | 123 +++++++++++++++++-
 4 files changed, 150 insertions(+), 14 deletions(-)
 create mode 100644 .changeset/wet-chicken-scream.md

diff --git a/.changeset/wet-chicken-scream.md b/.changeset/wet-chicken-scream.md
new file mode 100644
index 000000000000..610be5e8cd44
--- /dev/null
+++ b/.changeset/wet-chicken-scream.md
@@ -0,0 +1,5 @@
+---
+"@rocket.chat/meteor": patch
+---
+
+Fixes contact update failing in case a custom field is removed from the workspace
diff --git a/apps/meteor/app/livechat/server/lib/contacts/updateContact.ts b/apps/meteor/app/livechat/server/lib/contacts/updateContact.ts
index 8ec929ae4b34..752bb62b301f 100644
--- a/apps/meteor/app/livechat/server/lib/contacts/updateContact.ts
+++ b/apps/meteor/app/livechat/server/lib/contacts/updateContact.ts
@@ -24,8 +24,8 @@ export type UpdateContactParams = {
 export async function updateContact(params: UpdateContactParams): Promise<ILivechatContact> {
 	const { contactId, name, emails, phones, customFields: receivedCustomFields, contactManager, channels, wipeConflicts } = params;
 
-	const contact = await LivechatContacts.findOneById<Pick<ILivechatContact, '_id' | 'name'>>(contactId, {
-		projection: { _id: 1, name: 1 },
+	const contact = await LivechatContacts.findOneById<Pick<ILivechatContact, '_id' | 'name' | 'customFields'>>(contactId, {
+		projection: { _id: 1, name: 1, customFields: 1 },
 	});
 
 	if (!contact) {
@@ -36,7 +36,27 @@ export async function updateContact(params: UpdateContactParams): Promise<ILivec
 		await validateContactManager(contactManager);
 	}
 
-	const customFields = receivedCustomFields && validateCustomFields(await getAllowedCustomFields(), receivedCustomFields);
+	const workspaceAllowedCustomFields = await getAllowedCustomFields();
+	const workspaceAllowedCustomFieldsIds = workspaceAllowedCustomFields.map((customField) => customField._id);
+	const currentCustomFieldsIds = Object.keys(contact.customFields || {});
+	const notRegisteredCustomFields = currentCustomFieldsIds
+		.filter((customFieldId) => !workspaceAllowedCustomFieldsIds.includes(customFieldId))
+		.map((customFieldId) => ({ _id: customFieldId }));
+
+	const customFieldsToUpdate =
+		receivedCustomFields &&
+		validateCustomFields(workspaceAllowedCustomFields, receivedCustomFields, {
+			ignoreAdditionalFields: !!notRegisteredCustomFields.length,
+		});
+
+	if (receivedCustomFields && customFieldsToUpdate && notRegisteredCustomFields.length) {
+		const allowedCustomFields = [...workspaceAllowedCustomFields, ...notRegisteredCustomFields];
+		validateCustomFields(allowedCustomFields, receivedCustomFields);
+
+		notRegisteredCustomFields.forEach((notRegisteredCustomField) => {
+			customFieldsToUpdate[notRegisteredCustomField._id] = contact.customFields?.[notRegisteredCustomField._id] as string;
+		});
+	}
 
 	const updatedContact = await LivechatContacts.updateContact(contactId, {
 		name,
@@ -44,7 +64,7 @@ export async function updateContact(params: UpdateContactParams): Promise<ILivec
 		phones: phones?.map((phoneNumber) => ({ phoneNumber })),
 		contactManager,
 		channels,
-		customFields,
+		customFields: customFieldsToUpdate,
 		...(wipeConflicts && { conflictingFields: [] }),
 	});
 
diff --git a/apps/meteor/app/livechat/server/lib/contacts/validateCustomFields.ts b/apps/meteor/app/livechat/server/lib/contacts/validateCustomFields.ts
index 4efede65b266..3ab981cf2513 100644
--- a/apps/meteor/app/livechat/server/lib/contacts/validateCustomFields.ts
+++ b/apps/meteor/app/livechat/server/lib/contacts/validateCustomFields.ts
@@ -4,7 +4,7 @@ import { trim } from '../../../../../lib/utils/stringUtils';
 import { i18n } from '../../../../utils/lib/i18n';
 
 export function validateCustomFields(
-	allowedCustomFields: AtLeast<ILivechatCustomField, '_id' | 'label' | 'regexp' | 'required'>[],
+	allowedCustomFields: AtLeast<ILivechatCustomField, '_id'>[],
 	customFields: Record<string, string | unknown>,
 	{
 		ignoreAdditionalFields = false,
@@ -16,7 +16,7 @@ export function validateCustomFields(
 	for (const cf of allowedCustomFields) {
 		if (!customFields.hasOwnProperty(cf._id)) {
 			if (cf.required && !ignoreValidationErrors) {
-				throw new Error(i18n.t('error-invalid-custom-field-value', { field: cf.label }));
+				throw new Error(i18n.t('error-invalid-custom-field-value', { field: cf.label || cf._id }));
 			}
 			continue;
 		}
@@ -24,7 +24,7 @@ export function validateCustomFields(
 
 		if (!cfValue || typeof cfValue !== 'string') {
 			if (cf.required && !ignoreValidationErrors) {
-				throw new Error(i18n.t('error-invalid-custom-field-value', { field: cf.label }));
+				throw new Error(i18n.t('error-invalid-custom-field-value', { field: cf.label || cf._id }));
 			}
 			continue;
 		}
@@ -36,7 +36,7 @@ export function validateCustomFields(
 					continue;
 				}
 
-				throw new Error(i18n.t('error-invalid-custom-field-value', { field: cf.label }));
+				throw new Error(i18n.t('error-invalid-custom-field-value', { field: cf.label || cf._id }));
 			}
 		}
 
diff --git a/apps/meteor/tests/end-to-end/api/livechat/contacts.ts b/apps/meteor/tests/end-to-end/api/livechat/contacts.ts
index daaffb1f9eb3..fc87d32fc5da 100644
--- a/apps/meteor/tests/end-to-end/api/livechat/contacts.ts
+++ b/apps/meteor/tests/end-to-end/api/livechat/contacts.ts
@@ -142,18 +142,37 @@ describe('LIVECHAT - contacts', () => {
 		});
 
 		describe('Custom Fields', () => {
+			let contactId: string;
 			before(async () => {
-				await createCustomField({
-					field: 'cf1',
-					label: 'Custom Field 1',
-					scope: 'visitor',
+				const defaultProps = {
+					scope: 'visitor' as const,
 					visibility: 'public',
 					type: 'input',
-					required: true,
 					regexp: '^[0-9]+$',
 					searchable: true,
 					public: true,
-				});
+				};
+
+				await Promise.all([
+					createCustomField({
+						...defaultProps,
+						field: 'cf1',
+						label: 'Custom Field 1',
+						required: true,
+					}),
+					createCustomField({
+						...defaultProps,
+						field: 'cf2',
+						label: 'Custom Field 2',
+						required: false,
+					}),
+					createCustomField({
+						...defaultProps,
+						field: 'cfOptional',
+						label: 'Optional Custom Field',
+						required: false,
+					}),
+				]);
 			});
 
 			after(async () => {
@@ -211,6 +230,98 @@ describe('LIVECHAT - contacts', () => {
 				expect(res.body).to.have.property('error');
 				expect(res.body.error).to.be.equal('Invalid value for Custom Field 1 field');
 			});
+
+			it('should keep a legacy custom field, but not update it, nor throw an error if it is specified on update', async () => {
+				const createRes = await request
+					.post(api('omnichannel/contacts'))
+					.set(credentials)
+					.send({
+						name: faker.person.fullName(),
+						emails: [faker.internet.email().toLowerCase()],
+						phones: [faker.phone.number()],
+						customFields: {
+							cf1: '123',
+							cf2: '456',
+						},
+					});
+				expect(createRes.body).to.have.property('success', true);
+				expect(createRes.body).to.have.property('contactId').that.is.a('string');
+				contactId = createRes.body.contactId;
+
+				await deleteCustomField('cf2');
+
+				const updateRes = await request
+					.post(api('omnichannel/contacts.update'))
+					.set(credentials)
+					.send({
+						contactId,
+						customFields: {
+							cf1: '456',
+							cf2: '789',
+						},
+					});
+				expect(updateRes.body).to.have.property('success', true);
+				expect(updateRes.body).to.have.property('contact').that.is.an('object');
+				expect(updateRes.body.contact).to.have.property('_id', contactId);
+				expect(updateRes.body.contact).to.have.property('customFields').that.is.an('object');
+				expect(updateRes.body.contact.customFields).to.have.property('cf1', '456');
+				expect(updateRes.body.contact.customFields).to.have.property('cf2', '456');
+			});
+
+			it('should keep a legacy custom field and not throw an error if it is not specified on update', async () => {
+				const updateRes = await request
+					.post(api('omnichannel/contacts.update'))
+					.set(credentials)
+					.send({
+						contactId,
+						customFields: {
+							cf1: '789',
+							cfOptional: '567',
+						},
+					});
+				expect(updateRes.body).to.have.property('success', true);
+				expect(updateRes.body).to.have.property('contact').that.is.an('object');
+				expect(updateRes.body.contact).to.have.property('_id', contactId);
+				expect(updateRes.body.contact).to.have.property('customFields').that.is.an('object');
+				expect(updateRes.body.contact.customFields).to.have.property('cf1', '789');
+				expect(updateRes.body.contact.customFields).to.have.property('cfOptional', '567');
+				expect(updateRes.body.contact.customFields).to.have.property('cf2', '456');
+			});
+
+			it('should keep a legacy custom field, but remove an optional registered custom field if it is not specified on update', async () => {
+				const updateRes = await request
+					.post(api('omnichannel/contacts.update'))
+					.set(credentials)
+					.send({
+						contactId,
+						customFields: {
+							cf1: '789',
+						},
+					});
+				expect(updateRes.body).to.have.property('success', true);
+				expect(updateRes.body).to.have.property('contact').that.is.an('object');
+				expect(updateRes.body.contact).to.have.property('_id', contactId);
+				expect(updateRes.body.contact).to.have.property('customFields').that.is.an('object');
+				expect(updateRes.body.contact.customFields).to.have.property('cf1', '789');
+				expect(updateRes.body.contact.customFields).to.have.property('cf2', '456');
+				expect(updateRes.body.contact.customFields).to.not.have.property('cfOptional');
+			});
+
+			it('should throw an error if trying to update a custom field that is not registered in the workspace and does not exist in the contact', async () => {
+				const updateRes = await request
+					.post(api('omnichannel/contacts.update'))
+					.set(credentials)
+					.send({
+						contactId,
+						customFields: {
+							cf1: '123',
+							cf3: 'invalid',
+						},
+					});
+				expect(updateRes.body).to.have.property('success', false);
+				expect(updateRes.body).to.have.property('error');
+				expect(updateRes.body.error).to.be.equal('Custom field cf3 is not allowed');
+			});
 		});
 
 		describe('Fields Validation', () => {