claude-session-share 1.0.0

package/dist/__tests__/pipeline.test.js

@@ -0,0 +1,342 @@
+import { describe, it, expect } from 'vitest';
+import { sanitizeSession, inferBasePath } from '../sanitization/pipeline.js';
+describe('sanitizeSession', () => {
+    const basePath = '/Users/testuser/project';
+    it('should sanitize full session with all message types', () => {
+        const messages = [
+            {
+                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',
+            },
+            {
+                type: 'assistant',
+                uuid: 'msg-2',
+                sessionId: 'session-1',
+                timestamp: '2026-01-11T12:00:01Z',
+                parentUuid: 'msg-1',
+                messageId: 'msg-2',
+                snapshot: {
+                    thinking: 'Internal reasoning',
+                    messages: [
+                        {
+                            role: 'assistant',
+                            content: 'File at /Users/testuser/project/src/index.ts with api_key="secret123456"',
+                        },
+                    ],
+                },
+            },
+            {
+                type: 'file-history-snapshot',
+                uuid: 'msg-3',
+                sessionId: 'session-1',
+                timestamp: '2026-01-11T12:00:02Z',
+                parentUuid: 'msg-2',
+                isSnapshotUpdate: false,
+                snapshot: {
+                    files: [{ path: '/Users/testuser/project/src/utils.ts' }],
+                },
+            },
+        ];
+        const sanitized = sanitizeSession(messages, basePath);
+        // Verify thinking stripped
+        expect(sanitized[1].snapshot.thinking).toBeNull();
+        // Verify cwd sanitized
+        expect(sanitized[0].cwd).toBe('src');
+        // Verify file paths sanitized
+        expect(sanitized[2].snapshot.files[0].path).toBe('src/utils.ts');
+        // Verify secret redacted
+        expect(sanitized[1].snapshot.messages[0].content).toContain('[REDACTED]');
+        expect(sanitized[1].snapshot.messages[0].content).not.toContain('secret123456');
+        // Verify path in content sanitized
+        expect(sanitized[1].snapshot.messages[0].content).toContain('src/index.ts');
+        expect(sanitized[1].snapshot.messages[0].content).not.toContain('/Users/testuser/project/src/index.ts');
+    });
+    it('should handle empty session', () => {
+        const messages = [];
+        const sanitized = sanitizeSession(messages, basePath);
+        expect(sanitized).toEqual([]);
+    });
+    it('should handle session with only user messages', () => {
+        const messages = [
+            {
+                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',
+            },
+            {
+                type: 'user',
+                uuid: 'msg-2',
+                sessionId: 'session-1',
+                timestamp: '2026-01-11T12:00:01Z',
+                parentUuid: 'msg-1',
+                message: { role: 'user', content: 'Another message' },
+                cwd: '/Users/testuser/project/src',
+                version: '1.0',
+            },
+        ];
+        const sanitized = sanitizeSession(messages, basePath);
+        expect(sanitized[0].cwd).toBe('.');
+        expect(sanitized[1].cwd).toBe('src');
+    });
+    it('should handle session with only assistant messages', () => {
+        const messages = [
+            {
+                type: 'assistant',
+                uuid: 'msg-1',
+                sessionId: 'session-1',
+                timestamp: '2026-01-11T12:00:00Z',
+                parentUuid: null,
+                messageId: 'msg-1',
+                snapshot: {
+                    thinking: 'Thinking 1',
+                    messages: [{ role: 'assistant', content: 'Response 1' }],
+                },
+            },
+            {
+                type: 'assistant',
+                uuid: 'msg-2',
+                sessionId: 'session-1',
+                timestamp: '2026-01-11T12:00:01Z',
+                parentUuid: 'msg-1',
+                messageId: 'msg-2',
+                snapshot: {
+                    thinking: 'Thinking 2',
+                    messages: [{ role: 'assistant', content: 'Response 2' }],
+                },
+            },
+        ];
+        const sanitized = sanitizeSession(messages, basePath);
+        expect(sanitized[0].snapshot.thinking).toBeNull();
+        expect(sanitized[1].snapshot.thinking).toBeNull();
+    });
+    it('should preserve message order', () => {
+        const messages = [
+            {
+                type: 'user',
+                uuid: 'msg-1',
+                sessionId: 'session-1',
+                timestamp: '2026-01-11T12:00:00Z',
+                parentUuid: null,
+                message: { role: 'user', content: 'First' },
+                cwd: '/Users/testuser/project',
+                version: '1.0',
+            },
+            {
+                type: 'assistant',
+                uuid: 'msg-2',
+                sessionId: 'session-1',
+                timestamp: '2026-01-11T12:00:01Z',
+                parentUuid: 'msg-1',
+                messageId: 'msg-2',
+                snapshot: { thinking: null, messages: [{ role: 'assistant', content: 'Second' }] },
+            },
+            {
+                type: 'user',
+                uuid: 'msg-3',
+                sessionId: 'session-1',
+                timestamp: '2026-01-11T12:00:02Z',
+                parentUuid: 'msg-2',
+                message: { role: 'user', content: 'Third' },
+                cwd: '/Users/testuser/project',
+                version: '1.0',
+            },
+        ];
+        const sanitized = sanitizeSession(messages, basePath);
+        expect(sanitized[0].type).toBe('user');
+        expect(sanitized[1].type).toBe('assistant');
+        expect(sanitized[2].type).toBe('user');
+        expect(sanitized[0].message.content).toBe('First');
+        expect(sanitized[1].snapshot.messages[0].content).toBe('Second');
+        expect(sanitized[2].message.content).toBe('Third');
+    });
+    it('should be immutable (preserve original messages)', () => {
+        const messages = [
+            {
+                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 = sanitizeSession(messages, basePath);
+        // Original unchanged
+        expect(messages[0].snapshot.thinking).toBe('Original thinking');
+        expect(messages[0].snapshot.messages[0].content).toBe('Original content');
+        // Sanitized changed
+        expect(sanitized[0].snapshot.thinking).toBeNull();
+    });
+    it('should handle realistic session snippet', () => {
+        // Fixture: Small realistic session with thinking, paths, and secrets
+        const messages = [
+            {
+                type: 'user',
+                uuid: 'user-1',
+                sessionId: 'session-abc',
+                timestamp: '2026-01-11T14:30:00Z',
+                parentUuid: null,
+                message: { role: 'user', content: 'Create an API endpoint' },
+                cwd: '/Users/testuser/project',
+                version: '1.0',
+            },
+            {
+                type: 'assistant',
+                uuid: 'asst-1',
+                sessionId: 'session-abc',
+                timestamp: '2026-01-11T14:30:05Z',
+                parentUuid: 'user-1',
+                messageId: 'asst-1',
+                snapshot: {
+                    thinking: 'User wants an API endpoint. I should create a REST endpoint with proper validation.',
+                    messages: [
+                        {
+                            role: 'assistant',
+                            content: 'I will create the endpoint at /Users/testuser/project/src/api/users.ts',
+                        },
+                        {
+                            role: 'tool',
+                            content: JSON.stringify({
+                                file_path: '/Users/testuser/project/src/api/users.ts',
+                                api_key: 'sk-1234567890abcdef',
+                                status: 'created',
+                            }),
+                        },
+                    ],
+                },
+            },
+            {
+                type: 'file-history-snapshot',
+                uuid: 'snapshot-1',
+                sessionId: 'session-abc',
+                timestamp: '2026-01-11T14:30:06Z',
+                parentUuid: 'asst-1',
+                isSnapshotUpdate: true,
+                snapshot: {
+                    files: [
+                        { path: '/Users/testuser/project/src/api/users.ts' },
+                        { path: '/Users/testuser/project/src/types.ts' },
+                    ],
+                },
+            },
+        ];
+        const sanitized = sanitizeSession(messages, basePath);
+        // User message: cwd sanitized
+        expect(sanitized[0].cwd).toBe('.');
+        // Assistant message: thinking stripped, paths sanitized, secrets redacted
+        const assistantMsg = sanitized[1];
+        expect(assistantMsg.snapshot.thinking).toBeNull();
+        expect(assistantMsg.snapshot.messages[0].content).toContain('src/api/users.ts');
+        expect(assistantMsg.snapshot.messages[0].content).not.toContain('/Users/testuser/project/src');
+        expect(assistantMsg.snapshot.messages[1].content).toContain('[REDACTED]');
+        expect(assistantMsg.snapshot.messages[1].content).not.toContain('sk-1234567890abcdef');
+        // File snapshot: paths sanitized
+        const snapshotMsg = sanitized[2];
+        expect(snapshotMsg.snapshot.files[0].path).toBe('src/api/users.ts');
+        expect(snapshotMsg.snapshot.files[1].path).toBe('src/types.ts');
+    });
+});
+describe('inferBasePath', () => {
+    it('should extract base path from first user message', () => {
+        const messages = [
+            {
+                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 basePath = inferBasePath(messages);
+        expect(basePath).toBe('/Users/testuser/project');
+    });
+    it('should return empty string if no user messages', () => {
+        const messages = [
+            {
+                type: 'assistant',
+                uuid: 'msg-1',
+                sessionId: 'session-1',
+                timestamp: '2026-01-11T12:00:00Z',
+                parentUuid: null,
+                messageId: 'msg-1',
+                snapshot: { thinking: null, messages: [] },
+            },
+        ];
+        const basePath = inferBasePath(messages);
+        expect(basePath).toBe('');
+    });
+    it('should return empty string for empty session', () => {
+        const messages = [];
+        const basePath = inferBasePath(messages);
+        expect(basePath).toBe('');
+    });
+    it('should use first user message even if multiple exist', () => {
+        const messages = [
+            {
+                type: 'user',
+                uuid: 'msg-1',
+                sessionId: 'session-1',
+                timestamp: '2026-01-11T12:00:00Z',
+                parentUuid: null,
+                message: { role: 'user', content: 'First' },
+                cwd: '/Users/testuser/project',
+                version: '1.0',
+            },
+            {
+                type: 'user',
+                uuid: 'msg-2',
+                sessionId: 'session-1',
+                timestamp: '2026-01-11T12:00:01Z',
+                parentUuid: 'msg-1',
+                message: { role: 'user', content: 'Second' },
+                cwd: '/Users/testuser/different',
+                version: '1.0',
+            },
+        ];
+        const basePath = inferBasePath(messages);
+        expect(basePath).toBe('/Users/testuser/project');
+    });
+    it('should skip non-user messages when finding cwd', () => {
+        const messages = [
+            {
+                type: 'assistant',
+                uuid: 'msg-1',
+                sessionId: 'session-1',
+                timestamp: '2026-01-11T12:00:00Z',
+                parentUuid: null,
+                messageId: 'msg-1',
+                snapshot: { thinking: null, messages: [] },
+            },
+            {
+                type: 'user',
+                uuid: 'msg-2',
+                sessionId: 'session-1',
+                timestamp: '2026-01-11T12:00:01Z',
+                parentUuid: 'msg-1',
+                message: { role: 'user', content: 'Hello' },
+                cwd: '/Users/testuser/project',
+                version: '1.0',
+            },
+        ];
+        const basePath = inferBasePath(messages);
+        expect(basePath).toBe('/Users/testuser/project');
+    });
+});

package/dist/__tests__/redactor.test.js

@@ -0,0 +1,162 @@
+import { describe, it, expect } from 'vitest';
+import { redactSecrets } from '../sanitization/redactor.js';
+describe('redactSecrets', () => {
+    describe('API keys in JSON notation', () => {
+        it('should redact api_key in JSON', () => {
+            const input = '{"api_key": "sk-1234567890abcdef"}';
+            const result = redactSecrets(input);
+            expect(result).toBe('{"api_key": "[REDACTED]"}');
+        });
+        it('should redact apiKey in JSON', () => {
+            const input = '{"apiKey": "abc123def456xyz789"}';
+            const result = redactSecrets(input);
+            expect(result).toBe('{"apiKey": "[REDACTED]"}');
+        });
+        it('should redact API_KEY in JSON', () => {
+            const input = '{"API_KEY": "secret123456"}';
+            const result = redactSecrets(input);
+            expect(result).toBe('{"API_KEY": "[REDACTED]"}');
+        });
+        it('should redact access_token', () => {
+            const input = '{"access_token": "token123456789"}';
+            const result = redactSecrets(input);
+            expect(result).toBe('{"access_token": "[REDACTED]"}');
+        });
+        it('should redact bearer_token', () => {
+            const input = '{"bearer_token": "bearer123456789"}';
+            const result = redactSecrets(input);
+            expect(result).toBe('{"bearer_token": "[REDACTED]"}');
+        });
+        it('should redact secret_key', () => {
+            const input = '{"secret_key": "secret123456"}';
+            const result = redactSecrets(input);
+            expect(result).toBe('{"secret_key": "[REDACTED]"}');
+        });
+    });
+    describe('Environment variable format', () => {
+        it('should redact API_KEY=value', () => {
+            const input = 'API_KEY=abc123def456';
+            const result = redactSecrets(input);
+            expect(result).toBe('API_KEY=[REDACTED]');
+        });
+        it('should redact SECRET_TOKEN=value', () => {
+            const input = 'SECRET_TOKEN=xyz789abc123';
+            const result = redactSecrets(input);
+            expect(result).toBe('SECRET_TOKEN=[REDACTED]');
+        });
+        it('should redact multiple env vars', () => {
+            const input = 'API_KEY=abc123def456\nSECRET_PASSWORD=xyz789abc123';
+            const result = redactSecrets(input);
+            expect(result).toContain('API_KEY=[REDACTED]');
+            expect(result).toContain('SECRET_PASSWORD=[REDACTED]');
+        });
+    });
+    describe('GitHub tokens', () => {
+        it('should redact ghp_ tokens', () => {
+            const input = 'token: ghp_1234567890abcdefghijklmnopqrstuvwxyz';
+            const result = redactSecrets(input);
+            expect(result).toBe('token: [REDACTED]');
+        });
+        it('should redact ghs_ tokens', () => {
+            const input = 'token: ghs_1234567890abcdefghijklmnopqrstuvwxyz';
+            const result = redactSecrets(input);
+            expect(result).toBe('token: [REDACTED]');
+        });
+        it('should redact github_pat_ tokens', () => {
+            const input = 'token: github_pat_1234567890abcdefghijklmnopqrstuvwxyz';
+            const result = redactSecrets(input);
+            expect(result).toBe('token: [REDACTED]');
+        });
+    });
+    describe('AWS credentials', () => {
+        it('should redact AWS access keys', () => {
+            const input = 'AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE';
+            const result = redactSecrets(input);
+            expect(result).toContain('[REDACTED]');
+        });
+        it('should redact aws_secret_access_key', () => {
+            const input = 'aws_secret_access_key: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY';
+            const result = redactSecrets(input);
+            expect(result).toContain('[REDACTED]');
+        });
+    });
+    describe('Generic long strings', () => {
+        it('should redact base64-like strings', () => {
+            const input = 'token=SGVsbG9Xb3JsZFRoaXNJc0FMb25nQmFzZTY0U3RyaW5n';
+            const result = redactSecrets(input);
+            expect(result).toBe('token=[REDACTED]');
+        });
+        it('should not redact short strings', () => {
+            const input = 'token=short123';
+            const result = redactSecrets(input);
+            // Short values might still be caught by other patterns, but generic pattern should not
+            expect(result).toContain('short123');
+        });
+        it('should not redact file paths', () => {
+            const input = 'path=/usr/local/bin/node/lib/modules/core';
+            const result = redactSecrets(input);
+            expect(result).toContain('/usr/local/bin');
+        });
+    });
+    describe('Private keys', () => {
+        it('should redact RSA private keys', () => {
+            const input = `-----BEGIN RSA PRIVATE KEY-----
+MIIEowIBAAKCAQEA123456789
+-----END RSA PRIVATE KEY-----`;
+            const result = redactSecrets(input);
+            expect(result).toBe('[REDACTED PRIVATE KEY]');
+        });
+        it('should redact generic private keys', () => {
+            const input = `-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEF
+-----END PRIVATE KEY-----`;
+            const result = redactSecrets(input);
+            expect(result).toBe('[REDACTED PRIVATE KEY]');
+        });
+    });
+    describe('Mixed content', () => {
+        it('should redact secrets while preserving other text', () => {
+            const input = 'Response from API: {"api_key": "secret123456", "status": "success"}';
+            const result = redactSecrets(input);
+            expect(result).toContain('[REDACTED]');
+            expect(result).toContain('status');
+            expect(result).toContain('success');
+            expect(result).not.toContain('secret123456');
+        });
+        it('should handle multiple secret types in one string', () => {
+            const input = `Config:
+API_KEY=abc123def456
+token: ghp_1234567890abcdefghijklmnopqrstuvwxyz
+AWS: AKIAIOSFODNN7EXAMPLE`;
+            const result = redactSecrets(input);
+            expect(result).toContain('API_KEY=[REDACTED]');
+            expect(result).toContain('token: [REDACTED]');
+            expect(result).toContain('[REDACTED]'); // AWS key
+            expect(result).not.toContain('abc123def456');
+            expect(result).not.toContain('ghp_123');
+        });
+    });
+    describe('Edge cases', () => {
+        it('should handle empty string', () => {
+            const result = redactSecrets('');
+            expect(result).toBe('');
+        });
+        it('should handle content with no secrets', () => {
+            const input = 'This is just normal text with no secrets';
+            const result = redactSecrets(input);
+            expect(result).toBe(input);
+        });
+        it('should handle null/undefined values gracefully', () => {
+            expect(redactSecrets('')).toBe('');
+        });
+        it('should preserve structure when redacting', () => {
+            const input = '{"apiKey": "secret123456", "userId": 42, "name": "test"}';
+            const result = redactSecrets(input);
+            expect(result).toContain('userId');
+            expect(result).toContain('42');
+            expect(result).toContain('name');
+            expect(result).toContain('test');
+            expect(result).not.toContain('secret123456');
+        });
+    });
+});