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

6.1 KB
Raw Blame
import type { CodeEnvRef } from 'librechat-data-provider';
import type { ServerRequest } from '~/types';
import { createFileProvisionRecovery } from '../operations';
import { createCodeFileDeleter } from './delete';

const req = { user: { id: 'owner' } } as ServerRequest;
const ref: CodeEnvRef = {
  kind: 'user',
  id: 'owner',
  file_id: 'remote-copy',
  storage_session_id: 'session',
  provisionedAt: Date.now(),
};

function setup() {
  const httpClient = jest.fn().mockResolvedValue({ status: 204 });
  const clearFileCodeEnvRefs = jest.fn().mockResolvedValue(true);
  const remove = createCodeFileDeleter({
    httpClient,
    clearFileCodeEnvRefs,
    getAuthHeaders: jest.fn().mockResolvedValue({}),
    getBaseUrl: jest.fn(() => 'https://code.example'),
    routeKey: jest.fn(() => 'default'),
    profileHeaders: jest.fn(() => ({})),
    downloadQuery: jest.fn(() => '?kind=user&id=owner'),
    logger: { warn: jest.fn() },
  });
  return { httpClient, clearFileCodeEnvRefs, remove };
}

it.each([204, 403, 404])('reconciles a confirmed code deletion or absence (%s)', async (status) => {
  const { httpClient, clearFileCodeEnvRefs, remove } = setup();
  if (status !== 204) httpClient.mockRejectedValue({ response: { status } });
  const file = { file_id: 'stored-file', metadata: { codeEnvRefs: { default: ref } } };
  await expect(remove(req, file)).resolves.toEqual({ deleted: true });
  expect(clearFileCodeEnvRefs).toHaveBeenCalledWith({
    file_id: 'stored-file',
    userId: 'owner',
    tenantId: undefined,
    refs: [{ routeKey: 'default', ref }],
  });
  expect(file.metadata.codeEnvRefs.default).toBe(ref);
});

it('persists each confirmed route before a later route fails', async () => {
  const { httpClient, clearFileCodeEnvRefs, remove } = setup();
  httpClient
    .mockResolvedValueOnce({ status: 204 })
    .mockRejectedValueOnce(new Error('code offline'));
  const other: CodeEnvRef = { ...ref, executionProfile: 'stateful', file_id: 'other-copy' };
  await expect(
    remove(req, {
      file_id: 'stored-file',
      metadata: { codeEnvRefs: { default: ref, stateful: other } },
    }),
  ).rejects.toThrow('code offline');
  expect(clearFileCodeEnvRefs).toHaveBeenCalledTimes(1);
  expect(clearFileCodeEnvRefs.mock.invocationCallOrder[0]).toBeLessThan(
    httpClient.mock.invocationCallOrder[1],
  );
});

it.each(['conflict', 'failure'])(
  'does not forgive code reconciliation %s as storage absence',
  async (mode) => {
    const { clearFileCodeEnvRefs, remove } = setup();
    if (mode === 'conflict') clearFileCodeEnvRefs.mockResolvedValue(false);
    else clearFileCodeEnvRefs.mockRejectedValue(new Error('resource not found'));
    await expect(
      remove(req, { file_id: 'stored-file', metadata: { codeEnvRef: ref } }),
    ).rejects.toThrow('Code storage reconciliation failed');
  },
);

it('does not confirm or invalidate an unmapped historical route', async () => {
  const { httpClient, clearFileCodeEnvRefs, remove } = setup();
  const route = 'stateful:0123456789abcdef0123456789abcdef';
  await expect(
    remove(req, {
      file_id: 'stored-file',
      metadata: {
        codeEnvRefs: {
          [route]: { ...ref, executionProfile: 'stateful', executionRouteKey: route },
        },
      },
    }),
  ).resolves.toBeUndefined();
  expect(httpClient).not.toHaveBeenCalled();
  expect(clearFileCodeEnvRefs).not.toHaveBeenCalled();
});

it('invalidates a confirmed code pointer even when a later vector deletion fails', async () => {
  const { createDeleteFileWithSecondaryStorage } = await import('../storage');
  const { FileSources } = await import('librechat-data-provider');
  const { clearFileCodeEnvRefs, remove } = setup();
  const retained = {
    file_id: 'stored-file',
    embedded: true,
    metadata: { codeEnvRef: ref },
  };
  const primary = jest.fn();
  const clearFileEmbeddings = jest.fn();
  const deleteFile = createDeleteFileWithSecondaryStorage({
    source: FileSources.local,
    deleteFile: primary,
    getDeleteFile: (source) =>
      source === FileSources.execute_code
        ? async () => remove(req, retained)
        : async () => {
            throw new Error('vector unavailable');
          },
    clearFileEmbeddings,
    isFileStorageClean: jest.fn().mockResolvedValue(true),
    fileStorage: {
      recovery: createFileProvisionRecovery(),
      acquireFileProvision: jest.fn().mockResolvedValue(true),
      releaseFileProvision: jest.fn().mockResolvedValue(true),
      commitFileProvision: jest.fn().mockResolvedValue(true),
      acquireFileDeletion: jest.fn().mockResolvedValue({ resumed: false }),
      releaseFileDeletion: jest.fn().mockResolvedValue(true),
    },
    logger: { warn: jest.fn() },
  });
  await expect(
    deleteFile(
      {
        user: { id: 'owner' },
        config: { fileConfig: { retainedFileCleanup: true } },
      },
      retained,
    ),
  ).rejects.toThrow('vector unavailable');
  expect(clearFileCodeEnvRefs).toHaveBeenCalledWith(
    expect.objectContaining({
      file_id: 'stored-file',
      refs: [{ routeKey: 'default', ref }],
    }),
  );
  expect(primary).not.toHaveBeenCalled();
  expect(clearFileEmbeddings).not.toHaveBeenCalled();
});

it.each([401, 409, 429, 500, 503])(
  'preserves retryable or unrelated Code API failures (%s)',
  async (status) => {
    const { httpClient, clearFileCodeEnvRefs, remove } = setup();
    const error = { response: { status } };
    httpClient.mockRejectedValue(error);
    await expect(
      remove(req, { file_id: 'stored-file', metadata: { codeEnvRef: ref } }),
    ).rejects.toBe(error);
    expect(clearFileCodeEnvRefs).not.toHaveBeenCalled();
  },
);

it.each([
  { ...ref, kind: 'skill' as const, id: 'skill-id', version: 1 },
  { ...ref, kind: 'agent' as const, id: 'agent-id' },
  { ...ref, id: 'other-owner' },
])('does not forgive a forbidden session outside the file owner identity', async (otherRef) => {
  const { httpClient, clearFileCodeEnvRefs, remove } = setup();
  const error = { response: { status: 403 } };
  httpClient.mockRejectedValue(error);
  await expect(
    remove(req, { file_id: 'stored-file', metadata: { codeEnvRef: otherRef } }),
  ).rejects.toBe(error);
  expect(clearFileCodeEnvRefs).not.toHaveBeenCalled();
});