Skip to content

Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active

🎟️ refactor: Require Credentials for Local Image Access by Default (#15252)

Danny Avilade59da963685
diff --git a/api/server/controllers/AuthController.js b/api/server/controllers/AuthController.js
index 47c7f2df0e..2445991ecc 100644
--- a/api/server/controllers/AuthController.js
+++ b/api/server/controllers/AuthController.js
@@ -13,6 +13,7 @@ const {
const {
requestPasswordReset,
setOpenIDAuthTokens,
+ storeOpenIDSession,
setCloudFrontAuthCookies,
resetPassword,
setAuthTokens,
@@ -242,6 +243,13 @@ const refreshController = async (req, res) => {
);
}
+ const activeRefreshToken = tokenset.refresh_token || refreshToken;
+ await storeOpenIDSession(
+ user._id.toString(),
+ activeRefreshToken,
+ user.tenantId,
+ refreshToken,
+ );
const token = setOpenIDAuthTokens(tokenset, req, res, {
userId: user._id.toString(),
existingRefreshToken: refreshToken,
diff --git a/api/server/controllers/AuthController.spec.js b/api/server/controllers/AuthController.spec.js
index 607d4b1b7d..7524df63d0 100644
--- a/api/server/controllers/AuthController.spec.js
+++ b/api/server/controllers/AuthController.spec.js
@@ -7,6 +7,7 @@ jest.mock('~/server/services/GraphTokenService', () => ({
jest.mock('~/server/services/AuthService', () => ({
requestPasswordReset: jest.fn(),
setOpenIDAuthTokens: jest.fn(),
+ storeOpenIDSession: jest.fn(),
setCloudFrontAuthCookies: jest.fn(),
resetPassword: jest.fn(),
setAuthTokens: jest.fn(),
@@ -47,6 +48,7 @@ const { graphTokenController, refreshController } = require('./AuthController');
const { getGraphApiToken } = require('~/server/services/GraphTokenService');
const {
setOpenIDAuthTokens,
+ storeOpenIDSession,
setCloudFrontAuthCookies,
setAuthTokens,
} = require('~/server/services/AuthService');
@@ -236,6 +238,7 @@ describe('refreshController – OpenID path', () => {
mockTokenset.claims.mockReturnValue(baseClaims);
getOpenIdEmail.mockReturnValue(baseClaims.email);
setOpenIDAuthTokens.mockReturnValue('new-app-token');
+ storeOpenIDSession.mockResolvedValue(true);
setCloudFrontAuthCookies.mockReturnValue(true);
findOpenIDUser.mockResolvedValue({ user: { ...defaultUser }, error: null, migration: false });
getUserById.mockResolvedValue({
@@ -289,6 +292,12 @@ describe('refreshController – OpenID path', () => {
existingRefreshToken: 'stored-refresh',
tenantId: undefined,
});
+ expect(storeOpenIDSession).toHaveBeenCalledWith(
+ 'user-db-id',
+ 'new-refresh',
+ undefined,
+ 'stored-refresh',
+ );
};
it('should call getOpenIdEmail with token claims and use result for findOpenIDUser', async () => {
diff --git a/api/server/controllers/assistants/v1.js b/api/server/controllers/assistants/v1.js
index 82aa174dff..7116edda75 100644
--- a/api/server/controllers/assistants/v1.js
+++ b/api/server/controllers/assistants/v1.js
@@ -95,7 +95,7 @@ const createAssistant = async (req, res) => {
const assistant = await openai.beta.assistants.create(assistantData);
- const createData = { user: req.user.id };
+ const createData = { user: req.user.id, endpoint };
if (conversation_starters) {
createData.conversation_starters = conversation_starters;
}
@@ -366,6 +366,7 @@ const uploadAssistantAvatar = async (req, res) => {
}
const { assistant_id } = req.params;
+ const endpoint = req.body?.endpoint ?? req.query?.endpoint;
if (!assistant_id) {
return res.status(400).json({ message: 'Assistant ID is required' });
}
@@ -422,6 +423,7 @@ const uploadAssistantAvatar = async (req, res) => {
source: appConfig.fileStrategy,
},
user: req.user.id,
+ endpoint,
},
),
);
diff --git a/api/server/controllers/assistants/v2.js b/api/server/controllers/assistants/v2.js
index 9b758097a5..afaf04f5d0 100644
--- a/api/server/controllers/assistants/v2.js
+++ b/api/server/controllers/assistants/v2.js
@@ -85,7 +85,7 @@ const createAssistant = async (req, res) => {
const assistant = await openai.beta.assistants.create(assistantData);
- const createData = { user: req.user.id };
+ const createData = { user: req.user.id, endpoint };
if (conversation_starters) {
createData.conversation_starters = conversation_starters;
}
diff --git a/api/server/controllers/auth/oauth.js b/api/server/controllers/auth/oauth.js
index b50fc65a47..368f8729f5 100644
--- a/api/server/controllers/auth/oauth.js
+++ b/api/server/controllers/auth/oauth.js
@@ -7,7 +7,11 @@ const {
generateAdminExchangeCode,
} = require('@librechat/api');
const { syncUserEntraGroupMemberships } = require('~/server/services/PermissionService');
-const { setAuthTokens, setOpenIDAuthTokens } = require('~/server/services/AuthService');
+const {
+ setAuthTokens,
+ setOpenIDAuthTokens,
+ storeOpenIDSession,
+} = require('~/server/services/AuthService');
const getLogStores = require('~/cache/getLogStores');
const { checkBan } = require('~/server/middleware');
const { generateToken } = require('~/models');
@@ -76,6 +80,11 @@ function createOAuthHandler(redirectUri = domains.client) {
isEnabled(process.env.OPENID_REUSE_TOKENS) === true
) {
await syncUserEntraGroupMemberships(req.user, req.user.tokenset.access_token);
+ await storeOpenIDSession(
+ req.user._id.toString(),
+ req.user.tokenset.refresh_token,
+ req.user.tenantId,
+ );
setOpenIDAuthTokens(req.user.tokenset, req, res, {
userId: req.user._id.toString(),
tenantId: req.user.tenantId,
diff --git a/api/server/controllers/auth/oauth.spec.js b/api/server/controllers/auth/oauth.spec.js
index d9984a8dd5..62290210e2 100644
--- a/api/server/controllers/auth/oauth.spec.js
+++ b/api/server/controllers/auth/oauth.spec.js
@@ -5,6 +5,7 @@ const mockGenerateAdminExchangeCode = jest.fn();
const mockSyncUserEntraGroupMemberships = jest.fn();
const mockSetAuthTokens = jest.fn();
const mockSetOpenIDAuthTokens = jest.fn();
+const mockStoreOpenIDSession = jest.fn();
const mockGetLogStores = jest.fn();
const mockCheckBan = jest.fn();
const mockGenerateToken = jest.fn();
@@ -33,6 +34,7 @@ jest.mock('~/server/services/PermissionService', () => ({
jest.mock('~/server/services/AuthService', () => ({
setAuthTokens: (...args) => mockSetAuthTokens(...args),
setOpenIDAuthTokens: (...args) => mockSetOpenIDAuthTokens(...args),
+ storeOpenIDSession: (...args) => mockStoreOpenIDSession(...args),
}));
jest.mock(
@@ -92,6 +94,7 @@ describe('createOAuthHandler', () => {
mockCheckBan.mockResolvedValue(undefined);
mockGenerateToken.mockResolvedValue('jwt-token');
mockGenerateAdminExchangeCode.mockResolvedValue('exchange-code');
+ mockStoreOpenIDSession.mockResolvedValue(true);
});
afterAll(() => {
@@ -149,6 +152,28 @@ describe('createOAuthHandler', () => {
expect(next).not.toHaveBeenCalled();
});
+ it('stores the OpenID refresh token before setting cookies for the standard app', async () => {
+ process.env.OPENID_REUSE_TOKENS = 'true';
+ mockIsAdminPanelRedirect.mockReturnValue(false);
+ const handler = createOAuthHandler('http://localhost:3080');
+ const req = buildReq();
+ const res = buildRes();
+ const next = jest.fn();
+
+ await handler(req, res, next);
+
+ expect(mockStoreOpenIDSession).toHaveBeenCalledWith(
+ 'user-123',
+ 'openid-refresh-token',
+ undefined,
+ );
+ expect(mockSetOpenIDAuthTokens).toHaveBeenCalledWith(req.user.tokenset, req, res, {
+ userId: 'user-123',
+ tenantId: undefined,
+ });
+ expect(res.redirect).toHaveBeenCalledWith('http://localhost:3080');
+ });
+
it('forwards the refresh token from req.authInfo for non-openid admin providers', async () => {
const handler = createOAuthHandler('http://admin.example.com/auth/google/callback');
const req = buildReq({
diff --git a/api/server/experimental.js b/api/server/experimental.js
index 9264df4544..edd3d84e02 100644
--- a/api/server/experimental.js
+++ b/api/server/experimental.js
@@ -535,7 +535,13 @@ if (cluster.isMaster) {
app.use('/api/config', preAuthTenantMiddleware, optionalJwtAuth, routes.config);
app.use('/api/assistants', routes.assistants);
app.use('/api/files', await routes.files.initialize());
- app.use('/images/', createValidateImageRequest(appConfig.secureImageLinks), routes.staticRoute);
+ app.use(
+ '/images/',
+ createValidateImageRequest({
+ secureImageLinks: appConfig.secureImageLinks,
+ }),
+ routes.staticRoute,
+ );
app.use('/api/share', preAuthTenantMiddleware, routes.share);
app.use('/api/roles', routes.roles);
app.use('/api/agents', routes.agents);
diff --git a/api/server/index.js b/api/server/index.js
index 05594e2661..795ca8ac6f 100644
--- a/api/server/index.js
+++ b/api/server/index.js
@@ -387,7 +387,13 @@ const startServer = async () => {
app.use('/api/config', preAuthTenantMiddleware, optionalJwtAuth, routes.config);
app.use('/api/assistants', routes.assistants);
app.use('/api/files', await routes.files.initialize());
- app.use('/images/', createValidateImageRequest(appConfig.secureImageLinks), routes.staticRoute);
+ app.use(
+ '/images/',
+ createValidateImageRequest({
+ secureImageLinks: appConfig.secureImageLinks,
+ }),
+ routes.staticRoute,
+ );
app.use('/api/share', preAuthTenantMiddleware, routes.share);
app.use('/api/roles', routes.roles);
app.use('/api/agents/chat', rejectChatStartsUntilReady);
diff --git a/api/server/middleware/spec/validateImages.spec.js b/api/server/middleware/spec/validateImages.spec.js
index ebf5eafc8a..ba04a27310 100644
--- a/api/server/middleware/spec/validateImages.spec.js
+++ b/api/server/middleware/spec/validateImages.spec.js
@@ -1,4 +1,5 @@
const jwt = require('jsonwebtoken');
+const { createHash } = require('node:crypto');
const createValidateImageRequest = require('~/server/middleware/validateImageRequest');
// Mock only isEnabled, keep getBasePath real so it reads process.env.DOMAIN_CLIENT
@@ -6,8 +7,30 @@ jest.mock('@librechat/api', () => ({
...jest.requireActual('@librechat/api'),
isEnabled: jest.fn(),
}));
+jest.mock('~/models', () => ({
+ findSession: jest.fn(),
+ getAgent: jest.fn(),
+ getAssistant: jest.fn(),
+ getUserById: jest.fn(),
+ getUserPrincipals: jest.fn(),
+ hasCapabilityForPrincipals: jest.fn(),
+ hasPermission: jest.fn(),
+}));
+jest.mock('~/server/services/Config', () => ({
+ getAppConfig: jest.fn(),
+}));
const { isEnabled } = require('@librechat/api');
+const {
+ findSession,
+ getAgent,
+ getAssistant,
+ getUserById,
+ getUserPrincipals,
+ hasCapabilityForPrincipals,
+ hasPermission,
+} = require('~/models');
+const { getAppConfig } = require('~/server/services/Config');
describe('validateImageRequest middleware', () => {
let req, res, next, validateImageRequest;
@@ -20,6 +43,7 @@ describe('validateImageRequest middleware', () => {
originalUrl: '',
};
res = {
+ locals: {},
status: jest.fn().mockReturnThis(),
send: jest.fn(),
};
@@ -30,6 +54,14 @@ describe('validateImageRequest middleware', () => {
// Default: OpenID token reuse disabled
isEnabled.mockReturnValue(false);
+ getAgent.mockResolvedValue(null);
+ getAssistant.mockResolvedValue(null);
+ getAppConfig.mockResolvedValue({ endpoints: {} });
+ getUserById.mockResolvedValue({ role: 'USER', tenantId: 'tenant-a', idOnTheSource: null });
+ findSession.mockResolvedValue({ _id: 'session' });
+ getUserPrincipals.mockResolvedValue([{ principalType: 'user', principalId: validObjectId }]);
+ hasCapabilityForPrincipals.mockResolvedValue(false);
+ hasPermission.mockResolvedValue(false);
});
afterEach(() => {
@@ -44,12 +76,68 @@ describe('validateImageRequest middleware', () => {
expect(res.status).not.toHaveBeenCalled();
});
- test('should return validation middleware if secureImageLinks is true', async () => {
- validateImageRequest = createValidateImageRequest(true);
+ test('should protect images when secureImageLinks is omitted', async () => {
+ validateImageRequest = createValidateImageRequest();
await validateImageRequest(req, res, next);
expect(res.status).toHaveBeenCalledWith(401);
expect(res.send).toHaveBeenCalledWith('Unauthorized');
});
+
+ test('should honor an owner-scoped setting that disables image protection', async () => {
+ getAppConfig.mockResolvedValue({ secureImageLinks: false, endpoints: {} });
+ req.originalUrl = '/images/65cfb246f7ecadb8b1e8036c/example.jpg';
+ const middleware = createValidateImageRequest({ secureImageLinks: true });
+
+ await middleware(req, res, next);
+
+ expect(next).toHaveBeenCalledTimes(1);
+ expect(res.locals.privateImageCache).toBeUndefined();
+ });
+
+ test('should honor an owner-scoped setting that enables image protection', async () => {
+ getAppConfig.mockResolvedValue({ secureImageLinks: true, endpoints: {} });
+ req.originalUrl = '/images/65cfb246f7ecadb8b1e8036c/example.jpg';
+ const middleware = createValidateImageRequest({ secureImageLinks: false });
+
+ await middleware(req, res, next);
+
+ expect(next).not.toHaveBeenCalled();
+ expect(res.status).toHaveBeenCalledWith(401);
+ expect(res.locals.privateImageCache).toBe(true);
+ });
+
+ test('should use the disabled fallback for an image without an owner layout', async () => {
+ req.originalUrl = '/images/logo.png';
+ const middleware = createValidateImageRequest({ secureImageLinks: false });
+
+ await middleware(req, res, next);
+
+ expect(next).toHaveBeenCalledTimes(1);
+ expect(getAppConfig).not.toHaveBeenCalled();
+ });
+
+ test('should use the disabled fallback when the path owner no longer exists', async () => {
+ getUserById.mockResolvedValue(null);
+ req.originalUrl = '/images/65cfb246f7ecadb8b1e8036c/orphaned.png';
+ const middleware = createValidateImageRequest({ secureImageLinks: false });
+
+ await middleware(req, res, next);
+
+ expect(next).toHaveBeenCalledTimes(1);
+ expect(getAppConfig).not.toHaveBeenCalled();
+ });
+
+ test('should normalize repeated separators before applying a disabled fallback', async () => {
+ getAppConfig.mockResolvedValue({ secureImageLinks: true, endpoints: {} });
+ req.originalUrl = '/images//65cfb246f7ecadb8b1e8036c/private.png';
+ const middleware = createValidateImageRequest({ secureImageLinks: false });
+
+ await middleware(req, res, next);
+
+ expect(next).not.toHaveBeenCalled();
+ expect(res.status).toHaveBeenCalledWith(401);
+ expect(getAppConfig).toHaveBeenCalledTimes(1);
+ });
});
describe('Standard LibreChat token flow', () => {
@@ -92,6 +180,21 @@ describe('validateImageRequest middleware', () => {
expect(next).toHaveBeenCalled();
});
+ test('should reject a valid refresh token after its session is revoked', async () => {
+ const validToken = jwt.sign(
+ { id: validObjectId, exp: Math.floor(Date.now() / 1000) + 3600 },
+ process.env.JWT_REFRESH_SECRET,
+ );
+ findSession.mockResolvedValue(null);
+ req.headers.cookie = `refreshToken=${validToken}`;
+ req.originalUrl = `/images/${validObjectId}/example.jpg`;
+
+ await validateImageRequest(req, res, next);
+
+ expect(next).not.toHaveBeenCalled();
+ expect(res.status).toHaveBeenCalledWith(403);
+ });
+
test('should return 403 for invalid image path', async () => {
const validToken = jwt.sign(
{ id: validObjectId, exp: Math.floor(Date.now() / 1000) + 3600 },
@@ -104,15 +207,120 @@ describe('validateImageRequest middleware', () => {
expect(res.send).toHaveBeenCalledWith('Access Denied');
});
- test('should allow agent avatar pattern for any valid ObjectId', async () => {
+ test('should allow an agent avatar when the user has VIEW access', async () => {
+ const validToken = jwt.sign(
+ { id: validObjectId, exp: Math.floor(Date.now() / 1000) + 3600 },
+ process.env.JWT_REFRESH_SECRET,
+ );
+ req.headers.cookie = `refreshToken=${validToken}`;
+ req.originalUrl = '/images/65cfb246f7ecadb8b1e8036c/agent-agent_abc123-avatar-12345.png';
+ getAgent.mockResolvedValue({ _id: '65cfb246f7ecadb8b1e8036c' });
+ hasPermission.mockResolvedValue(true);
+ await validateImageRequest(req, res, next);
+ expect(next).toHaveBeenCalled();
+ expect(getUserPrincipals).toHaveBeenCalledTimes(1);
+ expect(hasPermission).toHaveBeenLastCalledWith(
+ [{ principalType: 'user', principalId: validObjectId }],
+ 'agent',
+ '65cfb246f7ecadb8b1e8036c',
+ 1,
+ );
+ expect(getAgent).toHaveBeenCalledWith(
+ {
+ id: 'agent_abc123',
+ 'avatar.filepath': {
+ $in: [
+ '/images/65cfb246f7ecadb8b1e8036c/agent-agent_abc123-avatar-12345.png',
+ '/images/65cfb246f7ecadb8b1e8036c/agent-agent_abc123-avatar-12345.png?manual=false',
+ '/images/65cfb246f7ecadb8b1e8036c/agent-agent_abc123-avatar-12345.png?manual=true',
+ ],
+ },
+ },
+ { _id: 1 },
+ );
+ });
+
+ test('should deny an agent avatar when the user lacks VIEW access', async () => {
+ const validToken = jwt.sign(
+ { id: validObjectId, exp: Math.floor(Date.now() / 1000) + 3600 },
+ process.env.JWT_REFRESH_SECRET,
+ );
+ req.headers.cookie = `refreshToken=${validToken}`;
+ req.originalUrl = '/images/65cfb246f7ecadb8b1e8036c/agent-agent_abc123-avatar-12345.png';
+ getAgent.mockResolvedValue({ _id: '65cfb246f7ecadb8b1e8036c' });
+ await validateImageRequest(req, res, next);
+ expect(next).not.toHaveBeenCalled();
+ expect(res.status).toHaveBeenCalledWith(403);
+ });
+
+ test('should allow an agent avatar for a user who manages agents', async () => {
+ const validToken = jwt.sign(
+ { id: validObjectId, exp: Math.floor(Date.now() / 1000) + 3600 },
+ process.env.JWT_REFRESH_SECRET,
+ );
+ req.headers.cookie = `refreshToken=${validToken}`;
+ req.originalUrl = '/images/65cfb246f7ecadb8b1e8036c/agent-agent_abc123-avatar-12345.png';
+ getAgent.mockResolvedValue({ _id: '65cfb246f7ecadb8b1e8036c' });
+ hasCapabilityForPrincipals.mockResolvedValue(true);
+ await validateImageRequest(req, res, next);
+ expect(next).toHaveBeenCalled();
+ expect(hasCapabilityForPrincipals).toHaveBeenCalledWith(
+ expect.objectContaining({ tenantId: 'tenant-a' }),
+ );
+ expect(hasPermission).not.toHaveBeenCalled();
+ });
+
+ test('should allow an anonymous viewer to load a publicly viewable agent avatar', async () => {
+ req.originalUrl = '/images/65cfb246f7ecadb8b1e8036c/agent-agent_abc123-avatar-12345.png';
+ getAgent.mockResolvedValue({ _id: '65cfb246f7ecadb8b1e8036c' });
+ hasPermission.mockResolvedValue(true);
+
+ await validateImageRequest(req, res, next);
+
+ expect(next).toHaveBeenCalled();
+ expect(getUserPrincipals).not.toHaveBeenCalled();
+ expect(hasPermission).toHaveBeenCalledWith(
+ [{ principalType: 'public' }],
+ 'agent',
+ '65cfb246f7ecadb8b1e8036c',
+ 1,
+ );
+ });
+
+ test('should allow a shared assistant avatar for a different authenticated user', async () => {
+ validateImageRequest = createValidateImageRequest({
+ secureImageLinks: true,
+ });
+ getAppConfig.mockResolvedValue({
+ endpoints: { assistants: { privateAssistants: false } },
+ });
const validToken = jwt.sign(
{ id: validObjectId, exp: Math.floor(Date.now() / 1000) + 3600 },
process.env.JWT_REFRESH_SECRET,
);
req.headers.cookie = `refreshToken=${validToken}`;
- req.originalUrl = '/images/65cfb246f7ecadb8b1e8036c/agent-avatar-12345.png';
+ req.originalUrl = '/images/65cfb246f7ecadb8b1e8036c/assistant-avatar.png';
+ getAssistant.mockResolvedValue({
+ _id: '65cfb246f7ecadb8b1e8036d',
+ assistant_id: 'asst_shared',
+ endpoint: 'assistants',
+ });
+
await validateImageRequest(req, res, next);
+
expect(next).toHaveBeenCalled();
+ expect(getAssistant).toHaveBeenCalledWith(
+ {
+ 'avatar.filepath': {
+ $in: [
+ '/images/65cfb246f7ecadb8b1e8036c/assistant-avatar.png',
+ '/images/65cfb246f7ecadb8b1e8036c/assistant-avatar.png?manual=false',
+ '/images/65cfb246f7ecadb8b1e8036c/assistant-avatar.png?manual=true',
+ ],
+ },
+ },
+ { _id: 1, assistant_id: 1, endpoint: 1 },
+ );
});
test('should prevent file traversal attempts', async () => {
@@ -159,6 +367,7 @@ describe('validateImageRequest middleware', () => {
// Enable OpenID token reuse
isEnabled.mockReturnValue(true);
process.env.OPENID_REUSE_TOKENS = 'true';
+ req.session = { openidTokens: { refreshToken: 'dummy-token' } };
});
test('should return 403 if no OpenID user ID cookie when token_provider is openid', async () => {
@@ -179,6 +388,29 @@ describe('validateImageRequest middleware', () => {
expect(next).toHaveBeenCalled();
});
+ test('should validate a refresh-bound user ID after the OpenID session expires', async () => {
+ const refreshToken = 'dummy-token';
+ const signedUserId = jwt.sign(
+ {
+ id: validObjectId,
+ refreshTokenHash: createHash('sha256').update(refreshToken).digest('base64url'),
+ exp: Math.floor(Date.now() / 1000) + 3600,
+ },
+ process.env.JWT_REFRESH_SECRET,
+ );
+ req.session = undefined;
+ req.headers.cookie = `refreshToken=${refreshToken}; token_provider=openid; openid_user_id=${signedUserId}`;
+ req.originalUrl = `/images/${validObjectId}/example.jpg`;
+
+ await validateImageRequest(req, res, next);
+
+ expect(next).toHaveBeenCalled();
+ expect(findSession).toHaveBeenCalledWith({
+ userId: validObjectId,
+ refreshToken,
+ });
+ });
+
test('should return 403 for invalid JWT-signed user ID', async () => {
req.headers.cookie =
'refreshToken=dummy-token; token_provider=openid; openid_user_id=invalid-jwt';
@@ -217,7 +449,9 @@ describe('validateImageRequest middleware', () => {
process.env.JWT_REFRESH_SECRET,
);
req.headers.cookie = `refreshToken=dummy-token; token_provider=openid; openid_user_id=${signedUserId}`;
- req.originalUrl = '/images/65cfb246f7ecadb8b1e8036c/agent-avatar-12345.png';
+ req.originalUrl = '/images/65cfb246f7ecadb8b1e8036c/agent-agent_abc123-avatar-12345.png';
+ getAgent.mockResolvedValue({ _id: '65cfb246f7ecadb8b1e8036c' });
+ hasPermission.mockResolvedValue(true);
await validateImageRequest(req, res, next);
expect(next).toHaveBeenCalled();
});
@@ -332,7 +566,10 @@ describe('validateImageRequest middleware', () => {
process.env.JWT_REFRESH_SECRET,
);
req.headers.cookie = `refreshToken=${validToken}`;
- req.originalUrl = `/librechat/images/${validObjectId}/agent-avatar.png`;
+ req.originalUrl =
+ '/librechat/images/65cfb246f7ecadb8b1e8036c/agent-agent_abc123-avatar-12345.png';
+ getAgent.mockResolvedValue({ _id: '65cfb246f7ecadb8b1e8036c' });
+ hasPermission.mockResolvedValue(true);
await validateImageRequest(req, res, next);
expect(next).toHaveBeenCalled();
@@ -465,6 +702,7 @@ describe('validateImageRequest middleware', () => {
process.env.JWT_REFRESH_SECRET,
);
req.headers.cookie = `refreshToken=${validToken}; token_provider=openid; openid_user_id=${validToken}`;
+ req.session = { openidTokens: { refreshToken: validToken } };
req.originalUrl = `/librechat/images/${validObjectId}/test.jpg`;
await validateImageRequest(req, res, next);
diff --git a/api/server/middleware/validateImageRequest.js b/api/server/middleware/validateImageRequest.js
index 4d954d07c4..ac8b9f00d4 100644
--- a/api/server/middleware/validateImageRequest.js
+++ b/api/server/middleware/validateImageRequest.js
@@ -1,162 +1,72 @@
-const cookies = require('cookie');
-const jwt = require('jsonwebtoken');
-const { logger } = require('@librechat/data-schemas');
-const { isEnabled, getBasePath } = require('@librechat/api');
-
-const OBJECT_ID_LENGTH = 24;
-const OBJECT_ID_PATTERN = /^[0-9a-f]{24}$/i;
-
-/**
- * Validates if a string is a valid MongoDB ObjectId
- * @param {string} id - String to validate
- * @returns {boolean} - Whether string is a valid ObjectId format
- */
-function isValidObjectId(id) {
- if (typeof id !== 'string') {
- return false;
- }
- if (id.length !== OBJECT_ID_LENGTH) {
- return false;
- }
- return OBJECT_ID_PATTERN.test(id);
-}
-
-/**
- * Validates a LibreChat refresh token
- * @param {string} refreshToken - The refresh token to validate
- * @returns {{valid: boolean, userId?: string, error?: string}} - Validation result
- */
-function validateToken(refreshToken) {
- try {
- const payload = jwt.verify(refreshToken, process.env.JWT_REFRESH_SECRET);
-
- if (!isValidObjectId(payload.id)) {
- return { valid: false, error: 'Invalid User ID' };
- }
-
- const currentTimeInSeconds = Math.floor(Date.now() / 1000);
- if (payload.exp < currentTimeInSeconds) {
- return { valid: false, error: 'Refresh token expired' };
- }
-
- return { valid: true, userId: payload.id };
- } catch (err) {
- logger.warn('[validateToken]', err);
- return { valid: false, error: 'Invalid token' };
- }
-}
+const cookie = require('cookie');
+const {
+ createImageAuthorizationMiddleware,
+ getAppConfigOptionsFromUser,
+ getBasePath,
+ isEnabled,
+} = require('@librechat/api');
+const {
+ findSession,
+ getAgent,
+ getAssistant,
+ getUserById,
+ getUserPrincipals,
+ hasCapabilityForPrincipals,
+ hasPermission,
+} = require('~/models');
+const { getAppConfig } = require('~/server/services/Config');
+
+const getAssistantEndpointConfigs = (appConfig) =>
+ [
+ appConfig?.endpoints?.assistants && {
+ endpoint: 'assistants',
+ ...appConfig.endpoints.assistants,
+ },
+ appConfig?.endpoints?.azureAssistants && {
+ endpoint: 'azureAssistants',
+ ...appConfig.endpoints.azureAssistants,
+ },
+ ].filter(Boolean);
/**
- * Factory to create the `validateImageRequest` middleware with configured secureImageLinks
- * @param {boolean} [secureImageLinks] - Whether secure image links are enabled
+ * Thin Express adapter for the typed image-authorization service in `@librechat/api`.
+ * @param {boolean | {secureImageLinks?: boolean, assistantEndpoints?: object[]}} [config]
*/
-function createValidateImageRequest(secureImageLinks) {
- if (!secureImageLinks) {
- return (_req, _res, next) => next();
- }
- /**
- * Middleware to validate image request.
- * Supports both LibreChat refresh tokens and OpenID JWT tokens.
- * Must be set by `secureImageLinks` via custom config file.
- */
- return async function validateImageRequest(req, res, next) {
- try {
- const cookieHeader = req.headers.cookie;
- if (!cookieHeader) {
- logger.warn('[validateImageRequest] No cookies provided');
- return res.status(401).send('Unauthorized');
- }
-
- const parsedCookies = cookies.parse(cookieHeader);
- const tokenProvider = parsedCookies.token_provider;
- let userIdForPath;
-
- if (tokenProvider === 'openid' && isEnabled(process.env.OPENID_REUSE_TOKENS)) {
- /** For OpenID users with OPENID_REUSE_TOKENS, use openid_user_id cookie */
- const openidUserId = parsedCookies.openid_user_id;
- if (!openidUserId) {
- logger.warn('[validateImageRequest] No OpenID user ID cookie found');
- return res.status(403).send('Access Denied');
- }
-
- const validationResult = validateToken(openidUserId);
- if (!validationResult.valid) {
- logger.warn(`[validateImageRequest] ${validationResult.error}`);
- return res.status(403).send('Access Denied');
- }
- userIdForPath = validationResult.userId;
- } else {
- /**
- * For non-OpenID users (or OpenID without REUSE_TOKENS), use refreshToken from cookies.
- * These users authenticate via setAuthTokens() which stores refreshToken in cookies.
- */
- const refreshToken = parsedCookies.refreshToken;
-
- if (!refreshToken) {
- logger.warn('[validateImageRequest] Token not provided');
- return res.status(401).send('Unauthorized');
- }
-
- const validationResult = validateToken(refreshToken);
- if (!validationResult.valid) {
- logger.warn(`[validateImageRequest] ${validationResult.error}`);
- return res.status(403).send('Access Denied');
- }
- userIdForPath = validationResult.userId;
- }
-
- if (!userIdForPath) {
- logger.warn('[validateImageRequest] No user ID available for path validation');
- return res.status(403).send('Access Denied');
- }
-
- const MAX_URL_LENGTH = 2048;
- if (req.originalUrl.length > MAX_URL_LENGTH) {
- logger.warn('[validateImageRequest] URL too long');
- return res.status(403).send('Access Denied');
- }
-
- if (req.originalUrl.includes('\x00')) {
- logger.warn('[validateImageRequest] URL contains null byte');
- return res.status(403).send('Access Denied');
- }
-
- let fullPath;
- try {
- fullPath = decodeURIComponent(req.originalUrl);
- } catch {
- logger.warn('[validateImageRequest] Invalid URL encoding');
- return res.status(403).send('Access Denied');
- }
-
- const basePath = getBasePath();
- const imagesPath = `${basePath}/images`;
-
- const agentAvatarPattern = new RegExp(
- `^${imagesPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}/[a-f0-9]{24}/agent-[^/]*$`,
- );
- if (agentAvatarPattern.test(fullPath)) {
- logger.debug('[validateImageRequest] Image request validated');
- return next();
- }
-
- const escapedUserId = userIdForPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
- const pathPattern = new RegExp(
- `^${imagesPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}/${escapedUserId}/[^/]+$`,
+function createValidateImageRequest(config = {}) {
+ const resolveDynamicConfig = typeof config !== 'boolean';
+ const options =
+ typeof config === 'boolean'
+ ? { secureImageLinks: config }
+ : {
+ secureImageLinks: config.secureImageLinks,
+ assistantEndpoints: config.assistantEndpoints,
+ };
+
+ const deps = {
+ parseCookies: cookie.parse,
+ isOpenIdReuseEnabled: () => isEnabled(process.env.OPENID_REUSE_TOKENS),
+ getBasePath,
+ findSession,
+ getAgent,
+ getAssistant,
+ getUserById,
+ getUserPrincipals,
+ hasCapabilityForPrincipals,
+ hasPermission,
+ };
+ if (resolveDynamicConfig) {
+ deps.getImageConfig = async ({ userId, user }) => {
+ const appConfig = await getAppConfig(
+ getAppConfigOptionsFromUser({ ...user, id: userId }, user.tenantId),
);
+ return {
+ secureImageLinks: appConfig.secureImageLinks,
+ assistantEndpoints: getAssistantEndpointConfigs(appConfig),
+ };
+ };
+ }
- if (pathPattern.test(fullPath)) {
- logger.debug('[validateImageRequest] Image request validated');
- next();
- } else {
- logger.warn('[validateImageRequest] Invalid image path');
- res.status(403).send('Access Denied');
- }
- } catch (error) {
- logger.error('[validateImageRequest] Error:', error);
- res.status(500).send('Internal Server Error');
- }
- };
+ return createImageAuthorizationMiddleware(options, deps);
}
module.exports = createValidateImageRequest;
diff --git a/api/server/services/AuthService.js b/api/server/services/AuthService.js
index 40595d3081..224e8436bf 100644
--- a/api/server/services/AuthService.js
+++ b/api/server/services/AuthService.js
@@ -1,6 +1,6 @@
const bcrypt = require('bcryptjs');
const jwt = require('jsonwebtoken');
-const { webcrypto } = require('node:crypto');
+const { createHash, webcrypto } = require('node:crypto');
const {
logger,
getTenantId,
@@ -11,6 +11,7 @@ const { ErrorTypes, SystemRoles, errorsToString } = require('librechat-data-prov
const {
math,
isEnabled,
+ storeOpenIdSession,
checkEmailConfig,
setCloudFrontCookies,
getCloudFrontConfig,
@@ -32,6 +33,7 @@ const {
deleteTokens,
deleteSession,
createSession,
+ upsertSession,
generateToken,
deleteUserById,
generateRefreshToken,
@@ -826,10 +828,13 @@ const setOpenIDAuthTokens = (
sameSite: 'strict',
});
if (userId && isEnabled(process.env.OPENID_REUSE_TOKENS)) {
- /** JWT-signed user ID cookie for image path validation when OPENID_REUSE_TOKENS is enabled */
- const signedUserId = jwt.sign({ id: userId }, process.env.JWT_REFRESH_SECRET, {
- expiresIn: expiryInMilliseconds / 1000,
- });
+ /** Bind image cookie identity to the durable refresh-token session. */
+ const refreshTokenHash = createHash('sha256').update(refreshToken).digest('base64url');
+ const signedUserId = jwt.sign(
+ { id: userId, refreshTokenHash },
+ process.env.JWT_REFRESH_SECRET,
+ { expiresIn: expiryInMilliseconds / 1000 },
+ );
res.cookie('openid_user_id', signedUserId, {
expires: expirationDate,
httpOnly: true,
@@ -847,6 +852,14 @@ const setOpenIDAuthTokens = (
}
};
+/** Stores OpenID refresh-token state independently of the shorter Express session. */
+const storeOpenIDSession = async (userId, refreshToken, tenantId, previousRefreshToken) => {
+ return storeOpenIdSession(
+ { userId, refreshToken, tenantId, previousRefreshToken },
+ { upsertSession, deleteSession },
+ );
+};
+
/**
* Resend Verification Email
* @param {Object} req
@@ -915,6 +928,7 @@ module.exports = {
setAuthTokens,
resetPassword,
setOpenIDAuthTokens,
+ storeOpenIDSession,
setCloudFrontAuthCookies,
requestPasswordReset,
resendVerificationEmail,
diff --git a/api/server/services/AuthService.spec.js b/api/server/services/AuthService.spec.js
index 4750a52cbd..fb74692f9a 100644
--- a/api/server/services/AuthService.spec.js
+++ b/api/server/services/AuthService.spec.js
@@ -2,6 +2,7 @@ jest.mock(
'@librechat/data-schemas',
() => ({
logger: { info: jest.fn(), warn: jest.fn(), debug: jest.fn(), error: jest.fn() },
+ runAsSystem: (callback) => callback(),
getTenantId: jest.fn(() => undefined),
DEFAULT_SESSION_EXPIRY: 900000,
DEFAULT_REFRESH_TOKEN_EXPIRY: 604800000,
@@ -24,6 +25,7 @@ jest.mock(
checkEmailConfig: jest.fn(),
isEmailDomainAllowed: jest.fn(),
math: jest.fn((val, fallback) => (val ? Number(val) : fallback)),
+ storeOpenIdSession: jest.fn(),
shouldUseSecureCookie: jest.fn(() => false),
resolveAppConfigForUser: jest.fn(async (_getAppConfig, _user) => ({})),
setCloudFrontCookies: jest.fn(() => true),
@@ -51,6 +53,7 @@ jest.mock('~/models', () => ({
deleteTokens: jest.fn(),
deleteSession: jest.fn(),
createSession: jest.fn(),
+ upsertSession: jest.fn(),
generateToken: jest.fn(),
deleteUserById: jest.fn(),
generateRefreshToken: jest.fn(),
@@ -80,8 +83,10 @@ const {
setCloudFrontCookies,
getCloudFrontConfig,
parseCloudFrontCookieScope,
+ storeOpenIdSession,
} = require('@librechat/api');
const jwt = require('jsonwebtoken');
+const { createHash } = require('node:crypto');
const { logger, getTenantId } = require('@librechat/data-schemas');
const {
findUser,
@@ -93,6 +98,8 @@ const {
generateToken,
generateRefreshToken,
createSession,
+ upsertSession,
+ deleteSession,
createToken,
deleteTokens,
} = require('~/models');
@@ -101,6 +108,7 @@ const { sendEmail } = require('~/server/utils');
const bcrypt = require('bcryptjs');
const {
setOpenIDAuthTokens,
+ storeOpenIDSession,
requestPasswordReset,
registerUser,
resetPassword,
@@ -309,6 +317,57 @@ describe('setOpenIDAuthTokens', () => {
});
});
+ it('binds the signed OpenID user cookie to its refresh token', () => {
+ const tokenset = {
+ id_token: 'the-id-token',
+ access_token: 'the-access-token',
+ refresh_token: 'the-refresh-token',
+ };
+ const req = mockRequest();
+ const res = mockResponse();
+
+ setOpenIDAuthTokens(tokenset, req, res, 'user-123');
+
+ expect(jwt.verify(res._cookies.openid_user_id.value, process.env.JWT_REFRESH_SECRET)).toEqual(
+ expect.objectContaining({
+ id: 'user-123',
+ refreshTokenHash: createHash('sha256').update(tokenset.refresh_token).digest('base64url'),
+ }),
+ );
+ });
+
+ it('stores an OpenID refresh token for durable revocation checks', async () => {
+ storeOpenIdSession.mockResolvedValue(true);
+
+ await storeOpenIDSession('user-123', 'the-refresh-token', 'tenant-a');
+
+ expect(storeOpenIdSession).toHaveBeenCalledWith(
+ {
+ userId: 'user-123',
+ refreshToken: 'the-refresh-token',
+ tenantId: 'tenant-a',
+ previousRefreshToken: undefined,
+ },
+ { upsertSession, deleteSession },
+ );
+ });
+
+ it('revokes the previous durable session when the IdP rotates the refresh token', async () => {
+ storeOpenIdSession.mockResolvedValue(true);
+
+ await storeOpenIDSession('user-123', 'new-refresh-token', 'tenant-a', 'old-refresh-token');
+
+ expect(storeOpenIdSession).toHaveBeenCalledWith(
+ {
+ userId: 'user-123',
+ refreshToken: 'new-refresh-token',
+ tenantId: 'tenant-a',
+ previousRefreshToken: 'old-refresh-token',
+ },
+ { upsertSession, deleteSession },
+ );
+ });
+
describe('cookie secure flag', () => {
it('should call shouldUseSecureCookie for every cookie set', () => {
const tokenset = {
diff --git a/api/server/utils/__tests__/staticCache.spec.js b/api/server/utils/__tests__/staticCache.spec.js
index 2b22223393..66138927b1 100644
--- a/api/server/utils/__tests__/staticCache.spec.js
+++ b/api/server/utils/__tests__/staticCache.spec.js
@@ -132,6 +132,19 @@ describe('staticCache', () => {
expect(response.headers['cache-control']).toBe('no-store, no-cache, must-revalidate');
});
+
+ it('should prevent shared caching when authorization marks an image private', async () => {
+ app.use((_req, res, next) => {
+ res.locals.privateImageCache = true;
+ next();
+ });
+ app.use(staticCache(testDir));
+
+ const response = await request(app).get('/test.js').expect(200);
+
+ expect(response.headers['cache-control']).toBe('private, no-store');
+ expect(response.headers.vary).toBe('Cookie');
+ });
});
describe('cache headers in non-production', () => {
diff --git a/api/server/utils/staticCache.js b/api/server/utils/staticCache.js
index a16830a56c..f5d1af5cab 100644
--- a/api/server/utils/staticCache.js
+++ b/api/server/utils/staticCache.js
@@ -22,6 +22,11 @@ function staticCache(staticPath, options = {}) {
const enableBrotli = isEnabled(process.env.ENABLE_STATIC_ASSET_BROTLI);
const setHeaders = (res, filePath) => {
+ if (res.locals?.privateImageCache) {
+ res.setHeader('Cache-Control', 'private, no-store');
+ res.setHeader('Vary', 'Cookie');
+ return;
+ }
if (process.env.NODE_ENV?.toLowerCase() !== 'production') {
return;
}
diff --git a/packages/api/src/app/AppService.spec.ts b/packages/api/src/app/AppService.spec.ts
index c77ea9db5b..f4f64ef23c 100644
--- a/packages/api/src/app/AppService.spec.ts
+++ b/packages/api/src/app/AppService.spec.ts
@@ -120,7 +120,7 @@ describe('AppService', () => {
mcpConfig: null,
imageOutputType: expect.any(String),
fileConfig: undefined,
- secureImageLinks: undefined,
+ secureImageLinks: true,
balance: { enabled: true },
filteredTools: undefined,
includedTools: undefined,
@@ -163,6 +163,14 @@ describe('AppService', () => {
);
});
+ it('should require authentication for image links unless explicitly disabled', async () => {
+ const secureResult = await AppService({ config: {} });
+ const legacyResult = await AppService({ config: { secureImageLinks: false } });
+
+ expect(secureResult.secureImageLinks).toBe(true);
+ expect(legacyResult.secureImageLinks).toBe(false);
+ });
+
it('should default to `PNG` `imageOutputType` with no provided type', async () => {
const config = {
version: '0.10.0',
diff --git a/packages/api/src/images/authorization.spec.ts b/packages/api/src/images/authorization.spec.ts
new file mode 100644
index 0000000000..66bf6a77c3
--- /dev/null
+++ b/packages/api/src/images/authorization.spec.ts
@@ -0,0 +1,531 @@
+import jwt from 'jsonwebtoken';
+import { createHash } from 'node:crypto';
+import type { NextFunction, Request, Response } from 'express';
+import type { ImageAuthorizationDeps } from './authorization';
+import { createImageAuthorizationMiddleware } from './authorization';
+
+const VIEWER_ID = '65cfb246f7ecadb8b1e8036b';
+const OWNER_ID = '65cfb246f7ecadb8b1e8036c';
+const AGENT_DB_ID = '65cfb246f7ecadb8b1e8036d';
+const AGENT_PATH = `/images/${OWNER_ID}/agent-agent_abc123-avatar-12345.png`;
+const USER_AVATAR_PATH = `/images/${OWNER_ID}/avatar-12345.png`;
+
+function createResponse(): Response {
+ const response = {
+ locals: {},
+ status: jest.fn().mockReturnThis(),
+ send: jest.fn().mockReturnThis(),
+ };
+ return response as unknown as Response;
+}
+
+function createDeps(): ImageAuthorizationDeps {
+ return {
+ parseCookies: (header: string) =>
+ Object.fromEntries(
+ header.split(';').map((part: string) => {
+ const [key, ...value] = part.trim().split('=');
+ return [key, value.join('=')];
+ }),
+ ),
+ isOpenIdReuseEnabled: jest.fn().mockReturnValue(false),
+ getBasePath: jest.fn().mockReturnValue(''),
+ findSession: jest.fn().mockResolvedValue({ _id: 'active-session' }),
+ getUserById: jest.fn().mockResolvedValue({
+ role: 'USER',
+ tenantId: 'tenant-a',
+ idOnTheSource: null,
+ }),
+ getAgent: jest.fn().mockResolvedValue(null),
+ getAssistant: jest.fn().mockResolvedValue(null),
+ getUserPrincipals: jest
+ .fn()
+ .mockResolvedValue([{ principalType: 'user', principalId: VIEWER_ID }]),
+ hasCapabilityForPrincipals: jest.fn().mockResolvedValue(false),
+ hasPermission: jest.fn().mockResolvedValue(false),
+ } as unknown as ImageAuthorizationDeps;
+}
+
+function createRequest(path: string, cookie?: string): Request {
+ return {
+ originalUrl: path,
+ headers: cookie ? { cookie } : {},
+ } as unknown as Request;
+}
+
+function signUser(userId: string): string {
+ return jwt.sign({ id: userId }, process.env.JWT_REFRESH_SECRET as string, { expiresIn: '1h' });
+}
+
+function signOpenIdUser(userId: string, refreshToken: string): string {
+ return jwt.sign(
+ {
+ id: userId,
+ refreshTokenHash: createHash('sha256').update(refreshToken).digest('base64url'),
+ },
+ process.env.JWT_REFRESH_SECRET as string,
+ { expiresIn: '1h' },
+ );
+}
+
+describe('createImageAuthorizationMiddleware', () => {
+ let deps: ImageAuthorizationDeps;
+ let response: Response;
+ let next: jest.MockedFunction<NextFunction>;
+
+ beforeEach(() => {
+ process.env.JWT_REFRESH_SECRET = 'image-authorization-secret';
+ deps = createDeps();
+ response = createResponse();
+ next = jest.fn();
+ });
+
+ it('authenticates an active session and allows the owner path', async () => {
+ const token = signUser(VIEWER_ID);
+ const middleware = createImageAuthorizationMiddleware({}, deps);
+
+ await middleware(
+ createRequest(`/images/${VIEWER_ID}/profile.png`, `refreshToken=${token}`),
+ response,
+ next,
+ );
+
+ expect(next).toHaveBeenCalledTimes(1);
+ expect(deps.findSession).toHaveBeenCalledWith({ userId: VIEWER_ID, refreshToken: token });
+ });
+
+ it('rejects a signed refresh token whose session was revoked', async () => {
+ (deps.findSession as jest.Mock).mockResolvedValue(null);
+ const token = signUser(VIEWER_ID);
+ const middleware = createImageAuthorizationMiddleware({}, deps);
+
+ await middleware(
+ createRequest(`/images/${VIEWER_ID}/profile.png`, `refreshToken=${token}`),
+ response,
+ next,
+ );
+
+ expect(next).not.toHaveBeenCalled();
+ expect(response.status).toHaveBeenCalledWith(403);
+ });
+
+ it('authenticates a refresh-bound OpenID cookie after the Express session expires', async () => {
+ const refreshToken = 'openid-refresh-token';
+ const signedUserId = signOpenIdUser(VIEWER_ID, refreshToken);
+ (deps.isOpenIdReuseEnabled as jest.Mock).mockReturnValue(true);
+ const middleware = createImageAuthorizationMiddleware({}, deps);
+
+ await middleware(
+ createRequest(
+ `/images/${VIEWER_ID}/profile.png`,
+ `refreshToken=${refreshToken}; token_provider=openid; openid_user_id=${signedUserId}`,
+ ),
+ response,
+ next,
+ );
+
+ expect(next).toHaveBeenCalledTimes(1);
+ expect(deps.findSession).toHaveBeenCalledWith({
+ userId: VIEWER_ID,
+ refreshToken,
+ });
+ });
+
+ it('rejects an OpenID identity cookie paired with a different refresh token', async () => {
+ const signedUserId = signOpenIdUser(VIEWER_ID, 'expected-refresh-token');
+ (deps.isOpenIdReuseEnabled as jest.Mock).mockReturnValue(true);
+ const middleware = createImageAuthorizationMiddleware({}, deps);
+
+ await middleware(
+ createRequest(
+ `/images/${VIEWER_ID}/profile.png`,
+ `refreshToken=different-refresh-token; token_provider=openid; openid_user_id=${signedUserId}`,
+ ),
+ response,
+ next,
+ );
+
+ expect(next).not.toHaveBeenCalled();
+ expect(response.status).toHaveBeenCalledWith(403);
+ });
+
+ it('rejects a refresh-bound OpenID cookie after its durable session is revoked', async () => {
+ const refreshToken = 'revoked-openid-refresh-token';
+ const signedUserId = signOpenIdUser(VIEWER_ID, refreshToken);
+ (deps.isOpenIdReuseEnabled as jest.Mock).mockReturnValue(true);
+ (deps.findSession as jest.Mock).mockResolvedValue(null);
+ const middleware = createImageAuthorizationMiddleware({}, deps);
+
+ await middleware(
+ createRequest(
+ `/images/${VIEWER_ID}/profile.png`,
+ `refreshToken=${refreshToken}; token_provider=openid; openid_user_id=${signedUserId}`,
+ ),
+ response,
+ next,
+ );
+
+ expect(next).not.toHaveBeenCalled();
+ expect(response.status).toHaveBeenCalledWith(403);
+ });
+
+ it('requires an active Express session for a legacy OpenID identity cookie', async () => {
+ const refreshToken = 'legacy-refresh-token';
+ const signedUserId = signUser(VIEWER_ID);
+ (deps.isOpenIdReuseEnabled as jest.Mock).mockReturnValue(true);
+ const request = {
+ ...createRequest(
+ `/images/${VIEWER_ID}/profile.png`,
+ `refreshToken=${refreshToken}; token_provider=openid; openid_user_id=${signedUserId}`,
+ ),
+ session: { openidTokens: { refreshToken } },
+ } as unknown as Request;
+ const middleware = createImageAuthorizationMiddleware({}, deps);
+
+ await middleware(request, response, next);
+
+ expect(next).toHaveBeenCalledTimes(1);
+ });
+
+ it('uses the disabled fallback for an image path without an owner layout', async () => {
+ deps.getImageConfig = jest.fn();
+ const middleware = createImageAuthorizationMiddleware({ secureImageLinks: false }, deps);
+
+ await middleware(createRequest('/images/logo.png'), response, next);
+
+ expect(next).toHaveBeenCalledTimes(1);
+ expect(deps.getUserById).not.toHaveBeenCalled();
+ });
+
+ it('uses the disabled fallback when the path owner no longer exists', async () => {
+ deps.getImageConfig = jest.fn();
+ (deps.getUserById as jest.Mock).mockResolvedValue(null);
+ const middleware = createImageAuthorizationMiddleware({ secureImageLinks: false }, deps);
+
+ await middleware(createRequest(`/images/${OWNER_ID}/orphaned.png`), response, next);
+
+ expect(next).toHaveBeenCalledTimes(1);
+ expect(deps.getImageConfig).not.toHaveBeenCalled();
+ });
+
+ it('normalizes repeated separators before applying a disabled fallback', async () => {
+ deps.getImageConfig = jest.fn().mockResolvedValue({ secureImageLinks: true });
+ const middleware = createImageAuthorizationMiddleware({ secureImageLinks: false }, deps);
+
+ await middleware(createRequest(`/images//${OWNER_ID}/private.png`), response, next);
+
+ expect(next).not.toHaveBeenCalled();
+ expect(response.status).toHaveBeenCalledWith(401);
+ expect(deps.getImageConfig).toHaveBeenCalledTimes(1);
+ });
+
+ it('resolves principals once and applies the tenant to an agent capability check', async () => {
+ (deps.getAgent as jest.Mock).mockResolvedValue({ _id: AGENT_DB_ID });
+ (deps.hasPermission as jest.Mock).mockResolvedValue(true);
+ const token = signUser(VIEWER_ID);
+ const middleware = createImageAuthorizationMiddleware({}, deps);
+
+ await middleware(createRequest(AGENT_PATH, `refreshToken=${token}`), response, next);
+
+ expect(next).toHaveBeenCalledTimes(1);
+ expect(deps.getAgent).toHaveBeenCalledWith(
+ {
+ id: 'agent_abc123',
+ 'avatar.filepath': {
+ $in: [AGENT_PATH, `${AGENT_PATH}?manual=false`, `${AGENT_PATH}?manual=true`],
+ },
+ },
+ { _id: 1 },
+ );
+ expect(deps.getUserPrincipals).toHaveBeenCalledTimes(1);
+ expect(deps.hasCapabilityForPrincipals).toHaveBeenCalledWith(
+ expect.objectContaining({ tenantId: 'tenant-a' }),
+ );
+ expect(deps.hasPermission).toHaveBeenCalledTimes(1);
+ });
+
+ it('allows an anonymous request only when the agent has PUBLIC VIEW', async () => {
+ (deps.getAgent as jest.Mock).mockResolvedValue({ _id: AGENT_DB_ID });
+ (deps.hasPermission as jest.Mock).mockResolvedValue(true);
+ const middleware = createImageAuthorizationMiddleware({}, deps);
+
+ await middleware(createRequest(AGENT_PATH), response, next);
+
+ expect(next).toHaveBeenCalledTimes(1);
+ expect(deps.getUserPrincipals).not.toHaveBeenCalled();
+ expect(deps.hasPermission).toHaveBeenCalledWith(
+ [{ principalType: 'public' }],
+ 'agent',
+ AGENT_DB_ID,
+ 1,
+ );
+ });
+
+ it('does not apply a viewer role or group grant across tenant boundaries', async () => {
+ (deps.getAgent as jest.Mock).mockResolvedValue({ _id: AGENT_DB_ID });
+ (deps.getUserById as jest.Mock)
+ .mockResolvedValueOnce({ tenantId: 'tenant-a' })
+ .mockResolvedValueOnce({ role: 'USER', tenantId: 'tenant-b', idOnTheSource: null });
+ (deps.hasPermission as jest.Mock).mockResolvedValue(true);
+ const token = signUser(VIEWER_ID);
+ const middleware = createImageAuthorizationMiddleware({}, deps);
+
+ await middleware(createRequest(AGENT_PATH, `refreshToken=${token}`), response, next);
+
+ expect(next).toHaveBeenCalledTimes(1);
+ expect(deps.getUserPrincipals).not.toHaveBeenCalled();
+ expect(deps.hasCapabilityForPrincipals).not.toHaveBeenCalled();
+ expect(deps.hasPermission).toHaveBeenCalledWith(
+ [{ principalType: 'public' }],
+ 'agent',
+ AGENT_DB_ID,
+ 1,
+ );
+ });
+
+ it('preserves shared assistant avatars by matching their stored filepath', async () => {
+ (deps.getAssistant as jest.Mock).mockResolvedValue({
+ _id: '65cfb246f7ecadb8b1e8036e',
+ assistant_id: 'asst_shared',
+ endpoint: 'assistants',
+ });
+ const assistantPath = `/images/${OWNER_ID}/assistant-avatar.png`;
+ const middleware = createImageAuthorizationMiddleware(
+ { assistantEndpoints: [{ endpoint: 'assistants', privateAssistants: false }] },
+ deps,
+ );
+ const token = signUser(VIEWER_ID);
+
+ await middleware(createRequest(assistantPath, `refreshToken=${token}`), response, next);
+
+ expect(next).toHaveBeenCalledTimes(1);
+ expect(deps.getAssistant).toHaveBeenCalledWith(
+ {
+ 'avatar.filepath': {
+ $in: [assistantPath, `${assistantPath}?manual=false`, `${assistantPath}?manual=true`],
+ },
+ },
+ { _id: 1, assistant_id: 1, endpoint: 1 },
+ );
+ });
+
+ it('requires authentication for an otherwise shared assistant avatar', async () => {
+ (deps.getAssistant as jest.Mock).mockResolvedValue({
+ _id: '65cfb246f7ecadb8b1e8036e',
+ assistant_id: 'asst_shared',
+ endpoint: 'assistants',
+ });
+ const assistantPath = `/images/${OWNER_ID}/assistant-avatar.png`;
+ const middleware = createImageAuthorizationMiddleware(
+ { assistantEndpoints: [{ endpoint: 'assistants', privateAssistants: false }] },
+ deps,
+ );
+
+ await middleware(createRequest(assistantPath), response, next);
+
+ expect(next).not.toHaveBeenCalled();
+ expect(response.status).toHaveBeenCalledWith(401);
+ });
+
+ it('does not use a shared endpoint policy for a private endpoint assistant', async () => {
+ (deps.getAssistant as jest.Mock).mockResolvedValue({
+ _id: '65cfb246f7ecadb8b1e8036e',
+ assistant_id: 'asst_private',
+ endpoint: 'azureAssistants',
+ });
+ const assistantPath = `/images/${OWNER_ID}/assistant-avatar.png`;
+ const middleware = createImageAuthorizationMiddleware(
+ {
+ assistantEndpoints: [
+ { endpoint: 'assistants', privateAssistants: false },
+ { endpoint: 'azureAssistants', privateAssistants: true },
+ ],
+ },
+ deps,
+ );
+
+ await middleware(createRequest(assistantPath), response, next);
+
+ expect(next).not.toHaveBeenCalled();
+ expect(response.status).toHaveBeenCalledWith(401);
+ });
+
+ it('allows an authenticated same-tenant viewer to load the stored user avatar', async () => {
+ (deps.getUserById as jest.Mock)
+ .mockResolvedValueOnce({
+ tenantId: 'tenant-a',
+ avatar: `${USER_AVATAR_PATH}?manual=true`,
+ })
+ .mockResolvedValueOnce({ tenantId: 'tenant-a' });
+ const token = signUser(VIEWER_ID);
+ const middleware = createImageAuthorizationMiddleware({}, deps);
+
+ await middleware(createRequest(USER_AVATAR_PATH, `refreshToken=${token}`), response, next);
+
+ expect(next).toHaveBeenCalledTimes(1);
+ expect(deps.getUserById).toHaveBeenNthCalledWith(
+ 1,
+ OWNER_ID,
+ 'role tenantId idOnTheSource avatar',
+ );
+ expect(deps.getUserById).toHaveBeenNthCalledWith(2, VIEWER_ID, 'tenantId');
+ });
+
+ it('denies the stored user avatar to a viewer from another tenant', async () => {
+ (deps.getUserById as jest.Mock)
+ .mockResolvedValueOnce({
+ tenantId: 'tenant-a',
+ avatar: `${USER_AVATAR_PATH}?manual=true`,
+ })
+ .mockResolvedValueOnce({ tenantId: 'tenant-b' });
+ const token = signUser(VIEWER_ID);
+ const middleware = createImageAuthorizationMiddleware({}, deps);
+
+ await middleware(createRequest(USER_AVATAR_PATH, `refreshToken=${token}`), response, next);
+
+ expect(next).not.toHaveBeenCalled();
+ expect(response.status).toHaveBeenCalledWith(403);
+ });
+
+ it('normalizes a stored root image URL when the app uses a base path', async () => {
+ (deps.getBasePath as jest.Mock).mockReturnValue('/chat');
+ (deps.getUserById as jest.Mock)
+ .mockResolvedValueOnce({
+ tenantId: 'tenant-a',
+ avatar: `${USER_AVATAR_PATH}?manual=true`,
+ })
+ .mockResolvedValueOnce({ tenantId: 'tenant-a' });
+ const token = signUser(VIEWER_ID);
+ const middleware = createImageAuthorizationMiddleware({}, deps);
+
+ await middleware(
+ createRequest(`/chat${USER_AVATAR_PATH}`, `refreshToken=${token}`),
+ response,
+ next,
+ );
+
+ expect(next).toHaveBeenCalledTimes(1);
+ });
+
+ it('uses the owner principal endpoint config instead of the startup fallback', async () => {
+ (deps.getAssistant as jest.Mock).mockResolvedValue({
+ _id: '65cfb246f7ecadb8b1e8036e',
+ assistant_id: 'asst_private',
+ endpoint: 'assistants',
+ });
+ deps.getImageConfig = jest.fn().mockResolvedValue({
+ secureImageLinks: true,
+ assistantEndpoints: [{ endpoint: 'assistants', privateAssistants: true }],
+ });
+ const assistantPath = `/images/${OWNER_ID}/assistant-avatar.png`;
+ const middleware = createImageAuthorizationMiddleware(
+ { assistantEndpoints: [{ endpoint: 'assistants', privateAssistants: false }] },
+ deps,
+ );
+
+ await middleware(createRequest(assistantPath), response, next);
+
+ expect(next).not.toHaveBeenCalled();
+ expect(response.status).toHaveBeenCalledWith(401);
+ expect(deps.getImageConfig).toHaveBeenCalledWith({
+ userId: OWNER_ID,
+ user: expect.objectContaining({ tenantId: 'tenant-a' }),
+ });
+ });
+
+ it('starts protected image authentication while owner config is resolving', async () => {
+ let resolveConfig: ((config: { secureImageLinks: boolean }) => void) | undefined;
+ deps.getImageConfig = jest.fn(
+ () =>
+ new Promise((resolve) => {
+ resolveConfig = resolve;
+ }),
+ );
+ const token = signUser(VIEWER_ID);
+ const middleware = createImageAuthorizationMiddleware({}, deps);
+ const pending = middleware(
+ createRequest(`/images/${VIEWER_ID}/profile.png`, `refreshToken=${token}`),
+ response,
+ next,
+ );
+
+ await Promise.resolve();
+ await Promise.resolve();
+
+ expect(deps.getImageConfig).toHaveBeenCalledTimes(1);
+ expect(deps.findSession).toHaveBeenCalledWith({ userId: VIEWER_ID, refreshToken: token });
+ resolveConfig?.({ secureImageLinks: true });
+ await pending;
+ expect(next).toHaveBeenCalledTimes(1);
+ });
+
+ it('honors an owner-scoped setting that disables secure image links', async () => {
+ deps.getImageConfig = jest.fn().mockResolvedValue({
+ secureImageLinks: false,
+ assistantEndpoints: [],
+ });
+ const middleware = createImageAuthorizationMiddleware({}, deps);
+
+ await middleware(createRequest(`/images/${OWNER_ID}/private.png`), response, next);
+
+ expect(next).toHaveBeenCalledTimes(1);
+ expect(response.locals.privateImageCache).toBeUndefined();
+ });
+
+ it('honors an owner-scoped setting that enables protection over a disabled fallback', async () => {
+ deps.getImageConfig = jest.fn().mockResolvedValue({
+ secureImageLinks: true,
+ assistantEndpoints: [],
+ });
+ const middleware = createImageAuthorizationMiddleware({ secureImageLinks: false }, deps);
+
+ await middleware(createRequest(`/images/${OWNER_ID}/private.png`), response, next);
+
+ expect(next).not.toHaveBeenCalled();
+ expect(response.status).toHaveBeenCalledWith(401);
+ expect(response.locals.privateImageCache).toBe(true);
+ });
+
+ it('decodes an encoded deployment base path consistently with the request URL', async () => {
+ (deps.getBasePath as jest.Mock).mockReturnValue('/libre%20chat');
+ const token = signUser(VIEWER_ID);
+ const middleware = createImageAuthorizationMiddleware({}, deps);
+
+ await middleware(
+ createRequest(`/libre%20chat/images/${VIEWER_ID}/profile.png`, `refreshToken=${token}`),
+ response,
+ next,
+ );
+
+ expect(next).toHaveBeenCalledTimes(1);
+ });
+
+ it('marks protected image responses as private before serving them', async () => {
+ const token = signUser(VIEWER_ID);
+ const middleware = createImageAuthorizationMiddleware({}, deps);
+
+ await middleware(
+ createRequest(`/images/${VIEWER_ID}/profile.png`, `refreshToken=${token}`),
+ response,
+ next,
+ );
+
+ expect(response.locals.privateImageCache).toBe(true);
+ });
+
+ it('rejects encoded traversal before any resource lookup', async () => {
+ const token = signUser(VIEWER_ID);
+ const middleware = createImageAuthorizationMiddleware({}, deps);
+
+ await middleware(
+ createRequest(`/images/${VIEWER_ID}/..%2F..%2Fetc%2Fpasswd`, `refreshToken=${token}`),
+ response,
+ next,
+ );
+
+ expect(next).not.toHaveBeenCalled();
+ expect(response.status).toHaveBeenCalledWith(403);
+ expect(deps.getAgent).not.toHaveBeenCalled();
+ expect(deps.getAssistant).not.toHaveBeenCalled();
+ });
+});
diff --git a/packages/api/src/images/authorization.ts b/packages/api/src/images/authorization.ts
new file mode 100644
index 0000000000..87a7e26b2f
--- /dev/null
+++ b/packages/api/src/images/authorization.ts
@@ -0,0 +1,523 @@
+import { createHash } from 'node:crypto';
+import jwt, { type JwtPayload } from 'jsonwebtoken';
+import { PermissionBits, PrincipalType, ResourceType } from 'librechat-data-provider';
+import {
+ ResourceCapabilityMap,
+ SystemCapabilities,
+ logger,
+ runAsSystem,
+ tenantStorage,
+} from '@librechat/data-schemas';
+import type { IAgent, IAssistant, SystemCapability } from '@librechat/data-schemas';
+import type { Request, Response, NextFunction, RequestHandler } from 'express';
+import type { FilterQuery, ProjectionType, Types } from 'mongoose';
+
+const MAX_URL_LENGTH = 2048;
+const OBJECT_ID_PATTERN = /^[0-9a-f]{24}$/i;
+const AGENT_AVATAR_PATTERN = /^agent-(.+)-avatar-\d+\.[^/]+$/;
+
+type Principal = {
+ principalType: PrincipalType;
+ principalId?: string | Types.ObjectId;
+};
+
+type ImageUser = {
+ role?: string | null;
+ tenantId?: string;
+ idOnTheSource?: string | null;
+ avatar?: string | null;
+};
+
+type AssistantConfig = {
+ endpoint: string;
+ privateAssistants?: boolean;
+ supportedIds?: string[];
+ excludedIds?: string[];
+};
+
+type ImagePath = {
+ ownerId: string;
+ filename: string;
+ canonicalPath: string;
+ agentId?: string;
+};
+
+type AssistantImageRecord = Pick<IAssistant, '_id' | 'assistant_id'> & {
+ endpoint?: string;
+};
+
+type ResolvedImageConfig = {
+ secureImageLinks: boolean;
+ assistantEndpoints: AssistantConfig[];
+};
+
+type CookieAuthResult =
+ | { status: 'missing' }
+ | { status: 'invalid' }
+ | { status: 'authenticated'; userId: string };
+
+type OpenIdCookieAuthResult =
+ | { status: 'invalid' }
+ | { status: 'legacy'; userId: string }
+ | { status: 'authenticated'; userId: string };
+
+export interface ImageAuthorizationDeps {
+ parseCookies: (cookieHeader: string) => Record<string, string | undefined>;
+ isOpenIdReuseEnabled: () => boolean;
+ getBasePath: () => string;
+ findSession: (query: { userId: string; refreshToken: string }) => Promise<unknown | null>;
+ getUserById: (userId: string, select: string) => Promise<ImageUser | null>;
+ getAgent: (
+ query: FilterQuery<IAgent>,
+ projection?: ProjectionType<IAgent>,
+ ) => Promise<Pick<IAgent, '_id'> | null>;
+ getAssistant: (
+ query: FilterQuery<IAssistant>,
+ projection?: ProjectionType<IAssistant>,
+ ) => Promise<AssistantImageRecord | null>;
+ getImageConfig?: (params: { userId: string; user: ImageUser }) => Promise<{
+ secureImageLinks?: boolean;
+ assistantEndpoints?: AssistantConfig[];
+ }>;
+ getUserPrincipals: (params: {
+ userId: string;
+ role?: string | null;
+ idOnTheSource?: string | null;
+ }) => Promise<Principal[]>;
+ hasCapabilityForPrincipals: (params: {
+ principals: Principal[];
+ capability: SystemCapability;
+ tenantId?: string;
+ }) => Promise<boolean>;
+ hasPermission: (
+ principals: Principal[],
+ resourceType: ResourceType,
+ resourceId: string | Types.ObjectId,
+ permissionBit: number,
+ ) => Promise<boolean>;
+}
+
+export interface ImageAuthorizationOptions {
+ secureImageLinks?: boolean;
+ assistantEndpoints?: AssistantConfig[];
+}
+
+type ImageRequest = Request & {
+ session?: Request['session'] & {
+ openidTokens?: { refreshToken?: string };
+ };
+};
+
+function escapeRegExp(value: string): string {
+ return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function parseImagePath(originalUrl: string, basePath: string): ImagePath | null {
+ if (!originalUrl || originalUrl.length > MAX_URL_LENGTH || originalUrl.includes('\0')) {
+ return null;
+ }
+
+ let decodedUrl: string;
+ try {
+ decodedUrl = decodeURIComponent(originalUrl);
+ } catch {
+ return null;
+ }
+
+ if (decodedUrl.includes('\0')) {
+ return null;
+ }
+
+ const cleanPath = decodedUrl.split(/[?#]/, 1)[0];
+ let decodedBasePath: string;
+ try {
+ decodedBasePath = decodeURIComponent(basePath);
+ } catch {
+ return null;
+ }
+ const imagesPath = `${decodedBasePath}/images`;
+ const imagesPrefix = `${imagesPath}/`;
+ const normalizedPath = cleanPath.startsWith(imagesPrefix)
+ ? `${imagesPrefix}${cleanPath.slice(imagesPrefix.length).replace(/^\/+/, '')}`
+ : cleanPath;
+ const match = normalizedPath.match(
+ new RegExp(`^${escapeRegExp(imagesPath)}/([a-f0-9]{24})/([^/]+)$`, 'i'),
+ );
+ if (!match) {
+ return null;
+ }
+
+ const [, ownerId, filename] = match;
+ if (filename === '.' || filename === '..' || filename.includes('\\')) {
+ return null;
+ }
+ return {
+ ownerId,
+ filename,
+ canonicalPath: `/images/${ownerId}/${filename}`,
+ agentId: filename.match(AGENT_AVATAR_PATTERN)?.[1],
+ };
+}
+
+function getSignedUserId(token: string | undefined): string | null {
+ const secret = process.env.JWT_REFRESH_SECRET;
+ if (!token || !secret) {
+ return null;
+ }
+ try {
+ const payload = jwt.verify(token, secret) as JwtPayload;
+ return typeof payload.id === 'string' && OBJECT_ID_PATTERN.test(payload.id) ? payload.id : null;
+ } catch (error) {
+ logger.warn('[imageAuthorization] Invalid signed user token', error);
+ return null;
+ }
+}
+
+function getSignedOpenIdUserId(
+ token: string | undefined,
+ refreshToken: string,
+): OpenIdCookieAuthResult {
+ const secret = process.env.JWT_REFRESH_SECRET;
+ if (!token || !secret) {
+ return { status: 'invalid' };
+ }
+ try {
+ const payload = jwt.verify(token, secret) as JwtPayload;
+ if (typeof payload.id !== 'string' || !OBJECT_ID_PATTERN.test(payload.id)) {
+ return { status: 'invalid' };
+ }
+ if (typeof payload.refreshTokenHash !== 'string') {
+ return { status: 'legacy', userId: payload.id };
+ }
+ const refreshTokenHash = createHash('sha256').update(refreshToken).digest('base64url');
+ return payload.refreshTokenHash === refreshTokenHash
+ ? { status: 'authenticated', userId: payload.id }
+ : { status: 'invalid' };
+ } catch (error) {
+ logger.warn('[imageAuthorization] Invalid signed OpenID user token', error);
+ return { status: 'invalid' };
+ }
+}
+
+function getStoredPathCandidates(canonicalPath: string): string[] {
+ return [canonicalPath, `${canonicalPath}?manual=false`, `${canonicalPath}?manual=true`];
+}
+
+async function authenticateRequest(
+ req: ImageRequest,
+ deps: ImageAuthorizationDeps,
+): Promise<CookieAuthResult> {
+ const cookieHeader = req.headers.cookie;
+ if (!cookieHeader) {
+ return { status: 'missing' };
+ }
+
+ let parsed: Record<string, string | undefined>;
+ try {
+ parsed = deps.parseCookies(cookieHeader);
+ } catch {
+ return { status: 'invalid' };
+ }
+
+ const refreshToken = parsed.refreshToken;
+ if (!refreshToken) {
+ return { status: 'missing' };
+ }
+
+ if (parsed.token_provider === 'openid' && deps.isOpenIdReuseEnabled()) {
+ const openIdAuth = getSignedOpenIdUserId(parsed.openid_user_id, refreshToken);
+ if (openIdAuth.status === 'invalid') {
+ return { status: 'invalid' };
+ }
+ if (openIdAuth.status === 'legacy') {
+ return refreshToken === req.session?.openidTokens?.refreshToken
+ ? { status: 'authenticated', userId: openIdAuth.userId }
+ : { status: 'invalid' };
+ }
+ const session = await runAsSystem(() =>
+ deps.findSession({ userId: openIdAuth.userId, refreshToken }),
+ );
+ return session ? openIdAuth : { status: 'invalid' };
+ }
+
+ const userId = getSignedUserId(refreshToken);
+ if (!userId) {
+ return { status: 'invalid' };
+ }
+ const session = await runAsSystem(() => deps.findSession({ userId, refreshToken }));
+ return session ? { status: 'authenticated', userId } : { status: 'invalid' };
+}
+
+function isSharedAssistant(assistant: AssistantImageRecord, configs: AssistantConfig[]): boolean {
+ let matchingConfigs: AssistantConfig[] = [];
+ if (assistant.endpoint) {
+ matchingConfigs = configs.filter((config) => config.endpoint === assistant.endpoint);
+ } else if (configs.length === 1) {
+ matchingConfigs = configs;
+ }
+
+ return matchingConfigs.some((config) => {
+ if (config.privateAssistants) {
+ return false;
+ }
+ if (config.supportedIds?.length) {
+ return config.supportedIds.includes(assistant.assistant_id);
+ }
+ if (config.excludedIds?.length) {
+ return !config.excludedIds.includes(assistant.assistant_id);
+ }
+ return true;
+ });
+}
+
+async function loadPrincipals(
+ userId: string,
+ user: ImageUser,
+ deps: ImageAuthorizationDeps,
+): Promise<Principal[]> {
+ return deps.getUserPrincipals({
+ userId,
+ role: user.role,
+ idOnTheSource: user.idOnTheSource ?? null,
+ });
+}
+
+async function canViewAgentAvatar(
+ imagePath: ImagePath,
+ viewerId: string | undefined,
+ owner: ImageUser,
+ deps: ImageAuthorizationDeps,
+): Promise<boolean> {
+ const agent = await deps.getAgent(
+ {
+ id: imagePath.agentId,
+ 'avatar.filepath': { $in: getStoredPathCandidates(imagePath.canonicalPath) },
+ },
+ { _id: 1 },
+ );
+ if (!agent) {
+ return false;
+ }
+
+ const publicPrincipal: Principal[] = [{ principalType: PrincipalType.PUBLIC }];
+ if (!viewerId) {
+ return deps.hasPermission(publicPrincipal, ResourceType.AGENT, agent._id, PermissionBits.VIEW);
+ }
+
+ const viewer = await runAsSystem(() => deps.getUserById(viewerId, 'role tenantId idOnTheSource'));
+ if (!viewer || viewer.tenantId !== owner.tenantId) {
+ return deps.hasPermission(publicPrincipal, ResourceType.AGENT, agent._id, PermissionBits.VIEW);
+ }
+
+ const principals = await loadPrincipals(viewerId, viewer, deps);
+ let managesAgents = false;
+ try {
+ managesAgents = await deps.hasCapabilityForPrincipals({
+ principals,
+ capability: ResourceCapabilityMap[ResourceType.AGENT],
+ tenantId: owner.tenantId,
+ });
+ } catch (error) {
+ logger.warn('[imageAuthorization] Agent capability check failed', error);
+ }
+ return (
+ managesAgents ||
+ (await deps.hasPermission(principals, ResourceType.AGENT, agent._id, PermissionBits.VIEW))
+ );
+}
+
+async function canViewAssistantAvatar(
+ imagePath: ImagePath,
+ viewerId: string | undefined,
+ owner: ImageUser,
+ configs: AssistantConfig[],
+ deps: ImageAuthorizationDeps,
+): Promise<boolean> {
+ const assistant = await deps.getAssistant(
+ { 'avatar.filepath': { $in: getStoredPathCandidates(imagePath.canonicalPath) } },
+ { _id: 1, assistant_id: 1, endpoint: 1 },
+ );
+ if (!assistant) {
+ return false;
+ }
+ if (!viewerId) {
+ return false;
+ }
+
+ const viewer = await runAsSystem(() => deps.getUserById(viewerId, 'role tenantId idOnTheSource'));
+ if (!viewer || viewer.tenantId !== owner.tenantId) {
+ return false;
+ }
+ if (isSharedAssistant(assistant, configs)) {
+ return true;
+ }
+ const principals = await loadPrincipals(viewerId, viewer, deps);
+ try {
+ return await deps.hasCapabilityForPrincipals({
+ principals,
+ capability: SystemCapabilities.MANAGE_ASSISTANTS,
+ tenantId: owner.tenantId,
+ });
+ } catch (error) {
+ logger.warn('[imageAuthorization] Assistant capability check failed', error);
+ return false;
+ }
+}
+
+async function resolveImageConfig(
+ ownerId: string,
+ owner: ImageUser,
+ options: ImageAuthorizationOptions,
+ deps: ImageAuthorizationDeps,
+): Promise<ResolvedImageConfig> {
+ if (!deps.getImageConfig) {
+ return {
+ secureImageLinks: options.secureImageLinks !== false,
+ assistantEndpoints: options.assistantEndpoints ?? [],
+ };
+ }
+ try {
+ const config = await deps.getImageConfig({ userId: ownerId, user: owner });
+ return {
+ secureImageLinks: config.secureImageLinks !== false,
+ assistantEndpoints: config.assistantEndpoints ?? [],
+ };
+ } catch (error) {
+ logger.warn('[imageAuthorization] Image config resolution failed', error);
+ return { secureImageLinks: true, assistantEndpoints: [] };
+ }
+}
+
+function isStoredUserAvatar(
+ imagePath: ImagePath,
+ owner: ImageUser,
+ deps: ImageAuthorizationDeps,
+): boolean {
+ if (typeof owner.avatar !== 'string') {
+ return false;
+ }
+ const storedAvatar =
+ parseImagePath(owner.avatar, deps.getBasePath()) ?? parseImagePath(owner.avatar, '');
+ return storedAvatar?.canonicalPath === imagePath.canonicalPath;
+}
+
+async function canViewUserAvatar(
+ viewerId: string | undefined,
+ owner: ImageUser,
+ deps: ImageAuthorizationDeps,
+): Promise<boolean> {
+ if (!viewerId) {
+ return false;
+ }
+ const viewer = await runAsSystem(() => deps.getUserById(viewerId, 'tenantId'));
+ return viewer != null && viewer.tenantId === owner.tenantId;
+}
+
+function denyRequest(res: Response, auth: CookieAuthResult): void {
+ if (auth.status === 'missing') {
+ res.status(401).send('Unauthorized');
+ return;
+ }
+ res.status(403).send('Access Denied');
+}
+
+export function createImageAuthorizationMiddleware(
+ options: ImageAuthorizationOptions,
+ deps: ImageAuthorizationDeps,
+): RequestHandler {
+ if (!deps.getImageConfig && options.secureImageLinks === false) {
+ return (_req: Request, _res: Response, next: NextFunction): void => next();
+ }
+
+ return async function authorizeImageRequest(
+ req: ImageRequest,
+ res: Response,
+ next: NextFunction,
+ ): Promise<void> {
+ try {
+ const imagePath = parseImagePath(req.originalUrl, deps.getBasePath());
+ if (!imagePath) {
+ if (options.secureImageLinks === false) {
+ next();
+ return;
+ }
+ const auth = await authenticateRequest(req, deps);
+ denyRequest(res, auth);
+ return;
+ }
+
+ const owner = await runAsSystem(() =>
+ deps.getUserById(imagePath.ownerId, 'role tenantId idOnTheSource avatar'),
+ );
+ if (!owner) {
+ if (options.secureImageLinks === false) {
+ next();
+ return;
+ }
+ const auth = await authenticateRequest(req, deps);
+ denyRequest(res, auth);
+ return;
+ }
+
+ const authPromise = authenticateRequest(req, deps);
+ void authPromise.catch(() => undefined);
+ const loadImageConfig = (): Promise<ResolvedImageConfig> =>
+ resolveImageConfig(imagePath.ownerId, owner, options, deps);
+ const imageConfig = owner.tenantId
+ ? await tenantStorage.run(
+ { tenantId: owner.tenantId, userId: imagePath.ownerId },
+ loadImageConfig,
+ )
+ : await runAsSystem(loadImageConfig);
+ if (!imageConfig.secureImageLinks) {
+ next();
+ return;
+ }
+
+ res.locals.privateImageCache = true;
+ const auth = await authPromise;
+ const viewerId = auth.status === 'authenticated' ? auth.userId : undefined;
+ if (viewerId === imagePath.ownerId) {
+ next();
+ return;
+ }
+
+ const authorizeSpecialAvatar = async (): Promise<boolean> => {
+ if (imagePath.agentId) {
+ return canViewAgentAvatar(imagePath, viewerId, owner, deps);
+ }
+ if (isStoredUserAvatar(imagePath, owner, deps)) {
+ return canViewUserAvatar(viewerId, owner, deps);
+ }
+ if (imageConfig.assistantEndpoints.length > 0) {
+ const canViewAssistant = await canViewAssistantAvatar(
+ imagePath,
+ viewerId,
+ owner,
+ imageConfig.assistantEndpoints,
+ deps,
+ );
+ if (canViewAssistant) {
+ return true;
+ }
+ }
+ return false;
+ };
+ const allowed = owner.tenantId
+ ? await tenantStorage.run(
+ { tenantId: owner.tenantId, userId: viewerId ?? imagePath.ownerId },
+ authorizeSpecialAvatar,
+ )
+ : await runAsSystem(authorizeSpecialAvatar);
+ if (allowed) {
+ next();
+ return;
+ }
+
+ denyRequest(res, auth);
+ } catch (error) {
+ logger.error('[imageAuthorization] Error authorizing image request', error);
+ res.status(500).send('Internal Server Error');
+ }
+ };
+}
diff --git a/packages/api/src/images/index.ts b/packages/api/src/images/index.ts
new file mode 100644
index 0000000000..a70be20840
--- /dev/null
+++ b/packages/api/src/images/index.ts
@@ -0,0 +1,2 @@
+export * from './authorization';
+export * from './session';
diff --git a/packages/api/src/images/session.spec.ts b/packages/api/src/images/session.spec.ts
new file mode 100644
index 0000000000..fe9877ee3a
--- /dev/null
+++ b/packages/api/src/images/session.spec.ts
@@ -0,0 +1,58 @@
+import { storeOpenIdSession } from './session';
+
+describe('storeOpenIdSession', () => {
+ const originalRefreshTokenExpiry = process.env.REFRESH_TOKEN_EXPIRY;
+ const deps = {
+ upsertSession: jest.fn(),
+ deleteSession: jest.fn(),
+ };
+
+ beforeEach(() => {
+ jest.clearAllMocks();
+ delete process.env.REFRESH_TOKEN_EXPIRY;
+ deps.upsertSession.mockResolvedValue({ _id: 'session-id' });
+ deps.deleteSession.mockResolvedValue({ deletedCount: 1 });
+ });
+
+ afterAll(() => {
+ if (originalRefreshTokenExpiry === undefined) {
+ delete process.env.REFRESH_TOKEN_EXPIRY;
+ return;
+ }
+ process.env.REFRESH_TOKEN_EXPIRY = originalRefreshTokenExpiry;
+ });
+
+ it('stores the active OpenID refresh token with a durable expiration', async () => {
+ const before = Date.now();
+
+ await storeOpenIdSession(
+ { userId: 'user-id', refreshToken: 'new-refresh', tenantId: 'tenant-a' },
+ deps,
+ );
+
+ expect(deps.upsertSession).toHaveBeenCalledWith(
+ 'user-id',
+ 'new-refresh',
+ expect.objectContaining({ tenantId: 'tenant-a', expiration: expect.any(Date) }),
+ );
+ expect(deps.upsertSession.mock.calls[0][2].expiration.getTime()).toBeGreaterThan(before);
+ });
+
+ it('revokes the previous durable session after refresh-token rotation', async () => {
+ await storeOpenIdSession(
+ {
+ userId: 'user-id',
+ refreshToken: 'new-refresh',
+ previousRefreshToken: 'old-refresh',
+ },
+ deps,
+ );
+
+ expect(deps.deleteSession).toHaveBeenCalledWith({ refreshToken: 'old-refresh' });
+ });
+
+ it('does not create a durable session without a refresh token', async () => {
+ await expect(storeOpenIdSession({ userId: 'user-id' }, deps)).resolves.toBe(false);
+ expect(deps.upsertSession).not.toHaveBeenCalled();
+ });
+});
diff --git a/packages/api/src/images/session.ts b/packages/api/src/images/session.ts
new file mode 100644
index 0000000000..35f212fb2c
--- /dev/null
+++ b/packages/api/src/images/session.ts
@@ -0,0 +1,42 @@
+import { DEFAULT_REFRESH_TOKEN_EXPIRY, runAsSystem } from '@librechat/data-schemas';
+import type { ISession, DeleteSessionParams } from '@librechat/data-schemas';
+import { math } from '~/utils/math';
+
+export interface OpenIdSessionParams {
+ userId: string;
+ refreshToken?: string;
+ tenantId?: string;
+ previousRefreshToken?: string;
+}
+
+export interface OpenIdSessionDeps {
+ upsertSession: (
+ userId: string,
+ refreshToken: string,
+ options: { expiration: Date; tenantId?: string },
+ ) => Promise<ISession>;
+ deleteSession: (params: DeleteSessionParams) => Promise<{ deletedCount?: number }>;
+}
+
+export async function storeOpenIdSession(
+ params: OpenIdSessionParams,
+ deps: OpenIdSessionDeps,
+): Promise<boolean> {
+ if (!params.userId || !params.refreshToken) {
+ return false;
+ }
+
+ const refreshToken = params.refreshToken;
+ const expiresIn = math(process.env.REFRESH_TOKEN_EXPIRY, DEFAULT_REFRESH_TOKEN_EXPIRY);
+ await runAsSystem(() =>
+ deps.upsertSession(params.userId, refreshToken, {
+ expiration: new Date(Date.now() + expiresIn),
+ tenantId: params.tenantId,
+ }),
+ );
+ const previousRefreshToken = params.previousRefreshToken;
+ if (previousRefreshToken && previousRefreshToken !== refreshToken) {
+ await runAsSystem(() => deps.deleteSession({ refreshToken: previousRefreshToken }));
+ }
+ return true;
+}
diff --git a/packages/api/src/index.ts b/packages/api/src/index.ts
index febecf5405..dc65c9947b 100644
--- a/packages/api/src/index.ts
+++ b/packages/api/src/index.ts
@@ -78,6 +78,8 @@ export * from './plugins';
export * from './endpoints';
/* Files */
export * from './files';
+/* Images */
+export * from './images';
/* Storage */
export * from './storage';
/* Tools */
diff --git a/packages/data-schemas/src/app/service.ts b/packages/data-schemas/src/app/service.ts
index 76212be66b..e762d1620e 100644
--- a/packages/data-schemas/src/app/service.ts
+++ b/packages/data-schemas/src/app/service.ts
@@ -197,6 +197,7 @@ export const AppService = async (params?: {
mcpConfig: mcpServersConfig,
fileStrategies: config.fileStrategies,
cloudfront: config.cloudfront as AppConfig['cloudfront'],
+ secureImageLinks: config.secureImageLinks !== false,
};
const agentsDefaults = agentsConfigSetup(config);
@@ -235,7 +236,6 @@ export const AppService = async (params?: {
const appConfig: AppConfig = {
...defaultConfig,
fileConfig: config?.fileConfig as AppConfig['fileConfig'],
- secureImageLinks: config?.secureImageLinks,
modelSpecs: processModelSpecs(config?.endpoints, config.modelSpecs, interfaceConfig),
endpoints: loadedEndpoints,
};
diff --git a/packages/data-schemas/src/methods/agent.ts b/packages/data-schemas/src/methods/agent.ts
index c374f7475e..74de873cd4 100644
--- a/packages/data-schemas/src/methods/agent.ts
+++ b/packages/data-schemas/src/methods/agent.ts
@@ -6,7 +6,7 @@ import {
actionDelimiter,
isActionTool,
} from 'librechat-data-provider';
-import type { FilterQuery, Model, PipelineStage, Types } from 'mongoose';
+import type { FilterQuery, Model, PipelineStage, ProjectionType, Types } from 'mongoose';
import type { AgentToolResources } from 'librechat-data-provider';
import type { IAgent, IAclEntry } from '~/types';
import { filterExistingSkillIds } from './skill';
@@ -440,7 +440,10 @@ export function createAgentMethods(
mongoose: typeof import('mongoose'),
deps: AgentDeps,
): {
- getAgent: (searchParameter: FilterQuery<IAgent>) => Promise<IAgent | null>;
+ getAgent: (
+ searchParameter: FilterQuery<IAgent>,
+ projection?: ProjectionType<IAgent>,
+ ) => Promise<IAgent | null>;
getAgentVersions: (searchParameter: FilterQuery<IAgent>) => Promise<IAgent['versions'] | null>;
getAgentWithVersionCount: (
searchParameter: FilterQuery<IAgent>,
@@ -556,9 +559,12 @@ export function createAgentMethods(
/**
* Get an agent document based on the provided search parameter.
*/
- async function getAgent(searchParameter: FilterQuery<IAgent>): Promise<IAgent | null> {
+ async function getAgent(
+ searchParameter: FilterQuery<IAgent>,
+ projection?: ProjectionType<IAgent>,
+ ): Promise<IAgent | null> {
const Agent = mongoose.models.Agent as Model<IAgent>;
- return await Agent.findOne(searchParameter).lean<IAgent>();
+ return await Agent.findOne(searchParameter, projection).lean<IAgent>();
}
/**
diff --git a/packages/data-schemas/src/methods/assistant.ts b/packages/data-schemas/src/methods/assistant.ts
index cc558ebc33..5751293f1c 100644
--- a/packages/data-schemas/src/methods/assistant.ts
+++ b/packages/data-schemas/src/methods/assistant.ts
@@ -1,5 +1,6 @@
-import type { FilterQuery, Model } from 'mongoose';
+import type { FilterQuery, Model, ProjectionType } from 'mongoose';
import type { IAssistant } from '~/types';
+import { createIndexesWithRetry } from '~/utils/retry';
export function createAssistantMethods(mongoose: typeof import('mongoose')): {
updateAssistantDoc: (
@@ -12,8 +13,25 @@ export function createAssistantMethods(mongoose: typeof import('mongoose')): {
searchParams: FilterQuery<IAssistant>,
select?: string | Record<string, number> | null,
) => Promise<IAssistant[]>;
- getAssistant: (searchParams: FilterQuery<IAssistant>) => Promise<IAssistant | null>;
+ getAssistant: (
+ searchParams: FilterQuery<IAssistant>,
+ projection?: ProjectionType<IAssistant>,
+ ) => Promise<IAssistant | null>;
+ ensureAssistantIndexes: () => Promise<void>;
} {
+ const Assistant = () => mongoose.models.Assistant as Model<IAssistant>;
+ let assistantIndexesPromise: Promise<void> | null = null;
+
+ function ensureAssistantIndexes(): Promise<void> {
+ if (!assistantIndexesPromise) {
+ assistantIndexesPromise = createIndexesWithRetry(Assistant()).catch((error) => {
+ assistantIndexesPromise = null;
+ throw error;
+ });
+ }
+ return assistantIndexesPromise;
+ }
+
/**
* Update an assistant with new data without overwriting existing properties,
* or create a new assistant if it doesn't exist.
@@ -22,17 +40,19 @@ export function createAssistantMethods(mongoose: typeof import('mongoose')): {
searchParams: FilterQuery<IAssistant>,
updateData: Partial<IAssistant>,
): Promise<IAssistant | null> {
- const Assistant = mongoose.models.Assistant as Model<IAssistant>;
const options = { new: true, upsert: true };
- return await Assistant.findOneAndUpdate(searchParams, updateData, options).lean<IAssistant>();
+ return await Assistant().findOneAndUpdate(searchParams, updateData, options).lean<IAssistant>();
}
/**
* Retrieves an assistant document based on the provided search params.
*/
- async function getAssistant(searchParams: FilterQuery<IAssistant>): Promise<IAssistant | null> {
- const Assistant = mongoose.models.Assistant as Model<IAssistant>;
- return await Assistant.findOne(searchParams).lean<IAssistant>();
+ async function getAssistant(
+ searchParams: FilterQuery<IAssistant>,
+ projection?: ProjectionType<IAssistant>,
+ ): Promise<IAssistant | null> {
+ await ensureAssistantIndexes();
+ return await Assistant().findOne(searchParams, projection).lean<IAssistant>();
}
/**
@@ -42,8 +62,7 @@ export function createAssistantMethods(mongoose: typeof import('mongoose')): {
searchParams: FilterQuery<IAssistant>,
select: string | Record<string, number> | null = null,
): Promise<IAssistant[]> {
- const Assistant = mongoose.models.Assistant as Model<IAssistant>;
- const query = Assistant.find(searchParams);
+ const query = Assistant().find(searchParams);
return await (select ? query.select(select) : query).lean<IAssistant[]>();
}
@@ -54,16 +73,14 @@ export function createAssistantMethods(mongoose: typeof import('mongoose')): {
async function deleteAssistant(
searchParams: FilterQuery<IAssistant>,
): Promise<IAssistant | null> {
- const Assistant = mongoose.models.Assistant as Model<IAssistant>;
- return await Assistant.findOneAndDelete(searchParams);
+ return await Assistant().findOneAndDelete(searchParams);
}
/**
* Deletes all assistants matching the given search parameters.
*/
async function deleteAssistants(searchParams: FilterQuery<IAssistant>): Promise<number> {
- const Assistant = mongoose.models.Assistant as Model<IAssistant>;
- const result = await Assistant.deleteMany(searchParams);
+ const result = await Assistant().deleteMany(searchParams);
return result.deletedCount;
}
@@ -73,6 +90,7 @@ export function createAssistantMethods(mongoose: typeof import('mongoose')): {
deleteAssistants,
getAssistants,
getAssistant,
+ ensureAssistantIndexes,
};
}
diff --git a/packages/data-schemas/src/methods/session.ts b/packages/data-schemas/src/methods/session.ts
index 391ef9e39f..5b8b42cae0 100644
--- a/packages/data-schemas/src/methods/session.ts
+++ b/packages/data-schemas/src/methods/session.ts
@@ -1,4 +1,5 @@
import type * as t from '~/types/session';
+import { createIndexesWithRetry } from '~/utils/retry';
import { signPayload, hashToken } from '~/crypto';
import logger from '~/config/winston';
@@ -24,6 +25,12 @@ export function createSessionMethods(mongoose: typeof import('mongoose')): {
SessionError: typeof SessionError;
deleteSession: (params: t.DeleteSessionParams) => Promise<{ deletedCount?: number }>;
createSession: (userId: string, options?: t.CreateSessionOptions) => Promise<t.SessionResult>;
+ upsertSession: (
+ userId: string,
+ refreshToken: string,
+ options: t.UpsertSessionOptions,
+ ) => Promise<t.ISession>;
+ ensureSessionIndexes: () => Promise<void>;
updateExpiration: (
session: t.ISession | string,
newExpiration?: Date,
@@ -36,6 +43,18 @@ export function createSessionMethods(mongoose: typeof import('mongoose')): {
options?: t.DeleteAllSessionsOptions,
) => Promise<{ deletedCount?: number }>;
} {
+ let sessionIndexesPromise: Promise<void> | null = null;
+
+ function ensureSessionIndexes(): Promise<void> {
+ if (!sessionIndexesPromise) {
+ sessionIndexesPromise = createIndexesWithRetry(mongoose.models.Session).catch((error) => {
+ sessionIndexesPromise = null;
+ throw error;
+ });
+ }
+ return sessionIndexesPromise;
+ }
+
/**
* Creates a new session for a user
*/
@@ -50,6 +69,7 @@ export function createSessionMethods(mongoose: typeof import('mongoose')): {
const expiresIn = options.expiresIn ?? DEFAULT_REFRESH_TOKEN_EXPIRY;
try {
+ await ensureSessionIndexes();
const Session = mongoose.models.Session;
const currentSession = new Session({
user: userId,
@@ -64,6 +84,43 @@ export function createSessionMethods(mongoose: typeof import('mongoose')): {
}
}
+ /** Stores an externally issued refresh token so logout and administrative revocation apply. */
+ async function upsertSession(
+ userId: string,
+ refreshToken: string,
+ options: t.UpsertSessionOptions,
+ ): Promise<t.ISession> {
+ if (!userId || !refreshToken || !options.expiration) {
+ throw new SessionError('User, refresh token, and expiration are required', 'INVALID_SESSION');
+ }
+
+ try {
+ await ensureSessionIndexes();
+ const Session = mongoose.models.Session;
+ const refreshTokenHash = await hashToken(refreshToken);
+ const update: Record<string, unknown> = {
+ user: userId,
+ refreshTokenHash,
+ expiration: options.expiration,
+ };
+ if (options.tenantId) {
+ update.tenantId = options.tenantId;
+ }
+ const session = await Session.findOneAndUpdate(
+ { user: userId, refreshTokenHash },
+ { $set: update },
+ { upsert: true, new: true, setDefaultsOnInsert: true },
+ ).exec();
+ if (!session) {
+ throw new SessionError('Stored session was not returned', 'SESSION_NOT_FOUND');
+ }
+ return session as t.ISession;
+ } catch (error) {
+ logger.error('[upsertSession] Error storing session:', error);
+ throw new SessionError('Failed to store session', 'UPSERT_SESSION_FAILED');
+ }
+ }
+
/**
* Finds a session by various parameters
*/
@@ -284,6 +341,8 @@ export function createSessionMethods(mongoose: typeof import('mongoose')): {
SessionError,
deleteSession,
createSession,
+ upsertSession,
+ ensureSessionIndexes,
updateExpiration,
countActiveSessions,
generateRefreshToken,
diff --git a/packages/data-schemas/src/methods/session.upsert.spec.ts b/packages/data-schemas/src/methods/session.upsert.spec.ts
new file mode 100644
index 0000000000..e201ce797a
--- /dev/null
+++ b/packages/data-schemas/src/methods/session.upsert.spec.ts
@@ -0,0 +1,43 @@
+import { createHash } from 'node:crypto';
+import { createSessionMethods } from './session';
+
+jest.mock('~/config/winston', () => ({
+ error: jest.fn(),
+ warn: jest.fn(),
+ debug: jest.fn(),
+}));
+
+describe('upsertSession', () => {
+ it('stores an externally issued refresh token as a revocable hash', async () => {
+ const storedSession = { _id: 'session-id' };
+ const createIndexes = jest.fn().mockResolvedValue(undefined);
+ const exec = jest.fn().mockResolvedValue(storedSession);
+ const findOneAndUpdate = jest.fn().mockReturnValue({ exec });
+ const mongoose = {
+ models: { Session: { modelName: 'Session', createIndexes, findOneAndUpdate } },
+ } as unknown as typeof import('mongoose');
+ const methods = createSessionMethods(mongoose);
+ const expiration = new Date(Date.now() + 60_000);
+
+ const result = await methods.upsertSession('user-id', 'external-refresh', {
+ expiration,
+ tenantId: 'tenant-a',
+ });
+
+ const refreshTokenHash = createHash('sha256').update('external-refresh').digest('hex');
+ expect(createIndexes).toHaveBeenCalledTimes(1);
+ expect(findOneAndUpdate).toHaveBeenCalledWith(
+ { user: 'user-id', refreshTokenHash },
+ {
+ $set: {
+ user: 'user-id',
+ refreshTokenHash,
+ expiration,
+ tenantId: 'tenant-a',
+ },
+ },
+ { upsert: true, new: true, setDefaultsOnInsert: true },
+ );
+ expect(result).toBe(storedSession);
+ });
+});
diff --git a/packages/data-schemas/src/schema/assistant.spec.ts b/packages/data-schemas/src/schema/assistant.spec.ts
new file mode 100644
index 0000000000..9d1edc064f
--- /dev/null
+++ b/packages/data-schemas/src/schema/assistant.spec.ts
@@ -0,0 +1,26 @@
+import { createAssistantMethods } from '~/methods/assistant';
+import assistantSchema from './assistant';
+
+describe('assistantSchema', () => {
+ it('indexes tenant-scoped avatar filepath lookups', () => {
+ expect(assistantSchema.indexes()).toContainEqual([
+ { tenantId: 1, 'avatar.filepath': 1 },
+ { background: true },
+ ]);
+ });
+
+ it('creates schema indexes before the first assistant lookup when auto-indexing is disabled', async () => {
+ const createIndexes = jest.fn().mockResolvedValue(undefined);
+ const lean = jest.fn().mockResolvedValue(null);
+ const findOne = jest.fn().mockReturnValue({ lean });
+ const mongoose = {
+ models: { Assistant: { modelName: 'Assistant', createIndexes, findOne } },
+ } as unknown as typeof import('mongoose');
+ const methods = createAssistantMethods(mongoose);
+
+ await methods.getAssistant({ assistant_id: 'assistant-id' });
+ await methods.getAssistant({ assistant_id: 'assistant-id' });
+
+ expect(createIndexes).toHaveBeenCalledTimes(1);
+ });
+});
diff --git a/packages/data-schemas/src/schema/assistant.ts b/packages/data-schemas/src/schema/assistant.ts
index da2c86b762..44a108c052 100644
--- a/packages/data-schemas/src/schema/assistant.ts
+++ b/packages/data-schemas/src/schema/assistant.ts
@@ -13,6 +13,9 @@ const assistantSchema: Schema<IAssistant> = new Schema<IAssistant>(
index: true,
required: true,
},
+ endpoint: {
+ type: String,
+ },
avatar: {
type: Schema.Types.Mixed,
default: undefined,
@@ -40,4 +43,6 @@ const assistantSchema: Schema<IAssistant> = new Schema<IAssistant>(
},
);
+assistantSchema.index({ tenantId: 1, 'avatar.filepath': 1 });
+
export default assistantSchema;
diff --git a/packages/data-schemas/src/schema/session.spec.ts b/packages/data-schemas/src/schema/session.spec.ts
new file mode 100644
index 0000000000..35df959c8f
--- /dev/null
+++ b/packages/data-schemas/src/schema/session.spec.ts
@@ -0,0 +1,10 @@
+import sessionSchema from './session';
+
+describe('sessionSchema', () => {
+ it('prevents duplicate durable refresh-token sessions', () => {
+ expect(sessionSchema.indexes()).toContainEqual([
+ { user: 1, refreshTokenHash: 1 },
+ { unique: true, background: true },
+ ]);
+ });
+});
diff --git a/packages/data-schemas/src/schema/session.ts b/packages/data-schemas/src/schema/session.ts
index 4a66a37535..298180f0ab 100644
--- a/packages/data-schemas/src/schema/session.ts
+++ b/packages/data-schemas/src/schema/session.ts
@@ -22,4 +22,6 @@ const sessionSchema: Schema<ISession> = new Schema({
},
});
+sessionSchema.index({ user: 1, refreshTokenHash: 1 }, { unique: true });
+
export default sessionSchema;
diff --git a/packages/data-schemas/src/types/app.ts b/packages/data-schemas/src/types/app.ts
index 4a5d992585..df2a4b6054 100644
--- a/packages/data-schemas/src/types/app.ts
+++ b/packages/data-schemas/src/types/app.ts
@@ -104,7 +104,7 @@ export interface AppConfig {
mcpSettings?: TCustomConfig['mcpSettings'] | null;
/** File configuration */
fileConfig?: TFileConfig;
- /** Secure image links configuration */
+ /** Secure image links configuration, enabled unless explicitly disabled */
secureImageLinks?: TCustomConfig['secureImageLinks'];
/** Processed model specifications */
modelSpecs?: TCustomConfig['modelSpecs'];
diff --git a/packages/data-schemas/src/types/assistant.ts b/packages/data-schemas/src/types/assistant.ts
index 33381f7399..065e0cd6b8 100644
--- a/packages/data-schemas/src/types/assistant.ts
+++ b/packages/data-schemas/src/types/assistant.ts
@@ -3,6 +3,7 @@ import { Document, Types } from 'mongoose';
export interface IAssistant extends Document {
user: Types.ObjectId;
assistant_id: string;
+ endpoint?: string;
avatar?: {
filepath: string;
source: string;
diff --git a/packages/data-schemas/src/types/session.ts b/packages/data-schemas/src/types/session.ts
index db01a23162..f67ab947df 100644
--- a/packages/data-schemas/src/types/session.ts
+++ b/packages/data-schemas/src/types/session.ts
@@ -13,6 +13,11 @@ export interface CreateSessionOptions {
expiresIn?: number;
}
+export interface UpsertSessionOptions {
+ expiration: Date;
+ tenantId?: string;
+}
+
export interface UpdateExpirationOptions {
/** Duration in milliseconds for session expiry. Default: 7 days */
expiresIn?: number;