claude-session-share 1.0.0

package/dist/__tests__/sanitizer.test.js

@@ -0,0 +1,345 @@
+import { describe, it, expect } from 'vitest';
+import { sanitizeAssistantMessage, sanitizeUserMessage, sanitizeFileHistorySnapshot, } from '../sanitization/sanitizer.js';
+describe('sanitizeAssistantMessage', () => {
+    const basePath = '/Users/testuser/project';
+    it('should strip thinking block', () => {
+        const msg = {
+            type: 'assistant',
+            uuid: 'msg-1',
+            sessionId: 'session-1',
+            timestamp: '2026-01-11T12:00:00Z',
+            parentUuid: null,
+            messageId: 'msg-1',
+            snapshot: {
+                thinking: 'This is internal reasoning that should be removed',
+                messages: [{ role: 'assistant', content: 'Hello' }],
+            },
+        };
+        const sanitized = sanitizeAssistantMessage(msg, basePath);
+        expect(sanitized.snapshot.thinking).toBeNull();
+    });
+    it('should handle null thinking gracefully', () => {
+        const msg = {
+            type: 'assistant',
+            uuid: 'msg-1',
+            sessionId: 'session-1',
+            timestamp: '2026-01-11T12:00:00Z',
+            parentUuid: null,
+            messageId: 'msg-1',
+            snapshot: {
+                thinking: null,
+                messages: [{ role: 'assistant', content: 'Hello' }],
+            },
+        };
+        const sanitized = sanitizeAssistantMessage(msg, basePath);
+        expect(sanitized.snapshot.thinking).toBeNull();
+    });
+    it('should handle empty thinking string', () => {
+        const msg = {
+            type: 'assistant',
+            uuid: 'msg-1',
+            sessionId: 'session-1',
+            timestamp: '2026-01-11T12:00:00Z',
+            parentUuid: null,
+            messageId: 'msg-1',
+            snapshot: {
+                thinking: '',
+                messages: [{ role: 'assistant', content: 'Hello' }],
+            },
+        };
+        const sanitized = sanitizeAssistantMessage(msg, basePath);
+        expect(sanitized.snapshot.thinking).toBeNull();
+    });
+    it('should sanitize absolute paths in tool results', () => {
+        const msg = {
+            type: 'assistant',
+            uuid: 'msg-1',
+            sessionId: 'session-1',
+            timestamp: '2026-01-11T12:00:00Z',
+            parentUuid: null,
+            messageId: 'msg-1',
+            snapshot: {
+                thinking: null,
+                messages: [
+                    {
+                        role: 'assistant',
+                        content: 'File at /Users/testuser/project/src/index.ts',
+                    },
+                ],
+            },
+        };
+        const sanitized = sanitizeAssistantMessage(msg, basePath);
+        expect(sanitized.snapshot.messages[0].content).toContain('src/index.ts');
+        expect(sanitized.snapshot.messages[0].content).not.toContain('/Users/testuser/project/src');
+    });
+    it('should leave external paths unchanged', () => {
+        const msg = {
+            type: 'assistant',
+            uuid: 'msg-1',
+            sessionId: 'session-1',
+            timestamp: '2026-01-11T12:00:00Z',
+            parentUuid: null,
+            messageId: 'msg-1',
+            snapshot: {
+                thinking: null,
+                messages: [
+                    {
+                        role: 'assistant',
+                        content: 'External file at /opt/external/file.txt',
+                    },
+                ],
+            },
+        };
+        const sanitized = sanitizeAssistantMessage(msg, basePath);
+        expect(sanitized.snapshot.messages[0].content).toBe('External file at /opt/external/file.txt');
+    });
+    it('should handle multiple paths in same content', () => {
+        const msg = {
+            type: 'assistant',
+            uuid: 'msg-1',
+            sessionId: 'session-1',
+            timestamp: '2026-01-11T12:00:00Z',
+            parentUuid: null,
+            messageId: 'msg-1',
+            snapshot: {
+                thinking: null,
+                messages: [
+                    {
+                        role: 'assistant',
+                        content: 'Files: /Users/testuser/project/src/a.ts and /Users/testuser/project/src/b.ts',
+                    },
+                ],
+            },
+        };
+        const sanitized = sanitizeAssistantMessage(msg, basePath);
+        expect(sanitized.snapshot.messages[0].content).toContain('src/a.ts');
+        expect(sanitized.snapshot.messages[0].content).toContain('src/b.ts');
+        expect(sanitized.snapshot.messages[0].content).not.toContain('/Users/testuser/project');
+    });
+    it('should preserve original message (immutable)', () => {
+        const msg = {
+            type: 'assistant',
+            uuid: 'msg-1',
+            sessionId: 'session-1',
+            timestamp: '2026-01-11T12:00:00Z',
+            parentUuid: null,
+            messageId: 'msg-1',
+            snapshot: {
+                thinking: 'Original thinking',
+                messages: [{ role: 'assistant', content: 'Original content' }],
+            },
+        };
+        const sanitized = sanitizeAssistantMessage(msg, basePath);
+        expect(msg.snapshot.thinking).toBe('Original thinking');
+        expect(msg.snapshot.messages[0].content).toBe('Original content');
+        expect(sanitized.snapshot.thinking).toBeNull();
+    });
+    it('should handle empty messages array', () => {
+        const msg = {
+            type: 'assistant',
+            uuid: 'msg-1',
+            sessionId: 'session-1',
+            timestamp: '2026-01-11T12:00:00Z',
+            parentUuid: null,
+            messageId: 'msg-1',
+            snapshot: {
+                thinking: 'Thinking',
+                messages: [],
+            },
+        };
+        const sanitized = sanitizeAssistantMessage(msg, basePath);
+        expect(sanitized.snapshot.messages).toEqual([]);
+        expect(sanitized.snapshot.thinking).toBeNull();
+    });
+    it('should handle paths in JSON tool results', () => {
+        const msg = {
+            type: 'assistant',
+            uuid: 'msg-1',
+            sessionId: 'session-1',
+            timestamp: '2026-01-11T12:00:00Z',
+            parentUuid: null,
+            messageId: 'msg-1',
+            snapshot: {
+                thinking: null,
+                messages: [
+                    {
+                        role: 'tool',
+                        content: JSON.stringify({
+                            file_path: '/Users/testuser/project/src/index.ts',
+                            status: 'success',
+                        }),
+                    },
+                ],
+            },
+        };
+        const sanitized = sanitizeAssistantMessage(msg, basePath);
+        expect(sanitized.snapshot.messages[0].content).toContain('src/index.ts');
+        expect(sanitized.snapshot.messages[0].content).not.toContain('/Users/testuser/project/src');
+    });
+});
+describe('sanitizeUserMessage', () => {
+    const basePath = '/Users/testuser/project';
+    it('should sanitize absolute cwd to relative', () => {
+        const msg = {
+            type: 'user',
+            uuid: 'msg-1',
+            sessionId: 'session-1',
+            timestamp: '2026-01-11T12:00:00Z',
+            parentUuid: null,
+            message: { role: 'user', content: 'Hello' },
+            cwd: '/Users/testuser/project/src',
+            version: '1.0',
+        };
+        const sanitized = sanitizeUserMessage(msg, basePath);
+        expect(sanitized.cwd).toBe('src');
+    });
+    it('should handle cwd equal to basePath', () => {
+        const msg = {
+            type: 'user',
+            uuid: 'msg-1',
+            sessionId: 'session-1',
+            timestamp: '2026-01-11T12:00:00Z',
+            parentUuid: null,
+            message: { role: 'user', content: 'Hello' },
+            cwd: '/Users/testuser/project',
+            version: '1.0',
+        };
+        const sanitized = sanitizeUserMessage(msg, basePath);
+        expect(sanitized.cwd).toBe('.');
+    });
+    it('should leave external cwd unchanged', () => {
+        const msg = {
+            type: 'user',
+            uuid: 'msg-1',
+            sessionId: 'session-1',
+            timestamp: '2026-01-11T12:00:00Z',
+            parentUuid: null,
+            message: { role: 'user', content: 'Hello' },
+            cwd: '/opt/external',
+            version: '1.0',
+        };
+        const sanitized = sanitizeUserMessage(msg, basePath);
+        expect(sanitized.cwd).toBe('/opt/external');
+    });
+    it('should preserve original message (immutable)', () => {
+        const msg = {
+            type: 'user',
+            uuid: 'msg-1',
+            sessionId: 'session-1',
+            timestamp: '2026-01-11T12:00:00Z',
+            parentUuid: null,
+            message: { role: 'user', content: 'Hello' },
+            cwd: '/Users/testuser/project/src',
+            version: '1.0',
+        };
+        const sanitized = sanitizeUserMessage(msg, basePath);
+        expect(msg.cwd).toBe('/Users/testuser/project/src');
+        expect(sanitized.cwd).toBe('src');
+    });
+    it('should handle empty basePath', () => {
+        const msg = {
+            type: 'user',
+            uuid: 'msg-1',
+            sessionId: 'session-1',
+            timestamp: '2026-01-11T12:00:00Z',
+            parentUuid: null,
+            message: { role: 'user', content: 'Hello' },
+            cwd: '/Users/testuser/project',
+            version: '1.0',
+        };
+        const sanitized = sanitizeUserMessage(msg, '');
+        expect(sanitized.cwd).toBe('/Users/testuser/project');
+    });
+});
+describe('sanitizeFileHistorySnapshot', () => {
+    const basePath = '/Users/testuser/project';
+    it('should sanitize all file paths', () => {
+        const msg = {
+            type: 'file-history-snapshot',
+            uuid: 'msg-1',
+            sessionId: 'session-1',
+            timestamp: '2026-01-11T12:00:00Z',
+            parentUuid: null,
+            isSnapshotUpdate: false,
+            snapshot: {
+                files: [
+                    { path: '/Users/testuser/project/src/index.ts' },
+                    { path: '/Users/testuser/project/src/utils.ts' },
+                ],
+            },
+        };
+        const sanitized = sanitizeFileHistorySnapshot(msg, basePath);
+        expect(sanitized.snapshot.files[0].path).toBe('src/index.ts');
+        expect(sanitized.snapshot.files[1].path).toBe('src/utils.ts');
+    });
+    it('should handle empty files array', () => {
+        const msg = {
+            type: 'file-history-snapshot',
+            uuid: 'msg-1',
+            sessionId: 'session-1',
+            timestamp: '2026-01-11T12:00:00Z',
+            parentUuid: null,
+            isSnapshotUpdate: false,
+            snapshot: {
+                files: [],
+            },
+        };
+        const sanitized = sanitizeFileHistorySnapshot(msg, basePath);
+        expect(sanitized.snapshot.files).toEqual([]);
+    });
+    it('should leave external paths unchanged', () => {
+        const msg = {
+            type: 'file-history-snapshot',
+            uuid: 'msg-1',
+            sessionId: 'session-1',
+            timestamp: '2026-01-11T12:00:00Z',
+            parentUuid: null,
+            isSnapshotUpdate: false,
+            snapshot: {
+                files: [
+                    { path: '/Users/testuser/project/src/index.ts' },
+                    { path: '/opt/external/lib.ts' },
+                ],
+            },
+        };
+        const sanitized = sanitizeFileHistorySnapshot(msg, basePath);
+        expect(sanitized.snapshot.files[0].path).toBe('src/index.ts');
+        expect(sanitized.snapshot.files[1].path).toBe('/opt/external/lib.ts');
+    });
+    it('should preserve original message (immutable)', () => {
+        const msg = {
+            type: 'file-history-snapshot',
+            uuid: 'msg-1',
+            sessionId: 'session-1',
+            timestamp: '2026-01-11T12:00:00Z',
+            parentUuid: null,
+            isSnapshotUpdate: false,
+            snapshot: {
+                files: [{ path: '/Users/testuser/project/src/index.ts' }],
+            },
+        };
+        const sanitized = sanitizeFileHistorySnapshot(msg, basePath);
+        expect(msg.snapshot.files[0].path).toBe('/Users/testuser/project/src/index.ts');
+        expect(sanitized.snapshot.files[0].path).toBe('src/index.ts');
+    });
+    it('should handle mix of relative and absolute paths', () => {
+        const msg = {
+            type: 'file-history-snapshot',
+            uuid: 'msg-1',
+            sessionId: 'session-1',
+            timestamp: '2026-01-11T12:00:00Z',
+            parentUuid: null,
+            isSnapshotUpdate: false,
+            snapshot: {
+                files: [
+                    { path: '/Users/testuser/project/src/index.ts' },
+                    { path: 'src/already-relative.ts' },
+                ],
+            },
+        };
+        const sanitized = sanitizeFileHistorySnapshot(msg, basePath);
+        expect(sanitized.snapshot.files[0].path).toBe('src/index.ts');
+        // Already relative path should remain unchanged
+        expect(sanitized.snapshot.files[1].path).toBe('src/already-relative.ts');
+    });
+});

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

@@ -0,0 +1,216 @@
+/**
+ * Tests for session import service
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { importSession } from '../services/session-importer.js';
+import * as gistClient from '../gist/client.js';
+import * as sessionWriter from '../session/writer.js';
+describe('importSession', () => {
+    const mockGist = {
+        id: 'abc123',
+        url: 'https://api.github.com/gists/abc123',
+        html_url: 'https://gist.github.com/user/abc123',
+        files: {
+            'session.jsonl': {
+                filename: 'session.jsonl',
+                type: 'text/plain',
+                language: 'JSON',
+                raw_url: 'https://gist.githubusercontent.com/user/abc123/raw/session.jsonl',
+                size: 100,
+                content: '{"type":"user","uuid":"uuid1","sessionId":"session1","parentUuid":null,"message":"Hello","timestamp":"2024-01-01T00:00:00Z"}\n' +
+                    '{"type":"assistant","uuid":"uuid2","sessionId":"session1","parentUuid":"uuid1","message":"Hi","timestamp":"2024-01-01T00:00:01Z"}',
+            },
+            'metadata.json': {
+                filename: 'metadata.json',
+                type: 'text/plain',
+                language: 'JSON',
+                raw_url: 'https://gist.githubusercontent.com/user/abc123/raw/metadata.json',
+                size: 30,
+                content: '{"title":"Test Session"}',
+            },
+        },
+        public: false,
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z',
+        description: 'Test Gist',
+    };
+    beforeEach(() => {
+        process.env.GITHUB_TOKEN = 'test_token';
+        vi.clearAllMocks();
+    });
+    // Helper to mock GistClient
+    function mockGistClient(fetchGistFn) {
+        vi.spyOn(gistClient, 'GistClient').mockImplementation(function () {
+            this.fetchGist = fetchGistFn;
+            this.createGist = vi.fn();
+            this.getOctokit = vi.fn();
+            return this;
+        });
+    }
+    describe('successful import', () => {
+        it('should orchestrate full import pipeline', async () => {
+            const mockFetchGist = vi.fn().mockResolvedValue(mockGist);
+            mockGistClient(mockFetchGist);
+            const mockWriteSession = vi.spyOn(sessionWriter, 'writeSessionToLocal').mockResolvedValue({
+                filePath: '/Users/test/.claude/projects/encoded/session-id.jsonl',
+                sessionId: 'new-session-id',
+            });
+            const result = await importSession('https://gist.github.com/user/abc123', '/Users/test/project');
+            expect(result).toEqual({
+                sessionPath: '/Users/test/.claude/projects/encoded/session-id.jsonl',
+                sessionId: 'new-session-id',
+                messageCount: 2,
+                projectPath: '/Users/test/project',
+            });
+            // Verify fetchGist was called with correct URL
+            expect(mockFetchGist).toHaveBeenCalledWith('https://gist.github.com/user/abc123');
+            // Verify writeSessionToLocal was called
+            expect(mockWriteSession).toHaveBeenCalledWith(expect.any(Array), '/Users/test/project');
+            // Verify messages were remapped (UUIDs should be different)
+            const writtenMessages = mockWriteSession.mock.calls[0][0];
+            expect(writtenMessages).toHaveLength(2);
+            expect(writtenMessages[0].uuid).not.toBe('uuid1');
+            expect(writtenMessages[1].uuid).not.toBe('uuid2');
+            expect(writtenMessages[0].sessionId).not.toBe('session1');
+            expect(writtenMessages[1].sessionId).not.toBe('session1');
+        });
+        it('should extract JSONL file from gist', async () => {
+            const mockFetchGist = vi.fn().mockResolvedValue(mockGist);
+            mockGistClient(mockFetchGist);
+            const mockWriteSession = vi.spyOn(sessionWriter, 'writeSessionToLocal').mockResolvedValue({
+                filePath: '/Users/test/.claude/projects/encoded/session-id.jsonl',
+                sessionId: 'new-session-id',
+            });
+            await importSession('abc123', '/Users/test/project');
+            // Verify writeSessionToLocal received parsed messages
+            const writtenMessages = mockWriteSession.mock.calls[0][0];
+            expect(writtenMessages).toHaveLength(2);
+            expect(writtenMessages[0].type).toBe('user');
+            // User messages have 'message' field with role/content
+            expect(writtenMessages[1].type).toBe('assistant');
+        });
+        it('should remap UUIDs consistently', async () => {
+            const mockFetchGist = vi.fn().mockResolvedValue(mockGist);
+            mockGistClient(mockFetchGist);
+            const mockWriteSession = vi.spyOn(sessionWriter, 'writeSessionToLocal').mockResolvedValue({
+                filePath: '/Users/test/.claude/projects/encoded/session-id.jsonl',
+                sessionId: 'new-session-id',
+            });
+            await importSession('abc123', '/Users/test/project');
+            const writtenMessages = mockWriteSession.mock.calls[0][0];
+            // First message parent should be remapped consistently
+            expect(writtenMessages[0].parentUuid).toBeNull();
+            // Second message parent should reference first message's remapped UUID
+            expect(writtenMessages[1].parentUuid).toBe(writtenMessages[0].uuid);
+            // Session IDs should be consistently remapped
+            expect(writtenMessages[0].sessionId).toBe(writtenMessages[1].sessionId);
+        });
+        it('should handle bare gist ID (not URL)', async () => {
+            const mockFetchGist = vi.fn().mockResolvedValue(mockGist);
+            mockGistClient(mockFetchGist);
+            vi.spyOn(sessionWriter, 'writeSessionToLocal').mockResolvedValue({
+                filePath: '/Users/test/.claude/projects/encoded/session-id.jsonl',
+                sessionId: 'new-session-id',
+            });
+            await importSession('abc123', '/Users/test/project');
+            expect(mockFetchGist).toHaveBeenCalledWith('abc123');
+        });
+    });
+    describe('error handling', () => {
+        it('should throw error if no JSONL file in gist', async () => {
+            const gistWithoutJsonl = {
+                ...mockGist,
+                files: {
+                    'metadata.json': {
+                        filename: 'metadata.json',
+                        type: 'text/plain',
+                        language: 'JSON',
+                        raw_url: 'https://gist.githubusercontent.com/user/abc123/raw/metadata.json',
+                        size: 20,
+                        content: '{"title":"Test"}',
+                    },
+                },
+            };
+            const mockFetchGist = vi.fn().mockResolvedValue(gistWithoutJsonl);
+            mockGistClient(mockFetchGist);
+            await expect(importSession('abc123', '/Users/test/project')).rejects.toThrow('No JSONL file found in gist. Expected a .jsonl file containing session messages.');
+        });
+        it('should throw error if JSONL file has no content', async () => {
+            const gistWithEmptyJsonl = {
+                ...mockGist,
+                files: {
+                    'session.jsonl': {
+                        filename: 'session.jsonl',
+                        type: 'text/plain',
+                        language: 'JSON',
+                        raw_url: 'https://gist.githubusercontent.com/user/abc123/raw/session.jsonl',
+                        size: 0,
+                        content: '',
+                    },
+                },
+            };
+            const mockFetchGist = vi.fn().mockResolvedValue(gistWithEmptyJsonl);
+            mockGistClient(mockFetchGist);
+            await expect(importSession('abc123', '/Users/test/project')).rejects.toThrow('JSONL file "session.jsonl" has no content');
+        });
+        it('should handle gist not found (404)', async () => {
+            const notFoundError = new Error('Gist not found');
+            notFoundError.status = 404;
+            const mockFetchGist = vi.fn().mockRejectedValue(notFoundError);
+            mockGistClient(mockFetchGist);
+            await expect(importSession('nonexistent', '/Users/test/project')).rejects.toThrow('Failed to import session: Gist not found');
+        });
+        it('should recover from parse errors on individual lines', async () => {
+            const gistWithBadLines = {
+                ...mockGist,
+                files: {
+                    'session.jsonl': {
+                        filename: 'session.jsonl',
+                        type: 'text/plain',
+                        language: 'JSON',
+                        raw_url: 'https://gist.githubusercontent.com/user/abc123/raw/session.jsonl',
+                        size: 150,
+                        content: '{"type":"user","uuid":"uuid1","sessionId":"session1","parentUuid":null,"message":"Hello","timestamp":"2024-01-01T00:00:00Z"}\n' +
+                            'invalid json line\n' +
+                            '{"type":"assistant","uuid":"uuid2","sessionId":"session1","parentUuid":"uuid1","message":"Hi","timestamp":"2024-01-01T00:00:01Z"}',
+                    },
+                },
+            };
+            const mockFetchGist = vi.fn().mockResolvedValue(gistWithBadLines);
+            mockGistClient(mockFetchGist);
+            const mockWriteSession = vi.spyOn(sessionWriter, 'writeSessionToLocal').mockResolvedValue({
+                filePath: '/Users/test/.claude/projects/encoded/session-id.jsonl',
+                sessionId: 'new-session-id',
+            });
+            const result = await importSession('abc123', '/Users/test/project');
+            // Should import 2 valid messages despite parse error
+            expect(result.messageCount).toBe(2);
+            const writtenMessages = mockWriteSession.mock.calls[0][0];
+            expect(writtenMessages).toHaveLength(2);
+        });
+        it('should throw error if all lines fail to parse', async () => {
+            const gistWithAllBadLines = {
+                ...mockGist,
+                files: {
+                    'session.jsonl': {
+                        filename: 'session.jsonl',
+                        type: 'text/plain',
+                        language: 'JSON',
+                        raw_url: 'https://gist.githubusercontent.com/user/abc123/raw/session.jsonl',
+                        size: 40,
+                        content: 'invalid json\n{bad syntax\nmore bad json',
+                    },
+                },
+            };
+            const mockFetchGist = vi.fn().mockResolvedValue(gistWithAllBadLines);
+            mockGistClient(mockFetchGist);
+            await expect(importSession('abc123', '/Users/test/project')).rejects.toThrow('No valid messages found in JSONL file');
+        });
+        it('should propagate write errors', async () => {
+            const mockFetchGist = vi.fn().mockResolvedValue(mockGist);
+            mockGistClient(mockFetchGist);
+            vi.spyOn(sessionWriter, 'writeSessionToLocal').mockRejectedValue(new Error('Permission denied'));
+            await expect(importSession('abc123', '/Users/test/project')).rejects.toThrow('Failed to import session: Permission denied');
+        });
+    });
+});