yaver-feedback-react-native 0.5.3 → 0.5.4

package/dist/__tests__/SDKToken.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/SDKToken.test.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const P2PClient_1 = require("../P2PClient");
+// Mock react-native Platform
+jest.mock('react-native', () => ({
+    Platform: { OS: 'ios' },
+}));
+// Mock fetch globally
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+// Mock AbortController
+class MockAbortController {
+    constructor() {
+        this.signal = {};
+        this.abort = jest.fn();
+    }
+}
+global.AbortController = MockAbortController;
+beforeEach(() => {
+    jest.clearAllMocks();
+    mockFetch.mockReset();
+});
+describe('SDK Token Auth', () => {
+    describe('Bearer token in requests', () => {
+        it('sends SDK token in Authorization header for feedback', async () => {
+            mockFetch.mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({ id: 'report-1' }),
+                text: () => Promise.resolve(''),
+            });
+            const client = new P2PClient_1.P2PClient('http://192.168.1.10:18080', 'sdk-token-abc123');
+            const bundle = {
+                metadata: {
+                    timestamp: '2026-03-25T00:00:00Z',
+                    device: { platform: 'ios', osVersion: '18', model: 'iPhone', screenWidth: 393, screenHeight: 852 },
+                    app: {},
+                },
+                screenshots: [],
+            };
+            await client.uploadFeedback(bundle);
+            expect(mockFetch).toHaveBeenCalledWith('http://192.168.1.10:18080/feedback', expect.objectContaining({
+                headers: expect.objectContaining({
+                    Authorization: 'Bearer sdk-token-abc123',
+                }),
+            }));
+        });
+        it('sends SDK token in Authorization header for voice', async () => {
+            mockFetch.mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({ voiceInputEnabled: true }),
+                text: () => Promise.resolve(''),
+            });
+            const client = new P2PClient_1.P2PClient('http://localhost:18080', 'my-sdk-token');
+            await client.voiceStatus();
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:18080/voice/status', expect.objectContaining({
+                headers: expect.objectContaining({
+                    Authorization: 'Bearer my-sdk-token',
+                }),
+            }));
+        });
+        it('sends SDK token for test session', async () => {
+            mockFetch.mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({ sessionId: 'sess-1' }),
+                text: () => Promise.resolve(''),
+            });
+            const client = new P2PClient_1.P2PClient('http://localhost:18080', 'test-sdk-token');
+            await client.startTestSession();
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:18080/test-app/start', expect.objectContaining({
+                headers: expect.objectContaining({
+                    Authorization: 'Bearer test-sdk-token',
+                }),
+            }));
+        });
+    });
+    describe('setAuthToken()', () => {
+        it('updates token for subsequent requests', async () => {
+            mockFetch.mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({ hostname: 'test' }),
+                text: () => Promise.resolve(''),
+            });
+            const client = new P2PClient_1.P2PClient('http://localhost:18080', 'old-token');
+            client.setAuthToken('new-sdk-token');
+            await client.info();
+            expect(mockFetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                headers: expect.objectContaining({
+                    Authorization: 'Bearer new-sdk-token',
+                }),
+            }));
+        });
+    });
+    describe('Error handling for SDK token auth failures', () => {
+        it('throws on 403 Forbidden (scope violation)', async () => {
+            mockFetch.mockResolvedValue({
+                ok: false,
+                status: 403,
+                text: () => Promise.resolve('SDK token scope does not allow this endpoint'),
+            });
+            const client = new P2PClient_1.P2PClient('http://localhost:18080', 'limited-sdk');
+            await expect(client.info()).rejects.toThrow('403');
+        });
+        it('throws on 403 Forbidden (IP binding)', async () => {
+            mockFetch.mockResolvedValue({
+                ok: false,
+                status: 403,
+                text: () => Promise.resolve('SDK token not allowed from this IP'),
+            });
+            const client = new P2PClient_1.P2PClient('http://localhost:18080', 'ip-bound-sdk');
+            await expect(client.info()).rejects.toThrow('403');
+        });
+        it('throws on 401 Unauthorized (expired token)', async () => {
+            mockFetch.mockResolvedValue({
+                ok: false,
+                status: 401,
+                text: () => Promise.resolve('Invalid or expired SDK token'),
+            });
+            const client = new P2PClient_1.P2PClient('http://localhost:18080', 'expired-sdk');
+            await expect(client.info()).rejects.toThrow('401');
+        });
+    });
+    describe('Token rotation', () => {
+        it('rotateToken() calls POST /sdk/token/rotate', async () => {
+            mockFetch.mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({
+                    token: 'new-rotated-token',
+                    expiresAt: Date.now() + 365 * 24 * 60 * 60 * 1000,
+                }),
+                text: () => Promise.resolve(''),
+            });
+            const client = new P2PClient_1.P2PClient('http://localhost:18080', 'current-sdk-token');
+            const result = await client.rotateToken();
+            expect(result.token).toBe('new-rotated-token');
+            expect(result.expiresAt).toBeGreaterThan(Date.now());
+            // Verify the request was made correctly
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:18080/sdk/token/rotate', expect.objectContaining({
+                method: 'POST',
+                headers: expect.objectContaining({
+                    Authorization: 'Bearer current-sdk-token',
+                }),
+            }));
+        });
+        it('rotateToken() auto-updates internal token', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({
+                    token: 'rotated-token-xyz',
+                    expiresAt: Date.now() + 365 * 24 * 60 * 60 * 1000,
+                }),
+                text: () => Promise.resolve(''),
+            });
+            const client = new P2PClient_1.P2PClient('http://localhost:18080', 'old-token');
+            await client.rotateToken();
+            // Now make another request — should use the new token
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({ hostname: 'test' }),
+                text: () => Promise.resolve(''),
+            });
+            await client.info();
+            // Second call should use the rotated token
+            expect(mockFetch).toHaveBeenLastCalledWith(expect.any(String), expect.objectContaining({
+                headers: expect.objectContaining({
+                    Authorization: 'Bearer rotated-token-xyz',
+                }),
+            }));
+        });
+        it('rotateToken() throws on failure', async () => {
+            mockFetch.mockResolvedValue({
+                ok: false,
+                status: 401,
+                text: () => Promise.resolve('Token already rotated'),
+            });
+            const client = new P2PClient_1.P2PClient('http://localhost:18080', 'already-rotated');
+            await expect(client.rotateToken()).rejects.toThrow('Token rotation failed');
+        });
+    });
+    describe('Health endpoint with TLS info', () => {
+        it('health response includes TLS fingerprint', async () => {
+            mockFetch.mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({
+                    ok: true,
+                    hostname: 'MacBook',
+                    version: '1.45.0',
+                    tlsFingerprint: 'abc123def456789',
+                    tlsPort: 18443,
+                }),
+                text: () => Promise.resolve(''),
+            });
+            const client = new P2PClient_1.P2PClient('http://localhost:18080', 'tok');
+            const info = await client.info();
+            expect(info.hostname).toBe('MacBook');
+            expect(info.version).toBe('1.45.0');
+        });
+    });
+    describe('Multiple SDK token scenarios', () => {
+        it('works with long token strings', async () => {
+            const longToken = 'a'.repeat(64); // 64-char hex token
+            mockFetch.mockResolvedValue({ ok: true });
+            const client = new P2PClient_1.P2PClient('http://localhost:18080', longToken);
+            const healthy = await client.health();
+            expect(healthy).toBe(true);
+        });
+        it('health check does not send auth header', async () => {
+            mockFetch.mockResolvedValue({ ok: true });
+            const client = new P2PClient_1.P2PClient('http://localhost:18080', 'secret-sdk');
+            await client.health();
+            // health() should NOT send Authorization header
+            const call = mockFetch.mock.calls[0];
+            expect(call[1].headers).toBeUndefined();
+        });
+    });
+});

package/dist/__tests__/YaverFeedback.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/YaverFeedback.test.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const YaverFeedback_1 = require("../YaverFeedback");
+// Mock react-native: DeviceEventEmitter for event dispatch + Platform so
+// ShakeDetector.start() can branch on iOS without hitting a real RN runtime.
+jest.mock('react-native', () => ({
+    DeviceEventEmitter: {
+        emit: jest.fn(),
+        addListener: jest.fn(() => ({ remove: jest.fn() })),
+    },
+    Platform: { OS: 'ios' },
+}));
+// Mock Discovery
+jest.mock('../Discovery', () => ({
+    YaverDiscovery: {
+        discover: jest.fn(),
+    },
+}));
+// Reset module-level state between tests by re-requiring
+beforeEach(() => {
+    // YaverFeedback uses module-level variables (config, enabled, p2pClient).
+    // We reset them by calling init with a known state or relying on isInitialized checks.
+    // For a clean slate, we re-init with enabled=false then verify.
+    jest.clearAllMocks();
+});
+describe('YaverFeedback', () => {
+    describe('init()', () => {
+        it('sets config correctly with defaults', () => {
+            YaverFeedback_1.YaverFeedback.init({
+                authToken: 'test-token',
+                agentUrl: 'http://localhost:18080',
+            });
+            const cfg = YaverFeedback_1.YaverFeedback.getConfig();
+            expect(cfg).not.toBeNull();
+            expect(cfg.authToken).toBe('test-token');
+            expect(cfg.agentUrl).toBe('http://localhost:18080');
+            expect(cfg.trigger).toBe('shake');
+            expect(cfg.maxRecordingDuration).toBe(120);
+            expect(cfg.feedbackMode).toBe('batch');
+            expect(cfg.agentCommentaryLevel).toBe(0);
+        });
+        it('respects user-provided values over defaults', () => {
+            YaverFeedback_1.YaverFeedback.init({
+                authToken: 'tok',
+                trigger: 'floating-button',
+                maxRecordingDuration: 60,
+                feedbackMode: 'live',
+                agentCommentaryLevel: 7,
+            });
+            const cfg = YaverFeedback_1.YaverFeedback.getConfig();
+            expect(cfg.trigger).toBe('floating-button');
+            expect(cfg.maxRecordingDuration).toBe(60);
+            expect(cfg.feedbackMode).toBe('live');
+            expect(cfg.agentCommentaryLevel).toBe(7);
+        });
+        it('with enabled=false sets enabled to false', () => {
+            YaverFeedback_1.YaverFeedback.init({
+                authToken: 'tok',
+                enabled: false,
+            });
+            expect(YaverFeedback_1.YaverFeedback.isInitialized()).toBe(true);
+            expect(YaverFeedback_1.YaverFeedback.isEnabled()).toBe(false);
+        });
+        it('with enabled=true sets enabled to true', () => {
+            YaverFeedback_1.YaverFeedback.init({
+                authToken: 'tok',
+                enabled: true,
+            });
+            expect(YaverFeedback_1.YaverFeedback.isEnabled()).toBe(true);
+        });
+        it('creates P2PClient when agentUrl is provided', () => {
+            YaverFeedback_1.YaverFeedback.init({
+                authToken: 'tok',
+                agentUrl: 'http://192.168.1.10:18080',
+            });
+            expect(YaverFeedback_1.YaverFeedback.getP2PClient()).not.toBeNull();
+        });
+        it('does not create P2PClient when agentUrl is omitted', () => {
+            YaverFeedback_1.YaverFeedback.init({
+                authToken: 'tok',
+            });
+            expect(YaverFeedback_1.YaverFeedback.getP2PClient()).toBeNull();
+        });
+    });
+    describe('isInitialized()', () => {
+        it('returns true after init()', () => {
+            YaverFeedback_1.YaverFeedback.init({ authToken: 'tok' });
+            expect(YaverFeedback_1.YaverFeedback.isInitialized()).toBe(true);
+        });
+    });
+    describe('setEnabled()', () => {
+        it('toggles enabled state', () => {
+            YaverFeedback_1.YaverFeedback.init({ authToken: 'tok', enabled: true });
+            expect(YaverFeedback_1.YaverFeedback.isEnabled()).toBe(true);
+            YaverFeedback_1.YaverFeedback.setEnabled(false);
+            expect(YaverFeedback_1.YaverFeedback.isEnabled()).toBe(false);
+            YaverFeedback_1.YaverFeedback.setEnabled(true);
+            expect(YaverFeedback_1.YaverFeedback.isEnabled()).toBe(true);
+        });
+    });
+    describe('getConfig()', () => {
+        it('returns the config after init', () => {
+            YaverFeedback_1.YaverFeedback.init({
+                authToken: 'my-token',
+                agentUrl: 'http://10.0.0.1:18080',
+            });
+            const cfg = YaverFeedback_1.YaverFeedback.getConfig();
+            expect(cfg).toBeDefined();
+            expect(cfg.authToken).toBe('my-token');
+            expect(cfg.agentUrl).toBe('http://10.0.0.1:18080');
+        });
+    });
+    describe('getFeedbackMode()', () => {
+        it('defaults to batch when no config', () => {
+            // After any init, feedbackMode defaults to 'batch'
+            YaverFeedback_1.YaverFeedback.init({ authToken: 'tok' });
+            expect(YaverFeedback_1.YaverFeedback.getFeedbackMode()).toBe('batch');
+        });
+        it('returns configured mode', () => {
+            YaverFeedback_1.YaverFeedback.init({ authToken: 'tok', feedbackMode: 'narrated' });
+            expect(YaverFeedback_1.YaverFeedback.getFeedbackMode()).toBe('narrated');
+        });
+        it('returns live when configured', () => {
+            YaverFeedback_1.YaverFeedback.init({ authToken: 'tok', feedbackMode: 'live' });
+            expect(YaverFeedback_1.YaverFeedback.getFeedbackMode()).toBe('live');
+        });
+    });
+    describe('getCommentaryLevel()', () => {
+        it('defaults to 0', () => {
+            YaverFeedback_1.YaverFeedback.init({ authToken: 'tok' });
+            expect(YaverFeedback_1.YaverFeedback.getCommentaryLevel()).toBe(0);
+        });
+        it('returns configured level', () => {
+            YaverFeedback_1.YaverFeedback.init({ authToken: 'tok', agentCommentaryLevel: 5 });
+            expect(YaverFeedback_1.YaverFeedback.getCommentaryLevel()).toBe(5);
+        });
+        it('returns max level when set to 10', () => {
+            YaverFeedback_1.YaverFeedback.init({ authToken: 'tok', agentCommentaryLevel: 10 });
+            expect(YaverFeedback_1.YaverFeedback.getCommentaryLevel()).toBe(10);
+        });
+    });
+    describe('startReport()', () => {
+        it('does nothing when not enabled', async () => {
+            YaverFeedback_1.YaverFeedback.init({ authToken: 'tok', enabled: false });
+            // Should not throw
+            await YaverFeedback_1.YaverFeedback.startReport();
+            const { DeviceEventEmitter } = require('react-native');
+            expect(DeviceEventEmitter.emit).not.toHaveBeenCalled();
+        });
+        it('emits event when enabled and agentUrl is set', async () => {
+            YaverFeedback_1.YaverFeedback.init({
+                authToken: 'tok',
+                enabled: true,
+                agentUrl: 'http://localhost:18080',
+            });
+            await YaverFeedback_1.YaverFeedback.startReport();
+            const { DeviceEventEmitter } = require('react-native');
+            expect(DeviceEventEmitter.emit).toHaveBeenCalledWith('yaverFeedback:startReport');
+        });
+    });
+});

package/dist/__tests__/types.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/types.test.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+describe('React Native SDK types', () => {
+    describe('FeedbackConfig', () => {
+        it('can be constructed with only required fields', () => {
+            const config = {
+                authToken: 'test-token',
+            };
+            expect(config.authToken).toBe('test-token');
+            expect(config.agentUrl).toBeUndefined();
+            expect(config.trigger).toBeUndefined();
+            expect(config.enabled).toBeUndefined();
+            expect(config.maxRecordingDuration).toBeUndefined();
+            expect(config.feedbackMode).toBeUndefined();
+            expect(config.agentCommentaryLevel).toBeUndefined();
+        });
+        it('can be constructed with all optional fields', () => {
+            const config = {
+                authToken: 'tok',
+                agentUrl: 'http://192.168.1.10:18080',
+                trigger: 'shake',
+                enabled: true,
+                maxRecordingDuration: 60,
+                feedbackMode: 'live',
+                agentCommentaryLevel: 7,
+            };
+            expect(config.trigger).toBe('shake');
+            expect(config.feedbackMode).toBe('live');
+            expect(config.agentCommentaryLevel).toBe(7);
+        });
+        it('accepts all trigger types', () => {
+            const triggers = ['shake', 'floating-button', 'manual'];
+            triggers.forEach((trigger) => {
+                const config = { authToken: 'tok', trigger };
+                expect(config.trigger).toBe(trigger);
+            });
+        });
+        it('accepts all feedback modes', () => {
+            const modes = ['live', 'narrated', 'batch'];
+            modes.forEach((mode) => {
+                const config = { authToken: 'tok', feedbackMode: mode };
+                expect(config.feedbackMode).toBe(mode);
+            });
+        });
+    });
+    describe('FeedbackBundle', () => {
+        it('can be constructed with required fields', () => {
+            const bundle = {
+                metadata: {
+                    timestamp: '2026-03-24T12:00:00Z',
+                    device: {
+                        platform: 'ios',
+                        osVersion: '18.0',
+                        model: 'iPhone 16 Pro',
+                        screenWidth: 393,
+                        screenHeight: 852,
+                    },
+                    app: {
+                        bundleId: 'com.example.app',
+                        version: '1.0.0',
+                        buildNumber: '42',
+                    },
+                },
+                screenshots: [],
+            };
+            expect(bundle.metadata.timestamp).toBe('2026-03-24T12:00:00Z');
+            expect(bundle.metadata.device.platform).toBe('ios');
+            expect(bundle.screenshots).toEqual([]);
+            expect(bundle.video).toBeUndefined();
+            expect(bundle.audio).toBeUndefined();
+        });
+        it('can include optional video, audio, and screenshots', () => {
+            const bundle = {
+                metadata: {
+                    timestamp: '2026-03-24T12:00:00Z',
+                    device: {
+                        platform: 'android',
+                        osVersion: '15',
+                        model: 'Pixel 9',
+                        screenWidth: 412,
+                        screenHeight: 915,
+                    },
+                    app: {},
+                    userNote: 'This button does not work',
+                },
+                video: '/tmp/recording.mp4',
+                audio: '/tmp/voice.m4a',
+                screenshots: ['/tmp/ss1.png', '/tmp/ss2.png'],
+            };
+            expect(bundle.video).toBe('/tmp/recording.mp4');
+            expect(bundle.audio).toBe('/tmp/voice.m4a');
+            expect(bundle.screenshots).toHaveLength(2);
+            expect(bundle.metadata.userNote).toBe('This button does not work');
+        });
+    });
+    describe('TimelineEvent', () => {
+        it('has correct structure for screenshot event', () => {
+            const event = {
+                type: 'screenshot',
+                path: '/tmp/screenshot.png',
+                timestamp: '2026-03-24T12:00:05Z',
+            };
+            expect(event.type).toBe('screenshot');
+            expect(event.path).toBe('/tmp/screenshot.png');
+            expect(event.duration).toBeUndefined();
+        });
+        it('supports optional duration for audio/video events', () => {
+            const event = {
+                type: 'audio',
+                path: '/tmp/voice.m4a',
+                timestamp: '2026-03-24T12:00:10Z',
+                duration: 15.5,
+            };
+            expect(event.duration).toBe(15.5);
+        });
+        it('accepts all event types', () => {
+            const types = ['screenshot', 'audio', 'video'];
+            types.forEach((type) => {
+                const event = { type, path: '/tmp/file', timestamp: 'now' };
+                expect(event.type).toBe(type);
+            });
+        });
+    });
+    describe('DeviceInfo', () => {
+        it('has all required fields', () => {
+            const device = {
+                platform: 'ios',
+                osVersion: '18.0',
+                model: 'iPhone 16 Pro Max',
+                screenWidth: 430,
+                screenHeight: 932,
+            };
+            expect(device.platform).toBe('ios');
+            expect(device.screenWidth).toBe(430);
+            expect(device.screenHeight).toBe(932);
+        });
+    });
+    describe('AppInfo', () => {
+        it('can be empty (all fields optional)', () => {
+            const app = {};
+            expect(app.bundleId).toBeUndefined();
+            expect(app.version).toBeUndefined();
+            expect(app.buildNumber).toBeUndefined();
+        });
+        it('can have all fields populated', () => {
+            const app = {
+                bundleId: 'com.yaver.test',
+                version: '2.0.0',
+                buildNumber: '100',
+            };
+            expect(app.bundleId).toBe('com.yaver.test');
+        });
+    });
+    describe('FeedbackReport', () => {
+        it('has correct structure', () => {
+            const report = {
+                id: 'report-123',
+                bundle: {
+                    metadata: {
+                        timestamp: 'now',
+                        device: { platform: 'ios', osVersion: '18', model: 'iPhone', screenWidth: 393, screenHeight: 852 },
+                        app: {},
+                    },
+                    screenshots: [],
+                },
+                status: 'pending',
+            };
+            expect(report.status).toBe('pending');
+            expect(report.error).toBeUndefined();
+        });
+        it('accepts all status values', () => {
+            const statuses = ['pending', 'uploading', 'uploaded', 'failed'];
+            statuses.forEach((status) => {
+                const report = {
+                    id: '1',
+                    bundle: {
+                        metadata: {
+                            timestamp: 'now',
+                            device: { platform: 'ios', osVersion: '18', model: 'iPhone', screenWidth: 393, screenHeight: 852 },
+                            app: {},
+                        },
+                        screenshots: [],
+                    },
+                    status,
+                };
+                expect(report.status).toBe(status);
+            });
+        });
+    });
+    describe('AgentCommentary', () => {
+        it('has correct structure', () => {
+            const commentary = {
+                id: 'cmt-1',
+                timestamp: '2026-03-24T12:00:00Z',
+                message: 'I see a layout issue on the login screen',
+                type: 'observation',
+            };
+            expect(commentary.type).toBe('observation');
+        });
+        it('accepts all commentary types', () => {
+            const types = ['observation', 'suggestion', 'question', 'action'];
+            types.forEach((type) => {
+                const c = { id: '1', timestamp: 'now', message: 'test', type };
+                expect(c.type).toBe(type);
+            });
+        });
+    });
+    describe('FeedbackStreamEvent', () => {
+        it('has correct structure', () => {
+            const event = {
+                type: 'tap',
+                timestamp: '2026-03-24T12:00:00Z',
+                data: { x: 100, y: 200 },
+            };
+            expect(event.type).toBe('tap');
+            expect(event.data.x).toBe(100);
+        });
+    });
+});