mirror of
https://github.com/danny-avila/LibreChat.git
synced 2026-11-16 13:00:55 +00:00
🔐 fix: Encrypt User Plugin Credentials With Random-IV v3 Format (#16996)
* fix: Encrypt User Plugin Credentials With Random-IV v3 Format * test: Cover Credential Encryption Formats in Mock E2E Scenarios * test: Round-Trip Real Credential Helpers in PluginService Spec * 🙈 fix: Remove SharePoint Picker Payload Logging (#16997) * fix: Add credentials.writeFormat to Gate v3 Credential Writes During Rollouts * test: Expect 201 When the Legacy Write Format Override Is Created * 🔊 fix: Clear TTS Audio Cache On Session End and Hash Its Keys (#16998) * fix: Clear TTS Audio Cache On Session End and Hash Its Keys * fix: Read Manual TTS Replays From the Hashed Cache Key * fix: Purge Legacy TTS Cache Keys and Fence Writes Across Logout * fix: Keep TTS Cache Writes Off the Playback Path * test: Expect Hashed Keys in the StreamAudio Cache Lookup * test: Use a Single-Token Reply Label in the TTS Cache Scenario * fix: Settle TTS Cache Clear Before IdP Logout and Across Tabs * test: Cover the TTS Cache Fence When Another Tab Logs Out * test: Wait for the Second Tab Before Logging Out in the TTS Scenario * fix: Latch TTS Cache Writes Shut Until the Tab Authenticates Again * fix: Reopen TTS Cache Writes When Authentication Completes In Place * fix: Leave for the IdP Even When TTS Cache Cleanup Fails * fix: Retry a Failed Legacy TTS Purge and Fence Other Tabs on Manual Clear * fix: Rerun the Legacy TTS Purge After Each Clear and Sign-In * fix: Rerun the Legacy TTS Purge When Another Tab Clears * fix: Fence Pre-Auth TTS Writes, Retry Failed Clears, and Fall Back to Storage Events * fix: Version the Hashed TTS Cache Key Path * fix: Move TTS Audio to a New Cache and Keep It Closed Until a Failed Clear Succeeds * fix: Persist a Pending TTS Cache Delete Across Navigation * fix: Reopen TTS Caching Only on Session Start and Fence Cache Reads * fix: Keep the TTS Delete Fence in Cache Storage and Close Reads After Logout * refactor: Keep Read-Aloud Audio in Tab Memory Instead of Cache Storage * test: Return to the Conversation After Re-Login in the TTS Logout Scenario * test: Close the Phone Sidebar Before Replaying in the TTS Logout Scenario * fix: Bound the In-Memory TTS Cache by Size as Well as Count * fix: Scope Cached TTS Audio to the Signed-In User * fix: Keep the Settings Cache Delete Available While Legacy Audio Remains * fix: Recheck Legacy TTS Audio After a Settings Clear and on Unowned Handoff * fix: Fence TTS Writes Started Before an Account Signs In * test: Opt the Fresh TTS Account Into Enter-to-Send
This commit is contained in:
parent
8829a3975c
commit
a06ee14b75
31 changed files with 1476 additions and 85 deletions
|
|
@ -312,7 +312,13 @@ const updateUserPluginsController = async (req, res) => {
|
|||
authService =
|
||||
pluginKey === Tools.web_search && value === ''
|
||||
? await deleteUserPluginAuth(user.id, field)
|
||||
: await updateUserPluginAuth(user.id, field, pluginKey, value);
|
||||
: await updateUserPluginAuth(
|
||||
user.id,
|
||||
field,
|
||||
pluginKey,
|
||||
value,
|
||||
appConfig?.credentials?.writeFormat,
|
||||
);
|
||||
if (authService instanceof Error) {
|
||||
logger.error('[authService]', authService);
|
||||
({ status, message } = normalizeHttpError(authService));
|
||||
|
|
|
|||
|
|
@ -226,6 +226,7 @@ describe('updateUserPluginsController', () => {
|
|||
await updateUserPluginsController(
|
||||
{
|
||||
config: {
|
||||
credentials: { writeFormat: 'legacy' },
|
||||
webSearch: {
|
||||
keenableApiKey: '${KEENABLE_API_KEY}',
|
||||
keenableApiUrl: '${KEENABLE_API_URL}',
|
||||
|
|
@ -253,6 +254,7 @@ describe('updateUserPluginsController', () => {
|
|||
'KEENABLE_API_KEY',
|
||||
'web_search',
|
||||
'new-key',
|
||||
'legacy',
|
||||
);
|
||||
for (const selectionField of Object.values(webSearchSelectionFields)) {
|
||||
expect(updateUserPluginAuth).not.toHaveBeenCalledWith(
|
||||
|
|
@ -260,6 +262,7 @@ describe('updateUserPluginsController', () => {
|
|||
selectionField,
|
||||
'web_search',
|
||||
expect.anything(),
|
||||
expect.anything(),
|
||||
);
|
||||
}
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
const { logger } = require('@librechat/data-schemas');
|
||||
const { encrypt, decrypt } = require('@librechat/api');
|
||||
const { encryptCredential, decryptCredential } = require('@librechat/api');
|
||||
const { findOnePluginAuth, updatePluginAuth, deletePluginAuth } = require('~/models');
|
||||
|
||||
/**
|
||||
|
|
@ -47,7 +47,7 @@ const getUserPluginAuthValue = async (userId, authField, throwError = true, plug
|
|||
throw error;
|
||||
}
|
||||
|
||||
const decryptedValue = await decrypt(pluginAuth.value);
|
||||
const decryptedValue = await decryptCredential(pluginAuth.value);
|
||||
return decryptedValue;
|
||||
} catch (err) {
|
||||
if (!throwError) {
|
||||
|
|
@ -92,12 +92,13 @@ const getUserPluginAuthValue = async (userId, authField, throwError = true, plug
|
|||
* @param {string} authField
|
||||
* @param {string} pluginKey
|
||||
* @param {string} value
|
||||
* @param {'v3' | 'legacy'} [writeFormat] - `credentials.writeFormat` from the app config
|
||||
* @returns {Promise<IPluginAuth>}
|
||||
* @throws {Error}
|
||||
*/
|
||||
const updateUserPluginAuth = async (userId, authField, pluginKey, value) => {
|
||||
const updateUserPluginAuth = async (userId, authField, pluginKey, value, writeFormat) => {
|
||||
try {
|
||||
const encryptedValue = await encrypt(value);
|
||||
const encryptedValue = await encryptCredential(value, writeFormat);
|
||||
return await updatePluginAuth({
|
||||
userId,
|
||||
authField,
|
||||
|
|
|
|||
|
|
@ -1,22 +1,24 @@
|
|||
const mockLoggerError = jest.fn();
|
||||
const mockFindOnePluginAuth = jest.fn();
|
||||
const mockUpdatePluginAuth = jest.fn();
|
||||
|
||||
jest.mock('@librechat/data-schemas', () => ({
|
||||
...jest.requireActual('@librechat/data-schemas'),
|
||||
logger: { error: mockLoggerError },
|
||||
}));
|
||||
|
||||
jest.mock('@librechat/api', () => ({
|
||||
encrypt: jest.fn(),
|
||||
decrypt: jest.fn(),
|
||||
}));
|
||||
jest.mock('@librechat/api', () => {
|
||||
const { encryptCredential, decryptCredential } = jest.requireActual('@librechat/api');
|
||||
return { encryptCredential, decryptCredential };
|
||||
});
|
||||
|
||||
jest.mock('~/models', () => ({
|
||||
findOnePluginAuth: (...args) => mockFindOnePluginAuth(...args),
|
||||
updatePluginAuth: jest.fn(),
|
||||
updatePluginAuth: (...args) => mockUpdatePluginAuth(...args),
|
||||
deletePluginAuth: jest.fn(),
|
||||
}));
|
||||
|
||||
const { getUserPluginAuthValue } = require('./PluginService');
|
||||
const { getUserPluginAuthValue, updateUserPluginAuth } = require('./PluginService');
|
||||
|
||||
describe('getUserPluginAuthValue', () => {
|
||||
beforeEach(() => {
|
||||
|
|
@ -44,3 +46,42 @@ describe('getUserPluginAuthValue', () => {
|
|||
expect(mockLoggerError).toHaveBeenCalledWith('[getUserPluginAuthValue]', error);
|
||||
});
|
||||
});
|
||||
|
||||
describe('plugin auth encryption', () => {
|
||||
beforeEach(() => {
|
||||
jest.clearAllMocks();
|
||||
});
|
||||
|
||||
it('stores a random-IV v3 value that reads back as the plaintext', async () => {
|
||||
mockUpdatePluginAuth.mockImplementation(async (doc) => doc);
|
||||
|
||||
await updateUserPluginAuth('user-id', 'API_KEY', 'plugin', 'plain');
|
||||
await updateUserPluginAuth('user-id', 'API_KEY', 'plugin', 'plain');
|
||||
|
||||
const [first, second] = mockUpdatePluginAuth.mock.calls.map(([doc]) => doc.value);
|
||||
expect(first).toMatch(/^v3:[0-9a-f]{32}:[0-9a-f]+$/);
|
||||
expect(second).not.toBe(first);
|
||||
|
||||
mockFindOnePluginAuth.mockResolvedValue({ value: first });
|
||||
await expect(getUserPluginAuthValue('user-id', 'API_KEY')).resolves.toBe('plain');
|
||||
});
|
||||
|
||||
it('stores the legacy fixed-IV format when the write format is legacy', async () => {
|
||||
const { encrypt } = jest.requireActual('@librechat/data-schemas');
|
||||
mockUpdatePluginAuth.mockImplementation(async (doc) => doc);
|
||||
|
||||
await updateUserPluginAuth('user-id', 'API_KEY', 'plugin', 'plain', 'legacy');
|
||||
|
||||
const [[{ value }]] = mockUpdatePluginAuth.mock.calls;
|
||||
expect(value).toBe(await encrypt('plain'));
|
||||
mockFindOnePluginAuth.mockResolvedValue({ value });
|
||||
await expect(getUserPluginAuthValue('user-id', 'API_KEY')).resolves.toBe('plain');
|
||||
});
|
||||
|
||||
it('reads a value stored in the legacy fixed-IV format', async () => {
|
||||
const { encrypt } = jest.requireActual('@librechat/data-schemas');
|
||||
mockFindOnePluginAuth.mockResolvedValue({ value: await encrypt('legacy-plain') });
|
||||
|
||||
await expect(getUserPluginAuthValue('user-id', 'API_KEY')).resolves.toBe('legacy-plain');
|
||||
});
|
||||
});
|
||||
|
|
|
|||
|
|
@ -10,9 +10,15 @@ import {
|
|||
MediaSourceAppender,
|
||||
usePauseGlobalAudio,
|
||||
} from '~/hooks/Audio';
|
||||
import {
|
||||
logger,
|
||||
getTTSCacheKey,
|
||||
setCachedTTSAudio,
|
||||
getCachedTTSAudio,
|
||||
getTTSCacheGeneration,
|
||||
} from '~/utils';
|
||||
import { useAuthContext } from '~/hooks';
|
||||
import { globalAudioId } from '~/common';
|
||||
import { logger } from '~/utils';
|
||||
import store from '~/store';
|
||||
|
||||
function timeoutPromise(ms: number, message?: string) {
|
||||
|
|
@ -25,7 +31,7 @@ const promiseTimeoutMessage = 'Reader promise timed out';
|
|||
const maxPromiseTime = 15000;
|
||||
|
||||
export default function StreamAudio({ index = 0 }) {
|
||||
const { token } = useAuthContext();
|
||||
const { token, user } = useAuthContext();
|
||||
|
||||
const cacheTTS = useRecoilValue(store.cacheTTS);
|
||||
const playbackRate = useRecoilValue(store.playbackRate);
|
||||
|
|
@ -57,6 +63,7 @@ export default function StreamAudio({ index = 0 }) {
|
|||
|
||||
async function fetchAudio() {
|
||||
setIsFetching(true);
|
||||
const generation = getTTSCacheGeneration();
|
||||
let mediaSource: MediaSourceAppender | undefined;
|
||||
|
||||
try {
|
||||
|
|
@ -68,15 +75,15 @@ export default function StreamAudio({ index = 0 }) {
|
|||
|
||||
/** Keyed by the spoken text, as manual playback is, so audio cached from an
|
||||
* unfiltered message (reasoning included) is never replayed. */
|
||||
let cacheKey = latestMessage ? getSpeechText(latestMessage) : '';
|
||||
const cache = await caches.open('tts-responses');
|
||||
const cachedResponse = await cache.match(cacheKey);
|
||||
let cacheKey = latestMessage
|
||||
? await getTTSCacheKey(getSpeechText(latestMessage), voice, user?.id)
|
||||
: null;
|
||||
const cachedAudio = cacheKey ? getCachedTTSAudio(cacheKey) : undefined;
|
||||
|
||||
setAudioRunId(activeRunId);
|
||||
if (cachedResponse) {
|
||||
if (cachedAudio) {
|
||||
logger.log('Audio found in cache');
|
||||
const audioBlob = await cachedResponse.blob();
|
||||
const blobUrl = URL.createObjectURL(audioBlob);
|
||||
const blobUrl = URL.createObjectURL(cachedAudio);
|
||||
setGlobalAudioURL(blobUrl);
|
||||
setIsFetching(false);
|
||||
return;
|
||||
|
|
@ -141,12 +148,14 @@ export default function StreamAudio({ index = 0 }) {
|
|||
const targetMessage = latestMessages.find(
|
||||
(msg) => msg.messageId === latestMessage?.messageId,
|
||||
);
|
||||
cacheKey = targetMessage ? getSpeechText(targetMessage) : '';
|
||||
cacheKey = targetMessage
|
||||
? await getTTSCacheKey(getSpeechText(targetMessage), voice, user?.id)
|
||||
: null;
|
||||
if (!cacheKey) {
|
||||
logger.warn('Cache key not found, skipping audio cache');
|
||||
} else {
|
||||
logger.log('Adding audio to cache');
|
||||
await cache.put(cacheKey, new Response(audioBlob));
|
||||
setCachedTTSAudio(cacheKey, audioBlob, generation);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -181,6 +190,7 @@ export default function StreamAudio({ index = 0 }) {
|
|||
audioRef,
|
||||
voice,
|
||||
token,
|
||||
user?.id,
|
||||
]);
|
||||
|
||||
useEffect(() => {
|
||||
|
|
|
|||
|
|
@ -1,10 +1,13 @@
|
|||
import React from 'react';
|
||||
import { TextEncoder } from 'util';
|
||||
import { webcrypto } from 'crypto';
|
||||
import { RecoilRoot } from 'recoil';
|
||||
import { render, waitFor } from '@testing-library/react';
|
||||
import { MemoryRouter, Routes, Route } from 'react-router-dom';
|
||||
import { Constants, QueryKeys } from 'librechat-data-provider';
|
||||
import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
|
||||
import type { TMessage, TConversation } from 'librechat-data-provider';
|
||||
import { getTTSCacheKey, setCachedTTSAudio, getTTSCacheGeneration } from '~/utils';
|
||||
import StreamAudio from '../StreamAudio';
|
||||
import store from '~/store';
|
||||
|
||||
|
|
@ -12,15 +15,14 @@ jest.mock('~/hooks', () => ({ useAuthContext: () => ({ token: 'token' }) }));
|
|||
|
||||
const conversationId = 'convo-1';
|
||||
|
||||
const match = jest.fn(async (_key: string) => ({ blob: async () => new Blob() }));
|
||||
const recording = new Blob(['spoken answer'], { type: 'audio/mpeg' });
|
||||
const fetchMock = jest.fn(() => Promise.reject(new Error('not cached')));
|
||||
|
||||
describe('StreamAudio cache', () => {
|
||||
beforeAll(() => {
|
||||
Object.defineProperty(global, 'caches', {
|
||||
writable: true,
|
||||
configurable: true,
|
||||
value: { open: async () => ({ match, put: jest.fn() }) },
|
||||
});
|
||||
Object.defineProperty(global, 'crypto', { value: webcrypto, configurable: true });
|
||||
Object.assign(global, { TextEncoder });
|
||||
Object.assign(global, { fetch: fetchMock });
|
||||
URL.createObjectURL = jest.fn(() => 'blob:audio');
|
||||
URL.revokeObjectURL = jest.fn();
|
||||
});
|
||||
|
|
@ -28,6 +30,8 @@ describe('StreamAudio cache', () => {
|
|||
/** Audio cached before reasoning was filtered is keyed by the full text; looking up the
|
||||
* spoken answer instead means that recording is never replayed. */
|
||||
it('looks up cached audio by the spoken answer, not the stored text', async () => {
|
||||
const key = await getTTSCacheKey('The capital of Germany is Berlin.');
|
||||
setCachedTTSAudio(key as string, recording, getTTSCacheGeneration());
|
||||
const message = {
|
||||
messageId: 'assistant-1',
|
||||
conversationId,
|
||||
|
|
@ -58,7 +62,7 @@ describe('StreamAudio cache', () => {
|
|||
</QueryClientProvider>,
|
||||
);
|
||||
|
||||
await waitFor(() => expect(match).toHaveBeenCalled());
|
||||
expect(match).toHaveBeenCalledWith('The capital of Germany is Berlin.');
|
||||
await waitFor(() => expect(URL.createObjectURL).toHaveBeenCalledWith(recording));
|
||||
expect(fetchMock).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
|
|
|||
|
|
@ -9,6 +9,7 @@ import {
|
|||
InfoHoverCard,
|
||||
useOnClickOutside,
|
||||
} from '@librechat/client';
|
||||
import { clearTTSCache, hasLegacyTTSCache, hasCachedTTSAudio } from '~/utils';
|
||||
import { useLocalize } from '~/hooks';
|
||||
import { ESide } from '~/common';
|
||||
|
||||
|
|
@ -22,9 +23,7 @@ export const DeleteCache = ({ disabled = false }: { disabled?: boolean }) => {
|
|||
useOnClickOutside(contentRef, () => confirmClear && setConfirmClear(false), []);
|
||||
|
||||
const checkCache = useCallback(async () => {
|
||||
const cache = await caches.open('tts-responses');
|
||||
const keys = await cache.keys();
|
||||
setIsCacheEmpty(keys.length === 0);
|
||||
setIsCacheEmpty(!hasCachedTTSAudio() && !(await hasLegacyTTSCache()));
|
||||
}, []);
|
||||
|
||||
useEffect(() => {
|
||||
|
|
@ -33,10 +32,11 @@ export const DeleteCache = ({ disabled = false }: { disabled?: boolean }) => {
|
|||
|
||||
const revokeAllUserKeys = useCallback(async () => {
|
||||
setIsLoading(true);
|
||||
const cache = await caches.open('tts-responses');
|
||||
await cache.keys().then((keys) => Promise.all(keys.map((key) => cache.delete(key))));
|
||||
await clearTTSCache();
|
||||
/** A legacy delete that failed leaves the action available for another try. */
|
||||
await checkCache();
|
||||
setIsLoading(false);
|
||||
}, []);
|
||||
}, [checkCache]);
|
||||
|
||||
return (
|
||||
<div className="flex items-center justify-between">
|
||||
|
|
|
|||
|
|
@ -0,0 +1,59 @@
|
|||
import React from 'react';
|
||||
import { fireEvent, render, screen, waitFor } from '@testing-library/react';
|
||||
import { clearTTSCache, setCachedTTSAudio, getTTSCacheGeneration } from '~/utils';
|
||||
import { DeleteCache } from '../DeleteCache';
|
||||
|
||||
jest.mock('~/hooks', () => ({
|
||||
useLocalize: () => (key: string) => key,
|
||||
}));
|
||||
|
||||
const deleteButton = () => screen.getByRole('button', { name: 'com_nav_delete_cache_storage' });
|
||||
|
||||
describe('DeleteCache', () => {
|
||||
const has = jest.fn(async (_name: string) => false);
|
||||
|
||||
beforeEach(() => {
|
||||
has.mockResolvedValue(false);
|
||||
Object.defineProperty(globalThis, 'caches', {
|
||||
value: { has, delete: jest.fn(async () => true) },
|
||||
configurable: true,
|
||||
});
|
||||
clearTTSCache();
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
Reflect.deleteProperty(globalThis, 'caches');
|
||||
});
|
||||
|
||||
it('is disabled when nothing is cached in memory or left on disk', async () => {
|
||||
render(<DeleteCache />);
|
||||
await waitFor(() => expect(has).toHaveBeenCalled());
|
||||
expect(deleteButton()).toBeDisabled();
|
||||
});
|
||||
|
||||
it('is enabled while audio is cached in this tab', async () => {
|
||||
setCachedTTSAudio('key', new Blob(['audio']), getTTSCacheGeneration());
|
||||
render(<DeleteCache />);
|
||||
await waitFor(() => expect(deleteButton()).toBeEnabled());
|
||||
});
|
||||
|
||||
it("stays available when an earlier build's cache could not be deleted at startup", async () => {
|
||||
has.mockImplementation(async (name: string) => name === 'tts-responses');
|
||||
render(<DeleteCache />);
|
||||
await waitFor(() => expect(deleteButton()).toBeEnabled());
|
||||
});
|
||||
|
||||
it('stays available after a delete whose legacy cache could not be removed', async () => {
|
||||
setCachedTTSAudio('key', new Blob(['audio']), getTTSCacheGeneration());
|
||||
has.mockImplementation(async (name: string) => name === 'tts-responses');
|
||||
render(<DeleteCache />);
|
||||
await waitFor(() => expect(deleteButton()).toBeEnabled());
|
||||
|
||||
has.mockClear();
|
||||
fireEvent.click(deleteButton());
|
||||
fireEvent.click(await screen.findByRole('button', { name: 'com_ui_delete' }));
|
||||
/** The recheck after the delete finds the legacy cache still there. */
|
||||
await waitFor(() => expect(has).toHaveBeenCalled());
|
||||
expect(deleteButton()).toBeEnabled();
|
||||
});
|
||||
});
|
||||
|
|
@ -160,7 +160,7 @@ export const useSharePointBatchDownload = (): UseMutationResult<
|
|||
|
||||
return downloadedFile;
|
||||
} catch (error) {
|
||||
console.error(`Failed to download ${file.name}:`, error);
|
||||
console.error('SharePoint file download failed');
|
||||
failed.push(file.name);
|
||||
completed++;
|
||||
onProgress?.({
|
||||
|
|
@ -183,7 +183,7 @@ export const useSharePointBatchDownload = (): UseMutationResult<
|
|||
}
|
||||
|
||||
if (failed.length > 0) {
|
||||
console.warn(`Failed to download ${failed.length} files:`, failed);
|
||||
console.warn(`Failed to download ${failed.length} files`);
|
||||
}
|
||||
|
||||
return downloadedFiles;
|
||||
|
|
|
|||
|
|
@ -25,7 +25,9 @@ import {
|
|||
import type * as t from 'librechat-data-provider';
|
||||
import type { ReactNode } from 'react';
|
||||
import {
|
||||
clearTTSCache,
|
||||
isSafeRedirect,
|
||||
setTTSCacheOwner,
|
||||
getPostLoginRedirect,
|
||||
clearPostLoginRedirect,
|
||||
persistRedirectToSession,
|
||||
|
|
@ -66,6 +68,7 @@ const endSessionClientState = (): void => {
|
|||
clearRetainedFileDeletions();
|
||||
clearComposerDraftStorage();
|
||||
endPullRequestSession();
|
||||
void clearTTSCache();
|
||||
};
|
||||
/**
|
||||
* Only recognized codes override the HTTP status used by the login error translation.
|
||||
|
|
@ -119,6 +122,8 @@ const AuthContextProvider = ({
|
|||
setIsAuthReady(true);
|
||||
if (isAuthenticated) {
|
||||
setQueriesEnabled(true);
|
||||
/** A different account signing in without a logout must not inherit cached audio. */
|
||||
setTTSCacheOwner(user?.id);
|
||||
/**
|
||||
* Any accepted full-auth response supersedes a staged enrollment, whichever path minted
|
||||
* it. The setup endpoints trust the stored bearer independently of the session, so a
|
||||
|
|
@ -259,6 +264,7 @@ const AuthContextProvider = ({
|
|||
setIsAuthReady(true);
|
||||
setQueriesEnabled(true);
|
||||
openFileDeletionRetention();
|
||||
setTTSCacheOwner(authenticatedUser.id);
|
||||
navigate(redirect, { replace: true });
|
||||
},
|
||||
[navigate, setQueriesEnabled, setUser],
|
||||
|
|
|
|||
|
|
@ -67,7 +67,6 @@ export default function useSharePointPicker({
|
|||
try {
|
||||
switch (message.data.type) {
|
||||
case 'notification':
|
||||
console.log('SharePoint picker notification:', message.data);
|
||||
break;
|
||||
|
||||
case 'command': {
|
||||
|
|
@ -78,13 +77,9 @@ export default function useSharePointPicker({
|
|||
});
|
||||
|
||||
const command = message.data.data;
|
||||
console.log('SharePoint picker command:', command);
|
||||
|
||||
switch (command.command) {
|
||||
case 'authenticate':
|
||||
console.log('Authentication requested, providing token');
|
||||
console.log('Command details:', command); // Add this line
|
||||
console.log('Token available:', !!token?.access_token); // Add this line
|
||||
if (token?.access_token) {
|
||||
port.postMessage({
|
||||
type: 'result',
|
||||
|
|
@ -111,7 +106,6 @@ export default function useSharePointPicker({
|
|||
break;
|
||||
|
||||
case 'close':
|
||||
console.log('Close command received');
|
||||
port.postMessage({
|
||||
type: 'result',
|
||||
id: message.data.id,
|
||||
|
|
@ -123,10 +117,7 @@ export default function useSharePointPicker({
|
|||
break;
|
||||
|
||||
case 'pick': {
|
||||
console.log('Files picked from SharePoint:', command);
|
||||
|
||||
const items = command.items || command.files || [];
|
||||
console.log('Extracted items:', items);
|
||||
|
||||
if (items && items.length > 0) {
|
||||
const selectedFiles = items.map((item: any) => ({
|
||||
|
|
@ -144,8 +135,6 @@ export default function useSharePointPicker({
|
|||
sharePointItem: item,
|
||||
}));
|
||||
|
||||
console.log('Processed SharePoint files:', selectedFiles);
|
||||
|
||||
if (onFilesSelected) {
|
||||
onFilesSelected(selectedFiles);
|
||||
}
|
||||
|
|
@ -185,7 +174,6 @@ export default function useSharePointPicker({
|
|||
}
|
||||
|
||||
default:
|
||||
console.log('Unknown message type:', message.data.type);
|
||||
break;
|
||||
}
|
||||
} catch (error) {
|
||||
|
|
@ -198,18 +186,11 @@ export default function useSharePointPicker({
|
|||
// Initialization message handler - establishes MessagePort communication
|
||||
const initMessageHandler = useCallback(
|
||||
(event: MessageEvent) => {
|
||||
console.log('=== SharePoint picker init message received ===');
|
||||
console.log('Event source:', event.source);
|
||||
console.log('Event data:', event.data);
|
||||
console.log('Expected channelId:', channelIdRef.current);
|
||||
|
||||
// Check if this message is from our iframe
|
||||
if (event.source && event.source === iframeRef.current?.contentWindow) {
|
||||
const message = event.data;
|
||||
|
||||
if (message.type === 'initialize' && message.channelId === channelIdRef.current) {
|
||||
console.log('Establishing MessagePort communication');
|
||||
|
||||
// Get the MessagePort from the event
|
||||
portRef.current = event.ports[0];
|
||||
|
||||
|
|
@ -222,8 +203,6 @@ export default function useSharePointPicker({
|
|||
portRef.current.postMessage({
|
||||
type: 'activate',
|
||||
});
|
||||
|
||||
console.log('MessagePort established and activated');
|
||||
} else {
|
||||
console.error('No MessagePort found in initialize event');
|
||||
}
|
||||
|
|
@ -251,15 +230,6 @@ export default function useSharePointPicker({
|
|||
const channelId = generateChannelId();
|
||||
channelIdRef.current = channelId;
|
||||
|
||||
console.log('=== SharePoint File Picker v8 (MessagePort) ===');
|
||||
console.log('Token available:', {
|
||||
hasToken: !!token.access_token,
|
||||
tokenType: token.token_type,
|
||||
expiresIn: token.expires_in,
|
||||
scopes: token.scope,
|
||||
});
|
||||
console.log('Channel ID:', channelId);
|
||||
|
||||
const pickerOptions: SPPickerConfig = {
|
||||
sdk: '8.0',
|
||||
entry: {
|
||||
|
|
|
|||
|
|
@ -1,8 +1,14 @@
|
|||
import { useState, useMemo, useRef, useCallback, useEffect } from 'react';
|
||||
import { useRecoilValue } from 'recoil';
|
||||
import { useToastContext } from '@librechat/client';
|
||||
import {
|
||||
getTTSCacheKey,
|
||||
setCachedTTSAudio,
|
||||
getCachedTTSAudio,
|
||||
getTTSCacheGeneration,
|
||||
} from '~/utils';
|
||||
import { useTextToSpeechMutation, useVoicesQuery } from '~/data-provider';
|
||||
import { useLocalize } from '~/hooks';
|
||||
import { useLocalize, useAuthContext } from '~/hooks';
|
||||
import store from '~/store';
|
||||
|
||||
const createFormData = (text: string, voice: string) => {
|
||||
|
|
@ -28,6 +34,7 @@ function useTextToSpeechExternal({
|
|||
index = 0,
|
||||
}: TUseTTSExternal) {
|
||||
const localize = useLocalize();
|
||||
const { user } = useAuthContext();
|
||||
const { showToast } = useToastContext();
|
||||
const voice = useRecoilValue(store.voice);
|
||||
const cacheTTS = useRecoilValue(store.cacheTTS);
|
||||
|
|
@ -36,6 +43,8 @@ function useTextToSpeechExternal({
|
|||
const [downloadFile, setDownloadFile] = useState(false);
|
||||
|
||||
const promiseAudioRef = useRef<HTMLAudioElement | null>(null);
|
||||
/** The cache generation each request started in, so audio from before a logout is not kept. */
|
||||
const requestGenerations = useRef(new WeakMap<FormData, number>());
|
||||
|
||||
/* Global Audio Variables */
|
||||
const globalIsFetching = useRecoilValue(store.globalAudioFetchingFamily(index));
|
||||
|
|
@ -105,11 +114,12 @@ function useTextToSpeechExternal({
|
|||
const inputText = (variables.get('input') ?? '') as string;
|
||||
const audioBlob = new Blob([data], { type: 'audio/mpeg' });
|
||||
|
||||
if (cacheTTS && inputText) {
|
||||
const cache = await caches.open('tts-responses');
|
||||
const request = new Request(inputText);
|
||||
const response = new Response(audioBlob);
|
||||
cache.put(request, response);
|
||||
const generation = requestGenerations.current.get(variables);
|
||||
if (cacheTTS && inputText && generation != null) {
|
||||
/** Not awaited: caching must never delay playback. */
|
||||
void getTTSCacheKey(inputText, (variables.get('voice') ?? '') as string, user?.id).then(
|
||||
(cacheKey) => cacheKey && setCachedTTSAudio(cacheKey, audioBlob, generation),
|
||||
);
|
||||
}
|
||||
|
||||
const blobUrl = URL.createObjectURL(audioBlob);
|
||||
|
|
@ -134,6 +144,7 @@ function useTextToSpeechExternal({
|
|||
|
||||
const startMutation = (text: string, download: boolean) => {
|
||||
const formData = createFormData(text, voice ?? '');
|
||||
requestGenerations.current.set(formData, getTTSCacheGeneration());
|
||||
setDownloadFile(download);
|
||||
processAudio(formData);
|
||||
};
|
||||
|
|
@ -147,12 +158,12 @@ function useTextToSpeechExternal({
|
|||
};
|
||||
|
||||
const handleCachedResponse = async (text: string, download: boolean) => {
|
||||
const cachedResponse = await caches.match(text);
|
||||
if (!cachedResponse) {
|
||||
const cacheKey = await getTTSCacheKey(text, voice ?? '', user?.id);
|
||||
const cachedAudio = cacheKey ? getCachedTTSAudio(cacheKey) : undefined;
|
||||
if (!cachedAudio) {
|
||||
return startMutation(text, download);
|
||||
}
|
||||
const audioBlob = await cachedResponse.blob();
|
||||
const blobUrl = URL.createObjectURL(audioBlob);
|
||||
const blobUrl = URL.createObjectURL(cachedAudio);
|
||||
if (download) {
|
||||
downloadAudio(blobUrl);
|
||||
} else {
|
||||
|
|
|
|||
|
|
@ -14,18 +14,21 @@ import {
|
|||
persistTwoFactorSetupToken,
|
||||
} from 'librechat-data-provider';
|
||||
import type { TAuthConfig } from '~/common';
|
||||
import {
|
||||
SESSION_KEY,
|
||||
getCachedTTSAudio,
|
||||
setCachedTTSAudio,
|
||||
retainFileDeletion,
|
||||
getTTSCacheGeneration,
|
||||
clearRetainedFileDeletions,
|
||||
takeRetainedFileDeletions,
|
||||
} from '~/utils';
|
||||
import {
|
||||
chatFilterStatusAtom,
|
||||
chatFilterTagsAtom,
|
||||
chatSortAtom,
|
||||
resetChatFilterSessionAtom,
|
||||
} from '~/components/Conversations/chatFilters';
|
||||
import {
|
||||
SESSION_KEY,
|
||||
retainFileDeletion,
|
||||
clearRetainedFileDeletions,
|
||||
takeRetainedFileDeletions,
|
||||
} from '~/utils';
|
||||
import { AuthContextProvider, useAuthContext } from '../AuthContext';
|
||||
|
||||
const mockNavigate = jest.fn();
|
||||
|
|
@ -1146,3 +1149,97 @@ describe('AuthContextProvider: enrollment hand-off that keeps the document', ()
|
|||
expect(readTwoFactorSetupToken()).toBe('setup-token');
|
||||
});
|
||||
});
|
||||
|
||||
describe('AuthContextProvider: read-aloud cache at every session end', () => {
|
||||
const mockUseGetUserQuery = jest.requireMock('~/data-provider').useGetUserQuery;
|
||||
const cacheAudio = () =>
|
||||
setCachedTTSAudio('departing', new Blob(['audio']), getTTSCacheGeneration());
|
||||
const refreshOptions = () =>
|
||||
mockRefreshMutate.mock.calls[0][1] as {
|
||||
onSuccess: (data: unknown) => void;
|
||||
onError: (error: unknown) => void;
|
||||
};
|
||||
|
||||
beforeEach(() => {
|
||||
jest.clearAllMocks();
|
||||
jest.spyOn(window.location, 'replace').mockImplementation(() => {});
|
||||
cacheAudio();
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
jest.useRealTimers();
|
||||
window.history.replaceState({}, '', '/');
|
||||
});
|
||||
|
||||
it('empties on logout', () => {
|
||||
renderProvider();
|
||||
act(() => mockCapturedLogoutOptions.onSuccess({ message: 'Logout successful' }));
|
||||
expect(getCachedTTSAudio('departing')).toBeUndefined();
|
||||
});
|
||||
|
||||
it('empties on an IdP logout redirect', () => {
|
||||
renderProvider();
|
||||
act(() =>
|
||||
mockCapturedLogoutOptions.onSuccess({
|
||||
message: 'Logout successful',
|
||||
redirect: 'https://idp.example.com/logout',
|
||||
}),
|
||||
);
|
||||
expect(getCachedTTSAudio('departing')).toBeUndefined();
|
||||
});
|
||||
|
||||
it('empties when the logout request fails', () => {
|
||||
renderProvider();
|
||||
act(() => mockCapturedLogoutOptions.onError(new Error('network')));
|
||||
expect(getCachedTTSAudio('departing')).toBeUndefined();
|
||||
});
|
||||
|
||||
it('empties when the refresh token is rejected', () => {
|
||||
renderProviderLive();
|
||||
act(() => refreshOptions().onError(new Error('401')));
|
||||
expect(getCachedTTSAudio('departing')).toBeUndefined();
|
||||
});
|
||||
|
||||
it('empties when a refresh returns no session', () => {
|
||||
renderProviderLive();
|
||||
act(() => refreshOptions().onSuccess({}));
|
||||
expect(getCachedTTSAudio('departing')).toBeUndefined();
|
||||
});
|
||||
|
||||
it('empties when the user query fails', () => {
|
||||
mockUseGetUserQuery.mockReturnValue({
|
||||
data: undefined,
|
||||
isError: true,
|
||||
error: new Error('401'),
|
||||
});
|
||||
renderProvider();
|
||||
expect(getCachedTTSAudio('departing')).toBeUndefined();
|
||||
mockUseGetUserQuery.mockReturnValue({ data: undefined, isError: false, error: null });
|
||||
});
|
||||
|
||||
it('empties when a different account signs in without a logout', () => {
|
||||
jest.useFakeTimers();
|
||||
renderProviderLive();
|
||||
act(() => {
|
||||
refreshOptions().onSuccess({ user: { id: 'first', role: 'USER' }, token: 'first-token' });
|
||||
jest.advanceTimersByTime(100);
|
||||
});
|
||||
cacheAudio();
|
||||
act(() => {
|
||||
capturedAuthContext?.completeAuthentication('second-token', { id: 'second' } as never);
|
||||
});
|
||||
expect(getCachedTTSAudio('departing')).toBeUndefined();
|
||||
});
|
||||
|
||||
it('keeps the cache when the same account signs in again', () => {
|
||||
renderProvider();
|
||||
act(() => {
|
||||
capturedAuthContext?.completeAuthentication('token', { id: 'same' } as never);
|
||||
});
|
||||
cacheAudio();
|
||||
act(() => {
|
||||
capturedAuthContext?.completeAuthentication('token-2', { id: 'same' } as never);
|
||||
});
|
||||
expect(getCachedTTSAudio('departing')).toBeDefined();
|
||||
});
|
||||
});
|
||||
|
|
|
|||
|
|
@ -7,9 +7,13 @@ import '@librechat/client/style.css';
|
|||
import './style.css';
|
||||
import './mobile.css';
|
||||
import { ApiErrorBoundaryProvider } from './hooks/ApiErrorBoundaryContext';
|
||||
import { clearTTSCache } from './utils/ttscache';
|
||||
import 'katex/dist/katex.min.css';
|
||||
import 'katex/dist/contrib/copy-tex.js';
|
||||
|
||||
/** Read-aloud audio lives in memory now; drop what earlier versions persisted to disk. */
|
||||
void clearTTSCache();
|
||||
|
||||
const container = document.getElementById('root');
|
||||
const root = createRoot(container);
|
||||
|
||||
|
|
|
|||
|
|
@ -4,6 +4,7 @@ import type { TAskFunction } from '~/common';
|
|||
import logger from './logger';
|
||||
|
||||
export * from './map';
|
||||
export * from './ttscache';
|
||||
export * from './policies';
|
||||
export * from './json';
|
||||
export * from './icons';
|
||||
|
|
|
|||
174
client/src/utils/ttscache.spec.ts
Normal file
174
client/src/utils/ttscache.spec.ts
Normal file
|
|
@ -0,0 +1,174 @@
|
|||
import { TextEncoder } from 'util';
|
||||
import { webcrypto } from 'crypto';
|
||||
import {
|
||||
clearTTSCache,
|
||||
getTTSCacheKey,
|
||||
hasCachedTTSAudio,
|
||||
hasLegacyTTSCache,
|
||||
setCachedTTSAudio,
|
||||
setTTSCacheOwner,
|
||||
getCachedTTSAudio,
|
||||
getTTSCacheGeneration,
|
||||
} from './ttscache';
|
||||
|
||||
const text = 'a private assistant reply';
|
||||
const audio = (label: string) => new Blob([label], { type: 'audio/mpeg' });
|
||||
|
||||
beforeEach(() => {
|
||||
clearTTSCache();
|
||||
});
|
||||
|
||||
describe('getTTSCacheKey', () => {
|
||||
beforeAll(() => {
|
||||
Object.defineProperty(globalThis, 'crypto', { value: webcrypto, configurable: true });
|
||||
Object.assign(globalThis, { TextEncoder });
|
||||
});
|
||||
|
||||
it('is a SHA-256 hash that never contains the message text', async () => {
|
||||
const key = await getTTSCacheKey(text, 'alloy');
|
||||
expect(key).toMatch(/^[0-9a-f]{64}$/);
|
||||
expect(key).not.toContain('private');
|
||||
});
|
||||
|
||||
it('is stable for the same text and voice and differs by voice or text', async () => {
|
||||
const key = await getTTSCacheKey(text, 'alloy');
|
||||
expect(await getTTSCacheKey(text, 'alloy')).toBe(key);
|
||||
expect(await getTTSCacheKey(text, 'echo')).not.toBe(key);
|
||||
expect(await getTTSCacheKey('other', 'alloy')).not.toBe(key);
|
||||
});
|
||||
|
||||
it("differs by user, so one account never matches another account's audio", async () => {
|
||||
expect(await getTTSCacheKey(text, 'alloy', 'user-a')).not.toBe(
|
||||
await getTTSCacheKey(text, 'alloy', 'user-b'),
|
||||
);
|
||||
});
|
||||
|
||||
it('returns null for empty text', async () => {
|
||||
expect(await getTTSCacheKey('', 'alloy')).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe('in-memory audio cache', () => {
|
||||
it('returns stored audio and misses unknown keys', () => {
|
||||
const recording = audio('one');
|
||||
setCachedTTSAudio('one', recording, getTTSCacheGeneration());
|
||||
expect(getCachedTTSAudio('one')).toBe(recording);
|
||||
expect(getCachedTTSAudio('two')).toBeUndefined();
|
||||
expect(hasCachedTTSAudio()).toBe(true);
|
||||
});
|
||||
|
||||
it('evicts the least recently used entry beyond its cap', () => {
|
||||
const generation = getTTSCacheGeneration();
|
||||
for (let index = 0; index < 50; index += 1) {
|
||||
setCachedTTSAudio(`key-${index}`, audio(`${index}`), generation);
|
||||
}
|
||||
/** Playing the oldest entry makes it the most recent, so the next one goes instead. */
|
||||
expect(getCachedTTSAudio('key-0')).toBeDefined();
|
||||
setCachedTTSAudio('key-50', audio('50'), generation);
|
||||
|
||||
expect(getCachedTTSAudio('key-0')).toBeDefined();
|
||||
expect(getCachedTTSAudio('key-1')).toBeUndefined();
|
||||
expect(getCachedTTSAudio('key-50')).toBeDefined();
|
||||
});
|
||||
|
||||
it('evicts the oldest recordings once their total size exceeds the budget', () => {
|
||||
const generation = getTTSCacheGeneration();
|
||||
const tenMegabytes = 10 * 1024 * 1024;
|
||||
for (let index = 0; index < 4; index += 1) {
|
||||
setCachedTTSAudio(`long-${index}`, new Blob([new Uint8Array(tenMegabytes)]), generation);
|
||||
}
|
||||
expect(getCachedTTSAudio('long-0')).toBeUndefined();
|
||||
expect(getCachedTTSAudio('long-3')).toBeDefined();
|
||||
});
|
||||
|
||||
it('does not keep a single recording larger than the budget', () => {
|
||||
const huge = new Blob([new Uint8Array(33 * 1024 * 1024)]);
|
||||
setCachedTTSAudio('huge', huge, getTTSCacheGeneration());
|
||||
expect(getCachedTTSAudio('huge')).toBeUndefined();
|
||||
});
|
||||
|
||||
it('empties on clear', () => {
|
||||
setCachedTTSAudio('one', audio('one'), getTTSCacheGeneration());
|
||||
clearTTSCache();
|
||||
expect(getCachedTTSAudio('one')).toBeUndefined();
|
||||
expect(hasCachedTTSAudio()).toBe(false);
|
||||
});
|
||||
|
||||
it('empties when a different account takes over the tab, not when the same one returns', () => {
|
||||
setTTSCacheOwner('first');
|
||||
setCachedTTSAudio('mine', audio('mine'), getTTSCacheGeneration());
|
||||
setTTSCacheOwner('first');
|
||||
setTTSCacheOwner(undefined);
|
||||
expect(getCachedTTSAudio('mine')).toBeDefined();
|
||||
|
||||
setTTSCacheOwner('second');
|
||||
expect(getCachedTTSAudio('mine')).toBeUndefined();
|
||||
});
|
||||
|
||||
it('does not hand audio recorded after a clear to the next account that signs in', () => {
|
||||
setTTSCacheOwner('first');
|
||||
clearTTSCache();
|
||||
setCachedTTSAudio('unowned', audio('unowned'), getTTSCacheGeneration());
|
||||
setTTSCacheOwner('second');
|
||||
expect(getCachedTTSAudio('unowned')).toBeUndefined();
|
||||
});
|
||||
|
||||
it('drops audio from a request started before an account signed in', () => {
|
||||
clearTTSCache();
|
||||
const generation = getTTSCacheGeneration();
|
||||
setTTSCacheOwner('arriving');
|
||||
setCachedTTSAudio('early', audio('early'), generation);
|
||||
expect(getCachedTTSAudio('early')).toBeUndefined();
|
||||
});
|
||||
|
||||
it('drops audio from a request that was in flight across a clear', () => {
|
||||
const generation = getTTSCacheGeneration();
|
||||
clearTTSCache();
|
||||
setCachedTTSAudio('late', audio('late'), generation);
|
||||
expect(getCachedTTSAudio('late')).toBeUndefined();
|
||||
|
||||
setCachedTTSAudio('next', audio('next'), getTTSCacheGeneration());
|
||||
expect(getCachedTTSAudio('next')).toBeDefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe('legacy Cache Storage cleanup', () => {
|
||||
afterEach(() => {
|
||||
Reflect.deleteProperty(globalThis, 'caches');
|
||||
});
|
||||
|
||||
it('deletes the cache earlier versions persisted', async () => {
|
||||
const del = jest.fn().mockResolvedValue(true);
|
||||
Object.defineProperty(globalThis, 'caches', { value: { delete: del }, configurable: true });
|
||||
clearTTSCache();
|
||||
await Promise.resolve();
|
||||
expect(del).toHaveBeenCalledWith('tts-responses');
|
||||
expect(del).toHaveBeenCalledWith('tts-responses-v1');
|
||||
expect(del).toHaveBeenCalledWith('tts-responses-v1:pending');
|
||||
});
|
||||
|
||||
it("reports an earlier build's cache that is still on disk", async () => {
|
||||
const has = jest.fn(async (name: string) => name === 'tts-responses');
|
||||
Object.defineProperty(globalThis, 'caches', { value: { has }, configurable: true });
|
||||
await expect(hasLegacyTTSCache()).resolves.toBe(true);
|
||||
|
||||
has.mockResolvedValue(false);
|
||||
await expect(hasLegacyTTSCache()).resolves.toBe(false);
|
||||
/** An unreadable state keeps the retry available rather than reporting it empty. */
|
||||
has.mockRejectedValue(new Error('blocked'));
|
||||
await expect(hasLegacyTTSCache()).resolves.toBe(true);
|
||||
Reflect.deleteProperty(globalThis, 'caches');
|
||||
await expect(hasLegacyTTSCache()).resolves.toBe(false);
|
||||
});
|
||||
|
||||
it('tolerates a missing Cache API and a rejected delete', async () => {
|
||||
Reflect.deleteProperty(globalThis, 'caches');
|
||||
expect(() => clearTTSCache()).not.toThrow();
|
||||
|
||||
const del = jest.fn().mockRejectedValue(new Error('blocked'));
|
||||
Object.defineProperty(globalThis, 'caches', { value: { delete: del }, configurable: true });
|
||||
expect(() => clearTTSCache()).not.toThrow();
|
||||
await expect(clearTTSCache()).resolves.toBeUndefined();
|
||||
expect(del).toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
124
client/src/utils/ttscache.ts
Normal file
124
client/src/utils/ttscache.ts
Normal file
|
|
@ -0,0 +1,124 @@
|
|||
/** Cache Storage names earlier builds persisted read-aloud audio under (the first keyed by the
|
||||
* message text). Audio is now held only in this tab's memory, so these are just deleted. */
|
||||
const LEGACY_TTS_CACHE_NAMES = ['tts-responses', 'tts-responses-v1', 'tts-responses-v1:pending'];
|
||||
const MAX_ENTRIES = 50;
|
||||
/** Long replies make large recordings, so the cache is bounded by size as well as count. */
|
||||
const MAX_BYTES = 32 * 1024 * 1024;
|
||||
|
||||
/** Spoken audio by hashed key, oldest first; it never leaves this tab and dies with it. */
|
||||
const audioByKey = new Map<string, Blob>();
|
||||
let totalBytes = 0;
|
||||
/** Bumped on every clear, so a request that was in flight across a logout cannot write. */
|
||||
let generation = 0;
|
||||
/** The account the cached audio belongs to. */
|
||||
let ownerId: string | undefined;
|
||||
|
||||
const toHex = (buffer: ArrayBuffer): string =>
|
||||
Array.from(new Uint8Array(buffer), (byte) => byte.toString(16).padStart(2, '0')).join('');
|
||||
|
||||
/** Returns a SHA-256 hash of the user, voice and spoken text, so the cache holds no message text
|
||||
* and one account can never match another's audio. Returns null when hashing is unavailable
|
||||
* (no secure context); the caller skips the cache. */
|
||||
export async function getTTSCacheKey(
|
||||
text: string,
|
||||
voice?: string | null,
|
||||
userId?: string | null,
|
||||
): Promise<string | null> {
|
||||
if (!text || typeof crypto === 'undefined' || !crypto.subtle) {
|
||||
return null;
|
||||
}
|
||||
try {
|
||||
const data = new TextEncoder().encode(JSON.stringify([userId ?? '', voice ?? '', text]));
|
||||
return toHex(await crypto.subtle.digest('SHA-256', data));
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
export const getTTSCacheGeneration = (): number => generation;
|
||||
|
||||
export const hasCachedTTSAudio = (): boolean => audioByKey.size > 0;
|
||||
|
||||
/** Whether an earlier build's audio may still be on disk (its delete failed), so it can be
|
||||
* retried. A check that fails reads as "may be", which keeps the retry available. */
|
||||
export async function hasLegacyTTSCache(): Promise<boolean> {
|
||||
if (typeof caches === 'undefined') {
|
||||
return false;
|
||||
}
|
||||
try {
|
||||
const found = await Promise.all(LEGACY_TTS_CACHE_NAMES.map((name) => caches.has(name)));
|
||||
return found.some(Boolean);
|
||||
} catch {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
export function getCachedTTSAudio(key: string): Blob | undefined {
|
||||
const audio = audioByKey.get(key);
|
||||
if (audio) {
|
||||
/** Most recently played stays last, so eviction drops the least recently used. */
|
||||
audioByKey.delete(key);
|
||||
audioByKey.set(key, audio);
|
||||
}
|
||||
return audio;
|
||||
}
|
||||
|
||||
const removeAudio = (key: string): void => {
|
||||
const audio = audioByKey.get(key);
|
||||
if (audio) {
|
||||
totalBytes -= audio.size;
|
||||
audioByKey.delete(key);
|
||||
}
|
||||
};
|
||||
|
||||
/** Stores audio for a request started at `requestGeneration`; skipped if a clear came since, or
|
||||
* if the recording alone exceeds the size budget. */
|
||||
export function setCachedTTSAudio(key: string, audio: Blob, requestGeneration: number): void {
|
||||
if (requestGeneration !== generation || audio.size > MAX_BYTES) {
|
||||
return;
|
||||
}
|
||||
removeAudio(key);
|
||||
audioByKey.set(key, audio);
|
||||
totalBytes += audio.size;
|
||||
while (audioByKey.size > MAX_ENTRIES || totalBytes > MAX_BYTES) {
|
||||
const oldest = audioByKey.keys().next().value;
|
||||
if (oldest === undefined) {
|
||||
break;
|
||||
}
|
||||
removeAudio(oldest);
|
||||
}
|
||||
}
|
||||
|
||||
/** Drops every cached recording and any audio earlier versions left in Cache Storage. */
|
||||
export function clearTTSCache(): Promise<void> {
|
||||
audioByKey.clear();
|
||||
totalBytes = 0;
|
||||
generation += 1;
|
||||
ownerId = undefined;
|
||||
if (typeof caches === 'undefined') {
|
||||
return Promise.resolve();
|
||||
}
|
||||
/** Settles when the legacy deletes do; callers that need not know can ignore it. */
|
||||
return Promise.all(
|
||||
LEGACY_TTS_CACHE_NAMES.map((name) =>
|
||||
Promise.resolve()
|
||||
.then(() => caches.delete(name))
|
||||
.catch(() => false),
|
||||
),
|
||||
).then(() => undefined);
|
||||
}
|
||||
|
||||
/** Records the signed-in account; signing in as a different one in this tab empties the cache. */
|
||||
export function setTTSCacheOwner(userId?: string | null): void {
|
||||
if (!userId) {
|
||||
return;
|
||||
}
|
||||
/** Audio recorded while no owner was set (after a clear) is not handed to whoever signs in. */
|
||||
if (ownerId !== userId && (ownerId !== undefined || audioByKey.size > 0)) {
|
||||
void clearTTSCache();
|
||||
} else if (ownerId !== userId) {
|
||||
/** A request started before this account signed in cannot write into its cache. */
|
||||
generation += 1;
|
||||
}
|
||||
ownerId = userId;
|
||||
}
|
||||
|
|
@ -75,6 +75,22 @@ mcpServers:
|
|||
title: E2E Memory
|
||||
description: Local MCP fixture used by mock end-to-end tests.
|
||||
timeout: 30000
|
||||
e2e-user-vars:
|
||||
type: stdio
|
||||
command: node
|
||||
args:
|
||||
- e2e/setup/fake-mcp-server.js
|
||||
startup: false
|
||||
env:
|
||||
E2E_MCP_USER_TOKEN: '{{E2E_MCP_USER_TOKEN}}'
|
||||
E2E_MCP_EXPECTED_USER_TOKEN: e2e-user-token-secret
|
||||
customUserVars:
|
||||
E2E_MCP_USER_TOKEN:
|
||||
title: E2E User Token
|
||||
description: Per-user token the fixture refuses to start without.
|
||||
title: E2E User Vars
|
||||
description: Stdio MCP fixture that starts only with the expected per-user token.
|
||||
timeout: 30000
|
||||
e2e-http:
|
||||
type: streamable-http
|
||||
url: http://127.0.0.1:8765/mcp
|
||||
|
|
|
|||
|
|
@ -114,6 +114,11 @@ if (process.env.E2E_MCP_LIST_CHANGED === 'true') {
|
|||
}
|
||||
|
||||
async function main() {
|
||||
const expectedUserToken = process.env.E2E_MCP_EXPECTED_USER_TOKEN;
|
||||
if (expectedUserToken && process.env.E2E_MCP_USER_TOKEN !== expectedUserToken) {
|
||||
console.error('[fake-mcp-server] E2E_MCP_USER_TOKEN does not match the expected value');
|
||||
process.exit(1);
|
||||
}
|
||||
await server.connect(new StdioServerTransport());
|
||||
}
|
||||
|
||||
|
|
|
|||
369
e2e/specs/mock/scenarios/credential-encryption.spec.ts
Normal file
369
e2e/specs/mock/scenarios/credential-encryption.spec.ts
Normal file
|
|
@ -0,0 +1,369 @@
|
|||
import { ObjectId } from 'mongodb';
|
||||
import { randomUUID } from 'crypto';
|
||||
import { expect, test } from '@playwright/test';
|
||||
import type { APIRequestContext } from '@playwright/test';
|
||||
import type { User } from '../../../types';
|
||||
import cleanupUser from '../../../setup/cleanupUser';
|
||||
import { loginAdmin } from '../content-filters.helpers';
|
||||
import { withMongo } from '../db';
|
||||
|
||||
/**
|
||||
* Stored user credentials (tool and web search keys, MCP custom user variables) are
|
||||
* written in the random-IV `v3:` format and read by format, so records written in the
|
||||
* legacy fixed-IV format keep working next to new ones. The `e2e-user-vars` MCP fixture
|
||||
* starts only when the token it receives equals the expected plaintext, so a successful
|
||||
* reinitialize proves the server decrypted the stored value exactly. `credentials.writeFormat:
|
||||
* legacy` switches new writes back to the fixed-IV format for rolling upgrades.
|
||||
*/
|
||||
|
||||
const MCP_SERVER = 'e2e-user-vars';
|
||||
const MCP_PLUGIN_KEY = `mcp_${MCP_SERVER}`;
|
||||
const MCP_VAR = 'E2E_MCP_USER_TOKEN';
|
||||
/** Must match `E2E_MCP_EXPECTED_USER_TOKEN` in e2e/config/librechat.e2e.yaml. */
|
||||
const MCP_TOKEN = 'e2e-user-token-secret';
|
||||
const WEB_SEARCH = 'web_search';
|
||||
const WEB_SEARCH_FIELDS = {
|
||||
serperApiKey: 'SERPER_API_KEY',
|
||||
firecrawlApiKey: 'FIRECRAWL_API_KEY',
|
||||
jinaApiKey: 'JINA_API_KEY',
|
||||
} as const;
|
||||
const V3_FORMAT = /^v3:[0-9a-f]{32}:[0-9a-f]+$/;
|
||||
const LEGACY_FORMAT = /^[0-9a-f]+$/;
|
||||
|
||||
type StoredAuth = { authField: string; value: string; pluginKey?: string };
|
||||
|
||||
async function registerAndLogin(
|
||||
request: APIRequestContext,
|
||||
user: User,
|
||||
): Promise<{ token: string; userId: string }> {
|
||||
const registerResponse = await request.post('/api/auth/register', {
|
||||
data: {
|
||||
email: user.email,
|
||||
name: user.name,
|
||||
password: user.password,
|
||||
confirm_password: user.password,
|
||||
},
|
||||
});
|
||||
expect(registerResponse.ok()).toBeTruthy();
|
||||
|
||||
const loginResponse = await request.post('/api/auth/login', {
|
||||
data: { email: user.email, password: user.password },
|
||||
});
|
||||
expect(loginResponse.ok()).toBeTruthy();
|
||||
const body = (await loginResponse.json()) as { token?: string; user?: { _id?: string } };
|
||||
if (!body.token || !body.user?._id) {
|
||||
throw new Error('Expected login response to include a bearer token and user id');
|
||||
}
|
||||
return { token: body.token, userId: body.user._id };
|
||||
}
|
||||
|
||||
function newUser(label: string): User {
|
||||
return {
|
||||
email: `credential-${label}-${randomUUID()}@example.com`,
|
||||
name: 'Credential Encryption',
|
||||
password: 'securepassword123',
|
||||
};
|
||||
}
|
||||
|
||||
async function installPluginAuth(
|
||||
request: APIRequestContext,
|
||||
token: string,
|
||||
pluginKey: string,
|
||||
auth: Record<string, string>,
|
||||
): Promise<void> {
|
||||
const response = await request.post('/api/user/plugins', {
|
||||
headers: { Authorization: `Bearer ${token}` },
|
||||
data: { pluginKey, action: 'install', auth },
|
||||
});
|
||||
expect(response.status(), await response.text()).toBe(200);
|
||||
}
|
||||
|
||||
async function readStoredAuths(userId: string, pluginKey: string): Promise<StoredAuth[]> {
|
||||
return withMongo(async (db) => {
|
||||
const docs = await db.collection('pluginauths').find({ userId, pluginKey }).toArray();
|
||||
return docs.map((doc) => ({
|
||||
authField: doc.authField as string,
|
||||
value: doc.value as string,
|
||||
pluginKey: doc.pluginKey as string | undefined,
|
||||
}));
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Produces a value in the legacy fixed-IV format by letting the server encrypt it on a
|
||||
* path that still writes that format (user endpoint keys), then removes the key record.
|
||||
*/
|
||||
async function legacyCiphertext(
|
||||
request: APIRequestContext,
|
||||
token: string,
|
||||
userId: string,
|
||||
plaintext: string,
|
||||
): Promise<string> {
|
||||
const name = `e2e-legacy-${randomUUID()}`;
|
||||
const response = await request.put('/api/keys', {
|
||||
headers: { Authorization: `Bearer ${token}` },
|
||||
data: { name, value: plaintext },
|
||||
});
|
||||
expect(response.status()).toBe(201);
|
||||
return withMongo(async (db) => {
|
||||
const doc = await db
|
||||
.collection('keys')
|
||||
.findOneAndDelete({ userId: new ObjectId(userId), name });
|
||||
const value = (doc as { value?: unknown } | null)?.value;
|
||||
if (typeof value !== 'string') {
|
||||
throw new Error('Expected the legacy key record to carry an encrypted value');
|
||||
}
|
||||
expect(value).toMatch(LEGACY_FORMAT);
|
||||
return value;
|
||||
});
|
||||
}
|
||||
|
||||
async function seedStoredAuth(userId: string, auth: StoredAuth): Promise<void> {
|
||||
await withMongo(async (db) => {
|
||||
const now = new Date();
|
||||
await db
|
||||
.collection('pluginauths')
|
||||
.updateOne(
|
||||
{ userId, pluginKey: auth.pluginKey, authField: auth.authField },
|
||||
{ $set: { value: auth.value, updatedAt: now }, $setOnInsert: { createdAt: now } },
|
||||
{ upsert: true },
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
async function cleanupCredentials(user: User): Promise<void> {
|
||||
await withMongo(async (db) => {
|
||||
const doc = await db.collection('users').findOne({ email: user.email });
|
||||
if (doc) {
|
||||
await db.collection('pluginauths').deleteMany({ userId: doc._id.toString() });
|
||||
}
|
||||
});
|
||||
await cleanupUser(user);
|
||||
}
|
||||
|
||||
async function webSearchAuthenticated(request: APIRequestContext, token: string): Promise<boolean> {
|
||||
const response = await request.get(`/api/agents/tools/${WEB_SEARCH}/auth`, {
|
||||
headers: { Authorization: `Bearer ${token}` },
|
||||
});
|
||||
expect(response.status(), await response.text()).toBe(200);
|
||||
const body = (await response.json()) as { authenticated?: boolean };
|
||||
return body.authenticated === true;
|
||||
}
|
||||
|
||||
async function mcpVarIsSet(request: APIRequestContext, token: string): Promise<boolean> {
|
||||
const response = await request.get(`/api/mcp/${MCP_SERVER}/auth-values`, {
|
||||
headers: { Authorization: `Bearer ${token}` },
|
||||
});
|
||||
expect(response.status(), await response.text()).toBe(200);
|
||||
const body = (await response.json()) as { authValueFlags?: Record<string, boolean> };
|
||||
return body.authValueFlags?.[MCP_VAR] === true;
|
||||
}
|
||||
|
||||
async function reinitializeMcp(request: APIRequestContext, token: string): Promise<boolean> {
|
||||
const response = await request.post(`/api/mcp/${MCP_SERVER}/reinitialize`, {
|
||||
headers: { Authorization: `Bearer ${token}` },
|
||||
});
|
||||
if (!response.ok()) {
|
||||
return false;
|
||||
}
|
||||
const body = (await response.json()) as { success?: boolean };
|
||||
return body.success === true;
|
||||
}
|
||||
|
||||
test.describe('stored credential encryption', () => {
|
||||
test('a saved web search key is stored with a random IV and still authenticates @scenario:plugin-credential-save-stores-v3', async ({
|
||||
request,
|
||||
}) => {
|
||||
const user = newUser('web-save');
|
||||
try {
|
||||
const { token, userId } = await registerAndLogin(request, user);
|
||||
const secret = `e2e-search-${randomUUID()}`;
|
||||
const auth = Object.fromEntries(Object.keys(WEB_SEARCH_FIELDS).map((key) => [key, secret]));
|
||||
|
||||
await installPluginAuth(request, token, WEB_SEARCH, auth);
|
||||
const first = await readStoredAuths(userId, WEB_SEARCH);
|
||||
const credentials = first.filter((doc) =>
|
||||
(Object.values(WEB_SEARCH_FIELDS) as string[]).includes(doc.authField),
|
||||
);
|
||||
expect(credentials.map((doc) => doc.authField).sort()).toEqual(
|
||||
Object.values(WEB_SEARCH_FIELDS).sort(),
|
||||
);
|
||||
for (const doc of credentials) {
|
||||
expect(doc.value).toMatch(V3_FORMAT);
|
||||
expect(doc.value).not.toContain(secret);
|
||||
}
|
||||
/** Same plaintext in three fields: a fixed IV would give three identical values. */
|
||||
expect(new Set(credentials.map((doc) => doc.value)).size).toBe(credentials.length);
|
||||
|
||||
expect(await webSearchAuthenticated(request, token)).toBe(true);
|
||||
|
||||
/** Saving the same value again yields a new ciphertext. */
|
||||
await installPluginAuth(request, token, WEB_SEARCH, auth);
|
||||
const second = await readStoredAuths(userId, WEB_SEARCH);
|
||||
for (const doc of credentials) {
|
||||
const resaved = second.find((entry) => entry.authField === doc.authField);
|
||||
expect(resaved?.value).toMatch(V3_FORMAT);
|
||||
expect(resaved?.value).not.toBe(doc.value);
|
||||
}
|
||||
expect(await webSearchAuthenticated(request, token)).toBe(true);
|
||||
} finally {
|
||||
await cleanupCredentials(user);
|
||||
}
|
||||
});
|
||||
|
||||
test('a web search key stored in the legacy format still authenticates and is not rewritten @scenario:plugin-credential-legacy-record-authenticates', async ({
|
||||
request,
|
||||
}) => {
|
||||
const user = newUser('web-legacy');
|
||||
try {
|
||||
const { token, userId } = await registerAndLogin(request, user);
|
||||
expect(await webSearchAuthenticated(request, token)).toBe(false);
|
||||
|
||||
const seeded: StoredAuth[] = [];
|
||||
for (const authField of Object.values(WEB_SEARCH_FIELDS)) {
|
||||
const value = await legacyCiphertext(request, token, userId, `e2e-legacy-${authField}`);
|
||||
const auth = { authField, value, pluginKey: WEB_SEARCH };
|
||||
await seedStoredAuth(userId, auth);
|
||||
seeded.push(auth);
|
||||
}
|
||||
|
||||
expect(await webSearchAuthenticated(request, token)).toBe(true);
|
||||
|
||||
const stored = await readStoredAuths(userId, WEB_SEARCH);
|
||||
for (const auth of seeded) {
|
||||
expect(stored.find((doc) => doc.authField === auth.authField)?.value).toBe(auth.value);
|
||||
}
|
||||
} finally {
|
||||
await cleanupCredentials(user);
|
||||
}
|
||||
});
|
||||
|
||||
test('legacy and v3 web search keys for one user authenticate together @scenario:plugin-credential-mixed-records-authenticate', async ({
|
||||
request,
|
||||
}) => {
|
||||
const user = newUser('web-mixed');
|
||||
try {
|
||||
const { token, userId } = await registerAndLogin(request, user);
|
||||
const secret = `e2e-search-${randomUUID()}`;
|
||||
await installPluginAuth(request, token, WEB_SEARCH, {
|
||||
firecrawlApiKey: secret,
|
||||
jinaApiKey: secret,
|
||||
});
|
||||
const legacy = await legacyCiphertext(request, token, userId, secret);
|
||||
await seedStoredAuth(userId, {
|
||||
authField: WEB_SEARCH_FIELDS.serperApiKey,
|
||||
value: legacy,
|
||||
pluginKey: WEB_SEARCH,
|
||||
});
|
||||
|
||||
const stored = await readStoredAuths(userId, WEB_SEARCH);
|
||||
const formats = Object.values(WEB_SEARCH_FIELDS).map(
|
||||
(field) => stored.find((doc) => doc.authField === field)?.value ?? '',
|
||||
);
|
||||
expect(formats[0]).toMatch(LEGACY_FORMAT);
|
||||
expect(formats[1]).toMatch(V3_FORMAT);
|
||||
expect(formats[2]).toMatch(V3_FORMAT);
|
||||
|
||||
expect(await webSearchAuthenticated(request, token)).toBe(true);
|
||||
} finally {
|
||||
await cleanupCredentials(user);
|
||||
}
|
||||
});
|
||||
|
||||
test('a saved MCP custom user variable is stored as v3 and reaches the server decrypted @scenario:mcp-user-var-save-stores-v3', async ({
|
||||
request,
|
||||
}) => {
|
||||
test.setTimeout(90000);
|
||||
const user = newUser('mcp-save');
|
||||
try {
|
||||
const { token, userId } = await registerAndLogin(request, user);
|
||||
expect(await mcpVarIsSet(request, token)).toBe(false);
|
||||
expect(await reinitializeMcp(request, token)).toBe(false);
|
||||
|
||||
await installPluginAuth(request, token, MCP_PLUGIN_KEY, { [MCP_VAR]: MCP_TOKEN });
|
||||
const stored = await readStoredAuths(userId, MCP_PLUGIN_KEY);
|
||||
expect(stored).toHaveLength(1);
|
||||
expect(stored[0].authField).toBe(MCP_VAR);
|
||||
expect(stored[0].value).toMatch(V3_FORMAT);
|
||||
expect(stored[0].value).not.toContain(MCP_TOKEN);
|
||||
|
||||
expect(await mcpVarIsSet(request, token)).toBe(true);
|
||||
expect(await reinitializeMcp(request, token)).toBe(true);
|
||||
} finally {
|
||||
await cleanupCredentials(user);
|
||||
}
|
||||
});
|
||||
|
||||
test('an MCP custom user variable stored in the legacy format still connects and is not rewritten @scenario:mcp-user-var-legacy-record-connects', async ({
|
||||
request,
|
||||
}) => {
|
||||
test.setTimeout(90000);
|
||||
const user = newUser('mcp-legacy');
|
||||
try {
|
||||
const { token, userId } = await registerAndLogin(request, user);
|
||||
const value = await legacyCiphertext(request, token, userId, MCP_TOKEN);
|
||||
await seedStoredAuth(userId, { authField: MCP_VAR, value, pluginKey: MCP_PLUGIN_KEY });
|
||||
|
||||
expect(await mcpVarIsSet(request, token)).toBe(true);
|
||||
expect(await reinitializeMcp(request, token)).toBe(true);
|
||||
|
||||
const stored = await readStoredAuths(userId, MCP_PLUGIN_KEY);
|
||||
expect(stored.map((doc) => doc.value)).toEqual([value]);
|
||||
} finally {
|
||||
await cleanupCredentials(user);
|
||||
}
|
||||
});
|
||||
|
||||
test('with the legacy write format configured, a saved credential is stored in the legacy format and still connects @scenario:credential-legacy-write-format-config', async ({
|
||||
request,
|
||||
}) => {
|
||||
test.setTimeout(90000);
|
||||
const user = newUser('legacy-format');
|
||||
const adminToken = await loginAdmin(request);
|
||||
const adminHeaders = { Authorization: `Bearer ${adminToken}` };
|
||||
let userId: string | undefined;
|
||||
try {
|
||||
const login = await registerAndLogin(request, user);
|
||||
userId = login.userId;
|
||||
const { token } = login;
|
||||
|
||||
/** Per-user override, so only this fresh user's writes change format. */
|
||||
const put = await request.put(`/api/admin/config/user/${userId}`, {
|
||||
headers: adminHeaders,
|
||||
data: { overrides: { credentials: { writeFormat: 'legacy' } } },
|
||||
});
|
||||
/** A first override for a principal is created (201, `configVersion` 1). */
|
||||
expect(put.status(), await put.text()).toBe(201);
|
||||
const created = (await put.json()) as {
|
||||
config?: { overrides?: { credentials?: { writeFormat?: string } } };
|
||||
};
|
||||
expect(created.config?.overrides?.credentials?.writeFormat).toBe('legacy');
|
||||
|
||||
/** The override reaches the merged config after an async cache invalidation. */
|
||||
await expect
|
||||
.poll(
|
||||
async () => {
|
||||
await installPluginAuth(request, token, MCP_PLUGIN_KEY, { [MCP_VAR]: MCP_TOKEN });
|
||||
const [stored] = await readStoredAuths(login.userId, MCP_PLUGIN_KEY);
|
||||
return LEGACY_FORMAT.test(stored?.value ?? '') ? 'legacy' : stored?.value;
|
||||
},
|
||||
{ timeout: 30000, intervals: [500, 1000, 2000] },
|
||||
)
|
||||
.toBe('legacy');
|
||||
|
||||
const stored = await readStoredAuths(userId, MCP_PLUGIN_KEY);
|
||||
expect(stored).toHaveLength(1);
|
||||
expect(stored[0].value).not.toContain(MCP_TOKEN);
|
||||
expect(await mcpVarIsSet(request, token)).toBe(true);
|
||||
expect(await reinitializeMcp(request, token)).toBe(true);
|
||||
} finally {
|
||||
if (userId) {
|
||||
const del = await request.delete(`/api/admin/config/user/${userId}`, {
|
||||
headers: adminHeaders,
|
||||
});
|
||||
expect([200, 204, 404]).toContain(del.status());
|
||||
}
|
||||
await cleanupCredentials(user);
|
||||
}
|
||||
});
|
||||
});
|
||||
99
e2e/specs/mock/scenarios/sharepoint-picker-logs.spec.ts
Normal file
99
e2e/specs/mock/scenarios/sharepoint-picker-logs.spec.ts
Normal file
|
|
@ -0,0 +1,99 @@
|
|||
import { expect, test } from '@playwright/test';
|
||||
import type { Page } from '@playwright/test';
|
||||
import { NEW_CHAT_PATH } from '../helpers';
|
||||
|
||||
const SHAREPOINT_ORIGIN = 'https://contoso.sharepoint.example';
|
||||
const DOWNLOAD_URL = 'https://download.example.test/secret-contract.pdf';
|
||||
const SECRET_FILE_NAME = 'secret-contract-q3.pdf';
|
||||
const SECRET_TOKEN = 'graph-token-must-not-be-logged';
|
||||
|
||||
/** The picker page SharePoint serves: it hands the app a MessagePort, then plays the picker's side. */
|
||||
const PICKER_PAGE = `<!doctype html><html><body><script>
|
||||
const options = JSON.parse(new URLSearchParams(location.search).get('filePicker'));
|
||||
const channel = new MessageChannel();
|
||||
window.parent.postMessage(
|
||||
{ type: 'initialize', channelId: options.messaging.channelId },
|
||||
options.messaging.origin,
|
||||
[channel.port2],
|
||||
);
|
||||
channel.port1.onmessage = (event) => {
|
||||
if (event.data.type !== 'activate') return;
|
||||
channel.port1.postMessage({ type: 'notification', data: { note: '${SECRET_FILE_NAME}' } });
|
||||
channel.port1.postMessage({ type: 'command', id: '1', data: { command: 'authenticate' } });
|
||||
channel.port1.postMessage({
|
||||
type: 'command',
|
||||
id: '2',
|
||||
data: {
|
||||
command: 'pick',
|
||||
items: [{ id: 'item-1', name: '${SECRET_FILE_NAME}', downloadUrl: '${DOWNLOAD_URL}' }],
|
||||
},
|
||||
});
|
||||
};
|
||||
</script></body></html>`;
|
||||
|
||||
async function enableSharePoint(page: Page) {
|
||||
await page.route('**/api/config', async (route) => {
|
||||
const response = await route.fetch();
|
||||
const config = await response.json();
|
||||
await route.fulfill({
|
||||
response,
|
||||
json: {
|
||||
...config,
|
||||
sharePointFilePickerEnabled: true,
|
||||
sharePointBaseUrl: SHAREPOINT_ORIGIN,
|
||||
sharePointPickerGraphScope: 'Files.Read.All',
|
||||
sharePointPickerSharePointScope: `${SHAREPOINT_ORIGIN}/.default`,
|
||||
},
|
||||
});
|
||||
});
|
||||
await page.route('**/api/user', async (route) => {
|
||||
const response = await route.fetch();
|
||||
const user = await response.json();
|
||||
await route.fulfill({ response, json: { ...user, provider: 'openid' } });
|
||||
});
|
||||
await page.route('**/api/auth/graph-token*', (route) =>
|
||||
route.fulfill({
|
||||
json: { access_token: SECRET_TOKEN, token_type: 'Bearer', expires_in: 3600, scope: 'x' },
|
||||
}),
|
||||
);
|
||||
await page.route(`${SHAREPOINT_ORIGIN}/**`, (route) =>
|
||||
route.fulfill({ contentType: 'text/html', body: PICKER_PAGE }),
|
||||
);
|
||||
await page.route(DOWNLOAD_URL, (route) => route.fulfill({ status: 500, body: 'unavailable' }));
|
||||
}
|
||||
|
||||
test.use({ serviceWorkers: 'block', viewport: { width: 1280, height: 800 } });
|
||||
|
||||
test('picking SharePoint files keeps file names and tokens out of the console @scenario:sharepoint-picker-keeps-payloads-out-of-console', async ({
|
||||
page,
|
||||
}) => {
|
||||
test.setTimeout(60000);
|
||||
const pending: Promise<string>[] = [];
|
||||
page.on('console', (message) => {
|
||||
const args = message.args().map((arg) => arg.jsonValue().catch(() => '[unserializable]'));
|
||||
pending.push(
|
||||
Promise.all(args).then((values) =>
|
||||
[message.text(), ...values.map((value) => JSON.stringify(value))].join(' '),
|
||||
),
|
||||
);
|
||||
});
|
||||
await enableSharePoint(page);
|
||||
|
||||
await page.goto(NEW_CHAT_PATH);
|
||||
await page.getByRole('button', { name: 'Attach and tools' }).click();
|
||||
await page.getByRole('button', { name: 'More upload options' }).click();
|
||||
await page
|
||||
.getByRole('button', { name: /From SharePoint/ })
|
||||
.first()
|
||||
.click();
|
||||
|
||||
await expect
|
||||
.poll(async () => (await Promise.all(pending)).some((text) => text.includes('download failed')))
|
||||
.toBe(true);
|
||||
|
||||
const logged = await Promise.all(pending);
|
||||
const leaked = logged.filter((text) =>
|
||||
[SECRET_FILE_NAME, SECRET_TOKEN, DOWNLOAD_URL].some((secret) => text.includes(secret)),
|
||||
);
|
||||
expect(leaked).toEqual([]);
|
||||
});
|
||||
226
e2e/specs/mock/scenarios/tts-cache.spec.ts
Normal file
226
e2e/specs/mock/scenarios/tts-cache.spec.ts
Normal file
|
|
@ -0,0 +1,226 @@
|
|||
import { randomUUID } from 'node:crypto';
|
||||
import { expect, test } from '@playwright/test';
|
||||
import type { Browser, BrowserContext, Page } from '@playwright/test';
|
||||
import type { User } from '../../../types';
|
||||
import {
|
||||
MOCK_ENDPOINTS,
|
||||
NEW_CHAT_PATH,
|
||||
replyPrompt,
|
||||
replyText,
|
||||
selectMockEndpoint,
|
||||
sendMessageAndWaitForCompletion,
|
||||
} from '../helpers';
|
||||
import { deleteConversations } from '../db';
|
||||
import cleanupUser from '../../../setup/cleanupUser';
|
||||
|
||||
/**
|
||||
* Read-aloud audio is cached only in the tab's memory: a replay plays without a second TTS
|
||||
* request, nothing is written to Cache Storage, logout empties the cache, and the cache that
|
||||
* earlier versions persisted to disk is deleted when the app starts.
|
||||
*/
|
||||
|
||||
test.describe.configure({ timeout: 120_000 });
|
||||
|
||||
/** The Cache Storage name earlier versions persisted audio under, keyed by message text. */
|
||||
const LEGACY_TTS_CACHE = 'tts-responses';
|
||||
const createdConversationIds: string[] = [];
|
||||
|
||||
test.afterAll(async () => {
|
||||
await deleteConversations(createdConversationIds);
|
||||
});
|
||||
|
||||
/** Stands in for a configured external TTS provider: the e2e config has none. */
|
||||
async function routeExternalSpeech(
|
||||
target: Page | BrowserContext,
|
||||
): Promise<{ requests: () => number }> {
|
||||
let ttsRequests = 0;
|
||||
await target.route('**/api/files/speech/config/get', (route) =>
|
||||
route.fulfill({
|
||||
json: { textToSpeech: true, engineTTS: 'external', cacheTTS: true, ttsExternal: true },
|
||||
}),
|
||||
);
|
||||
await target.route('**/api/files/speech/tts/voices', (route) =>
|
||||
route.fulfill({ json: ['alloy'] }),
|
||||
);
|
||||
await target.route('**/api/files/speech/tts/manual', (route) => {
|
||||
ttsRequests += 1;
|
||||
return route.fulfill({
|
||||
body: Buffer.from([0xff, 0xf3, 0x00, 0x00]),
|
||||
contentType: 'audio/mpeg',
|
||||
});
|
||||
});
|
||||
return { requests: () => ttsRequests };
|
||||
}
|
||||
|
||||
const useExternalEngine = (target: Page | BrowserContext) =>
|
||||
target.addInitScript(() => {
|
||||
localStorage.setItem('engineTTS', JSON.stringify('external'));
|
||||
localStorage.setItem('voice', JSON.stringify('alloy'));
|
||||
});
|
||||
|
||||
/** Sends a message to the mock model and returns the read-aloud button of its reply. */
|
||||
async function replyToReadAloud(page: Page, prefix: string) {
|
||||
await selectMockEndpoint(page, MOCK_ENDPOINTS[0]);
|
||||
const label = `${prefix}-${randomUUID().slice(0, 8)}`;
|
||||
await sendMessageAndWaitForCompletion(page, replyPrompt(label));
|
||||
await expect(page.getByText(replyText(label)).first()).toBeVisible({ timeout: 20000 });
|
||||
const conversationId = new URL(page.url()).pathname.split('/c/')[1];
|
||||
if (conversationId) createdConversationIds.push(conversationId);
|
||||
return page.getByRole('button', { name: 'Read aloud' }).last();
|
||||
}
|
||||
|
||||
const cacheStorageNames = (page: Page) => page.evaluate(() => caches.keys());
|
||||
|
||||
test.describe('read-aloud audio cache', () => {
|
||||
test('replaying a message plays from memory without a second TTS request @scenario:tts-replay-served-from-memory', async ({
|
||||
page,
|
||||
}) => {
|
||||
await useExternalEngine(page);
|
||||
const speech = await routeExternalSpeech(page);
|
||||
await page.goto(NEW_CHAT_PATH, { timeout: 10000 });
|
||||
|
||||
const readAloud = await replyToReadAloud(page, 'tts');
|
||||
await readAloud.click();
|
||||
await expect.poll(() => speech.requests()).toBe(1);
|
||||
|
||||
await expect(readAloud).toHaveAccessibleName('Read aloud');
|
||||
await readAloud.click();
|
||||
/** Give a second request time to start, if one were going to. */
|
||||
await page.waitForTimeout(1500);
|
||||
expect(speech.requests()).toBe(1);
|
||||
});
|
||||
|
||||
test('read-aloud audio is never written to Cache Storage @scenario:tts-audio-never-persisted', async ({
|
||||
page,
|
||||
}) => {
|
||||
await useExternalEngine(page);
|
||||
const speech = await routeExternalSpeech(page);
|
||||
await page.goto(NEW_CHAT_PATH, { timeout: 10000 });
|
||||
|
||||
const readAloud = await replyToReadAloud(page, 'disk');
|
||||
await readAloud.click();
|
||||
await expect.poll(() => speech.requests()).toBe(1);
|
||||
await page.waitForTimeout(1000);
|
||||
|
||||
expect(await cacheStorageNames(page)).not.toContain(LEGACY_TTS_CACHE);
|
||||
expect((await cacheStorageNames(page)).filter((name) => name.startsWith('tts'))).toEqual([]);
|
||||
});
|
||||
|
||||
test('logging out empties the read-aloud cache @scenario:tts-memory-cleared-on-logout', async ({
|
||||
browser,
|
||||
baseURL,
|
||||
}) => {
|
||||
const { context, page, user } = await signInFreshUser(browser, baseURL);
|
||||
try {
|
||||
await useExternalEngine(context);
|
||||
const speech = await routeExternalSpeech(context);
|
||||
await page.goto(NEW_CHAT_PATH, { timeout: 10000 });
|
||||
|
||||
const readAloud = await replyToReadAloud(page, 'logout');
|
||||
const conversationPath = new URL(page.url()).pathname;
|
||||
await readAloud.click();
|
||||
await expect.poll(() => speech.requests()).toBe(1);
|
||||
|
||||
/** Same tab, no reload: only the logout can have emptied the in-memory cache. The marker
|
||||
* would be gone if the document had been replaced. */
|
||||
await page.evaluate(() => Object.assign(window, { ttsSameDocument: true }));
|
||||
await logOut(page);
|
||||
await logIn(page, user, /\/c\//);
|
||||
if (new URL(page.url()).pathname !== conversationPath) {
|
||||
await page.evaluate((path) => {
|
||||
window.history.pushState({}, '', path);
|
||||
window.dispatchEvent(new PopStateEvent('popstate'));
|
||||
}, conversationPath);
|
||||
}
|
||||
await expect(page).toHaveURL(new RegExp(conversationPath));
|
||||
expect(await page.evaluate(() => 'ttsSameDocument' in window)).toBe(true);
|
||||
/** On a phone the sidebar drawer reopens over the conversation after signing in. */
|
||||
if ((page.viewportSize()?.width ?? 0) < 768) {
|
||||
const closeSidebar = page.getByTestId('close-sidebar-button');
|
||||
if (await closeSidebar.isVisible()) {
|
||||
await closeSidebar.click();
|
||||
}
|
||||
}
|
||||
await page.getByRole('button', { name: 'Read aloud' }).last().click();
|
||||
await expect.poll(() => speech.requests()).toBe(2);
|
||||
} finally {
|
||||
await context.close().catch(() => undefined);
|
||||
await cleanupUser(user);
|
||||
}
|
||||
});
|
||||
|
||||
test('audio earlier versions saved to Cache Storage is deleted when the app starts @scenario:tts-legacy-disk-cache-purged-at-startup', async ({
|
||||
page,
|
||||
}) => {
|
||||
await page.goto(NEW_CHAT_PATH, { timeout: 10000 });
|
||||
await page.evaluate(async (name) => {
|
||||
const cache = await caches.open(name);
|
||||
await cache.put(
|
||||
'/E2E%20legacy%20reply%20text',
|
||||
new Response(new Blob([new Uint8Array([1])])),
|
||||
);
|
||||
}, LEGACY_TTS_CACHE);
|
||||
|
||||
await page.reload();
|
||||
await expect
|
||||
.poll(() => page.evaluate((name) => caches.has(name), LEGACY_TTS_CACHE))
|
||||
.toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
/** A dedicated account, so logging out does not end the session other specs share. */
|
||||
async function signInFreshUser(
|
||||
browser: Browser,
|
||||
baseURL: string | undefined,
|
||||
): Promise<{ context: BrowserContext; page: Page; user: User }> {
|
||||
if (typeof baseURL !== 'string') {
|
||||
throw new Error('baseURL must be configured for mock scenarios');
|
||||
}
|
||||
const user: User = {
|
||||
name: 'TTS Cache',
|
||||
email: `tts-cache-${randomUUID().slice(0, 8)}@example.com`,
|
||||
password: `Pw-${randomUUID()}`,
|
||||
};
|
||||
await cleanupUser(user);
|
||||
const context = await browser.newContext({ storageState: undefined, baseURL });
|
||||
await context.addInitScript(() => {
|
||||
localStorage.setItem('navVisible', 'true');
|
||||
/** The shared storage state opts into sending with Enter; a fresh account has to as well. */
|
||||
localStorage.setItem('enterToSend', 'true');
|
||||
});
|
||||
const registered = await context.request.post('/api/auth/register', {
|
||||
data: {
|
||||
email: user.email,
|
||||
name: user.name,
|
||||
password: user.password,
|
||||
confirm_password: user.password,
|
||||
},
|
||||
});
|
||||
expect(registered.ok()).toBeTruthy();
|
||||
|
||||
const page = await context.newPage();
|
||||
await page.goto('/login', { timeout: 10000 });
|
||||
await logIn(page, user);
|
||||
return { context, page, user };
|
||||
}
|
||||
|
||||
async function logIn(page: Page, user: User, landing = /\/c\/new/): Promise<void> {
|
||||
await page.getByLabel('Email').fill(user.email);
|
||||
await page.getByLabel('Password').fill(user.password);
|
||||
await page.getByTestId('login-button').click();
|
||||
await page.waitForURL(landing, { timeout: 10000 });
|
||||
}
|
||||
|
||||
async function logOut(page: Page): Promise<void> {
|
||||
/** The sidebar toggle is only meaningful once the app has rendered its chrome. */
|
||||
await expect(page.getByRole('textbox', { name: 'Message input' })).toBeVisible({
|
||||
timeout: 20000,
|
||||
});
|
||||
const navUser = page.getByTestId('nav-user');
|
||||
if (!(await navUser.isVisible())) {
|
||||
await page.getByTestId('header-open-sidebar-button').click();
|
||||
}
|
||||
await navUser.click();
|
||||
await page.getByRole('menuitem', { name: 'Log out' }).click();
|
||||
await page.waitForURL(/\/login/, { timeout: 10000 });
|
||||
}
|
||||
|
|
@ -29,6 +29,14 @@ projects:
|
|||
# outputChars: 512 # characters of each output kept, half from the start and half from the end
|
||||
# argsChars: 512 # characters of serialized arguments kept; JSON stays valid JSON
|
||||
|
||||
# Stored user credentials (tool and web search keys, MCP custom user variables) are
|
||||
# written with a random IV per value ("v3", the default). Both formats are always read.
|
||||
# During a rolling upgrade of a multi-replica deployment, set "legacy" until every
|
||||
# replica runs a release that reads v3, then remove it. A rollback to a release that
|
||||
# predates v3 cannot read credentials saved in the v3 format.
|
||||
# credentials:
|
||||
# writeFormat: v3
|
||||
|
||||
# Langfuse connections are managed through Settings > Langfuse when available.
|
||||
# That flow verifies the credentials and stores the secret key encrypted; do not
|
||||
# place a plaintext langfuse.secretKey in this file. Environment-managed central
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
import { logger, decrypt } from '@librechat/data-schemas';
|
||||
import { logger } from '@librechat/data-schemas';
|
||||
import type { IPluginAuth, PluginAuthMethods } from '@librechat/data-schemas';
|
||||
import { decryptCredential } from '~/crypto/credentials';
|
||||
|
||||
export interface GetPluginAuthMapParams {
|
||||
userId: string;
|
||||
|
|
@ -53,7 +54,7 @@ export async function getPluginAuthMap({
|
|||
decryptionPromises.push(
|
||||
(async () => {
|
||||
try {
|
||||
const decryptedValue = await decrypt(auth.value);
|
||||
const decryptedValue = await decryptCredential(auth.value);
|
||||
authMap[pluginKey][auth.authField] = decryptedValue;
|
||||
} catch (error) {
|
||||
const message = error instanceof Error ? error.message : 'Unknown error';
|
||||
|
|
|
|||
90
packages/api/src/crypto/credentials.spec.ts
Normal file
90
packages/api/src/crypto/credentials.spec.ts
Normal file
|
|
@ -0,0 +1,90 @@
|
|||
import '~/mcp/registry/__tests__/helpers/setupCredsEnv';
|
||||
import mongoose from 'mongoose';
|
||||
import { MongoMemoryServer } from 'mongodb-memory-server';
|
||||
import { encrypt, decrypt, createModels, createMethods } from '@librechat/data-schemas';
|
||||
import type { PluginAuthMethods } from '@librechat/data-schemas';
|
||||
import { encryptCredential, decryptCredential } from './credentials';
|
||||
import { getPluginAuthMap } from '~/agents/auth';
|
||||
|
||||
describe('credential encryption', () => {
|
||||
it('writes v3 values with a fresh IV each time and reads them back', async () => {
|
||||
const first = await encryptCredential('sk-secret');
|
||||
const second = await encryptCredential('sk-secret');
|
||||
|
||||
expect(first).toMatch(/^v3:[0-9a-f]{32}:[0-9a-f]+$/);
|
||||
expect(second).not.toBe(first);
|
||||
await expect(decryptCredential(first)).resolves.toBe('sk-secret');
|
||||
await expect(decryptCredential(second)).resolves.toBe('sk-secret');
|
||||
});
|
||||
|
||||
it('writes v3 when the format is v3 explicitly', async () => {
|
||||
const value = await encryptCredential('sk-secret', 'v3');
|
||||
|
||||
expect(value).toMatch(/^v3:[0-9a-f]{32}:[0-9a-f]+$/);
|
||||
await expect(decryptCredential(value)).resolves.toBe('sk-secret');
|
||||
});
|
||||
|
||||
it('writes the legacy fixed-IV format when configured, readable by legacy decrypt', async () => {
|
||||
const value = await encryptCredential('sk-secret', 'legacy');
|
||||
|
||||
expect(value).toMatch(/^[0-9a-f]+$/);
|
||||
expect(value).toBe(await encrypt('sk-secret'));
|
||||
await expect(decrypt(value)).resolves.toBe('sk-secret');
|
||||
await expect(decryptCredential(value)).resolves.toBe('sk-secret');
|
||||
});
|
||||
|
||||
it('still reads legacy fixed-IV values', async () => {
|
||||
const legacy = await encrypt('legacy-secret');
|
||||
|
||||
expect(legacy.startsWith('v3:')).toBe(false);
|
||||
await expect(decryptCredential(legacy)).resolves.toBe('legacy-secret');
|
||||
});
|
||||
|
||||
it('round-trips an empty string', async () => {
|
||||
await expect(decryptCredential(await encryptCredential(''))).resolves.toBe('');
|
||||
});
|
||||
});
|
||||
|
||||
describe('getPluginAuthMap with mixed-version records', () => {
|
||||
let mongoServer: MongoMemoryServer;
|
||||
let methods: PluginAuthMethods;
|
||||
|
||||
beforeAll(async () => {
|
||||
mongoServer = await MongoMemoryServer.create();
|
||||
await mongoose.connect(mongoServer.getUri());
|
||||
createModels(mongoose);
|
||||
methods = createMethods(mongoose);
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await mongoose.disconnect();
|
||||
await mongoServer.stop();
|
||||
});
|
||||
|
||||
it('decrypts legacy and v3 records stored for the same plugin', async () => {
|
||||
const userId = new mongoose.Types.ObjectId().toString();
|
||||
const pluginKey = 'mcp_server';
|
||||
await methods.updatePluginAuth({
|
||||
userId,
|
||||
pluginKey,
|
||||
authField: 'LEGACY_KEY',
|
||||
value: await encrypt('legacy-value'),
|
||||
});
|
||||
await methods.updatePluginAuth({
|
||||
userId,
|
||||
pluginKey,
|
||||
authField: 'NEW_KEY',
|
||||
value: await encryptCredential('new-value'),
|
||||
});
|
||||
|
||||
const authMap = await getPluginAuthMap({
|
||||
userId,
|
||||
pluginKeys: [pluginKey],
|
||||
findPluginAuthsByKeys: methods.findPluginAuthsByKeys,
|
||||
});
|
||||
|
||||
expect(authMap).toEqual({
|
||||
[pluginKey]: { LEGACY_KEY: 'legacy-value', NEW_KEY: 'new-value' },
|
||||
});
|
||||
});
|
||||
});
|
||||
33
packages/api/src/crypto/credentials.ts
Normal file
33
packages/api/src/crypto/credentials.ts
Normal file
|
|
@ -0,0 +1,33 @@
|
|||
import { encryptV3, decryptV3, encrypt, decrypt } from '@librechat/data-schemas';
|
||||
import type { TCredentialsConfig } from 'librechat-data-provider';
|
||||
|
||||
const V3_PREFIX = 'v3:';
|
||||
|
||||
export type CredentialWriteFormat = TCredentialsConfig['writeFormat'];
|
||||
|
||||
/**
|
||||
* Encrypts a stored user credential (plugin, tool, or MCP custom user variable).
|
||||
* `v3` (the default) uses a random IV per value and carries the `v3:` prefix;
|
||||
* `legacy` writes the fixed-IV format that releases predating `v3` can read.
|
||||
*/
|
||||
export async function encryptCredential(
|
||||
value: string,
|
||||
format: CredentialWriteFormat = 'v3',
|
||||
): Promise<string> {
|
||||
if (format === 'legacy') {
|
||||
return encrypt(value);
|
||||
}
|
||||
return encryptV3(value);
|
||||
}
|
||||
|
||||
/**
|
||||
* Decrypts a stored user credential by format: `v3:` values use `decryptV3`,
|
||||
* anything else is a legacy fixed-IV value (hex only, so it can never start
|
||||
* with `v3:`) and uses the legacy `decrypt`.
|
||||
*/
|
||||
export async function decryptCredential(value: string): Promise<string> {
|
||||
if (value.startsWith(V3_PREFIX)) {
|
||||
return decryptV3(value);
|
||||
}
|
||||
return decrypt(value);
|
||||
}
|
||||
|
|
@ -9,3 +9,4 @@ export {
|
|||
getRandomValues,
|
||||
} from '@librechat/data-schemas';
|
||||
export * from './jwt';
|
||||
export * from './credentials';
|
||||
|
|
|
|||
|
|
@ -3882,6 +3882,19 @@ export const langfuseTraceConfigSchema = z.object({
|
|||
|
||||
export type LangfuseTraceConfig = z.infer<typeof langfuseTraceConfigSchema>;
|
||||
|
||||
/**
|
||||
* Format new stored user credentials (tool, web search and MCP custom user variable values)
|
||||
* are written in. Both formats are always readable; `legacy` keeps writes readable by
|
||||
* replicas on releases that predate `v3` during a rolling upgrade.
|
||||
*/
|
||||
export const credentialsConfigSchema = z
|
||||
.object({
|
||||
writeFormat: z.enum(['v3', 'legacy']).default('v3'),
|
||||
})
|
||||
.strict();
|
||||
|
||||
export type TCredentialsConfig = z.infer<typeof credentialsConfigSchema>;
|
||||
|
||||
export const langfuseConfigSchema = z.object({
|
||||
enabled: z.boolean().optional(),
|
||||
publicKey: z.string().optional(),
|
||||
|
|
@ -4012,6 +4025,7 @@ export const configSchema = z.object({
|
|||
.strict()
|
||||
.optional(),
|
||||
langfuse: langfuseConfigSchema.optional(),
|
||||
credentials: credentialsConfigSchema.optional(),
|
||||
memory: memorySchema.optional(),
|
||||
summarization: summarizationConfigSchema.optional(),
|
||||
skillSync: skillSyncConfigSchema,
|
||||
|
|
|
|||
|
|
@ -309,6 +309,20 @@ describe('AppService MCP App sandbox configuration', () => {
|
|||
});
|
||||
});
|
||||
|
||||
describe('AppService credential write format', () => {
|
||||
it('defaults stored credential writes to v3', async () => {
|
||||
const result = await AppService({ config: {} as DeepPartial<TCustomConfig> });
|
||||
expect(result.credentials).toEqual({ writeFormat: 'v3' });
|
||||
});
|
||||
|
||||
it('carries a configured legacy write format onto the app config', async () => {
|
||||
const result = await AppService({
|
||||
config: { credentials: { writeFormat: 'legacy' } } as DeepPartial<TCustomConfig>,
|
||||
});
|
||||
expect(result.credentials).toEqual({ writeFormat: 'legacy' });
|
||||
});
|
||||
});
|
||||
|
||||
describe('AppService conversation list limits', () => {
|
||||
it('carries the configured filter limits onto the app config', async () => {
|
||||
const result = await AppService({
|
||||
|
|
|
|||
|
|
@ -234,6 +234,7 @@ export const AppService = async (params?: {
|
|||
fileStrategies: config.fileStrategies,
|
||||
cloudfront: config.cloudfront as AppConfig['cloudfront'],
|
||||
secureImageLinks: config.secureImageLinks !== false,
|
||||
credentials: { writeFormat: config.credentials?.writeFormat ?? 'v3' },
|
||||
conversationList: loadConversationListConfig(config),
|
||||
toolCallPreviews: loadToolCallPreviewsConfig(config),
|
||||
};
|
||||
|
|
|
|||
|
|
@ -4,6 +4,7 @@ import type {
|
|||
TFileConfig,
|
||||
TAzureConfig,
|
||||
TCustomConfig,
|
||||
TCredentialsConfig,
|
||||
TChatProjectsConfig,
|
||||
TMemoryConfig,
|
||||
EModelEndpoint,
|
||||
|
|
@ -118,6 +119,8 @@ export interface AppConfig {
|
|||
fileConfig?: TFileConfig;
|
||||
/** Secure image links configuration, enabled unless explicitly disabled */
|
||||
secureImageLinks?: TCustomConfig['secureImageLinks'];
|
||||
/** Stored user credential write format, `v3` unless configured */
|
||||
credentials?: TCredentialsConfig;
|
||||
/** Validation limits for the conversation list's filter facets */
|
||||
conversationList?: TConversationListConfig;
|
||||
/** Bounds for the tool-call previews sent on conversation loads */
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue