From 1bfaa5f96f5d3b35d675716d3caead8ee15dc1a5 Mon Sep 17 00:00:00 2001
From: Marco Beretta <81851188+berry-13@users.noreply.github.com>
Date: Wed, 23 Sep 2026 10:46:22 +0200
Subject: [PATCH] =?UTF-8?q?=E2=9A=96=EF=B8=8F=20refactor:=20Move=20Policy?=
=?UTF-8?q?=20Links=20to=20the=20Signup=20Consent=20(#16138)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
api/server/experimental.js | 1 -
api/server/index.js | 1 -
client/src/components/Auth/AuthLayout.tsx | 34 ++-
client/src/components/Auth/Footer.tsx | 14 +-
client/src/components/Auth/LegalConsent.tsx | 63 +++++
client/src/components/Auth/Registration.tsx | 5 +
.../Auth/__tests__/AuthLayout.spec.tsx | 190 +++++++++++++++
.../Auth/__tests__/Registration.spec.tsx | 122 +++++++++-
client/src/components/Chat/ChatView.tsx | 6 +-
client/src/components/Chat/Footer.tsx | 34 +--
.../components/Chat/__tests__/Footer.spec.tsx | 54 +++++
client/src/locales/en/translation.json | 3 +
client/src/utils/index.ts | 1 +
client/src/utils/policies.ts | 40 ++++
.../scenarios/footer-shell-answer.spec.ts | 22 +-
.../scenarios/policy-links-placement.spec.ts | 147 ++++++++++++
.../scenarios/registration-consent.spec.ts | 218 ++++++++++++++++++
packages/api/src/html/footer.spec.ts | 31 +--
packages/api/src/html/footer.ts | 16 +-
packages/data-provider/src/footer.spec.ts | 22 +-
packages/data-provider/src/footer.ts | 34 +--
21 files changed, 937 insertions(+), 121 deletions(-)
create mode 100644 client/src/components/Auth/LegalConsent.tsx
create mode 100644 client/src/components/Auth/__tests__/AuthLayout.spec.tsx
create mode 100644 client/src/utils/policies.ts
create mode 100644 e2e/specs/mock/scenarios/policy-links-placement.spec.ts
create mode 100644 e2e/specs/mock/scenarios/registration-consent.spec.ts
diff --git a/api/server/experimental.js b/api/server/experimental.js
index d6b610a595..92cac2099b 100644
--- a/api/server/experimental.js
+++ b/api/server/experimental.js
@@ -541,7 +541,6 @@ if (cluster.isMaster) {
so the answer is the deployment's base configuration, like index.js. */
indexHTML = injectConfiguredFooterBootstrap(indexHTML, {
customFooter: process.env.CUSTOM_FOOTER,
- interfaceConfig: baseAppConfig?.interfaceConfig,
});
const cspPolicy = createCspPolicy();
diff --git a/api/server/index.js b/api/server/index.js
index b4555e7b26..b83d2cc003 100644
--- a/api/server/index.js
+++ b/api/server/index.js
@@ -292,7 +292,6 @@ const startServer = async () => {
caller's and the client prefers it. */
indexHTML = injectConfiguredFooterBootstrap(indexHTML, {
customFooter: process.env.CUSTOM_FOOTER,
- interfaceConfig: appConfig?.interfaceConfig,
});
const cspPolicy = createCspPolicy();
diff --git a/client/src/components/Auth/AuthLayout.tsx b/client/src/components/Auth/AuthLayout.tsx
index 57fa4e5d86..bb05dd0cb4 100644
--- a/client/src/components/Auth/AuthLayout.tsx
+++ b/client/src/components/Auth/AuthLayout.tsx
@@ -1,9 +1,11 @@
import { ThemeSelector } from '@librechat/client';
import { TStartupConfig } from 'librechat-data-provider';
import { ErrorMessage } from '~/components/Auth/ErrorMessage';
+import { hasPublishedPolicies } from '~/utils/policies';
import { TranslationKeys, useLocalize } from '~/hooks';
import SocialLoginRender from './SocialLoginRender';
import { BlinkAnimation } from './BlinkAnimation';
+import LegalConsent from './LegalConsent';
import { Banner } from '../Banners';
import Footer from './Footer';
@@ -27,6 +29,30 @@ function AuthLayout({
const localize = useLocalize();
const hasStartupConfigError = startupConfigError !== null && startupConfigError !== undefined;
+ const isRegister = pathname.includes('register');
+ const isLogin = !pathname.includes('2fa') && pathname.includes('login');
+ const showsSocialLogin = isLogin || isRegister;
+ /** Both ways in state it, rather than the layout guessing which of them can
+ * create an account. That guess is not available here: account creation
+ * also happens on a first provider sign-in, on a first LDAP sign-in through
+ * the ordinary form, and is gated server-side by ALLOW_SOCIAL_REGISTRATION,
+ * which the startup payload does not carry. The sentence is about
+ * continuing, which is what both screens do, and it names the same policies
+ * the footer bar linked, so a screen states them once. */
+ const hasPolicies = hasPublishedPolicies(startupConfig);
+ /** Registration states it under its own submit button, where it is read
+ * before the account is created rather than below however many provider
+ * buttons a deployment configured, and it renders that form only once the
+ * config has loaded without error. The login screen has no submit button of
+ * its own to sit under, so there the layout states it below the providers,
+ * for as long as it knows the policies: a background refetch must not swap
+ * the sentence for the bar and back. */
+ const registrationStatesConsent =
+ isRegister && hasPolicies && !hasStartupConfigError && !isFetching;
+ const statesConsentBelowProviders = isLogin && hasPolicies;
+ /** The bar is dropped exactly when the sentence is on the screen, so a
+ * reader never meets both and never meets neither. */
+ const statesConsent = registrationStatesConsent || statesConsentBelowProviders;
const DisplayError = () => {
if (hasStartupConfigError) {
return (
@@ -87,13 +113,11 @@ function AuthLayout({
)}
{children}
- {!pathname.includes('2fa') &&
- (pathname.includes('login') || pathname.includes('register')) && (
-
- )}
+ {showsSocialLogin && }
+ {statesConsentBelowProviders && }
-
+ {!statesConsent && }
);
}
diff --git a/client/src/components/Auth/Footer.tsx b/client/src/components/Auth/Footer.tsx
index 30fe354f11..182ed1195d 100644
--- a/client/src/components/Auth/Footer.tsx
+++ b/client/src/components/Auth/Footer.tsx
@@ -1,4 +1,5 @@
import { TStartupConfig } from 'librechat-data-provider';
+import { policyUrls } from '~/utils/policies';
import { useLocalize } from '~/hooks';
function Footer({ startupConfig }: { startupConfig: TStartupConfig | null | undefined }) {
@@ -6,13 +7,14 @@ function Footer({ startupConfig }: { startupConfig: TStartupConfig | null | unde
if (!startupConfig) {
return null;
}
- const privacyPolicy = startupConfig.interface?.privacyPolicy;
- const termsOfService = startupConfig.interface?.termsOfService;
+ /** Read the way the consent reads them, so a blank url is not a policy on one
+ * screen and a link back to this page on another. */
+ const { privacyPolicyUrl, termsOfServiceUrl } = policyUrls(startupConfig);
- const privacyPolicyRender = privacyPolicy?.externalUrl && (
+ const privacyPolicyRender = privacyPolicyUrl != null && (
);
- const termsOfServiceRender = termsOfService?.externalUrl && (
+ const termsOfServiceRender = termsOfServiceUrl != null && (
{
+ if (termsOfServiceUrl == null) {
+ return 'com_auth_legal_consent_privacy';
+ }
+ if (privacyPolicyUrl == null) {
+ return 'com_auth_legal_consent_terms';
+ }
+ return 'com_auth_legal_consent';
+};
+
+/**
+ * The consent an account is created under, stated where it is created rather
+ * than left to a link beneath the composer. It closes the auth card, so it
+ * covers the registration form and the provider buttons alike: a first sign-in
+ * through a provider creates an account too. Absent entirely on a deployment
+ * that published neither policy.
+ */
+function LegalConsent({ startupConfig }: { startupConfig: TStartupConfig | null | undefined }) {
+ const localize = useLocalize();
+ const { privacyPolicyUrl, termsOfServiceUrl } = policyUrls(startupConfig);
+
+ /** The same answer the layout uses to drop its footer bar, so the two cannot
+ * both be on the screen: it is false with nothing published, and on a
+ * deployment that collects an explicit acceptance of its own. */
+ if (!hasPublishedPolicies(startupConfig)) {
+ return null;
+ }
+
+ return (
+
+
+ {localize('com_ui_privacy_policy')}
+
+ ),
+ terms: (
+
+ {localize('com_ui_terms_of_service')}
+
+ ),
+ }}
+ />
+
+ );
+}
+
+export default LegalConsent;
diff --git a/client/src/components/Auth/Registration.tsx b/client/src/components/Auth/Registration.tsx
index 77da29c8f4..ac2877597e 100644
--- a/client/src/components/Auth/Registration.tsx
+++ b/client/src/components/Auth/Registration.tsx
@@ -9,6 +9,7 @@ import type { TRegisterUser, TError } from 'librechat-data-provider';
import type { TLoginLayoutContext } from '~/common';
import { useLocalize, TranslationKeys } from '~/hooks';
import { ErrorMessage } from './ErrorMessage';
+import LegalConsent from './LegalConsent';
const Registration: React.FC = () => {
const navigate = useNavigate();
@@ -237,6 +238,10 @@ const Registration: React.FC = () => {
{isSubmitting ? : localize('com_auth_continue')}
+
+ {/* Under the button it is agreed to, and read before the account is
+ created; the auth layout drops its footer bar in exchange. */}
+
diff --git a/client/src/components/Auth/__tests__/AuthLayout.spec.tsx b/client/src/components/Auth/__tests__/AuthLayout.spec.tsx
new file mode 100644
index 0000000000..42ad0f9746
--- /dev/null
+++ b/client/src/components/Auth/__tests__/AuthLayout.spec.tsx
@@ -0,0 +1,190 @@
+import { I18nextProvider } from 'react-i18next';
+import type { TStartupConfig } from 'librechat-data-provider';
+import * as endpointQueries from '~/data-provider/Endpoints/queries';
+import * as miscDataProvider from '~/data-provider/Misc/queries';
+import { render, screen } from 'test/layout-test-utils';
+import AuthLayout from '~/components/Auth/AuthLayout';
+import i18n from '~/locales/i18n';
+
+/**
+ * The auth layout decides where the consent is stated, and a screen that states
+ * it does not also carry the footer bar linking the same two policies. Both
+ * ways in state it: which of them can create an account is not knowable here
+ * (a provider sign-in and an LDAP sign-in both create one, and
+ * ALLOW_SOCIAL_REGISTRATION is server-side), and the sentence is about
+ * continuing, which both screens do.
+ *
+ * `test/setupTests.js` stubs `initReactI18next`, so nothing binds the app's
+ * i18next instance to react-i18next the way `locales/i18n` does at runtime;
+ * `Trans` reads it from the provider below instead.
+ */
+
+const PRIVACY_URL = 'https://example.com/privacy';
+const TERMS_URL = 'https://example.com/terms';
+
+const policies = {
+ privacyPolicy: { externalUrl: PRIVACY_URL },
+ termsOfService: { externalUrl: TERMS_URL },
+};
+
+type Options = {
+ pathname?: string;
+ isFetching?: boolean;
+ startupConfigError?: unknown;
+ socialLoginEnabled?: boolean;
+ /** What `socialLogins` lists, and whether the listed provider's own flag is
+ * set: a button needs both, not just the global switch. */
+ providers?: string[];
+ googleLoginEnabled?: boolean;
+ /** Partial on purpose: a fixture sets the policies under test, and the field
+ * names are still checked against the real interface config. */
+ interfaceConfig?: Partial>;
+};
+
+function setup({
+ pathname = 'register',
+ isFetching = false,
+ startupConfigError = null,
+ socialLoginEnabled = false,
+ providers,
+ googleLoginEnabled,
+ interfaceConfig,
+}: Options) {
+ const startupConfig = {
+ appTitle: 'LibreChat',
+ socialLoginEnabled,
+ socialLogins: providers ?? (socialLoginEnabled ? ['google'] : []),
+ googleLoginEnabled: googleLoginEnabled ?? socialLoginEnabled,
+ serverDomain: 'mock-server',
+ interface: interfaceConfig,
+ } as unknown as TStartupConfig;
+
+ jest
+ .spyOn(endpointQueries, 'useGetStartupConfig')
+ //@ts-ignore - the layout reads only the resolved data
+ .mockReturnValue({ data: startupConfig, isFetching: false, isError: false });
+ jest
+ .spyOn(miscDataProvider, 'useGetBannerQuery')
+ //@ts-ignore - the banner is not under test
+ .mockReturnValue({ data: null, isLoading: false, isError: false });
+
+ return render(
+
+
+
+
+ ,
+ );
+}
+
+const consent = () => screen.queryByText(/By continuing/i);
+const footerBar = () => document.querySelector('[role="contentinfo"]');
+
+describe('AuthLayout legal placement', () => {
+ /** The registration form states the consent itself, under its own submit
+ * button (Registration.spec covers that); the layout's part is dropping the
+ * footer bar so the same two policies are not linked twice. */
+ test('registration drops the footer bar the consent replaces', () => {
+ setup({ pathname: 'register', interfaceConfig: policies });
+
+ expect(footerBar()).toBeNull();
+ expect(consent()).not.toBeInTheDocument();
+ });
+
+ test('the login screen states it too', () => {
+ setup({ pathname: 'login', socialLoginEnabled: true, interfaceConfig: policies });
+
+ expect(consent()).toBeInTheDocument();
+ expect(document.querySelectorAll(`a[href="${PRIVACY_URL}"]`)).toHaveLength(1);
+ expect(document.querySelectorAll(`a[href="${TERMS_URL}"]`)).toHaveLength(1);
+ expect(footerBar()).toBeNull();
+ });
+
+ /** No provider button is needed for the screen to be a way in: a first LDAP
+ * sign-in creates the account through this very form. */
+ test('a login screen with no provider button states it as well', () => {
+ setup({ pathname: 'login', socialLoginEnabled: false, interfaceConfig: policies });
+
+ expect(consent()).toBeInTheDocument();
+ expect(footerBar()).toBeNull();
+ });
+
+ /** The second factor is not a way in of its own; the screen that sent the
+ * reader here already stated the consent. */
+ test('the second factor states nothing', () => {
+ setup({ pathname: 'login/2fa', socialLoginEnabled: true, interfaceConfig: policies });
+
+ expect(consent()).not.toBeInTheDocument();
+ expect(footerBar()).not.toBeNull();
+ });
+
+ /** The consent and the footer bar read policy urls the same way, so a blank
+ * one is not a policy on one screen and a link to nowhere on the other. */
+ test('a blank policy url leaves neither a consent nor a link in the footer bar', () => {
+ setup({ pathname: 'login', interfaceConfig: { privacyPolicy: { externalUrl: ' ' } } });
+
+ expect(consent()).not.toBeInTheDocument();
+ expect(footerBar()).not.toBeNull();
+ expect(document.querySelector('[role="contentinfo"] a')).toBeNull();
+ });
+
+ /** Registration renders its form, and with it the consent, only once the
+ * config has loaded without error. The footer bar carries the policies
+ * until then, so the screen is never left with neither. */
+ test('registration refetching its config keeps the footer bar', () => {
+ setup({ pathname: 'register', isFetching: true, interfaceConfig: policies });
+
+ expect(consent()).not.toBeInTheDocument();
+ expect(footerBar()).not.toBeNull();
+ });
+
+ test('registration whose config failed keeps the footer bar', () => {
+ setup({
+ pathname: 'register',
+ startupConfigError: new Error('config unavailable'),
+ interfaceConfig: policies,
+ });
+
+ expect(consent()).not.toBeInTheDocument();
+ expect(footerBar()).not.toBeNull();
+ });
+
+ /** The login screen states it itself, so a background refetch of an already
+ * known config must not swap the sentence for the bar and back. */
+ test('the login screen keeps the consent across a background refetch', () => {
+ setup({ pathname: 'login', isFetching: true, interfaceConfig: policies });
+
+ expect(consent()).toBeInTheDocument();
+ expect(footerBar()).toBeNull();
+ });
+
+ /** A deployment that asks for explicit acceptance in a modal after sign-in
+ * must not be told it already agreed by continuing. */
+ test('a modal-acceptance deployment keeps the bare links instead', () => {
+ setup({
+ pathname: 'register',
+ interfaceConfig: {
+ privacyPolicy: { externalUrl: PRIVACY_URL },
+ termsOfService: { externalUrl: TERMS_URL, modalAcceptance: true },
+ },
+ });
+
+ expect(consent()).not.toBeInTheDocument();
+ expect(footerBar()).not.toBeNull();
+ expect(document.querySelectorAll(`a[href="${TERMS_URL}"]`)).toHaveLength(1);
+ });
+
+ test('a deployment with no policies keeps the footer bar it always had', () => {
+ setup({ pathname: 'register', interfaceConfig: undefined });
+
+ expect(consent()).not.toBeInTheDocument();
+ expect(footerBar()).not.toBeNull();
+ });
+});
diff --git a/client/src/components/Auth/__tests__/Registration.spec.tsx b/client/src/components/Auth/__tests__/Registration.spec.tsx
index 292458d555..69cc6540ea 100644
--- a/client/src/components/Auth/__tests__/Registration.spec.tsx
+++ b/client/src/components/Auth/__tests__/Registration.spec.tsx
@@ -1,4 +1,5 @@
import * as reactRouter from 'react-router-dom';
+import { I18nextProvider } from 'react-i18next';
import userEvent from '@testing-library/user-event';
import * as mockDataProvider from 'librechat-data-provider/react-query';
import type { TStartupConfig } from 'librechat-data-provider';
@@ -9,6 +10,7 @@ import * as authMutations from '~/data-provider/Auth/mutations';
import * as authQueries from '~/data-provider/Auth/queries';
import Registration from '~/components/Auth/Registration';
import AuthLayout from '~/components/Auth/AuthLayout';
+import i18n from '~/locales/i18n';
jest.mock('librechat-data-provider/react-query');
@@ -87,17 +89,23 @@ const setup = ({
.spyOn(miscDataProvider, 'useGetBannerQuery')
//@ts-ignore - we don't need all parameters of the QueryObserverSuccessResult
.mockReturnValue(useGetBannerQueryReturnValue);
+ /* `test/setupTests.js` stubs `initReactI18next`, so nothing binds the app's
+ i18next instance to react-i18next the way `locales/i18n` does at runtime.
+ `Trans` reads it from this provider instead, and renders the sentence it
+ renders in the app. */
const renderResult = render(
-
-
- ,
+
+
+
+
+ ,
);
return {
@@ -230,3 +238,97 @@ test('shows error message when registration fails', async () => {
);
});
});
+
+const withInterface = (interfaceConfig: Partial>) => ({
+ ...mockStartupConfig,
+ data: { ...mockStartupConfig.data, interface: interfaceConfig },
+});
+
+test('states the consent, with a link to each policy the deployment configured', () => {
+ const { getByRole, getByText } = setup({
+ useGetStartupConfigReturnValue: withInterface({
+ privacyPolicy: { externalUrl: 'https://example.com/privacy' },
+ termsOfService: { externalUrl: 'https://example.com/terms' },
+ }),
+ });
+
+ expect(getByText(/By continuing, you agree to the/i)).toBeInTheDocument();
+
+ const terms = getByRole('link', { name: 'Terms of Service' });
+ expect(terms).toHaveAttribute('href', 'https://example.com/terms');
+ expect(terms).not.toHaveAttribute('target');
+
+ const privacy = getByRole('link', { name: 'Privacy Policy' });
+ expect(privacy).toHaveAttribute('href', 'https://example.com/privacy');
+ expect(privacy).not.toHaveAttribute('target');
+});
+
+test('claims agreement only to the policy the deployment published', () => {
+ const { getByRole, getByText, queryByRole } = setup({
+ useGetStartupConfigReturnValue: withInterface({
+ privacyPolicy: { externalUrl: 'https://example.com/privacy' },
+ }),
+ });
+
+ expect(getByText(/By continuing, you acknowledge the/i)).toBeInTheDocument();
+ expect(getByRole('link', { name: 'Privacy Policy' })).toBeInTheDocument();
+ expect(queryByRole('link', { name: 'Terms of Service' })).not.toBeInTheDocument();
+});
+
+test('claims agreement to terms a deployment published without a privacy policy', () => {
+ const { getByRole, getByText, queryByRole } = setup({
+ useGetStartupConfigReturnValue: withInterface({
+ termsOfService: { externalUrl: 'https://example.com/terms' },
+ }),
+ });
+
+ expect(getByText(/By continuing, you agree to the/i)).toBeInTheDocument();
+ expect(getByRole('link', { name: 'Terms of Service' })).toBeInTheDocument();
+ expect(queryByRole('link', { name: 'Privacy Policy' })).not.toBeInTheDocument();
+});
+
+/** `externalUrl` is an optional string, so an operator can set it to nothing.
+ * A blank one would link back to this page and name a policy that does not
+ * exist, which is worse than saying nothing. */
+test('treats a blank policy url as a policy the deployment never published', () => {
+ const { getByText, queryByRole } = setup({
+ useGetStartupConfigReturnValue: withInterface({
+ privacyPolicy: { externalUrl: ' ' },
+ termsOfService: { externalUrl: 'https://example.com/terms' },
+ }),
+ });
+
+ expect(getByText(/By continuing, you agree to the/i)).toBeInTheDocument();
+ expect(queryByRole('link', { name: 'Privacy Policy' })).not.toBeInTheDocument();
+ expect(document.querySelector('a[href=""]')).toBeNull();
+});
+
+test('says nothing about policies a deployment never configured', () => {
+ const { queryByText } = setup();
+
+ expect(queryByText(/By continuing/i)).not.toBeInTheDocument();
+});
+
+/** A deployment that collects an explicit acceptance after sign-in is not one
+ * where continuing is the agreement, so the form states nothing. */
+test('says nothing on a deployment that accepts its terms in a modal', () => {
+ const { queryByText } = setup({
+ useGetStartupConfigReturnValue: withInterface({
+ privacyPolicy: { externalUrl: 'https://example.com/privacy' },
+ termsOfService: { externalUrl: 'https://example.com/terms', modalAcceptance: true },
+ }),
+ });
+
+ expect(queryByText(/By continuing/i)).not.toBeInTheDocument();
+});
+
+test('says nothing when every configured policy url is blank', () => {
+ const { queryByText } = setup({
+ useGetStartupConfigReturnValue: withInterface({
+ privacyPolicy: { externalUrl: '' },
+ termsOfService: { externalUrl: '' },
+ }),
+ });
+
+ expect(queryByText(/By continuing/i)).not.toBeInTheDocument();
+});
diff --git a/client/src/components/Chat/ChatView.tsx b/client/src/components/Chat/ChatView.tsx
index bb8ffcb351..d881fd3673 100644
--- a/client/src/components/Chat/ChatView.tsx
+++ b/client/src/components/Chat/ChatView.tsx
@@ -216,9 +216,9 @@ function ChatView({ index = 0, project }: { index?: number; project?: TChatProje
centerFormOnLanding={centerFormOnLanding}
/>
)}
- {/* The generic disclaimer is the welcome screen's; a
- deployment's own footer, privacy policy and terms
- stay with the conversation that always showed them. */}
+ {/* The generic disclaimer and the policy links are the
+ welcome screen's; a deployment's own footer stays
+ with the conversation that always showed it. */}
{!isLandingPage && configuredFooter && }
diff --git a/client/src/components/Chat/Footer.tsx b/client/src/components/Chat/Footer.tsx
index 1b50fbd467..2a793d53e2 100644
--- a/client/src/components/Chat/Footer.tsx
+++ b/client/src/components/Chat/Footer.tsx
@@ -4,17 +4,18 @@ import ReactMarkdown from 'react-markdown';
import { Constants, hasConfiguredFooter } from 'librechat-data-provider';
import type { TStartupConfig } from 'librechat-data-provider';
import { useGetStartupConfig } from '~/data-provider';
+import { policyUrls } from '~/utils/policies';
import { useLocalize } from '~/hooks';
type FooterProps = {
className?: string;
startupConfig?: FooterStartupConfig | null;
- /** A started conversation keeps only what the deployment configured. The
+ /** A started conversation keeps only the footer the deployment wrote. The
* generic model disclaimer belongs to the welcome screen, where it is first
- * read, but a custom footer, a privacy policy and terms of service are the
- * operator's own content: scoping the disclaimer out must not take their
- * configuration off the screen that used to carry it. With nothing
- * configured, this renders nothing at all. */
+ * read, and the policy links belong where they are agreed to: registration
+ * states the consent with both links, and the welcome screen the
+ * conversation starts from carries them under the composer. With no custom
+ * footer configured, this renders nothing at all. */
configuredOnly?: boolean;
};
@@ -42,10 +43,10 @@ const shellHasConfiguredFooter =
* over. Both decisions read this one answer so they cannot disagree.
*
* Until `/api/config` answers, that answer is the shell's, which is the
- * deployment's own configuration (`librechat.yaml` plus `CUSTOM_FOOTER`). A DB
- * config override that adds or removes a policy link for the caller's tenant,
- * role or user is resolved only by `/api/config`, so on such a deployment the
- * resolved answer — the one that wins here — can differ from the shell's.
+ * deployment's own `CUSTOM_FOOTER`. A DB config override that sets or clears
+ * the footer for the caller's tenant, role or user is resolved only by
+ * `/api/config`, so on such a deployment the resolved answer (the one that
+ * wins here) can differ from the shell's.
*/
export function useConfiguredFooter(): boolean {
const { data: config, isSuccess } = useGetStartupConfig();
@@ -59,23 +60,24 @@ function Footer({ className, startupConfig, configuredOnly = false }: FooterProp
const config = shouldFetchConfig ? fetchedConfig : startupConfig;
const localize = useLocalize();
- const privacyPolicy = config?.interface?.privacyPolicy;
- const termsOfService = config?.interface?.termsOfService;
+ /** The same reading the consent and the auth footer use: a blank url is not
+ * a published policy. */
+ const { privacyPolicyUrl, termsOfServiceUrl } = policyUrls(configuredOnly ? undefined : config);
- const privacyPolicyRender = privacyPolicy?.externalUrl != null && (
-
+ const privacyPolicyRender = privacyPolicyUrl != null && (
+
{localize('com_ui_privacy_policy')}
);
- const termsOfServiceRender = termsOfService?.externalUrl != null && (
-
+ const termsOfServiceRender = termsOfServiceUrl != null && (
+
{localize('com_ui_terms_of_service')}
);
const configuredFooter = typeof config?.customFooter === 'string' ? config.customFooter : null;
- /** The generic disclaimer is the part a conversation drops; operator content is not. */
+ /** The generic disclaimer is the part a conversation drops; the operator's own footer is not. */
const genericFooter = configuredOnly
? ''
: '[LibreChat ' +
diff --git a/client/src/components/Chat/__tests__/Footer.spec.tsx b/client/src/components/Chat/__tests__/Footer.spec.tsx
index c855b746f0..5613b03a4f 100644
--- a/client/src/components/Chat/__tests__/Footer.spec.tsx
+++ b/client/src/components/Chat/__tests__/Footer.spec.tsx
@@ -53,4 +53,58 @@ describe('Footer', () => {
expect(screen.getByRole('link', { name: 'Privacy policy' })).not.toHaveAttribute('target');
expect(screen.getByRole('link', { name: 'Terms of service' })).not.toHaveAttribute('target');
});
+
+ test('leaves the policy links behind once a conversation starts', () => {
+ render(
+ ,
+ );
+
+ expect(screen.getByText('Operator policy')).toBeInTheDocument();
+ expect(screen.queryByRole('link', { name: 'Privacy policy' })).not.toBeInTheDocument();
+ expect(screen.queryByRole('link', { name: 'Terms of service' })).not.toBeInTheDocument();
+ });
+
+ /** `externalUrl` is an optional string, so an operator can set it to nothing;
+ * a link to a blank url points back at the page the reader is on. */
+ test('treats a blank policy url as a policy the deployment never published', () => {
+ const { container } = render(
+ ,
+ );
+
+ expect(screen.queryByRole('link', { name: 'Privacy policy' })).not.toBeInTheDocument();
+ expect(screen.queryByRole('link', { name: 'Terms of service' })).not.toBeInTheDocument();
+ expect(container.querySelector('a[href=""]')).toBeNull();
+ });
+
+ test('places no bar in a conversation whose deployment configured only policies', () => {
+ const { container } = render(
+ ,
+ );
+
+ expect(container).toBeEmptyDOMElement();
+ });
});
diff --git a/client/src/locales/en/translation.json b/client/src/locales/en/translation.json
index c4f97a9d08..d379ff23fd 100644
--- a/client/src/locales/en/translation.json
+++ b/client/src/locales/en/translation.json
@@ -253,6 +253,9 @@
"com_auth_github_login": "Continue with Github",
"com_auth_google_login": "Continue with Google",
"com_auth_here": "HERE",
+ "com_auth_legal_consent": "By continuing, you agree to the Terms of Service and acknowledge the Privacy Policy.",
+ "com_auth_legal_consent_privacy": "By continuing, you acknowledge the Privacy Policy.",
+ "com_auth_legal_consent_terms": "By continuing, you agree to the Terms of Service.",
"com_auth_login": "Login",
"com_auth_login_with_new_password": "You may now login with your new password.",
"com_auth_name_max_length": "Name must be less than 80 characters",
diff --git a/client/src/utils/index.ts b/client/src/utils/index.ts
index 34addf5e1c..7786cf3855 100644
--- a/client/src/utils/index.ts
+++ b/client/src/utils/index.ts
@@ -4,6 +4,7 @@ import { TAskFunction } from '~/common';
import logger from './logger';
export * from './map';
+export * from './policies';
export * from './json';
export * from './icons';
export * from './svg';
diff --git a/client/src/utils/policies.ts b/client/src/utils/policies.ts
new file mode 100644
index 0000000000..00086e9510
--- /dev/null
+++ b/client/src/utils/policies.ts
@@ -0,0 +1,40 @@
+import type { TStartupConfig } from 'librechat-data-provider';
+
+/**
+ * The policy links a deployment published, as the surfaces that render them
+ * agree to read it. `externalUrl` is an optional string, so an operator can
+ * leave it blank; a blank one is not a published policy, because rendered as a
+ * link it points back at the page the reader is on and names a document that
+ * does not exist.
+ */
+export function publishedPolicyUrl(externalUrl?: string): string | undefined {
+ const url = externalUrl?.trim();
+ return url != null && url !== '' ? url : undefined;
+}
+
+type PolicySource = {
+ interface?: Pick, 'privacyPolicy' | 'termsOfService'>;
+};
+
+export function policyUrls(startupConfig: PolicySource | null | undefined) {
+ return {
+ privacyPolicyUrl: publishedPolicyUrl(startupConfig?.interface?.privacyPolicy?.externalUrl),
+ termsOfServiceUrl: publishedPolicyUrl(startupConfig?.interface?.termsOfService?.externalUrl),
+ };
+}
+
+/** Whether the deployment published anything to consent to by continuing. The
+ * auth layout reads this to choose between the consent and its footer bar, so
+ * the two cannot disagree about whether the sentence is on the screen.
+ *
+ * A deployment that asks for the terms to be accepted in a modal has its own
+ * explicit acceptance after sign-in (`routes/Root.tsx`), so a sentence saying
+ * the reader already agreed by continuing would contradict the dialog it is
+ * about to show; those screens keep the bare links they always had. */
+export function hasPublishedPolicies(startupConfig: PolicySource | null | undefined): boolean {
+ if (startupConfig?.interface?.termsOfService?.modalAcceptance === true) {
+ return false;
+ }
+ const { privacyPolicyUrl, termsOfServiceUrl } = policyUrls(startupConfig);
+ return privacyPolicyUrl != null || termsOfServiceUrl != null;
+}
diff --git a/e2e/specs/mock/scenarios/footer-shell-answer.spec.ts b/e2e/specs/mock/scenarios/footer-shell-answer.spec.ts
index 3a5c144771..7768664036 100644
--- a/e2e/specs/mock/scenarios/footer-shell-answer.spec.ts
+++ b/e2e/specs/mock/scenarios/footer-shell-answer.spec.ts
@@ -10,10 +10,9 @@ import { deleteConversations, deleteMessagesByConversation, seedConversations }
* deployment's own configuration, so two cases have to keep working: a document
* that carries no answer at all (the Vite dev server serves `client/index.html`
* itself, and a proxy could strip the script), and a caller whose resolved
- * configuration disagrees with it — a per-tenant, role or user config override
- * of `interface.privacyPolicy` is resolved only by `/api/config`. In both, the
- * resolved answer is the one that decides, and the bar never covers the
- * composer once it has.
+ * configuration disagrees with it, since a per-tenant, role or user override of
+ * `customFooter` is resolved only by `/api/config`. In both, the resolved answer
+ * is the one that decides, and the bar never covers the composer once it has.
*
* The footer is hidden below `sm`, so this runs on the desktop viewport it
* describes.
@@ -103,21 +102,19 @@ test.describe('footer answer in the shell', () => {
}
});
- test('a policy link this caller alone has still clears the composer @scenario:an-override-policy-link-clears-the-composer', async ({
+ test('a footer this caller alone has still clears the composer @scenario:an-override-custom-footer-clears-the-composer', async ({
page,
}) => {
test.setTimeout(60000);
const conversationId = randomUUID();
await seedConversations(getE2EUser().email, [
- { conversationId, title: 'Override policy link', updatedAt: new Date() },
+ { conversationId, title: 'Override custom footer', updatedAt: new Date() },
]);
try {
/** The harness deployment configures no footer, so its document says so:
* this caller's resolved configuration is the one that disagrees. */
- await serveResolvedConfig(page, {
- interface: { privacyPolicy: { externalUrl: 'https://example.com/privacy' } },
- });
+ await serveResolvedConfig(page, { customFooter: CUSTOM_FOOTER });
await page.goto(`/c/${conversationId}`, { timeout: 15000 });
await expect(page.locator(COMPOSER)).toBeVisible();
@@ -126,10 +123,9 @@ test.describe('footer answer in the shell', () => {
'the deployment was expected to report no configured footer',
).toBe(false);
- const policyLink = page.getByRole('link', { name: /privacy/i });
- await expect(policyLink).toBeVisible({ timeout: 15000 });
- await expect(policyLink).toHaveAttribute('href', 'https://example.com/privacy');
- await expectFooterBelowComposer(page, policyLink);
+ const footer = page.getByText(CUSTOM_FOOTER);
+ await expect(footer).toBeVisible({ timeout: 15000 });
+ await expectFooterBelowComposer(page, footer);
/** The bar arrived after the first paint, so the check that matters is the
* composer's action row still taking its own clicks. */
diff --git a/e2e/specs/mock/scenarios/policy-links-placement.spec.ts b/e2e/specs/mock/scenarios/policy-links-placement.spec.ts
new file mode 100644
index 0000000000..0cf881f504
--- /dev/null
+++ b/e2e/specs/mock/scenarios/policy-links-placement.spec.ts
@@ -0,0 +1,147 @@
+import { randomUUID } from 'crypto';
+import { expect, test } from '@playwright/test';
+import type { Page } from '@playwright/test';
+import { getE2EUser } from '../../../setup/user';
+import { deleteConversations, deleteMessagesByConversation, seedConversations } from '../db';
+
+/**
+ * A policy link is read where it is agreed to. Registration states the consent
+ * with both links, and the welcome screen a conversation starts from carries
+ * them under its composer; the conversation itself does not, on every turn of
+ * every thread. What a conversation keeps is the operator's own custom footer.
+ *
+ * The second scenario is the layout half of the same change: the footer bar is
+ * absolutely positioned in a zero-height wrapper, so the composer reserves its
+ * band. A deployment that configures policy links and nothing else now paints
+ * no bar in a conversation, so it must not reserve one either.
+ *
+ * The footer is hidden below `sm`, so this runs on the desktop viewport it
+ * describes.
+ */
+
+const COMPOSER = '[data-testid="composer-surface"]';
+const PRIVACY_URL = 'https://example.com/privacy';
+const TERMS_URL = 'https://example.com/terms';
+
+test.use({ viewport: { width: 1280, height: 800 } });
+
+/** The harness deployment configures no policies, so a spec that needs them
+ * answers the startup config for itself rather than changing the config every
+ * other spec reads. The rest of `interface` is preserved: replacing it would
+ * take permissions and capabilities off the page with it. */
+async function withPolicies(page: Page, policies: Record) {
+ await page.route('**/api/config', async (route) => {
+ const response = await route.fetch();
+ const config = await response.json();
+ await route.fulfill({
+ response,
+ json: { ...config, interface: { ...config.interface, ...policies } },
+ });
+ });
+}
+
+async function composerBottom(page: Page) {
+ const box = await page.locator(COMPOSER).boundingBox();
+ expect(box).not.toBeNull();
+ return Math.round((box?.y ?? 0) + (box?.height ?? 0));
+}
+
+test.describe('policy link placement', () => {
+ test('the policy links leave a started conversation @scenario:policy-links-leave-a-started-conversation', async ({
+ page,
+ }) => {
+ test.setTimeout(60000);
+ const conversationId = randomUUID();
+ await seedConversations(getE2EUser().email, [
+ { conversationId, title: 'Policy link placement', updatedAt: new Date() },
+ ]);
+
+ try {
+ await withPolicies(page, {
+ privacyPolicy: { externalUrl: PRIVACY_URL },
+ termsOfService: { externalUrl: TERMS_URL },
+ });
+
+ await page.goto('/c/new', { timeout: 15000 });
+ await expect(page.locator(`a[href="${PRIVACY_URL}"]`)).toBeVisible({ timeout: 15000 });
+ await expect(page.locator(`a[href="${TERMS_URL}"]`)).toBeVisible();
+
+ await page.goto(`/c/${conversationId}`, { timeout: 15000 });
+ await expect(page.getByRole('textbox', { name: 'Message input' })).toBeVisible();
+ /** The config has answered by now: the welcome screen above read it from
+ * the same cache, so an empty count here is the placement and not a
+ * request still in flight. */
+ await expect(page.locator(`a[href="${PRIVACY_URL}"]`)).toHaveCount(0);
+ await expect(page.locator(`a[href="${TERMS_URL}"]`)).toHaveCount(0);
+ } finally {
+ await deleteMessagesByConversation([conversationId]);
+ await deleteConversations([conversationId]);
+ }
+ });
+
+ test('an empty custom footer reserves no band either @scenario:an-empty-custom-footer-leaves-no-band-in-a-conversation', async ({
+ page,
+ }) => {
+ test.setTimeout(60000);
+ const conversationId = randomUUID();
+ await seedConversations(getE2EUser().email, [
+ { conversationId, title: 'Empty custom footer', updatedAt: new Date() },
+ ]);
+
+ try {
+ await page.goto(`/c/${conversationId}`, { timeout: 15000 });
+ await expect(page.getByRole('textbox', { name: 'Message input' })).toBeVisible();
+ const withoutFooter = await composerBottom(page);
+
+ /** An operator who sets the footer to nothing is suppressing the welcome
+ * screen's disclaimer; a conversation renders no bar for it. */
+ await page.route('**/api/config', async (route) => {
+ const response = await route.fetch();
+ const config = await response.json();
+ await route.fulfill({ response, json: { ...config, customFooter: '' } });
+ });
+ await page.reload({ timeout: 15000 });
+ await expect(page.getByRole('textbox', { name: 'Message input' })).toBeVisible();
+
+ expect(
+ await composerBottom(page),
+ 'the conversation reserved a band for an empty footer',
+ ).toBe(withoutFooter);
+ } finally {
+ await deleteMessagesByConversation([conversationId]);
+ await deleteConversations([conversationId]);
+ }
+ });
+
+ test('a deployment with policies alone reserves no band in a conversation @scenario:a-policy-only-deployment-leaves-no-band-in-a-conversation', async ({
+ page,
+ }) => {
+ test.setTimeout(60000);
+ const conversationId = randomUUID();
+ await seedConversations(getE2EUser().email, [
+ { conversationId, title: 'Policy only clearance', updatedAt: new Date() },
+ ]);
+
+ try {
+ await page.goto(`/c/${conversationId}`, { timeout: 15000 });
+ await expect(page.getByRole('textbox', { name: 'Message input' })).toBeVisible();
+ const withoutPolicies = await composerBottom(page);
+
+ await withPolicies(page, {
+ privacyPolicy: { externalUrl: PRIVACY_URL },
+ termsOfService: { externalUrl: TERMS_URL },
+ });
+ await page.reload({ timeout: 15000 });
+ await expect(page.getByRole('textbox', { name: 'Message input' })).toBeVisible();
+ await expect(page.locator(`a[href="${PRIVACY_URL}"]`)).toHaveCount(0);
+
+ expect(
+ await composerBottom(page),
+ 'the conversation reserved a band for a bar it does not paint',
+ ).toBe(withoutPolicies);
+ } finally {
+ await deleteMessagesByConversation([conversationId]);
+ await deleteConversations([conversationId]);
+ }
+ });
+});
diff --git a/e2e/specs/mock/scenarios/registration-consent.spec.ts b/e2e/specs/mock/scenarios/registration-consent.spec.ts
new file mode 100644
index 0000000000..9bc764a7b7
--- /dev/null
+++ b/e2e/specs/mock/scenarios/registration-consent.spec.ts
@@ -0,0 +1,218 @@
+import { expect, test } from '@playwright/test';
+import type { TStartupConfig } from 'librechat-data-provider';
+import type { Browser, Page } from '@playwright/test';
+
+/**
+ * A deployment's policies are agreed to on the way in, so both ways in state
+ * the consent, with a direct link to each policy it published: the registration
+ * form under its own submit button, the login screen below the provider
+ * buttons. Which of them creates the account is not knowable in the client, and
+ * the sentence is about continuing, which both screens do. It is worded for
+ * what is configured: a deployment that published only one policy must not
+ * claim the reader agreed to the other, and one that published neither says
+ * nothing at all.
+ *
+ * These run unauthenticated, because an authenticated session redirects away
+ * from the auth screens before anything renders.
+ */
+
+const PRIVACY_URL = 'https://example.com/privacy';
+const TERMS_URL = 'https://example.com/terms';
+
+type ConfigOverrides = Partial;
+
+/** The harness deployment configures no policies, so a spec that needs them
+ * answers the startup config for itself. `interface` is merged rather than
+ * replaced: overwriting it would take the page's own capabilities with it. */
+async function withConfig(page: Page, overrides: ConfigOverrides) {
+ await page.route('**/api/config', async (route) => {
+ const response = await route.fetch();
+ const config = (await response.json()) as TStartupConfig;
+ await route.fulfill({
+ response,
+ json: {
+ ...config,
+ ...overrides,
+ interface: { ...config.interface, ...overrides.interface },
+ },
+ });
+ });
+}
+
+/** A signed-out visitor, which is the only one who ever reaches these screens. */
+async function openAuthScreen(
+ browser: Browser,
+ baseURL: string | undefined,
+ path: string,
+ overrides: ConfigOverrides,
+) {
+ const context = await browser.newContext({ storageState: undefined, baseURL });
+ const page = await context.newPage();
+ await withConfig(page, overrides);
+ await page.goto(path, { timeout: 15000 });
+ await expect(page.getByRole('textbox', { name: 'Email' })).toBeVisible({ timeout: 15000 });
+ return { context, page };
+}
+
+const bothPolicies: ConfigOverrides = {
+ interface: {
+ privacyPolicy: { externalUrl: PRIVACY_URL },
+ termsOfService: { externalUrl: TERMS_URL },
+ },
+};
+
+test.describe('registration consent', () => {
+ test('registration states the consent with a link to each policy @scenario:registration-states-the-policy-consent', async ({
+ browser,
+ baseURL,
+ }) => {
+ test.setTimeout(60000);
+ const { context, page } = await openAuthScreen(browser, baseURL, '/register', bothPolicies);
+
+ try {
+ await expect(page.getByText(/By continuing, you agree to the/i)).toBeVisible();
+
+ /** One link each: the screen states the consent instead of also carrying
+ * the footer bar that used to repeat both links beneath it. */
+ const privacy = page.locator(`a[href="${PRIVACY_URL}"]`);
+ const terms = page.locator(`a[href="${TERMS_URL}"]`);
+ await expect(privacy).toHaveCount(1);
+ await expect(terms).toHaveCount(1);
+ await expect(privacy).toBeVisible();
+ await expect(terms).toBeVisible();
+
+ /** The links are read by name, so they carry their own text rather than
+ * leaving a screen reader with the sentence around them. */
+ await expect(privacy).toHaveText('Privacy Policy');
+ await expect(terms).toHaveText('Terms of Service');
+
+ /** Reachable by keyboard, not only by pointer. */
+ await terms.focus();
+ await expect(terms).toBeFocused();
+ } finally {
+ await context.close();
+ }
+ });
+
+ test('the consent names only the policy the deployment published @scenario:registration-consent-names-only-the-published-policy', async ({
+ browser,
+ baseURL,
+ }) => {
+ test.setTimeout(60000);
+ const { context, page } = await openAuthScreen(browser, baseURL, '/register', {
+ interface: { privacyPolicy: { externalUrl: PRIVACY_URL } },
+ });
+
+ try {
+ await expect(page.getByText(/By continuing, you acknowledge the/i)).toBeVisible();
+ await expect(page.locator(`a[href="${PRIVACY_URL}"]`)).toHaveCount(1);
+ await expect(page.getByText(/agree to the Terms of Service/i)).toHaveCount(0);
+ } finally {
+ await context.close();
+ }
+ });
+
+ test('a deployment with no policies states no consent @scenario:registration-without-policies-states-no-consent', async ({
+ browser,
+ baseURL,
+ }) => {
+ test.setTimeout(60000);
+ const { context, page } = await openAuthScreen(browser, baseURL, '/register', {});
+
+ try {
+ await expect(page.getByRole('button', { name: 'Submit registration' })).toBeVisible();
+ await expect(page.getByText(/By continuing/i)).toHaveCount(0);
+ } finally {
+ await context.close();
+ }
+ });
+
+ test('a blank policy url is not a published policy @scenario:a-blank-policy-url-is-not-a-published-policy', async ({
+ browser,
+ baseURL,
+ }) => {
+ test.setTimeout(60000);
+ /** `externalUrl` is an optional string, so this is a configuration an
+ * operator can write; a link to nothing would name a document that does
+ * not exist and navigate back to this page. */
+ const { context, page } = await openAuthScreen(browser, baseURL, '/register', {
+ interface: { privacyPolicy: { externalUrl: '' }, termsOfService: { externalUrl: '' } },
+ });
+
+ try {
+ await expect(page.getByRole('button', { name: 'Submit registration' })).toBeVisible();
+ await expect(page.getByText(/By continuing/i)).toHaveCount(0);
+ await expect(page.locator('a[href=""]')).toHaveCount(0);
+ } finally {
+ await context.close();
+ }
+ });
+
+ test('the login screen states the consent without any provider button @scenario:the-login-screen-states-the-consent', async ({
+ browser,
+ baseURL,
+ }) => {
+ test.setTimeout(60000);
+ /** No provider button is needed for this screen to be a way in: a first
+ * LDAP sign-in creates the account through this very form
+ * (api/strategies/ldapStrategy.js). */
+ const { context, page } = await openAuthScreen(browser, baseURL, '/login', bothPolicies);
+
+ try {
+ await expect(page.getByRole('link', { name: /Continue with/i })).toHaveCount(0);
+ await expect(page.getByText(/By continuing, you agree to the/i)).toBeVisible();
+ await expect(page.locator(`a[href="${PRIVACY_URL}"]`)).toHaveCount(1);
+ await expect(page.locator(`a[href="${TERMS_URL}"]`)).toHaveCount(1);
+ } finally {
+ await context.close();
+ }
+ });
+
+ test('a modal-acceptance deployment keeps the bare links @scenario:a-modal-acceptance-deployment-states-no-passive-consent', async ({
+ browser,
+ baseURL,
+ }) => {
+ test.setTimeout(60000);
+ /** That deployment asks for the terms to be accepted in a dialog after
+ * sign-in, so a sentence saying the reader already agreed by continuing
+ * would contradict the dialog it is about to show. */
+ const { context, page } = await openAuthScreen(browser, baseURL, '/register', {
+ interface: {
+ privacyPolicy: { externalUrl: PRIVACY_URL },
+ termsOfService: { externalUrl: TERMS_URL, modalAcceptance: true },
+ },
+ });
+
+ try {
+ await expect(page.getByText(/By continuing/i)).toHaveCount(0);
+ await expect(page.locator(`a[href="${PRIVACY_URL}"]`)).toHaveCount(1);
+ await expect(page.locator(`a[href="${TERMS_URL}"]`)).toHaveCount(1);
+ } finally {
+ await context.close();
+ }
+ });
+
+ test('a login screen that can create an account states the consent @scenario:a-social-login-screen-states-the-consent', async ({
+ browser,
+ baseURL,
+ }) => {
+ test.setTimeout(60000);
+ /** A provider button on the login screen creates the account on a first
+ * sign-in, so that screen is a place an account is created. */
+ const { context, page } = await openAuthScreen(browser, baseURL, '/login', {
+ ...bothPolicies,
+ socialLoginEnabled: true,
+ googleLoginEnabled: true,
+ socialLogins: ['google'],
+ });
+
+ try {
+ await expect(page.getByRole('link', { name: /Continue with Google/i })).toBeVisible();
+ await expect(page.getByText(/By continuing, you agree to the/i)).toBeVisible();
+ await expect(page.locator(`a[href="${PRIVACY_URL}"]`)).toHaveCount(1);
+ await expect(page.locator(`a[href="${TERMS_URL}"]`)).toHaveCount(1);
+ } finally {
+ await context.close();
+ }
+ });
+});
diff --git a/packages/api/src/html/footer.spec.ts b/packages/api/src/html/footer.spec.ts
index 24631c689d..464e7b8806 100644
--- a/packages/api/src/html/footer.spec.ts
+++ b/packages/api/src/html/footer.spec.ts
@@ -11,35 +11,20 @@ const flagOf = (html: string): boolean | undefined => {
};
describe('injectConfiguredFooterBootstrap', () => {
- it('answers yes for each kind of configured footer content', () => {
+ it('answers yes for the footer the deployment configured', () => {
expect(flagOf(injectConfiguredFooterBootstrap(SHELL, { customFooter: 'Operator' }))).toBe(true);
- expect(
- flagOf(
- injectConfiguredFooterBootstrap(SHELL, {
- interfaceConfig: { privacyPolicy: { externalUrl: 'https://example.com/privacy' } },
- }),
- ),
- ).toBe(true);
- expect(
- flagOf(
- injectConfiguredFooterBootstrap(SHELL, {
- interfaceConfig: { termsOfService: { externalUrl: 'https://example.com/terms' } },
- }),
- ),
- ).toBe(true);
+ expect(flagOf(injectConfiguredFooterBootstrap(SHELL, { customFooter: 'A | B' }))).toBe(true);
});
it('answers no for a deployment that configured nothing', () => {
expect(flagOf(injectConfiguredFooterBootstrap(SHELL, {}))).toBe(false);
expect(flagOf(injectConfiguredFooterBootstrap(SHELL))).toBe(false);
- expect(
- flagOf(
- injectConfiguredFooterBootstrap(SHELL, {
- customFooter: undefined,
- interfaceConfig: { privacyPolicy: {}, termsOfService: {} },
- }),
- ),
- ).toBe(false);
+ expect(flagOf(injectConfiguredFooterBootstrap(SHELL, { customFooter: undefined }))).toBe(false);
+ expect(flagOf(injectConfiguredFooterBootstrap(SHELL, { customFooter: null }))).toBe(false);
+ /** Set to nothing: the welcome screen's disclaimer is suppressed, and a
+ * conversation renders no bar to reserve a band for. */
+ expect(flagOf(injectConfiguredFooterBootstrap(SHELL, { customFooter: '' }))).toBe(false);
+ expect(flagOf(injectConfiguredFooterBootstrap(SHELL, { customFooter: ' ' }))).toBe(false);
});
it('places the answer ahead of the app that reads it', () => {
diff --git a/packages/api/src/html/footer.ts b/packages/api/src/html/footer.ts
index 1352cea1ea..97a78cf658 100644
--- a/packages/api/src/html/footer.ts
+++ b/packages/api/src/html/footer.ts
@@ -1,14 +1,11 @@
import { hasConfiguredFooter } from 'librechat-data-provider';
-import type { TInterfaceConfig } from 'librechat-data-provider';
import { injectBootstrapConfig } from './bootstrap';
const CONFIGURED_FOOTER_SENTINEL = 'data-librechat-configured-footer="true"';
-/** What the deployment configured, as the server holds it: the footer env var
- * and the interface config the app loaded. */
+/** What the deployment configured, as the server holds it: the footer env var. */
export interface ConfiguredFooterSource {
customFooter?: string | null;
- interfaceConfig?: Pick | null;
}
/**
@@ -19,13 +16,9 @@ export interface ConfiguredFooterSource {
* server already knows when it serves the document, so it says so and no client
* has to guess: a first-ever visit to a configured deployment paints the
* composer in its final position instead of correcting by the bar's height.
- * The answer is the deployment's own configuration — `librechat.yaml` plus
- * `CUSTOM_FOOTER` — because the document is served before there is a caller to
- * resolve: a per-tenant, role or user config override of `privacyPolicy` or
- * `termsOfService` is resolved by `/api/config`, and the client prefers that
- * resolved answer over this one. Reading the effective config here would cost
- * an override query on the document that carries the conversation's LCP, and
- * still could not resolve role or user overrides pre-authentication.
+ * The answer is the deployment's own `CUSTOM_FOOTER`, because the document is
+ * served before there is a caller whose config overrides could be resolved; the
+ * client prefers `/api/config`'s resolved answer once it has it.
*
* Always injected, including the negative answer, so an absent flag means "no
* server said" (the Vite dev server) rather than "no footer".
@@ -39,7 +32,6 @@ export const injectConfiguredFooterBootstrap = (
values: {
hasConfiguredFooter: hasConfiguredFooter({
customFooter: source?.customFooter ?? undefined,
- interface: source?.interfaceConfig ?? null,
}),
},
});
diff --git a/packages/data-provider/src/footer.spec.ts b/packages/data-provider/src/footer.spec.ts
index 48686c97bc..bf350b1d84 100644
--- a/packages/data-provider/src/footer.spec.ts
+++ b/packages/data-provider/src/footer.spec.ts
@@ -1,26 +1,20 @@
import { hasConfiguredFooter } from './footer';
describe('hasConfiguredFooter', () => {
- it('is true for any content the deployment configured itself', () => {
+ it('is true for a footer the deployment configured itself', () => {
expect(hasConfiguredFooter({ customFooter: 'Operator policy' })).toBe(true);
- /** An operator who set the footer to nothing still set it. */
- expect(hasConfiguredFooter({ customFooter: '' })).toBe(true);
- expect(
- hasConfiguredFooter({ interface: { privacyPolicy: { externalUrl: 'https://x/privacy' } } }),
- ).toBe(true);
- expect(
- hasConfiguredFooter({ interface: { termsOfService: { externalUrl: 'https://x/terms' } } }),
- ).toBe(true);
+ expect(hasConfiguredFooter({ customFooter: '[Docs](https://example.com)' })).toBe(true);
});
it('is false for a deployment that configured none of it', () => {
expect(hasConfiguredFooter()).toBe(false);
expect(hasConfiguredFooter(null)).toBe(false);
expect(hasConfiguredFooter({})).toBe(false);
- /** The links carry the policy sections, so a section without one is not a
- * footer: this is what the bar renders from. */
- expect(hasConfiguredFooter({ interface: { privacyPolicy: {}, termsOfService: {} } })).toBe(
- false,
- );
+ /** An operator who set the footer to nothing suppressed the welcome
+ * screen's disclaimer; a conversation renders nothing for it, so it must
+ * not reserve the band a bar would need. */
+ expect(hasConfiguredFooter({ customFooter: '' })).toBe(false);
+ /** The bar trims each part, so whitespace is the same nothing. */
+ expect(hasConfiguredFooter({ customFooter: ' ' })).toBe(false);
});
});
diff --git a/packages/data-provider/src/footer.ts b/packages/data-provider/src/footer.ts
index aaac0b8ca4..dd19c2d193 100644
--- a/packages/data-provider/src/footer.ts
+++ b/packages/data-provider/src/footer.ts
@@ -1,31 +1,31 @@
import type { TStartupConfig } from './config';
/**
- * The startup-config fields that put a footer bar beneath a conversation's
+ * The startup-config field that puts a footer bar beneath a conversation's
* composer. Narrow on purpose: the server answers the same question while it
- * serves the HTML shell, reading these fields off its own configuration instead
+ * serves the HTML shell, reading this field off its own configuration instead
* of assembling a startup payload it has no request for.
*/
-export type TConfiguredFooterSource = Pick, 'customFooter'> & {
- interface?: Pick<
- NonNullable,
- 'privacyPolicy' | 'termsOfService'
- > | null;
-};
+export type TConfiguredFooterSource = Pick, 'customFooter'>;
/**
- * Whether a deployment configured footer content of its own — a custom footer,
- * a privacy policy or terms of service.
+ * Whether a deployment configured footer content of its own.
+ *
+ * Only a custom footer with content counts. A privacy policy and terms of
+ * service are read where they are agreed to, on the auth screens, and on the
+ * welcome screen the conversation starts from; a started conversation carries
+ * neither, so neither one puts a bar beneath its composer. A footer of
+ * nothing, or of whitespace the bar trims away, is an operator suppressing the
+ * default disclaimer on the welcome screen; it renders nothing in a
+ * conversation, so it is no bar either.
*
* The footer bar is absolutely positioned in a zero-height wrapper, so the
* composer above it is what reserves its band: this answer decides both the
- * bar and the clearance. The client and the server share it because the two
- * answering differently is exactly the layout correction it exists to remove.
+ * bar and the clearance, and it has to match what the bar renders or the
+ * composer reserves a band for nothing. The client and the server share it
+ * because the two answering differently is exactly the layout correction it
+ * exists to remove.
*/
export function hasConfiguredFooter(source?: TConfiguredFooterSource | null): boolean {
- return (
- typeof source?.customFooter === 'string' ||
- source?.interface?.privacyPolicy?.externalUrl != null ||
- source?.interface?.termsOfService?.externalUrl != null
- );
+ return typeof source?.customFooter === 'string' && source.customFooter.trim() !== '';
}