A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
feat(push): gate relay delivery on operator consent (#2984)
Hampus01f53a168d7b
diff --git a/fluxer_admin/openapi-admin.json b/fluxer_admin/openapi-admin.jsonindex cd2a92ff3..3fa13a51d 100644--- a/fluxer_admin/openapi-admin.json+++ b/fluxer_admin/openapi-admin.json@@ -15225,7 +15225,8 @@"maxItems": 1000,"type": "array","items": {"type": "string", "pattern": "^\\d{1,20}$"}- }+ },+ "relay_consent_accepted": {"type": "boolean"}}},"VoiceNoiseSuppressionConfigUpdateRequest": {@@ -15357,7 +15358,16 @@"maxItems": 1000,"type": "array","items": {"type": "string", "pattern": "^\\d{1,20}$"}- }+ },+ "relay_consent_accepted": {"default": false, "type": "boolean"},+ "relay_consent_accepted_at": {+ "default": null,+ "nullable": true,+ "type": "string",+ "format": "date-time",+ "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:\\.\\d+)?(?:Z))$"+ },+ "relay_consent_accepted_by": {"default": null, "nullable": true, "type": "string", "pattern": "^\\d{1,20}$"}},"required": ["enabled",@@ -15365,7 +15375,10 @@"rollout_basis_points","rollout_salt","included_user_ids",- "excluded_user_ids"+ "excluded_user_ids",+ "relay_consent_accepted",+ "relay_consent_accepted_at",+ "relay_consent_accepted_by"],"additionalProperties": false},diff --git a/fluxer_admin/src/api/types/instance_config.rs b/fluxer_admin/src/api/types/instance_config.rsindex f7da80b66..f62487814 100644--- a/fluxer_admin/src/api/types/instance_config.rs+++ b/fluxer_admin/src/api/types/instance_config.rs@@ -552,6 +552,9 @@ pub struct PushServiceDeliveryConfigResponse {pub rollout_salt: String,pub included_user_ids: Vec<String>,pub excluded_user_ids: Vec<String>,+ pub relay_consent_accepted: bool,+ pub relay_consent_accepted_at: Option<String>,+ pub relay_consent_accepted_by: Option<String>,}impl Default for PushServiceDeliveryConfigResponse {@@ -563,6 +566,9 @@ impl Default for PushServiceDeliveryConfigResponse {rollout_salt: PUSH_SERVICE_DELIVERY_DEFAULT_SALT.to_owned(),included_user_ids: Vec::new(),excluded_user_ids: Vec::new(),+ relay_consent_accepted: false,+ relay_consent_accepted_at: None,+ relay_consent_accepted_by: None,}}}@@ -579,6 +585,8 @@ pub struct PushServiceDeliveryConfigUpdateRequest {pub included_user_ids: Option<Vec<String>>,#[serde(skip_serializing_if = "Option::is_none")]pub excluded_user_ids: Option<Vec<String>>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub relay_consent_accepted: Option<bool>,}#[derive(Clone, Debug, Deserialize, Serialize)]diff --git a/fluxer_admin/src/routes/system_actions.rs b/fluxer_admin/src/routes/system_actions.rsindex 1270dcab6..95b102ee7 100644--- a/fluxer_admin/src/routes/system_actions.rs+++ b/fluxer_admin/src/routes/system_actions.rs@@ -680,6 +680,9 @@ fn build_push_service_delivery_update(.unwrap_or_default(),"Excluded user IDs",)?),+ relay_consent_accepted: Some(+ form.bool_value("push_service_delivery_relay_consent_accepted"),+ ),}),..Default::default()})@@ -1731,6 +1734,30 @@ mod tests {}}+ #[test]+ fn build_push_service_delivery_update_reads_the_relay_consent_checkbox() {+ let unchecked = MultiValueForm::parse(b"_csrf=token");+ assert_eq!(+ build_push_service_delivery_update(&unchecked)+ .expect("valid form")+ .push_service_delivery+ .expect("push service delivery update")+ .relay_consent_accepted,+ Some(false)+ );++ let checked =+ MultiValueForm::parse(b"_csrf=token&push_service_delivery_relay_consent_accepted=true");+ assert_eq!(+ build_push_service_delivery_update(&checked)+ .expect("valid form")+ .push_service_delivery+ .expect("push service delivery update")+ .relay_consent_accepted,+ Some(true)+ );+ }+#[test]fn build_experiment_delivery_update_leaves_both_fields_unchanged_when_absent() {let form = MultiValueForm::parse(b"_csrf=token");diff --git a/fluxer_admin/src/templates/pages/instance_config.rs b/fluxer_admin/src/templates/pages/instance_config.rsindex c182d414c..eec16e183 100644--- a/fluxer_admin/src/templates/pages/instance_config.rs+++ b/fluxer_admin/src/templates/pages/instance_config.rs@@ -1191,6 +1191,14 @@ fn push_service_delivery_section(};let included_user_ids = push_service_delivery.included_user_ids.join("\n");let excluded_user_ids = push_service_delivery.excluded_user_ids.join("\n");+ let relay_consent_stamp = match (+ push_service_delivery.relay_consent_accepted_at.as_deref(),+ push_service_delivery.relay_consent_accepted_by.as_deref(),+ ) {+ (Some(at), Some(by)) => Some(format!("Accepted {at} by user {by}")),+ (Some(at), None) => Some(format!("Accepted {at}")),+ _ => None,+ };section_card_with_description("Push Service Delivery","Routes push notification delivery for the selected accounts through the push service. \@@ -1219,6 +1227,28 @@ fn push_service_delivery_section(effect at all."}+ h3 class="text-sm font-semibold text-neutral-900" { "Managed relay consent" }+ (checkbox(+ "push_service_delivery_relay_consent_accepted",+ "true",+ "Accept the push relay supplemental privacy notice",+ push_service_delivery.relay_consent_accepted,+ true,+ ))+ p class="text-xs text-neutral-500" {+ "Required only for the official mobile apps, whose notifications travel \+ through Fluxer's relay to Apple and Google. Until this is accepted those \+ notifications are dropped. Self-hosted UnifiedPush and ntfy endpoints \+ never reach the relay and are unaffected. "+ a href="https://fluxer.com/push-relay" target="_blank" rel="noreferrer"+ class="text-neutral-900 underline decoration-neutral-300 hover:text-neutral-600 hover:decoration-neutral-500" {+ "Read the notice"+ }+ }+ @if let Some(stamp) = relay_consent_stamp {+ p class="text-xs text-neutral-500" { (stamp) }+ }+h3 class="text-sm font-semibold text-neutral-900" { "Rollout" }(number_field("push_service_delivery_rollout_basis_points",@@ -2086,6 +2116,29 @@ mod tests {assert!(!markup.contains("at the cap"));}+ #[test]+ fn push_service_delivery_section_shows_the_relay_consent_toggle() {+ let accepted = PushServiceDeliveryConfigResponse {+ relay_consent_accepted: true,+ relay_consent_accepted_at: Some("2026-09-27T10:11:12.000Z".to_owned()),+ relay_consent_accepted_by: Some("1130650140672000000".to_owned()),+ ..PushServiceDeliveryConfigResponse::default()+ };+ let markup = push_service_delivery_section("/admin", "csrf", &accepted).into_string();+ assert!(markup.contains("name=\"push_service_delivery_relay_consent_accepted\""));+ assert!(markup.contains("https://fluxer.com/push-relay"));+ assert!(markup.contains("Accepted 2026-09-27T10:11:12.000Z by user 1130650140672000000"));++ let unaccepted = push_service_delivery_section(+ "/admin",+ "csrf",+ &PushServiceDeliveryConfigResponse::default(),+ )+ .into_string();+ assert!(unaccepted.contains("name=\"push_service_delivery_relay_consent_accepted\""));+ assert!(!unaccepted.contains("Accepted "));+ }+#[test]fn voice_noise_suppression_section_flags_a_list_at_its_cap() {let voice_noise_suppression = VoiceNoiseSuppressionConfigResponse {diff --git a/fluxer_admin/tests/api_deserialization.rs b/fluxer_admin/tests/api_deserialization.rsindex 7454f83dc..be3289052 100644--- a/fluxer_admin/tests/api_deserialization.rs+++ b/fluxer_admin/tests/api_deserialization.rs@@ -415,7 +415,10 @@ fn deserialize_instance_config_response_with_unknown_keys() {"rollout_basis_points": 5000,"rollout_salt": "push-service-delivery-v1","included_user_ids": ["1500000000000000002"],- "excluded_user_ids": []+ "excluded_user_ids": [],+ "relay_consent_accepted": true,+ "relay_consent_accepted_at": "2026-09-27T10:11:12.000Z",+ "relay_consent_accepted_by": "1130650140672000000"},"domain_migration": {"enabled": true,@@ -564,6 +567,7 @@ fn deserialize_instance_config_response_with_unknown_keys() {assert_eq!(resp.domain_migration.included_user_ids.len(), 1);assert_eq!(resp.domain_migration.anonymous_rollout_basis_points, 100);assert!(resp.domain_migration.standalone_forwarding);+ assert!(resp.push_service_delivery.relay_consent_accepted);assert_eq!(resp.experiment_delivery.poll_interval_seconds, 300);assert!(resp.policy.single_community_guild_id.is_none());assert_eq!(resp.policy.services.gif_enabled, Some(true));@@ -596,6 +600,71 @@ fn deserialize_instance_config_response_with_unknown_keys() {);}+#[test]+fn deserialize_push_service_delivery_relay_consent() {+ let accepted: types::PushServiceDeliveryConfigResponse = serde_json::from_str(+ r#"{+ "enabled": true,+ "config_version": 3,+ "rollout_basis_points": 5000,+ "rollout_salt": "push-service-delivery-v1",+ "included_user_ids": [],+ "excluded_user_ids": [],+ "relay_consent_accepted": true,+ "relay_consent_accepted_at": "2026-09-27T10:11:12.000Z",+ "relay_consent_accepted_by": "1130650140672000000"+ }"#,+ )+ .expect("an accepted relay consent must deserialize");++ assert!(accepted.relay_consent_accepted);+ assert_eq!(+ accepted.relay_consent_accepted_at.as_deref(),+ Some("2026-09-27T10:11:12.000Z")+ );+ assert_eq!(+ accepted.relay_consent_accepted_by.as_deref(),+ Some("1130650140672000000")+ );++ let legacy: types::PushServiceDeliveryConfigResponse = serde_json::from_str(+ r#"{+ "enabled": true,+ "config_version": 3,+ "rollout_basis_points": 5000,+ "rollout_salt": "push-service-delivery-v1",+ "included_user_ids": [],+ "excluded_user_ids": []+ }"#,+ )+ .expect("a response written before relay consent must still deserialize");++ assert!(!legacy.relay_consent_accepted);+ assert!(legacy.relay_consent_accepted_at.is_none());+ assert!(legacy.relay_consent_accepted_by.is_none());+}++#[test]+fn serialize_push_service_delivery_update_omits_an_unset_relay_consent() {+ let without = types::PushServiceDeliveryConfigUpdateRequest {+ enabled: Some(true),+ ..Default::default()+ };+ assert_eq!(+ serde_json::to_value(&without).unwrap(),+ serde_json::json!({"enabled": true})+ );++ let with = types::PushServiceDeliveryConfigUpdateRequest {+ relay_consent_accepted: Some(true),+ ..Default::default()+ };+ assert_eq!(+ serde_json::to_value(&with).unwrap(),+ serde_json::json!({"relay_consent_accepted": true})+ );+}+#[test]fn deserialize_search_reports_response() {let json = r#"{diff --git a/fluxer_api/src/api/admin/controllers/InstanceConfigAdminController.ts b/fluxer_api/src/api/admin/controllers/InstanceConfigAdminController.tsindex 6430e3ae3..7fdf50df0 100644--- a/fluxer_api/src/api/admin/controllers/InstanceConfigAdminController.ts+++ b/fluxer_api/src/api/admin/controllers/InstanceConfigAdminController.ts@@ -36,7 +36,11 @@ import {} from '@fluxer/schema/src/domains/admin/AdminSchemas';import {DomainMigrationConfigSchema} from '@fluxer/schema/src/domains/admin/DomainMigrationSchemas';import {GatewayRolloutConfigSchema} from '@fluxer/schema/src/domains/admin/GatewayRolloutSchemas';-import {PushServiceDeliveryConfigSchema} from '@fluxer/schema/src/domains/admin/PushServiceDeliverySchemas';+import {+ type PushServiceDeliveryConfig,+ PushServiceDeliveryConfigSchema,+ type PushServiceDeliveryConfigUpdateRequest,+} from '@fluxer/schema/src/domains/admin/PushServiceDeliverySchemas';import {VoiceNoiseSuppressionConfigSchema} from '@fluxer/schema/src/domains/admin/VoiceNoiseSuppressionSchemas';import {UserIdParam} from '@fluxer/schema/src/domains/common/CommonParamSchemas';import {ExperimentDeliveryConfigSchema} from '@fluxer/schema/src/domains/experiment/ExperimentSchemas';@@ -194,6 +198,20 @@ async function grantSetupCompleterAdminACL(ctx: Context<HonoEnv>): Promise<boolereturn true;}+function relayConsentStamp(+ current: PushServiceDeliveryConfig,+ patch: Partial<PushServiceDeliveryConfigUpdateRequest>,+ adminUserId: string,+): Partial<PushServiceDeliveryConfig> {+ const accepted = patch.relay_consent_accepted;+ if (accepted === undefined || accepted === current.relay_consent_accepted) {+ return {};+ }+ return accepted+ ? {relay_consent_accepted_at: new Date().toISOString(), relay_consent_accepted_by: adminUserId}+ : {relay_consent_accepted_at: null, relay_consent_accepted_by: null};+}+function listSuppliedSections(data: InstanceConfigUpdateRequest): string | undefined {const sections = Object.entries(data).filter(([, value]) => value != null)@@ -276,10 +294,12 @@ export function InstanceConfigAdminController(app: HonoApp) {if (data.push_service_delivery) {const patch = omitUndefinedFields(data.push_service_delivery);if (Object.keys(patch).length > 0) {+ const adminUserId = ctx.get('adminUserId').toString();const landed = await instanceConfigRepository.updatePushServiceDeliveryConfig((current) =>PushServiceDeliveryConfigSchema.parse({...current,...patch,+ ...relayConsentStamp(current, patch, adminUserId),config_version: current.config_version + 1,}),);diff --git a/fluxer_api/src/api/admin/tests/PushRelayConsentAdmin.test.ts b/fluxer_api/src/api/admin/tests/PushRelayConsentAdmin.test.tsnew file mode 100644index 000000000..9c3f942d8--- /dev/null+++ b/fluxer_api/src/api/admin/tests/PushRelayConsentAdmin.test.ts@@ -0,0 +1,132 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++import type {TestAccount} from '@app/api/auth/tests/AuthTestUtils';+import {createTestAccount, setUserACLs} from '@app/api/auth/tests/AuthTestUtils';+import {PushServiceDeliveryConfigPublisher} from '@app/api/instance/PushServiceDeliveryConfigPublisher';+import type {ApiTestHarness} from '@app/api/test/ApiTestHarness';+import {createApiTestHarness} from '@app/api/test/ApiTestHarness';+import {createBuilder} from '@app/api/test/TestRequestBuilder';+import {AdminACLs} from '@fluxer/constants/src/AdminACLs';+import type {InstanceConfigResponse} from '@fluxer/schema/src/domains/admin/AdminSchemas';+import {afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi} from 'vitest';++describe('push relay supplemental notice consent', () => {+ let harness: ApiTestHarness;++ beforeAll(async () => {+ harness = await createApiTestHarness();+ });++ beforeEach(async () => {+ await harness.reset();+ vi.spyOn(PushServiceDeliveryConfigPublisher.prototype, 'publish').mockResolvedValue(undefined);+ });++ afterEach(() => {+ vi.restoreAllMocks();+ });++ afterAll(async () => {+ await harness.shutdown();+ });++ const createAdmin = async (): Promise<TestAccount> =>+ await setUserACLs(harness, await createTestAccount(harness), [+ AdminACLs.AUTHENTICATE,+ AdminACLs.INSTANCE_CONFIG_VIEW,+ AdminACLs.INSTANCE_CONFIG_UPDATE,+ ]);++ const patchConfig = (admin: TestAccount, body: Record<string, unknown>) =>+ createBuilder<InstanceConfigResponse>(harness, admin.token).patch('/admin/instance/config').body(body);++ const readConfig = (admin: TestAccount) =>+ createBuilder<InstanceConfigResponse>(harness, admin.token).get('/admin/instance/config');++ it('reads back as unaccepted before an operator agrees', async () => {+ const admin = await createAdmin();++ const config = await readConfig(admin).execute();++ expect(config.push_service_delivery).toMatchObject({+ relay_consent_accepted: false,+ relay_consent_accepted_at: null,+ relay_consent_accepted_by: null,+ });+ });++ it('stamps the acting admin and the acceptance time when consent is given', async () => {+ const admin = await createAdmin();++ const updated = await patchConfig(admin, {push_service_delivery: {relay_consent_accepted: true}}).execute();++ expect(updated.push_service_delivery.relay_consent_accepted).toBe(true);+ expect(updated.push_service_delivery.relay_consent_accepted_by).toBe(admin.userId);+ expect(Date.parse(updated.push_service_delivery.relay_consent_accepted_at ?? '')).not.toBeNaN();+ });++ it('keeps the first acceptance stamp when a later patch changes only the rollout', async () => {+ const admin = await createAdmin();+ const accepted = await patchConfig(admin, {push_service_delivery: {relay_consent_accepted: true}}).execute();++ const rolledOut = await patchConfig(admin, {+ push_service_delivery: {enabled: true, rollout_basis_points: 2500},+ }).execute();++ expect(rolledOut.push_service_delivery).toMatchObject({+ enabled: true,+ rollout_basis_points: 2500,+ relay_consent_accepted: true,+ relay_consent_accepted_at: accepted.push_service_delivery.relay_consent_accepted_at,+ relay_consent_accepted_by: admin.userId,+ });+ });++ it('keeps the stamp untouched when consent is re-sent unchanged', async () => {+ const admin = await createAdmin();+ const accepted = await patchConfig(admin, {push_service_delivery: {relay_consent_accepted: true}}).execute();++ const resent = await patchConfig(admin, {push_service_delivery: {relay_consent_accepted: true}}).execute();++ expect(resent.push_service_delivery.relay_consent_accepted_at).toBe(+ accepted.push_service_delivery.relay_consent_accepted_at,+ );+ });++ it('clears the stamp when an operator withdraws consent', async () => {+ const admin = await createAdmin();+ await patchConfig(admin, {push_service_delivery: {relay_consent_accepted: true}}).execute();++ const withdrawn = await patchConfig(admin, {push_service_delivery: {relay_consent_accepted: false}}).execute();++ expect(withdrawn.push_service_delivery).toMatchObject({+ relay_consent_accepted: false,+ relay_consent_accepted_at: null,+ relay_consent_accepted_by: null,+ });+ });++ it('ignores an acceptance stamp supplied by the caller', async () => {+ const admin = await createAdmin();++ const updated = await patchConfig(admin, {+ push_service_delivery: {+ relay_consent_accepted: true,+ relay_consent_accepted_at: '2020-01-01T00:00:00.000Z',+ relay_consent_accepted_by: '1500000000000000009',+ },+ }).execute();++ expect(updated.push_service_delivery.relay_consent_accepted_at).not.toBe('2020-01-01T00:00:00.000Z');+ expect(updated.push_service_delivery.relay_consent_accepted_by).toBe(admin.userId);+ });++ it('publishes the consent to the delivery services', async () => {+ const admin = await createAdmin();+ const publish = vi.mocked(PushServiceDeliveryConfigPublisher.prototype.publish);++ await patchConfig(admin, {push_service_delivery: {relay_consent_accepted: true}}).execute();++ expect(publish).toHaveBeenCalledWith(expect.objectContaining({relay_consent_accepted: true}));+ });+});diff --git a/fluxer_app/src/features/app/components/setup/SelfHostedSetupWizardGate.module.css b/fluxer_app/src/features/app/components/setup/SelfHostedSetupWizardGate.module.cssindex 0bb5809d3..430028ab6 100644--- a/fluxer_app/src/features/app/components/setup/SelfHostedSetupWizardGate.module.css+++ b/fluxer_app/src/features/app/components/setup/SelfHostedSetupWizardGate.module.css@@ -233,6 +233,15 @@text-align: center;}+.noticeLink {+ align-self: flex-start;+ border-radius: 0.25rem;+ color: var(--text-link);+ font-size: 0.875rem;+ line-height: 1.45;+ text-decoration: underline;+}+.integrationFields {display: flex;flex-direction: column;diff --git a/fluxer_app/src/features/app/components/setup/SelfHostedSetupWizardGate.tsx b/fluxer_app/src/features/app/components/setup/SelfHostedSetupWizardGate.tsxindex b46612d65..55a52972a 100644--- a/fluxer_app/src/features/app/components/setup/SelfHostedSetupWizardGate.tsx+++ b/fluxer_app/src/features/app/components/setup/SelfHostedSetupWizardGate.tsx@@ -30,6 +30,7 @@ import {MediaExpiryStep,type PremiumMode,PremiumStep,+ PushRelayConsentStep,type RegistrationMode,RegistrationStep,type ServiceAvailability,@@ -459,6 +460,7 @@ export const SelfHostedSetupWizardGate = observer(() => {youtube: false,bluesky: false,});+ const [pushRelayConsentAccepted, setPushRelayConsentAccepted] = useState(false);const [premiumMode, setPremiumMode] = useState<PremiumMode>('mirror');const [assets, setAssets] = useState<ReadonlyArray<BrandingAssetState>>(() =>BRANDING_ASSET_KINDS.map((kind) => ({kind, url: null, preview: null})),@@ -549,6 +551,7 @@ export const SelfHostedSetupWizardGate = observer(() => {clearStepNavigationLock();setIntegrationDraft({...DEFAULT_INTEGRATION_DRAFT});setMediaExpiryDraft({...DEFAULT_MEDIA_EXPIRY_DRAFT});+ setPushRelayConsentAccepted(false);setSmtpTesting(false);setSmtpTestResult(null);try {@@ -569,6 +572,7 @@ export const SelfHostedSetupWizardGate = observer(() => {setSingleCommunityEnabled(next.policy.single_community_enabled);setDirectMessagesDisabled(next.policy.direct_messages_disabled);setPremiumMode(next.policy.premium_mode);+ setPushRelayConsentAccepted(next.push_service_delivery.relay_consent_accepted);setServiceSelection({gif: next.policy.services_resolved.gif_enabled,youtube: next.policy.services_resolved.youtube_enabled,@@ -677,6 +681,7 @@ export const SelfHostedSetupWizardGate = observer(() => {if (step === 'branding') return !productNameError;if (step === 'community') return !singleCommunityNameError;if (step === 'media_expiry') return isMediaExpiryStepValid(mediaExpiryDraft);+ if (step === 'push_relay_consent') return true;const integrationKind = wizardStepToIntegrationKind(step);if (integrationKind) return isIntegrationStepValid(integrationKind, integrationDraft);return true;@@ -766,6 +771,10 @@ export const SelfHostedSetupWizardGate = observer(() => {const nextConfig = await updateInstanceConfig({integrations: buildIntegrationsPatch(integrationDraft),media: buildMediaPatch(mediaExpiryDraft),+ push_service_delivery:+ config.push_service_delivery.relay_consent_accepted === pushRelayConsentAccepted+ ? undefined+ : {relay_consent_accepted: pushRelayConsentAccepted},registration: {mode: registrationMode},app_public: {branding: {@@ -804,6 +813,7 @@ export const SelfHostedSetupWizardGate = observer(() => {singleCommunityEnabled,singleCommunityNameTrimmed,directMessagesDisabled,+ pushRelayConsentAccepted,premiumMode,serviceAvailability,serviceSelection,@@ -972,6 +982,14 @@ export const SelfHostedSetupWizardGate = observer(() => {data-flx="app.setup.self-hosted-setup-wizard-gate.integration-step"/>)}+ {step === 'push_relay_consent' && (+ <PushRelayConsentStep+ accepted={pushRelayConsentAccepted}+ disabled={submitting}+ onChange={setPushRelayConsentAccepted}+ data-flx="app.setup.self-hosted-setup-wizard-gate.push-relay-consent-step"+ />+ )}{step === 'services' && (<ServicesStepavailable={serviceAvailability}@@ -996,6 +1014,7 @@ export const SelfHostedSetupWizardGate = observer(() => {singleCommunityEnabled={singleCommunityEnabled}directMessagesDisabled={directMessagesDisabled}attachmentExpiryEnabled={mediaExpiryDraft.enabled}+ pushRelayConsentAccepted={pushRelayConsentAccepted}premiumMode={premiumMode}submitError={submitError}data-flx="app.setup.self-hosted-setup-wizard-gate.finish-step"diff --git a/fluxer_app/src/features/app/components/setup/SetupWizardStateMachine.ts b/fluxer_app/src/features/app/components/setup/SetupWizardStateMachine.tsindex 61a7d13cd..999afe111 100644--- a/fluxer_app/src/features/app/components/setup/SetupWizardStateMachine.ts+++ b/fluxer_app/src/features/app/components/setup/SetupWizardStateMachine.ts@@ -17,6 +17,7 @@ export type WizardStep =| 'integration_captcha'| 'integration_email'| 'integration_bluesky'+ | 'push_relay_consent'| 'services'| 'premium'| 'finish';@@ -36,6 +37,7 @@ export const CONFIGURE_STEPS: ReadonlyArray<WizardStep> = ['integration_captcha','integration_email','integration_bluesky',+ 'push_relay_consent','services','premium','finish',diff --git a/fluxer_app/src/features/app/components/setup/SetupWizardSteps.tsx b/fluxer_app/src/features/app/components/setup/SetupWizardSteps.tsxindex 8519ac6fd..7142c1465 100644--- a/fluxer_app/src/features/app/components/setup/SetupWizardSteps.tsx+++ b/fluxer_app/src/features/app/components/setup/SetupWizardSteps.tsx@@ -13,6 +13,7 @@ import {ColorPickerField} from '@app/features/ui/components/form/ColorPickerFielimport {Input} from '@app/features/ui/components/form/FormInput';import {Switch} from '@app/features/ui/components/form/FormSwitch';import {Spinner} from '@app/features/ui/components/Spinner';+import FocusRing from '@app/features/ui/focus_ring/FocusRing';import {RadioGroup, type RadioOption} from '@app/features/ui/radio_group/RadioGroup';import {ThemeSelector} from '@app/features/user/components/modals/tabs/appearance_tab/theme/ThemeTabContent';import {LanguageSelector} from '@app/features/user/components/modals/tabs/LanguageTab';@@ -27,6 +28,8 @@ import {observer} from 'mobx-react-lite';import type React from 'react';import {useCallback, useEffect, useLayoutEffect, useRef, useState} from 'react';+const PUSH_RELAY_NOTICE_URL = 'https://fluxer.com/push-relay';+export type RegistrationMode = 'open' | 'approval' | 'closed';export type PremiumMode = 'mirror' | 'everyone';@@ -263,6 +266,29 @@ const MEDIA_RENEW_WINDOW_LABEL_DESCRIPTOR = msg({comment: 'Label for attachment decay renewal window.',});+const PUSH_RELAY_TITLE_DESCRIPTOR = msg({+ message: 'Mobile push notifications',+ comment: 'Setup wizard push relay consent step title.',+});+const PUSH_RELAY_BODY_DESCRIPTOR = msg({+ message:+ "The official Fluxer mobile apps receive notifications through Fluxer's push relay, which hands them to Apple and Google. Self-hosted UnifiedPush and ntfy endpoints never reach the relay and need no agreement.",+ comment: 'Setup wizard push relay consent step body.',+});+const PUSH_RELAY_ACCEPT_LABEL_DESCRIPTOR = msg({+ message: 'Accept the push relay supplemental privacy notice',+ comment: 'Label for the push relay consent switch during setup.',+});+const PUSH_RELAY_ACCEPT_DESC_DESCRIPTOR = msg({+ message:+ 'Leaving this off keeps the relay unused and drops notifications to the official mobile apps. You can accept it later in the admin panel.',+ comment: 'Description for the push relay consent switch during setup.',+});+const PUSH_RELAY_NOTICE_LINK_DESCRIPTOR = msg({+ message: 'Read the supplemental privacy notice',+ comment: 'Link to the push relay supplemental privacy notice shown during setup.',+});+const SERVICES_TITLE_DESCRIPTOR = msg({message: 'Optional services',comment: 'Setup wizard optional services step title.',@@ -353,10 +379,22 @@ const SUMMARY_ATTACHMENT_EXPIRY_DESCRIPTOR = msg({message: 'Attachment expiration',comment: 'Summary row label for the attachment expiry choice in the setup wizard.',});+const SUMMARY_PUSH_RELAY_DESCRIPTOR = msg({+ message: 'Push relay notice',+ comment: 'Summary row label for the push relay consent on the setup wizard finish step.',+});const SUMMARY_PREMIUM_DESCRIPTOR = msg({message: 'Premium model',comment: 'Summary row label for the premium model in the setup wizard.',});+const SUMMARY_ACCEPTED_DESCRIPTOR = msg({+ message: 'Accepted',+ comment: 'Summary value when the operator accepted the push relay notice.',+});+const SUMMARY_NOT_ACCEPTED_DESCRIPTOR = msg({+ message: 'Not accepted',+ comment: 'Summary value when the operator left the push relay notice unaccepted.',+});const SUMMARY_ON_DESCRIPTOR = msg({message: 'Enabled',comment: 'Summary value when a setup option is enabled.',@@ -1531,6 +1569,40 @@ export const IntegrationStep = observer(},);+export const PushRelayConsentStep = observer(+ ({accepted, disabled, onChange}: {accepted: boolean; disabled: boolean; onChange: (value: boolean) => void}) => {+ const {i18n} = useLingui();+ return (+ <section className={styles.step} data-flx="app.self-hosted-setup-wizard-gate.push-relay-consent-step">+ <StepHeader+ title={i18n._(PUSH_RELAY_TITLE_DESCRIPTOR)}+ body={i18n._(PUSH_RELAY_BODY_DESCRIPTOR)}+ data-flx="app.setup.setup-wizard-steps.push-relay-consent-step.step-header"+ />+ <Switch+ label={i18n._(PUSH_RELAY_ACCEPT_LABEL_DESCRIPTOR)}+ description={i18n._(PUSH_RELAY_ACCEPT_DESC_DESCRIPTOR)}+ value={accepted}+ onChange={onChange}+ disabled={disabled}+ data-flx="app.self-hosted-setup-wizard-gate.push-relay-consent-switch"+ />+ <FocusRing data-flx="app.setup.setup-wizard-steps.push-relay-consent-step.focus-ring">+ <a+ className={styles.noticeLink}+ href={PUSH_RELAY_NOTICE_URL}+ target="_blank"+ rel="noreferrer"+ data-flx="app.self-hosted-setup-wizard-gate.push-relay-notice-link"+ >+ {i18n._(PUSH_RELAY_NOTICE_LINK_DESCRIPTOR)}+ </a>+ </FocusRing>+ </section>+ );+ },+);+export const ServicesStep = observer(({available,@@ -1650,6 +1722,7 @@ export const FinishStep = observer(singleCommunityEnabled,directMessagesDisabled,attachmentExpiryEnabled,+ pushRelayConsentAccepted,premiumMode,submitError,}: {@@ -1658,6 +1731,7 @@ export const FinishStep = observer(singleCommunityEnabled: boolean;directMessagesDisabled: boolean;attachmentExpiryEnabled: boolean;+ pushRelayConsentAccepted: boolean;premiumMode: PremiumMode;submitError: string | null;}) => {@@ -1705,10 +1779,17 @@ export const FinishStep = observer(value={attachmentExpiryEnabled ? onLabel : offLabel}data-flx="app.setup.setup-wizard-steps.finish-step.summary-row--5"/>+ <SummaryRow+ label={i18n._(SUMMARY_PUSH_RELAY_DESCRIPTOR)}+ value={+ pushRelayConsentAccepted ? i18n._(SUMMARY_ACCEPTED_DESCRIPTOR) : i18n._(SUMMARY_NOT_ACCEPTED_DESCRIPTOR)+ }+ data-flx="app.setup.setup-wizard-steps.finish-step.summary-row--6"+ /><SummaryRowlabel={i18n._(SUMMARY_PREMIUM_DESCRIPTOR)}value={premiumLabel}- data-flx="app.setup.setup-wizard-steps.finish-step.summary-row--6"+ data-flx="app.setup.setup-wizard-steps.finish-step.summary-row--7"/></div>{submitError && (diff --git a/fluxer_docs/scripts/VerifyDocsStyle.ts b/fluxer_docs/scripts/VerifyDocsStyle.tsindex c0e41dfd9..9acb28239 100644--- a/fluxer_docs/scripts/VerifyDocsStyle.ts+++ b/fluxer_docs/scripts/VerifyDocsStyle.ts@@ -271,7 +271,7 @@ const ACCEPTED_TABLE_FINDINGS = new Map<string, Readonly<Partial<Record<TableRul['admin-api/discovery.mdx', {'table-identifier': 1}],['admin-api/guilds.mdx', {'table-identifier': 3}],['admin-api/index.mdx', {'table-fit': 1, 'table-identifier': 3}],- ['admin-api/instance.mdx', {'table-fit': 1, 'table-identifier': 6}],+ ['admin-api/instance.mdx', {'table-fit': 1, 'table-identifier': 7}],['admin-api/messages.mdx', {'table-identifier': 1}],['admin-api/reports.mdx', {'table-fit': 1, 'table-identifier': 2}],['admin-api/users.mdx', {'table-fit': 1, 'table-identifier': 1}],diff --git a/fluxer_docs/src/content/docs/admin-api/instance.mdx b/fluxer_docs/src/content/docs/admin-api/instance.mdxindex 3504dbb65..e69c59582 100644--- a/fluxer_docs/src/content/docs/admin-api/instance.mdx+++ b/fluxer_docs/src/content/docs/admin-api/instance.mdx@@ -136,9 +136,14 @@ The instance rollout of push service delivery.| rollout_salt | string | Salt of the sampling hash (1-64 printable ASCII characters, default `push-service-delivery-v1`) || included_user_ids | array[snowflake] | Accounts the rollout always selects, up to 1000 entries (default empty) || excluded_user_ids | array[snowflake] | Accounts the rollout never selects, up to 1000 entries (default empty) |+| relay_consent_accepted | boolean | Whether the operator accepted the push relay supplemental privacy notice (default false) |+| relay_consent_accepted_at | ?string | ISO 8601 timestamp of that acceptance, or null when the notice stands unaccepted (default null) |+| relay_consent_accepted_by | ?snowflake | Admin account that accepted the notice, or null when the notice stands unaccepted (default null) |Every field is present on read. An absent document or missing field uses the defaults above.+The notice covers only the Fluxer-run relay that reaches Apple and Google for the official mobile apps. A subscription whose endpoint points at another distributor, such as a self-hosted UnifiedPush server or ntfy, never reaches that relay and needs no acceptance.+## Domain migration configuration objectThe instance rollout that moves the official web client from its legacy origin to a new one. [Experiments](/http-api/experiments/#domain-migration-assignment-object) defines what a signed-in client resolves from it. The [instance discovery document](/http-api/instance/#domain-migration-object) publishes `enabled`, `anonymous_rollout_basis_points`, `rollout_salt`, and `standalone_forwarding` for clients that are not signed in.@@ -591,7 +596,7 @@ The body has one optional object for each section. Fluxer leaves an absent secti`voice_noise_suppression` takes every [voice noise suppression configuration](#voice-noise-suppression-configuration-object) field except `config_version`, each bound as documented there. Fluxer raises `config_version` by one on each request that supplies at least one of them. A section that is absent, or present with no field set, writes nothing and leaves `config_version` alone.-`push_service_delivery` works the same way, over the [push service delivery configuration](#push-service-delivery-configuration-object) fields and its own `config_version`.+`push_service_delivery` works the same way, over the [push service delivery configuration](#push-service-delivery-configuration-object) fields and its own `config_version`. It also takes `relay_consent_accepted`. Fluxer sets `relay_consent_accepted_at` and `relay_consent_accepted_by` itself on the request that changes that flag, and accepts neither from a request: turning the flag on stamps the current time and the acting Admin account, and turning it off clears both to null. A request that repeats the flag it already holds leaves the stamp alone.`domain_migration` works the same way, over the [domain migration configuration](#domain-migration-configuration-object) fields and its own `config_version`.diff --git a/fluxer_gateway/src/gateway/fluxer_gateway_config.erl b/fluxer_gateway/src/gateway/fluxer_gateway_config.erlindex 6ec671df4..8fc2e34aa 100644--- a/fluxer_gateway/src/gateway/fluxer_gateway_config.erl+++ b/fluxer_gateway/src/gateway/fluxer_gateway_config.erl@@ -19,6 +19,7 @@-type gateway_role() :: websocket | sessions | presence | guilds | calls | push | all.-define(MAX_CLUSTER_STATIC_PEERS, 256).+-define(DEFAULT_MANAGED_RELAY_HOSTS, <<"push.fluxer.com">>).-spec load() -> config().load() ->@@ -87,6 +88,12 @@ env_gateway_base_config() -><<"push_endpoint_guard_enabled">> => env_bool("FLUXER_GATEWAY_PUSH_ENDPOINT_GUARD_ENABLED", true),+ <<"push_managed_relay_hosts">> => env_binary(+ "FLUXER_GATEWAY_PUSH_MANAGED_RELAY_HOSTS", ?DEFAULT_MANAGED_RELAY_HOSTS+ ),+ <<"push_relay_consent_accepted">> => env_bool(+ "FLUXER_GATEWAY_PUSH_RELAY_CONSENT_ACCEPTED", false+ ),<<"push_outbox_request_timeout_ms">> => env_int("FLUXER_GATEWAY_PUSH_OUTBOX_REQUEST_TIMEOUT_MS", 100000),@@ -268,6 +275,12 @@ build_push_config(Service, Public) ->push_endpoint_guard_enabled => get_bool(Service, <<"push_endpoint_guard_enabled">>, true),+ push_managed_relay_hosts => parse_host_list(+ get_binary(Service, <<"push_managed_relay_hosts">>, ?DEFAULT_MANAGED_RELAY_HOSTS)+ ),+ push_relay_consent_accepted => get_bool(+ Service, <<"push_relay_consent_accepted">>, false+ ),push_outbox_max_queue => get_int(Service, <<"push_outbox_max_queue">>, 10000),push_outbox_max_inflight => get_int(Service, <<"push_outbox_max_inflight">>, 64),push_outbox_request_timeout_ms => get_int(@@ -590,6 +603,24 @@ to_binary(Str, _) when is_list(Str) -> list_to_binary(config_char_list(Str));to_binary(Atom, _) when is_atom(Atom) -> list_to_binary(atom_to_list(Atom));to_binary(_, Default) -> Default.+-spec parse_host_list(binary()) -> [binary()].+parse_host_list(Bin) ->+ parse_host_list(string:lexemes(binary_to_list(Bin), ", \t"), []).++-spec parse_host_list([string()], [binary()]) -> [binary()].+parse_host_list([], Acc) ->+ lists:reverse(Acc);+parse_host_list([Host | Rest], Acc) ->+ parse_host_list(Rest, [list_to_binary(lower_string(Host)) | Acc]).++-spec lower_string(string()) -> string().+lower_string(Value) ->+ [lower_char(Char) || Char <- Value].++-spec lower_char(char()) -> char().+lower_char(Char) when Char >= $A, Char =< $Z -> Char + 32;+lower_char(Char) -> Char.+-spec parse_node_list(binary() | undefined) -> [node()].parse_node_list(undefined) ->[];diff --git a/fluxer_gateway/src/push/push_delivery_config.erl b/fluxer_gateway/src/push/push_delivery_config.erlindex fdc03b2fc..39087776b 100644--- a/fluxer_gateway/src/push/push_delivery_config.erl+++ b/fluxer_gateway/src/push/push_delivery_config.erl@@ -37,7 +37,8 @@rollout_basis_points := non_neg_integer(),rollout_salt := binary(),included := user_id_set(),- excluded := user_id_set()+ excluded := user_id_set(),+ relay_consent_accepted := boolean()}.-type state() :: #{nats_subscription := term(),@@ -170,7 +171,8 @@ default_config() ->rollout_basis_points => 0,rollout_salt => ?DEFAULT_SALT,included => #{},- excluded => #{}+ excluded => #{},+ relay_consent_accepted => false}.-spec fetch_config_from_api() -> store_result().@@ -254,7 +256,8 @@ config_fields() ->{rollout_basis_points, <<"rollout_basis_points">>, fun validate_basis_points/1},{rollout_salt, <<"rollout_salt">>, fun validate_salt/1},{included, <<"included_user_ids">>, fun validate_user_ids/1},- {excluded, <<"excluded_user_ids">>, fun validate_user_ids/1}+ {excluded, <<"excluded_user_ids">>, fun validate_user_ids/1},+ {relay_consent_accepted, <<"relay_consent_accepted">>, fun validate_enabled/1}].-spec validate_field(@@ -419,7 +422,7 @@ result_index(rejected) -> 4.log_config_transitions(Previous, Current) ->lists:foreach(fun(Key) -> log_key_transition(Key, Previous, Current) end,- [enabled, rollout_basis_points, config_version]+ [enabled, rollout_basis_points, config_version, relay_consent_accepted]).-spec log_key_transition(atom(), config(), config()) -> ok.@@ -435,3 +438,22 @@ log_key_transition(Key, Previous, Current) ->[Key, PreviousValue, CurrentValue])end.++-ifdef(TEST).+-include_lib("eunit/include/eunit.hrl").++an_accepted_relay_notice_is_read_off_the_wire_config_test() ->+ {ok, Config} = validate_config(#{<<"relay_consent_accepted">> => true}),+ ?assertEqual(true, maps:get(relay_consent_accepted, Config)).++a_wire_config_without_a_relay_notice_has_not_been_accepted_test() ->+ {ok, Config} = validate_config(#{<<"enabled">> => true}),+ ?assertEqual(false, maps:get(relay_consent_accepted, Config)).++a_relay_notice_that_is_not_a_boolean_is_refused_test() ->+ ?assertMatch(+ {error, {invalid_field, <<"relay_consent_accepted">>, _}},+ validate_config(#{<<"relay_consent_accepted">> => <<"yes">>})+ ).++-endif.diff --git a/fluxer_gateway/src/push/push_sender_delivery.erl b/fluxer_gateway/src/push/push_sender_delivery.erlindex 3d6a637af..f2eecb918 100644--- a/fluxer_gateway/src/push/push_sender_delivery.erl+++ b/fluxer_gateway/src/push/push_sender_delivery.erl@@ -21,6 +21,12 @@-define(OVERLOAD_MAX_DELAY_MS, 4000).-define(VAPID_TOKEN_TTL_SECONDS, 43200).-define(VAPID_TOKEN_SKEW_SECONDS, 60).+-define(DEFAULT_MANAGED_RELAY_HOSTS, ["push.fluxer.com"]).+-define(MANAGED_RELAY_PATH_PREFIXES, [+ "/relay/v1/apns/",+ "/relay/v1/apns-voip/",+ "/relay/v1/fcm/"+]).-type push_response() :: {ok, integer(), term(), binary()} | {error, term()}.@@ -40,12 +46,94 @@ send_webpush_notification(UserId, Subscription, Payload) ->send_to_allowed_endpoint(UserId, Endpoint, P256dhKey, AuthKey, SubscriptionId, Payload) ->case push_endpoint_guard:check(Endpoint) ofok ->- send_with_vapid(UserId, Endpoint, P256dhKey, AuthKey, SubscriptionId, Payload);+ send_to_consented_endpoint(+ UserId, Endpoint, P256dhKey, AuthKey, SubscriptionId, Payload+ );{error, Reason} ->log_endpoint_rejected(UserId, SubscriptionId, Reason),falseend.+-spec send_to_consented_endpoint(integer(), binary(), binary(), binary(), binary(), map()) ->+ false | {true, map()}.+send_to_consented_endpoint(UserId, Endpoint, P256dhKey, AuthKey, SubscriptionId, Payload) ->+ case relay_consent_missing(Endpoint) of+ false ->+ send_with_vapid(UserId, Endpoint, P256dhKey, AuthKey, SubscriptionId, Payload);+ true ->+ log_endpoint_rejected(UserId, SubscriptionId, relay_consent_required),+ false+ end.++-spec relay_consent_missing(binary()) -> boolean().+relay_consent_missing(Endpoint) ->+ not relay_consent_accepted() andalso is_managed_relay_endpoint(Endpoint).++-spec relay_consent_accepted() -> boolean().+relay_consent_accepted() ->+ env_relay_consent_accepted() orelse instance_relay_consent_accepted().++-spec env_relay_consent_accepted() -> boolean().+env_relay_consent_accepted() ->+ case fluxer_gateway_env:get(push_relay_consent_accepted) of+ Accepted when is_boolean(Accepted) -> Accepted;+ _ -> false+ end.++-spec instance_relay_consent_accepted() -> boolean().+instance_relay_consent_accepted() ->+ case maps:get(relay_consent_accepted, push_delivery_config:config(), false) of+ Accepted when is_boolean(Accepted) -> Accepted;+ _ -> false+ end.++-spec is_managed_relay_endpoint(binary()) -> boolean().+is_managed_relay_endpoint(Endpoint) ->+ case safe_parse_endpoint(Endpoint) of+ {ok, Parsed} ->+ Scheme = lower_string(to_string(maps:get(scheme, Parsed, ""))),+ Host = lower_string(to_string(maps:get(host, Parsed, ""))),+ Path = to_string(maps:get(path, Parsed, "")),+ Scheme =:= "https" andalso+ lists:member(Host, managed_relay_hosts()) andalso+ is_managed_relay_path(Path);+ error ->+ false+ end.++-spec safe_parse_endpoint(binary()) -> {ok, map()} | error.+safe_parse_endpoint(Endpoint) ->+ try uri_string:parse(binary_to_list(Endpoint)) of+ Parsed when is_map(Parsed) -> {ok, Parsed};+ _ -> error+ catch+ _:_ -> error+ end.++-spec is_managed_relay_path(string()) -> boolean().+is_managed_relay_path(Path) ->+ lists:any(fun(Prefix) -> lists:prefix(Prefix, Path) end, ?MANAGED_RELAY_PATH_PREFIXES).++-spec managed_relay_hosts() -> [string()].+managed_relay_hosts() ->+ case fluxer_gateway_env:get(push_managed_relay_hosts) of+ Hosts when is_list(Hosts) -> [lower_string(to_string(Host)) || Host <- Hosts];+ _ -> ?DEFAULT_MANAGED_RELAY_HOSTS+ end.++-spec to_string(term()) -> string().+to_string(Value) when is_list(Value) -> Value;+to_string(Value) when is_binary(Value) -> binary_to_list(Value);+to_string(_Value) -> "".++-spec lower_string(string()) -> string().+lower_string(Value) ->+ [lower_char(Char) || Char <- Value].++-spec lower_char(char()) -> char().+lower_char(Char) when Char >= $A, Char =< $Z -> Char + 32;+lower_char(Char) -> Char.+-spec log_endpoint_rejected(integer(), binary(), term()) -> ok.log_endpoint_rejected(UserId, SubscriptionId, Reason) ->logger:debug(@@ -775,10 +863,100 @@ capture_web_push(Payload) ->vapid_env_meck(vapid_email) -> <<"[email protected]">>;vapid_env_meck(vapid_public_key) -> <<"public-key">>;vapid_env_meck(vapid_private_key) -> <<"private-key">>;+vapid_env_meck(push_relay_consent_accepted) -> true;+vapid_env_meck(push_managed_relay_hosts) -> [<<"push.fluxer.com">>];vapid_env_meck(Key) -> meck:passthrough([Key]).capture_request_meck(push, post, _Endpoint, Headers, Body, _Opts) ->self() ! {captured_push, Headers, Body},{ok, 201, [], <<>>}.+a_managed_relay_endpoint_is_refused_without_operator_consent_test() ->+ ?assertEqual(no_push_request, attempt_push(false, managed_relay_endpoint(<<"apns">>))).++every_managed_relay_leg_is_refused_without_operator_consent_test() ->+ lists:foreach(+ fun(Leg) ->+ ?assertEqual(no_push_request, attempt_push(false, managed_relay_endpoint(Leg)))+ end,+ [<<"apns">>, <<"apns-voip">>, <<"fcm">>]+ ).++a_managed_relay_endpoint_is_delivered_once_the_operator_consents_test() ->+ Endpoint = managed_relay_endpoint(<<"apns">>),+ ?assertEqual(Endpoint, attempt_push(true, Endpoint)).++a_notice_accepted_in_the_instance_config_lets_the_managed_relay_send_through_test() ->+ Endpoint = managed_relay_endpoint(<<"apns">>),+ ?assertEqual(Endpoint, attempt_push(false, true, Endpoint)).++a_unified_push_endpoint_is_delivered_whatever_the_operator_accepted_test() ->+ Endpoint = <<"https://ntfy.sh/upZzH87cT9jJCc?up=1">>,+ ?assertEqual(Endpoint, attempt_push(false, Endpoint)),+ ?assertEqual(Endpoint, attempt_push(true, Endpoint)).++a_relay_we_do_not_operate_is_delivered_without_consent_test() ->+ Endpoint = <<"https://push.example.org/relay/v1/apns/stable/production/token">>,+ ?assertEqual(Endpoint, attempt_push(false, Endpoint)).++managed_relay_endpoint(Leg) ->+ <<"https://push.fluxer.com/relay/v1/", Leg/binary, "/stable/production/",+ (binary:copy(<<"a">>, 64))/binary>>.++attempt_push(EnvConsent, Endpoint) ->+ attempt_push(EnvConsent, false, Endpoint).++attempt_push(EnvConsent, InstanceConsent, Endpoint) ->+ {PeerPub, _PeerPriv} = crypto:generate_key(ecdh, prime256v1),+ Subscription = #{+ <<"endpoint">> => Endpoint,+ <<"p256dh_key">> => push_utils:base64url_encode(PeerPub),+ <<"auth_key">> => push_utils:base64url_encode(crypto:strong_rand_bytes(16)),+ <<"subscription_id">> => <<"sub-1">>+ },+ ok = push_ets_cache:init(),+ ok = meck:new(fluxer_gateway_env, [passthrough, no_link]),+ ok = meck:new(push_utils, [passthrough, no_link]),+ ok = meck:new(gateway_http_client, [passthrough, no_link]),+ ok = meck:new(push_endpoint_guard, [passthrough, no_link]),+ ok = meck:new(push_delivery_config, [passthrough, no_link]),+ try+ ok = meck:expect(push_endpoint_guard, check, fun(_Endpoint) -> ok end),+ ok = meck:expect(push_delivery_config, config, fun() ->+ #{relay_consent_accepted => InstanceConsent}+ end),+ ok = meck:expect(fluxer_gateway_env, get, consent_env_meck(EnvConsent)),+ ok = meck:expect(push_utils, generate_vapid_token, fun(_Claims, _Public, _Private) ->+ <<"vapid-token">>+ end),+ ok = meck:expect(gateway_http_client, request, fun requested_endpoint_meck/6),+ ?assertEqual(+ false, send_webpush_notification(42, Subscription, alert_payload(<<"Hello">>))+ ),+ receive+ {push_requested, Requested} -> Requested+ after 100 ->+ no_push_request+ end+ after+ meck:unload(push_delivery_config),+ meck:unload(push_endpoint_guard),+ meck:unload(gateway_http_client),+ meck:unload(push_utils),+ meck:unload(fluxer_gateway_env)+ end.++consent_env_meck(EnvConsent) ->+ fun+ (push_relay_consent_accepted) -> EnvConsent;+ (push_managed_relay_hosts) -> [<<"push.fluxer.com">>];+ (Key) -> vapid_env_meck(Key)+ end.++-spec requested_endpoint_meck(atom(), atom(), binary(), list(), binary(), term()) ->+ {ok, non_neg_integer(), list(), binary()}.+requested_endpoint_meck(push, post, Endpoint, _Headers, _Body, _Opts) ->+ self() ! {push_requested, Endpoint},+ {ok, 201, [], <<>>}.+-endif.diff --git a/fluxer_push/src/config.rs b/fluxer_push/src/config.rsindex 34e52e3ed..04329b911 100644--- a/fluxer_push/src/config.rs+++ b/fluxer_push/src/config.rs@@ -29,6 +29,7 @@ const DEFAULT_FCM_BASE_URL: &str = "https://fcm.googleapis.com";const DEFAULT_CLIENT_IP_HEADER_NAME: &str = "x-forwarded-for";const APNS_PRODUCTION_BASE_URL: &str = "https://api.push.apple.com";const APNS_DEVELOPMENT_BASE_URL: &str = "https://api.sandbox.push.apple.com";+const DEFAULT_MANAGED_RELAY_HOST: &str = "push.fluxer.com";const VOIP_TOPIC_SUFFIX: &str = ".voip";#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, clap::ValueEnum)]@@ -184,6 +185,8 @@ pub struct DeliveryConfig {pub apns: Option<ApnsConfig>,pub fcm: Option<FcmConfig>,pub own_relay_hosts: Vec<String>,+ pub managed_relay_hosts: Vec<String>,+ pub relay_consent_accepted: bool,}#[derive(Clone, Copy, Debug)]@@ -264,6 +267,12 @@ impl DeliveryConfig {apns: apns_config(&env)?,fcm: fcm_config(&env)?,own_relay_hosts: own_relay_hosts(&env),+ managed_relay_hosts: managed_relay_hosts(&env),+ relay_consent_accepted: parse_bool(+ "FLUXER_PUSH_SERVICE_RELAY_CONSENT_ACCEPTED",+ env.get("FLUXER_PUSH_SERVICE_RELAY_CONSENT_ACCEPTED"),+ )?+ .unwrap_or(false),})}}@@ -277,6 +286,16 @@ fn own_relay_hosts(env: &Env) -> Vec<String> {.collect()}+fn managed_relay_hosts(env: &Env) -> Vec<String> {+ let Some(raw) = env.get("FLUXER_PUSH_SERVICE_MANAGED_RELAY_HOSTS") else {+ return vec![DEFAULT_MANAGED_RELAY_HOST.to_owned()];+ };+ raw.split(',')+ .map(|host| host.trim().to_ascii_lowercase())+ .filter(|host| !host.is_empty())+ .collect()+}+impl RelayConfig {pub fn load_from_iter<I, K, V>(vars: I) -> anyhow::Result<Self>wherediff --git a/fluxer_push/src/providers/mod.rs b/fluxer_push/src/providers/mod.rsindex 9f4b27cfb..0a38be84d 100644--- a/fluxer_push/src/providers/mod.rs+++ b/fluxer_push/src/providers/mod.rs@@ -91,16 +91,20 @@ pub async fn send(state: &AppState, sub: &Subscription, envelope: &Value) -> Senreturn SendOutcome::permanent("unsupported_platform");};let started_ms = now_ms();- let direct = in_process_hop(&sub.endpoint, &state.cfg.own_relay_hosts);- let outcome = match (route, direct) {- (Route::WebPush, Some(hop)) => {- let hopped = hop.as_subscription(sub);- state.metrics.record_own_relay_shortcut();- apns::send(state, &hopped, envelope).await+ let outcome = if relay_consent_missing(state, &sub.endpoint) {+ SendOutcome::permanent("relay_consent_required")+ } else {+ let direct = in_process_hop(&sub.endpoint, &state.cfg.own_relay_hosts);+ match (route, direct) {+ (Route::WebPush, Some(hop)) => {+ let hopped = hop.as_subscription(sub);+ state.metrics.record_own_relay_shortcut();+ apns::send(state, &hopped, envelope).await+ }+ (Route::WebPush, None) => web_push::send(state, sub, envelope).await,+ (Route::LegacyApns, _) => apns::send(state, sub, envelope).await,+ (Route::LegacyFcm, _) => fcm::send(state, sub, envelope).await,}- (Route::WebPush, None) => web_push::send(state, sub, envelope).await,- (Route::LegacyApns, _) => apns::send(state, sub, envelope).await,- (Route::LegacyFcm, _) => fcm::send(state, sub, envelope).await,};state.metrics.record_send(provider_of(platform),@@ -113,6 +117,19 @@ pub async fn send(state: &AppState, sub: &Subscription, envelope: &Value) -> Senoutcome}+fn relay_consent_missing(state: &AppState, endpoint: &str) -> bool {+ !relay_consent_accepted(state)+ && own_relay::is_managed(endpoint, &state.cfg.managed_relay_hosts)+}++fn relay_consent_accepted(state: &AppState) -> bool {+ state.cfg.relay_consent_accepted+ || state+ .rollout+ .snapshot()+ .is_some_and(|held| held.relay_consent_accepted)+}+fn in_process_hop(endpoint: &str, hosts: &[String]) -> Option<own_relay::Hop> {own_relay::parse(endpoint, hosts).filter(|hop| matches!(hop.leg, own_relay::Leg::Apns))}@@ -172,3 +189,129 @@ mod hop_tests {assert!(in_process_hop(&voip, &ours()).is_none());}}++#[cfg(test)]+mod consent_tests {+ use super::*;+ use crate::config::DeliveryConfig;+ use crate::server::AppState;++ const TOKEN: &str = "3dbc5a5ef1a1c1666afc26f466e1b3ebaaf4c66d92dddeb0fd1b69c49641d4cd";+ const NTFY_ENDPOINT: &str = "https://ntfy.sh/upZzH87cT9jJCc?up=1";++ fn managed_endpoint() -> String {+ format!("https://push.fluxer.com/relay/v1/apns/stable/production/{TOKEN}")+ }++ fn state(relay_consent_accepted: bool) -> AppState {+ let cfg = DeliveryConfig::load_from_iter([+ ("FLUXER_INTERNAL_API_ENDPOINT", "http://127.0.0.1:8080"),+ ("FLUXER_GATEWAY_RPC_AUTH_TOKEN", "rpc-token"),+ ("FLUXER_VAPID_EMAIL", "[email protected]"),+ ("FLUXER_VAPID_PUBLIC_KEY", "public-key"),+ ("FLUXER_VAPID_PRIVATE_KEY", "private-key"),+ (+ "FLUXER_PUSH_SERVICE_RELAY_CONSENT_ACCEPTED",+ if relay_consent_accepted {+ "true"+ } else {+ "false"+ },+ ),+ ])+ .expect("the delivery config loads");+ AppState::try_new(cfg).expect("the delivery state builds")+ }++ fn subscription(endpoint: &str) -> Subscription {+ Subscription {+ subscription_id: "sub-1".to_owned(),+ endpoint: endpoint.to_owned(),+ p256dh_key: None,+ auth_key: None,+ platform: Some("web_push".to_owned()),+ app_id: None,+ provider_environment: None,+ }+ }++ async fn outcome_of(relay_consent_accepted: bool, endpoint: &str) -> SendOutcome {+ let state = state(relay_consent_accepted);+ send(&state, &subscription(endpoint), &Value::Null).await+ }++ #[tokio::test]+ async fn a_managed_relay_send_waits_for_the_operator_to_accept_the_notice() {+ assert_eq!(+ outcome_of(false, &managed_endpoint()).await,+ SendOutcome::permanent("relay_consent_required")+ );+ }++ #[tokio::test]+ async fn a_refused_managed_relay_send_keeps_the_registration() {+ assert!(!outcome_of(false, &managed_endpoint()).await.deletes_token());+ }++ #[tokio::test]+ async fn an_accepted_notice_lets_the_managed_relay_send_through() {+ assert_eq!(+ outcome_of(true, &managed_endpoint()).await,+ SendOutcome::permanent("missing_keys")+ );+ }++ #[tokio::test]+ async fn a_unified_push_endpoint_is_sent_whatever_the_operator_accepted() {+ assert_eq!(+ outcome_of(false, NTFY_ENDPOINT).await,+ SendOutcome::permanent("missing_keys")+ );+ assert_eq!(+ outcome_of(true, NTFY_ENDPOINT).await,+ SendOutcome::permanent("missing_keys")+ );+ }++ #[tokio::test]+ async fn a_notice_accepted_in_the_instance_config_lets_the_send_through() {+ let state = state(false);+ state.rollout.update(&serde_json::json!({+ "enabled": true,+ "config_version": 1,+ "relay_consent_accepted": true,+ }));+ assert_eq!(+ send(&state, &subscription(&managed_endpoint()), &Value::Null).await,+ SendOutcome::permanent("missing_keys")+ );+ }++ #[tokio::test]+ async fn an_instance_config_that_has_not_accepted_still_refuses_the_send() {+ let state = state(false);+ state.rollout.update(&serde_json::json!({+ "enabled": true,+ "config_version": 1,+ "relay_consent_accepted": false,+ }));+ assert_eq!(+ send(&state, &subscription(&managed_endpoint()), &Value::Null).await,+ SendOutcome::permanent("relay_consent_required")+ );+ }++ #[tokio::test]+ async fn a_refused_managed_relay_send_is_still_counted() {+ let state = state(false);+ let outcome = send(&state, &subscription(&managed_endpoint()), &Value::Null).await;+ assert_eq!(outcome, SendOutcome::permanent("relay_consent_required"));+ let rendered = state.metrics.render();+ for series in [+ "fluxer_push_sends_total{provider=\"web_push\",result=\"permanent\"} 1",+ "fluxer_push_delivery_routes_total{route=\"web_push\",result=\"permanent\"} 1",+ ] {+ assert!(rendered.contains(series), "{series} must be recorded");+ }+ }+}diff --git a/fluxer_push/src/providers/own_relay.rs b/fluxer_push/src/providers/own_relay.rsindex 427cef732..6a5e7a61a 100644--- a/fluxer_push/src/providers/own_relay.rs+++ b/fluxer_push/src/providers/own_relay.rs@@ -97,6 +97,10 @@ pub fn parse(endpoint: &str, hosts: &[String]) -> Option<Hop> {})}+pub fn is_managed(endpoint: &str, hosts: &[String]) -> bool {+ parse(endpoint, hosts).is_some()+}+fn decode(segment: &str) -> Option<String> {percent_encoding::percent_decode_str(segment).decode_utf8()@@ -185,6 +189,26 @@ mod tests {assert!(parse("https://ntfy.sh/upZzH87cT9jJCc?up=1", &ours()).is_none());}+ #[test]+ fn every_managed_relay_leg_is_recognised_and_nothing_else_is() {+ for path in [+ format!("apns/canary/production/{TOKEN}"),+ format!("apns-voip/canary/production/{TOKEN}"),+ "fcm/canary/dYC_x9gXTjyyrG8_Aw3nUM%3AAPA91bExample".to_owned(),+ ] {+ let endpoint = format!("https://push.fluxer.com/relay/v1/{path}");+ assert!(+ is_managed(&endpoint, &ours()),+ "{endpoint} must be a managed relay endpoint"+ );+ }+ assert!(!is_managed("https://ntfy.sh/upZzH87cT9jJCc?up=1", &ours()));+ assert!(!is_managed(+ "https://updates.push.services.mozilla.com/wpush/v2/gAAAAA",+ &ours()+ ));+ }+#[test]fn a_malformed_relay_path_is_refused() {for endpoint in [diff --git a/fluxer_push/src/rollout.rs b/fluxer_push/src/rollout.rsindex 020d4de77..99de02fdc 100644--- a/fluxer_push/src/rollout.rs+++ b/fluxer_push/src/rollout.rs@@ -54,6 +54,7 @@ pub struct RolloutSnapshot {pub enabled: bool,pub config_version: u64,pub rollout_basis_points: u32,+ pub relay_consent_accepted: bool,}impl RolloutConfig for RolloutSnapshot {@@ -77,6 +78,7 @@ impl RolloutConfig for RolloutSnapshot {enabled: parse_enabled(config)?,config_version: parse_config_version(config)?,rollout_basis_points,+ relay_consent_accepted: parse_flag(config, "relay_consent_accepted")?,})}@@ -98,9 +100,13 @@ impl RolloutConfig for RolloutSnapshot {}pub fn parse_enabled(config: &Value) -> Option<bool> {- match config.get("enabled") {+ parse_flag(config, "enabled")+}++fn parse_flag(config: &Value, key: &str) -> Option<bool> {+ match config.get(key) {None | Some(Value::Null) => Some(false),- Some(Value::Bool(enabled)) => Some(*enabled),+ Some(Value::Bool(flag)) => Some(*flag),Some(_) => None,}}@@ -160,7 +166,7 @@ impl<C: RolloutConfig> RolloutStore<C> {self.update(config)}- fn update(&self, config: &Value) -> RolloutOutcome {+ pub(crate) fn update(&self, config: &Value) -> RolloutOutcome {let Some(offered) = C::parse(config) else {warn!(config = C::NAME, "rollout config rejected as invalid");return RolloutOutcome::Rejected;@@ -288,3 +294,33 @@ fn config_object<'a>(value: &'a Value, message_type: &str) -> Option<&'a Value>}value.is_object().then_some(value)}++#[cfg(test)]+mod tests {+ use super::*;+ use serde_json::json;++ #[test]+ fn the_operator_relay_consent_is_read_off_the_instance_config() {+ let config = json!({+ "enabled": true,+ "config_version": 3,+ "relay_consent_accepted": true,+ });+ let snapshot = RolloutSnapshot::parse(&config).expect("the config parses");+ assert!(snapshot.relay_consent_accepted);+ }++ #[test]+ fn an_instance_config_without_the_consent_field_has_not_consented() {+ let config = json!({"enabled": true, "config_version": 3});+ let snapshot = RolloutSnapshot::parse(&config).expect("the config parses");+ assert!(!snapshot.relay_consent_accepted);+ }++ #[test]+ fn a_consent_field_that_is_not_a_boolean_is_refused() {+ let config = json!({"enabled": true, "relay_consent_accepted": "yes"});+ assert!(RolloutSnapshot::parse(&config).is_none());+ }+}diff --git a/packages/schema/src/domains/admin/PushServiceDeliverySchemas.test.ts b/packages/schema/src/domains/admin/PushServiceDeliverySchemas.test.tsnew file mode 100644index 000000000..d443e24f7--- /dev/null+++ b/packages/schema/src/domains/admin/PushServiceDeliverySchemas.test.ts@@ -0,0 +1,89 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++import {+ DEFAULT_PUSH_SERVICE_DELIVERY_CONFIG,+ type PushServiceDeliveryConfig,+ PushServiceDeliveryConfigSchema,+ PushServiceDeliveryConfigUpdateRequest,+ pushServiceDeliveryEnrols,+} from '@fluxer/schema/src/domains/admin/PushServiceDeliverySchemas';+import {describe, expect, test} from 'vitest';++const ADMIN_USER_ID = '1500000000000000001';+const TARGETED_USER_ID = '1500000000000000002';++function createConfig(overrides: Partial<PushServiceDeliveryConfig> = {}): PushServiceDeliveryConfig {+ return {+ ...DEFAULT_PUSH_SERVICE_DELIVERY_CONFIG,+ included_user_ids: [],+ excluded_user_ids: [],+ ...overrides,+ };+}++describe('push service delivery relay consent', () => {+ test('a stored configuration that predates relay consent reads back as not accepted', () => {+ expect(+ PushServiceDeliveryConfigSchema.parse({+ enabled: true,+ config_version: 4,+ rollout_basis_points: 10000,+ rollout_salt: 'push-service-delivery-v1',+ included_user_ids: [],+ excluded_user_ids: [],+ }),+ ).toMatchObject({+ relay_consent_accepted: false,+ relay_consent_accepted_at: null,+ relay_consent_accepted_by: null,+ });+ });++ test('the defaults export carries the unaccepted consent', () => {+ expect(DEFAULT_PUSH_SERVICE_DELIVERY_CONFIG.relay_consent_accepted).toBe(false);+ expect(DEFAULT_PUSH_SERVICE_DELIVERY_CONFIG.relay_consent_accepted_at).toBeNull();+ expect(DEFAULT_PUSH_SERVICE_DELIVERY_CONFIG.relay_consent_accepted_by).toBeNull();+ });++ test('an accepted consent round-trips through the stored schema', () => {+ const accepted = {+ ...DEFAULT_PUSH_SERVICE_DELIVERY_CONFIG,+ relay_consent_accepted: true,+ relay_consent_accepted_at: '2026-09-27T10:11:12.000Z',+ relay_consent_accepted_by: ADMIN_USER_ID,+ };+ expect(PushServiceDeliveryConfigSchema.parse(accepted)).toEqual(accepted);+ });++ test('the update request takes the consent flag on its own', () => {+ expect(PushServiceDeliveryConfigUpdateRequest.parse({relay_consent_accepted: true})).toEqual({+ relay_consent_accepted: true,+ });+ });++ test('the update request refuses a client-supplied acceptance stamp', () => {+ expect(+ PushServiceDeliveryConfigUpdateRequest.parse({+ relay_consent_accepted: true,+ relay_consent_accepted_at: '2020-01-01T00:00:00.000Z',+ relay_consent_accepted_by: ADMIN_USER_ID,+ }),+ ).toEqual({relay_consent_accepted: true});+ });++ test.each([+ {relay_consent_accepted_at: 'yesterday'},+ {relay_consent_accepted_at: '2026-09-27'},+ {relay_consent_accepted_by: 'not-an-id'},+ {relay_consent_accepted: 'yes'},+ ])('rejects a malformed stored consent: %j', (value) => {+ expect(PushServiceDeliveryConfigSchema.safeParse(value).success).toBe(false);+ });++ test('consent alone enrols nobody and refusing it excludes nobody', () => {+ const withConsent = createConfig({enabled: false, relay_consent_accepted: true});+ const withoutConsent = createConfig({enabled: true, rollout_basis_points: 10000});+ expect(pushServiceDeliveryEnrols(withConsent, TARGETED_USER_ID)).toBe(false);+ expect(pushServiceDeliveryEnrols(withoutConsent, TARGETED_USER_ID)).toBe(true);+ });+});diff --git a/packages/schema/src/domains/admin/PushServiceDeliverySchemas.ts b/packages/schema/src/domains/admin/PushServiceDeliverySchemas.tsindex 7951ce0fd..b7423bc91 100644--- a/packages/schema/src/domains/admin/PushServiceDeliverySchemas.ts+++ b/packages/schema/src/domains/admin/PushServiceDeliverySchemas.ts@@ -21,6 +21,9 @@ const pushServiceDeliveryConfigFields = {rollout_salt: z.string().trim().min(1).max(64).regex(PUSH_SERVICE_DELIVERY_SALT_PATTERN),included_user_ids: PushServiceDeliveryTargetedUserIdsSchema,excluded_user_ids: PushServiceDeliveryTargetedUserIdsSchema,+ relay_consent_accepted: z.boolean(),+ relay_consent_accepted_at: z.iso.datetime().nullable(),+ relay_consent_accepted_by: PushServiceDeliveryTargetIdSchema.nullable(),};export const PushServiceDeliveryConfigSchema = z.object({@@ -30,6 +33,9 @@ export const PushServiceDeliveryConfigSchema = z.object({rollout_salt: pushServiceDeliveryConfigFields.rollout_salt.default(DEFAULT_PUSH_SERVICE_DELIVERY_SALT),included_user_ids: pushServiceDeliveryConfigFields.included_user_ids.default([]),excluded_user_ids: pushServiceDeliveryConfigFields.excluded_user_ids.default([]),+ relay_consent_accepted: pushServiceDeliveryConfigFields.relay_consent_accepted.default(false),+ relay_consent_accepted_at: pushServiceDeliveryConfigFields.relay_consent_accepted_at.default(null),+ relay_consent_accepted_by: pushServiceDeliveryConfigFields.relay_consent_accepted_by.default(null),});export type PushServiceDeliveryConfig = z.infer<typeof PushServiceDeliveryConfigSchema>;@@ -40,7 +46,7 @@ export const DEFAULT_PUSH_SERVICE_DELIVERY_CONFIG: PushServiceDeliveryConfig = Pexport const PushServiceDeliveryConfigUpdateRequest = z.object(pushServiceDeliveryConfigFields)- .omit({config_version: true})+ .omit({config_version: true, relay_consent_accepted_at: true, relay_consent_accepted_by: true}).partial();export type PushServiceDeliveryConfigUpdateRequest = z.infer<typeof PushServiceDeliveryConfigUpdateRequest>;