claude-session-share 1.0.0

package/dist/__tests__/gist-client.test.js

@@ -0,0 +1,341 @@
+/**
+ * Tests for GitHub Gist client authentication and initialization
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { GistClient, GistAuthError, GistApiError } from '../gist/client.js';
+describe('GistClient', () => {
+    let originalToken;
+    beforeEach(() => {
+        // Save original token
+        originalToken = process.env.GITHUB_TOKEN;
+    });
+    afterEach(() => {
+        // Restore original token
+        if (originalToken) {
+            process.env.GITHUB_TOKEN = originalToken;
+        }
+        else {
+            delete process.env.GITHUB_TOKEN;
+        }
+    });
+    describe('initialization', () => {
+        it('should initialize successfully with valid GITHUB_TOKEN', () => {
+            process.env.GITHUB_TOKEN = 'ghp_test_token_1234567890';
+            expect(() => new GistClient()).not.toThrow();
+        });
+        it('should throw GistAuthError when GITHUB_TOKEN is missing', () => {
+            delete process.env.GITHUB_TOKEN;
+            expect(() => new GistClient()).toThrow(GistAuthError);
+            expect(() => new GistClient()).toThrow(/GITHUB_TOKEN environment variable is required/);
+        });
+        it('should provide helpful error message with token setup instructions', () => {
+            delete process.env.GITHUB_TOKEN;
+            try {
+                new GistClient();
+                expect.fail('Should have thrown GistAuthError');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(GistAuthError);
+                expect(error.message).toContain('https://github.com/settings/tokens');
+                expect(error.message).toContain('gist');
+            }
+        });
+        it('should initialize Octokit with authentication', () => {
+            process.env.GITHUB_TOKEN = 'ghp_test_token_1234567890';
+            const client = new GistClient();
+            const octokit = client.getOctokit();
+            expect(octokit).toBeDefined();
+        });
+    });
+    describe('throttling configuration', () => {
+        it('should configure rate limit handling', () => {
+            process.env.GITHUB_TOKEN = 'ghp_test_token_1234567890';
+            // Just verify initialization doesn't throw
+            // Actual throttling behavior is tested via Octokit's own tests
+            expect(() => new GistClient()).not.toThrow();
+        });
+    });
+    describe('fetchGist', () => {
+        beforeEach(() => {
+            process.env.GITHUB_TOKEN = 'ghp_test_token_1234567890';
+        });
+        it('should fetch a gist by ID successfully', async () => {
+            const client = new GistClient();
+            const octokit = client.getOctokit();
+            const mockGet = vi.fn().mockResolvedValue({
+                data: {
+                    id: 'abc123',
+                    url: 'https://api.github.com/gists/abc123',
+                    html_url: 'https://gist.github.com/user/abc123',
+                    files: {
+                        'session.jsonl': {
+                            filename: 'session.jsonl',
+                            type: 'application/jsonl',
+                            language: 'JSON',
+                            raw_url: 'https://gist.githubusercontent.com/raw/abc123/session.jsonl',
+                            size: 1024,
+                            content: '{"type":"user","uuid":"123"}\n{"type":"assistant","uuid":"456"}',
+                        },
+                    },
+                    public: false,
+                    created_at: '2024-01-01T00:00:00Z',
+                    updated_at: '2024-01-01T00:00:00Z',
+                    description: 'Session export',
+                },
+            });
+            octokit.rest.gists.get = mockGet;
+            const result = await client.fetchGist('abc123');
+            expect(result.id).toBe('abc123');
+            expect(result.html_url).toBe('https://gist.github.com/user/abc123');
+            expect(result.public).toBe(false);
+            expect(result.description).toBe('Session export');
+            expect(result.files['session.jsonl']).toBeDefined();
+            expect(result.files['session.jsonl'].content).toContain('type');
+            expect(mockGet).toHaveBeenCalledWith({
+                gist_id: 'abc123',
+            });
+        });
+        it('should extract gist ID from full URL', async () => {
+            const client = new GistClient();
+            const octokit = client.getOctokit();
+            const mockGet = vi.fn().mockResolvedValue({
+                data: {
+                    id: 'abc123def456',
+                    url: 'https://api.github.com/gists/abc123def456',
+                    html_url: 'https://gist.github.com/user/abc123def456',
+                    files: {},
+                    public: false,
+                    created_at: '2024-01-01T00:00:00Z',
+                    updated_at: '2024-01-01T00:00:00Z',
+                    description: '',
+                },
+            });
+            octokit.rest.gists.get = mockGet;
+            await client.fetchGist('https://gist.github.com/username/abc123def456');
+            expect(mockGet).toHaveBeenCalledWith({
+                gist_id: 'abc123def456',
+            });
+        });
+        it('should handle gist URL with trailing slash', async () => {
+            const client = new GistClient();
+            const octokit = client.getOctokit();
+            const mockGet = vi.fn().mockResolvedValue({
+                data: {
+                    id: 'xyz789',
+                    url: 'https://api.github.com/gists/xyz789',
+                    html_url: 'https://gist.github.com/user/xyz789',
+                    files: {},
+                    public: false,
+                    created_at: '2024-01-01T00:00:00Z',
+                    updated_at: '2024-01-01T00:00:00Z',
+                    description: '',
+                },
+            });
+            octokit.rest.gists.get = mockGet;
+            await client.fetchGist('https://gist.github.com/user/xyz789/');
+            // Should still extract xyz789 even with trailing slash
+            expect(mockGet).toHaveBeenCalledWith({
+                gist_id: 'xyz789',
+            });
+        });
+        it('should throw GistApiError on 404 (not found)', async () => {
+            const client = new GistClient();
+            const octokit = client.getOctokit();
+            octokit.rest.gists.get = vi.fn().mockRejectedValue({
+                status: 404,
+                message: 'Not Found',
+            });
+            await expect(client.fetchGist('nonexistent123')).rejects.toThrow(GistApiError);
+            await expect(client.fetchGist('nonexistent123')).rejects.toThrow(/Gist not found: nonexistent123/);
+        });
+        it('should throw GistApiError on 403 (private/deleted gist)', async () => {
+            const client = new GistClient();
+            const octokit = client.getOctokit();
+            octokit.rest.gists.get = vi.fn().mockRejectedValue({
+                status: 403,
+                message: 'Forbidden',
+            });
+            await expect(client.fetchGist('private123')).rejects.toThrow(GistApiError);
+            await expect(client.fetchGist('private123')).rejects.toThrow(/Access denied to gist private123/);
+        });
+        it('should throw GistApiError on 403 rate limit', async () => {
+            const client = new GistClient();
+            const octokit = client.getOctokit();
+            octokit.rest.gists.get = vi.fn().mockRejectedValue({
+                status: 403,
+                message: 'API rate limit exceeded',
+            });
+            await expect(client.fetchGist('abc123')).rejects.toThrow(GistApiError);
+            await expect(client.fetchGist('abc123')).rejects.toThrow(/rate limit exceeded/);
+        });
+        it('should throw GistAuthError on 401 (invalid token)', async () => {
+            const client = new GistClient();
+            const octokit = client.getOctokit();
+            octokit.rest.gists.get = vi.fn().mockRejectedValue({
+                status: 401,
+                message: 'Bad credentials',
+            });
+            await expect(client.fetchGist('abc123')).rejects.toThrow(GistAuthError);
+            await expect(client.fetchGist('abc123')).rejects.toThrow(/Invalid GITHUB_TOKEN/);
+        });
+        it('should extract content from files object', async () => {
+            const client = new GistClient();
+            const octokit = client.getOctokit();
+            const sessionContent = '{"type":"user","uuid":"123"}\n{"type":"assistant","uuid":"456"}';
+            const mockGet = vi.fn().mockResolvedValue({
+                data: {
+                    id: 'abc123',
+                    url: 'https://api.github.com/gists/abc123',
+                    html_url: 'https://gist.github.com/abc123',
+                    files: {
+                        'session.jsonl': {
+                            filename: 'session.jsonl',
+                            type: 'application/jsonl',
+                            language: 'JSON',
+                            raw_url: 'https://gist.githubusercontent.com/raw/abc123/session.jsonl',
+                            size: sessionContent.length,
+                            content: sessionContent,
+                        },
+                    },
+                    public: false,
+                    created_at: '2024-01-01T00:00:00Z',
+                    updated_at: '2024-01-01T00:00:00Z',
+                    description: 'Test',
+                },
+            });
+            octokit.rest.gists.get = mockGet;
+            const result = await client.fetchGist('abc123');
+            expect(result.files['session.jsonl'].content).toBe(sessionContent);
+        });
+    });
+    describe('createGist', () => {
+        beforeEach(() => {
+            process.env.GITHUB_TOKEN = 'ghp_test_token_1234567890';
+        });
+        it('should create a secret gist successfully', async () => {
+            const client = new GistClient();
+            const octokit = client.getOctokit();
+            // Mock the gists.create method
+            const mockCreate = vi.fn().mockResolvedValue({
+                data: {
+                    id: 'abc123',
+                    url: 'https://api.github.com/gists/abc123',
+                    html_url: 'https://gist.github.com/abc123',
+                    files: {
+                        'test.txt': {
+                            filename: 'test.txt',
+                            type: 'text/plain',
+                            language: 'Text',
+                            raw_url: 'https://gist.githubusercontent.com/raw/abc123/test.txt',
+                            size: 11,
+                            content: 'Hello World',
+                        },
+                    },
+                    public: false,
+                    created_at: '2024-01-01T00:00:00Z',
+                    updated_at: '2024-01-01T00:00:00Z',
+                    description: 'Test gist',
+                },
+            });
+            octokit.rest.gists.create = mockCreate;
+            const result = await client.createGist('Test gist', {
+                'test.txt': 'Hello World',
+            });
+            expect(result.id).toBe('abc123');
+            expect(result.html_url).toBe('https://gist.github.com/abc123');
+            expect(result.public).toBe(false);
+            expect(result.description).toBe('Test gist');
+            expect(result.files['test.txt']).toBeDefined();
+            // Verify it was called with public: false (secret gist)
+            expect(mockCreate).toHaveBeenCalledWith({
+                description: 'Test gist',
+                public: false,
+                files: {
+                    'test.txt': { content: 'Hello World' },
+                },
+            });
+        });
+        it('should handle multiple files', async () => {
+            const client = new GistClient();
+            const octokit = client.getOctokit();
+            const mockCreate = vi.fn().mockResolvedValue({
+                data: {
+                    id: 'abc123',
+                    url: 'https://api.github.com/gists/abc123',
+                    html_url: 'https://gist.github.com/abc123',
+                    files: {
+                        'file1.txt': { content: 'Content 1' },
+                        'file2.txt': { content: 'Content 2' },
+                    },
+                    public: false,
+                    created_at: '2024-01-01T00:00:00Z',
+                    updated_at: '2024-01-01T00:00:00Z',
+                    description: 'Multi-file gist',
+                },
+            });
+            octokit.rest.gists.create = mockCreate;
+            await client.createGist('Multi-file gist', {
+                'file1.txt': 'Content 1',
+                'file2.txt': 'Content 2',
+            });
+            expect(mockCreate).toHaveBeenCalledWith({
+                description: 'Multi-file gist',
+                public: false,
+                files: {
+                    'file1.txt': { content: 'Content 1' },
+                    'file2.txt': { content: 'Content 2' },
+                },
+            });
+        });
+        it('should throw GistAuthError on 401 (invalid token)', async () => {
+            const client = new GistClient();
+            const octokit = client.getOctokit();
+            octokit.rest.gists.create = vi.fn().mockRejectedValue({
+                status: 401,
+                message: 'Bad credentials',
+            });
+            await expect(client.createGist('Test', { 'test.txt': 'content' })).rejects.toThrow(GistAuthError);
+            await expect(client.createGist('Test', { 'test.txt': 'content' })).rejects.toThrow(/Invalid GITHUB_TOKEN/);
+        });
+        it('should throw GistApiError on 403 (permission denied)', async () => {
+            const client = new GistClient();
+            const octokit = client.getOctokit();
+            octokit.rest.gists.create = vi.fn().mockRejectedValue({
+                status: 403,
+                message: 'Forbidden',
+            });
+            await expect(client.createGist('Test', { 'test.txt': 'content' })).rejects.toThrow(GistApiError);
+            await expect(client.createGist('Test', { 'test.txt': 'content' })).rejects.toThrow(/Permission denied/);
+        });
+        it('should throw GistApiError on 403 rate limit', async () => {
+            const client = new GistClient();
+            const octokit = client.getOctokit();
+            octokit.rest.gists.create = vi.fn().mockRejectedValue({
+                status: 403,
+                message: 'API rate limit exceeded',
+            });
+            await expect(client.createGist('Test', { 'test.txt': 'content' })).rejects.toThrow(GistApiError);
+            await expect(client.createGist('Test', { 'test.txt': 'content' })).rejects.toThrow(/rate limit exceeded/);
+        });
+        it('should throw GistApiError on 422 (validation error)', async () => {
+            const client = new GistClient();
+            const octokit = client.getOctokit();
+            octokit.rest.gists.create = vi.fn().mockRejectedValue({
+                status: 422,
+                message: 'Validation Failed',
+            });
+            await expect(client.createGist('Test', { 'test.txt': 'content' })).rejects.toThrow(GistApiError);
+            await expect(client.createGist('Test', { 'test.txt': 'content' })).rejects.toThrow(/Invalid gist data/);
+        });
+        it('should throw GistApiError on other errors', async () => {
+            const client = new GistClient();
+            const octokit = client.getOctokit();
+            octokit.rest.gists.create = vi.fn().mockRejectedValue({
+                status: 500,
+                message: 'Internal Server Error',
+            });
+            await expect(client.createGist('Test', { 'test.txt': 'content' })).rejects.toThrow(GistApiError);
+            await expect(client.createGist('Test', { 'test.txt': 'content' })).rejects.toThrow(/Failed to create gist/);
+        });
+    });
+});

package/dist/__tests__/index.test.js

@@ -0,0 +1,16 @@
+import { describe, it, expect } from "vitest";
+/**
+ * Smoke test for MCP server module
+ *
+ * This test verifies that the server module can be imported successfully
+ * without runtime errors. Full MCP protocol testing requires a client setup
+ * and will be added in later phases as we implement actual tools.
+ */
+describe("MCP Server Module", () => {
+    it("should import without errors", async () => {
+        // This test verifies that the module structure is valid
+        // and all dependencies can be resolved
+        const moduleImport = import("../index.js");
+        await expect(moduleImport).resolves.toBeDefined();
+    });
+});