fix(app): gate one-Tab message focus behind an experiment (#2762)

fluxer_api/src/api/admin/controllers/InstanceConfigAdminController.ts

@@ -33,6 +33,7 @@ import {VoiceNoiseSuppressionConfigSchema} from '@fluxer/schema/src/domains/admi
 import {UserIdParam} from '@fluxer/schema/src/domains/common/CommonParamSchemas';
 import {ExperimentDeliveryConfigSchema} from '@fluxer/schema/src/domains/experiment/ExperimentSchemas';
 import {MessageHoverTrackingConfigSchema} from '@fluxer/schema/src/domains/experiment/MessageHoverTrackingSchemas';
+import {MessageKeyboardFocusConfigSchema} from '@fluxer/schema/src/domains/experiment/MessageKeyboardFocusSchemas';
 import type {InstanceBranding} from '@fluxer/schema/src/domains/instance/InstanceSchemas';
 import {SmtpEmailProvider} from '@pkgs/email/src/SmtpEmailProvider';
 import type {Context} from 'hono';
@@ -60,6 +61,7 @@ async function buildInstanceConfigResponse(): Promise<InstanceConfigResponse> {
 		voiceNoiseSuppression,
 		experimentDelivery,
 		messageHoverTracking,
+		messageKeyboardFocus,
 		registrationConfig,
 		registrationUrls,
 		pendingRegistrations,
@@ -69,6 +71,7 @@ async function buildInstanceConfigResponse(): Promise<InstanceConfigResponse> {
 		instanceConfigRepository.getVoiceNoiseSuppressionConfig(),
 		instanceConfigRepository.getExperimentDeliveryConfig(),
 		instanceConfigRepository.getMessageHoverTrackingConfig(),
+		instanceConfigRepository.getMessageKeyboardFocusConfig(),
 		instanceConfigRepository.getRegistrationConfig(),
 		instanceConfigRepository.getRegistrationUrlsForAdmin(),
 		instanceConfigRepository.getPendingRegistrations(),
@@ -101,6 +104,7 @@ async function buildInstanceConfigResponse(): Promise<InstanceConfigResponse> {
 		voice_noise_suppression: voiceNoiseSuppression,
 		experiment_delivery: experimentDelivery,
 		message_hover_tracking: messageHoverTracking,
+		message_keyboard_focus: messageKeyboardFocus,
 		registration: {
 			...registrationConfig,
 			urls: registrationUrls,
@@ -256,6 +260,18 @@ export function InstanceConfigAdminController(app: HonoApp) {
 					await instanceConfigRepository.setMessageHoverTrackingConfig(validated);
 				}
 			}
+			if (data.message_keyboard_focus) {
+				const patch = omitUndefinedFields(data.message_keyboard_focus);
+				if (Object.keys(patch).length > 0) {
+					const currentMessageKeyboardFocus = await instanceConfigRepository.getMessageKeyboardFocusConfig();
+					const validated = MessageKeyboardFocusConfigSchema.parse({
+						...currentMessageKeyboardFocus,
+						...patch,
+						config_version: currentMessageKeyboardFocus.config_version + 1,
+					});
+					await instanceConfigRepository.setMessageKeyboardFocusConfig(validated);
+				}
+			}
 			if (data.experiment_delivery) {
 				const currentExperimentDelivery = await instanceConfigRepository.getExperimentDeliveryConfig();
 				const validated = ExperimentDeliveryConfigSchema.parse({

fluxer_api/src/api/experiment/ExperimentController.ts

@@ -11,6 +11,7 @@ import {Headers as HttpHeaders} from '@fluxer/constants/src/Headers';
 import {resolveVoiceNoiseSuppressionAssignment} from '@fluxer/schema/src/domains/admin/VoiceNoiseSuppressionSchemas';
 import {ExperimentAssignmentsResponse} from '@fluxer/schema/src/domains/experiment/ExperimentSchemas';
 import {resolveMessageHoverTrackingAssignment} from '@fluxer/schema/src/domains/experiment/MessageHoverTrackingSchemas';
+import {resolveMessageKeyboardFocusAssignment} from '@fluxer/schema/src/domains/experiment/MessageKeyboardFocusSchemas';
 
 export function ExperimentController(app: HonoApp) {
 	app.get(
@@ -29,10 +30,11 @@ export function ExperimentController(app: HonoApp) {
 		}),
 		async (ctx) => {
 			const instanceConfigRepository = ctx.get('instanceConfigRepository');
-			const [delivery, voiceConfig, messageHoverTrackingConfig] = await Promise.all([
+			const [delivery, voiceConfig, messageHoverTrackingConfig, messageKeyboardFocusConfig] = await Promise.all([
 				instanceConfigRepository.getExperimentDeliveryConfig(),
 				instanceConfigRepository.getVoiceNoiseSuppressionConfig(),
 				instanceConfigRepository.getMessageHoverTrackingConfig(),
+				instanceConfigRepository.getMessageKeyboardFocusConfig(),
 			]);
 			const userId = ctx.get('user').id.toString();
 			const body: ExperimentAssignmentsResponse = {
@@ -41,6 +43,7 @@ export function ExperimentController(app: HonoApp) {
 				assignments: {
 					voice_noise_suppression: resolveVoiceNoiseSuppressionAssignment(voiceConfig, userId),
 					message_hover_tracking: resolveMessageHoverTrackingAssignment(messageHoverTrackingConfig, userId),
+					message_keyboard_focus: resolveMessageKeyboardFocusAssignment(messageKeyboardFocusConfig, userId),
 				},
 			};
 			const etag = `"${createHash('sha256').update(JSON.stringify(body)).digest('hex')}"`;

fluxer_api/src/api/experiment/tests/ExperimentController.test.ts

@@ -16,12 +16,17 @@ import {
 	type ExperimentAssignmentsResponse,
 	type ExperimentDeliveryConfigResponse,
 	readMessageHoverTrackingAssignment,
+	readMessageKeyboardFocusAssignment,
 	readVoiceNoiseSuppressionAssignment,
 } from '@fluxer/schema/src/domains/experiment/ExperimentSchemas';
 import {
 	DEFAULT_MESSAGE_HOVER_TRACKING_CONFIG,
 	INERT_MESSAGE_HOVER_TRACKING_ASSIGNMENT,
 } from '@fluxer/schema/src/domains/experiment/MessageHoverTrackingSchemas';
+import {
+	DEFAULT_MESSAGE_KEYBOARD_FOCUS_CONFIG,
+	INERT_MESSAGE_KEYBOARD_FOCUS_ASSIGNMENT,
+} from '@fluxer/schema/src/domains/experiment/MessageKeyboardFocusSchemas';
 import {afterAll, beforeAll, beforeEach, describe, expect, it} from 'vitest';
 
 const NOT_MODIFIED = 304;
@@ -57,6 +62,7 @@ describe('GET /experiments', () => {
 			assignments: {
 				voice_noise_suppression: INERT_VOICE_NOISE_SUPPRESSION_ASSIGNMENT,
 				message_hover_tracking: INERT_MESSAGE_HOVER_TRACKING_ASSIGNMENT,
+				message_keyboard_focus: INERT_MESSAGE_KEYBOARD_FOCUS_ASSIGNMENT,
 			},
 		});
 	});
@@ -134,17 +140,69 @@ describe('GET /experiments', () => {
 		});
 	});
 
-	it('resolves the two experiments independently', async () => {
+	it('populates the message keyboard focus key even when the rollout is disabled', async () => {
+		const account = await createTestAccount(harness);
+
+		const body = await createBuilder<ExperimentAssignmentsResponse>(harness, account.token).get(ENDPOINT).execute();
+
+		expect(Object.hasOwn(body.assignments, 'message_keyboard_focus')).toBe(true);
+		expect(readMessageKeyboardFocusAssignment(body)).toEqual(INERT_MESSAGE_KEYBOARD_FOCUS_ASSIGNMENT);
+	});
+
+	it('targets an allowlisted account for message keyboard focus', async () => {
+		const account = await createTestAccount(harness);
+		await getInstanceConfigRepository().setMessageKeyboardFocusConfig({
+			...DEFAULT_MESSAGE_KEYBOARD_FOCUS_CONFIG,
+			enabled: true,
+			config_version: 4,
+			included_user_ids: [account.userId],
+		});
+
+		const body = await createBuilder<ExperimentAssignmentsResponse>(harness, account.token).get(ENDPOINT).execute();
+
+		expect(readMessageKeyboardFocusAssignment(body)).toEqual({
+			enabled: true,
+			config_version: 4,
+			user_targeted: true,
+			source: 'user_rule',
+		});
+	});
+
+	it('leaves an account outside a zero-width message keyboard focus rollout', async () => {
+		const account = await createTestAccount(harness);
+		await getInstanceConfigRepository().setMessageKeyboardFocusConfig({
+			...DEFAULT_MESSAGE_KEYBOARD_FOCUS_CONFIG,
+			enabled: true,
+			config_version: 2,
+		});
+
+		const body = await createBuilder<ExperimentAssignmentsResponse>(harness, account.token).get(ENDPOINT).execute();
+
+		expect(readMessageKeyboardFocusAssignment(body)).toEqual({
+			enabled: true,
+			config_version: 2,
+			user_targeted: false,
+			source: null,
+		});
+	});
+
+	it('resolves all three experiments independently', async () => {
 		const account = await createTestAccount(harness);
 		await getInstanceConfigRepository().setMessageHoverTrackingConfig({
 			...DEFAULT_MESSAGE_HOVER_TRACKING_CONFIG,
 			enabled: true,
 			rollout_basis_points: 10000,
 		});
+		await getInstanceConfigRepository().setMessageKeyboardFocusConfig({
+			...DEFAULT_MESSAGE_KEYBOARD_FOCUS_CONFIG,
+			enabled: true,
+			rollout_basis_points: 10000,
+		});
 
 		const body = await createBuilder<ExperimentAssignmentsResponse>(harness, account.token).get(ENDPOINT).execute();
 
 		expect(readMessageHoverTrackingAssignment(body).user_targeted).toBe(true);
+		expect(readMessageKeyboardFocusAssignment(body).user_targeted).toBe(true);
 		expect(readVoiceNoiseSuppressionAssignment(body).enabled).toBe(false);
 	});
 

fluxer_api/src/api/instance/InstanceConfigRepository.test.ts

@@ -21,10 +21,15 @@ import {
 	DEFAULT_MESSAGE_HOVER_TRACKING_CONFIG,
 	type MessageHoverTrackingConfig,
 } from '@fluxer/schema/src/domains/experiment/MessageHoverTrackingSchemas';
+import {
+	DEFAULT_MESSAGE_KEYBOARD_FOCUS_CONFIG,
+	type MessageKeyboardFocusConfig,
+} from '@fluxer/schema/src/domains/experiment/MessageKeyboardFocusSchemas';
 import {afterEach, describe, expect, it, vi} from 'vitest';
 
 const VOICE_NOISE_SUPPRESSION_CONFIG_KEY = 'voice_noise_suppression_config';
 const MESSAGE_HOVER_TRACKING_CONFIG_KEY = 'message_hover_tracking_config';
+const MESSAGE_KEYBOARD_FOCUS_CONFIG_KEY = 'message_keyboard_focus_config';
 const EXPERIMENT_DELIVERY_CONFIG_KEY = 'experiment_delivery_config';
 const APP_PUBLIC_CONFIG_KEY = 'app_public_config';
 const INSTANCE_POLICY_CONFIG_KEY = 'instance_policy_config';
@@ -362,6 +367,51 @@ describe('InstanceConfigRepository', () => {
 		await expect(repository.getMessageHoverTrackingConfig()).resolves.toEqual(config);
 	});
 
+	it('returns the default message keyboard focus config when the key is absent', async () => {
+		const executor = new CountingInMemoryCassandraQueryExecutor();
+		setCassandraQueryExecutorForTesting(executor);
+		const kvProvider = new MockKVProvider();
+		const repository = createRepository(kvProvider);
+
+		await expect(repository.getMessageKeyboardFocusConfig()).resolves.toEqual(DEFAULT_MESSAGE_KEYBOARD_FOCUS_CONFIG);
+	});
+
+	it.each([
+		{name: 'unparseable text', stored: 'not-json'},
+		{name: 'a json array', stored: '[]'},
+		{name: 'out-of-range values', stored: '{"rollout_basis_points":99999}'},
+		{name: 'a target that is not a snowflake', stored: '{"included_user_ids":["nope"]}'},
+	])('falls back to the default message keyboard focus config for $name', async ({stored}) => {
+		const executor = new CountingInMemoryCassandraQueryExecutor();
+		setCassandraQueryExecutorForTesting(executor);
+		const kvProvider = new MockKVProvider();
+		const repository = createRepository(kvProvider);
+
+		await repository.setConfig(MESSAGE_KEYBOARD_FOCUS_CONFIG_KEY, stored);
+
+		await expect(repository.getMessageKeyboardFocusConfig()).resolves.toEqual(DEFAULT_MESSAGE_KEYBOARD_FOCUS_CONFIG);
+	});
+
+	it('round-trips a stored message keyboard focus config', async () => {
+		const executor = new CountingInMemoryCassandraQueryExecutor();
+		setCassandraQueryExecutorForTesting(executor);
+		const kvProvider = new MockKVProvider();
+		const repository = createRepository(kvProvider);
+
+		const config: MessageKeyboardFocusConfig = {
+			...DEFAULT_MESSAGE_KEYBOARD_FOCUS_CONFIG,
+			enabled: true,
+			config_version: 5,
+			rollout_basis_points: 2500,
+			rollout_salt: 'message-keyboard-focus-v2',
+			included_user_ids: ['1400000000000000001'],
+			excluded_user_ids: ['1400000000000000002'],
+		};
+		await repository.setMessageKeyboardFocusConfig(config);
+
+		await expect(repository.getMessageKeyboardFocusConfig()).resolves.toEqual(config);
+	});
+
 	it('fills newly added voice noise suppression fields from the schema defaults', async () => {
 		const executor = new CountingInMemoryCassandraQueryExecutor();
 		setCassandraQueryExecutorForTesting(executor);

fluxer_api/src/api/instance/InstanceConfigRepository.ts

@@ -40,6 +40,10 @@ import {
 	type MessageHoverTrackingConfig,
 	MessageHoverTrackingConfigSchema,
 } from '@fluxer/schema/src/domains/experiment/MessageHoverTrackingSchemas';
+import {
+	type MessageKeyboardFocusConfig,
+	MessageKeyboardFocusConfigSchema,
+} from '@fluxer/schema/src/domains/experiment/MessageKeyboardFocusSchemas';
 import {
 	type InstanceAppPublic,
 	InstanceAppPublicSchema,
@@ -60,6 +64,7 @@ const GATEWAY_ROLLOUT_CONFIG_KEY = 'gateway_rollout_config';
 const VOICE_NOISE_SUPPRESSION_CONFIG_KEY = 'voice_noise_suppression_config';
 const EXPERIMENT_DELIVERY_CONFIG_KEY = 'experiment_delivery_config';
 const MESSAGE_HOVER_TRACKING_CONFIG_KEY = 'message_hover_tracking_config';
+const MESSAGE_KEYBOARD_FOCUS_CONFIG_KEY = 'message_keyboard_focus_config';
 const REGISTRATION_CONFIG_KEY = 'registration_config';
 const REGISTRATION_URLS_KEY = 'registration_urls';
 const REGISTRATION_PENDING_APPROVALS_KEY = 'registration_pending_approvals';
@@ -344,6 +349,7 @@ type StoredConfigSection =
 	| 'voice noise suppression'
 	| 'experiment delivery'
 	| 'message hover tracking'
+	| 'message keyboard focus'
 	| 'instance policy'
 	| 'integrations'
 	| 'media'
@@ -489,6 +495,10 @@ function parseStoredMessageHoverTrackingConfig(raw: string | null): MessageHover
 	return parseStoredConfigOrDefault(MessageHoverTrackingConfigSchema, raw, 'message hover tracking');
 }
 
+function parseStoredMessageKeyboardFocusConfig(raw: string | null): MessageKeyboardFocusConfig {
+	return parseStoredConfigOrDefault(MessageKeyboardFocusConfigSchema, raw, 'message keyboard focus');
+}
+
 function validateStoredCollection<T>(schema: z.ZodType<T>, value: unknown, section: StoredConfigSection): Array<T> {
 	if (!Array.isArray(value)) {
 		throw new Error(`Stored ${section} configuration must be an array`);
@@ -1009,6 +1019,7 @@ export class InstanceConfigRepository {
 		parseStoredVoiceNoiseSuppressionConfig(snapshot.get(VOICE_NOISE_SUPPRESSION_CONFIG_KEY) ?? null);
 		parseStoredExperimentDeliveryConfig(snapshot.get(EXPERIMENT_DELIVERY_CONFIG_KEY) ?? null);
 		parseStoredMessageHoverTrackingConfig(snapshot.get(MESSAGE_HOVER_TRACKING_CONFIG_KEY) ?? null);
+		parseStoredMessageKeyboardFocusConfig(snapshot.get(MESSAGE_KEYBOARD_FOCUS_CONFIG_KEY) ?? null);
 		const policy = parseStoredInstancePolicyConfig(snapshot.get(INSTANCE_POLICY_CONFIG_KEY) ?? null);
 		checkStoredConfig('registration', () =>
 			parseStoredRegistrationConfig(snapshot.get(REGISTRATION_CONFIG_KEY) ?? null),
@@ -1104,6 +1115,16 @@ export class InstanceConfigRepository {
 		await this.setConfig(MESSAGE_HOVER_TRACKING_CONFIG_KEY, JSON.stringify(validated));
 	}
 
+	async getMessageKeyboardFocusConfig(): Promise<MessageKeyboardFocusConfig> {
+		const raw = await this.getConfig(MESSAGE_KEYBOARD_FOCUS_CONFIG_KEY);
+		return parseStoredMessageKeyboardFocusConfig(raw);
+	}
+
+	async setMessageKeyboardFocusConfig(config: MessageKeyboardFocusConfig): Promise<void> {
+		const validated = validateStoredConfig(MessageKeyboardFocusConfigSchema, config, 'message keyboard focus');
+		await this.setConfig(MESSAGE_KEYBOARD_FOCUS_CONFIG_KEY, JSON.stringify(validated));
+	}
+
 	async setExperimentDeliveryConfig(config: ExperimentDeliveryConfig): Promise<void> {
 		const validated = validateStoredConfig(ExperimentDeliveryConfigSchema, config, 'experiment delivery');
 		await this.setConfig(EXPERIMENT_DELIVERY_CONFIG_KEY, JSON.stringify(validated));

fluxer_api/src/api/openapi/openapi.json

@@ -28259,7 +28259,8 @@
 						"type": "object",
 						"properties": {
 							"voice_noise_suppression": {"$ref": "#/components/schemas/VoiceNoiseSuppressionAssignmentResponse"},
-							"message_hover_tracking": {"$ref": "#/components/schemas/MessageHoverTrackingAssignmentResponse"}
+							"message_hover_tracking": {"$ref": "#/components/schemas/MessageHoverTrackingAssignmentResponse"},
+							"message_keyboard_focus": {"$ref": "#/components/schemas/MessageKeyboardFocusAssignmentResponse"}
 						},
 						"additionalProperties": false
 					}
@@ -31997,6 +31998,17 @@
 				"additionalProperties": false
 			},
 			"DonationCurrency": {"type": "string", "enum": ["usd", "eur", "brl", "inr", "pln", "try"]},
+			"MessageKeyboardFocusAssignmentResponse": {
+				"type": "object",
+				"properties": {
+					"enabled": {"type": "boolean"},
+					"config_version": {"type": "integer", "minimum": -9007199254740991, "maximum": 9007199254740991},
+					"user_targeted": {"type": "boolean"},
+					"source": {"anyOf": [{"type": "string", "enum": ["user_rule", "canary"]}, {"type": "null"}]}
+				},
+				"required": ["enabled", "config_version", "user_targeted", "source"],
+				"additionalProperties": false
+			},
 			"MessageHoverTrackingAssignmentResponse": {
 				"type": "object",
 				"properties": {