1  import { describe, it, expect, vi, afterEach } from 'vitest';
  2  import {
  3    buildRepairContext, collectDiagnostic, isDiagnosticEnabled, emitDiagnostic,
  4    truncate, redactUrl, redactText, resolveAdapterSourcePath, MAX_DIAGNOSTIC_BYTES,
  5    type RepairContext,
  6  } from './diagnostic.js';
  7  import { SelectorError, CommandExecutionError } from './errors.js';
  8  import type { InternalCliCommand } from './registry.js';
  9  import type { IPage } from './types.js';
 10  
 11  function makeCmd(overrides: Partial<InternalCliCommand> = {}): InternalCliCommand {
 12    return {
 13      site: 'test-site',
 14      name: 'test-cmd',
 15      description: 'test',
 16      args: [],
 17      ...overrides,
 18    } as InternalCliCommand;
 19  }
 20  
 21  describe('isDiagnosticEnabled', () => {
 22    const origEnv = process.env.OPENCLI_DIAGNOSTIC;
 23    afterEach(() => {
 24      if (origEnv === undefined) delete process.env.OPENCLI_DIAGNOSTIC;
 25      else process.env.OPENCLI_DIAGNOSTIC = origEnv;
 26    });
 27  
 28    it('returns false when env not set', () => {
 29      delete process.env.OPENCLI_DIAGNOSTIC;
 30      expect(isDiagnosticEnabled()).toBe(false);
 31    });
 32  
 33    it('returns true when env is "1"', () => {
 34      process.env.OPENCLI_DIAGNOSTIC = '1';
 35      expect(isDiagnosticEnabled()).toBe(true);
 36    });
 37  
 38    it('returns false for other values', () => {
 39      process.env.OPENCLI_DIAGNOSTIC = 'true';
 40      expect(isDiagnosticEnabled()).toBe(false);
 41    });
 42  });
 43  
 44  describe('truncate', () => {
 45    it('returns short strings unchanged', () => {
 46      expect(truncate('hello', 100)).toBe('hello');
 47    });
 48  
 49    it('truncates long strings with marker', () => {
 50      const long = 'a'.repeat(200);
 51      const result = truncate(long, 50);
 52      expect(result.length).toBeLessThan(200);
 53      expect(result).toContain('...[truncated,');
 54      expect(result).toContain('150 chars omitted]');
 55    });
 56  });
 57  
 58  describe('redactUrl', () => {
 59    it('redacts sensitive query parameters', () => {
 60      expect(redactUrl('https://api.com/v1?token=abc123&q=test'))
 61        .toBe('https://api.com/v1?token=[REDACTED]&q=test');
 62    });
 63  
 64    it('redacts multiple sensitive params', () => {
 65      const url = 'https://api.com?api_key=xxx&secret=yyy&page=1';
 66      const result = redactUrl(url);
 67      expect(result).toContain('api_key=[REDACTED]');
 68      expect(result).toContain('secret=[REDACTED]');
 69      expect(result).toContain('page=1');
 70    });
 71  
 72    it('leaves clean URLs unchanged', () => {
 73      expect(redactUrl('https://example.com/page?q=test')).toBe('https://example.com/page?q=test');
 74    });
 75  });
 76  
 77  describe('redactText', () => {
 78    it('redacts Bearer tokens', () => {
 79      expect(redactText('Authorization: Bearer eyJhbGciOiJIUzI1NiJ9.test'))
 80        .toContain('Bearer [REDACTED]');
 81    });
 82  
 83    it('redacts JWT tokens', () => {
 84      const jwt = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.dozjgNryP4J3jVmNHl0w5N_XgL0n3I9PlFUP0THsR8U';
 85      expect(redactText(`token is ${jwt}`)).toContain('[REDACTED_JWT]');
 86      expect(redactText(`token is ${jwt}`)).not.toContain('eyJhbGci');
 87    });
 88  
 89    it('redacts inline token=value patterns', () => {
 90      expect(redactText('failed with token=abc123def456')).toContain('token=[REDACTED]');
 91    });
 92  
 93    it('redacts cookie values', () => {
 94      const result = redactText('cookie: session=abc123; user=xyz789; path=/');
 95      expect(result).toContain('[REDACTED]');
 96      expect(result).not.toContain('session=abc123');
 97    });
 98  
 99    it('leaves normal text unchanged', () => {
100      expect(redactText('Error: element not found')).toBe('Error: element not found');
101    });
102  });
103  
104  describe('resolveAdapterSourcePath', () => {
105    it('returns source when it is a real file path (not manifest:)', () => {
106      const cmd = makeCmd({ source: '/home/user/.opencli/clis/arxiv/search.js' });
107      expect(resolveAdapterSourcePath(cmd as InternalCliCommand)).toBe('/home/user/.opencli/clis/arxiv/search.js');
108    });
109  
110    it('skips manifest: pseudo-paths and falls back to _modulePath', () => {
111      const cmd = makeCmd({ source: 'manifest:arxiv/search', _modulePath: '/pkg/clis/arxiv/search.js' });
112      // Should try to map to source, but since files don't exist on disk, returns _modulePath
113      const result = resolveAdapterSourcePath(cmd as InternalCliCommand);
114      expect(result).toBeDefined();
115      expect(result).not.toContain('manifest:');
116    });
117  
118    it('returns undefined when only manifest: pseudo-path and no _modulePath', () => {
119      const cmd = makeCmd({ source: 'manifest:test/cmd' });
120      expect(resolveAdapterSourcePath(cmd as InternalCliCommand)).toBeUndefined();
121    });
122  
123    it('returns _modulePath when it is the only path available', () => {
124      const cmd = makeCmd({ _modulePath: '/project/clis/site/cmd.js' });
125      const result = resolveAdapterSourcePath(cmd as InternalCliCommand);
126      // Since file doesn't exist, returns _modulePath as best guess
127      expect(result).toBe('/project/clis/site/cmd.js');
128    });
129  });
130  
131  describe('buildRepairContext', () => {
132    it('captures CliError fields', () => {
133      const err = new SelectorError('.missing-element', 'Element removed');
134      const ctx = buildRepairContext(err, makeCmd());
135  
136      expect(ctx.error.code).toBe('SELECTOR');
137      expect(ctx.error.message).toContain('.missing-element');
138      expect(ctx.error.hint).toBe('Element removed');
139      expect(ctx.error.stack).toBeDefined();
140      expect(ctx.adapter.site).toBe('test-site');
141      expect(ctx.adapter.command).toBe('test-site/test-cmd');
142      expect(ctx.timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T/);
143    });
144  
145    it('handles non-CliError errors', () => {
146      const err = new TypeError('Cannot read property "x" of undefined');
147      const ctx = buildRepairContext(err, makeCmd());
148  
149      expect(ctx.error.code).toBe('UNKNOWN');
150      expect(ctx.error.message).toContain('Cannot read property');
151      expect(ctx.error.hint).toBeUndefined();
152    });
153  
154    it('includes page state when provided', () => {
155      const pageState: RepairContext['page'] = {
156        url: 'https://example.com/page',
157        snapshot: '<div>...</div>',
158        networkRequests: [{ url: '/api/data', status: 200 }],
159        consoleErrors: ['Uncaught TypeError'],
160      };
161      const ctx = buildRepairContext(new CommandExecutionError('boom'), makeCmd(), pageState);
162  
163      expect(ctx.page).toEqual(pageState);
164    });
165  
166    it('omits page when not provided', () => {
167      const ctx = buildRepairContext(new Error('boom'), makeCmd());
168      expect(ctx.page).toBeUndefined();
169    });
170  
171    it('truncates long stack traces', () => {
172      const err = new Error('boom');
173      err.stack = 'x'.repeat(10_000);
174      const ctx = buildRepairContext(err, makeCmd());
175      expect(ctx.error.stack!.length).toBeLessThan(10_000);
176      expect(ctx.error.stack).toContain('truncated');
177    });
178  
179    it('redacts sensitive data in error message and stack', () => {
180      const err = new Error('Request failed with Bearer eyJhbGciOiJIUzI1NiJ9.test.sig');
181      const ctx = buildRepairContext(err, makeCmd());
182      expect(ctx.error.message).toContain('Bearer [REDACTED]');
183      expect(ctx.error.message).not.toContain('eyJhbGci');
184      // Stack also gets redacted
185      expect(ctx.error.stack).toContain('Bearer [REDACTED]');
186    });
187  });
188  
189  describe('emitDiagnostic', () => {
190    it('writes delimited JSON to stderr', () => {
191      const writeSpy = vi.spyOn(process.stderr, 'write').mockReturnValue(true);
192  
193      const ctx = buildRepairContext(new CommandExecutionError('test error'), makeCmd());
194      emitDiagnostic(ctx);
195  
196      const output = writeSpy.mock.calls.map(c => c[0]).join('');
197      expect(output).toContain('___OPENCLI_DIAGNOSTIC___');
198      expect(output).toContain('"code":"COMMAND_EXEC"');
199      expect(output).toContain('"message":"test error"');
200  
201      // Verify JSON is parseable between markers
202      const match = output.match(/___OPENCLI_DIAGNOSTIC___\n(.*)\n___OPENCLI_DIAGNOSTIC___/);
203      expect(match).toBeTruthy();
204      const parsed = JSON.parse(match![1]);
205      expect(parsed.error.code).toBe('COMMAND_EXEC');
206  
207      writeSpy.mockRestore();
208    });
209  
210    it('drops page snapshot when over size budget', () => {
211      const writeSpy = vi.spyOn(process.stderr, 'write').mockReturnValue(true);
212  
213      const ctx: RepairContext = {
214        error: { code: 'COMMAND_EXEC', message: 'boom' },
215        adapter: { site: 'test', command: 'test/cmd' },
216        page: {
217          url: 'https://example.com',
218          snapshot: 'x'.repeat(MAX_DIAGNOSTIC_BYTES + 1000),
219          networkRequests: [],
220          consoleErrors: [],
221        },
222        timestamp: new Date().toISOString(),
223      };
224      emitDiagnostic(ctx);
225  
226      const output = writeSpy.mock.calls.map(c => c[0]).join('');
227      const match = output.match(/___OPENCLI_DIAGNOSTIC___\n(.*)\n___OPENCLI_DIAGNOSTIC___/);
228      expect(match).toBeTruthy();
229      const parsed = JSON.parse(match![1]);
230      // Page snapshot should be replaced or page dropped entirely
231      expect(parsed.page?.snapshot !== ctx.page!.snapshot || parsed.page === undefined).toBe(true);
232      expect(match![1].length).toBeLessThanOrEqual(MAX_DIAGNOSTIC_BYTES);
233  
234      writeSpy.mockRestore();
235    });
236  
237    it('redacts sensitive headers in network requests', () => {
238      const pageState: RepairContext['page'] = {
239        url: 'https://example.com',
240        snapshot: '<div/>',
241        networkRequests: [{
242          url: 'https://api.com/data?token=secret123',
243          headers: { authorization: 'Bearer xyz', 'content-type': 'application/json' },
244          body: '{"data": "ok"}',
245        }],
246        consoleErrors: [],
247      };
248      // Build context manually to test redaction via collectPageState
249      // Since collectPageState is private, test the output of buildRepairContext
250      // with already-collected page state — redaction happens in collectPageState.
251      // For unit test, verify redactUrl directly (tested above) and trust integration.
252      expect(redactUrl('https://api.com/data?token=secret123')).toContain('[REDACTED]');
253    });
254  });
255  
256  function makePage(overrides: Partial<IPage> = {}): IPage {
257    return {
258      goto: vi.fn(),
259      evaluate: vi.fn(),
260      getCookies: vi.fn(),
261      snapshot: vi.fn().mockResolvedValue('<div>...</div>'),
262      click: vi.fn(),
263      typeText: vi.fn(),
264      pressKey: vi.fn(),
265      scrollTo: vi.fn(),
266      getFormState: vi.fn(),
267      wait: vi.fn(),
268      tabs: vi.fn(),
269      selectTab: vi.fn(),
270      networkRequests: vi.fn().mockResolvedValue([]),
271      consoleMessages: vi.fn().mockResolvedValue([]),
272      scroll: vi.fn(),
273      autoScroll: vi.fn(),
274      installInterceptor: vi.fn(),
275      getInterceptedRequests: vi.fn().mockResolvedValue([]),
276      waitForCapture: vi.fn(),
277      screenshot: vi.fn(),
278      getCurrentUrl: vi.fn().mockResolvedValue('https://example.com/page'),
279      ...overrides,
280    } as IPage;
281  }
282  
283  describe('collectDiagnostic', () => {
284    it('keeps intercepted payloads in a dedicated capturedPayloads field', async () => {
285      const page = makePage({
286        networkRequests: vi.fn().mockResolvedValue([{ url: '/api/data', status: 200 }]),
287        getInterceptedRequests: vi.fn().mockResolvedValue([{ items: [{ id: 1 }] }]),
288      });
289  
290      const ctx = await collectDiagnostic(new Error('boom'), makeCmd(), page);
291  
292      expect(ctx.page?.networkRequests).toEqual([
293        { url: '/api/data', status: 200 },
294      ]);
295      expect(ctx.page?.capturedPayloads).toEqual([
296        { source: 'interceptor', responseBody: { items: [{ id: 1 }] } },
297      ]);
298    });
299  
300    it('preserves the previous network request output when interception is empty', async () => {
301      const page = makePage({
302        networkRequests: vi.fn().mockResolvedValue([{ url: '/api/data', status: 200 }]),
303        getInterceptedRequests: vi.fn().mockResolvedValue([]),
304      });
305  
306      const ctx = await collectDiagnostic(new Error('boom'), makeCmd(), page);
307  
308      expect(ctx.page?.networkRequests).toEqual([{ url: '/api/data', status: 200 }]);
309      expect(ctx.page?.capturedPayloads).toEqual([]);
310    });
311  
312    it('swallows intercepted request failures and still returns page state', async () => {
313      const page = makePage({
314        networkRequests: vi.fn().mockResolvedValue([{ url: '/api/data', status: 200 }]),
315        getInterceptedRequests: vi.fn().mockRejectedValue(new Error('interceptor unavailable')),
316      });
317  
318      const ctx = await collectDiagnostic(new Error('boom'), makeCmd(), page);
319  
320      expect(ctx.page).toEqual({
321        url: 'https://example.com/page',
322        snapshot: '<div>...</div>',
323        networkRequests: [{ url: '/api/data', status: 200 }],
324        capturedPayloads: [],
325        consoleErrors: [],
326      });
327    });
328  
329    it('redacts and truncates intercepted payloads recursively', async () => {
330      const page = makePage({
331        getInterceptedRequests: vi.fn().mockResolvedValue([{
332          token: 'token=abc123def456ghi789',
333          nested: {
334            cookie: 'cookie: session=super-secret-cookie-value',
335            body: 'x'.repeat(5000),
336          },
337        }]),
338      });
339  
340      const ctx = await collectDiagnostic(new Error('boom'), makeCmd(), page);
341      const payload = ctx.page?.capturedPayloads?.[0] as Record<string, unknown>;
342      const body = ((payload.responseBody as Record<string, unknown>).nested as Record<string, unknown>).body as string;
343  
344      expect(payload).toEqual({
345        source: 'interceptor',
346        responseBody: {
347          token: 'token=[REDACTED]',
348          nested: {
349            cookie: 'cookie: [REDACTED]',
350            body,
351          },
352        },
353      });
354      expect(body).toContain('[truncated,');
355      expect(body.length).toBeLessThan(5000);
356    });
357  });