claude-session-share 1.0.0

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

@@ -0,0 +1,298 @@
+/**
+ * Tests for session reading pipeline
+ *
+ * Validates JSONL parsing, error recovery, and metadata extraction.
+ */
+import { describe, it, expect } from 'vitest';
+import { parseSessionFile } from '../session/reader.js';
+import { extractMetadata } from '../session/metadata.js';
+import { writeFile, unlink } from 'fs/promises';
+import { join } from 'path';
+import { tmpdir } from 'os';
+describe('session-reader', () => {
+    describe('parseSessionFile', () => {
+        it('parses valid JSONL session file', async () => {
+            // Create minimal test fixture with 3 lines
+            const testData = [
+                {
+                    uuid: 'msg-1',
+                    sessionId: 'session-123',
+                    timestamp: '2026-01-11T10:00:00.000Z',
+                    parentUuid: null,
+                    type: 'user',
+                    message: { role: 'user', content: 'Hello' },
+                    cwd: '/Users/test/project',
+                    version: '1.0.0',
+                },
+                {
+                    uuid: 'msg-2',
+                    sessionId: 'session-123',
+                    timestamp: '2026-01-11T10:01:00.000Z',
+                    parentUuid: 'msg-1',
+                    type: 'assistant',
+                    messageId: 'assist-1',
+                    snapshot: { thinking: null, messages: [] },
+                },
+                {
+                    uuid: 'msg-3',
+                    sessionId: 'session-123',
+                    timestamp: '2026-01-11T10:02:00.000Z',
+                    parentUuid: 'msg-2',
+                    type: 'file-history-snapshot',
+                    isSnapshotUpdate: true,
+                    snapshot: { files: [] },
+                },
+            ];
+            // Write test JSONL file
+            const tmpFile = join(tmpdir(), `test-session-${Date.now()}.jsonl`);
+            const jsonlContent = testData.map(obj => JSON.stringify(obj)).join('\n');
+            await writeFile(tmpFile, jsonlContent, 'utf-8');
+            try {
+                // Parse the file
+                const messages = await parseSessionFile(tmpFile);
+                // Verify all messages parsed
+                expect(messages).toHaveLength(3);
+                expect(messages[0].type).toBe('user');
+                expect(messages[1].type).toBe('assistant');
+                expect(messages[2].type).toBe('file-history-snapshot');
+                expect(messages[0].uuid).toBe('msg-1');
+                expect(messages[0].sessionId).toBe('session-123');
+            }
+            finally {
+                // Cleanup
+                await unlink(tmpFile);
+            }
+        });
+        it('recovers from malformed JSON line and continues processing', async () => {
+            // Create JSONL with one malformed line
+            const lines = [
+                JSON.stringify({
+                    uuid: 'msg-1',
+                    sessionId: 'session-123',
+                    timestamp: '2026-01-11T10:00:00.000Z',
+                    parentUuid: null,
+                    type: 'user',
+                    message: { role: 'user', content: 'First' },
+                    cwd: '/test',
+                    version: '1.0.0',
+                }),
+                '{ invalid json here }', // Malformed line
+                JSON.stringify({
+                    uuid: 'msg-3',
+                    sessionId: 'session-123',
+                    timestamp: '2026-01-11T10:02:00.000Z',
+                    parentUuid: 'msg-1',
+                    type: 'user',
+                    message: { role: 'user', content: 'Third' },
+                    cwd: '/test',
+                    version: '1.0.0',
+                }),
+            ];
+            const tmpFile = join(tmpdir(), `test-error-recovery-${Date.now()}.jsonl`);
+            await writeFile(tmpFile, lines.join('\n'), 'utf-8');
+            try {
+                const messages = await parseSessionFile(tmpFile);
+                // Should have 2 messages (malformed line skipped)
+                expect(messages).toHaveLength(2);
+                expect(messages[0].uuid).toBe('msg-1');
+                expect(messages[1].uuid).toBe('msg-3');
+            }
+            finally {
+                await unlink(tmpFile);
+            }
+        });
+        it('skips empty lines without breaking parsing', async () => {
+            const lines = [
+                JSON.stringify({
+                    uuid: 'msg-1',
+                    sessionId: 'session-123',
+                    timestamp: '2026-01-11T10:00:00.000Z',
+                    parentUuid: null,
+                    type: 'user',
+                    message: { role: 'user', content: 'First' },
+                    cwd: '/test',
+                    version: '1.0.0',
+                }),
+                '', // Empty line
+                '   ', // Whitespace-only line
+                JSON.stringify({
+                    uuid: 'msg-2',
+                    sessionId: 'session-123',
+                    timestamp: '2026-01-11T10:01:00.000Z',
+                    parentUuid: 'msg-1',
+                    type: 'user',
+                    message: { role: 'user', content: 'Second' },
+                    cwd: '/test',
+                    version: '1.0.0',
+                }),
+            ];
+            const tmpFile = join(tmpdir(), `test-empty-lines-${Date.now()}.jsonl`);
+            await writeFile(tmpFile, lines.join('\n'), 'utf-8');
+            try {
+                const messages = await parseSessionFile(tmpFile);
+                // Should have 2 messages (empty lines skipped)
+                expect(messages).toHaveLength(2);
+                expect(messages[0].uuid).toBe('msg-1');
+                expect(messages[1].uuid).toBe('msg-2');
+            }
+            finally {
+                await unlink(tmpFile);
+            }
+        });
+        it('skips messages missing required fields', async () => {
+            const lines = [
+                JSON.stringify({
+                    uuid: 'msg-1',
+                    sessionId: 'session-123',
+                    timestamp: '2026-01-11T10:00:00.000Z',
+                    parentUuid: null,
+                    type: 'user',
+                    message: { role: 'user', content: 'Valid' },
+                    cwd: '/test',
+                    version: '1.0.0',
+                }),
+                JSON.stringify({
+                    // Missing uuid
+                    sessionId: 'session-123',
+                    timestamp: '2026-01-11T10:01:00.000Z',
+                    type: 'user',
+                }),
+                JSON.stringify({
+                    // Missing type
+                    uuid: 'msg-3',
+                    sessionId: 'session-123',
+                    timestamp: '2026-01-11T10:02:00.000Z',
+                }),
+                JSON.stringify({
+                    uuid: 'msg-4',
+                    sessionId: 'session-123',
+                    timestamp: '2026-01-11T10:03:00.000Z',
+                    parentUuid: 'msg-1',
+                    type: 'user',
+                    message: { role: 'user', content: 'Also valid' },
+                    cwd: '/test',
+                    version: '1.0.0',
+                }),
+            ];
+            const tmpFile = join(tmpdir(), `test-missing-fields-${Date.now()}.jsonl`);
+            await writeFile(tmpFile, lines.join('\n'), 'utf-8');
+            try {
+                const messages = await parseSessionFile(tmpFile);
+                // Should have 2 valid messages (2 with missing fields skipped)
+                expect(messages).toHaveLength(2);
+                expect(messages[0].uuid).toBe('msg-1');
+                expect(messages[1].uuid).toBe('msg-4');
+            }
+            finally {
+                await unlink(tmpFile);
+            }
+        });
+    });
+    describe('extractMetadata', () => {
+        it('extracts all fields correctly from valid messages', () => {
+            const messages = [
+                {
+                    uuid: 'msg-1',
+                    sessionId: 'session-abc',
+                    timestamp: '2026-01-11T10:00:00.000Z',
+                    parentUuid: null,
+                    type: 'user',
+                    message: { role: 'user', content: 'Hello' },
+                    cwd: '/Users/test/project',
+                    version: '1.2.3',
+                },
+                {
+                    uuid: 'msg-2',
+                    sessionId: 'session-abc',
+                    timestamp: '2026-01-11T10:05:00.000Z',
+                    parentUuid: 'msg-1',
+                    type: 'assistant',
+                    messageId: 'assist-1',
+                    snapshot: { thinking: null, messages: [] },
+                },
+            ];
+            const metadata = extractMetadata(messages);
+            expect(metadata).not.toBeNull();
+            expect(metadata?.sessionId).toBe('session-abc');
+            expect(metadata?.projectPath).toBe('/Users/test/project');
+            expect(metadata?.messageCount).toBe(2);
+            expect(metadata?.firstTimestamp).toBe('2026-01-11T10:00:00.000Z');
+            expect(metadata?.lastTimestamp).toBe('2026-01-11T10:05:00.000Z');
+            expect(metadata?.hasAgentConversations).toBe(false);
+            expect(metadata?.version).toBe('1.2.3');
+        });
+        it('detects agent conversations from isSidechain flag', () => {
+            const messages = [
+                {
+                    uuid: 'msg-1',
+                    sessionId: 'session-abc',
+                    timestamp: '2026-01-11T10:00:00.000Z',
+                    parentUuid: null,
+                    type: 'user',
+                    message: { role: 'user', content: 'Hello' },
+                    cwd: '/test',
+                    version: '1.0.0',
+                },
+                {
+                    uuid: 'msg-2',
+                    sessionId: 'session-abc',
+                    timestamp: '2026-01-11T10:01:00.000Z',
+                    parentUuid: 'msg-1',
+                    isSidechain: true, // Agent conversation marker
+                    type: 'assistant',
+                    messageId: 'assist-1',
+                    snapshot: { thinking: null, messages: [] },
+                },
+            ];
+            const metadata = extractMetadata(messages);
+            expect(metadata?.hasAgentConversations).toBe(true);
+        });
+        it('returns null for empty message array', () => {
+            const metadata = extractMetadata([]);
+            expect(metadata).toBeNull();
+        });
+        it('handles missing cwd and version with fallback', () => {
+            const messages = [
+                {
+                    uuid: 'msg-1',
+                    sessionId: 'session-abc',
+                    timestamp: '2026-01-11T10:00:00.000Z',
+                    parentUuid: null,
+                    type: 'assistant',
+                    messageId: 'assist-1',
+                    snapshot: { thinking: null, messages: [] },
+                },
+            ];
+            const metadata = extractMetadata(messages);
+            expect(metadata).not.toBeNull();
+            expect(metadata?.projectPath).toBe('unknown');
+            expect(metadata?.version).toBe('unknown');
+        });
+        it('finds user message even if not first message', () => {
+            const messages = [
+                {
+                    uuid: 'msg-1',
+                    sessionId: 'session-abc',
+                    timestamp: '2026-01-11T10:00:00.000Z',
+                    parentUuid: null,
+                    type: 'assistant',
+                    messageId: 'assist-1',
+                    snapshot: { thinking: null, messages: [] },
+                },
+                {
+                    uuid: 'msg-2',
+                    sessionId: 'session-abc',
+                    timestamp: '2026-01-11T10:01:00.000Z',
+                    parentUuid: 'msg-1',
+                    type: 'user',
+                    message: { role: 'user', content: 'Hello' },
+                    cwd: '/found/this/path',
+                    version: '2.0.0',
+                },
+            ];
+            const metadata = extractMetadata(messages);
+            expect(metadata?.projectPath).toBe('/found/this/path');
+            expect(metadata?.version).toBe('2.0.0');
+        });
+    });
+});

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

@@ -0,0 +1,216 @@
+/**
+ * Tests for session-to-gist upload service
+ *
+ * Verifies orchestration of:
+ * - Session reading
+ * - Privacy sanitization
+ * - JSONL formatting
+ * - Metadata extraction
+ * - Gist upload
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { uploadSession } from '../services/session-uploader.js';
+import * as reader from '../session/reader.js';
+import * as metadata from '../session/metadata.js';
+import * as pipeline from '../sanitization/pipeline.js';
+import * as gistClient from '../gist/client.js';
+describe('uploadSession', () => {
+    const mockSessionPath = '/test/session.jsonl';
+    const mockUserMessage = {
+        type: 'user',
+        uuid: 'user-1',
+        sessionId: 'test-session',
+        timestamp: '2026-01-12T10:00:00.000Z',
+        parentUuid: null,
+        message: { role: 'user', content: 'Hello' },
+        cwd: '/Users/test/project',
+        version: '1.0.0',
+    };
+    const mockAssistantMessage = {
+        type: 'assistant',
+        uuid: 'assistant-1',
+        sessionId: 'test-session',
+        timestamp: '2026-01-12T10:01:00.000Z',
+        parentUuid: 'user-1',
+        messageId: 'msg-1',
+        snapshot: {
+            thinking: 'Internal thinking',
+            messages: [{ role: 'assistant', content: 'Hi there!' }],
+        },
+    };
+    const mockMessages = [mockUserMessage, mockAssistantMessage];
+    const mockSanitizedMessages = [
+        { ...mockUserMessage, cwd: 'project' },
+        {
+            ...mockAssistantMessage,
+            snapshot: {
+                thinking: null,
+                messages: [{ role: 'assistant', content: 'Hi there!' }],
+            },
+        },
+    ];
+    const mockMetadata = {
+        sessionId: 'test-session',
+        projectPath: '/Users/test/project',
+        messageCount: 2,
+        firstTimestamp: '2026-01-12T10:00:00.000Z',
+        lastTimestamp: '2026-01-12T10:01:00.000Z',
+        hasAgentConversations: false,
+        version: '1.0.0',
+    };
+    const mockGistResponse = {
+        id: 'gist123',
+        url: 'https://api.github.com/gists/gist123',
+        html_url: 'https://gist.github.com/user/gist123',
+        files: {},
+        public: false,
+        created_at: '2026-01-12T10:00:00Z',
+        updated_at: '2026-01-12T10:00:00Z',
+        description: 'Test gist',
+    };
+    // Set up environment variable before tests
+    beforeEach(() => {
+        process.env.GITHUB_TOKEN = 'test_token';
+        vi.clearAllMocks();
+    });
+    // Helper to mock GistClient
+    function mockGistClient(createGistFn) {
+        vi.spyOn(gistClient, 'GistClient').mockImplementation(function () {
+            this.createGist = createGistFn;
+            this.getOctokit = vi.fn();
+            return this;
+        });
+    }
+    describe('successful upload', () => {
+        it('should orchestrate full upload pipeline and return gist URL', async () => {
+            // Mock all dependencies
+            const parseSessionFileSpy = vi.spyOn(reader, 'parseSessionFile').mockResolvedValue(mockMessages);
+            const inferBasePathSpy = vi.spyOn(pipeline, 'inferBasePath').mockReturnValue('/Users/test/project');
+            const sanitizeSessionSpy = vi.spyOn(pipeline, 'sanitizeSession').mockReturnValue(mockSanitizedMessages);
+            const extractMetadataSpy = vi.spyOn(metadata, 'extractMetadata').mockReturnValue(mockMetadata);
+            const mockCreateGist = vi.fn().mockResolvedValue(mockGistResponse);
+            mockGistClient(mockCreateGist);
+            // Execute
+            const result = await uploadSession(mockSessionPath);
+            // Verify correct call sequence
+            expect(parseSessionFileSpy).toHaveBeenCalledWith(mockSessionPath);
+            expect(inferBasePathSpy).toHaveBeenCalledWith(mockMessages);
+            expect(sanitizeSessionSpy).toHaveBeenCalledWith(mockMessages, '/Users/test/project');
+            expect(extractMetadataSpy).toHaveBeenCalledWith(mockSanitizedMessages);
+            expect(mockCreateGist).toHaveBeenCalled();
+            // Verify result
+            expect(result).toBe('https://gist.github.com/user/gist123');
+        });
+        it('should format JSONL correctly (one message per line)', async () => {
+            vi.spyOn(reader, 'parseSessionFile').mockResolvedValue(mockMessages);
+            vi.spyOn(pipeline, 'inferBasePath').mockReturnValue('/Users/test/project');
+            vi.spyOn(pipeline, 'sanitizeSession').mockReturnValue(mockSanitizedMessages);
+            vi.spyOn(metadata, 'extractMetadata').mockReturnValue(mockMetadata);
+            const mockCreateGist = vi.fn().mockResolvedValue(mockGistResponse);
+            mockGistClient(mockCreateGist);
+            await uploadSession(mockSessionPath);
+            // Verify JSONL format
+            const createGistCall = mockCreateGist.mock.calls[0];
+            const files = createGistCall[1];
+            const sessionJsonl = files['session.jsonl'];
+            // Should have one JSON object per line
+            const lines = sessionJsonl.split('\n');
+            expect(lines).toHaveLength(2);
+            // Each line should be valid JSON
+            const parsed1 = JSON.parse(lines[0]);
+            const parsed2 = JSON.parse(lines[1]);
+            expect(parsed1.type).toBe('user');
+            expect(parsed2.type).toBe('assistant');
+        });
+        it('should include metadata.json with correct structure', async () => {
+            vi.spyOn(reader, 'parseSessionFile').mockResolvedValue(mockMessages);
+            vi.spyOn(pipeline, 'inferBasePath').mockReturnValue('/Users/test/project');
+            vi.spyOn(pipeline, 'sanitizeSession').mockReturnValue(mockSanitizedMessages);
+            vi.spyOn(metadata, 'extractMetadata').mockReturnValue(mockMetadata);
+            const mockCreateGist = vi.fn().mockResolvedValue(mockGistResponse);
+            mockGistClient(mockCreateGist);
+            await uploadSession(mockSessionPath);
+            // Verify metadata file
+            const createGistCall = mockCreateGist.mock.calls[0];
+            const files = createGistCall[1];
+            const metadataJson = files['metadata.json'];
+            const parsedMetadata = JSON.parse(metadataJson);
+            expect(parsedMetadata).toEqual(mockMetadata);
+        });
+        it('should use project name in gist description when available', async () => {
+            vi.spyOn(reader, 'parseSessionFile').mockResolvedValue(mockMessages);
+            vi.spyOn(pipeline, 'inferBasePath').mockReturnValue('/Users/test/project');
+            vi.spyOn(pipeline, 'sanitizeSession').mockReturnValue(mockSanitizedMessages);
+            vi.spyOn(metadata, 'extractMetadata').mockReturnValue(mockMetadata);
+            const mockCreateGist = vi.fn().mockResolvedValue(mockGistResponse);
+            mockGistClient(mockCreateGist);
+            await uploadSession(mockSessionPath);
+            const createGistCall = mockCreateGist.mock.calls[0];
+            const description = createGistCall[0];
+            expect(description).toContain('project'); // Last path segment
+        });
+        it('should fallback to timestamp in description when no project path', async () => {
+            vi.spyOn(reader, 'parseSessionFile').mockResolvedValue(mockMessages);
+            vi.spyOn(pipeline, 'inferBasePath').mockReturnValue('');
+            vi.spyOn(pipeline, 'sanitizeSession').mockReturnValue(mockSanitizedMessages);
+            const metadataNoPath = { ...mockMetadata, projectPath: 'unknown' };
+            vi.spyOn(metadata, 'extractMetadata').mockReturnValue(metadataNoPath);
+            const mockCreateGist = vi.fn().mockResolvedValue(mockGistResponse);
+            mockGistClient(mockCreateGist);
+            await uploadSession(mockSessionPath);
+            const createGistCall = mockCreateGist.mock.calls[0];
+            const description = createGistCall[0];
+            expect(description).toContain('2026-01-12'); // Timestamp fallback
+        });
+    });
+    describe('error handling', () => {
+        it('should propagate error from parseSessionFile', async () => {
+            const parseError = new Error('File not found');
+            vi.spyOn(reader, 'parseSessionFile').mockRejectedValue(parseError);
+            await expect(uploadSession(mockSessionPath)).rejects.toThrow('Failed to upload session: File not found');
+        });
+        it('should throw error for empty session file', async () => {
+            vi.spyOn(reader, 'parseSessionFile').mockResolvedValue([]);
+            await expect(uploadSession(mockSessionPath)).rejects.toThrow('Session file is empty or contains no valid messages');
+        });
+        it('should propagate error from sanitizeSession', async () => {
+            vi.spyOn(reader, 'parseSessionFile').mockResolvedValue(mockMessages);
+            vi.spyOn(pipeline, 'inferBasePath').mockReturnValue('/Users/test/project');
+            vi.spyOn(pipeline, 'sanitizeSession').mockImplementation(() => {
+                throw new Error('Sanitization failed');
+            });
+            await expect(uploadSession(mockSessionPath)).rejects.toThrow('Failed to upload session: Sanitization failed');
+        });
+        it('should throw error when metadata extraction returns null', async () => {
+            vi.spyOn(reader, 'parseSessionFile').mockResolvedValue(mockMessages);
+            vi.spyOn(pipeline, 'inferBasePath').mockReturnValue('/Users/test/project');
+            vi.spyOn(pipeline, 'sanitizeSession').mockReturnValue(mockSanitizedMessages);
+            vi.spyOn(metadata, 'extractMetadata').mockReturnValue(null);
+            await expect(uploadSession(mockSessionPath)).rejects.toThrow('Failed to extract session metadata');
+        });
+        it('should propagate error from GistClient.createGist', async () => {
+            vi.spyOn(reader, 'parseSessionFile').mockResolvedValue(mockMessages);
+            vi.spyOn(pipeline, 'inferBasePath').mockReturnValue('/Users/test/project');
+            vi.spyOn(pipeline, 'sanitizeSession').mockReturnValue(mockSanitizedMessages);
+            vi.spyOn(metadata, 'extractMetadata').mockReturnValue(mockMetadata);
+            const gistError = new Error('GitHub API rate limit exceeded');
+            const mockCreateGist = vi.fn().mockRejectedValue(gistError);
+            mockGistClient(mockCreateGist);
+            await expect(uploadSession(mockSessionPath)).rejects.toThrow('Failed to upload session: GitHub API rate limit exceeded');
+        });
+    });
+    describe('immutability', () => {
+        it('should not modify original messages array', async () => {
+            const originalMessages = [...mockMessages];
+            vi.spyOn(reader, 'parseSessionFile').mockResolvedValue(mockMessages);
+            vi.spyOn(pipeline, 'inferBasePath').mockReturnValue('/Users/test/project');
+            vi.spyOn(pipeline, 'sanitizeSession').mockReturnValue(mockSanitizedMessages);
+            vi.spyOn(metadata, 'extractMetadata').mockReturnValue(mockMetadata);
+            const mockCreateGist = vi.fn().mockResolvedValue(mockGistResponse);
+            mockGistClient(mockCreateGist);
+            await uploadSession(mockSessionPath);
+            // Verify original not mutated
+            expect(mockMessages).toEqual(originalMessages);
+        });
+    });
+});