claude-session-share 1.0.0

package/dist/__tests__/session-writer.test.js

@@ -0,0 +1,286 @@
+/**
+ * Tests for session writer with local JSONL storage
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { writeSessionToLocal, SessionWriteError } from '../session/writer.js';
+import { homedir } from 'os';
+import { join } from 'path';
+// Mock fs/promises
+vi.mock('fs/promises', () => ({
+    mkdir: vi.fn(),
+    writeFile: vi.fn(),
+}));
+// Mock crypto for predictable UUID generation
+vi.mock('crypto', () => ({
+    randomUUID: vi.fn(() => 'test-session-uuid-123'),
+}));
+describe('writeSessionToLocal', () => {
+    let mockMkdir;
+    let mockWriteFile;
+    beforeEach(async () => {
+        // Get mocked functions
+        const fs = await import('fs/promises');
+        mockMkdir = fs.mkdir;
+        mockWriteFile = fs.writeFile;
+        // Reset mocks
+        vi.clearAllMocks();
+        // Default successful behavior
+        mockMkdir.mockResolvedValue(undefined);
+        mockWriteFile.mockResolvedValue(undefined);
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should write session messages to correct path', async () => {
+        const messages = [
+            {
+                type: 'user',
+                uuid: 'uuid-1',
+                sessionId: 'session-123',
+                timestamp: '2024-01-01T00:00:00Z',
+                parentUuid: null,
+                message: { role: 'user', content: 'Test message' },
+                cwd: '/Users/name/project',
+                version: '1.0.0',
+            },
+        ];
+        const projectPath = '/Users/name/project';
+        const result = await writeSessionToLocal(messages, projectPath);
+        // Verify directory creation
+        const expectedDir = join(homedir(), '.claude', 'projects', 'Users-name-project');
+        expect(mockMkdir).toHaveBeenCalledWith(expectedDir, { recursive: true });
+        // Verify file writing
+        const expectedPath = join(expectedDir, 'test-session-uuid-123.jsonl');
+        expect(mockWriteFile).toHaveBeenCalledWith(expectedPath, expect.any(String), { encoding: 'utf-8' });
+        // Verify result
+        expect(result.filePath).toBe(expectedPath);
+        expect(result.sessionId).toBe('test-session-uuid-123');
+    });
+    it('should format messages as JSONL with trailing newline', async () => {
+        const messages = [
+            {
+                type: 'user',
+                uuid: 'uuid-1',
+                sessionId: 'session-123',
+                timestamp: '2024-01-01T00:00:00Z',
+                parentUuid: null,
+                message: { role: 'user', content: 'First' },
+                cwd: '/Users/name/project',
+                version: '1.0.0',
+            },
+            {
+                type: 'user',
+                uuid: 'uuid-2',
+                sessionId: 'session-123',
+                timestamp: '2024-01-01T00:01:00Z',
+                parentUuid: 'uuid-1',
+                message: { role: 'user', content: 'Second' },
+                cwd: '/Users/name/project',
+                version: '1.0.0',
+            },
+        ];
+        await writeSessionToLocal(messages, '/Users/name/project');
+        const writtenContent = mockWriteFile.mock.calls[0][1];
+        const lines = writtenContent.split('\n');
+        // Should have 3 lines: 2 messages + trailing newline (which creates empty string)
+        expect(lines.length).toBe(3);
+        expect(lines[2]).toBe(''); // Trailing newline creates empty last element
+        // Each line should be valid JSON
+        expect(() => JSON.parse(lines[0])).not.toThrow();
+        expect(() => JSON.parse(lines[1])).not.toThrow();
+        // Verify content
+        const msg1 = JSON.parse(lines[0]);
+        const msg2 = JSON.parse(lines[1]);
+        expect(msg1.uuid).toBe('uuid-1');
+        expect(msg2.uuid).toBe('uuid-2');
+    });
+    it('should handle multiple message types', async () => {
+        const messages = [
+            {
+                type: 'user',
+                uuid: 'uuid-1',
+                sessionId: 'session-123',
+                timestamp: '2024-01-01T00:00:00Z',
+                parentUuid: null,
+                message: { role: 'user', content: 'Question' },
+                cwd: '/Users/name/project',
+                version: '1.0.0',
+            },
+            {
+                type: 'assistant',
+                uuid: 'uuid-2',
+                sessionId: 'session-123',
+                timestamp: '2024-01-01T00:01:00Z',
+                parentUuid: 'uuid-1',
+                messageId: 'msg-1',
+                snapshot: {
+                    thinking: 'Let me help',
+                    messages: [{ role: 'assistant', content: 'Answer' }],
+                },
+            },
+        ];
+        await writeSessionToLocal(messages, '/Users/name/project');
+        const writtenContent = mockWriteFile.mock.calls[0][1];
+        const lines = writtenContent.split('\n');
+        const msg1 = JSON.parse(lines[0]);
+        const msg2 = JSON.parse(lines[1]);
+        expect(msg1.type).toBe('user');
+        expect(msg2.type).toBe('assistant');
+        expect(msg2.snapshot.thinking).toBe('Let me help');
+    });
+    it('should encode project path correctly', async () => {
+        const messages = [
+            {
+                type: 'user',
+                uuid: 'uuid-1',
+                sessionId: 'session-123',
+                timestamp: '2024-01-01T00:00:00Z',
+                parentUuid: null,
+                message: { role: 'user', content: 'Test' },
+                cwd: '/opt/code/my-app',
+                version: '1.0.0',
+            },
+        ];
+        await writeSessionToLocal(messages, '/opt/code/my-app');
+        const expectedDir = join(homedir(), '.claude', 'projects', 'opt-code-my-app');
+        expect(mockMkdir).toHaveBeenCalledWith(expectedDir, { recursive: true });
+    });
+    it('should create directory with recursive flag', async () => {
+        const messages = [
+            {
+                type: 'user',
+                uuid: 'uuid-1',
+                sessionId: 'session-123',
+                timestamp: '2024-01-01T00:00:00Z',
+                parentUuid: null,
+                message: { role: 'user', content: 'Test' },
+                cwd: '/Users/name/project',
+                version: '1.0.0',
+            },
+        ];
+        await writeSessionToLocal(messages, '/Users/name/project');
+        expect(mockMkdir).toHaveBeenCalledWith(expect.any(String), { recursive: true });
+    });
+    it('should throw SessionWriteError on EACCES (permissions)', async () => {
+        const messages = [
+            {
+                type: 'user',
+                uuid: 'uuid-1',
+                sessionId: 'session-123',
+                timestamp: '2024-01-01T00:00:00Z',
+                parentUuid: null,
+                message: { role: 'user', content: 'Test' },
+                cwd: '/Users/name/project',
+                version: '1.0.0',
+            },
+        ];
+        mockMkdir.mockRejectedValue({
+            code: 'EACCES',
+            message: 'Permission denied',
+        });
+        await expect(writeSessionToLocal(messages, '/Users/name/project')).rejects.toThrow(SessionWriteError);
+        await expect(writeSessionToLocal(messages, '/Users/name/project')).rejects.toThrow(/Permission denied/);
+    });
+    it('should throw SessionWriteError on ENOSPC (disk full)', async () => {
+        const messages = [
+            {
+                type: 'user',
+                uuid: 'uuid-1',
+                sessionId: 'session-123',
+                timestamp: '2024-01-01T00:00:00Z',
+                parentUuid: null,
+                message: { role: 'user', content: 'Test' },
+                cwd: '/Users/name/project',
+                version: '1.0.0',
+            },
+        ];
+        mockWriteFile.mockRejectedValue({
+            code: 'ENOSPC',
+            message: 'No space left on device',
+        });
+        await expect(writeSessionToLocal(messages, '/Users/name/project')).rejects.toThrow(SessionWriteError);
+        await expect(writeSessionToLocal(messages, '/Users/name/project')).rejects.toThrow(/Disk full/);
+    });
+    it('should throw SessionWriteError on other filesystem errors', async () => {
+        const messages = [
+            {
+                type: 'user',
+                uuid: 'uuid-1',
+                sessionId: 'session-123',
+                timestamp: '2024-01-01T00:00:00Z',
+                parentUuid: null,
+                message: { role: 'user', content: 'Test' },
+                cwd: '/Users/name/project',
+                version: '1.0.0',
+            },
+        ];
+        mockWriteFile.mockRejectedValue({
+            code: 'UNKNOWN',
+            message: 'Something went wrong',
+        });
+        await expect(writeSessionToLocal(messages, '/Users/name/project')).rejects.toThrow(SessionWriteError);
+        await expect(writeSessionToLocal(messages, '/Users/name/project')).rejects.toThrow(/Failed to write session/);
+    });
+    it('should include error code in SessionWriteError', async () => {
+        const messages = [
+            {
+                type: 'user',
+                uuid: 'uuid-1',
+                sessionId: 'session-123',
+                timestamp: '2024-01-01T00:00:00Z',
+                parentUuid: null,
+                message: { role: 'user', content: 'Test' },
+                cwd: '/Users/name/project',
+                version: '1.0.0',
+            },
+        ];
+        mockMkdir.mockRejectedValue({
+            code: 'EACCES',
+            message: 'Permission denied',
+        });
+        try {
+            await writeSessionToLocal(messages, '/Users/name/project');
+            expect.fail('Should have thrown');
+        }
+        catch (error) {
+            expect(error).toBeInstanceOf(SessionWriteError);
+            expect(error.code).toBe('EACCES');
+        }
+    });
+    it('should write empty messages array', async () => {
+        const messages = [];
+        await writeSessionToLocal(messages, '/Users/name/project');
+        const writtenContent = mockWriteFile.mock.calls[0][1];
+        expect(writtenContent).toBe('\n'); // Just trailing newline
+    });
+    it('should preserve all message fields in written JSON', async () => {
+        const messages = [
+            {
+                type: 'user',
+                uuid: 'uuid-1',
+                sessionId: 'session-123',
+                timestamp: '2024-01-01T00:00:00Z',
+                parentUuid: null,
+                message: { role: 'user', content: 'Test message' },
+                cwd: '/Users/name/project',
+                version: '1.0.0',
+                gitBranch: 'main',
+                isSidechain: true,
+                isMeta: false,
+            },
+        ];
+        await writeSessionToLocal(messages, '/Users/name/project');
+        const writtenContent = mockWriteFile.mock.calls[0][1];
+        const parsed = JSON.parse(writtenContent.split('\n')[0]);
+        expect(parsed.type).toBe('user');
+        expect(parsed.uuid).toBe('uuid-1');
+        expect(parsed.sessionId).toBe('session-123');
+        expect(parsed.timestamp).toBe('2024-01-01T00:00:00Z');
+        expect(parsed.parentUuid).toBeNull();
+        expect(parsed.cwd).toBe('/Users/name/project');
+        expect(parsed.version).toBe('1.0.0');
+        expect(parsed.gitBranch).toBe('main');
+        expect(parsed.isSidechain).toBe(true);
+        expect(parsed.isMeta).toBe(false);
+    });
+});

package/dist/__tests__/uuid-mapper.test.js

@@ -0,0 +1,249 @@
+/**
+ * Tests for UUID remapper with collision avoidance
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { UUIDMapper } from '../utils/uuid-mapper.js';
+describe('UUIDMapper', () => {
+    let mapper;
+    beforeEach(() => {
+        mapper = new UUIDMapper();
+    });
+    describe('remap', () => {
+        it('should generate a new UUID for a given input', () => {
+            const original = 'abc-123-def';
+            const remapped = mapper.remap(original);
+            expect(remapped).toBeTruthy();
+            expect(remapped).not.toBe(original);
+            expect(typeof remapped).toBe('string');
+        });
+        it('should return the same UUID for the same input (consistency)', () => {
+            const original = 'abc-123-def';
+            const remapped1 = mapper.remap(original);
+            const remapped2 = mapper.remap(original);
+            const remapped3 = mapper.remap(original);
+            expect(remapped1).toBe(remapped2);
+            expect(remapped2).toBe(remapped3);
+        });
+        it('should generate different UUIDs for different inputs', () => {
+            const uuid1 = mapper.remap('original-1');
+            const uuid2 = mapper.remap('original-2');
+            const uuid3 = mapper.remap('original-3');
+            expect(uuid1).not.toBe(uuid2);
+            expect(uuid2).not.toBe(uuid3);
+            expect(uuid1).not.toBe(uuid3);
+        });
+        it('should handle null input by returning null', () => {
+            const result = mapper.remap(null);
+            expect(result).toBeNull();
+        });
+        it('should always return null for null input (multiple calls)', () => {
+            const result1 = mapper.remap(null);
+            const result2 = mapper.remap(null);
+            const result3 = mapper.remap(null);
+            expect(result1).toBeNull();
+            expect(result2).toBeNull();
+            expect(result3).toBeNull();
+        });
+        it('should generate valid UUID v4 format', () => {
+            const remapped = mapper.remap('test-uuid');
+            // UUID v4 format: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
+            const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+            expect(remapped).toMatch(uuidRegex);
+        });
+    });
+    describe('remapMessage', () => {
+        it('should remap UUIDs in a user message', () => {
+            const original = {
+                type: 'user',
+                uuid: 'user-uuid-1',
+                sessionId: 'session-123',
+                timestamp: '2024-01-01T00:00:00Z',
+                parentUuid: 'parent-uuid-1',
+                message: {
+                    role: 'user',
+                    content: 'Hello, world!',
+                },
+                cwd: '/home/user/project',
+                version: '1.0.0',
+                gitBranch: 'main',
+                isSidechain: false,
+            };
+            const remapped = mapper.remapMessage(original);
+            // UUIDs should be different
+            expect(remapped.uuid).not.toBe(original.uuid);
+            expect(remapped.sessionId).not.toBe(original.sessionId);
+            expect(remapped.parentUuid).not.toBe(original.parentUuid);
+            // Other fields should be preserved
+            expect(remapped.type).toBe(original.type);
+            expect(remapped.timestamp).toBe(original.timestamp);
+            expect(remapped.message).toEqual(original.message);
+            expect(remapped.cwd).toBe(original.cwd);
+            expect(remapped.version).toBe(original.version);
+            expect(remapped.gitBranch).toBe(original.gitBranch);
+            expect(remapped.isSidechain).toBe(original.isSidechain);
+        });
+        it('should remap UUIDs in an assistant message', () => {
+            const original = {
+                type: 'assistant',
+                uuid: 'assistant-uuid-1',
+                sessionId: 'session-123',
+                timestamp: '2024-01-01T00:01:00Z',
+                parentUuid: 'parent-uuid-2',
+                messageId: 'msg-123',
+                snapshot: {
+                    thinking: 'Let me help you',
+                    messages: [
+                        { role: 'assistant', content: 'Here is the answer' },
+                    ],
+                },
+            };
+            const remapped = mapper.remapMessage(original);
+            // UUIDs should be different
+            expect(remapped.uuid).not.toBe(original.uuid);
+            expect(remapped.sessionId).not.toBe(original.sessionId);
+            expect(remapped.parentUuid).not.toBe(original.parentUuid);
+            // Other fields should be preserved
+            expect(remapped.type).toBe(original.type);
+            expect(remapped.timestamp).toBe(original.timestamp);
+            expect(remapped.messageId).toBe(original.messageId);
+            expect(remapped.snapshot).toEqual(original.snapshot);
+        });
+        it('should remap UUIDs in a file-history-snapshot message', () => {
+            const original = {
+                type: 'file-history-snapshot',
+                uuid: 'snapshot-uuid-1',
+                sessionId: 'session-123',
+                timestamp: '2024-01-01T00:02:00Z',
+                parentUuid: null,
+                isSnapshotUpdate: true,
+                snapshot: {
+                    files: [
+                        { path: '/home/user/project/file.ts' },
+                    ],
+                },
+            };
+            const remapped = mapper.remapMessage(original);
+            // UUIDs should be different (except parentUuid which is null)
+            expect(remapped.uuid).not.toBe(original.uuid);
+            expect(remapped.sessionId).not.toBe(original.sessionId);
+            expect(remapped.parentUuid).toBeNull();
+            // Other fields should be preserved
+            expect(remapped.type).toBe(original.type);
+            expect(remapped.timestamp).toBe(original.timestamp);
+            expect(remapped.isSnapshotUpdate).toBe(original.isSnapshotUpdate);
+            expect(remapped.snapshot).toEqual(original.snapshot);
+        });
+        it('should not mutate the original message (immutability)', () => {
+            const original = {
+                type: 'user',
+                uuid: 'user-uuid-1',
+                sessionId: 'session-123',
+                timestamp: '2024-01-01T00:00:00Z',
+                parentUuid: 'parent-uuid-1',
+                message: {
+                    role: 'user',
+                    content: 'Test message',
+                },
+                cwd: '/home/user/project',
+                version: '1.0.0',
+            };
+            const originalCopy = { ...original };
+            const remapped = mapper.remapMessage(original);
+            // Original should be unchanged
+            expect(original).toEqual(originalCopy);
+            expect(original.uuid).toBe('user-uuid-1');
+            expect(original.sessionId).toBe('session-123');
+            expect(original.parentUuid).toBe('parent-uuid-1');
+            // Remapped should be different
+            expect(remapped.uuid).not.toBe(original.uuid);
+        });
+        it('should preserve parent-child relationships through consistent remapping', () => {
+            const parentMessage = {
+                type: 'user',
+                uuid: 'parent-uuid',
+                sessionId: 'session-123',
+                timestamp: '2024-01-01T00:00:00Z',
+                parentUuid: null,
+                message: { role: 'user', content: 'Parent' },
+                cwd: '/home/user/project',
+                version: '1.0.0',
+            };
+            const childMessage = {
+                type: 'assistant',
+                uuid: 'child-uuid',
+                sessionId: 'session-123',
+                timestamp: '2024-01-01T00:01:00Z',
+                parentUuid: 'parent-uuid', // References parent
+                messageId: 'msg-1',
+                snapshot: {
+                    thinking: null,
+                    messages: [],
+                },
+            };
+            const remappedParent = mapper.remapMessage(parentMessage);
+            const remappedChild = mapper.remapMessage(childMessage);
+            // Child's parentUuid should equal parent's uuid after remapping
+            expect(remappedChild.parentUuid).toBe(remappedParent.uuid);
+            // Both should have same sessionId after remapping
+            expect(remappedChild.sessionId).toBe(remappedParent.sessionId);
+        });
+        it('should handle multiple messages with consistent session ID remapping', () => {
+            const messages = [
+                {
+                    type: 'user',
+                    uuid: 'uuid-1',
+                    sessionId: 'session-abc',
+                    timestamp: '2024-01-01T00:00:00Z',
+                    parentUuid: null,
+                    message: { role: 'user', content: 'Message 1' },
+                    cwd: '/home/user/project',
+                    version: '1.0.0',
+                },
+                {
+                    type: 'user',
+                    uuid: 'uuid-2',
+                    sessionId: 'session-abc',
+                    timestamp: '2024-01-01T00:01:00Z',
+                    parentUuid: 'uuid-1',
+                    message: { role: 'user', content: 'Message 2' },
+                    cwd: '/home/user/project',
+                    version: '1.0.0',
+                },
+                {
+                    type: 'user',
+                    uuid: 'uuid-3',
+                    sessionId: 'session-abc',
+                    timestamp: '2024-01-01T00:02:00Z',
+                    parentUuid: 'uuid-2',
+                    message: { role: 'user', content: 'Message 3' },
+                    cwd: '/home/user/project',
+                    version: '1.0.0',
+                },
+            ];
+            const remapped = messages.map((msg) => mapper.remapMessage(msg));
+            // All should have the same remapped sessionId
+            expect(remapped[0].sessionId).toBe(remapped[1].sessionId);
+            expect(remapped[1].sessionId).toBe(remapped[2].sessionId);
+            // Parent-child chain should be preserved
+            expect(remapped[1].parentUuid).toBe(remapped[0].uuid);
+            expect(remapped[2].parentUuid).toBe(remapped[1].uuid);
+        });
+        it('should handle null parentUuid correctly', () => {
+            const message = {
+                type: 'user',
+                uuid: 'root-uuid',
+                sessionId: 'session-123',
+                timestamp: '2024-01-01T00:00:00Z',
+                parentUuid: null, // Root message
+                message: { role: 'user', content: 'Root message' },
+                cwd: '/home/user/project',
+                version: '1.0.0',
+            };
+            const remapped = mapper.remapMessage(message);
+            // parentUuid should remain null
+            expect(remapped.parentUuid).toBeNull();
+            expect(remapped.uuid).not.toBe(message.uuid);
+            expect(remapped.sessionId).not.toBe(message.sessionId);
+        });
+    });
+});