fix: narrow skill management CRUD and honor blob owners

This commit is contained in:
Dustin Healy 2026-10-11 19:20:20 -07:00
parent 976a15f3dc
commit 5d5c2225f6
19 changed files with 359 additions and 472 deletions

View file

@ -268,7 +268,6 @@ describe('Agents OpenAPI actual HTTP contract', () => {
app.post('/api/agents/v1/skills', skillHandlers.create);
app.put('/api/agents/v1/skills/:id/files/*relativePath', skillHandlers.updateFile);
app.delete('/api/agents/v1/skills/:id/files/*relativePath', skillHandlers.deleteFile);
app.delete('/api/agents/v1/skills/:id', skillHandlers.delete);
app.get('/api/agents/v1/agents/:id', (_req, _res, next) =>
next(new Error('contract fixture escaped error')),
);
@ -358,7 +357,7 @@ describe('Agents OpenAPI actual HTTP contract', () => {
expect(fs.readFileSync(diskPath, 'utf8')).toBe(content);
});
it('documents and validates Skill creation and complete deletion cleanup', async () => {
it('documents and validates Skill creation and file deletion', async () => {
const created = await request(app)
.post('/api/agents/v1/skills')
.set('Authorization', `Bearer ${token}`)
@ -390,13 +389,6 @@ describe('Agents OpenAPI actual HTTP contract', () => {
relativePath: 'references/delete-me.md',
}).lean(),
).toBeNull();
const deleted = await request(app)
.delete(`/api/agents/v1/skills/${created.body.id}`)
.set('Authorization', `Bearer ${token}`);
expect(deleted.status).toBe(200);
expectResponseToMatchSpec(spec, 'deleteSkill', deleted);
expect(await mongoose.models.Skill.findById(created.body.id).lean()).toBeNull();
});
it('validates parser and normalized management errors against their documented JSON forms', async () => {

View file

@ -17,7 +17,6 @@ jest.mock('@librechat/api', () => ({
create: mockWrite,
get: mockList,
update: mockWrite,
delete: mockWrite,
listFiles: mockList,
getFile: mockList,
updateFile: mockWrite,

View file

@ -30,7 +30,6 @@ router.get('/', handlers.list);
router.post('/', handlers.create);
router.get('/:id', handlers.get);
router.patch('/:id', handlers.update);
router.delete('/:id', handlers.delete);
router.get('/:id/files', handlers.listFiles);
router.get('/:id/files/*relativePath', handlers.getFile);
router.put('/:id/files/*relativePath', handlers.updateFile);

View file

@ -58,6 +58,7 @@ jest.mock('~/server/middleware/config/app', () => (req, _res, next) => {
jest.mock('~/server/services/Files/strategies', () => ({
getStrategyFunctions: jest.fn().mockReturnValue({
saveBuffer: jest.fn().mockResolvedValue('/uploads/test/file.txt'),
deleteFile: jest.fn().mockResolvedValue(undefined),
getDownloadStream: jest.fn().mockResolvedValue({
pipe: jest.fn(),
on: jest.fn(),
@ -871,7 +872,7 @@ describe('Skill routes', () => {
expect((await upload('stale', initial.body.file_id)).status).toBe(409);
const stored = await SkillFile.findOne({ skillId: created.body._id });
expect(stored.file_id).toBe(replaced.body.file_id);
await request(app).delete(`${url}/references/revision.md`);
await request(app).delete(`${url}/references/revision.md`).expect(200);
expect((await upload('resurrect', replaced.body.file_id)).status).toBe(409);
expect(await SkillFile.countDocuments({ skillId: created.body._id })).toBe(0);
});

View file

@ -5,6 +5,8 @@ const fetch = require('node-fetch');
const { logger } = require('@librechat/data-schemas');
const {
deleteRagFile,
createOwnedBlobFileDeleter,
extractAzureBlobPath,
assertRemoteFileURL,
getSafeErrorMetadata,
getAzureContainerClient,
@ -120,26 +122,18 @@ async function getAzureURL({ fileName, basePath = defaultBasePath, userId, conta
* @param {ServerRequest} params.req - The Express request object.
* @param {MongoFile} params.file - The file object.
*/
async function deleteFileFromAzure(req, file) {
await deleteRagFile({ userId: req.user.id, file });
try {
const containerClient = await getAzureContainerClient(AZURE_CONTAINER_NAME);
const blobPath = file.filepath.split(`${AZURE_CONTAINER_NAME}/`)[1];
if (!blobPath.includes(req.user.id)) {
throw new Error('User ID not found in blob path');
}
const blockBlobClient = containerClient.getBlockBlobClient(blobPath);
await blockBlobClient.delete();
logger.debug('[deleteFileFromAzure] Blob deleted successfully from Azure Blob Storage');
} catch (error) {
logger.error('[deleteFileFromAzure] Error deleting blob:', error);
if (error.statusCode === 404) {
return;
}
throw error;
}
}
const deleteFileFromAzure = (req, file) =>
createOwnedBlobFileDeleter({
extractPath: (filepath) => extractAzureBlobPath(filepath, AZURE_CONTAINER_NAME),
deleteBlob: async (blobPath) => {
const containerClient = await getAzureContainerClient(AZURE_CONTAINER_NAME);
const blockBlobClient = containerClient.getBlockBlobClient(blobPath);
await blockBlobClient.delete();
logger.debug('[deleteFileFromAzure] Blob deleted successfully from Azure Blob Storage');
},
isMissing: (error) => error?.statusCode === 404,
deleteRagFile,
})(req, file);
/**
* Streams a file from disk directly to Azure Blob Storage without loading

View file

@ -5,6 +5,8 @@ const fetch = require('node-fetch');
const { logger } = require('@librechat/data-schemas');
const {
deleteRagFile,
createOwnedBlobFileDeleter,
extractFirebaseBlobPath,
getFirebaseStorage,
assertRemoteFileURL,
getSafeErrorMetadata,
@ -153,26 +155,6 @@ async function saveBufferToFirebase({ userId, buffer, fileName, basePath = 'imag
* @param {string} urlString - The Firebase Storage URL.
* @returns {string} The decoded file path.
*/
function extractFirebaseFilePath(urlString) {
try {
const url = new URL(urlString);
const pathRegex = /\/o\/(.+?)(\?|$)/;
const match = url.pathname.match(pathRegex);
if (match && match[1]) {
return decodeURIComponent(match[1]);
}
return '';
} catch {
logger.debug(
'[extractFirebaseFilePath] Failed to extract Firebase file path from URL, returning empty string',
);
// If URL parsing fails, return an empty string
return '';
}
}
/**
* Deletes a file from Firebase storage. This function determines the filepath from the
* Firebase storage URL via regex for deletion. Validated by the user's ID.
@ -185,23 +167,13 @@ function extractFirebaseFilePath(urlString) {
* A promise that resolves when the file has been successfully deleted from Firebase storage.
* Throws an error if there is an issue with deletion.
*/
const deleteFirebaseFile = async (req, file) => {
await deleteRagFile({ userId: req.user.id, file });
const fileName = extractFirebaseFilePath(file.filepath);
if (!fileName.includes(req.user.id)) {
throw new Error('Invalid file path');
}
try {
await deleteFile('', fileName);
} catch (error) {
logger.error('Error deleting file from Firebase:', error);
if (error.code === 'storage/object-not-found') {
return;
}
throw error;
}
};
const deleteFirebaseFile = (req, file) =>
createOwnedBlobFileDeleter({
extractPath: extractFirebaseBlobPath,
deleteBlob: (filepath) => deleteFile('', filepath),
isMissing: (error) => error?.code === 'storage/object-not-found',
deleteRagFile,
})(req, file);
/**
* Uploads a file to Firebase Storage.

View file

@ -1,94 +0,0 @@
/** Exactly what `deleteLocalFile` reaches for, so the double does not depend on a built package. */
jest.mock('@librechat/api', () => ({
deleteRagFile: jest.fn().mockResolvedValue(undefined),
stripCacheBust: (filepath) => String(filepath).split('?')[0],
}));
jest.mock('@librechat/data-schemas', () => ({
logger: { warn: jest.fn(), error: jest.fn() },
}));
const fs = require('fs');
const os = require('os');
const path = require('path');
const { deleteRagFile } = require('@librechat/api');
const { deleteLocalFile } = require('../crud');
/* The resolved promise of a delete is what `processDeleteRequest` reads to decide that a record may
lose its metadata and its agent references, so this adapter may only resolve once the bytes are
actually gone. Storage that was already missing is the one benign case. */
describe('deleteLocalFile failure reporting', () => {
const userId = 'user-1';
let tmpBase;
let req;
beforeEach(() => {
jest.restoreAllMocks();
jest.clearAllMocks();
tmpBase = fs.mkdtempSync(path.join(os.tmpdir(), 'crud-delete-'));
fs.mkdirSync(path.join(tmpBase, 'uploads', userId), { recursive: true });
req = {
user: { id: userId },
config: {
paths: {
publicPath: path.join(tmpBase, 'public'),
uploads: path.join(tmpBase, 'uploads'),
},
},
};
});
afterEach(() => {
fs.rmSync(tmpBase, { recursive: true, force: true });
});
const uploadedFile = (filename, ownerId = userId) => {
fs.mkdirSync(path.join(tmpBase, 'uploads', ownerId), { recursive: true });
const filepath = path.join(tmpBase, 'uploads', ownerId, filename);
fs.writeFileSync(filepath, 'contents');
return { file_id: 'file-1', filepath: `/uploads/${ownerId}/${filename}`, user: ownerId };
};
it('removes the file and resolves', async () => {
const file = uploadedFile('knowledge.txt');
await expect(deleteLocalFile(req, file)).resolves.toBeUndefined();
expect(fs.existsSync(path.join(tmpBase, 'uploads', userId, 'knowledge.txt'))).toBe(false);
});
it('resolves when the file is already gone', async () => {
await expect(
deleteLocalFile(req, { file_id: 'file-1', filepath: `/uploads/${userId}/missing.txt` }),
).resolves.toBeUndefined();
});
it('rejects when the bytes survive the delete', async () => {
const file = uploadedFile('locked.txt');
jest
.spyOn(fs.promises, 'unlink')
.mockRejectedValue(Object.assign(new Error('permission denied'), { code: 'EACCES' }));
await expect(deleteLocalFile(req, file)).rejects.toThrow('permission denied');
expect(fs.existsSync(path.join(tmpBase, 'uploads', userId, 'locked.txt'))).toBe(true);
});
it("uses the recorded owner when a manager deletes another user's file", async () => {
const ownerId = 'user-2';
const file = uploadedFile('managed.txt', ownerId);
req.user.id = 'manager-1';
await expect(deleteLocalFile(req, file)).resolves.toBeUndefined();
expect(deleteRagFile).toHaveBeenCalledWith({ userId: ownerId, file });
expect(fs.existsSync(path.join(tmpBase, 'uploads', ownerId, 'managed.txt'))).toBe(false);
});
it('rejects a path outside the recorded owner namespace', async () => {
const file = uploadedFile('protected.txt', 'user-2');
file.user = 'user-3';
await expect(deleteLocalFile(req, file)).rejects.toThrow('Invalid file path');
expect(deleteRagFile).not.toHaveBeenCalled();
expect(fs.existsSync(path.join(tmpBase, 'uploads', 'user-2', 'protected.txt'))).toBe(true);
});
});

View file

@ -3,6 +3,7 @@ const path = require('path');
const axios = require('axios');
const {
deleteRagFile,
createLocalFileDeleter,
moveLocalFile,
stripCacheBust,
writeLocalFile,
@ -13,7 +14,6 @@ const {
saveLocalBuffer: saveBufferToLocalPath,
} = require('@librechat/api');
const { logger } = require('@librechat/data-schemas');
const { EModelEndpoint } = require('librechat-data-provider');
const { resizeImageBuffer } = require('~/server/services/Files/images/resize');
const { getBufferMetadata } = require('~/server/utils');
const paths = require('~/config/paths');
@ -150,102 +150,7 @@ async function getLocalFileURL({ fileName, basePath = 'images' }) {
return path.posix.join('/', basePath, fileName);
}
/**
* Validates that a filepath is strictly contained within a subdirectory under a base path,
* using path.relative to prevent prefix-collision bypasses.
*
* @param {string} base - The base directory path.
* @param {string} subfolder - The subdirectory under the base path.
* @param {string} ownerId - The persisted owner whose storage namespace contains the file.
* @param {string} filepath - The complete file path to be validated.
*
* @returns {boolean}
* Returns true if the filepath is within the specified base and subfolder, false otherwise.
*/
const isValidPath = (base, subfolder, ownerId, filepath) => {
const normalizedBase = path.resolve(base, subfolder, ownerId);
const normalizedFilepath = path.resolve(filepath);
const rel = path.relative(normalizedBase, normalizedFilepath);
return !rel.startsWith('..') && !path.isAbsolute(rel) && !rel.includes(`..${path.sep}`);
};
/**
* @param {string} filepath
*/
/**
* A file whose bytes are still on disk must not be reported as deleted: callers use the resolved
* promise to decide that a record may lose its metadata and its agent references. Storage that was
* already gone is the one benign case, and `processDeleteRequest` treats it as deleted by design.
*/
const unlinkFile = async (filepath) => {
try {
await fs.promises.unlink(filepath);
} catch (error) {
if (error?.code === 'ENOENT') {
logger.warn('Local file was already missing during delete:', error);
return;
}
logger.error('Error deleting file:', error);
throw error;
}
};
/**
* Deletes a file from the filesystem. This function takes a file object, constructs the full path, and
* verifies the path's validity before deleting the file. If the path is invalid, an error is thrown.
*
* @param {ServerRequest} req - The request object from Express.
* @param {MongoFile} file - The file object to be deleted. It should have a `filepath` property that is
* a string representing the path of the file relative to the publicPath.
*
* @returns {Promise<void>}
* A promise that resolves when the file has been successfully deleted, or throws an error if the
* file path is invalid or if there is an error in deletion.
*/
const deleteLocalFile = async (req, file) => {
const appConfig = req.config;
const { publicPath, uploads } = appConfig.paths;
const ownerId = file.user?.toString?.() || req.user.id;
/** Filepath stripped of query parameters (e.g., ?manual=true, ?v=<timestamp>) */
const cleanFilepath = stripCacheBust(file.filepath);
const uploadPrefix = `/uploads/${ownerId}/`;
if (cleanFilepath.startsWith(uploadPrefix)) {
const userUploadDir = path.join(uploads, ownerId);
const basePath = cleanFilepath.slice(uploadPrefix.length);
if (!basePath) {
throw new Error(`Invalid file path: ${cleanFilepath}`);
}
const filepath = path.join(userUploadDir, basePath);
const rel = path.relative(userUploadDir, filepath);
if (rel.startsWith('..') || path.isAbsolute(rel) || rel.includes(`..${path.sep}`)) {
throw new Error(`Invalid file path: ${cleanFilepath}`);
}
await deleteRagFile({ userId: ownerId, file });
await unlinkFile(filepath);
return;
}
const parts = cleanFilepath.split(path.sep);
const subfolder = parts[1];
if (!subfolder && parts[0] === EModelEndpoint.agents) {
logger.warn(`Agent File ${file.file_id} is missing filepath, may have been deleted already`);
return;
}
const filepath = path.join(publicPath, cleanFilepath);
if (!isValidPath(publicPath, subfolder, ownerId, filepath)) {
throw new Error('Invalid file path');
}
await deleteRagFile({ userId: ownerId, file });
await unlinkFile(filepath);
};
const deleteLocalFile = (req, file) => createLocalFileDeleter({ deleteRagFile, logger })(req, file);
/**
* Uploads a file to the specified upload directory.

View file

@ -10,7 +10,6 @@ execution router and does not accept browser sessions or execution API keys as f
| POST | `/api/agents/v1/skills` | Create an inline Skill |
| GET | `/api/agents/v1/skills/:id` | Read Skill metadata, body, and frontmatter |
| PATCH | `/api/agents/v1/skills/:id` | Update an inline Skill |
| DELETE | `/api/agents/v1/skills/:id` | Delete an inline Skill |
| GET | `/api/agents/v1/skills/:id/files` | List file metadata |
| GET | `/api/agents/v1/skills/:id/files/*relativePath` | Read a file as JSON |
| PUT | `/api/agents/v1/skills/:id/files/*relativePath` | Create or replace a text file |
@ -32,8 +31,7 @@ Create an inline Skill with its required identity and instruction fields:
```
Creation also accepts the editable optional fields described below. The authenticated principal is
recorded as the owner; callers cannot set ownership, tenant, source, or permissions. Skill deletion
uses the existing cleanup path for Agent allowlists, Skill files, permissions, and stored blobs.
recorded as the owner; callers cannot set ownership, tenant, source, or permissions.
Updates require the version returned by the latest read:
@ -54,9 +52,9 @@ permissions. Inaccessible and cross-tenant IDs return the same 404 envelope.
Text-file writes accept `{ "content": "replacement text" }`, capped at 1 MiB of UTF-8 data.
Use a relative path such as `references/guide.md`. Absolute paths, traversal, and NUL bytes are
rejected. Delete the same path to remove the file. Update `SKILL.md` through the Skill's `body`
field with `expectedVersion`, not the file endpoint. File writes use replacement semantics without a version precondition; serialize writers
to the same path. After a file write, read the Skill again before a versioned metadata/body update: file writes also
increment the parent version. Storage selection stays server-controlled. File JSON reads omit content for
field with `expectedVersion`, not the file endpoint. File writes use replacement semantics without
a version precondition; serialize writers to the same path. After a file write, read the Skill again
before a versioned metadata/body update: file writes also increment the parent version. Storage selection stays server-controlled. File JSON reads omit content for
binary or oversized files; raw download mode is not supported on this surface. File deletion completes
storage cleanup before returning success and reports a conflict if another writer replaced the path.

View file

@ -1658,134 +1658,6 @@
}
}
}
},
"delete": {
"operationId": "deleteSkill",
"summary": "Delete a skill",
"tags": [
"Skills"
],
"security": [
{
"oidcBearer": []
}
],
"parameters": [
{
"in": "path",
"name": "id",
"description": "The skill id",
"schema": {
"type": "string"
},
"required": true
}
],
"responses": {
"200": {
"description": "The skill was deleted",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/SkillDeleted"
}
}
}
},
"400": {
"description": "Invalid request, or a malformed JSON body",
"content": {
"application/json": {
"schema": {
"anyOf": [
{
"$ref": "#/components/schemas/Error"
},
{
"$ref": "#/components/schemas/JsonParseError"
}
]
}
}
}
},
"401": {
"description": "Authentication failed",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/ErrorMessage"
}
}
}
},
"403": {
"description": "Permission denied, the caller is banned, or the request fails tenant isolation",
"content": {
"application/json": {
"schema": {
"anyOf": [
{
"$ref": "#/components/schemas/Error"
},
{
"$ref": "#/components/schemas/MessageError"
},
{
"$ref": "#/components/schemas/ErrorMessage"
}
]
}
}
}
},
"404": {
"description": "Not found",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Error"
}
}
}
},
"409": {
"description": "The bound account is being deleted",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/AccountDeletionConflict"
}
}
}
},
"500": {
"description": "Internal server error. Errors normalized by the route use JSON; the final application error controller sends a text body with the text/html media type.",
"content": {
"application/json": {
"schema": {
"anyOf": [
{
"$ref": "#/components/schemas/Error"
},
{
"$ref": "#/components/schemas/ErrorMessage"
}
]
}
},
"text/html": {
"schema": {
"type": "string",
"enum": [
"An unknown error occurred.",
"Processing error in ErrorController."
]
}
}
}
}
}
}
},
"/skills/{id}/files": {
@ -4286,26 +4158,6 @@
"additionalProperties": false,
"minProperties": 2
},
"SkillDeleted": {
"type": "object",
"properties": {
"id": {
"type": "string",
"pattern": "^[a-f\\d]{24}$"
},
"deleted": {
"type": "boolean",
"const": true
},
"cleanupComplete": {
"type": "boolean"
}
},
"required": [
"id",
"deleted"
]
},
"SkillFile": {
"type": "object",
"properties": {

View file

@ -10,7 +10,6 @@ import {
skillFileContentSchema,
skillFileUpdateSchema,
skillFrontmatterValueSchema,
skillDeleteResponseSchema,
skillFileDeleteResponseSchema,
} from '../skills/management';
import {
@ -47,7 +46,6 @@ export const skillComponentSchemas: Record<string, ZodTypeAny> = {
SkillList: skillListResponseSchema,
SkillCreateRequest: skillManagementCreateSchema,
SkillUpdateRequest: skillManagementUpdateSchema,
SkillDeleted: skillDeleteResponseSchema,
SkillFile: skillFileSchema,
SkillFileList: skillFileListResponseSchema,
SkillFileContent: skillFileContentSchema,
@ -152,19 +150,6 @@ export const skillContracts: EndpointContract[] = [
},
],
},
{
operationId: 'deleteSkill',
method: 'delete',
path: '/skills/{id}',
tags: [TAG],
summary: 'Delete a skill',
security: SECURITY,
pathParams: [{ name: 'id', description: 'The skill id' }],
responses: [
{ status: 200, description: 'The skill was deleted', schema: skillDeleteResponseSchema },
...errorResponses,
],
},
{
operationId: 'listSkillFiles',
method: 'get',

View file

@ -3,6 +3,11 @@ import type { DeleteSkillResult, ISkillFile } from '@librechat/data-schemas';
import type { Response } from 'express';
import type { SkillsHandlersDeps } from './handlers';
import type { ServerRequest } from '~/types';
import {
createOwnedBlobFileDeleter,
extractAzureBlobPath,
extractFirebaseBlobPath,
} from '~/storage/ownedBlobDelete';
import { createSkillsHandlers } from './handlers';
function mockResponse(): Response {
@ -109,6 +114,65 @@ describe('skill delete handler', () => {
});
});
describe.each([
{
source: 'azure_blob',
filepath: 'https://example.blob.core.windows.net/files/uploads/author-1/file.txt',
extractPath: (url: string) => extractAzureBlobPath(url, 'files'),
},
{
source: 'firebase',
filepath: 'https://firebasestorage.googleapis.com/v0/b/bucket/o/uploads%2Fauthor-1%2Ffile.txt',
extractPath: extractFirebaseBlobPath,
},
])(
'cross-author Skill file deletion through $source storage',
({ source, filepath, extractPath }) => {
it('deletes with the persisted author while the manager remains the requester', async () => {
const skillId = new Types.ObjectId().toString();
const file = {
file_id: 'file-1',
filepath,
source,
author: new Types.ObjectId(),
relativePath: 'references/file.txt',
} as ISkillFile & { _id: Types.ObjectId };
const ownerId = file.author.toString();
const ownedFilepath = filepath.replace('author-1', ownerId);
file.filepath = ownedFilepath;
const deleteBlob = jest.fn().mockResolvedValue(undefined);
const deleteRagFile = jest.fn().mockResolvedValue(undefined);
const storageDelete = createOwnedBlobFileDeleter({
extractPath,
deleteBlob,
deleteRagFile,
isMissing: () => false,
});
const deleteSkillFile = jest.fn().mockResolvedValue({ deleted: true });
const handlers = createSkillsHandlers({
getSkillFileByPath: jest.fn().mockResolvedValue(file),
getStrategyFunctions: jest.fn(() => ({ deleteFile: storageDelete })),
deleteSkillFile,
} as unknown as SkillsHandlersDeps);
const req = {
params: { id: skillId, relativePath: 'references/file.txt' },
user: { id: 'manager-1' },
} as unknown as ServerRequest;
const res = mockResponse();
await handlers.deleteFile(req, res);
expect(deleteBlob).toHaveBeenCalledWith(`uploads/${ownerId}/file.txt`);
expect(deleteRagFile).toHaveBeenCalledWith({
userId: ownerId,
file: expect.objectContaining({ user: ownerId }),
});
expect(deleteSkillFile).toHaveBeenCalledWith(skillId, 'references/file.txt', 'file-1');
expect(res.status).toHaveBeenCalledWith(200);
});
},
);
describe('skill create handler', () => {
it('retries dependent cleanup after owner permission setup fails', async () => {
const skillId = new Types.ObjectId();

View file

@ -21,7 +21,6 @@ let db: AllMethods;
let app: express.Express;
let skillId: string;
let allowEdit: boolean;
let allowDelete: boolean;
let allowView: boolean;
let allowUse: boolean;
let allowCreate: boolean;
@ -56,7 +55,6 @@ afterAll(async () => {
beforeEach(async () => {
await mongoose.connection.dropDatabase();
allowEdit = true;
allowDelete = true;
allowView = true;
allowUse = true;
allowCreate = true;
@ -110,7 +108,6 @@ beforeEach(async () => {
}) as IRole,
checkPermission: async ({ requiredPermission }) => {
if (requiredPermission === PermissionBits.EDIT) return allowEdit;
if (requiredPermission === PermissionBits.DELETE) return allowDelete;
return allowView;
},
saveFile,
@ -135,9 +132,6 @@ beforeEach(async () => {
app.patch('/skills/:id', async (req, res) => {
await management.update(req, res);
});
app.delete('/skills/:id', async (req, res) => {
await management.delete(req, res);
});
app.get('/skills/:id/files', async (req, res) => {
await management.listFiles(req, res);
});
@ -193,19 +187,6 @@ it('requires create capability for management mutations', async () => {
.patch(`/skills/${skillId}`)
.send({ expectedVersion: 1, body: 'Denied' })
.expect(403);
await request(app).delete(`/skills/${skillId}`).expect(403);
});
it('deletes an authorized inline Skill through the existing cleanup path', async () => {
const response = await request(app).delete(`/skills/${skillId}`).expect(200);
expect(response.body).toEqual({ id: skillId, deleted: true, cleanupComplete: true });
expect(await inTenant(() => db.getSkillById(skillId))).toBeNull();
});
it('requires DELETE permission without revealing inaccessible Skills', async () => {
allowDelete = false;
await request(app).delete(`/skills/${skillId}`).expect(404);
expect(await inTenant(() => db.getSkillById(skillId))).not.toBeNull();
});
it('lists and retrieves stable representations without ownership or storage internals', async () => {
@ -273,7 +254,6 @@ it.each([
it('hides inaccessible and cross-tenant Skills, including on file writes', async () => {
allowView = false;
allowEdit = false;
allowDelete = false;
await request(app).get(`/skills/${skillId}`).expect(404);
await request(app)
.patch(`/skills/${skillId}`)
@ -283,7 +263,6 @@ it('hides inaccessible and cross-tenant Skills, including on file writes', async
.put(`/skills/${skillId}/files/reference.md`)
.send({ content: 'x' })
.expect(404);
await request(app).delete(`/skills/${skillId}`).expect(404);
await request(app).delete(`/skills/${skillId}/files/reference.md`).expect(404);
expect(saveFile).not.toHaveBeenCalled();
allowView = true;
@ -332,7 +311,6 @@ it('keeps synchronized Skill content and files read-only', async () => {
.put(`/skills/${skillId}/files/reference.md`)
.send({ content: 'x' })
.expect(403);
await request(app).delete(`/skills/${skillId}`).expect(403);
await request(app).delete(`/skills/${skillId}/files/reference.md`).expect(403);
expect(saveFile).not.toHaveBeenCalled();
});

View file

@ -10,7 +10,6 @@ import type {
SkillFrontmatterValue,
TCreateSkill,
TDeleteSkillFileResponse,
TDeleteSkillResponse,
TSkill,
TUpdateSkillPayload,
} from 'librechat-data-provider';
@ -126,11 +125,6 @@ export const skillFileContentSchema: z.AnyZodObject = skillFileSchema.extend({
export const skillFileUpdateSchema: z.AnyZodObject = z
.object({ content: z.string().max(1024 * 1024) })
.strict();
export const skillDeleteResponseSchema: z.ZodType<TDeleteSkillResponse> = z.object({
id: idSchema,
deleted: z.literal(true),
cleanupComplete: z.boolean().optional(),
});
export const skillFileDeleteResponseSchema: z.ZodType<TDeleteSkillFileResponse> = z.object({
skillId: idSchema,
relativePath: z.string(),
@ -239,15 +233,7 @@ async function admitFileWrite(req: Request, res: Response, limiters: RequestHand
export function createSkillManagementHandlers(
deps: SkillManagementDeps,
): Record<
| 'list'
| 'create'
| 'get'
| 'update'
| 'delete'
| 'listFiles'
| 'getFile'
| 'updateFile'
| 'deleteFile',
'list' | 'create' | 'get' | 'update' | 'listFiles' | 'getFile' | 'updateFile' | 'deleteFile',
(request: Request, res: Response) => Promise<Response>
> {
async function canManageSkills(req: ManagementRequest): Promise<boolean> {
@ -382,12 +368,6 @@ export function createSkillManagementHandlers(
},
{ mutation: true },
),
delete: wrap(
PermissionBits.DELETE,
(req, res) =>
runHandler(req, res, deps.handlers.delete, (body) => skillDeleteResponseSchema.parse(body)),
{ mutation: true },
),
listFiles: wrap(PermissionBits.VIEW, (req, res) =>
runHandler(req, res, deps.handlers.listFiles, (body) => ({
object: 'list',

View file

@ -7,3 +7,4 @@ export * from './metadata';
export * from './url';
export * from './path';
export * from './local';
export * from './ownedBlobDelete';

View file

@ -0,0 +1,69 @@
import fs from 'fs';
import os from 'os';
import path from 'path';
import { createLocalFileDeleter } from './local';
describe('local file deletion', () => {
let root: string;
let req: { user: { id: string }; config: { paths: { publicPath: string; uploads: string } } };
const deleteRagFile = jest.fn().mockResolvedValue(undefined);
const logger = { warn: jest.fn(), error: jest.fn() };
const remove = createLocalFileDeleter({ deleteRagFile, logger });
beforeEach(() => {
jest.clearAllMocks();
root = fs.mkdtempSync(path.join(os.tmpdir(), 'local-delete-'));
req = {
user: { id: 'user-1' },
config: {
paths: { publicPath: path.join(root, 'public'), uploads: path.join(root, 'uploads') },
},
};
});
afterEach(() => fs.rmSync(root, { recursive: true, force: true }));
const uploadedFile = (name: string, owner = 'user-1') => {
const dir = path.join(root, 'uploads', owner);
fs.mkdirSync(dir, { recursive: true });
fs.writeFileSync(path.join(dir, name), 'contents');
return { file_id: 'file-1', filepath: `/uploads/${owner}/${name}`, user: owner };
};
it('removes uploaded bytes and RAG data', async () => {
const file = uploadedFile('knowledge.txt');
await remove(req, file);
expect(fs.existsSync(path.join(root, 'uploads', 'user-1', 'knowledge.txt'))).toBe(false);
expect(deleteRagFile).toHaveBeenCalledWith({ userId: 'user-1', file });
});
it('accepts missing storage but rejects other unlink failures', async () => {
const file = { file_id: 'file-1', filepath: '/uploads/user-1/missing.txt', user: 'user-1' };
await expect(remove(req, file)).resolves.toBeUndefined();
const directory = path.join(root, 'uploads', 'user-1', 'not-a-file');
fs.mkdirSync(directory, { recursive: true });
const existing = { file_id: 'file-2', filepath: '/uploads/user-1/not-a-file', user: 'user-1' };
await expect(remove(req, existing)).rejects.toThrow();
expect(fs.existsSync(directory)).toBe(true);
});
it('uses the recorded owner for managers and rejects another owner namespace', async () => {
const file = uploadedFile('managed.txt', 'user-2');
req.user.id = 'manager-1';
await remove(req, file);
expect(deleteRagFile).toHaveBeenCalledWith({ userId: 'user-2', file });
const other = uploadedFile('protected.txt', 'user-2');
other.user = 'user-3';
deleteRagFile.mockClear();
await expect(remove(req, other)).rejects.toThrow('Invalid file path');
expect(deleteRagFile).not.toHaveBeenCalled();
});
it('cleans up RAG data for a legacy agent record without a disk path', async () => {
const file = { file_id: 'file-1', filepath: 'agents', user: 'user-2' };
await remove(req, file);
expect(deleteRagFile).toHaveBeenCalledWith({ userId: 'user-2', file });
});
});

View file

@ -1,12 +1,83 @@
import path from 'path';
import crypto from 'node:crypto';
import { EModelEndpoint } from 'librechat-data-provider';
import { mkdir, copyFile, rename, unlink, writeFile } from 'fs/promises';
import { stripCacheBust } from './path';
export interface LocalStoragePaths {
publicPath: string;
uploads: string;
}
interface LocalFile {
file_id: string;
filepath: string;
user?: { toString(): string };
}
interface LocalDeleteRequest {
user: { id: string };
config: { paths: LocalStoragePaths };
}
interface LocalFileDeleteDependencies {
deleteRagFile: (args: { userId: string; file: LocalFile }) => Promise<unknown>;
logger: { warn: (...args: unknown[]) => void; error: (...args: unknown[]) => void };
}
/** Deletes only within the persisted owner's namespace, and reports storage failures to callers. */
export function createLocalFileDeleter({ deleteRagFile, logger }: LocalFileDeleteDependencies) {
const unlinkStoredFile = async (filepath: string) => {
try {
await unlink(filepath);
} catch (error) {
if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
logger.warn('Local file was already missing during delete:', error);
return;
}
logger.error('Error deleting file:', error);
throw error;
}
};
return async (req: LocalDeleteRequest, file: LocalFile): Promise<void> => {
const { publicPath, uploads } = req.config.paths;
const ownerId = file.user?.toString() || req.user.id;
const cleanFilepath = stripCacheBust(file.filepath);
const uploadPrefix = `/uploads/${ownerId}/`;
if (cleanFilepath.startsWith(uploadPrefix)) {
const userUploadDir = path.join(uploads, ownerId);
const filePath = path.join(userUploadDir, cleanFilepath.slice(uploadPrefix.length));
if (!isStrictlyWithin(userUploadDir, filePath)) {
throw new Error(`Invalid file path: ${cleanFilepath}`);
}
await deleteRagFile({ userId: ownerId, file });
await unlinkStoredFile(filePath);
return;
}
const parts = cleanFilepath.split(path.sep);
const subfolder = parts[1];
if (!subfolder && parts[0] === EModelEndpoint.agents) {
await deleteRagFile({ userId: ownerId, file });
logger.warn(`Agent File ${file.file_id} is missing filepath, may have been deleted already`);
return;
}
const filePath = path.join(publicPath, cleanFilepath);
if (!subfolder || !isStrictlyWithin(path.join(publicPath, subfolder, ownerId), filePath)) {
throw new Error('Invalid file path');
}
await deleteRagFile({ userId: ownerId, file });
await unlinkStoredFile(filePath);
};
}
function isStrictlyWithin(directory: string, filePath: string): boolean {
const rel = path.relative(path.resolve(directory), path.resolve(filePath));
return !!rel && !rel.startsWith('..') && !path.isAbsolute(rel) && !rel.includes(`..${path.sep}`);
}
/**
* Fills a sibling temp file and renames it into place, so concurrent writers to one path each
* land whole (last rename wins) and readers never see a partly written file. The temp name is

View file

@ -0,0 +1,60 @@
import {
createOwnedBlobFileDeleter,
extractAzureBlobPath,
extractFirebaseBlobPath,
} from './ownedBlobDelete';
describe.each([
{
source: 'Azure',
filepath: 'https://example.blob.core.windows.net/files/uploads/author-1/file.txt',
extractPath: (url: string) => extractAzureBlobPath(url, 'files'),
},
{
source: 'Firebase',
filepath: 'https://firebasestorage.googleapis.com/v0/b/bucket/o/uploads%2Fauthor-1%2Ffile.txt',
extractPath: extractFirebaseBlobPath,
},
])('$source owner-aware deletion', ({ filepath, extractPath }) => {
const deleteBlob = jest.fn().mockResolvedValue(undefined);
const deleteRagFile = jest.fn().mockResolvedValue(undefined);
const remove = createOwnedBlobFileDeleter({
extractPath,
deleteBlob,
deleteRagFile,
isMissing: (error) => (error as { code?: string }).code === 'missing',
});
const req = { user: { id: 'manager-1' } };
beforeEach(() => {
deleteBlob.mockReset().mockResolvedValue(undefined);
deleteRagFile.mockClear();
});
it("deletes another author's file under the persisted owner", async () => {
const file = { filepath, user: 'author-1' };
await remove(req, file);
expect(deleteBlob).toHaveBeenCalledWith('uploads/author-1/file.txt');
expect(deleteRagFile).toHaveBeenCalledWith({ userId: 'author-1', file });
});
it('rejects an owner mismatch before deleting either blob or RAG data', async () => {
await expect(remove(req, { filepath, user: 'author-2' })).rejects.toThrow('Invalid file path');
expect(deleteBlob).not.toHaveBeenCalled();
expect(deleteRagFile).not.toHaveBeenCalled();
});
it('does not clean up RAG data when remote deletion fails', async () => {
deleteBlob.mockRejectedValueOnce(new Error('storage unavailable'));
await expect(remove(req, { filepath, user: 'author-1' })).rejects.toThrow(
'storage unavailable',
);
expect(deleteRagFile).not.toHaveBeenCalled();
});
it('treats an already missing blob as deleted and still cleans up RAG data', async () => {
deleteBlob.mockRejectedValueOnce(Object.assign(new Error('gone'), { code: 'missing' }));
await remove(req, { filepath, user: 'author-1' });
expect(deleteRagFile).toHaveBeenCalledWith({ userId: 'author-1', file: expect.any(Object) });
});
});

View file

@ -0,0 +1,61 @@
interface StoredBlobFile {
filepath: string;
user?: { toString(): string };
}
interface OwnedBlobDeleteDependencies {
extractPath: (url: string) => string;
deleteBlob: (path: string) => Promise<unknown>;
isMissing: (error: unknown) => boolean;
deleteRagFile: (args: { userId: string; file: StoredBlobFile }) => Promise<unknown>;
}
/** Storage cleanup uses the persisted owner, not the authorized caller's identity. */
export function createOwnedBlobFileDeleter({
extractPath,
deleteBlob,
isMissing,
deleteRagFile,
}: OwnedBlobDeleteDependencies) {
return async (req: { user: { id: string } }, file: StoredBlobFile): Promise<void> => {
const ownerId = file.user?.toString() || req.user.id;
const blobPath = extractPath(file.filepath);
const segments = blobPath.split('/');
// saveBuffer stores at <basePath>/<ownerId>/<filename>; the exact owner segment
// must be adjacent to the file name, not merely a substring elsewhere in the URL.
if (
!ownerId ||
segments.length < 3 ||
segments[segments.length - 2] !== ownerId ||
!segments[segments.length - 1]
) {
throw new Error('Invalid file path');
}
try {
await deleteBlob(blobPath);
} catch (error) {
if (!isMissing(error)) throw error;
}
await deleteRagFile({ userId: ownerId, file });
};
}
export function extractAzureBlobPath(filepath: string, containerName: string): string {
const segments = new URL(filepath).pathname.split('/').filter(Boolean);
const containerIndex = segments.indexOf(containerName);
if (containerIndex < 0 || containerIndex === segments.length - 1) {
throw new Error('Invalid Azure blob path');
}
return segments
.slice(containerIndex + 1)
.map(decodeURIComponent)
.join('/');
}
export function extractFirebaseBlobPath(filepath: string): string {
const pathname = new URL(filepath).pathname;
const objectIndex = pathname.indexOf('/o/');
if (objectIndex < 0) throw new Error('Invalid Firebase blob path');
return decodeURIComponent(pathname.slice(objectIndex + 3));
}