/**
 * @license
 * Copyright 2025 Google LLC
 * SPDX-License-Identifier: Apache-2.0
 */
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import * as fs from 'node:fs/promises';
import * as path from 'node:path';
import { SESSION_FILE_PREFIX, debugLogger, } from '@google/gemini-cli-core';
import { cleanupExpiredSessions } from './sessionCleanup.js';
import { getAllSessionFiles } from './sessionUtils.js';
// Mock the fs module
vi.mock('fs/promises');
vi.mock('./sessionUtils.js', () => ({
    getAllSessionFiles: vi.fn(),
}));
const mockFs = vi.mocked(fs);
const mockGetAllSessionFiles = vi.mocked(getAllSessionFiles);
// Create mock config
function createMockConfig(overrides = {}) {
    return {
        storage: {
            getProjectTempDir: vi.fn().mockReturnValue('/tmp/test-project'),
        },
        getSessionId: vi.fn().mockReturnValue('current123'),
        getDebugMode: vi.fn().mockReturnValue(false),
        initialize: vi.fn().mockResolvedValue(undefined),
        ...overrides,
    };
}
// Create test session data
function createTestSessions() {
    const now = new Date();
    const oneWeekAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
    const twoWeeksAgo = new Date(now.getTime() - 14 * 24 * 60 * 60 * 1000);
    const oneMonthAgo = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
    return [
        {
            id: 'current123',
            file: `${SESSION_FILE_PREFIX}2025-01-20T10-30-00-current12`,
            fileName: `${SESSION_FILE_PREFIX}2025-01-20T10-30-00-current12.json`,
            startTime: now.toISOString(),
            lastUpdated: now.toISOString(),
            messageCount: 5,
            displayName: 'Current session',
            firstUserMessage: 'Current session',
            isCurrentSession: true,
            index: 1,
        },
        {
            id: 'recent456',
            file: `${SESSION_FILE_PREFIX}2025-01-18T15-45-00-recent45`,
            fileName: `${SESSION_FILE_PREFIX}2025-01-18T15-45-00-recent45.json`,
            startTime: oneWeekAgo.toISOString(),
            lastUpdated: oneWeekAgo.toISOString(),
            messageCount: 10,
            displayName: 'Recent session',
            firstUserMessage: 'Recent session',
            isCurrentSession: false,
            index: 2,
        },
        {
            id: 'old789abc',
            file: `${SESSION_FILE_PREFIX}2025-01-10T09-15-00-old789ab`,
            fileName: `${SESSION_FILE_PREFIX}2025-01-10T09-15-00-old789ab.json`,
            startTime: twoWeeksAgo.toISOString(),
            lastUpdated: twoWeeksAgo.toISOString(),
            messageCount: 3,
            displayName: 'Old session',
            firstUserMessage: 'Old session',
            isCurrentSession: false,
            index: 3,
        },
        {
            id: 'ancient12',
            file: `${SESSION_FILE_PREFIX}2024-12-25T12-00-00-ancient1`,
            fileName: `${SESSION_FILE_PREFIX}2024-12-25T12-00-00-ancient1.json`,
            startTime: oneMonthAgo.toISOString(),
            lastUpdated: oneMonthAgo.toISOString(),
            messageCount: 15,
            displayName: 'Ancient session',
            firstUserMessage: 'Ancient session',
            isCurrentSession: false,
            index: 4,
        },
    ];
}
describe('Session Cleanup', () => {
    beforeEach(() => {
        vi.clearAllMocks();
        vi.spyOn(debugLogger, 'error').mockImplementation(() => { });
        vi.spyOn(debugLogger, 'warn').mockImplementation(() => { });
        // By default, return all test sessions as valid
        const sessions = createTestSessions();
        mockGetAllSessionFiles.mockResolvedValue(sessions.map((session) => ({
            fileName: session.fileName,
            sessionInfo: session,
        })));
    });
    afterEach(() => {
        vi.restoreAllMocks();
    });
    describe('cleanupExpiredSessions', () => {
        it('should return early when cleanup is disabled', async () => {
            const config = createMockConfig();
            const settings = {
                general: { sessionRetention: { enabled: false } },
            };
            const result = await cleanupExpiredSessions(config, settings);
            expect(result.disabled).toBe(true);
            expect(result.scanned).toBe(0);
            expect(result.deleted).toBe(0);
            expect(result.skipped).toBe(0);
            expect(result.failed).toBe(0);
        });
        it('should return early when sessionRetention is not configured', async () => {
            const config = createMockConfig();
            const settings = {};
            const result = await cleanupExpiredSessions(config, settings);
            expect(result.disabled).toBe(true);
            expect(result.scanned).toBe(0);
            expect(result.deleted).toBe(0);
        });
        it('should handle invalid maxAge configuration', async () => {
            const config = createMockConfig({
                getDebugMode: vi.fn().mockReturnValue(true),
            });
            const settings = {
                general: {
                    sessionRetention: {
                        enabled: true,
                        maxAge: 'invalid-format',
                    },
                },
            };
            const result = await cleanupExpiredSessions(config, settings);
            expect(result.disabled).toBe(true);
            expect(result.scanned).toBe(0);
            expect(result.deleted).toBe(0);
            expect(debugLogger.warn).toHaveBeenCalledWith(expect.stringContaining('Session cleanup disabled: Error: Invalid retention period format'));
        });
        it('should delete sessions older than maxAge', async () => {
            const config = createMockConfig();
            const settings = {
                general: {
                    sessionRetention: {
                        enabled: true,
                        maxAge: '10d', // 10 days
                    },
                },
            };
            // Mock successful file operations
            mockFs.access.mockResolvedValue(undefined);
            mockFs.readFile.mockResolvedValue(JSON.stringify({
                sessionId: 'test',
                messages: [],
                startTime: '2025-01-01T00:00:00Z',
                lastUpdated: '2025-01-01T00:00:00Z',
            }));
            mockFs.unlink.mockResolvedValue(undefined);
            const result = await cleanupExpiredSessions(config, settings);
            expect(result.disabled).toBe(false);
            expect(result.scanned).toBe(4);
            expect(result.deleted).toBe(2); // Should delete the 2-week-old and 1-month-old sessions
            expect(result.skipped).toBe(2); // Current session + recent session should be skipped
            expect(result.failed).toBe(0);
        });
        it('should never delete current session', async () => {
            const config = createMockConfig();
            const settings = {
                general: {
                    sessionRetention: {
                        enabled: true,
                        maxAge: '1d', // Very short retention
                    },
                },
            };
            // Mock successful file operations
            mockFs.access.mockResolvedValue(undefined);
            mockFs.readFile.mockResolvedValue(JSON.stringify({
                sessionId: 'test',
                messages: [],
                startTime: '2025-01-01T00:00:00Z',
                lastUpdated: '2025-01-01T00:00:00Z',
            }));
            mockFs.unlink.mockResolvedValue(undefined);
            const result = await cleanupExpiredSessions(config, settings);
            // Should delete all sessions except the current one
            expect(result.disabled).toBe(false);
            expect(result.deleted).toBe(3);
            // Verify that unlink was never called with the current session file
            const unlinkCalls = mockFs.unlink.mock.calls;
            const currentSessionPath = path.join('/tmp/test-project', 'chats', `${SESSION_FILE_PREFIX}2025-01-20T10-30-00-current12.json`);
            expect(unlinkCalls.find((call) => call[0] === currentSessionPath)).toBeUndefined();
        });
        it('should handle count-based retention', async () => {
            const config = createMockConfig();
            const settings = {
                general: {
                    sessionRetention: {
                        enabled: true,
                        maxCount: 2, // Keep only 2 most recent sessions
                    },
                },
            };
            // Mock successful file operations
            mockFs.access.mockResolvedValue(undefined);
            mockFs.readFile.mockResolvedValue(JSON.stringify({
                sessionId: 'test',
                messages: [],
                startTime: '2025-01-01T00:00:00Z',
                lastUpdated: '2025-01-01T00:00:00Z',
            }));
            mockFs.unlink.mockResolvedValue(undefined);
            const result = await cleanupExpiredSessions(config, settings);
            expect(result.disabled).toBe(false);
            expect(result.scanned).toBe(4);
            expect(result.deleted).toBe(2); // Should delete 2 oldest sessions (after skipping the current one)
            expect(result.skipped).toBe(2); // Current session + 1 recent session should be kept
        });
        it('should handle file system errors gracefully', async () => {
            const config = createMockConfig();
            const settings = {
                general: {
                    sessionRetention: {
                        enabled: true,
                        maxAge: '1d',
                    },
                },
            };
            // Mock file operations to succeed for access and readFile but fail for unlink
            mockFs.access.mockResolvedValue(undefined);
            mockFs.readFile.mockResolvedValue(JSON.stringify({
                sessionId: 'test',
                messages: [],
                startTime: '2025-01-01T00:00:00Z',
                lastUpdated: '2025-01-01T00:00:00Z',
            }));
            mockFs.unlink.mockRejectedValue(new Error('Permission denied'));
            const result = await cleanupExpiredSessions(config, settings);
            expect(result.disabled).toBe(false);
            expect(result.scanned).toBe(4);
            expect(result.deleted).toBe(0);
            expect(result.failed).toBeGreaterThan(0);
        });
        it('should handle empty sessions directory', async () => {
            const config = createMockConfig();
            const settings = {
                general: {
                    sessionRetention: {
                        enabled: true,
                        maxAge: '30d',
                    },
                },
            };
            mockGetAllSessionFiles.mockResolvedValue([]);
            const result = await cleanupExpiredSessions(config, settings);
            expect(result.disabled).toBe(false);
            expect(result.scanned).toBe(0);
            expect(result.deleted).toBe(0);
            expect(result.skipped).toBe(0);
            expect(result.failed).toBe(0);
        });
        it('should handle global errors gracefully', async () => {
            const config = createMockConfig();
            const settings = {
                general: {
                    sessionRetention: {
                        enabled: true,
                        maxAge: '30d',
                    },
                },
            };
            // Mock getSessionFiles to throw an error
            mockGetAllSessionFiles.mockRejectedValue(new Error('Directory access failed'));
            const result = await cleanupExpiredSessions(config, settings);
            expect(result.disabled).toBe(false);
            expect(result.failed).toBe(1);
            expect(debugLogger.warn).toHaveBeenCalledWith('Session cleanup failed: Directory access failed');
        });
        it('should respect minRetention configuration', async () => {
            const config = createMockConfig();
            const settings = {
                general: {
                    sessionRetention: {
                        enabled: true,
                        maxAge: '12h', // Less than 1 day minimum
                        minRetention: '1d',
                    },
                },
            };
            const result = await cleanupExpiredSessions(config, settings);
            // Should disable cleanup due to minRetention violation
            expect(result.disabled).toBe(true);
            expect(result.scanned).toBe(0);
            expect(result.deleted).toBe(0);
        });
        it('should log debug information when enabled', async () => {
            const config = createMockConfig({
                getDebugMode: vi.fn().mockReturnValue(true),
            });
            const settings = {
                general: {
                    sessionRetention: {
                        enabled: true,
                        maxAge: '10d',
                    },
                },
            };
            // Mock successful file operations
            mockFs.access.mockResolvedValue(undefined);
            mockFs.readFile.mockResolvedValue(JSON.stringify({
                sessionId: 'test',
                messages: [],
                startTime: '2025-01-01T00:00:00Z',
                lastUpdated: '2025-01-01T00:00:00Z',
            }));
            mockFs.unlink.mockResolvedValue(undefined);
            const debugSpy = vi
                .spyOn(debugLogger, 'debug')
                .mockImplementation(() => { });
            await cleanupExpiredSessions(config, settings);
            expect(debugSpy).toHaveBeenCalledWith(expect.stringContaining('Session cleanup: deleted'));
            expect(debugSpy).toHaveBeenCalledWith(expect.stringContaining('Deleted expired session:'));
            debugSpy.mockRestore();
        });
    });
    describe('Specific cleanup scenarios', () => {
        it('should delete sessions that exceed the cutoff date', async () => {
            const config = createMockConfig();
            const settings = {
                general: {
                    sessionRetention: {
                        enabled: true,
                        maxAge: '7d', // Keep sessions for 7 days
                    },
                },
            };
            // Create sessions with specific dates
            const now = new Date();
            const fiveDaysAgo = new Date(now.getTime() - 5 * 24 * 60 * 60 * 1000);
            const eightDaysAgo = new Date(now.getTime() - 8 * 24 * 60 * 60 * 1000);
            const fifteenDaysAgo = new Date(now.getTime() - 15 * 24 * 60 * 60 * 1000);
            const testSessions = [
                {
                    id: 'current',
                    file: `${SESSION_FILE_PREFIX}current`,
                    fileName: `${SESSION_FILE_PREFIX}current.json`,
                    startTime: now.toISOString(),
                    lastUpdated: now.toISOString(),
                    messageCount: 1,
                    displayName: 'Current',
                    firstUserMessage: 'Current',
                    isCurrentSession: true,
                    index: 1,
                },
                {
                    id: 'session5d',
                    file: `${SESSION_FILE_PREFIX}5d`,
                    fileName: `${SESSION_FILE_PREFIX}5d.json`,
                    startTime: fiveDaysAgo.toISOString(),
                    lastUpdated: fiveDaysAgo.toISOString(),
                    messageCount: 1,
                    displayName: '5 days old',
                    firstUserMessage: '5 days',
                    isCurrentSession: false,
                    index: 2,
                },
                {
                    id: 'session8d',
                    file: `${SESSION_FILE_PREFIX}8d`,
                    fileName: `${SESSION_FILE_PREFIX}8d.json`,
                    startTime: eightDaysAgo.toISOString(),
                    lastUpdated: eightDaysAgo.toISOString(),
                    messageCount: 1,
                    displayName: '8 days old',
                    firstUserMessage: '8 days',
                    isCurrentSession: false,
                    index: 3,
                },
                {
                    id: 'session15d',
                    file: `${SESSION_FILE_PREFIX}15d`,
                    fileName: `${SESSION_FILE_PREFIX}15d.json`,
                    startTime: fifteenDaysAgo.toISOString(),
                    lastUpdated: fifteenDaysAgo.toISOString(),
                    messageCount: 1,
                    displayName: '15 days old',
                    firstUserMessage: '15 days',
                    isCurrentSession: false,
                    index: 4,
                },
            ];
            mockGetAllSessionFiles.mockResolvedValue(testSessions.map((session) => ({
                fileName: session.fileName,
                sessionInfo: session,
            })));
            // Mock successful file operations
            mockFs.access.mockResolvedValue(undefined);
            mockFs.readFile.mockResolvedValue(JSON.stringify({
                sessionId: 'test',
                messages: [],
                startTime: '2025-01-01T00:00:00Z',
                lastUpdated: '2025-01-01T00:00:00Z',
            }));
            mockFs.unlink.mockResolvedValue(undefined);
            const result = await cleanupExpiredSessions(config, settings);
            // Should delete sessions older than 7 days (8d and 15d sessions)
            expect(result.disabled).toBe(false);
            expect(result.scanned).toBe(4);
            expect(result.deleted).toBe(2);
            expect(result.skipped).toBe(2); // Current + 5d session
            // Verify which files were deleted
            const unlinkCalls = mockFs.unlink.mock.calls.map((call) => call[0]);
            expect(unlinkCalls).toContain(path.join('/tmp/test-project', 'chats', `${SESSION_FILE_PREFIX}8d.json`));
            expect(unlinkCalls).toContain(path.join('/tmp/test-project', 'chats', `${SESSION_FILE_PREFIX}15d.json`));
            expect(unlinkCalls).not.toContain(path.join('/tmp/test-project', 'chats', `${SESSION_FILE_PREFIX}5d.json`));
        });
        it('should NOT delete sessions within the cutoff date', async () => {
            const config = createMockConfig();
            const settings = {
                general: {
                    sessionRetention: {
                        enabled: true,
                        maxAge: '14d', // Keep sessions for 14 days
                    },
                },
            };
            // Create sessions all within the retention period
            const now = new Date();
            const oneDayAgo = new Date(now.getTime() - 1 * 24 * 60 * 60 * 1000);
            const sevenDaysAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
            const thirteenDaysAgo = new Date(now.getTime() - 13 * 24 * 60 * 60 * 1000);
            const testSessions = [
                {
                    id: 'current',
                    file: `${SESSION_FILE_PREFIX}current`,
                    fileName: `${SESSION_FILE_PREFIX}current.json`,
                    startTime: now.toISOString(),
                    lastUpdated: now.toISOString(),
                    messageCount: 1,
                    displayName: 'Current',
                    firstUserMessage: 'Current',
                    isCurrentSession: true,
                    index: 1,
                },
                {
                    id: 'session1d',
                    file: `${SESSION_FILE_PREFIX}1d`,
                    fileName: `${SESSION_FILE_PREFIX}1d.json`,
                    startTime: oneDayAgo.toISOString(),
                    lastUpdated: oneDayAgo.toISOString(),
                    messageCount: 1,
                    displayName: '1 day old',
                    firstUserMessage: '1 day',
                    isCurrentSession: false,
                    index: 2,
                },
                {
                    id: 'session7d',
                    file: `${SESSION_FILE_PREFIX}7d`,
                    fileName: `${SESSION_FILE_PREFIX}7d.json`,
                    startTime: sevenDaysAgo.toISOString(),
                    lastUpdated: sevenDaysAgo.toISOString(),
                    messageCount: 1,
                    displayName: '7 days old',
                    firstUserMessage: '7 days',
                    isCurrentSession: false,
                    index: 3,
                },
                {
                    id: 'session13d',
                    file: `${SESSION_FILE_PREFIX}13d`,
                    fileName: `${SESSION_FILE_PREFIX}13d.json`,
                    startTime: thirteenDaysAgo.toISOString(),
                    lastUpdated: thirteenDaysAgo.toISOString(),
                    messageCount: 1,
                    displayName: '13 days old',
                    firstUserMessage: '13 days',
                    isCurrentSession: false,
                    index: 4,
                },
            ];
            mockGetAllSessionFiles.mockResolvedValue(testSessions.map((session) => ({
                fileName: session.fileName,
                sessionInfo: session,
            })));
            // Mock successful file operations
            mockFs.access.mockResolvedValue(undefined);
            mockFs.readFile.mockResolvedValue(JSON.stringify({
                sessionId: 'test',
                messages: [],
                startTime: '2025-01-01T00:00:00Z',
                lastUpdated: '2025-01-01T00:00:00Z',
            }));
            mockFs.unlink.mockResolvedValue(undefined);
            const result = await cleanupExpiredSessions(config, settings);
            // Should NOT delete any sessions as all are within 14 days
            expect(result.disabled).toBe(false);
            expect(result.scanned).toBe(4);
            expect(result.deleted).toBe(0);
            expect(result.skipped).toBe(4);
            expect(result.failed).toBe(0);
            // Verify no files were deleted
            expect(mockFs.unlink).not.toHaveBeenCalled();
        });
        it('should keep N most recent deletable sessions', async () => {
            const config = createMockConfig();
            const settings = {
                general: {
                    sessionRetention: {
                        enabled: true,
                        maxCount: 3, // Keep only 3 most recent sessions
                    },
                },
            };
            // Create 6 sessions with different timestamps
            const now = new Date();
            const sessions = [
                {
                    id: 'current',
                    file: `${SESSION_FILE_PREFIX}current`,
                    fileName: `${SESSION_FILE_PREFIX}current.json`,
                    startTime: now.toISOString(),
                    lastUpdated: now.toISOString(),
                    messageCount: 1,
                    displayName: 'Current (newest)',
                    firstUserMessage: 'Current',
                    isCurrentSession: true,
                    index: 1,
                },
            ];
            // Add 5 more sessions with decreasing timestamps
            for (let i = 1; i <= 5; i++) {
                const daysAgo = new Date(now.getTime() - i * 24 * 60 * 60 * 1000);
                sessions.push({
                    id: `session${i}`,
                    file: `${SESSION_FILE_PREFIX}${i}d`,
                    fileName: `${SESSION_FILE_PREFIX}${i}d.json`,
                    startTime: daysAgo.toISOString(),
                    lastUpdated: daysAgo.toISOString(),
                    messageCount: 1,
                    displayName: `${i} days old`,
                    firstUserMessage: `${i} days`,
                    isCurrentSession: false,
                    index: i + 1,
                });
            }
            mockGetAllSessionFiles.mockResolvedValue(sessions.map((session) => ({
                fileName: session.fileName,
                sessionInfo: session,
            })));
            // Mock successful file operations
            mockFs.access.mockResolvedValue(undefined);
            mockFs.readFile.mockResolvedValue(JSON.stringify({
                sessionId: 'test',
                messages: [],
                startTime: '2025-01-01T00:00:00Z',
                lastUpdated: '2025-01-01T00:00:00Z',
            }));
            mockFs.unlink.mockResolvedValue(undefined);
            const result = await cleanupExpiredSessions(config, settings);
            // Should keep current + 2 most recent (1d and 2d), delete 3d, 4d, 5d
            expect(result.disabled).toBe(false);
            expect(result.scanned).toBe(6);
            expect(result.deleted).toBe(3);
            expect(result.skipped).toBe(3);
            // Verify which files were deleted (should be the 3 oldest)
            const unlinkCalls = mockFs.unlink.mock.calls.map((call) => call[0]);
            expect(unlinkCalls).toContain(path.join('/tmp/test-project', 'chats', `${SESSION_FILE_PREFIX}3d.json`));
            expect(unlinkCalls).toContain(path.join('/tmp/test-project', 'chats', `${SESSION_FILE_PREFIX}4d.json`));
            expect(unlinkCalls).toContain(path.join('/tmp/test-project', 'chats', `${SESSION_FILE_PREFIX}5d.json`));
            // Verify which files were NOT deleted
            expect(unlinkCalls).not.toContain(path.join('/tmp/test-project', 'chats', `${SESSION_FILE_PREFIX}current.json`));
            expect(unlinkCalls).not.toContain(path.join('/tmp/test-project', 'chats', `${SESSION_FILE_PREFIX}1d.json`));
            expect(unlinkCalls).not.toContain(path.join('/tmp/test-project', 'chats', `${SESSION_FILE_PREFIX}2d.json`));
        });
        it('should handle combined maxAge and maxCount retention (most restrictive wins)', async () => {
            const config = createMockConfig();
            const settings = {
                general: {
                    sessionRetention: {
                        enabled: true,
                        maxAge: '10d', // Keep sessions for 10 days
                        maxCount: 2, // But also keep only 2 most recent
                    },
                },
            };
            // Create sessions where maxCount is more restrictive
            const now = new Date();
            const threeDaysAgo = new Date(now.getTime() - 3 * 24 * 60 * 60 * 1000);
            const fiveDaysAgo = new Date(now.getTime() - 5 * 24 * 60 * 60 * 1000);
            const sevenDaysAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
            const twelveDaysAgo = new Date(now.getTime() - 12 * 24 * 60 * 60 * 1000);
            const testSessions = [
                {
                    id: 'current',
                    file: `${SESSION_FILE_PREFIX}current`,
                    fileName: `${SESSION_FILE_PREFIX}current.json`,
                    startTime: now.toISOString(),
                    lastUpdated: now.toISOString(),
                    messageCount: 1,
                    displayName: 'Current',
                    firstUserMessage: 'Current',
                    isCurrentSession: true,
                    index: 1,
                },
                {
                    id: 'session3d',
                    file: `${SESSION_FILE_PREFIX}3d`,
                    fileName: `${SESSION_FILE_PREFIX}3d.json`,
                    startTime: threeDaysAgo.toISOString(),
                    lastUpdated: threeDaysAgo.toISOString(),
                    messageCount: 1,
                    displayName: '3 days old',
                    firstUserMessage: '3 days',
                    isCurrentSession: false,
                    index: 2,
                },
                {
                    id: 'session5d',
                    file: `${SESSION_FILE_PREFIX}5d`,
                    fileName: `${SESSION_FILE_PREFIX}5d.json`,
                    startTime: fiveDaysAgo.toISOString(),
                    lastUpdated: fiveDaysAgo.toISOString(),
                    messageCount: 1,
                    displayName: '5 days old',
                    firstUserMessage: '5 days',
                    isCurrentSession: false,
                    index: 3,
                },
                {
                    id: 'session7d',
                    file: `${SESSION_FILE_PREFIX}7d`,
                    fileName: `${SESSION_FILE_PREFIX}7d.json`,
                    startTime: sevenDaysAgo.toISOString(),
                    lastUpdated: sevenDaysAgo.toISOString(),
                    messageCount: 1,
                    displayName: '7 days old',
                    firstUserMessage: '7 days',
                    isCurrentSession: false,
                    index: 4,
                },
                {
                    id: 'session12d',
                    file: `${SESSION_FILE_PREFIX}12d`,
                    fileName: `${SESSION_FILE_PREFIX}12d.json`,
                    startTime: twelveDaysAgo.toISOString(),
                    lastUpdated: twelveDaysAgo.toISOString(),
                    messageCount: 1,
                    displayName: '12 days old',
                    firstUserMessage: '12 days',
                    isCurrentSession: false,
                    index: 5,
                },
            ];
            mockGetAllSessionFiles.mockResolvedValue(testSessions.map((session) => ({
                fileName: session.fileName,
                sessionInfo: session,
            })));
            // Mock successful file operations
            mockFs.access.mockResolvedValue(undefined);
            mockFs.readFile.mockResolvedValue(JSON.stringify({
                sessionId: 'test',
                messages: [],
                startTime: '2025-01-01T00:00:00Z',
                lastUpdated: '2025-01-01T00:00:00Z',
            }));
            mockFs.unlink.mockResolvedValue(undefined);
            const result = await cleanupExpiredSessions(config, settings);
            // Should delete:
            // - session12d (exceeds maxAge of 10d)
            // - session7d and session5d (exceed maxCount of 2, keeping current + 3d)
            expect(result.disabled).toBe(false);
            expect(result.scanned).toBe(5);
            expect(result.deleted).toBe(3);
            expect(result.skipped).toBe(2); // Current + 3d session
            // Verify which files were deleted
            const unlinkCalls = mockFs.unlink.mock.calls.map((call) => call[0]);
            expect(unlinkCalls).toContain(path.join('/tmp/test-project', 'chats', `${SESSION_FILE_PREFIX}5d.json`));
            expect(unlinkCalls).toContain(path.join('/tmp/test-project', 'chats', `${SESSION_FILE_PREFIX}7d.json`));
            expect(unlinkCalls).toContain(path.join('/tmp/test-project', 'chats', `${SESSION_FILE_PREFIX}12d.json`));
            // Verify which files were NOT deleted
            expect(unlinkCalls).not.toContain(path.join('/tmp/test-project', 'chats', `${SESSION_FILE_PREFIX}current.json`));
            expect(unlinkCalls).not.toContain(path.join('/tmp/test-project', 'chats', `${SESSION_FILE_PREFIX}3d.json`));
        });
    });
    describe('parseRetentionPeriod format validation', () => {
        // Test all supported formats
        it.each([
            ['1h', 60 * 60 * 1000],
            ['24h', 24 * 60 * 60 * 1000],
            ['168h', 168 * 60 * 60 * 1000],
            ['1d', 24 * 60 * 60 * 1000],
            ['7d', 7 * 24 * 60 * 60 * 1000],
            ['30d', 30 * 24 * 60 * 60 * 1000],
            ['365d', 365 * 24 * 60 * 60 * 1000],
            ['1w', 7 * 24 * 60 * 60 * 1000],
            ['2w', 14 * 24 * 60 * 60 * 1000],
            ['4w', 28 * 24 * 60 * 60 * 1000],
            ['52w', 364 * 24 * 60 * 60 * 1000],
            ['1m', 30 * 24 * 60 * 60 * 1000],
            ['3m', 90 * 24 * 60 * 60 * 1000],
            ['6m', 180 * 24 * 60 * 60 * 1000],
            ['12m', 360 * 24 * 60 * 60 * 1000],
        ])('should correctly parse valid format %s', async (input) => {
            const config = createMockConfig();
            const settings = {
                general: {
                    sessionRetention: {
                        enabled: true,
                        maxAge: input,
                        // Set minRetention to 1h to allow testing of hour-based maxAge values
                        minRetention: '1h',
                    },
                },
            };
            mockGetAllSessionFiles.mockResolvedValue([]);
            // If it parses correctly, cleanup should proceed without error
            const result = await cleanupExpiredSessions(config, settings);
            expect(result.disabled).toBe(false);
            expect(result.failed).toBe(0);
        });
        // Test invalid formats
        it.each([
            '30', // Missing unit
            '30x', // Invalid unit
            'd', // No number
            '1.5d', // Decimal not supported
            '-5d', // Negative number
            '1 d', // Space in format
            '1dd', // Double unit
            'abc', // Non-numeric
            '30s', // Unsupported unit (seconds)
            '30y', // Unsupported unit (years)
            '0d', // Zero value (technically valid regex but semantically invalid)
        ])('should reject invalid format %s', async (input) => {
            const config = createMockConfig({
                getDebugMode: vi.fn().mockReturnValue(true),
            });
            const settings = {
                general: {
                    sessionRetention: {
                        enabled: true,
                        maxAge: input,
                    },
                },
            };
            const result = await cleanupExpiredSessions(config, settings);
            expect(result.disabled).toBe(true);
            expect(result.scanned).toBe(0);
            expect(debugLogger.warn).toHaveBeenCalledWith(expect.stringContaining(input === '0d'
                ? 'Invalid retention period: 0d. Value must be greater than 0'
                : `Invalid retention period format: ${input}`));
        });
        // Test special case - empty string
        it('should reject empty string', async () => {
            const config = createMockConfig({
                getDebugMode: vi.fn().mockReturnValue(true),
            });
            const settings = {
                general: {
                    sessionRetention: {
                        enabled: true,
                        maxAge: '',
                    },
                },
            };
            const result = await cleanupExpiredSessions(config, settings);
            expect(result.disabled).toBe(true);
            expect(result.scanned).toBe(0);
            // Empty string means no valid retention method specified
            expect(debugLogger.warn).toHaveBeenCalledWith(expect.stringContaining('Either maxAge or maxCount must be specified'));
        });
        // Test edge cases
        it('should handle very large numbers', async () => {
            const config = createMockConfig();
            const settings = {
                general: {
                    sessionRetention: {
                        enabled: true,
                        maxAge: '9999d', // Very large number
                    },
                },
            };
            mockGetAllSessionFiles.mockResolvedValue([]);
            const result = await cleanupExpiredSessions(config, settings);
            expect(result.disabled).toBe(false);
            expect(result.failed).toBe(0);
        });
        it('should validate minRetention format', async () => {
            const config = createMockConfig({
                getDebugMode: vi.fn().mockReturnValue(true),
            });
            const settings = {
                general: {
                    sessionRetention: {
                        enabled: true,
                        maxAge: '5d',
                        minRetention: 'invalid-format', // Invalid minRetention
                    },
                },
            };
            mockGetAllSessionFiles.mockResolvedValue([]);
            // Should fall back to default minRetention and proceed
            const result = await cleanupExpiredSessions(config, settings);
            // Since maxAge (5d) > default minRetention (1d), this should succeed
            expect(result.disabled).toBe(false);
            expect(result.failed).toBe(0);
        });
    });
    describe('Configuration validation', () => {
        it('should require either maxAge or maxCount', async () => {
            const config = createMockConfig({
                getDebugMode: vi.fn().mockReturnValue(true),
            });
            const settings = {
                general: {
                    sessionRetention: {
                        enabled: true,
                        // Neither maxAge nor maxCount specified
                    },
                },
            };
            const result = await cleanupExpiredSessions(config, settings);
            expect(result.disabled).toBe(true);
            expect(result.scanned).toBe(0);
            expect(debugLogger.warn).toHaveBeenCalledWith(expect.stringContaining('Either maxAge or maxCount must be specified'));
        });
        it('should validate maxCount range', async () => {
            const config = createMockConfig({
                getDebugMode: vi.fn().mockReturnValue(true),
            });
            const settings = {
                general: {
                    sessionRetention: {
                        enabled: true,
                        maxCount: 0, // Invalid count
                    },
                },
            };
            const result = await cleanupExpiredSessions(config, settings);
            expect(result.disabled).toBe(true);
            expect(result.scanned).toBe(0);
            expect(debugLogger.warn).toHaveBeenCalledWith(expect.stringContaining('maxCount must be at least 1'));
        });
        describe('maxAge format validation', () => {
            it('should reject invalid maxAge format - no unit', async () => {
                const config = createMockConfig({
                    getDebugMode: vi.fn().mockReturnValue(true),
                });
                const settings = {
                    general: {
                        sessionRetention: {
                            enabled: true,
                            maxAge: '30', // Missing unit
                        },
                    },
                };
                const result = await cleanupExpiredSessions(config, settings);
                expect(result.disabled).toBe(true);
                expect(result.scanned).toBe(0);
                expect(debugLogger.warn).toHaveBeenCalledWith(expect.stringContaining('Invalid retention period format: 30'));
            });
            it('should reject invalid maxAge format - invalid unit', async () => {
                const config = createMockConfig({
                    getDebugMode: vi.fn().mockReturnValue(true),
                });
                const settings = {
                    general: {
                        sessionRetention: {
                            enabled: true,
                            maxAge: '30x', // Invalid unit 'x'
                        },
                    },
                };
                const result = await cleanupExpiredSessions(config, settings);
                expect(result.disabled).toBe(true);
                expect(result.scanned).toBe(0);
                expect(debugLogger.warn).toHaveBeenCalledWith(expect.stringContaining('Invalid retention period format: 30x'));
            });
            it('should reject invalid maxAge format - no number', async () => {
                const config = createMockConfig({
                    getDebugMode: vi.fn().mockReturnValue(true),
                });
                const settings = {
                    general: {
                        sessionRetention: {
                            enabled: true,
                            maxAge: 'd', // No number
                        },
                    },
                };
                const result = await cleanupExpiredSessions(config, settings);
                expect(result.disabled).toBe(true);
                expect(result.scanned).toBe(0);
                expect(debugLogger.warn).toHaveBeenCalledWith(expect.stringContaining('Invalid retention period format: d'));
            });
            it('should reject invalid maxAge format - decimal number', async () => {
                const config = createMockConfig({
                    getDebugMode: vi.fn().mockReturnValue(true),
                });
                const settings = {
                    general: {
                        sessionRetention: {
                            enabled: true,
                            maxAge: '1.5d', // Decimal not supported
                        },
                    },
                };
                const result = await cleanupExpiredSessions(config, settings);
                expect(result.disabled).toBe(true);
                expect(result.scanned).toBe(0);
                expect(debugLogger.warn).toHaveBeenCalledWith(expect.stringContaining('Invalid retention period format: 1.5d'));
            });
            it('should reject invalid maxAge format - negative number', async () => {
                const config = createMockConfig({
                    getDebugMode: vi.fn().mockReturnValue(true),
                });
                const settings = {
                    general: {
                        sessionRetention: {
                            enabled: true,
                            maxAge: '-5d', // Negative not allowed
                        },
                    },
                };
                const result = await cleanupExpiredSessions(config, settings);
                expect(result.disabled).toBe(true);
                expect(result.scanned).toBe(0);
                expect(debugLogger.warn).toHaveBeenCalledWith(expect.stringContaining('Invalid retention period format: -5d'));
            });
            it('should accept valid maxAge format - hours', async () => {
                const config = createMockConfig();
                const settings = {
                    general: {
                        sessionRetention: {
                            enabled: true,
                            maxAge: '48h', // Valid: 48 hours
                            maxCount: 10, // Need at least one valid retention method
                        },
                    },
                };
                mockGetAllSessionFiles.mockResolvedValue([]);
                const result = await cleanupExpiredSessions(config, settings);
                // Should not reject the configuration
                expect(result.disabled).toBe(false);
                expect(result.scanned).toBe(0);
                expect(result.failed).toBe(0);
            });
            it('should accept valid maxAge format - days', async () => {
                const config = createMockConfig();
                const settings = {
                    general: {
                        sessionRetention: {
                            enabled: true,
                            maxAge: '7d', // Valid: 7 days
                        },
                    },
                };
                mockGetAllSessionFiles.mockResolvedValue([]);
                const result = await cleanupExpiredSessions(config, settings);
                // Should not reject the configuration
                expect(result.disabled).toBe(false);
                expect(result.scanned).toBe(0);
                expect(result.failed).toBe(0);
            });
            it('should accept valid maxAge format - weeks', async () => {
                const config = createMockConfig();
                const settings = {
                    general: {
                        sessionRetention: {
                            enabled: true,
                            maxAge: '2w', // Valid: 2 weeks
                        },
                    },
                };
                mockGetAllSessionFiles.mockResolvedValue([]);
                const result = await cleanupExpiredSessions(config, settings);
                // Should not reject the configuration
                expect(result.disabled).toBe(false);
                expect(result.scanned).toBe(0);
                expect(result.failed).toBe(0);
            });
            it('should accept valid maxAge format - months', async () => {
                const config = createMockConfig();
                const settings = {
                    general: {
                        sessionRetention: {
                            enabled: true,
                            maxAge: '3m', // Valid: 3 months
                        },
                    },
                };
                mockGetAllSessionFiles.mockResolvedValue([]);
                const result = await cleanupExpiredSessions(config, settings);
                // Should not reject the configuration
                expect(result.disabled).toBe(false);
                expect(result.scanned).toBe(0);
                expect(result.failed).toBe(0);
            });
        });
        describe('minRetention validation', () => {
            it('should reject maxAge less than default minRetention (1d)', async () => {
                const config = createMockConfig({
                    getDebugMode: vi.fn().mockReturnValue(true),
                });
                const settings = {
                    general: {
                        sessionRetention: {
                            enabled: true,
                            maxAge: '12h', // Less than default 1d minRetention
                        },
                    },
                };
                const result = await cleanupExpiredSessions(config, settings);
                expect(result.disabled).toBe(true);
                expect(result.scanned).toBe(0);
                expect(debugLogger.warn).toHaveBeenCalledWith(expect.stringContaining('maxAge cannot be less than minRetention (1d)'));
            });
            it('should reject maxAge less than custom minRetention', async () => {
                const config = createMockConfig({
                    getDebugMode: vi.fn().mockReturnValue(true),
                });
                const settings = {
                    general: {
                        sessionRetention: {
                            enabled: true,
                            maxAge: '2d',
                            minRetention: '3d', // maxAge < minRetention
                        },
                    },
                };
                const result = await cleanupExpiredSessions(config, settings);
                expect(result.disabled).toBe(true);
                expect(result.scanned).toBe(0);
                expect(debugLogger.warn).toHaveBeenCalledWith(expect.stringContaining('maxAge cannot be less than minRetention (3d)'));
            });
            it('should accept maxAge equal to minRetention', async () => {
                const config = createMockConfig();
                const settings = {
                    general: {
                        sessionRetention: {
                            enabled: true,
                            maxAge: '2d',
                            minRetention: '2d', // maxAge == minRetention (edge case)
                        },
                    },
                };
                mockGetAllSessionFiles.mockResolvedValue([]);
                const result = await cleanupExpiredSessions(config, settings);
                // Should not reject the configuration
                expect(result.disabled).toBe(false);
                expect(result.scanned).toBe(0);
                expect(result.failed).toBe(0);
            });
            it('should accept maxAge greater than minRetention', async () => {
                const config = createMockConfig();
                const settings = {
                    general: {
                        sessionRetention: {
                            enabled: true,
                            maxAge: '7d',
                            minRetention: '2d', // maxAge > minRetention
                        },
                    },
                };
                mockGetAllSessionFiles.mockResolvedValue([]);
                const result = await cleanupExpiredSessions(config, settings);
                // Should not reject the configuration
                expect(result.disabled).toBe(false);
                expect(result.scanned).toBe(0);
                expect(result.failed).toBe(0);
            });
            it('should handle invalid minRetention format gracefully', async () => {
                const config = createMockConfig({
                    getDebugMode: vi.fn().mockReturnValue(true),
                });
                const settings = {
                    general: {
                        sessionRetention: {
                            enabled: true,
                            maxAge: '5d',
                            minRetention: 'invalid', // Invalid format
                        },
                    },
                };
                mockGetAllSessionFiles.mockResolvedValue([]);
                // When minRetention is invalid, it should default to 1d
                // Since maxAge (5d) > default minRetention (1d), this should be valid
                const result = await cleanupExpiredSessions(config, settings);
                // Should not reject due to minRetention (falls back to default)
                expect(result.disabled).toBe(false);
                expect(result.scanned).toBe(0);
                expect(result.failed).toBe(0);
            });
        });
        describe('maxCount boundary validation', () => {
            it('should accept maxCount = 1 (minimum valid)', async () => {
                const config = createMockConfig();
                const settings = {
                    general: {
                        sessionRetention: {
                            enabled: true,
                            maxCount: 1, // Minimum valid value
                        },
                    },
                };
                mockGetAllSessionFiles.mockResolvedValue([]);
                const result = await cleanupExpiredSessions(config, settings);
                // Should accept the configuration
                expect(result.disabled).toBe(false);
                expect(result.scanned).toBe(0);
                expect(result.failed).toBe(0);
            });
            it('should accept maxCount = 1000 (maximum valid)', async () => {
                const config = createMockConfig();
                const settings = {
                    general: {
                        sessionRetention: {
                            enabled: true,
                            maxCount: 1000, // Maximum valid value
                        },
                    },
                };
                mockGetAllSessionFiles.mockResolvedValue([]);
                const result = await cleanupExpiredSessions(config, settings);
                // Should accept the configuration
                expect(result.disabled).toBe(false);
                expect(result.scanned).toBe(0);
                expect(result.failed).toBe(0);
            });
            it('should reject negative maxCount', async () => {
                const config = createMockConfig({
                    getDebugMode: vi.fn().mockReturnValue(true),
                });
                const settings = {
                    general: {
                        sessionRetention: {
                            enabled: true,
                            maxCount: -1, // Negative value
                        },
                    },
                };
                const result = await cleanupExpiredSessions(config, settings);
                expect(result.disabled).toBe(true);
                expect(result.scanned).toBe(0);
                expect(debugLogger.warn).toHaveBeenCalledWith(expect.stringContaining('maxCount must be at least 1'));
            });
            it('should accept valid maxCount in normal range', async () => {
                const config = createMockConfig();
                const settings = {
                    general: {
                        sessionRetention: {
                            enabled: true,
                            maxCount: 50, // Normal valid value
                        },
                    },
                };
                mockGetAllSessionFiles.mockResolvedValue([]);
                const result = await cleanupExpiredSessions(config, settings);
                // Should accept the configuration
                expect(result.disabled).toBe(false);
                expect(result.scanned).toBe(0);
                expect(result.failed).toBe(0);
            });
        });
        describe('combined configuration validation', () => {
            it('should accept valid maxAge and maxCount together', async () => {
                const config = createMockConfig();
                const settings = {
                    general: {
                        sessionRetention: {
                            enabled: true,
                            maxAge: '30d',
                            maxCount: 10,
                        },
                    },
                };
                mockGetAllSessionFiles.mockResolvedValue([]);
                const result = await cleanupExpiredSessions(config, settings);
                // Should accept the configuration
                expect(result.disabled).toBe(false);
                expect(result.scanned).toBe(0);
                expect(result.failed).toBe(0);
            });
            it('should reject if both maxAge and maxCount are invalid', async () => {
                const config = createMockConfig({
                    getDebugMode: vi.fn().mockReturnValue(true),
                });
                const settings = {
                    general: {
                        sessionRetention: {
                            enabled: true,
                            maxAge: 'invalid',
                            maxCount: 0,
                        },
                    },
                };
                const result = await cleanupExpiredSessions(config, settings);
                expect(result.disabled).toBe(true);
                expect(result.scanned).toBe(0);
                // Should fail on first validation error (maxAge format)
                expect(debugLogger.warn).toHaveBeenCalledWith(expect.stringContaining('Invalid retention period format'));
            });
            it('should reject if maxAge is invalid even when maxCount is valid', async () => {
                const config = createMockConfig({
                    getDebugMode: vi.fn().mockReturnValue(true),
                });
                const settings = {
                    general: {
                        sessionRetention: {
                            enabled: true,
                            maxAge: 'invalid', // Invalid format
                            maxCount: 5, // Valid count
                        },
                    },
                };
                // The validation logic rejects invalid maxAge format even if maxCount is valid
                const result = await cleanupExpiredSessions(config, settings);
                // Should reject due to invalid maxAge format
                expect(result.disabled).toBe(true);
                expect(result.scanned).toBe(0);
                expect(debugLogger.warn).toHaveBeenCalledWith(expect.stringContaining('Invalid retention period format'));
            });
        });
        it('should never throw an exception, always returning a result', async () => {
            const config = createMockConfig();
            const settings = {
                general: {
                    sessionRetention: {
                        enabled: true,
                        maxAge: '7d',
                    },
                },
            };
            // Mock getSessionFiles to throw an error
            mockGetAllSessionFiles.mockRejectedValue(new Error('Failed to read directory'));
            // Should not throw, should return a result with errors
            const result = await cleanupExpiredSessions(config, settings);
            expect(result).toBeDefined();
            expect(result.disabled).toBe(false);
            expect(result.failed).toBe(1);
        });
        it('should delete corrupted session files', async () => {
            const config = createMockConfig();
            const settings = {
                general: {
                    sessionRetention: {
                        enabled: true,
                        maxAge: '30d',
                    },
                },
            };
            // Mock getAllSessionFiles to return both valid and corrupted files
            const validSession = createTestSessions()[0];
            mockGetAllSessionFiles.mockResolvedValue([
                { fileName: validSession.fileName, sessionInfo: validSession },
                {
                    fileName: `${SESSION_FILE_PREFIX}2025-01-02T10-00-00-corrupt1.json`,
                    sessionInfo: null,
                },
                {
                    fileName: `${SESSION_FILE_PREFIX}2025-01-03T10-00-00-corrupt2.json`,
                    sessionInfo: null,
                },
            ]);
            mockFs.unlink.mockResolvedValue(undefined);
            const result = await cleanupExpiredSessions(config, settings);
            expect(result.disabled).toBe(false);
            expect(result.scanned).toBe(3); // 1 valid + 2 corrupted
            expect(result.deleted).toBe(2); // Should delete the 2 corrupted files
            expect(result.skipped).toBe(1); // The valid session is kept
            // Verify corrupted files were deleted
            expect(mockFs.unlink).toHaveBeenCalledWith(expect.stringContaining('corrupt1.json'));
            expect(mockFs.unlink).toHaveBeenCalledWith(expect.stringContaining('corrupt2.json'));
        });
        it('should handle unexpected errors without throwing', async () => {
            const config = createMockConfig();
            const settings = {
                general: {
                    sessionRetention: {
                        enabled: true,
                        maxAge: '7d',
                    },
                },
            };
            // Mock getSessionFiles to throw a non-Error object
            mockGetAllSessionFiles.mockRejectedValue('String error');
            // Should not throw, should return a result with errors
            const result = await cleanupExpiredSessions(config, settings);
            expect(result).toBeDefined();
            expect(result.disabled).toBe(false);
            expect(result.failed).toBe(1);
        });
    });
});
//# sourceMappingURL=sessionCleanup.test.js.map